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) 2007: 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 import re

    26 import math

    27 import time

    28 from types import TupleType

    29 from threading import Lock

    30 

    31 import wx

    32 

    33 from plcopen.structures import *

    34 from PLCControler import ITEM_VAR_LOCAL, ITEM_POU, ITEM_PROGRAM, ITEM_FUNCTIONBLOCK

    35 

    36 from dialogs import *

    37 from graphics import *

    38 from EditorPanel import EditorPanel

    39 

    40 SCROLLBAR_UNIT = 10

    41 WINDOW_BORDER = 10

    42 SCROLL_ZONE = 10

    43 

    44 CURSORS = None

    45 

    46 def ResetCursors():

    47     global CURSORS

    48     if CURSORS == None:

    49         CURSORS = [wx.NullCursor, 

    50                    wx.StockCursor(wx.CURSOR_HAND),

    51                    wx.StockCursor(wx.CURSOR_SIZENWSE),

    52                    wx.StockCursor(wx.CURSOR_SIZENESW),

    53                    wx.StockCursor(wx.CURSOR_SIZEWE),

    54                    wx.StockCursor(wx.CURSOR_SIZENS)]

    55 

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

    57     if wx.VERSION >= (2, 6, 0):

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

    59     else:

    60         parent.Append(helpString=help, id=id, kind=kind, item=text)

    61 

    62 if wx.Platform == '__WXMSW__':

    63     faces = { 'times': 'Times New Roman',

    64               'mono' : 'Courier New',

    65               'helv' : 'Arial',

    66               'other': 'Comic Sans MS',

    67               'size' : 10,

    68              }

    69 else:

    70     faces = { 'times': 'Times',

    71               'mono' : 'Courier',

    72               'helv' : 'Helvetica',

    73               'other': 'new century schoolbook',

    74               'size' : 12,

    75              }

    76 

    77 ZOOM_FACTORS = [math.sqrt(2) ** x for x in xrange(-6, 7)]

    78 

    79 def GetVariableCreationFunction(variable_type):

    80     def variableCreationFunction(viewer, id, specific_values):

    81         return FBD_Variable(viewer, variable_type, 

    82                                     specific_values["name"], 

    83                                     specific_values["value_type"], 

    84                                     id,

    85                                     specific_values["executionOrder"])

    86     return variableCreationFunction

    87 

    88 def GetConnectorCreationFunction(connector_type):

    89     def connectorCreationFunction(viewer, id, specific_values):

    90         return FBD_Connector(viewer, connector_type, 

    91                                      specific_values["name"], id)

    92     return connectorCreationFunction

    93 

    94 def commentCreationFunction(viewer, id, specific_values):

    95     return Comment(viewer, specific_values["content"], id)

    96 

    97 def GetPowerRailCreationFunction(powerrail_type):

    98     def powerRailCreationFunction(viewer, id, specific_values):

    99         return LD_PowerRail(viewer, powerrail_type, id, 

   100                                     specific_values["connectors"])

   101     return powerRailCreationFunction

   102 

   103 CONTACT_TYPES = {(True, "none"): CONTACT_REVERSE,

   104                  (False, "rising"): CONTACT_RISING,

   105                  (False, "falling"): CONTACT_FALLING}

   106 

   107 def contactCreationFunction(viewer, id, specific_values):

   108     contact_type = CONTACT_TYPES.get((specific_values.get("negated", False), 

   109                                       specific_values.get("edge", "none")),

   110                                      CONTACT_NORMAL)

   111     return LD_Contact(viewer, contact_type, specific_values["name"], id)

   112 

   113 COIL_TYPES = {(True, "none", "none"): COIL_REVERSE,

   114               (False, "none", "set"): COIL_SET,

   115               (False, "none", "reset"): COIL_RESET,

   116               (False, "rising", "none"): COIL_RISING,

   117               (False, "falling", "none"): COIL_FALLING}

   118 

   119 def coilCreationFunction(viewer, id, specific_values):

   120     coil_type = COIL_TYPES.get((specific_values.get("negated", False), 

   121                                 specific_values.get("edge", "none"),

   122                                 specific_values.get("storage", "none")),

   123                                COIL_NORMAL)

   124     return LD_Coil(viewer, coil_type, specific_values["name"], id)

   125 

   126 def stepCreationFunction(viewer, id, specific_values):

   127     step = SFC_Step(viewer, specific_values["name"], 

   128                             specific_values.get("initial", False), id)

   129     if specific_values.get("action", None):

   130         step.AddAction()

   131         connector = step.GetActionConnector()

   132         connector.SetPosition(wx.Point(*specific_values["action"]["position"]))

   133     return step

   134 

   135 def transitionCreationFunction(viewer, id, specific_values):

   136     transition = SFC_Transition(viewer, specific_values["condition_type"], 

   137                                         specific_values.get("condition", None), 

   138                                         specific_values["priority"], id)

   139     return transition

   140 

   141 def GetDivergenceCreationFunction(divergence_type):

   142     def divergenceCreationFunction(viewer, id, specific_values):

   143         return SFC_Divergence(viewer, divergence_type, 

   144                                       specific_values["connectors"], id)

   145     return divergenceCreationFunction

   146 

   147 def jumpCreationFunction(viewer, id, specific_values):

   148     return SFC_Jump(viewer, specific_values["target"], id)

   149 

   150 def actionBlockCreationFunction(viewer, id, specific_values):

   151     return SFC_ActionBlock(viewer, specific_values["actions"], id)

   152 

   153 ElementCreationFunctions = {

   154     "input": GetVariableCreationFunction(INPUT),

   155     "output": GetVariableCreationFunction(OUTPUT),

   156     "inout": GetVariableCreationFunction(INOUT),

   157     "connector": GetConnectorCreationFunction(CONNECTOR),

   158     "continuation": GetConnectorCreationFunction(CONTINUATION),

   159     "comment": commentCreationFunction,

   160     "leftPowerRail": GetPowerRailCreationFunction(LEFTRAIL),

   161     "rightPowerRail": GetPowerRailCreationFunction(RIGHTRAIL),

   162     "contact": contactCreationFunction,

   163     "coil": coilCreationFunction,

   164     "step": stepCreationFunction, 

   165     "transition": transitionCreationFunction,

   166     "selectionDivergence": GetDivergenceCreationFunction(SELECTION_DIVERGENCE), 

   167     "selectionConvergence": GetDivergenceCreationFunction(SELECTION_CONVERGENCE), 

   168     "simultaneousDivergence": GetDivergenceCreationFunction(SIMULTANEOUS_DIVERGENCE), 

   169     "simultaneousConvergence": GetDivergenceCreationFunction(SIMULTANEOUS_CONVERGENCE), 

   170     "jump": jumpCreationFunction,

   171     "actionBlock": actionBlockCreationFunction,

   172 }

   173 

   174 def sort_blocks(block_infos1, block_infos2):

   175     x1, y1 = block_infos1[0].GetPosition()

   176     x2, y2 = block_infos2[0].GetPosition()

   177     if y1 == y2:

   178         return cmp(x1, x2)

   179     else:

   180         return cmp(y1, y2)

   181 

   182 #-------------------------------------------------------------------------------

   183 #                       Graphic elements Viewer base class

   184 #-------------------------------------------------------------------------------

   185 

   186 # ID Constants for alignment menu items

   187 [ID_VIEWERALIGNMENTMENUITEMS0, ID_VIEWERALIGNMENTMENUITEMS1,

   188  ID_VIEWERALIGNMENTMENUITEMS2, ID_VIEWERALIGNMENTMENUITEMS4,

   189  ID_VIEWERALIGNMENTMENUITEMS5, ID_VIEWERALIGNMENTMENUITEMS6,

   190 ] = [wx.NewId() for _init_coll_AlignmentMenu_Items in range(6)]

   191 

   192 # ID Constants for contextual menu items

   193 [ID_VIEWERCONTEXTUALMENUITEMS0, ID_VIEWERCONTEXTUALMENUITEMS1,

   194  ID_VIEWERCONTEXTUALMENUITEMS2, ID_VIEWERCONTEXTUALMENUITEMS3,

   195  ID_VIEWERCONTEXTUALMENUITEMS5, ID_VIEWERCONTEXTUALMENUITEMS6,

   196  ID_VIEWERCONTEXTUALMENUITEMS8, ID_VIEWERCONTEXTUALMENUITEMS9,

   197  ID_VIEWERCONTEXTUALMENUITEMS11, ID_VIEWERCONTEXTUALMENUITEMS12,

   198  ID_VIEWERCONTEXTUALMENUITEMS14, ID_VIEWERCONTEXTUALMENUITEMS16,

   199  ID_VIEWERCONTEXTUALMENUITEMS17,

   200 ] = [wx.NewId() for _init_coll_ContextualMenu_Items in range(13)]

   201 

   202 

   203 class ViewerDropTarget(wx.TextDropTarget):

   204     

   205     def __init__(self, parent):

   206         wx.TextDropTarget.__init__(self)

   207         self.ParentWindow = parent

   208     

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

   210         self.ParentWindow.Select()

   211         tagname = self.ParentWindow.GetTagName()

   212         pou_name, pou_type = self.ParentWindow.Controler.GetEditedElementType(tagname, self.ParentWindow.Debug)

   213         x, y = self.ParentWindow.CalcUnscrolledPosition(x, y)

   214         x = int(x / self.ParentWindow.ViewScale[0])

   215         y = int(y / self.ParentWindow.ViewScale[1])

   216         scaling = self.ParentWindow.Scaling

   217         message = None

   218         try:

   219             values = eval(data)

   220         except:

   221             message = _("Invalid value \"%s\" for viewer block")%data

   222             values = None

   223         if not isinstance(values, TupleType):

   224             message = _("Invalid value \"%s\" for viewer block")%data

   225             values = None

   226         if values is not None:

   227             if values[1] == "debug":

   228                 pass

   229             elif values[1] == "program":

   230                 message = _("Programs can't be used by other POUs!")

   231             elif values[1] in ["function", "functionBlock"]:

   232                 words = tagname.split("::")

   233                 if pou_name == values[0]:

   234                     message = _("\"%s\" can't use itself!")%pou_name

   235                 elif pou_type == "function" and values[1] != "function":

   236                     message = _("Function Blocks can't be used in Functions!")

   237                 elif self.ParentWindow.Controler.PouIsUsedBy(pou_name, values[0], self.ParentWindow.Debug):

   238                     message = _("\"%s\" is already used by \"%s\"!")%(pou_name, values[0])

   239                 else:

   240                     blockname = values[2]

   241                     if len(values) > 3:

   242                         blockinputs = values[3]

   243                     else:

   244                         blockinputs = None

   245                     if values[1] != "function" and blockname == "":

   246                         blockname = self.ParentWindow.GenerateNewName(blocktype=values[0])

   247                     if blockname.upper() in [name.upper() for name in self.ParentWindow.Controler.GetProjectPouNames(self.ParentWindow.Debug)]:

   248                         message = _("\"%s\" pou already exists!")%blockname

   249                     elif blockname.upper() in [name.upper() for name in self.ParentWindow.Controler.GetEditedElementVariables(tagname, self.ParentWindow.Debug)]:

   250                         message = _("\"%s\" element for this pou already exists!")%blockname

   251                     else:

   252                         id = self.ParentWindow.GetNewId()

   253                         block = FBD_Block(self.ParentWindow, values[0], blockname, id, inputs = blockinputs)

   254                         width, height = block.GetMinSize()

   255                         if scaling is not None:

   256                             x = round(float(x) / float(scaling[0])) * scaling[0]

   257                             y = round(float(y) / float(scaling[1])) * scaling[1]

   258                             width = round(float(width) / float(scaling[0]) + 0.5) * scaling[0]

   259                             height = round(float(height) / float(scaling[1]) + 0.5) * scaling[1]

   260                         block.SetPosition(x, y)

   261                         block.SetSize(width, height)

   262                         self.ParentWindow.AddBlock(block)

   263                         self.ParentWindow.Controler.AddEditedElementBlock(tagname, id, values[0], blockname)

   264                         self.ParentWindow.RefreshBlockModel(block)

   265                         self.ParentWindow.RefreshBuffer()

   266                         self.ParentWindow.RefreshScrollBars()

   267                         self.ParentWindow.RefreshVisibleElements()

   268                         self.ParentWindow.RefreshVariablePanel()

   269                         self.ParentWindow.Refresh(False)

   270             elif values[1] == "location":

   271                 if pou_type == "program":

   272                     location = values[0]

   273                     if not location.startswith("%"):

   274                         dialog = wx.SingleChoiceDialog(self.ParentWindow.ParentWindow, 

   275                               _("Select a variable class:"), _("Variable class"), 

   276                               ["Input", "Output", "Memory"], 

   277                               wx.DEFAULT_DIALOG_STYLE|wx.OK|wx.CANCEL)

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

   279                             selected = dialog.GetSelection()

   280                         else:

   281                             selected = None

   282                         dialog.Destroy()

   283                         if selected is None:

   284                             return

   285                         if selected == 0:

   286                             location = "%I" + location

   287                         elif selected == 1:

   288                             location = "%Q" + location

   289                         else:

   290                             location = "%M" + location

   291                     var_name = values[3]

   292                     if var_name.upper() in [name.upper() for name in self.ParentWindow.Controler.GetProjectPouNames(self.ParentWindow.Debug)]:

   293                         message = _("\"%s\" pou already exists!")%var_name

   294                     else:

   295                         if location[1] == "Q":

   296                             var_class = OUTPUT

   297                         else:

   298                             var_class = INPUT

   299                         if values[2] is not None:

   300                             var_type = values[2]

   301                         else:

   302                             var_type = LOCATIONDATATYPES.get(location[2], ["BOOL"])[0]

   303                         if not var_name.upper() in [name.upper() for name in self.ParentWindow.Controler.GetEditedElementVariables(tagname, self.ParentWindow.Debug)]:

   304                             self.ParentWindow.Controler.AddEditedElementPouVar(tagname, var_type, var_name, location, values[4])

   305                             self.ParentWindow.RefreshVariablePanel()

   306                             self.ParentWindow.ParentWindow.RefreshPouInstanceVariablesPanel()

   307                         self.ParentWindow.AddVariableBlock(x, y, scaling, var_class, var_name, var_type)

   308             elif values[1] == "Global":

   309                 var_name = values[0]

   310                 if var_name.upper() in [name.upper() for name in self.ParentWindow.Controler.GetProjectPouNames(self.ParentWindow.Debug)]:

   311                     message = _("\"%s\" pou already exists!")%var_name

   312                 else:

   313                     if not var_name.upper() in [name.upper() for name in self.ParentWindow.Controler.GetEditedElementVariables(tagname, self.ParentWindow.Debug)]:

   314                         self.ParentWindow.Controler.AddEditedElementPouExternalVar(tagname, values[2], var_name)

   315                         self.ParentWindow.RefreshVariablePanel()

   316                     self.ParentWindow.AddVariableBlock(x, y, scaling, INPUT, var_name, values[2])

   317             elif values[1] == "Constant":

   318                 self.ParentWindow.AddVariableBlock(x, y, scaling, INPUT, values[0], None)

   319             elif values[3] == tagname:

   320                 if values[1] == "Output":

   321                     var_class = OUTPUT

   322                 elif values[1] == "InOut":

   323                     var_class = INPUT

   324                 else:

   325                     var_class = INPUT

   326                 tree = dict([(var["Name"], var["Tree"]) for var in self.ParentWindow.Controler.GetEditedElementInterfaceVars(tagname, self.ParentWindow.Debug)]).get(values[0], None)

   327                 if tree is not None:

   328                     if len(tree[0]) > 0:

   329                         menu = wx.Menu(title='')

   330                         self.GenerateTreeMenu(x, y, scaling, menu, "", var_class, [(values[0], values[2], tree)])

   331                         self.ParentWindow.PopupMenuXY(menu)

   332                     else:

   333                         self.ParentWindow.AddVariableBlock(x, y, scaling, var_class, values[0], values[2])

   334                 else:

   335                     message = _("Unknown variable \"%s\" for this POU!") % values[0]

   336             else:

   337                 message = _("Variable don't belong to this POU!")

   338         if message is not None:

   339             wx.CallAfter(self.ShowMessage, message)

   340 

   341     def GenerateTreeMenu(self, x, y, scaling, menu, base_path, var_class, tree):

   342         for child_name, child_type, (child_tree, child_dimensions) in tree:

   343             if base_path:

   344                 child_path = "%s.%s" % (base_path, child_name)

   345             else:

   346                 child_path = child_name

   347             if len(child_dimensions) > 0:

   348                 child_path += "[%s]" % ",".join([str(dimension[0]) for dimension in child_dimensions])

   349                 child_name += "[]"

   350             new_id = wx.NewId()

   351             AppendMenu(menu, help='', id=new_id, kind=wx.ITEM_NORMAL, text=child_name)

   352             self.ParentWindow.Bind(wx.EVT_MENU, self.GetAddVariableBlockFunction(x, y, scaling, var_class, child_path, child_type), id=new_id)

   353             if len(child_tree) > 0:

   354                 new_id = wx.NewId()

   355                 child_menu = wx.Menu(title='')

   356                 self.GenerateTreeMenu(x, y, scaling, child_menu, child_path, var_class, child_tree)

   357                 menu.AppendMenu(new_id, "%s." % child_name, child_menu)

   358             

   359     def GetAddVariableBlockFunction(self, x, y, scaling, var_class, var_name, var_type):

   360         def AddVariableFunction(event):

   361             self.ParentWindow.AddVariableBlock(x, y, scaling, var_class, var_name, var_type)

   362         return AddVariableFunction

   363     

   364     def ShowMessage(self, message):

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

   366         message.ShowModal()

   367         message.Destroy()

   368 

   369 """

   370 Class that implements a Viewer based on a wx.ScrolledWindow for drawing and 

   371 manipulating graphic elements

   372 """

   373 

   374 class Viewer(EditorPanel, DebugViewer, DebugDataConsumer):

   375     

   376     if wx.VERSION < (2, 6, 0):

   377         def Bind(self, event, function, id = None):

   378             if id is not None:

   379                 event(self, id, function)

   380             else:

   381                 event(self, function)

   382     

   383     # Add list of menu items to the given menu

   384     def AddMenuItems(self, menu, items):

   385         for item in items:

   386             if item is None:

   387                 menu.AppendSeparator()

   388             else:

   389                 id, kind, text, help, callback = item

   390                 AppendMenu(menu, help=help, id=id, kind=kind, text=text)

   391                 # Link menu event to corresponding called functions

   392                 self.Bind(wx.EVT_MENU, callback, id=id)

   393     

   394     # Add Block Pin Menu items to the given menu

   395     def AddBlockPinMenuItems(self, menu, connector):

   396         [ID_NO_MODIFIER, ID_NEGATED, ID_RISING_EDGE, 

   397          ID_FALLING_EDGE] = [wx.NewId() for i in xrange(4)]

   398         

   399         # Create menu items

   400         self.AddMenuItems(menu, [

   401             (ID_NO_MODIFIER, wx.ITEM_RADIO, _(u'No Modifier'), '', self.OnNoModifierMenu),

   402             (ID_NEGATED, wx.ITEM_RADIO, _(u'Negated'), '', self.OnNegatedMenu),

   403             (ID_RISING_EDGE, wx.ITEM_RADIO, _(u'Rising Edge'), '', self.OnRisingEdgeMenu),

   404             (ID_FALLING_EDGE, wx.ITEM_RADIO, _(u'Falling Edge'), '', self.OnFallingEdgeMenu)])

   405         

   406         type = self.Controler.GetEditedElementType(self.TagName, self.Debug)

   407         menu.Enable(ID_RISING_EDGE, type != "function")

   408         menu.Enable(ID_FALLING_EDGE, type != "function")

   409         

   410         if connector.IsNegated():

   411             menu.Check(ID_NEGATED, True)

   412         elif connector.GetEdge() == "rising":

   413             menu.Check(ID_RISING_EDGE, True)

   414         elif connector.GetEdge() == "falling":

   415             menu.Check(ID_FALLING_EDGE, True)

   416         else:

   417             menu.Check(ID_NO_MODIFIER, True)

   418         

   419     # Add Alignment Menu items to the given menu

   420     def AddAlignmentMenuItems(self, menu):

   421         [ID_ALIGN_LEFT, ID_ALIGN_CENTER, ID_ALIGN_RIGHT,

   422          ID_ALIGN_TOP, ID_ALIGN_MIDDLE, ID_ALIGN_BOTTOM,

   423         ] = [wx.NewId() for i in xrange(6)]

   424         

   425         # Create menu items

   426         self.AddMenuItems(menu, [

   427             (ID_ALIGN_LEFT, wx.ITEM_NORMAL, _(u'Left'), '', self.OnAlignLeftMenu),

   428             (ID_ALIGN_CENTER, wx.ITEM_NORMAL, _(u'Center'), '', self.OnAlignCenterMenu), 

   429             (ID_ALIGN_RIGHT, wx.ITEM_NORMAL, _(u'Right'), '', self.OnAlignRightMenu),

   430             None,

   431             (ID_ALIGN_TOP, wx.ITEM_NORMAL, _(u'Top'), '', self.OnAlignTopMenu), 

   432             (ID_ALIGN_MIDDLE, wx.ITEM_NORMAL, _(u'Middle'), '', self.OnAlignMiddleMenu),

   433             (ID_ALIGN_BOTTOM, wx.ITEM_NORMAL, _(u'Bottom'), '', self.OnAlignBottomMenu)])

   434     

   435     # Add Wire Menu items to the given menu

   436     def AddWireMenuItems(self, menu, delete=False):

   437         [ID_ADD_SEGMENT, ID_DELETE_SEGMENT] = [wx.NewId() for i in xrange(2)]

   438         

   439         # Create menu items

   440         self.AddMenuItems(menu, [

   441             (ID_ADD_SEGMENT, wx.ITEM_NORMAL, _(u'Add Wire Segment'), '', self.OnAddSegmentMenu),

   442             (ID_DELETE_SEGMENT, wx.ITEM_NORMAL, _(u'Delete Wire Segment'), '', self.OnDeleteSegmentMenu)])

   443     

   444         menu.Enable(ID_DELETE_SEGMENT, delete)

   445     

   446     # Add Divergence Menu items to the given menu

   447     def AddDivergenceMenuItems(self, menu, delete=False):

   448         [ID_ADD_BRANCH, ID_DELETE_BRANCH] = [wx.NewId() for i in xrange(2)]

   449         

   450         # Create menu items

   451         self.AddMenuItems(menu, [

   452             (ID_ADD_BRANCH, wx.ITEM_NORMAL, _(u'Add Divergence Branch'), '', self.OnAddBranchMenu),

   453             (ID_DELETE_BRANCH, wx.ITEM_NORMAL, _(u'Delete Divergence Branch'), '', self.OnDeleteBranchMenu)])

   454         

   455         menu.Enable(ID_DELETE_BRANCH, delete)

   456     

   457     # Add Add Menu items to the given menu

   458     def AddAddMenuItems(self, menu):

   459         [ID_ADD_BLOCK, ID_ADD_VARIABLE, ID_ADD_CONNECTION,

   460          ID_ADD_COMMENT] = [wx.NewId() for i in xrange(4)]

   461         

   462         # Create menu items

   463         self.AddMenuItems(menu, [

   464             (ID_ADD_BLOCK, wx.ITEM_NORMAL, _(u'Block'), '', self.GetAddMenuCallBack(self.AddNewBlock)),

   465             (ID_ADD_VARIABLE, wx.ITEM_NORMAL, _(u'Variable'), '', self.GetAddMenuCallBack(self.AddNewVariable)),

   466             (ID_ADD_CONNECTION, wx.ITEM_NORMAL, _(u'Connection'), '', self.GetAddMenuCallBack(self.AddNewConnection)),

   467             None])

   468         

   469         if self.CurrentLanguage != "FBD":

   470             [ID_ADD_POWER_RAIL, ID_ADD_CONTACT, ID_ADD_COIL,

   471             ] = [wx.NewId() for i in xrange(3)]

   472             

   473             # Create menu items

   474             self.AddMenuItems(menu, [

   475                 (ID_ADD_POWER_RAIL, wx.ITEM_NORMAL, _(u'Power Rail'), '', self.GetAddMenuCallBack(self.AddNewPowerRail)),

   476                 (ID_ADD_CONTACT, wx.ITEM_NORMAL, _(u'Contact'), '', self.GetAddMenuCallBack(self.AddNewContact))])

   477                 

   478             if self.CurrentLanguage != "SFC":

   479                 self.AddMenuItems(menu, [

   480                      (ID_ADD_COIL, wx.ITEM_NORMAL, _(u'Coil'), '', self.GetAddMenuCallBack(self.AddNewCoil))])

   481             

   482             menu.AppendSeparator()

   483         

   484         if self.CurrentLanguage == "SFC":

   485             [ID_ADD_INITIAL_STEP, ID_ADD_STEP, ID_ADD_TRANSITION, 

   486              ID_ADD_ACTION_BLOCK, ID_ADD_DIVERGENCE, ID_ADD_JUMP,

   487             ] = [wx.NewId() for i in xrange(6)]

   488             

   489             # Create menu items

   490             self.AddMenuItems(menu, [

   491                 (ID_ADD_INITIAL_STEP, wx.ITEM_NORMAL, _(u'Initial Step'), '', self.GetAddMenuCallBack(self.AddNewStep, True)),

   492                 (ID_ADD_STEP, wx.ITEM_NORMAL, _(u'Step'), '', self.GetAddMenuCallBack(self.AddNewStep)),

   493                 (ID_ADD_TRANSITION, wx.ITEM_NORMAL, _(u'Transition'), '', self.GetAddMenuCallBack(self.AddNewTransition)),

   494                 (ID_ADD_ACTION_BLOCK, wx.ITEM_NORMAL, _(u'Action Block'), '', self.GetAddMenuCallBack(self.AddNewActionBlock)),

   495                 (ID_ADD_DIVERGENCE, wx.ITEM_NORMAL, _(u'Divergence'), '', self.GetAddMenuCallBack(self.AddNewDivergence)),

   496                 (ID_ADD_JUMP, wx.ITEM_NORMAL, _(u'Jump'), '', self.GetAddMenuCallBack(self.AddNewJump)),

   497                 None])

   498         

   499         self.AddMenuItems(menu, [

   500              (ID_ADD_COMMENT, wx.ITEM_NORMAL, _(u'Comment'), '', self.GetAddMenuCallBack(self.AddNewComment))])

   501         

   502     # Add Default Menu items to the given menu

   503     def AddDefaultMenuItems(self, menu, edit=False, block=False):

   504         if block:

   505             [ID_EDIT_BLOCK, ID_DELETE, ID_ADJUST_BLOCK_SIZE] = [wx.NewId() for i in xrange(3)]

   506         

   507             # Create menu items

   508             self.AddMenuItems(menu, [

   509                  (ID_EDIT_BLOCK, wx.ITEM_NORMAL, _(u'Edit Block'), '', self.OnEditBlockMenu),

   510                  (ID_ADJUST_BLOCK_SIZE, wx.ITEM_NORMAL, _(u'Adjust Block Size'), '', self.OnAdjustBlockSizeMenu),

   511                  (ID_DELETE, wx.ITEM_NORMAL, _(u'Delete'), '', self.OnDeleteMenu)])

   512         

   513             menu.Enable(ID_EDIT_BLOCK, edit)

   514         

   515         else:

   516             [ID_CLEAR_EXEC_ORDER, ID_RESET_EXEC_ORDER] = [wx.NewId() for i in xrange(2)]

   517         

   518             # Create menu items

   519             self.AddMenuItems(menu, [

   520                  (ID_CLEAR_EXEC_ORDER, wx.ITEM_NORMAL, _(u'Clear Execution Order'), '', self.OnClearExecutionOrderMenu),

   521                  (ID_RESET_EXEC_ORDER, wx.ITEM_NORMAL, _(u'Reset Execution Order'), '', self.OnResetExecutionOrderMenu)])

   522             

   523             menu.AppendSeparator()

   524             

   525             add_menu = wx.Menu(title='')

   526             self.AddAddMenuItems(add_menu)

   527             menu.AppendMenu(-1, _(u'Add'), add_menu)

   528         

   529         menu.AppendSeparator()

   530         

   531         [ID_CUT, ID_COPY, ID_PASTE] = [wx.NewId() for i in xrange(3)]

   532         

   533         # Create menu items

   534         self.AddMenuItems(menu, [

   535              (ID_CUT, wx.ITEM_NORMAL, _(u'Cut'), '', self.GetClipboardCallBack(self.Cut)),

   536              (ID_COPY, wx.ITEM_NORMAL, _(u'Copy'), '', self.GetClipboardCallBack(self.Copy)),

   537              (ID_PASTE, wx.ITEM_NORMAL, _(u'Paste'), '', self.GetAddMenuCallBack(self.Paste))])

   538         

   539         menu.Enable(ID_CUT, block)

   540         menu.Enable(ID_COPY, block)

   541         menu.Enable(ID_PASTE, self.ParentWindow.GetCopyBuffer() is not None)

   542         

   543     def _init_Editor(self, prnt):

   544         self.Editor = wx.ScrolledWindow(prnt, name="Viewer", 

   545             pos=wx.Point(0, 0), size=wx.Size(0, 0), 

   546             style=wx.HSCROLL | wx.VSCROLL | wx.ALWAYS_SHOW_SB)

   547         self.Editor.ParentWindow = self

   548     

   549     # Create a new Viewer

   550     def __init__(self, parent, tagname, window, controler, debug = False, instancepath = ""):

   551         self.VARIABLE_PANEL_TYPE = controler.GetPouType(tagname.split("::")[1])

   552         

   553         EditorPanel.__init__(self, parent, tagname, window, controler, debug)

   554         DebugViewer.__init__(self, controler, debug)

   555         DebugDataConsumer.__init__(self)

   556         

   557         # Adding a rubberband to Viewer

   558         self.rubberBand = RubberBand(viewer=self)

   559         self.Editor.SetBackgroundColour(wx.Colour(255,255,255))

   560         self.Editor.SetBackgroundStyle(wx.BG_STYLE_CUSTOM)

   561         self.ResetView()

   562         self.Scaling = None

   563         self.DrawGrid = True

   564         self.GridBrush = wx.TRANSPARENT_BRUSH

   565         self.PageSize = None

   566         self.PagePen = wx.TRANSPARENT_PEN

   567         self.DrawingWire = False

   568         self.current_id = 0

   569         self.TagName = tagname

   570         self.Highlights = []

   571         self.SearchParams = None

   572         self.SearchResults = None

   573         self.CurrentFindHighlight = None

   574         self.InstancePath = instancepath

   575         self.StartMousePos = None

   576         self.StartScreenPos = None

   577         self.Buffering = False

   578         

   579         # Initialize Cursors

   580         ResetCursors()

   581         self.CurrentCursor = 0

   582         

   583         # Initialize Block, Wire and Comment numbers

   584         self.wire_id = 0

   585         

   586         # Initialize Viewer mode to Selection mode

   587         self.Mode = MODE_SELECTION

   588         self.SavedMode = False

   589         self.CurrentLanguage = "FBD"

   590         

   591         if not self.Debug:

   592             self.Editor.SetDropTarget(ViewerDropTarget(self))

   593         

   594         self.ElementRefreshList = []

   595         self.ElementRefreshList_lock = Lock()

   596         

   597         dc = wx.ClientDC(self.Editor)

   598         font = wx.Font(faces["size"], wx.SWISS, wx.NORMAL, wx.NORMAL, faceName = faces["mono"])

   599         dc.SetFont(font)

   600         width, height = dc.GetTextExtent("ABCDEFGHIJKLMNOPQRSTUVWXYZ")

   601         while width > 260:

   602             faces["size"] -= 1

   603             font = wx.Font(faces["size"], wx.SWISS, wx.NORMAL, wx.NORMAL, faceName = faces["mono"])

   604             dc.SetFont(font)

   605             width, height = dc.GetTextExtent("ABCDEFGHIJKLMNOPQRSTUVWXYZ")

   606         self.SetFont(font)

   607         self.MiniTextDC = wx.MemoryDC()

   608         self.MiniTextDC.SetFont(wx.Font(faces["size"] * 0.75, wx.SWISS, wx.NORMAL, wx.NORMAL, faceName = faces["helv"]))

   609         

   610         self.CurrentScale = None

   611         self.SetScale(len(ZOOM_FACTORS) / 2, False)

   612         

   613         self.RefreshHighlightsTimer = wx.Timer(self, -1)

   614         self.Bind(wx.EVT_TIMER, self.OnRefreshHighlightsTimer, self.RefreshHighlightsTimer)

   615         

   616         self.ResetView()

   617         

   618         # Link Viewer event to corresponding methods

   619         self.Editor.Bind(wx.EVT_PAINT, self.OnPaint)

   620         self.Editor.Bind(wx.EVT_LEFT_DOWN, self.OnViewerLeftDown)

   621         self.Editor.Bind(wx.EVT_LEFT_UP, self.OnViewerLeftUp)

   622         self.Editor.Bind(wx.EVT_LEFT_DCLICK, self.OnViewerLeftDClick)

   623         self.Editor.Bind(wx.EVT_RIGHT_DOWN, self.OnViewerRightDown)

   624         self.Editor.Bind(wx.EVT_RIGHT_UP, self.OnViewerRightUp)

   625         self.Editor.Bind(wx.EVT_MIDDLE_DOWN, self.OnViewerMiddleDown)

   626         self.Editor.Bind(wx.EVT_MIDDLE_UP, self.OnViewerMiddleUp)

   627         self.Editor.Bind(wx.EVT_LEAVE_WINDOW, self.OnLeaveViewer)

   628         self.Editor.Bind(wx.EVT_MOTION, self.OnViewerMotion)

   629         self.Editor.Bind(wx.EVT_CHAR, self.OnChar)

   630         self.Editor.Bind(wx.EVT_SCROLLWIN, self.OnScrollWindow)

   631         self.Editor.Bind(wx.EVT_SCROLLWIN_THUMBRELEASE, self.OnScrollStop)

   632         self.Editor.Bind(wx.EVT_MOUSEWHEEL, self.OnMouseWheelWindow)

   633         self.Editor.Bind(wx.EVT_SIZE, self.OnMoveWindow)

   634         self.Editor.Bind(wx.EVT_MOUSE_EVENTS, self.OnViewerMouseEvent)

   635     

   636     # Destructor

   637     def __del__(self):

   638         DebugViewer.__del__(self)

   639         self.Flush()

   640         self.ResetView()

   641         self.RefreshHighlightsTimer.Stop()

   642     

   643     def SetCurrentCursor(self, cursor):

   644         if self.Mode != MODE_MOTION:

   645             global CURSORS

   646             if self.CurrentCursor != cursor:

   647                 self.CurrentCursor = cursor

   648                 self.Editor.SetCursor(CURSORS[cursor])

   649     

   650     def GetScrolledRect(self, rect):

   651         rect.x, rect.y = self.Editor.CalcScrolledPosition(int(rect.x * self.ViewScale[0]), 

   652                                                    int(rect.y * self.ViewScale[1]))

   653         rect.width = int(rect.width * self.ViewScale[0]) + 2

   654         rect.height = int(rect.height * self.ViewScale[1]) + 2

   655         return rect

   656     

   657     def GetTitle(self):

   658         if self.Debug:

   659             if len(self.InstancePath) > 15:

   660                 return "..." + self.InstancePath[-12:]

   661             return self.InstancePath

   662         return EditorPanel.GetTitle(self)

   663     

   664     def GetScaling(self):

   665         return self.Scaling

   666     

   667     def GetInstancePath(self, variable_base=False):

   668         if variable_base:

   669             words = self.TagName.split("::")

   670             if words[0] in ["A", "T"]:

   671                 return ".".join(self.InstancePath.split(".")[:-1])

   672         return self.InstancePath

   673     

   674     def IsViewing(self, tagname):

   675         if self.Debug:

   676             return self.InstancePath == tagname

   677         return EditorPanel.IsViewing(self, tagname)

   678     

   679     # Returns a new id

   680     def GetNewId(self):

   681         self.current_id += 1

   682         return self.current_id

   683         

   684     def SetScale(self, scale_number, refresh=True, mouse_event=None):

   685         new_scale = max(0, min(scale_number, len(ZOOM_FACTORS) - 1))

   686         if self.CurrentScale != new_scale:

   687             if refresh:

   688                 dc = self.GetLogicalDC()

   689             self.CurrentScale = new_scale

   690             self.ViewScale = (ZOOM_FACTORS[self.CurrentScale], ZOOM_FACTORS[self.CurrentScale])

   691             if refresh:

   692                 self.Editor.Freeze()

   693                 if mouse_event is None:

   694                     client_size = self.Editor.GetClientSize()

   695                     mouse_pos = wx.Point(client_size[0] / 2, client_size[1] / 2)

   696                     mouse_event = wx.MouseEvent(wx.EVT_MOUSEWHEEL.typeId)

   697                     mouse_event.m_x = mouse_pos.x

   698                     mouse_event.m_y = mouse_pos.y

   699                 else:

   700                     mouse_pos = mouse_event.GetPosition()

   701                 pos = mouse_event.GetLogicalPosition(dc)

   702                 xmax = self.GetScrollRange(wx.HORIZONTAL) - self.GetScrollThumb(wx.HORIZONTAL)

   703                 ymax = self.GetScrollRange(wx.VERTICAL) - self.GetScrollThumb(wx.VERTICAL)

   704                 scrollx = max(0, round(pos.x * self.ViewScale[0] - mouse_pos.x) / SCROLLBAR_UNIT)

   705                 scrolly = max(0, round(pos.y * self.ViewScale[1] - mouse_pos.y) / SCROLLBAR_UNIT)

   706                 if scrollx > xmax or scrolly > ymax:

   707                     self.RefreshScrollBars(max(0, scrollx - xmax), max(0, scrolly - ymax))

   708                     self.Scroll(scrollx, scrolly)

   709                 else:

   710                     self.Scroll(scrollx, scrolly)

   711                     self.RefreshScrollBars()

   712                 self.RefreshScaling(refresh)

   713                 self.Editor.Thaw()

   714     

   715     def GetScale(self):

   716         return self.CurrentScale

   717 

   718     def GetViewScale(self):

   719         return self.ViewScale

   720 

   721     def GetState(self):

   722         return {"position": self.Editor.GetViewStart(),

   723                 "zoom": self.CurrentScale}

   724 

   725     def SetState(self, state):

   726         if self:

   727             if state.has_key("zoom"):

   728                 self.SetScale(state["zoom"])

   729             if state.has_key("position"):

   730                 self.Scroll(*state["position"])

   731             self.RefreshVisibleElements()

   732         

   733     def GetLogicalDC(self, buffered=False):

   734         if buffered:

   735             bitmap = wx.EmptyBitmap(*self.Editor.GetClientSize())

   736             dc = wx.MemoryDC(bitmap)

   737         else:

   738             dc = wx.ClientDC(self.Editor)

   739         dc.SetFont(self.GetFont())

   740         if wx.VERSION >= (2, 6, 0):

   741             self.Editor.DoPrepareDC(dc)

   742         else:

   743             self.Editor.PrepareDC(dc)

   744         dc.SetUserScale(self.ViewScale[0], self.ViewScale[1])

   745         return dc

   746     

   747     def RefreshRect(self, rect, eraseBackground=True):

   748         self.Editor.RefreshRect(rect, eraseBackground)

   749     

   750     def Scroll(self, x, y):

   751         self.Editor.Scroll(x, y)

   752     

   753     def GetScrollPos(self, orientation):

   754         return self.Editor.GetScrollPos(orientation)

   755     

   756     def GetScrollRange(self, orientation):

   757         return self.Editor.GetScrollRange(orientation)

   758     

   759     def GetScrollThumb(self, orientation):

   760         return self.Editor.GetScrollThumb(orientation)

   761     

   762     def CalcUnscrolledPosition(self, x, y):

   763         return self.Editor.CalcUnscrolledPosition(x, y)

   764     

   765     def GetViewStart(self):

   766         return self.Editor.GetViewStart()

   767     

   768     def GetTextExtent(self, text):

   769         return self.Editor.GetTextExtent(text)

   770     

   771     def GetFont(self):

   772         return self.Editor.GetFont()

   773     

   774     def GetMiniTextExtent(self, text):

   775         return self.MiniTextDC.GetTextExtent(text)

   776     

   777     def GetMiniFont(self):

   778         return self.MiniTextDC.GetFont()

   779     

   780 #-------------------------------------------------------------------------------

   781 #                         Element management functions

   782 #-------------------------------------------------------------------------------

   783 

   784     def AddBlock(self, block):

   785         self.Blocks[block.GetId()] = block

   786         

   787     def AddWire(self, wire):

   788         self.wire_id += 1

   789         self.Wires[wire] = self.wire_id

   790         

   791     def AddComment(self, comment):

   792         self.Comments[comment.GetId()] = comment

   793 

   794     def IsBlock(self, block):

   795         if block is not None:

   796             return self.Blocks.get(block.GetId(), False)

   797         return False

   798         

   799     def IsWire(self, wire):

   800         return self.Wires.get(wire, False)

   801         

   802     def IsComment(self, comment):

   803         if comment is not None:

   804             return self.Comments.get(comment.GetId(), False)

   805         return False

   806 

   807     def RemoveBlock(self, block):

   808         self.Blocks.pop(block.GetId())

   809         

   810     def RemoveWire(self, wire):

   811         self.Wires.pop(wire)

   812         

   813     def RemoveComment(self, comment):

   814         self.Comments.pop(comment.GetId())

   815 

   816     def GetElements(self, sort_blocks=False, sort_wires=False, sort_comments=False):

   817         blocks = self.Blocks.values()

   818         wires = self.Wires.keys()

   819         comments = self.Comments.values()

   820         if sort_blocks:

   821             blocks.sort(lambda x, y: cmp(x.GetId(), y.GetId()))

   822         if sort_wires:

   823             wires.sort(lambda x, y: cmp(self.Wires[x], self.Wires[y]))

   824         if sort_comments:

   825             comments.sort(lambda x, y: cmp(x.GetId(), y.GetId()))

   826         return blocks + wires + comments

   827 

   828     def GetConnectorByName(self, name):

   829         for block in self.Blocks.itervalues():

   830             if isinstance(block, FBD_Connector) and\

   831                block.GetType() == CONNECTOR and\

   832                block.GetName() == name:

   833                 return block

   834         return None

   835     

   836     def RefreshVisibleElements(self, xp = None, yp = None):

   837         x, y = self.Editor.CalcUnscrolledPosition(0, 0)

   838         if xp is not None:

   839             x = xp * self.Editor.GetScrollPixelsPerUnit()[0]

   840         if yp is not None:

   841             y = yp * self.Editor.GetScrollPixelsPerUnit()[1]

   842         width, height = self.Editor.GetClientSize()

   843         screen = wx.Rect(int(x / self.ViewScale[0]), int(y / self.ViewScale[1]),

   844                          int(width / self.ViewScale[0]), int(height / self.ViewScale[1]))

   845         for comment in self.Comments.itervalues():

   846             comment.TestVisible(screen)

   847         for wire in self.Wires.iterkeys():

   848             wire.TestVisible(screen)

   849         for block in self.Blocks.itervalues():

   850             block.TestVisible(screen)

   851     

   852     def GetElementIECPath(self, element):

   853         iec_path = None

   854         instance_path = self.GetInstancePath(True)

   855         if isinstance(element, Wire) and element.EndConnected is not None:

   856             block = element.EndConnected.GetParentBlock()

   857             if isinstance(block, FBD_Block):

   858                 blockname = block.GetName()

   859                 connectorname = element.EndConnected.GetName()

   860                 if blockname != "":

   861                     iec_path = "%s.%s.%s"%(instance_path, blockname, connectorname)

   862                 else:

   863                     if connectorname == "":

   864                         iec_path = "%s.%s%d"%(instance_path, block.GetType(), block.GetId())

   865                     else:

   866                         iec_path = "%s.%s%d_%s"%(instance_path, block.GetType(), block.GetId(), connectorname)

   867             elif isinstance(block, FBD_Variable):

   868                 iec_path = "%s.%s"%(instance_path, block.GetName())

   869             elif isinstance(block, FBD_Connector):

   870                 connection = self.GetConnectorByName(block.GetName())

   871                 if connection is not None:

   872                     connector = connection.GetConnector()

   873                     if len(connector.Wires) == 1:

   874                         iec_path = self.GetElementIECPath(connector.Wires[0][0])

   875         elif isinstance(element, LD_Contact):

   876             iec_path = "%s.%s"%(instance_path, element.GetName())

   877         elif isinstance(element, SFC_Step):

   878             iec_path = "%s.%s.X"%(instance_path, element.GetName())

   879         elif isinstance(element, SFC_Transition):

   880             connectors = element.GetConnectors()

   881             previous_steps = self.GetPreviousSteps(connectors["inputs"])

   882             next_steps = self.GetNextSteps(connectors["outputs"])

   883             iec_path = "%s.%s->%s"%(instance_path, ",".join(previous_steps), ",".join(next_steps))

   884         return iec_path

   885        

   886 #-------------------------------------------------------------------------------

   887 #                              Reset functions

   888 #-------------------------------------------------------------------------------

   889 

   890     # Resets Viewer lists

   891     def ResetView(self):

   892         self.Blocks = {}

   893         self.Wires = {}

   894         self.Comments = {}

   895         self.Subscribed = {}

   896         self.SelectedElement = None

   897         self.HighlightedElement = None

   898         self.ToolTipElement = None

   899     

   900     def Flush(self):

   901         self.DeleteDataConsumers()

   902         for block in self.Blocks.itervalues():

   903             block.Flush()

   904     

   905     # Remove all elements

   906     def CleanView(self):

   907         for block in self.Blocks.itervalues():

   908             block.Clean()

   909         self.ResetView()

   910     

   911     # Changes Viewer mode

   912     def SetMode(self, mode):

   913         if self.Mode != mode or mode == MODE_SELECTION:    

   914             if self.Mode == MODE_MOTION:

   915                 wx.CallAfter(self.Editor.SetCursor, wx.NullCursor)

   916             self.Mode = mode

   917             self.SavedMode = False

   918         else:

   919             self.SavedMode = True

   920         # Reset selection

   921         if self.Mode != MODE_SELECTION and self.SelectedElement:

   922             self.SelectedElement.SetSelected(False)

   923             self.SelectedElement = None

   924         if self.Mode == MODE_MOTION:

   925             wx.CallAfter(self.Editor.SetCursor, wx.StockCursor(wx.CURSOR_HAND))

   926             self.SavedMode = True

   927         

   928     # Return current drawing mode

   929     def GetDrawingMode(self):

   930         return self.ParentWindow.GetDrawingMode()

   931     

   932     # Buffer the last model state

   933     def RefreshBuffer(self):

   934         self.Controler.BufferProject()

   935         if self.ParentWindow:

   936             self.ParentWindow.RefreshTitle()

   937             self.ParentWindow.RefreshFileMenu()

   938             self.ParentWindow.RefreshEditMenu()

   939     

   940     def StartBuffering(self):

   941         if not self.Buffering:

   942             self.Buffering = True

   943             self.Controler.StartBuffering()

   944             if self.ParentWindow:

   945                 self.ParentWindow.RefreshTitle()

   946                 self.ParentWindow.RefreshFileMenu()

   947                 self.ParentWindow.RefreshEditMenu()

   948     

   949     def ResetBuffer(self):

   950         if self.Buffering:

   951             self.Controler.EndBuffering()

   952             self.Buffering = False

   953     

   954     def GetBufferState(self):

   955         if not self.Debug:

   956             return self.Controler.GetBufferState()

   957         return False, False

   958     

   959     def Undo(self):

   960         if not self.Debug:

   961             self.Controler.LoadPrevious()

   962             self.ParentWindow.CloseTabsWithoutModel()

   963             

   964     def Redo(self):

   965         if not self.Debug:

   966             self.Controler.LoadNext()

   967             self.ParentWindow.CloseTabsWithoutModel()

   968         

   969     def HasNoModel(self):

   970         if not self.Debug:

   971             return self.Controler.GetEditedElement(self.TagName) is None

   972         return False

   973     

   974     # Refresh the current scaling

   975     def RefreshScaling(self, refresh=True):

   976         properties = self.Controler.GetProjectProperties(self.Debug)

   977         scaling = properties["scaling"][self.CurrentLanguage]

   978         if scaling[0] != 0 and scaling[1] != 0:

   979             self.Scaling = scaling

   980             if self.DrawGrid:

   981                 width = max(2, int(scaling[0] * self.ViewScale[0]))

   982                 height = max(2, int(scaling[1] * self.ViewScale[1]))

   983                 bitmap = wx.EmptyBitmap(width, height)

   984                 dc = wx.MemoryDC(bitmap)

   985                 dc.SetBackground(wx.Brush(self.Editor.GetBackgroundColour()))

   986                 dc.Clear()

   987                 dc.SetPen(MiterPen(wx.Colour(180, 180, 180)))

   988                 dc.DrawPoint(0, 0)

   989                 self.GridBrush = wx.BrushFromBitmap(bitmap)

   990             else:

   991                 self.GridBrush = wx.TRANSPARENT_BRUSH

   992         else:

   993             self.Scaling = None

   994             self.GridBrush = wx.TRANSPARENT_BRUSH

   995         page_size = properties["pageSize"]

   996         if page_size != (0, 0):

   997             self.PageSize = map(int, page_size)

   998             self.PagePen = MiterPen(wx.Colour(180, 180, 180))

   999         else:

  1000             self.PageSize = None

  1001             self.PagePen = wx.TRANSPARENT_PEN

  1002         if refresh:

  1003             self.RefreshVisibleElements()

  1004             self.Refresh(False)

  1005         

  1006         

  1007 #-------------------------------------------------------------------------------

  1008 #                          Refresh functions

  1009 #-------------------------------------------------------------------------------

  1010     

  1011     VALUE_TRANSLATION = {True: _("Active"), False: _("Inactive")}

  1012 

  1013     def SetValue(self, value):

  1014         if self.Value != value:

  1015             self.Value = value

  1016             

  1017             xstart, ystart = self.GetViewStart()

  1018             window_size = self.Editor.GetClientSize()

  1019             refresh_rect = self.GetRedrawRect()

  1020             if (xstart * SCROLLBAR_UNIT <= refresh_rect.x + refresh_rect.width and 

  1021                 xstart * SCROLLBAR_UNIT + window_size[0] >= refresh_rect.x and

  1022                 ystart * SCROLLBAR_UNIT <= refresh_rect.y + refresh_rect.height and 

  1023                 ystart * SCROLLBAR_UNIT + window_size[1] >= refresh_rect.y):

  1024                 self.ElementNeedRefresh(self)

  1025     

  1026     def GetRedrawRect(self):

  1027         dc = self.GetLogicalDC()

  1028         ipw, iph = dc.GetTextExtent(_("Debug: %s") % self.InstancePath)

  1029         vw, vh = 0, 0

  1030         for value in self.VALUE_TRANSLATION.itervalues():

  1031             w, h = dc.GetTextExtent("(%s)" % value)

  1032             vw = max(vw, w)

  1033             vh = max(vh, h)

  1034         return wx.Rect(ipw + 4, 2, vw, vh)

  1035     

  1036     def ElementNeedRefresh(self, element):

  1037         self.ElementRefreshList_lock.acquire()

  1038         self.ElementRefreshList.append(element)

  1039         self.ElementRefreshList_lock.release()

  1040         

  1041     def RefreshNewData(self):

  1042         refresh_rect = None

  1043         self.ElementRefreshList_lock.acquire()

  1044         for element in self.ElementRefreshList:

  1045             if refresh_rect is None:

  1046                 refresh_rect = element.GetRedrawRect()

  1047             else:

  1048                 refresh_rect.Union(element.GetRedrawRect())

  1049         self.ElementRefreshList = []

  1050         self.ElementRefreshList_lock.release()

  1051         

  1052         if refresh_rect is not None:

  1053             self.RefreshRect(self.GetScrolledRect(refresh_rect), False)

  1054         else:

  1055             DebugViewer.RefreshNewData(self)

  1056         

  1057     # Refresh Viewer elements

  1058     def RefreshView(self, variablepanel=True, selection=None):

  1059         EditorPanel.RefreshView(self, variablepanel)

  1060         

  1061         if self.TagName.split("::")[0] == "A":

  1062             self.AddDataConsumer("%s.Q" % self.InstancePath.upper(), self)

  1063         

  1064         if self.ToolTipElement is not None:

  1065             self.ToolTipElement.ClearToolTip()

  1066             self.ToolTipElement = None

  1067         

  1068         self.Inhibit(True)

  1069         self.current_id = 0

  1070         # Start by reseting Viewer

  1071         self.Flush()

  1072         self.ResetView()

  1073         self.ResetBuffer()

  1074         instance = {}

  1075         # List of ids of already loaded blocks

  1076         ids = []

  1077         # Load Blocks until they are all loaded

  1078         while instance is not None:

  1079             instance = self.Controler.GetEditedElementInstanceInfos(self.TagName, exclude = ids, debug = self.Debug)

  1080             if instance is not None:

  1081                 self.loadInstance(instance, ids, selection)

  1082         self.RefreshScrollBars()

  1083         

  1084         for wire in self.Wires:

  1085             if not wire.IsConnectedCompatible():

  1086                 wire.SetValid(False)

  1087             if self.Debug:

  1088                 iec_path = self.GetElementIECPath(wire)

  1089                 if iec_path is None:

  1090                     block = wire.EndConnected.GetParentBlock()

  1091                     if isinstance(block, LD_PowerRail):

  1092                         wire.SetValue(True)

  1093                 elif self.AddDataConsumer(iec_path.upper(), wire) is None:

  1094                     wire.SetValue("undefined")

  1095 

  1096         if self.Debug:

  1097             for block in self.Blocks.itervalues():

  1098                 block.SpreadCurrent()

  1099                 iec_path = self.GetElementIECPath(block)

  1100                 if iec_path is not None:

  1101                     self.AddDataConsumer(iec_path.upper(), block)

  1102 

  1103         self.Inhibit(False)

  1104         self.RefreshVisibleElements()

  1105         self.ShowHighlights()

  1106         self.Refresh(False)

  1107     

  1108     def GetPreviousSteps(self, connectors):

  1109         steps = []

  1110         for connector in connectors:

  1111             for wire, handle in connector.GetWires():

  1112                 previous = wire.GetOtherConnected(connector).GetParentBlock()

  1113                 if isinstance(previous, SFC_Step):

  1114                     steps.append(previous.GetName())

  1115                 elif isinstance(previous, SFC_Divergence) and previous.GetType() in [SIMULTANEOUS_CONVERGENCE, SELECTION_DIVERGENCE]:

  1116                     connectors = previous.GetConnectors()

  1117                     steps.extend(self.GetPreviousSteps(connectors["inputs"]))

  1118         return steps

  1119     

  1120     def GetNextSteps(self, connectors):

  1121         steps = []

  1122         for connector in connectors:

  1123             for wire, handle in connector.GetWires():

  1124                 next = wire.GetOtherConnected(connector).GetParentBlock()

  1125                 if isinstance(next, SFC_Step):

  1126                     steps.append(next.GetName())

  1127                 elif isinstance(next, SFC_Jump):

  1128                     steps.append(next.GetTarget())

  1129                 elif isinstance(next, SFC_Divergence) and next.GetType() in [SIMULTANEOUS_DIVERGENCE, SELECTION_CONVERGENCE]:

  1130                     connectors = next.GetConnectors()

  1131                     steps.extend(self.GetNextSteps(connectors["outputs"]))

  1132         return steps

  1133     

  1134     def GetMaxSize(self):

  1135         maxx = maxy = 0