plcopeneditor_history: comparison PLCOpenEditor.py

equal deleted inserted replaced

-:add8e391e00c
+:40b91ba978db
 __version__ = "$Revision$"
 CWD = os.path.split(__file__)[0]
 [ID_PLCOPENEDITOR, ID_PLCOPENEDITORPROJECTTREE,
-ID_PLCOPENEDITORMAINSPLITTER, ID_PLCOPENEDITOREDITORPANEL,
+ID_PLCOPENEDITORMAINSPLITTER, ID_PLCOPENEDITORSECONDSPLITTER,
-ID_PLCOPENEDITORTABSOPENED, ID_PLCOPENEDITORTOOLBAR,
+ID_PLCOPENEDITOREDITORPANEL, ID_PLCOPENEDITORTABSOPENED,
-ID_PLCOPENEDITORDEFAULTTOOLBAR, ID_PLCOPENEDITORSFCTOOLBAR,
+ID_PLCOPENEDITORTOOLBAR, ID_PLCOPENEDITORDEFAULTTOOLBAR,
-ID_PLCOPENEDITORFBDTOOLBAR, ID_PLCOPENEDITORLDTOOLBAR,
+ID_PLCOPENEDITORSFCTOOLBAR, ID_PLCOPENEDITORFBDTOOLBAR,
-] = [wx.NewId() for _init_ctrls in range(10)]
+ID_PLCOPENEDITORLDTOOLBAR,
+] = [wx.NewId() for _init_ctrls in range(11)]
 [ID_PLCOPENEDITORFILEMENUITEMS0, ID_PLCOPENEDITORFILEMENUITEMS1,
 ID_PLCOPENEDITORFILEMENUITEMS2, ID_PLCOPENEDITORFILEMENUITEMS3,
 ID_PLCOPENEDITORFILEMENUITEMS5, ID_PLCOPENEDITORFILEMENUITEMS6,
 ID_PLCOPENEDITORFILEMENUITEMS7, ID_PLCOPENEDITORFILEMENUITEMS9,
 if wx.VERSION >= (2, 6, 0):
 parent.Append(help=help, id=id, kind=kind, text=text)
 else:
 parent.Append(helpString=help, id=id, kind=kind, item=text)
-class PLCOpenEditor(wx.Frame):
+if wx.VERSION >= (2, 8, 0):
+base_class = wx.aui.AuiMDIParentFrame
+else:
+base_class = wx.Frame
+class PLCOpenEditor(base_class):
 _custom_classes = {'wx.SashWindow' : ['Viewer']}
 if wx.VERSION < (2, 6, 0):
 def Bind(self, event, function, id = None):
 if id is not None:
 self._init_coll_HelpMenu_Items(self.HelpMenu)
 self._init_coll_SFCMenu_Items(self.SFCMenu)
 self._init_coll_ConfigMenu_Items(self.ConfigMenu)
 def _init_ctrls(self, prnt):
-wx.Frame.__init__(self, id=ID_PLCOPENEDITOR, name=u'PLCOpenEditor',
+if wx.VERSION >= (2, 8, 0):
-parent=prnt, pos=wx.Point(235, 287), size=wx.Size(1000, 600),
+wx.aui.AuiMDIParentFrame.__init__(self, winid=ID_PLCOPENEDITOR, name=u'PLCOpenEditor',
-style=wx.DEFAULT_FRAME_STYLE, title=u'PLCOpenEditor')
+parent=prnt, pos=wx.DefaultPosition, size=wx.Size(1000, 600),
+style=wx.DEFAULT_FRAME_STYLE|wx.SUNKEN_BORDER|wx.CLIP_CHILDREN, title=u'PLCOpenEditor')
+else:
+wx.Frame.__init__(self, id=ID_PLCOPENEDITOR, name=u'PLCOpenEditor',
+parent=prnt, pos=wx.DefaultPosition, size=wx.Size(1000, 600),
+style=wx.DEFAULT_FRAME_STYLE, title=u'PLCOpenEditor')
 self._init_utils()
 self.SetClientSize(wx.Size(1000, 600))
 self.SetMenuBar(self.menuBar1)
 self.Bind(wx.EVT_CLOSE, self.OnCloseFrame)
 if not self.ModeSolo:
+self.Bind(wx.EVT_MENU, self.OnCloseTabMenu, id=ID_PLCOPENEDITORFILEMENUITEMS2)
 self.Bind(wx.EVT_MENU, self.OnSaveProjectMenu, id=ID_PLCOPENEDITORFILEMENUITEMS5)
-accel = wx.AcceleratorTable([wx.AcceleratorEntry(wx.ACCEL_CTRL, 83, ID_PLCOPENEDITORFILEMENUITEMS5)])
+accel = wx.AcceleratorTable([wx.AcceleratorEntry(wx.ACCEL_CTRL, 119, ID_PLCOPENEDITORFILEMENUITEMS2),
+wx.AcceleratorEntry(wx.ACCEL_CTRL, 83, ID_PLCOPENEDITORFILEMENUITEMS5)])
 self.SetAcceleratorTable(accel)
 if wx.VERSION >= (2, 8, 0):
 self.AUIManager = wx.aui.AuiManager(self)
+self.AUIManager.SetDockSizeConstraint(0.5, 0.5)
 self.Panes = {}
 if wx.VERSION < (2, 8, 0):
 self.MainSplitter = wx.SplitterWindow(id=ID_PLCOPENEDITORMAINSPLITTER,
 name='MainSplitter', parent=self, point=wx.Point(0, 0),
 else:
 self.ProjectTree = wx.TreeCtrl(id=ID_PLCOPENEDITORPROJECTTREE,
 name='treeCtrl1', parent=self, pos=wx.Point(0, 0),
 size=wx.Size(200, -1),
 style=wx.TR_HAS_BUTTONS|wx.TR_EDIT_LABELS|wx.TR_SINGLE|wx.SUNKEN_BORDER)
-self.AUIManager.AddPane(self.ProjectTree, wx.aui.AuiPaneInfo().Caption("Project Tree").CloseButton(False))
+self.AUIManager.AddPane(self.ProjectTree, wx.aui.AuiPaneInfo().Caption("Project Tree").Left().Layer(1).BestSize(wx.Size(200, 500)).CloseButton(False))
 if wx.VERSION >= (2, 6, 0):
 self.ProjectTree.Bind(wx.EVT_RIGHT_UP, self.OnProjectTreeRightUp)
 else:
 wx.EVT_RIGHT_UP(self.ProjectTree, self.OnProjectTreeRightUp)
 self.Bind(wx.EVT_TREE_BEGIN_DRAG, self.OnProjectTreeBeginDrag,
 self.Bind(wx.EVT_TOOL, self.OnSelectionTool,
 id=ID_PLCOPENEDITORTOOLBARSELECTION)
 if wx.VERSION < (2, 8, 0):
+self.SecondSplitter = wx.SplitterWindow(id=ID_PLCOPENEDITORSECONDSPLITTER,
+name='SecondSplitter', parent=self.MainSplitter, point=wx.Point(0, 0),
+size=wx.Size(0, 0), style=wx.SP_3D)
+self.SecondSplitter.SetMinimumPaneSize(1)
+self.MainSplitter.SplitVertically(self.ProjectTree, self.SecondSplitter, 200)
 self.TabsOpened = wx.Notebook(id=ID_PLCOPENEDITORTABSOPENED,
-name='TabsOpened', parent=self.MainSplitter, pos=wx.Point(0,
+name='TabsOpened', parent=self.SecondSplitter, pos=wx.Point(0,
 0), size=wx.Size(0, 0), style=0)
-self.MainSplitter.SplitVertically(self.ProjectTree, self.TabsOpened, 200)
+if wx.VERSION >= (2, 6, 0):
-else:
+self.TabsOpened.Bind(wx.EVT_NOTEBOOK_PAGE_CHANGED,
-self.TabsOpened = wx.Notebook(id=ID_PLCOPENEDITORTABSOPENED,
+self.OnPouSelectedChanged, id=ID_PLCOPENEDITORTABSOPENED)
-name='TabsOpened', parent=self, pos=wx.Point(0,
+else:
-0), size=wx.Size(0, 0), style=0)
+wx.EVT_NOTEBOOK_PAGE_CHANGED(self.TabsOpened, ID_PLCOPENEDITORTABSOPENED,
-self.AUIManager.AddPane(self.TabsOpened, wx.aui.AuiPaneInfo().Name("TabsOpened").CenterPane())
+self.OnPouSelectedChanged)
-if wx.VERSION >= (2, 6, 0):
+if wx.VERSION < (2, 8, 0):
-self.TabsOpened.Bind(wx.EVT_NOTEBOOK_PAGE_CHANGED,
+self.VariablePanelIndexer = VariablePanelIndexer(self.SecondSplitter, self.Controler)
-self.OnPouSelectedChanged, id=ID_PLCOPENEDITORTABSOPENED)
-else:
+self.SecondSplitter.SplitHorizontally(self.TabsOpened, self.VariablePanelIndexer, -200)
-wx.EVT_NOTEBOOK_PAGE_CHANGED(self.TabsOpened, ID_PLCOPENEDITORTABSOPENED,
+else:
-self.OnPouSelectedChanged)
+self.VariablePanelIndexer = VariablePanelIndexer(self, self.Controler)
+self.AUIManager.AddPane(self.VariablePanelIndexer, wx.aui.AuiPaneInfo().Caption("Variable Panel").Bottom().Layer(0).BestSize(wx.Size(800, 200)).CloseButton(False))
-if wx.VERSION > (2, 8, 0):
 self.AUIManager.Update();
 def __init__(self, parent, controler = None, fileOpen = None):
 self.ModeSolo = controler == None
+if self.ModeSolo:
+self.Controler = PLCControler()
+if fileOpen is not None:
+self.Controler.OpenXMLFile(fileOpen)
+else:
+self.Controler = controler
 self._init_ctrls(parent)
 if wx.Platform != '__WXMSW__':
 self.TreeImageList = wx.ImageList(16, 16)
 for language in LANGUAGES:
 self.TreeImageList.Add(wx.Bitmap(os.path.join(CWD, 'Images', '%s.png'%language)))
 self.ProjectTree.AssignImageList(self.TreeImageList)
-if self.ModeSolo:
-self.Controler = PLCControler()
-if fileOpen:
-self.Controler.OpenXMLFile(fileOpen)
-self.RefreshProjectTree()
-else:
-self.Controler = controler
-self.RefreshProjectTree()
 self.CurrentToolBar = []
 self.CurrentLanguage = ""
 self.CopyBuffer = None
 self.DrawingMode = FREEDRAWING_MODE
 #self.DrawingMode = DRIVENDRAWING_MODE
+if not self.ModeSolo or fileOpen is not None:
+self.RefreshProjectTree()
 self.RefreshFileMenu()
 self.RefreshEditMenu()
 self.RefreshTitle()
 self.RefreshToolBar()
+def GetPageCount(self):
+if wx.VERSION >= (2, 8, 0):
+notebook = self.GetNotebook()
+if notebook is not None:
+return notebook.GetPageCount()
+else:
+return 0
+else:
+return self.TabsOpened.GetPageCount()
+def GetPage(self, idx):
+if wx.VERSION >= (2, 8, 0):
+notebook = self.GetNotebook()
+if notebook is not None:
+return notebook.GetPage(idx).GetViewer()
+else:
+return None
+else:
+return self.TabsOpened.GetPage(idx)
+def GetPageSelection(self):
+if wx.VERSION >= (2, 8, 0):
+notebook = self.GetNotebook()
+if notebook is not None:
+return notebook.GetSelection()
+else:
+return -1
+else:
+return self.TabsOpened.GetSelection()
+def SetPageSelection(self, idx):
+if wx.VERSION >= (2, 8, 0):
+notebook = self.GetNotebook()
+if notebook is not None:
+notebook.SetSelection(idx)
+else:
+self.TabsOpened.SetSelection(idx)
+def DeletePage(self, idx):
+if wx.VERSION >= (2, 8, 0):
+notebook = self.GetNotebook()
+if notebook is not None:
+notebook.DeletePage(idx)
+else:
+self.TabsOpened.DeletePage(idx)
+def DeleteAllPages(self):
+if wx.VERSION >= (2, 8, 0):
+notebook = self.GetNotebook()
+if notebook is not None:
+for idx in xrange(notebook.GetPageCount()):
+notebook.DeletePage(idx)
+else:
+self.TabsOpened.DeleteAllPages()
+def SetPageText(self, idx, text):
+if wx.VERSION >= (2, 8, 0):
+notebook = self.GetNotebook()
+if notebook is not None:
+return notebook.SetPageText(idx, text)
+else:
+return self.TabsOpened.SetPageText(idx, text)
+def GetPageText(self, idx):
+if wx.VERSION >= (2, 8, 0):
+notebook = self.GetNotebook()
+if notebook is not None:
+return notebook.GetPageText(idx)
+else:
+return ""
+else:
+return self.TabsOpened.GetPageText(idx)
+def OnPageClose(self, event):
+selected = self.GetPageSelection()
+if selected >= 0:
+tagname = self.GetPage(selected).GetTagName()
+self.VariablePanelIndexer.RemoveVariablePanel(tagname)
+if self.GetPageCount() > 0:
+new_index = min(selected, self.GetPageCount() - 1)
+tagname = self.GetPage(new_index).GetTagName()
+self.SetPageSelection(new_index)
+self.VariablePanelIndexer.ChangeVariablePanel(tagname)
+self.RefreshTitle()
+self.RefreshFileMenu()
+self.RefreshEditMenu()
+self.RefreshToolBar()
+event.Skip()
 def GetCopyBuffer(self):
 return self.CopyBuffer
 def SetCopyBuffer(self, element):
 self.CopyBuffer = element
 self.SetTitle("PLCOpenEditor")
 def RefreshFileMenu(self):
 if self.FileMenu:
 if self.Controler.HasOpenedProject():
-if self.TabsOpened.GetPageCount() > 0:
+if self.GetPageCount() > 0:
 self.FileMenu.Enable(ID_PLCOPENEDITORFILEMENUITEMS2, True)
 else:
 self.FileMenu.Enable(ID_PLCOPENEDITORFILEMENUITEMS2, False)
 self.FileMenu.Enable(ID_PLCOPENEDITORFILEMENUITEMS3, True)
 self.FileMenu.Enable(ID_PLCOPENEDITORFILEMENUITEMS5, True)
 self.EditMenu.Enable(ID_PLCOPENEDITOREDITMENUITEMS2, redo)
 else:
 self.EditMenu.Enable(ID_PLCOPENEDITOREDITMENUITEMS1, False)
 self.EditMenu.Enable(ID_PLCOPENEDITOREDITMENUITEMS2, False)
 if self.Controler.HasOpenedProject():
-if self.TabsOpened.GetPageCount() > 0:
+if self.GetPageCount() > 0:
 self.EditMenu.Enable(ID_PLCOPENEDITOREDITMENUITEMS0, True)
 else:
 self.EditMenu.Enable(ID_PLCOPENEDITOREDITMENUITEMS0, False)
 self.EditMenu.Enable(ID_PLCOPENEDITOREDITMENUITEMS8, True)
 self.EditMenu.Enable(ID_PLCOPENEDITOREDITMENUITEMS9, True)
 else:
 self.EditMenu.Enable(ID_PLCOPENEDITOREDITMENUITEMS0, False)
 self.EditMenu.Enable(ID_PLCOPENEDITOREDITMENUITEMS8, False)
 self.EditMenu.Enable(ID_PLCOPENEDITOREDITMENUITEMS9, False)
-bodytype = self.Controler.GetCurrentElementEditingBodyType()
 self.EditMenu.Enable(ID_PLCOPENEDITOREDITMENUITEMS4, True)
 self.EditMenu.Enable(ID_PLCOPENEDITOREDITMENUITEMS5, True)
 if self.CopyBuffer is not None:
 self.EditMenu.Enable(ID_PLCOPENEDITOREDITMENUITEMS6, True)
 else:
 self.EditMenu.Enable(ID_PLCOPENEDITOREDITMENUITEMS6, False)
-def RefreshEditor(self):
+def RefreshEditor(self, variablepanel = True):
-selected = self.TabsOpened.GetSelection()
+selected = self.GetPageSelection()
 if selected != -1:
-self.TabsOpened.GetPage(selected).RefreshView()
+window = self.GetPage(selected)
+window.RefreshView()
+if variablepanel:
+self.VariablePanelIndexer.RefreshVariablePanel(window.GetTagName())
 def ShowProperties(self):
 old_values = self.Controler.GetProjectProperties()
 dialog = ProjectDialog(self)
 dialog.SetValues(old_values)
 self.RefreshProjectTree()
 dialog.Destroy()
 def OnCloseFrame(self, event):
 if not self.ModeSolo and getattr(self, "_onclose", None) is not None:
-self.Controler.CloseAllElements()
+self.AUIManager.UnInit()
 self._onclose()
 event.Skip()
 elif not self.Controler.ProjectIsSaved():
 dialog = wx.MessageDialog(self, "There are changes, do you want to save?", "Close Application", wx.YES_NO|wx.CANCEL|wx.ICON_QUESTION)
 answer = dialog.ShowModal()
 if answer == wx.ID_YES:
 self.SaveProject()
 event.Skip()
 elif answer == wx.ID_NO:
 self.Controler.Reset()
+self.AUIManager.UnInit()
 wx.CallAfter(self.Close)
 event.Skip()
 else:
 event.Veto()
 else:
 dialog = wx.FileDialog(self, "Choose a file", directory, "",  "PLCOpen files (*.xml)|*.xml|All files|*.*", wx.OPEN)
 if dialog.ShowModal() == wx.ID_OK:
 filepath = dialog.GetPath()
 if os.path.isfile(filepath):
 self.Controler.OpenXMLFile(filepath)
-self.TabsOpened.DeleteAllPages()
+self.DeleteAllPages()
 self.RefreshProjectTree()
 self.RefreshTitle()
 self.RefreshFileMenu()
 self.RefreshEditMenu()
 self.RefreshToolBar()
 dialog.Destroy()
 event.Skip()
 def OnCloseTabMenu(self, event):
-selected = self.TabsOpened.GetSelection()
+selected = self.GetPageSelection()
 if selected >= 0:
-self.Controler.CloseElementEditing()
+tagname = self.GetPage(selected).GetTagName()
-self.TabsOpened.DeletePage(selected)
+self.DeletePage(selected)
-if self.TabsOpened.GetPageCount() > 0:
+self.VariablePanelIndexer.RemoveVariablePanel(tagname)
-self.TabsOpened.SetSelection(min(selected, self.TabsOpened.GetPageCount() - 1))
+if self.GetPageCount() > 0:
+new_index = min(selected, self.GetPageCount() - 1)
+tagname = self.GetPage(new_index).GetTagName()
+self.SetPageSelection(new_index)
+self.VariablePanelIndexer.ChangeVariablePanel(tagname)
 self.RefreshTitle()
 self.RefreshFileMenu()
 self.RefreshEditMenu()
 self.RefreshToolBar()
 event.Skip()
 def OnCloseProjectMenu(self, event):
-self.TabsOpened.DeleteAllPages()
+self.DeleteAllPages()
+self.VariablePanelIndexer.RemoveAllPanels()
 self.ProjectTree.DeleteAllItems()
 self.Controler.Reset()
 self.RefreshTitle()
 self.RefreshFileMenu()
 self.RefreshEditMenu()
 def OnQuitMenu(self, event):
 self.Close()
 event.Skip()
 def ResetCurrentMode(self):
-selected = self.TabsOpened.GetSelection()
+selected = self.GetPageSelection()
 if selected != -1:
-window = self.TabsOpened.GetPage(selected)
+window = self.GetPage(selected)
 window.SetMode(MODE_SELECTION)
 if wx.VERSION < (2, 8, 0):
-self.ToolBar.ToggleTool(ID_PLCOPENEDITORTOOLBARSELECTION, True)
+ToolBar = self.ToolBar
 else:
-self.Panes["ToolBar"].ToggleTool(ID_PLCOPENEDITORTOOLBARSELECTION, True)
+ToolBar = self.Panes["ToolBar"]
+if ToolBar:
+ToolBar.ToggleTool(ID_PLCOPENEDITORTOOLBARSELECTION, True)
 def ResetToolToggle(self, id):
 if wx.VERSION < (2, 8, 0):
 tool = self.ToolBar.FindById(id)
 else:
 tool = self.Panes["ToolBar"].FindById(id)
 tool.SetToggle(False)
 def OnSelectionTool(self, event):
-selected = self.TabsOpened.GetSelection()
+self.GetPageSelection()
 if selected != -1:
-self.TabsOpened.GetPage(selected).SetMode(MODE_SELECTION)
+self.GetPage(selected).SetMode(MODE_SELECTION)
 event.Skip()
 def OnCommentTool(self, event):
 self.ResetToolToggle(ID_PLCOPENEDITORTOOLBARCOMMENT)
-selected = self.TabsOpened.GetSelection()
+selected = self.GetPageSelection()
 if selected != -1:
-self.TabsOpened.GetPage(selected).SetMode(MODE_COMMENT)
+self.GetPage(selected).SetMode(MODE_COMMENT)
 event.Skip()
 def OnVariableTool(self, event):
 self.ResetToolToggle(ID_PLCOPENEDITORTOOLBARVARIABLE)
-selected = self.TabsOpened.GetSelection()
+selected = self.GetPageSelection()
 if selected != -1:
-self.TabsOpened.GetPage(selected).SetMode(MODE_VARIABLE)
+self.GetPage(selected).SetMode(MODE_VARIABLE)
 event.Skip()
 def OnBlockTool(self, event):
-selected = self.TabsOpened.GetSelection()
+selected = self.GetPageSelection()
 if selected != -1:
-self.TabsOpened.GetPage(selected).SetMode(MODE_BLOCK)
+self.GetPage(selected).SetMode(MODE_BLOCK)
 event.Skip()
 def OnConnectionTool(self, event):
 self.ResetToolToggle(ID_PLCOPENEDITORTOOLBARCONNECTION)
-selected = self.TabsOpened.GetSelection()
+selected = self.GetPageSelection()
 if selected != -1:
-self.TabsOpened.GetPage(selected).SetMode(MODE_CONNECTION)
+self.GetPage(selected).SetMode(MODE_CONNECTION)
 event.Skip()
 def OnWireTool(self, event):
 self.ResetToolToggle(ID_PLCOPENEDITORTOOLBARWIRE)
-selected = self.TabsOpened.GetSelection()
+selected = self.GetPageSelection()
 if selected != -1:
-self.TabsOpened.GetPage(selected).SetMode(MODE_WIRE)
+self.GetPage(selected).SetMode(MODE_WIRE)
 event.Skip()
 def OnPowerRailTool(self, event):
 self.ResetToolToggle(ID_PLCOPENEDITORTOOLBARPOWERRAIL)
-selected = self.TabsOpened.GetSelection()
+selected = self.GetPageSelection()
 if selected != -1:
-self.TabsOpened.GetPage(selected).SetMode(MODE_POWERRAIL)
+self.GetPage(selected).SetMode(MODE_POWERRAIL)
 event.Skip()
 def OnRungTool(self, event):
-selected = self.TabsOpened.GetSelection()
+selected = self.GetPageSelection()
 if selected != -1:
-self.TabsOpened.GetPage(selected).Viewer.AddLadderRung()
+self.GetPage(selected).AddLadderRung()
 event.Skip()
 def OnCoilTool(self, event):
 self.ResetToolToggle(ID_PLCOPENEDITORTOOLBARCOIL)
-selected = self.TabsOpened.GetSelection()
+selected = self.GetPageSelection()
 if selected != -1:
-self.TabsOpened.GetPage(selected).SetMode(MODE_COIL)
+self.GetPage(selected).SetMode(MODE_COIL)
 event.Skip()
 def OnContactTool(self, event):
 if self.DrawingMode == FREEDRAWING_MODE:
 self.ResetToolToggle(ID_PLCOPENEDITORTOOLBARCONTACT)
-selected = self.TabsOpened.GetSelection()
+selected = self.GetPageSelection()
 if selected != -1:
 if self.DrawingMode == FREEDRAWING_MODE:
-self.TabsOpened.GetPage(selected).SetMode(MODE_CONTACT)
+self.GetPage(selected).SetMode(MODE_CONTACT)
 else:
-self.TabsOpened.GetPage(selected).Viewer.AddLadderContact()
+self.GetPage(selected).AddLadderContact()
 event.Skip()
 def OnBranchTool(self, event):
-selected = self.TabsOpened.GetSelection()
+selected = self.GetPageSelection()
 if selected != -1:
-self.TabsOpened.GetPage(selected).Viewer.AddLadderBranch()
+self.GetPage(selected).AddLadderBranch()
 event.Skip()
 def OnInitialStepTool(self, event):
 self.ResetToolToggle(ID_PLCOPENEDITORTOOLBARINITIALSTEP)
-selected = self.TabsOpened.GetSelection()
+selected = self.GetPageSelection()
 if selected != -1:
-self.TabsOpened.GetPage(selected).SetMode(MODE_INITIALSTEP)
+self.GetPage(selected).SetMode(MODE_INITIALSTEP)
 event.Skip()
 def OnStepTool(self, event):
 if self.GetDrawingMode() == FREEDRAWING_MODE:
 self.ResetToolToggle(ID_PLCOPENEDITORTOOLBARSTEP)
-selected = self.TabsOpened.GetSelection()
+selected = self.GetPageSelection()
 if selected != -1:
 if self.GetDrawingMode() == FREEDRAWING_MODE:
-self.TabsOpened.GetPage(selected).SetMode(MODE_STEP)
+self.GetPage(selected).SetMode(MODE_STEP)
 else:
-self.TabsOpened.GetPage(selected).Viewer.AddStep()
+self.GetPage(selected).AddStep()
 event.Skip()
 def OnActionBlockTool(self, event):
 if self.GetDrawingMode() == FREEDRAWING_MODE:
 self.ResetToolToggle(ID_PLCOPENEDITORTOOLBARACTIONBLOCK)
-selected = self.TabsOpened.GetSelection()
+selected = self.GetPageSelection()
 if selected != -1:
 if self.GetDrawingMode() == FREEDRAWING_MODE:
-self.TabsOpened.GetPage(selected).SetMode(MODE_ACTION)
+self.GetPage(selected).SetMode(MODE_ACTION)
 else:
-self.TabsOpened.GetPage(selected).Viewer.AddStepAction()
+self.GetPage(selected).AddStepAction()
 event.Skip()
 def OnTransitionTool(self, event):
 self.ResetToolToggle(ID_PLCOPENEDITORTOOLBARTRANSITION)
-selected = self.TabsOpened.GetSelection()
+selected = self.GetPageSelection()
 if selected != -1:
-self.TabsOpened.GetPage(selected).SetMode(MODE_TRANSITION)
+self.GetPage(selected).SetMode(MODE_TRANSITION)
 event.Skip()
 def OnDivergenceTool(self, event):
 if self.GetDrawingMode() == FREEDRAWING_MODE:
 self.ResetToolToggle(ID_PLCOPENEDITORTOOLBARDIVERGENCE)
-selected = self.TabsOpened.GetSelection()
+selected = self.GetPageSelection()
 if selected != -1:
 if self.GetDrawingMode() == FREEDRAWING_MODE:
-self.TabsOpened.GetPage(selected).SetMode(MODE_DIVERGENCE)
+self.GetPage(selected).SetMode(MODE_DIVERGENCE)
 else:
-self.TabsOpened.GetPage(selected).Viewer.AddDivergence()
+self.GetPage(selected).AddDivergence()
 event.Skip()
 def OnJumpTool(self, event):
 if self.GetDrawingMode() == FREEDRAWING_MODE:
 self.ResetToolToggle(ID_PLCOPENEDITORTOOLBARJUMP)
-selected = self.TabsOpened.GetSelection()
+selected = self.GetPageSelection()
 if selected != -1:
 if self.GetDrawingMode() == FREEDRAWING_MODE:
-self.TabsOpened.GetPage(selected).SetMode(MODE_JUMP)
+self.GetPage(selected).SetMode(MODE_JUMP)
 else:
-self.TabsOpened.GetPage(selected).Viewer.AddJump()
+self.GetPage(selected).AddJump()
 event.Skip()
 def OnPouSelectedChanged(self, event):
-old_selected = self.TabsOpened.GetSelection()
+if wx.VERSION < (2, 8, 0) or event.GetActive():
-if old_selected >= 0:
+old_selected = self.GetPageSelection()
-self.TabsOpened.GetPage(old_selected).ResetBuffer()
+if old_selected >= 0:
-selected = event.GetSelection()
+self.GetPage(old_selected).ResetBuffer()
-if selected >= 0:
+if wx.VERSION >= (2, 8, 0):
-self.Controler.RefreshCurrentElementEditing(selected)
+window = event.GetEventObject().GetViewer()
-found = False
+else:
-name = self.TabsOpened.GetPageText(selected)
+selected = event.GetSelection()
-if self.ProjectTree:
+if selected >= 0:
-root = self.ProjectTree.GetRootItem()
+window = self.GetPage(selected)
-if wx.VERSION >= (2, 6, 0):
-item, root_cookie = self.ProjectTree.GetFirstChild(root)
 else:
-item, root_cookie = self.ProjectTree.GetFirstChild(root, 0)
+window = None
-while item.IsOk() and not found:
+if window:
-if self.ProjectTree.GetItemText(item) == name:
+##                found = False
-self.ProjectTree.SelectItem(item)
+##                words = window.GetTagName().split("::")
-item, root_cookie = self.ProjectTree.GetNextChild(root, root_cookie)
+##                if self.ProjectTree:
-self.TabsOpened.GetPage(selected).RefreshView()
+##                    root = self.ProjectTree.GetRootItem()
-self.RefreshFileMenu()
+##                    if wx.VERSION >= (2, 6, 0):
-self.RefreshEditMenu()
+##                        item, root_cookie = self.ProjectTree.GetFirstChild(root)
-self.RefreshToolBar()
+##                    else:
+##                        item, root_cookie = self.ProjectTree.GetFirstChild(root, 0)
+##                    while item.IsOk() and not found:
+##                        if self.ProjectTree.GetItemText(item) == words[1]:
+##                            self.ProjectTree.SelectItem(item)
+##                        item, root_cookie = self.ProjectTree.GetNextChild(root, root_cookie)
+window.RefreshView()
+self.VariablePanelIndexer.ChangeVariablePanel(window.GetTagName())
+self.RefreshFileMenu()
+self.RefreshEditMenu()
+self.RefreshToolBar()
 event.Skip()
 def OnProjectTreeBeginDrag(self, event):
 item = event.GetItem()
 if self.ProjectTree.GetPyData(item) == ITEM_POU:
 dragSource = wx.DropSource(self.ProjectTree)
 dragSource.SetData(data)
 dragSource.DoDragDrop()
 def RefreshEditorNames(self, item_type, old_name, new_name):
-for i in xrange(self.TabsOpened.GetPageCount()):
+for i in xrange(self.GetPageCount()):
-editor = self.TabsOpened.GetPage(i)
+editor = self.GetPage(i)
 editor.RefreshName(item_type, old_name, new_name)
 def OnProjectTreeItemEndEdit(self, event):
 message = None
 abort = False
 abort = True
 messageDialog.Destroy()
 if not abort:
 self.Controler.ChangePouName(old_name, new_name)
 self.RefreshEditorNames(itemtype, old_name, new_name)
-self.RefreshTabsOpenedTitles()
+self.RefreshPageTitles()
 elif itemtype == ITEM_TRANSITION:
 parent = self.ProjectTree.GetItemParent(item)
 parent_type = self.ProjectTree.GetPyData(parent)
 while parent_type != ITEM_POU:
 parent = self.ProjectTree.GetItemParent(parent)
 elif new_name.upper() in [name.upper() for name in self.Controler.GetProjectPouVariables(pou_name) if name != old_name]:
 message = "A variable with \"%s\" as name already exists in this pou!"%new_name
 else:
 self.Controler.ChangePouTransitionName(pou_name, old_name, new_name)
 self.RefreshEditorNames(itemtype, old_name, new_name)
-self.RefreshTabsOpenedTitles()
+self.RefreshPageTitles()
 elif itemtype == ITEM_ACTION:
 parent = self.ProjectTree.GetItemParent(item)
 parent_type = self.ProjectTree.GetPyData(parent)
 while parent_type != ITEM_POU:
 parent = self.ProjectTree.GetItemParent(parent)
 elif new_name.upper() in [name.upper() for name in self.Controler.GetProjectPouVariables(pou_name) if name != old_name]:
 message = "A variable with \"%s\" as name already exists in this pou!"%new_name
 else:
 self.Controler.ChangePouActionName(pou_name, old_name, new_name)
 self.RefreshEditorNames(itemtype, old_name, new_name)
-self.RefreshTabsOpenedTitles()
+self.RefreshPageTitles()
 elif itemtype == ITEM_CONFIGURATION:
 if new_name.upper() in [name.upper() for name in self.Controler.GetProjectConfigNames() if name != old_name]:
 message = "\"%s\" config already exists!"%new_name
 abort = True
 elif new_name.upper() in [name.upper() for name in self.Controler.GetProjectPouNames()]:
 abort = True
 messageDialog.Destroy()
 if not abort:
 self.Controler.ChangeConfigurationName(old_name, new_name)
 self.RefreshEditorNames(itemtype, old_name, new_name)
-self.RefreshTabsOpenedTitles()
+self.RefreshPageTitles()
 elif itemtype == ITEM_RESOURCE:
 parent = self.ProjectTree.GetItemParent(item)
 parent_type = self.ProjectTree.GetPyData(parent)
 while parent_type != ITEM_CONFIGURATION:
 parent = self.ProjectTree.GetItemParent(parent)
 abort = True
 messageDialog.Destroy()
 if not abort:
 self.Controler.ChangeConfigurationResourceName(config_name, old_name, new_name)
 self.RefreshEditorNames(itemtype, old_name, new_name)
-self.RefreshTabsOpenedTitles()
+self.RefreshPageTitles()
 if message or abort:
 if message:
 messageDialog = wx.MessageDialog(self, message, "Error", wx.OK|wx.ICON_ERROR)
 messageDialog.ShowModal()
 messageDialog.Destroy()
 item = event.GetItem()
 wx.CallAfter(self.ProjectTree.EditLabel, item)
 event.Veto()
 else:
 wx.CallAfter(self.RefreshProjectTree)
-window = self.TabsOpened.GetCurrentPage()
+selected = self.GetPageSelection()
-if window:
+if selected != -1:
-window.RefreshView()
+self.GetPage(selected).RefreshView()
 event.Skip()
 def OnProjectTreeItemBeginEdit(self, event):
 selected = event.GetItem()
 if self.ProjectTree.GetPyData(selected) == ITEM_UNEDITABLE:
 self.ProjectTree.Expand(selected)
 name = self.ProjectTree.GetItemText(selected)
 data = self.ProjectTree.GetPyData(selected)
 if name == "Properties":
 self.ShowProperties()
-if data in [ITEM_POU, ITEM_CONFIGURATION]:
+if data == ITEM_POU:
-self.EditProjectElement(data, name)
+self.EditProjectElement(data, self.Controler.ComputePouName(name))
+elif data == ITEM_CONFIGURATION:
+self.EditProjectElement(data, self.Controler.ComputeConfigurationName(name))
 elif data == ITEM_RESOURCE:
 item = self.ProjectTree.GetItemParent(selected)
 item_type = self.ProjectTree.GetPyData(item)
 while item_type != ITEM_CONFIGURATION:
 item = self.ProjectTree.GetItemParent(item)
 item_type = self.ProjectTree.GetPyData(item)
 config_name = self.ProjectTree.GetItemText(item)
-self.EditProjectElement(data, "%s::%s"%(config_name, name))
+self.EditProjectElement(data, self.Controler.ComputeConfigurationResourceName(config_name, name))
 elif data in [ITEM_TRANSITION, ITEM_ACTION]:
 item = self.ProjectTree.GetItemParent(selected)
 item_type = self.ProjectTree.GetPyData(item)
 while item_type != ITEM_POU:
 item = self.ProjectTree.GetItemParent(item)
 item_type = self.ProjectTree.GetPyData(item)
 pou_name = self.ProjectTree.GetItemText(item)
-self.EditProjectElement(data, "%s::%s"%(pou_name, name))
+if data == ITEM_TRANSITION:
+tagname = self.Controler.ComputePouTransitionName(pou_name, name)
+elif data == ITEM_ACTION:
+tagname = self.Controler.ComputePouActionName(pou_name, name)
+self.EditProjectElement(data, tagname)
 def OnProjectTreeItemSelected(self, event):
 selected = event.GetItem()
 name = self.ProjectTree.GetItemText(selected)
 data = self.ProjectTree.GetPyData(selected)
-if data in [ITEM_POU, ITEM_CONFIGURATION]:
+if data == ITEM_POU:
-self.EditProjectElement(data, name, True)
+self.EditProjectElement(data, self.Controler.ComputePouName(name), True)
+elif data == ITEM_CONFIGURATION:
+self.EditProjectElement(data, self.Controler.ComputeConfigurationName(name), True)
 elif data == ITEM_RESOURCE:
 item = self.ProjectTree.GetItemParent(selected)
 item_type = self.ProjectTree.GetPyData(item)
 while item_type != ITEM_CONFIGURATION:
 item = self.ProjectTree.GetItemParent(item)
 item_type = self.ProjectTree.GetPyData(item)
 config_name = self.ProjectTree.GetItemText(item)
-self.EditProjectElement(data, "%s::%s"%(config_name, name), True)
+self.EditProjectElement(data, self.Controler.ComputeConfigurationResourceName(config_name, name), True)
 elif data in [ITEM_TRANSITION, ITEM_ACTION]:
 item = self.ProjectTree.GetItemParent(selected)
 item_type = self.ProjectTree.GetPyData(item)
 while item_type != ITEM_POU:
 item = self.ProjectTree.GetItemParent(item)
 item_type = self.ProjectTree.GetPyData(item)
 pou_name = self.ProjectTree.GetItemText(item)
-self.EditProjectElement(data, "%s::%s"%(pou_name, name), True)
+if data == ITEM_TRANSITION:
-event.Skip()
+tagname = self.Controler.ComputePouTransitionName(pou_name, name)
+elif data == ITEM_ACTION:
-def EditProjectElement(self, elementtype, elementname, onlyopened = False):
+tagname = self.Controler.ComputePouActionName(pou_name, name)
-idx = None
+self.EditProjectElement(data, tagname, True)
-names = elementname.split("::")
+event.Skip()
-if elementtype == ITEM_CONFIGURATION and len(names) == 1:
-if not onlyopened:
+def IsOpened(self, tagname):
-idx = self.Controler.OpenConfigurationEditing(*names)
+for idx in xrange(self.GetPageCount()):
-if idx is not None:
+if self.GetPage(idx).IsViewing(tagname):
-new_window = PouEditorPanel(self.TabsOpened, self, self.Controler, "config", config_name = names[0])
+return idx
-new_window.SetIndex(idx)
+return None
+def EditProjectElement(self, elementtype, tagname, onlyopened = False):
+openedidx = self.IsOpened(tagname)
+if openedidx is not None:
+old_selected = self.GetPageSelection()
+if old_selected != openedidx:
+if old_selected >= 0:
+self.GetPage(old_selected).ResetBuffer()
+self.SetPageSelection(openedidx)
+self.GetPage(openedidx).RefreshView()
+self.VariablePanelIndexer.ChangeVariablePanel(tagname)
+self.RefreshPageTitles()
+self.RefreshFileMenu()
+self.RefreshEditMenu()
+self.RefreshToolBar()
+elif not onlyopened:
+if wx.VERSION >= (2, 8, 0):
+if elementtype == ITEM_CONFIGURATION:
+new_window = MDIConfigurationEditor(self, tagname, self, self.Controler)
+self.VariablePanelIndexer.AddVariablePanel(tagname, "config")
+elif elementtype == ITEM_RESOURCE:
+new_window = MDIResourceEditor(self, tagname, self, self.Controler)
+self.VariablePanelIndexer.AddVariablePanel(tagname, "resource")
+elif elementtype in [ITEM_POU, ITEM_TRANSITION, ITEM_ACTION]:
+bodytype = self.Controler.GetEditedElementBodyType(tagname)
+if bodytype == "FBD":
+new_window = MDIViewer(self, tagname, self, self.Controler)
+elif bodytype == "LD":
+new_window = LD_MDIViewer(self, tagname, self, self.Controler)
+elif bodytype == "SFC":
+new_window = SFC_MDIViewer(self, tagname, self, self.Controler)
+else:
+new_window = TextMDIViewer(self, tagname, self, self.Controler)
+viewer = new_window.GetViewer()
+viewer.SetTextSyntax(elementtype)
+if bodytype == "IL":
+viewer.SetKeywords(IL_KEYWORDS)
+else:
+viewer.SetKeywords(ST_KEYWORDS)
+new_window.Bind(wx.EVT_ACTIVATE, self.OnPouSelectedChanged)
+new_window.Bind(wx.EVT_CLOSE, self.OnPageClose)
+else:
+if elementtype == ITEM_CONFIGURATION:
+new_window = ConfigurationEditor(self.TabsOpened, tagname, self, self.Controler)
 self.TabsOpened.AddPage(new_window, "")
-if idx is None:
+self.VariablePanelIndexer.AddVariablePanel(tagname, "config")
-idx = self.Controler.ChangeConfigurationEditing(*names)
+elif elementtype == ITEM_RESOURCE:
-elif elementtype == ITEM_RESOURCE and len(names) == 2:
+new_window = ResourceEditor(self.TabsOpened, tagname, self, self.Controler)
-if not onlyopened:
-idx = self.Controler.OpenConfigurationResourceEditing(*names)
-if idx is not None:
-new_window = PouEditorPanel(self.TabsOpened, self, self.Controler, "resource", config_name = names[0], resource_name = names[1])
-new_window.SetIndex(idx)
 self.TabsOpened.AddPage(new_window, "")
-if idx is None:
+self.VariablePanelIndexer.AddVariablePanel(tagname, "resource")
-idx = self.Controler.ChangeConfigurationResourceEditing(*names)
+elif elementtype in [ITEM_POU, ITEM_TRANSITION, ITEM_ACTION]:
-elif elementtype == ITEM_POU and len(names) == 1:
+bodytype = self.Controler.GetEditedElementBodyType(tagname)
-if not onlyopened:
+if bodytype == "FBD":
-idx = self.Controler.OpenPouEditing(*names)
+new_window = Viewer(self.TabsOpened, tagname, self, self.Controler)
-if idx != None:
+elif bodytype == "LD":
-new_window = PouEditorPanel(self.TabsOpened, self, self.Controler, self.Controler.GetPouType(names[0]), pou_name = names[0])
+new_window = LD_Viewer(self.TabsOpened, tagname, self, self.Controler)
-new_window.SetIndex(idx)
+elif bodytype == "SFC":
+new_window = SFC_Viewer(self.TabsOpened, tagname, self, self.Controler)
+else:
+new_window = TextViewer(self.TabsOpened, tagname, self, self.Controler)
+new_window.SetTextSyntax(elementtype)
+if bodytype == "IL":
+new_window.SetKeywords(IL_KEYWORDS)
+else:
+new_window.SetKeywords(ST_KEYWORDS)
 self.TabsOpened.AddPage(new_window, "")
-if idx is None:
+if elementtype == ITEM_POU:
-idx = self.Controler.ChangePouEditing(*names)
+words = tagname.split("::")
-elif elementtype == ITEM_TRANSITION and len(names) == 2:
+self.VariablePanelIndexer.AddVariablePanel(tagname, self.Controler.GetPouType(words[1]))
-if not onlyopened:
+elif elementtype == ITEM_TRANSITION:
-idx = self.Controler.OpenPouTransitionEditing(*names)
+self.VariablePanelIndexer.AddVariablePanel(tagname, "transition")
-if idx is not None:
+elif elementtype == ITEM_TRANSITION:
-new_window = PouEditorPanel(self.TabsOpened, self, self.Controler, "transition", pou_name = names[0], transition_name = names[1])
+self.VariablePanelIndexer.AddVariablePanel(tagname, "action")
-new_window.SetIndex(idx)
+self.VariablePanelIndexer.ChangeVariablePanel(tagname)
-self.TabsOpened.AddPage(new_window, "")
+openedidx = self.IsOpened(tagname)
-if idx is None:
+old_selected = self.GetPageSelection()
-idx = self.Controler.ChangePouTransitionEditing(*names)
+if old_selected != openedidx:
-elif elementtype == ITEM_ACTION and len(names) == 2:
+if old_selected >= 0:
-if not onlyopened:
+self.GetPage(old_selected).ResetBuffer()
-idx = self.Controler.OpenPouActionEditing(*names)
+for i in xrange(self.GetPageCount()):
-if idx is not None:
+window = self.GetPage(i)
-new_window = PouEditorPanel(self.TabsOpened, self, self.Controler, "action", pou_name = names[0], action_name = names[1])
+if window.GetTagName() == tagname:
-new_window.SetIndex(idx)
+self.SetPageSelection(i)
-self.TabsOpened.AddPage(new_window, "")
-if idx is None:
-idx = self.Controler.ChangePouActionEditing(*names)
-if idx != None:
-old_selected = self.TabsOpened.GetSelection()
-if old_selected >= 0:
-self.TabsOpened.GetPage(old_selected).ResetBuffer()
-for i in xrange(self.TabsOpened.GetPageCount()):
-window = self.TabsOpened.GetPage(i)
-if window.GetIndex() == idx:
-self.TabsOpened.SetSelection(i)
 window.RefreshView()
-self.RefreshTabsOpenedTitles()
+self.RefreshPageTitles()
 self.RefreshFileMenu()
 self.RefreshEditMenu()
 self.RefreshToolBar()
-return
 def OnProjectTreeRightUp(self, event):
 cursor_pos = event.GetPosition()
 selected = self.ProjectTree.GetSelection()
 if self.ProjectTree.GetPyData(selected) == ITEM_POU:
 if wx.VERSION < (2, 8, 0):
 ToolBar = self.ToolBar
 else:
 ToolBar = self.Panes["ToolBar"]
-ToolBar.DeleteTool(item)
+if ToolBar:
-ToolBar.Realize()
+ToolBar.DeleteTool(item)
-if wx.VERSION >= (2, 8, 0):
+ToolBar.Realize()
-self.AUIManager.GetPane("ToolBar").BestSize(ToolBar.GetBestSize())
+if wx.VERSION >= (2, 8, 0):
-self.AUIManager.Update()
+self.AUIManager.GetPane("ToolBar").BestSize(ToolBar.GetBestSize())
+self.AUIManager.Update()
 def RefreshToolBar(self):
-language = self.Controler.GetCurrentElementEditingBodyType()
+selected = self.GetPageSelection()
-if language and language != self.CurrentLanguage:
+if selected != -1:
+language = self.Controler.GetEditedElementBodyType(self.GetPage(selected).GetTagName())
+else:
+language = None
+if language is not None and language != self.CurrentLanguage:
 self.ResetToolBar()
 self.CurrentLanguage = language
 self.CurrentToolBar = []
 if wx.VERSION < (2, 8, 0):
 ToolBar = self.ToolBar
 else:
 ToolBar = self.Panes["ToolBar"]
-for radio, modes, id, method, picture, help in ToolBarItems[language]:
+if ToolBar:
-if modes & self.DrawingMode:
+for radio, modes, id, method, picture, help in ToolBarItems[language]:
-if radio or self.DrawingMode == FREEDRAWING_MODE:
+if modes & self.DrawingMode:
-ToolBar.AddRadioTool(id, wx.Bitmap(os.path.join(CWD, "Images", picture)), wx.NullBitmap, help)
+if radio or self.DrawingMode == FREEDRAWING_MODE:
-else:
+ToolBar.AddRadioTool(id, wx.Bitmap(os.path.join(CWD, "Images", picture)), wx.NullBitmap, help)
-ToolBar.AddSimpleTool(id, wx.Bitmap(os.path.join(CWD, "Images", picture)), help)
+else:
-self.Bind(wx.EVT_TOOL, getattr(self, method), id=id)
+ToolBar.AddSimpleTool(id, wx.Bitmap(os.path.join(CWD, "Images", picture)), help)
-self.CurrentToolBar.append(id)
+self.Bind(wx.EVT_TOOL, getattr(self, method), id=id)
-ToolBar.Realize()
+self.CurrentToolBar.append(id)
-if wx.VERSION >= (2, 8, 0):
+ToolBar.Realize()
-self.AUIManager.GetPane("ToolBar").BestSize(ToolBar.GetBestSize())
+if wx.VERSION >= (2, 8, 0):
-self.AUIManager.Update()
+self.AUIManager.GetPane("ToolBar").BestSize(ToolBar.GetBestSize())
+self.AUIManager.Update()
 elif not language:
 self.ResetToolBar()
 self.CurrentLanguage = language
 self.ResetCurrentMode()
-def RefreshTabsOpenedTitles(self):
+def RefreshPageTitles(self):
-pous = self.Controler.GetElementsOpenedNames()
+for idx in xrange(self.GetPageCount()):
-for i, pou in enumerate(pous):
+window = self.GetPage(idx)
-self.TabsOpened.SetPageText(i, pou)
+words = window.GetTagName().split("::")
+self.SetPageText(idx, "-".join(words[1:]))
 def OnRefreshMenu(self, event):
-selected = self.TabsOpened.GetSelection()
+selected = self.GetPageSelection()
 if selected != -1:
-self.TabsOpened.GetPage(selected).RefreshView()
+window = self.GetPage(selected)
-self.TabsOpened.GetPage(selected).Refresh()
+window.RefreshView()
+self.VariablePanelIndexer.RefreshVariablePanel(window.GetTagName())
 event.Skip()
 def OnUndoMenu(self, event):
 self.Controler.LoadPrevious()
-selected = self.TabsOpened.GetSelection()
+selected = self.GetPageSelection()
 if selected != -1:
-self.TabsOpened.GetPage(selected).RefreshView()
+window = self.GetPage(selected)
-self.TabsOpened.GetPage(selected).Refresh()
+window.RefreshView()
+self.VariablePanelIndexer.RefreshVariablePanel(window.GetTagName())
 self.RefreshTitle()
 self.RefreshEditMenu()
 self.RefreshProjectTree()
 event.Skip()
 def OnRedoMenu(self, event):
 self.Controler.LoadNext()
-selected = self.TabsOpened.GetSelection()
+selected = self.GetPageSelection()
 if selected != -1:
-self.TabsOpened.GetPage(selected).RefreshView()
+window = self.GetPage(selected)
-self.TabsOpened.GetPage(selected).Refresh()
+window.RefreshView()
+self.VariablePanelIndexer.RefreshVariablePanel(window.GetTagName())
 self.RefreshTitle()
 self.RefreshEditMenu()
 self.RefreshProjectTree()
 event.Skip()
 def OnCutMenu(self, event):
-selected = self.TabsOpened.GetSelection()
+selected = self.GetPageSelection()
 if selected != -1:
 try:
-self.TabsOpened.GetPage(selected).Viewer.Cut()
+self.GetPage(selected).Cut()
 except:
 pass
 event.Skip()
 def OnCopyMenu(self, event):
-selected = self.TabsOpened.GetSelection()
+selected = self.GetPageSelection()
 if selected != -1:
 try:
-self.TabsOpened.GetPage(selected).Viewer.Copy()
+self.GetPage(selected).Copy()
 except:
 pass
 event.Skip()
 def OnPasteMenu(self, event):
-selected = self.TabsOpened.GetSelection()
+selected = self.GetPageSelection()
 if selected != -1:
 try:
-self.TabsOpened.GetPage(selected).Viewer.Paste()
+self.GetPage(selected).Paste()
 except:
 pass
 event.Skip()
 def OnAddPouMenu(self, event):
 dialog = wx.SingleChoiceDialog(self, "Select POU to remove:", "POU Remove", pous, wx.OK|wx.CANCEL)
 if dialog.ShowModal() == wx.ID_OK:
 selected = dialog.GetStringSelection()
 if not self.Controler.PouIsUsed(selected):
 self.Controler.ProjectRemovePou(selected)
-deleted = None
+tagname = self.Controler.ComputePouName(selected)
-for i in xrange(self.TabsOpened.GetPageCount()):
+idx = self.IsOpened(tagname)
-if self.TabsOpened.GetPageText(i) == selected:
+if idx is not None:
-deleted = i
+self.VariablePanelIndexer.RemoveVariablePanel(self.GetPage(idx).GetTagName())
-if deleted is not None:
+self.DeletePage(idx)
-self.TabsOpened.DeletePage(deleted)
 self.RefreshTitle()
 self.RefreshEditMenu()
 self.RefreshProjectTree()
 self.RefreshToolBar()
 else:
 configs = self.Controler.GetProjectConfigNames()
 dialog = wx.SingleChoiceDialog(self, "Please select a configuration", "Remove configuration", configs, wx.OK|wx.CANCEL)
 if dialog.ShowModal() == wx.ID_OK:
 selected = dialog.GetStringSelection()
 self.Controler.ProjectRemoveConfiguration(selected)
+tagname = self.Controler.ComputeConfigurationName(selected)
+idx = self.IsOpened(tagname)
+if idx is not None:
+self.VariablePanelIndexer.RemoveVariablePanel(self.GetPage(idx).GetTagName())
+self.DeletePage(idx)
 self.RefreshTitle()
 self.RefreshEditMenu()
 self.RefreshProjectTree()
 event.Skip()
 transitions = self.Controler.GetPouTransitions(pouname)
 dialog = wx.SingleChoiceDialog(self, "Select Transition to remove:", "Remove transition", transitions, wx.OK|wx.CANCEL)
 if dialog.ShowModal() == wx.ID_OK:
 selected = dialog.GetStringSelection()
 self.Controler.ProjectRemovePouTransition(pouname, selected)
+tagname = self.Controler.ComputePouTransitionName(pouname, selected)
+idx = self.IsOpened(tagname)
+if idx is not None:
+self.VariablePanelIndexer.RemoveVariablePanel(self.GetPage(idx).GetTagName())
+self.DeletePage(idx)
 self.RefreshTitle()
 self.RefreshEditMenu()
 self.RefreshProjectTree()
 dialog.Destroy()
 event.Skip()
 actions = self.Controler.GetPouActions(pouname)
 dialog = wx.SingleChoiceDialog(self, "Select Action to remove:", "Remove action", actions, wx.OK|wx.CANCEL)
 if dialog.ShowModal() == wx.ID_OK:
 selected = dialog.GetStringSelection()
 self.Controler.ProjectRemovePouAction(pouname, selected)
+tagname = self.Controler.ComputePouActionName(pouname, selected)
+idx = self.IsOpened(tagname)
+if idx is not None:
+self.VariablePanelIndexer.RemoveVariablePanel(self.GetPage(idx).GetTagName())
+self.DeletePage(idx)
 self.RefreshTitle()
 self.RefreshEditMenu()
 self.RefreshProjectTree()
 dialog.Destroy()
 event.Skip()
 dialog.SetPouNames(self.Controler.GetProjectPouNames())
 dialog.SetPouElementNames(self.Controler.GetProjectPouVariables())
 if dialog.ShowModal() == wx.ID_OK:
 value = dialog.GetValue()
 self.Controler.ProjectAddConfigurationResource(config_name, value)
+tagname = self.Controler.ComputeConfigurationResourceName(config_name, selected)
+idx = self.IsOpened(tagname)
+if idx is not None:
+self.VariablePanelIndexer.RemoveVariablePanel(self.GetPage(idx).GetTagName())
+self.DeletePage(idx)
 self.RefreshTitle()
 self.RefreshEditMenu()
 self.RefreshProjectTree()
 dialog.Destroy()
 event.Skip()
 def GetValue(self):
 return self.GetSizer().GetItem(1).GetWindow().GetValue()
 #-------------------------------------------------------------------------------
-#                            Pou Editor Panel
+#                            Variables Editor Panel
+#-------------------------------------------------------------------------------
+class VariablePanelIndexer(wx.Panel):
+def _init_sizers(self):
+self.MainSizer = wx.BoxSizer(wx.HORIZONTAL)
+self.SetSizer(self.MainSizer)
+def _init_ctrls(self, prnt):
+wx.Panel.__init__(self, id=wx.NewId(),
+name='VariablePanelIndexer', parent=prnt, pos=wx.Point(0, 0),
+size=wx.Size(0, 300), style=wx.TAB_TRAVERSAL)
+self._init_sizers()
+def __init__(self, parent, controler):
+self._init_ctrls(parent)
+self.ParentWindow = parent
+self.Controler = controler
+self.VariablePanelList = {}
+self.CurrentPanel = None
+def AddVariablePanel(self, tagname, element_type):
+new_panel = VariablePanel(self, self.ParentWindow, self.Controler, element_type)
+new_panel.SetTagName(tagname)
+new_panel.Hide()
+new_panel.RefreshView()
+self.MainSizer.AddWindow(new_panel, 1, border=0, flag=wx.GROW)
+self.VariablePanelList[tagname] = new_panel
+def RemoveVariablePanel(self, tagname):
+if tagname in self.VariablePanelList:
+panel = self.VariablePanelList.pop(tagname)
+panel.Hide()
+self.MainSizer.Remove(panel)
+if self.CurrentPanel == tagname:
+self.CurrentPanel = None
+def RemoveAllPanels(self):
+if self.CurrentPanel is not None and self.CurrentPanel in self.VariablePanelList:
+self.VariablePanelList[self.CurrentPanel].Hide()
+self.VariablePanelList = {}
+self.MainSizer.Clear()
+self.CurrentPanel = None
+def UpdateVariablePanelTagName(self, old_tagname, new_tagname):
+if old_name in self.VariablePanelList:
+self.VariablePanelList[new_tagname] = self.VariablePanelList.pop(old_tagname)
+if self.CurrentPanel == old_tagname:
+self.CurrentPanel = new_tagname
+def ChangeVariablePanel(self, tagname):
+if tagname in self.VariablePanelList and tagname != self.CurrentPanel:
+if self.CurrentPanel is not None:
+self.VariablePanelList[self.CurrentPanel].Hide()
+self.CurrentPanel = tagname
+self.VariablePanelList[self.CurrentPanel].RefreshView()
+self.VariablePanelList[self.CurrentPanel].Show()
+self.MainSizer.Layout()
+def RefreshVariablePanel(self, tagname):
+if tagname in self.VariablePanelList:
+self.VariablePanelList[self.CurrentPanel].RefreshView()
+#-------------------------------------------------------------------------------
+#                            Variables Editor Panel
 #-------------------------------------------------------------------------------
 class VariableTable(wx.grid.PyGridTableBase):
 """
 if message is not None:
 message = wx.MessageDialog(self.ParentWindow, message, "Error", wx.OK|wx.ICON_ERROR)
 message.ShowModal()
 message.Destroy()
-[ID_POUEDITORPANEL, ID_POUEDITORPANELVIEWER,
+[ID_VARIABLEEDITORPANEL, ID_VARIABLEEDITORPANELVARIABLESGRID,
-ID_POUEDITORPANELVARIABLESGRID, ID_POUEDITORPANELRETURNTYPE,
+ID_VARIABLEEDITORPANELRETURNTYPE, ID_VARIABLEEDITORPANELCLASSFILTER,
-ID_POUEDITORPANELCLASSFILTER, ID_POUEDITORPANELADDBUTTON,
+ID_VARIABLEEDITORPANELADDBUTTON, ID_VARIABLEEDITORPANELDELETEBUTTON,
-ID_POUEDITORPANELDELETEBUTTON, ID_POUEDITORPANELUPBUTTON,
+ID_VARIABLEEDITORPANELUPBUTTON, ID_VARIABLEEDITORPANELDOWNBUTTON,
-ID_POUEDITORPANELDOWNBUTTON, ID_POUEDITORPANELSTATICTEXT1,
+ID_VARIABLEEDITORPANELSTATICTEXT1, ID_VARIABLEEDITORPANELSTATICTEXT2,
-ID_POUEDITORPANELSTATICTEXT2, ID_POUEDITORPANELSTATICTEXT3,
+ID_VARIABLEEDITORPANELSTATICTEXT3,
-] = [wx.NewId() for _init_ctrls in range(12)]
+] = [wx.NewId() for _init_ctrls in range(11)]
-class PouEditorPanel(wx.SplitterWindow):
+class VariablePanel(wx.Panel):
 if wx.VERSION < (2, 6, 0):
 def Bind(self, event, function, id = None):
 if id is not None:
 event(self, id, function)
 else:
 event(self, function)
-def _init_coll_VariablePanelSizer_Items(self, parent):
+def _init_coll_MainSizer_Items(self, parent):
 parent.AddWindow(self.VariablesGrid, 0, border=0, flag=wx.GROW)
 parent.AddSizer(self.ControlPanelSizer, 0, border=0, flag=wx.GROW)
-def _init_coll_VariablePanelSizer_Growables(self, parent):
+def _init_coll_MainSizer_Growables(self, parent):
 parent.AddGrowableCol(0)
 parent.AddGrowableRow(0)
 def _init_coll_ControlPanelSizer_Items(self, parent):
 parent.AddSizer(self.ChoicePanelSizer, 0, border=0, flag=wx.GROW)
 parent.AddGrowableCol(2)
 parent.AddGrowableCol(3)
 parent.AddGrowableRow(0)
 def _init_sizers(self):
-self.VariablePanelSizer = wx.FlexGridSizer(cols=2, hgap=10, rows=1, vgap=0)
+self.MainSizer = wx.FlexGridSizer(cols=2, hgap=10, rows=1, vgap=0)
 self.ControlPanelSizer = wx.FlexGridSizer(cols=1, hgap=0, rows=2, vgap=10)
 self.ChoicePanelSizer = wx.GridSizer(cols=1, hgap=5, rows=4, vgap=5)
 self.ButtonPanelSizer = wx.FlexGridSizer(cols=2, hgap=5, rows=2, vgap=0)
-self._init_coll_VariablePanelSizer_Items(self.VariablePanelSizer)
+self._init_coll_MainSizer_Items(self.MainSizer)
-self._init_coll_VariablePanelSizer_Growables(self.VariablePanelSizer)
+self._init_coll_MainSizer_Growables(self.MainSizer)
 self._init_coll_ControlPanelSizer_Items(self.ControlPanelSizer)
 self._init_coll_ControlPanelSizer_Growables(self.ControlPanelSizer)
 self._init_coll_ChoicePanelSizer_Items(self.ChoicePanelSizer)
 self._init_coll_ButtonPanelSizer_Items(self.ButtonPanelSizer)
 self._init_coll_ButtonPanelSizer_Growables(self.ButtonPanelSizer)
-self.VariablePanel.SetSizer(self.VariablePanelSizer)
+self.SetSizer(self.MainSizer)
-def _init_ctrls(self, prnt, element_type):
+def _init_ctrls(self, prnt):
-wx.SplitterWindow.__init__(self, id=ID_POUEDITORPANEL,
+wx.Panel.__init__(self, id=ID_VARIABLEEDITORPANEL,
-name='EditVariablePanel', parent=prnt, point=wx.Point(0, 0),
+name='VariableEditorPanel', parent=prnt, pos=wx.Point(0, 0),
-size=wx.Size(0, 0), style=wx.SP_3D)
-self.SetNeedUpdating(True)
-self.SetMinimumPaneSize(1)
-if element_type == "config":
-self.Viewer = wx.Panel(id=ID_POUEDITORPANELVIEWER,
-name='ConfigPanel', parent=self, pos=wx.Point(0, 0),
-size=wx.Size(0, 0), style=0)
-self.Viewer.SetSizer(wx.BoxSizer(wx.VERTICAL))
-self.Viewer.ResetBuffer = lambda: None
-self.Viewer.RefreshView = lambda: None
-elif element_type == "resource":
-self.Viewer = ResourceEditor(self, self.ParentWindow, self.Controler)
-elif element_type == "FBD":
-self.Viewer = Viewer(self, self.ParentWindow, self.Controler)
-elif element_type == "LD":
-self.Viewer = LD_Viewer(self, self.ParentWindow, self.Controler)
-elif element_type == "SFC":
-self.Viewer = SFC_Viewer(self, self.ParentWindow, self.Controler)
-else:
-self.Viewer = TextViewer(self, self.ParentWindow, self.Controler)
-self.Viewer.SetTextSyntax(element_type)
-if element_type == "IL":
-self.Viewer.SetKeywords(IL_KEYWORDS)
-else:
-self.Viewer.SetKeywords(ST_KEYWORDS)
-self.VariablePanel = wx.Panel(id=ID_POUEDITORPANELVIEWER,
-name='VariablePanel', parent=self, pos=wx.Point(0, 0),
 size=wx.Size(0, 0), style=wx.TAB_TRAVERSAL)
-self.staticText1 = wx.StaticText(id=ID_POUEDITORPANELSTATICTEXT1,
+self.staticText1 = wx.StaticText(id=ID_VARIABLEEDITORPANELSTATICTEXT1,
-label='Return Type:', name='staticText1', parent=self.VariablePanel,
+label='Return Type:', name='staticText1', parent=self,
 pos=wx.Point(0, 0), size=wx.Size(95, 17), style=0)
-self.ReturnType = wx.Choice(id=ID_POUEDITORPANELRETURNTYPE,
+self.ReturnType = wx.Choice(id=ID_VARIABLEEDITORPANELRETURNTYPE,
-name='ReturnType', parent=self.VariablePanel, pos=wx.Point(0, 0),
+name='ReturnType', parent=self, pos=wx.Point(0, 0),
 size=wx.Size(145, 24), style=0)
-self.Bind(wx.EVT_CHOICE, self.OnReturnTypeChanged, id=ID_POUEDITORPANELRETURNTYPE)
+self.Bind(wx.EVT_CHOICE, self.OnReturnTypeChanged, id=ID_VARIABLEEDITORPANELRETURNTYPE)
-self.staticText2 = wx.StaticText(id=ID_POUEDITORPANELSTATICTEXT2,
+self.staticText2 = wx.StaticText(id=ID_VARIABLEEDITORPANELSTATICTEXT2,
-label='Class Filter:', name='staticText2', parent=self.VariablePanel,
+label='Class Filter:', name='staticText2', parent=self,
 pos=wx.Point(0, 0), size=wx.Size(95, 17), style=0)
-self.ClassFilter = wx.Choice(id=ID_POUEDITORPANELCLASSFILTER,
+self.ClassFilter = wx.Choice(id=ID_VARIABLEEDITORPANELCLASSFILTER,
-name='ClassFilter', parent=self.VariablePanel, pos=wx.Point(0, 0),
+name='ClassFilter', parent=self, pos=wx.Point(0, 0),
 size=wx.Size(145, 24), style=0)
-self.Bind(wx.EVT_CHOICE, self.OnClassFilter, id=ID_POUEDITORPANELCLASSFILTER)
+self.Bind(wx.EVT_CHOICE, self.OnClassFilter, id=ID_VARIABLEEDITORPANELCLASSFILTER)
-self.VariablesGrid = wx.grid.Grid(id=ID_POUEDITORPANELVARIABLESGRID,
+self.VariablesGrid = wx.grid.Grid(id=ID_VARIABLEEDITORPANELVARIABLESGRID,
-name='VariablesGrid', parent=self.VariablePanel, pos=wx.Point(0, 0),
+name='VariablesGrid', parent=self, pos=wx.Point(0, 0),
 size=wx.Size(0, 150), style=wx.VSCROLL)
 self.VariablesGrid.SetFont(wx.Font(12, 77, wx.NORMAL, wx.NORMAL, False,
 'Sans'))
 self.VariablesGrid.SetLabelFont(wx.Font(10, 77, wx.NORMAL, wx.NORMAL,
 False, 'Sans'))
 wx.grid.EVT_GRID_SELECT_CELL(self.VariablesGrid, self.OnVariablesGridSelectCell)
 wx.grid.EVT_GRID_CELL_LEFT_CLICK(self.VariablesGrid, self.OnVariablesGridCellLeftClick)
 wx.grid.EVT_GRID_EDITOR_SHOWN(self.VariablesGrid, self.OnVariablesGridEditorShown)
 self.VariablesGrid.SetDropTarget(VariableDropTarget(self))
-self.AddButton = wx.Button(id=ID_POUEDITORPANELADDBUTTON, label='Add',
+self.AddButton = wx.Button(id=ID_VARIABLEEDITORPANELADDBUTTON, label='Add',
-name='AddButton', parent=self.VariablePanel, pos=wx.Point(345, 340),
+name='AddButton', parent=self, pos=wx.Point(345, 340),
 size=wx.Size(72, 32), style=0)
-self.Bind(wx.EVT_BUTTON, self.OnAddButton, id=ID_POUEDITORPANELADDBUTTON)
+self.Bind(wx.EVT_BUTTON, self.OnAddButton, id=ID_VARIABLEEDITORPANELADDBUTTON)
-self.DeleteButton = wx.Button(id=ID_POUEDITORPANELDELETEBUTTON, label='Delete',
+self.DeleteButton = wx.Button(id=ID_VARIABLEEDITORPANELDELETEBUTTON, label='Delete',
-name='DeleteButton', parent=self.VariablePanel, pos=wx.Point(425, 340),
+name='DeleteButton', parent=self, pos=wx.Point(425, 340),
 size=wx.Size(72, 32), style=0)
-self.Bind(wx.EVT_BUTTON, self.OnDeleteButton, id=ID_POUEDITORPANELDELETEBUTTON)
+self.Bind(wx.EVT_BUTTON, self.OnDeleteButton, id=ID_VARIABLEEDITORPANELDELETEBUTTON)
-self.UpButton = wx.Button(id=ID_POUEDITORPANELUPBUTTON, label='^',
+self.UpButton = wx.Button(id=ID_VARIABLEEDITORPANELUPBUTTON, label='^',
-name='UpButton', parent=self.VariablePanel, pos=wx.Point(505, 340),
+name='UpButton', parent=self, pos=wx.Point(505, 340),
 size=wx.Size(32, 32), style=0)
-self.Bind(wx.EVT_BUTTON, self.OnUpButton, id=ID_POUEDITORPANELUPBUTTON)
+self.Bind(wx.EVT_BUTTON, self.OnUpButton, id=ID_VARIABLEEDITORPANELUPBUTTON)
-self.DownButton = wx.Button(id=ID_POUEDITORPANELDOWNBUTTON, label='v',
+self.DownButton = wx.Button(id=ID_VARIABLEEDITORPANELDOWNBUTTON, label='v',
-name='DownButton', parent=self.VariablePanel, pos=wx.Point(545, 340),
+name='DownButton', parent=self, pos=wx.Point(545, 340),
 size=wx.Size(32, 32), style=0)
-self.Bind(wx.EVT_BUTTON, self.OnDownButton, id=ID_POUEDITORPANELDOWNBUTTON)
+self.Bind(wx.EVT_BUTTON, self.OnDownButton, id=ID_VARIABLEEDITORPANELDOWNBUTTON)
-self.SplitHorizontally(self.Viewer, self.VariablePanel, -200)
 self._init_sizers()
-def __init__(self, parent, window, controler, element_type, pou_name = None, transition_name = None, action_name = None, config_name = None, resource_name = None):
+def __init__(self, parent, window, controler, element_type):
+self._init_ctrls(parent)
 self.ParentWindow = window
 self.Controler = controler
 self.ElementType = element_type
-self.PouName = pou_name
-self.TransitionName = transition_name
-self.ActionName = action_name
-self.ConfigName = config_name
-self.ResourceName = resource_name
-if element_type == "config":
-self._init_ctrls(parent, "config")
-pou_type = "config"
-elif element_type == "resource":
-self._init_ctrls(parent, "resource")
-pou_type = "resource"
-else:
-if element_type == "transition":
-self._init_ctrls(parent, self.Controler.GetTransitionBodyType(pou_name, transition_name))
-elif element_type == "action":
-self._init_ctrls(parent, self.Controler.GetActionBodyType(pou_name, action_name))
-else:
-self._init_ctrls(parent, self.Controler.GetPouBodyType(pou_name))
-pou_type = self.Controler.GetPouType(pou_name)
 self.Filter = "All"
 self.FilterChoices = []
 self.FilterChoiceTransfer = {"All" : "All", "Interface" : "Interface",
 "   Input" : "Input", "   Output" : "Output", "   InOut" : "InOut",
 "   External" : "External", "Variables" : "Variables", "   Local" : "Local",
 "   Temp" : "Temp", "Global" : "Global", "Access" : "Access"}
-if pou_type in ["config", "resource"]:
+if element_type in ["config", "resource"]:
 self.DefaultTypes = {"All" : "Global"}
 self.DefaultValue = {"Name" : "", "Class" : "", "Type" : "INT", "Location" : "", "Initial Value" : "", "Retain" : "No", "Constant" : "No", "Edit" : True}
 else:
 self.DefaultTypes = {"All" : "Local", "Interface" : "Input", "Variables" : "Local"}
 self.DefaultValue = {"Name" : "", "Class" : "", "Type" : "INT", "Location" : "", "Initial Value" : "", "Retain" : "No", "Constant" : "No", "Edit" : True}
-if pou_type in ["config", "resource"] or pou_type == "program":
+if element_type in ["config", "resource"] or element_type in ["program", "transition", "action"]:
 self.Table = VariableTable(self, [], ["#", "Name", "Class", "Type", "Location", "Initial Value", "Retain", "Constant"])
-if pou_type not in ["config", "resource"]:
+if element_type not in ["config", "resource"]:
 self.FilterChoices = ["All","Interface","   Input","   Output","   InOut","   External","Variables","   Local","   Temp","Global","Access"]
 else:
 self.FilterChoices = ["All","Global","Access"]
 self.ColSizes = [40, 80, 70, 80, 80, 80, 60, 70]
 self.ColAlignements = [wx.ALIGN_CENTER, wx.ALIGN_LEFT, wx.ALIGN_LEFT, wx.ALIGN_LEFT, wx.ALIGN_LEFT, wx.ALIGN_LEFT, wx.ALIGN_CENTER, wx.ALIGN_CENTER]
 self.RefreshTypeList()
 self.OptionList = "Yes,No"
 self.TypeList = [value for value, parent in TypeHierarchy_list if not value.startswith("ANY")]
-if pou_type == "function":
+if element_type == "function":
 for value, parent in TypeHierarchy_list:
 if not value.startswith("ANY"):
 self.ReturnType.Append(value)
 self.ReturnType.Enable(True)
 else:
 attr = wx.grid.GridCellAttr()
 attr.SetAlignment(self.ColAlignements[col], wx.ALIGN_CENTRE)
 self.VariablesGrid.SetColAttr(col, attr)
 self.VariablesGrid.SetColSize(col, self.ColSizes[col])
-def SetIndex(self, index):
+def SetTagName(self, tagname):
-self.ControlerIndex = index
+self.TagName = tagname
-def GetIndex(self):
-return self.ControlerIndex
-def RefreshName(self, name_type, old_name, new_name):
-if name_type == ITEM_POU and self.PouName == old_name:
-self.PouName = new_name
-elif name_type == ITEM_TRANSITION and self.TransitionName == old_name:
-self.TransitionName = new_name
-elif name_type == ITEM_ACTION and self.ActionName == old_name:
-self.ActionName = new_name
-elif name_type == ITEM_CONFIGURATION and self.ConfigName == old_name:
-self.ConfigName = new_name
-elif name_type == ITEM_RESOURCE and self.ResourceName == old_name:
-self.ResourceName = new_name
-def SetMode(self, mode):
-if self.ElementType not in ["resource", "config"]:
-if self.ElementType == "transition":
-language = self.Controler.GetTransitionBodyType(self.PouName, self.TransitionName)
-elif self.ElementType == "action":
-language = self.Controler.GetActionBodyType(self.PouName, self.ActionName)
-else:
-language = self.Controler.GetPouBodyType(self.PouName)
-if language not in ["IL", "ST"]:
-self.Viewer.SetMode(mode)
-def ResetBuffer(self):
-self.Viewer.ResetBuffer()
 def RefreshView(self):
 self.PouNames = self.Controler.GetProjectPouNames()
+words = self.TagName.split("::")
 if self.ElementType == "config":
 self.PouIsUsed = False
 returnType = None
-self.Values = self.Controler.GetConfigurationGlobalVars(self.ConfigName)
+self.Values = self.Controler.GetConfigurationGlobalVars(words[1])
 elif self.ElementType == "resource":
 self.PouIsUsed = False
 returnType = None
-self.Values = self.Controler.GetConfigurationResourceGlobalVars(self.ConfigName, self.ResourceName)
+self.Values = self.Controler.GetConfigurationResourceGlobalVars(words[1], words[2])
 else:
-self.PouIsUsed = self.Controler.PouIsUsed(self.PouName)
+self.PouIsUsed = self.Controler.PouIsUsed(words[1])
-returnType = self.Controler.GetCurrentElementEditingInterfaceReturnType()
+returnType = self.Controler.GetEditedElementInterfaceReturnType(self.TagName)
-self.Values = self.Controler.GetCurrentElementEditingInterfaceVars()
+self.Values = self.Controler.GetEditedElementInterfaceVars(self.TagName)
 if returnType and self.ReturnType.IsEnabled():
 self.ReturnType.SetStringSelection(returnType)
 self.RefreshValues()
-self.RefreshViewerVarList()
 self.RefreshButtons()
-self.Viewer.RefreshView()
-def RefreshViewerVarList(self):
-if self.ElementType not in ["config", "resource"]:
-varlist = [var["Name"] for var in self.Values]
-if self.ElementType == "transition":
-language = self.Controler.GetTransitionBodyType(self.PouName, self.TransitionName)
-varlist.append(self.TransitionName)
-elif self.ElementType == "action":
-language = self.Controler.GetActionBodyType(self.PouName, self.ActionName)
-varlist.append(self.ActionName)
-else:
-language = self.Controler.GetPouBodyType(self.PouName)
-varlist.append(self.PouName)
-if language in ["IL", "ST"]:
-self.Viewer.SetVariables(varlist)
-self.Viewer.SetFunctions(self.Controler.GetBlockTypes())
 def OnReturnTypeChanged(self, event):
-self.Controler.SetPouInterfaceReturnType(self.PouName, self.ReturnType.GetStringSelection())
+words = self.TagName.split("::")
+self.Controler.SetPouInterfaceReturnType(words[1], self.ReturnType.GetStringSelection())
 self.Controler.BufferProject()
 self.ParentWindow.RefreshTitle()
 self.ParentWindow.RefreshEditMenu()
 event.Skip()
 event.Veto()
 else:
 self.SaveValues(False)
 old_value = self.Table.GetOldValue()
 if old_value != "":
-self.Controler.UpdateCurrentPouEditingUsedVariable(old_value, value)
+self.Controler.UpdateEditedElementUsedVariable(self.TagName, old_value, value)
 self.Controler.BufferProject()
+self.ParentWindow.RefreshEditor(variablepanel = False)
 self.ParentWindow.RefreshTitle()
 self.ParentWindow.RefreshEditMenu()
-self.RefreshViewerVarList()
-self.Viewer.RefreshView()
 event.Skip()
 else:
 self.SaveValues()
 if colname == "Class":
 self.Table.ResetView(self.VariablesGrid)
 event.Skip()
-def OnVariablesGridCellLeftClick(self, event):
-if event.GetCol() == "#":
-row = event.GetRow()
-var_name = self.Table.GetValueByName(row, "Name")
-var_class = self.Table.GetValueByName(row, "Class")
-var_type = self.Table.GetValueByName(row, "Type")
-data = wx.TextDataObject(str((var_name, var_class, var_type)))
-dragSource = wx.DropSource(self.VariablesGrid)
-dragSource.SetData(data)
-dragSource.DoDragDrop()
-event.Skip()
 def OnVariablesGridEditorShown(self, event):
 row, col = event.GetRow(), event.GetCol()
 if self.Table.GetColLabelValue(col) == "Type":
 type_menu = wx.Menu(title='')
 def VariableTypeFunction(event):
 row = self.VariablesGrid.GetGridCursorRow()
 self.Table.SetValueByName(row, "Type", base_type)
 self.Table.ResetView(self.VariablesGrid)
 self.SaveValues(False)
-self.Viewer.RefreshView()
+self.ParentWindow.RefreshEditor(variablepanel = False)
-self.Viewer.VerifyVariableTypeCompatibility()
 self.Controler.BufferProject()
 self.ParentWindow.RefreshTitle()
 self.ParentWindow.RefreshEditMenu()
 event.Skip()
 return VariableTypeFunction
 if event.GetCol() == 0:
 row = event.GetRow()
 var_name = self.Table.GetValueByName(row, "Name")
 var_class = self.Table.GetValueByName(row, "Class")
 var_type = self.Table.GetValueByName(row, "Type")
-data = wx.TextDataObject(str((var_name, var_class, var_type)))
+data = wx.TextDataObject(str((var_name, var_class, var_type, self.TagName)))
 dragSource = wx.DropSource(self.VariablesGrid)
 dragSource.SetData(data)
 dragSource.DoDragDrop()
 event.Skip()
 data.append(variable)
 self.Table.SetData(data)
 self.Table.ResetView(self.VariablesGrid)
 def SaveValues(self, buffer = True):
+words = self.TagName.split("::")
 if self.ElementType == "config":
-self.Controler.SetConfigurationGlobalVars(self.ConfigName, self.Values)
+self.Controler.SetConfigurationGlobalVars(words[1], self.Values)
 elif self.ElementType == "resource":
-self.Controler.SetConfigurationResourceGlobalVars(self.ConfigName, self.ResourceName, self.Values)
+self.Controler.SetConfigurationResourceGlobalVars(words[1], words[2], self.Values)
 else:
 if self.ReturnType.IsEnabled():
-self.Controler.SetPouInterfaceReturnType(self.PouName, self.ReturnType.GetStringSelection())
+self.Controler.SetPouInterfaceReturnType(words[1], self.ReturnType.GetStringSelection())
-self.Controler.SetPouInterfaceVars(self.PouName, self.Values)
+self.Controler.SetPouInterfaceVars(words[1], self.Values)
 if buffer:
 self.Controler.BufferProject()
 self.ParentWindow.RefreshTitle()
 self.ParentWindow.RefreshEditMenu()

changeset 121	40b91ba978db
parent 120	add8e391e00c
child 122	e6faee0c271b