objdictgen/networkedit.py
changeset 715 5795fb789230
parent 614 9b1fe0532d0d
child 744 bc1bbbb5ef71
equal deleted inserted replaced
690:1c2cb6088050 715:5795fb789230
    82 if __name__ == '__main__':
    82 if __name__ == '__main__':
    83     __builtin__.__dict__['_'] = wx.GetTranslation
    83     __builtin__.__dict__['_'] = wx.GetTranslation
    84 
    84 
    85 from nodelist import *
    85 from nodelist import *
    86 from nodemanager import *
    86 from nodemanager import *
       
    87 from nodeeditor import NodeEditorTemplate
    87 from subindextable import *
    88 from subindextable import *
    88 from commondialogs import *
    89 from commondialogs import *
    89 from doc_index.DS301_index import *
    90 from doc_index.DS301_index import *
    90 
    91 
    91 try:
    92 try:
   157     
   158     
   158     Html_Window = True
   159     Html_Window = True
   159 except:
   160 except:
   160     Html_Window = False
   161     Html_Window = False
   161 
   162 
       
   163 [ID_NETWORKEDITORNETWORKNODES,
       
   164 ] = [wx.NewId() for _init_ctrls in range(1)]
       
   165 
       
   166 class NetworkEditorTemplate(NodeEditorTemplate):
       
   167     
       
   168     def _init_ctrls(self, prnt):
       
   169         self.NetworkNodes = wx.Notebook(id=ID_NETWORKEDITNETWORKNODES,
       
   170               name='NetworkNodes', parent=prnt, pos=wx.Point(0, 0),
       
   171               size=wx.Size(0, 0), style=wx.NB_LEFT)
       
   172         self.NetworkNodes.Bind(wx.EVT_NOTEBOOK_PAGE_CHANGED,
       
   173               self.OnNodeSelectedChanged, id=ID_NETWORKEDITNETWORKNODES)
       
   174     
       
   175     def __init__(self, manager, frame, mode_solo):
       
   176         self.NodeList = manager
       
   177         NodeEditorTemplate.__init__(self, self.NodeList.GetManager(), frame, mode_solo)
       
   178     
       
   179     def GetCurrentNodeId(self):
       
   180         selected = self.NetworkNodes.GetSelection()
       
   181         # At init selected = -1
       
   182         if selected > 0:
       
   183             window = self.NetworkNodes.GetPage(selected)
       
   184             return window.GetIndex()
       
   185         else:
       
   186             return 0
       
   187     
       
   188     def RefreshCurrentIndexList(self):
       
   189         selected = self.NetworkNodes.GetSelection()
       
   190         if selected == 0:
       
   191             window = self.NetworkNodes.GetPage(selected)
       
   192             window.RefreshIndexList()
       
   193         else:
       
   194             pass
       
   195 
       
   196     def RefreshNetworkNodes(self):
       
   197         if self.NetworkNodes.GetPageCount() > 0:
       
   198             self.NetworkNodes.DeleteAllPages()
       
   199         if self.NodeList:
       
   200             new_editingpanel = EditingPanel(self.NetworkNodes, self, self.Manager)
       
   201             new_editingpanel.SetIndex(0)
       
   202             self.NetworkNodes.AddPage(new_editingpanel, "")
       
   203             for idx in self.NodeList.GetSlaveIDs():
       
   204                 new_editingpanel = EditingPanel(self.NetworkNodes, self, self.NodeList, False)
       
   205                 new_editingpanel.SetIndex(idx)
       
   206                 self.NetworkNodes.AddPage(new_editingpanel, "")
       
   207     
       
   208     
       
   209     
       
   210     def OnNodeSelectedChanged(self, event):
       
   211         if not self.Closing:
       
   212             selected = event.GetSelection()
       
   213             # At init selected = -1
       
   214             if selected >= 0:
       
   215                 window = self.NetworkNodes.GetPage(selected)
       
   216                 self.NodeList.SetCurrentSelected(window.GetIndex())
       
   217             wx.CallAfter(self.RefreshMainMenu)
       
   218             wx.CallAfter(self.RefreshStatusBar)
       
   219         event.Skip()
       
   220 
       
   221 #-------------------------------------------------------------------------------
       
   222 #                              Buffer Functions
       
   223 #-------------------------------------------------------------------------------
       
   224 
       
   225     def RefreshBufferState(self):
       
   226         if self.NodeList is not None:
       
   227             nodeID = self.Manager.GetCurrentNodeID()
       
   228             if nodeID != None:
       
   229                 nodename = "0x%2.2X %s"%(nodeID, self.Manager.GetCurrentNodeName())
       
   230             else:
       
   231                 nodename = self.Manager.GetCurrentNodeName()
       
   232             self.NetworkNodes.SetPageText(0, nodename)
       
   233             for idx, name in enumerate(self.NodeList.GetSlaveNames()):
       
   234                 self.NetworkNodes.SetPageText(idx + 1, name)
       
   235 
       
   236 #-------------------------------------------------------------------------------
       
   237 #                             Slave Nodes Management
       
   238 #-------------------------------------------------------------------------------
       
   239 
       
   240     def OnAddSlaveMenu(self, event):
       
   241         dialog = AddSlaveDialog(self.Frame)
       
   242         dialog.SetNodeList(self.NodeList)
       
   243         if dialog.ShowModal() == wx.ID_OK:
       
   244             values = dialog.GetValues()
       
   245             result = self.NodeList.AddSlaveNode(values["slaveName"], values["slaveNodeID"], values["edsFile"])
       
   246             if not result:
       
   247                 new_editingpanel = EditingPanel(self.NetworkNodes, self, self.NodeList, False)
       
   248                 new_editingpanel.SetIndex(values["slaveNodeID"])
       
   249                 idx = self.NodeList.GetOrderNumber(values["slaveNodeID"])
       
   250                 self.NetworkNodes.InsertPage(idx, new_editingpanel, "")
       
   251                 self.NodeList.SetCurrentSelected(idx)
       
   252                 self.NetworkNodes.SetSelection(idx)
       
   253                 self.RefreshBufferState()
       
   254             else:
       
   255                 self.ShowErrorMessage(result)
       
   256         dialog.Destroy()
       
   257         
       
   258     def OnRemoveSlaveMenu(self, event):
       
   259         slavenames = self.NodeList.GetSlaveNames()
       
   260         slaveids = self.NodeList.GetSlaveIDs()
       
   261         dialog = wx.SingleChoiceDialog(self.Frame, _("Choose a slave to remove"), _("Remove slave"), slavenames)
       
   262         if dialog.ShowModal() == wx.ID_OK:
       
   263             choice = dialog.GetSelection()
       
   264             result = self.NodeList.RemoveSlaveNode(slaveids[choice])
       
   265             if not result:
       
   266                 slaveids.pop(choice)
       
   267                 current = self.NetworkNodes.GetSelection()
       
   268                 self.NetworkNodes.DeletePage(choice + 1)
       
   269                 if self.NetworkNodes.GetPageCount() > 0:
       
   270                     new_selection = min(current, self.NetworkNodes.GetPageCount() - 1)
       
   271                     self.NetworkNodes.SetSelection(new_selection)
       
   272                     if new_selection > 0:
       
   273                         self.NodeList.SetCurrentSelected(slaveids[new_selection - 1])
       
   274                     self.RefreshBufferState()
       
   275             else:
       
   276                 self.ShowErrorMessage(result)
       
   277         dialog.Destroy()
       
   278 
       
   279     def OpenMasterDCFDialog(self, node_id):
       
   280         self.NetworkNodes.SetSelection(0)
       
   281         self.NetworkNodes.GetPage(0).OpenDCFDialog(node_id)
       
   282 
   162 
   283 
   163 [ID_NETWORKEDIT, ID_NETWORKEDITNETWORKNODES, 
   284 [ID_NETWORKEDIT, ID_NETWORKEDITNETWORKNODES, 
   164  ID_NETWORKEDITHELPBAR,
   285  ID_NETWORKEDITHELPBAR,
   165 ] = [wx.NewId() for _init_ctrls in range(3)]
   286 ] = [wx.NewId() for _init_ctrls in range(3)]
   166 
   287 
   174 [ID_NETWORKEDITADDMENUSDOSERVER, ID_NETWORKEDITADDMENUSDOCLIENT, 
   295 [ID_NETWORKEDITADDMENUSDOSERVER, ID_NETWORKEDITADDMENUSDOCLIENT, 
   175  ID_NETWORKEDITADDMENUPDOTRANSMIT, ID_NETWORKEDITADDMENUPDORECEIVE, 
   296  ID_NETWORKEDITADDMENUPDOTRANSMIT, ID_NETWORKEDITADDMENUPDORECEIVE, 
   176  ID_NETWORKEDITADDMENUMAPVARIABLE, ID_NETWORKEDITADDMENUUSERTYPE, 
   297  ID_NETWORKEDITADDMENUMAPVARIABLE, ID_NETWORKEDITADDMENUUSERTYPE, 
   177 ] = [wx.NewId() for _init_coll_AddMenu_Items in range(6)]
   298 ] = [wx.NewId() for _init_coll_AddMenu_Items in range(6)]
   178 
   299 
   179 class networkedit(wx.Frame):
   300 class networkedit(wx.Frame, NetworkEditorTemplate):
       
   301     
       
   302     EDITMENU_ID = ID_NETWORKEDITEDITMENUOTHERPROFILE
       
   303     
   180     def _init_coll_MenuBar_Menus(self, parent):
   304     def _init_coll_MenuBar_Menus(self, parent):
   181         if self.ModeSolo:
   305         if self.ModeSolo:
   182             parent.Append(menu=self.FileMenu, title=_('File'))
   306             parent.Append(menu=self.FileMenu, title=_('File'))
   183         parent.Append(menu=self.NetworkMenu, title=_('Network'))
   307         parent.Append(menu=self.NetworkMenu, title=_('Network'))
   184         parent.Append(menu=self.EditMenu, title=_('Edit'))
   308         parent.Append(menu=self.EditMenu, title=_('Edit'))
   323         if not self.ModeSolo:
   447         if not self.ModeSolo:
   324             self.Bind(wx.EVT_MENU, self.OnSaveProjectMenu, id=wx.ID_SAVE)
   448             self.Bind(wx.EVT_MENU, self.OnSaveProjectMenu, id=wx.ID_SAVE)
   325             accel = wx.AcceleratorTable([wx.AcceleratorEntry(wx.ACCEL_CTRL, 83, wx.ID_SAVE)])
   449             accel = wx.AcceleratorTable([wx.AcceleratorEntry(wx.ACCEL_CTRL, 83, wx.ID_SAVE)])
   326             self.SetAcceleratorTable(accel)
   450             self.SetAcceleratorTable(accel)
   327 
   451 
   328         self.NetworkNodes = wx.Notebook(id=ID_NETWORKEDITNETWORKNODES,
   452         NetworkEditorTemplate._init_ctrls(self, self)
   329               name='NetworkNodes', parent=self, pos=wx.Point(0, 0),
       
   330               size=wx.Size(0, 0), style=wx.NB_LEFT)
       
   331         self.NetworkNodes.Bind(wx.EVT_NOTEBOOK_PAGE_CHANGED,
       
   332               self.OnNodeSelectedChanged, id=ID_NETWORKEDITNETWORKNODES)
       
   333 
   453 
   334         self.HelpBar = wx.StatusBar(id=ID_NETWORKEDITHELPBAR, name='HelpBar',
   454         self.HelpBar = wx.StatusBar(id=ID_NETWORKEDITHELPBAR, name='HelpBar',
   335               parent=self, style=wx.ST_SIZEGRIP)
   455               parent=self, style=wx.ST_SIZEGRIP)
   336         self._init_coll_HelpBar_Fields(self.HelpBar)
   456         self._init_coll_HelpBar_Fields(self.HelpBar)
   337         self.SetStatusBar(self.HelpBar)
   457         self.SetStatusBar(self.HelpBar)
   338 
   458 
   339     def __init__(self, parent, nodelist = None, projectOpen = None):
   459     def __init__(self, parent, nodelist = None, projectOpen = None):
   340         self.ModeSolo = nodelist == None
   460         if nodelist is None:
       
   461             NetworkEditorTemplate.__init__(self, NodeList(NodeManager()), self, True)
       
   462         else:
       
   463             NetworkEditorTemplate.__init__(self, nodelist, self, False)
   341         self._init_ctrls(parent)
   464         self._init_ctrls(parent)
   342         self.HtmlFrameOpened = []
   465         self.HtmlFrameOpened = []
   343         self.BusId = None
       
   344         self.Closing = False
       
   345         
   466         
   346         icon = wx.Icon(os.path.join(ScriptDirectory,"networkedit.ico"),wx.BITMAP_TYPE_ICO)
   467         icon = wx.Icon(os.path.join(ScriptDirectory,"networkedit.ico"),wx.BITMAP_TYPE_ICO)
   347         self.SetIcon(icon)
   468         self.SetIcon(icon)
   348                  
   469                  
   349         if self.ModeSolo:
   470         if self.ModeSolo:
   350             self.Manager = NodeManager()
       
   351             if projectOpen:
   471             if projectOpen:
   352                 self.NodeList = NodeList(self.Manager)
       
   353                 result = self.NodeList.LoadProject(projectOpen)
   472                 result = self.NodeList.LoadProject(projectOpen)
   354                 if not result:
   473                 if not result:
       
   474                     self.NodeList.SetCurrentSelected(0)
   355                     self.RefreshNetworkNodes()
   475                     self.RefreshNetworkNodes()
       
   476                     self.RefreshProfileMenu()
   356             else:
   477             else:
   357                 self.NodeList = None
   478                 self.NodeList = None
   358         else:
   479         else:
   359             self.NodeList = nodelist
       
   360             self.Manager = self.NodeList.GetManager()
       
   361             self.NodeList.SetCurrentSelected(0)
   480             self.NodeList.SetCurrentSelected(0)
   362             self.RefreshNetworkNodes()
   481             self.RefreshNetworkNodes()
   363             self.RefreshProfileMenu()
   482             self.RefreshProfileMenu()
   364             self.NetworkNodes.SetFocus()
   483         self.NetworkNodes.SetFocus()
   365         
   484         
   366         self.RefreshBufferState()
   485         self.RefreshBufferState()
   367         self.RefreshTitle()
   486         self.RefreshTitle()
   368         self.RefreshMainMenu()
   487         self.RefreshMainMenu()
   369 
       
   370     def SetBusId(self, bus_id):
       
   371         self.BusId = bus_id
       
   372 
       
   373     def GetBusId(self):
       
   374         return self.BusId
       
   375 
       
   376     def IsClosing(self):
       
   377         return self.Closing
       
   378 
       
   379     def GetCurrentNodeId(self):
       
   380         selected = self.NetworkNodes.GetSelection()
       
   381         # At init selected = -1
       
   382         if selected > 0:
       
   383             window = self.NetworkNodes.GetPage(selected)
       
   384             return window.GetIndex()
       
   385         else:
       
   386             return 0
       
   387 
   488 
   388     def OnCloseFrame(self, event):
   489     def OnCloseFrame(self, event):
   389         self.Closing = True
   490         self.Closing = True
   390         if not self.ModeSolo and getattr(self, "_onclose", None) != None:
   491         if not self.ModeSolo and getattr(self, "_onclose", None) != None:
   391             self._onclose()
   492             self._onclose()
   396             self._onsave()
   497             self._onsave()
   397         #event.Skip()
   498         #event.Skip()
   398 
   499 
   399     def OnQuitMenu(self, event):
   500     def OnQuitMenu(self, event):
   400         self.Close()
   501         self.Close()
   401         
       
   402     def OnAddSDOServerMenu(self, event):
       
   403         self.Manager.AddSDOServerToCurrent()
       
   404         self.RefreshBufferState()
       
   405         self.RefreshCurrentIndexList()
       
   406         
       
   407     def OnAddSDOClientMenu(self, event):
       
   408         self.Manager.AddSDOClientToCurrent()
       
   409         self.RefreshBufferState()
       
   410         self.RefreshCurrentIndexList()
       
   411         
       
   412     def OnAddPDOTransmitMenu(self, event):
       
   413         self.Manager.AddPDOTransmitToCurrent()
       
   414         self.RefreshBufferState()
       
   415         self.RefreshCurrentIndexList()
       
   416         
       
   417     def OnAddPDOReceiveMenu(self, event):
       
   418         self.Manager.AddPDOReceiveToCurrent()
       
   419         self.RefreshBufferState()
       
   420         self.RefreshCurrentIndexList()
       
   421         
       
   422     def OnAddMapVariableMenu(self, event):
       
   423         self.AddMapVariable()
       
   424         
       
   425     def OnAddUserTypeMenu(self, event):
       
   426         self.AddUserType()
       
   427         
       
   428     def OnNodeSelectedChanged(self, event):
       
   429         if not self.Closing:
       
   430             selected = event.GetSelection()
       
   431             # At init selected = -1
       
   432             if selected >= 0:
       
   433                 window = self.NetworkNodes.GetPage(selected)
       
   434                 self.NodeList.SetCurrentSelected(window.GetIndex())
       
   435             wx.CallAfter(self.RefreshMainMenu)
       
   436             wx.CallAfter(self.RefreshStatusBar)
       
   437         event.Skip()
       
   438 
   502 
   439 #-------------------------------------------------------------------------------
   503 #-------------------------------------------------------------------------------
   440 #                         Load and Save Funtions
   504 #                         Load and Save Funtions
   441 #-------------------------------------------------------------------------------
   505 #-------------------------------------------------------------------------------
   442 
   506 
   524                 self.NodeList = None
   588                 self.NodeList = None
   525                 self.RefreshNetworkNodes()
   589                 self.RefreshNetworkNodes()
   526                 self.RefreshTitle()
   590                 self.RefreshTitle()
   527                 self.RefreshMainMenu()
   591                 self.RefreshMainMenu()
   528         
   592         
   529 #-------------------------------------------------------------------------------
       
   530 #                             Slave Nodes Management
       
   531 #-------------------------------------------------------------------------------
       
   532 
       
   533     def OnAddSlaveMenu(self, event):
       
   534         dialog = AddSlaveDialog(self)
       
   535         dialog.SetNodeList(self.NodeList)
       
   536         if dialog.ShowModal() == wx.ID_OK:
       
   537             values = dialog.GetValues()
       
   538             result = self.NodeList.AddSlaveNode(values["slaveName"], values["slaveNodeID"], values["edsFile"])
       
   539             if not result:
       
   540                 new_editingpanel = EditingPanel(self.NetworkNodes, self, self.NodeList, False)
       
   541                 new_editingpanel.SetIndex(values["slaveNodeID"])
       
   542                 idx = self.NodeList.GetOrderNumber(values["slaveNodeID"])
       
   543                 self.NetworkNodes.InsertPage(idx, new_editingpanel, "")
       
   544                 self.NodeList.SetCurrentSelected(idx)
       
   545                 self.NetworkNodes.SetSelection(idx)
       
   546                 self.RefreshBufferState()
       
   547             else:
       
   548                 message = wx.MessageDialog(self, result, _("Error"), wx.OK|wx.ICON_ERROR)
       
   549                 message.ShowModal()
       
   550                 message.Destroy()
       
   551         dialog.Destroy()
       
   552         
       
   553     def OnRemoveSlaveMenu(self, event):
       
   554         slavenames = self.NodeList.GetSlaveNames()
       
   555         slaveids = self.NodeList.GetSlaveIDs()
       
   556         dialog = wx.SingleChoiceDialog(self, _("Choose a slave to remove"), _("Remove slave"), slavenames)
       
   557         if dialog.ShowModal() == wx.ID_OK:
       
   558             choice = dialog.GetSelection()
       
   559             result = self.NodeList.RemoveSlaveNode(slaveids[choice])
       
   560             if not result:
       
   561                 slaveids.pop(choice)
       
   562                 current = self.NetworkNodes.GetSelection()
       
   563                 self.NetworkNodes.DeletePage(choice + 1)
       
   564                 if self.NetworkNodes.GetPageCount() > 0:
       
   565                     new_selection = min(current, self.NetworkNodes.GetPageCount() - 1)
       
   566                     self.NetworkNodes.SetSelection(new_selection)
       
   567                     if new_selection > 0:
       
   568                         self.NodeList.SetCurrentSelected(slaveids[new_selection - 1])
       
   569                     self.RefreshBufferState()
       
   570             else:
       
   571                 message = wx.MessageDialog(self, result, _("Error"), wx.OK|wx.ICON_ERROR)
       
   572                 message.ShowModal()
       
   573                 message.Destroy()
       
   574         
   593         
   575 #-------------------------------------------------------------------------------
   594 #-------------------------------------------------------------------------------
   576 #                             Refresh Functions
   595 #                             Refresh Functions
   577 #-------------------------------------------------------------------------------
   596 #-------------------------------------------------------------------------------
   578 
   597 
   579     def RefreshTitle(self):
   598     def RefreshTitle(self):
   580         if self.NodeList != None:
   599         if self.NodeList != None:
   581             self.SetTitle(_("Networkedit - %s")%self.NodeList.GetNetworkName())
   600             self.SetTitle(_("Networkedit - %s") % self.NodeList.GetNetworkName())
   582         else:
   601         else:
   583             self.SetTitle(_("Networkedit"))
   602             self.SetTitle(_("Networkedit"))
   584 
   603     
   585     def OnRefreshMenu(self, event):
       
   586         self.RefreshCurrentIndexList()
       
   587         
       
   588     def RefreshCurrentIndexList(self):
       
   589         selected = self.NetworkNodes.GetSelection()
       
   590         if selected == 0:
       
   591             window = self.NetworkNodes.GetPage(selected)
       
   592             window.RefreshIndexList()
       
   593         else:
       
   594             pass
       
   595 
       
   596     def RefreshNetworkNodes(self):
       
   597         if self.NetworkNodes.GetPageCount() > 0:
       
   598             self.NetworkNodes.DeleteAllPages()
       
   599         if self.NodeList:
       
   600             new_editingpanel = EditingPanel(self.NetworkNodes, self, self.Manager)
       
   601             new_editingpanel.SetIndex(0)
       
   602             self.NetworkNodes.AddPage(new_editingpanel, "")
       
   603             for idx in self.NodeList.GetSlaveIDs():
       
   604                 new_editingpanel = EditingPanel(self.NetworkNodes, self, self.NodeList, False)
       
   605                 new_editingpanel.SetIndex(idx)
       
   606                 self.NetworkNodes.AddPage(new_editingpanel, "")
       
   607 
       
   608     def RefreshStatusBar(self):
   604     def RefreshStatusBar(self):
   609         selected = self.NetworkNodes.GetSelection()
   605         selected = self.NetworkNodes.GetSelection()
   610         if self.HelpBar and selected >= 0:
   606         if self.HelpBar and selected >= 0:
   611             window = self.NetworkNodes.GetPage(selected)
   607             window = self.NetworkNodes.GetPage(selected)
   612             selection = window.GetSelection()
   608             self.SetStatusBarText(window.GetSelection(), self.NodeList)
   613             if selection:
   609     
   614                 index, subIndex = selection
       
   615                 if self.NodeList.IsCurrentEntry(index):
       
   616                     self.HelpBar.SetStatusText(_("Index: 0x%04X")%index, 0)
       
   617                     self.HelpBar.SetStatusText(_("Subindex: 0x%02X")%subIndex, 1)
       
   618                     entryinfos = self.NodeList.GetEntryInfos(index)
       
   619                     name = entryinfos["name"]
       
   620                     category = _("Optional")
       
   621                     if entryinfos["need"]:
       
   622                         category = _("Mandatory")
       
   623                     struct = "VAR"
       
   624                     number = ""
       
   625                     if entryinfos["struct"] & OD_IdenticalIndexes:
       
   626                         number = _(" possibly defined %d times")%entryinfos["nbmax"]
       
   627                     if entryinfos["struct"] & OD_IdenticalSubindexes:
       
   628                         struct = "REC"
       
   629                     elif entryinfos["struct"] & OD_MultipleSubindexes:
       
   630                         struct = "ARRAY"
       
   631                     text = _("%s: %s entry of struct %s%s.")%(name,category,struct,number)
       
   632                     self.HelpBar.SetStatusText(text, 2)
       
   633                 else:
       
   634                     for i in xrange(3):
       
   635                         self.HelpBar.SetStatusText("", i)
       
   636             else:
       
   637                 for i in xrange(3):
       
   638                     self.HelpBar.SetStatusText("", i)
       
   639 
       
   640     def RefreshMainMenu(self):
   610     def RefreshMainMenu(self):
   641         self.NetworkMenu.Enable(ID_NETWORKEDITNETWORKMENUBUILDMASTER, False)
   611         self.NetworkMenu.Enable(ID_NETWORKEDITNETWORKMENUBUILDMASTER, False)
   642         if self.NodeList == None:
   612         if self.NodeList == None:
   643             if self.ModeSolo:
   613             if self.ModeSolo:
   644                 self.MenuBar.EnableTop(1, False)
   614                 self.MenuBar.EnableTop(1, False)
   670                     self.MenuBar.EnableTop(2, True)
   640                     self.MenuBar.EnableTop(2, True)
   671                 else:
   641                 else:
   672                     self.MenuBar.EnableTop(1, False)      
   642                     self.MenuBar.EnableTop(1, False)      
   673                     self.MenuBar.EnableTop(2, False)
   643                     self.MenuBar.EnableTop(2, False)
   674 
   644 
   675     def RefreshProfileMenu(self):
       
   676         profile = self.Manager.GetCurrentProfileName()
       
   677         edititem = self.EditMenu.FindItemById(ID_NETWORKEDITEDITMENUOTHERPROFILE)
       
   678         if edititem:
       
   679             length = self.AddMenu.GetMenuItemCount()
       
   680             for i in xrange(length-6):
       
   681                 additem = self.AddMenu.FindItemByPosition(6)
       
   682                 self.AddMenu.Delete(additem.GetId())
       
   683             if profile not in ("None", "DS-301"):
       
   684                 edititem.SetText(_("%s Profile")%profile)
       
   685                 edititem.Enable(True)
       
   686                 self.AddMenu.AppendSeparator()
       
   687                 for text, indexes in self.Manager.GetCurrentSpecificMenu():
       
   688                     new_id = wx.NewId()
       
   689                     self.AddMenu.Append(help='', id=new_id, kind=wx.ITEM_NORMAL, text=text)
       
   690                     self.Bind(wx.EVT_MENU, self.GetProfileCallBack(text), id=new_id)
       
   691             else:
       
   692                 edititem.SetText(_("Other Profile"))
       
   693                 edititem.Enable(False)
       
   694 
       
   695     def GetProfileCallBack(self, text):
       
   696         def ProfileCallBack(event):
       
   697             self.Manager.AddSpecificEntryToCurrent(text)
       
   698             self.RefreshBufferState()
       
   699             self.RefreshCurrentIndexList()
       
   700         return ProfileCallBack
       
   701 
       
   702 #-------------------------------------------------------------------------------
   645 #-------------------------------------------------------------------------------
   703 #                              Buffer Functions
   646 #                              Buffer Functions
   704 #-------------------------------------------------------------------------------
   647 #-------------------------------------------------------------------------------
   705 
   648 
   706     def RefreshBufferState(self):
   649     def RefreshBufferState(self):
       
   650         NetworkEditorTemplate.RefreshBufferState(self)
   707         if self.NodeList is not None:
   651         if self.NodeList is not None:
   708             nodeID = self.Manager.GetCurrentNodeID()
       
   709             if nodeID != None:
       
   710                 nodename = "0x%2.2X %s"%(nodeID, self.Manager.GetCurrentNodeName())
       
   711             else:
       
   712                 nodename = self.Manager.GetCurrentNodeName()
       
   713             self.NetworkNodes.SetPageText(0, nodename)
       
   714             for idx, name in enumerate(self.NodeList.GetSlaveNames()):
       
   715                 self.NetworkNodes.SetPageText(idx + 1, name)
       
   716             self.RefreshTitle()
   652             self.RefreshTitle()
   717 
       
   718     def OnUndoMenu(self, event):
       
   719         self.Manager.LoadCurrentPrevious()
       
   720         self.RefreshCurrentIndexList()
       
   721         self.RefreshBufferState()
       
   722 
       
   723     def OnRedoMenu(self, event):
       
   724         self.Manager.LoadCurrentNext()
       
   725         self.RefreshCurrentIndexList()
       
   726         self.RefreshBufferState()
       
   727 
   653 
   728 #-------------------------------------------------------------------------------
   654 #-------------------------------------------------------------------------------
   729 #                                Help Method
   655 #                                Help Method
   730 #-------------------------------------------------------------------------------
   656 #-------------------------------------------------------------------------------
   731 
   657 
   769             window = HtmlFrame(self, self.HtmlFrameOpened)
   695             window = HtmlFrame(self, self.HtmlFrameOpened)
   770             window.SetTitle(title)
   696             window.SetTitle(title)
   771             window.SetHtmlPage(file)
   697             window.SetHtmlPage(file)
   772             window.SetClientSize(size)
   698             window.SetClientSize(size)
   773             window.Show()
   699             window.Show()
   774 
       
   775 #-------------------------------------------------------------------------------
       
   776 #                          Editing Profiles functions
       
   777 #-------------------------------------------------------------------------------
       
   778 
       
   779     def OnCommunicationMenu(self, event):
       
   780         dictionary,current = self.Manager.GetCurrentCommunicationLists()
       
   781         self.EditProfile(_("Edit DS-301 Profile"), dictionary, current)
       
   782     
       
   783     def OnOtherCommunicationMenu(self, event):
       
   784         dictionary,current = self.Manager.GetCurrentDS302Lists()
       
   785         self.EditProfile(_("Edit DS-302 Profile"), dictionary, current)
       
   786     
       
   787     def OnEditProfileMenu(self, event):
       
   788         title = _("Edit %s Profile")%self.Manager.GetCurrentProfileName()
       
   789         dictionary,current = self.Manager.GetCurrentProfileLists()
       
   790         self.EditProfile(title, dictionary, current)
       
   791     
       
   792     def EditProfile(self, title, dictionary, current):
       
   793         dialog = CommunicationDialog(self)
       
   794         dialog.SetTitle(title)
       
   795         dialog.SetIndexDictionary(dictionary)
       
   796         dialog.SetCurrentList(current)
       
   797         dialog.RefreshLists()
       
   798         if dialog.ShowModal() == wx.ID_OK:
       
   799             new_profile = dialog.GetCurrentList()
       
   800             addinglist = []
       
   801             removinglist = []
       
   802             for index in new_profile:
       
   803                 if index not in current:
       
   804                     addinglist.append(index)
       
   805             for index in current:
       
   806                 if index not in new_profile:
       
   807                     removinglist.append(index)
       
   808             self.Manager.ManageEntriesOfCurrent(addinglist, removinglist)
       
   809             self.Manager.BufferCurrentNode()
       
   810             self.RefreshBufferState()
       
   811             self.RefreshCurrentIndexList()
       
   812         dialog.Destroy()
       
   813 
       
   814 #-------------------------------------------------------------------------------
       
   815 #                         Edit Node informations function
       
   816 #-------------------------------------------------------------------------------
       
   817 
       
   818     def OnNodeInfosMenu(self, event):
       
   819         dialog = NodeInfosDialog(self)
       
   820         name, id, type, description = self.Manager.GetCurrentNodeInfos()
       
   821         defaultstringsize = self.Manager.GetCurrentNodeDefaultStringSize()
       
   822         dialog.SetValues(name, id, type, description, defaultstringsize)
       
   823         if dialog.ShowModal() == wx.ID_OK:
       
   824             name, id, type, description, defaultstringsize = dialog.GetValues()
       
   825             self.Manager.SetCurrentNodeInfos(name, id, type, description)
       
   826             self.Manager.SetCurrentNodeDefaultStringSize(defaultstringsize)
       
   827             self.RefreshBufferState()
       
   828             self.RefreshProfileMenu()
       
   829             selected = self.NetworkNodes.GetSelection()
       
   830             if selected >= 0:
       
   831                 window = self.NetworkNodes.GetPage(selected)
       
   832                 window.RefreshTable()
       
   833 
       
   834 
       
   835 #-------------------------------------------------------------------------------
       
   836 #                           Add User Types and Variables
       
   837 #-------------------------------------------------------------------------------
       
   838         
       
   839     def AddMapVariable(self):
       
   840         index = self.Manager.GetCurrentNextMapIndex()
       
   841         if index:
       
   842             dialog = MapVariableDialog(self)
       
   843             dialog.SetIndex(index)
       
   844             if dialog.ShowModal() == wx.ID_OK:
       
   845                 index, name, struct, number = dialog.GetValues()
       
   846                 result = self.Manager.AddMapVariableToCurrent(index, name, struct, number)
       
   847                 if not isinstance(result, (StringType, UnicodeType)):
       
   848                     self.RefreshBufferState()
       
   849                     self.RefreshCurrentIndexList()
       
   850                 else:
       
   851                     message = wx.MessageDialog(self, result, _("Error"), wx.OK|wx.ICON_ERROR)
       
   852                     message.ShowModal()
       
   853                     message.Destroy()
       
   854             dialog.Destroy()
       
   855         else:
       
   856             message = wx.MessageDialog(self, result, _("No map variable index left!"), wx.OK|wx.ICON_ERROR)
       
   857             message.ShowModal()
       
   858             message.Destroy()
       
   859         
       
   860     def AddUserType(self):
       
   861         dialog = UserTypeDialog(self)
       
   862         dialog.SetTypeList(self.Manager.GetCustomisableTypes())
       
   863         if dialog.ShowModal() == wx.ID_OK:
       
   864             type, min, max, length = dialog.GetValues()
       
   865             result = self.Manager.AddUserTypeToCurrent(type, min, max, length)
       
   866             if not IsOfType(result, StringType):
       
   867                 self.RefreshBufferState()
       
   868                 self.RefreshCurrentIndexList()
       
   869             else:
       
   870                 message = wx.MessageDialog(self, result, _("Error"), wx.OK|wx.ICON_ERROR)
       
   871                 message.ShowModal()
       
   872                 message.Destroy()
       
   873         dialog.Destroy()
       
   874 
       
   875     def OpenMasterDCFDialog(self, node_id):
       
   876         self.NetworkNodes.SetSelection(0)
       
   877         self.NetworkNodes.GetPage(0).OpenDCFDialog(node_id)
       
   878 
   700 
   879 #-------------------------------------------------------------------------------
   701 #-------------------------------------------------------------------------------
   880 #                               Exception Handler
   702 #                               Exception Handler
   881 #-------------------------------------------------------------------------------
   703 #-------------------------------------------------------------------------------
   882 
   704