plcopeneditor_history: comparison PLCControler.py

equal deleted inserted replaced

-:f7832baaad84
+:aaa80b48bead
 #
 #You should have received a copy of the GNU General Public
 #License along with this library; if not, write to the Free Software
 #Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-from minixsv import pyxsval
 from xml.dom import minidom
 from types import StringType, UnicodeType
 import cPickle
 import os,sys,re
 from time import localtime
 [ITEM_UNEDITABLE, ITEM_PROJECT, ITEM_POU, ITEM_CLASS, ITEM_VARIABLE,
 ITEM_TRANSITION, ITEM_ACTION, ITEM_CONFIGURATION, ITEM_RESOURCE,
 ITEM_DATATYPE] = range(10)
 ScriptDirectory = os.path.split(os.path.realpath(__file__))[0]
-"""
-pyxsval is not complete and the parts that are not supported print some error
-reports. This class is used for not displaying them
-"""
-class HolePseudoFile:
-""" Base class for file like objects to facilitate StdOut for the Shell."""
-def __init__(self, output = None):
-if output is None: output = []
-self.output = output
-def writelines(self, l):
-map(self.write, l)
-def write(self, s):
-pass
-def flush(self):
-pass
-def isatty(self):
-return false
 #-------------------------------------------------------------------------------
 #                         Undo Buffer for PLCOpenEditor
 #-------------------------------------------------------------------------------
 self.LastNewIndex = 0
 self.Reset()
 # Reset PLCControler internal variables
 def Reset(self):
-self.VerifyXML = False
 self.Project = None
 self.ProjectBuffer = None
 self.Buffering = False
 self.FilePath = ""
 self.FileName = ""
 # Create a new project by replacing the current one
 def CreateNewProject(self, properties):
 # Create the project
 self.Project = plcopen.project()
 properties["creationDateTime"] = datetime(*localtime()[:6])
-self.Project.setFileHeader(properties)
+self.Project.setfileHeader(properties)
-self.Project.setContentHeader(properties)
+self.Project.setcontentHeader(properties)
 self.SetFilePath("")
 # Initialize the project buffer
 self.ProjectBuffer = UndoBuffer(self.Copy(self.Project), False)
 self.Buffering = False
 # Return project data type names
 def GetProjectDataTypeNames(self):
 if self.Project:
-return [datatype.getName() for datatype in self.Project.getDataTypes()]
+return [datatype.getname() for datatype in self.Project.getdataTypes()]
 return []
 # Return project pou names
 def GetProjectPouNames(self):
 if self.Project:
-return [pou.getName() for pou in self.Project.getPous()]
+return [pou.getname() for pou in self.Project.getpous()]
 return []
 # Return project pou names
 def GetProjectConfigNames(self):
 if self.Project:
-return [config.getName() for config in self.Project.getConfigurations()]
+return [config.getName() for config in self.Project.getconfigurations()]
 return []
 # Return project pou variables
 def GetProjectPouVariables(self, pou_name=None):
 variables = []
-for pou in self.Project.getPous():
+for pou in self.Project.getpous():
-if not pou_name or pou_name == pou.getName():
+if not pou_name or pou_name == pou.getname():
 variables.extend([var["Name"] for var in self.GetPouInterfaceVars(pou)])
-for transition in pou.getTransitionList():
+for transition in pou.gettransitionList():
-variables.append(transition.getName())
+variables.append(transition.getname())
-for action in pou.getActionList():
+for action in pou.getactionList():
-variables.append(action.getName())
+variables.append(action.getname())
 return variables
 # Return if project is saved
 def ProjectIsSaved(self):
 return self.ProjectBuffer.IsCurrentSaved()
 self.FileName = os.path.splitext(os.path.basename(filepath))[0]
 # Change project properties
 def SetProjectProperties(self, name = None, properties = None):
 if name != None:
-self.Project.setName(name)
+self.Project.setname(name)
 if properties != None:
-self.Project.setFileHeader(properties)
+self.Project.setfileHeader(properties)
-self.Project.setContentHeader(properties)
+self.Project.setcontentHeader(properties)
 if name != None or properties != None:
 self.BufferProject()
 # Return project properties
 def GetProjectProperties(self):
-properties = self.Project.getFileHeader()
+properties = self.Project.getfileHeader()
-properties.update(self.Project.getContentHeader())
+properties.update(self.Project.getcontentHeader())
 return properties
 # Return project informations
 def GetProjectInfos(self):
 if self.Project:
-infos = {"name": self.Project.getName(), "type": ITEM_PROJECT}
+infos = {"name": self.Project.getname(), "type": ITEM_PROJECT}
 datatypes = {"name": "Data Types", "type": ITEM_UNEDITABLE, "values":[]}
-for datatype in self.Project.getDataTypes():
+for datatype in self.Project.getdataTypes():
-datatypes["values"].append({"name": datatype.getName(), "type": ITEM_DATATYPE, "values": []})
+datatypes["values"].append({"name": datatype.getname(), "type": ITEM_DATATYPE, "values": []})
 pou_types = {"function": {"name": "Functions", "type": ITEM_UNEDITABLE, "values":[]},
 "functionBlock": {"name": "Function Blocks", "type": ITEM_UNEDITABLE, "values":[]},
 "program": {"name": "Programs", "type": ITEM_UNEDITABLE, "values":[]}}
-for pou in self.Project.getPous():
+for pou in self.Project.getpous():
-pou_type = pou.getPouType().getValue()
+pou_type = pou.getpouType()
-pou_infos = {"name": pou.getName(), "type": ITEM_POU}
+pou_infos = {"name": pou.getname(), "type": ITEM_POU}
 pou_values = []
-if pou.getBodyType() == "SFC":
+if pou.getbodyType() == "SFC":
 transitions = []
-for transition in pou.getTransitionList():
+for transition in pou.gettransitionList():
-transitions.append({"name": transition.getName(), "type": ITEM_TRANSITION, "values": []})
+transitions.append({"name": transition.getname(), "type": ITEM_TRANSITION, "values": []})
 pou_values.append({"name": "Transitions", "type": ITEM_UNEDITABLE, "values": transitions})
 actions = []
-for action in pou.getActionList():
+for action in pou.getactionList():
-actions.append({"name": action.getName(), "type": ITEM_ACTION, "values": []})
+actions.append({"name": action.getname(), "type": ITEM_ACTION, "values": []})
 pou_values.append({"name": "Actions", "type": ITEM_UNEDITABLE, "values": actions})
 if pou_type in pou_types:
 pou_infos["values"] = pou_values
 pou_types[pou_type]["values"].append(pou_infos)
 configurations = {"name": "Configurations", "type": ITEM_UNEDITABLE, "values": []}
-for config in self.Project.getConfigurations():
+for config in self.Project.getconfigurations():
-config_name = config.getName()
+config_name = config.getname()
 config_infos = {"name": config_name, "type": ITEM_CONFIGURATION, "values": []}
 resources = {"name": "Resources", "type": ITEM_UNEDITABLE, "values": []}
-for resource in config.getResource():
+for resource in config.getresource():
-resource_name = resource.getName()
+resource_name = resource.getname()
 resource_infos = {"name": resource_name, "type": ITEM_RESOURCE, "values": []}
 resources["values"].append(resource_infos)
 config_infos["values"] = [resources]
 configurations["values"].append(config_infos)
 infos["values"] = [{"name": "Properties", "type": ITEM_UNEDITABLE, "values": []},
 # Refresh the tree of user-defined data type cross-use
 def RefreshDataTypeUsingTree(self):
 # Reset the tree of user-defined pou cross-use
 self.DataTypeUsingTree = {}
 if self.Project:
-datatypes = self.Project.getDataTypes()
+datatypes = self.Project.getdataTypes()
 # Reference all the user-defined data type names and initialize the tree of
 # user-defined data type cross-use
-datatypenames = [datatype.getName() for datatype in datatypes]
+datatypenames = [datatype.getname() for datatype in datatypes]
 for name in datatypenames:
 self.DataTypeUsingTree[name] = []
 # Analyze each data type
 for datatype in datatypes:
-name = datatype.getName()
+name = datatype.getname()
-basetype_content = datatype.getBaseType().getContent()
+basetype_content = datatype.getbaseType().getcontent()
 if basetype_content["name"] == "derived":
-basetype_name = basetype_content["value"].getName()
+basetype_name = basetype_content["value"].getname()
 if basetype_name in datatypenames and name not in self.DataTypeUsingTree[basetype_name]:
 self.DataTypeUsingTree[basetype_name].append(name)
 elif basetype_content["name"] in ["subrangeSigned", "subrangeUnsigned", "array"]:
-base_type = basetype_content["value"].baseType.getContent()
+base_type = basetype_content["value"].baseType.getcontent()
 if base_type["value"] is not None:
-basetype_name = base_type["value"].getName()
+basetype_name = base_type["value"].getname()
 if basetype_name in datatypenames and name not in self.DataTypeUsingTree[basetype_name]:
 self.DataTypeUsingTree[basetype_name].append(name)
 # Refresh the tree of user-defined pou cross-use
 def RefreshPouUsingTree(self):
 # Reset the tree of user-defined pou cross-use
 self.PouUsingTree = {}
 if self.Project:
-pous = self.Project.getPous()
+pous = self.Project.getpous()
 # Reference all the user-defined pou names and initialize the tree of
 # user-defined pou cross-use
-pounames = [pou.getName() for pou in pous]
+pounames = [pou.getname() for pou in pous]
 for name in pounames:
 self.PouUsingTree[name] = []
 # Analyze each pou
 for pou in pous:
-name = pou.getName()
+name = pou.getname()
 if pou.interface:
 # Extract variables from every varLists
-for type, varlist in pou.getVars():
+for type, varlist in pou.getvars():
-for var in varlist.getVariable():
+for var in varlist.getvariable():
-vartype_content = var.getType().getContent()
+vartype_content = var.gettype().getcontent()
 if vartype_content["name"] == "derived":
-typename = vartype_content["value"].getName()
+typename = vartype_content["value"].getname()
 if typename in pounames and name not in self.PouUsingTree[typename]:
 self.PouUsingTree[typename].append(name)
-bodytype = pou.getBodyType()
+bodytype = pou.getbodyType()
 # If pou is written in a graphical language
 if bodytype in ["FBD","LD","SFC"]:
 # Analyze each instance of the pou
-for instance in pou.getInstances():
+for instance in pou.getinstances():
-if isinstance(instance, plcopen.block):
+if isinstance(instance, plcopen.fbdObjects_block):
-typename = instance.getTypeName()
+typename = instance.gettypeName()
 # Update tree if there is a cross-use
 if typename in pounames and name not in self.PouUsingTree[typename]:
 self.PouUsingTree[typename].append(name)
 # If pou is written in a textual language
 elif bodytype in ["IL", "ST"]:
-text = pou.getText()
+text = pou.gettext()
 # Search if each pou is mentioned in the pou text
 for typename in pounames:
 typename_model = re.compile("[ \t\n]%s[ \t\n]"%typename)
 # Update tree if there is a cross-use
 if typename != name and typename_model.search(text):
 #-------------------------------------------------------------------------------
 # Add a Data Type to Project
 def ProjectAddDataType(self, datatype_name):
 # Add the pou to project
-self.Project.appendDataType(datatype_name)
+self.Project.appenddataType(datatype_name)
 self.RefreshDataTypeUsingTree()
 self.RefreshDataTypes()
 self.BufferProject()
 # Remove a Data Type from project
 def ProjectRemoveDataType(self, datatype_name):
-self.Project.removeDataType(datatype_name)
+self.Project.removedataType(datatype_name)
 self.RefreshDataTypeUsingTree()
 self.RefreshDataTypes()
 self.BufferProject()
 # 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.Project.appendpou(pou_name, pou_type, body_type)
 if pou_type == "function":
 self.SetPouInterfaceReturnType(pou_name, "BOOL")
 self.RefreshPouUsingTree()
 self.RefreshBlockTypes()
 self.BufferProject()
 # Remove a Pou from project
 def ProjectRemovePou(self, pou_name):
-self.Project.removePou(pou_name)
+self.Project.removepou(pou_name)
 self.RefreshPouUsingTree()
 self.RefreshBlockTypes()
 self.BufferProject()
 # Add a configuration to Project
 def ProjectAddConfiguration(self, config_name):
-self.Project.addConfiguration(config_name)
+self.Project.addconfiguration(config_name)
 self.BufferProject()
 # Remove a configuration from project
 def ProjectRemoveConfiguration(self, config_name):
-self.Project.removeConfiguration(config_name)
+self.Project.removeconfiguration(config_name)
 self.BufferProject()
 # Add a resource to a configuration of the Project
 def ProjectAddConfigurationResource(self, config_name, resource_name):
-self.Project.addConfigurationResource(config_name, resource_name)
+self.Project.addconfigurationResource(config_name, resource_name)
 self.BufferProject()
 # Remove a resource from a configuration of the project
 def ProjectRemoveConfigurationResource(self, config_name, resource_name):
-self.Project.removeConfigurationResource(config_name, resource_name)
+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 = self.Project.getPou(pou_name)
+pou = self.Project.getpou(pou_name)
-pou.addTransition(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):
-pou = self.Project.getPou(pou_name)
+pou = self.Project.getpou(pou_name)
-pou.removeTransition(transition_name)
+pou.removetransition(transition_name)
 self.BufferProject()
 # Add an Action to a Project Pou
 def ProjectAddPouAction(self, pou_name, action_name, action_type):
-pou = self.Project.getPou(pou_name)
+pou = self.Project.getpou(pou_name)
-pou.addAction(action_name, action_type)
+pou.addaction(action_name, action_type)
 self.BufferProject()
 # Remove an Action from a Project Pou
 def ProjectRemovePouAction(self, pou_name, action_name):
 # Search if the pou removed is currently opened
 for i, element in enumerate(self.ElementsOpened):
 words = element.split("::")
 if words[0] == "A" and words[1] == pou_name and words[2] == action_name:
 self.RemoveElementEditing(i)
-pou = self.Project.getPou(pou_name)
+pou = self.Project.getpou(pou_name)
-pou.removeAction(action_name)
+pou.removeaction(action_name)
 self.BufferProject()
 # Change the name of a pou
 def ChangeDataTypeName(self, old_name, new_name):
 # Found the pou corresponding to old name and change its name to new name
-datatype = self.Project.getDataType(old_name)
+datatype = self.Project.getdataType(old_name)
-datatype.setName(new_name)
+datatype.setname(new_name)
 self.Project.updateElementName(old_name, new_name)
 self.BufferProject()
 # 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 = self.Project.getpou(old_name)
-pou.setName(new_name)
+pou.setname(new_name)
 self.Project.updateElementName(old_name, new_name)
 self.RefreshPouUsingTree()
 self.RefreshBlockTypes()
 self.BufferProject()
 # Change the name of a pou transition
 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)
+pou = self.Project.getpou(pou_name)
-transition = pou.getTransition(old_name)
+transition = pou.gettransition(old_name)
-transition.setName(new_name)
+transition.setname(new_name)
 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)
+pou = self.Project.getpou(pou_name)
-action = pou.getAction(old_name)
+action = pou.getaction(old_name)
-action.setName(new_name)
+action.setname(new_name)
 pou.updateElementName(old_name, new_name)
 self.BufferProject()
 # Change the name of a pou variable
 def ChangePouVariableName(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)
+pou = self.Project.getpou(pou_name)
-for type, varlist in pou.getVars():
+for type, varlist in pou.getvars():
-for var in varlist.getVariable():
+for var in varlist.getvariable():
-if var.getName() == old_name:
+if var.getname() == old_name:
-var.setName(new_name)
+var.setname(new_name)
 self.RefreshBlockTypes()
 self.BufferProject()
 # 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 = self.Project.getconfiguration(old_name)
-configuration.setName(new_name)
+configuration.setname(new_name)
 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 = self.Project.getconfigurationResource(config_name)
 resource.setName(new_name)
 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
-pou = self.Project.getPou(name)
+pou = self.Project.getpou(name)
-return pou.pouType.getValue()
+return pou.getpouType()
 # Return pous with SFC language
 def GetSFCPous(self):
 list = []
 if self.Project:
-for pou in self.Project.getPous():
+for pou in self.Project.getpous():
 if pou.getBodyType() == "SFC":
-list.append(pou.getName())
+list.append(pou.getname())
 return list
 # Return the body language of the pou given by its name
 def GetPouBodyType(self, name):
 # Found the pou correponding to name and return its body language
-pou = self.Project.getPou(name)
+pou = self.Project.getpou(name)
-return pou.getBodyType()
+return pou.getbodyType()
 # Return the actions of a pou
 def GetPouTransitions(self, pou_name):
 transitions = []
-pou = self.Project.getPou(pou_name)
+pou = self.Project.getpou(pou_name)
-if pou.getBodyType() == "SFC":
+if pou.getbodyType() == "SFC":
-for transition in pou.getTransitionList():
+for transition in pou.gettransitionList():
-transitions.append(transition.getName())
+transitions.append(transition.getname())
 return transitions
 # Return the body language of the transition given by its name
 def GetTransitionBodyType(self, pou_name, pou_transition):
 # Found the pou correponding to name and return its body language
-pou = self.Project.getPou(pou_name)
+pou = self.Project.getpou(pou_name)
-transition = pou.getTransition(pou_transition)
+transition = pou.gettransition(pou_transition)
-return transition.getBodyType()
+return transition.getbodyType()
 # Return the actions of a pou
 def GetPouActions(self, pou_name):
 actions = []
-pou = self.Project.getPou(pou_name)
+pou = self.Project.getpou(pou_name)
-if pou.getBodyType() == "SFC":
+if pou.getbodyType() == "SFC":
-for action in pou.getActionList():
+for action in pou.getactionList():
-actions.append(action.getName())
+actions.append(action.getname())
 return actions
 # Return the body language of the pou given by its name
 def GetActionBodyType(self, pou_name, pou_action):
 # Found the pou correponding to name and return its body language
-pou = self.Project.getPou(pou_name)
+pou = self.Project.getpou(pou_name)
-action = pou.getAction(pou_action)
+action = pou.getaction(pou_action)
-return action.getBodyType()
+return action.getbodyType()
 # Extract varlists from a list of vars
 def ExtractVarLists(self, vars):
 varlist_list = []
 current_varlist = None
 current_type = None
 for var in vars:
 if current_type != (var["Class"], var["Retain"], var["Constant"], var["Location"] in ["", None]):
 current_type = (var["Class"], var["Retain"], var["Constant"], var["Location"] in ["", None])
-current_varlist = plcopen.varList()
+if var["Class"] == "Local":
+current_varlist = plcopen.interface_localVars()
+elif var["Class"] == "Global":
+current_varlist = plcopen.interface_globalVars()
+elif var["Class"] == "External":
+current_varlist = plcopen.interface_externalVars()
+elif var["Class"] == "Temp":
+current_varlist = plcopen.interface_tempVars()
+elif var["Class"] == "Input":
+current_varlist = plcopen.interface_inputVars()
+elif var["Class"] == "Output":
+current_varlist = plcopen.interface_outputVars()
+elif var["Class"] == "InOut":
+current_varlist = plcopen.interface_inOutVars()
+else:
+current_varlist = plcopen.varList()
 varlist_list.append((var["Class"], current_varlist))
 if var["Retain"] == "Yes":
-varlist.setRetain(True)
+current_varlist.setretain(True)
 if var["Constant"] == "Yes":
-varlist.setConstant(True)
+current_varlist.setconstant(True)
 # Create variable and change its properties
 tempvar = plcopen.varListPlain_variable()
-tempvar.setName(var["Name"])
+tempvar.setname(var["Name"])
 var_type = plcopen.dataType()
-if var["Type"] not in var_type.getChoices():
+if var["Type"] in self.GetBaseTypes():
 if var["Type"] == "STRING":
-var_type.setContent("string", plcopen.string())
+var_type.setcontent({"name" : "string", "value" : plcopen.elementaryTypes_string()})
 elif var["Type"] == "WSTRING":
-var_type.setContent("wstring", plcopen.wstring())
+var_type.setcontent({"name" : "wstring", "value" : plcopen.elementaryTypes_wstring()})
 else:
-derived_type = plcopen.derived()
+var_type.setcontent({"name" : var["Type"], "value" : None})
-derived_type.setName(var["Type"])
-var_type.setContent("derived", derived_type)
 else:
-var_type.setContent(var["Type"], None)
+derived_type = plcopen.derivedTypes_derived()
-tempvar.setType(var_type)
+derived_type.setname(var["Type"])
+var_type.setcontent({"name" : "derived", "value" : derived_type})
+tempvar.settype(var_type)
 if var["Initial Value"] != "":
 value = plcopen.value()
-value.setValue(var["Initial Value"])
+value.setvalue(var["Initial Value"])
-tempvar.setInitialValue(value)
+tempvar.setinitialValue(value)
 if var["Location"] != "":
-tempvar.setAddress(var["Location"])
+tempvar.setaddress(var["Location"])
 else:
-tempvar.setAddress(None)
+tempvar.setaddress(None)
 # Add variable to varList
-current_varlist.appendVariable(tempvar)
+current_varlist.appendvariable(tempvar)
 return varlist_list
 # Replace the configuration globalvars by those given
 def SetConfigurationGlobalVars(self, name, vars):
 # Found the configuration corresponding to name
-configuration = self.Project.getConfiguration(name)
+configuration = self.Project.getconfiguration(name)
 if configuration:
 # Set configuration global vars
-configuration.setGlobalVars([])
+configuration.setglobalVars([])
 for vartype, varlist in self.ExtractVarLists(vars):
 configuration.globalVars.append(varlist)
 self.RefreshBlockTypes()
 # Return the configuration globalvars
 def GetConfigurationGlobalVars(self, name):
 vars = []
 # Found the configuration corresponding to name
-configuration = self.Project.getConfiguration(name)
+configuration = self.Project.getconfiguration(name)
 if configuration:
 # Extract variables from every varLists
-for varlist in configuration.getGlobalVars():
+for varlist in configuration.getglobalVars():
-for var in varlist.getVariable():
+for var in varlist.getvariable():
-tempvar = {"Name":var.getName(),"Class":"Global"}
+tempvar = {"Name" : var.getname(), "Class" : "Global"}
-vartype_content = var.getType().getContent()
+vartype_content = var.gettype().getcontent()
 if vartype_content["name"] == "derived":
-tempvar["Type"] = vartype_content["value"].getName()
+tempvar["Type"] = vartype_content["value"].getname()
 elif vartype_content["name"] in ["string", "wstring"]:
 tempvar["Type"] = vartype_content["name"].upper()
 else:
 tempvar["Type"] = vartype_content["name"]
 tempvar["Edit"] = True
-initial = var.getInitialValue()
+initial = var.getinitialValue()
 if initial:
-tempvar["Initial Value"] = initial.getValue()
+tempvar["Initial Value"] = initial.getvalue()
 else:
 tempvar["Initial Value"] = ""
-address = var.getAddress()
+address = var.getaddress()
 if address:
 tempvar["Location"] = address
 else:
 tempvar["Location"] = ""
-if varlist.getRetain():
+if varlist.getretain():
 tempvar["Retain"] = "Yes"
 else:
 tempvar["Retain"] = "No"
-if varlist.getConstant():
+if varlist.getconstant():
 tempvar["Constant"] = "Yes"
 else:
 tempvar["Constant"] = "No"
 vars.append(tempvar)
 return vars
 # Replace the resource globalvars by those given
 def SetConfigurationResourceGlobalVars(self, config_name, name, vars):
 # Found the resource corresponding to name
-resource = self.Project.getConfigurationResource(config_name, name)
+resource = self.Project.getconfigurationResource(config_name, name)
 # Set resource global vars
 if resource:
-resource.setGlobalVars([])
+resource.setglobalVars([])
 for vartype, varlist in self.ExtractVarLists(vars):
 resource.globalVars.append(varlist)
 self.RefreshBlockTypes()
 # Return the resource globalvars
 def GetConfigurationResourceGlobalVars(self, config_name, name):
 vars = []
 # Found the resource corresponding to name
-resource = self.Project.getConfigurationResource(config_name, name)
+resource = self.Project.getconfigurationResource(config_name, name)
 if resource:
 # Extract variables from every varLists
-for varlist in resource.getGlobalVars():
+for varlist in resource.getglobalVars():
-for var in varlist.getVariable():
+for var in varlist.getvariable():
-tempvar = {"Name":var.getName(),"Class":"Global"}
+tempvar = {"Name" : var.getname(), "Class" : "Global"}
-vartype_content = var.getType().getContent()
+vartype_content = var.gettype().getcontent()
 if vartype_content["name"] == "derived":
-tempvar["Type"] = vartype_content["value"].getName()
+tempvar["Type"] = vartype_content["value"].getname()
 elif vartype_content["name"] in ["string", "wstring"]:
 tempvar["Type"] = vartype_content["name"].upper()
 else:
 tempvar["Type"] = vartype_content["name"]
 tempvar["Edit"] = True
-initial = var.getInitialValue()
+initial = var.getinitialValue()
 if initial:
-tempvar["Initial Value"] = initial.getValue()
+tempvar["Initial Value"] = initial.getvalue()
 else:
 tempvar["Initial Value"] = ""
-address = var.getAddress()
+address = var.getaddress()
 if address:
 tempvar["Location"] = address
 else:
 tempvar["Location"] = ""
-if varlist.getRetain():
+if varlist.getretain():
 tempvar["Retain"] = "Yes"
 else:
 tempvar["Retain"] = "No"
-if varlist.getConstant():
+if varlist.getconstant():
 tempvar["Constant"] = "Yes"
 else:
 tempvar["Constant"] = "No"
 vars.append(tempvar)
 return vars
 # Return the interface of the pou given by its name
 def GetPouInterfaceVarsByName(self, name):
 # Found the pou correponding to name and return the interface
-return self.GetPouInterfaceVars(self.Project.getPou(name))
+return self.GetPouInterfaceVars(self.Project.getpou(name))
 # Return the interface for the given pou
 def GetPouInterfaceVars(self, pou):
 vars = []
 # Verify that the pou has an interface
 if pou.interface:
 # Extract variables from every varLists
-for type, varlist in pou.getVars():
+for type, varlist in pou.getvars():
-for var in varlist.getVariable():
+for var in varlist.getvariable():
-tempvar = {"Name":var.getName(),"Class":type}
+tempvar = {"Name" : var.getname(), "Class" : type}
-vartype_content = var.getType().getContent()
+vartype_content = var.gettype().getcontent()
 if vartype_content["name"] == "derived":
-tempvar["Type"] = vartype_content["value"].getName()
+tempvar["Type"] = vartype_content["value"].getname()
-tempvar["Edit"] = not pou.hasBlock(tempvar["Name"])
+tempvar["Edit"] = not pou.hasblock(tempvar["Name"])
 else:
 if vartype_content["name"] in ["string", "wstring"]:
 tempvar["Type"] = vartype_content["name"].upper()
 else:
 tempvar["Type"] = vartype_content["name"]
 tempvar["Edit"] = True
-initial = var.getInitialValue()
+initial = var.getinitialValue()
 if initial:
-tempvar["Initial Value"] = initial.getValue()
+tempvar["Initial Value"] = initial.getvalue()
 else:
 tempvar["Initial Value"] = ""
-address = var.getAddress()
+address = var.getaddress()
 if address:
 tempvar["Location"] = address
 else:
 tempvar["Location"] = ""
-if varlist.getRetain():
+if varlist.getretain():
 tempvar["Retain"] = "Yes"
 else:
 tempvar["Retain"] = "No"
-if varlist.getConstant():
+if varlist.getconstant():
 tempvar["Constant"] = "Yes"
 else:
 tempvar["Constant"] = "No"
 vars.append(tempvar)
 return vars
 # Replace the Pou interface by the one given
 def SetPouInterfaceVars(self, name, vars):
 # Found the pou corresponding to name and add interface if there isn't one yet
-pou = self.Project.getPou(name)
+pou = self.Project.getpou(name)
 if not pou.interface:
 pou.interface = plcopen.pou_interface()
 # Set Pou interface
-pou.setVars(self.ExtractVarLists(vars))
+pou.setvars(self.ExtractVarLists(vars))
 self.RefreshPouUsingTree()
 self.RefreshBlockTypes()
 # Replace the return type of the pou given by its name (only for functions)
 def SetPouInterfaceReturnType(self, name, type):
-pou = self.Project.getPou(name)
+pou = self.Project.getpou(name)
 if not pou.interface:
 pou.interface = plcopen.pou_interface()
 # If there isn't any return type yet, add it
-return_type = pou.interface.getReturnType()
+return_type = pou.interface.getreturnType()
 if not return_type:
 return_type = plcopen.dataType()
-pou.interface.setReturnType(return_type)
+pou.interface.setreturnType(return_type)
 # Change return type
 if type in self.GetBaseTypes():
-return_type.setContent(type, None)
+if type == "STRING":
+return_type.setcontent({"name" : "string", "value" : plcopen.elementaryTypes_string()})
+elif type == "WSTRING":
+return_type.setcontent({"name" : "wstring", "value" : plcopen.elementaryTypes_wstring()})
+else:
+return_type.setcontent({"name" : type, "value" : None})
 else:
-derived_type = plcopen.derived()
+derived_type = plcopen.derivedTypes_derived()
-derived_type.setName(type)
+derived_type.setname(type)
-return_type.setContent("derived", derived_type)
+return_type.setcontent({"name" : "derived", "value" : derived_type})
 self.RefreshBlockTypes()
 def UpdateProjectUsedPous(self, old_name, new_name):
 if self.Project:
 self.Project.updateElementName(old_name, new_name)
 pou.updateElementName(old_name, new_name)
 # Return the return type of the pou given by its name
 def GetPouInterfaceReturnTypeByName(self, name):
 # Found the pou correponding to name and return the return type
-return self.GetPouInterfaceReturnType(self.Project.getPou(name))
+return self.GetPouInterfaceReturnType(self.Project.getpou(name))
 # Return the return type of the given pou
 def GetPouInterfaceReturnType(self, pou):
 # Verify that the pou has an interface
 if pou.interface:
 # Return the return type if there is one
-return_type = pou.interface.getReturnType()
+return_type = pou.interface.getreturnType()
 if return_type:
-returntype_content = return_type.getContent()
+returntype_content = return_type.getcontent()
 if returntype_content["name"] == "derived":
-return returntype_content["value"].getName()
+return returntype_content["value"].getname()
 elif returntype_content["name"] in ["string", "wstring"]:
 return returntype_content["name"].upper()
 else:
 return returntype_content["name"]
 return None
 # Update data types with user-defined data types added
 def RefreshDataTypes(self):
 ResetTypeHierarchy()
 ResetEnumeratedDataValues()
 if self.Project:
-for datatype in self.Project.getDataTypes():
+for datatype in self.Project.getdataTypes():
-name = datatype.getName()
+name = datatype.getname()
-basetype_content = datatype.getBaseType().getContent()
+basetype_content = datatype.getbaseType().getcontent()
 if basetype_content["value"] is None:
 AddDataTypeHierarchy(name, basetype_content["name"])
 elif basetype_content["name"] in ["string", "wstring"]:
 AddDataTypeHierarchy(name, basetype_content["name"].upper())
 elif basetype_content["name"] == "derived":
-AddDataTypeHierarchy(name, basetype_content["value"].getName())
+AddDataTypeHierarchy(name, basetype_content["value"].getname())
 elif basetype_content["name"] in ["subrangeSigned", "subrangeUnsigned"]:
-base_type = basetype_content["value"].baseType.getContent()
+base_type = basetype_content["value"].baseType.getcontent()
 if base_type["value"] is None:
 AddDataTypeHierarchy(name, base_type["name"])
 else:
-AddDataTypeHierarchy(name, base_type["value"].getName())
+AddDataTypeHierarchy(name, base_type["value"].getname())
 else:
 if basetype_content["name"] == "enum":
 values = []
-for value in basetype_content["value"].values.getValue():
+for value in basetype_content["value"].values.getvalue():
-values.append(value.getName())
+values.append(value.getname())
 AddEnumeratedDataValues(values)
 AddDataTypeHierarchy(name, "ANY_DERIVED")
 # Update Block types with user-defined pou added
 def RefreshBlockTypes(self):
 if BlockTypes[-1]["name"] == "User-defined POUs":
 BlockTypes[-1]["list"] = []
 else:
 BlockTypes.append({"name" : "User-defined POUs", "list": []})
 if self.Project:
-for pou in self.Project.getPous():
+for pou in self.Project.getpous():
-pou_name = pou.getName()
+pou_name = pou.getname()
-pou_type = pou.pouType.getValue()
+pou_type = pou.getpouType()
 if pou_type != "program":
 block_infos = {"name" : pou_name, "type" : pou_type, "extensible" : False,
 "inputs" : [], "outputs" : [], "comment" : "",
 "generate" : generate_block, "initialise" : initialise_block }
-if pou.getInterface():
+if pou.getinterface():
-for type, varlist in pou.getVars():
+for type, varlist in pou.getvars():
 if type == "InOut":
-for var in varlist.getVariable():
+for var in varlist.getvariable():
-var_type = var.type.getContent()
+var_type = var.type.getcontent()
 if var_type["name"] == "derived":
-block_infos["inputs"].append((var.getName(),var_type["value"].getName(),"none"))
+block_infos["inputs"].append((var.getname(), var_type["value"].getname(), "none"))
-block_infos["outputs"].append((var.getName(),var_type["value"].getName(),"none"))
+block_infos["outputs"].append((var.getname(), var_type["value"].getname(), "none"))
 elif var_type["name"] in ["string", "wstring"]:
-block_infos["inputs"].append((var.getName(),var_type["name"].upper(),"none"))
+block_infos["inputs"].append((var.getname(), var_type["name"].upper(), "none"))
-block_infos["outputs"].append((var.getName(),var_type["name"].upper(),"none"))
+block_infos["outputs"].append((var.getname(), var_type["name"].upper(), "none"))
 else:
-block_infos["inputs"].append((var.getName(),var_type["name"],"none"))
+block_infos["inputs"].append((var.getname(), var_type["name"], "none"))
-block_infos["outputs"].append((var.getName(),var_type["name"],"none"))
+block_infos["outputs"].append((var.getname(), var_type["name"], "none"))
 elif type == "Input":
-for var in varlist.getVariable():
+for var in varlist.getvariable():
-var_type = var.type.getContent()
+var_type = var.type.getcontent()
 if var_type["name"] == "derived":
-block_infos["inputs"].append((var.getName(),var_type["value"].getName(),"none"))
+block_infos["inputs"].append((var.getname(), var_type["value"].getname(), "none"))
 elif var_type["name"] in ["string", "wstring"]:
-block_infos["inputs"].append((var.getName(),var_type["name"].upper(),"none"))
+block_infos["inputs"].append((var.getname(), var_type["name"].upper(), "none"))
 else:
-block_infos["inputs"].append((var.getName(),var_type["name"],"none"))
+block_infos["inputs"].append((var.getname(), var_type["name"], "none"))
 elif type == "Output":
-for var in varlist.getVariable():
+for var in varlist.getvariable():
-var_type = var.type.getContent()
+var_type = var.type.getcontent()
 if var_type["name"] == "derived":
-block_infos["outputs"].append((var.getName(),var_type["value"].getName(),"none"))
+block_infos["outputs"].append((var.getname(), var_type["value"].getname(), "none"))
 elif var_type["name"] in ["string", "wstring"]:
-block_infos["outputs"].append((var.getName(),var_type["name"].upper(),"none"))
+block_infos["outputs"].append((var.getname(), var_type["name"].upper(), "none"))
 else:
-block_infos["outputs"].append((var.getName(),var_type["name"],"none"))
+block_infos["outputs"].append((var.getname(), var_type["name"], "none"))
-return_type = pou.interface.getReturnType()
+return_type = pou.interface.getreturnType()
 if return_type:
-var_type = return_type.getContent()
+var_type = return_type.getcontent()
 if var_type["name"] == "derived":
-block_infos["outputs"].append(("",var_type["value"].getName(),"none"))
+block_infos["outputs"].append(("", var_type["value"].getname(), "none"))
 elif var_type["name"] in ["string", "wstring"]:
-block_infos["outputs"].append(("",var_type["name"].upper(),"none"))
+block_infos["outputs"].append(("", var_type["name"].upper(), "none"))
 else:
-block_infos["outputs"].append(("",var_type["name"],"none"))
+block_infos["outputs"].append(("", var_type["name"], "none"))
-if pou.getBodyType() in ["FBD","LD","SFC"]:
+if pou.getbodyType() in ["FBD","LD","SFC"]:
-for instance in pou.getInstances():
+for instance in pou.getinstances():
-if isinstance(instance, plcopen.comment):
+if isinstance(instance, plcopen.commonObjects_comment):
-block_infos["comment"] = instance.getContentText()
+block_infos["comment"] = instance.getcontentText()
 BlockTypes[-1]["list"].append(block_infos)
 # Return Block types checking for recursion
 def GetBlockTypes(self, tagname = ""):
 name = ""
 for category in BlockTypes[:-1]:
 for blocktype in category["list"]:
 if blocktype["type"] == "program":
 blocktypes.append(blocktype["name"])
 if self.Project:
-for pou in self.Project.getPous():
+for pou in self.Project.getpous():
-if pou.pouType.getValue() == "program":
+if pou.getpouType() == "program":
-blocktypes.append(pou.getName())
+blocktypes.append(pou.getname())
 return blocktypes
 # Return Data Types checking for recursion
 def GetDataTypes(self, tagname = "", basetypes = True):
 if basetypes:
 words = tagname.split("::")
 if words[0] in ["D"]:
 name = words[1]
 else:
 name = ""
-for datatype in self.Project.getDataTypes():
+for datatype in self.Project.getdataTypes():
-datatype_name = datatype.getName()
+datatype_name = datatype.getname()
 if datatype_name != name and not self.DataTypeIsUsedBy(name, datatype_name):
 datatypes.append(datatype_name)
 return datatypes
 # Return Base Types
 # Return the data type informations
 def GetDataTypeInfos(self, tagname):
 words = tagname.split("::")
 if words[0] == "D":
 infos = {}
-datatype = self.Project.getDataType(words[1])
+datatype = self.Project.getdataType(words[1])
-basetype_content = datatype.baseType.getContent()
+basetype_content = datatype.baseType.getcontent()
 if basetype_content["value"] is None:
 infos["type"] = "Directly"
 infos["base_type"] = basetype_content["name"]
 elif basetype_content["name"] == "derived":
 infos["type"] = "Directly"
-infos["base_type"] = basetype_content["value"].getName()
+infos["base_type"] = basetype_content["value"].getname()
 elif basetype_content["name"] in ["subrangeSigned", "subrangeUnsigned"]:
 infos["type"] = "Subrange"
-infos["min"] = basetype_content["value"].range.getLower()
+infos["min"] = basetype_content["value"].range.getlower()
-infos["max"] = basetype_content["value"].range.getUpper()
+infos["max"] = basetype_content["value"].range.getupper()
-base_type = basetype_content["value"].baseType.getContent()
+base_type = basetype_content["value"].baseType.getcontent()
 if base_type["value"] is None:
 infos["base_type"] = base_type["name"]
 else:
-infos["base_type"] = base_type["value"].getName()
+infos["base_type"] = base_type["value"].getname()
 elif basetype_content["name"] == "enum":
 infos["type"] = "Enumerated"
 infos["values"] = []
-for value in basetype_content["value"].values.getValue():
+for value in basetype_content["value"].values.getvalue():
-infos["values"].append(value.getName())
+infos["values"].append(value.getname())
 elif basetype_content["name"] == "array":
 infos["type"] = "Array"
 infos["dimensions"] = []
-for dimension in basetype_content["value"].getDimension():
+for dimension in basetype_content["value"].getdimension():
-infos["dimensions"].append(str(dimension.getUpper()))
+infos["dimensions"].append(str(dimension.getupper()))
-base_type = basetype_content["value"].baseType.getContent()
+base_type = basetype_content["value"].baseType.getcontent()
 if base_type["value"] is None:
 infos["base_type"] = base_type["name"]
 else:
-infos["base_type"] = base_type["value"].getName()
+infos["base_type"] = base_type["value"].getname()
 if datatype.initialValue is not None:
-infos["initial"] = str(datatype.initialValue.getValue())
+infos["initial"] = str(datatype.initialValue.getvalue())
 else:
 infos["initial"] = ""
 return infos
 return None
 # Change the data type informations
 def SetDataTypeInfos(self, tagname, infos):
 words = tagname.split("::")
 if words[0] == "D":
-datatype = self.Project.getDataType(words[1])
+datatype = self.Project.getdataType(words[1])
 if infos["type"] == "Directly":
 if infos["base_type"] in self.GetBaseTypes():
 if infos["base_type"] == "STRING":
-datatype.baseType.setContent("string", plcopen.string())
+datatype.baseType.setcontent({"name" : "string", "value" : plcopen.elementaryTypes_string()})
 elif infos["base_type"] == "WSTRING":
-datatype.baseType.setContent("wstring", plcopen.wstring())
+datatype.baseType.setcontent({"name" : "wstring", "value" : plcopen.elementaryTypes_wstring()})
 else:
-datatype.baseType.setContent(infos["base_type"], None)
+datatype.baseType.setcontent({"name" : infos["base_type"], "value" : None})
 else:
-derived_datatype = plcopen.derived()
+derived_datatype = plcopen.derivedTypes_derived()
-derived_datatype.setName(infos["base_type"])
+derived_datatype.setname(infos["base_type"])
-datatype.baseType.setContent("derived", derived_datatype)
+datatype.baseType.setcontent({"name" : "derived", "value" : derived_datatype})
 elif infos["type"] == "Subrange":
 if infos["base_type"] in GetSubTypes("ANY_UINT"):
-subrange = plcopen.subrangeUnsigned()
+subrange = plcopen.derivedTypes_subrangeUnsigned()
-datatype.baseType.setContent("subrangeUnsigned", subrange)
+datatype.baseType.setcontent({"name" : "subrangeUnsigned", "value" : subrange})
 else:
-subrange = plcopen.subrangeSigned()
+subrange = plcopen.derivedTypes_subrangeSigned()
-datatype.baseType.setContent("subrangeSigned", subrange)
+datatype.baseType.setcontent({"name" : "subrangeSigned", "value" : subrange})
-subrange.range.setLower(infos["min"])
+subrange.range.setlower(infos["min"])
-subrange.range.setUpper(infos["max"])
+subrange.range.setupper(infos["max"])
 if infos["base_type"] in self.GetBaseTypes():
-subrange.baseType.setContent(infos["base_type"], None)
+subrange.baseType.setcontent({"name" : infos["base_type"], "value" : None})
 else:
-derived_datatype = plcopen.derived()
+derived_datatype = plcopen.derivedTypes_derived()
-derived_datatype.setName(infos["base_type"])
+derived_datatype.setname(infos["base_type"])
-subrange.baseType.setContent("derived", derived_datatype)
+subrange.baseType.setcontent({"name" : "derived", "value" : derived_datatype})
 elif infos["type"] == "Enumerated":
-enumerated = plcopen.enum()
+enumerated = plcopen.derivedTypes_enum()
-for enum_value in infos["values"]:
+for i, enum_value in enumerate(infos["values"]):
 value = plcopen.values_value()
-value.setName(enum_value)
+value.setname(enum_value)
-enumerated.values.appendValue(value)
+if i == 0:
-datatype.baseType.setContent("enum", enumerated)
+enumerated.values.setvalue([value])
+else:
+enumerated.values.appendvalue(value)
+datatype.baseType.setcontent({"name" : "enum", "value" : enumerated})
 elif infos["type"] == "Array":
-array = plcopen.array()
+array = plcopen.derivedTypes_array()
 for dimension in infos["dimensions"]:
 dimension_range = plcopen.rangeSigned()
-dimension_range.setLower(1)
+dimension_range.setlower(1)
-dimension_range.setUpper(int(dimension))
+dimension_range.setupper(int(dimension))
-array.appendDimension(dimension_range)
+array.appenddimension(dimension_range)
 if infos["base_type"] in self.GetBaseTypes():
 if infos["base_type"] == "STRING":
-array.baseType.setContent("string", plcopen.string())
+array.baseType.setcontent({"name" : "string", "value" : plcopen.elementaryTypes_string()})
 elif infos["base_type"] == "WSTRING":
-array.baseType.setContent("wstring", plcopen.wstring())
+array.baseType.setcontent({"name" : "wstring", "value" : plcopen.wstring()})
 else:
-array.baseType.setContent(infos["base_type"], None)
+array.baseType.setcontent({"name" : infos["base_type"], "value" : None})
 else:
-derived_datatype = plcopen.derived()
+derived_datatype = plcopen.derivedTypes_derived()
-derived_datatype.setName(infos["base_type"])
+derived_datatype.setname(infos["base_type"])
-array.baseType.setContent("derived", derived_datatype)
+array.baseType.setcontent({"name" : "derived", "value" : derived_datatype})
-datatype.baseType.setContent("array", array)
+datatype.baseType.setcontent({"name" : "array", "value" : array})
 if infos["initial"] != "":
 if datatype.initialValue is None:
 datatype.initialValue = plcopen.value()
-datatype.initialValue.setValue(infos["initial"])
+datatype.initialValue.setvalue(infos["initial"])
 else:
 datatype.initialValue = None
 self.RefreshDataTypeUsingTree()
 self.RefreshDataTypes()
 self.BufferProject()
 # Return edited element
 def GetEditedElement(self, tagname):
 words = tagname.split("::")
 if words[0] == "P":
-return self.Project.getPou(words[1])
+return self.Project.getpou(words[1])
 if words[0] in ['T', 'A']:
-pou = self.Project.getPou(words[1])
+pou = self.Project.getpou(words[1])
 if words[0] == 'T':
-return pou.getTransition(words[2])
+return pou.gettransition(words[2])
 elif words[0] == 'A':
-return pou.getAction(words[2])
+return pou.getaction(words[2])
 elif words[0] == 'C':
-return self.Project.getConfiguration(words[1])
+return self.Project.getconfiguration(words[1])
 elif words[0] == 'R':
-return self.Project.getConfigurationResource(words[1], words[2])
+return self.Project.getconfigurationResource(words[1], words[2])
 return None
 # Return edited element name
 def GetEditedElementName(self, tagname):
 words = tagname.split("::")
 # 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])
+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])
+pou = self.Project.getpou(words[1])
 return self.GetPouInterfaceReturnType(pou)
 elif words[0] == 'T':
 return "BOOL"
 return None
 # Change the edited element text
 def SetEditedElementText(self, tagname, text):
 element = self.GetEditedElement(tagname)
 if element != None:
-element.setText(text)
+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 element.gettext()
 return ""
 # Return the edited element transitions
 def GetEditedElementTransitions(self, tagname):
 pou = self.GetEditedElement(tagname)
-if pou != None and pou.getBodyType() == "SFC":
+if pou != None and pou.getbodyType() == "SFC":
 transitions = []
-for transition in pou.getTransitionList():
+for transition in pou.gettransitionList():
-transitions.append(transition.getName())
+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":
+if pou != None and pou.getbodyType() == "SFC":
 actions = []
-for action in pou.getActionList():
+for action in pou.getactionList():
-actions.append(action.getName())
+actions.append(action.getname())
 return actions
 return []
 # Return the names of the pou elements
 def GetEditedElementVariables(self, tagname):
 instance = None
 element = self.GetEditedElement(tagname)
 if element is not None:
 # if id is defined
 if id is not None:
-instance = element.getInstance(id)
+instance = element.getinstance(id)
 else:
-instance = element.getRandomInstance(exclude)
+instance = element.getrandomInstance(exclude)
 if instance is not None:
 if id is not None:
 infos["id"] = id
 else:
-infos["id"] = instance.getLocalId()
+infos["id"] = instance.getlocalId()
-infos["x"] = instance.getX()
+infos["x"] = instance.getx()
-infos["y"] = instance.getY()
+infos["y"] = instance.gety()
-infos["height"] = instance.getHeight()
+infos["height"] = instance.getheight()
-infos["width"] = instance.getWidth()
+infos["width"] = instance.getwidth()
-if isinstance(instance, plcopen.block):
+if isinstance(instance, plcopen.fbdObjects_block):
-infos["name"] = instance.getInstanceName()
+infos["name"] = instance.getinstanceName()
-infos["type"] = instance.getTypeName()
+infos["type"] = instance.gettypeName()
-executionOrder = instance.getExecutionOrderId()
+executionOrder = instance.getexecutionOrderId()
 if executionOrder is not None:
 infos["executionOrder"] = executionOrder
 else:
 infos["executionOrder"] = 0
 infos["connectors"] = {"inputs":[],"outputs":[]}
-for variable in instance.inputVariables.getVariable():
+for variable in instance.inputVariables.getvariable():
 connector = {}
-connector["name"] = variable.getFormalParameter()
+connector["name"] = variable.getformalParameter()
-connector["position"] = variable.connectionPointIn.getRelPosition()
+connector["position"] = variable.connectionPointIn.getrelPositionXY()
-connector["negated"] = variable.getNegated()
+connector["negated"] = variable.getnegated()
-connector["edge"] = variable.getConnectorEdge()
+connector["edge"] = variable.getedge()
 connector["links"] = []
-connections = variable.connectionPointIn.getConnections()
+connections = variable.connectionPointIn.getconnections()
 if connections:
 for link in connections:
-dic = {"refLocalId":link.getRefLocalId(),"points":link.getPoints(),"formalParameter":link.getFormalParameter()}
+dic = {"refLocalId":link.getrefLocalId(),"points":link.getpoints(),"formalParameter":link.getformalParameter()}
 connector["links"].append(dic)
 infos["connectors"]["inputs"].append(connector)
-for variable in instance.outputVariables.getVariable():
+for variable in instance.outputVariables.getvariable():
 connector = {}
-connector["name"] = variable.getFormalParameter()
+connector["name"] = variable.getformalParameter()
-connector["position"] = variable.connectionPointOut.getRelPosition()
+connector["position"] = variable.connectionPointOut.getrelPositionXY()
-connector["negated"] = variable.getNegated()
+connector["negated"] = variable.getnegated()
-connector["edge"] = variable.getConnectorEdge()
+connector["edge"] = variable.getedge()
 infos["connectors"]["outputs"].append(connector)
-elif isinstance(instance, plcopen.inVariable):
+elif isinstance(instance, plcopen.fbdObjects_inVariable):
-infos["name"] = instance.getExpression()
+infos["name"] = instance.getexpression()
 infos["value_type"] = self.GetEditedElementVarValueType(tagname, infos["name"])
 infos["type"] = "input"
-executionOrder = instance.getExecutionOrderId()
+executionOrder = instance.getexecutionOrderId()
 if executionOrder is not None:
 infos["executionOrder"] = executionOrder
 else:
 infos["executionOrder"] = 0
 infos["connector"] = {}
-infos["connector"]["position"] = instance.connectionPointOut.getRelPosition()
+infos["connector"]["position"] = instance.connectionPointOut.getrelPositionXY()
-infos["connector"]["negated"] = instance.getNegated()
+infos["connector"]["negated"] = instance.getnegated()
-infos["connector"]["edge"] = instance.getConnectorEdge()
+infos["connector"]["edge"] = instance.getedge()
-elif isinstance(instance, plcopen.outVariable):
+elif isinstance(instance, plcopen.fbdObjects_outVariable):
-infos["name"] = instance.getExpression()
+infos["name"] = instance.getexpression()
 infos["value_type"] = self.GetEditedElementVarValueType(tagname, infos["name"])
 infos["type"] = "output"
-executionOrder = instance.getExecutionOrderId()
+executionOrder = instance.getexecutionOrderId()
 if executionOrder is not None:
 infos["executionOrder"] = executionOrder
 else:
 infos["executionOrder"] = 0
 infos["connector"] = {}
-infos["connector"]["position"] = instance.connectionPointIn.getRelPosition()
+infos["connector"]["position"] = instance.connectionPointIn.getrelPositionXY()
-infos["connector"]["negated"] = instance.getNegated()
+infos["connector"]["negated"] = instance.getnegated()
-infos["connector"]["edge"] = instance.getConnectorEdge()
+infos["connector"]["edge"] = instance.getedge()
 infos["connector"]["links"] = []
-connections = instance.connectionPointIn.getConnections()
+connections = instance.connectionPointIn.getconnections()
 if connections:
 for link in connections:
-dic = {"refLocalId":link.getRefLocalId(),"points":link.getPoints(),"formalParameter":link.getFormalParameter()}
+dic = {"refLocalId":link.getrefLocalId(),"points":link.getpoints(),"formalParameter":link.getformalParameter()}
 infos["connector"]["links"].append(dic)
-elif isinstance(instance, plcopen.inOutVariable):
+elif isinstance(instance, plcopen.fbdObjects_inOutVariable):
-infos["name"] = instance.getExpression()
+infos["name"] = instance.getexpression()
 infos["value_type"] = self.GetEditedElementVarValueType(tagname, infos["name"])
 infos["type"] = "inout"
-executionOrder = instance.getExecutionOrderId()
+executionOrder = instance.getexecutionOrderId()
 if executionOrder is not None:
 infos["executionOrder"] = executionOrder
 else:
 infos["executionOrder"] = 0
 infos["connectors"] = {"input":{},"output":{}}
-infos["connectors"]["output"]["position"] = instance.connectionPointOut.getRelPosition()
+infos["connectors"]["output"]["position"] = instance.connectionPointOut.getrelPositionXY()
-infos["connectors"]["output"]["negated"] = instance.getNegatedOut()
+infos["connectors"]["output"]["negated"] = instance.getnegatedOut()
-infos["connectors"]["output"]["edge"] = instance.getOutputEdge()
+infos["connectors"]["output"]["edge"] = instance.getedgeOut()
-infos["connectors"]["input"]["position"] = instance.connectionPointIn.getRelPosition()
+infos["connectors"]["input"]["position"] = instance.connectionPointIn.getrelPositionXY()
-infos["connectors"]["input"]["negated"] = instance.getNegatedIn()
+infos["connectors"]["input"]["negated"] = instance.getnegatedIn()
-infos["connectors"]["input"]["edge"] = instance.getInputEdge()
+infos["connectors"]["input"]["edge"] = instance.getedgeIn()
 infos["connectors"]["input"]["links"] = []
-connections = instance.connectionPointIn.getConnections()
+connections = instance.connectionPointIn.getconnections()
 if connections:
 for link in connections:
-dic = {"refLocalId":link.getRefLocalId(),"points":link.getPoints(),"formalParameter":link.getFormalParameter()}
+dic = {"refLocalId":link.getrefLocalId(),"points":link.getpoints(),"formalParameter":link.getformalParameter()}
 infos["connectors"]["input"]["links"].append(dic)
-elif isinstance(instance, plcopen.continuation):
+elif isinstance(instance, plcopen.commonObjects_continuation):
-infos["name"] = instance.getName()
+infos["name"] = instance.getname()
 infos["type"] = "continuation"
 infos["connector"] = {}
-infos["connector"]["position"] = instance.connectionPointOut.getRelPosition()
+infos["connector"]["position"] = instance.connectionPointOut.getrelPositionXY()
-elif isinstance(instance, plcopen.connector):
+elif isinstance(instance, plcopen.commonObjects_connector):
 infos["name"] = instance.getName()
 infos["type"] = "connection"
 infos["connector"] = {}
-infos["connector"]["position"] = instance.connectionPointIn.getRelPosition()
+infos["connector"]["position"] = instance.connectionPointIn.getrelPositionXY()
 infos["connector"]["links"] = []
-connections = instance.connectionPointIn.getConnections()
+connections = instance.connectionPointIn.getconnections()
 if connections:
 for link in connections:
-dic = {"refLocalId":link.getRefLocalId(),"points":link.getPoints(),"formalParameter":link.getFormalParameter()}
+dic = {"refLocalId":link.getrefLocalId(),"points":link.getpoints(),"formalParameter":link.getformalParameter()}
 infos["connector"]["links"].append(dic)
-elif isinstance(instance, plcopen.comment):
+elif isinstance(instance, plcopen.commonObjects_comment):
 infos["type"] = "comment"
-infos["content"] = instance.getContentText()
+infos["content"] = instance.getcontentText()
-elif isinstance(instance, plcopen.leftPowerRail):
+elif isinstance(instance, plcopen.ldObjects_leftPowerRail):
 infos["type"] = "leftPowerRail"
 infos["connectors"] = []
-for connection in instance.getConnectionPointOut():
+for connection in instance.getconnectionPointOut():
 connector = {}
-connector["position"] = connection.getRelPosition()
+connector["position"] = connection.getrelPositionXY()
 infos["connectors"].append(connector)
-elif isinstance(instance, plcopen.rightPowerRail):
+elif isinstance(instance, plcopen.ldObjects_rightPowerRail):
 infos["type"] = "rightPowerRail"
 infos["connectors"] = []
-for connection in instance.getConnectionPointIn():
+for connection in instance.getconnectionPointIn():
 connector = {}
-connector["position"] = connection.getRelPosition()
+connector["position"] = connection.getrelPositionXY()
 connector["links"] = []
-connections = connection.getConnections()
+connections = connection.getconnections()
 if connections:
-for link in connection.getConnections():
+for link in connection.getconnections():
-dic = {"refLocalId":link.getRefLocalId(),"points":link.getPoints(),"formalParameter":link.getFormalParameter()}
+dic = {"refLocalId":link.getrefLocalId(),"points":link.getpoints(),"formalParameter":link.getformalParameter()}
 connector["links"].append(dic)
 infos["connectors"].append(connector)
-elif isinstance(instance, plcopen.contact):
+elif isinstance(instance, plcopen.ldObjects_contact):
-infos["name"] = instance.getVariable()
+infos["name"] = instance.getvariable()
 infos["type"] = "contact"
-executionOrder = instance.getExecutionOrderId()
+executionOrder = instance.getexecutionOrderId()
 if executionOrder is not None:
 infos["executionOrder"] = executionOrder
 else:
 infos["executionOrder"] = 0
-infos["negated"] = instance.getNegated()
+infos["negated"] = instance.getnegated()
-infos["edge"] = instance.getContactEdge()
+infos["edge"] = instance.getedge()
 infos["connectors"] = {"input":{},"output":{}}
-infos["connectors"]["input"]["position"] = instance.connectionPointIn.getRelPosition()
+infos["connectors"]["input"]["position"] = instance.connectionPointIn.getrelPositionXY()
 infos["connectors"]["input"]["links"] = []
-connections = instance.connectionPointIn.getConnections()
+connections = instance.connectionPointIn.getconnections()
 if connections:
 for link in connections:
-dic = {"refLocalId":link.getRefLocalId(),"points":link.getPoints(),"formalParameter":link.getFormalParameter()}
+dic = {"refLocalId":link.getrefLocalId(),"points":link.getpoints(),"formalParameter":link.getformalParameter()}
 infos["connectors"]["input"]["links"].append(dic)
-infos["connectors"]["output"]["position"] = instance.connectionPointOut.getRelPosition()
+infos["connectors"]["output"]["position"] = instance.connectionPointOut.getrelPositionXY()
-elif isinstance(instance, plcopen.coil):
+elif isinstance(instance, plcopen.ldObjects_coil):
-infos["name"] = instance.getVariable()
+infos["name"] = instance.getvariable()
 infos["type"] = "coil"
-executionOrder = instance.getExecutionOrderId()
+executionOrder = instance.getexecutionOrderId()
 if executionOrder is not None:
 infos["executionOrder"] = executionOrder
 else:
 infos["executionOrder"] = 0
-infos["negated"] = instance.getNegated()
+infos["negated"] = instance.getnegated()
-infos["storage"] = instance.getCoilStorage()
+infos["storage"] = instance.getstorage()
 infos["connectors"] = {"input":{},"output":{}}
-infos["connectors"]["input"]["position"] = instance.connectionPointIn.getRelPosition()
+infos["connectors"]["input"]["position"] = instance.connectionPointIn.getrelPositionXY()
 infos["connectors"]["input"]["links"] = []
-connections = instance.connectionPointIn.getConnections()
+connections = instance.connectionPointIn.getconnections()
 if connections:
 for link in connections:
-dic = {"refLocalId":link.getRefLocalId(),"points":link.getPoints(),"formalParameter":link.getFormalParameter()}
+dic = {"refLocalId":link.getrefLocalId(),"points":link.getpoints(),"formalParameter":link.getformalParameter()}
 infos["connectors"]["input"]["links"].append(dic)
-infos["connectors"]["output"]["position"] = instance.connectionPointOut.getRelPosition()
+infos["connectors"]["output"]["position"] = instance.connectionPointOut.getrelPositionXY()
-elif isinstance(instance, plcopen.step):
+elif isinstance(instance, plcopen.sfcObjects_step):
-infos["name"] = instance.getName()
+infos["name"] = instance.getname()
 infos["type"] = "step"
-infos["initial"] = instance.getInitialStep()
+infos["initial"] = instance.getinitialStep()
 infos["connectors"] = {}
 if instance.connectionPointIn:
 infos["connectors"]["input"] = {}
-infos["connectors"]["input"]["position"] = instance.connectionPointIn.getRelPosition()
+infos["connectors"]["input"]["position"] = instance.connectionPointIn.getrelPositionXY()
 infos["connectors"]["input"]["links"] = []
-connections = instance.connectionPointIn.getConnections()
+connections = instance.connectionPointIn.getconnections()
 if connections:
 for link in connections:
-dic = {"refLocalId":link.getRefLocalId(),"points":link.getPoints(),"formalParameter":link.getFormalParameter()}
+dic = {"refLocalId":link.getrefLocalId(),"points":link.getpoints(),"formalParameter":link.getformalParameter()}
 infos["connectors"]["input"]["links"].append(dic)
 if instance.connectionPointOut:
-infos["connectors"]["output"] = {"position" : instance.connectionPointOut.getRelPosition()}
+infos["connectors"]["output"] = {"position" : instance.connectionPointOut.getrelPositionXY()}
 if instance.connectionPointOutAction:
-infos["connectors"]["action"] = {"position" : instance.connectionPointOutAction.getRelPosition()}
+infos["connectors"]["action"] = {"position" : instance.connectionPointOutAction.getrelPositionXY()}
-elif isinstance(instance, plcopen.transition):
+elif isinstance(instance, plcopen.sfcObjects_transition):
 infos["type"] = "transition"
-condition = instance.getConditionContent()
+condition = instance.getconditionContent()
-priority = instance.getPriority()
+priority = instance.getpriority()
 if priority == None:
 infos["priority"] = 0
 else:
 infos["priority"] = priority
 infos["condition_type"] = condition["type"]
 infos["connectors"] = {"input":{},"output":{}}
-infos["connectors"]["input"]["position"] = instance.connectionPointIn.getRelPosition()
+infos["connectors"]["input"]["position"] = instance.connectionPointIn.getrelPositionXY()
 infos["connectors"]["input"]["links"] = []
-connections = instance.connectionPointIn.getConnections()
+connections = instance.connectionPointIn.getconnections()
 if connections:
 for link in connections:
-dic = {"refLocalId":link.getRefLocalId(),"points":link.getPoints(),"formalParameter":link.getFormalParameter()}
+dic = {"refLocalId":link.getrefLocalId(),"points":link.getpoints(),"formalParameter":link.getformalParameter()}
 infos["connectors"]["input"]["links"].append(dic)
-infos["connectors"]["output"]["position"] = instance.connectionPointOut.getRelPosition()
+infos["connectors"]["output"]["position"] = instance.connectionPointOut.getrelPositionXY()
 if infos["condition_type"] == "connection":
 infos["connectors"]["connection"] = {}
 infos["connectors"]["connection"]["links"] = []
-connections = instance.getConnections()
+connections = instance.getconnections()
 if connections:
 for link in connections:
-dic = {"refLocalId":link.getRefLocalId(),"points":link.getPoints(),"formalParameter":link.getFormalParameter()}
+dic = {"refLocalId":link.getrefLocalId(),"points":link.getpoints(),"formalParameter":link.getformalParameter()}
 infos["connectors"]["connection"]["links"].append(dic)
 infos["condition"] = None
 else:
 infos["condition"] = condition["value"]
-elif isinstance(instance, (plcopen.selectionDivergence, plcopen.simultaneousDivergence)):
+elif isinstance(instance, (plcopen.sfcObjects_selectionDivergence, plcopen.sfcObjects_simultaneousDivergence)):
-if isinstance(instance, plcopen.selectionDivergence):
+if isinstance(instance, plcopen.sfcObjects_selectionDivergence):
 infos["type"] = "selectionDivergence"
 else:
 infos["type"] = "simultaneousDivergence"
 infos["connectors"] = {"inputs":[],"outputs":[]}
 connector = {}
-connector["position"] = instance.connectionPointIn.getRelPosition()
+connector["position"] = instance.connectionPointIn.getrelPositionXY()
 connector["links"] = []
-connections = instance.connectionPointIn.getConnections()
+connections = instance.connectionPointIn.getconnections()
 if connections:
 for link in connections:
-dic = {"refLocalId":link.getRefLocalId(),"points":link.getPoints(),"formalParameter":link.getFormalParameter()}
+dic = {"refLocalId":link.getrefLocalId(),"points":link.getpoints(),"formalParameter":link.getformalParameter()}
 connector["links"].append(dic)
 infos["connectors"]["inputs"].append(connector)
-for sequence in instance.getConnectionPointOut():
+for sequence in instance.getconnectionPointOut():
 connector = {}
-connector["position"] = sequence.getRelPosition()
+connector["position"] = sequence.getrelPositionXY()
 infos["connectors"]["outputs"].append(connector)
-elif isinstance(instance, (plcopen.selectionConvergence, plcopen.simultaneousConvergence)):
+elif isinstance(instance, (plcopen.sfcObjects_selectionConvergence, plcopen.sfcObjects_simultaneousConvergence)):
-if isinstance(instance, plcopen.selectionConvergence):
+if isinstance(instance, plcopen.sfcObjects_selectionConvergence):
 infos["type"] = "selectionConvergence"
 else:
 infos["type"] = "simultaneousConvergence"
 infos["connectors"] = {"inputs":[],"outputs":[]}
-for sequence in instance.getConnectionPointIn():
+for sequence in instance.getconnectionPointIn():
 connector = {}
-connector["position"] = sequence.getRelPosition()
+connector["position"] = sequence.getrelPositionXY()
 connector["links"] = []
-connections = sequence.getConnections()
+connections = sequence.getconnections()
 if connections:
 for link in connections:
-dic = {"refLocalId":link.getRefLocalId(),"points":link.getPoints(),"formalParameter":link.getFormalParameter()}
+dic = {"refLocalId":link.getrefLocalId(),"points":link.getpoints(),"formalParameter":link.getformalParameter()}
 connector["links"].append(dic)
 infos["connectors"]["inputs"].append(connector)
 connector = {}
-connector["position"] = instance.connectionPointOut.getRelPosition()
+connector["position"] = instance.connectionPointOut.getrelPositionXY()
 infos["connectors"]["outputs"].append(connector)
-elif isinstance(instance, plcopen.jumpStep):
+elif isinstance(instance, plcopen.sfcObjects_jumpStep):
 infos["type"] = "jump"
-infos["target"] = instance.getTargetName()
+infos["target"] = instance.gettargetName()
 infos["connector"] = {}
-infos["connector"]["position"] = instance.connectionPointIn.getRelPosition()
+infos["connector"]["position"] = instance.connectionPointIn.getrelPositionXY()
 infos["connector"]["links"] = []
-connections = instance.connectionPointIn.getConnections()
+connections = instance.connectionPointIn.getconnections()
 if connections:
 for link in connections:
-dic = {"refLocalId":link.getRefLocalId(),"points":link.getPoints(),"formalParameter":link.getFormalParameter()}
+dic = {"refLocalId":link.getrefLocalId(),"points":link.getpoints(),"formalParameter":link.getformalParameter()}
 infos["connector"]["links"].append(dic)
-elif isinstance(instance, plcopen.actionBlock):
+elif isinstance(instance, plcopen.commonObjects_actionBlock):
 infos["type"] = "actionBlock"
-infos["actions"] = instance.getActions()
+infos["actions"] = instance.getactions()
 infos["connector"] = {}
-infos["connector"]["position"] = instance.connectionPointIn.getRelPosition()
+infos["connector"]["position"] = instance.connectionPointIn.getrelPositionXY()
 infos["connector"]["links"] = []
-connections = instance.connectionPointIn.getConnections()
+connections = instance.connectionPointIn.getconnections()
 if connections:
 for link in connections:
-dic = {"refLocalId":link.getRefLocalId(),"points":link.getPoints(),"formalParameter":link.getFormalParameter()}
+dic = {"refLocalId":link.getrefLocalId(),"points":link.getpoints(),"formalParameter":link.getformalParameter()}
 infos["connector"]["links"].append(dic)
 return infos
 return False
 def ClearEditedElementExecutionOrder(self, tagname):
 element = self.GetEditedElement(tagname)
 if element is not None:
-element.resetExecutionOrder()
+element.resetexecutionOrder()
 def ResetEditedElementExecutionOrder(self, tagname):
 element = self.GetEditedElement(tagname)
 if element is not None:
-element.compileExecutionOrder()
+element.compileexecutionOrder()
 # Return the variable type of the given pou
 def GetEditedElementVarValueType(self, tagname, varname):
 words = tagname.split("::")
 if words[0] in ["P","T","A"]:
-pou = self.Project.getPou(words[1])
+pou = self.Project.getpou(words[1])
-for type, varlist in pou.getVars():
+for type, varlist in pou.getvars():
-for var in varlist.getVariable():
+for var in varlist.getvariable():
-if var.getName() == varname:
+if var.getname() == varname:
-vartype_content = var.getType().getContent()
+vartype_content = var.gettype().getcontent()
 if vartype_content["name"] == "derived":
-return vartype_content["value"].getName()
+return vartype_content["value"].getname()
 elif vartype_content["name"] in ["string", "wstring"]:
 return vartype_content["name"].upper()
 else:
 return vartype_content["name"]
 return None
 result = wire.GetConnectedInfos(-1)
 else:
 result = wire.GetConnectedInfos(0)
 if result != None:
 refLocalId, formalParameter = result
-connection.addConnection()
+connection.addconnection()
-connection.setConnectionId(idx, refLocalId)
+connection.setconnectionId(idx, refLocalId)
-connection.setConnectionPoints(idx, points)
+connection.setconnectionPoints(idx, points)
 if formalParameter != "":
-connection.setConnectionParameter(idx, formalParameter)
+connection.setconnectionParameter(idx, formalParameter)
 else:
-connection.setConnectionParameter(idx, None)
+connection.setconnectionParameter(idx, None)
 idx += 1
 def AddEditedElementPouVar(self, tagname, type, name):
 words = tagname.split("::")
 if words[0] in ['P', 'T', 'A']:
-pou = self.Project.getPou(words[1])
+pou = self.Project.getpou(words[1])
-pou.addPouVar(type, name)
+pou.addpouVar(type, name)
 def ChangeEditedElementPouVar(self, tagname, old_type, old_name, new_type, new_name):
 words = tagname.split("::")
 if words[0] in ['P', 'T', 'A']:
-pou = self.Project.getPou(words[1])
+pou = self.Project.getpou(words[1])
-pou.changePouVar(old_type, old_name, new_type, new_name)
+pou.changepouVar(old_type, old_name, new_type, new_name)
 def AddEditedElementBlock(self, tagname, id, blocktype, blockname = None):
 element = self.GetEditedElement(tagname)
 if element is not None:
-block = plcopen.block()
+block = plcopen.fbdObjects_block()
-block.setLocalId(id)
+block.setlocalId(id)
-block.setTypeName(blocktype)
+block.settypeName(blocktype)
 blocktype_infos = GetBlockType(blocktype)
 if blocktype_infos["type"] != "function" and blockname is not None:
-block.setInstanceName(blockname)
+block.setinstanceName(blockname)
 self.AddEditedElementPouVar(tagname, blocktype, blockname)
-element.addInstance("block", block)
+element.addinstance("block", block)
 self.RefreshPouUsingTree()
 def SetEditedElementBlockInfos(self, tagname, id, infos):
 element = self.GetEditedElement(tagname)
 if element is not None:
-block = element.getInstance(id)
+block = element.getinstance(id)
-blocktype = infos.get("type", block.getTypeName())
+blocktype = infos.get("type", block.gettypeName())
 blocktype_infos = GetBlockType(blocktype)
 if blocktype_infos["type"] != "function":
 if "name" in infos or "type" in infos:
-old_name = block.getInstanceName()
+old_name = block.getinstanceName()
-old_type = block.getTypeName()
+old_type = block.gettypeName()
 new_name = infos.get("name", old_name)
 new_type = infos.get("type", old_type)
 self.ChangeEditedElementPouVar(tagname, old_type, old_name, new_type, new_name)
 for param, value in infos.items():
 if param == "name":
-block.setInstanceName(value)
+block.setinstanceName(value)
 elif param == "type":
-block.setTypeName(value)
+block.settypeName(value)
-elif param == "executionOrder" and block.getExecutionOrderId() != value:
+elif param == "executionOrder" and block.getexecutionOrderId() != value:
-self.GetEditedElement(tagname).setElementExecutionOrder(block, value)
+self.GetEditedElement(tagname).setelementExecutionOrder(block, value)
 elif param == "height":
-block.setHeight(value)
+block.setheight(value)
 elif param == "width":
-block.setWidth(value)
+block.setwidth(value)
 elif param == "x":
-block.setX(value)
+block.setx(value)
 elif param == "y":
-block.setY(value)
+block.sety(value)
 elif param == "connectors":
-block.inputVariables.setVariable([])
+block.inputVariables.setvariable([])
-block.outputVariables.setVariable([])
+block.outputVariables.setvariable([])
 for connector in value["inputs"]:
 variable = plcopen.inputVariables_variable()
-variable.setFormalParameter(connector.GetName())
+variable.setformalParameter(connector.GetName())
 if connector.IsNegated():
-variable.setNegated(True)
+variable.setnegated(True)
 if connector.GetEdge() != "none":
-variable.setConnectorEdge(connector.GetEdge())
+variable.setedge(connector.GetEdge())
 position = connector.GetRelPosition()
-variable.connectionPointIn.setRelPosition(position.x, position.y)
+variable.connectionPointIn.setrelPositionXY(position.x, position.y)
 self.SetConnectionWires(variable.connectionPointIn, connector)
-block.inputVariables.appendVariable(variable)
+block.inputVariables.appendvariable(variable)
 for connector in value["outputs"]:
 variable = plcopen.outputVariables_variable()
-variable.setFormalParameter(connector.GetName())
+variable.setformalParameter(connector.GetName())
 if connector.IsNegated():
-variable.setNegated(True)
+variable.setnegated(True)
 if connector.GetEdge() != "none":
-variable.setConnectorEdge(connector.GetEdge())
+variable.setedge(connector.GetEdge())
 position = connector.GetRelPosition()
-variable.addConnectionPointOut()
+variable.addconnectionPointOut()
-variable.connectionPointOut.setRelPosition(position.x, position.y)
+variable.connectionPointOut.setrelPositionXY(position.x, position.y)
-block.outputVariables.appendVariable(variable)
+block.outputVariables.appendvariable(variable)
 self.RefreshPouUsingTree()
 def AddEditedElementVariable(self, tagname, id, type):
 element = self.GetEditedElement(tagname)
 if element is not None:
 if type == INPUT:
 name = "inVariable"
-variable = plcopen.inVariable()
+variable = plcopen.fbdObjects_inVariable()
 elif type == OUTPUT:
 name = "outVariable"
-variable = plcopen.outVariable()
+variable = plcopen.fbdObjects_outVariable()
 elif type == INOUT:
 name = "inOutVariable"
-variable = plcopen.inOutVariable()
+variable = plcopen.fbdObjects_inOutVariable()
-variable.setLocalId(id)
+variable.setlocalId(id)
-element.addInstance(name, variable)
+element.addinstance(name, variable)
 def SetEditedElementVariableInfos(self, tagname, id, infos):
 element = self.GetEditedElement(tagname)
 if element is not None:
-variable = element.getInstance(id)
+variable = element.getinstance(id)
 for param, value in infos.items():
 if param == "name":
-variable.setExpression(value)
+variable.setexpression(value)
-elif param == "executionOrder" and variable.getExecutionOrderId() != value:
+elif param == "executionOrder" and variable.getexecutionOrderId() != value:
-self.GetEditedElement(tagname).setElementExecutionOrder(variable, value)
+self.GetEditedElement(tagname).setelementExecutionOrder(variable, value)
 elif param == "height":
-variable.setHeight(value)
+variable.setheight(value)
 elif param == "width":
-variable.setWidth(value)
+variable.setwidth(value)
 elif param == "x":
-variable.setX(value)
+variable.setx(value)
 elif param == "y":
-variable.setY(value)
+variable.sety(value)
 elif param == "connectors":
-if isinstance(variable, plcopen.inVariable):
+if isinstance(variable, plcopen.fbdObjects_inVariable):
 if value["output"].IsNegated():
-variable.setNegated(True)
+variable.setnegated(True)
 if value["output"].GetEdge() != "none":
-variable.setConnectorEdge(value["output"].GetEdge())
+variable.setedge(value["output"].GetEdge())
 position = value["output"].GetRelPosition()
-variable.addConnectionPointOut()
+variable.addconnectionPointOut()
-variable.connectionPointOut.setRelPosition(position.x, position.y)
+variable.connectionPointOut.setrelPositionXY(position.x, position.y)
-elif isinstance(variable, plcopen.outVariable):
+elif isinstance(variable, plcopen.fbdObjects_outVariable):
 if value["input"].IsNegated():
-variable.setNegated(True)
+variable.setnegated(True)
 if value["input"].GetEdge() != "none":
-variable.setConnectorEdge(value["input"].GetEdge())
+variable.setedge(value["input"].GetEdge())
 position = value["input"].GetRelPosition()
-variable.addConnectionPointIn()
+variable.addconnectionPointIn()
-variable.connectionPointIn.setRelPosition(position.x, position.y)
+variable.connectionPointIn.setrelPositionXY(position.x, position.y)
 self.SetConnectionWires(variable.connectionPointIn, value["input"])
-elif isinstance(variable, plcopen.inOutVariable):
+elif isinstance(variable, plcopen.fbdObjects_inOutVariable):
 if value["input"].IsNegated():
-variable.setNegatedIn(True)
+variable.setnegatedIn(True)
 if value["input"].GetEdge() != "none":
-variable.setInputEdge(value["input"].GetEdge())
+variable.setedgeIn(value["input"].GetEdge())
 if value["output"].IsNegated():
-variable.setNegatedOut(True)
+variable.setnegatedOut(True)
 if value["output"].GetEdge() != "none":
-variable.setOutputEdge(value["output"].GetEdge())
+variable.setedgeOut(value["output"].GetEdge())
 position = value["output"].GetRelPosition()
-variable.addConnectionPointOut()
+variable.addconnectionPointOut()
-variable.connectionPointOut.setRelPosition(position.x, position.y)
+variable.connectionPointOut.setrelPositionXY(position.x, position.y)
 position = value["input"].GetRelPosition()
-variable.addConnectionPointIn()
+variable.addconnectionPointIn()
-variable.connectionPointIn.setRelPosition(position.x, position.y)
+variable.connectionPointIn.setrelPositionXY(position.x, position.y)
 self.SetConnectionWires(variable.connectionPointIn, value["input"])
 def AddEditedElementConnection(self, tagname, id, type):
 element = self.GetEditedElement(tagname)
 if element is not None:
 if type == CONNECTOR:
 name = "connector"
-connection = plcopen.connector()
+connection = plcopen.commonObjects_connector()
 elif type == CONTINUATION:
 name = "continuation"
-connection = plcopen.continuation()
+connection = plcopen.commonObjects_continuation()
-connection.setLocalId(id)
+connection.setlocalId(id)
-element.addInstance(name, connection)
+element.addinstance(name, connection)
 def SetEditedElementConnectionInfos(self, tagname, id, infos):
 element = self.GetEditedElement(tagname)
 if element is not None:
-connection = element.getInstance(id)
+connection = element.getinstance(id)
 for param, value in infos.items():
 if param == "name":
-connection.setName(value)
+connection.setname(value)
 elif param == "height":
-connection.setHeight(value)
+connection.setheight(value)
 elif param == "width":
-connection.setWidth(value)
+connection.setwidth(value)
 elif param == "x":
-connection.setX(value)
+connection.setx(value)
 elif param == "y":
-connection.setY(value)
+connection.sety(value)
 elif param == "connector":
 position = value.GetRelPosition()
-if isinstance(connection, plcopen.continuation):
+if isinstance(connection, plcopen.commonObjects_continuation):
-connection.addConnectionPointOut()
+connection.addconnectionPointOut()
-connection.connectionPointOut.setRelPosition(position.x, position.y)
+connection.connectionPointOut.setrelPositionXY(position.x, position.y)
-elif isinstance(connection, plcopen.connector):
+elif isinstance(connection, plcopen.commonObjects_connector):
-connection.addConnectionPointIn()
+connection.addconnectionPointIn()
-connection.connectionPointIn.setRelPosition(position.x, position.y)
+connection.connectionPointIn.setrelPositionXY(position.x, position.y)
 self.SetConnectionWires(connection.connectionPointIn, value)
 def AddEditedElementComment(self, tagname, id):
 element = self.GetEditedElement(tagname)
 if element is not None:
-comment = plcopen.comment()
+comment = plcopen.commonObjects_comment()
-comment.setLocalId(id)
+comment.setlocalId(id)
-element.addInstance("comment", comment)
+element.addinstance("comment", comment)
 def SetEditedElementCommentInfos(self, tagname, id, infos):
 element = self.GetEditedElement(tagname)
 if element is not None:
-comment = element.getInstance(id)
+comment = element.getinstance(id)
 for param, value in infos.items():
 if param == "content":
-comment.setContentText(value)
+comment.setcontentText(value)
 elif param == "height":
-comment.setHeight(value)
+comment.setheight(value)
 elif param == "width":
-comment.setWidth(value)
+comment.setwidth(value)
 elif param == "x":
-comment.setX(value)
+comment.setx(value)
 elif param == "y":
-comment.setY(value)
+comment.sety(value)
 def AddEditedElementPowerRail(self, tagname, id, type):
 element = self.GetEditedElement(tagname)
 if element is not None:
 if type == LEFTRAIL:
 name = "leftPowerRail"
-powerrail = plcopen.leftPowerRail()
+powerrail = plcopen.ldObjects_leftPowerRail()
 elif type == RIGHTRAIL:
 name = "rightPowerRail"
-powerrail = plcopen.rightPowerRail()
+powerrail = plcopen.ldObjects_rightPowerRail()
-powerrail.setLocalId(id)
+powerrail.setlocalId(id)
-element.addInstance(name, powerrail)
+element.addinstance(name, powerrail)
 def SetEditedElementPowerRailInfos(self, tagname, id, infos):
 element = self.GetEditedElement(tagname)
 if element is not None:
-powerrail = element.getInstance(id)
+powerrail = element.getinstance(id)
 for param, value in infos.items():
 if param == "height":
-powerrail.setHeight(value)
+powerrail.setheight(value)
 elif param == "width":
-powerrail.setWidth(value)
+powerrail.setwidth(value)
 elif param == "x":
-powerrail.setX(value)
+powerrail.setx(value)
 elif param == "y":
-powerrail.setY(value)
+powerrail.sety(value)
 elif param == "connectors":
-if isinstance(powerrail, plcopen.leftPowerRail):
+if isinstance(powerrail, plcopen.ldObjects_leftPowerRail):
-powerrail.setConnectionPointOut([])
+powerrail.setconnectionPointOut([])
 for connector in value:
 position = connector.GetRelPosition()
 connection = plcopen.leftPowerRail_connectionPointOut()
-connection.setRelPosition(position.x, position.y)
+connection.setrelPositionXY(position.x, position.y)
 powerrail.connectionPointOut.append(connection)
-elif isinstance(powerrail, plcopen.rightPowerRail):
+elif isinstance(powerrail, plcopen.ldObjects_rightPowerRail):
-powerrail.setConnectionPointIn([])
+powerrail.setconnectionPointIn([])
 for connector in value:
 position = connector.GetRelPosition()
 connection = plcopen.connectionPointIn()
-connection.setRelPosition(position.x, position.y)
+connection.setrelPositionXY(position.x, position.y)
 self.SetConnectionWires(connection, connector)
 powerrail.connectionPointIn.append(connection)
 def AddEditedElementContact(self, tagname, id):
 element = self.GetEditedElement(tagname)
 if element is not None:
-contact = plcopen.contact()
+contact = plcopen.ldObjects_contact()
-contact.setLocalId(id)
+contact.setlocalId(id)
-element.addInstance("contact", contact)
+element.addinstance("contact", contact)
 def SetEditedElementContactInfos(self, tagname, id, infos):
 element = self.GetEditedElement(tagname)
 if element is not None:
-contact = element.getInstance(id)
+contact = element.getinstance(id)
 for param, value in infos.items():
 if param == "name":
-contact.setVariable(value)
+contact.setvariable(value)
 elif param == "type":
 if value == CONTACT_NORMAL:
-contact.setNegated(False)
+contact.setnegated(False)
-contact.setContactEdge("none")
+contact.setedge("none")
 elif value == CONTACT_REVERSE:
-contact.setNegated(True)
+contact.setnegated(True)
-contact.setContactEdge("none")
+contact.setedge("none")
 elif value == CONTACT_RISING:
-contact.setNegated(False)
+contact.setnegated(False)
-contact.setContactEdge("rising")
+contact.setedge("rising")
 elif value == CONTACT_FALLING:
-contact.setNegated(False)
+contact.setnegated(False)
-contact.setContactEdge("falling")
+contact.setedge("falling")
 elif param == "height":
-contact.setHeight(value)
+contact.setheight(value)
 elif param == "width":
-contact.setWidth(value)
+contact.setwidth(value)
 elif param == "x":
-contact.setX(value)
+contact.setx(value)
 elif param == "y":
-contact.setY(value)
+contact.sety(value)
 elif param == "connectors":
 input_connector = value["input"]
 position = input_connector.GetRelPosition()
-contact.addConnectionPointIn()
+contact.addconnectionPointIn()
-contact.connectionPointIn.setRelPosition(position.x, position.y)
+contact.connectionPointIn.setrelPositionXY(position.x, position.y)
 self.SetConnectionWires(contact.connectionPointIn, input_connector)
 output_connector = value["output"]
 position = output_connector.GetRelPosition()
-contact.addConnectionPointOut()
+contact.addconnectionPointOut()
-contact.connectionPointOut.setRelPosition(position.x, position.y)
+contact.connectionPointOut.setrelPositionXY(position.x, position.y)
 def AddEditedElementCoil(self, tagname, id):
 element = self.GetEditedElement(tagname)
 if element is not None:
-coil = plcopen.coil()
+coil = plcopen.ldObjects_coil()
-coil.setLocalId(id)
+coil.setlocalId(id)
-element.addInstance("coil", coil)
+element.addinstance("coil", coil)
 def SetEditedElementCoilInfos(self, tagname, id, infos):
 element = self.GetEditedElement(tagname)
 if element is not None:
-coil = element.getInstance(id)
+coil = element.getinstance(id)
 for param, value in infos.items():
 if param == "name":
-coil.setVariable(value)
+coil.setvariable(value)
 elif param == "type":
 if value == COIL_NORMAL:
-coil.setNegated(False)
+coil.setnegated(False)
-coil.setCoilStorage("none")
+coil.setstorage("none")
 elif value == COIL_REVERSE:
-coil.setNegated(True)
+coil.setnegated(True)
-coil.setCoilStorage("none")
+coil.setstorage("none")
 elif value == COIL_SET:
-coil.setNegated(False)
+coil.setnegated(False)
-coil.setCoilStorage("set")
+coil.setstorage("set")
 elif value == COIL_RESET:
-coil.setNegated(False)
+coil.setnegated(False)
-coil.setCoilStorage("reset")
+coil.setstorage("reset")
 elif param == "height":
-coil.setHeight(value)
+coil.setheight(value)
 elif param == "width":
-coil.setWidth(value)
+coil.setwidth(value)
 elif param == "x":
-coil.setX(value)
+coil.setx(value)
 elif param == "y":
-coil.setY(value)
+coil.sety(value)
 elif param == "connectors":
 input_connector = value["input"]
 position = input_connector.GetRelPosition()
-coil.addConnectionPointIn()
+coil.addconnectionPointIn()
-coil.connectionPointIn.setRelPosition(position.x, position.y)
+coil.connectionPointIn.setrelPositionXY(position.x, position.y)
 self.SetConnectionWires(coil.connectionPointIn, input_connector)
 output_connector = value["output"]
 position = output_connector.GetRelPosition()
-coil.addConnectionPointOut()
+coil.addconnectionPointOut()
-coil.connectionPointOut.setRelPosition(position.x, position.y)
+coil.connectionPointOut.setrelPositionXY(position.x, position.y)
 def AddEditedElementStep(self, tagname, id):
 element = self.GetEditedElement(tagname)
 if element is not None:
-step = plcopen.step()
+step = plcopen.sfcObjects_step()
-step.setLocalId(id)
+step.setlocalId(id)
-element.addInstance("step", step)
+element.addinstance("step", step)
 def SetEditedElementStepInfos(self, tagname, id, infos):
 element = self.GetEditedElement(tagname)
 if element is not None:
-step = element.getInstance(id)
+step = element.getinstance(id)
 for param, value in infos.items():
 if param == "name":
-step.setName(value)
+step.setname(value)
 elif param == "initial":
-step.setInitialStep(value)
+step.setinitialStep(value)
 elif param == "height":
-step.setHeight(value)
+step.setheight(value)
 elif param == "width":
-step.setWidth(value)
+step.setwidth(value)
 elif param == "x":
-step.setX(value)
+step.setx(value)
 elif param == "y":
-step.setY(value)
+step.sety(value)
 elif param == "connectors":
 input_connector = value["input"]
 if input_connector:
 position = input_connector.GetRelPosition()
-step.addConnectionPointIn()
+step.addconnectionPointIn()
-step.connectionPointIn.setRelPosition(position.x, position.y)
+step.connectionPointIn.setrelPositionXY(position.x, position.y)
 self.SetConnectionWires(step.connectionPointIn, input_connector)
 else:
-step.deleteConnectionPointIn()
+step.deleteconnectionPointIn()
 output_connector = value["output"]
 if output_connector:
 position = output_connector.GetRelPosition()
-step.addConnectionPointOut()
+step.addconnectionPointOut()
-step.connectionPointOut.setRelPosition(position.x, position.y)
+step.connectionPointOut.setrelPositionXY(position.x, position.y)
 else:
-step.deleteConnectionPointOut()
+step.deleteconnectionPointOut()
 action_connector = value["action"]
 if action_connector:
 position = action_connector.GetRelPosition()
-step.addConnectionPointOutAction()
+step.addconnectionPointOutAction()
-step.connectionPointOutAction.setRelPosition(position.x, position.y)
+step.connectionPointOutAction.setrelPositionXY(position.x, position.y)
 else:
-step.deleteConnectionPointOutAction()
+step.deleteconnectionPointOutAction()
 def AddEditedElementTransition(self, tagname, id):
 element = self.GetEditedElement(tagname)
 if element is not None:
-transition = plcopen.transition()
+transition = plcopen.sfcObjects_transition()
-transition.setLocalId(id)
+transition.setlocalId(id)
-element.addInstance("transition", transition)
+element.addinstance("transition", transition)
 def SetEditedElementTransitionInfos(self, tagname, id, infos):
 element = self.GetEditedElement(tagname)
 if element is not None:
-transition = element.getInstance(id)
+transition = element.getinstance(id)
 for param, value in infos.items():
 if param == "type" and value != "connection":
-transition.setConditionContent(value, infos["condition"])
+transition.setconditionContent(value, infos["condition"])
 elif param == "height":
-transition.setHeight(value)
+transition.setheight(value)
 elif param == "width":
-transition.setWidth(value)
+transition.setwidth(value)
 elif param == "x":
-transition.setX(value)
+transition.setx(value)
 elif param == "y":
-transition.setY(value)
+transition.sety(value)
 elif param == "priority":
 if value != 0:
-transition.setPriority(value)
+transition.setpriority(value)
 else:
-transition.setPriority(None)
+transition.setpriority(None)
 elif param == "connectors":
 input_connector = value["input"]
 position = input_connector.GetRelPosition()
-transition.addConnectionPointIn()
+transition.addconnectionPointIn()
-transition.connectionPointIn.setRelPosition(position.x, position.y)
+transition.connectionPointIn.setrelPositionXY(position.x, position.y)
 self.SetConnectionWires(transition.connectionPointIn, input_connector)
 output_connector = value["output"]
 position = output_connector.GetRelPosition()
-transition.addConnectionPointOut()
+transition.addconnectionPointOut()
-transition.connectionPointOut.setRelPosition(position.x, position.y)
+transition.connectionPointOut.setrelPositionXY(position.x, position.y)
 if infos.get("type", None) == "connection":
-transition.setConditionContent("connection", None)
+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()
+divergence = plcopen.sfcObjects_selectionDivergence()
 elif type == SELECTION_CONVERGENCE:
 name = "selectionConvergence"
-divergence = plcopen.selectionConvergence()
+divergence = plcopen.sfcObjects_selectionConvergence()
 elif type == SIMULTANEOUS_DIVERGENCE:
 name = "simultaneousDivergence"
-divergence = plcopen.simultaneousDivergence()
+divergence = plcopen.sfcObjects_simultaneousDivergence()
 elif type == SIMULTANEOUS_CONVERGENCE:
 name = "simultaneousConvergence"
-divergence = plcopen.simultaneousConvergence()
+divergence = plcopen.sfcObjects_simultaneousConvergence()
-divergence.setLocalId(id)
+divergence.setlocalId(id)
-element.addInstance(name, divergence)
+element.addinstance(name, divergence)
 def SetEditedElementDivergenceInfos(self, tagname, id, infos):
 element = self.GetEditedElement(tagname)
 if element is not None:
-divergence = element.getInstance(id)
+divergence = element.getinstance(id)
 for param, value in infos.items():
 if param == "height":
-divergence.setHeight(value)
+divergence.setheight(value)
 elif param == "width":
-divergence.setWidth(value)
+divergence.setwidth(value)
 elif param == "x":
-divergence.setX(value)
+divergence.setx(value)
 elif param == "y":
-divergence.setY(value)
+divergence.sety(value)
 elif param == "connectors":
 input_connectors = value["inputs"]
-if isinstance(divergence, (plcopen.selectionDivergence, plcopen.simultaneousDivergence)):
+if isinstance(divergence, (plcopen.sfcObjects_selectionDivergence, plcopen.sfcObjects_simultaneousDivergence)):
 position = input_connectors[0].GetRelPosition()
-divergence.addConnectionPointIn()
+divergence.addconnectionPointIn()
-divergence.connectionPointIn.setRelPosition(position.x, position.y)
+divergence.connectionPointIn.setrelPositionXY(position.x, position.y)
 self.SetConnectionWires(divergence.connectionPointIn, input_connectors[0])
 else:
-divergence.setConnectionPointIn([])
+divergence.setconnectionPointIn([])
 for input_connector in input_connectors:
 position = input_connector.GetRelPosition()
-if isinstance(divergence, plcopen.selectionConvergence):
+if isinstance(divergence, plcopen.sfcObjects_selectionConvergence):
 connection = plcopen.selectionConvergence_connectionPointIn()
 else:
 connection = plcopen.connectionPointIn()
-connection.setRelPosition(position.x, position.y)
+connection.setrelPositionXY(position.x, position.y)
 self.SetConnectionWires(connection, input_connector)
-divergence.appendConnectionPointIn(connection)
+divergence.appendconnectionPointIn(connection)
 output_connectors = value["outputs"]
-if isinstance(divergence, (plcopen.selectionConvergence, plcopen.simultaneousConvergence)):
+if isinstance(divergence, (plcopen.sfcObjects_selectionConvergence, plcopen.sfcObjects_simultaneousConvergence)):
 position = output_connectors[0].GetRelPosition()
-divergence.addConnectionPointOut()
+divergence.addconnectionPointOut()
-divergence.connectionPointOut.setRelPosition(position.x, position.y)
+divergence.connectionPointOut.setrelPositionXY(position.x, position.y)
 else:
-divergence.setConnectionPointOut([])
+divergence.setconnectionPointOut([])
 for output_connector in output_connectors:
 position = output_connector.GetRelPosition()
-if isinstance(divergence, plcopen.selectionDivergence):
+if isinstance(divergence, plcopen.sfcObjects_selectionDivergence):
 connection = plcopen.selectionDivergence_connectionPointOut()
 else:
 connection = plcopen.simultaneousDivergence_connectionPointOut()
-connection.setRelPosition(position.x, position.y)
+connection.setrelPositionXY(position.x, position.y)
-divergence.appendConnectionPointOut(connection)
+divergence.appendconnectionPointOut(connection)
 def AddEditedElementJump(self, tagname, id):
 element = self.GetEditedElement(tagname)
 if element is not None:
-jump = plcopen.jumpStep()
+jump = plcopen.sfcObjects_jumpStep()
-jump.setLocalId(id)
+jump.setlocalId(id)
-element.addInstance("jumpStep", jump)
+element.addinstance("jumpStep", jump)
 def SetEditedElementJumpInfos(self, tagname, id, infos):
 element = self.GetEditedElement(tagname)
 if element is not None:
-jump = element.getInstance(id)
+jump = element.getinstance(id)
 for param, value in infos.items():
 if param == "target":
-jump.setTargetName(value)
+jump.settargetName(value)
 elif param == "height":
-jump.setHeight(value)
+jump.setheight(value)
 elif param == "width":
-jump.setWidth(value)
+jump.setwidth(value)
 elif param == "x":
-jump.setX(value)
+jump.setx(value)
 elif param == "y":
-jump.setY(value)
+jump.sety(value)
 elif param == "connector":
 position = value.GetRelPosition()
-jump.addConnectionPointIn()
+jump.addconnectionPointIn()
-jump.connectionPointIn.setRelPosition(position.x, position.y)
+jump.connectionPointIn.setrelPositionXY(position.x, position.y)
 self.SetConnectionWires(jump.connectionPointIn, value)
 def AddEditedElementActionBlock(self, tagname, id):
 element = self.GetEditedElement(tagname)
 if element is not None:
-actionBlock = plcopen.actionBlock()
+actionBlock = plcopen.commonObjects_actionBlock()
-actionBlock.setLocalId(id)
+actionBlock.setlocalId(id)
-element.addInstance("actionBlock", actionBlock)
+element.addinstance("actionBlock", actionBlock)
 def SetEditedElementActionBlockInfos(self, tagname, id, infos):
 element = self.GetEditedElement(tagname)
 if element is not None:
-actionBlock = element.getInstance(id)
+actionBlock = element.getinstance(id)
 for param, value in infos.items():
 if param == "actions":
-actionBlock.setActions(value)
+actionBlock.setactions(value)
 elif param == "height":
-actionBlock.setHeight(value)
+actionBlock.setheight(value)
 elif param == "width":
-actionBlock.setWidth(value)
+actionBlock.setwidth(value)
 elif param == "x":
-actionBlock.setX(value)
+actionBlock.setx(value)
 elif param == "y":
-actionBlock.setY(value)
+actionBlock.sety(value)
 elif param == "connector":
 position = value.GetRelPosition()
-actionBlock.addConnectionPointIn()
+actionBlock.addconnectionPointIn()
-actionBlock.connectionPointIn.setRelPosition(position.x, position.y)
+actionBlock.connectionPointIn.setrelPositionXY(position.x, position.y)
 self.SetConnectionWires(actionBlock.connectionPointIn, value)
 def RemoveEditedElementInstance(self, tagname, id):
 element = self.GetEditedElement(tagname)
 if element is not None:
-instance = element.getInstance(id)
+instance = element.getinstance(id)
-if isinstance(instance, plcopen.block):
+if isinstance(instance, plcopen.fbdObjects_block):
-blocktype = instance.getTypeName()
+blocktype = instance.gettypeName()
-element.removePouVar(blocktype, instance.getInstanceName())
+element.removepouVar(blocktype, instance.getinstanceName())
-element.removeInstance(id)
+element.removeinstance(id)
 self.RefreshPouUsingTree()
 def GetEditedResourceVariables(self, tagname):
 varlist = []
 words = tagname.split("::")
 return varlist
 def SetEditedResourceInfos(self, tagname, tasks, instances):
 resource = self.GetEditedElement(tagname)
 if resource is not None:
-resource.setTask([])
+resource.settask([])
-resource.setPouInstance([])
+resource.setpouInstance([])
 task_list = {}
 for task in tasks:
 new_task = plcopen.resource_task()
-new_task.setName(task["Name"])
+new_task.setname(task["Name"])
 if task["Single"] != "":
-new_task.setSingle(task["Single"])
+new_task.setsingle(task["Single"])
 result = duration_model.match(task["Interval"]).groups()
 if reduce(lambda x, y: x or y != None, result):
 values = []
 for value in result[:-1]:
 if value != None:
 values.append(int(value))
 else:
 values.append(0)
 values.append(int(float(result[-1]) * 1000))
-new_task.setInterval(time(*values))
+new_task.setinterval(time(*values))
-new_task.priority.setValue(int(task["Priority"]))
+new_task.setpriority(int(task["Priority"]))
 if task["Name"] != "":
 task_list[task["Name"]] = new_task
-resource.appendTask(new_task)
+resource.appendtask(new_task)
 for instance in instances:
 new_instance = plcopen.pouInstance()
-new_instance.setName(instance["Name"])
+new_instance.setname(instance["Name"])
-new_instance.setType(instance["Type"])
+new_instance.settype(instance["Type"])
 if instance["Task"] != "":
-task_list[instance["Task"]].appendPouInstance(new_instance)
+task_list[instance["Task"]].appendpouInstance(new_instance)
 else:
-resource.appendPouInstance(new_instance)
+resource.appendpouInstance(new_instance)
 def GetEditedResourceInfos(self, tagname):
 resource = self.GetEditedElement(tagname)
 if resource is not None:
-tasks = resource.getTask()
+tasks = resource.gettask()
-instances = resource.getPouInstance()
+instances = resource.getpouInstance()
 tasks_data = []
 instances_data = []
 for task in tasks:
 new_task = {}
-new_task["Name"] = task.getName()
+new_task["Name"] = task.getname()
-single = task.getSingle()
+single = task.getsingle()
 if single:
 new_task["Single"] = single
 else:
 new_task["Single"] = ""
-interval = task.getInterval()
+interval = task.getinterval()
 if interval:
 text = ""
 if interval.hour != 0:
 text += "%dh"%interval.hour
 if interval.minute != 0:
 else:
 text += "%dms"%(interval.microsecond / 1000)
 new_task["Interval"] = text
 else:
 new_task["Interval"] = ""
-new_task["Priority"] = str(task.priority.getValue())
+new_task["Priority"] = str(task.getpriority())
 tasks_data.append(new_task)
-for instance in task.getPouInstance():
+for instance in task.getpouInstance():
 new_instance = {}
-new_instance["Name"] = instance.getName()
+new_instance["Name"] = instance.getname()
-new_instance["Type"] = instance.getType()
+new_instance["Type"] = instance.gettype()
-new_instance["Task"] = task.getName()
+new_instance["Task"] = task.getname()
 instances_data.append(new_instance)
 for instance in instances:
 new_instance = {}
-new_instance["Name"] = instance.getName()
+new_instance["Name"] = instance.getname()
-new_instance["Type"] = instance.getType()
+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:
+xmlfile = open(filepath, 'r')
-if sys:
+tree = minidom.parse(xmlfile)
-sys.stdout = HolePseudoFile()
+xmlfile.close()
-result = pyxsval.parseAndValidate(filepath, os.path.join(ScriptDirectory, "plcopen", "TC6_XML_V10_B.xsd"))
-if sys:
-sys.stdout = sys.__stdout__
-tree = result.getTree()
-else:
-xmlfile = open(filepath, 'r')
-tree = minidom.parse(xmlfile)
-xmlfile.close()
 self.Project = plcopen.project()
 for child in tree.childNodes:
 if child.nodeType == tree.ELEMENT_NODE and child.nodeName == "project":
-self.Project.loadXMLTree(child)
+self.Project.loadXMLTree(child, ["xmlns", "xmlns:xhtml", "xmlns:xsi", "xsi:schemaLocation"])
 self.SetFilePath(filepath)
 self.ProjectBuffer = UndoBuffer(self.Copy(self.Project), True)
 self.Buffering = False
 self.ElementsOpened = []
 self.CurrentElementEditing = None
 def SaveXMLFile(self, filepath = None):
 if not filepath and self.FilePath == "":
 return False
 else:
-contentheader = self.Project.getContentHeader()
+contentheader = self.Project.getcontentHeader()
 contentheader["modificationDateTime"] = datetime(*localtime()[:6])
-self.Project.setContentHeader(contentheader)
+self.Project.setcontentHeader(contentheader)
 text = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
 extras = {"xmlns" : "http://www.plcopen.org/xml/tc6.xsd",
 "xmlns:xhtml" : "http://www.w3.org/1999/xhtml",
 "xmlns:xsi" : "http://www.w3.org/2001/XMLSchema-instance",
 "xsi:schemaLocation" : "http://www.plcopen.org/xml/tc6.xsd http://www.plcopen.org/xml/tc6.xsd"}
 text += self.Project.generateXMLText("project", 0, extras)
-if self.VerifyXML:
-if sys:
-sys.stdout = HolePseudoFile()
-pyxsval.parseAndValidateString(text, open(os.path.join(ScriptDirectory, "plcopen", "TC6_XML_V10_B.xsd"),"r").read())
-if sys:
-sys.stdout = sys.__stdout__
 if filepath:
 xmlfile = open(filepath,"w")
 else:
 xmlfile = open(self.FilePath,"w")

changeset 151	aaa80b48bead
parent 145	4fb225afddf4
child 154	203c4acdaf27