beremiz: comparison controls/DebugVariablePanel.py

equal deleted inserted replaced

-:364d178df2d3
+:bd6fdbb61784
 #CANVAS_HIGHLIGHT_TYPES
 [HIGHLIGHT_NONE,
 HIGHLIGHT_BEFORE,
 HIGHLIGHT_AFTER,
 HIGHLIGHT_LEFT,
-HIGHLIGHT_RIGHT] = range(5)
+HIGHLIGHT_RIGHT,
+HIGHLIGHT_RESIZE] = range(6)
-HIGHLIGHT_PEN = wx.Pen(wx.Colour(0, 128, 255))
-HIGHLIGHT_BRUSH = wx.Brush(wx.Colour(0, 128, 255, 128))
+HIGHLIGHT_DROP_PEN = wx.Pen(wx.Colour(0, 128, 255))
+HIGHLIGHT_DROP_BRUSH = wx.Brush(wx.Colour(0, 128, 255, 128))
+HIGHLIGHT_RESIZE_PEN = wx.Pen(wx.Colour(200, 200, 200))
+HIGHLIGHT_RESIZE_BRUSH = wx.Brush(wx.Colour(200, 200, 200))
 #CANVAS_SIZE_TYPES
 [SIZE_MINI, SIZE_MIDDLE, SIZE_MAXI] = [0, 100, 200]
 DEFAULT_CANVAS_HEIGHT = 200.
 def __init__(self, x, y, bitmap, callback):
 self.Position = wx.Point(x, y)
 self.Bitmap = bitmap
 self.Shown = True
+self.Enabled = True
 self.Callback = callback
 def __del__(self):
 self.callback = None
 return self.Bitmap.GetSize()
 def SetPosition(self, x, y):
 self.Position = wx.Point(x, y)
-def SetBitmap(self, bitmap):
-self.Bitmap = bitmap
-def SetCallback(self, callback):
-self.Callback = callback
 def Show(self):
 self.Shown = True
 def Hide(self):
 self.Shown = False
+def IsShown(self):
+return self.Shown
+def Enable(self):
+self.Enabled = True
+def Disable(self):
+self.Enabled = False
+def IsEnabled(self):
+return self.Enabled
 def HitTest(self, x, y):
-if self.Shown:
+if self.Shown and self.Enabled:
 w, h = self.Bitmap.GetSize()
 rect = wx.Rect(self.Position.x, self.Position.y, w, h)
 if rect.InsideXY(x, y):
 return True
 return False
 def ProcessCallback(self):
 if self.Callback is not None:
 wx.CallAfter(self.Callback)
 def Draw(self, dc):
-if self.Shown:
+if self.Shown and self.Enabled:
 dc.DrawBitmap(self.Bitmap, self.Position.x, self.Position.y, True)
 class DraggingFigureCanvas(FigureCanvas):
 def __init__(self, parent, window, *args, **kwargs):
 self.ParentWindow = window
 self.Highlight = HIGHLIGHT_NONE
 self.CanvasSize = SIZE_MAXI
 self.Buttons = []
-self.SizeButtonsParams = dict(
-[(size, (GetBitmap(bitmap), self.GetOnChangeSizeButton(size)))
-for size, bitmap in zip([SIZE_MINI, SIZE_MIDDLE, SIZE_MAXI],
-["minimize_graph", "middle_graph", "maximize_graph"])])
 self.ContextualButtons = []
 self.ContextualButtonsItem = None
-for size in [SIZE_MINI, SIZE_MIDDLE]:
+for size, bitmap in zip([SIZE_MINI, SIZE_MIDDLE, SIZE_MAXI],
-self.Buttons.append(GraphButton(0, 0, *self.SizeButtonsParams[size]))
+["minimize_graph", "middle_graph", "maximize_graph"]):
+self.Buttons.append(GraphButton(0, 0, GetBitmap(bitmap), self.GetOnChangeSizeButton(size)))
 self.Buttons.append(
 GraphButton(0, 0, GetBitmap("export_graph_mini"), self.OnExportGraphButton))
 self.Buttons.append(
 GraphButton(0, 0, GetBitmap("delete_graph"), self.OnCloseButton))
 destDC.SelectObject(self.bitmap)
 destGC = wx.GCDC(destDC)
 destGC.BeginDrawing()
-destGC.SetPen(HIGHLIGHT_PEN)
+if self.Highlight == HIGHLIGHT_RESIZE:
-destGC.SetBrush(HIGHLIGHT_BRUSH)
+destGC.SetPen(HIGHLIGHT_RESIZE_PEN)
-if self.Highlight in [HIGHLIGHT_BEFORE]:
+destGC.SetBrush(HIGHLIGHT_RESIZE_BRUSH)
-destGC.DrawLine(0, 1, width - 1, 1)
+destGC.DrawRectangle(0, height - 5, width, 5)
-elif self.Highlight in [HIGHLIGHT_AFTER]:
+else:
-destGC.DrawLine(0, height - 1, width - 1, height - 1)
+destGC.SetPen(HIGHLIGHT_DROP_PEN)
-elif self.Highlight == HIGHLIGHT_LEFT:
+destGC.SetBrush(HIGHLIGHT_DROP_BRUSH)
-destGC.DrawRectangle(bbox.x, bbox.y,
+if self.Highlight in [HIGHLIGHT_BEFORE]:
-bbox.width / 2, bbox.height)
+destGC.DrawLine(0, 1, width - 1, 1)
-elif self.Highlight == HIGHLIGHT_RIGHT:
+elif self.Highlight in [HIGHLIGHT_AFTER]:
-destGC.DrawRectangle(bbox.x + bbox.width / 2, bbox.y,
+destGC.DrawLine(0, height - 1, width - 1, height - 1)
-bbox.width / 2, bbox.height)
+elif self.Highlight == HIGHLIGHT_LEFT:
+destGC.DrawRectangle(bbox.x, bbox.y,
+bbox.width / 2, bbox.height)
+elif self.Highlight == HIGHLIGHT_RIGHT:
+destGC.DrawRectangle(bbox.x + bbox.width / 2, bbox.y,
+bbox.width / 2, bbox.height)
 for button in self.Buttons + self.ContextualButtons:
 button.Draw(destGC)
 if self.ParentWindow.IsDragging():
 for button in self.ContextualButtons:
 if button.HitTest(x, y):
 return True
 return False
+def SetMinSize(self, size):
+wx.Window.SetMinSize(self, size)
+wx.CallAfter(self.RefreshButtonsState)
 def ShowButtons(self, show):
 for button in self.Buttons:
 if show:
 button.Show()
 else:
 button.Hide()
+self.RefreshButtonsState()
 self.ParentWindow.ForceRefresh()
 def OnEnterWindow(self, event):
 self.ShowButtons(True)
 event.Skip()
 def OnLeaveWindow(self, event):
-x, y = event.GetPosition()
+if self.Highlight != HIGHLIGHT_RESIZE or self.Parent.CanvasStartSize is None:
-width, height = self.GetSize()
+x, y = event.GetPosition()
-if (x <= 0 or x >= width - 1 or
+width, height = self.GetSize()
-y <= 0 or y >= height - 1):
+if (x <= 0 or x >= width - 1 or
-self.ShowButtons(False)
+y <= 0 or y >= height - 1):
+self.ShowButtons(False)
 event.Skip()
 def GetOnChangeSizeButton(self, size):
 def OnChangeSizeButton():
 self.CanvasSize = size
 self.Parent.SetCanvasSize(200, self.CanvasSize)
-params = []
-if self.CanvasSize != SIZE_MINI:
-params.append(self.SizeButtonsParams[SIZE_MINI])
-else:
-params.append(self.SizeButtonsParams[SIZE_MIDDLE])
-if self.CanvasSize != SIZE_MAXI:
-params.append(self.SizeButtonsParams[SIZE_MAXI])
-else:
-params.append(self.SizeButtonsParams[SIZE_MIDDLE])
-for button, (bitmap, callback) in zip(self.Buttons, params):
-button.SetBitmap(bitmap)
-button.SetCallback(callback)
 return OnChangeSizeButton
 def OnExportGraphButton(self):
 self.Parent.ExportGraph()
 def OnRemoveItemButton(self):
 wx.CallAfter(self.ParentWindow.DeleteValue, self.Parent,
 self.ContextualButtonsItem)
 self.DismissContextualButtons()
+def RefreshButtonsState(self, refresh_positions=False):
+width, height = self.GetSize()
+min_width, min_height = self.Parent.GetCanvasMinSize()
+for button, size in zip(self.Buttons,
+[min_height, SIZE_MIDDLE, SIZE_MAXI]):
+if size == height and button.IsEnabled():
+button.Disable()
+refresh_positions = True
+elif not button.IsEnabled():
+button.Enable()
+refresh_positions = True
+if refresh_positions:
+offset = 0
+buttons = self.Buttons[:]
+buttons.reverse()
+for button in buttons:
+if button.IsShown() and button.IsEnabled():
+w, h = button.GetSize()
+button.SetPosition(width - 5 - w - offset, 5)
+offset += w + 2
+self.ParentWindow.ForceRefresh()
 def OnResizeWindow(self, event):
-width, height = self.GetSize()
+wx.CallAfter(self.RefreshButtonsState, True)
-offset = 0
-buttons = self.Buttons[:]
-buttons.reverse()
-for button in buttons:
-w, h = button.GetSize()
-button.SetPosition(width - 5 - w - offset, 5)
-offset += w + 2
 event.Skip()
 class DebugVariableGraphic(DebugVariableViewer):
 def __init__(self, parent, window, items, graph_type):
 self.GraphType = graph_type
 self.CursorTick = None
 self.MouseStartPos = None
 self.StartCursorTick = None
+self.CanvasStartSize = None
 main_sizer = wx.BoxSizer(wx.VERTICAL)
 self.Figure = matplotlib.figure.Figure(facecolor='w')
 self.Figure.subplotpars.update(top=0.95, left=0.1, bottom=0.1, right=0.95)
 self.Canvas.SetDropTarget(DebugVariableDropTarget(self.ParentWindow, self))
 self.Canvas.mpl_connect('button_press_event', self.OnCanvasButtonPressed)
 self.Canvas.mpl_connect('motion_notify_event', self.OnCanvasMotion)
 self.Canvas.mpl_connect('button_release_event', self.OnCanvasButtonReleased)
 self.Canvas.mpl_connect('scroll_event', self.OnCanvasScroll)
+self.Canvas.Bind(wx.EVT_LEAVE_WINDOW, self.OnCanvasLeave)
 main_sizer.AddWindow(self.Canvas, 1, flag=wx.GROW)
 self.SetSizer(main_sizer)
 self.ResetGraphics()
 self.AxesLabels[1].set_position((0.05, 2 * CANVAS_PADDING * graph_ratio))
 self.Labels[1].set_position((0.05, 1.0 - CANVAS_PADDING * graph_ratio))
 self.Figure.subplots_adjust()
+def GetCanvasMinSize(self):
+return wx.Size(200,
+CANVAS_BORDER[0] + CANVAS_BORDER[1] +
+2 * CANVAS_PADDING + VALUE_LABEL_HEIGHT * len(self.Items))
 def SetCanvasSize(self, width, height):
-height = max(height,
+height = max(height, self.GetCanvasMinSize()[1])
-CANVAS_BORDER[0] + CANVAS_BORDER[1] +
-2 * CANVAS_PADDING + VALUE_LABEL_HEIGHT * len(self.Items))
 self.Canvas.SetMinSize(wx.Size(width, height))
 self.RefreshLabelsPosition(height)
 self.ParentWindow.RefreshGraphicsSizer()
 def GetAxesBoundingBox(self, absolute=False):
 return bbox
 def OnCanvasButtonPressed(self, event):
 width, height = self.Canvas.GetSize()
 x, y = event.x, height - event.y
-if not self.Canvas.IsOverButton(x, y) and not self.Is3DCanvas():
+if not self.Canvas.IsOverButton(x, y):
-rect = self.GetAxesBoundingBox()
+if event.inaxes == self.Axes and not self.Is3DCanvas():
-if rect.InsideXY(x, y):
 self.MouseStartPos = wx.Point(x, y)
 item_idx = None
 for i, t in ([pair for pair in enumerate(self.AxesLabels)] +
 [pair for pair in enumerate(self.Labels)]):
 (x0, y0), (x1, y1) = t.get_window_extent().get_points()
 rect = wx.Rect(x0, height - y1, x1 - x0, y1 - y0)
 if rect.InsideXY(x, y):
 item_idx = i
 break
 if item_idx is not None:
 self.Canvas.ShowButtons(False)
 self.Canvas.DismissContextualButtons()
 xw, yw = self.GetPosition()
 self.ParentWindow.StartDragNDrop(self,
 self.Items[item_idx], x + xw, y + yw, x + xw, y + yw)
 elif event.button == 1 and event.inaxes == self.Axes:
 self.StartCursorTick = self.CursorTick
 self.HandleCursorMove(event)
 elif event.button == 2 and self.GraphType == GRAPH_PARALLEL:
 width, height = self.Canvas.GetSize()
 start_tick, end_tick = self.ParentWindow.GetRange()
+self.StartCursorTick = start_tick
+elif event.button == 1 and event.y <= 5:
 self.MouseStartPos = wx.Point(x, y)
-self.StartCursorTick = start_tick
+self.CanvasStartSize = self.Canvas.GetSize()
 def OnCanvasButtonReleased(self, event):
 if self.ParentWindow.IsDragging():
 width, height = self.Canvas.GetSize()
 xw, yw = self.GetPosition()
 xw + event.x,
 yw + height - event.y)
 else:
 self.MouseStartPos = None
 self.StartCursorTick = None
+self.CanvasStartSize = None
 width, height = self.Canvas.GetSize()
 self.Canvas.HandleButtons(event.x, height - event.y)
+if event.y > 5 and self.Canvas.SetHighlight(HIGHLIGHT_NONE):
+self.Canvas.SetCursor(wx.NullCursor)
+self.ParentWindow.ForceRefresh()
 def OnCanvasMotion(self, event):
 width, height = self.Canvas.GetSize()
 if self.ParentWindow.IsDragging():
 xw, yw = self.GetPosition()
 self.ParentWindow.MoveDragNDrop(
 xw + event.x,
 yw + height - event.y)
-elif not self.Is3DCanvas():
+else:
-if event.button == 1:
+if not self.Is3DCanvas():
-if event.inaxes == self.Axes:
+if event.button == 1 and self.CanvasStartSize is None:
-if self.MouseStartPos is not None:
+if event.inaxes == self.Axes:
-self.HandleCursorMove(event)
+if self.MouseStartPos is not None:
-elif self.MouseStartPos is not None and len(self.Items) == 1:
+self.HandleCursorMove(event)
-xw, yw = self.GetPosition()
+elif self.MouseStartPos is not None and len(self.Items) == 1:
-self.ParentWindow.SetCursorTick(self.StartCursorTick)
+xw, yw = self.GetPosition()
-self.ParentWindow.StartDragNDrop(self,
+self.ParentWindow.SetCursorTick(self.StartCursorTick)
-self.Items[0],
+self.ParentWindow.StartDragNDrop(self,
-event.x + xw, height - event.y + yw,
+self.Items[0],
-self.MouseStartPos.x + xw, self.MouseStartPos.y + yw)
+event.x + xw, height - event.y + yw,
-elif event.button == 2 and self.GraphType == GRAPH_PARALLEL:
+self.MouseStartPos.x + xw, self.MouseStartPos.y + yw)
-start_tick, end_tick = self.ParentWindow.GetRange()
+elif event.button == 2 and self.GraphType == GRAPH_PARALLEL:
-rect = self.GetAxesBoundingBox()
+start_tick, end_tick = self.ParentWindow.GetRange()
-self.ParentWindow.SetCanvasPosition(
+rect = self.GetAxesBoundingBox()
-self.StartCursorTick + (self.MouseStartPos.x - event.x) *
+self.ParentWindow.SetCanvasPosition(
-(end_tick - start_tick) / rect.width)
+self.StartCursorTick + (self.MouseStartPos.x - event.x) *
+(end_tick - start_tick) / rect.width)
+if event.button == 1 and self.CanvasStartSize is not None:
+width, height = self.Canvas.GetSize()
+self.SetCanvasSize(width,
+self.CanvasStartSize.height + height - event.y - self.MouseStartPos.y)
 elif event.button in [None, "up", "down"]:
 if self.GraphType == GRAPH_PARALLEL:
 orientation = [wx.RIGHT] * len(self.AxesLabels) + [wx.LEFT] * len(self.Labels)
 elif len(self.AxesLabels) > 0:
 orientation = [wx.RIGHT, wx.TOP, wx.LEFT, wx.BOTTOM]
 item_idx = None
 item_style = None
 for (i, t), style in zip([pair for pair in enumerate(self.AxesLabels)] +
 if item_idx is not None:
 self.Canvas.PopupContextualButtons(self.Items[item_idx], rect, item_style)
 return
 if not self.Canvas.IsOverContextualButton(event.x, height - event.y):
 self.Canvas.DismissContextualButtons()
+if event.y <= 5:
+if self.Canvas.SetHighlight(HIGHLIGHT_RESIZE):
+self.Canvas.SetCursor(wx.StockCursor(wx.CURSOR_SIZENS))
+self.ParentWindow.ForceRefresh()
+else:
+if self.Canvas.SetHighlight(HIGHLIGHT_NONE):
+self.Canvas.SetCursor(wx.NullCursor)
+self.ParentWindow.ForceRefresh()
 def OnCanvasMouseDragging(self, x, y):
 xw, yw = self.GetPosition()
 self.ParentWindow.RefreshHighlight(x + xw, y + yw)
 start_tick, end_tick = self.ParentWindow.GetRange()
 tick = (start_tick + end_tick) / 2.
 else:
 tick = event.xdata
 self.ParentWindow.ChangeRange(int(-event.step) / 3, tick)
+def OnCanvasLeave(self, event):
+if self.CanvasStartSize is None and self.Canvas.SetHighlight(HIGHLIGHT_NONE):
+self.Canvas.SetCursor(wx.NullCursor)
+self.ParentWindow.ForceRefresh()
+event.Skip()
 def HighlightCanvas(self, highlight):
 self.Canvas.SetHighlight(highlight)
 def HandleCursorMove(self, event):

changeset 937	bd6fdbb61784
parent 936	364d178df2d3
child 938	ef1bfe848bf9