plcopeneditor_history: comparison Viewer.py

equal deleted inserted replaced

-:add8e391e00c
+:40b91ba978db
 if values[1] == "program":
 message = wx.MessageDialog(self.ParentWindow, "Programs can't be used by other POUs!", "Error", wx.OK|wx.ICON_ERROR)
 message.ShowModal()
 message.Destroy()
 elif values[1] in ["function", "functionBlock", "program"]:
-name, type = self.ParentWindow.Controler.GetCurrentElementEditingType()
+name, type = self.ParentWindow.Controler.GetEditedElementType(self.TagName)
 if name == values[0]:
 message = wx.MessageDialog(self.ParentWindow, "\"%s\" can't use itself!"%name, "Error", wx.OK|wx.ICON_ERROR)
 message.ShowModal()
 message.Destroy()
 elif type == "function" and values[1] != "function":
 block = FBD_Block(self.ParentWindow, values[0], blockname, id)
 block.SetPosition(x, y)
 width, height = block.GetMinSize()
 block.SetSize(width, height)
 self.ParentWindow.AddBlock(block)
-self.ParentWindow.Controler.AddCurrentElementEditingBlock(id, values[0], blockname)
+self.ParentWindow.Controler.AddEditedElementBlock(self.TagName, id, values[0], blockname)
 self.ParentWindow.RefreshBlockModel(block)
 self.ParentWindow.RefreshBuffer()
 self.ParentWindow.RefreshScrollBars()
 self.ParentWindow.ParentWindow.RefreshEditor()
 self.ParentWindow.Refresh()
 elif values[1] != "location":
-id = self.ParentWindow.GetNewId()
+if values[3] == self.ParentWindow.GetTagName():
-if values[1] == "Output":
+id = self.ParentWindow.GetNewId()
-var_type = OUTPUT
+if values[1] == "Output":
-elif values[1] == "InOut":
+var_type = OUTPUT
-var_type = INPUT
+elif values[1] == "InOut":
-else:
+var_type = INPUT
-var_type = INPUT
+else:
-variable = FBD_Variable(self.ParentWindow, var_type, values[0], values[2], id)
+var_type = INPUT
-variable.SetPosition(x, y)
+variable = FBD_Variable(self.ParentWindow, var_type, values[0], values[2], id)
-width, height = variable.GetMinSize()
+variable.SetPosition(x, y)
-variable.SetSize(width, height)
+width, height = variable.GetMinSize()
-self.ParentWindow.AddBlock(variable)
+variable.SetSize(width, height)
-self.ParentWindow.Controler.AddCurrentElementEditingVariable(id, var_type)
+self.ParentWindow.AddBlock(variable)
-self.ParentWindow.RefreshVariableModel(variable)
+self.ParentWindow.Controler.AddEditedElementVariable(self.TagName, id, var_type)
-self.ParentWindow.RefreshBuffer()
+self.ParentWindow.RefreshVariableModel(variable)
-self.ParentWindow.RefreshScrollBars()
+self.ParentWindow.RefreshBuffer()
-self.ParentWindow.Refresh()
+self.ParentWindow.RefreshScrollBars()
+self.ParentWindow.Refresh()
+else:
+message = wx.MessageDialog(self.ParentWindow, "Variable don't belong to this POU!", "Error", wx.OK|wx.ICON_ERROR)
+message.ShowModal()
+message.Destroy()
+if wx.VERSION >= (2, 8, 0):
+import wx.aui
+class MDIViewer(wx.aui.AuiMDIChildFrame):
+def __init__(self, parent, tagname, window, controler):
+wx.aui.AuiMDIChildFrame.__init__(self, parent, -1, title = "")
+sizer = wx.BoxSizer(wx.HORIZONTAL)
+self.Viewer = Viewer(self, tagname, window, controler)
+sizer.AddWindow(self.Viewer, 1, border=0, flag=wx.GROW)
+self.SetSizer(sizer)
+def GetViewer(self):
+return self.Viewer
 """
 Class that implements a Viewer based on a wx.ScrolledWindow for drawing and
 manipulating graphic elements
 """
 self.ContextualMenu = wx.Menu(title='')
 self._init_coll_ContextualMenu_Items(self.ContextualMenu)
 # Create a new Viewer
-def __init__(self, parent, window, controler):
+def __init__(self, parent, tagname, window, controler):
 wx.ScrolledWindow.__init__(self, parent, pos=wx.Point(0, 0), size=wx.Size(0, 0),
 style=wx.SUNKEN_BORDER | wx.HSCROLL | wx.VSCROLL)
 self._init_menus()
 # Adding a rubberband to Viewer
 self.rubberBand = RubberBand(drawingSurface=self)
 self.ResetView()
 self.Scaling = None
 #self.Scaling = (8, 8)
 self.DrawGrid = True
 self.current_id = 0
+self.TagName = tagname
 # Initialize Block, Wire and Comment numbers
 self.block_id = self.wire_id = self.comment_id = 0
 # Initialize Viewer mode to Selection mode
 self.Bind(wx.EVT_CHAR, self.OnChar)
 if wx.VERSION < (2, 7, 0):
 self.Bind(wx.EVT_SCROLLWIN, self.OnMoveWindow)
 self.Bind(wx.EVT_SIZE, self.OnMoveWindow)
+def SetTagName(self, tagname):
+self.TagName = tagname
+def GetTagName(self):
+return self.TagName
+def IsViewing(self, tagname):
+return self.TagName == tagname
 # Returns a new id
 def GetNewId(self):
 self.current_id += 1
 return self.current_id
 self.Blocks = {}
 self.Wires = {}
 self.Comments = {}
 self.SelectedElement = None
-# Verify wires type compatibility
-def VerifyVariableTypeCompatibility(self):
-to_delete = []
-for wire in self.Wires:
-if not wire.IsConnectedCompatible():
-to_delete.append(wire)
-for wire in to_delete:
-wire.Delete()
 # Remove all elements
 def CleanView(self):
 for block in self.Blocks.keys():
 block.Clean()
 self.ResetView()
 instance = True
 # List of ids of already loaded blocks
 ids = []
 # Load Blocks until they are all loaded
 while instance:
-instance = self.Controler.GetCurrentElementEditingInstanceInfos(exclude=ids)
+instance = self.Controler.GetEditedElementInstanceInfos(self.TagName, exclude=ids)
 if instance:
 self.loadInstance(instance, ids)
 self.RefreshScrollBars()
+to_delete = []
+for wire in self.Wires:
+if not wire.IsConnectedCompatible():
+to_delete.append(wire)
+for wire in to_delete:
+wire.Delete()
 self.Refresh(False)
 def RefreshScrollBars(self):
 xstart, ystart = self.GetViewStart()
 window_size = self.GetClientSize()
 def CreateWires(self, start_connector, links, ids):
 for link in links:
 refLocalId = link["refLocalId"]
 if refLocalId != None:
 if refLocalId not in ids:
-new_instance = self.Controler.GetCurrentElementEditingInstanceInfos(refLocalId)
+new_instance = self.Controler.GetEditedElementInstanceInfos(self.TagName, refLocalId)
 if new_instance:
 self.loadInstance(new_instance, ids)
 connected = self.FindElementById(refLocalId)
 if connected:
 points = link["points"]
 #                           Popup menu functions
 #-------------------------------------------------------------------------------
 def PopupBlockMenu(self, connector = None):
 if connector is not None and connector.IsCompatible("BOOL"):
-type = self.Controler.GetCurrentElementEditingType()
+type = self.Controler.GetEditedElementType(self.TagName)
 self.ContextualMenu.Enable(ID_FBDVIEWERCONTEXTUALMENUITEMS0, True)
 self.ContextualMenu.Enable(ID_FBDVIEWERCONTEXTUALMENUITEMS1, True)
 self.ContextualMenu.Enable(ID_FBDVIEWERCONTEXTUALMENUITEMS2, type != "function")
 self.ContextualMenu.Enable(ID_FBDVIEWERCONTEXTUALMENUITEMS3, type != "function")
 else:
 self.SelectedElement = None
 self.RefreshBuffer()
 event.Skip()
 def OnClearExecutionOrderMenu(self, event):
-self.Controler.ClearCurrentExecutionOrder()
+self.Controler.ClearEditedElementExecutionOrder(self.TagName)
 self.RefreshBuffer()
 self.RefreshView()
 def OnResetExecutionOrderMenu(self, event):
-self.Controler.ResetCurrentExecutionOrder()
+self.Controler.ResetEditedElementExecutionOrder(self.TagName)
 self.RefreshBuffer()
 self.RefreshView()
 #-------------------------------------------------------------------------------
 #                          Mouse event functions
 #                          Model adding functions
 #-------------------------------------------------------------------------------
 def AddNewBlock(self, bbox):
 dialog = BlockPropertiesDialog(self.ParentWindow)
-dialog.SetBlockList(self.Controler.GetBlockTypes())
+dialog.SetBlockList(self.Controler.GetBlockTypes(self.TagName))
 dialog.SetPouNames(self.Controler.GetProjectPouNames())
-dialog.SetPouElementNames(self.Controler.GetCurrentElementEditingVariables())
+dialog.SetPouElementNames(self.Controler.GetEditedElementVariables(self.TagName))
 dialog.SetMinBlockSize((bbox.width, bbox.height))
 if dialog.ShowModal() == wx.ID_OK:
 id = self.GetNewId()
 values = dialog.GetValues()
 if "name" in values:
 else:
 block = FBD_Block(self, values["type"], "", id, values["extension"], values["inputs"])
 block.SetPosition(bbox.x, bbox.y)
 block.SetSize(values["width"], values["height"])
 self.AddBlock(block)
-self.Controler.AddCurrentElementEditingBlock(id, values["type"], values.get("name", None))
+self.Controler.AddEditedElementBlock(self.TagName, id, values["type"], values.get("name", None))
 self.RefreshBlockModel(block)
 self.RefreshBuffer()
 self.RefreshScrollBars()
 self.ParentWindow.RefreshEditor()
 self.Refresh(False)
 def AddNewVariable(self, bbox):
 dialog = VariablePropertiesDialog(self.ParentWindow)
 dialog.SetMinVariableSize((bbox.width, bbox.height))
 varlist = []
-vars = self.Controler.GetCurrentElementEditingInterfaceVars()
+vars = self.Controler.GetEditedElementInterfaceVars(self.TagName)
 if vars:
 for var in vars:
 if var["Edit"]:
 varlist.append((var["Name"], var["Class"], var["Type"]))
-returntype = self.Controler.GetCurrentElementEditingInterfaceReturnType()
+returntype = self.Controler.GetEditedElementInterfaceReturnType(self.TagName)
 if returntype:
-varlist.append((self.Controler.GetCurrentElementEditingName(), "Output", returntype))
+varlist.append((self.Controler.GetEditedElementName(self.TagName), "Output", returntype))
 dialog.SetVariables(varlist)
 if dialog.ShowModal() == wx.ID_OK:
 id = self.GetNewId()
 values = dialog.GetValues()
 variable = FBD_Variable(self, values["type"], values["name"], values["value_type"], id)
 variable.SetPosition(bbox.x, bbox.y)
 variable.SetSize(values["width"], values["height"])
 self.AddBlock(variable)
-self.Controler.AddCurrentElementEditingVariable(id, values["type"])
+self.Controler.AddEditedElementVariable(self.TagName, id, values["type"])
 self.RefreshVariableModel(variable)
 self.RefreshBuffer()
 self.RefreshScrollBars()
 self.Refresh(False)
 dialog.Destroy()
 values = dialog.GetValues()
 connection = FBD_Connector(self, values["type"], values["name"], id)
 connection.SetPosition(bbox.x, bbox.y)
 connection.SetSize(values["width"], values["height"])
 self.AddBlock(connection)
-self.Controler.AddCurrentElementEditingConnection(id, values["type"])
+self.Controler.AddEditedElementConnection(self.TagName, id, values["type"])
 self.RefreshConnectionModel(connection)
 self.RefreshBuffer()
 self.RefreshScrollBars()
 self.Refresh(False)
 dialog.Destroy()
 comment = Comment(self, value, id)
 comment.SetPosition(bbox.x, bbox.y)
 min_width, min_height = comment.GetMinSize()
 comment.SetSize(max(min_width,bbox.width),max(min_height,bbox.height))
 self.AddComment(comment)
-self.Controler.AddCurrentElementEditingComment(id)
+self.Controler.AddEditedElementComment(self.TagName, id)
 self.RefreshCommentModel(comment)
 self.RefreshBuffer()
 self.RefreshScrollBars()
 self.Refresh(False)
 dialog.Destroy()
 def AddNewContact(self, bbox):
 dialog = LDElementDialog(self.ParentWindow, "contact")
 varlist = []
-vars = self.Controler.GetCurrentElementEditingInterfaceVars()
+vars = self.Controler.GetEditedElementInterfaceVars(self.TagName)
 if vars:
 for var in vars:
 if var["Class"] != "Output" and var["Type"] == "BOOL":
 varlist.append(var["Name"])
 dialog.SetVariables(varlist)
 values = dialog.GetValues()
 contact = LD_Contact(self, values["type"], values["name"], id)
 contact.SetPosition(bbox.x, bbox.y)
 contact.SetSize(values["width"], values["height"])
 self.AddBlock(contact)
-self.Controler.AddCurrentElementEditingContact(id)
+self.Controler.AddEditedElementContact(self.TagName, id)
 self.RefreshContactModel(contact)
 self.RefreshBuffer()
 self.RefreshScrollBars()
 self.Refresh(False)
 dialog.Destroy()
 def AddNewCoil(self, bbox):
 dialog = LDElementDialog(self.ParentWindow, "coil")
 varlist = []
-vars = self.Controler.GetCurrentElementEditingInterfaceVars()
+vars = self.Controler.GetEditedElementInterfaceVars(self.TagName)
 if vars:
 for var in vars:
 if var["Class"] != "Input" and var["Type"] == "BOOL":
 varlist.append(var["Name"])
-returntype = self.Controler.GetCurrentElementEditingInterfaceReturnType()
+returntype = self.Controler.GetEditedElementInterfaceReturnType(self.TagName)
 if returntype == "BOOL":
-varlist.append(self.Controler.GetCurrentElementEditingName())
+varlist.append(self.Controler.GetEditedElementName(self.TagName))
 dialog.SetVariables(varlist)
 dialog.SetValues({"name":"","type":COIL_NORMAL})
 dialog.SetElementSize((bbox.width, bbox.height))
 if dialog.ShowModal() == wx.ID_OK:
 id = self.GetNewId()
 values = dialog.GetValues()
 coil = LD_Coil(self, values["type"], values["name"], id)
 coil.SetPosition(bbox.x, bbox.y)
 coil.SetSize(values["width"], values["height"])
 self.AddBlock(coil)
-self.Controler.AddCurrentElementEditingCoil(id)
+self.Controler.AddEditedElementCoil(self.TagName, id)
 self.RefreshCoilModel(coil)
 self.RefreshBuffer()
 self.RefreshScrollBars()
 self.Refresh(False)
 dialog.Destroy()
 values = dialog.GetValues()
 powerrail = LD_PowerRail(self, values["type"], id, [True for i in xrange(values["number"])])
 powerrail.SetPosition(bbox.x, bbox.y)
 powerrail.SetSize(values["width"], values["height"])
 self.AddBlock(powerrail)
-self.Controler.AddCurrentElementEditingPowerRail(id, values["type"])
+self.Controler.AddEditedElementPowerRail(self.TagName, id, values["type"])
 self.RefreshPowerRailModel(powerrail)
 self.RefreshBuffer()
 self.RefreshScrollBars()
 self.Refresh(False)
 dialog.Destroy()
 def AddNewStep(self, bbox, initial = False):
 dialog = StepContentDialog(self.ParentWindow, initial)
 dialog.SetPouNames(self.Controler.GetProjectPouNames())
-dialog.SetVariables(self.Controler.GetCurrentElementEditingInterfaceVars())
+dialog.SetVariables(self.Controler.GetEditedElementInterfaceVars(self.TagName))
 dialog.SetStepNames([block.GetName() for block in self.Blocks if isinstance(block, SFC_Step)])
 dialog.SetMinStepSize((bbox.width, bbox.height))
 if dialog.ShowModal() == wx.ID_OK:
 id = self.GetNewId()
 values = dialog.GetValues()
 step.RemoveAction()
 step.SetPosition(bbox.x, bbox.y)
 min_width, min_height = step.GetMinSize()
 step.SetSize(max(bbox.width, min_width), max(bbox.height, min_height))
 self.AddBlock(step)
-self.Controler.AddCurrentElementEditingStep(id)
+self.Controler.AddEditedElementStep(self.TagName, id)
 self.RefreshStepModel(step)
 self.RefreshBuffer()
 self.RefreshScrollBars()
 self.Refresh(False)
 dialog.Destroy()
 def AddNewTransition(self, bbox):
 dialog = TransitionContentDialog(self.ParentWindow, self.GetDrawingMode() == FREEDRAWING_MODE)
-dialog.SetTransitions(self.Controler.GetCurrentElementEditingTransitions())
+dialog.SetTransitions(self.Controler.GetEditedElementTransitions(self.TagName))
 if dialog.ShowModal() == wx.ID_OK:
 id = self.GetNewId()
 values = dialog.GetValues()
 transition = SFC_Transition(self, values["type"], values["value"], values["priority"], id)
 transition.SetPosition(bbox.x, bbox.y)
 min_width, min_height = transition.GetMinSize()
 transition.SetSize(max(bbox.width, min_width), max(bbox.height, min_height))
 self.AddBlock(transition)
-self.Controler.AddCurrentElementEditingTransition(id)
+self.Controler.AddEditedElementTransition(self.TagName, id)
 self.RefreshTransitionModel(transition)
 self.RefreshBuffer()
 self.RefreshScrollBars()
 self.Refresh(False)
 dialog.Destroy()
 divergence = SFC_Divergence(self, values["type"], values["number"], id)
 divergence.SetPosition(bbox.x, bbox.y)
 min_width, min_height = divergence.GetMinSize(True)
 divergence.SetSize(max(bbox.width, min_width), max(bbox.height, min_height))
 self.AddBlock(divergence)
-self.Controler.AddCurrentElementEditingDivergence(id, values["type"])
+self.Controler.AddEditedElementDivergence(self.TagName, id, values["type"])
 self.RefreshDivergenceModel(divergence)
 self.RefreshBuffer()
 self.RefreshScrollBars()
 self.Refresh(False)
 dialog.Destroy()
 jump = SFC_Jump(self, value, id)
 jump.SetPosition(bbox.x, bbox.y)
 min_width, min_height = jump.GetMinSize()
 jump.SetSize(max(bbox.width, min_width), max(bbox.height, min_height))
 self.AddBlock(jump)
-self.Controler.AddCurrentElementEditingJump(id)
+self.Controler.AddEditedElementJump(self.TagName, id)
 self.RefreshJumpModel(jump)
 self.RefreshBuffer()
 self.RefreshScrollBars()
 self.Refresh()
 dialog.Destroy()
 def AddNewActionBlock(self, bbox):
 dialog = ActionBlockDialog(self.ParentWindow)
 dialog.SetQualifierList(self.Controler.GetQualifierTypes())
-dialog.SetActionList(self.Controler.GetCurrentElementEditingActions())
+dialog.SetActionList(self.Controler.GetEditedElementActions(self.TagName))
-dialog.SetVariableList(self.Controler.GetCurrentElementEditingInterfaceVars())
+dialog.SetVariableList(self.Controler.GetEditedElementInterfaceVars(self.TagName))
 if dialog.ShowModal() == wx.ID_OK:
 actions = dialog.GetValues()
 id = self.GetNewId()
 actionblock = SFC_ActionBlock(self, actions, id)
 actionblock.SetPosition(bbox.x, bbox.y)
 min_width, min_height = actionblock.GetMinSize()
 actionblock.SetSize(max(bbox.width, min_width), max(bbox.height, min_height))
 self.AddBlock(actionblock)
-self.Controler.AddCurrentElementEditingActionBlock(id)
+self.Controler.AddEditedElementActionBlock(self.TagName, id)
 self.RefreshActionBlockModel(actionblock)
 self.RefreshBuffer()
 self.RefreshScrollBars()
 self.Refresh()
 dialog.Destroy()
 #                          Edit element content functions
 #-------------------------------------------------------------------------------
 def EditBlockContent(self, block):
 dialog = BlockPropertiesDialog(self.ParentWindow)
-dialog.SetBlockList(self.Controler.GetBlockTypes())
+dialog.SetBlockList(self.Controler.GetBlockTypes(self.TagName))
 dialog.SetPouNames(self.Controler.GetProjectPouNames())
-variable_names = self.Controler.GetCurrentElementEditingVariables()
+variable_names = self.Controler.GetEditedElementVariables(self.TagName)
 if block.GetName() != "":
 variable_names.remove(block.GetName())
 dialog.SetPouElementNames(variable_names)
 dialog.SetMinBlockSize(block.GetSize())
 old_values = {"name" : block.GetName(), "type" : block.GetType(), "inputs" : block.GetInputTypes(),
 def EditVariableContent(self, variable):
 dialog = VariablePropertiesDialog(self.ParentWindow)
 dialog.SetMinVariableSize(variable.GetSize())
 varlist = []
-vars = self.Controler.GetCurrentElementEditingInterfaceVars()
+vars = self.Controler.GetEditedElementInterfaceVars(self.TagName)
 if vars:
 for var in vars:
 if var["Edit"]:
 varlist.append((var["Name"], var["Class"], var["Type"]))
-returntype = self.Controler.GetCurrentElementEditingInterfaceReturnType()
+returntype = self.Controler.GetEditedElementInterfaceReturnType(self.TagName)
 if returntype:
-varlist.append((self.Controler.GetCurrentElementEditingName(), "Output", returntype))
+varlist.append((self.Controler.GetEditedElementName(self.TagName), "Output", returntype))
 dialog.SetVariables(varlist)
 old_values = {"name" : variable.GetName(), "type" : variable.GetType(),
 "executionOrder" : variable.GetExecutionOrder()}
 dialog.SetValues(old_values)
 if dialog.ShowModal() == wx.ID_OK:
 variable.SetType(new_values["type"], new_values["value_type"])
 variable.SetSize(new_values["width"], new_values["height"])
 variable.SetExecutionOrder(new_values["executionOrder"])
 if old_values["type"] != new_values["type"]:
 id = variable.GetId()
-self.Controler.RemoveCurrentElementEditingInstance(id)
+self.Controler.RemoveEditedElementInstance(self.TagName, id)
-self.Controler.AddCurrentElementEditingVariable(id, new_values["type"])
+self.Controler.AddEditedElementVariable(self.TagName, id, new_values["type"])
 self.RefreshVariableModel(variable)
 if old_values["executionOrder"] != new_values["executionOrder"]:
 self.RefreshView()
 self.RefreshBuffer()
 self.RefreshScrollBars()
 connection.SetName(values["name"])
 connection.SetType(values["type"])
 connection.SetSize(values["width"], values["height"])
 if old_type != values["type"]:
 id = connection.GetId()
-self.Controler.RemoveCurrentElementEditingInstance(id)
+self.Controler.RemoveEditedElementInstance(self.TagName, id)
-self.Controler.AddCurrentElementEditingConnection(id, values["type"])
+self.Controler.AddEditedElementConnection(self.TagName, id, values["type"])
 self.RefreshConnectionModel(connection)
 self.RefreshBuffer()
 self.RefreshScrollBars()
 self.Refresh(False)
 dialog.Destroy()
 def EditContactContent(self, contact):
 dialog = LDElementDialog(self.ParentWindow, "contact")
 varlist = []
-vars = self.Controler.GetCurrentElementEditingInterfaceVars()
+vars = self.Controler.GetEditedElementInterfaceVars(self.TagName)
 if vars:
 for var in vars:
 if var["Class"] != "Output" and var["Type"] == "BOOL":
 varlist.append(var["Name"])
 dialog.SetVariables(varlist)
 dialog.Destroy()
 def EditCoilContent(self, coil):
 dialog = LDElementDialog(self.ParentWindow, "coil")
 varlist = []
-vars = self.Controler.GetCurrentElementEditingInterfaceVars()
+vars = self.Controler.GetEditedElementInterfaceVars(self.TagName)
 if vars:
 for var in vars:
 if var["Class"] != "Input" and var["Type"] == "BOOL":
 varlist.append(var["Name"])
-returntype = self.Controler.GetCurrentElementEditingInterfaceReturnType()
+returntype = self.Controler.GetEditedElementInterfaceReturnType(self.TagName)
 if returntype == "BOOL":
-varlist.append(self.Controler.GetCurrentElementEditingName())
+varlist.append(self.Controler.GetEditedElementName(self.TagName))
 dialog.SetVariables(varlist)
 values = {"name" : coil.GetName(), "type" : coil.GetType()}
 dialog.SetValues(values)
 dialog.SetElementSize(coil.GetSize())
 if dialog.ShowModal() == wx.ID_OK:
 values = dialog.GetValues()
 powerrail.SetType(values["type"], [True for i in xrange(values["number"])])
 powerrail.SetSize(values["width"], values["height"])
 if old_type != values["type"]:
 id = powerrail.GetId()
-self.Controler.RemoveCurrentElementEditingInstance(id)
+self.Controler.RemoveEditedElementInstance(self.TagName, id)
-self.Controler.AddCurrentElementEditingPowerRail(id, values["type"])
+self.Controler.AddEditedElementPowerRail(self.TagName, id, values["type"])
 self.RefreshPowerRailModel(powerrail)
 self.RefreshBuffer()
 self.RefreshScrollBars()
 self.Refresh(False)
 dialog.Destroy()
 def EditStepContent(self, step):
 dialog = StepContentDialog(self.ParentWindow, step.GetInitial())
 dialog.SetPouNames(self.Controler.GetProjectPouNames())
-dialog.SetVariables(self.Controler.GetCurrentElementEditingInterfaceVars())
+dialog.SetVariables(self.Controler.GetEditedElementInterfaceVars(self.TagName))
 dialog.SetStepNames([block.GetName() for block in self.Blocks if isinstance(block, SFC_Step) and block.GetName() != step.GetName()])
 dialog.SetMinStepSize(step.GetSize())
 values = {"name" : step.GetName()}
 connectors = step.GetConnectors()
 values["input"] = connectors["input"] != None
 self.RefreshScrollBars()
 self.Refresh(False)
 def EditTransitionContent(self, transition):
 dialog = TransitionContentDialog(self.ParentWindow, self.GetDrawingMode() == FREEDRAWING_MODE)
-dialog.SetTransitions(self.Controler.GetCurrentElementEditingTransitions())
+dialog.SetTransitions(self.Controler.GetEditedElementTransitions(self.TagName))
 dialog.SetValues({"type":transition.GetType(),"value":transition.GetCondition(), "priority":transition.GetPriority()})
 dialog.SetElementSize(transition.GetSize())
 if dialog.ShowModal() == wx.ID_OK:
 values = dialog.GetValues()
 transition.SetType(values["type"],values["value"])
 dialog.Destroy()
 def EditActionBlockContent(self, actionblock):
 dialog = ActionBlockDialog(self.ParentWindow)
 dialog.SetQualifierList(self.Controler.GetQualifierTypes())
-dialog.SetActionList(self.Controler.GetCurrentElementEditingActions())
+dialog.SetActionList(self.Controler.GetEditedElementActions(self.TagName))
-dialog.SetVariableList(self.Controler.GetCurrentElementEditingInterfaceVars())
+dialog.SetVariableList(self.Controler.GetEditedElementInterfaceVars(self.TagName))
 dialog.SetValues(actionblock.GetActions())
 if dialog.ShowModal() == wx.ID_OK:
 actions = dialog.GetValues()
 actionblock.SetActions(actions)
 actionblock.RefreshModel()
 infos["name"] = block.GetName()
 infos["executionOrder"] = block.GetExecutionOrder()
 infos["x"], infos["y"] = block.GetPosition()
 infos["width"], infos["height"] = block.GetSize()
 infos["connectors"] = block.GetConnectors()
-self.Controler.SetCurrentElementEditingBlockInfos(blockid, infos)
+self.Controler.SetEditedElementBlockInfos(self.TagName, blockid, infos)
 def RefreshVariableModel(self, variable):
 variableid = variable.GetId()
 infos = {}
 infos["name"] = variable.GetName()
 infos["executionOrder"] = variable.GetExecutionOrder()
 infos["x"], infos["y"] = variable.GetPosition()
 infos["width"], infos["height"] = variable.GetSize()
 infos["connectors"] = variable.GetConnectors()
-self.Controler.SetCurrentElementEditingVariableInfos(variableid, infos)
+self.Controler.SetEditedElementVariableInfos(self.TagName, variableid, infos)
 def RefreshConnectionModel(self, connection):
 connectionid = connection.GetId()
 infos = {}
 infos["name"] = connection.GetName()
 infos["executionOrder"] = connection.GetExecutionOrder()
 infos["x"], infos["y"] = connection.GetPosition()
 infos["width"], infos["height"] = connection.GetSize()
 infos["connector"] = connection.GetConnector()
-self.Controler.SetCurrentElementEditingConnectionInfos(connectionid, infos)
+self.Controler.SetEditedElementConnectionInfos(self.TagName, connectionid, infos)
 def RefreshCommentModel(self, comment):
 commentid = comment.GetId()
 infos = {}
 infos["content"] = comment.GetContent()
 infos["x"], infos["y"] = comment.GetPosition()
 infos["width"], infos["height"] = comment.GetSize()
-self.Controler.SetCurrentElementEditingCommentInfos(commentid, infos)
+self.Controler.SetEditedElementCommentInfos(self.TagName, commentid, infos)
 def RefreshPowerRailModel(self, powerrail):
 powerrailid = powerrail.GetId()
 infos = {}
 infos["x"], infos["y"] = powerrail.GetPosition()
 infos["width"], infos["height"] = powerrail.GetSize()
 infos["connectors"] = powerrail.GetConnectors()
-self.Controler.SetCurrentElementEditingPowerRailInfos(powerrailid, infos)
+self.Controler.SetEditedElementPowerRailInfos(self.TagName, powerrailid, infos)
 def RefreshContactModel(self, contact):
 contactid = contact.GetId()
 infos = {}
 infos["name"] = contact.GetName()
 infos["type"] = contact.GetType()
 infos["x"], infos["y"] = contact.GetPosition()
 infos["width"], infos["height"] = contact.GetSize()
 infos["connectors"] = contact.GetConnectors()
-self.Controler.SetCurrentElementEditingContactInfos(contactid, infos)
+self.Controler.SetEditedElementContactInfos(self.TagName, contactid, infos)
 def RefreshCoilModel(self, coil):
 coilid = coil.GetId()
 infos = {}
 infos["name"] = coil.GetName()
 infos["type"] = coil.GetType()
 infos["x"], infos["y"] = coil.GetPosition()
 infos["width"], infos["height"] = coil.GetSize()
 infos["connectors"] = coil.GetConnectors()
-self.Controler.SetCurrentElementEditingCoilInfos(coilid, infos)
+self.Controler.SetEditedElementCoilInfos(self.TagName, coilid, infos)
 def RefreshStepModel(self, step):
 stepid = step.GetId()
 infos = {}
 infos["name"] = step.GetName()
 infos["initial"] = step.GetInitial()
 infos["x"], infos["y"] = step.GetPosition()
 infos["width"], infos["height"] = step.GetSize()
 infos["connectors"] = step.GetConnectors()
-self.Controler.SetCurrentElementEditingStepInfos(stepid, infos)
+self.Controler.SetEditedElementStepInfos(self.TagName, stepid, infos)
 def RefreshTransitionModel(self, transition):
 transitionid = transition.GetId()
 infos = {}
 infos["type"] = transition.GetType()
 infos["priority"] = transition.GetPriority()
 infos["condition"] = transition.GetCondition()
 infos["x"], infos["y"] = transition.GetPosition()
 infos["width"], infos["height"] = transition.GetSize()
 infos["connectors"] = transition.GetConnectors()
-self.Controler.SetCurrentElementEditingTransitionInfos(transitionid, infos)
+self.Controler.SetEditedElementTransitionInfos(self.TagName, transitionid, infos)
 def RefreshDivergenceModel(self, divergence):
 divergenceid = divergence.GetId()
 infos = {}
 infos["x"], infos["y"] = divergence.GetPosition()
 infos["width"], infos["height"] = divergence.GetSize()
 infos["connectors"] = divergence.GetConnectors()
-self.Controler.SetCurrentElementEditingDivergenceInfos(divergenceid, infos)
+self.Controler.SetEditedElementDivergenceInfos(self.TagName, divergenceid, infos)
 def RefreshJumpModel(self, jump):
 jumpid = jump.GetId()
 infos = {}
 infos["target"] = jump.GetTarget()
 infos["x"], infos["y"] = jump.GetPosition()
 infos["width"], infos["height"] = jump.GetSize()
 infos["connector"] = jump.GetConnector()
-self.Controler.SetCurrentElementEditingJumpInfos(jumpid, infos)
+self.Controler.SetEditedElementJumpInfos(self.TagName, jumpid, infos)
 def RefreshActionBlockModel(self, actionblock):
 actionblockid = actionblock.GetId()
 infos = {}
 infos["actions"] = actionblock.GetActions()
 infos["x"], infos["y"] = actionblock.GetPosition()
 infos["width"], infos["height"] = actionblock.GetSize()
 infos["connector"] = actionblock.GetConnector()
-self.Controler.SetCurrentElementEditingActionBlockInfos(actionblockid, infos)
+self.Controler.SetEditedElementActionBlockInfos(self.TagName, actionblockid, infos)
 #-------------------------------------------------------------------------------
 #                          Model delete functions
 #-------------------------------------------------------------------------------
 for element in output.GetConnectedBlocks():
 if element not in elements:
 elements.append(element)
 block.Clean()
 self.RemoveBlock(block)
-self.Controler.RemoveCurrentElementEditingInstance(block.GetId())
+self.Controler.RemoveEditedElementInstance(self.TagName, block.GetId())
 for element in elements:
 element.RefreshModel()
 wx.CallAfter(self.ParentWindow.RefreshEditor)
 def DeleteVariable(self, variable):
 elements = connectors["output"].GetConnectedBlocks()
 else:
 elements = []
 variable.Clean()
 self.RemoveBlock(variable)
-self.Controler.RemoveCurrentElementEditingInstance(variable.GetId())
+self.Controler.RemoveEditedElementInstance(self.TagName, variable.GetId())
 for element in elements:
 element.RefreshModel()
 def DeleteConnection(self, connection):
 if connection.GetType() == CONTINUATION:
 elements = connection.GetConnector().GetConnectedBlocks()
 else:
 elements = []
 connection.Clean()
 self.RemoveBlock(connection)
-self.Controler.RemoveCurrentElementEditingInstance(connection.GetId())
+self.Controler.RemoveEditedElementInstance(self.TagName, connection.GetId())
 for element in elements:
 element.RefreshModel()
 def DeleteComment(self, comment):
 self.RemoveComment(comment)
-self.Controler.RemoveCurrentElementEditingInstance(comment.GetId())
+self.Controler.RemoveEditedElementInstance(self.TagName, comment.GetId())
 def DeleteWire(self, wire):
 if wire in self.Wires:
 connected = wire.GetConnected()
 wire.Clean()
 def DeleteContact(self, contact):
 connectors = contact.GetConnectors()
 elements = connectors["output"].GetConnectedBlocks()
 contact.Clean()
 self.RemoveBlock(contact)
-self.Controler.RemoveCurrentElementEditingInstance(contact.GetId())
+self.Controler.RemoveEditedElementInstance(self.TagName, contact.GetId())
 for element in elements:
 element.RefreshModel()
 def DeleteCoil(self, coil):
 connectors = coil.GetConnectors()
 elements = connectors["output"].GetConnectedBlocks()
 coil.Clean()
 self.RemoveBlock(coil)
-self.Controler.RemoveCurrentElementEditingInstance(coil.GetId())
+self.Controler.RemoveEditedElementInstance(self.TagName, coil.GetId())
 for element in elements:
 element.RefreshModel()
 def DeletePowerRail(self, powerrail):
 elements = []
 for element in connector.GetConnectedBlocks():
 if element not in elements:
 elements.append(element)
 powerrail.Clean()
 self.RemoveBlock(powerrail)
-self.Controler.RemoveCurrentElementEditingInstance(powerrail.GetId())
+self.Controler.RemoveEditedElementInstance(self.TagName, powerrail.GetId())
 for element in elements:
 element.RefreshModel()
 def DeleteStep(self, step):
 elements = []
 for element in connectors["action"].GetConnectedBlocks():
 if element not in elements:
 elements.append(element)
 step.Clean()
 self.RemoveBlock(step)
-self.Controler.RemoveCurrentElementEditingInstance(step.GetId())
+self.Controler.RemoveEditedElementInstance(self.TagName, step.GetId())
 for element in elements:
 element.RefreshModel()
 def DeleteTransition(self, transition):
 elements = []
 for element in connectors["output"].GetConnectedBlocks():
 if element not in elements:
 elements.append(element)
 transition.Clean()
 self.RemoveBlock(transition)
-self.Controler.RemoveCurrentElementEditingInstance(transition.GetId())
+self.Controler.RemoveEditedElementInstance(self.TagName, transition.GetId())
 for element in elements:
 element.RefreshModel()
 def DeleteDivergence(self, divergence):
 elements = []
 for element in output.GetConnectedBlocks():
 if element not in elements:
 elements.append(element)
 divergence.Clean()
 self.RemoveBlock(divergence)
-self.Controler.RemoveCurrentElementEditingInstance(divergence.GetId())
+self.Controler.RemoveEditedElementInstance(self.TagName, divergence.GetId())
 for element in elements:
 element.RefreshModel()
 def DeleteJump(self, jump):
 jump.Clean()
 self.RemoveBlock(jump)
-self.Controler.RemoveCurrentElementEditingInstance(jump.GetId())
+self.Controler.RemoveEditedElementInstance(self.TagName, jump.GetId())
 def DeleteActionBlock(self, actionblock):
 actionblock.Clean()
 self.RemoveBlock(actionblock)
-self.Controler.RemoveCurrentElementEditingInstance(actionblock.GetId())
+self.Controler.RemoveEditedElementInstance(self.TagName, actionblock.GetId())
 #-------------------------------------------------------------------------------
 #                            Editing functions
 #-------------------------------------------------------------------------------
 def CopyBlock(self, element, pos):
 id = self.GetNewId()
 block = element.Clone(id, pos)
 self.AddBlock(block)
 if isinstance(block, Comment):
-self.Controler.AddCurrentElementEditingComment(id)
+self.Controler.AddEditedElementComment(self.TagName, id)
 self.RefreshCommentModel(comment)
 elif isinstance(block, FBD_Block):
-self.Controler.AddCurrentElementEditingBlock(id, block.GetType(), None)
+self.Controler.AddEditedElementBlock(self.TagName, id, block.GetType(), None)
 self.RefreshBlockModel(block)
 elif isinstance(block, FBD_Variable):
-self.Controler.AddCurrentElementEditingVariable(id, block.GetType())
+self.Controler.AddEditedElementVariable(self.TagName, id, block.GetType())
 self.RefreshVariableModel(block)
 elif isinstance(block, FBD_Connector):
-self.Controler.AddCurrentElementEditingConnection(id, block.GetType())
+self.Controler.AddEditedElementConnection(self.TagName, id, block.GetType())
 self.RefreshConnectionModel(block)
 elif isinstance(block, LD_Contact):
-self.Controler.AddCurrentElementEditingContact(id)
+self.Controler.AddEditedElementContact(self.TagName, id)
 self.RefreshContactModel(block)
 elif isinstance(block, LD_Coil):
-self.Controler.AddCurrentElementEditingCoil(id)
+self.Controler.AddEditedElementCoil(self.TagName, id)
 self.RefreshCoilModel(block)
 elif isinstance(block, LD_PowerRail):
-self.Controler.AddCurrentElementEditingPowerRail(id, block.GetType())
+self.Controler.AddEditedElementPowerRail(self.TagName, id, block.GetType())
 self.RefreshPowerRailModel(block)
 elif isinstance(block, SFC_Step):
-self.Controler.AddCurrentElementEditingStep(id)
+self.Controler.AddEditedElementStep(self.TagName, id)
 self.RefreshStepModel(block)
 elif isinstance(block, SFC_Transition):
-self.Controler.AddCurrentElementEditingTransition(id)
+self.Controler.AddEditedElementTransition(self.TagName, id)
 self.RefreshTransitionModel(block)
 elif isinstance(block, SFC_Divergence):
-self.Controler.AddCurrentElementEditingDivergence(id, block.GetType())
+self.Controler.AddEditedElementDivergence(self.TagName, id, block.GetType())
 self.RefreshActionDivergenceModel(block)
 elif isinstance(block, SFC_Jump):
-self.Controler.AddCurrentElementEditingJump(id)
+self.Controler.AddEditedElementJump(self.TagName, id)
 self.RefreshJumpModel(block)
 elif isinstance(block, SFC_ActionBlock):
-self.Controler.AddCurrentElementEditingActionBlock(id)
+self.Controler.AddEditedElementActionBlock(self.TagName, id)
 self.RefreshActionBlockModel(block)
 return block
 #-------------------------------------------------------------------------------

changeset 121	40b91ba978db
parent 118	0c53d6a36013
child 122	e6faee0c271b