Mercurial Mercurial > plcopeneditor_history / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Viewer.py
changeset 323 fd3a3a002bce
parent 319 efe0671df286
child 327 7fd5233ce5ce
equal deleted inserted replaced
322:bf5a968bb7e0 323:fd3a3a002bce 
    87         wx.TextDropTarget.__init__(self)
 
    87         wx.TextDropTarget.__init__(self)
 
    88         self.ParentWindow = parent
 
    88         self.ParentWindow = parent
 
    89     
    89     
    90     def OnDropText(self, x, y, data):
 
    90     def OnDropText(self, x, y, data):
 
    91         x, y = self.ParentWindow.CalcUnscrolledPosition(x, y)
 
    91         x, y = self.ParentWindow.CalcUnscrolledPosition(x, y)
 
       
    92         x = int(x / self.ParentWindow.ViewScale[0])
 
       
    93         y = int(y / self.ParentWindow.ViewScale[1])
 
    92         scaling = self.ParentWindow.Scaling
 
    94         scaling = self.ParentWindow.Scaling
 
    93         message = None
 
    95         message = None
 
    94         try:
 
    96         try:
 
    95             values = eval(data)
 
    97             values = eval(data)
 
    96         except:
 
    98         except:
 
   346         self.ResetView()
 
   348         self.ResetView()
 
   347         self.Scaling = None
 
   349         self.Scaling = None
 
   348         self.DrawGrid = True
 
   350         self.DrawGrid = True
 
   349         self.GridBrush = wx.TRANSPARENT_BRUSH
 
   351         self.GridBrush = wx.TRANSPARENT_BRUSH
 
   350         self.PageSize = None
 
   352         self.PageSize = None
 
       
   353         self.ViewScale = (1.0, 1.0)
 
   351         self.PagePen = wx.TRANSPARENT_PEN
 
   354         self.PagePen = wx.TRANSPARENT_PEN
 
   352         self.DrawingWire = False
 
   355         self.DrawingWire = False
 
   353         self.current_id = 0
 
   356         self.current_id = 0
 
   354         self.TagName = tagname
 
   357         self.TagName = tagname
 
   355         self.Errors = []
 
   358         self.Errors = []
 
   401         self.Bind(wx.EVT_SCROLLWIN_THUMBRELEASE, self.OnScrollStop)
 
   404         self.Bind(wx.EVT_SCROLLWIN_THUMBRELEASE, self.OnScrollStop)
 
   402         self.Bind(wx.EVT_MOUSEWHEEL, self.OnMouseWheelWindow)
 
   405         self.Bind(wx.EVT_MOUSEWHEEL, self.OnMouseWheelWindow)
 
   403         self.Bind(wx.EVT_SIZE, self.OnMoveWindow)
 
   406         self.Bind(wx.EVT_SIZE, self.OnMoveWindow)
 
   404     
   407     
   405     def GetScrolledRect(self, rect):
 
   408     def GetScrolledRect(self, rect):
 
   406         rect.x, rect.y = self.CalcScrolledPosition(rect.x, rect.y)
 
   409         rect.x, rect.y = self.CalcScrolledPosition(int(rect.x * self.ViewScale[0]), 
       
   410                                                    int(rect.y * self.ViewScale[1]))
 
       
   411         rect.width = int(rect.width * self.ViewScale[0]) + 2
 
       
   412         rect.height = int(rect.height * self.ViewScale[1]) + 2
 
   407         return rect
 
   413         return rect
 
   408     
   414     
   409     def GetScaling(self):
 
   415     def GetScaling(self):
 
   410         return self.Scaling
 
   416         return self.Scaling
 
   411     
   417     
   431     
   437     
   432     # Destructor
 
   438     # Destructor
 
   433     def __del__(self):
 
   439     def __del__(self):
 
   434         self.Flush()
 
   440         self.Flush()
 
   435         self.ResetView()
 
   441         self.ResetView()
 
       
   442     
       
   443     def SetScale(self, scalex, scaley):
 
       
   444         self.ViewScale = (scalex, scaley)
 
       
   445         self.RefreshScaling()
 
   436 
   446 
   437     def GetLogicalDC(self, buffered=False):
 
   447     def GetLogicalDC(self, buffered=False):
 
   438         if buffered:
 
   448         if buffered:
 
   439             dc = wx.AutoBufferedPaintDC(self)
 
   449             dc = wx.AutoBufferedPaintDC(self)
 
   440         else:
 
   450         else:
 
   442         dc.SetFont(self.GetFont())
 
   452         dc.SetFont(self.GetFont())
 
   443         if wx.VERSION >= (2, 6, 0):
 
   453         if wx.VERSION >= (2, 6, 0):
 
   444             self.DoPrepareDC(dc)
 
   454             self.DoPrepareDC(dc)
 
   445         else:
 
   455         else:
 
   446             self.PrepareDC(dc)
 
   456             self.PrepareDC(dc)
 
       
   457         dc.SetUserScale(self.ViewScale[0], self.ViewScale[1])
 
   447         return dc
 
   458         return dc
 
   448 
   459 
   449     def GetMiniFont(self):
 
   460     def GetMiniFont(self):
 
   450         font = self.GetFont()
 
   461         font = self.GetFont()
 
   451         return wx.Font(font.GetPointSize() * 0.75, wx.SWISS, wx.NORMAL, wx.NORMAL, faceName = faces["helv"])
 
   462         return wx.Font(font.GetPointSize() * 0.75, wx.SWISS, wx.NORMAL, wx.NORMAL, faceName = faces["helv"])
 
   501         if xp is not None:
 
   512         if xp is not None:
 
   502             x = xp * self.GetScrollPixelsPerUnit()[0]
 
   513             x = xp * self.GetScrollPixelsPerUnit()[0]
 
   503         if yp is not None:
 
   514         if yp is not None:
 
   504             y = yp * self.GetScrollPixelsPerUnit()[1]
 
   515             y = yp * self.GetScrollPixelsPerUnit()[1]
 
   505         width, height = self.GetClientSize()
 
   516         width, height = self.GetClientSize()
 
   506         screen = wx.Rect(x, y, width, height)
 
   517         screen = wx.Rect(int(x / self.ViewScale[0]), int(y / self.ViewScale[1]),
 
       
   518                          int(width / self.ViewScale[0]), int(height / self.ViewScale[1]))
 
   507         for comment in self.Comments:
 
   519         for comment in self.Comments:
 
   508             comment.TestVisible(screen)
 
   520             comment.TestVisible(screen)
 
   509         for wire in self.Wires:
 
   521         for wire in self.Wires:
 
   510             wire.TestVisible(screen)
 
   522             wire.TestVisible(screen)
 
   511         for block in self.Blocks:
 
   523         for block in self.Blocks:
 
   563         properties = self.Controler.GetProjectProperties(self.Debug)
 
   575         properties = self.Controler.GetProjectProperties(self.Debug)
 
   564         scaling = properties["scaling"][self.CurrentLanguage]
 
   576         scaling = properties["scaling"][self.CurrentLanguage]
 
   565         if scaling != (0, 0):
 
   577         if scaling != (0, 0):
 
   566             self.Scaling = scaling
 
   578             self.Scaling = scaling
 
   567             if self.DrawGrid:
 
   579             if self.DrawGrid:
 
   568                 bitmap = wx.EmptyBitmap(*scaling)
 
   580                 width = max(2, int(scaling[0] * self.ViewScale[0]))
 
       
   581                 height = max(2, int(scaling[1] * self.ViewScale[1]))
 
       
   582                 bitmap = wx.EmptyBitmap(width, height)
 
   569                 dc = wx.MemoryDC(bitmap)
 
   583                 dc = wx.MemoryDC(bitmap)
 
   570                 dc.SetBackground(wx.Brush(self.GetBackgroundColour()))
 
   584                 dc.SetBackground(wx.Brush(self.GetBackgroundColour()))
 
   571                 dc.Clear()
 
   585                 dc.Clear()
 
   572                 dc.SetPen(wx.Pen(wx.Colour(180, 180, 180)))
 
   586                 dc.SetPen(wx.Pen(wx.Colour(180, 180, 180)))
 
   573                 dc.DrawPoint(0, 0)
 
   587                 dc.DrawPoint(0, 0)
 
   700     
   714     
   701     def RefreshScrollBars(self, width_incr=0, height_incr=0):
 
   715     def RefreshScrollBars(self, width_incr=0, height_incr=0):
 
   702         xstart, ystart = self.GetViewStart()
 
   716         xstart, ystart = self.GetViewStart()
 
   703         window_size = self.GetClientSize()
 
   717         window_size = self.GetClientSize()
 
   704         maxx, maxy = self.GetMaxSize()
 
   718         maxx, maxy = self.GetMaxSize()
 
   705         maxx = max(maxx + WINDOW_BORDER, xstart * SCROLLBAR_UNIT + window_size[0])
 
   719         maxx = max(maxx + WINDOW_BORDER, (xstart * SCROLLBAR_UNIT + window_size[0]) / self.ViewScale[0])
 
   706         maxy = max(maxy + WINDOW_BORDER, ystart * SCROLLBAR_UNIT + window_size[1])
 
   720         maxy = max(maxy + WINDOW_BORDER, (ystart * SCROLLBAR_UNIT + window_size[1]) / self.ViewScale[1])
 
   707         if self.rubberBand.IsShown():
 
   721         if self.rubberBand.IsShown():
 
   708             extent = self.rubberBand.GetCurrentExtent()
 
   722             extent = self.rubberBand.GetCurrentExtent()
 
   709             maxx = max(maxx, extent.x + extent.width)
 
   723             maxx = max(maxx, extent.x + extent.width)
 
   710             maxy = max(maxy, extent.y + extent.height)
 
   724             maxy = max(maxy, extent.y + extent.height)
 
       
   725         maxx = int(maxx * self.ViewScale[0])
 
       
   726         maxy = int(maxy * self.ViewScale[1])
 
   711         self.SetScrollbars(SCROLLBAR_UNIT, SCROLLBAR_UNIT, 
   727         self.SetScrollbars(SCROLLBAR_UNIT, SCROLLBAR_UNIT, 
   712             round(maxx / SCROLLBAR_UNIT) + width_incr, round(maxy / SCROLLBAR_UNIT) + height_incr, 
   728             round(maxx / SCROLLBAR_UNIT) + width_incr, round(maxy / SCROLLBAR_UNIT) + height_incr, 
   713             xstart, ystart, True)
 
   729             xstart, ystart, True)
 
   714         
   730         
   715     # Load instance from given informations
 
   731     # Load instance from given informations
 
  1479     
  1495     
  1480     def OnViewerMotion(self, event):
 
  1496     def OnViewerMotion(self, event):
 
  1481         refresh = False
 
  1497         refresh = False
 
  1482         dc = self.GetLogicalDC()
 
  1498         dc = self.GetLogicalDC()
 
  1483         pos = GetScaledEventPosition(event, dc, self.Scaling)
 
  1499         pos = GetScaledEventPosition(event, dc, self.Scaling)
 
  1484         if event.LeftIsDown():
 
  1500         if event.MiddleIsDown():
 
       
  1501             if self.StartMousePos is not None and self.StartScreenPos is not None:
 
       
  1502                 new_pos = event.GetPosition()
 
       
  1503                 xmax = self.GetScrollRange(wx.HORIZONTAL) - self.GetScrollThumb(wx.HORIZONTAL)
 
       
  1504                 ymax = self.GetScrollRange(wx.VERTICAL) - self.GetScrollThumb(wx.VERTICAL)
 
       
  1505                 scrollx = max(0, self.StartScreenPos[0] + (new_pos[0] - self.StartMousePos[0]) * self.ViewScale[0] / SCROLLBAR_UNIT)
 
       
  1506                 scrolly = max(0, self.StartScreenPos[1] + (new_pos[1] - self.StartMousePos[1]) * self.ViewScale[1] / SCROLLBAR_UNIT)
 
       
  1507                 if scrollx > xmax or scrolly > ymax:
 
       
  1508                     self.RefreshScrollBars(max(0, scrollx - xmax), max(0, scrolly - ymax))
 
       
  1509                     self.Scroll(scrollx, scrolly)
 
       
  1510                 else:
 
       
  1511                     self.Scroll(scrollx, scrolly)
 
       
  1512                     self.RefreshScrollBars()
 
       
  1513                 self.RefreshVisibleElements()
 
       
  1514         else:
 
  1485             if not event.Dragging():
 
  1515             if not event.Dragging():
 
  1486                 highlighted = self.FindElement(pos) 
  1516                 highlighted = self.FindElement(pos) 
  1487                 if self.HighlightedElement is not None and self.HighlightedElement != highlighted:
 
  1517                 if self.HighlightedElement is not None and self.HighlightedElement != highlighted:
 
  1488                     self.HighlightedElement.SetHighlighted(False)
 
  1518                     self.HighlightedElement.SetHighlighted(False)
 
  1489                     self.HighlightedElement = None
 
  1519                     self.HighlightedElement = None
 
  1504                 else:
 
  1534                 else:
 
  1505                     movex, movey = self.SelectedElement.OnMotion(event, dc, self.Scaling)
 
  1535                     movex, movey = self.SelectedElement.OnMotion(event, dc, self.Scaling)
 
  1506                     if movex != 0 or movey != 0:
 
  1536                     if movex != 0 or movey != 0:
 
  1507                         self.RefreshRect(self.GetScrolledRect(self.SelectedElement.GetRedrawRect(movex, movey)), False)
 
  1537                         self.RefreshRect(self.GetScrolledRect(self.SelectedElement.GetRedrawRect(movex, movey)), False)
 
  1508             self.UpdateScrollPos(event)
 
  1538             self.UpdateScrollPos(event)
 
  1509         elif event.MiddleIsDown():
 
       
  1510             if self.StartMousePos is not None and self.StartScreenPos is not None:
 
       
  1511                 new_pos = event.GetPosition()
 
       
  1512                 xmax = self.GetScrollRange(wx.HORIZONTAL) - self.GetScrollThumb(wx.HORIZONTAL)
 
       
  1513                 ymax = self.GetScrollRange(wx.VERTICAL) - self.GetScrollThumb(wx.VERTICAL)
 
       
  1514                 scrollx = max(0, self.StartScreenPos[0] + (new_pos[0] - self.StartMousePos[0]) / SCROLLBAR_UNIT)
 
       
  1515                 scrolly = max(0, self.StartScreenPos[1] + (new_pos[1] - self.StartMousePos[1]) / SCROLLBAR_UNIT)
 
       
  1516                 if scrollx > xmax or scrolly > ymax:
 
       
  1517                     self.RefreshScrollBars(max(0, scrollx - xmax), max(0, scrolly - ymax))
 
       
  1518                     self.Scroll(scrollx, scrolly)
 
       
  1519                 else:
 
       
  1520                     self.Scroll(scrollx, scrolly)
 
       
  1521                     self.RefreshScrollBars()
 
       
  1522                 self.RefreshVisibleElements()
 
       
  1523         event.Skip()
 
  1539         event.Skip()
 
  1524 
  1540 
  1525     def OnLeaveViewer(self, event):
 
  1541     def OnLeaveViewer(self, event):
 
  1526         if self.SelectedElement is not None and self.SelectedElement.GetDragging():
 
  1542         if self.SelectedElement is not None and self.SelectedElement.GetDragging():
 
  1527             event.Skip()
 
  1543             event.Skip()
 
  2660         self.RefreshScrollBars()
 
  2676         self.RefreshScrollBars()
 
  2661         event.Skip()
 
  2677         event.Skip()
 
  2662 
  2678 
  2663     def OnMouseWheelWindow(self, event):
 
  2679     def OnMouseWheelWindow(self, event):
 
  2664         if self.StartMousePos is None or self.StartScreenPos is None:
 
  2680         if self.StartMousePos is None or self.StartScreenPos is None:
 
  2665             x, y = self.GetViewStart()
 
  2681             rotation = event.GetWheelRotation() / event.GetWheelDelta()
 
  2666             yp = max(0, min(y - event.GetWheelRotation() / event.GetWheelDelta() * 3, self.GetVirtualSize()[1] / self.GetScrollPixelsPerUnit()[1]))
 
  2682             if event.ShiftDown():
 
  2667             self.RefreshVisibleElements(yp = yp)
 
  2683                 x, y = self.GetViewStart()
 
  2668             self.Scroll(x, yp)
 
  2684                 xp = max(0, min(x - rotation * 3, self.GetVirtualSize()[0] / self.GetScrollPixelsPerUnit()[0]))
 
       
  2685                 self.RefreshVisibleElements(xp = xp)
 
       
  2686                 self.Scroll(xp, y)
 
       
  2687             elif event.ControlDown():
 
       
  2688                 dc = self.GetLogicalDC()
 
       
  2689                 pos = event.GetLogicalPosition(dc)
 
       
  2690                 mouse_pos = event.GetPosition()
 
       
  2691                 factor = 0.75 ** rotation
 
       
  2692                 self.SetScale(self.ViewScale[0] * factor, self.ViewScale[1] * factor)
 
       
  2693                 self.Scroll(round(pos.x * self.ViewScale[0] - mouse_pos.x) / SCROLLBAR_UNIT,
 
       
  2694                             round(pos.y * self.ViewScale[1] - mouse_pos.y) / SCROLLBAR_UNIT)
 
       
  2695                 self.RefreshScrollBars()
 
       
  2696                 self.RefreshVisibleElements()
 
       
  2697                 self.Refresh()
 
       
  2698             else:
 
       
  2699                 x, y = self.GetViewStart()
 
       
  2700                 yp = max(0, min(y - rotation * 3, self.GetVirtualSize()[1] / self.GetScrollPixelsPerUnit()[1]))
 
       
  2701                 self.RefreshVisibleElements(yp = yp)
 
       
  2702                 self.Scroll(x, yp)
 
  2669         
  2703         
  2670     def OnMoveWindow(self, event):
 
  2704     def OnMoveWindow(self, event):
 
  2671         if not USE_AUI:
 
  2705         if not USE_AUI:
 
  2672             self.GetBestSize()
 
  2706             self.GetBestSize()
 
  2673         self.RefreshScrollBars()
 
  2707         self.RefreshScrollBars()
 
  2689             dc.SetPen(wx.TRANSPARENT_PEN)
 
  2723             dc.SetPen(wx.TRANSPARENT_PEN)
 
  2690             dc.SetBrush(self.GridBrush)
 
  2724             dc.SetBrush(self.GridBrush)
 
  2691             xstart, ystart = self.GetViewStart()
 
  2725             xstart, ystart = self.GetViewStart()
 
  2692             window_size = self.GetClientSize()
 
  2726             window_size = self.GetClientSize()
 
  2693             width, height = self.GetVirtualSize()
 
  2727             width, height = self.GetVirtualSize()
 
  2694             width = max(width, xstart * SCROLLBAR_UNIT + window_size[0])
 
  2728             width = int(max(width, xstart * SCROLLBAR_UNIT + window_size[0]) / self.ViewScale[0])
 
  2695             height = max(height, ystart * SCROLLBAR_UNIT + window_size[1])
 
  2729             height = int(max(height, ystart * SCROLLBAR_UNIT + window_size[1]) / self.ViewScale[1])
 
  2696             dc.DrawRectangle(0, 0, width, height)
 
  2730             dc.DrawRectangle(0, 0, width, height)
 
  2697         if self.PageSize is not None and not printing:
 
  2731         if self.PageSize is not None and not printing:
 
  2698             dc.SetPen(self.PagePen)
 
  2732             dc.SetPen(self.PagePen)
 
  2699             xstart, ystart = self.GetViewStart()
 
  2733             xstart, ystart = self.GetViewStart()
 
  2700             window_size = self.GetClientSize()
 
  2734             window_size = self.GetClientSize()
plcopeneditor_history