--- a/plcopen/plcopen.py Tue Jan 22 10:53:34 2008 +0100
+++ b/plcopen/plcopen.py Tue Jan 22 10:57:41 2008 +0100
@@ -44,37 +44,10 @@
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:
@@ -91,187 +64,187 @@
if cls:
cls.singleLineAttributes = False
- def setName(self, name):
- self.contentHeader.setName(name)
- setattr(cls, "setName", setName)
+ def setname(self, name):
+ self.contentHeader.setname(name)
+ setattr(cls, "setname", setname)
- def getName(self):
- return self.contentHeader.getName()
- setattr(cls, "getName", getName)
-
- def getFileHeader(self):
+ def getname(self):
+ return self.contentHeader.getname()
+ setattr(cls, "getname", getname)
+
+ def getfileHeader(self):
fileheader = {}
- fileheader["companyName"] = self.fileHeader.getCompanyName()
- if self.fileHeader.getCompanyURL():
- fileheader["companyURL"] = self.fileHeader.getCompanyURL()
- fileheader["productName"] = self.fileHeader.getProductName()
- fileheader["productVersion"] = self.fileHeader.getProductVersion()
- if self.fileHeader.getProductRelease():
- fileheader["productRelease"] = self.fileHeader.getProductRelease()
- fileheader["creationDateTime"] = self.fileHeader.getCreationDateTime()
- if self.fileHeader.getContentDescription():
- fileheader["contentDescription"] = self.fileHeader.getContentDescription()
+ fileheader["companyName"] = self.fileHeader.getcompanyName()
+ if self.fileHeader.getcompanyURL():
+ fileheader["companyURL"] = self.fileHeader.getcompanyURL()
+ fileheader["productName"] = self.fileHeader.getproductName()
+ fileheader["productVersion"] = self.fileHeader.getproductVersion()
+ if self.fileHeader.getproductRelease():
+ fileheader["productRelease"] = self.fileHeader.getproductRelease()
+ fileheader["creationDateTime"] = self.fileHeader.getcreationDateTime()
+ if self.fileHeader.getcontentDescription():
+ fileheader["contentDescription"] = self.fileHeader.getcontentDescription()
return fileheader
- setattr(cls, "getFileHeader", getFileHeader)
-
- def setFileHeader(self, fileheader):
- self.fileHeader.setCompanyName(fileheader["companyName"])
+ setattr(cls, "getfileHeader", getfileHeader)
+
+ def setfileHeader(self, fileheader):
+ self.fileHeader.setcompanyName(fileheader["companyName"])
if "companyURL" in fileheader:
- self.fileHeader.setCompanyURL(fileheader["companyURL"])
- self.fileHeader.setProductName(fileheader["productName"])
- self.fileHeader.setProductVersion(fileheader["productVersion"])
+ self.fileHeader.setcompanyURL(fileheader["companyURL"])
+ self.fileHeader.setproductName(fileheader["productName"])
+ self.fileHeader.setproductVersion(fileheader["productVersion"])
if "productRelease" in fileheader:
- self.fileHeader.setProductRelease(fileheader["productRelease"])
- self.fileHeader.setCreationDateTime(fileheader["creationDateTime"])
+ self.fileHeader.setproductRelease(fileheader["productRelease"])
+ self.fileHeader.setcreationDateTime(fileheader["creationDateTime"])
if "contentDescription" in fileheader:
- self.fileHeader.setContentDescription(fileheader["contentDescription"])
- setattr(cls, "setFileHeader", setFileHeader)
-
- def getContentHeader(self):
+ self.fileHeader.setcontentDescription(fileheader["contentDescription"])
+ setattr(cls, "setfileHeader", setfileHeader)
+
+ def getcontentHeader(self):
contentheader = {}
- contentheader["projectName"] = self.contentHeader.getName()
- if self.contentHeader.getVersion():
- contentheader["projectVersion"] = self.contentHeader.getVersion()
- if self.contentHeader.getModificationDateTime():
- contentheader["modificationDateTime"] = self.contentHeader.getModificationDateTime()
- if self.contentHeader.getOrganization():
- contentheader["organization"] = self.contentHeader.getOrganization()
- if self.contentHeader.getAuthor():
- contentheader["authorName"] = self.contentHeader.getAuthor()
- if self.contentHeader.getLanguage():
- contentheader["language"] = self.contentHeader.getLanguage()
- contentheader["pageSize"] = self.contentHeader.getPageSize()
- contentheader["scaling"] = self.contentHeader.getScaling()
+ contentheader["projectName"] = self.contentHeader.getname()
+ if self.contentHeader.getversion():
+ contentheader["projectVersion"] = self.contentHeader.getversion()
+ if self.contentHeader.getmodificationDateTime():
+ contentheader["modificationDateTime"] = self.contentHeader.getmodificationDateTime()
+ if self.contentHeader.getorganization():
+ contentheader["organization"] = self.contentHeader.getorganization()
+ if self.contentHeader.getauthor():
+ contentheader["authorName"] = self.contentHeader.getauthor()
+ if self.contentHeader.getlanguage():
+ contentheader["language"] = self.contentHeader.getlanguage()
+ contentheader["pageSize"] = self.contentHeader.getpageSize()
+ contentheader["scaling"] = self.contentHeader.getscaling()
return contentheader
- setattr(cls, "getContentHeader", getContentHeader)
-
- def setContentHeader(self, contentheader):
- self.contentHeader.setName(contentheader["projectName"])
+ setattr(cls, "getcontentHeader", getcontentHeader)
+
+ def setcontentHeader(self, contentheader):
+ 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.setPageSize(*contentheader["pageSize"])
- self.contentHeader.setScaling(contentheader["scaling"])
- setattr(cls, "setContentHeader", setContentHeader)
-
- def getDataTypes(self):
- return self.types.getDataTypeElements()
- setattr(cls, "getDataTypes", getDataTypes)
-
- def getDataType(self, name):
- return self.types.getDataTypeElement(name)
- setattr(cls, "getDataType", getDataType)
-
- def appendDataType(self, name):
- self.types.appendDataTypeElement(name)
- setattr(cls, "appendDataType", appendDataType)
+ self.contentHeader.setlanguage(contentheader["language"])
+ self.contentHeader.setpageSize(*contentheader["pageSize"])
+ self.contentHeader.setscaling(contentheader["scaling"])
+ setattr(cls, "setcontentHeader", setcontentHeader)
+
+ def getdataTypes(self):
+ return self.types.getdataTypeElements()
+ setattr(cls, "getdataTypes", getdataTypes)
+
+ def getdataType(self, name):
+ return self.types.getdataTypeElement(name)
+ setattr(cls, "getdataType", getdataType)
+
+ def appenddataType(self, name):
+ self.types.appenddataTypeElement(name)
+ setattr(cls, "appenddataType", appenddataType)
- def insertDataType(self, index, datatype):
- self.types.insertDataTypeElement(index, datatype)
- setattr(cls, "insertDataType", insertDataType)
-
- def removeDataType(self, name):
- self.types.removeDataTypeElement(name)
- setattr(cls, "removeDataType", removeDataType)
-
- def getPous(self):
- return self.types.getPouElements()
- setattr(cls, "getPous", getPous)
-
- def getPou(self, name):
- return self.types.getPouElement(name)
- setattr(cls, "getPou", getPou)
-
- def appendPou(self, name, pou_type, body_type):
- self.types.appendPouElement(name, pou_type, body_type)
- setattr(cls, "appendPou", appendPou)
+ def insertdataType(self, index, datatype):
+ self.types.insertdataTypeElement(index, datatype)
+ setattr(cls, "insertdataType", insertdataType)
+
+ def removedataType(self, name):
+ self.types.removedataTypeElement(name)
+ setattr(cls, "removedataType", removedataType)
+
+ def getpous(self):
+ return self.types.getpouElements()
+ setattr(cls, "getpous", getpous)
+
+ def getpou(self, name):
+ return self.types.getpouElement(name)
+ setattr(cls, "getpou", getpou)
+
+ def appendpou(self, name, pou_type, body_type):
+ self.types.appendpouElement(name, pou_type, body_type)
+ setattr(cls, "appendpou", appendpou)
- def insertPou(self, index, pou):
- self.types.insertPouElement(index, pou)
- setattr(cls, "insertPou", insertPou)
-
- def removePou(self, name):
- self.types.removePouElement(name)
- setattr(cls, "removePou", removePou)
-
- def getConfigurations(self):
- configurations = self.instances.configurations.getConfiguration()
+ def insertpou(self, index, pou):
+ self.types.insertpouElement(index, pou)
+ setattr(cls, "insertpou", insertpou)
+
+ def removepou(self, name):
+ self.types.removepouElement(name)
+ setattr(cls, "removepou", removepou)
+
+ def getconfigurations(self):
+ configurations = self.instances.configurations.getconfiguration()
if configurations:
return configurations
return []
- setattr(cls, "getConfigurations", getConfigurations)
-
- def getConfiguration(self, name):
- for configuration in self.instances.configurations.getConfiguration():
- if configuration.getName() == name:
+ setattr(cls, "getconfigurations", getconfigurations)
+
+ def getconfiguration(self, name):
+ for configuration in self.instances.configurations.getconfiguration():
+ if configuration.getname() == name:
return configuration
return None
- setattr(cls, "getConfiguration", getConfiguration)
-
- def addConfiguration(self, name):
- for configuration in self.instances.configurations.getConfiguration():
- if configuration.getName() == name:
+ setattr(cls, "getconfiguration", getconfiguration)
+
+ def addconfiguration(self, name):
+ for configuration in self.instances.configurations.getconfiguration():
+ if configuration.getname() == name:
raise ValueError, "\"%s\" configuration already exists !!!"%name
new_configuration = PLCOpenClasses["configurations_configuration"]()
- new_configuration.setName(name)
- self.instances.configurations.appendConfiguration(new_configuration)
- setattr(cls, "addConfiguration", addConfiguration)
-
- def removeConfiguration(self, name):
+ new_configuration.setname(name)
+ self.instances.configurations.appendconfiguration(new_configuration)
+ setattr(cls, "addconfiguration", addconfiguration)
+
+ def removeconfiguration(self, name):
found = False
- for idx, configuration in enumerate(self.instances.configurations.getConfiguration()):
- if configuration.getName() == name:
- self.instances.configurations.removeConfiguration(idx)
+ for idx, configuration in enumerate(self.instances.configurations.getconfiguration()):
+ if configuration.getname() == name:
+ self.instances.configurations.removeconfiguration(idx)
found = True
break
if not found:
raise ValueError, "\"%s\" configuration doesn't exist !!!"%name
- setattr(cls, "removeConfiguration", removeConfiguration)
-
- def getConfigurationResource(self, config_name, name):
- configuration = self.getConfiguration(config_name)
+ setattr(cls, "removeconfiguration", removeconfiguration)
+
+ def getconfigurationResource(self, config_name, name):
+ configuration = self.getconfiguration(config_name)
if configuration:
- for resource in configuration.getResource():
- if resource.getName() == name:
+ for resource in configuration.getresource():
+ if resource.getname() == name:
return resource
return None
- setattr(cls, "getConfigurationResource", getConfigurationResource)
-
- def addConfigurationResource(self, config_name, name):
- configuration = self.getConfiguration(config_name)
+ setattr(cls, "getconfigurationResource", getconfigurationResource)
+
+ def addconfigurationResource(self, config_name, name):
+ configuration = self.getconfiguration(config_name)
if configuration:
- for resource in configuration.getResource():
- if resource.getName() == name:
+ for resource in configuration.getresource():
+ 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)
- configuration.appendResource(new_resource)
- setattr(cls, "addConfigurationResource", addConfigurationResource)
-
- def removeConfigurationResource(self, config_name, name):
- configuration = self.getConfiguration(config_name)
+ new_resource.setname(name)
+ configuration.appendresource(new_resource)
+ setattr(cls, "addconfigurationResource", addconfigurationResource)
+
+ def removeconfigurationResource(self, config_name, name):
+ configuration = self.getconfiguration(config_name)
if configuration:
found = False
- for idx, resource in enumerate(configuration.getResource()):
- if resource.getName() == name:
- configuration.removeResource(idx)
+ for idx, resource in enumerate(configuration.getresource()):
+ if resource.getname() == name:
+ 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)
-
- def updateElementName(self, old_name, new_name):
- for pou in self.types.getPouElements():
+ setattr(cls, "removeconfigurationResource", removeconfigurationResource)
+
+ def updateElementName(self, old_name, new_name):
+ 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)
@@ -283,71 +256,71 @@
if cls:
cls.singleLineAttributes = False
- def setPageSize(self, width, height):
- self.coordinateInfo.setPageSize(width, height)
- setattr(cls, "setPageSize", setPageSize)
-
- def getPageSize(self):
- return self.coordinateInfo.getPageSize()
- setattr(cls, "getPageSize", getPageSize)
-
- def setScaling(self, scaling):
+ def setpageSize(self, width, height):
+ self.coordinateInfo.setpageSize(width, height)
+ setattr(cls, "setpageSize", setpageSize)
+
+ def getpageSize(self):
+ return self.coordinateInfo.getpageSize()
+ setattr(cls, "getpageSize", getpageSize)
+
+ def setscaling(self, scaling):
for language, (x, y) in scaling.items():
- self.coordinateInfo.setScaling(language, x, y)
- setattr(cls, "setScaling", setScaling)
-
- def getScaling(self):
+ self.coordinateInfo.setscaling(language, x, y)
+ setattr(cls, "setscaling", setscaling)
+
+ def getscaling(self):
scaling = {}
- scaling["FBD"] = self.coordinateInfo.getScaling("FBD")
- scaling["LD"] = self.coordinateInfo.getScaling("LD")
- scaling["SFC"] = self.coordinateInfo.getScaling("SFC")
+ scaling["FBD"] = self.coordinateInfo.getscaling("FBD")
+ scaling["LD"] = self.coordinateInfo.getscaling("LD")
+ 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.pageSize.setX(width)
- self.pageSize.setY(height)
- setattr(cls, "setPageSize", setPageSize)
-
- def getPageSize(self):
+ self.addpageSize()
+ self.pageSize.setx(width)
+ self.pageSize.sety(height)
+ setattr(cls, "setpageSize", setpageSize)
+
+ 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)
-
- def setScaling(self, language, x, y):
+ setattr(cls, "getpageSize", getpageSize)
+
+ def setscaling(self, language, x, y):
if language == "FBD":
- self.fbd.scaling.setX(x)
- self.fbd.scaling.setY(y)
+ self.fbd.scaling.setx(x)
+ self.fbd.scaling.sety(y)
elif language == "LD":
- self.ld.scaling.setX(x)
- self.ld.scaling.setY(y)
+ self.ld.scaling.setx(x)
+ self.ld.scaling.sety(y)
elif language == "SFC":
- self.sfc.scaling.setX(x)
- self.sfc.scaling.setY(y)
- setattr(cls, "setScaling", setScaling)
-
- def getScaling(self, language):
+ self.sfc.scaling.setx(x)
+ self.sfc.scaling.sety(y)
+ setattr(cls, "setscaling", setscaling)
+
+ 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)
@@ -379,850 +352,798 @@
cls = PLCOpenClasses.get("project_types", None)
if cls:
- def getDataTypeElements(self):
- return self.dataTypes.getDataType()
- setattr(cls, "getDataTypeElements", getDataTypeElements)
-
- def getDataTypeElement(self, name):
- elements = self.dataTypes.getDataType()
+ def getdataTypeElements(self):
+ return self.dataTypes.getdataType()
+ setattr(cls, "getdataTypeElements", getdataTypeElements)
+
+ def getdataTypeElement(self, name):
+ elements = self.dataTypes.getdataType()
for element in elements:
- if element.getName() == name:
+ if element.getname() == name:
return element
return None
- setattr(cls, "getDataTypeElement", getDataTypeElement)
-
- def appendDataTypeElement(self, name):
- for element in self.dataTypes.getDataType():
- if element.getName() == name:
+ setattr(cls, "getdataTypeElement", getdataTypeElement)
+
+ def appenddataTypeElement(self, name):
+ for element in self.dataTypes.getdataType():
+ if element.getname() == name:
raise ValueError, "\"%s\" Data Type already exists !!!"%name
new_datatype = PLCOpenClasses["dataTypes_dataType"]()
- new_datatype.setName(name)
- new_datatype.baseType.setContent("BOOL", None)
- self.dataTypes.appendDataType(new_datatype)
- setattr(cls, "appendDataTypeElement", appendDataTypeElement)
+ new_datatype.setname(name)
+ new_datatype.baseType.setcontent({"name" : "BOOL", "value" : None})
+ self.dataTypes.appenddataType(new_datatype)
+ setattr(cls, "appenddataTypeElement", appenddataTypeElement)
- def insertDataTypeElement(self, index, datatype):
- self.dataTypes.insertDataType(index, datatype)
- setattr(cls, "insertDataTypeElement", insertDataTypeElement)
-
- def removeDataTypeElement(self, name):
+ def insertdataTypeElement(self, index, dataType):
+ self.dataTypes.insertdataType(index, dataType)
+ setattr(cls, "insertdataTypeElement", insertdataTypeElement)
+
+ def removedataTypeElement(self, name):
found = False
- for idx, element in enumerate(self.dataTypes.getDataType()):
- if element.getName() == name:
- self.dataTypes.removeDataType(idx)
+ for idx, element in enumerate(self.dataTypes.getdataType()):
+ if element.getname() == name:
+ self.dataTypes.removedataType(idx)
found = True
break
if not found:
raise ValueError, "\"%s\" Data Type doesn't exist !!!"%name
- setattr(cls, "removeDataTypeElement", removeDataTypeElement)
-
- def getPouElements(self):
- return self.pous.getPou()
- setattr(cls, "getPouElements", getPouElements)
-
- def getPouElement(self, name):
- elements = self.pous.getPou()
+ setattr(cls, "removedataTypeElement", removedataTypeElement)
+
+ def getpouElements(self):
+ return self.pous.getpou()
+ setattr(cls, "getpouElements", getpouElements)
+
+ def getpouElement(self, name):
+ elements = self.pous.getpou()
for element in elements:
- if element.getName() == name:
+ if element.getname() == name:
return element
return None
- setattr(cls, "getPouElement", getPouElement)
-
- def appendPouElement(self, name, pou_type, body_type):
- for element in self.pous.getPou():
- if element.getName() == name:
+ setattr(cls, "getpouElement", getpouElement)
+
+ def appendpouElement(self, name, pou_type, body_type):
+ for element in self.pous.getpou():
+ if element.getname() == name:
raise ValueError, "\"%s\" POU already exists !!!"%name
new_pou = PLCOpenClasses["pous_pou"]()
- new_pou.setName(name)
- new_pou.pouType.setValue(pou_type)
- new_pou.setBody(PLCOpenClasses["body"]())
- new_pou.setBodyType(body_type)
- self.pous.appendPou(new_pou)
- setattr(cls, "appendPouElement", appendPouElement)
+ new_pou.setname(name)
+ new_pou.setpouType(pou_type)
+ new_pou.setbody(PLCOpenClasses["body"]())
+ new_pou.setbodyType(body_type)
+ self.pous.appendpou(new_pou)
+ setattr(cls, "appendpouElement", appendpouElement)
- def insertPouElement(self, index, pou):
- self.pous.insertPou(index, pou)
- setattr(cls, "insertPouElement", insertPouElement)
-
- def removePouElement(self, name):
+ def insertpouElement(self, index, pou):
+ self.pous.insertpou(index, pou)
+ setattr(cls, "insertpouElement", insertpouElement)
+
+ def removepouElement(self, name):
found = False
- for idx, element in enumerate(self.pous.getPou()):
- if element.getName() == name:
- self.pous.removePou(idx)
+ for idx, element in enumerate(self.pous.getpou()):
+ if element.getname() == name:
+ self.pous.removepou(idx)
found = True
break
if not found:
raise ValueError, "\"%s\" POU doesn't exist !!!"%name
- setattr(cls, "removePouElement", removePouElement)
-
-def setBodyType(self, type):
+ setattr(cls, "removepouElement", removepouElement)
+
+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):
- return self.body.getContent()["name"]
-
-def resetExecutionOrder(self):
- self.body.resetExecutionOrder()
-
-def compileExecutionOrder(self):
- self.body.compileExecutionOrder()
-
-def setElementExecutionOrder(self, instance, new_executionOrder):
- self.body.setElementExecutionOrder(instance, new_executionOrder)
-
-def addInstance(self, name, instance):
- self.body.appendContentInstance(name, instance)
-
-def getInstances(self):
- return self.body.getContentInstances()
-
-def getInstance(self, id):
- return self.body.getContentInstance(id)
-
-def getRandomInstance(self, exclude):
- return self.body.getContentRandomInstance(exclude)
-
-def getInstanceByName(self, name):
- return self.body.getContentInstanceByName(name)
-
-def removeInstance(self, id):
- self.body.removeContentInstance(id)
-
-def setText(self, text):
- self.body.setText(text)
-
-def getText(self):
- return self.body.getText()
-setattr(cls, "getText", getText)
+def getbodyType(self):
+ return self.body.getcontent()["name"]
+
+def resetexecutionOrder(self):
+ self.body.resetexecutionOrder()
+
+def compileexecutionOrder(self):
+ self.body.compileexecutionOrder()
+
+def setelementExecutionOrder(self, instance, new_executionOrder):
+ self.body.setelementExecutionOrder(instance, new_executionOrder)
+
+def addinstance(self, name, instance):
+ self.body.appendcontentInstance(name, instance)
+
+def getinstances(self):
+ return self.body.getcontentInstances()
+
+def getinstance(self, id):
+ return self.body.getcontentInstance(id)
+
+def getrandomInstance(self, exclude):
+ return self.body.getcontentRandomInstance(exclude)
+
+def getinstanceByName(self, name):
+ return self.body.getcontentInstanceByName(name)
+
+def removeinstance(self, id):
+ self.body.removecontentInstance(id)
+
+def settext(self, text):
+ self.body.settext(text)
+
+def gettext(self):
+ return self.body.gettext()
+setattr(cls, "gettext", gettext)
cls = PLCOpenClasses.get("pous_pou", None)
if cls:
- setattr(cls, "setBodyType", setBodyType)
- setattr(cls, "getBodyType", getBodyType)
- setattr(cls, "resetExecutionOrder", resetExecutionOrder)
- setattr(cls, "compileExecutionOrder", compileExecutionOrder)
- setattr(cls, "setElementExecutionOrder", setElementExecutionOrder)
- setattr(cls, "addInstance", addInstance)
- setattr(cls, "getInstances", getInstances)
- setattr(cls, "getInstance", getInstance)
- setattr(cls, "getRandomInstance", getRandomInstance)
- setattr(cls, "getInstanceByName", getInstanceByName)
- setattr(cls, "removeInstance", removeInstance)
- setattr(cls, "setText", setText)
- setattr(cls, "getText", getText)
-
- def getVars(self):
+ setattr(cls, "setbodyType", setbodyType)
+ setattr(cls, "getbodyType", getbodyType)
+ setattr(cls, "resetexecutionOrder", resetexecutionOrder)
+ setattr(cls, "compileexecutionOrder", compileexecutionOrder)
+ setattr(cls, "setelementExecutionOrder", setelementExecutionOrder)
+ setattr(cls, "addinstance", addinstance)
+ setattr(cls, "getinstances", getinstances)
+ setattr(cls, "getinstance", getinstance)
+ setattr(cls, "getrandomInstance", getrandomInstance)
+ setattr(cls, "getinstanceByName", getinstanceByName)
+ setattr(cls, "removeinstance", removeinstance)
+ setattr(cls, "settext", settext)
+ setattr(cls, "gettext", gettext)
+
+ 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)
-
- def setVars(self, vars):
- self.interface.setContent([])
+ setattr(cls, "getvars", getvars)
+
+ def setvars(self, vars):
+ self.interface.setcontent([])
for vartype, varlist in vars:
- self.interface.appendContent(VarTypes[vartype], varlist)
- setattr(cls, "setVars", setVars)
-
- def addPouVar(self, type, name):
- content = self.interface.getContent()
+ self.interface.appendcontent({"name" : VarTypes[vartype], "value" : varlist})
+ setattr(cls, "setvars", setvars)
+
+ def addpouVar(self, type, name):
+ 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()
- if varlist.getConstant() or varlist.getRetain() or len(variables) > 0 and variables[0].getAddress():
- content.append({"name" : "localVars", "value" : PLCOpenClasses["varList"]()})
+ variables = varlist.getvariable()
+ if varlist.getconstant() or varlist.getretain() or len(variables) > 0 and variables[0].getaddress():
+ 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.setName(type)
- var_type.setContent("derived", derived_type)
- var.setType(var_type)
- content[-1]["value"].appendVariable(var)
- setattr(cls, "addPouVar", addPouVar)
-
- def changePouVar(self, old_type, old_name, new_type, new_name):
- content = self.interface.getContent()
+ derived_type = PLCOpenClasses["derivedTypes_derived"]()
+ derived_type.setname(type)
+ var_type.setcontent({"name" : "derived", "value" : derived_type})
+ var.settype(var_type)
+ content[-1]["value"].appendvariable(var)
+ setattr(cls, "addpouVar", addpouVar)
+
+ def changepouVar(self, old_type, old_name, new_type, new_name):
+ 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:
- vartype_content = var.getType().getContent()
- if vartype_content["name"] == "derived" and vartype_content["value"].getName() == old_type:
- var.setName(new_name)
- vartype_content["value"].setName(new_type)
+ if var.getname() == old_name:
+ vartype_content = var.gettype().getcontent()
+ if vartype_content["name"] == "derived" and vartype_content["value"].getname() == old_type:
+ var.setname(new_name)
+ vartype_content["value"].setname(new_type)
return
- setattr(cls, "changePouVar", changePouVar)
-
- def removePouVar(self, type, name):
- content = self.interface.getContent()
+ setattr(cls, "changepouVar", changepouVar)
+
+ def removepouVar(self, type, name):
+ content = self.interface.getcontent()
for varlist in content:
- variables = varlist["value"].getVariable()
+ variables = varlist["value"].getvariable()
for var in variables:
- if var.getName() == name:
- vartype_content = var.getType().getContent()
- if vartype_content["name"] == "derived" and vartype_content["value"].getName() == type:
+ if var.getname() == name:
+ vartype_content = var.gettype().getcontent()
+ 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)
-
- def hasBlock(self, name):
- if self.getBodyType() in ["FBD", "LD", "SFC"]:
- for instance in self.getInstances():
- if isinstance(instance, PLCOpenClasses["block"]) and instance.getInstanceName() == name:
+ setattr(cls, "removepouVar", removepouVar)
+
+ def hasblock(self, name):
+ if self.getbodyType() in ["FBD", "LD", "SFC"]:
+ for instance in self.getinstances():
+ if isinstance(instance, PLCOpenClasses["fbdObjects_block"]) and instance.getinstanceName() == name:
return True
if self.transitions:
- for transition in self.transitions.getTransition():
- result = transition.hasBlock(name)
+ for transition in self.transitions.gettransition():
+ result = transition.hasblock(name)
if result:
return result
if self.actions:
- for action in self.actions.getAction():
- result = action.hasBlock(name)
+ for action in self.actions.getaction():
+ result = action.hasblock(name)
if result:
return result
return False
- setattr(cls, "hasBlock", hasBlock)
-
- def addTransition(self, name, type):
+ setattr(cls, "hasblock", hasblock)
+
+ def addtransition(self, name, type):
if not self.transitions:
- self.addTransitions()
- self.transitions.setTransition([])
+ self.addtransitions()
+ self.transitions.settransition([])
transition = PLCOpenClasses["transitions_transition"]()
- transition.setName(name)
- transition.setBodyType(type)
- self.transitions.appendTransition(transition)
- setattr(cls, "addTransition", addTransition)
-
- def getTransition(self, name):
+ transition.setname(name)
+ transition.setbodyType(type)
+ self.transitions.appendtransition(transition)
+ setattr(cls, "addtransition", addtransition)
+
+ def gettransition(self, name):
if self.transitions:
- for transition in self.transitions.getTransition():
- if transition.getName() == name:
+ for transition in self.transitions.gettransition():
+ 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)
-
- def removeTransition(self, name):
+ setattr(cls, "gettransitionList", gettransitionList)
+
+ 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)
-
- def addAction(self, name, type):
+ setattr(cls, "removetransition", removetransition)
+
+ def addaction(self, name, type):
if not self.actions:
- self.addActions()
- self.actions.setAction([])
+ self.addactions()
+ self.actions.setaction([])
action = PLCOpenClasses["actions_action"]()
- action.setName(name)
- action.setBodyType(type)
- self.actions.appendAction(action)
- setattr(cls, "addAction", addAction)
-
- def getAction(self, name):
+ action.setname(name)
+ action.setbodyType(type)
+ self.actions.appendaction(action)
+ setattr(cls, "addaction", addaction)
+
+ def getaction(self, name):
if self.actions:
- for action in self.actions.getAction():
- if action.getName() == name:
+ for action in self.actions.getaction():
+ if action.getname() == name:
return action
return None
- setattr(cls, "getAction", getAction)
-
- def getActionList(self):
+ setattr(cls, "getaction", getaction)
+
+ 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, "getBodyType", getBodyType)
- setattr(cls, "resetExecutionOrder", resetExecutionOrder)
- setattr(cls, "compileExecutionOrder", compileExecutionOrder)
- setattr(cls, "setElementExecutionOrder", setElementExecutionOrder)
- setattr(cls, "addInstance", addInstance)
- setattr(cls, "getInstances", getInstances)
- setattr(cls, "getInstance", getInstance)
- setattr(cls, "getRandomInstance", getRandomInstance)
- setattr(cls, "getInstanceByName", getInstanceByName)
- setattr(cls, "removeInstance", removeInstance)
- setattr(cls, "setText", setText)
- setattr(cls, "getText", getText)
+ setattr(cls, "setbodyType", setbodyType)
+ setattr(cls, "getbodyType", getbodyType)
+ setattr(cls, "resetexecutionOrder", resetexecutionOrder)
+ setattr(cls, "compileexecutionOrder", compileexecutionOrder)
+ setattr(cls, "setelementExecutionOrder", setelementExecutionOrder)
+ setattr(cls, "addinstance", addinstance)
+ setattr(cls, "getinstances", getinstances)
+ setattr(cls, "getinstance", getinstance)
+ setattr(cls, "getrandomInstance", getrandomInstance)
+ setattr(cls, "getinstanceByName", getinstanceByName)
+ setattr(cls, "removeinstance", removeinstance)
+ setattr(cls, "settext", settext)
+ 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):
- if self.getBodyType() in ["FBD", "LD", "SFC"]:
- for instance in self.getInstances():
- if isinstance(instance, PLCOpenClasses["block"]) and instance.getInstanceName() == name:
+ def hasblock(self, name):
+ if self.getbodyType() in ["FBD", "LD", "SFC"]:
+ for instance in self.getinstances():
+ 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, "getBodyType", getBodyType)
- setattr(cls, "resetExecutionOrder", resetExecutionOrder)
- setattr(cls, "compileExecutionOrder", compileExecutionOrder)
- setattr(cls, "setElementExecutionOrder", setElementExecutionOrder)
- setattr(cls, "addInstance", addInstance)
- setattr(cls, "getInstances", getInstances)
- setattr(cls, "getInstance", getInstance)
- setattr(cls, "getRandomInstance", getRandomInstance)
- setattr(cls, "getInstanceByName", getInstanceByName)
- setattr(cls, "removeInstance", removeInstance)
- setattr(cls, "setText", setText)
- setattr(cls, "getText", getText)
+ setattr(cls, "setbodyType", setbodyType)
+ setattr(cls, "getbodyType", getbodyType)
+ setattr(cls, "resetexecutionOrder", resetexecutionOrder)
+ setattr(cls, "compileexecutionOrder", compileexecutionOrder)
+ setattr(cls, "setelementExecutionOrder", setelementExecutionOrder)
+ setattr(cls, "addinstance", addinstance)
+ setattr(cls, "getinstances", getinstances)
+ setattr(cls, "getinstance", getinstance)
+ setattr(cls, "getrandomInstance", getrandomInstance)
+ setattr(cls, "getinstanceByName", getinstanceByName)
+ setattr(cls, "removeinstance", removeinstance)
+ setattr(cls, "settext", settext)
+ 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):
- if self.getBodyType() in ["FBD", "LD", "SFC"]:
- for instance in self.getInstances():
- if isinstance(instance, PLCOpenClasses["block"]) and instance.getInstanceName() == name:
+ def hasblock(self, name):
+ if self.getbodyType() in ["FBD", "LD", "SFC"]:
+ for instance in self.getinstances():
+ 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)
-
- def getNewExecutionOrderId(self):
+ setattr(cls, "resetcurrentExecutionOrderId", resetcurrentExecutionOrderId)
+
+ def getnewExecutionOrderId(self):
self.currentExecutionOrderId += 1
return self.currentExecutionOrderId
- setattr(cls, "getNewExecutionOrderId", getNewExecutionOrderId)
-
- def resetExecutionOrder(self):
+ setattr(cls, "getnewExecutionOrderId", getnewExecutionOrderId)
+
+ def resetexecutionOrder(self):
if self.content["name"] == "FBD":
- for element in self.content["value"].getContent():
- if not isinstance(element["value"], (PLCOpenClasses.get("comment", None), PLCOpenClasses.get("connector", None), PLCOpenClasses.get("continuation", None))):
- element["value"].setExecutionOrderId(0)
+ for element in self.content["value"].getcontent():
+ if not isinstance(element["value"], (PLCOpenClasses.get("commonObjects_comment", None),
+ 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)
-
- def compileExecutionOrder(self):
+ setattr(cls, "resetexecutionOrder", resetexecutionOrder)
+
+ def compileexecutionOrder(self):
if self.content["name"] == "FBD":
- self.resetExecutionOrder()
- self.resetCurrentExecutionOrderId()
- for element in self.content["value"].getContent():
- if isinstance(element["value"], PLCOpenClasses.get("outVariable", None)) and element["value"].getExecutionOrderId() == 0:
- connections = element["value"].connectionPointIn.getConnections()
+ self.resetexecutionOrder()
+ self.resetcurrentExecutionOrderId()
+ for element in self.content["value"].getcontent():
+ if isinstance(element["value"], PLCOpenClasses.get("fbdObjects_outVariable", None)) and element["value"].getExecutionOrderId() == 0:
+ connections = element["value"].connectionPointIn.getconnections()
if connections and len(connections) == 1:
- self.compileElementExecutionOrder(connections[0])
- element["value"].setExecutionOrderId(self.getNewExecutionOrderId())
+ self.compileelementExecutionOrder(connections[0])
+ element["value"].setexecutionOrderId(self.getnewExecutionOrderId())
else:
raise TypeError, "Can only generate execution order on FBD networks!"
- setattr(cls, "compileExecutionOrder", compileExecutionOrder)
-
- def compileElementExecutionOrder(self, link):
+ setattr(cls, "compileexecutionOrder", compileexecutionOrder)
+
+ def compileelementExecutionOrder(self, link):
if self.content["name"] == "FBD":
- localid = link.getRefLocalId()
- instance = self.getContentInstance(localid)
- if isinstance(instance, PLCOpenClasses.get("block", None)) and instance.getExecutionOrderId() == 0:
- for variable in instance.inputVariables.getVariable():
- connections = variable.connectionPointIn.getConnections()
+ localid = link.getrefLocalId()
+ instance = self.getcontentInstance(localid)
+ if isinstance(instance, PLCOpenClasses.get("fbdObjects_block", None)) and instance.getexecutionOrderId() == 0:
+ for variable in instance.inputVariables.getvariable():
+ connections = variable.connectionPointIn.getconnections()
if connections and len(connections) == 1:
- self.compileElementExecutionOrder(connections[0])
- instance.setExecutionOrderId(self.getNewExecutionOrderId())
- elif isinstance(instance, PLCOpenClasses.get("continuation", None)) and instance.getExecutionOrderId() == 0:
- name = instance.getName()
- for tmp_instance in self.getContentInstances():
- if isinstance(tmp_instance, PLCOpenClasses.get("connector", None)) and tmp_instance.getName() == name and tmp_instance.getExecutionOrderId() == 0:
- connections = tmp_instance.connectionPointIn.getConnections()
+ self.compileelementExecutionOrder(connections[0])
+ instance.setexecutionOrderId(self.getnewExecutionOrderId())
+ elif isinstance(instance, PLCOpenClasses.get("commonObjects_continuation", None)) and instance.getexecutionOrderId() == 0:
+ name = instance.getname()
+ for tmp_instance in self.getcontentInstances():
+ if isinstance(tmp_instance, PLCOpenClasses.get("commonObjects_connector", None)) and tmp_instance.getname() == name and tmp_instance.getexecutionOrderId() == 0:
+ 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)
-
- def setElementExecutionOrder(self, instance, new_executionOrder):
+ setattr(cls, "compileelementExecutionOrder", compileelementExecutionOrder)
+
+ 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():
- if element["value"] != instance and not isinstance(element["value"], PLCOpenClasses.get("comment", None)):
- element_executionOrder = element["value"].getExecutionOrderId()
+ for element in self.content["value"].getcontent():
+ if element["value"] != instance and not isinstance(element["value"], PLCOpenClasses.get("commonObjects_comment", None)):
+ 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)
- instance.setExecutionOrderId(new_executionOrder)
+ element["value"].setexecutionOrderId(element_executionOrder + 1)
+ instance.setexecutionOrderId(new_executionOrder)
else:
raise TypeError, "Can only generate execution order on FBD networks!"
- setattr(cls, "setElementExecutionOrder", setElementExecutionOrder)
-
- def appendContentInstance(self, name, instance):
+ setattr(cls, "setelementExecutionOrder", setelementExecutionOrder)
+
+ 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)
-
- def getContentInstances(self):
+ setattr(cls, "appendcontentInstance", appendcontentInstance)
+
+ 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)
-
- def getContentInstance(self, id):
+ setattr(cls, "getcontentInstances", getcontentInstances)
+
+ def getcontentInstance(self, id):
if self.content["name"] in ["LD","FBD","SFC"]:
- for element in self.content["value"].getContent():
- if element["value"].getLocalId() == id:
+ for element in self.content["value"].getcontent():
+ 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)
-
- def getContentRandomInstance(self, exclude):
+ setattr(cls, "getcontentInstance", getcontentInstance)
+
+ def getcontentRandomInstance(self, exclude):
if self.content["name"] in ["LD","FBD","SFC"]:
- for element in self.content["value"].getContent():
- if element["value"].getLocalId() not in exclude:
+ for element in self.content["value"].getcontent():
+ 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)
-
- def getContentInstanceByName(self, name):
+ setattr(cls, "getcontentRandomInstance", getcontentRandomInstance)
+
+ 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)
-
- def removeContentInstance(self, id):
+ setattr(cls, "getcontentInstanceByName", getcontentInstanceByName)
+
+ 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:
- self.content["value"].removeContent(i)
+ if elements[i]["value"].getlocalId() == id:
+ 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)
-
- def setText(self, text):
+ setattr(cls, "removecontentInstance", removecontentInstance)
+
+ 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)
-
- def getText(self):
+ setattr(cls, "settext", settext)
+
+ 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):
- return self.position.getX()
-
-def getY(self):
- return self.position.getY()
-
-def setX(self, x):
- self.position.setX(x)
-
-def setY(self, y):
- self.position.setY(y)
-
-cls = PLCOpenClasses.get("comment", None)
-if cls:
- setattr(cls, "getX", getX)
- setattr(cls, "getY", getY)
- setattr(cls, "setX", setX)
- setattr(cls, "setY", setY)
-
- def setContentText(self, text):
- self.content.setText(text)
- setattr(cls, "setContentText", setContentText)
+def getx(self):
+ return self.position.getx()
+
+def gety(self):
+ return self.position.gety()
+
+def setx(self, x):
+ self.position.setx(x)
+
+def sety(self, y):
+ self.position.sety(y)
+
+cls = PLCOpenClasses.get("commonObjects_comment", None)
+if cls:
+ setattr(cls, "getx", getx)
+ setattr(cls, "gety", gety)
+ setattr(cls, "setx", setx)
+ setattr(cls, "sety", sety)
+
+ def setcontentText(self, text):
+ self.content.settext(text)
+ setattr(cls, "setcontentText", setcontentText)
- def getContentText(self):
- return self.content.getText()
- setattr(cls, "getContentText", getContentText)
+ def getcontentText(self):
+ return self.content.gettext()
+ 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)
-if cls:
- setattr(cls, "getX", getX)
- setattr(cls, "getY", getY)
- setattr(cls, "setX", setX)
- setattr(cls, "setY", setY)
+cls = PLCOpenClasses.get("fbdObjects_block", 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):
if self.typeName == old_name:
self.typeName = new_name
setattr(cls, "updateElementName", updateElementName)
-cls = PLCOpenClasses.get("inputVariables_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("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)
+cls = PLCOpenClasses.get("ldObjects_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)
-if cls:
- setattr(cls, "getX", getX)
- setattr(cls, "getY", getY)
- setattr(cls, "setX", setX)
- setattr(cls, "setY", setY)
+cls = PLCOpenClasses.get("ldObjects_rightPowerRail", 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("contact", None)
-if cls:
- setattr(cls, "getX", getX)
- setattr(cls, "getY", getY)
- setattr(cls, "setX", setX)
- 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)
+cls = PLCOpenClasses.get("ldObjects_contact", 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):
if self.variable == old_name:
self.variable = new_name
setattr(cls, "updateElementName", updateElementName)
-cls = PLCOpenClasses.get("coil", None)
-if cls:
- setattr(cls, "getX", getX)
- setattr(cls, "getY", getY)
- setattr(cls, "setX", setX)
- 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)
+cls = PLCOpenClasses.get("ldObjects_coil", 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):
if self.variable == old_name:
self.variable = new_name
setattr(cls, "updateElementName", updateElementName)
-cls = PLCOpenClasses.get("step", None)
-if cls:
- setattr(cls, "getX", getX)
- setattr(cls, "getY", getY)
- setattr(cls, "setX", setX)
- setattr(cls, "setY", setY)
+cls = PLCOpenClasses.get("sfcObjects_step", 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("transition", None)
-if cls:
- setattr(cls, "getX", getX)
- setattr(cls, "getY", getY)
- setattr(cls, "setX", setX)
- setattr(cls, "setY", setY)
-
- def setConditionContent(self, type, value):
+cls = PLCOpenClasses.get("sfcObjects_transition", None)
+if cls:
+ setattr(cls, "getx", getx)
+ setattr(cls, "gety", gety)
+ setattr(cls, "setx", setx)
+ setattr(cls, "sety", sety)
+
+ 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.setText(value)
+ condition.setcontent({"name" : "ST", "value" : PLCOpenClasses["formattedText"]()})
+ condition.settext(value)
elif type == "connection":
condition = []
- self.condition.setContent(type, condition)
- setattr(cls, "setConditionContent", setConditionContent)
+ self.condition.setcontent({"name" : type, "value" : condition})
+ 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:
- content["value"].setName(new_name)
+ if content["value"].getname() == old_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", [])
- content = self.condition.getContent()
+ self.condition.setcontent({"name" : "connection", "value" : []})
+ content = self.condition.getcontent()
content["value"].append(PLCOpenClasses["connection"]())
- setattr(cls, "addConnection", addConnection)
-
- def removeConnection(self, idx):
+ setattr(cls, "addconnection", addconnection)
+
+ 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)
-
- def removeConnections(self):
+ setattr(cls, "removeconnection", removeconnection)
+
+ def removeconnections(self):
if self.condition:
- content = self.condition.getContent()
+ content = self.condition.getcontent()
if content["name"] == "connection":
content["value"] = []
- setattr(cls, "removeConnections", removeConnections)
-
- def getConnections(self):
+ setattr(cls, "removeconnections", removeconnections)
+
+ 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)
-
- def setConnectionId(self, idx, id):
+ setattr(cls, "getconnections", getconnections)
+
+ 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)
- setattr(cls, "setConnectionId", setConnectionId)
-
- def getConnectionId(self, idx):
+ content["value"][idx].setrefLocalId(id)
+ setattr(cls, "setconnectionId", setconnectionId)
+
+ 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)
-
- def setConnectionPoints(self, idx, points):
+ setattr(cls, "getconnectionId", getconnectionId)
+
+ 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)
- setattr(cls, "setConnectionPoints", setConnectionPoints)
-
- def getConnectionPoints(self, idx):
+ content["value"][idx].setpoints(points)
+ setattr(cls, "setconnectionPoints", setconnectionPoints)
+
+ 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)
-
- def setConnectionParameter(self, idx, parameter):
+ setattr(cls, "getconnectionPoints", getconnectionPoints)
+
+ 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)
- setattr(cls, "setConnectionParameter", setConnectionParameter)
-
- def getConnectionParameter(self, idx):
+ content["value"][idx].setformalParameter(parameter)
+ setattr(cls, "setconnectionParameter", setconnectionParameter)
+
+ 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, "addConnection", addConnection)
-
-cls = PLCOpenClasses.get("selectionDivergence", None)
-if cls:
- setattr(cls, "getX", getX)
- setattr(cls, "getY", getY)
- setattr(cls, "setX", setX)
- setattr(cls, "setY", setY)
+ setattr(cls, "getconnectionParameter", getconnectionParameter)
+
+cls = PLCOpenClasses.get("sfcObjects_selectionDivergence", 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("selectionConvergence", None)
-if cls:
- setattr(cls, "getX", getX)
- setattr(cls, "getY", getY)
- setattr(cls, "setX", setX)
- setattr(cls, "setY", setY)
+cls = PLCOpenClasses.get("sfcObjects_selectionConvergence", 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("simultaneousDivergence", None)
-if cls:
- setattr(cls, "getX", getX)
- setattr(cls, "getY", getY)
- setattr(cls, "setX", setX)
- setattr(cls, "setY", setY)
+cls = PLCOpenClasses.get("sfcObjects_simultaneousDivergence", 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("simultaneousConvergence", None)
-if cls:
- setattr(cls, "getX", getX)
- setattr(cls, "getY", getY)
- setattr(cls, "setX", setX)
- setattr(cls, "setY", setY)
+cls = PLCOpenClasses.get("sfcObjects_simultaneousConvergence", 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("jumpStep", None)
-if cls:
- setattr(cls, "getX", getX)
- setattr(cls, "getY", getY)
- setattr(cls, "setX", setX)
- setattr(cls, "setY", setY)
+cls = PLCOpenClasses.get("sfcObjects_jumpStep", 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
@@ -1230,202 +1151,142 @@
cls = PLCOpenClasses.get("actionBlock_action", None)
if cls:
- def setQualifierValue(self, value):
- if self.qualifier:
- self.qualifier.setValue(value)
- setattr(cls, "setQualifierValue", setQualifierValue)
-
- def getQualifierValue(self):
- if self.qualifier:
- return self.qualifier.getValue()
+ def setreferenceName(self, name):
+ if self.reference:
+ self.reference.setname(name)
+ setattr(cls, "setreferenceName", setreferenceName)
+
+ def getreferenceName(self):
+ if self.reference:
+ return self.reference.getname()
return None
- setattr(cls, "getQualifierValue", getQualifierValue)
-
- def setReferenceName(self, name):
- if self.reference:
- self.reference.setName(name)
- setattr(cls, "setReferenceName", setReferenceName)
-
- def getReferenceName(self):
- if self.reference:
- return self.reference.getName()
+ setattr(cls, "getreferenceName", getreferenceName)
+
+ def setinlineContent(self, content):
+ if self.inline:
+ self.inline.setcontent({"name" : "ST", "value" : PLCOpenClasses["formattedText"]()})
+ self.inline.settext(content)
+ setattr(cls, "setinlineContent", setinlineContent)
+
+ def getinlineContent(self):
+ if self.inline:
+ return self.inline.gettext()
return None
- setattr(cls, "getReferenceName", getReferenceName)
-
- def setInlineContent(self, content):
- if self.inline:
- self.inline.setContent("ST", PLCOpenClasses["formattedText"]())
- 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)
+ 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)
-if cls:
- setattr(cls, "getX", getX)
- setattr(cls, "getY", getY)
- setattr(cls, "setX", setX)
- setattr(cls, "setY", setY)
-
- def setActions(self, actions):
+cls = PLCOpenClasses.get("commonObjects_actionBlock", None)
+if cls:
+ setattr(cls, "getx", getx)
+ setattr(cls, "gety", gety)
+ setattr(cls, "setx", setx)
+ setattr(cls, "sety", sety)
+
+ def setactions(self, actions):
self.action = []
for params in actions:
action = PLCOpenClasses["actionBlock_action"]()
- action.addQualifier()
- action.setQualifierValue(params["qualifier"])
+ action.setqualifier(params["qualifier"])
if params["type"] == "reference":
- action.addReference()
- action.setReferenceName(params["value"])
+ action.addreference()
+ action.setreferenceName(params["value"])
else:
- action.addInline()
- action.setInlineContent(params["value"])
+ action.addinline()
+ 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)
-
- def getActions(self):
+ setattr(cls, "setactions", setactions)
+
+ 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()
- elif action.getInline():
+ params["value"] = action.getreferenceName()
+ elif action.getinline():
params["type"] = "inline"
- params["value"] = action.getInlineContent()
- duration = action.getDuration()
+ params["value"] = action.getinlineContent()
+ 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)
-if cls:
- setattr(cls, "getX", getX)
- setattr(cls, "getY", getY)
- setattr(cls, "setX", setX)
- 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)
+cls = PLCOpenClasses.get("fbdObjects_inVariable", 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):
if self.expression == old_name:
self.expression = new_name
setattr(cls, "updateElementName", updateElementName)
-cls = PLCOpenClasses.get("outVariable", None)
-if cls:
- setattr(cls, "getX", getX)
- setattr(cls, "getY", getY)
- setattr(cls, "setX", setX)
- 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)
+cls = PLCOpenClasses.get("fbdObjects_outVariable", 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):
if self.expression == old_name:
self.expression = new_name
setattr(cls, "updateElementName", updateElementName)
-cls = PLCOpenClasses.get("inOutVariable", None)
-if cls:
- setattr(cls, "getX", getX)
- setattr(cls, "getY", getY)
- setattr(cls, "setX", setX)
- 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)
+cls = PLCOpenClasses.get("fbdObjects_inOutVariable", 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):
if self.expression == old_name:
self.expression = new_name
setattr(cls, "updateElementName", updateElementName)
-cls = PLCOpenClasses.get("continuation", None)
-if cls:
- setattr(cls, "getX", getX)
- setattr(cls, "getY", getY)
- setattr(cls, "setX", setX)
- setattr(cls, "setY", setY)
+cls = PLCOpenClasses.get("commonObjects_continuation", 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("connector", None)
-if cls:
- setattr(cls, "getX", getX)
- setattr(cls, "getY", getY)
- setattr(cls, "setX", setX)
- setattr(cls, "setY", setY)
+cls = PLCOpenClasses.get("commonObjects_connector", 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
@@ -1433,126 +1294,126 @@
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.setY(point.y)
+ position.setx(point.x)
+ position.sety(point.y)
self.position.append(position)
- setattr(cls, "setPoints", setPoints)
-
- def getPoints(self):
+ setattr(cls, "setpoints", setpoints)
+
+ 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.setY(y)
- setattr(cls, "setRelPosition", setRelPosition)
-
- def getRelPosition(self):
+ self.relPosition.setx(x)
+ self.relPosition.sety(y)
+ setattr(cls, "setrelPositionXY", setrelPositionXY)
+
+ 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)
-
- def addConnection(self):
+ setattr(cls, "getrelPositionXY", getrelPositionXY)
+
+ 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)
-
- def removeConnection(self, idx):
+ setattr(cls, "addconnection", addconnection)
+
+ 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)
-
- def removeConnections(self):
+ setattr(cls, "removeconnection", removeconnection)
+
+ def removeconnections(self):
if self.content:
self.content = None
- setattr(cls, "removeConnections", removeConnections)
-
- def getConnections(self):
+ setattr(cls, "removeconnections", removeconnections)
+
+ def getconnections(self):
if self.content:
return self.content["value"]
- setattr(cls, "getConnections", getConnections)
-
- def setConnectionId(self, idx, id):
+ setattr(cls, "getconnections", getconnections)
+
+ def setconnectionId(self, idx, id):
if self.content:
- self.content["value"][idx].setRefLocalId(id)
- setattr(cls, "setConnectionId", setConnectionId)
-
- def getConnectionId(self, idx):
+ self.content["value"][idx].setrefLocalId(id)
+ setattr(cls, "setconnectionId", setconnectionId)
+
+ 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)
-
- def setConnectionPoints(self, idx, points):
+ setattr(cls, "getconnectionId", getconnectionId)
+
+ def setconnectionPoints(self, idx, points):
if self.content:
- self.content["value"][idx].setPoints(points)
- setattr(cls, "setConnectionPoints", setConnectionPoints)
-
- def getConnectionPoints(self, idx):
+ self.content["value"][idx].setpoints(points)
+ setattr(cls, "setconnectionPoints", setconnectionPoints)
+
+ 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)
-
- def setConnectionParameter(self, idx, parameter):
+ setattr(cls, "getconnectionPoints", getconnectionPoints)
+
+ def setconnectionParameter(self, idx, parameter):
if self.content:
- self.content["value"][idx].setFormalParameter(parameter)
- setattr(cls, "setConnectionParameter", setConnectionParameter)
-
- def getConnectionParameter(self, idx):
+ self.content["value"][idx].setformalParameter(parameter)
+ setattr(cls, "setconnectionParameter", setconnectionParameter)
+
+ 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.setY(y)
- setattr(cls, "setRelPosition", setRelPosition)
-
- def getRelPosition(self):
+ self.relPosition.setx(x)
+ self.relPosition.sety(y)
+ setattr(cls, "setrelPositionXY", setrelPositionXY)
+
+ 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["value"].setValue(value)
- setattr(cls, "setValue", setValue)
-
- def getValue(self):
- return self.content["value"].getValue()
- setattr(cls, "getValue", getValue)
+ self.content = {"name" : "simpleValue", "value": simpleValue}
+ self.content["value"].setvalue(value)
+ setattr(cls, "setvalue", setvalue)
+
+ def getvalue(self):
+ return self.content["value"].getvalue()
+ setattr(cls, "getvalue", getvalue)
def extractValues(values):
items = values.split(",")
@@ -1572,7 +1433,7 @@
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()
@@ -1580,43 +1441,43 @@
result = arrayValue_model.match(item)
if result is not None:
groups = result.groups()
- element.setRepetitionValue(int(groups[0]))
- element.setValue(groups[1].strip())
+ element.setrepetitionValue(int(groups[0]))
+ element.setvalue(groups[1].strip())
else:
- element.setValue(item)
+ element.setvalue(item)
self.value.append(element)
- setattr(cls, "setValue", setValue)
-
- def getValue(self):
+ setattr(cls, "setvalue", setvalue)
+
+ 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.setValue(groups[1].strip())
+ element.setmember(groups[0].strip())
+ element.setvalue(groups[1].strip())
self.value.append(element)
- setattr(cls, "setValue", setValue)
-
- def getValue(self):
+ setattr(cls, "setvalue", setvalue)
+
+ 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)