1 #!/usr/bin/env python

     2 # -*- coding: utf-8 -*-

     3 

     4 #This file is part of PLCOpenEditor, a library implementing an IEC 61131-3 editor

     5 #based on the plcopen standard. 

     6 #

     7 #Copyright (C) 2012: Edouard TISSERANT and Laurent BESSARD

     8 #

     9 #See COPYING file for copyrights details.

    10 #

    11 #This library is free software; you can redistribute it and/or

    12 #modify it under the terms of the GNU General Public

    13 #License as published by the Free Software Foundation; either

    14 #version 2.1 of the License, or (at your option) any later version.

    15 #

    16 #This library is distributed in the hope that it will be useful,

    17 #but WITHOUT ANY WARRANTY; without even the implied warranty of

    18 #MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    19 #General Public License for more details.

    20 #

    21 #You should have received a copy of the GNU General Public

    22 #License along with this library; if not, write to the Free Software

    23 #Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    24 

    25 from types import TupleType

    26 from time import time as gettime

    27 import math

    28 import numpy

    29 

    30 import wx

    31 import wx.lib.buttons

    32 

    33 import matplotlib

    34 matplotlib.use('WX')

    35 import matplotlib.pyplot

    36 from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg as FigureCanvas

    37 from matplotlib.backends.backend_wxagg import _convert_agg_to_wx_bitmap

    38 from matplotlib.backends.backend_agg import FigureCanvasAgg

    39 from mpl_toolkits.mplot3d import Axes3D

    40 color_cycle = ['r', 'b', 'g', 'm', 'y', 'k']

    41 cursor_color = '#800080'

    42 

    43 from editors.DebugViewer import DebugViewer, REFRESH_PERIOD

    44 from controls.DebugVariablePanel.DebugVariableItem import DebugVariableItem

    45 from dialogs.ForceVariableDialog import ForceVariableDialog

    46 from util.BitmapLibrary import GetBitmap

    47 

    48 class DebugVariableDropTarget(wx.TextDropTarget):

    49     

    50     def __init__(self, parent, control=None):

    51         wx.TextDropTarget.__init__(self)

    52         self.ParentWindow = parent

    53         self.ParentControl = control

    54     

    55     def __del__(self):

    56         self.ParentWindow = None

    57         self.ParentControl = None

    58     

    59     def OnDragOver(self, x, y, d):

    60         if self.ParentControl is not None:

    61             self.ParentControl.OnMouseDragging(x, y)

    62         else:

    63             self.ParentWindow.RefreshHighlight(x, y)

    64         return wx.TextDropTarget.OnDragOver(self, x, y, d)

    65         

    66     def OnDropText(self, x, y, data):

    67         message = None

    68         try:

    69             values = eval(data)

    70         except:

    71             message = _("Invalid value \"%s\" for debug variable")%data

    72             values = None

    73         if not isinstance(values, TupleType):

    74             message = _("Invalid value \"%s\" for debug variable")%data

    75             values = None

    76         

    77         if message is not None:

    78             wx.CallAfter(self.ShowMessage, message)

    79         elif values is not None and values[1] == "debug":

    80             if self.ParentControl is not None:

    81                 width, height = self.ParentControl.GetSize()

    82                 target_idx = self.ParentControl.GetIndex()

    83                 merge_type = GRAPH_PARALLEL

    84                 if isinstance(self.ParentControl, DebugVariableGraphic):

    85                     if self.ParentControl.Is3DCanvas():

    86                         if y > height / 2:

    87                             target_idx += 1

    88                         if len(values) > 1 and values[2] == "move":

    89                             self.ParentWindow.MoveValue(values[0], target_idx)

    90                         else:

    91                             self.ParentWindow.InsertValue(values[0], target_idx, force=True)

    92                         

    93                     else:

    94                         rect = self.ParentControl.GetAxesBoundingBox()

    95                         if rect.InsideXY(x, y):

    96                             merge_rect = wx.Rect(rect.x, rect.y, rect.width / 2., rect.height)

    97                             if merge_rect.InsideXY(x, y):

    98                                 merge_type = GRAPH_ORTHOGONAL

    99                             wx.CallAfter(self.ParentWindow.MergeGraphs, values[0], target_idx, merge_type, force=True)

   100                         else:

   101                             if y > height / 2:

   102                                 target_idx += 1

   103                             if len(values) > 2 and values[2] == "move":

   104                                 self.ParentWindow.MoveValue(values[0], target_idx)

   105                             else:

   106                                 self.ParentWindow.InsertValue(values[0], target_idx, force=True)

   107                 else:

   108                     if y > height / 2:

   109                         target_idx += 1

   110                     if len(values) > 2 and values[2] == "move":

   111                         self.ParentWindow.MoveValue(values[0], target_idx)

   112                     else:

   113                         self.ParentWindow.InsertValue(values[0], target_idx, force=True)

   114                     

   115             elif len(values) > 2 and values[2] == "move":

   116                 self.ParentWindow.MoveValue(values[0])

   117             else:

   118                 self.ParentWindow.InsertValue(values[0], force=True)

   119     

   120     def OnLeave(self):

   121         self.ParentWindow.ResetHighlight()

   122         return wx.TextDropTarget.OnLeave(self)

   123     

   124     def ShowMessage(self, message):

   125         dialog = wx.MessageDialog(self.ParentWindow, message, _("Error"), wx.OK|wx.ICON_ERROR)

   126         dialog.ShowModal()

   127         dialog.Destroy()

   128 

   129 MILLISECOND = 1000000

   130 SECOND = 1000 * MILLISECOND

   131 MINUTE = 60 * SECOND

   132 HOUR = 60 * MINUTE

   133 DAY = 24 * HOUR

   134 

   135 ZOOM_VALUES = map(lambda x:("x %.1f" % x, x), [math.sqrt(2) ** i for i in xrange(8)])

   136 RANGE_VALUES = \

   137     [("%dms" % i, i * MILLISECOND) for i in (10, 20, 50, 100, 200, 500)] + \

   138     [("%ds" % i, i * SECOND) for i in (1, 2, 5, 10, 20, 30)] + \

   139     [("%dm" % i, i * MINUTE) for i in (1, 2, 5, 10, 20, 30)] + \

   140     [("%dh" % i, i * HOUR) for i in (1, 2, 3, 6, 12, 24)]

   141 

   142 GRAPH_PARALLEL, GRAPH_ORTHOGONAL = range(2)

   143 

   144 SCROLLBAR_UNIT = 10

   145 

   146 #CANVAS_HIGHLIGHT_TYPES

   147 [HIGHLIGHT_NONE,

   148  HIGHLIGHT_BEFORE,

   149  HIGHLIGHT_AFTER,

   150  HIGHLIGHT_LEFT,

   151  HIGHLIGHT_RIGHT,

   152  HIGHLIGHT_RESIZE] = range(6)

   153 

   154 HIGHLIGHT_DROP_PEN = wx.Pen(wx.Colour(0, 128, 255))

   155 HIGHLIGHT_DROP_BRUSH = wx.Brush(wx.Colour(0, 128, 255, 128))

   156 HIGHLIGHT_RESIZE_PEN = wx.Pen(wx.Colour(200, 200, 200))

   157 HIGHLIGHT_RESIZE_BRUSH = wx.Brush(wx.Colour(200, 200, 200))

   158 

   159 #CANVAS_SIZE_TYPES

   160 [SIZE_MINI, SIZE_MIDDLE, SIZE_MAXI] = [0, 100, 200]

   161 

   162 DEFAULT_CANVAS_HEIGHT = 200.

   163 CANVAS_BORDER = (20., 10.)

   164 CANVAS_PADDING = 8.5

   165 VALUE_LABEL_HEIGHT = 17.

   166 AXES_LABEL_HEIGHT = 12.75

   167 

   168 def compute_mask(x, y):

   169     mask = []

   170     for xp, yp in zip(x, y):

   171         if xp == yp:

   172             mask.append(xp)

   173         else:

   174             mask.append("*")

   175     return mask

   176 

   177 def NextTick(variables):

   178     next_tick = None

   179     for item, data in variables:

   180         if len(data) > 0:

   181             if next_tick is None:

   182                 next_tick = data[0][0]

   183             else:

   184                 next_tick = min(next_tick, data[0][0])

   185     return next_tick

   186 

   187 def OrthogonalData(item, start_tick, end_tick):

   188     data = item.GetData(start_tick, end_tick)

   189     min_value, max_value = item.GetValueRange()

   190     if min_value is not None and max_value is not None:

   191         center = (min_value + max_value) / 2.

   192         range = max(1.0, max_value - min_value)

   193     else:

   194         center = 0.5

   195         range = 1.0

   196     return data, center - range * 0.55, center + range * 0.55

   197 

   198 class GraphButton():

   199     

   200     def __init__(self, x, y, bitmap, callback):

   201         self.Position = wx.Point(x, y)

   202         self.Bitmap = bitmap

   203         self.Shown = True

   204         self.Enabled = True

   205         self.Callback = callback

   206     

   207     def __del__(self):

   208         self.callback = None

   209     

   210     def GetSize(self):

   211         return self.Bitmap.GetSize()

   212     

   213     def SetPosition(self, x, y):

   214         self.Position = wx.Point(x, y)

   215     

   216     def Show(self):

   217         self.Shown = True

   218         

   219     def Hide(self):

   220         self.Shown = False

   221     

   222     def IsShown(self):

   223         return self.Shown

   224     

   225     def Enable(self):

   226         self.Enabled = True

   227     

   228     def Disable(self):

   229         self.Enabled = False

   230     

   231     def IsEnabled(self):

   232         return self.Enabled

   233     

   234     def HitTest(self, x, y):

   235         if self.Shown and self.Enabled:

   236             w, h = self.Bitmap.GetSize()

   237             rect = wx.Rect(self.Position.x, self.Position.y, w, h)

   238             if rect.InsideXY(x, y):

   239                 return True

   240         return False

   241     

   242     def ProcessCallback(self):

   243         if self.Callback is not None:

   244             wx.CallAfter(self.Callback)

   245             

   246     def Draw(self, dc):

   247         if self.Shown and self.Enabled:

   248             dc.DrawBitmap(self.Bitmap, self.Position.x, self.Position.y, True)

   249 

   250 class DebugVariableViewer:

   251     

   252     def __init__(self, window, items=[]):

   253         self.ParentWindow = window

   254         self.Items = items

   255         

   256         self.Highlight = HIGHLIGHT_NONE

   257         self.Buttons = []

   258     

   259     def __del__(self):

   260         self.ParentWindow = None

   261     

   262     def GetIndex(self):

   263         return self.ParentWindow.GetViewerIndex(self)

   264     

   265     def GetItem(self, variable):

   266         for item in self.Items:

   267             if item.GetVariable() == variable:

   268                 return item

   269         return None

   270     

   271     def GetItems(self):

   272         return self.Items

   273     

   274     def GetVariables(self):

   275         if len(self.Items) > 1:

   276             variables = [item.GetVariable() for item in self.Items]

   277             if self.GraphType == GRAPH_ORTHOGONAL:

   278                 return tuple(variables)

   279             return variables

   280         return self.Items[0].GetVariable()

   281     

   282     def AddItem(self, item):

   283         self.Items.append(item)

   284         

   285     def RemoveItem(self, item):

   286         if item in self.Items:

   287             self.Items.remove(item)

   288         

   289     def Clear(self):

   290         for item in self.Items:

   291             self.ParentWindow.RemoveDataConsumer(item)

   292         self.Items = []

   293         

   294     def IsEmpty(self):

   295         return len(self.Items) == 0

   296     

   297     def UnregisterObsoleteData(self):

   298         for item in self.Items[:]:

   299             iec_path = item.GetVariable()

   300             if self.ParentWindow.GetDataType(iec_path) is None:

   301                 self.ParentWindow.RemoveDataConsumer(item)

   302                 self.RemoveItem(item)

   303             else:

   304                 self.ParentWindow.AddDataConsumer(iec_path.upper(), item)

   305                 item.RefreshVariableType()

   306         

   307     def ResetData(self):

   308         for item in self.Items:

   309             item.ResetData()

   310     

   311     def RefreshViewer(self):

   312         pass

   313     

   314     def SetHighlight(self, highlight):

   315         if self.Highlight != highlight:

   316             self.Highlight = highlight

   317             return True

   318         return False

   319     

   320     def GetButtons(self):

   321         return self.Buttons

   322     

   323     def HandleButtons(self, x, y):

   324         for button in self.GetButtons():

   325             if button.HitTest(x, y):

   326                 button.ProcessCallback()

   327                 return True

   328         return False

   329     

   330     def IsOverButton(self, x, y):

   331         for button in self.GetButtons():

   332             if button.HitTest(x, y):

   333                 return True

   334         return False

   335     

   336     def ShowButtons(self, show):

   337         for button in self.Buttons:

   338             if show:

   339                 button.Show()

   340             else:

   341                 button.Hide()

   342         self.RefreshButtonsState()

   343         self.ParentWindow.ForceRefresh()

   344     

   345     def RefreshButtonsState(self, refresh_positions=False):

   346         if self:

   347             width, height = self.GetSize()

   348             if refresh_positions:

   349                 offset = 0

   350                 buttons = self.Buttons[:]

   351                 buttons.reverse()

   352                 for button in buttons:

   353                     w, h = button.GetSize()

   354                     button.SetPosition(width - 5 - w - offset, 5)

   355                     offset += w + 2

   356                 self.ParentWindow.ForceRefresh()

   357     

   358     def DrawCommonElements(self, dc, buttons=None):

   359         width, height = self.GetSize()

   360         

   361         dc.SetPen(HIGHLIGHT_DROP_PEN)

   362         dc.SetBrush(HIGHLIGHT_DROP_BRUSH)

   363         if self.Highlight in [HIGHLIGHT_BEFORE]:

   364             dc.DrawLine(0, 1, width - 1, 1)

   365         elif self.Highlight in [HIGHLIGHT_AFTER]:

   366             dc.DrawLine(0, height - 1, width - 1, height - 1)

   367         

   368         if buttons is None:

   369             buttons = self.Buttons

   370         for button in buttons:

   371             button.Draw(dc)

   372             

   373         if self.ParentWindow.IsDragging():

   374             destBBox = self.ParentWindow.GetDraggingAxesClippingRegion(self)

   375             srcPos = self.ParentWindow.GetDraggingAxesPosition(self)

   376             if destBBox.width > 0 and destBBox.height > 0:

   377                 srcPanel = self.ParentWindow.DraggingAxesPanel

   378                 srcBBox = srcPanel.GetAxesBoundingBox()

   379                 

   380                 if destBBox.x == 0:

   381                     srcX = srcBBox.x - srcPos.x

   382                 else:

   383                     srcX = srcBBox.x

   384                 if destBBox.y == 0:

   385                     srcY = srcBBox.y - srcPos.y

   386                 else:

   387                     srcY = srcBBox.y

   388                 

   389                 srcBmp = _convert_agg_to_wx_bitmap(srcPanel.get_renderer(), None)

   390                 srcDC = wx.MemoryDC()

   391                 srcDC.SelectObject(srcBmp)

   392                 

   393                 dc.Blit(destBBox.x, destBBox.y, 

   394                         int(destBBox.width), int(destBBox.height), 

   395                         srcDC, srcX, srcY)

   396     

   397     def OnEnter(self, event):

   398         self.ShowButtons(True)

   399         event.Skip()

   400         

   401     def OnLeave(self, event):

   402         if self.Highlight != HIGHLIGHT_RESIZE or self.CanvasStartSize is None:

   403             x, y = event.GetPosition()

   404             width, height = self.GetSize()

   405             if (x <= 0 or x >= width - 1 or

   406                 y <= 0 or y >= height - 1):

   407                 self.ShowButtons(False)

   408         event.Skip()

   409     

   410     def OnCloseButton(self):

   411         wx.CallAfter(self.ParentWindow.DeleteValue, self)

   412     

   413     def OnForceButton(self):

   414         wx.CallAfter(self.ForceValue, self.Items[0])

   415         

   416     def OnReleaseButton(self):

   417         wx.CallAfter(self.ReleaseValue, self.Items[0])

   418     

   419     def OnResizeWindow(self, event):

   420         wx.CallAfter(self.RefreshButtonsState, True)

   421         event.Skip()

   422     

   423     def OnMouseDragging(self, x, y):

   424         xw, yw = self.GetPosition()

   425         self.ParentWindow.RefreshHighlight(x + xw, y + yw)

   426     

   427     def OnDragging(self, x, y):

   428         width, height = self.GetSize()

   429         if y < height / 2:

   430             if self.ParentWindow.IsViewerFirst(self):

   431                 self.SetHighlight(HIGHLIGHT_BEFORE)

   432             else:

   433                 self.SetHighlight(HIGHLIGHT_NONE)

   434                 self.ParentWindow.HighlightPreviousViewer(self)

   435         else:

   436             self.SetHighlight(HIGHLIGHT_AFTER)

   437     

   438     def OnEraseBackground(self, event):

   439         pass

   440     

   441     def OnResize(self, event):

   442         wx.CallAfter(self.RefreshButtonsState, True)

   443         event.Skip()

   444     

   445     def ForceValue(self, item):

   446         iec_path = item.GetVariable()

   447         iec_type = self.ParentWindow.GetDataType(iec_path)

   448         if iec_type is not None:

   449             dialog = ForceVariableDialog(self, iec_type, str(item.GetValue()))

   450             if dialog.ShowModal() == wx.ID_OK:

   451                 self.ParentWindow.ForceDataValue(iec_path.upper(), dialog.GetValue())

   452     

   453     def ReleaseValue(self, item):

   454         iec_path = item.GetVariable().upper()

   455         self.ParentWindow.ReleaseDataValue(iec_path)

   456 

   457 

   458 class DebugVariableText(DebugVariableViewer, wx.Panel):

   459     

   460     def __init__(self, parent, window, items=[]):

   461         DebugVariableViewer.__init__(self, window, items)

   462         

   463         wx.Panel.__init__(self, parent)

   464         self.SetBackgroundColour(wx.WHITE)

   465         self.SetDropTarget(DebugVariableDropTarget(window, self))

   466         self.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown)

   467         self.Bind(wx.EVT_LEFT_UP, self.OnLeftUp)

   468         self.Bind(wx.EVT_ENTER_WINDOW, self.OnEnter)

   469         self.Bind(wx.EVT_LEAVE_WINDOW, self.OnLeave)

   470         self.Bind(wx.EVT_SIZE, self.OnResize)

   471         self.Bind(wx.EVT_ERASE_BACKGROUND, self.OnEraseBackground)

   472         self.Bind(wx.EVT_PAINT, self.OnPaint)

   473         

   474         self.SetMinSize(wx.Size(0, 25))

   475         

   476         self.Buttons.append(

   477             GraphButton(0, 0, GetBitmap("force"), self.OnForceButton))

   478         self.Buttons.append(

   479             GraphButton(0, 0, GetBitmap("release"), self.OnReleaseButton))

   480         self.Buttons.append(

   481             GraphButton(0, 0, GetBitmap("delete_graph"), self.OnCloseButton))

   482         

   483         self.ShowButtons(False)

   484         

   485     def RefreshViewer(self):

   486         width, height = self.GetSize()

   487         bitmap = wx.EmptyBitmap(width, height)

   488         

   489         dc = wx.BufferedDC(wx.ClientDC(self), bitmap)

   490         dc.Clear()

   491         dc.BeginDrawing()

   492         

   493         gc = wx.GCDC(dc)

   494         

   495         item_name = self.Items[0].GetVariable(self.ParentWindow.GetVariableNameMask())

   496         w, h = gc.GetTextExtent(item_name)

   497         gc.DrawText(item_name, 20, (height - h) / 2)

   498         

   499         if self.Items[0].IsForced():

   500             gc.SetTextForeground(wx.BLUE)

   501             self.Buttons[0].Disable()

   502             self.Buttons[1].Enable()

   503         else:

   504             self.Buttons[1].Disable()

   505             self.Buttons[0].Enable()

   506         self.RefreshButtonsState(True)

   507         

   508         item_value = self.Items[0].GetValue()

   509         w, h = gc.GetTextExtent(item_value)

   510         gc.DrawText(item_value, width - 40 - w, (height - h) / 2)

   511         

   512         self.DrawCommonElements(gc)

   513         

   514         gc.EndDrawing()

   515     

   516     def OnLeftDown(self, event):

   517         width, height = self.GetSize()

   518         item_name = self.Items[0].GetVariable(self.ParentWindow.GetVariableNameMask())

   519         w, h = self.GetTextExtent(item_name)

   520         x, y = event.GetPosition()

   521         rect = wx.Rect(20, (height - h) / 2, w, h)

   522         if rect.InsideXY(x, y):

   523             data = wx.TextDataObject(str((self.Items[0].GetVariable(), "debug", "move")))

   524             dragSource = wx.DropSource(self)

   525             dragSource.SetData(data)

   526             dragSource.DoDragDrop()

   527         else:

   528             event.Skip()

   529     

   530     def OnLeftUp(self, event):

   531         x, y = event.GetPosition()

   532         wx.CallAfter(self.HandleButtons, x, y)

   533         event.Skip()

   534     

   535     def OnPaint(self, event):

   536         self.RefreshViewer()

   537         event.Skip()

   538 

   539 class DebugVariableGraphic(DebugVariableViewer, FigureCanvas):

   540     

   541     def __init__(self, parent, window, items, graph_type):

   542         DebugVariableViewer.__init__(self, window, items)

   543         

   544         self.CanvasSize = SIZE_MINI

   545         self.GraphType = graph_type

   546         self.CursorTick = None

   547         self.MouseStartPos = None

   548         self.StartCursorTick = None

   549         self.CanvasStartSize = None

   550         self.ContextualButtons = []

   551         self.ContextualButtonsItem = None

   552         

   553         self.Figure = matplotlib.figure.Figure(facecolor='w')

   554         self.Figure.subplotpars.update(top=0.95, left=0.1, bottom=0.1, right=0.95)

   555         

   556         FigureCanvas.__init__(self, parent, -1, self.Figure)

   557         self.SetWindowStyle(wx.WANTS_CHARS)

   558         self.SetBackgroundColour(wx.WHITE)

   559         self.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown)

   560         self.Bind(wx.EVT_ENTER_WINDOW, self.OnEnter)

   561         self.Bind(wx.EVT_LEAVE_WINDOW, self.OnLeave)

   562         self.Bind(wx.EVT_ERASE_BACKGROUND, self.OnEraseBackground)

   563         self.Bind(wx.EVT_SIZE, self.OnResize)

   564         

   565         canvas_size = self.GetCanvasMinSize()

   566         self.SetMinSize(canvas_size)

   567         self.SetDropTarget(DebugVariableDropTarget(self.ParentWindow, self))

   568         self.mpl_connect('button_press_event', self.OnCanvasButtonPressed)

   569         self.mpl_connect('motion_notify_event', self.OnCanvasMotion)

   570         self.mpl_connect('button_release_event', self.OnCanvasButtonReleased)

   571         self.mpl_connect('scroll_event', self.OnCanvasScroll)

   572         

   573         for size, bitmap in zip([SIZE_MINI, SIZE_MIDDLE, SIZE_MAXI],

   574                                 ["minimize_graph", "middle_graph", "maximize_graph"]):

   575             self.Buttons.append(GraphButton(0, 0, GetBitmap(bitmap), self.GetOnChangeSizeButton(size)))

   576         self.Buttons.append(

   577             GraphButton(0, 0, GetBitmap("export_graph_mini"), self.OnExportGraphButton))

   578         self.Buttons.append(

   579             GraphButton(0, 0, GetBitmap("delete_graph"), self.OnCloseButton))

   580         

   581         self.ResetGraphics()

   582         self.RefreshLabelsPosition(canvas_size.height)

   583         self.ShowButtons(False)

   584     

   585     def draw(self, drawDC=None):

   586         FigureCanvasAgg.draw(self)

   587 

   588         self.bitmap = _convert_agg_to_wx_bitmap(self.get_renderer(), None)

   589         self.bitmap.UseAlpha() 

   590         width, height = self.GetSize()

   591         bbox = self.GetAxesBoundingBox()

   592         

   593         destDC = wx.MemoryDC()

   594         destDC.SelectObject(self.bitmap)

   595         

   596         destGC = wx.GCDC(destDC)

   597         

   598         destGC.BeginDrawing()

   599         if self.Highlight == HIGHLIGHT_RESIZE:

   600             destGC.SetPen(HIGHLIGHT_RESIZE_PEN)

   601             destGC.SetBrush(HIGHLIGHT_RESIZE_BRUSH)

   602             destGC.DrawRectangle(0, height - 5, width, 5)

   603         else:

   604             destGC.SetPen(HIGHLIGHT_DROP_PEN)

   605             destGC.SetBrush(HIGHLIGHT_DROP_BRUSH)

   606             if self.Highlight == HIGHLIGHT_LEFT:

   607                 destGC.DrawRectangle(bbox.x, bbox.y, 

   608                                      bbox.width / 2, bbox.height)

   609             elif self.Highlight == HIGHLIGHT_RIGHT:

   610                 destGC.DrawRectangle(bbox.x + bbox.width / 2, bbox.y, 

   611                                      bbox.width / 2, bbox.height)

   612         

   613         self.DrawCommonElements(destGC, self.Buttons + self.ContextualButtons)

   614         

   615         destGC.EndDrawing()

   616         

   617         self._isDrawn = True

   618         self.gui_repaint(drawDC=drawDC)

   619     

   620     def GetButtons(self):

   621         return self.Buttons + self.ContextualButtons

   622     

   623     def PopupContextualButtons(self, item, rect, style=wx.RIGHT):

   624         if self.ContextualButtonsItem is not None and item != self.ContextualButtonsItem:

   625             self.DismissContextualButtons()

   626         

   627         if self.ContextualButtonsItem is None:

   628             self.ContextualButtonsItem = item

   629             

   630             if self.ContextualButtonsItem.IsForced():

   631                 self.ContextualButtons.append(

   632                     GraphButton(0, 0, GetBitmap("release"), self.OnReleaseButton))

   633             self.ContextualButtons.append(

   634                 GraphButton(0, 0, GetBitmap("force"), self.OnForceButton))

   635             self.ContextualButtons.append(

   636                 GraphButton(0, 0, GetBitmap("export_graph_mini"), self.OnExportItemGraphButton))

   637             self.ContextualButtons.append(

   638                 GraphButton(0, 0, GetBitmap("delete_graph"), self.OnRemoveItemButton))

   639             

   640             offset = 0

   641             buttons = self.ContextualButtons[:]

   642             if style in [wx.TOP, wx.LEFT]:

   643                  buttons.reverse()

   644             for button in buttons:

   645                 w, h = button.GetSize()

   646                 if style in [wx.LEFT, wx.RIGHT]:

   647                     if style == wx.LEFT:

   648                         x = rect.x - w - offset

   649                     else:

   650                         x = rect.x + rect.width + offset

   651                     y = rect.y + (rect.height - h) / 2

   652                     offset += w

   653                 else:

   654                     x = rect.x + (rect.width - w ) / 2

   655                     if style == wx.TOP:

   656                         y = rect.y - h - offset

   657                     else:

   658                         y = rect.y + rect.height + offset

   659                     offset += h

   660                 button.SetPosition(x, y)

   661             self.ParentWindow.ForceRefresh()

   662     

   663     def DismissContextualButtons(self):

   664         if self.ContextualButtonsItem is not None:

   665             self.ContextualButtonsItem = None

   666             self.ContextualButtons = []

   667             self.ParentWindow.ForceRefresh()

   668     

   669     def IsOverContextualButton(self, x, y):

   670         for button in self.ContextualButtons:

   671             if button.HitTest(x, y):

   672                 return True

   673         return False

   674     

   675     def SetMinSize(self, size):

   676         wx.Window.SetMinSize(self, size)

   677         wx.CallAfter(self.RefreshButtonsState)

   678     

   679     def GetOnChangeSizeButton(self, size):

   680         def OnChangeSizeButton():

   681             self.CanvasSize = size

   682             self.SetCanvasSize(200, self.CanvasSize)

   683         return OnChangeSizeButton

   684     

   685     def OnExportGraphButton(self):

   686         self.ExportGraph()

   687     

   688     def OnForceButton(self):

   689         wx.CallAfter(self.ForceValue, 

   690                      self.ContextualButtonsItem)

   691         self.DismissContextualButtons()

   692         

   693     def OnReleaseButton(self):

   694         wx.CallAfter(self.ReleaseValue, 

   695                      self.ContextualButtonsItem)

   696         self.DismissContextualButtons()

   697     

   698     def OnExportItemGraphButton(self):

   699         wx.CallAfter(self.ExportGraph, 

   700                      self.ContextualButtonsItem)

   701         self.DismissContextualButtons()

   702         

   703     def OnRemoveItemButton(self):            

   704         wx.CallAfter(self.ParentWindow.DeleteValue, self, 

   705                      self.ContextualButtonsItem)

   706         self.DismissContextualButtons()

   707     

   708     def RefreshLabelsPosition(self, height):

   709         canvas_ratio = 1. / height

   710         graph_ratio = 1. / ((1.0 - (CANVAS_BORDER[0] + CANVAS_BORDER[1]) * canvas_ratio) * height)

   711         

   712         self.Figure.subplotpars.update(

   713             top= 1.0 - CANVAS_BORDER[1] * canvas_ratio, 

   714             bottom= CANVAS_BORDER[0] * canvas_ratio)

   715         

   716         if self.GraphType == GRAPH_PARALLEL or self.Is3DCanvas():

   717             num_item = len(self.Items)

   718             for idx in xrange(num_item):

   719                 if not self.Is3DCanvas():

   720                     self.AxesLabels[idx].set_position(

   721                         (0.05, 

   722                          1.0 - (CANVAS_PADDING + AXES_LABEL_HEIGHT * idx) * graph_ratio))

   723                 self.Labels[idx].set_position(

   724                     (0.95, 

   725                      CANVAS_PADDING * graph_ratio + 

   726                      (num_item - idx - 1) * VALUE_LABEL_HEIGHT * graph_ratio))

   727         else:

   728             self.AxesLabels[0].set_position((0.1, CANVAS_PADDING * graph_ratio))

   729             self.Labels[0].set_position((0.95, CANVAS_PADDING * graph_ratio))

   730             self.AxesLabels[1].set_position((0.05, 2 * CANVAS_PADDING * graph_ratio))

   731             self.Labels[1].set_position((0.05, 1.0 - CANVAS_PADDING * graph_ratio))

   732     

   733         self.Figure.subplots_adjust()

   734     

   735     def GetCanvasMinSize(self):

   736         return wx.Size(200, 

   737                        CANVAS_BORDER[0] + CANVAS_BORDER[1] + 

   738                        2 * CANVAS_PADDING + VALUE_LABEL_HEIGHT * len(self.Items))

   739     

   740     def SetCanvasSize(self, width, height):

   741         height = max(height, self.GetCanvasMinSize()[1])

   742         self.SetMinSize(wx.Size(width, height))

   743         self.RefreshLabelsPosition(height)

   744         self.RefreshButtonsState()

   745         self.ParentWindow.RefreshGraphicsSizer()

   746         

   747     def GetAxesBoundingBox(self, absolute=False):

   748         width, height = self.GetSize()

   749         ax, ay, aw, ah = self.figure.gca().get_position().bounds

   750         bbox = wx.Rect(ax * width, height - (ay + ah) * height - 1,

   751                        aw * width + 2, ah * height + 1)

   752         if absolute:

   753             xw, yw = self.GetPosition()

   754             bbox.x += xw

   755             bbox.y += yw

   756         return bbox

   757     

   758     def OnCanvasButtonPressed(self, event):

   759         width, height = self.GetSize()

   760         x, y = event.x, height - event.y

   761         if not self.IsOverButton(x, y):

   762             if event.inaxes == self.Axes:

   763                 item_idx = None

   764                 for i, t in ([pair for pair in enumerate(self.AxesLabels)] + 

   765                              [pair for pair in enumerate(self.Labels)]):

   766                     (x0, y0), (x1, y1) = t.get_window_extent().get_points()

   767                     rect = wx.Rect(x0, height - y1, x1 - x0, y1 - y0)

   768                     if rect.InsideXY(x, y):

   769                         item_idx = i

   770                         break

   771                 if item_idx is not None:

   772                     self.ShowButtons(False)

   773                     self.DismissContextualButtons()

   774                     xw, yw = self.GetPosition()

   775                     self.ParentWindow.StartDragNDrop(self, 

   776                         self.Items[item_idx], x + xw, y + yw, x + xw, y + yw)

   777                 elif not self.Is3DCanvas():

   778                     self.MouseStartPos = wx.Point(x, y)

   779                     if event.button == 1 and event.inaxes == self.Axes:

   780                         self.StartCursorTick = self.CursorTick

   781                         self.HandleCursorMove(event)

   782                     elif event.button == 2 and self.GraphType == GRAPH_PARALLEL:

   783                         width, height = self.GetSize()

   784                         start_tick, end_tick = self.ParentWindow.GetRange()

   785                         self.StartCursorTick = start_tick

   786             

   787             elif event.button == 1 and event.y <= 5:

   788                 self.MouseStartPos = wx.Point(x, y)

   789                 self.CanvasStartSize = self.GetSize()

   790     

   791     def OnCanvasButtonReleased(self, event):

   792         if self.ParentWindow.IsDragging():

   793             width, height = self.GetSize()

   794             xw, yw = self.GetPosition()

   795             self.ParentWindow.StopDragNDrop(

   796                 self.ParentWindow.DraggingAxesPanel.Items[0].GetVariable(),

   797                 xw + event.x, 

   798                 yw + height - event.y)

   799         else:

   800             self.MouseStartPos = None

   801             self.StartCursorTick = None

   802             self.CanvasStartSize = None

   803             width, height = self.GetSize()

   804             self.HandleButtons(event.x, height - event.y)

   805             if event.y > 5 and self.SetHighlight(HIGHLIGHT_NONE):

   806                 self.SetCursor(wx.NullCursor)

   807                 self.ParentWindow.ForceRefresh()

   808     

   809     def OnCanvasMotion(self, event):

   810         width, height = self.GetSize()

   811         if self.ParentWindow.IsDragging():

   812             xw, yw = self.GetPosition()

   813             self.ParentWindow.MoveDragNDrop(

   814                 xw + event.x, 

   815                 yw + height - event.y)

   816         else:

   817             if not self.Is3DCanvas():

   818                 if event.button == 1 and self.CanvasStartSize is None:

   819                     if event.inaxes == self.Axes:

   820                         if self.MouseStartPos is not None:

   821                             self.HandleCursorMove(event)

   822                     elif self.MouseStartPos is not None and len(self.Items) == 1:

   823                         xw, yw = self.GetPosition()

   824                         self.ParentWindow.SetCursorTick(self.StartCursorTick)

   825                         self.ParentWindow.StartDragNDrop(self, 

   826                             self.Items[0],

   827                             event.x + xw, height - event.y + yw, 

   828                             self.MouseStartPos.x + xw, self.MouseStartPos.y + yw)

   829                 elif event.button == 2 and self.GraphType == GRAPH_PARALLEL and self.MouseStartPos is not None:

   830                     start_tick, end_tick = self.ParentWindow.GetRange()

   831                     rect = self.GetAxesBoundingBox()

   832                     self.ParentWindow.SetCanvasPosition(

   833                         self.StartCursorTick + (self.MouseStartPos.x - event.x) *

   834                         (end_tick - start_tick) / rect.width)    

   835             

   836             if event.button == 1 and self.CanvasStartSize is not None:

   837                 width, height = self.GetSize()

   838                 self.SetCanvasSize(width, 

   839                     self.CanvasStartSize.height + height - event.y - self.MouseStartPos.y)

   840                 

   841             elif event.button in [None, "up", "down"]:

   842                 if self.GraphType == GRAPH_PARALLEL:

   843                     orientation = [wx.RIGHT] * len(self.AxesLabels) + [wx.LEFT] * len(self.Labels)

   844                 elif len(self.AxesLabels) > 0:

   845                     orientation = [wx.RIGHT, wx.TOP, wx.LEFT, wx.BOTTOM]

   846                 else:

   847                     orientation = [wx.LEFT] * len(self.Labels)

   848                 item_idx = None

   849                 item_style = None

   850                 for (i, t), style in zip([pair for pair in enumerate(self.AxesLabels)] + 

   851                                          [pair for pair in enumerate(self.Labels)], 

   852                                          orientation):

   853                     (x0, y0), (x1, y1) = t.get_window_extent().get_points()

   854                     rect = wx.Rect(x0, height - y1, x1 - x0, y1 - y0)

   855                     if rect.InsideXY(event.x, height - event.y):

   856                         item_idx = i

   857                         item_style = style

   858                         break

   859                 if item_idx is not None:

   860                     self.PopupContextualButtons(self.Items[item_idx], rect, item_style)

   861                     return 

   862                 if not self.IsOverContextualButton(event.x, height - event.y):

   863                     self.DismissContextualButtons()

   864                 

   865                 if event.y <= 5:

   866                     if self.SetHighlight(HIGHLIGHT_RESIZE):

   867                         self.SetCursor(wx.StockCursor(wx.CURSOR_SIZENS))

   868                         self.ParentWindow.ForceRefresh()

   869                 else:

   870                     if self.SetHighlight(HIGHLIGHT_NONE):

   871                         self.SetCursor(wx.NullCursor)

   872                         self.ParentWindow.ForceRefresh()

   873     

   874     def OnCanvasScroll(self, event):

   875         if event.inaxes is not None and event.guiEvent.ControlDown():

   876             if self.GraphType == GRAPH_ORTHOGONAL:

   877                 start_tick, end_tick = self.ParentWindow.GetRange()

   878                 tick = (start_tick + end_tick) / 2.

   879             else:

   880                 tick = event.xdata

   881             self.ParentWindow.ChangeRange(int(-event.step) / 3, tick)

   882             self.ParentWindow.VetoScrollEvent = True

   883     

   884     def OnDragging(self, x, y):

   885         width, height = self.GetSize()

   886         bbox = self.GetAxesBoundingBox()

   887         if bbox.InsideXY(x, y) and not self.Is3DCanvas():

   888             rect = wx.Rect(bbox.x, bbox.y, bbox.width / 2, bbox.height)

   889             if rect.InsideXY(x, y):

   890                 self.SetHighlight(HIGHLIGHT_LEFT)

   891             else:

   892                 self.SetHighlight(HIGHLIGHT_RIGHT)

   893         elif y < height / 2:

   894             if self.ParentWindow.IsViewerFirst(self):

   895                 self.SetHighlight(HIGHLIGHT_BEFORE)

   896             else:

   897                 self.SetHighlight(HIGHLIGHT_NONE)

   898                 self.ParentWindow.HighlightPreviousViewer(self)

   899         else:

   900             self.SetHighlight(HIGHLIGHT_AFTER)

   901     

   902     def OnLeave(self, event):

   903         if self.CanvasStartSize is None and self.SetHighlight(HIGHLIGHT_NONE):

   904             self.SetCursor(wx.NullCursor)

   905             self.ParentWindow.ForceRefresh()

   906         DebugVariableViewer.OnLeave(self, event)

   907     

   908     KEY_CURSOR_INCREMENT = {

   909         wx.WXK_LEFT: -1,

   910         wx.WXK_RIGHT: 1,

   911         wx.WXK_UP: -10,

   912         wx.WXK_DOWN: 10}

   913     def OnKeyDown(self, event):

   914         if self.CursorTick is not None:

   915             move = self.KEY_CURSOR_INCREMENT.get(event.GetKeyCode(), None)

   916             if move is not None:

   917                 self.ParentWindow.MoveCursorTick(move)

   918         event.Skip()

   919     

   920     def HandleCursorMove(self, event):

   921         start_tick, end_tick = self.ParentWindow.GetRange()

   922         cursor_tick = None

   923         if self.GraphType == GRAPH_ORTHOGONAL:

   924             x_data = self.Items[0].GetData(start_tick, end_tick)

   925             y_data = self.Items[1].GetData(start_tick, end_tick)

   926             if len(x_data) > 0 and len(y_data) > 0:

   927                 length = min(len(x_data), len(y_data))

   928                 d = numpy.sqrt((x_data[:length,1]-event.xdata) ** 2 + (y_data[:length,1]-event.ydata) ** 2)

   929                 cursor_tick = x_data[numpy.argmin(d), 0]

   930         else:

   931             data = self.Items[0].GetData(start_tick, end_tick)

   932             if len(data) > 0:

   933                 cursor_tick = data[numpy.argmin(numpy.abs(data[:,0] - event.xdata)), 0]

   934         if cursor_tick is not None:

   935             self.ParentWindow.SetCursorTick(cursor_tick)

   936     

   937     def OnAxesMotion(self, event):

   938         if self.Is3DCanvas():

   939             current_time = gettime()

   940             if current_time - self.LastMotionTime > REFRESH_PERIOD:

   941                 self.LastMotionTime = current_time

   942                 Axes3D._on_move(self.Axes, event)

   943     

   944     def ResetGraphics(self):

   945         self.Figure.clear()

   946         if self.Is3DCanvas():

   947             self.Axes = self.Figure.gca(projection='3d')

   948             self.Axes.set_color_cycle(['b'])

   949             self.LastMotionTime = gettime()

   950             setattr(self.Axes, "_on_move", self.OnAxesMotion)

   951             self.Axes.mouse_init()

   952             self.Axes.tick_params(axis='z', labelsize='small')

   953         else:

   954             self.Axes = self.Figure.gca()

   955             self.Axes.set_color_cycle(color_cycle)

   956         self.Axes.tick_params(axis='x', labelsize='small')

   957         self.Axes.tick_params(axis='y', labelsize='small')

   958         self.Plots = []

   959         self.VLine = None

   960         self.HLine = None

   961         self.Labels = []

   962         self.AxesLabels = []

   963         if not self.Is3DCanvas():

   964             text_func = self.Axes.text

   965         else:

   966             text_func = self.Axes.text2D

   967         if self.GraphType == GRAPH_PARALLEL or self.Is3DCanvas():

   968             num_item = len(self.Items)

   969             for idx in xrange(num_item):

   970                 if num_item == 1:

   971                     color = 'k'

   972                 else:

   973                     color = color_cycle[idx % len(color_cycle)]

   974                 if not self.Is3DCanvas():

   975                     self.AxesLabels.append(

   976                         text_func(0, 0, "", size='small',

   977                                   verticalalignment='top', 

   978                                   color=color,

   979                                   transform=self.Axes.transAxes))

   980                 self.Labels.append(

   981                     text_func(0, 0, "", size='large', 

   982                               horizontalalignment='right',

   983                               color=color,

   984                               transform=self.Axes.transAxes))

   985         else:

   986             self.AxesLabels.append(

   987                 self.Axes.text(0, 0, "", size='small',

   988                                transform=self.Axes.transAxes))

   989             self.Labels.append(

   990                 self.Axes.text(0, 0, "", size='large',

   991                                horizontalalignment='right',

   992                                transform=self.Axes.transAxes))

   993             self.AxesLabels.append(

   994                 self.Axes.text(0, 0, "", size='small',

   995                                rotation='vertical',

   996                                verticalalignment='bottom',

   997                                transform=self.Axes.transAxes))

   998             self.Labels.append(

   999                 self.Axes.text(0, 0, "", size='large',

  1000                                rotation='vertical',

  1001                                verticalalignment='top',

  1002                                transform=self.Axes.transAxes))

  1003         width, height = self.GetSize()

  1004         self.RefreshLabelsPosition(height)

  1005         

  1006     def AddItem(self, item):

  1007         DebugVariableViewer.AddItem(self, item)

  1008         self.ResetGraphics()

  1009         

  1010     def RemoveItem(self, item):

  1011         DebugVariableViewer.RemoveItem(self, item)

  1012         if not self.IsEmpty():

  1013             if len(self.Items) == 1:

  1014                 self.GraphType = GRAPH_PARALLEL

  1015             self.ResetGraphics()

  1016     

  1017     def UnregisterObsoleteData(self):

  1018         DebugVariableViewer.UnregisterObsoleteData(self)

  1019         if not self.IsEmpty():

  1020             self.ResetGraphics()

  1021     

  1022     def Is3DCanvas(self):

  1023         return self.GraphType == GRAPH_ORTHOGONAL and len(self.Items) == 3

  1024     

  1025     def SetCursorTick(self, cursor_tick):

  1026         self.CursorTick = cursor_tick

  1027         

  1028     def RefreshViewer(self, refresh_graphics=True):

  1029         

  1030         if refresh_graphics:

  1031             start_tick, end_tick = self.ParentWindow.GetRange()

  1032             

  1033             if self.GraphType == GRAPH_PARALLEL:    

  1034                 min_value = max_value = None

  1035                 

  1036                 for idx, item in enumerate(self.Items):

  1037                     data = item.GetData(start_tick, end_tick)

  1038                     if data is not None:

  1039                         item_min_value, item_max_value = item.GetValueRange()

  1040                         if min_value is None:

  1041                             min_value = item_min_value

  1042                         elif item_min_value is not None:

  1043                             min_value = min(min_value, item_min_value)

  1044                         if max_value is None:

  1045                             max_value = item_max_value

  1046                         elif item_max_value is not None:

  1047                             max_value = max(max_value, item_max_value)

  1048                         

  1049                         if len(self.Plots) <= idx:

  1050                             self.Plots.append(

  1051                                 self.Axes.plot(data[:, 0], data[:, 1])[0])

  1052                         else:

  1053                             self.Plots[idx].set_data(data[:, 0], data[:, 1])

  1054                     

  1055                 if min_value is not None and max_value is not None:

  1056                     y_center = (min_value + max_value) / 2.

  1057                     y_range = max(1.0, max_value - min_value)

  1058                 else:

  1059                     y_center = 0.5

  1060                     y_range = 1.0

  1061                 x_min, x_max = start_tick, end_tick

  1062                 y_min, y_max = y_center - y_range * 0.55, y_center + y_range * 0.55

  1063                 

  1064                 if self.CursorTick is not None and start_tick <= self.CursorTick <= end_tick:

  1065                     if self.VLine is None:

  1066                         self.VLine = self.Axes.axvline(self.CursorTick, color=cursor_color)

  1067                     else:

  1068                         self.VLine.set_xdata((self.CursorTick, self.CursorTick))

  1069                     self.VLine.set_visible(True)

  1070                 else:

  1071                     if self.VLine is not None:

  1072                         self.VLine.set_visible(False)

  1073             else:

  1074                 min_start_tick = reduce(max, [item.GetData()[0, 0] 

  1075                                               for item in self.Items

  1076                                               if len(item.GetData()) > 0], 0)

  1077                 start_tick = max(start_tick, min_start_tick)

  1078                 end_tick = max(end_tick, min_start_tick)

  1079                 x_data, x_min, x_max = OrthogonalData(self.Items[0], start_tick, end_tick)

  1080                 y_data, y_min, y_max = OrthogonalData(self.Items[1], start_tick, end_tick)

  1081                 if self.CursorTick is not None:

  1082                     x_cursor, x_forced = self.Items[0].GetValue(self.CursorTick, raw=True)

  1083                     y_cursor, y_forced = self.Items[1].GetValue(self.CursorTick, raw=True)

  1084                 length = 0

  1085                 if x_data is not None and y_data is not None:  

  1086                     length = min(len(x_data), len(y_data))

  1087                 if len(self.Items) < 3:

  1088                     if x_data is not None and y_data is not None:

  1089                         if len(self.Plots) == 0:

  1090                             self.Plots.append(

  1091                                 self.Axes.plot(x_data[:, 1][:length], 

  1092                                                y_data[:, 1][:length])[0])

  1093                         else:

  1094                             self.Plots[0].set_data(

  1095                                 x_data[:, 1][:length], 

  1096                                 y_data[:, 1][:length])

  1097                     

  1098                     if self.CursorTick is not None and start_tick <= self.CursorTick <= end_tick:

  1099                         if self.VLine is None:

  1100                             self.VLine = self.Axes.axvline(x_cursor, color=cursor_color)

  1101                         else:

  1102                             self.VLine.set_xdata((x_cursor, x_cursor))

  1103                         if self.HLine is None:

  1104                             self.HLine = self.Axes.axhline(y_cursor, color=cursor_color)

  1105                         else:

  1106                             self.HLine.set_ydata((y_cursor, y_cursor))

  1107                         self.VLine.set_visible(True)

  1108                         self.HLine.set_visible(True)

  1109                     else:

  1110                         if self.VLine is not None:

  1111                             self.VLine.set_visible(False)

  1112                         if self.HLine is not None:

  1113                             self.HLine.set_visible(False)

  1114                 else:

  1115                     while len(self.Axes.lines) > 0:

  1116                         self.Axes.lines.pop()

  1117                     z_data, z_min, z_max = OrthogonalData(self.Items[2], start_tick, end_tick)

  1118                     if self.CursorTick is not None:

  1119                         z_cursor, z_forced = self.Items[2].GetValue(self.CursorTick, raw=True)

  1120                     if x_data is not None and y_data is not None and z_data is not None:

  1121                         length = min(length, len(z_data))

  1122                         self.Axes.plot(x_data[:, 1][:length],

  1123                                        y_data[:, 1][:length],

  1124                                        zs = z_data[:, 1][:length])

  1125                     self.Axes.set_zlim(z_min, z_max)

  1126                     if self.CursorTick is not None and start_tick <= self.CursorTick <= end_tick:

  1127                         for kwargs in [{"xs": numpy.array([x_min, x_max])},

  1128                                        {"ys": numpy.array([y_min, y_max])},

  1129                                        {"zs": numpy.array([z_min, z_max])}]:

  1130                             for param, value in [("xs", numpy.array([x_cursor, x_cursor])),

  1131                                                  ("ys", numpy.array([y_cursor, y_cursor])),

  1132                                                  ("zs", numpy.array([z_cursor, z_cursor]))]:

  1133                                 kwargs.setdefault(param, value)

  1134                             kwargs["color"] = cursor_color

  1135                             self.Axes.plot(**kwargs)