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, ListType, FloatType

    26 from time import time as gettime

    27 import math

    28 import numpy

    29 import binascii

    30 

    31 import wx

    32 import wx.lib.buttons

    33 

    34 try:

    35     import matplotlib

    36     matplotlib.use('WX')

    37     import matplotlib.pyplot

    38     from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg as FigureCanvas

    39     from matplotlib.backends.backend_wxagg import _convert_agg_to_wx_bitmap

    40     from matplotlib.backends.backend_agg import FigureCanvasAgg

    41     from mpl_toolkits.mplot3d import Axes3D

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

    43     cursor_color = '#800080'

    44     USE_MPL = True

    45 except:

    46     USE_MPL = False

    47 

    48 from graphics.DebugDataConsumer import DebugDataConsumer

    49 from editors.DebugViewer import DebugViewer, REFRESH_PERIOD

    50 from controls import CustomGrid, CustomTable

    51 from dialogs.ForceVariableDialog import ForceVariableDialog

    52 from util.BitmapLibrary import GetBitmap

    53 

    54 def AppendMenu(parent, help, id, kind, text):

    55     parent.Append(help=help, id=id, kind=kind, text=text)

    56 

    57 def GetDebugVariablesTableColnames():

    58     _ = lambda x : x

    59     return [_("Variable"), _("Value")]

    60 

    61 CRC_SIZE = 8

    62 CRC_MASK = 2 ** CRC_SIZE - 1

    63 

    64 class VariableTableItem(DebugDataConsumer):

    65     

    66     def __init__(self, parent, variable):

    67         DebugDataConsumer.__init__(self)

    68         self.Parent = parent

    69         self.Variable = variable

    70         self.RefreshVariableType()

    71         self.Value = ""

    72         

    73     def __del__(self):

    74         self.Parent = None

    75     

    76     def SetVariable(self, variable):

    77         if self.Parent and self.Variable != variable:

    78             self.Variable = variable

    79             self.RefreshVariableType()

    80             self.Parent.RefreshView()

    81     

    82     def GetVariable(self, mask=None):

    83         variable = self.Variable

    84         if mask is not None:

    85             parts = variable.split('.')

    86             mask = mask + ['*'] * max(0, len(parts) - len(mask))

    87             last = None

    88             variable = ""

    89             for m, v in zip(mask, parts):

    90                 if m == '*':

    91                     if last == '*':

    92                         variable += '.'

    93                     variable += v

    94                 elif last is None or last == '*':

    95                     variable += '..'

    96                 last = m

    97         return variable

    98     

    99     def RefreshVariableType(self):

   100         self.VariableType = self.Parent.GetDataType(self.Variable)

   101         if USE_MPL:

   102             self.ResetData()

   103     

   104     def GetVariableType(self):

   105         return self.VariableType

   106     

   107     def GetData(self, start_tick=None, end_tick=None):

   108         if USE_MPL and self.IsNumVariable():

   109             if len(self.Data) == 0:

   110                 return self.Data

   111             

   112             start_idx = end_idx = None

   113             if start_tick is not None:

   114                 start_idx = self.GetNearestData(start_tick, -1)

   115             if end_tick is not None:

   116                 end_idx = self.GetNearestData(end_tick, 1)

   117             if start_idx is None:

   118                 start_idx = 0

   119             if end_idx is not None:

   120                 return self.Data[start_idx:end_idx + 1]

   121             else:

   122                 return self.Data[start_idx:]

   123             

   124         return None

   125     

   126     def GetRawValue(self, idx):

   127         if self.VariableType in ["STRING", "WSTRING"] and idx < len(self.RawData):

   128             return self.RawData[idx][0]

   129         return ""

   130     

   131     def GetRange(self):

   132         return self.MinValue, self.MaxValue

   133     

   134     def ResetData(self):

   135         if self.IsNumVariable():

   136             self.Data = numpy.array([]).reshape(0, 3)

   137             if self.VariableType in ["STRING", "WSTRING"]:

   138                 self.RawData = []

   139             self.MinValue = None

   140             self.MaxValue = None

   141         else:

   142             self.Data = None

   143         self.Value = ""

   144     

   145     def IsNumVariable(self):

   146         return (self.Parent.IsNumType(self.VariableType) or 

   147                 self.VariableType in ["STRING", "WSTRING"])

   148     

   149     def NewValue(self, tick, value, forced=False):

   150         if USE_MPL and self.IsNumVariable():

   151             if self.VariableType in ["STRING", "WSTRING"]:

   152                 num_value = binascii.crc32(value) & CRC_MASK

   153             else:

   154                 num_value = float(value)

   155             if self.MinValue is None:

   156                 self.MinValue = num_value

   157             else:

   158                 self.MinValue = min(self.MinValue, num_value)

   159             if self.MaxValue is None:

   160                 self.MaxValue = num_value

   161             else:

   162                 self.MaxValue = max(self.MaxValue, num_value)

   163             forced_value = float(forced)

   164             if self.VariableType in ["STRING", "WSTRING"]:

   165                 raw_data = (value, forced_value)

   166                 if len(self.RawData) == 0 or self.RawData[-1] != raw_data:

   167                     extra_value = len(self.RawData)

   168                     self.RawData.append(raw_data)

   169                 else:

   170                     extra_value = len(self.RawData) - 1

   171             else:

   172                 extra_value = forced_value

   173             self.Data = numpy.append(self.Data, [[float(tick), num_value, extra_value]], axis=0)

   174             self.Parent.HasNewData = True

   175         DebugDataConsumer.NewValue(self, tick, value, forced)

   176     

   177     def SetForced(self, forced):

   178         if self.Forced != forced:

   179             self.Forced = forced

   180             self.Parent.HasNewData = True

   181     

   182     def SetValue(self, value):

   183         if (self.VariableType == "STRING" and value.startswith("'") and value.endswith("'") or

   184             self.VariableType == "WSTRING" and value.startswith('"') and value.endswith('"')):

   185             value = value[1:-1]

   186         if self.Value != value:

   187             self.Value = value

   188             self.Parent.HasNewData = True

   189             

   190     def GetValue(self, tick=None, raw=False):

   191         if tick is not None and self.IsNumVariable():

   192             if len(self.Data) > 0:

   193                 idx = numpy.argmin(abs(self.Data[:, 0] - tick))

   194                 if self.VariableType in ["STRING", "WSTRING"]:

   195                     value, forced = self.RawData[int(self.Data[idx, 2])]

   196                     if not raw:

   197                         if self.VariableType == "STRING":

   198                             value = "'%s'" % value

   199                         else:

   200                             value = '"%s"' % value

   201                     return value, forced

   202                 else:

   203                     value = self.Data[idx, 1]

   204                     if not raw and isinstance(value, FloatType):

   205                         value = "%.6g" % value

   206                     return value, self.Data[idx, 2]

   207             return self.Value, self.IsForced()

   208         elif not raw:

   209             if self.VariableType == "STRING":

   210                 return "'%s'" % self.Value

   211             elif self.VariableType == "WSTRING":

   212                 return '"%s"' % self.Value

   213             elif isinstance(self.Value, FloatType):

   214                 return "%.6g" % self.Value

   215         return self.Value

   216 

   217     def GetNearestData(self, tick, adjust):

   218         if USE_MPL and self.IsNumVariable():

   219             ticks = self.Data[:, 0]

   220             new_cursor = numpy.argmin(abs(ticks - tick))

   221             if adjust == -1 and ticks[new_cursor] > tick and new_cursor > 0:

   222                 new_cursor -= 1

   223             elif adjust == 1 and ticks[new_cursor] < tick and new_cursor < len(ticks):

   224                 new_cursor += 1

   225             return new_cursor

   226         return None

   227 

   228 class DebugVariableTable(CustomTable):

   229     

   230     def GetValue(self, row, col):

   231         if row < self.GetNumberRows():

   232             return self.GetValueByName(row, self.GetColLabelValue(col, False))

   233         return ""

   234     

   235     def SetValue(self, row, col, value):

   236         if col < len(self.colnames):

   237             self.SetValueByName(row, self.GetColLabelValue(col, False), value)

   238             

   239     def GetValueByName(self, row, colname):

   240         if row < self.GetNumberRows():

   241             if colname == "Variable":

   242                 return self.data[row].GetVariable()

   243             elif colname == "Value":

   244                 return self.data[row].GetValue()

   245         return ""

   246 

   247     def SetValueByName(self, row, colname, value):

   248         if row < self.GetNumberRows():

   249             if colname == "Variable":

   250                 self.data[row].SetVariable(value)

   251             elif colname == "Value":

   252                 self.data[row].SetValue(value)

   253     

   254     def IsForced(self, row):

   255         if row < self.GetNumberRows():

   256             return self.data[row].IsForced()

   257         return False

   258     

   259     def IsNumVariable(self, row):

   260         if row < self.GetNumberRows():

   261             return self.data[row].IsNumVariable()

   262         return False

   263     

   264     def _updateColAttrs(self, grid):

   265         """

   266         wx.grid.Grid -> update the column attributes to add the

   267         appropriate renderer given the column name.

   268 

   269         Otherwise default to the default renderer.

   270         """

   271         

   272         for row in range(self.GetNumberRows()):

   273             for col in range(self.GetNumberCols()):

   274                 colname = self.GetColLabelValue(col, False)

   275                 if colname == "Value":

   276                     if self.IsForced(row):

   277                         grid.SetCellTextColour(row, col, wx.BLUE)

   278                     else:

   279                         grid.SetCellTextColour(row, col, wx.BLACK)

   280                 grid.SetReadOnly(row, col, True)

   281             self.ResizeRow(grid, row)

   282                 

   283     def AppendItem(self, data):

   284         self.data.append(data)

   285     

   286     def InsertItem(self, idx, data):

   287         self.data.insert(idx, data)

   288     

   289     def RemoveItem(self, idx):

   290         self.data.pop(idx)

   291     

   292     def MoveItem(self, idx, new_idx):

   293         self.data.insert(new_idx, self.data.pop(idx))

   294         

   295     def GetItem(self, idx):

   296         return self.data[idx]

   297 

   298 class DebugVariableDropTarget(wx.TextDropTarget):

   299     

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

   301         wx.TextDropTarget.__init__(self)

   302         self.ParentWindow = parent

   303         self.ParentControl = control

   304     

   305     def __del__(self):

   306         self.ParentWindow = None

   307         self.ParentControl = None

   308     

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

   310         if not isinstance(self.ParentControl, CustomGrid):

   311             if self.ParentControl is not None:

   312                 self.ParentControl.OnMouseDragging(x, y)

   313             else:

   314                 self.ParentWindow.RefreshHighlight(x, y)

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

   316         

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

   318         message = None

   319         try:

   320             values = eval(data)

   321         except:

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

   323             values = None

   324         if not isinstance(values, TupleType):

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

   326             values = None

   327         

   328         if message is not None:

   329             wx.CallAfter(self.ShowMessage, message)

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

   331             if isinstance(self.ParentControl, CustomGrid):

   332                 x, y = self.ParentControl.CalcUnscrolledPosition(x, y)

   333                 row = self.ParentControl.YToRow(y - self.ParentControl.GetColLabelSize())

   334                 if row == wx.NOT_FOUND:

   335                     row = self.ParentWindow.Table.GetNumberRows()

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

   337             elif self.ParentControl is not None:

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

   339                 target_idx = self.ParentControl.GetIndex()

   340                 merge_type = GRAPH_PARALLEL

   341                 if isinstance(self.ParentControl, DebugVariableGraphic):

   342                     if self.ParentControl.Is3DCanvas():

   343                         if y > height / 2:

   344                             target_idx += 1

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

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

   347                         else:

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

   349                         

   350                     else:

   351                         rect = self.ParentControl.GetAxesBoundingBox()

   352                         if rect.InsideXY(x, y):

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

   354                             if merge_rect.InsideXY(x, y):

   355                                 merge_type = GRAPH_ORTHOGONAL

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

   357                         else:

   358                             if y > height / 2:

   359                                 target_idx += 1

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

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

   362                             else:

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

   364                 else:

   365                     if y > height / 2:

   366                         target_idx += 1

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

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

   369                     else:

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

   371                     

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

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

   374             else:

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

   376     

   377     def OnLeave(self):

   378         if not isinstance(self.ParentControl, CustomGrid):

   379             self.ParentWindow.ResetHighlight()

   380         return wx.TextDropTarget.OnLeave(self)

   381     

   382     def ShowMessage(self, message):

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

   384         dialog.ShowModal()

   385         dialog.Destroy()

   386 

   387 if USE_MPL:

   388     MILLISECOND = 1000000

   389     SECOND = 1000 * MILLISECOND

   390     MINUTE = 60 * SECOND

   391     HOUR = 60 * MINUTE

   392     DAY = 24 * HOUR

   393     

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

   395     RANGE_VALUES = \

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

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

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

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

   400     

   401     GRAPH_PARALLEL, GRAPH_ORTHOGONAL = range(2)

   402     

   403     SCROLLBAR_UNIT = 10

   404     

   405     #CANVAS_HIGHLIGHT_TYPES

   406     [HIGHLIGHT_NONE,

   407      HIGHLIGHT_BEFORE,

   408      HIGHLIGHT_AFTER,

   409      HIGHLIGHT_LEFT,

   410      HIGHLIGHT_RIGHT,

   411      HIGHLIGHT_RESIZE] = range(6)

   412     

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

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

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

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

   417     

   418     #CANVAS_SIZE_TYPES

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

   420     

   421     DEFAULT_CANVAS_HEIGHT = 200.

   422     CANVAS_BORDER = (20., 10.)

   423     CANVAS_PADDING = 8.5

   424     VALUE_LABEL_HEIGHT = 17.

   425     AXES_LABEL_HEIGHT = 12.75

   426     

   427     def compute_mask(x, y):

   428         mask = []

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

   430             if xp == yp:

   431                 mask.append(xp)

   432             else:

   433                 mask.append("*")

   434         return mask

   435     

   436     def NextTick(variables):

   437         next_tick = None

   438         for item, data in variables:

   439             if len(data) > 0:

   440                 if next_tick is None:

   441                     next_tick = data[0][0]

   442                 else:

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

   444         return next_tick

   445     

   446     def OrthogonalData(item, start_tick, end_tick):

   447         data = item.GetData(start_tick, end_tick)

   448         min_value, max_value = item.GetRange()

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

   450             center = (min_value + max_value) / 2.

   451             range = max(1.0, max_value - min_value)

   452         else:

   453             center = 0.5

   454             range = 1.0

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

   456     

   457     class GraphButton():

   458         

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

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

   461             self.Bitmap = bitmap

   462             self.Shown = True

   463             self.Enabled = True

   464             self.Callback = callback

   465         

   466         def __del__(self):

   467             self.callback = None

   468         

   469         def GetSize(self):

   470             return self.Bitmap.GetSize()

   471         

   472         def SetPosition(self, x, y):

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

   474         

   475         def Show(self):

   476             self.Shown = True

   477             

   478         def Hide(self):

   479             self.Shown = False

   480         

   481         def IsShown(self):

   482             return self.Shown

   483         

   484         def Enable(self):

   485             self.Enabled = True

   486         

   487         def Disable(self):

   488             self.Enabled = False

   489         

   490         def IsEnabled(self):

   491             return self.Enabled

   492         

   493         def HitTest(self, x, y):

   494             if self.Shown and self.Enabled:

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

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

   497                 if rect.InsideXY(x, y):

   498                     return True

   499             return False

   500         

   501         def ProcessCallback(self):

   502             if self.Callback is not None:

   503                 wx.CallAfter(self.Callback)

   504                 

   505         def Draw(self, dc):

   506             if self.Shown and self.Enabled:

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

   508     

   509     class DebugVariableViewer:

   510         

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

   512             self.ParentWindow = window

   513             self.Items = items

   514             

   515             self.Highlight = HIGHLIGHT_NONE

   516             self.Buttons = []

   517         

   518         def __del__(self):

   519             self.ParentWindow = None

   520         

   521         def GetIndex(self):

   522             return self.ParentWindow.GetViewerIndex(self)

   523         

   524         def GetItem(self, variable):

   525             for item in self.Items:

   526                 if item.GetVariable() == variable:

   527                     return item

   528             return None

   529         

   530         def GetItems(self):

   531             return self.Items

   532         

   533         def GetVariables(self):

   534             if len(self.Items) > 1:

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

   536                 if self.GraphType == GRAPH_ORTHOGONAL:

   537                     return tuple(variables)

   538                 return variables

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

   540         

   541         def AddItem(self, item):

   542             self.Items.append(item)

   543             

   544         def RemoveItem(self, item):

   545             if item in self.Items:

   546                 self.Items.remove(item)

   547             

   548         def Clear(self):

   549             for item in self.Items:

   550                 self.ParentWindow.RemoveDataConsumer(item)

   551             self.Items = []

   552             

   553         def IsEmpty(self):

   554             return len(self.Items) == 0

   555         

   556         def UnregisterObsoleteData(self):

   557             for item in self.Items[:]:

   558                 iec_path = item.GetVariable()

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

   560                     self.ParentWindow.RemoveDataConsumer(item)

   561                     self.RemoveItem(item)

   562                 else:

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

   564                     item.RefreshVariableType()

   565             

   566         def ResetData(self):

   567             for item in self.Items:

   568                 item.ResetData()

   569         

   570         def RefreshViewer(self):

   571             pass

   572         

   573         def SetHighlight(self, highlight):

   574             if self.Highlight != highlight:

   575                 self.Highlight = highlight

   576                 return True

   577             return False

   578         

   579         def GetButtons(self):

   580             return self.Buttons

   581         

   582         def HandleButtons(self, x, y):

   583             for button in self.GetButtons():

   584                 if button.HitTest(x, y):

   585                     button.ProcessCallback()

   586                     return True

   587             return False

   588         

   589         def IsOverButton(self, x, y):

   590             for button in self.GetButtons():

   591                 if button.HitTest(x, y):

   592                     return True

   593             return False

   594         

   595         def ShowButtons(self, show):

   596             for button in self.Buttons:

   597                 if show:

   598                     button.Show()

   599                 else:

   600                     button.Hide()

   601             self.RefreshButtonsState()

   602             self.ParentWindow.ForceRefresh()

   603         

   604         def RefreshButtonsState(self, refresh_positions=False):

   605             if self:

   606                 width, height = self.GetSize()

   607                 if refresh_positions:

   608                     offset = 0

   609                     buttons = self.Buttons[:]

   610                     buttons.reverse()

   611                     for button in buttons:

   612                         w, h = button.GetSize()

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

   614                         offset += w + 2

   615                     self.ParentWindow.ForceRefresh()

   616         

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

   618             width, height = self.GetSize()

   619             

   620             dc.SetPen(HIGHLIGHT_DROP_PEN)

   621             dc.SetBrush(HIGHLIGHT_DROP_BRUSH)

   622             if self.Highlight in [HIGHLIGHT_BEFORE]:

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

   624             elif self.Highlight in [HIGHLIGHT_AFTER]:

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

   626             

   627             if buttons is None:

   628                 buttons = self.Buttons

   629             for button in buttons:

   630                 button.Draw(dc)

   631                 

   632             if self.ParentWindow.IsDragging():

   633                 destBBox = self.ParentWindow.GetDraggingAxesClippingRegion(self)

   634                 srcPos = self.ParentWindow.GetDraggingAxesPosition(self)

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

   636                     srcPanel = self.ParentWindow.DraggingAxesPanel

   637                     srcBBox = srcPanel.GetAxesBoundingBox()

   638                     

   639                     if destBBox.x == 0:

   640                         srcX = srcBBox.x - srcPos.x

   641                     else:

   642                         srcX = srcBBox.x

   643                     if destBBox.y == 0:

   644                         srcY = srcBBox.y - srcPos.y

   645                     else:

   646                         srcY = srcBBox.y

   647                     

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

   649                     srcDC = wx.MemoryDC()

   650                     srcDC.SelectObject(srcBmp)

   651                     

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

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

   654                             srcDC, srcX, srcY)

   655         

   656         def OnEnter(self, event):

   657             self.ShowButtons(True)

   658             event.Skip()

   659             

   660         def OnLeave(self, event):

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

   662                 x, y = event.GetPosition()

   663                 width, height = self.GetSize()

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

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

   666                     self.ShowButtons(False)

   667             event.Skip()

   668         

   669         def OnCloseButton(self):

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

   671         

   672         def OnForceButton(self):

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

   674             

   675         def OnReleaseButton(self):

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

   677         

   678         def OnResizeWindow(self, event):

   679             wx.CallAfter(self.RefreshButtonsState, True)

   680             event.Skip()

   681         

   682         def OnMouseDragging(self, x, y):

   683             xw, yw = self.GetPosition()

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

   685         

   686         def OnDragging(self, x, y):

   687             width, height = self.GetSize()

   688             if y < height / 2:

   689                 if self.ParentWindow.IsViewerFirst(self):

   690                     self.SetHighlight(HIGHLIGHT_BEFORE)

   691                 else:

   692                     self.SetHighlight(HIGHLIGHT_NONE)

   693                     self.ParentWindow.HighlightPreviousViewer(self)

   694             else:

   695                 self.SetHighlight(HIGHLIGHT_AFTER)

   696         

   697         def OnEraseBackground(self, event):

   698             pass

   699         

   700         def OnResize(self, event):

   701             wx.CallAfter(self.RefreshButtonsState, True)

   702             event.Skip()

   703         

   704         def ForceValue(self, item):

   705             iec_path = item.GetVariable()

   706             iec_type = self.ParentWindow.GetDataType(iec_path)

   707             if iec_type is not None:

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

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

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

   711         

   712         def ReleaseValue(self, item):

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

   714             self.ParentWindow.ReleaseDataValue(iec_path)

   715     

   716     

   717     class DebugVariableText(DebugVariableViewer, wx.Panel):

   718         

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

   720             DebugVariableViewer.__init__(self, window, items)

   721             

   722             wx.Panel.__init__(self, parent)

   723             self.SetBackgroundColour(wx.WHITE)

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

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

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

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

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

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

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

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

   732             

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

   734             

   735             self.Buttons.append(

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

   737             self.Buttons.append(

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

   739             self.Buttons.append(

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

   741             

   742             self.ShowButtons(False)

   743             

   744         def RefreshViewer(self):

   745             width, height = self.GetSize()

   746             bitmap = wx.EmptyBitmap(width, height)

   747             

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

   749             dc.Clear()

   750             dc.BeginDrawing()

   751             

   752             gc = wx.GCDC(dc)

   753             

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

   755             w, h = gc.GetTextExtent(item_name)

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

   757             

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

   759                 gc.SetTextForeground(wx.BLUE)

   760                 self.Buttons[0].Disable()

   761                 self.Buttons[1].Enable()

   762             else:

   763                 self.Buttons[1].Disable()

   764                 self.Buttons[0].Enable()

   765             self.RefreshButtonsState(True)

   766             

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

   768             w, h = gc.GetTextExtent(item_value)

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

   770             

   771             self.DrawCommonElements(gc)

   772             

   773             gc.EndDrawing()

   774         

   775         def OnLeftDown(self, event):

   776             width, height = self.GetSize()

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

   778             w, h = self.GetTextExtent(item_name)

   779             x, y = event.GetPosition()

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

   781             if rect.InsideXY(x, y):

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

   783                 dragSource = wx.DropSource(self)

   784                 dragSource.SetData(data)

   785                 dragSource.DoDragDrop()

   786             else:

   787                 event.Skip()

   788         

   789         def OnLeftUp(self, event):

   790             x, y = event.GetPosition()

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

   792             event.Skip()

   793         

   794         def OnPaint(self, event):

   795             self.RefreshViewer()

   796             event.Skip()

   797     

   798     class DebugVariableGraphic(DebugVariableViewer, FigureCanvas):

   799         

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

   801             DebugVariableViewer.__init__(self, window, items)

   802             

   803             self.CanvasSize = SIZE_MINI

   804             self.GraphType = graph_type

   805             self.CursorTick = None

   806             self.MouseStartPos = None

   807             self.StartCursorTick = None

   808             self.CanvasStartSize = None

   809             self.ContextualButtons = []

   810             self.ContextualButtonsItem = None

   811             

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

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

   814             

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

   816             self.SetWindowStyle(wx.WANTS_CHARS)

   817             self.SetBackgroundColour(wx.WHITE)

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

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

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

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

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

   823             

   824             canvas_size = self.GetCanvasMinSize()

   825             self.SetMinSize(canvas_size)

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

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

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

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

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

   831             

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

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

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

   835             self.Buttons.append(

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

   837             self.Buttons.append(

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

   839             

   840             self.ResetGraphics()

   841             self.RefreshLabelsPosition(canvas_size.height)

   842             self.ShowButtons(False)

   843         

   844         def draw(self, drawDC=None):

   845             FigureCanvasAgg.draw(self)

   846     

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

   848             self.bitmap.UseAlpha() 

   849             width, height = self.GetSize()

   850             bbox = self.GetAxesBoundingBox()

   851             

   852             destDC = wx.MemoryDC()

   853             destDC.SelectObject(self.bitmap)

   854             

   855             destGC = wx.GCDC(destDC)

   856             

   857             destGC.BeginDrawing()

   858             if self.Highlight == HIGHLIGHT_RESIZE:

   859                 destGC.SetPen(HIGHLIGHT_RESIZE_PEN)

   860                 destGC.SetBrush(HIGHLIGHT_RESIZE_BRUSH)

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

   862             else:

   863                 destGC.SetPen(HIGHLIGHT_DROP_PEN)

   864                 destGC.SetBrush(HIGHLIGHT_DROP_BRUSH)

   865                 if self.Highlight == HIGHLIGHT_LEFT:

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

   867                                          bbox.width / 2, bbox.height)

   868                 elif self.Highlight == HIGHLIGHT_RIGHT:

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

   870                                          bbox.width / 2, bbox.height)

   871             

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

   873             

   874             destGC.EndDrawing()

   875             

   876             self._isDrawn = True

   877             self.gui_repaint(drawDC=drawDC)

   878         

   879         def GetButtons(self):

   880             return self.Buttons + self.ContextualButtons

   881         

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

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

   884                 self.DismissContextualButtons()

   885             

   886             if self.ContextualButtonsItem is None:

   887                 self.ContextualButtonsItem = item

   888                 

   889                 if self.ContextualButtonsItem.IsForced():

   890                     self.ContextualButtons.append(

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

   892                 self.ContextualButtons.append(

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

   894                 self.ContextualButtons.append(

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

   896                 self.ContextualButtons.append(

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

   898                 

   899                 offset = 0

   900                 buttons = self.ContextualButtons[:]

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

   902                      buttons.reverse()

   903                 for button in buttons:

   904                     w, h = button.GetSize()

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

   906                         if style == wx.LEFT:

   907                             x = rect.x - w - offset

   908                         else:

   909                             x = rect.x + rect.width + offset

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

   911                         offset += w

   912                     else:

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

   914                         if style == wx.TOP:

   915                             y = rect.y - h - offset

   916                         else:

   917                             y = rect.y + rect.height + offset

   918                         offset += h

   919                     button.SetPosition(x, y)

   920                 self.ParentWindow.ForceRefresh()

   921         

   922         def DismissContextualButtons(self):

   923             if self.ContextualButtonsItem is not None:

   924                 self.ContextualButtonsItem = None

   925                 self.ContextualButtons = []

   926                 self.ParentWindow.ForceRefresh()

   927         

   928         def IsOverContextualButton(self, x, y):

   929             for button in self.ContextualButtons:

   930                 if button.HitTest(x, y):

   931                     return True

   932             return False

   933         

   934         def SetMinSize(self, size):

   935             wx.Window.SetMinSize(self, size)

   936             wx.CallAfter(self.RefreshButtonsState)

   937         

   938         def GetOnChangeSizeButton(self, size):

   939             def OnChangeSizeButton():

   940                 self.CanvasSize = size

   941                 self.SetCanvasSize(200, self.CanvasSize)

   942             return OnChangeSizeButton

   943         

   944         def OnExportGraphButton(self):

   945             self.ExportGraph()

   946         

   947         def OnForceButton(self):

   948             wx.CallAfter(self.ForceValue, 

   949                          self.ContextualButtonsItem)

   950             self.DismissContextualButtons()

   951             

   952         def OnReleaseButton(self):

   953             wx.CallAfter(self.ReleaseValue, 

   954                          self.ContextualButtonsItem)

   955             self.DismissContextualButtons()

   956         

   957         def OnExportItemGraphButton(self):

   958             wx.CallAfter(self.ExportGraph, 

   959                          self.ContextualButtonsItem)

   960             self.DismissContextualButtons()

   961             

   962         def OnRemoveItemButton(self):            

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

   964                          self.ContextualButtonsItem)

   965             self.DismissContextualButtons()

   966         

   967         def RefreshLabelsPosition(self, height):

   968             canvas_ratio = 1. / height

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

   970             

   971             self.Figure.subplotpars.update(

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

   973                 bottom= CANVAS_BORDER[0] * canvas_ratio)

   974             

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

   976                 num_item = len(self.Items)

   977                 for idx in xrange(num_item):

   978                     if not self.Is3DCanvas():

   979                         self.AxesLabels[idx].set_position(

   980                             (0.05, 

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

   982                     self.Labels[idx].set_position(

   983                         (0.95, 

   984                          CANVAS_PADDING * graph_ratio + 

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

   986             else:

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

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

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

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

   991         

   992             self.Figure.subplots_adjust()

   993         

   994         def GetCanvasMinSize(self):

   995             return wx.Size(200, 

   996                            CANVAS_BORDER[0] + CANVAS_BORDER[1] + 

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

   998         

   999         def SetCanvasSize(self, width, height):

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

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

  1002             self.RefreshLabelsPosition(height)

  1003             self.RefreshButtonsState()

  1004             self.ParentWindow.RefreshGraphicsSizer()

  1005             

  1006         def GetAxesBoundingBox(self, absolute=False):

  1007             width, height = self.GetSize()

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

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

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

  1011             if absolute:

  1012                 xw, yw = self.GetPosition()

  1013                 bbox.x += xw

  1014                 bbox.y += yw

  1015             return bbox

  1016         

  1017         def OnCanvasButtonPressed(self, event):

  1018             width, height = self.GetSize()

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

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

  1021                 if event.inaxes == self.Axes:

  1022                     item_idx = None

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

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

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

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

  1027                         if rect.InsideXY(x, y):

  1028                             item_idx = i

  1029                             break

  1030                     if item_idx is not None:

  1031                         self.ShowButtons(False)

  1032                         self.DismissContextualButtons()

  1033                         xw, yw = self.GetPosition()

  1034                         self.ParentWindow.StartDragNDrop(self, 

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

  1036                     elif not self.Is3DCanvas():

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

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

  1039                             self.StartCursorTick = self.CursorTick

  1040                             self.HandleCursorMove(event)

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

  1042                             width, height = self.GetSize()

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

  1044                             self.StartCursorTick = start_tick

  1045                 

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

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

  1048                     self.CanvasStartSize = self.GetSize()

  1049         

  1050         def OnCanvasButtonReleased(self, event):

  1051             if self.ParentWindow.IsDragging():

  1052                 width, height = self.GetSize()

  1053                 xw, yw = self.GetPosition()

  1054                 self.ParentWindow.StopDragNDrop(

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

  1056                     xw + event.x, 

  1057                     yw + height - event.y)

  1058             else:

  1059                 self.MouseStartPos = None

  1060                 self.StartCursorTick = None

  1061                 self.CanvasStartSize = None

  1062                 width, height = self.GetSize()

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

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

  1065                     self.SetCursor(wx.NullCursor)

  1066                     self.ParentWindow.ForceRefresh()

  1067         

  1068         def OnCanvasMotion(self, event):

  1069             width, height = self.GetSize()

  1070             if self.ParentWindow.IsDragging():

  1071                 xw, yw = self.GetPosition()

  1072                 self.ParentWindow.MoveDragNDrop(

  1073                     xw + event.x, 

  1074                     yw + height - event.y)

  1075             else:

  1076                 if not self.Is3DCanvas():

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

  1078                         if event.inaxes == self.Axes:

  1079                             if self.MouseStartPos is not None:

  1080                                 self.HandleCursorMove(event)

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

  1082                             xw, yw = self.GetPosition()

  1083                             self.ParentWindow.SetCursorTick(self.StartCursorTick)

  1084                             self.ParentWindow.StartDragNDrop(self, 

  1085                                 self.Items[0],

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

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

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

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

  1090                         rect = self.GetAxesBoundingBox()

  1091                         self.ParentWindow.SetCanvasPosition(

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

  1093                             (end_tick - start_tick) / rect.width)    

  1094                 

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

  1096                     width, height = self.GetSize()

  1097                     self.SetCanvasSize(width, 

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

  1099                     

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

  1101                     if self.GraphType == GRAPH_PARALLEL:

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

  1103                     elif len(self.AxesLabels) > 0:

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

  1105                     else:

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

  1107                     item_idx = None

  1108                     item_style = None

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

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

  1111                                              orientation):

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

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

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

  1115                             item_idx = i

  1116                             item_style = style

  1117                             break

  1118                     if item_idx is not None:

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

  1120                         return 

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

  1122                         self.DismissContextualButtons()

  1123                     

  1124                     if event.y <= 5:

  1125                         if self.SetHighlight(HIGHLIGHT_RESIZE):

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

  1127                             self.ParentWindow.ForceRefresh()

  1128                     else:

  1129                         if self.SetHighlight(HIGHLIGHT_NONE):

  1130                             self.SetCursor(wx.NullCursor)

  1131                             self.ParentWindow.ForceRefresh()

  1132         

  1133         def OnCanvasScroll(self, event):

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

  1135                 if self.GraphType == GRAPH_ORTHOGONAL:

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