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 import DebugDataConsumer, DebugViewer, REFRESH_PERIOD

    49 from controls import CustomGrid, CustomTable

    50 from dialogs.ForceVariableDialog import ForceVariableDialog

    51 from util.BitmapLibrary import GetBitmap

    52 

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

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

    55 

    56 def GetDebugVariablesTableColnames():

    57     _ = lambda x : x

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

    59 

    60 CRC_SIZE = 8

    61 CRC_MASK = 2 ** CRC_SIZE - 1

    62 

    63 class VariableTableItem(DebugDataConsumer):

    64     

    65     def __init__(self, parent, variable):

    66         DebugDataConsumer.__init__(self)

    67         self.Parent = parent

    68         self.Variable = variable

    69         self.RefreshVariableType()

    70         self.Value = ""

    71         

    72     def __del__(self):

    73         self.Parent = None

    74     

    75     def SetVariable(self, variable):

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

    77             self.Variable = variable

    78             self.RefreshVariableType()

    79             self.Parent.RefreshView()

    80     

    81     def GetVariable(self, mask=None):

    82         variable = self.Variable

    83         if mask is not None:

    84             parts = variable.split('.')

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

    86             last = None

    87             variable = ""

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

    89                 if m == '*':

    90                     if last == '*':

    91                         variable += '.'

    92                     variable += v

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

    94                     variable += '..'

    95                 last = m

    96         return variable

    97     

    98     def RefreshVariableType(self):

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

   100         if USE_MPL:

   101             self.ResetData()

   102     

   103     def GetVariableType(self):

   104         return self.VariableType

   105     

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

   107         if USE_MPL and self.IsNumVariable():

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

   109                 return self.Data

   110             

   111             start_idx = end_idx = None

   112             if start_tick is not None:

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

   114             if end_tick is not None:

   115                 end_idx = self.GetNearestData(end_tick, 1)

   116             if start_idx is None:

   117                 start_idx = 0

   118             if end_idx is not None:

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

   120             else:

   121                 return self.Data[start_idx:]

   122             

   123         return None

   124     

   125     def GetRawValue(self, idx):

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

   127             return self.RawData[idx][0]

   128         return ""

   129     

   130     def GetRange(self):

   131         return self.MinValue, self.MaxValue

   132     

   133     def ResetData(self):

   134         if self.IsNumVariable():

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

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

   137                 self.RawData = []

   138             self.MinValue = None

   139             self.MaxValue = None

   140         else:

   141             self.Data = None

   142     

   143     def IsNumVariable(self):

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

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

   146     

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

   148         if USE_MPL and self.IsNumVariable():

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

   150                 num_value = binascii.crc32(value) & CRC_MASK

   151             else:

   152                 num_value = float(value)

   153             if self.MinValue is None:

   154                 self.MinValue = num_value

   155             else:

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

   157             if self.MaxValue is None:

   158                 self.MaxValue = num_value

   159             else:

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

   161             forced_value = float(forced)

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

   163                 raw_data = (value, forced_value)

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

   165                     extra_value = len(self.RawData)

   166                     self.RawData.append(raw_data)

   167                 else:

   168                     extra_value = len(self.RawData) - 1

   169             else:

   170                 extra_value = forced_value

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

   172             self.Parent.HasNewData = True

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

   174     

   175     def SetForced(self, forced):

   176         if self.Forced != forced:

   177             self.Forced = forced

   178             self.Parent.HasNewData = True

   179     

   180     def SetValue(self, value):

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

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

   183             value = value[1:-1]

   184         if self.Value != value:

   185             self.Value = value

   186             self.Parent.HasNewData = True

   187             

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

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

   190             if len(self.Data) > 0:

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

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

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

   194                     if not raw:

   195                         if self.VariableType == "STRING":

   196                             value = "'%s'" % value

   197                         else:

   198                             value = '"%s"' % value

   199                     return value, forced

   200                 else:

   201                     value = self.Data[idx, 1]

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

   203                         value = "%.6g" % value

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

   205             return self.Value, self.IsForced()

   206         elif not raw:

   207             if self.VariableType == "STRING":

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

   209             elif self.VariableType == "WSTRING":

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

   211             elif isinstance(self.Value, FloatType):

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

   213         return self.Value

   214 

   215     def GetNearestData(self, tick, adjust):

   216         if USE_MPL and self.IsNumVariable():

   217             ticks = self.Data[:, 0]

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

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

   220                 new_cursor -= 1

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

   222                 new_cursor += 1

   223             return new_cursor

   224         return None

   225 

   226 class DebugVariableTable(CustomTable):

   227     

   228     def GetValue(self, row, col):

   229         if row < self.GetNumberRows():

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

   231         return ""

   232     

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

   234         if col < len(self.colnames):

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

   236             

   237     def GetValueByName(self, row, colname):

   238         if row < self.GetNumberRows():

   239             if colname == "Variable":

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

   241             elif colname == "Value":

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

   243         return ""

   244 

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

   246         if row < self.GetNumberRows():

   247             if colname == "Variable":

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

   249             elif colname == "Value":

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

   251     

   252     def IsForced(self, row):

   253         if row < self.GetNumberRows():

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

   255         return False

   256     

   257     def IsNumVariable(self, row):

   258         if row < self.GetNumberRows():

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

   260         return False

   261     

   262     def _updateColAttrs(self, grid):

   263         """

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

   265         appropriate renderer given the column name.

   266 

   267         Otherwise default to the default renderer.

   268         """

   269         

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

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

   272                 colname = self.GetColLabelValue(col, False)

   273                 if colname == "Value":

   274                     if self.IsForced(row):

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

   276                     else:

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

   278                 grid.SetReadOnly(row, col, True)

   279             self.ResizeRow(grid, row)

   280                 

   281     def AppendItem(self, data):

   282         self.data.append(data)

   283     

   284     def InsertItem(self, idx, data):

   285         self.data.insert(idx, data)

   286     

   287     def RemoveItem(self, idx):

   288         self.data.pop(idx)

   289     

   290     def MoveItem(self, idx, new_idx):

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

   292         

   293     def GetItem(self, idx):

   294         return self.data[idx]

   295 

   296 class DebugVariableDropTarget(wx.TextDropTarget):

   297     

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

   299         wx.TextDropTarget.__init__(self)

   300         self.ParentWindow = parent

   301         self.ParentControl = control

   302     

   303     def __del__(self):

   304         self.ParentWindow = None

   305         self.ParentControl = None

   306     

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

   308         if self.ParentControl is not None:

   309             self.ParentControl.OnMouseDragging(x, y)

   310         else:

   311             self.ParentWindow.RefreshHighlight(x, y)

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

   313         

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

   315         message = None

   316         try:

   317             values = eval(data)

   318         except:

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

   320             values = None

   321         if not isinstance(values, TupleType):

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

   323             values = None

   324         

   325         if message is not None:

   326             wx.CallAfter(self.ShowMessage, message)

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

   328             if isinstance(self.ParentControl, CustomGrid):

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

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

   331                 if row == wx.NOT_FOUND:

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

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

   334             elif self.ParentControl is not None:

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

   336                 target_idx = self.ParentControl.GetIndex()

   337                 merge_type = GRAPH_PARALLEL

   338                 if isinstance(self.ParentControl, DebugVariableGraphic):

   339                     if self.ParentControl.Is3DCanvas():

   340                         if y > height / 2:

   341                             target_idx += 1

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

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

   344                         else:

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

   346                         

   347                     else:

   348                         rect = self.ParentControl.GetAxesBoundingBox()

   349                         if rect.InsideXY(x, y):

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

   351                             if merge_rect.InsideXY(x, y):

   352                                 merge_type = GRAPH_ORTHOGONAL

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

   354                         else:

   355                             if y > height / 2:

   356                                 target_idx += 1

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

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

   359                             else:

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

   361                 else:

   362                     if y > height / 2:

   363                         target_idx += 1

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

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

   366                     else:

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

   368                     

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

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

   371             else:

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

   373     

   374     def OnLeave(self):

   375         self.ParentWindow.ResetHighlight()

   376         return wx.TextDropTarget.OnLeave(self)

   377     

   378     def ShowMessage(self, message):

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

   380         dialog.ShowModal()

   381         dialog.Destroy()

   382 

   383 if USE_MPL:

   384     MILLISECOND = 1000000

   385     SECOND = 1000 * MILLISECOND

   386     MINUTE = 60 * SECOND

   387     HOUR = 60 * MINUTE

   388     DAY = 24 * HOUR

   389     

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

   391     RANGE_VALUES = map(lambda x: (str(x), x), [25 * 2 ** i for i in xrange(6)])

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

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

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

   395     

   396     GRAPH_PARALLEL, GRAPH_ORTHOGONAL = range(2)

   397     

   398     SCROLLBAR_UNIT = 10

   399     

   400     #CANVAS_HIGHLIGHT_TYPES

   401     [HIGHLIGHT_NONE,

   402      HIGHLIGHT_BEFORE,

   403      HIGHLIGHT_AFTER,

   404      HIGHLIGHT_LEFT,

   405      HIGHLIGHT_RIGHT,

   406      HIGHLIGHT_RESIZE] = range(6)

   407     

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

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

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

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

   412     

   413     #CANVAS_SIZE_TYPES

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

   415     

   416     DEFAULT_CANVAS_HEIGHT = 200.

   417     CANVAS_BORDER = (20., 10.)

   418     CANVAS_PADDING = 8.5

   419     VALUE_LABEL_HEIGHT = 17.

   420     AXES_LABEL_HEIGHT = 12.75

   421     

   422     def compute_mask(x, y):

   423         mask = []

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

   425             if xp == yp:

   426                 mask.append(xp)

   427             else:

   428                 mask.append("*")

   429         return mask

   430     

   431     def NextTick(variables):

   432         next_tick = None

   433         for item, data in variables:

   434             if len(data) > 0:

   435                 if next_tick is None:

   436                     next_tick = data[0][0]

   437                 else:

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

   439         return next_tick

   440     

   441     def OrthogonalData(item, start_tick, end_tick):

   442         data = item.GetData(start_tick, end_tick)

   443         min_value, max_value = item.GetRange()

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

   445             center = (min_value + max_value) / 2.

   446             range = max(1.0, max_value - min_value)

   447         else:

   448             center = 0.5

   449             range = 1.0

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

   451     

   452     class GraphButton():

   453         

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

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

   456             self.Bitmap = bitmap

   457             self.Shown = True

   458             self.Enabled = True

   459             self.Callback = callback

   460         

   461         def __del__(self):

   462             self.callback = None

   463         

   464         def GetSize(self):

   465             return self.Bitmap.GetSize()

   466         

   467         def SetPosition(self, x, y):

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

   469         

   470         def Show(self):

   471             self.Shown = True

   472             

   473         def Hide(self):

   474             self.Shown = False

   475         

   476         def IsShown(self):

   477             return self.Shown

   478         

   479         def Enable(self):

   480             self.Enabled = True

   481         

   482         def Disable(self):

   483             self.Enabled = False

   484         

   485         def IsEnabled(self):

   486             return self.Enabled

   487         

   488         def HitTest(self, x, y):

   489             if self.Shown and self.Enabled:

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

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

   492                 if rect.InsideXY(x, y):

   493                     return True

   494             return False

   495         

   496         def ProcessCallback(self):

   497             if self.Callback is not None:

   498                 wx.CallAfter(self.Callback)

   499                 

   500         def Draw(self, dc):

   501             if self.Shown and self.Enabled:

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

   503     

   504     class DebugVariableViewer:

   505         

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

   507             self.ParentWindow = window

   508             self.Items = items

   509             

   510             self.Highlight = HIGHLIGHT_NONE

   511             self.Buttons = []

   512         

   513         def __del__(self):

   514             self.ParentWindow = None

   515         

   516         def GetIndex(self):

   517             return self.ParentWindow.GetViewerIndex(self)

   518         

   519         def GetItem(self, variable):

   520             for item in self.Items:

   521                 if item.GetVariable() == variable:

   522                     return item

   523             return None

   524         

   525         def GetItems(self):

   526             return self.Items

   527         

   528         def GetVariables(self):

   529             if len(self.Items) > 1:

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

   531                 if self.GraphType == GRAPH_ORTHOGONAL:

   532                     return tuple(variables)

   533                 return variables

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

   535         

   536         def AddItem(self, item):

   537             self.Items.append(item)

   538             

   539         def RemoveItem(self, item):

   540             if item in self.Items:

   541                 self.Items.remove(item)

   542             

   543         def Clear(self):

   544             for item in self.Items:

   545                 self.ParentWindow.RemoveDataConsumer(item)

   546             self.Items = []

   547             

   548         def IsEmpty(self):

   549             return len(self.Items) == 0

   550         

   551         def UnregisterObsoleteData(self):

   552             for item in self.Items[:]:

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

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

   555                     self.ParentWindow.RemoveDataConsumer(item)

   556                     self.RemoveItem(item)

   557                 else:

   558                     self.ParentWindow.AddDataConsumer(iec_path, item)

   559                     item.RefreshVariableType()

   560             

   561         def ResetData(self):

   562             for item in self.Items:

   563                 item.ResetData()

   564         

   565         def RefreshViewer(self):

   566             pass

   567         

   568         def SetHighlight(self, highlight):

   569             if self.Highlight != highlight:

   570                 self.Highlight = highlight

   571                 return True

   572             return False

   573         

   574         def GetButtons(self):

   575             return self.Buttons

   576         

   577         def HandleButtons(self, x, y):

   578             for button in self.GetButtons():

   579                 if button.HitTest(x, y):

   580                     button.ProcessCallback()

   581                     return True

   582             return False

   583         

   584         def IsOverButton(self, x, y):

   585             for button in self.GetButtons():

   586                 if button.HitTest(x, y):

   587                     return True

   588             return False

   589         

   590         def ShowButtons(self, show):

   591             for button in self.Buttons:

   592                 if show:

   593                     button.Show()

   594                 else:

   595                     button.Hide()

   596             self.RefreshButtonsState()

   597             self.ParentWindow.ForceRefresh()

   598         

   599         def RefreshButtonsState(self, refresh_positions=False):

   600             if self:

   601                 width, height = self.GetSize()

   602                 if refresh_positions:

   603                     offset = 0

   604                     buttons = self.Buttons[:]

   605                     buttons.reverse()

   606                     for button in buttons:

   607                         if button.IsShown() and button.IsEnabled():

   608                             w, h = button.GetSize()

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

   610                             offset += w + 2

   611                     self.ParentWindow.ForceRefresh()

   612         

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

   614             width, height = self.GetSize()

   615             

   616             dc.SetPen(HIGHLIGHT_DROP_PEN)

   617             dc.SetBrush(HIGHLIGHT_DROP_BRUSH)

   618             if self.Highlight in [HIGHLIGHT_BEFORE]:

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

   620             elif self.Highlight in [HIGHLIGHT_AFTER]:

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

   622             

   623             if buttons is None:

   624                 buttons = self.Buttons

   625             for button in buttons:

   626                 button.Draw(dc)

   627                 

   628             if self.ParentWindow.IsDragging():

   629                 destBBox = self.ParentWindow.GetDraggingAxesClippingRegion(self)

   630                 srcPos = self.ParentWindow.GetDraggingAxesPosition(self)

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

   632                     srcPanel = self.ParentWindow.DraggingAxesPanel

   633                     srcBBox = srcPanel.GetAxesBoundingBox()

   634                     

   635                     if destBBox.x == 0:

   636                         srcX = srcBBox.x - srcPos.x

   637                     else:

   638                         srcX = srcBBox.x

   639                     if destBBox.y == 0:

   640                         srcY = srcBBox.y - srcPos.y

   641                     else:

   642                         srcY = srcBBox.y

   643                     

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

   645                     srcDC = wx.MemoryDC()

   646                     srcDC.SelectObject(srcBmp)

   647                     

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

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

   650                             srcDC, srcX, srcY)

   651         

   652         def OnEnter(self, event):

   653             self.ShowButtons(True)

   654             event.Skip()

   655             

   656         def OnLeave(self, event):

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

   658                 x, y = event.GetPosition()

   659                 width, height = self.GetSize()

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

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

   662                     self.ShowButtons(False)

   663             event.Skip()

   664         

   665         def OnCloseButton(self):

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

   667         

   668         def OnForceButton(self):

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

   670             

   671         def OnReleaseButton(self):

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

   673         

   674         def OnResizeWindow(self, event):

   675             wx.CallAfter(self.RefreshButtonsState, True)

   676             event.Skip()

   677         

   678         def OnMouseDragging(self, x, y):

   679             xw, yw = self.GetPosition()

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

   681         

   682         def OnDragging(self, x, y):

   683             width, height = self.GetSize()

   684             if y < height / 2:

   685                 if self.ParentWindow.IsViewerFirst(self):

   686                     self.SetHighlight(HIGHLIGHT_BEFORE)

   687                 else:

   688                     self.SetHighlight(HIGHLIGHT_NONE)

   689                     self.ParentWindow.HighlightPreviousViewer(self)

   690             else:

   691                 self.SetHighlight(HIGHLIGHT_AFTER)

   692         

   693         def OnResize(self, event):

   694             wx.CallAfter(self.RefreshButtonsState, True)

   695             event.Skip()

   696         

   697         def ForceValue(self, item):

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

   699             iec_type = self.ParentWindow.GetDataType(iec_path)

   700             if iec_type is not None:

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

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

   703                     self.ParentWindow.ForceDataValue(iec_path, dialog.GetValue())

   704         

   705         def ReleaseValue(self, item):

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

   707             self.ParentWindow.ReleaseDataValue(iec_path)

   708     

   709     

   710     class DebugVariableText(DebugVariableViewer, wx.Panel):

   711         

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

   713             DebugVariableViewer.__init__(self, window, items)

   714             

   715             wx.Panel.__init__(self, parent)

   716             self.SetBackgroundColour(wx.WHITE)

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

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

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

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

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

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

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

   724             

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

   726             

   727             self.Buttons.append(

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

   729             self.Buttons.append(

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

   731             self.Buttons.append(

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

   733             

   734             self.ShowButtons(False)

   735             

   736         def RefreshViewer(self):

   737             width, height = self.GetSize()

   738             bitmap = wx.EmptyBitmap(width, height)

   739             

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

   741             dc.Clear()

   742             dc.BeginDrawing()

   743             

   744             gc = wx.GCDC(dc)

   745             

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

   747             w, h = gc.GetTextExtent(item_name)

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

   749             

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

   751                 gc.SetTextForeground(wx.BLUE)

   752                 self.Buttons[0].Disable()

   753                 self.Buttons[1].Enable()

   754             else:

   755                 self.Buttons[1].Disable()

   756                 self.Buttons[0].Enable()

   757             self.RefreshButtonsState(True)

   758             

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

   760             w, h = gc.GetTextExtent(item_value)

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

   762             

   763             self.DrawCommonElements(gc)

   764             

   765             gc.EndDrawing()

   766         

   767         def OnLeftDown(self, event):

   768             width, height = self.GetSize()

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

   770             w, h = self.GetTextExtent(item_name)

   771             x, y = event.GetPosition()

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

   773             if rect.InsideXY(x, y):

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

   775                 dragSource = wx.DropSource(self)

   776                 dragSource.SetData(data)

   777                 dragSource.DoDragDrop()

   778             else:

   779                 event.Skip()

   780         

   781         def OnLeftUp(self, event):

   782             x, y = event.GetPosition()

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

   784             event.Skip()

   785         

   786         def OnPaint(self, event):

   787             self.RefreshViewer()

   788             event.Skip()

   789     

   790     class DebugVariableGraphic(DebugVariableViewer, FigureCanvas):

   791         

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

   793             DebugVariableViewer.__init__(self, window, items)

   794             

   795             self.CanvasSize = SIZE_MAXI

   796             self.GraphType = graph_type

   797             self.CursorTick = None

   798             self.MouseStartPos = None

   799             self.StartCursorTick = None

   800             self.CanvasStartSize = None

   801             self.ContextualButtons = []

   802             self.ContextualButtonsItem = None

   803             

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

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

   806             

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

   808             self.SetBackgroundColour(wx.WHITE)

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

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

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

   812             

   813             self.SetMinSize(wx.Size(200, 200))

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

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

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

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

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

   819             

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

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

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

   823             self.Buttons.append(

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

   825             self.Buttons.append(

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

   827             

   828             self.ResetGraphics()

   829             self.RefreshLabelsPosition(200)

   830             self.ShowButtons(False)

   831         

   832         def draw(self, drawDC=None):

   833             FigureCanvasAgg.draw(self)

   834     

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

   836             self.bitmap.UseAlpha() 

   837             width, height = self.GetSize()

   838             bbox = self.GetAxesBoundingBox()

   839             

   840             destDC = wx.MemoryDC()

   841             destDC.SelectObject(self.bitmap)

   842             

   843             destGC = wx.GCDC(destDC)

   844             

   845             destGC.BeginDrawing()

   846             if self.Highlight == HIGHLIGHT_RESIZE:

   847                 destGC.SetPen(HIGHLIGHT_RESIZE_PEN)

   848                 destGC.SetBrush(HIGHLIGHT_RESIZE_BRUSH)

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

   850             else:

   851                 destGC.SetPen(HIGHLIGHT_DROP_PEN)

   852                 destGC.SetBrush(HIGHLIGHT_DROP_BRUSH)

   853                 if self.Highlight == HIGHLIGHT_LEFT:

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

   855                                          bbox.width / 2, bbox.height)

   856                 elif self.Highlight == HIGHLIGHT_RIGHT:

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

   858                                          bbox.width / 2, bbox.height)

   859             

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

   861             

   862             destGC.EndDrawing()

   863             

   864             self._isDrawn = True

   865             self.gui_repaint(drawDC=drawDC)

   866         

   867         def GetButtons(self):

   868             return self.Buttons + self.ContextualButtons

   869         

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

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

   872                 self.DismissContextualButtons()

   873             

   874             if self.ContextualButtonsItem is None:

   875                 self.ContextualButtonsItem = item

   876                 

   877                 if self.ContextualButtonsItem.IsForced():

   878                     self.ContextualButtons.append(

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

   880                 else:

   881                     self.ContextualButtons.append(

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

   883                 self.ContextualButtons.append(

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

   885                 self.ContextualButtons.append(

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

   887                 

   888                 offset = 0

   889                 buttons = self.ContextualButtons[:]

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

   891                      buttons.reverse()

   892                 for button in buttons:

   893                     w, h = button.GetSize()

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

   895                         if style == wx.LEFT:

   896                             x = rect.x - w - offset

   897                         else:

   898                             x = rect.x + rect.width + offset

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

   900                         offset += w

   901                     else:

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

   903                         if style == wx.TOP:

   904                             y = rect.y - h - offset

   905                         else:

   906                             y = rect.y + rect.height + offset

   907                         offset += h

   908                     button.SetPosition(x, y)

   909                 self.ParentWindow.ForceRefresh()

   910         

   911         def DismissContextualButtons(self):

   912             if self.ContextualButtonsItem is not None:

   913                 self.ContextualButtonsItem = None

   914                 self.ContextualButtons = []

   915                 self.ParentWindow.ForceRefresh()

   916         

   917         def IsOverContextualButton(self, x, y):

   918             for button in self.ContextualButtons:

   919                 if button.HitTest(x, y):

   920                     return True

   921             return False

   922         

   923         def SetMinSize(self, size):

   924             wx.Window.SetMinSize(self, size)

   925             wx.CallAfter(self.RefreshButtonsState)

   926         

   927         def GetOnChangeSizeButton(self, size):

   928             def OnChangeSizeButton():

   929                 self.CanvasSize = size

   930                 self.SetCanvasSize(200, self.CanvasSize)

   931             return OnChangeSizeButton

   932         

   933         def OnExportGraphButton(self):

   934             self.ExportGraph()

   935         

   936         def OnForceButton(self):

   937             wx.CallAfter(self.ForceValue, 

   938                          self.ContextualButtonsItem)

   939             self.DismissContextualButtons()

   940             

   941         def OnReleaseButton(self):

   942             wx.CallAfter(self.ReleaseValue, 

   943                          self.ContextualButtonsItem)

   944             self.DismissContextualButtons()

   945         

   946         def OnExportItemGraphButton(self):

   947             wx.CallAfter(self.ExportGraph, 

   948                          self.ContextualButtonsItem)

   949             self.DismissContextualButtons()

   950             

   951         def OnRemoveItemButton(self):            

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

   953                          self.ContextualButtonsItem)

   954             self.DismissContextualButtons()

   955         

   956         def RefreshButtonsState(self, refresh_positions=False):

   957             if self:

   958                 width, height = self.GetSize()

   959                 min_width, min_height = self.GetCanvasMinSize()

   960                 for button, size in zip(self.Buttons, 

   961                                         [min_height, SIZE_MIDDLE, SIZE_MAXI]):

   962                     if size == height and button.IsEnabled():

   963                         button.Disable()

   964                         refresh_positions = True

   965                     elif not button.IsEnabled():

   966                         button.Enable()

   967                         refresh_positions = True

   968                 if refresh_positions:

   969                     offset = 0

   970                     buttons = self.Buttons[:]

   971                     buttons.reverse()

   972                     for button in buttons:

   973                         if button.IsShown() and button.IsEnabled():

   974                             w, h = button.GetSize()

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

   976                             offset += w + 2

   977                     self.ParentWindow.ForceRefresh()

   978         

   979         def RefreshLabelsPosition(self, height):

   980             canvas_ratio = 1. / height

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

   982             

   983             self.Figure.subplotpars.update(

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

   985                 bottom= CANVAS_BORDER[0] * canvas_ratio)

   986             

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

   988                 num_item = len(self.Items)

   989                 for idx in xrange(num_item):

   990                     if not self.Is3DCanvas():

   991                         self.AxesLabels[idx].set_position(

   992                             (0.05, 

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

   994                     self.Labels[idx].set_position(

   995                         (0.95, 

   996                          CANVAS_PADDING * graph_ratio + 

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

   998             else:

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

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

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

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

  1003         

  1004             self.Figure.subplots_adjust()

  1005         

  1006         def GetCanvasMinSize(self):

  1007             return wx.Size(200, 

  1008                            CANVAS_BORDER[0] + CANVAS_BORDER[1] + 

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

  1010         

  1011         def SetCanvasSize(self, width, height):

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

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

  1014             self.RefreshLabelsPosition(height)

  1015             self.ParentWindow.RefreshGraphicsSizer()

  1016             

  1017         def GetAxesBoundingBox(self, absolute=False):

  1018             width, height = self.GetSize()

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

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

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

  1022             if absolute:

  1023                 xw, yw = self.GetPosition()

  1024                 bbox.x += xw

  1025                 bbox.y += yw

  1026             return bbox

  1027         

  1028         def OnCanvasButtonPressed(self, event):

  1029             width, height = self.GetSize()

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

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

  1032                 if event.inaxes == self.Axes:

  1033                     item_idx = None

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

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

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

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

  1038                         if rect.InsideXY(x, y):

  1039                             item_idx = i

  1040                             break

  1041                     if item_idx is not None:

  1042                         self.ShowButtons(False)

  1043                         self.DismissContextualButtons()

  1044                         xw, yw = self.GetPosition()

  1045                         self.ParentWindow.StartDragNDrop(self, 

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

  1047                     elif not self.Is3DCanvas():

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

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

  1050                             self.StartCursorTick = self.CursorTick

  1051                             self.HandleCursorMove(event)

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

  1053                             width, height = self.GetSize()

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

  1055                             self.StartCursorTick = start_tick

  1056                 

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

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

  1059                     self.CanvasStartSize = self.GetSize()

  1060         

  1061         def OnCanvasButtonReleased(self, event):

  1062             if self.ParentWindow.IsDragging():

  1063                 width, height = self.GetSize()

  1064                 xw, yw = self.GetPosition()

  1065                 self.ParentWindow.StopDragNDrop(

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

  1067                     xw + event.x, 

  1068                     yw + height - event.y)

  1069             else:

  1070                 self.MouseStartPos = None

  1071                 self.StartCursorTick = None

  1072                 self.CanvasStartSize = None

  1073                 width, height = self.GetSize()

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

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

  1076                     self.SetCursor(wx.NullCursor)

  1077                     self.ParentWindow.ForceRefresh()

  1078         

  1079         def OnCanvasMotion(self, event):

  1080             width, height = self.GetSize()

  1081             if self.ParentWindow.IsDragging():

  1082                 xw, yw = self.GetPosition()

  1083                 self.ParentWindow.MoveDragNDrop(

  1084                     xw + event.x, 

  1085                     yw + height - event.y)

  1086             else:

  1087                 if not self.Is3DCanvas():

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

  1089                         if event.inaxes == self.Axes:

  1090                             if self.MouseStartPos is not None:

  1091                                 self.HandleCursorMove(event)

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

  1093                             xw, yw = self.GetPosition()

  1094                             self.ParentWindow.SetCursorTick(self.StartCursorTick)

  1095                             self.ParentWindow.StartDragNDrop(self, 

  1096                                 self.Items[0],

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

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

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

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

  1101                         rect = self.GetAxesBoundingBox()

  1102                         self.ParentWindow.SetCanvasPosition(

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

  1104                             (end_tick - start_tick) / rect.width)    

  1105                 

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

  1107                     width, height = self.GetSize()

  1108                     self.SetCanvasSize(width, 

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

  1110                     

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

  1112                     if self.GraphType == GRAPH_PARALLEL:

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

  1114                     elif len(self.AxesLabels) > 0:

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

  1116                     else:

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

  1118                     item_idx = None

  1119                     item_style = None

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

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

  1122                                              orientation):

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

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

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

  1126                             item_idx = i

  1127                             item_style = style

  1128                             break

  1129                     if item_idx is not None:

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

  1131                         return 

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

  1133                         self.DismissContextualButtons()

  1134                     

  1135                     if event.y <= 5: