controls/DebugVariablePanel.py
changeset 934 fc00c11feff5
parent 932 ebe63100b6d7
child 935 fc1515f27e1f
equal deleted inserted replaced
933:6c320534627e 934:fc00c11feff5
   304         self.ParentWindow = None
   304         self.ParentWindow = None
   305         self.ParentControl = None
   305         self.ParentControl = None
   306     
   306     
   307     def OnDragOver(self, x, y, d):
   307     def OnDragOver(self, x, y, d):
   308         if self.ParentControl is not None:
   308         if self.ParentControl is not None:
   309             self.ParentControl.OnCanvasDragging(x, y)
   309             self.ParentControl.OnCanvasMouseDragging(x, y)
       
   310         else:
       
   311             self.ParentWindow.RefreshHighlight(x, y)
   310         return wx.TextDropTarget.OnDragOver(self, x, y, d)
   312         return wx.TextDropTarget.OnDragOver(self, x, y, d)
   311         
   313         
   312     def OnDropText(self, x, y, data):
   314     def OnDropText(self, x, y, data):
   313         message = None
   315         message = None
   314         try:
   316         try:
   349                             target_idx += 1
   351                             target_idx += 1
   350                         self.ParentWindow.InsertValue(values[0], target_idx, force=True)
   352                         self.ParentWindow.InsertValue(values[0], target_idx, force=True)
   351             self.ParentWindow.InsertValue(values[0], force=True)
   353             self.ParentWindow.InsertValue(values[0], force=True)
   352     
   354     
   353     def OnLeave(self):
   355     def OnLeave(self):
   354         if self.ParentControl is not None:
   356         self.ParentWindow.ResetHighlight()
   355             self.ParentControl.OnCanvasLeave()
       
   356         return wx.TextDropTarget.OnLeave(self)
   357         return wx.TextDropTarget.OnLeave(self)
   357         
   358     
   358     def ShowMessage(self, message):
   359     def ShowMessage(self, message):
   359         dialog = wx.MessageDialog(self.ParentWindow, message, _("Error"), wx.OK|wx.ICON_ERROR)
   360         dialog = wx.MessageDialog(self.ParentWindow, message, _("Error"), wx.OK|wx.ICON_ERROR)
   360         dialog.ShowModal()
   361         dialog.ShowModal()
   361         dialog.Destroy()
   362         dialog.Destroy()
   362 
   363 
   610         return mask
   611         return mask
   611     
   612     
   612     #CANVAS_HIGHLIGHT_TYPES
   613     #CANVAS_HIGHLIGHT_TYPES
   613     [HIGHLIGHT_NONE,
   614     [HIGHLIGHT_NONE,
   614      HIGHLIGHT_BEFORE,
   615      HIGHLIGHT_BEFORE,
       
   616      HIGHLIGHT_BEFORE_DOUBLE,
   615      HIGHLIGHT_AFTER,
   617      HIGHLIGHT_AFTER,
       
   618      HIGHLIGHT_AFTER_DOUBLE,
   616      HIGHLIGHT_LEFT,
   619      HIGHLIGHT_LEFT,
   617      HIGHLIGHT_RIGHT] = range(5)
   620      HIGHLIGHT_RIGHT] = range(7)
   618     
   621     
   619     HIGHLIGHT_PEN = wx.Pen(wx.Colour(0, 128, 255))
   622     HIGHLIGHT_PEN = wx.Pen(wx.Colour(0, 128, 255))
   620     HIGHLIGHT_BRUSH = wx.Brush(wx.Colour(0, 128, 255, 128))
   623     HIGHLIGHT_BRUSH = wx.Brush(wx.Colour(0, 128, 255, 128))
   621     
   624     
   622     #CANVAS_SIZE_TYPES
   625     #CANVAS_SIZE_TYPES
   717             destGC = wx.GCDC(destDC)
   720             destGC = wx.GCDC(destDC)
   718             
   721             
   719             destGC.BeginDrawing()
   722             destGC.BeginDrawing()
   720             destGC.SetPen(HIGHLIGHT_PEN)
   723             destGC.SetPen(HIGHLIGHT_PEN)
   721             destGC.SetBrush(HIGHLIGHT_BRUSH)
   724             destGC.SetBrush(HIGHLIGHT_BRUSH)
   722             if self.Highlight == HIGHLIGHT_BEFORE:
   725             if self.Highlight in [HIGHLIGHT_BEFORE]:
   723                 destGC.DrawLine(0, 0, width - 1, 0)
   726                 destGC.DrawLine(0, 1, width - 1, 1)
   724             elif self.Highlight == HIGHLIGHT_AFTER:
   727             elif self.Highlight in [HIGHLIGHT_AFTER]:
   725                 destGC.DrawLine(0, height - 1, width - 1, height - 1)
   728                 destGC.DrawLine(0, height - 1, width - 1, height - 1)
   726             elif self.Highlight == HIGHLIGHT_LEFT:
   729             elif self.Highlight == HIGHLIGHT_LEFT:
   727                 destGC.DrawRectangle(bbox.x, bbox.y, 
   730                 destGC.DrawRectangle(bbox.x, bbox.y, 
   728                                      bbox.width / 2, bbox.height)
   731                                      bbox.width / 2, bbox.height)
   729             elif self.Highlight == HIGHLIGHT_RIGHT:
   732             elif self.Highlight == HIGHLIGHT_RIGHT:
   803                             y = rect.y - h - offset
   806                             y = rect.y - h - offset
   804                         else:
   807                         else:
   805                             y = rect.y + rect.height + offset
   808                             y = rect.y + rect.height + offset
   806                         offset += h
   809                         offset += h
   807                     button.SetPosition(x, y)
   810                     button.SetPosition(x, y)
   808             self.ParentWindow.ForceRefresh()
   811                 self.ParentWindow.ForceRefresh()
   809         
   812         
   810         def DismissContextualButtons(self):
   813         def DismissContextualButtons(self):
   811             if self.ContextualButtonsItem is not None:
   814             if self.ContextualButtonsItem is not None:
   812                 self.ContextualButtonsItem = None
   815                 self.ContextualButtonsItem = None
   813                 self.ContextualButtons = []
   816                 self.ContextualButtons = []
   814             self.ParentWindow.ForceRefresh()
   817                 self.ParentWindow.ForceRefresh()
   815         
   818         
   816         def IsOverButton(self, x, y):
   819         def IsOverButton(self, x, y):
   817             for button in self.Buttons + self.ContextualButtons:
   820             for button in self.Buttons + self.ContextualButtons:
   818                 if button.HitTest(x, y):
   821                 if button.HitTest(x, y):
   819                     return True
   822                     return True
  1036                         self.Canvas.PopupContextualButtons(self.Items[item_idx], rect, item_style)
  1039                         self.Canvas.PopupContextualButtons(self.Items[item_idx], rect, item_style)
  1037                         return 
  1040                         return 
  1038                     if not self.Canvas.IsOverContextualButton(event.x, height - event.y):
  1041                     if not self.Canvas.IsOverContextualButton(event.x, height - event.y):
  1039                         self.Canvas.DismissContextualButtons()
  1042                         self.Canvas.DismissContextualButtons()
  1040         
  1043         
  1041         def OnCanvasDragging(self, x, y, refresh=True):
  1044         def OnCanvasMouseDragging(self, x, y):
       
  1045             xw, yw = self.GetPosition()
       
  1046             self.ParentWindow.RefreshHighlight(x + xw, y + yw)
       
  1047         
       
  1048         def OnCanvasDragging(self, x, y):
  1042             width, height = self.Canvas.GetSize()
  1049             width, height = self.Canvas.GetSize()
  1043             bbox = self.Canvas.GetAxesBoundingBox()
  1050             bbox = self.Canvas.GetAxesBoundingBox()
  1044             if bbox.InsideXY(x, y) and not self.Is3DCanvas():
  1051             if bbox.InsideXY(x, y) and not self.Is3DCanvas():
  1045                 rect = wx.Rect(bbox.x, bbox.y, bbox.width / 2, bbox.height)
  1052                 rect = wx.Rect(bbox.x, bbox.y, bbox.width / 2, bbox.height)
  1046                 if rect.InsideXY(x, y):
  1053                 if rect.InsideXY(x, y):
  1047                     self.Canvas.SetHighlight(HIGHLIGHT_LEFT)
  1054                     self.Canvas.SetHighlight(HIGHLIGHT_LEFT)
  1048                 else:
  1055                 else:
  1049                     self.Canvas.SetHighlight(HIGHLIGHT_RIGHT)
  1056                     self.Canvas.SetHighlight(HIGHLIGHT_RIGHT)
  1050             elif y < height / 2:
  1057             elif y < height / 2:
  1051                 self.Canvas.SetHighlight(HIGHLIGHT_BEFORE)
  1058                 if self.ParentWindow.IsViewerFirst(self):
       
  1059                     self.Canvas.SetHighlight(HIGHLIGHT_BEFORE)
       
  1060                 else:
       
  1061                     self.Canvas.SetHighlight(HIGHLIGHT_NONE)
       
  1062                     self.ParentWindow.HighlightPreviousViewer(self)
  1052             else:
  1063             else:
  1053                 self.Canvas.SetHighlight(HIGHLIGHT_AFTER)
  1064                 self.Canvas.SetHighlight(HIGHLIGHT_AFTER)
  1054             if refresh:
       
  1055                 self.ParentWindow.ForceRefresh()
       
  1056         
       
  1057         def OnCanvasLeave(self, refresh=True):
       
  1058             self.Canvas.SetHighlight(HIGHLIGHT_NONE)
       
  1059             if refresh:
       
  1060                 self.ParentWindow.ForceRefresh()
       
  1061         
  1065         
  1062         def OnCanvasScroll(self, event):
  1066         def OnCanvasScroll(self, event):
  1063             if event.inaxes is not None:
  1067             if event.inaxes is not None:
  1064                 if self.GraphType == GRAPH_ORTHOGONAL:
  1068                 if self.GraphType == GRAPH_ORTHOGONAL:
  1065                     start_tick, end_tick = self.ParentWindow.GetRange()
  1069                     start_tick, end_tick = self.ParentWindow.GetRange()
  1069                 self.ParentWindow.ChangeRange(int(-event.step) / 3, tick)
  1073                 self.ParentWindow.ChangeRange(int(-event.step) / 3, tick)
  1070         
  1074         
  1071         def OnCanvasMouseWheel(self, event):
  1075         def OnCanvasMouseWheel(self, event):
  1072             if self.ItemButtons is not None:
  1076             if self.ItemButtons is not None:
  1073                 event.Skip()
  1077                 event.Skip()
       
  1078         
       
  1079         def HighlightCanvas(self, highlight):
       
  1080             self.Canvas.SetHighlight(highlight)
  1074         
  1081         
  1075         def HandleCursorMove(self, event):
  1082         def HandleCursorMove(self, event):
  1076             start_tick, end_tick = self.ParentWindow.GetRange()
  1083             start_tick, end_tick = self.ParentWindow.GetRange()
  1077             cursor_tick = None
  1084             cursor_tick = None
  1078             if self.GraphType == GRAPH_ORTHOGONAL:
  1085             if self.GraphType == GRAPH_ORTHOGONAL:
  1546         self.MoveDragNDrop(x_mouse, y_mouse)
  1553         self.MoveDragNDrop(x_mouse, y_mouse)
  1547         
  1554         
  1548     def MoveDragNDrop(self, x_mouse, y_mouse):
  1555     def MoveDragNDrop(self, x_mouse, y_mouse):
  1549         self.DraggingAxesBoundingBox.x = x_mouse - self.DraggingAxesMousePos.x
  1556         self.DraggingAxesBoundingBox.x = x_mouse - self.DraggingAxesMousePos.x
  1550         self.DraggingAxesBoundingBox.y = y_mouse - self.DraggingAxesMousePos.y
  1557         self.DraggingAxesBoundingBox.y = y_mouse - self.DraggingAxesMousePos.y
       
  1558         self.RefreshHighlight(x_mouse, y_mouse)
       
  1559     
       
  1560     def RefreshHighlight(self, x_mouse, y_mouse):
  1551         for idx, panel in enumerate(self.GraphicPanels):
  1561         for idx, panel in enumerate(self.GraphicPanels):
  1552             x, y = panel.GetPosition()
  1562             x, y = panel.GetPosition()
  1553             width, height = panel.Canvas.GetSize()
  1563             width, height = panel.Canvas.GetSize()
  1554             rect = wx.Rect(x, y, width, height)
  1564             rect = wx.Rect(x, y, width, height)
  1555             if (rect.InsideXY(x_mouse, y_mouse) or 
  1565             if (rect.InsideXY(x_mouse, y_mouse) or 
  1556                 idx == 0 and y_mouse < 0 or
  1566                 idx == 0 and y_mouse < 0 or
  1557                 idx == len(self.GraphicPanels) - 1 and y_mouse > panel.GetPosition()[1]):
  1567                 idx == len(self.GraphicPanels) - 1 and y_mouse > panel.GetPosition()[1]):
  1558                 panel.OnCanvasDragging(x_mouse - x, y_mouse - y, False)
  1568                 panel.OnCanvasDragging(x_mouse - x, y_mouse - y)
  1559             else:
  1569             else:
  1560                 panel.OnCanvasLeave(False)
  1570                 panel.HighlightCanvas(HIGHLIGHT_NONE)
       
  1571         self.ForceRefresh()
       
  1572     
       
  1573     def ResetHighlight(self):
       
  1574         for panel in self.GraphicPanels:
       
  1575             panel.HighlightCanvas(HIGHLIGHT_NONE)
  1561         self.ForceRefresh()
  1576         self.ForceRefresh()
  1562     
  1577     
  1563     def IsDragging(self):
  1578     def IsDragging(self):
  1564         return self.DraggingAxesPanel is not None
  1579         return self.DraggingAxesPanel is not None
  1565     
  1580     
  1575     def StopDragNDrop(self, variable, x_mouse, y_mouse):
  1590     def StopDragNDrop(self, variable, x_mouse, y_mouse):
  1576         self.DraggingAxesPanel = None
  1591         self.DraggingAxesPanel = None
  1577         self.DraggingAxesBoundingBox = None
  1592         self.DraggingAxesBoundingBox = None
  1578         self.DraggingAxesMousePos = None
  1593         self.DraggingAxesMousePos = None
  1579         for idx, panel in enumerate(self.GraphicPanels):
  1594         for idx, panel in enumerate(self.GraphicPanels):
  1580             panel.OnCanvasLeave(False)
  1595             panel.HighlightCanvas(HIGHLIGHT_NONE)
  1581             xw, yw = panel.GetPosition()
  1596             xw, yw = panel.GetPosition()
  1582             width, height = panel.Canvas.GetSize()
  1597             width, height = panel.Canvas.GetSize()
  1583             bbox = wx.Rect(xw, yw, width, height)
  1598             bbox = wx.Rect(xw, yw, width, height)
  1584             if bbox.InsideXY(x_mouse, y_mouse):
  1599             if bbox.InsideXY(x_mouse, y_mouse):
  1585                 merge_type = GRAPH_PARALLEL
  1600                 merge_type = GRAPH_PARALLEL
  1633                 refresh_graphics = True
  1648                 refresh_graphics = True
  1634             else:
  1649             else:
  1635                 refresh_graphics = False
  1650                 refresh_graphics = False
  1636             
  1651             
  1637             if self.DraggingAxesPanel is not None and self.DraggingAxesPanel not in self.GraphicPanels:
  1652             if self.DraggingAxesPanel is not None and self.DraggingAxesPanel not in self.GraphicPanels:
  1638                 self.DraggingAxesPanel.Refresh()
  1653                 self.DraggingAxesPanel.Refresh(refresh_graphics)
  1639             for panel in self.GraphicPanels:
  1654             for panel in self.GraphicPanels:
  1640                 if isinstance(panel, DebugVariableGraphic):
  1655                 if isinstance(panel, DebugVariableGraphic):
  1641                     panel.Refresh(refresh_graphics)
  1656                     panel.Refresh(refresh_graphics)
  1642                 else:
  1657                 else:
  1643                     panel.Refresh()
  1658                     panel.Refresh()
  1908     
  1923     
  1909     def GetViewerIndex(self, viewer):
  1924     def GetViewerIndex(self, viewer):
  1910         if viewer in self.GraphicPanels:
  1925         if viewer in self.GraphicPanels:
  1911             return self.GraphicPanels.index(viewer)
  1926             return self.GraphicPanels.index(viewer)
  1912         return None
  1927         return None
       
  1928     
       
  1929     def IsViewerFirst(self, viewer):
       
  1930         return viewer == self.GraphicPanels[0]
       
  1931     
       
  1932     def IsViewerLast(self, viewer):
       
  1933         return viewer == self.GraphicPanels[-1]
       
  1934     
       
  1935     def HighlightPreviousViewer(self, viewer):
       
  1936         if self.IsViewerFirst(viewer):
       
  1937             return
       
  1938         idx = self.GetViewerIndex(viewer)
       
  1939         if idx is None:
       
  1940             return
       
  1941         self.GraphicPanels[idx-1].HighlightCanvas(HIGHLIGHT_AFTER)
  1913     
  1942     
  1914     def ResetVariableNameMask(self):
  1943     def ResetVariableNameMask(self):
  1915         items = []
  1944         items = []
  1916         for panel in self.GraphicPanels:
  1945         for panel in self.GraphicPanels:
  1917             items.extend(panel.GetItems())
  1946             items.extend(panel.GetItems())