beremiz

Fixed diagram editing in xmlclass refactoring

2013-08-29, Laurent Bessard
40117d02601b
Parents bac1b86276d9
Children f02ba5b83811
Fixed diagram editing in xmlclass refactoring
4 files changed, 225 insertions(+), 234 deletions(-)
  • +89 -92
    PLCControler.py
  • +1 -1
    editors/Viewer.py
  • +115 -124
    plcopen/plcopen.py
  • +20 -17
    xmlclass/xmlclass.py
    • --- a/PLCControler.py Wed Aug 28 11:53:50 2013 +0200
    +++ b/PLCControler.py Thu Aug 29 00:28:39 2013 +0200
    @@ -1258,16 +1258,16 @@
    dimensions.append((dimension.getlower(), dimension.getupper()))
    base_type = vartype_content.baseType.getcontent()
    base_type_type = base_type.getLocalTag()
    - if base_type is None or base_type_type in ["string", "wstring"]:
    + if base_type_type == "derived":
    + base_type_name = base_type.getname()
    + else:
    base_type_name = base_type_type.upper()
    - else:
    - base_type_name = base_type.getname()
    tempvar["Type"] = ("array", base_type_name, dimensions)
    else:
    tempvar["Type"] = vartype_content_type.upper()
    tempvar["Edit"] = True
    -
    +
    initial = var.getinitialValue()
    if initial is not None:
    tempvar["Initial Value"] = initial.getvalue()
    @@ -2460,7 +2460,7 @@
    if blocktype_infos["type"] != "function" and blockname is not None:
    block.setinstanceName(blockname)
    self.AddEditedElementPouVar(tagname, blocktype, blockname)
    - element.addinstance("block", block)
    + element.addinstance(block)
    self.Project.RefreshElementUsingTree()
    def SetEditedElementBlockInfos(self, tagname, id, infos):
    @@ -2506,7 +2506,8 @@
    block.inputVariables.setvariable([])
    block.outputVariables.setvariable([])
    for connector in value["inputs"]:
    - variable = plcopen.inputVariables_variable()
    + variable = PLCOpenParser.CreateElement("variable", "inputVariables")
    + block.inputVariables.appendvariable(variable)
    variable.setformalParameter(connector.GetName())
    if connector.IsNegated():
    variable.setnegated(True)
    @@ -2515,9 +2516,9 @@
    position = connector.GetRelPosition()
    variable.connectionPointIn.setrelPositionXY(position.x, position.y)
    self.SetConnectionWires(variable.connectionPointIn, connector)
    - block.inputVariables.appendvariable(variable)
    for connector in value["outputs"]:
    - variable = plcopen.outputVariables_variable()
    + variable = PLCOpenParser.CreateElement("variable", "outputVariables")
    + block.outputVariables.appendvariable(variable)
    variable.setformalParameter(connector.GetName())
    if connector.IsNegated():
    variable.setnegated(True)
    @@ -2526,23 +2527,18 @@
    position = connector.GetRelPosition()
    variable.addconnectionPointOut()
    variable.connectionPointOut.setrelPositionXY(position.x, position.y)
    - block.outputVariables.appendvariable(variable)
    + block.tostring()
    self.Project.RefreshElementUsingTree()
    - def AddEditedElementVariable(self, tagname, id, type):
    + def AddEditedElementVariable(self, tagname, id, var_type):
    element = self.GetEditedElement(tagname)
    - if element is not None:
    - if type == INPUT:
    - name = "inVariable"
    - variable = plcopen.fbdObjects_inVariable()
    - elif type == OUTPUT:
    - name = "outVariable"
    - variable = plcopen.fbdObjects_outVariable()
    - elif type == INOUT:
    - name = "inOutVariable"
    - variable = plcopen.fbdObjects_inOutVariable()
    + if element is not None:
    + variable = PLCOpenParser.CreateElement(
    + {INPUT: "inVariable",
    + OUTPUT: "outVariable",
    + INOUT: "inOutVariable"}[var_type], "fbdObjects")
    variable.setlocalId(id)
    - element.addinstance(name, variable)
    + element.addinstance(variable)
    def SetEditedElementVariableInfos(self, tagname, id, infos):
    element = self.GetEditedElement(tagname)
    @@ -2552,7 +2548,9 @@
    return
    for param, value in infos.items():
    if param == "name":
    - variable.setexpression(value)
    + expression = PLCOpenParser.CreateElement("expression", variable.getLocalTag())
    + expression.text = value
    + variable.setexpression(expression)
    elif param == "executionOrder" and variable.getexecutionOrderId() != value:
    element.setelementExecutionOrder(variable, value)
    elif param == "height":
    @@ -2588,17 +2586,14 @@
    variable.connectionPointIn.setrelPositionXY(position.x, position.y)
    self.SetConnectionWires(variable.connectionPointIn, input)
    - def AddEditedElementConnection(self, tagname, id, type):
    + def AddEditedElementConnection(self, tagname, id, connection_type):
    element = self.GetEditedElement(tagname)
    if element is not None:
    - if type == CONNECTOR:
    - name = "connector"
    - connection = plcopen.commonObjects_connector()
    - elif type == CONTINUATION:
    - name = "continuation"
    - connection = plcopen.commonObjects_continuation()
    + connection = PLCOpenParser.CreateElement(
    + {CONNECTOR: "connector",
    + CONTINUATION: "continuation"}[connection_type], "commonObjects")
    connection.setlocalId(id)
    - element.addinstance(name, connection)
    + element.addinstance(connection)
    def SetEditedElementConnectionInfos(self, tagname, id, infos):
    element = self.GetEditedElement(tagname)
    @@ -2619,10 +2614,10 @@
    connection.sety(value)
    elif param == "connector":
    position = value.GetRelPosition()
    - if isinstance(connection, plcopen.commonObjects_continuation):
    + if isinstance(connection, PLCOpenParser.GetElementClass("continuation", "commonObjects")):
    connection.addconnectionPointOut()
    connection.connectionPointOut.setrelPositionXY(position.x, position.y)
    - elif isinstance(connection, plcopen.commonObjects_connector):
    + elif isinstance(connection, PLCOpenParser.GetElementClass("connector", "commonObjects")):
    connection.addconnectionPointIn()
    connection.connectionPointIn.setrelPositionXY(position.x, position.y)
    self.SetConnectionWires(connection.connectionPointIn, value)
    @@ -2630,9 +2625,9 @@
    def AddEditedElementComment(self, tagname, id):
    element = self.GetEditedElement(tagname)
    if element is not None:
    - comment = plcopen.commonObjects_comment()
    + comment = PLCOpenParser.CreateElement("comment", "commonObjects")
    comment.setlocalId(id)
    - element.addinstance("comment", comment)
    + element.addinstance(comment)
    def SetEditedElementCommentInfos(self, tagname, id, infos):
    element = self.GetEditedElement(tagname)
    @@ -2650,17 +2645,14 @@
    elif param == "y":
    comment.sety(value)
    - def AddEditedElementPowerRail(self, tagname, id, type):
    + def AddEditedElementPowerRail(self, tagname, id, powerrail_type):
    element = self.GetEditedElement(tagname)
    if element is not None:
    - if type == LEFTRAIL:
    - name = "leftPowerRail"
    - powerrail = plcopen.ldObjects_leftPowerRail()
    - elif type == RIGHTRAIL:
    - name = "rightPowerRail"
    - powerrail = plcopen.ldObjects_rightPowerRail()
    + powerrail = PLCOpenParser.CreateElement(
    + {LEFTRAIL: "leftPowerRail",
    + RIGHTRAIL: "rightPowerRail"}[powerrail_type], "ldObjects")
    powerrail.setlocalId(id)
    - element.addinstance(name, powerrail)
    + element.addinstance(powerrail)
    def SetEditedElementPowerRailInfos(self, tagname, id, infos):
    element = self.GetEditedElement(tagname)
    @@ -2678,28 +2670,28 @@
    elif param == "y":
    powerrail.sety(value)
    elif param == "connectors":
    - if isinstance(powerrail, plcopen.ldObjects_leftPowerRail):
    + if isinstance(powerrail, PLCOpenParser.GetElementClass("leftPowerRail", "ldObjects")):
    powerrail.setconnectionPointOut([])
    for connector in value["outputs"]:
    position = connector.GetRelPosition()
    - connection = plcopen.leftPowerRail_connectionPointOut()
    + connection = PLCOpenParser.CreateElement("connectionPointOut", "leftPowerRail")
    + powerrail.appendconnectionPointOut(connection)
    connection.setrelPositionXY(position.x, position.y)
    - powerrail.connectionPointOut.append(connection)
    - elif isinstance(powerrail, plcopen.ldObjects_rightPowerRail):
    + elif isinstance(powerrail, PLCOpenParser.GetElementClass("rightPowerRail", "ldObjects")):
    powerrail.setconnectionPointIn([])
    for connector in value["inputs"]:
    position = connector.GetRelPosition()
    - connection = plcopen.connectionPointIn()
    + connection = PLCOpenParser.CreateElement("connectionPointIn", "rightPowerRail")
    + powerrail.appendconnectionPointIn(connection)
    connection.setrelPositionXY(position.x, position.y)
    self.SetConnectionWires(connection, connector)
    - powerrail.connectionPointIn.append(connection)
    -
    +
    def AddEditedElementContact(self, tagname, id):
    element = self.GetEditedElement(tagname)
    if element is not None:
    - contact = plcopen.ldObjects_contact()
    + contact = PLCOpenParser.CreateElement("contact", "ldObjects")
    contact.setlocalId(id)
    - element.addinstance("contact", contact)
    + element.addinstance(contact)
    def SetEditedElementContactInfos(self, tagname, id, infos):
    element = self.GetEditedElement(tagname)
    @@ -2709,7 +2701,9 @@
    return
    for param, value in infos.items():
    if param == "name":
    - contact.setvariable(value)
    + variable = PLCOpenParser.CreateElement("variable", "contact")
    + variable.text = value
    + contact.setvariable(variable)
    elif param == "type":
    if value == CONTACT_NORMAL:
    contact.setnegated(False)
    @@ -2745,9 +2739,9 @@
    def AddEditedElementCoil(self, tagname, id):
    element = self.GetEditedElement(tagname)
    if element is not None:
    - coil = plcopen.ldObjects_coil()
    + coil = PLCOpenParser.CreateElement("coil", "ldObjects")
    coil.setlocalId(id)
    - element.addinstance("coil", coil)
    + element.addinstance(coil)
    def SetEditedElementCoilInfos(self, tagname, id, infos):
    element = self.GetEditedElement(tagname)
    @@ -2757,7 +2751,9 @@
    return
    for param, value in infos.items():
    if param == "name":
    - coil.setvariable(value)
    + variable = PLCOpenParser.CreateElement("variable", "coil")
    + variable.text = value
    + coil.setvariable(variable)
    elif param == "type":
    if value == COIL_NORMAL:
    coil.setnegated(False)
    @@ -2805,9 +2801,9 @@
    def AddEditedElementStep(self, tagname, id):
    element = self.GetEditedElement(tagname)
    if element is not None:
    - step = plcopen.sfcObjects_step()
    + step = PLCOpenParser.CreateElement("step", "sfcObjects")
    step.setlocalId(id)
    - element.addinstance("step", step)
    + element.addinstance(step)
    def SetEditedElementStepInfos(self, tagname, id, infos):
    element = self.GetEditedElement(tagname)
    @@ -2855,9 +2851,9 @@
    def AddEditedElementTransition(self, tagname, id):
    element = self.GetEditedElement(tagname)
    if element is not None:
    - transition = plcopen.sfcObjects_transition()
    + transition = PLCOpenParser.CreateElement("transition", "sfcObjects")
    transition.setlocalId(id)
    - element.addinstance("transition", transition)
    + element.addinstance(transition)
    def SetEditedElementTransitionInfos(self, tagname, id, infos):
    element = self.GetEditedElement(tagname)
    @@ -2893,25 +2889,31 @@
    transition.connectionPointOut.setrelPositionXY(position.x, position.y)
    elif infos.get("type", None) == "connection" and param == "connection" and value:
    transition.setconditionContent("connection", None)
    - self.SetConnectionWires(transition.condition.content["value"], value)
    + self.SetConnectionWires(transition.condition.content, value)
    - def AddEditedElementDivergence(self, tagname, id, type):
    + def AddEditedElementDivergence(self, tagname, id, divergence_type):
    element = self.GetEditedElement(tagname)
    if element is not None:
    - if type == SELECTION_DIVERGENCE:
    - name = "selectionDivergence"
    - divergence = plcopen.sfcObjects_selectionDivergence()
    - elif type == SELECTION_CONVERGENCE:
    - name = "selectionConvergence"
    - divergence = plcopen.sfcObjects_selectionConvergence()
    - elif type == SIMULTANEOUS_DIVERGENCE:
    - name = "simultaneousDivergence"
    - divergence = plcopen.sfcObjects_simultaneousDivergence()
    - elif type == SIMULTANEOUS_CONVERGENCE:
    - name = "simultaneousConvergence"
    - divergence = plcopen.sfcObjects_simultaneousConvergence()
    + divergence = PLCOpenParser.CreateElement(
    + {SELECTION_DIVERGENCE: "selectionDivergence",
    + SELECTION_CONVERGENCE: "selectionConvergence",
    + SIMULTANEOUS_DIVERGENCE: "simultaneousDivergence",
    + SIMULTANEOUS_CONVERGENCE: "simultaneousConvergence"}.get(
    + divergence_type), "sfcObjects")
    divergence.setlocalId(id)
    - element.addinstance(name, divergence)
    + element.addinstance(divergence)
    +
    + DivergenceTypes = [
    + (divergence_type,
    + PLCOpenParser.GetElementClass(divergence_type, "sfcObjects"))
    + for divergence_type in ["selectionDivergence", "simultaneousDivergence",
    + "selectionConvergence", "simultaneousConvergence"]]
    +
    + def GetDivergenceType(self, divergence):
    + for divergence_type, divergence_class in self.DivergenceTypes:
    + if isinstance(divergence, divergence_class):
    + return divergence_type
    + return None
    def SetEditedElementDivergenceInfos(self, tagname, id, infos):
    element = self.GetEditedElement(tagname)
    @@ -2930,7 +2932,8 @@
    divergence.sety(value)
    elif param == "connectors":
    input_connectors = value["inputs"]
    - if isinstance(divergence, (plcopen.sfcObjects_selectionDivergence, plcopen.sfcObjects_simultaneousDivergence)):
    + divergence_type = self.GetDivergenceType(divergence)
    + if divergence_type in ["selectionDivergence", "simultaneousDivergence"]:
    position = input_connectors[0].GetRelPosition()
    divergence.addconnectionPointIn()
    divergence.connectionPointIn.setrelPositionXY(position.x, position.y)
    @@ -2939,15 +2942,12 @@
    divergence.setconnectionPointIn([])
    for input_connector in input_connectors:
    position = input_connector.GetRelPosition()
    - if isinstance(divergence, plcopen.sfcObjects_selectionConvergence):
    - connection = plcopen.selectionConvergence_connectionPointIn()
    - else:
    - connection = plcopen.connectionPointIn()
    + connection = PLCOpenParser.CreateElement("connectionPointIn", divergence_type)
    + divergence.appendconnectionPointIn(connection)
    connection.setrelPositionXY(position.x, position.y)
    self.SetConnectionWires(connection, input_connector)
    - divergence.appendconnectionPointIn(connection)
    output_connectors = value["outputs"]
    - if isinstance(divergence, (plcopen.sfcObjects_selectionConvergence, plcopen.sfcObjects_simultaneousConvergence)):
    + if divergence_type in ["selectionConvergence", "simultaneousConvergence"]:
    position = output_connectors[0].GetRelPosition()
    divergence.addconnectionPointOut()
    divergence.connectionPointOut.setrelPositionXY(position.x, position.y)
    @@ -2955,19 +2955,16 @@
    divergence.setconnectionPointOut([])
    for output_connector in output_connectors:
    position = output_connector.GetRelPosition()
    - if isinstance(divergence, plcopen.sfcObjects_selectionDivergence):
    - connection = plcopen.selectionDivergence_connectionPointOut()
    - else:
    - connection = plcopen.simultaneousDivergence_connectionPointOut()
    + connection = PLCOpenParser.CreateElement("connectionPointOut", divergence_type)
    + divergence.appendconnectionPointOut(connection)
    connection.setrelPositionXY(position.x, position.y)
    - divergence.appendconnectionPointOut(connection)
    -
    +
    def AddEditedElementJump(self, tagname, id):
    element = self.GetEditedElement(tagname)
    if element is not None:
    - jump = plcopen.sfcObjects_jumpStep()
    + jump = PLCOpenParser.CreateElement("jumpStep", "sfcObjects")
    jump.setlocalId(id)
    - element.addinstance("jumpStep", jump)
    + element.addinstance(jump)
    def SetEditedElementJumpInfos(self, tagname, id, infos):
    element = self.GetEditedElement(tagname)
    @@ -2995,9 +2992,9 @@
    def AddEditedElementActionBlock(self, tagname, id):
    element = self.GetEditedElement(tagname)
    if element is not None:
    - actionBlock = plcopen.commonObjects_actionBlock()
    + actionBlock = PLCOpenParser.CreateElement("actionBlock", "commonObjects")
    actionBlock.setlocalId(id)
    - element.addinstance("actionBlock", actionBlock)
    + element.addinstance(actionBlock)
    def SetEditedElementActionBlockInfos(self, tagname, id, infos):
    element = self.GetEditedElement(tagname)
    @@ -3026,7 +3023,7 @@
    element = self.GetEditedElement(tagname)
    if element is not None:
    instance = element.getinstance(id)
    - if isinstance(instance, plcopen.fbdObjects_block):
    + if isinstance(instance, PLCOpenParser.GetElementClass("block", "fbdObjects")):
    self.RemoveEditedElementPouVar(tagname, instance.gettypeName(), instance.getinstanceName())
    element.removeinstance(id)
    self.Project.RefreshElementUsingTree()
    --- a/editors/Viewer.py Wed Aug 28 11:53:50 2013 +0200
    +++ b/editors/Viewer.py Thu Aug 29 00:28:39 2013 +0200
    @@ -1074,7 +1074,7 @@
    def RefreshView(self, variablepanel=True, selection=None):
    EditorPanel.RefreshView(self, variablepanel)
    - if self.TagName.split("::")[0] == "A":
    + if self.TagName.split("::")[0] == "A" and self.Debug:
    self.AddDataConsumer("%s.Q" % self.InstancePath.upper(), self)
    if self.ToolTipElement is not None:
    --- a/plcopen/plcopen.py Wed Aug 28 11:53:50 2013 +0200
    +++ b/plcopen/plcopen.py Thu Aug 29 00:28:39 2013 +0200
    @@ -880,7 +880,7 @@
    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)
    @@ -1079,9 +1079,9 @@
    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):
    @@ -1116,11 +1116,11 @@
    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):
    @@ -1260,7 +1260,7 @@
    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)
    @@ -1285,9 +1285,9 @@
    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):
    @@ -1345,7 +1345,6 @@
    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=""):
    @@ -1366,8 +1365,8 @@
    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"))
    - var = PLCOpenParser.CreateElementClass("variable", "varListPlain")
    + self.appendcontent(PLCOpenParser.CreateElement(var_class, "interface"))
    + 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")]:
    @@ -1441,21 +1440,21 @@
    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
    @@ -1463,13 +1462,13 @@
    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:
    @@ -1486,17 +1485,17 @@
    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
    @@ -1510,7 +1509,7 @@
    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:
    @@ -1527,7 +1526,7 @@
    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()
    @@ -1548,7 +1547,7 @@
    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()
    @@ -1562,7 +1561,7 @@
    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:
    @@ -1570,7 +1569,7 @@
    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()
    @@ -1628,8 +1627,8 @@
    def setelementExecutionOrder(self, instance, new_executionOrder):
    self.body.setelementExecutionOrder(instance, new_executionOrder)
    -def addinstance(self, name, instance):
    - self.body.appendcontentInstance(name, instance)
    +def addinstance(self, instance):
    + self.body.appendcontentInstance(instance)
    def getinstances(self):
    return self.body.getcontentInstances()
    @@ -1801,18 +1800,18 @@
    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):
    @@ -1822,7 +1821,7 @@
    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):
    @@ -1835,7 +1834,7 @@
    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):
    @@ -1845,7 +1844,7 @@
    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):
    @@ -1856,28 +1855,28 @@
    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):
    @@ -2140,12 +2139,12 @@
    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()
    @@ -2274,39 +2273,31 @@
    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"))
    -
    - def updateElementName(self, old_name, new_name):
    - if self.variable == old_name:
    - 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)
    + setattr(cls, "updateElementName", _UpdateLDElementName)
    + setattr(cls, "updateElementAddress", _UpdateLDElementAddress)
    + setattr(cls, "Search", _getSearchInLDElement("contact"))
    cls = _initElementClass("coil", "ldObjects", "single")
    if cls:
    setattr(cls, "getinfos", _getldelementinfosFunction("coil"))
    -
    - def updateElementName(self, old_name, new_name):
    - if self.variable == old_name:
    - 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)
    + setattr(cls, "updateElementName", _UpdateLDElementName)
    + setattr(cls, "updateElementAddress", _UpdateLDElementAddress)
    + setattr(cls, "Search", _getSearchInLDElement("coil"))
    cls = _initElementClass("step", "sfcObjects", "single")
    if cls:
    @@ -2370,16 +2361,16 @@
    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.GetElementClass("ST", "inline"))
    - condition.setanyText(value)
    - elif condition_type == "connection":
    - condition = PLCOpenParser.CreateElementClass("connectionPointIn")
    - self.condition.setcontent(condition)
    + condition.setcontent(PLCOpenParser.CreateElement("ST", "inline"))
    + condition.settext(value)
    setattr(cls, "setconditionContent", setconditionContent)
    def getconditionContent(self):
    @@ -2389,7 +2380,7 @@
    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
    @@ -2400,7 +2391,7 @@
    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)
    @@ -2533,7 +2524,7 @@
    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)
    @@ -2645,51 +2636,34 @@
    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))
    -
    - def updateElementName(self, old_name, new_name):
    - 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, "updateElementName", _UpdateIOElementName)
    + setattr(cls, "updateElementAddress", _UpdateIOElementAddress)
    setattr(cls, "Search", _SearchInIOVariable)
    cls = _initElementClass("outVariable", "fbdObjects", "single")
    if cls:
    setattr(cls, "getinfos", _getvariableinfosFunction("output", True, False))
    -
    - def updateElementName(self, old_name, new_name):
    - 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, "updateElementName", _UpdateIOElementName)
    + setattr(cls, "updateElementAddress", _UpdateIOElementAddress)
    setattr(cls, "Search", _SearchInIOVariable)
    cls = _initElementClass("inOutVariable", "fbdObjects", "single")
    if cls:
    setattr(cls, "getinfos", _getvariableinfosFunction("inout", True, True))
    -
    - def updateElementName(self, old_name, new_name):
    - 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, "updateElementName", _UpdateIOElementName)
    + setattr(cls, "updateElementAddress", _UpdateIOElementAddress)
    setattr(cls, "Search", _SearchInIOVariable)
    @@ -2721,11 +2695,11 @@
    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):
    @@ -2738,7 +2712,7 @@
    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)
    @@ -2750,7 +2724,7 @@
    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):
    @@ -2766,43 +2740,57 @@
    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:
    - self.content[idx].setrefLocalId(local_id)
    + connection = self.getconnection(idx)
    + if connection is not None:
    + connection.setrefLocalId(local_id)
    setattr(cls, "setconnectionId", setconnectionId)
    def getconnectionId(self, idx):
    - if len(self.content) > idx:
    - return self.content[idx].getrefLocalId()
    + connection = self.getconnection(idx)
    + if connection is not None:
    + return connection.getrefLocalId()
    return None
    setattr(cls, "getconnectionId", getconnectionId)
    def setconnectionPoints(self, idx, points):
    - if len(self.content) > idx:
    - self.content[idx].setpoints(points)
    + connection = self.getconnection(idx)
    + if connection is not None:
    + connection.setpoints(points)
    setattr(cls, "setconnectionPoints", setconnectionPoints)
    def getconnectionPoints(self, idx):
    - if len(self.content) > idx:
    - return self.content[idx].getpoints()
    + connection = self.getconnection(idx)
    + if connection is not None:
    + return connection.getpoints()
    return []
    setattr(cls, "getconnectionPoints", getconnectionPoints)
    def setconnectionParameter(self, idx, parameter):
    - if len(self.content) > idx:
    - self.content[idx].setformalParameter(parameter)
    + connection = self.getconnection(idx)
    + if connection is not None:
    + connection.setformalParameter(parameter)
    setattr(cls, "setconnectionParameter", setconnectionParameter)
    def getconnectionParameter(self, idx):
    - if len(self.content) > idx:
    - return self.content[idx].getformalParameter()
    + connection = self.getconnection(idx)
    + 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)
    @@ -2868,8 +2856,11 @@
    def getvalue(self):
    values = []
    for element in self.value:
    - repetition = element.getrepetitionValue()
    - if repetition is not None and int(repetition) > 1:
    + try:
    + repetition = int(element.getrepetitionValue())
    + except:
    + repetition = 1
    + if repetition > 1:
    value = element.getvalue()
    if value is None:
    value = ""
    --- a/xmlclass/xmlclass.py Wed Aug 28 11:53:50 2013 +0200
    +++ b/xmlclass/xmlclass.py Thu Aug 29 00:28:39 2013 +0200
    @@ -549,18 +549,19 @@
    p.text = etree.CDATA(value)
    def InitialAny():
    - text = etree.CDATA(value)
    if infos["namespace"][0] == "##any":
    element_name = "p"
    else:
    element_name = "{%s}p" % infos["namespace"][0]
    - return etree.Element(element_name, text)
    + p = etree.Element(element_name)
    + p.text = etree.CDATA("")
    + return p
    return {
    "type": COMPLEXTYPE,
    "extract": ExtractAny,
    "generate": GenerateAny,
    - "initial": lambda: GenerateAny(""),
    + "initial": InitialAny,
    "check": lambda x: isinstance(x, (StringType, UnicodeType, etree.ElementBase))
    }
    @@ -600,7 +601,7 @@
    infos["elmt_type"] = FindTypeInfos(factory, infos["elmt_type"])
    if infos["minOccurs"] == 1:
    element_name = factory.etreeNamespaceFormat % infos["name"]
    - if infos["type"] == SIMPLETYPE:
    + if infos["elmt_type"]["type"] == SIMPLETYPE:
    def initial_value():
    value = etree.Element(element_name)
    value.text = (infos["elmt_type"]["generate"](infos["elmt_type"]["initial"]()))
    @@ -608,7 +609,9 @@
    else:
    def initial_value():
    value = infos["elmt_type"]["initial"]()
    - DefaultElementClass.__setattr__(value, "tag", element_name)
    + if infos["type"] != ANY:
    + DefaultElementClass.__setattr__(value, "tag", element_name)
    + value.init()
    return value
    return [initial_value() for i in xrange(infos["minOccurs"])]
    else:
    @@ -1115,9 +1118,12 @@
    def ExtractTypeInfos(self, name, parent, typeinfos):
    if isinstance(typeinfos, (StringType, UnicodeType)):
    namespace, type_name = DecomposeQualifiedName(typeinfos)
    - if namespace == self.TargetNamespace and name != "base":
    - self.AddToLookupClass(name, parent, type_name)
    infos = self.GetQualifiedNameInfos(type_name, namespace)
    + if name != "base":
    + if infos["type"] == SIMPLETYPE:
    + self.AddToLookupClass(name, parent, DefaultElementClass)
    + elif namespace == self.TargetNamespace:
    + self.AddToLookupClass(name, parent, type_name)
    if infos["type"] == COMPLEXTYPE:
    type_name, parent = self.SplitQualifiedName(type_name, namespace)
    result = self.CreateClass(type_name, parent, infos)
    @@ -1874,10 +1880,7 @@
    else factory.etreeNamespaceFormat % element["name"])
    initial = GetElementInitialValue(factory, element)
    if initial is not None:
    - for value in initial:
    - DefaultElementClass.__setattr__(value, "tag", element_name)
    - value.init()
    - self.append(value)
    + map(self.append, initial)
    return initMethod
    def generateSetMethod(attr):
    @@ -1894,16 +1897,16 @@
    def addMethod(self):
    if infos["type"] == ATTRIBUTE:
    infos["attr_type"] = FindTypeInfos(factory, infos["attr_type"])
    - initial = infos["attr_type"]["initial"]
    - extract = infos["attr_type"]["extract"]
    + if not infos.has_key("default"):
    + setattr(self, attr, infos["attr_type"]["initial"]())
    elif infos["type"] == ELEMENT:
    infos["elmt_type"] = FindTypeInfos(factory, infos["elmt_type"])
    - initial = infos["elmt_type"]["initial"]
    - extract = infos["elmt_type"]["extract"]
    + value = infos["elmt_type"]["initial"]()
    + DefaultElementClass.__setattr__(value, "tag", factory.etreeNamespaceFormat % attr)
    + setattr(self, attr, value)
    + value.init()
    else:
    raise ValueError("Invalid class attribute!")
    - if not infos.has_key("default"):
    - setattr(self, attr, initial())
    return addMethod
    def generateDeleteMethod(attr):