plcopeneditor_history: comparison PLCControler.py

equal deleted inserted replaced

-:add8e391e00c
+:40b91ba978db
 self.ProjectBuffer = None
 self.Buffering = False
 self.FilePath = ""
 self.FileName = ""
 self.ProgramFilePath = ""
-self.ElementsOpened = []
-self.CurrentElementEditing = None
 self.RefreshPouUsingTree()
 self.RefreshBlockTypes()
 def GetQualifierTypes(self):
 return plcopen.QualifierList
 return False
 #-------------------------------------------------------------------------------
 #                        Project Pous management functions
 #-------------------------------------------------------------------------------
-def RemoveElementEditing(self, index):
-self.ElementsOpened.pop(index)
-if self.CurrentElementEditing > index:
-self.CurrentElementEditing -= 1
-if len(self.ElementsOpened) > 0:
-self.CurrentElementEditing = max(0, min(self.CurrentElementEditing, len(self.ElementsOpened) - 1))
-else:
-self.CurrentElementEditing = None
 # Add a Pou to Project
 def ProjectAddPou(self, pou_name, pou_type, body_type):
 # Add the pou to project
 self.Project.appendPou(pou_name, pou_type, body_type)
 self.RefreshBlockTypes()
 self.BufferProject()
 # Remove a pou from project
 def ProjectRemovePou(self, pou_name):
-# Search if the pou removed is currently opened
-for i, element in enumerate(self.ElementsOpened):
-words = element.split("::")
-if words[0] == "P" and words[1] == pou_name:
-self.RemoveElementEditing(i)
-# Remove pou from project
 self.Project.removePou(pou_name)
 self.RefreshPouUsingTree()
 self.RefreshBlockTypes()
 self.BufferProject()
 self.RefreshBlockTypes()
 self.BufferProject()
 # Remove a configuration from project
 def ProjectRemoveConfiguration(self, config_name):
-# Search if the pou removed is currently opened
-for i, element in enumerate(self.ElementsOpened):
-words = element.split("::")
-if words[0] == "C" and words[1] == config_name:
-self.RemoveElementEditing(i)
 self.Project.removeConfiguration(config_name)
 self.BufferProject()
 # Add a resource to a configuration of the Project
 def ProjectAddConfigurationResource(self, config_name, resource_name):
 self.RefreshBlockTypes()
 self.BufferProject()
 # Remove a resource from a configuration of the project
 def ProjectRemoveConfigurationResource(self, config_name, resource_name):
-# Search if the pou removed is currently opened
-for i, element in enumerate(self.ElementsOpened):
-words = element.split("::")
-if words[0] == "R" and words[1] == config_name and words[2] == resource_name:
-self.RemoveElementEditing(i)
 self.Project.removeConfigurationResource(config_name, resource_name)
 self.BufferProject()
 # Add a Transition to a Project Pou
 def ProjectAddPouTransition(self, pou_name, transition_name, transition_type):
 pou.addTransition(transition_name, transition_type)
 self.BufferProject()
 # Remove a Transition from a Project Pou
 def ProjectRemovePouTransition(self, pou_name, transition_name):
-# Search if the pou removed is currently opened
-for i, element in enumerate(self.ElementsOpened):
-words = element.split("::")
-if words[0] == "T" and words[1] == pou_name and words[2] == transition_name:
-self.RemoveElementEditing(i)
 pou = self.Project.getPou(pou_name)
 pou.removeTransition(transition_name)
 self.BufferProject()
 # Add an Action to a Project Pou
 # Change the name of a pou
 def ChangePouName(self, old_name, new_name):
 # Found the pou corresponding to old name and change its name to new name
 pou = self.Project.getPou(old_name)
 pou.setName(new_name)
-# If pou is currently opened, change its name in the list of opened pous
-for idx, element in enumerate(self.ElementsOpened):
-words = element.split("::")
-if words[0] in ["P","T","A"] and words[1] == old_name:
-if words[0] == "P":
-self.ElementsOpened[idx] = self.ComputePouName(new_name)
-elif words[0] == "T":
-self.ElementsOpened[idx] = self.ComputePouTransitionName(new_name, words[2])
-else:
-self.ElementsOpened[idx] = self.ComputePouActionName(new_name, words[2])
 self.Project.updateElementName(old_name, new_name)
 self.RefreshPouUsingTree()
 self.RefreshBlockTypes()
 self.BufferProject()
 def ChangePouTransitionName(self, pou_name, old_name, new_name):
 # Found the pou transition corresponding to old name and change its name to new name
 pou = self.Project.getPou(pou_name)
 transition = pou.getTransition(old_name)
 transition.setName(new_name)
-# If pou transition is currently opened, change its name in the list of opened elements
-old_computedname = self.ComputePouTransitionName(pou_name, old_name)
-new_computedname = self.ComputePouTransitionName(pou_name, new_name)
-if old_computedname in self.ElementsOpened:
-idx = self.ElementsOpened.index(old_computedname)
-self.ElementsOpened[idx] = new_computedname
 pou.updateElementName(old_name, new_name)
 self.BufferProject()
 # Change the name of a pou action
 def ChangePouActionName(self, pou_name, old_name, new_name):
 # Found the pou action corresponding to old name and change its name to new name
 pou = self.Project.getPou(pou_name)
 action = pou.getAction(old_name)
 action.setName(new_name)
-# If pou action is currently opened, change its name in the list of opened elements
-old_computedname = self.ComputePouActionName(pou_name, old_name)
-new_computedname = self.ComputePouActionName(pou_name, new_name)
-if old_computedname in self.ElementsOpened:
-idx = self.ElementsOpened.index(old_computedname)
-self.ElementsOpened[idx] = new_computedname
 pou.updateElementName(old_name, new_name)
 self.BufferProject()
 # Change the name of a pou variable
 def ChangePouVariableName(self, pou_name, old_name, new_name):
 # Change the name of a configuration
 def ChangeConfigurationName(self, old_name, new_name):
 # Found the configuration corresponding to old name and change its name to new name
 configuration = self.Project.getConfiguration(old_name)
 configuration.setName(new_name)
-# If configuration is currently opened, change its name in the list of opened elements
-for idx, element in enumerate(self.ElementsOpened):
-words = element.split("::")
-if words[0] in ["C","R"] and words[1] == old_name:
-if words[0] == "C":
-self.ElementsOpened[idx] = self.ComputeConfigurationName(new_name)
-else:
-self.ElementsOpened[idx] = self.ComputeConfigurationResourceName(new_name, words[2])
 self.BufferProject()
 # Change the name of a configuration resource
 def ChangeConfigurationResourceName(self, config_name, old_name, new_name):
 # Found the resource corresponding to old name and change its name to new name
 resource = self.Project.getConfigurationResource(config_name)
 resource.setName(new_name)
-# If resource is currently opened, change its name in the list of opened elements
-old_computedname = self.ComputeConfigurationResourceName(config_name, old_name)
-new_computedname = self.ComputeConfigurationResourceName(config_name, new_name)
-if old_computedname in self.ElementsOpened:
-idx = self.ElementsOpened.index(old_computedname)
-self.ElementsOpened[idx] = new_computedname
 self.BufferProject()
 # Return the type of the pou given by its name
 def GetPouType(self, name):
 # Found the pou correponding to name and return its type
 def UpdateProjectUsedPous(self, old_name, new_name):
 if self.Project:
 self.Project.updateElementName(old_name, new_name)
-def UpdateCurrentPouEditingUsedVariable(self, old_name, new_name):
+def UpdateEditedElementUsedVariable(self, tagname, old_name, new_name):
-pou = self.GetCurrentElementEditing()
+pou = self.GetEditedElement(tagname)
 if pou:
 pou.updateElementName(old_name, new_name)
 # Return the return type of the pou given by its name
 def GetPouInterfaceReturnTypeByName(self, name):
 if isinstance(instance, plcopen.comment):
 block_infos["comment"] = instance.getContentText()
 BlockTypes[-1]["list"].append(block_infos)
 # Return Block types checking for recursion
-def GetBlockTypes(self):
+def GetBlockTypes(self, tagname = ""):
-if self.CurrentElementEditing != None:
+if self.Project:
-if self.Project:
+words = tagname.split("::")
-current_name = self.ElementsOpened[self.CurrentElementEditing]
+if len(words) == 1:
-words = current_name.split("::")
+name = current_name
+else:
+name = words[1]
+type = self.GetPouType(name)
+else:
+name = ""
+type = None
+if type == "function":
+blocktypes = []
+for category in BlockTypes[:-1] + PluginTypes:
+cat = {"name" : category["name"], "list" : []}
+for block in category["list"]:
+if block["type"] == "function":
+cat["list"].append(block)
+if len(cat["list"]) > 0:
+blocktypes.append(cat)
+else:
+blocktypes = [category for category in BlockTypes[:-1] + PluginTypes]
+if self.Project:
+blocktypes.append({"name" : "User-defined POUs", "list": []})
+for blocktype in BlockTypes[-1]["list"]:
+if blocktype["name"] != name and not self.PouIsUsedBy(name, blocktype["name"]) and not (type == "function" and blocktype["type"] != "function"):
+blocktypes[-1]["list"].append(blocktype)
+return blocktypes
+# Return Function Block types checking for recursion
+def GetFunctionBlockTypes(self, tagname = ""):
+name = ""
+type = None
+if self.Project:
+words = tagname.split("::")
+if words[0] in ["P","T","A"]:
 if len(words) == 1:
 name = current_name
 else:
 name = words[1]
 type = self.GetPouType(name)
-else:
+blocktypes = []
-name = ""
+for category in BlockTypes[:-1]:
-type = None
+for block in category["list"]:
-if type == "function":
+if block["type"] != "function":
-blocktypes = []
+blocktypes.append(block["name"])
-for category in BlockTypes[:-1] + PluginTypes:
+if self.Project:
-cat = {"name" : category["name"], "list" : []}
+for blocktype in BlockTypes[-1]["list"]:
-for block in category["list"]:
+if blocktype["name"] != name and not self.PouIsUsedBy(name, blocktype["name"]) and not (type == "function" and blocktype["type"] != "function"):
-if block["type"] == "function":
+blocktypes.append(blocktype["name"])
-cat["list"].append(block)
+return blocktypes
-if len(cat["list"]) > 0:
-blocktypes.append(cat)
-else:
-blocktypes = [category for category in BlockTypes[:-1] + PluginTypes]
-if self.Project:
-blocktypes.append({"name" : "User-defined POUs", "list": []})
-for blocktype in BlockTypes[-1]["list"]:
-if blocktype["name"] != name and not self.PouIsUsedBy(name, blocktype["name"]) and not (type == "function" and blocktype["type"] != "function"):
-blocktypes[-1]["list"].append(blocktype)
-return blocktypes
-return []
-# Return Function Block types checking for recursion
-def GetFunctionBlockTypes(self):
-if self.CurrentElementEditing != None:
-name = ""
-type = None
-if self.Project:
-current_name = self.ElementsOpened[self.CurrentElementEditing]
-words = current_name.split("::")
-if words[0] in ["P","T","A"]:
-if len(words) == 1:
-name = current_name
-else:
-name = words[1]
-type = self.GetPouType(name)
-blocktypes = []
-for category in BlockTypes[:-1]:
-for block in category["list"]:
-if block["type"] != "function":
-blocktypes.append(block["name"])
-if self.Project:
-for blocktype in BlockTypes[-1]["list"]:
-if blocktype["name"] != name and not self.PouIsUsedBy(name, blocktype["name"]) and not (type == "function" and blocktype["type"] != "function"):
-blocktypes.append(blocktype["name"])
-return blocktypes
-return []
 # Return Block types checking for recursion
 def GetBlockResource(self):
 blocktypes = []
 for category in BlockTypes[:-1]:
 if pou.pouType.getValue() == "program":
 blocktypes.append(pou.getName())
 return blocktypes
 #-------------------------------------------------------------------------------
-#                       Project opened Pous management functions
+#                   Project Element tag name computation functions
 #-------------------------------------------------------------------------------
-# Return the list of pou names
-def GetElementsOpenedNames(self):
-names = []
-for pou_name in self.ElementsOpened:
-words = pou_name.split("::")
-if words[0] in ["P","C"]:
-names.append(words[1])
-else:
-names.append("%s-%s"%(words[1],words[2]))
-return names
 # Compute a pou transition name
 def ComputePouName(self, pou):
 return "P::%s" % pou
 # Compute a pou  name
 def ComputeConfigurationResourceName(self, config, resource):
 return "R::%s::%s" % (config, resource)
-# Open a pou by giving its name
-def OpenElementEditing(self, name):
-# If pou not opened yet
-if name not in self.ElementsOpened:
-# Add pou name to list of pou opened and make it current editing
-self.ElementsOpened.append(name)
-self.CurrentElementEditing = len(self.ElementsOpened) - 1
-return self.CurrentElementEditing
-return None
-# Open a pou transition by giving pou and transition names
-def OpenPouEditing(self, pou):
-return self.OpenElementEditing(self.ComputePouName(pou))
-# Open a pou transition by giving pou and transition names
-def OpenPouTransitionEditing(self, pou, transition):
-return self.OpenElementEditing(self.ComputePouTransitionName(pou, transition))
-# Open a pou action by giving pou and action names
-def OpenPouActionEditing(self, pou, action):
-return self.OpenElementEditing(self.ComputePouActionName(pou, action))
-# Open a configuration resource by giving configuration name
-def OpenConfigurationEditing(self, config):
-return self.OpenElementEditing(self.ComputeConfigurationName(config))
-# Open a configuration resource by giving configuration and resource names
-def OpenConfigurationResourceEditing(self, config, resource):
-return self.OpenElementEditing(self.ComputeConfigurationResourceName(config, resource))
-# Return if pou given by name is opened
-def IsPouEditing(self, pou):
-return self.ComputePouName(pou) in self.ElementsOpened
-# Return if pou transition given by pou and transition names is opened
-def IsPouTransitionEditing(self, pou, transition):
-return self.ComputePouTransitionName(pou, transition) in self.ElementsOpened
-# Return if pou action given by pou and action names is opened
-def IsPouActionEditing(self, pou, action):
-return self.ComputePouActionName(pou, action) in self.ElementsOpened
-# Return if pou action given by configuration name is opened
-def IsConfigurationEditing(self, config):
-return self.ComputeConfigurationName(config) in self.ElementsOpened
-# Return if pou action given by configuration and resource names is opened
-def IsConfigurationResourceEditing(self, config, resource):
-return self.ComputeConfigurationResourceName(config, resource) in self.ElementsOpened
-# Close current element editing
-def CloseElementEditing(self):
-# Remove pou from list of pou opened
-self.ElementsOpened.pop(self.CurrentElementEditing)
-# Update index of current element editing
-if len(self.ElementsOpened) > 0:
-self.CurrentElementEditing = min(self.CurrentElementEditing, len(self.ElementsOpened) - 1)
-else:
-self.CurrentElementEditing = None
-# Close current element editing
-def CloseAllElements(self):
-# Clear the pou opened list
-self.ElementsOpened = []
-self.CurrentElementEditing = None
-# Change current element editing for pou given by name
-def ChangeElementEditing(self, name):
-# Verify that element is opened
-if name in self.ElementsOpened:
-# Change current element editing
-self.CurrentElementEditing = self.ElementsOpened.index(name)
-return self.CurrentElementEditing
-return None
-# Change current element editing for pou given by pou name
-def ChangePouEditing(self, pou):
-return self.ChangeElementEditing(self.ComputePouName(pou))
-# Change current element editing for transition given by pou and transition names
-def ChangePouTransitionEditing(self, pou, transition):
-return self.ChangeElementEditing(self.ComputePouTransitionName(pou, transition))
-# Change current element editing for action given by pou and action names
-def ChangePouActionEditing(self, pou, action):
-return self.ChangeElementEditing(self.ComputePouActionName(pou, action))
-# Change current element editing for configuration given by configuration name
-def ChangeConfigurationEditing(self, config):
-return self.ChangeElementEditing(self.ComputeConfigurationName(config))
-# Change current element editing for resource given by configuration and resource names
-def ChangeConfigurationResourceEditing(self, config, resource):
-return self.ChangeElementEditing(self.ComputeConfigurationResourceName(config, resource))
 #-------------------------------------------------------------------------------
 #                       Project opened Pous management functions
 #-------------------------------------------------------------------------------
-# Return current pou editing
+# Return edited element
-def GetCurrentElementEditing(self):
+def GetEditedElement(self, tagname):
-# Verify that there's one editing and return it
+words = tagname.split("::")
-if self.CurrentElementEditing != None:
+if words[0] == "P":
-name = self.ElementsOpened[self.CurrentElementEditing]
+return self.Project.getPou(words[1])
-words = name.split("::")
+if words[0] in ['T', 'A']:
-if words[0] == "P":
+pou = self.Project.getPou(words[1])
-return self.Project.getPou(words[1])
+if words[0] == 'T':
-if words[0] in ['T', 'A']:
+return pou.getTransition(words[2])
-pou = self.Project.getPou(words[1])
+elif words[0] == 'A':
-if words[0] == 'T':
+return pou.getAction(words[2])
-return pou.getTransition(words[2])
+elif words[0] == 'C':
-elif words[0] == 'A':
+return self.Project.getConfiguration(words[1])
-return pou.getAction(words[2])
+elif words[0] == 'R':
-elif words[0] == 'C':
+return self.Project.getConfigurationResource(words[1], words[2])
-return self.Project.getConfiguration(words[1])
-elif words[0] == 'R':
-return self.Project.getConfigurationResource(words[1], words[2])
 return None
-# Return current pou editing name
+# Return edited element name
-def GetCurrentElementEditingName(self):
+def GetEditedElementName(self, tagname):
-# Verify that there's one editing and return its name
+words = tagname.split("::")
-if self.CurrentElementEditing != None:
+if words[0] in ["P","C"]:
-name = self.ElementsOpened[self.CurrentElementEditing]
+return words[1]
-words = name.split("::")
+else:
-if words[0] in ["P","C"]:
+return words[2]
-return words[1]
+return None
+# Return edited element name and type
+def GetEditedElementType(self, tagname):
+words = tagname.split("::")
+if words[0] in ["P","T","A"]:
+return words[1], self.GetPouType(words[1])
+return None, None
+# Return language in which edited element is written
+def GetEditedElementBodyType(self, tagname):
+words = tagname.split("::")
+if words[0] == "P":
+return self.GetPouBodyType(words[1])
+elif words[0] == 'T':
+return self.GetTransitionBodyType(words[1], words[2])
+elif words[0] == 'A':
+return self.GetActionBodyType(words[1], words[2])
+return None
+# Return the edited element variables
+def GetEditedElementInterfaceVars(self, tagname):
+words = tagname.split("::")
+if words[0] in ["P","T","A"]:
+pou = self.Project.getPou(words[1])
+return self.GetPouInterfaceVars(pou)
+return []
+# Return the edited element return type
+def GetEditedElementInterfaceReturnType(self, tagname):
+words = tagname.split("::")
+if words[0] == "P":
+pou = self.Project.getPou(words[1])
+return self.GetPouInterfaceReturnType(pou)
+elif words[0] == 'T':
+return "BOOL"
+return None
+# Change the edited element taxt
+def SetEditedElementText(self, tagname, text):
+element = self.GetEditedElement(tagname)
+if element != None:
+element.setText(text)
+self.RefreshPouUsingTree()
+# Return the edited element text
+def GetEditedElementText(self, tagname):
+element = self.GetEditedElement(tagname)
+if element != None:
+return element.getText()
+return ""
+# Return the edited element transitions
+def GetEditedElementTransitions(self, tagname):
+pou = self.GetEditedElement(tagname)
+if pou != None and pou.getBodyType() == "SFC":
+transitions = []
+for transition in pou.getTransitionList():
+transitions.append(transition.getName())
+return transitions
+return []
+# Return edited element transitions
+def GetEditedElementActions(self, tagname):
+pou = self.GetEditedElement(tagname)
+if pou != None and pou.getBodyType() == "SFC":
+actions = []
+for action in pou.getActionList():
+actions.append(action.getName())
+return actions
+return []
+# Return the names of the pou elements
+def GetEditedElementVariables(self, tagname):
+words = tagname.split("::")
+if words[0] in ["P","T","A"]:
+return self.GetProjectPouVariables(words[1])
+return []
+# Return the current pou editing informations
+def GetEditedElementInstanceInfos(self, tagname, id = None, exclude = []):
+infos = {}
+instance = None
+element = self.GetEditedElement(tagname)
+if element is not None:
+# if id is defined
+if id is not None:
+instance = element.getInstance(id)
 else:
-return words[2]
+instance = element.getRandomInstance(exclude)
-return None
+if instance is not None:
+if id is not None:
-# Replace the index of current pou editing by the one given
-def RefreshCurrentElementEditing(self, index):
-self.CurrentElementEditing = index
-# Return current pou editing name and type
-def GetCurrentElementEditingType(self):
-if self.CurrentElementEditing != None:
-name = self.ElementsOpened[self.CurrentElementEditing]
-words = name.split("::")
-if words[0] in ["P","T","A"]:
-return words[1], self.GetPouType(words[1])
-return None, None
-# Return language in which current pou editing is written
-def GetCurrentElementEditingBodyType(self):
-if self.CurrentElementEditing != None:
-name = self.ElementsOpened[self.CurrentElementEditing]
-words = name.split("::")
-if words[0] == "P":
-return self.GetPouBodyType(words[1])
-elif words[0] == 'T':
-return self.GetTransitionBodyType(words[1], words[2])
-elif words[0] == 'A':
-return self.GetActionBodyType(words[1], words[2])
-return None
-# Return the variables of the current pou editing
-def GetCurrentElementEditingInterfaceVars(self):
-if self.CurrentElementEditing != None:
-current_name = self.ElementsOpened[self.CurrentElementEditing]
-words = current_name.split("::")
-if words[0] in ["P","T","A"]:
-pou = self.Project.getPou(words[1])
-return self.GetPouInterfaceVars(pou)
-return []
-# Return the return type of the current pou editing
-def GetCurrentElementEditingInterfaceReturnType(self):
-if self.CurrentElementEditing != None:
-current_name = self.ElementsOpened[self.CurrentElementEditing]
-words = current_name.split("::")
-if words[0] == "P":
-pou = self.Project.getPou(words[1])
-return self.GetPouInterfaceReturnType(pou)
-elif words[0] == 'T':
-return "BOOL"
-return None
-# Change the text of the current pou editing
-def SetCurrentElementEditingText(self, text):
-if self.CurrentElementEditing != None:
-self.GetCurrentElementEditing().setText(text)
-self.RefreshPouUsingTree()
-# Return the current pou editing text
-def GetCurrentElementEditingText(self):
-if self.CurrentElementEditing != None:
-return self.GetCurrentElementEditing().getText()
-return ""
-# Return the current pou editing transitions
-def GetCurrentElementEditingTransitions(self):
-if self.CurrentElementEditing != None:
-pou = self.GetCurrentElementEditing()
-if pou.getBodyType() == "SFC":
-transitions = []
-for transition in pou.getTransitionList():
-transitions.append(transition.getName())
-return transitions
-return []
-# Return the current pou editing transitions
-def GetCurrentElementEditingActions(self):
-if self.CurrentElementEditing != None:
-pou = self.GetCurrentElementEditing()
-if pou.getBodyType() == "SFC":
-actions = []
-for action in pou.getActionList():
-actions.append(action.getName())
-return actions
-return []
-# Return the names of the pou elements
-def GetCurrentElementEditingVariables(self):
-if self.CurrentElementEditing != None:
-current_name = self.ElementsOpened[self.CurrentElementEditing]
-words = current_name.split("::")
-if words[0] in ["P","T","A"]:
-return self.GetProjectPouVariables(words[1])
-return []
-# Return the current pou editing informations
-def GetCurrentElementEditingInstanceInfos(self, id = None, exclude = []):
-infos = {}
-# if id is defined
-if id != None:
-instance = self.GetCurrentElementEditing().getInstance(id)
-else:
-instance = self.GetCurrentElementEditing().getRandomInstance(exclude)
-if instance:
-if id != None:
 infos["id"] = id
 else:
 infos["id"] = instance.getLocalId()
 infos["x"] = instance.getX()
 infos["y"] = instance.getY()
 connector["negated"] = variable.getNegated()
 connector["edge"] = variable.getConnectorEdge()
 infos["connectors"]["outputs"].append(connector)
 elif isinstance(instance, plcopen.inVariable):
 infos["name"] = instance.getExpression()
-infos["value_type"] = self.GetCurrentPouVarValueType(infos["name"])
+infos["value_type"] = self.GetEditedElementVarValueType(tagname, infos["name"])
 infos["type"] = "input"
 executionOrder = instance.getExecutionOrderId()
 if executionOrder is not None:
 infos["executionOrder"] = executionOrder
 else:
 infos["connector"]["position"] = instance.connectionPointOut.getRelPosition()
 infos["connector"]["negated"] = instance.getNegated()
 infos["connector"]["edge"] = instance.getConnectorEdge()
 elif isinstance(instance, plcopen.outVariable):
 infos["name"] = instance.getExpression()
-infos["value_type"] = self.GetCurrentPouVarValueType(infos["name"])
+infos["value_type"] = self.GetEditedElementVarValueType(tagname, infos["name"])
 infos["type"] = "output"
 executionOrder = instance.getExecutionOrderId()
 if executionOrder is not None:
 infos["executionOrder"] = executionOrder
 else:
 for link in connections:
 dic = {"refLocalId":link.getRefLocalId(),"points":link.getPoints(),"formalParameter":link.getFormalParameter()}
 infos["connector"]["links"].append(dic)
 elif isinstance(instance, plcopen.inOutVariable):
 infos["name"] = instance.getExpression()
-infos["value_type"] = self.GetCurrentPouVarValueType(infos["name"])
+infos["value_type"] = self.GetEditedElementVarValueType(tagname, infos["name"])
 infos["type"] = "inout"
 executionOrder = instance.getExecutionOrderId()
 if executionOrder is not None:
 infos["executionOrder"] = executionOrder
 else:
 dic = {"refLocalId":link.getRefLocalId(),"points":link.getPoints(),"formalParameter":link.getFormalParameter()}
 infos["connector"]["links"].append(dic)
 return infos
 return False
-def ClearCurrentExecutionOrder(self):
+def ClearEditedElementExecutionOrder(self, tagname):
-self.GetCurrentElementEditing().resetExecutionOrder()
+element = self.GetEditedElement(tagname)
+if element is not None:
-def ResetCurrentExecutionOrder(self):
+element.resetExecutionOrder()
-self.GetCurrentElementEditing().compileExecutionOrder()
+def ResetEditedElementExecutionOrder(self, tagname):
+element = self.GetEditedElement(tagname)
+if element is not None:
+element.compileExecutionOrder()
 # Return the variable type of the given pou
-def GetCurrentPouVarValueType(self, varname):
+def GetEditedElementVarValueType(self, tagname, varname):
-current_name = self.ElementsOpened[self.CurrentElementEditing]
+words = tagname.split("::")
-words = current_name.split("::")
 if words[0] in ["P","T","A"]:
 pou = self.Project.getPou(words[1])
 for type, varlist in pou.getVars():
 for var in varlist.getVariable():
 if var.getName() == varname:
 connection.setConnectionParameter(idx, formalParameter)
 else:
 connection.setConnectionParameter(idx, None)
 idx += 1
-def AddCurrentElementEditingBlock(self, id, blocktype, blockname = None):
+def AddEditedElementBlock(self, tagname, id, blocktype, blockname = None):
-block = plcopen.block()
+element = self.GetEditedElement(tagname)
-block.setLocalId(id)
+if element is not None:
-block.setTypeName(blocktype)
+block = plcopen.block()
-if blockname:
+block.setLocalId(id)
-block.setInstanceName(blockname)
+block.setTypeName(blocktype)
-element = self.GetCurrentElementEditing()
+blocktype_infos = GetBlockType(blocktype)
-blocktype_infos = GetBlockType(blocktype)
+if blocktype_infos["type"] != "function" and blockname is not None:
-if blocktype_infos["type"] != "function":
+block.setInstanceName(blockname)
-if self.CurrentElementEditing != None:
+element.addPouVar(blocktype, blockname)
-name = self.ElementsOpened[self.CurrentElementEditing]
+element.addInstance("block", block)
-words = name.split("::")
+self.RefreshPouUsingTree()
-if words[0] in ["P","T","A"]:
-pou = self.Project.getPou(words[1])
+def SetEditedElementBlockInfos(self, tagname, id, infos):
-pou.addPouVar(blocktype, blockname)
+element = self.GetEditedElement(tagname)
-element.addInstance("block", block)
+if element is not None:
-self.RefreshPouUsingTree()
+block = element.getInstance(id)
+if "name" in infos or "type" in infos:
-def SetCurrentElementEditingBlockInfos(self, id, infos):
+old_name = block.getInstanceName()
-block = self.GetCurrentElementEditing().getInstance(id)
+old_type = block.getTypeName()
-if "name" in infos or "type" in infos:
+new_name = infos.get("name", old_name)
-old_name = block.getInstanceName()
+new_type = infos.get("type", old_type)
-old_type = block.getTypeName()
+self.GetEditedElement(tagname).changePouVar(old_type, old_name, new_type, new_name)
-new_name = infos.get("name", old_name)
+for param, value in infos.items():
-new_type = infos.get("type", old_type)
+if param == "name":
-self.GetCurrentElementEditing().changePouVar(old_type, old_name, new_type, new_name)
+block.setInstanceName(value)
-for param, value in infos.items():
+elif param == "type":
-if param == "name":
+block.setTypeName(value)
-block.setInstanceName(value)
+elif param == "executionOrder" and block.getExecutionOrderId() != value:
-elif param == "type":
+self.GetEditedElement(tagname).setElementExecutionOrder(block, value)
-block.setTypeName(value)
+elif param == "height":
-elif param == "executionOrder" and block.getExecutionOrderId() != value:
+block.setHeight(value)
-self.GetCurrentElementEditing().setElementExecutionOrder(block, value)
+elif param == "width":
-elif param == "height":
+block.setWidth(value)
-block.setHeight(value)
+elif param == "x":
-elif param == "width":
+block.setX(value)
-block.setWidth(value)
+elif param == "y":
-elif param == "x":
+block.setY(value)
-block.setX(value)
+elif param == "connectors":
-elif param == "y":
+block.inputVariables.setVariable([])
-block.setY(value)
+block.outputVariables.setVariable([])
-elif param == "connectors":
+for connector in value["inputs"]:
-block.inputVariables.setVariable([])
+variable = plcopen.inputVariables_variable()
-block.outputVariables.setVariable([])
+variable.setFormalParameter(connector.GetName())
-for connector in value["inputs"]:
+if connector.IsNegated():
-variable = plcopen.inputVariables_variable()
+variable.setNegated(True)
-variable.setFormalParameter(connector.GetName())
+if connector.GetEdge() != "none":
-if connector.IsNegated():
+variable.setConnectorEdge(connector.GetEdge())
-variable.setNegated(True)
+position = connector.GetRelPosition()
-if connector.GetEdge() != "none":
+variable.connectionPointIn.setRelPosition(position.x, position.y)
-variable.setConnectorEdge(connector.GetEdge())
+self.SetConnectionWires(variable.connectionPointIn, connector)
-position = connector.GetRelPosition()
+block.inputVariables.appendVariable(variable)
-variable.connectionPointIn.setRelPosition(position.x, position.y)
+for connector in value["outputs"]:
-self.SetConnectionWires(variable.connectionPointIn, connector)
+variable = plcopen.outputVariables_variable()
-block.inputVariables.appendVariable(variable)
+variable.setFormalParameter(connector.GetName())
-for connector in value["outputs"]:
+if connector.IsNegated():
-variable = plcopen.outputVariables_variable()
+variable.setNegated(True)
-variable.setFormalParameter(connector.GetName())
+if connector.GetEdge() != "none":
-if connector.IsNegated():
+variable.setConnectorEdge(connector.GetEdge())
-variable.setNegated(True)
+position = connector.GetRelPosition()
-if connector.GetEdge() != "none":
+variable.addConnectionPointOut()
-variable.setConnectorEdge(connector.GetEdge())
+variable.connectionPointOut.setRelPosition(position.x, position.y)
-position = connector.GetRelPosition()
+block.outputVariables.appendVariable(variable)
-variable.addConnectionPointOut()
+self.RefreshPouUsingTree()
-variable.connectionPointOut.setRelPosition(position.x, position.y)
-block.outputVariables.appendVariable(variable)
-self.RefreshPouUsingTree()
-def AddCurrentElementEditingVariable(self, id, type):
+def AddEditedElementVariable(self, tagname, id, type):
-if type == INPUT:
+element = self.GetEditedElement(tagname)
-name = "inVariable"
+if element is not None:
-variable = plcopen.inVariable()
+if type == INPUT:
-elif type == OUTPUT:
+name = "inVariable"
-name = "outVariable"
+variable = plcopen.inVariable()
-variable = plcopen.outVariable()
+elif type == OUTPUT:
-elif type == INOUT:
+name = "outVariable"
-name = "inOutVariable"
+variable = plcopen.outVariable()
-variable = plcopen.inOutVariable()
+elif type == INOUT:
-variable.setLocalId(id)
+name = "inOutVariable"
-self.GetCurrentElementEditing().addInstance(name, variable)
+variable = plcopen.inOutVariable()
+variable.setLocalId(id)
+element.addInstance(name, variable)
-def SetCurrentElementEditingVariableInfos(self, id, infos):
+def SetEditedElementVariableInfos(self, tagname, id, infos):
-variable = self.GetCurrentElementEditing().getInstance(id)
+element = self.GetEditedElement(tagname)
-for param, value in infos.items():
+if element is not None:
-if param == "name":
+variable = element.getInstance(id)
-variable.setExpression(value)
+for param, value in infos.items():
-elif param == "executionOrder" and variable.getExecutionOrderId() != value:
+if param == "name":
-self.GetCurrentElementEditing().setElementExecutionOrder(variable, value)
+variable.setExpression(value)
-elif param == "height":
+elif param == "executionOrder" and variable.getExecutionOrderId() != value:
-variable.setHeight(value)
+self.GetEditedElement(tagname).setElementExecutionOrder(variable, value)
-elif param == "width":
+elif param == "height":
-variable.setWidth(value)
+variable.setHeight(value)
-elif param == "x":
+elif param == "width":
-variable.setX(value)
+variable.setWidth(value)
-elif param == "y":
+elif param == "x":
-variable.setY(value)
+variable.setX(value)
-elif param == "connectors":
+elif param == "y":
-if isinstance(variable, plcopen.inVariable):
+variable.setY(value)
-if value["output"].IsNegated():
+elif param == "connectors":
-variable.setNegated(True)
+if isinstance(variable, plcopen.inVariable):
-if value["output"].GetEdge() != "none":
+if value["output"].IsNegated():
-variable.setConnectorEdge(value["output"].GetEdge())
+variable.setNegated(True)
-position = value["output"].GetRelPosition()
+if value["output"].GetEdge() != "none":
-variable.addConnectionPointOut()
+variable.setConnectorEdge(value["output"].GetEdge())
-variable.connectionPointOut.setRelPosition(position.x, position.y)
+position = value["output"].GetRelPosition()
-elif isinstance(variable, plcopen.outVariable):
+variable.addConnectionPointOut()
-if value["input"].IsNegated():
+variable.connectionPointOut.setRelPosition(position.x, position.y)
-variable.setNegated(True)
+elif isinstance(variable, plcopen.outVariable):
-if value["input"].GetEdge() != "none":
+if value["input"].IsNegated():
-variable.setConnectorEdge(value["input"].GetEdge())
+variable.setNegated(True)
-position = value["input"].GetRelPosition()
+if value["input"].GetEdge() != "none":
-variable.addConnectionPointIn()
+variable.setConnectorEdge(value["input"].GetEdge())
-variable.connectionPointIn.setRelPosition(position.x, position.y)
+position = value["input"].GetRelPosition()
-self.SetConnectionWires(variable.connectionPointIn, value["input"])
+variable.addConnectionPointIn()
-elif isinstance(variable, plcopen.inOutVariable):
+variable.connectionPointIn.setRelPosition(position.x, position.y)
-if value["input"].IsNegated():
+self.SetConnectionWires(variable.connectionPointIn, value["input"])
-variable.setNegatedIn(True)
+elif isinstance(variable, plcopen.inOutVariable):
-if value["input"].GetEdge() != "none":
+if value["input"].IsNegated():
-variable.setInputEdge(value["input"].GetEdge())
+variable.setNegatedIn(True)
-if value["output"].IsNegated():
+if value["input"].GetEdge() != "none":
-variable.setNegatedOut(True)
+variable.setInputEdge(value["input"].GetEdge())
-if value["output"].GetEdge() != "none":
+if value["output"].IsNegated():
-variable.setOutputEdge(value["output"].GetEdge())
+variable.setNegatedOut(True)
-position = value["output"].GetRelPosition()
+if value["output"].GetEdge() != "none":
-variable.addConnectionPointOut()
+variable.setOutputEdge(value["output"].GetEdge())
-variable.connectionPointOut.setRelPosition(position.x, position.y)
+position = value["output"].GetRelPosition()
-position = value["input"].GetRelPosition()
+variable.addConnectionPointOut()
-variable.addConnectionPointIn()
+variable.connectionPointOut.setRelPosition(position.x, position.y)
-variable.connectionPointIn.setRelPosition(position.x, position.y)
+position = value["input"].GetRelPosition()
-self.SetConnectionWires(variable.connectionPointIn, value["input"])
+variable.addConnectionPointIn()
+variable.connectionPointIn.setRelPosition(position.x, position.y)
+self.SetConnectionWires(variable.connectionPointIn, value["input"])
-def AddCurrentElementEditingConnection(self, id, type):
-if type == CONNECTOR:
+def AddEditedElementConnection(self, tagname, id, type):
-name = "connector"
+element = self.GetEditedElement(tagname)
-connection = plcopen.connector()
+if element is not None:
-elif type == CONTINUATION:
+if type == CONNECTOR:
-name = "continuation"
+name = "connector"
-connection = plcopen.continuation()
+connection = plcopen.connector()
-connection.setLocalId(id)
+elif type == CONTINUATION:
-self.GetCurrentElementEditing().addInstance(name, connection)
+name = "continuation"
+connection = plcopen.continuation()
+connection.setLocalId(id)
+element.addInstance(name, connection)
-def SetCurrentElementEditingConnectionInfos(self, id, infos):
+def SetEditedElementConnectionInfos(self, tagname, id, infos):
-connection = self.GetCurrentElementEditing().getInstance(id)
+element = self.GetEditedElement(tagname)
-for param, value in infos.items():
+if element is not None:
-if param == "name":
+connection = element.getInstance(id)
-connection.setName(value)
+for param, value in infos.items():
-elif param == "height":
+if param == "name":
-connection.setHeight(value)
+connection.setName(value)
-elif param == "width":
+elif param == "height":
-connection.setWidth(value)
+connection.setHeight(value)
-elif param == "x":
+elif param == "width":
-connection.setX(value)
+connection.setWidth(value)
-elif param == "y":
+elif param == "x":
-connection.setY(value)
+connection.setX(value)
-elif param == "connector":
+elif param == "y":
-position = value.GetRelPosition()
+connection.setY(value)
-if isinstance(connection, plcopen.continuation):
+elif param == "connector":
-connection.addConnectionPointOut()
+position = value.GetRelPosition()
-connection.connectionPointOut.setRelPosition(position.x, position.y)
+if isinstance(connection, plcopen.continuation):
-elif isinstance(connection, plcopen.connector):
+connection.addConnectionPointOut()
-connection.addConnectionPointIn()
+connection.connectionPointOut.setRelPosition(position.x, position.y)
-connection.connectionPointIn.setRelPosition(position.x, position.y)
+elif isinstance(connection, plcopen.connector):
-self.SetConnectionWires(connection.connectionPointIn, value)
+connection.addConnectionPointIn()
+connection.connectionPointIn.setRelPosition(position.x, position.y)
-def AddCurrentElementEditingComment(self, id):
+self.SetConnectionWires(connection.connectionPointIn, value)
-comment = plcopen.comment()
-comment.setLocalId(id)
+def AddEditedElementComment(self, tagname, id):
-self.GetCurrentElementEditing().addInstance("comment", comment)
+element = self.GetEditedElement(tagname)
+if element is not None:
-def SetCurrentElementEditingCommentInfos(self, id, infos):
+comment = plcopen.comment()
-comment = self.GetCurrentElementEditing().getInstance(id)
+comment.setLocalId(id)
-for param, value in infos.items():
+element.addInstance("comment", comment)
-if param == "content":
-comment.setContentText(value)
+def SetEditedElementCommentInfos(self, tagname, id, infos):
-elif param == "height":
+element = self.GetEditedElement(tagname)
-comment.setHeight(value)
+if element is not None:
-elif param == "width":
+comment = element.getInstance(id)
-comment.setWidth(value)
+for param, value in infos.items():
-elif param == "x":
+if param == "content":
-comment.setX(value)
+comment.setContentText(value)
-elif param == "y":
+elif param == "height":
-comment.setY(value)
+comment.setHeight(value)
+elif param == "width":
-def AddCurrentElementEditingPowerRail(self, id, type):
+comment.setWidth(value)
-if type == LEFTRAIL:
+elif param == "x":
-name = "leftPowerRail"
+comment.setX(value)
-powerrail = plcopen.leftPowerRail()
+elif param == "y":
-elif type == RIGHTRAIL:
+comment.setY(value)
-name = "rightPowerRail"
-powerrail = plcopen.rightPowerRail()
+def AddEditedElementPowerRail(self, tagname, id, type):
-powerrail.setLocalId(id)
+element = self.GetEditedElement(tagname)
-self.GetCurrentElementEditing().addInstance(name, powerrail)
+if element is not None:
+if type == LEFTRAIL:
-def SetCurrentElementEditingPowerRailInfos(self, id, infos):
+name = "leftPowerRail"
-powerrail = self.GetCurrentElementEditing().getInstance(id)
+powerrail = plcopen.leftPowerRail()
-for param, value in infos.items():
+elif type == RIGHTRAIL:
-if param == "height":
+name = "rightPowerRail"
-powerrail.setHeight(value)
+powerrail = plcopen.rightPowerRail()
-elif param == "width":
+powerrail.setLocalId(id)
-powerrail.setWidth(value)
+element.addInstance(name, powerrail)
-elif param == "x":
-powerrail.setX(value)
+def SetEditedElementPowerRailInfos(self, tagname, id, infos):
-elif param == "y":
+element = self.GetEditedElement(tagname)
-powerrail.setY(value)
+if element is not None:
-elif param == "connectors":
+powerrail = element.getInstance(id)
-if isinstance(powerrail, plcopen.leftPowerRail):
+for param, value in infos.items():
-powerrail.setConnectionPointOut([])
+if param == "height":
-for connector in value:
+powerrail.setHeight(value)
-position = connector.GetRelPosition()
+elif param == "width":
-connection = plcopen.leftPowerRail_connectionPointOut()
+powerrail.setWidth(value)
-connection.setRelPosition(position.x, position.y)
+elif param == "x":
-powerrail.connectionPointOut.append(connection)
+powerrail.setX(value)
-elif isinstance(powerrail, plcopen.rightPowerRail):
+elif param == "y":
-powerrail.setConnectionPointIn([])
+powerrail.setY(value)
-for connector in value:
+elif param == "connectors":
-position = connector.GetRelPosition()
+if isinstance(powerrail, plcopen.leftPowerRail):
-connection = plcopen.connectionPointIn()
+powerrail.setConnectionPointOut([])
-connection.setRelPosition(position.x, position.y)
+for connector in value:
-self.SetConnectionWires(connection, connector)
+position = connector.GetRelPosition()
-powerrail.connectionPointIn.append(connection)
+connection = plcopen.leftPowerRail_connectionPointOut()
+connection.setRelPosition(position.x, position.y)
-def AddCurrentElementEditingContact(self, id):
+powerrail.connectionPointOut.append(connection)
-contact = plcopen.contact()
+elif isinstance(powerrail, plcopen.rightPowerRail):
-contact.setLocalId(id)
+powerrail.setConnectionPointIn([])
-self.GetCurrentElementEditing().addInstance("contact", contact)
+for connector in value:
+position = connector.GetRelPosition()
-def SetCurrentElementEditingContactInfos(self, id, infos):
+connection = plcopen.connectionPointIn()
-contact = self.GetCurrentElementEditing().getInstance(id)
+connection.setRelPosition(position.x, position.y)
-for param, value in infos.items():
+self.SetConnectionWires(connection, connector)
-if param == "name":
+powerrail.connectionPointIn.append(connection)
-contact.setVariable(value)
-elif param == "type":
+def AddEditedElementEditingContact(self, tagname, id):
-if value == CONTACT_NORMAL:
+element = self.GetEditedElement(tagname)
-contact.setNegated(False)
+if element is not None:
-contact.setContactEdge("none")
+contact = plcopen.contact()
-elif value == CONTACT_REVERSE:
+contact.setLocalId(id)
-contact.setNegated(True)
+element.addInstance("contact", contact)
-contact.setContactEdge("none")
-elif value == CONTACT_RISING:
+def SetEditedElementContactInfos(self, tagname, id, infos):
-contact.setNegated(False)
+element = self.GetEditedElement(tagname)
-contact.setContactEdge("rising")
+if element is not None:
-elif value == CONTACT_FALLING:
+contact = element.getInstance(id)
-contact.setNegated(False)
+for param, value in infos.items():
-contact.setContactEdge("falling")
+if param == "name":
-elif param == "height":
+contact.setVariable(value)
-contact.setHeight(value)
+elif param == "type":
-elif param == "width":
+if value == CONTACT_NORMAL:
-contact.setWidth(value)
+contact.setNegated(False)
-elif param == "x":
+contact.setContactEdge("none")
-contact.setX(value)
+elif value == CONTACT_REVERSE:
-elif param == "y":
+contact.setNegated(True)
-contact.setY(value)
+contact.setContactEdge("none")
-elif param == "connectors":
+elif value == CONTACT_RISING:
-input_connector = value["input"]
+contact.setNegated(False)
-position = input_connector.GetRelPosition()
+contact.setContactEdge("rising")
-contact.addConnectionPointIn()
+elif value == CONTACT_FALLING:
-contact.connectionPointIn.setRelPosition(position.x, position.y)
+contact.setNegated(False)
-self.SetConnectionWires(contact.connectionPointIn, input_connector)
+contact.setContactEdge("falling")
-output_connector = value["output"]
+elif param == "height":
-position = output_connector.GetRelPosition()
+contact.setHeight(value)
-contact.addConnectionPointOut()
+elif param == "width":
-contact.connectionPointOut.setRelPosition(position.x, position.y)
+contact.setWidth(value)
+elif param == "x":
-def AddCurrentElementEditingCoil(self, id):
+contact.setX(value)
-coil = plcopen.coil()
+elif param == "y":
-coil.setLocalId(id)
+contact.setY(value)
-self.GetCurrentElementEditing().addInstance("coil", coil)
+elif param == "connectors":
+input_connector = value["input"]
-def SetCurrentElementEditingCoilInfos(self, id, infos):
-coil = self.GetCurrentElementEditing().getInstance(id)
-for param, value in infos.items():
-if param == "name":
-coil.setVariable(value)
-elif param == "type":
-if value == COIL_NORMAL:
-coil.setNegated(False)
-coil.setCoilStorage("none")
-elif value == COIL_REVERSE:
-coil.setNegated(True)
-coil.setCoilStorage("none")
-elif value == COIL_SET:
-coil.setNegated(False)
-coil.setCoilStorage("set")
-elif value == COIL_RESET:
-coil.setNegated(False)
-coil.setCoilStorage("reset")
-elif param == "height":
-coil.setHeight(value)
-elif param == "width":
-coil.setWidth(value)
-elif param == "x":
-coil.setX(value)
-elif param == "y":
-coil.setY(value)
-elif param == "connectors":
-input_connector = value["input"]
-position = input_connector.GetRelPosition()
-coil.addConnectionPointIn()
-coil.connectionPointIn.setRelPosition(position.x, position.y)
-self.SetConnectionWires(coil.connectionPointIn, input_connector)
-output_connector = value["output"]
-position = output_connector.GetRelPosition()
-coil.addConnectionPointOut()
-coil.connectionPointOut.setRelPosition(position.x, position.y)
-def AddCurrentElementEditingStep(self, id):
-step = plcopen.step()
-step.setLocalId(id)
-self.GetCurrentElementEditing().addInstance("step", step)
-def SetCurrentElementEditingStepInfos(self, id, infos):
-step = self.GetCurrentElementEditing().getInstance(id)
-for param, value in infos.items():
-if param == "name":
-step.setName(value)
-elif param == "initial":
-step.setInitialStep(value)
-elif param == "height":
-step.setHeight(value)
-elif param == "width":
-step.setWidth(value)
-elif param == "x":
-step.setX(value)
-elif param == "y":
-step.setY(value)
-elif param == "connectors":
-input_connector = value["input"]
-if input_connector:
 position = input_connector.GetRelPosition()
-step.addConnectionPointIn()
+contact.addConnectionPointIn()
-step.connectionPointIn.setRelPosition(position.x, position.y)
+contact.connectionPointIn.setRelPosition(position.x, position.y)
-self.SetConnectionWires(step.connectionPointIn, input_connector)
+self.SetConnectionWires(contact.connectionPointIn, input_connector)
-else:
+output_connector = value["output"]
-step.deleteConnectionPointIn()
-output_connector = value["output"]
-if output_connector:
 position = output_connector.GetRelPosition()
-step.addConnectionPointOut()
+contact.addConnectionPointOut()
-step.connectionPointOut.setRelPosition(position.x, position.y)
+contact.connectionPointOut.setRelPosition(position.x, position.y)
-else:
-step.deleteConnectionPointOut()
+def AddEditedElementCoil(self, tagname, id):
-action_connector = value["action"]
+element = self.GetEditedElement(tagname)
-if action_connector:
+if element is not None:
-position = action_connector.GetRelPosition()
+coil = plcopen.coil()
-step.addConnectionPointOutAction()
+coil.setLocalId(id)
-step.connectionPointOutAction.setRelPosition(position.x, position.y)
+element.addInstance("coil", coil)
-else:
-step.deleteConnectionPointOutAction()
+def SetEditedElementCoilInfos(self, tagname, id, infos):
+element = self.GetEditedElement(tagname)
-def AddCurrentElementEditingTransition(self, id):
+if element is not None:
-transition = plcopen.transition()
+coil = element.getInstance(id)
-transition.setLocalId(id)
+for param, value in infos.items():
-self.GetCurrentElementEditing().addInstance("transition", transition)
+if param == "name":
+coil.setVariable(value)
-def SetCurrentElementEditingTransitionInfos(self, id, infos):
+elif param == "type":
-transition = self.GetCurrentElementEditing().getInstance(id)
+if value == COIL_NORMAL:
-for param, value in infos.items():
+coil.setNegated(False)
-if param == "type" and value != "connection":
+coil.setCoilStorage("none")
-transition.setConditionContent(value, infos["condition"])
+elif value == COIL_REVERSE:
-elif param == "height":
+coil.setNegated(True)
-transition.setHeight(value)
+coil.setCoilStorage("none")
-elif param == "width":
+elif value == COIL_SET:
-transition.setWidth(value)
+coil.setNegated(False)
-elif param == "x":
+coil.setCoilStorage("set")
-transition.setX(value)
+elif value == COIL_RESET:
-elif param == "y":
+coil.setNegated(False)
-transition.setY(value)
+coil.setCoilStorage("reset")
-elif param == "priority":
+elif param == "height":
-if value != 0:
+coil.setHeight(value)
-transition.setPriority(value)
+elif param == "width":
-else:
+coil.setWidth(value)
-transition.setPriority(None)
+elif param == "x":
-elif param == "connectors":
+coil.setX(value)
-input_connector = value["input"]
+elif param == "y":
-position = input_connector.GetRelPosition()
+coil.setY(value)
-transition.addConnectionPointIn()
+elif param == "connectors":
-transition.connectionPointIn.setRelPosition(position.x, position.y)
+input_connector = value["input"]
-self.SetConnectionWires(transition.connectionPointIn, input_connector)
+position = input_connector.GetRelPosition()
-output_connector = value["output"]
+coil.addConnectionPointIn()
-position = output_connector.GetRelPosition()
+coil.connectionPointIn.setRelPosition(position.x, position.y)
-transition.addConnectionPointOut()
+self.SetConnectionWires(coil.connectionPointIn, input_connector)
-transition.connectionPointOut.setRelPosition(position.x, position.y)
+output_connector = value["output"]
-if infos.get("type", None) == "connection":
+position = output_connector.GetRelPosition()
-transition.setConditionContent("connection", None)
+coil.addConnectionPointOut()
-connection_connector = value["connection"]
+coil.connectionPointOut.setRelPosition(position.x, position.y)
-self.SetConnectionWires(transition, connection_connector)
+def AddEditedElementStep(self, tagname, id):
-def AddCurrentElementEditingDivergence(self, id, type):
+element = self.GetEditedElement(tagname)
-if type == SELECTION_DIVERGENCE:
+if element is not None:
-name = "selectionDivergence"
+step = plcopen.step()
-divergence = plcopen.selectionDivergence()
+step.setLocalId(id)
-elif type == SELECTION_CONVERGENCE:
+element.addInstance("step", step)
-name = "selectionConvergence"
-divergence = plcopen.selectionConvergence()
+def SetEditedElementStepInfos(self, tagname, id, infos):
-elif type == SIMULTANEOUS_DIVERGENCE:
+element = self.GetEditedElement(tagname)
-name = "simultaneousDivergence"
+if element is not None:
-divergence = plcopen.simultaneousDivergence()
+step = element.getInstance(id)
-elif type == SIMULTANEOUS_CONVERGENCE:
+for param, value in infos.items():
-name = "simultaneousConvergence"
+if param == "name":
-divergence = plcopen.simultaneousConvergence()
+step.setName(value)
-divergence.setLocalId(id)
+elif param == "initial":
-self.GetCurrentElementEditing().addInstance(name, divergence)
+step.setInitialStep(value)
+elif param == "height":
-def SetCurrentElementEditingDivergenceInfos(self, id, infos):
+step.setHeight(value)
-divergence = self.GetCurrentElementEditing().getInstance(id)
+elif param == "width":
-for param, value in infos.items():
+step.setWidth(value)
-if param == "height":
+elif param == "x":
-divergence.setHeight(value)
+step.setX(value)
-elif param == "width":
+elif param == "y":
-divergence.setWidth(value)
+step.setY(value)
-elif param == "x":
+elif param == "connectors":
-divergence.setX(value)
+input_connector = value["input"]
-elif param == "y":
+if input_connector:
-divergence.setY(value)
-elif param == "connectors":
-input_connectors = value["inputs"]
-if isinstance(divergence, (plcopen.selectionDivergence, plcopen.simultaneousDivergence)):
-position = input_connectors[0].GetRelPosition()
-divergence.addConnectionPointIn()
-divergence.connectionPointIn.setRelPosition(position.x, position.y)
-self.SetConnectionWires(divergence.connectionPointIn, input_connectors[0])
-else:
-divergence.setConnectionPointIn([])
-for input_connector in input_connectors:
 position = input_connector.GetRelPosition()
-if isinstance(divergence, plcopen.selectionConvergence):
+step.addConnectionPointIn()
-connection = plcopen.selectionConvergence_connectionPointIn()
+step.connectionPointIn.setRelPosition(position.x, position.y)
-else:
+self.SetConnectionWires(step.connectionPointIn, input_connector)
-connection = plcopen.connectionPointIn()
+else:
-connection.setRelPosition(position.x, position.y)
+step.deleteConnectionPointIn()
-self.SetConnectionWires(connection, input_connector)
+output_connector = value["output"]
-divergence.appendConnectionPointIn(connection)
+if output_connector:
-output_connectors = value["outputs"]
-if isinstance(divergence, (plcopen.selectionConvergence, plcopen.simultaneousConvergence)):
-position = output_connectors[0].GetRelPosition()
-divergence.addConnectionPointOut()
-divergence.connectionPointOut.setRelPosition(position.x, position.y)
-else:
-divergence.setConnectionPointOut([])
-for output_connector in output_connectors:
 position = output_connector.GetRelPosition()
-if isinstance(divergence, plcopen.selectionDivergence):
+step.addConnectionPointOut()
-connection = plcopen.selectionDivergence_connectionPointOut()
+step.connectionPointOut.setRelPosition(position.x, position.y)
 else:
-connection = plcopen.simultaneousDivergence_connectionPointOut()
+step.deleteConnectionPointOut()
-connection.setRelPosition(position.x, position.y)
+action_connector = value["action"]
-divergence.appendConnectionPointOut(connection)
+if action_connector:
+position = action_connector.GetRelPosition()
-def AddCurrentElementEditingJump(self, id):
+step.addConnectionPointOutAction()
-jump = plcopen.jumpStep()
+step.connectionPointOutAction.setRelPosition(position.x, position.y)
-jump.setLocalId(id)
+else:
-self.GetCurrentElementEditing().addInstance("jumpStep", jump)
+step.deleteConnectionPointOutAction()
-def SetCurrentElementEditingJumpInfos(self, id, infos):
+def AddEditedElementTransition(self, tagname, id):
-jump = self.GetCurrentElementEditing().getInstance(id)
+element = self.GetEditedElement(tagname)
-for param, value in infos.items():
+if element is not None:
-if param == "target":
+transition = plcopen.transition()
-jump.setTargetName(value)
+transition.setLocalId(id)
-elif param == "height":
+element.addInstance("transition", transition)
-jump.setHeight(value)
-elif param == "width":
+def SetEditedElementTransitionInfos(self, tagname, id, infos):
-jump.setWidth(value)
+element = self.GetEditedElement(tagname)
-elif param == "x":
+if element is not None:
-jump.setX(value)
+transition = element.getInstance(id)
-elif param == "y":
+for param, value in infos.items():
-jump.setY(value)
+if param == "type" and value != "connection":
-elif param == "connector":
+transition.setConditionContent(value, infos["condition"])
-position = value.GetRelPosition()
+elif param == "height":
-jump.addConnectionPointIn()
+transition.setHeight(value)
-jump.connectionPointIn.setRelPosition(position.x, position.y)
+elif param == "width":
-self.SetConnectionWires(jump.connectionPointIn, value)
+transition.setWidth(value)
+elif param == "x":
+transition.setX(value)
+elif param == "y":
+transition.setY(value)
+elif param == "priority":
+if value != 0:
+transition.setPriority(value)
+else:
+transition.setPriority(None)
+elif param == "connectors":
+input_connector = value["input"]
+position = input_connector.GetRelPosition()
+transition.addConnectionPointIn()
+transition.connectionPointIn.setRelPosition(position.x, position.y)
+self.SetConnectionWires(transition.connectionPointIn, input_connector)
+output_connector = value["output"]
+position = output_connector.GetRelPosition()
+transition.addConnectionPointOut()
+transition.connectionPointOut.setRelPosition(position.x, position.y)
+if infos.get("type", None) == "connection":
+transition.setConditionContent("connection", None)
+connection_connector = value["connection"]
+self.SetConnectionWires(transition, connection_connector)
+def AddEditedElementDivergence(self, tagname, id, type):
+element = self.GetEditedElement(tagname)
+if element is not None:
+if type == SELECTION_DIVERGENCE:
+name = "selectionDivergence"
+divergence = plcopen.selectionDivergence()
+elif type == SELECTION_CONVERGENCE:
+name = "selectionConvergence"
+divergence = plcopen.selectionConvergence()
+elif type == SIMULTANEOUS_DIVERGENCE:
+name = "simultaneousDivergence"
+divergence = plcopen.simultaneousDivergence()
+elif type == SIMULTANEOUS_CONVERGENCE:
+name = "simultaneousConvergence"
+divergence = plcopen.simultaneousConvergence()
+divergence.setLocalId(id)
+element.addInstance(name, divergence)
+def SetEditedElementDivergenceInfos(self, tagname, id, infos):
+element = self.GetEditedElement(tagname)
+if element is not None:
+divergence = element.getInstance(id)
+for param, value in infos.items():
+if param == "height":
+divergence.setHeight(value)
+elif param == "width":
+divergence.setWidth(value)
+elif param == "x":
+divergence.setX(value)
+elif param == "y":
+divergence.setY(value)
+elif param == "connectors":
+input_connectors = value["inputs"]
+if isinstance(divergence, (plcopen.selectionDivergence, plcopen.simultaneousDivergence)):
+position = input_connectors[0].GetRelPosition()
+divergence.addConnectionPointIn()
+divergence.connectionPointIn.setRelPosition(position.x, position.y)
+self.SetConnectionWires(divergence.connectionPointIn, input_connectors[0])
+else:
+divergence.setConnectionPointIn([])
+for input_connector in input_connectors:
+position = input_connector.GetRelPosition()
+if isinstance(divergence, plcopen.selectionConvergence):
+connection = plcopen.selectionConvergence_connectionPointIn()
+else:
+connection = plcopen.connectionPointIn()
+connection.setRelPosition(position.x, position.y)
+self.SetConnectionWires(connection, input_connector)
+divergence.appendConnectionPointIn(connection)
+output_connectors = value["outputs"]
+if isinstance(divergence, (plcopen.selectionConvergence, plcopen.simultaneousConvergence)):
+position = output_connectors[0].GetRelPosition()
+divergence.addConnectionPointOut()
+divergence.connectionPointOut.setRelPosition(position.x, position.y)
+else:
+divergence.setConnectionPointOut([])
+for output_connector in output_connectors:
+position = output_connector.GetRelPosition()
+if isinstance(divergence, plcopen.selectionDivergence):
+connection = plcopen.selectionDivergence_connectionPointOut()
+else:
+connection = plcopen.simultaneousDivergence_connectionPointOut()
+connection.setRelPosition(position.x, position.y)
+divergence.appendConnectionPointOut(connection)
+def AddEditedElementJump(self, tagname, id):
+element = self.GetEditedElement(tagname)
+if element is not None:
+jump = plcopen.jumpStep()
+jump.setLocalId(id)
+element.addInstance("jumpStep", jump)
+def SetEditedElementJumpInfos(self, tagname, id, infos):
+element = self.GetEditedElement(tagname)
+if element is not None:
+jump = element.getInstance(id)
+for param, value in infos.items():
+if param == "target":
+jump.setTargetName(value)
+elif param == "height":
+jump.setHeight(value)
+elif param == "width":
+jump.setWidth(value)
+elif param == "x":
+jump.setX(value)
+elif param == "y":
+jump.setY(value)
+elif param == "connector":
+position = value.GetRelPosition()
+jump.addConnectionPointIn()
+jump.connectionPointIn.setRelPosition(position.x, position.y)
+self.SetConnectionWires(jump.connectionPointIn, value)
-def AddCurrentElementEditingActionBlock(self, id):
+def AddEditedElementActionBlock(self, tagname, id):
-actionBlock = plcopen.actionBlock()
+element = self.GetEditedElement(tagname)
-actionBlock.setLocalId(id)
+if element is not None:
-self.GetCurrentElementEditing().addInstance("actionBlock", actionBlock)
+actionBlock = plcopen.actionBlock()
+actionBlock.setLocalId(id)
-def SetCurrentElementEditingActionBlockInfos(self, id, infos):
+element.addInstance("actionBlock", actionBlock)
-actionBlock = self.GetCurrentElementEditing().getInstance(id)
-for param, value in infos.items():
+def SetEditedElementActionBlockInfos(self, tagname, id, infos):
-if param == "actions":
+element = self.GetEditedElement(tagname)
-actionBlock.setActions(value)
+if element is not None:
-elif param == "height":
+actionBlock = element.getInstance(id)
-actionBlock.setHeight(value)
+for param, value in infos.items():
-elif param == "width":
+if param == "actions":
-actionBlock.setWidth(value)
+actionBlock.setActions(value)
-elif param == "x":
+elif param == "height":
-actionBlock.setX(value)
+actionBlock.setHeight(value)
-elif param == "y":
+elif param == "width":
-actionBlock.setY(value)
+actionBlock.setWidth(value)
-elif param == "connector":
+elif param == "x":
-position = value.GetRelPosition()
+actionBlock.setX(value)
-actionBlock.addConnectionPointIn()
+elif param == "y":
-actionBlock.connectionPointIn.setRelPosition(position.x, position.y)
+actionBlock.setY(value)
-self.SetConnectionWires(actionBlock.connectionPointIn, value)
+elif param == "connector":
+position = value.GetRelPosition()
-def RemoveCurrentElementEditingInstance(self, id):
+actionBlock.addConnectionPointIn()
-element = self.GetCurrentElementEditing()
+actionBlock.connectionPointIn.setRelPosition(position.x, position.y)
-instance = element.getInstance(id)
+self.SetConnectionWires(actionBlock.connectionPointIn, value)
-if isinstance(instance, plcopen.block):
-blocktype = instance.getTypeName()
+def RemoveEditedElementInstance(self, tagname, id):
-if self.CurrentElementEditing != None:
+element = self.GetEditedElement(tagname)
-name = self.ElementsOpened[self.CurrentElementEditing]
+if element is not None:
-words = name.split("::")
+instance = element.getInstance(id)
-if words[0] in ["P","T","A"]:
+if isinstance(instance, plcopen.block):
-pou = self.Project.getPou(words[1])
+blocktype = instance.getTypeName()
-pou.removePouVar(blocktype, instance.getInstanceName())
+element.removePouVar(blocktype, instance.getInstanceName())
 element.removeInstance(id)
 self.RefreshPouUsingTree()
-def GetCurrentResourceEditingVariables(self):
+def GetEditedResourceVariables(self, tagname):
 varlist = []
-name = self.ElementsOpened[self.CurrentElementEditing]
+words = tagname.split("::")
-words = name.split("::")
 for var in self.GetConfigurationGlobalVars(words[1]):
 if var["Type"] == "BOOL":
 varlist.append(var["Name"])
 for var in self.GetConfigurationResourceGlobalVars(words[1], words[2]):
 if var["Type"] == "BOOL":
 varlist.append(var["Name"])
 return varlist
-def SetCurrentResourceEditingInfos(self, tasks, instances):
+def SetEditedResourceInfos(self, tasks, instances):
-resource = self.GetCurrentElementEditing()
+resource = self.GetEditedElement(tagname)
-resource.setTask([])
+if resource is not None:
-resource.setPouInstance([])
+resource.setTask([])
-task_list = {}
+resource.setPouInstance([])
-for task in tasks:
+task_list = {}
-new_task = plcopen.resource_task()
+for task in tasks:
-new_task.setName(task["Name"])
+new_task = plcopen.resource_task()
-if task["Single"] != "":
+new_task.setName(task["Name"])
-new_task.setSingle(task["Single"])
+if task["Single"] != "":
-result = duration_model.match(task["Interval"]).groups()
+new_task.setSingle(task["Single"])
-if reduce(lambda x, y: x or y != None, result):
+result = duration_model.match(task["Interval"]).groups()
-values = []
+if reduce(lambda x, y: x or y != None, result):
-for value in result[:-1]:
+values = []
-if value != None:
+for value in result[:-1]:
-values.append(int(value))
+if value != None:
-else:
+values.append(int(value))
-values.append(0)
+else:
-values.append(int(float(result[-1]) * 1000))
+values.append(0)
-new_task.setInterval(time(*values))
+values.append(int(float(result[-1]) * 1000))
-new_task.priority.setValue(int(task["Priority"]))
+new_task.setInterval(time(*values))
-if task["Name"] != "":
+new_task.priority.setValue(int(task["Priority"]))
-task_list[task["Name"]] = new_task
+if task["Name"] != "":
-resource.appendTask(new_task)
+task_list[task["Name"]] = new_task
-for instance in instances:
+resource.appendTask(new_task)
-new_instance = plcopen.pouInstance()
+for instance in instances:
-new_instance.setName(instance["Name"])
+new_instance = plcopen.pouInstance()
-new_instance.setType(instance["Type"])
+new_instance.setName(instance["Name"])
-if instance["Task"] != "":
+new_instance.setType(instance["Type"])
-task_list[instance["Task"]].appendPouInstance(new_instance)
+if instance["Task"] != "":
-else:
+task_list[instance["Task"]].appendPouInstance(new_instance)
-resource.appendPouInstance(new_instance)
+else:
+resource.appendPouInstance(new_instance)
-def GetCurrentResourceEditingInfos(self):
-resource = self.GetCurrentElementEditing()
+def GetEditedResourceInfos(self, tagname):
-tasks = resource.getTask()
+resource = self.GetEditedElement(tagname)
-instances = resource.getPouInstance()
+if resource is not None:
-tasks_data = []
+tasks = resource.getTask()
-instances_data = []
+instances = resource.getPouInstance()
-for task in tasks:
+tasks_data = []
-new_task = {}
+instances_data = []
-new_task["Name"] = task.getName()
+for task in tasks:
-single = task.getSingle()
+new_task = {}
-if single:
+new_task["Name"] = task.getName()
-new_task["Single"] = single
+single = task.getSingle()
-else:
+if single:
-new_task["Single"] = ""
+new_task["Single"] = single
-interval = task.getInterval()
+else:
-if interval:
+new_task["Single"] = ""
-text = ""
+interval = task.getInterval()
-if interval.hour != 0:
+if interval:
-text += "%dh"%interval.hour
+text = ""
-if interval.minute != 0:
+if interval.hour != 0:
-text += "%dm"%interval.minute
+text += "%dh"%interval.hour
-if interval.second != 0:
+if interval.minute != 0:
-text += "%ds"%interval.second
+text += "%dm"%interval.minute
-if interval.microsecond != 0:
+if interval.second != 0:
-if interval.microsecond % 1000 != 0:
+text += "%ds"%interval.second
-text += "%.3fms"%(float(interval.microsecond) / 1000)
+if interval.microsecond != 0:
-else:
+if interval.microsecond % 1000 != 0:
-text += "%dms"%(interval.microsecond / 1000)
+text += "%.3fms"%(float(interval.microsecond) / 1000)
-new_task["Interval"] = text
+else:
-else:
+text += "%dms"%(interval.microsecond / 1000)
-new_task["Interval"] = ""
+new_task["Interval"] = text
-new_task["Priority"] = str(task.priority.getValue())
+else:
-tasks_data.append(new_task)
+new_task["Interval"] = ""
-for instance in task.getPouInstance():
+new_task["Priority"] = str(task.priority.getValue())
+tasks_data.append(new_task)
+for instance in task.getPouInstance():
+new_instance = {}
+new_instance["Name"] = instance.getName()
+new_instance["Type"] = instance.getType()
+new_instance["Task"] = task.getName()
+instances_data.append(new_instance)
+for instance in instances:
 new_instance = {}
 new_instance["Name"] = instance.getName()
 new_instance["Type"] = instance.getType()
-new_instance["Task"] = task.getName()
+new_instance["Task"] = ""
 instances_data.append(new_instance)
-for instance in instances:
+return tasks_data, instances_data
-new_instance = {}
-new_instance["Name"] = instance.getName()
-new_instance["Type"] = instance.getType()
-new_instance["Task"] = ""
-instances_data.append(new_instance)
-return tasks_data, instances_data
 def OpenXMLFile(self, filepath):
 if self.VerifyXML:
 if sys:
 sys.stdout = HolePseudoFile()

changeset 121	40b91ba978db
parent 118	0c53d6a36013
child 125	394d9f168258