beremiz: comparison plcopen/plcopen.py

equal deleted inserted replaced

-:bac1b86276d9
+:40117d02601b
 var_type_obj.setcontent(derived_type)
 var.settype(var_type_obj)
 if location != "":
 var.setaddress(location)
 if description != "":
-ft = PLCOpenParser.CreateElementClass("formattedText")
+ft = PLCOpenParser.CreateElement("formattedText")
 ft.setanyText(description)
 var.setdocumentation(ft)
 globalvars[-1].appendvariable(var)
 setattr(cls, "addglobalVar", addglobalVar)
 return None
 setattr(cls, "getdataTypeElement", getdataTypeElement)
 def appenddataTypeElement(self, name):
 new_datatype = PLCOpenParser.CreateElement("dataType", "dataTypes")
+self.dataTypes.appenddataType(new_datatype)
 new_datatype.setname(name)
 new_datatype.baseType.setcontent(PLCOpenParser.CreateElement("BOOL"))
-self.dataTypes.appenddataType(new_datatype)
 setattr(cls, "appenddataTypeElement", appenddataTypeElement)
 def insertdataTypeElement(self, index, dataType):
 self.dataTypes.insertdataType(index, dataType)
 setattr(cls, "insertdataTypeElement", insertdataTypeElement)
 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 = PLCOpenParser.CreateElement("pou", "pous")
+self.pous.appendpou(new_pou)
 new_pou.setname(name)
 new_pou.setpouType(pou_type)
-new_pou.appendbody(PLCOpenParser.CreateElement("body"))
+new_pou.appendbody(PLCOpenParser.CreateElement("body", "pou"))
 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)
 setattr(cls, "getdescription", getdescription)
 def setbodyType(self, body_type):
 if len(self.body) > 0:
 if body_type in ["IL", "ST", "LD", "FBD", "SFC"]:
-self.body[0].setcontent(PLCOpenParser.CreateElementClass(body_type, "body"))
+self.body[0].setcontent(PLCOpenParser.CreateElement(body_type, "body"))
 else:
 raise ValueError, "%s isn't a valid body type!"%type
 setattr(cls, "setbodyType", setbodyType)
 def getbodyType(self):
 def setelementExecutionOrder(self, instance, new_executionOrder):
 if len(self.body) > 0:
 self.body[0].setelementExecutionOrder(instance, new_executionOrder)
 setattr(cls, "setelementExecutionOrder", setelementExecutionOrder)
-def addinstance(self, name, instance):
+def addinstance(self, instance):
 if len(self.body) > 0:
-self.body[0].appendcontentInstance(name, instance)
+self.body[0].appendcontentInstance(instance)
 setattr(cls, "addinstance", addinstance)
 def getinstances(self):
 if len(self.body) > 0:
 return self.body[0].getcontentInstances()
 def setvars(self, vars):
 if self.interface is None:
 self.interface = PLCOpenParser.CreateElement("interface", "pou")
 self.interface.setcontent(vars)
-print self.interface.tostring()
 setattr(cls, "setvars", setvars)
 def addpouLocalVar(self, var_type, name, location="", description=""):
 self.addpouVar(var_type, name, location=location, description=description)
 setattr(cls, "addpouLocalVar", addpouLocalVar)
 self.appendcontent(PLCOpenParser.CreateElement(var_class, "interface"))
 else:
 varlist = content[-1]["value"]
 variables = varlist.getvariable()
 if varlist.getconstant() or varlist.getretain() or len(variables) > 0 and variables[0].getaddress():
-self.appendcontent(PLCOpenParser.CreateElementClass(var_class, "interface"))
+self.appendcontent(PLCOpenParser.CreateElement(var_class, "interface"))
-var = PLCOpenParser.CreateElementClass("variable", "varListPlain")
+var = PLCOpenParser.CreateElement("variable", "varListPlain")
 var.setname(name)
 var_type_obj = PLCOpenParser.CreateElement("dataType")
 if var_type in [x for x,y in TypeHierarchy_list if not x.startswith("ANY")]:
 var_type_obj.setcontent(PLCOpenParser.CreateElement(
 var_type.lower() if var_type in ["STRING", "WSTRING"]
 return self.body[0].hasblock(block_type)
 return False
 setattr(cls, "hasblock", hasblock)
 def addtransition(self, name, body_type):
-if not self.transitions:
+if self.transitions is None:
 self.addtransitions()
 self.transitions.settransition([])
 transition = PLCOpenParser.CreateElement("transition", "transitions")
+self.transitions.appendtransition(transition)
 transition.setname(name)
 transition.setbodyType(body_type)
 if body_type == "ST":
 transition.setanyText(":= ;")
 elif body_type == "IL":
 transition.setanyText("\tST\t%s"%name)
-self.transitions.appendtransition(transition)
 setattr(cls, "addtransition", addtransition)
 def gettransition(self, name):
-if self.transitions:
+if self.transitions is not None:
 for transition in self.transitions.gettransition():
 if transition.getname() == name:
 return transition
 return None
 setattr(cls, "gettransition", gettransition)
 def gettransitionList(self):
-if self.transitions:
+if self.transitions is not None:
 return self.transitions.gettransition()
 return []
 setattr(cls, "gettransitionList", gettransitionList)
 def removetransition(self, name):
-if self.transitions:
+if self.transitions is not None:
 removed = False
 for transition in self.transitions.gettransition():
 if transition.getname() == name:
 if transition.getbodyType() in ["FBD", "LD", "SFC"]:
 for instance in transition.getinstances():
 if not removed:
 raise ValueError, _("Transition with name %s doesn't exist!")%name
 setattr(cls, "removetransition", removetransition)
 def addaction(self, name, body_type):
-if not self.actions:
+if self.actions is None:
 self.addactions()
 self.actions.setaction([])
 action = PLCOpenParser.CreateElement("action", "actions")
+self.actions.appendaction(action)
 action.setname(name)
 action.setbodyType(body_type)
-self.actions.appendaction(action)
 setattr(cls, "addaction", addaction)
 def getaction(self, name):
-if self.actions:
+if self.actions is not None:
 for action in self.actions.getaction():
 if action.getname() == name:
 return action
 return None
 setattr(cls, "getaction", getaction)
 return self.actions.getaction()
 return []
 setattr(cls, "getactionList", getactionList)
 def removeaction(self, name):
-if self.actions:
+if self.actions is not None:
 removed = False
 for action in self.actions.getaction():
 if action.getname() == name:
 if action.getbodyType() in ["FBD", "LD", "SFC"]:
 for instance in action.getinstances():
 if not removed:
 raise ValueError, _("Action with name %s doesn't exist!")%name
 setattr(cls, "removeaction", removeaction)
 def updateElementName(self, old_name, new_name):
-if self.interface:
+if self.interface is not None:
 for content in self.interface.getcontent():
 for var in content.getvariable():
 var_address = var.getaddress()
 if var_address is not None:
 if var_address == old_name:
 for transition in self.gettransitionList():
 transition.updateElementName(old_name, new_name)
 setattr(cls, "updateElementName", updateElementName)
 def updateElementAddress(self, address_model, new_leading):
-if self.interface:
+if self.interface is not None:
 for content in self.interface.getcontent():
 for var in content.getvariable():
 var_address = var.getaddress()
 if var_address is not None:
 var.setaddress(update_address(var_address, address_model, new_leading))
 for transition in self.gettransitionList():
 transition.updateElementAddress(address_model, new_leading)
 setattr(cls, "updateElementAddress", updateElementAddress)
 def removeVariableByAddress(self, address):
-if self.interface:
+if self.interface is not None:
 for content in self.interface.getcontent():
 for variable in content.getvariable():
 if variable.getaddress() == address:
 content.remove(variable)
 setattr(cls, "removeVariableByAddress", removeVariableByAddress)
 def removeVariableByFilter(self, address_model):
-if self.interface:
+if self.interface is not None:
 for content in self.interface.getcontent():
 for variable in content.getvariable():
 var_address = variable.getaddress()
 if var_address is not None:
 result = address_model.match(var_address)
 self.body.compileexecutionOrder()
 def setelementExecutionOrder(self, instance, new_executionOrder):
 self.body.setelementExecutionOrder(instance, new_executionOrder)
-def addinstance(self, name, instance):
+def addinstance(self, instance):
-self.body.appendcontentInstance(name, instance)
+self.body.appendcontentInstance(instance)
 def getinstances(self):
 return self.body.getcontentInstances()
 def getinstance(self, id):
 instance.setexecutionOrderId(new_executionOrder)
 else:
 raise TypeError, _("Can only generate execution order on FBD networks!")
 setattr(cls, "setelementExecutionOrder", setelementExecutionOrder)
-def appendcontentInstance(self, name, instance):
+def appendcontentInstance(self, instance):
 if self.content.getLocalTag() in ["LD","FBD","SFC"]:
 self.content.appendcontent(instance)
 else:
-raise TypeError, _("%s body don't have instances!")%self.content["name"]
+raise TypeError, _("%s body don't have instances!")%self.content.getLocalTag()
 setattr(cls, "appendcontentInstance", appendcontentInstance)
 def getcontentInstances(self):
 if self.content.getLocalTag() in ["LD","FBD","SFC"]:
 return self.content.getcontent()
 else:
-raise TypeError, _("%s body don't have instances!")%self.content["name"]
+raise TypeError, _("%s body don't have instances!")%self.content.getLocalTag()
 setattr(cls, "getcontentInstances", getcontentInstances)
 def getcontentInstance(self, local_id):
 if self.content.getLocalTag() in ["LD","FBD","SFC"]:
 instance = self.content.xpath("*[@localId=%d]" % local_id)
 if len(instance) > 0:
 return instance[0]
 return None
 else:
-raise TypeError, _("%s body don't have instances!")%self.content["name"]
+raise TypeError, _("%s body don't have instances!")%self.content.getLocalTag()
 setattr(cls, "getcontentInstance", getcontentInstance)
 def getcontentRandomInstance(self, exclude):
 if self.content.getLocalTag() in ["LD","FBD","SFC"]:
 instance = self.content.xpath("*%s[position()=1]" %
 if len(exclude) > 0 else ""))
 if len(instance) > 0:
 return instance[0]
 return None
 else:
-raise TypeError, _("%s body don't have instances!")%self.content["name"]
+raise TypeError, _("%s body don't have instances!")%self.content.getLocalTag()
 setattr(cls, "getcontentRandomInstance", getcontentRandomInstance)
 def getcontentInstanceByName(self, name):
 if self.content.getLocalTag() in ["LD","FBD","SFC"]:
 instance = self.content.xpath("ppx:block[@instanceName=%s]" % name, namespaces=PLCOpenParser.NSMAP)
 if len(instance) > 0:
 return instance[0]
 return None
 else:
-raise TypeError, _("%s body don't have instances!")%self.content["name"]
+raise TypeError, _("%s body don't have instances!")%self.content.getLocalTag()
 setattr(cls, "getcontentInstanceByName", getcontentInstanceByName)
 def removecontentInstance(self, local_id):
 if self.content.getLocalTag() in ["LD","FBD","SFC"]:
 instance = self.content.xpath("*[@localId=%d]" % local_id)
 if len(instance) > 0:
 self.content.remove(instance[0])
 else:
 raise ValueError, _("Instance with id %d doesn't exist!")%id
 else:
-raise TypeError, "%s body don't have instances!"%self.content["name"]
+raise TypeError, "%s body don't have instances!"%self.content.getLocalTag()
 setattr(cls, "removecontentInstance", removecontentInstance)
 def settext(self, text):
 if self.content.getLocalTag() in ["IL","ST"]:
 self.content.setanyText(text)
 else:
-raise TypeError, _("%s body don't have text!")%self.content["name"]
+raise TypeError, _("%s body don't have text!")%self.content.getLocalTag()
 setattr(cls, "settext", settext)
 def gettext(self):
 if self.content.getLocalTag() in ["IL","ST"]:
 return self.content.getanyText()
 else:
-raise TypeError, _("%s body don't have text!")%self.content["name"]
+raise TypeError, _("%s body don't have text!")%self.content.getLocalTag()
 setattr(cls, "gettext", gettext)
 def hasblock(self, block_type):
 if self.content.getLocalTag() in ["IL","ST"]:
 return self.content.hasblock(block_type)
 else:
-raise TypeError, _("%s body don't have text!")%self.content["name"]
+raise TypeError, _("%s body don't have text!")%self.content.getLocalTag()
 setattr(cls, "hasblock", hasblock)
 def updateElementName(self, old_name, new_name):
 if self.content.getLocalTag() in ["IL", "ST"]:
 self.content.updateElementName(old_name, new_name)
 infos["outputs"].append(_getconnectioninfos(self, connectionPointOut))
 infos["specific_values"]["connectors"] = len(infos["outputs"])
 return infos
 return getpowerrailinfos
-def _getldelementinfosFunction(type):
+def _getldelementinfosFunction(ld_element_type):
 def getldelementinfos(self):
 infos = _getelementinfos(self)
-infos["type"] = type
+infos["type"] = ld_element_type
 specific_values = infos["specific_values"]
-specific_values["name"] = self.getvariable()
+specific_values["name"] = self.getvariable().text
 _getexecutionOrder(self, specific_values)
 specific_values["negated"] = self.getnegated()
 specific_values["edge"] = self.getedge()
 if type == "coil":
 specific_values["storage"] = self.getstorage()
 cls = _initElementClass("rightPowerRail", "ldObjects", "multiple")
 if cls:
 setattr(cls, "getinfos", _getpowerrailinfosFunction("rightPowerRail"))
+def _UpdateLDElementName(self, old_name, new_name):
+if self.variable.text == old_name:
+self.variable.text = new_name
+def _UpdateLDElementAddress(self, address_model, new_leading):
+self.variable.text = update_address(self.variable.text, address_model, new_leading)
+def _getSearchInLDElement(ld_element_type):
+def SearchInLDElement(self, criteria, parent_infos=[]):
+return _Search([("reference", self.variable.text)], criteria, parent_infos + [ld_element_type, self.getlocalId()])
+return SearchInLDElement
 cls = _initElementClass("contact", "ldObjects", "single")
 if cls:
 setattr(cls, "getinfos", _getldelementinfosFunction("contact"))
+setattr(cls, "updateElementName", _UpdateLDElementName)
-def updateElementName(self, old_name, new_name):
+setattr(cls, "updateElementAddress", _UpdateLDElementAddress)
-if self.variable == old_name:
+setattr(cls, "Search", _getSearchInLDElement("contact"))
-self.variable = new_name
-setattr(cls, "updateElementName", updateElementName)
-def updateElementAddress(self, address_model, new_leading):
-self.variable = update_address(self.variable, address_model, new_leading)
-setattr(cls, "updateElementAddress", updateElementAddress)
-def Search(self, criteria, parent_infos=[]):
-return _Search([("reference", self.getvariable())], criteria, parent_infos + ["contact", self.getlocalId()])
-setattr(cls, "Search", Search)
 cls = _initElementClass("coil", "ldObjects", "single")
 if cls:
 setattr(cls, "getinfos", _getldelementinfosFunction("coil"))
+setattr(cls, "updateElementName", _UpdateLDElementName)
-def updateElementName(self, old_name, new_name):
+setattr(cls, "updateElementAddress", _UpdateLDElementAddress)
-if self.variable == old_name:
+setattr(cls, "Search", _getSearchInLDElement("coil"))
-self.variable = new_name
-setattr(cls, "updateElementName", updateElementName)
-def updateElementAddress(self, address_model, new_leading):
-self.variable = update_address(self.variable, address_model, new_leading)
-setattr(cls, "updateElementAddress", updateElementAddress)
-def Search(self, criteria, parent_infos=[]):
-return _Search([("reference", self.getvariable())], criteria, parent_infos + ["coil", self.getlocalId()])
-setattr(cls, "Search", Search)
 cls = _initElementClass("step", "sfcObjects", "single")
 if cls:
 def getinfos(self):
 infos = _getelementinfos(self)
 setattr(cls, "getinfos", getinfos)
 def setconditionContent(self, condition_type, value):
 if not self.condition:
 self.addcondition()
+if condition_type == "connection":
+condition = PLCOpenParser.CreateElement("connectionPointIn", "condition")
+else:
+condition = PLCOpenParser.CreateElement(condition_type, "condition")
+self.condition.setcontent(condition)
 if condition_type == "reference":
-condition = PLCOpenParser.CreateElement("reference", "condition")
 condition.setname(value)
 elif condition_type == "inline":
-condition = PLCOpenParser.CreateElement("inline", "condition")
+condition.setcontent(PLCOpenParser.CreateElement("ST", "inline"))
-condition.setcontent(PLCOpenParser.GetElementClass("ST", "inline"))
+condition.settext(value)
-condition.setanyText(value)
-elif condition_type == "connection":
-condition = PLCOpenParser.CreateElementClass("connectionPointIn")
-self.condition.setcontent(condition)
 setattr(cls, "setconditionContent", setconditionContent)
 def getconditionContent(self):
 if self.condition:
 content = self.condition.getcontent()
 values = {"type" : content.getLocalTag()}
 if values["type"] == "reference":
 values["value"] = content.getname()
 elif values["type"] == "inline":
-values["value"] = content.getanyText()
+values["value"] = content.gettext()
 elif values["type"] == "connectionPointIn":
 values["type"] = "connection"
 values["value"] = content
 return values
 return ""
 setattr(cls, "getconditionContent", getconditionContent)
 def getconditionConnection(self):
 if self.condition:
 content = self.condition.getcontent()
-if content.getLocalTag() == "connectionPointIn":
+if content.getLocalTag() == "connection":
 return content
 return None
 setattr(cls, "getconditionConnection", getconditionConnection)
 def getBoundingBox(self):
 return None
 setattr(cls, "getreferenceName", getreferenceName)
 def setinlineContent(self, content):
 if self.inline:
-self.inline.setcontent(PLCOpenParser.CreateElementClass("ST", "action"))
+self.inline.setcontent(PLCOpenParser.CreateElement("ST", "action"))
 self.inline.setanyText(content)
 setattr(cls, "setinlineContent", setinlineContent)
 def getinlineContent(self):
 if self.inline:
 search_result.extend(action.Search(criteria, parent_infos + ["action", idx]))
 return search_result
 setattr(cls, "Search", Search)
 def _SearchInIOVariable(self, criteria, parent_infos=[]):
-return _Search([("expression", self.getexpression())], criteria, parent_infos + ["io_variable", self.getlocalId()])
+return _Search([("expression", self.expression.text)], criteria, parent_infos + ["io_variable", self.getlocalId()])
+def _UpdateIOElementName(self, old_name, new_name):
+if self.expression.text == old_name:
+self.expression.text = new_name
+def _UpdateIOElementAddress(self, old_name, new_name):
+self.expression.text = update_address(self.expression.text, address_model, new_leading)
 cls = _initElementClass("inVariable", "fbdObjects")
 if cls:
 setattr(cls, "getinfos", _getvariableinfosFunction("input", False, True))
+setattr(cls, "updateElementName", _UpdateIOElementName)
-def updateElementName(self, old_name, new_name):
+setattr(cls, "updateElementAddress", _UpdateIOElementAddress)
-if self.expression == old_name:
-self.expression = new_name
-setattr(cls, "updateElementName", updateElementName)
-def updateElementAddress(self, address_model, new_leading):
-self.expression = update_address(self.expression, address_model, new_leading)
-setattr(cls, "updateElementAddress", updateElementAddress)
 setattr(cls, "Search", _SearchInIOVariable)
 cls = _initElementClass("outVariable", "fbdObjects", "single")
 if cls:
 setattr(cls, "getinfos", _getvariableinfosFunction("output", True, False))
+setattr(cls, "updateElementName", _UpdateIOElementName)
-def updateElementName(self, old_name, new_name):
+setattr(cls, "updateElementAddress", _UpdateIOElementAddress)
-if self.expression == old_name:
-self.expression = new_name
-setattr(cls, "updateElementName", updateElementName)
-def updateElementAddress(self, address_model, new_leading):
-self.expression = update_address(self.expression, address_model, new_leading)
-setattr(cls, "updateElementAddress", updateElementAddress)
 setattr(cls, "Search", _SearchInIOVariable)
 cls = _initElementClass("inOutVariable", "fbdObjects", "single")
 if cls:
 setattr(cls, "getinfos", _getvariableinfosFunction("inout", True, True))
+setattr(cls, "updateElementName", _UpdateIOElementName)
-def updateElementName(self, old_name, new_name):
+setattr(cls, "updateElementAddress", _UpdateIOElementAddress)
-if self.expression == old_name:
-self.expression = new_name
-setattr(cls, "updateElementName", updateElementName)
-def updateElementAddress(self, address_model, new_leading):
-self.expression = update_address(self.expression, address_model, new_leading)
-setattr(cls, "updateElementAddress", updateElementAddress)
 setattr(cls, "Search", _SearchInIOVariable)
 def _SearchInConnector(self, criteria, parent_infos=[]):
 return _Search([("name", self.getname())], criteria, parent_infos + ["connector", self.getlocalId()])
 cls = PLCOpenParser.GetElementClass("connection")
 if cls:
 def setpoints(self, points):
 positions = []
 for point in points:
-position = PLCOpenParser.CreateElement("position")
+position = PLCOpenParser.CreateElement("position", "connection")
 position.setx(point.x)
 position.sety(point.y)
 positions.append(position)
-self.positions = positions
+self.position = positions
 setattr(cls, "setpoints", setpoints)
 def getpoints(self):
 points = []
 for position in self.position:
 setattr(cls, "getpoints", getpoints)
 cls = PLCOpenParser.GetElementClass("connectionPointIn")
 if cls:
 def setrelPositionXY(self, x, y):
-self.relPosition = PLCOpenParser.CreateElement("position")
+self.relPosition = PLCOpenParser.CreateElement("relPosition", "connectionPointIn")
 self.relPosition.setx(x)
 self.relPosition.sety(y)
 setattr(cls, "setrelPositionXY", setrelPositionXY)
 def getrelPositionXY(self):
 return self.relPosition.getx(), self.relPosition.gety()
 return self.relPosition
 setattr(cls, "getrelPositionXY", getrelPositionXY)
 def addconnection(self):
-self.appendcontent(PLCOpenParser.CreateElement("connection"))
+self.append(PLCOpenParser.CreateElement("connection", "connectionPointIn"))
 setattr(cls, "addconnection", addconnection)
 def removeconnection(self, idx):
 if len(self.content) > idx:
 self.remove(self.content[idx])
 def getconnections(self):
 return self.xpath("ppx:connection", namespaces=PLCOpenParser.NSMAP)
 setattr(cls, "getconnections", getconnections)
+def getconnection(self, idx):
+connection = self.xpath("ppx:connection[position()=%d]" % (idx + 1),
+namespaces=PLCOpenParser.NSMAP)
+if len(connection) > 0:
+return connection[0]
+return None
+setattr(cls, "getconnection", getconnection)
 def setconnectionId(self, idx, local_id):
-if len(self.content) > idx:
+connection = self.getconnection(idx)
-self.content[idx].setrefLocalId(local_id)
+if connection is not None:
+connection.setrefLocalId(local_id)
 setattr(cls, "setconnectionId", setconnectionId)
 def getconnectionId(self, idx):
-if len(self.content) > idx:
+connection = self.getconnection(idx)
-return self.content[idx].getrefLocalId()
+if connection is not None:
+return connection.getrefLocalId()
 return None
 setattr(cls, "getconnectionId", getconnectionId)
 def setconnectionPoints(self, idx, points):
-if len(self.content) > idx:
+connection = self.getconnection(idx)
-self.content[idx].setpoints(points)
+if connection is not None:
+connection.setpoints(points)
 setattr(cls, "setconnectionPoints", setconnectionPoints)
 def getconnectionPoints(self, idx):
-if len(self.content) > idx:
+connection = self.getconnection(idx)
-return self.content[idx].getpoints()
+if connection is not None:
+return connection.getpoints()
 return []
 setattr(cls, "getconnectionPoints", getconnectionPoints)
 def setconnectionParameter(self, idx, parameter):
-if len(self.content) > idx:
+connection = self.getconnection(idx)
-self.content[idx].setformalParameter(parameter)
+if connection is not None:
+connection.setformalParameter(parameter)
 setattr(cls, "setconnectionParameter", setconnectionParameter)
 def getconnectionParameter(self, idx):
-if len(self.content) > idx:
+connection = self.getconnection(idx)
-return self.content[idx].getformalParameter()
+if connection is not None:
+return connection.getformalParameter()
 return None
 setattr(cls, "getconnectionParameter", getconnectionParameter)
 cls = PLCOpenParser.GetElementClass("connectionPointOut")
 if cls:
 def setrelPositionXY(self, x, y):
-self.relPosition = PLCOpenParser.CreateElement("position")
+self.relPosition = PLCOpenParser.CreateElement("relPosition", "connectionPointOut")
 self.relPosition.setx(x)
 self.relPosition.sety(y)
 setattr(cls, "setrelPositionXY", setrelPositionXY)
 def getrelPositionXY(self):
 setattr(cls, "setvalue", setvalue)
 def getvalue(self):
 values = []
 for element in self.value:
-repetition = element.getrepetitionValue()
+try:
-if repetition is not None and int(repetition) > 1:
+repetition = int(element.getrepetitionValue())
+except:
+repetition = 1
+if repetition > 1:
 value = element.getvalue()
 if value is None:
 value = ""
 values.append("%s(%s)"%(repetition, value))
 else:

changeset 1293	40117d02601b
parent 1291	42ea51d083ce
child 1294	f02ba5b83811