plcopeneditor_history: comparison plcopen/plcopen.py

equal deleted inserted replaced

-:f7832baaad84
+:aaa80b48bead
 Define which action qualifier must be associated with a duration
 """
 QualifierList = {"N" : False, "R" : False, "S" : False, "L" : True, "D" : True,
 "P" : False, "P0" : False, "P1" : False, "SD" : True, "DS" : True, "SL" : True}
-PLCOpenClasses, PLCOpenTypes = GenerateClassesFromXSD(os.path.join(os.path.split(__file__)[0], "TC6_XML_V10_B.xsd"))
+PLCOpenClasses = GenerateClassesFromXSD(os.path.join(os.path.split(__file__)[0], "TC6_XML_V10_B.xsd"))
 cls = PLCOpenClasses.get("formattedText", None)
 if cls:
-cls.text = ""
-def getText(self):
-return self.text
-setattr(cls, "getText", getText)
-def setText(self, text):
-self.text = text
-setattr(cls, "setText", setText)
-def loadXMLTree(self, tree):
-self.text = GetAttributeValue(tree)
-if len(self.text.splitlines()) > 1:
-self.text = self.text[1:].rstrip()
-setattr(cls, "loadXMLTree", loadXMLTree)
-def generateXMLText(self, name, indent, extras = {}):
-ind1, ind2 = getIndent(indent, name)
-if len(self.text.splitlines()) > 1:
-text = ind1 + "<%s>\n<![CDATA[\n"%name
-text += "%s\n"%self.text
-text += "]]>\n" + ind1 + "</%s>\n"%name
-return text
-else:
-return ind1 + "<%s><![CDATA[%s]]></%s>\n"%(name, self.text, name)
-setattr(cls, "generateXMLText", generateXMLText)
 def updateElementName(self, old_name, new_name):
 index = self.text.find(old_name)
 while index != -1:
 if index > 0 and (self.text[index - 1].isalnum() or self.text[index - 1] == "_"):
 index = self.text.find(old_name, index + len(old_name))
 cls = PLCOpenClasses.get("project", None)
 if cls:
 cls.singleLineAttributes = False
-def setName(self, name):
+def setname(self, name):
-self.contentHeader.setName(name)
+self.contentHeader.setname(name)
-setattr(cls, "setName", setName)
+setattr(cls, "setname", setname)
-def getName(self):
+def getname(self):
-return self.contentHeader.getName()
+return self.contentHeader.getname()
-setattr(cls, "getName", getName)
+setattr(cls, "getname", getname)
-def getFileHeader(self):
+def getfileHeader(self):
 fileheader = {}
-fileheader["companyName"] = self.fileHeader.getCompanyName()
+fileheader["companyName"] = self.fileHeader.getcompanyName()
-if self.fileHeader.getCompanyURL():
+if self.fileHeader.getcompanyURL():
-fileheader["companyURL"] = self.fileHeader.getCompanyURL()
+fileheader["companyURL"] = self.fileHeader.getcompanyURL()
-fileheader["productName"] = self.fileHeader.getProductName()
+fileheader["productName"] = self.fileHeader.getproductName()
-fileheader["productVersion"] = self.fileHeader.getProductVersion()
+fileheader["productVersion"] = self.fileHeader.getproductVersion()
-if self.fileHeader.getProductRelease():
+if self.fileHeader.getproductRelease():
-fileheader["productRelease"] = self.fileHeader.getProductRelease()
+fileheader["productRelease"] = self.fileHeader.getproductRelease()
-fileheader["creationDateTime"] = self.fileHeader.getCreationDateTime()
+fileheader["creationDateTime"] = self.fileHeader.getcreationDateTime()
-if self.fileHeader.getContentDescription():
+if self.fileHeader.getcontentDescription():
-fileheader["contentDescription"] = self.fileHeader.getContentDescription()
+fileheader["contentDescription"] = self.fileHeader.getcontentDescription()
 return fileheader
-setattr(cls, "getFileHeader", getFileHeader)
+setattr(cls, "getfileHeader", getfileHeader)
-def setFileHeader(self, fileheader):
+def setfileHeader(self, fileheader):
-self.fileHeader.setCompanyName(fileheader["companyName"])
+self.fileHeader.setcompanyName(fileheader["companyName"])
 if "companyURL" in fileheader:
-self.fileHeader.setCompanyURL(fileheader["companyURL"])
+self.fileHeader.setcompanyURL(fileheader["companyURL"])
-self.fileHeader.setProductName(fileheader["productName"])
+self.fileHeader.setproductName(fileheader["productName"])
-self.fileHeader.setProductVersion(fileheader["productVersion"])
+self.fileHeader.setproductVersion(fileheader["productVersion"])
 if "productRelease" in fileheader:
-self.fileHeader.setProductRelease(fileheader["productRelease"])
+self.fileHeader.setproductRelease(fileheader["productRelease"])
-self.fileHeader.setCreationDateTime(fileheader["creationDateTime"])
+self.fileHeader.setcreationDateTime(fileheader["creationDateTime"])
 if "contentDescription" in fileheader:
-self.fileHeader.setContentDescription(fileheader["contentDescription"])
+self.fileHeader.setcontentDescription(fileheader["contentDescription"])
-setattr(cls, "setFileHeader", setFileHeader)
+setattr(cls, "setfileHeader", setfileHeader)
-def getContentHeader(self):
+def getcontentHeader(self):
 contentheader = {}
-contentheader["projectName"] = self.contentHeader.getName()
+contentheader["projectName"] = self.contentHeader.getname()
-if self.contentHeader.getVersion():
+if self.contentHeader.getversion():
-contentheader["projectVersion"] = self.contentHeader.getVersion()
+contentheader["projectVersion"] = self.contentHeader.getversion()
-if self.contentHeader.getModificationDateTime():
+if self.contentHeader.getmodificationDateTime():
-contentheader["modificationDateTime"] = self.contentHeader.getModificationDateTime()
+contentheader["modificationDateTime"] = self.contentHeader.getmodificationDateTime()
-if self.contentHeader.getOrganization():
+if self.contentHeader.getorganization():
-contentheader["organization"] = self.contentHeader.getOrganization()
+contentheader["organization"] = self.contentHeader.getorganization()
-if self.contentHeader.getAuthor():
+if self.contentHeader.getauthor():
-contentheader["authorName"] = self.contentHeader.getAuthor()
+contentheader["authorName"] = self.contentHeader.getauthor()
-if self.contentHeader.getLanguage():
+if self.contentHeader.getlanguage():
-contentheader["language"] = self.contentHeader.getLanguage()
+contentheader["language"] = self.contentHeader.getlanguage()
-contentheader["pageSize"] = self.contentHeader.getPageSize()
+contentheader["pageSize"] = self.contentHeader.getpageSize()
-contentheader["scaling"] = self.contentHeader.getScaling()
+contentheader["scaling"] = self.contentHeader.getscaling()
 return contentheader
-setattr(cls, "getContentHeader", getContentHeader)
+setattr(cls, "getcontentHeader", getcontentHeader)
-def setContentHeader(self, contentheader):
+def setcontentHeader(self, contentheader):
-self.contentHeader.setName(contentheader["projectName"])
+self.contentHeader.setname(contentheader["projectName"])
 if "projectVersion" in contentheader:
-self.contentHeader.setVersion(contentheader["projectVersion"])
+self.contentHeader.setversion(contentheader["projectVersion"])
 if "modificationDateTime" in contentheader:
-self.contentHeader.setModificationDateTime(contentheader["modificationDateTime"])
+self.contentHeader.setmodificationDateTime(contentheader["modificationDateTime"])
 if "organization" in contentheader:
-self.contentHeader.setOrganization(contentheader["organization"])
+self.contentHeader.setorganization(contentheader["organization"])
 if "authorName" in contentheader:
-self.contentHeader.setAuthor(contentheader["authorName"])
+self.contentHeader.setauthor(contentheader["authorName"])
 if "language" in contentheader:
-self.contentHeader.setLanguage(contentheader["language"])
+self.contentHeader.setlanguage(contentheader["language"])
-self.contentHeader.setPageSize(*contentheader["pageSize"])
+self.contentHeader.setpageSize(*contentheader["pageSize"])
-self.contentHeader.setScaling(contentheader["scaling"])
+self.contentHeader.setscaling(contentheader["scaling"])
-setattr(cls, "setContentHeader", setContentHeader)
+setattr(cls, "setcontentHeader", setcontentHeader)
-def getDataTypes(self):
+def getdataTypes(self):
-return self.types.getDataTypeElements()
+return self.types.getdataTypeElements()
-setattr(cls, "getDataTypes", getDataTypes)
+setattr(cls, "getdataTypes", getdataTypes)
-def getDataType(self, name):
+def getdataType(self, name):
-return self.types.getDataTypeElement(name)
+return self.types.getdataTypeElement(name)
-setattr(cls, "getDataType", getDataType)
+setattr(cls, "getdataType", getdataType)
-def appendDataType(self, name):
+def appenddataType(self, name):
-self.types.appendDataTypeElement(name)
+self.types.appenddataTypeElement(name)
-setattr(cls, "appendDataType", appendDataType)
+setattr(cls, "appenddataType", appenddataType)
-def insertDataType(self, index, datatype):
+def insertdataType(self, index, datatype):
-self.types.insertDataTypeElement(index, datatype)
+self.types.insertdataTypeElement(index, datatype)
-setattr(cls, "insertDataType", insertDataType)
+setattr(cls, "insertdataType", insertdataType)
-def removeDataType(self, name):
+def removedataType(self, name):
-self.types.removeDataTypeElement(name)
+self.types.removedataTypeElement(name)
-setattr(cls, "removeDataType", removeDataType)
+setattr(cls, "removedataType", removedataType)
-def getPous(self):
+def getpous(self):
-return self.types.getPouElements()
+return self.types.getpouElements()
-setattr(cls, "getPous", getPous)
+setattr(cls, "getpous", getpous)
-def getPou(self, name):
+def getpou(self, name):
-return self.types.getPouElement(name)
+return self.types.getpouElement(name)
-setattr(cls, "getPou", getPou)
+setattr(cls, "getpou", getpou)
-def appendPou(self, name, pou_type, body_type):
+def appendpou(self, name, pou_type, body_type):
-self.types.appendPouElement(name, pou_type, body_type)
+self.types.appendpouElement(name, pou_type, body_type)
-setattr(cls, "appendPou", appendPou)
+setattr(cls, "appendpou", appendpou)
-def insertPou(self, index, pou):
+def insertpou(self, index, pou):
-self.types.insertPouElement(index, pou)
+self.types.insertpouElement(index, pou)
-setattr(cls, "insertPou", insertPou)
+setattr(cls, "insertpou", insertpou)
-def removePou(self, name):
+def removepou(self, name):
-self.types.removePouElement(name)
+self.types.removepouElement(name)
-setattr(cls, "removePou", removePou)
+setattr(cls, "removepou", removepou)
-def getConfigurations(self):
+def getconfigurations(self):
-configurations = self.instances.configurations.getConfiguration()
+configurations = self.instances.configurations.getconfiguration()
 if configurations:
 return configurations
 return []
-setattr(cls, "getConfigurations", getConfigurations)
+setattr(cls, "getconfigurations", getconfigurations)
-def getConfiguration(self, name):
+def getconfiguration(self, name):
-for configuration in self.instances.configurations.getConfiguration():
+for configuration in self.instances.configurations.getconfiguration():
-if configuration.getName() == name:
+if configuration.getname() == name:
 return configuration
 return None
-setattr(cls, "getConfiguration", getConfiguration)
+setattr(cls, "getconfiguration", getconfiguration)
-def addConfiguration(self, name):
+def addconfiguration(self, name):
-for configuration in self.instances.configurations.getConfiguration():
+for configuration in self.instances.configurations.getconfiguration():
-if configuration.getName() == name:
+if configuration.getname() == name:
 raise ValueError, "\"%s\" configuration already exists !!!"%name
 new_configuration = PLCOpenClasses["configurations_configuration"]()
-new_configuration.setName(name)
+new_configuration.setname(name)
-self.instances.configurations.appendConfiguration(new_configuration)
+self.instances.configurations.appendconfiguration(new_configuration)
-setattr(cls, "addConfiguration", addConfiguration)
+setattr(cls, "addconfiguration", addconfiguration)
-def removeConfiguration(self, name):
+def removeconfiguration(self, name):
 found = False
-for idx, configuration in enumerate(self.instances.configurations.getConfiguration()):
+for idx, configuration in enumerate(self.instances.configurations.getconfiguration()):
-if configuration.getName() == name:
+if configuration.getname() == name:
-self.instances.configurations.removeConfiguration(idx)
+self.instances.configurations.removeconfiguration(idx)
 found = True
 break
 if not found:
 raise ValueError, "\"%s\" configuration doesn't exist !!!"%name
-setattr(cls, "removeConfiguration", removeConfiguration)
+setattr(cls, "removeconfiguration", removeconfiguration)
-def getConfigurationResource(self, config_name, name):
+def getconfigurationResource(self, config_name, name):
-configuration = self.getConfiguration(config_name)
+configuration = self.getconfiguration(config_name)
 if configuration:
-for resource in configuration.getResource():
+for resource in configuration.getresource():
-if resource.getName() == name:
+if resource.getname() == name:
 return resource
 return None
-setattr(cls, "getConfigurationResource", getConfigurationResource)
+setattr(cls, "getconfigurationResource", getconfigurationResource)
-def addConfigurationResource(self, config_name, name):
+def addconfigurationResource(self, config_name, name):
-configuration = self.getConfiguration(config_name)
+configuration = self.getconfiguration(config_name)
 if configuration:
-for resource in configuration.getResource():
+for resource in configuration.getresource():
-if resource.getName() == name:
+if resource.getname() == name:
 raise ValueError, "\"%s\" resource already exists in \"%s\" configuration !!!"%(name, config_name)
 new_resource = PLCOpenClasses["configuration_resource"]()
-new_resource.setName(name)
+new_resource.setname(name)
-configuration.appendResource(new_resource)
+configuration.appendresource(new_resource)
-setattr(cls, "addConfigurationResource", addConfigurationResource)
+setattr(cls, "addconfigurationResource", addconfigurationResource)
-def removeConfigurationResource(self, config_name, name):
+def removeconfigurationResource(self, config_name, name):
-configuration = self.getConfiguration(config_name)
+configuration = self.getconfiguration(config_name)
 if configuration:
 found = False
-for idx, resource in enumerate(configuration.getResource()):
+for idx, resource in enumerate(configuration.getresource()):
-if resource.getName() == name:
+if resource.getname() == name:
-configuration.removeResource(idx)
+configuration.removeresource(idx)
 found = True
 break
 if not found:
 raise ValueError, "\"%s\" resource doesn't exist in \"%s\" configuration !!!"%(name, config_name)
-setattr(cls, "removeConfigurationResource", removeConfigurationResource)
+setattr(cls, "removeconfigurationResource", removeconfigurationResource)
 def updateElementName(self, old_name, new_name):
-for pou in self.types.getPouElements():
+for pou in self.types.getpouElements():
 pou.updateElementName(old_name, new_name)
-for configuration in self.instances.configurations.getConfiguration():
+for configuration in self.instances.configurations.getconfiguration():
 configuration.updateElementName(old_name, new_name)
 setattr(cls, "updateElementName", updateElementName)
 cls = PLCOpenClasses.get("project_fileHeader", None)
 if cls:
 cls = PLCOpenClasses.get("project_contentHeader", None)
 if cls:
 cls.singleLineAttributes = False
-def setPageSize(self, width, height):
+def setpageSize(self, width, height):
-self.coordinateInfo.setPageSize(width, height)
+self.coordinateInfo.setpageSize(width, height)
-setattr(cls, "setPageSize", setPageSize)
+setattr(cls, "setpageSize", setpageSize)
-def getPageSize(self):
+def getpageSize(self):
-return self.coordinateInfo.getPageSize()
+return self.coordinateInfo.getpageSize()
-setattr(cls, "getPageSize", getPageSize)
+setattr(cls, "getpageSize", getpageSize)
-def setScaling(self, scaling):
+def setscaling(self, scaling):
 for language, (x, y) in scaling.items():
-self.coordinateInfo.setScaling(language, x, y)
+self.coordinateInfo.setscaling(language, x, y)
-setattr(cls, "setScaling", setScaling)
+setattr(cls, "setscaling", setscaling)
-def getScaling(self):
+def getscaling(self):
 scaling = {}
-scaling["FBD"] = self.coordinateInfo.getScaling("FBD")
+scaling["FBD"] = self.coordinateInfo.getscaling("FBD")
-scaling["LD"] = self.coordinateInfo.getScaling("LD")
+scaling["LD"] = self.coordinateInfo.getscaling("LD")
-scaling["SFC"] = self.coordinateInfo.getScaling("SFC")
+scaling["SFC"] = self.coordinateInfo.getscaling("SFC")
 return scaling
-setattr(cls, "getScaling", getScaling)
+setattr(cls, "getscaling", getscaling)
 cls = PLCOpenClasses.get("contentHeader_coordinateInfo", None)
 if cls:
-def setPageSize(self, width, height):
+def setpageSize(self, width, height):
 if width == 0 and height == 0:
-self.deletePageSize()
+self.deletepageSize()
 else:
 if self.pageSize is None:
-self.addPageSize()
+self.addpageSize()
-self.pageSize.setX(width)
+self.pageSize.setx(width)
-self.pageSize.setY(height)
+self.pageSize.sety(height)
-setattr(cls, "setPageSize", setPageSize)
+setattr(cls, "setpageSize", setpageSize)
-def getPageSize(self):
+def getpageSize(self):
 if self.pageSize is not None:
-return self.pageSize.getX(), self.pageSize.getY()
+return self.pageSize.getx(), self.pageSize.gety()
 return 0, 0
-setattr(cls, "getPageSize", getPageSize)
+setattr(cls, "getpageSize", getpageSize)
-def setScaling(self, language, x, y):
+def setscaling(self, language, x, y):
 if language == "FBD":
-self.fbd.scaling.setX(x)
+self.fbd.scaling.setx(x)
-self.fbd.scaling.setY(y)
+self.fbd.scaling.sety(y)
 elif language == "LD":
-self.ld.scaling.setX(x)
+self.ld.scaling.setx(x)
-self.ld.scaling.setY(y)
+self.ld.scaling.sety(y)
 elif language == "SFC":
-self.sfc.scaling.setX(x)
+self.sfc.scaling.setx(x)
-self.sfc.scaling.setY(y)
+self.sfc.scaling.sety(y)
-setattr(cls, "setScaling", setScaling)
+setattr(cls, "setscaling", setscaling)
-def getScaling(self, language):
+def getscaling(self, language):
 if language == "FBD":
-return self.fbd.scaling.getX(), self.fbd.scaling.getY()
+return self.fbd.scaling.getx(), self.fbd.scaling.gety()
 elif language == "LD":
-return self.ld.scaling.getX(), self.ld.scaling.getY()
+return self.ld.scaling.getx(), self.ld.scaling.gety()
 elif language == "SFC":
-return self.sfc.scaling.getX(), self.sfc.scaling.getY()
+return self.sfc.scaling.getx(), self.sfc.scaling.gety()
 return 0, 0
-setattr(cls, "getScaling", getScaling)
+setattr(cls, "getscaling", getscaling)
 cls = PLCOpenClasses.get("configurations_configuration", None)
 if cls:
 def updateElementName(self, old_name, new_name):
-for resource in self.getResource():
+for resource in self.getresource():
 resource.updateElementName(old_name, new_name)
 setattr(cls, "updateElementName", updateElementName)
 cls = PLCOpenClasses.get("configuration_resource", None)
 self.type = new_name
 setattr(cls, "updateElementName", updateElementName)
 cls = PLCOpenClasses.get("project_types", None)
 if cls:
-def getDataTypeElements(self):
+def getdataTypeElements(self):
-return self.dataTypes.getDataType()
+return self.dataTypes.getdataType()
-setattr(cls, "getDataTypeElements", getDataTypeElements)
+setattr(cls, "getdataTypeElements", getdataTypeElements)
-def getDataTypeElement(self, name):
+def getdataTypeElement(self, name):
-elements = self.dataTypes.getDataType()
+elements = self.dataTypes.getdataType()
 for element in elements:
-if element.getName() == name:
+if element.getname() == name:
 return element
 return None
-setattr(cls, "getDataTypeElement", getDataTypeElement)
+setattr(cls, "getdataTypeElement", getdataTypeElement)
-def appendDataTypeElement(self, name):
+def appenddataTypeElement(self, name):
-for element in self.dataTypes.getDataType():
+for element in self.dataTypes.getdataType():
-if element.getName() == name:
+if element.getname() == name:
 raise ValueError, "\"%s\" Data Type already exists !!!"%name
 new_datatype = PLCOpenClasses["dataTypes_dataType"]()
-new_datatype.setName(name)
+new_datatype.setname(name)
-new_datatype.baseType.setContent("BOOL", None)
+new_datatype.baseType.setcontent({"name" : "BOOL", "value" : None})
-self.dataTypes.appendDataType(new_datatype)
+self.dataTypes.appenddataType(new_datatype)
-setattr(cls, "appendDataTypeElement", appendDataTypeElement)
+setattr(cls, "appenddataTypeElement", appenddataTypeElement)
-def insertDataTypeElement(self, index, datatype):
+def insertdataTypeElement(self, index, dataType):
-self.dataTypes.insertDataType(index, datatype)
+self.dataTypes.insertdataType(index, dataType)
-setattr(cls, "insertDataTypeElement", insertDataTypeElement)
+setattr(cls, "insertdataTypeElement", insertdataTypeElement)
-def removeDataTypeElement(self, name):
+def removedataTypeElement(self, name):
 found = False
-for idx, element in enumerate(self.dataTypes.getDataType()):
+for idx, element in enumerate(self.dataTypes.getdataType()):
-if element.getName() == name:
+if element.getname() == name:
-self.dataTypes.removeDataType(idx)
+self.dataTypes.removedataType(idx)
 found = True
 break
 if not found:
 raise ValueError, "\"%s\" Data Type doesn't exist !!!"%name
-setattr(cls, "removeDataTypeElement", removeDataTypeElement)
+setattr(cls, "removedataTypeElement", removedataTypeElement)
-def getPouElements(self):
+def getpouElements(self):
-return self.pous.getPou()
+return self.pous.getpou()
-setattr(cls, "getPouElements", getPouElements)
+setattr(cls, "getpouElements", getpouElements)
-def getPouElement(self, name):
+def getpouElement(self, name):
-elements = self.pous.getPou()
+elements = self.pous.getpou()
 for element in elements:
-if element.getName() == name:
+if element.getname() == name:
 return element
 return None
-setattr(cls, "getPouElement", getPouElement)
+setattr(cls, "getpouElement", getpouElement)
-def appendPouElement(self, name, pou_type, body_type):
+def appendpouElement(self, name, pou_type, body_type):
-for element in self.pous.getPou():
+for element in self.pous.getpou():
-if element.getName() == name:
+if element.getname() == name:
 raise ValueError, "\"%s\" POU already exists !!!"%name
 new_pou = PLCOpenClasses["pous_pou"]()
-new_pou.setName(name)
+new_pou.setname(name)
-new_pou.pouType.setValue(pou_type)
+new_pou.setpouType(pou_type)
-new_pou.setBody(PLCOpenClasses["body"]())
+new_pou.setbody(PLCOpenClasses["body"]())
-new_pou.setBodyType(body_type)
+new_pou.setbodyType(body_type)
-self.pous.appendPou(new_pou)
+self.pous.appendpou(new_pou)
-setattr(cls, "appendPouElement", appendPouElement)
+setattr(cls, "appendpouElement", appendpouElement)
-def insertPouElement(self, index, pou):
+def insertpouElement(self, index, pou):
-self.pous.insertPou(index, pou)
+self.pous.insertpou(index, pou)
-setattr(cls, "insertPouElement", insertPouElement)
+setattr(cls, "insertpouElement", insertpouElement)
-def removePouElement(self, name):
+def removepouElement(self, name):
 found = False
-for idx, element in enumerate(self.pous.getPou()):
+for idx, element in enumerate(self.pous.getpou()):
-if element.getName() == name:
+if element.getname() == name:
-self.pous.removePou(idx)
+self.pous.removepou(idx)
 found = True
 break
 if not found:
 raise ValueError, "\"%s\" POU doesn't exist !!!"%name
-setattr(cls, "removePouElement", removePouElement)
+setattr(cls, "removepouElement", removepouElement)
-def setBodyType(self, type):
+def setbodyType(self, type):
 if type == "IL":
-self.body.setContent("IL", PLCOpenClasses["formattedText"]())
+self.body.setcontent({"name" : "IL", "value" : PLCOpenClasses["formattedText"]()})
 elif type == "ST":
-self.body.setContent("ST", PLCOpenClasses["formattedText"]())
+self.body.setcontent({"name" : "ST", "value" : PLCOpenClasses["formattedText"]()})
 elif type == "LD":
-self.body.setContent("LD", PLCOpenClasses["body_LD"]())
+self.body.setcontent({"name" : "LD", "value" : PLCOpenClasses["body_LD"]()})
 elif type == "FBD":
-self.body.setContent("FBD", PLCOpenClasses["body_FBD"]())
+self.body.setcontent({"name" : "FBD", "value" : PLCOpenClasses["body_FBD"]()})
 elif type == "SFC":
-self.body.setContent("SFC", PLCOpenClasses["body_SFC"]())
+self.body.setcontent({"name" : "SFC", "value" : PLCOpenClasses["body_SFC"]()})
 else:
 raise ValueError, "%s isn't a valid body type!"%type
-def getBodyType(self):
+def getbodyType(self):
-return self.body.getContent()["name"]
+return self.body.getcontent()["name"]
-def resetExecutionOrder(self):
+def resetexecutionOrder(self):
-self.body.resetExecutionOrder()
+self.body.resetexecutionOrder()
-def compileExecutionOrder(self):
+def compileexecutionOrder(self):
-self.body.compileExecutionOrder()
+self.body.compileexecutionOrder()
-def setElementExecutionOrder(self, instance, new_executionOrder):
+def setelementExecutionOrder(self, instance, new_executionOrder):
-self.body.setElementExecutionOrder(instance, new_executionOrder)
+self.body.setelementExecutionOrder(instance, new_executionOrder)
-def addInstance(self, name, instance):
+def addinstance(self, name, instance):
-self.body.appendContentInstance(name, instance)
+self.body.appendcontentInstance(name, instance)
-def getInstances(self):
+def getinstances(self):
-return self.body.getContentInstances()
+return self.body.getcontentInstances()
-def getInstance(self, id):
+def getinstance(self, id):
-return self.body.getContentInstance(id)
+return self.body.getcontentInstance(id)
-def getRandomInstance(self, exclude):
+def getrandomInstance(self, exclude):
-return self.body.getContentRandomInstance(exclude)
+return self.body.getcontentRandomInstance(exclude)
-def getInstanceByName(self, name):
+def getinstanceByName(self, name):
-return self.body.getContentInstanceByName(name)
+return self.body.getcontentInstanceByName(name)
-def removeInstance(self, id):
+def removeinstance(self, id):
-self.body.removeContentInstance(id)
+self.body.removecontentInstance(id)
-def setText(self, text):
+def settext(self, text):
-self.body.setText(text)
+self.body.settext(text)
-def getText(self):
+def gettext(self):
-return self.body.getText()
+return self.body.gettext()
-setattr(cls, "getText", getText)
+setattr(cls, "gettext", gettext)
 cls = PLCOpenClasses.get("pous_pou", None)
 if cls:
-setattr(cls, "setBodyType", setBodyType)
+setattr(cls, "setbodyType", setbodyType)
-setattr(cls, "getBodyType", getBodyType)
+setattr(cls, "getbodyType", getbodyType)
-setattr(cls, "resetExecutionOrder", resetExecutionOrder)
+setattr(cls, "resetexecutionOrder", resetexecutionOrder)
-setattr(cls, "compileExecutionOrder", compileExecutionOrder)
+setattr(cls, "compileexecutionOrder", compileexecutionOrder)
-setattr(cls, "setElementExecutionOrder", setElementExecutionOrder)
+setattr(cls, "setelementExecutionOrder", setelementExecutionOrder)
-setattr(cls, "addInstance", addInstance)
+setattr(cls, "addinstance", addinstance)
-setattr(cls, "getInstances", getInstances)
+setattr(cls, "getinstances", getinstances)
-setattr(cls, "getInstance", getInstance)
+setattr(cls, "getinstance", getinstance)
-setattr(cls, "getRandomInstance", getRandomInstance)
+setattr(cls, "getrandomInstance", getrandomInstance)
-setattr(cls, "getInstanceByName", getInstanceByName)
+setattr(cls, "getinstanceByName", getinstanceByName)
-setattr(cls, "removeInstance", removeInstance)
+setattr(cls, "removeinstance", removeinstance)
-setattr(cls, "setText", setText)
+setattr(cls, "settext", settext)
-setattr(cls, "getText", getText)
+setattr(cls, "gettext", gettext)
-def getVars(self):
+def getvars(self):
 vars = []
 reverse_types = {}
 for name, value in VarTypes.items():
 reverse_types[value] = name
-for varlist in self.interface.getContent():
+for varlist in self.interface.getcontent():
 vars.append((reverse_types[varlist["name"]], varlist["value"]))
 return vars
-setattr(cls, "getVars", getVars)
+setattr(cls, "getvars", getvars)
-def setVars(self, vars):
+def setvars(self, vars):
-self.interface.setContent([])
+self.interface.setcontent([])
 for vartype, varlist in vars:
-self.interface.appendContent(VarTypes[vartype], varlist)
+self.interface.appendcontent({"name" : VarTypes[vartype], "value" : varlist})
-setattr(cls, "setVars", setVars)
+setattr(cls, "setvars", setvars)
-def addPouVar(self, type, name):
+def addpouVar(self, type, name):
-content = self.interface.getContent()
+content = self.interface.getcontent()
 if len(content) == 0 or content[-1]["name"] != "localVars":
-content.append({"name" : "localVars", "value" : PLCOpenClasses["varList"]()})
+content.append({"name" : "localVars", "value" : PLCOpenClasses["interface_localVars"]()})
 else:
 varlist = content[-1]["value"]
-variables = varlist.getVariable()
+variables = varlist.getvariable()
-if varlist.getConstant() or varlist.getRetain() or len(variables) > 0 and variables[0].getAddress():
+if varlist.getconstant() or varlist.getretain() or len(variables) > 0 and variables[0].getaddress():
-content.append({"name" : "localVars", "value" : PLCOpenClasses["varList"]()})
+content.append({"name" : "localVars", "value" : PLCOpenClasses["interface_localVars"]()})
 var = PLCOpenClasses["varListPlain_variable"]()
-var.setName(name)
+var.setname(name)
 var_type = PLCOpenClasses["dataType"]()
-derived_type = PLCOpenClasses["derived"]()
+derived_type = PLCOpenClasses["derivedTypes_derived"]()
-derived_type.setName(type)
+derived_type.setname(type)
-var_type.setContent("derived", derived_type)
+var_type.setcontent({"name" : "derived", "value" : derived_type})
-var.setType(var_type)
+var.settype(var_type)
-content[-1]["value"].appendVariable(var)
+content[-1]["value"].appendvariable(var)
-setattr(cls, "addPouVar", addPouVar)
+setattr(cls, "addpouVar", addpouVar)
-def changePouVar(self, old_type, old_name, new_type, new_name):
+def changepouVar(self, old_type, old_name, new_type, new_name):
-content = self.interface.getContent()
+content = self.interface.getcontent()
 for varlist in content:
-variables = varlist["value"].getVariable()
+variables = varlist["value"].getvariable()
 for var in variables:
-if var.getName() == old_name:
+if var.getname() == old_name:
-vartype_content = var.getType().getContent()
+vartype_content = var.gettype().getcontent()
-if vartype_content["name"] == "derived" and vartype_content["value"].getName() == old_type:
+if vartype_content["name"] == "derived" and vartype_content["value"].getname() == old_type:
-var.setName(new_name)
+var.setname(new_name)
-vartype_content["value"].setName(new_type)
+vartype_content["value"].setname(new_type)
 return
-setattr(cls, "changePouVar", changePouVar)
+setattr(cls, "changepouVar", changepouVar)
-def removePouVar(self, type, name):
+def removepouVar(self, type, name):
-content = self.interface.getContent()
+content = self.interface.getcontent()
 for varlist in content:
-variables = varlist["value"].getVariable()
+variables = varlist["value"].getvariable()
 for var in variables:
-if var.getName() == name:
+if var.getname() == name:
-vartype_content = var.getType().getContent()
+vartype_content = var.gettype().getcontent()
-if vartype_content["name"] == "derived" and vartype_content["value"].getName() == type:
+if vartype_content["name"] == "derived" and vartype_content["value"].getname() == type:
 variables.remove(var)
 break
-if len(varlist["value"].getVariable()) == 0:
+if len(varlist["value"].getvariable()) == 0:
 content.remove(varlist)
 break
-setattr(cls, "removePouVar", removePouVar)
+setattr(cls, "removepouVar", removepouVar)
-def hasBlock(self, name):
+def hasblock(self, name):
-if self.getBodyType() in ["FBD", "LD", "SFC"]:
+if self.getbodyType() in ["FBD", "LD", "SFC"]:
-for instance in self.getInstances():
+for instance in self.getinstances():
-if isinstance(instance, PLCOpenClasses["block"]) and instance.getInstanceName() == name:
+if isinstance(instance, PLCOpenClasses["fbdObjects_block"]) and instance.getinstanceName() == name:
 return True
 if self.transitions:
-for transition in self.transitions.getTransition():
+for transition in self.transitions.gettransition():
-result = transition.hasBlock(name)
+result = transition.hasblock(name)
 if result:
 return result
 if self.actions:
-for action in self.actions.getAction():
+for action in self.actions.getaction():
-result = action.hasBlock(name)
+result = action.hasblock(name)
 if result:
 return result
 return False
-setattr(cls, "hasBlock", hasBlock)
+setattr(cls, "hasblock", hasblock)
-def addTransition(self, name, type):
+def addtransition(self, name, type):
 if not self.transitions:
-self.addTransitions()
+self.addtransitions()
-self.transitions.setTransition([])
+self.transitions.settransition([])
 transition = PLCOpenClasses["transitions_transition"]()
-transition.setName(name)
+transition.setname(name)
-transition.setBodyType(type)
+transition.setbodyType(type)
-self.transitions.appendTransition(transition)
+self.transitions.appendtransition(transition)
-setattr(cls, "addTransition", addTransition)
+setattr(cls, "addtransition", addtransition)
-def getTransition(self, name):
+def gettransition(self, name):
 if self.transitions:
-for transition in self.transitions.getTransition():
+for transition in self.transitions.gettransition():
-if transition.getName() == name:
+if transition.getname() == name:
 return transition
 return None
-setattr(cls, "getTransition", getTransition)
+setattr(cls, "gettransition", gettransition)
-def getTransitionList(self):
+def gettransitionList(self):
 if self.transitions:
-return self.transitions.getTransition()
+return self.transitions.gettransition()
 return []
-setattr(cls, "getTransitionList", getTransitionList)
+setattr(cls, "gettransitionList", gettransitionList)
-def removeTransition(self, name):
+def removetransition(self, name):
 if self.transitions:
-transitions = self.transitions.getTransition()
+transitions = self.transitions.gettransition()
 i = 0
 removed = False
 while i < len(transitions) and not removed:
-if transitions[i].getName() == name:
+if transitions[i].getname() == name:
 transitions.pop(i)
 removed = True
 i += 1
 if not removed:
 raise ValueError, "Transition with name %s doesn't exists!"%name
-setattr(cls, "removeTransition", removeTransition)
+setattr(cls, "removetransition", removetransition)
-def addAction(self, name, type):
+def addaction(self, name, type):
 if not self.actions:
-self.addActions()
+self.addactions()
-self.actions.setAction([])
+self.actions.setaction([])
 action = PLCOpenClasses["actions_action"]()
-action.setName(name)
+action.setname(name)
-action.setBodyType(type)
+action.setbodyType(type)
-self.actions.appendAction(action)
+self.actions.appendaction(action)
-setattr(cls, "addAction", addAction)
+setattr(cls, "addaction", addaction)
-def getAction(self, name):
+def getaction(self, name):
 if self.actions:
-for action in self.actions.getAction():
+for action in self.actions.getaction():
-if action.getName() == name:
+if action.getname() == name:
 return action
 return None
-setattr(cls, "getAction", getAction)
+setattr(cls, "getaction", getaction)
-def getActionList(self):
+def getactionList(self):
 if self.actions:
-return self.actions.getAction()
+return self.actions.getaction()
 return []
-setattr(cls, "getActionList", getActionList)
+setattr(cls, "getactionList", getactionList)
-def removeAction(self, name):
+def removeaction(self, name):
 if self.actions:
-actions = self.actions.getAction()
+actions = self.actions.getaction()
 i = 0
 removed = False
 while i < len(actions) and not removed:
-if actions[i].getName() == name:
+if actions[i].getname() == name:
 actions.pop(i)
 removed = True
 i += 1
 if not removed:
 raise ValueError, "Action with name %s doesn't exists!"%name
-setattr(cls, "removeAction", removeAction)
+setattr(cls, "removeaction", removeaction)
 def updateElementName(self, old_name, new_name):
 self.body.updateElementName(old_name, new_name)
-for action in self.getActionList():
+for action in self.getactionList():
 action.updateElementName(old_name, new_name)
-for transition in self.getTransitionList():
+for transition in self.gettransitionList():
 transition.updateElementName(old_name, new_name)
 setattr(cls, "updateElementName", updateElementName)
 cls = PLCOpenClasses.get("transitions_transition", None)
 if cls:
-setattr(cls, "setBodyType", setBodyType)
+setattr(cls, "setbodyType", setbodyType)
-setattr(cls, "getBodyType", getBodyType)
+setattr(cls, "getbodyType", getbodyType)
-setattr(cls, "resetExecutionOrder", resetExecutionOrder)
+setattr(cls, "resetexecutionOrder", resetexecutionOrder)
-setattr(cls, "compileExecutionOrder", compileExecutionOrder)
+setattr(cls, "compileexecutionOrder", compileexecutionOrder)
-setattr(cls, "setElementExecutionOrder", setElementExecutionOrder)
+setattr(cls, "setelementExecutionOrder", setelementExecutionOrder)
-setattr(cls, "addInstance", addInstance)
+setattr(cls, "addinstance", addinstance)
-setattr(cls, "getInstances", getInstances)
+setattr(cls, "getinstances", getinstances)
-setattr(cls, "getInstance", getInstance)
+setattr(cls, "getinstance", getinstance)
-setattr(cls, "getRandomInstance", getRandomInstance)
+setattr(cls, "getrandomInstance", getrandomInstance)
-setattr(cls, "getInstanceByName", getInstanceByName)
+setattr(cls, "getinstanceByName", getinstanceByName)
-setattr(cls, "removeInstance", removeInstance)
+setattr(cls, "removeinstance", removeinstance)
-setattr(cls, "setText", setText)
+setattr(cls, "settext", settext)
-setattr(cls, "getText", getText)
+setattr(cls, "gettext", gettext)
 def updateElementName(self, old_name, new_name):
 self.body.updateElementName(old_name, new_name)
 setattr(cls, "updateElementName", updateElementName)
-def hasBlock(self, name):
+def hasblock(self, name):
-if self.getBodyType() in ["FBD", "LD", "SFC"]:
+if self.getbodyType() in ["FBD", "LD", "SFC"]:
-for instance in self.getInstances():
+for instance in self.getinstances():
-if isinstance(instance, PLCOpenClasses["block"]) and instance.getInstanceName() == name:
+if isinstance(instance, PLCOpenClasses["fbdObjects_block"]) and instance.getinstanceName() == name:
 return True
 return False
-setattr(cls, "hasBlock", hasBlock)
+setattr(cls, "hasblock", hasblock)
 cls = PLCOpenClasses.get("actions_action", None)
 if cls:
-setattr(cls, "setBodyType", setBodyType)
+setattr(cls, "setbodyType", setbodyType)
-setattr(cls, "getBodyType", getBodyType)
+setattr(cls, "getbodyType", getbodyType)
-setattr(cls, "resetExecutionOrder", resetExecutionOrder)
+setattr(cls, "resetexecutionOrder", resetexecutionOrder)
-setattr(cls, "compileExecutionOrder", compileExecutionOrder)
+setattr(cls, "compileexecutionOrder", compileexecutionOrder)
-setattr(cls, "setElementExecutionOrder", setElementExecutionOrder)
+setattr(cls, "setelementExecutionOrder", setelementExecutionOrder)
-setattr(cls, "addInstance", addInstance)
+setattr(cls, "addinstance", addinstance)
-setattr(cls, "getInstances", getInstances)
+setattr(cls, "getinstances", getinstances)
-setattr(cls, "getInstance", getInstance)
+setattr(cls, "getinstance", getinstance)
-setattr(cls, "getRandomInstance", getRandomInstance)
+setattr(cls, "getrandomInstance", getrandomInstance)
-setattr(cls, "getInstanceByName", getInstanceByName)
+setattr(cls, "getinstanceByName", getinstanceByName)
-setattr(cls, "removeInstance", removeInstance)
+setattr(cls, "removeinstance", removeinstance)
-setattr(cls, "setText", setText)
+setattr(cls, "settext", settext)
-setattr(cls, "getText", getText)
+setattr(cls, "gettext", gettext)
 def updateElementName(self, old_name, new_name):
 self.body.updateElementName(old_name, new_name)
 setattr(cls, "updateElementName", updateElementName)
-def hasBlock(self, name):
+def hasblock(self, name):
-if self.getBodyType() in ["FBD", "LD", "SFC"]:
+if self.getbodyType() in ["FBD", "LD", "SFC"]:
-for instance in self.getInstances():
+for instance in self.getinstances():
-if isinstance(instance, PLCOpenClasses["block"]) and instance.getInstanceName() == name:
+if isinstance(instance, PLCOpenClasses["fbdObjects_block"]) and instance.getinstanceName() == name:
 return True
 return False
-setattr(cls, "hasBlock", hasBlock)
+setattr(cls, "hasblock", hasblock)
 cls = PLCOpenClasses.get("body", None)
 if cls:
 cls.currentExecutionOrderId = 0
-def resetCurrentExecutionOrderId(self):
+def resetcurrentExecutionOrderId(self):
 self.currentExecutionOrderId = 0
-setattr(cls, "resetCurrentExecutionOrderId", resetCurrentExecutionOrderId)
+setattr(cls, "resetcurrentExecutionOrderId", resetcurrentExecutionOrderId)
-def getNewExecutionOrderId(self):
+def getnewExecutionOrderId(self):
 self.currentExecutionOrderId += 1
 return self.currentExecutionOrderId
-setattr(cls, "getNewExecutionOrderId", getNewExecutionOrderId)
+setattr(cls, "getnewExecutionOrderId", getnewExecutionOrderId)
-def resetExecutionOrder(self):
+def resetexecutionOrder(self):
 if self.content["name"] == "FBD":
-for element in self.content["value"].getContent():
+for element in self.content["value"].getcontent():
-if not isinstance(element["value"], (PLCOpenClasses.get("comment", None), PLCOpenClasses.get("connector", None), PLCOpenClasses.get("continuation", None))):
+if not isinstance(element["value"], (PLCOpenClasses.get("commonObjects_comment", None),
-element["value"].setExecutionOrderId(0)
+PLCOpenClasses.get("commonObjects_connector", None),
+PLCOpenClasses.get("commonObjects_continuation", None))):
+element["value"].setexecutionOrderId(0)
 else:
 raise TypeError, "Can only generate execution order on FBD networks!"
-setattr(cls, "resetExecutionOrder", resetExecutionOrder)
+setattr(cls, "resetexecutionOrder", resetexecutionOrder)
-def compileExecutionOrder(self):
+def compileexecutionOrder(self):
 if self.content["name"] == "FBD":
-self.resetExecutionOrder()
+self.resetexecutionOrder()
-self.resetCurrentExecutionOrderId()
+self.resetcurrentExecutionOrderId()
-for element in self.content["value"].getContent():
+for element in self.content["value"].getcontent():
-if isinstance(element["value"], PLCOpenClasses.get("outVariable", None)) and element["value"].getExecutionOrderId() == 0:
+if isinstance(element["value"], PLCOpenClasses.get("fbdObjects_outVariable", None)) and element["value"].getExecutionOrderId() == 0:
-connections = element["value"].connectionPointIn.getConnections()
+connections = element["value"].connectionPointIn.getconnections()
 if connections and len(connections) == 1:
-self.compileElementExecutionOrder(connections[0])
+self.compileelementExecutionOrder(connections[0])
-element["value"].setExecutionOrderId(self.getNewExecutionOrderId())
+element["value"].setexecutionOrderId(self.getnewExecutionOrderId())
 else:
 raise TypeError, "Can only generate execution order on FBD networks!"
-setattr(cls, "compileExecutionOrder", compileExecutionOrder)
+setattr(cls, "compileexecutionOrder", compileexecutionOrder)
-def compileElementExecutionOrder(self, link):
+def compileelementExecutionOrder(self, link):
 if self.content["name"] == "FBD":
-localid = link.getRefLocalId()
+localid = link.getrefLocalId()
-instance = self.getContentInstance(localid)
+instance = self.getcontentInstance(localid)
-if isinstance(instance, PLCOpenClasses.get("block", None)) and instance.getExecutionOrderId() == 0:
+if isinstance(instance, PLCOpenClasses.get("fbdObjects_block", None)) and instance.getexecutionOrderId() == 0:
-for variable in instance.inputVariables.getVariable():
+for variable in instance.inputVariables.getvariable():
-connections = variable.connectionPointIn.getConnections()
+connections = variable.connectionPointIn.getconnections()
 if connections and len(connections) == 1:
-self.compileElementExecutionOrder(connections[0])
+self.compileelementExecutionOrder(connections[0])
-instance.setExecutionOrderId(self.getNewExecutionOrderId())
+instance.setexecutionOrderId(self.getnewExecutionOrderId())
-elif isinstance(instance, PLCOpenClasses.get("continuation", None)) and instance.getExecutionOrderId() == 0:
+elif isinstance(instance, PLCOpenClasses.get("commonObjects_continuation", None)) and instance.getexecutionOrderId() == 0:
-name = instance.getName()
+name = instance.getname()
-for tmp_instance in self.getContentInstances():
+for tmp_instance in self.getcontentInstances():
-if isinstance(tmp_instance, PLCOpenClasses.get("connector", None)) and tmp_instance.getName() == name and tmp_instance.getExecutionOrderId() == 0:
+if isinstance(tmp_instance, PLCOpenClasses.get("commonObjects_connector", None)) and tmp_instance.getname() == name and tmp_instance.getexecutionOrderId() == 0:
-connections = tmp_instance.connectionPointIn.getConnections()
+connections = tmp_instance.connectionPointIn.getconnections()
 if connections and len(connections) == 1:
-self.compileElementExecutionOrder(connections[0])
+self.compileelementExecutionOrder(connections[0])
 else:
 raise TypeError, "Can only generate execution order on FBD networks!"
-setattr(cls, "compileElementExecutionOrder", compileElementExecutionOrder)
+setattr(cls, "compileelementExecutionOrder", compileelementExecutionOrder)
-def setElementExecutionOrder(self, instance, new_executionOrder):
+def setelementExecutionOrder(self, instance, new_executionOrder):
 if self.content["name"] == "FBD":
-old_executionOrder = instance.getExecutionOrderId()
+old_executionOrder = instance.getexecutionOrderId()
 if old_executionOrder is not None and old_executionOrder != 0 and new_executionOrder != 0:
-for element in self.content["value"].getContent():
+for element in self.content["value"].getcontent():
-if element["value"] != instance and not isinstance(element["value"], PLCOpenClasses.get("comment", None)):
+if element["value"] != instance and not isinstance(element["value"], PLCOpenClasses.get("commonObjects_comment", None)):
-element_executionOrder = element["value"].getExecutionOrderId()
+element_executionOrder = element["value"].getexecutionOrderId()
 if old_executionOrder <= element_executionOrder <= new_executionOrder:
-element["value"].setExecutionOrderId(element_executionOrder - 1)
+element["value"].setexecutionOrderId(element_executionOrder - 1)
 if new_executionOrder <= element_executionOrder <= old_executionOrder:
-element["value"].setExecutionOrderId(element_executionOrder + 1)
+element["value"].setexecutionOrderId(element_executionOrder + 1)
-instance.setExecutionOrderId(new_executionOrder)
+instance.setexecutionOrderId(new_executionOrder)
 else:
 raise TypeError, "Can only generate execution order on FBD networks!"
-setattr(cls, "setElementExecutionOrder", setElementExecutionOrder)
+setattr(cls, "setelementExecutionOrder", setelementExecutionOrder)
-def appendContentInstance(self, name, instance):
+def appendcontentInstance(self, name, instance):
 if self.content["name"] in ["LD","FBD","SFC"]:
-self.content["value"].appendContent(name, instance)
+self.content["value"].appendcontent({"name" : name, "value" : instance})
 else:
 raise TypeError, "%s body don't have instances!"%self.content["name"]
-setattr(cls, "appendContentInstance", appendContentInstance)
+setattr(cls, "appendcontentInstance", appendcontentInstance)
-def getContentInstances(self):
+def getcontentInstances(self):
 if self.content["name"] in ["LD","FBD","SFC"]:
 instances = []
-for element in self.content["value"].getContent():
+for element in self.content["value"].getcontent():
 instances.append(element["value"])
 return instances
 else:
 raise TypeError, "%s body don't have instances!"%self.content["name"]
-setattr(cls, "getContentInstances", getContentInstances)
+setattr(cls, "getcontentInstances", getcontentInstances)
-def getContentInstance(self, id):
+def getcontentInstance(self, id):
 if self.content["name"] in ["LD","FBD","SFC"]:
-for element in self.content["value"].getContent():
+for element in self.content["value"].getcontent():
-if element["value"].getLocalId() == id:
+if element["value"].getlocalId() == id:
 return element["value"]
 return None
 else:
 raise TypeError, "%s body don't have instances!"%self.content["name"]
-setattr(cls, "getContentInstance", getContentInstance)
+setattr(cls, "getcontentInstance", getcontentInstance)
-def getContentRandomInstance(self, exclude):
+def getcontentRandomInstance(self, exclude):
 if self.content["name"] in ["LD","FBD","SFC"]:
-for element in self.content["value"].getContent():
+for element in self.content["value"].getcontent():
-if element["value"].getLocalId() not in exclude:
+if element["value"].getlocalId() not in exclude:
 return element["value"]
 return None
 else:
 raise TypeError, "%s body don't have instances!"%self.content["name"]
-setattr(cls, "getContentRandomInstance", getContentRandomInstance)
+setattr(cls, "getcontentRandomInstance", getcontentRandomInstance)
-def getContentInstanceByName(self, name):
+def getcontentInstanceByName(self, name):
 if self.content["name"] in ["LD","FBD","SFC"]:
-for element in self.content["value"].getContent():
+for element in self.content["value"].getcontent():
 if element["value"].getLocalId() == name:
 return element["value"]
 else:
 raise TypeError, "%s body don't have instances!"%self.content["name"]
-setattr(cls, "getContentInstanceByName", getContentInstanceByName)
+setattr(cls, "getcontentInstanceByName", getcontentInstanceByName)
-def removeContentInstance(self, id):
+def removecontentInstance(self, id):
 if self.content["name"] in ["LD","FBD","SFC"]:
 i = 0
 removed = False
-elements = self.content["value"].getContent()
+elements = self.content["value"].getcontent()
 while i < len(elements) and not removed:
-if elements[i]["value"].getLocalId() == id:
+if elements[i]["value"].getlocalId() == id:
-self.content["value"].removeContent(i)
+self.content["value"].removecontent(i)
 removed = True
 i += 1
 if not removed:
 raise ValueError, "Instance with id %d doesn't exists!"%id
 else:
 raise TypeError, "%s body don't have instances!"%self.content["name"]
-setattr(cls, "removeContentInstance", removeContentInstance)
+setattr(cls, "removecontentInstance", removecontentInstance)
-def setText(self, text):
+def settext(self, text):
 if self.content["name"] in ["IL","ST"]:
-self.content["value"].setText(text)
+self.content["value"].settext(text)
 else:
 raise TypeError, "%s body don't have text!"%self.content["name"]
-setattr(cls, "setText", setText)
+setattr(cls, "settext", settext)
-def getText(self):
+def gettext(self):
 if self.content["name"] in ["IL","ST"]:
-return self.content["value"].getText()
+return self.content["value"].gettext()
 else:
 raise TypeError, "%s body don't have text!"%self.content["name"]
-setattr(cls, "getText", getText)
+setattr(cls, "gettext", gettext)
 def updateElementName(self, old_name, new_name):
 if self.content["name"] in ["IL", "ST"]:
 self.content["value"].updateElementName(old_name, new_name)
 else:
-for element in self.content["value"].getContent():
+for element in self.content["value"].getcontent():
 element["value"].updateElementName(old_name, new_name)
 setattr(cls, "updateElementName", updateElementName)
-def getX(self):
+def getx(self):
-return self.position.getX()
+return self.position.getx()
-def getY(self):
+def gety(self):
-return self.position.getY()
+return self.position.gety()
-def setX(self, x):
+def setx(self, x):
-self.position.setX(x)
+self.position.setx(x)
-def setY(self, y):
+def sety(self, y):
-self.position.setY(y)
+self.position.sety(y)
-cls = PLCOpenClasses.get("comment", None)
+cls = PLCOpenClasses.get("commonObjects_comment", None)
 if cls:
-setattr(cls, "getX", getX)
+setattr(cls, "getx", getx)
-setattr(cls, "getY", getY)
+setattr(cls, "gety", gety)
-setattr(cls, "setX", setX)
+setattr(cls, "setx", setx)
-setattr(cls, "setY", setY)
+setattr(cls, "sety", sety)
-def setContentText(self, text):
+def setcontentText(self, text):
-self.content.setText(text)
+self.content.settext(text)
-setattr(cls, "setContentText", setContentText)
+setattr(cls, "setcontentText", setcontentText)
-def getContentText(self):
+def getcontentText(self):
-return self.content.getText()
+return self.content.gettext()
-setattr(cls, "getContentText", getContentText)
+setattr(cls, "getcontentText", getcontentText)
 def updateElementName(self, old_name, new_name):
 self.content.updateElementName(old_name, new_name)
 setattr(cls, "updateElementName", updateElementName)
-cls = PLCOpenClasses.get("block", None)
+cls = PLCOpenClasses.get("fbdObjects_block", None)
 if cls:
-setattr(cls, "getX", getX)
+setattr(cls, "getx", getx)
-setattr(cls, "getY", getY)
+setattr(cls, "gety", gety)
-setattr(cls, "setX", setX)
+setattr(cls, "setx", setx)
-setattr(cls, "setY", setY)
+setattr(cls, "sety", sety)
 def updateElementName(self, old_name, new_name):
 if self.typeName == old_name:
 self.typeName = new_name
 setattr(cls, "updateElementName", updateElementName)
-cls = PLCOpenClasses.get("inputVariables_variable", None)
+cls = PLCOpenClasses.get("ldObjects_leftPowerRail", None)
 if cls:
-def setConnectorEdge(self, edge):
+setattr(cls, "getx", getx)
-if not self.edge:
+setattr(cls, "gety", gety)
-self.edge = PLCOpenClasses["edgeModifierType"]()
+setattr(cls, "setx", setx)
-self.edge.setValue(edge)
+setattr(cls, "sety", sety)
-setattr(cls, "setConnectorEdge", setConnectorEdge)
-def getConnectorEdge(self):
-if self.edge:
-return self.edge.getValue()
-return None
-setattr(cls, "getConnectorEdge", getConnectorEdge)
-cls = PLCOpenClasses.get("outputVariables_variable", None)
-if cls:
-def setConnectorEdge(self, edge):
-if not self.edge:
-self.edge = PLCOpenClasses["edgeModifierType"]()
-self.edge.setValue(edge)
-setattr(cls, "setConnectorEdge", setConnectorEdge)
-def getConnectorEdge(self):
-if self.edge:
-return self.edge.getValue()
-return None
-setattr(cls, "getConnectorEdge", getConnectorEdge)
-cls = PLCOpenClasses.get("leftPowerRail", None)
-if cls:
-setattr(cls, "getX", getX)
-setattr(cls, "getY", getY)
-setattr(cls, "setX", setX)
-setattr(cls, "setY", setY)
 def updateElementName(self, old_name, new_name):
 pass
 setattr(cls, "updateElementName", updateElementName)
-cls = PLCOpenClasses.get("rightPowerRail", None)
+cls = PLCOpenClasses.get("ldObjects_rightPowerRail", None)
 if cls:
-setattr(cls, "getX", getX)
+setattr(cls, "getx", getx)
-setattr(cls, "getY", getY)
+setattr(cls, "gety", gety)
-setattr(cls, "setX", setX)
+setattr(cls, "setx", setx)
-setattr(cls, "setY", setY)
+setattr(cls, "sety", sety)
 def updateElementName(self, old_name, new_name):
 pass
 setattr(cls, "updateElementName", updateElementName)
-cls = PLCOpenClasses.get("contact", None)
+cls = PLCOpenClasses.get("ldObjects_contact", None)
 if cls:
-setattr(cls, "getX", getX)
+setattr(cls, "getx", getx)
-setattr(cls, "getY", getY)
+setattr(cls, "gety", gety)
-setattr(cls, "setX", setX)
+setattr(cls, "setx", setx)
-setattr(cls, "setY", setY)
+setattr(cls, "sety", sety)
-def setContactEdge(self, edge):
-if not self.edge:
-self.edge = PLCOpenClasses["edgeModifierType"]()
-self.edge.setValue(edge)
-setattr(cls, "setContactEdge", setContactEdge)
-def getContactEdge(self):
-if self.edge:
-return self.edge.getValue()
-return None
-setattr(cls, "getContactEdge", getContactEdge)
 def updateElementName(self, old_name, new_name):
 if self.variable == old_name:
 self.variable = new_name
 setattr(cls, "updateElementName", updateElementName)
-cls = PLCOpenClasses.get("coil", None)
+cls = PLCOpenClasses.get("ldObjects_coil", None)
 if cls:
-setattr(cls, "getX", getX)
+setattr(cls, "getx", getx)
-setattr(cls, "getY", getY)
+setattr(cls, "gety", gety)
-setattr(cls, "setX", setX)
+setattr(cls, "setx", setx)
-setattr(cls, "setY", setY)
+setattr(cls, "sety", sety)
-def setCoilStorage(self, edge):
-if not self.storage:
-self.storage = PLCOpenClasses["storageModifierType"]()
-self.storage.setValue(edge)
-setattr(cls, "setCoilStorage", setCoilStorage)
-def getCoilStorage(self):
-if self.storage:
-return self.storage.getValue()
-return None
-setattr(cls, "getCoilStorage", getCoilStorage)
 def updateElementName(self, old_name, new_name):
 if self.variable == old_name:
 self.variable = new_name
 setattr(cls, "updateElementName", updateElementName)
-cls = PLCOpenClasses.get("step", None)
+cls = PLCOpenClasses.get("sfcObjects_step", None)
 if cls:
-setattr(cls, "getX", getX)
+setattr(cls, "getx", getx)
-setattr(cls, "getY", getY)
+setattr(cls, "gety", gety)
-setattr(cls, "setX", setX)
+setattr(cls, "setx", setx)
-setattr(cls, "setY", setY)
+setattr(cls, "sety", sety)
 def updateElementName(self, old_name, new_name):
 pass
 setattr(cls, "updateElementName", updateElementName)
-cls = PLCOpenClasses.get("transition", None)
+cls = PLCOpenClasses.get("sfcObjects_transition", None)
 if cls:
-setattr(cls, "getX", getX)
+setattr(cls, "getx", getx)
-setattr(cls, "getY", getY)
+setattr(cls, "gety", gety)
-setattr(cls, "setX", setX)
+setattr(cls, "setx", setx)
-setattr(cls, "setY", setY)
+setattr(cls, "sety", sety)
-def setConditionContent(self, type, value):
+def setconditionContent(self, type, value):
 if not self.condition:
-self.addCondition()
+self.addcondition()
 if type == "reference":
 condition = PLCOpenClasses["condition_reference"]()
-condition.setName(value)
+condition.setname(value)
 elif type == "inline":
 condition = PLCOpenClasses["condition_inline"]()
-condition.setContent("ST", PLCOpenClasses["formattedText"]())
+condition.setcontent({"name" : "ST", "value" : PLCOpenClasses["formattedText"]()})
-condition.setText(value)
+condition.settext(value)
 elif type == "connection":
 condition = []
-self.condition.setContent(type, condition)
+self.condition.setcontent({"name" : type, "value" : condition})
-setattr(cls, "setConditionContent", setConditionContent)
+setattr(cls, "setconditionContent", setconditionContent)
-def getConditionContent(self):
+def getconditionContent(self):
 if self.condition:
-content = self.condition.getContent()
+content = self.condition.getcontent()
 values = {"type" : content["name"]}
 if values["type"] == "reference":
-values["value"] = content["value"].getName()
+values["value"] = content["value"].getname()
 elif values["type"] == "inline":
-values["value"] = content["value"].getText()
+values["value"] = content["value"].gettext()
 return values
 return ""
-setattr(cls, "getConditionContent", getConditionContent)
+setattr(cls, "getconditionContent", getconditionContent)
 def updateElementName(self, old_name, new_name):
 if self.condition:
-content = self.condition.getContent()
+content = self.condition.getcontent()
 if content["name"] == "reference":
-if content["value"].getName() == old_name:
+if content["value"].getname() == old_name:
-content["value"].setName(new_name)
+content["value"].setname(new_name)
 elif content["name"] == "inline":
 content["value"].updateElementName(old_name, new_name)
 setattr(cls, "updateElementName", updateElementName)
-def addConnection(self):
+def addconnection(self):
 if self.condition:
-content = self.condition.getContent()
+content = self.condition.getcontent()
 if content["name"] != "connection":
-self.condition.setContent("connection", [])
+self.condition.setcontent({"name" : "connection", "value" : []})
-content = self.condition.getContent()
+content = self.condition.getcontent()
 content["value"].append(PLCOpenClasses["connection"]())
-setattr(cls, "addConnection", addConnection)
+setattr(cls, "addconnection", addconnection)
-def removeConnection(self, idx):
+def removeconnection(self, idx):
 if self.condition:
-content = self.condition.getContent()
+content = self.condition.getcontent()
 if content["name"] == "connection":
 content["value"].pop(idx)
-setattr(cls, "removeConnection", removeConnection)
+setattr(cls, "removeconnection", removeconnection)
-def removeConnections(self):
+def removeconnections(self):
 if self.condition:
-content = self.condition.getContent()
+content = self.condition.getcontent()
 if content["name"] == "connection":
 content["value"] = []
-setattr(cls, "removeConnections", removeConnections)
+setattr(cls, "removeconnections", removeconnections)
-def getConnections(self):
+def getconnections(self):
 if self.condition:
-content = self.condition.getContent()
+content = self.condition.getcontent()
 if content["name"] == "connection":
 return content["value"]
-setattr(cls, "getConnections", getConnections)
+setattr(cls, "getconnections", getconnections)
-def setConnectionId(self, idx, id):
+def setconnectionId(self, idx, id):
 if self.condition:
-content = self.condition.getContent()
+content = self.condition.getcontent()
 if content["name"] == "connection":
-content["value"][idx].setRefLocalId(id)
+content["value"][idx].setrefLocalId(id)
-setattr(cls, "setConnectionId", setConnectionId)
+setattr(cls, "setconnectionId", setconnectionId)
-def getConnectionId(self, idx):
+def getconnectionId(self, idx):
 if self.condition:
-content = self.condition.getContent()
+content = self.condition.getcontent()
 if content["name"] == "connection":
-return content["value"][idx].getRefLocalId()
+return content["value"][idx].getrefLocalId()
 return None
-setattr(cls, "getConnectionId", getConnectionId)
+setattr(cls, "getconnectionId", getconnectionId)
-def setConnectionPoints(self, idx, points):
+def setconnectionPoints(self, idx, points):
 if self.condition:
-content = self.condition.getContent()
+content = self.condition.getcontent()
 if content["name"] == "connection":
-content["value"][idx].setPoints(points)
+content["value"][idx].setpoints(points)
-setattr(cls, "setConnectionPoints", setConnectionPoints)
+setattr(cls, "setconnectionPoints", setconnectionPoints)
-def getConnectionPoints(self, idx):
+def getconnectionPoints(self, idx):
 if self.condition:
-content = self.condition.getContent()
+content = self.condition.getcontent()
 if content["name"] == "connection":
-return content["value"][idx].getPoints()
+return content["value"][idx].getpoints()
 return None
-setattr(cls, "getConnectionPoints", getConnectionPoints)
+setattr(cls, "getconnectionPoints", getconnectionPoints)
-def setConnectionParameter(self, idx, parameter):
+def setconnectionParameter(self, idx, parameter):
 if self.condition:
-content = self.condition.getContent()
+content = self.condition.getcontent()
 if content["name"] == "connection":
-content["value"][idx].setFormalParameter(parameter)
+content["value"][idx].setformalParameter(parameter)
-setattr(cls, "setConnectionParameter", setConnectionParameter)
+setattr(cls, "setconnectionParameter", setconnectionParameter)
-def getConnectionParameter(self, idx):
+def getconnectionParameter(self, idx):
 if self.condition:
-content = self.condition.getContent()
+content = self.condition.getcontent()
 if content["name"] == "connection":
-return content["value"][idx].getFormalParameter()
+return content["value"][idx].getformalParameter()
 return None
-setattr(cls, "getConnectionParameter", getConnectionParameter)
+setattr(cls, "getconnectionParameter", getconnectionParameter)
-setattr(cls, "addConnection", addConnection)
+cls = PLCOpenClasses.get("sfcObjects_selectionDivergence", None)
+if cls:
-cls = PLCOpenClasses.get("selectionDivergence", None)
+setattr(cls, "getx", getx)
-if cls:
+setattr(cls, "gety", gety)
-setattr(cls, "getX", getX)
+setattr(cls, "setx", setx)
-setattr(cls, "getY", getY)
+setattr(cls, "sety", sety)
-setattr(cls, "setX", setX)
-setattr(cls, "setY", setY)
 def updateElementName(self, old_name, new_name):
 pass
 setattr(cls, "updateElementName", updateElementName)
-cls = PLCOpenClasses.get("selectionConvergence", None)
+cls = PLCOpenClasses.get("sfcObjects_selectionConvergence", None)
 if cls:
-setattr(cls, "getX", getX)
+setattr(cls, "getx", getx)
-setattr(cls, "getY", getY)
+setattr(cls, "gety", gety)
-setattr(cls, "setX", setX)
+setattr(cls, "setx", setx)
-setattr(cls, "setY", setY)
+setattr(cls, "sety", sety)
 def updateElementName(self, old_name, new_name):
 pass
 setattr(cls, "updateElementName", updateElementName)
-cls = PLCOpenClasses.get("simultaneousDivergence", None)
+cls = PLCOpenClasses.get("sfcObjects_simultaneousDivergence", None)
 if cls:
-setattr(cls, "getX", getX)
+setattr(cls, "getx", getx)
-setattr(cls, "getY", getY)
+setattr(cls, "gety", gety)
-setattr(cls, "setX", setX)
+setattr(cls, "setx", setx)
-setattr(cls, "setY", setY)
+setattr(cls, "sety", sety)
 def updateElementName(self, old_name, new_name):
 pass
 setattr(cls, "updateElementName", updateElementName)
-cls = PLCOpenClasses.get("simultaneousConvergence", None)
+cls = PLCOpenClasses.get("sfcObjects_simultaneousConvergence", None)
 if cls:
-setattr(cls, "getX", getX)
+setattr(cls, "getx", getx)
-setattr(cls, "getY", getY)
+setattr(cls, "gety", gety)
-setattr(cls, "setX", setX)
+setattr(cls, "setx", setx)
-setattr(cls, "setY", setY)
+setattr(cls, "sety", sety)
 def updateElementName(self, old_name, new_name):
 pass
 setattr(cls, "updateElementName", updateElementName)
-cls = PLCOpenClasses.get("jumpStep", None)
+cls = PLCOpenClasses.get("sfcObjects_jumpStep", None)
 if cls:
-setattr(cls, "getX", getX)
+setattr(cls, "getx", getx)
-setattr(cls, "getY", getY)
+setattr(cls, "gety", gety)
-setattr(cls, "setX", setX)
+setattr(cls, "setx", setx)
-setattr(cls, "setY", setY)
+setattr(cls, "sety", sety)
 def updateElementName(self, old_name, new_name):
 pass
 setattr(cls, "updateElementName", updateElementName)
 cls = PLCOpenClasses.get("actionBlock_action", None)
 if cls:
-def setQualifierValue(self, value):
+def setreferenceName(self, name):
-if self.qualifier:
+if self.reference:
-self.qualifier.setValue(value)
+self.reference.setname(name)
-setattr(cls, "setQualifierValue", setQualifierValue)
+setattr(cls, "setreferenceName", setreferenceName)
-def getQualifierValue(self):
+def getreferenceName(self):
-if self.qualifier:
+if self.reference:
-return self.qualifier.getValue()
+return self.reference.getname()
 return None
-setattr(cls, "getQualifierValue", getQualifierValue)
+setattr(cls, "getreferenceName", getreferenceName)
-def setReferenceName(self, name):
+def setinlineContent(self, content):
-if self.reference:
+if self.inline:
-self.reference.setName(name)
+self.inline.setcontent({"name" : "ST", "value" : PLCOpenClasses["formattedText"]()})
-setattr(cls, "setReferenceName", setReferenceName)
+self.inline.settext(content)
+setattr(cls, "setinlineContent", setinlineContent)
-def getReferenceName(self):
-if self.reference:
+def getinlineContent(self):
-return self.reference.getName()
+if self.inline:
+return self.inline.gettext()
 return None
-setattr(cls, "getReferenceName", getReferenceName)
+setattr(cls, "getinlineContent", getinlineContent)
-def setInlineContent(self, content):
+def updateElementName(self, old_name, new_name):
-if self.inline:
+if self.reference and self.reference.getname() == old_name:
-self.inline.setContent("ST", PLCOpenClasses["formattedText"]())
+self.reference.setname(new_name)
-self.inline.setText(content)
-setattr(cls, "setInlineContent", setInlineContent)
-def getInlineContent(self):
-if self.inline:
-return self.inline.getText()
-return None
-setattr(cls, "getInlineContent", getInlineContent)
-def updateElementName(self, old_name, new_name):
-if self.reference and self.reference.getName() == old_name:
-self.reference.setName(new_name)
 if self.inline:
 self.inline.updateElementName(old_name, new_name)
 setattr(cls, "updateElementName", updateElementName)
-cls = PLCOpenClasses.get("actionBlock", None)
+cls = PLCOpenClasses.get("commonObjects_actionBlock", None)
 if cls:
-setattr(cls, "getX", getX)
+setattr(cls, "getx", getx)
-setattr(cls, "getY", getY)
+setattr(cls, "gety", gety)
-setattr(cls, "setX", setX)
+setattr(cls, "setx", setx)
-setattr(cls, "setY", setY)
+setattr(cls, "sety", sety)
-def setActions(self, actions):
+def setactions(self, actions):
 self.action = []
 for params in actions:
 action = PLCOpenClasses["actionBlock_action"]()
-action.addQualifier()
+action.setqualifier(params["qualifier"])
-action.setQualifierValue(params["qualifier"])
 if params["type"] == "reference":
-action.addReference()
+action.addreference()
-action.setReferenceName(params["value"])
+action.setreferenceName(params["value"])
 else:
-action.addInline()
+action.addinline()
-action.setInlineContent(params["value"])
+action.setinlineContent(params["value"])
 if "duration" in params:
-action.setDuration(params["duration"])
+action.setduration(params["duration"])
 if "indicator" in params:
-action.setIndicator(params["indicator"])
+action.setindicator(params["indicator"])
 self.action.append(action)
-setattr(cls, "setActions", setActions)
+setattr(cls, "setactions", setactions)
-def getActions(self):
+def getactions(self):
 actions = []
 for action in self.action:
 params = {}
-params["qualifier"] = action.getQualifierValue()
+params["qualifier"] = action.getqualifier()
 if params["qualifier"] is None:
 params["qualifier"] = "N"
-if action.getReference():
+if action.getreference():
 params["type"] = "reference"
-params["value"] = action.getReferenceName()
+params["value"] = action.getreferenceName()
-elif action.getInline():
+elif action.getinline():
 params["type"] = "inline"
-params["value"] = action.getInlineContent()
+params["value"] = action.getinlineContent()
-duration = action.getDuration()
+duration = action.getduration()
 if duration:
 params["duration"] = duration
-indicator = action.getIndicator()
+indicator = action.getindicator()
 if indicator:
 params["indicator"] = indicator
 actions.append(params)
 return actions
-setattr(cls, "getActions", getActions)
+setattr(cls, "getactions", getactions)
 def updateElementName(self, old_name, new_name):
 for action in self.action:
 action.updateElementName(old_name, new_name)
 setattr(cls, "updateElementName", updateElementName)
-cls = PLCOpenClasses.get("inVariable", None)
+cls = PLCOpenClasses.get("fbdObjects_inVariable", None)
 if cls:
-setattr(cls, "getX", getX)
+setattr(cls, "getx", getx)
-setattr(cls, "getY", getY)
+setattr(cls, "gety", gety)
-setattr(cls, "setX", setX)
+setattr(cls, "setx", setx)
-setattr(cls, "setY", setY)
+setattr(cls, "sety", sety)
-def setConnectorEdge(self, edge):
-if not self.edge:
-self.edge = PLCOpenClasses["edgeModifierType"]()
-self.edge.setValue(edge)
-setattr(cls, "setConnectorEdge", setConnectorEdge)
-def getConnectorEdge(self):
-if self.edge:
-return self.edge.getValue()
-return None
-setattr(cls, "getConnectorEdge", getConnectorEdge)
 def updateElementName(self, old_name, new_name):
 if self.expression == old_name:
 self.expression = new_name
 setattr(cls, "updateElementName", updateElementName)
-cls = PLCOpenClasses.get("outVariable", None)
+cls = PLCOpenClasses.get("fbdObjects_outVariable", None)
 if cls:
-setattr(cls, "getX", getX)
+setattr(cls, "getx", getx)
-setattr(cls, "getY", getY)
+setattr(cls, "gety", gety)
-setattr(cls, "setX", setX)
+setattr(cls, "setx", setx)
-setattr(cls, "setY", setY)
+setattr(cls, "sety", sety)
-def setConnectorEdge(self, edge):
-if not self.edge:
-self.edge = PLCOpenClasses["edgeModifierType"]()
-self.edge.setValue(edge)
-setattr(cls, "setConnectorEdge", setConnectorEdge)
-def getConnectorEdge(self):
-if self.edge:
-return self.edge.getValue()
-return None
-setattr(cls, "getConnectorEdge", getConnectorEdge)
 def updateElementName(self, old_name, new_name):
 if self.expression == old_name:
 self.expression = new_name
 setattr(cls, "updateElementName", updateElementName)
-cls = PLCOpenClasses.get("inOutVariable", None)
+cls = PLCOpenClasses.get("fbdObjects_inOutVariable", None)
 if cls:
-setattr(cls, "getX", getX)
+setattr(cls, "getx", getx)
-setattr(cls, "getY", getY)
+setattr(cls, "gety", gety)
-setattr(cls, "setX", setX)
+setattr(cls, "setx", setx)
-setattr(cls, "setY", setY)
+setattr(cls, "sety", sety)
-def setInputEdge(self, edge):
-if not self.edgeIn:
-self.edgeIn = PLCOpenClasses["edgeModifierType"]()
-self.edgeIn.setValue(edge)
-setattr(cls, "setInputEdge", setInputEdge)
-def getInputEdge(self):
-if self.edgeIn:
-return self.edgeIn.getValue()
-return None
-setattr(cls, "getInputEdge", getInputEdge)
-def setOutputEdge(self, edge):
-if not self.edgeOut:
-self.edgeOut = PLCOpenClasses["edgeModifierType"]()
-self.edgeOut.setValue(edge)
-setattr(cls, "setInputEdge", setInputEdge)
-def getOutputEdge(self):
-if self.edgeOut:
-return self.edgeOut.getValue()
-return None
-setattr(cls, "getOutputEdge", getOutputEdge)
 def updateElementName(self, old_name, new_name):
 if self.expression == old_name:
 self.expression = new_name
 setattr(cls, "updateElementName", updateElementName)
-cls = PLCOpenClasses.get("continuation", None)
+cls = PLCOpenClasses.get("commonObjects_continuation", None)
 if cls:
-setattr(cls, "getX", getX)
+setattr(cls, "getx", getx)
-setattr(cls, "getY", getY)
+setattr(cls, "gety", gety)
-setattr(cls, "setX", setX)
+setattr(cls, "setx", setx)
-setattr(cls, "setY", setY)
+setattr(cls, "sety", sety)
 def updateElementName(self, old_name, new_name):
 pass
 setattr(cls, "updateElementName", updateElementName)
-cls = PLCOpenClasses.get("connector", None)
+cls = PLCOpenClasses.get("commonObjects_connector", None)
 if cls:
-setattr(cls, "getX", getX)
+setattr(cls, "getx", getx)
-setattr(cls, "getY", getY)
+setattr(cls, "gety", gety)
-setattr(cls, "setX", setX)
+setattr(cls, "setx", setx)
-setattr(cls, "setY", setY)
+setattr(cls, "sety", sety)
 def updateElementName(self, old_name, new_name):
 pass
 setattr(cls, "updateElementName", updateElementName)
 cls = PLCOpenClasses.get("connection", None)
 if cls:
-def setPoints(self, points):
+def setpoints(self, points):
 self.position = []
 for point in points:
 position = PLCOpenClasses["position"]()
-position.setX(point.x)
+position.setx(point.x)
-position.setY(point.y)
+position.sety(point.y)
 self.position.append(position)
-setattr(cls, "setPoints", setPoints)
+setattr(cls, "setpoints", setpoints)
-def getPoints(self):
+def getpoints(self):
 points = []
 for position in self.position:
-points.append((position.getX(),position.getY()))
+points.append((position.getx(),position.gety()))
 return points
-setattr(cls, "getPoints", getPoints)
+setattr(cls, "getpoints", getpoints)
 cls = PLCOpenClasses.get("connectionPointIn", None)
 if cls:
-def setRelPosition(self, x, y):
+def setrelPositionXY(self, x, y):
 self.relPosition = PLCOpenClasses["position"]()
-self.relPosition.setX(x)
+self.relPosition.setx(x)
-self.relPosition.setY(y)
+self.relPosition.sety(y)
-setattr(cls, "setRelPosition", setRelPosition)
+setattr(cls, "setrelPositionXY", setrelPositionXY)
-def getRelPosition(self):
+def getrelPositionXY(self):
 if self.relPosition:
-return self.relPosition.getX(), self.relPosition.getY()
+return self.relPosition.getx(), self.relPosition.gety()
 else:
 return self.relPosition
-setattr(cls, "getRelPosition", getRelPosition)
+setattr(cls, "getrelPositionXY", getrelPositionXY)
-def addConnection(self):
+def addconnection(self):
 if not self.content:
-self.content = {"name":"connection","value":[PLCOpenClasses["connection"]()]}
+self.content = {"name" : "connection", "value" : [PLCOpenClasses["connection"]()]}
 else:
 self.content["value"].append(PLCOpenClasses["connection"]())
-setattr(cls, "addConnection", addConnection)
+setattr(cls, "addconnection", addconnection)
-def removeConnection(self, idx):
+def removeconnection(self, idx):
 if self.content:
 self.content["value"].pop(idx)
 if len(self.content["value"]) == 0:
 self.content = None
-setattr(cls, "removeConnection", removeConnection)
+setattr(cls, "removeconnection", removeconnection)
-def removeConnections(self):
+def removeconnections(self):
 if self.content:
 self.content = None
-setattr(cls, "removeConnections", removeConnections)
+setattr(cls, "removeconnections", removeconnections)
-def getConnections(self):
+def getconnections(self):
 if self.content:
 return self.content["value"]
-setattr(cls, "getConnections", getConnections)
+setattr(cls, "getconnections", getconnections)
-def setConnectionId(self, idx, id):
+def setconnectionId(self, idx, id):
 if self.content:
-self.content["value"][idx].setRefLocalId(id)
+self.content["value"][idx].setrefLocalId(id)
-setattr(cls, "setConnectionId", setConnectionId)
+setattr(cls, "setconnectionId", setconnectionId)
-def getConnectionId(self, idx):
+def getconnectionId(self, idx):
 if self.content:
-return self.content["value"][idx].getRefLocalId()
+return self.content["value"][idx].getrefLocalId()
 return None
-setattr(cls, "getConnectionId", getConnectionId)
+setattr(cls, "getconnectionId", getconnectionId)
-def setConnectionPoints(self, idx, points):
+def setconnectionPoints(self, idx, points):
 if self.content:
-self.content["value"][idx].setPoints(points)
+self.content["value"][idx].setpoints(points)
-setattr(cls, "setConnectionPoints", setConnectionPoints)
+setattr(cls, "setconnectionPoints", setconnectionPoints)
-def getConnectionPoints(self, idx):
+def getconnectionPoints(self, idx):
 if self.content:
-return self.content["value"][idx].getPoints()
+return self.content["value"][idx].getpoints()
 return None
-setattr(cls, "getConnectionPoints", getConnectionPoints)
+setattr(cls, "getconnectionPoints", getconnectionPoints)
-def setConnectionParameter(self, idx, parameter):
+def setconnectionParameter(self, idx, parameter):
 if self.content:
-self.content["value"][idx].setFormalParameter(parameter)
+self.content["value"][idx].setformalParameter(parameter)
-setattr(cls, "setConnectionParameter", setConnectionParameter)
+setattr(cls, "setconnectionParameter", setconnectionParameter)
-def getConnectionParameter(self, idx):
+def getconnectionParameter(self, idx):
 if self.content:
-return self.content["value"][idx].getFormalParameter()
+return self.content["value"][idx].getformalParameter()
 return None
-setattr(cls, "getConnectionParameter", getConnectionParameter)
+setattr(cls, "getconnectionParameter", getconnectionParameter)
 cls = PLCOpenClasses.get("connectionPointOut", None)
 if cls:
-def setRelPosition(self, x, y):
+def setrelPositionXY(self, x, y):
 self.relPosition = PLCOpenClasses["position"]()
-self.relPosition.setX(x)
+self.relPosition.setx(x)
-self.relPosition.setY(y)
+self.relPosition.sety(y)
-setattr(cls, "setRelPosition", setRelPosition)
+setattr(cls, "setrelPositionXY", setrelPositionXY)
-def getRelPosition(self):
+def getrelPositionXY(self):
 if self.relPosition:
-return self.relPosition.getX(), self.relPosition.getY()
+return self.relPosition.getx(), self.relPosition.gety()
 return self.relPosition
-setattr(cls, "getRelPosition", getRelPosition)
+setattr(cls, "getrelPositionXY", getrelPositionXY)
 cls = PLCOpenClasses.get("value", None)
 if cls:
-def setValue(self, value):
+def setvalue(self, value):
 if value.startswith("[") and value.endswith("]"):
 arrayValue = PLCOpenClasses["value_arrayValue"]()
-self.content = {"name":"arrayValue","value":arrayValue}
+self.content = {"name" : "arrayValue", "value" : arrayValue}
 elif value.startswith("(") and value.endswith(")"):
 structValue = PLCOpenClasses["value_structValue"]()
-self.content = {"name":"structValue","value":structValue}
+self.content = {"name" : "structValue", "value" : structValue}
 else:
 simpleValue = PLCOpenClasses["value_simpleValue"]()
-self.content = {"name":"simpleValue","value":simpleValue}
+self.content = {"name" : "simpleValue", "value": simpleValue}
-self.content["value"].setValue(value)
+self.content["value"].setvalue(value)
-setattr(cls, "setValue", setValue)
+setattr(cls, "setvalue", setvalue)
-def getValue(self):
+def getvalue(self):
-return self.content["value"].getValue()
+return self.content["value"].getvalue()
-setattr(cls, "getValue", getValue)
+setattr(cls, "getvalue", getvalue)
 def extractValues(values):
 items = values.split(",")
 i = 1
 while i < len(items):
 cls = PLCOpenClasses.get("value_arrayValue", None)
 if cls:
 arrayValue_model = re.compile("([0-9]*)\((.*)\)$")
-def setValue(self, value):
+def setvalue(self, value):
 self.value = []
 for item in extractValues(value[1:-1]):
 item = item.strip()
 element = PLCOpenClasses["arrayValue_value"]()
 result = arrayValue_model.match(item)
 if result is not None:
 groups = result.groups()
-element.setRepetitionValue(int(groups[0]))
+element.setrepetitionValue(int(groups[0]))
-element.setValue(groups[1].strip())
+element.setvalue(groups[1].strip())
 else:
-element.setValue(item)
+element.setvalue(item)
 self.value.append(element)
-setattr(cls, "setValue", setValue)
+setattr(cls, "setvalue", setvalue)
-def getValue(self):
+def getvalue(self):
 values = []
 for element in self.value:
-repetition = element.getRepetitionValue()
+repetition = element.getrepetitionValue()
 if repetition is not None and repetition > 1:
-values.append("%d(%s)"%(repetition, element.getValue()))
+values.append("%d(%s)"%(repetition, element.getvalue()))
 else:
-values.append(element.getValue())
+values.append(element.getvalue())
 return "[%s]"%", ".join(values)
-setattr(cls, "getValue", getValue)
+setattr(cls, "getvalue", getvalue)
 cls = PLCOpenClasses.get("value_structValue", None)
 if cls:
 structValue_model = re.compile("(.*):=(.*)")
-def setValue(self, value):
+def setvalue(self, value):
 self.value = []
 for item in extractValues(value[1:-1]):
 result = arrayValue_model.match(item)
 if result is not None:
 groups = result.groups()
 element = PLCOpenClasses["structValue_value"]()
-element.setMember(groups[0].strip())
+element.setmember(groups[0].strip())
-element.setValue(groups[1].strip())
+element.setvalue(groups[1].strip())
 self.value.append(element)
-setattr(cls, "setValue", setValue)
+setattr(cls, "setvalue", setvalue)
-def getValue(self):
+def getvalue(self):
 values = []
 for element in self.value:
-values.append("%s := %s"%(element.getMember(), element.getValue()))
+values.append("%s := %s"%(element.getmember(), element.getvalue()))
 return "(%s)"%", ".join(values)
-setattr(cls, "getValue", getValue)
+setattr(cls, "getvalue", getvalue)

changeset 151	aaa80b48bead
parent 147	5ef987c1b927
child 166	de1845119cdd