Mercurial Mercurial > plcopeneditor_history / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Viewer.py
changeset 666 d4bb66691248
parent 658 89d20745b061
child 667 baab9eb5b8ad
equal deleted inserted replaced
665:6a376615142e 666:d4bb66691248 
   338     def ShowMessage(self, message):
 
   338     def ShowMessage(self, message):
 
   339         message = wx.MessageDialog(self.ParentWindow, message, _("Error"), wx.OK|wx.ICON_ERROR)
 
   339         message = wx.MessageDialog(self.ParentWindow, message, _("Error"), wx.OK|wx.ICON_ERROR)
 
   340         message.ShowModal()
 
   340         message.ShowModal()
 
   341         message.Destroy()
 
   341         message.Destroy()
 
   342 
   342 
   343 
       
   344 """
 
   343 """
 
   345 Class that implements a Viewer based on a wx.ScrolledWindow for drawing and 
   344 Class that implements a Viewer based on a wx.ScrolledWindow for drawing and 
   346 manipulating graphic elements
 
   345 manipulating graphic elements
 
   347 """
 
   346 """
 
   348 
   347 
   353             if id is not None:
 
   352             if id is not None:
 
   354                 event(self, id, function)
 
   353                 event(self, id, function)
 
   355             else:
 
   354             else:
 
   356                 event(self, function)
 
   355                 event(self, function)
 
   357     
   356     
   358     # Create Alignment Menu items
 
   357     # Add list of menu items to the given menu
 
   359     def _init_coll_AlignmentMenu_Items(self, parent):
 
   358     def AddMenuItems(self, menu, items):
 
       
   359         for item in items:
 
       
   360             if item is None:
 
       
   361                 menu.AppendSeparator()
 
       
   362             else:
 
       
   363                 id, kind, text, help, callback = item
 
       
   364                 AppendMenu(menu, help=help, id=id, kind=kind, text=text)
 
       
   365                 # Link menu event to corresponding called functions
 
       
   366                 self.Bind(wx.EVT_MENU, callback, id=id)
 
       
   367     
       
   368     # Add Block Pin Menu items to the given menu
 
       
   369     def AddBlockPinMenuItems(self, menu, connector):
 
       
   370         [ID_NO_MODIFIER, ID_NEGATED, ID_RISING_EDGE, 
       
   371          ID_FALLING_EDGE] = [wx.NewId() for i in xrange(4)]
 
       
   372         
   360         # Create menu items
 
   373         # Create menu items
 
   361         AppendMenu(parent, help='', id=ID_VIEWERALIGNMENTMENUITEMS0,
 
   374         self.AddMenuItems(menu, [
 
   362               kind=wx.ITEM_NORMAL, text=_(u'Left'))
 
   375             (ID_NO_MODIFIER, wx.ITEM_RADIO, _(u'No Modifier'), '', self.OnNoModifierMenu),
 
   363         AppendMenu(parent, help='', id=ID_VIEWERALIGNMENTMENUITEMS1,
 
   376             (ID_NEGATED, wx.ITEM_RADIO, _(u'Negated'), '', self.OnNegatedMenu),
 
   364               kind=wx.ITEM_NORMAL, text=_(u'Center'))
 
   377             (ID_RISING_EDGE, wx.ITEM_RADIO, _(u'Rising Edge'), '', self.OnRisingEdgeMenu),
 
   365         AppendMenu(parent, help='', id=ID_VIEWERALIGNMENTMENUITEMS2,
 
   378             (ID_FALLING_EDGE, wx.ITEM_RADIO, _(u'Falling Edge'), '', self.OnFallingEdgeMenu)])
 
   366               kind=wx.ITEM_NORMAL, text=_(u'Right'))
 
   379         
   367         parent.AppendSeparator()
 
   380         type = self.Controler.GetEditedElementType(self.TagName, self.Debug)
 
   368         AppendMenu(parent, help='', id=ID_VIEWERALIGNMENTMENUITEMS4,
 
   381         menu.Enable(ID_RISING_EDGE, type != "function")
 
   369               kind=wx.ITEM_NORMAL, text=_(u'Top'))
 
   382         menu.Enable(ID_FALLING_EDGE, type != "function")
 
   370         AppendMenu(parent, help='', id=ID_VIEWERALIGNMENTMENUITEMS5,
 
   383         
   371               kind=wx.ITEM_NORMAL, text=_(u'Middle'))
 
   384         if connector.IsNegated():
 
   372         AppendMenu(parent, help='', id=ID_VIEWERALIGNMENTMENUITEMS6,
 
   385             menu.Check(ID_NEGATED, True)
 
   373               kind=wx.ITEM_NORMAL, text=_(u'Bottom'))
 
   386         elif connector.GetEdge() == "rising":
 
   374         # Link menu event to corresponding called functions
 
   387             menu.Check(ID_RISING_EDGE, True)
 
   375         self.Bind(wx.EVT_MENU, self.OnAlignLeftMenu,
 
   388         elif connector.GetEdge() == "falling":
 
   376               id=ID_VIEWERALIGNMENTMENUITEMS0)
 
   389             menu.Check(ID_FALLING_EDGE, True)
 
   377         self.Bind(wx.EVT_MENU, self.OnAlignCenterMenu,
 
   390         else:
 
   378               id=ID_VIEWERALIGNMENTMENUITEMS1)
 
   391             menu.Check(ID_NO_MODIFIER, True)
 
   379         self.Bind(wx.EVT_MENU, self.OnAlignRightMenu,
 
   392         
   380               id=ID_VIEWERALIGNMENTMENUITEMS2)
 
   393     # Add Alignment Menu items to the given menu
 
   381         self.Bind(wx.EVT_MENU, self.OnAlignTopMenu,
 
   394     def AddAlignmentMenuItems(self, menu):
 
   382               id=ID_VIEWERALIGNMENTMENUITEMS4)
 
   395         [ID_ALIGN_LEFT, ID_ALIGN_CENTER, ID_ALIGN_RIGHT,
 
   383         self.Bind(wx.EVT_MENU, self.OnAlignMiddleMenu,
 
   396          ID_ALIGN_TOP, ID_ALIGN_MIDDLE, ID_ALIGN_BOTTOM,
 
   384               id=ID_VIEWERALIGNMENTMENUITEMS5)
 
   397         ] = [wx.NewId() for i in xrange(6)]
 
   385         self.Bind(wx.EVT_MENU, self.OnAlignBottomMenu,
 
   398         
   386               id=ID_VIEWERALIGNMENTMENUITEMS6)
 
       
   387     
       
   388     # Create Contextual Menu items
 
       
   389     def _init_coll_ContextualMenu_Items(self, parent):
 
       
   390         # Create menu items
 
   399         # Create menu items
 
   391         AppendMenu(parent, help='', id=ID_VIEWERCONTEXTUALMENUITEMS0,
 
   400         self.AddMenuItems(menu, [
 
   392               kind=wx.ITEM_RADIO, text=_(u'No Modifier'))
 
   401             (ID_ALIGN_LEFT, wx.ITEM_NORMAL, _(u'Left'), '', self.OnAlignLeftMenu),
 
   393         AppendMenu(parent, help='', id=ID_VIEWERCONTEXTUALMENUITEMS1,
 
   402             (ID_ALIGN_CENTER, wx.ITEM_NORMAL, _(u'Center'), '', self.OnAlignCenterMenu), 
   394               kind=wx.ITEM_RADIO, text=_(u'Negated'))
 
   403             (ID_ALIGN_RIGHT, wx.ITEM_NORMAL, _(u'Right'), '', self.OnAlignRightMenu),
 
   395         AppendMenu(parent, help='', id=ID_VIEWERCONTEXTUALMENUITEMS2,
 
   404             None,
 
   396               kind=wx.ITEM_RADIO, text=_(u'Rising Edge'))
 
   405             (ID_ALIGN_TOP, wx.ITEM_NORMAL, _(u'Top'), '', self.OnAlignTopMenu), 
   397         AppendMenu(parent, help='', id=ID_VIEWERCONTEXTUALMENUITEMS3,
 
   406             (ID_ALIGN_MIDDLE, wx.ITEM_NORMAL, _(u'Middle'), '', self.OnAlignMiddleMenu),
 
   398               kind=wx.ITEM_RADIO, text=_(u'Falling Edge'))
 
   407             (ID_ALIGN_BOTTOM, wx.ITEM_NORMAL, _(u'Bottom'), '', self.OnAlignBottomMenu)])
 
   399         parent.AppendSeparator()
 
   408     
   400         AppendMenu(parent, help='', id=ID_VIEWERCONTEXTUALMENUITEMS5,
 
   409     # Add Wire Menu items to the given menu
 
   401               kind=wx.ITEM_NORMAL, text=_(u'Add Wire Segment'))
 
   410     def AddWireMenuItems(self, menu, delete=False):
 
   402         AppendMenu(parent, help='', id=ID_VIEWERCONTEXTUALMENUITEMS6,
 
   411         [ID_ADD_SEGMENT, ID_DELETE_SEGMENT] = [wx.NewId() for i in xrange(2)]
 
   403               kind=wx.ITEM_NORMAL, text=_(u'Delete Wire Segment'))
 
   412         
   404         parent.AppendSeparator()
 
   413         # Create menu items
 
   405         AppendMenu(parent, help='', id=ID_VIEWERCONTEXTUALMENUITEMS8,
 
   414         self.AddMenuItems(menu, [
 
   406               kind=wx.ITEM_NORMAL, text=_(u'Add Divergence Branch'))
 
   415             (ID_ADD_SEGMENT, wx.ITEM_NORMAL, _(u'Add Wire Segment'), '', self.OnAddSegmentMenu),
 
   407         AppendMenu(parent, help='', id=ID_VIEWERCONTEXTUALMENUITEMS9,
 
   416             (ID_DELETE_SEGMENT, wx.ITEM_NORMAL, _(u'Delete Wire Segment'), '', self.OnDeleteSegmentMenu)])
 
   408               kind=wx.ITEM_NORMAL, text=_(u'Delete Divergence Branch'))
 
   417     
   409         parent.AppendSeparator()
 
   418         menu.Enable(ID_DELETE_SEGMENT, delete)
 
   410         AppendMenu(parent, help='', id=ID_VIEWERCONTEXTUALMENUITEMS11,
 
   419     
   411               kind=wx.ITEM_NORMAL, text=_(u'Clear Execution Order'))
 
   420     # Add Divergence Menu items to the given menu
 
   412         AppendMenu(parent, help='', id=ID_VIEWERCONTEXTUALMENUITEMS12,
 
   421     def AddDivergenceMenuItems(self, menu, delete=False):
 
   413               kind=wx.ITEM_NORMAL, text=_(u'Reset Execution Order'))
 
   422         [ID_ADD_BRANCH, ID_DELETE_BRANCH] = [wx.NewId() for i in xrange(2)]
 
   414         parent.AppendSeparator()
 
   423         
   415         parent.AppendMenu(ID_VIEWERCONTEXTUALMENUITEMS14, _("Alignment"), self.AlignmentMenu)
 
   424         # Create menu items
 
   416         parent.AppendSeparator()
 
   425         self.AddMenuItems(menu, [
 
   417         AppendMenu(parent, help='', id=ID_VIEWERCONTEXTUALMENUITEMS16,
 
   426             (ID_ADD_BRANCH, wx.ITEM_NORMAL, _(u'Add Divergence Branch'), '', self.OnAddBranchMenu),
 
   418               kind=wx.ITEM_NORMAL, text=_(u'Edit Block'))
 
   427             (ID_DELETE_BRANCH, wx.ITEM_NORMAL, _(u'Delete Divergence Branch'), '', self.OnDeleteBranchMenu)])
 
   419         AppendMenu(parent, help='', id=ID_VIEWERCONTEXTUALMENUITEMS17,
 
   428         
   420               kind=wx.ITEM_NORMAL, text=_(u'Delete'))
 
   429         menu.Enable(ID_DELETE_BRANCH, delete)
 
   421         # Link menu event to corresponding called functions
 
   430     
   422         self.Bind(wx.EVT_MENU, self.OnNoModifierMenu,
 
   431     # Add Add Menu items to the given menu
 
   423               id=ID_VIEWERCONTEXTUALMENUITEMS0)
 
   432     def AddAddMenuItems(self, menu):
 
   424         self.Bind(wx.EVT_MENU, self.OnNegatedMenu,
 
   433         [ID_ADD_BLOCK, ID_ADD_VARIABLE, ID_ADD_CONNECTION,
 
   425               id=ID_VIEWERCONTEXTUALMENUITEMS1)
 
   434          ID_ADD_COMMENT] = [wx.NewId() for i in xrange(4)]
 
   426         self.Bind(wx.EVT_MENU, self.OnRisingEdgeMenu,
 
   435         
   427               id=ID_VIEWERCONTEXTUALMENUITEMS2)
 
   436         # Create menu items
 
   428         self.Bind(wx.EVT_MENU, self.OnFallingEdgeMenu,
 
   437         self.AddMenuItems(menu, [
 
   429               id=ID_VIEWERCONTEXTUALMENUITEMS3)
 
   438             (ID_ADD_BLOCK, wx.ITEM_NORMAL, _(u'Block'), '', self.GetAddMenuCallBack(self.AddNewBlock)),
 
   430         self.Bind(wx.EVT_MENU, self.OnAddSegmentMenu,
 
   439             (ID_ADD_VARIABLE, wx.ITEM_NORMAL, _(u'Variable'), '', self.GetAddMenuCallBack(self.AddNewVariable)),
 
   431               id=ID_VIEWERCONTEXTUALMENUITEMS5)
 
   440             (ID_ADD_CONNECTION, wx.ITEM_NORMAL, _(u'Connection'), '', self.GetAddMenuCallBack(self.AddNewConnection)),
 
   432         self.Bind(wx.EVT_MENU, self.OnDeleteSegmentMenu,
 
   441             None])
 
   433               id=ID_VIEWERCONTEXTUALMENUITEMS6)
 
   442         
   434         self.Bind(wx.EVT_MENU, self.OnAddBranchMenu,
 
   443         if self.CurrentLanguage != "FBD":
 
   435               id=ID_VIEWERCONTEXTUALMENUITEMS8)
 
   444             [ID_ADD_POWER_RAIL, ID_ADD_CONTACT, ID_ADD_COIL,
 
   436         self.Bind(wx.EVT_MENU, self.OnDeleteBranchMenu,
 
   445             ] = [wx.NewId() for i in xrange(3)]
 
   437               id=ID_VIEWERCONTEXTUALMENUITEMS9)
 
   446             
   438         self.Bind(wx.EVT_MENU, self.OnClearExecutionOrderMenu,
 
   447             # Create menu items
 
   439               id=ID_VIEWERCONTEXTUALMENUITEMS11)
 
   448             self.AddMenuItems(menu, [
 
   440         self.Bind(wx.EVT_MENU, self.OnResetExecutionOrderMenu,
 
   449                 (ID_ADD_POWER_RAIL, wx.ITEM_NORMAL, _(u'Power Rail'), '', self.GetAddMenuCallBack(self.AddNewPowerRail)),
 
   441               id=ID_VIEWERCONTEXTUALMENUITEMS12)
 
   450                 (ID_ADD_CONTACT, wx.ITEM_NORMAL, _(u'Contact'), '', self.GetAddMenuCallBack(self.AddNewContact))])
 
   442         self.Bind(wx.EVT_MENU, self.OnEditBlockMenu,
 
   451                 
   443               id=ID_VIEWERCONTEXTUALMENUITEMS16)
 
   452             if self.CurrentLanguage != "SFC":
 
   444         self.Bind(wx.EVT_MENU, self.OnDeleteMenu,
 
   453                 self.AddMenuItems(menu, [
 
   445               id=ID_VIEWERCONTEXTUALMENUITEMS17)
 
   454                      (ID_ADD_COIL, wx.ITEM_NORMAL, _(u'Coil'), '', self.GetAddMenuCallBack(self.AddNewCoil))])
 
   446     
   455             
   447     # Create and initialize Contextual Menu
 
   456             menu.AppendSeparator()
 
   448     def _init_menus(self):
 
   457         
   449         self.AlignmentMenu = wx.Menu(title='')
 
   458         if self.CurrentLanguage == "SFC":
 
   450         self.ContextualMenu = wx.Menu(title='')
 
   459             [ID_ADD_INITIAL_STEP, ID_ADD_STEP, ID_ADD_TRANSITION, 
   451         
   460              ID_ADD_ACTION_BLOCK, ID_ADD_DIVERGENCE, ID_ADD_JUMP,
 
   452         self._init_coll_AlignmentMenu_Items(self.AlignmentMenu)
 
   461             ] = [wx.NewId() for i in xrange(6)]
 
   453         self._init_coll_ContextualMenu_Items(self.ContextualMenu)
 
   462             
   454     
   463             # Create menu items
 
       
   464             self.AddMenuItems(menu, [
 
       
   465                 (ID_ADD_INITIAL_STEP, wx.ITEM_NORMAL, _(u'Initial Step'), '', self.GetAddMenuCallBack(self.AddNewStep, True)),
 
       
   466                 (ID_ADD_STEP, wx.ITEM_NORMAL, _(u'Step'), '', self.GetAddMenuCallBack(self.AddNewStep)),
 
       
   467                 (ID_ADD_TRANSITION, wx.ITEM_NORMAL, _(u'Transition'), '', self.GetAddMenuCallBack(self.AddNewTransition)),
 
       
   468                 (ID_ADD_ACTION_BLOCK, wx.ITEM_NORMAL, _(u'Action Block'), '', self.GetAddMenuCallBack(self.AddNewActionBlock)),
 
       
   469                 (ID_ADD_DIVERGENCE, wx.ITEM_NORMAL, _(u'Divergence'), '', self.GetAddMenuCallBack(self.AddNewDivergence)),
 
       
   470                 (ID_ADD_JUMP, wx.ITEM_NORMAL, _(u'Jump'), '', self.GetAddMenuCallBack(self.AddNewJump)),
 
       
   471                 None])
 
       
   472         
       
   473         self.AddMenuItems(menu, [
 
       
   474              (ID_ADD_COMMENT, wx.ITEM_NORMAL, _(u'Comment'), '', self.GetAddMenuCallBack(self.AddNewComment))])
 
       
   475         
       
   476     # Add Default Menu items to the given menu
 
       
   477     def AddDefaultMenuItems(self, menu, edit=False, block=False):
 
       
   478         if block:
 
       
   479             [ID_EDIT_BLOCK, ID_DELETE] = [wx.NewId() for i in xrange(2)]
 
       
   480         
       
   481             # Create menu items
 
       
   482             self.AddMenuItems(menu, [
 
       
   483                  (ID_EDIT_BLOCK, wx.ITEM_NORMAL, _(u'Edit Block'), '', self.OnEditBlockMenu),
 
       
   484                  (ID_DELETE, wx.ITEM_NORMAL, _(u'Delete'), '', self.OnDeleteMenu)])
 
       
   485         
       
   486             menu.Enable(ID_EDIT_BLOCK, edit)
 
       
   487         
       
   488         else:
 
       
   489             [ID_CLEAR_EXEC_ORDER, ID_RESET_EXEC_ORDER] = [wx.NewId() for i in xrange(2)]
 
       
   490         
       
   491             # Create menu items
 
       
   492             self.AddMenuItems(menu, [
 
       
   493                  (ID_CLEAR_EXEC_ORDER, wx.ITEM_NORMAL, _(u'Clear Execution Order'), '', self.OnClearExecutionOrderMenu),
 
       
   494                  (ID_RESET_EXEC_ORDER, wx.ITEM_NORMAL, _(u'Reset Execution Order'), '', self.OnResetExecutionOrderMenu)])
 
       
   495             
       
   496             menu.AppendSeparator()
 
       
   497             
       
   498             add_menu = wx.Menu(title='')
 
       
   499             self.AddAddMenuItems(add_menu)
 
       
   500             menu.AppendMenu(-1, _(u'Add'), add_menu)
 
       
   501         
       
   502         menu.AppendSeparator()
 
       
   503         
       
   504         [ID_CUT, ID_COPY, ID_PASTE] = [wx.NewId() for i in xrange(3)]
 
       
   505         
       
   506         # Create menu items
 
       
   507         self.AddMenuItems(menu, [
 
       
   508              (ID_CUT, wx.ITEM_NORMAL, _(u'Cut'), '', self.GetClipboardCallBack(self.Cut)),
 
       
   509              (ID_COPY, wx.ITEM_NORMAL, _(u'Copy'), '', self.GetClipboardCallBack(self.Copy)),
 
       
   510              (ID_PASTE, wx.ITEM_NORMAL, _(u'Paste'), '', self.GetAddMenuCallBack(self.Paste))])
 
       
   511         
       
   512         menu.Enable(ID_CUT, block)
 
       
   513         menu.Enable(ID_COPY, block)
 
       
   514         menu.Enable(ID_PASTE, self.ParentWindow.GetCopyBuffer() is not None)
 
       
   515         
   455     def _init_Editor(self, prnt):
 
   516     def _init_Editor(self, prnt):
 
   456         self.Editor = wx.ScrolledWindow(prnt, name="Viewer", 
   517         self.Editor = wx.ScrolledWindow(prnt, name="Viewer", 
   457             pos=wx.Point(0, 0), size=wx.Size(0, 0), 
   518             pos=wx.Point(0, 0), size=wx.Size(0, 0), 
   458             style=wx.HSCROLL | wx.VSCROLL | wx.ALWAYS_SHOW_SB)
 
   519             style=wx.HSCROLL | wx.VSCROLL | wx.ALWAYS_SHOW_SB)
 
   459     
   520     
   461     def __init__(self, parent, tagname, window, controler, debug = False, instancepath = ""):
 
   522     def __init__(self, parent, tagname, window, controler, debug = False, instancepath = ""):
 
   462         self.VARIABLE_PANEL_TYPE = controler.GetPouType(tagname.split("::")[1])
 
   523         self.VARIABLE_PANEL_TYPE = controler.GetPouType(tagname.split("::")[1])
 
   463         
   524         
   464         EditorPanel.__init__(self, parent, tagname, window, controler, debug)
 
   525         EditorPanel.__init__(self, parent, tagname, window, controler, debug)
 
   465         DebugViewer.__init__(self, controler, debug)
 
   526         DebugViewer.__init__(self, controler, debug)
 
   466         
       
   467         self._init_menus()
 
       
   468         
   527         
   469         # Adding a rubberband to Viewer
 
   528         # Adding a rubberband to Viewer
 
   470         self.rubberBand = RubberBand(viewer=self)
 
   529         self.rubberBand = RubberBand(viewer=self)
 
   471         self.Editor.SetBackgroundColour(wx.Colour(255,255,255))
 
   530         self.Editor.SetBackgroundColour(wx.Colour(255,255,255))
 
   472         self.Editor.SetBackgroundStyle(wx.BG_STYLE_CUSTOM)
 
   531         self.Editor.SetBackgroundStyle(wx.BG_STYLE_CUSTOM)
 
  1215             if self.SelectedElement.IsForced():
 
  1274             if self.SelectedElement.IsForced():
 
  1216                 menu.Enable(new_id, True)
 
  1275                 menu.Enable(new_id, True)
 
  1217             else:
 
  1276             else:
 
  1218                 menu.Enable(new_id, False)
 
  1277                 menu.Enable(new_id, False)
 
  1219             self.Editor.PopupMenu(menu)
 
  1278             self.Editor.PopupMenu(menu)
 
       
  1279             menu.Destroy()
 
  1220 
  1280 
  1221     def PopupBlockMenu(self, connector = None):
 
  1281     def PopupBlockMenu(self, connector = None):
 
       
  1282         menu = wx.Menu(title='')
 
  1222         if connector is not None and connector.IsCompatible("BOOL"):
 
  1283         if connector is not None and connector.IsCompatible("BOOL"):
 
  1223             type = self.Controler.GetEditedElementType(self.TagName, self.Debug)
 
  1284             self.AddBlockPinMenuItems(menu, connector)
 
  1224             self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS0, True)
 
       
  1225             self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS1, True)
 
       
  1226             self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS2, type != "function")
 
       
  1227             self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS3, type != "function")
 
       
  1228         else:
 
  1285         else:
 
  1229             self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS0, False)
 
  1286             edit = self.SelectedElement.GetType() in self.Controler.GetProjectPouNames(self.Debug)
 
  1230             self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS1, False)
 
  1287             self.AddDefaultMenuItems(menu, block=True, edit=edit)
 
  1231             self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS2, False)
 
  1288         self.Editor.PopupMenu(menu)
 
  1232             self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS3, False)
 
  1289         menu.Destroy()
 
  1233         self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS5, False)
 
       
  1234         self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS6, False)
 
       
  1235         self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS8, False)
 
       
  1236         self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS9, False)
 
       
  1237         self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS14, False)
 
       
  1238         self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS16, self.SelectedElement.GetType() in self.Controler.GetProjectPouNames(self.Debug))
 
       
  1239         self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS17, True)
 
       
  1240         if connector is not None:
 
       
  1241             if connector.IsNegated():
 
       
  1242                 self.ContextualMenu.Check(ID_VIEWERCONTEXTUALMENUITEMS1, True)
 
       
  1243             elif connector.GetEdge() == "rising":
 
       
  1244                 self.ContextualMenu.Check(ID_VIEWERCONTEXTUALMENUITEMS2, True)
 
       
  1245             elif connector.GetEdge() == "falling":
 
       
  1246                 self.ContextualMenu.Check(ID_VIEWERCONTEXTUALMENUITEMS3, True)
 
       
  1247             else:
 
       
  1248                 self.ContextualMenu.Check(ID_VIEWERCONTEXTUALMENUITEMS0, True)
 
       
  1249         self.Editor.PopupMenu(self.ContextualMenu)
 
       
  1250     
  1290     
  1251     def PopupWireMenu(self, delete=True):
 
  1291     def PopupWireMenu(self, delete=True):
 
  1252         self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS0, False)
 
  1292         menu = wx.Menu(title='')
 
  1253         self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS1, False)
 
  1293         self.AddWireMenuItems(menu, delete)
 
  1254         self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS2, False)
 
  1294         menu.AppendSeparator()
 
  1255         self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS3, False)
 
  1295         self.AddDefaultMenuItems(menu, block=True)
 
  1256         self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS5, True)
 
  1296         self.Editor.PopupMenu(menu)
 
  1257         self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS6, delete)
 
  1297         menu.Destroy()
 
  1258         self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS8, False)
 
  1298         
  1259         self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS9, False)
 
       
  1260         self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS14, False)
 
       
  1261         self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS16, False)
 
       
  1262         self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS17, True)
 
       
  1263         self.Editor.PopupMenu(self.ContextualMenu)
 
       
  1264     
       
  1265     def PopupDivergenceMenu(self, connector):
 
  1299     def PopupDivergenceMenu(self, connector):
 
  1266         self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS0, False)
 
  1300         menu = wx.Menu(title='')
 
  1267         self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS1, False)
 
  1301         self.AddDivergenceMenuItems(menu, connector)
 
  1268         self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS2, False)
 
  1302         menu.AppendSeparator()
 
  1269         self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS3, False)
 
  1303         self.AddDefaultMenuItems(menu, block=True)
 
  1270         self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS5, False)
 
  1304         self.Editor.PopupMenu(menu)
 
  1271         self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS6, False)
 
  1305         menu.Destroy()
 
  1272         self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS8, True)
 
       
  1273         self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS9, connector)
 
       
  1274         self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS14, False)
 
       
  1275         self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS16, False)
 
       
  1276         self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS17, True)
 
       
  1277         self.Editor.PopupMenu(self.ContextualMenu)
 
       
  1278     
  1306     
  1279     def PopupGroupMenu(self):
 
  1307     def PopupGroupMenu(self):
 
  1280         self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS0, False)
 
  1308         menu = wx.Menu(title='')
 
  1281         self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS1, False)
 
  1309         align_menu = wx.Menu(title='')
 
  1282         self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS2, False)
 
  1310         self.AddAlignmentMenuItems(align_menu)
 
  1283         self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS3, False)
 
  1311         menu.AppenMenu(-1, _(u'Alignment'), align_menu)
 
  1284         self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS5, False)
 
  1312         menu.AppendSeparator()
 
  1285         self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS6, False)
 
  1313         self.AddDefaultMenuItems(menu, block=True)
 
  1286         self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS8, False)
 
  1314         self.Editor.PopupMenu(menu)
 
  1287         self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS9, False)
 
  1315         menu.Destroy()
 
  1288         self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS14, True)
 
  1316         
  1289         self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS16, False)
 
  1317     def PopupDefaultMenu(self, block=True):
 
  1290         self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS17, True)
 
  1318         menu = wx.Menu(title='')
 
  1291         self.Editor.PopupMenu(self.ContextualMenu)
 
  1319         self.AddDefaultMenuItems(menu, block=block)
 
  1292     
  1320         self.Editor.PopupMenu(menu)
 
  1293     def PopupDefaultMenu(self, block = True):
 
  1321         menu.Destroy()
 
  1294         self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS0, False)
 
       
  1295         self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS1, False)
 
       
  1296         self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS2, False)
 
       
  1297         self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS3, False)
 
       
  1298         self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS5, False)
 
       
  1299         self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS6, False)
 
       
  1300         self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS8, False)
 
       
  1301         self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS9, False)
 
       
  1302         self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS14, False)
 
       
  1303         self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS16, False)
 
       
  1304         self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS17, block)
 
       
  1305         self.Editor.PopupMenu(self.ContextualMenu)
 
       
  1306 
  1322 
  1307 #-------------------------------------------------------------------------------
 
  1323 #-------------------------------------------------------------------------------
 
  1308 #                            Menu items functions
 
  1324 #                            Menu items functions
 
  1309 #-------------------------------------------------------------------------------
 
  1325 #-------------------------------------------------------------------------------
 
  1310 
  1326 
  1404         
  1420         
  1405     def OnResetExecutionOrderMenu(self, event):
 
  1421     def OnResetExecutionOrderMenu(self, event):
 
  1406         self.Controler.ResetEditedElementExecutionOrder(self.TagName)
 
  1422         self.Controler.ResetEditedElementExecutionOrder(self.TagName)
 
  1407         self.RefreshBuffer()
 
  1423         self.RefreshBuffer()
 
  1408         self.RefreshView()
 
  1424         self.RefreshView()
 
       
  1425 
       
  1426     def GetAddMenuCallBack(self, func, *args):
 
       
  1427         def AddMenuCallBack(event):
 
       
  1428             wx.CallAfter(func, self.rubberBand.GetCurrentExtent(), *args)
 
       
  1429         return AddMenuCallBack
 
       
  1430 
       
  1431     def GetClipboardCallBack(self, func):
 
       
  1432         def ClipboardCallback(event):
 
       
  1433             wx.CallAfter(func)
 
       
  1434         return ClipboardCallback
 
  1409 
  1435 
  1410 #-------------------------------------------------------------------------------
 
  1436 #-------------------------------------------------------------------------------
 
  1411 #                          Mouse event functions
 
  1437 #                          Mouse event functions
 
  1412 #-------------------------------------------------------------------------------
 
  1438 #-------------------------------------------------------------------------------
 
  1413 
  1439 
  1425                 tooltip_pos.y += 10
 
  1451                 tooltip_pos.y += 10
 
  1426                 self.ToolTipElement.CreateToolTip(tooltip_pos)
 
  1452                 self.ToolTipElement.CreateToolTip(tooltip_pos)
 
  1427         event.Skip()
 
  1453         event.Skip()
 
  1428     
  1454     
  1429     def OnViewerLeftDown(self, event):
 
  1455     def OnViewerLeftDown(self, event):
 
       
  1456         self.Editor.CaptureMouse()
 
  1430         if self.Mode == MODE_SELECTION:
 
  1457         if self.Mode == MODE_SELECTION:
 
  1431             dc = self.GetLogicalDC()
 
  1458             dc = self.GetLogicalDC()
 
  1432             pos = event.GetLogicalPosition(dc)
 
  1459             pos = event.GetLogicalPosition(dc)
 
  1433             if event.ShiftDown() and not event.ControlDown() and self.SelectedElement is not None:
 
  1460             if event.ShiftDown() and not event.ControlDown() and self.SelectedElement is not None:
 
  1434                 element = self.FindElement(event, True)
 
  1461                 element = self.FindElement(event, True)
 
  1603         elif self.Mode == MODE_MOTION:
 
  1630         elif self.Mode == MODE_MOTION:
 
  1604             self.StartMousePos = None
 
  1631             self.StartMousePos = None
 
  1605             self.StartScreenPos = None
 
  1632             self.StartScreenPos = None
 
  1606         if self.Mode != MODE_SELECTION and not self.SavedMode:
 
  1633         if self.Mode != MODE_SELECTION and not self.SavedMode:
 
  1607             wx.CallAfter(self.ParentWindow.ResetCurrentMode)
 
  1634             wx.CallAfter(self.ParentWindow.ResetCurrentMode)
 
       
  1635         if self.Editor.HasCapture():
 
       
  1636             self.Editor.ReleaseMouse()
 
  1608         event.Skip()
 
  1637         event.Skip()
 
  1609     
  1638     
  1610     def OnViewerMiddleDown(self, event):
 
  1639     def OnViewerMiddleDown(self, event):
 
       
  1640         self.Editor.CaptureMouse()
 
  1611         self.StartMousePos = event.GetPosition()
 
  1641         self.StartMousePos = event.GetPosition()
 
  1612         self.StartScreenPos = self.GetScrollPos(wx.HORIZONTAL), self.GetScrollPos(wx.VERTICAL)
 
  1642         self.StartScreenPos = self.GetScrollPos(wx.HORIZONTAL), self.GetScrollPos(wx.VERTICAL)
 
  1613         event.Skip()
 
  1643         event.Skip()
 
  1614         
  1644         
  1615     def OnViewerMiddleUp(self, event):
 
  1645     def OnViewerMiddleUp(self, event):
 
  1616         self.StartMousePos = None
 
  1646         self.StartMousePos = None
 
  1617         self.StartScreenPos = None
 
  1647         self.StartScreenPos = None
 
       
  1648         if self.Editor.HasCapture():
 
       
  1649             self.Editor.ReleaseMouse()
 
  1618         event.Skip()
 
  1650         event.Skip()
 
  1619     
  1651     
  1620     def OnViewerRightDown(self, event):
 
  1652     def OnViewerRightDown(self, event):
 
       
  1653         self.Editor.CaptureMouse()
 
  1621         if self.Mode == MODE_SELECTION:
 
  1654         if self.Mode == MODE_SELECTION:
 
  1622             element = self.FindElement(event)
 
  1655             element = self.FindElement(event)
 
  1623             if self.SelectedElement is not None and self.SelectedElement != element:
 
  1656             if self.SelectedElement is not None and self.SelectedElement != element:
 
  1624                 self.SelectedElement.SetSelected(False)
 
  1657                 self.SelectedElement.SetSelected(False)
 
  1625                 self.SelectedElement = None
 
  1658                 self.SelectedElement = None
 
  1631                     self.SelectedElement.OnRightDown(event, self.GetLogicalDC(), self.Scaling)
 
  1664                     self.SelectedElement.OnRightDown(event, self.GetLogicalDC(), self.Scaling)
 
  1632                 self.SelectedElement.Refresh()
 
  1665                 self.SelectedElement.Refresh()
 
  1633         event.Skip()
 
  1666         event.Skip()
 
  1634     
  1667     
  1635     def OnViewerRightUp(self, event):
 
  1668     def OnViewerRightUp(self, event):
 
       
  1669         dc = self.GetLogicalDC()
 
       
  1670         self.rubberBand.Reset()
 
       
  1671         self.rubberBand.OnLeftDown(event, dc, self.Scaling)
 
       
  1672         self.rubberBand.OnLeftUp(event, dc, self.Scaling)
 
  1636         if self.SelectedElement is not None:
 
  1673         if self.SelectedElement is not None:
 
  1637             if self.Debug:
 
  1674             if self.Debug:
 
  1638                 Graphic_Element.OnRightUp(self.SelectedElement, event, self.GetLogicalDC(), self.Scaling)
 
  1675                 Graphic_Element.OnRightUp(self.SelectedElement, event, self.GetLogicalDC(), self.Scaling)
 
  1639             else:
 
  1676             else:
 
  1640                 self.SelectedElement.OnRightUp(event, self.GetLogicalDC(), self.Scaling)
 
  1677                 self.SelectedElement.OnRightUp(event, self.GetLogicalDC(), self.Scaling)
 
  1641             wx.CallAfter(self.SetCurrentCursor, 0)
 
  1678             wx.CallAfter(self.SetCurrentCursor, 0)
 
  1642         elif not self.Debug:
 
  1679         elif not self.Debug:
 
  1643             self.PopupDefaultMenu(False)
 
  1680             self.PopupDefaultMenu(False)
 
       
  1681         if self.Editor.HasCapture():
 
       
  1682             self.Editor.ReleaseMouse()
 
  1644         event.Skip()
 
  1683         event.Skip()
 
  1645     
  1684     
  1646     def OnViewerLeftDClick(self, event):
 
  1685     def OnViewerLeftDClick(self, event):
 
  1647         if self.Mode == MODE_SELECTION and self.SelectedElement is not None:
 
  1686         if self.Mode == MODE_SELECTION and self.SelectedElement is not None:
 
  1648             if self.Debug:
 
  1687             if self.Debug:
 
  1670             else:
 
  1709             else:
 
  1671                 self.SelectedElement.OnLeftDClick(event, self.GetLogicalDC(), self.Scaling)
 
  1710                 self.SelectedElement.OnLeftDClick(event, self.GetLogicalDC(), self.Scaling)
 
  1672         event.Skip()
 
  1711         event.Skip()
 
  1673     
  1712     
  1674     def OnViewerMotion(self, event):
 
  1713     def OnViewerMotion(self, event):
 
       
  1714         if self.Editor.HasCapture() and not event.Dragging():
 
       
  1715             return
 
  1675         refresh = False
 
  1716         refresh = False
 
  1676         dc = self.GetLogicalDC()
 
  1717         dc = self.GetLogicalDC()
 
  1677         pos = GetScaledEventPosition(event, dc, self.Scaling)
 
  1718         pos = GetScaledEventPosition(event, dc, self.Scaling)
 
  1678         if event.MiddleIsDown() or self.Mode == MODE_MOTION:
 
  1719         if event.MiddleIsDown() or self.Mode == MODE_MOTION:
 
  1679             if self.StartMousePos is not None and self.StartScreenPos is not None:
 
  1720             if self.StartMousePos is not None and self.StartScreenPos is not None:
 
  2792         if not self.Debug and (self.IsBlock(self.SelectedElement) or self.IsComment(self.SelectedElement) or isinstance(self.SelectedElement, Graphic_Group)):
 
  2833         if not self.Debug and (self.IsBlock(self.SelectedElement) or self.IsComment(self.SelectedElement) or isinstance(self.SelectedElement, Graphic_Group)):
 
  2793             blocks, wires = self.SelectedElement.GetDefinition()
 
  2834             blocks, wires = self.SelectedElement.GetDefinition()
 
  2794             text = self.Controler.GetEditedElementInstancesCopy(self.TagName, blocks, wires, self.Debug)
 
  2835             text = self.Controler.GetEditedElementInstancesCopy(self.TagName, blocks, wires, self.Debug)
 
  2795             self.ParentWindow.SetCopyBuffer(text)
 
  2836             self.ParentWindow.SetCopyBuffer(text)
 
  2796             
  2837             
  2797     def Paste(self):
 
  2838     def Paste(self, bbx=None):
 
  2798         if not self.Debug:
 
  2839         if not self.Debug:
 
  2799             element = self.ParentWindow.GetCopyBuffer()
 
  2840             element = self.ParentWindow.GetCopyBuffer()
 
  2800             mouse_pos = self.Editor.ScreenToClient(wx.GetMousePosition())
 
  2841             if bbx is None:
 
  2801             middle = wx.Rect(0, 0, *self.Editor.GetClientSize()).InsideXY(mouse_pos.x, mouse_pos.y)
 
  2842                 mouse_pos = self.Editor.ScreenToClient(wx.GetMousePosition())
 
  2802             if middle:
 
  2843                 middle = wx.Rect(0, 0, *self.Editor.GetClientSize()).InsideXY(mouse_pos.x, mouse_pos.y)
 
  2803                 x, y = self.CalcUnscrolledPosition(mouse_pos.x, mouse_pos.y)
 
  2844                 if middle:
 
       
  2845                     x, y = self.CalcUnscrolledPosition(mouse_pos.x, mouse_pos.y)
 
       
  2846                 else:
 
       
  2847                     x, y = self.CalcUnscrolledPosition(0, 0)
 
       
  2848                 new_pos = [int(x / self.ViewScale[0]), int(y / self.ViewScale[1])]
 
  2804             else:
 
  2849             else:
 
  2805                 x, y = self.CalcUnscrolledPosition(0, 0)
 
  2850                 middle = True
 
  2806             new_pos = [int(x / self.ViewScale[0]), int(y / self.ViewScale[1])]
 
  2851                 new_pos = [bbx.x, bbx.y]
 
  2807             result = self.Controler.PasteEditedElementInstances(self.TagName, element, new_pos, middle, self.Debug)
 
  2852             result = self.Controler.PasteEditedElementInstances(self.TagName, element, new_pos, middle, self.Debug)
 
  2808             if not isinstance(result, (StringType, UnicodeType)):
 
  2853             if not isinstance(result, (StringType, UnicodeType)):
 
  2809                 self.RefreshBuffer()
 
  2854                 self.RefreshBuffer()
 
  2810                 self.RefreshView(selection=result)
 
  2855                 self.RefreshView(selection=result)
 
  2811                 self.RefreshVariablePanel()
 
  2856                 self.RefreshVariablePanel()
 
  2925 #-------------------------------------------------------------------------------
 
  2970 #-------------------------------------------------------------------------------
 
  2926 #                            Drawing functions
 
  2971 #                            Drawing functions
 
  2927 #-------------------------------------------------------------------------------
 
  2972 #-------------------------------------------------------------------------------
 
  2928 
  2973 
  2929     def OnScrollWindow(self, event):
 
  2974     def OnScrollWindow(self, event):
 
       
  2975         if self.Editor.HasCapture():
 
       
  2976             return
 
  2930         if wx.Platform == '__WXMSW__':
 
  2977         if wx.Platform == '__WXMSW__':
 
  2931             wx.CallAfter(self.RefreshVisibleElements)
 
  2978             wx.CallAfter(self.RefreshVisibleElements)
 
  2932         elif event.GetOrientation() == wx.HORIZONTAL:
 
  2979         elif event.GetOrientation() == wx.HORIZONTAL:
 
  2933             self.RefreshVisibleElements(xp = event.GetPosition())
 
  2980             self.RefreshVisibleElements(xp = event.GetPosition())
 
  2934         else:
 
  2981         else:
plcopeneditor_history