Mercurial Mercurial > plcopeneditor_history / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
PLCControler.py
changeset 383 25ffba02b6a8
parent 369 b506dea7a103
child 384 ed27a676d5c9
equal deleted inserted replaced
382:42a9b03bba82 383:25ffba02b6a8 
  1590             if id is not None:
 
  1590             if id is not None:
 
  1591                 instance = element.getinstance(id)
 
  1591                 instance = element.getinstance(id)
 
  1592             else:
 
  1592             else:
 
  1593                 instance = element.getrandomInstance(exclude)
 
  1593                 instance = element.getrandomInstance(exclude)
 
  1594         if instance is not None:
 
  1594         if instance is not None:
 
  1595             if id is not None:
 
  1595             infos = instance.getinfos()
 
  1596                 infos["id"] = id
 
  1596             if infos["type"] in ["input", "output", "inout"]:
 
  1597             else:
 
  1597                 var_type = self.GetEditedElementVarValueType(tagname, infos["specific_values"]["name"], debug)
 
  1598                 infos["id"] = instance.getlocalId() 
  1598                 infos["specific_values"]["value_type"] = var_type
 
  1599             infos["x"] = instance.getx()
 
       
  1600             infos["y"] = instance.gety()
 
       
  1601             infos["height"] = instance.getheight()
 
       
  1602             infos["width"] = instance.getwidth()
 
       
  1603             if isinstance(instance, plcopen.fbdObjects_block):
 
       
  1604                 infos["name"] = instance.getinstanceName()
 
       
  1605                 infos["type"] = instance.gettypeName()
 
       
  1606                 executionOrder = instance.getexecutionOrderId()
 
       
  1607                 if executionOrder is not None:
 
       
  1608                     infos["executionOrder"] = executionOrder
 
       
  1609                 else:
 
       
  1610                     infos["executionOrder"] = 0
 
       
  1611                 infos["connectors"] = {"inputs":[],"outputs":[]}
 
       
  1612                 for variable in instance.inputVariables.getvariable():
 
       
  1613                     connector = {}
 
       
  1614                     connector["name"] = variable.getformalParameter()
 
       
  1615                     connector["position"] = variable.connectionPointIn.getrelPositionXY()
 
       
  1616                     connector["negated"] = variable.getnegated()
 
       
  1617                     connector["edge"] = variable.getedge()
 
       
  1618                     connector["links"] = []
 
       
  1619                     connections = variable.connectionPointIn.getconnections()
 
       
  1620                     if connections:
 
       
  1621                         for link in connections:
 
       
  1622                             dic = {"refLocalId":link.getrefLocalId(),"points":link.getpoints(),"formalParameter":link.getformalParameter()}
 
       
  1623                             connector["links"].append(dic)
 
       
  1624                     infos["connectors"]["inputs"].append(connector)
 
       
  1625                 for variable in instance.outputVariables.getvariable():
 
       
  1626                     connector = {}
 
       
  1627                     connector["name"] = variable.getformalParameter()
 
       
  1628                     connector["position"] = variable.connectionPointOut.getrelPositionXY()
 
       
  1629                     connector["negated"] = variable.getnegated()
 
       
  1630                     connector["edge"] = variable.getedge()
 
       
  1631                     infos["connectors"]["outputs"].append(connector)
 
       
  1632             elif isinstance(instance, plcopen.fbdObjects_inVariable):
 
       
  1633                 infos["name"] = instance.getexpression()
 
       
  1634                 infos["value_type"] = self.GetEditedElementVarValueType(tagname, infos["name"], debug)
 
       
  1635                 infos["type"] = "input"
 
       
  1636                 executionOrder = instance.getexecutionOrderId()
 
       
  1637                 if executionOrder is not None:
 
       
  1638                     infos["executionOrder"] = executionOrder
 
       
  1639                 else:
 
       
  1640                     infos["executionOrder"] = 0
 
       
  1641                 infos["connector"] = {}
 
       
  1642                 infos["connector"]["position"] = instance.connectionPointOut.getrelPositionXY()
 
       
  1643                 infos["connector"]["negated"] = instance.getnegated()
 
       
  1644                 infos["connector"]["edge"] = instance.getedge()
 
       
  1645             elif isinstance(instance, plcopen.fbdObjects_outVariable):
 
       
  1646                 infos["name"] = instance.getexpression()
 
       
  1647                 infos["value_type"] = self.GetEditedElementVarValueType(tagname, infos["name"], debug)
 
       
  1648                 infos["type"] = "output"
 
       
  1649                 executionOrder = instance.getexecutionOrderId()
 
       
  1650                 if executionOrder is not None:
 
       
  1651                     infos["executionOrder"] = executionOrder
 
       
  1652                 else:
 
       
  1653                     infos["executionOrder"] = 0
 
       
  1654                 infos["connector"] = {}
 
       
  1655                 infos["connector"]["position"] = instance.connectionPointIn.getrelPositionXY()
 
       
  1656                 infos["connector"]["negated"] = instance.getnegated()
 
       
  1657                 infos["connector"]["edge"] = instance.getedge()
 
       
  1658                 infos["connector"]["links"] = []
 
       
  1659                 connections = instance.connectionPointIn.getconnections()
 
       
  1660                 if connections:
 
       
  1661                     for link in connections:
 
       
  1662                         dic = {"refLocalId":link.getrefLocalId(),"points":link.getpoints(),"formalParameter":link.getformalParameter()}
 
       
  1663                         infos["connector"]["links"].append(dic)
 
       
  1664             elif isinstance(instance, plcopen.fbdObjects_inOutVariable):
 
       
  1665                 infos["name"] = instance.getexpression()
 
       
  1666                 infos["value_type"] = self.GetEditedElementVarValueType(tagname, infos["name"], debug)
 
       
  1667                 infos["type"] = "inout"
 
       
  1668                 executionOrder = instance.getexecutionOrderId()
 
       
  1669                 if executionOrder is not None:
 
       
  1670                     infos["executionOrder"] = executionOrder
 
       
  1671                 else:
 
       
  1672                     infos["executionOrder"] = 0
 
       
  1673                 infos["connectors"] = {"input":{},"output":{}}
 
       
  1674                 infos["connectors"]["output"]["position"] = instance.connectionPointOut.getrelPositionXY()
 
       
  1675                 infos["connectors"]["output"]["negated"] = instance.getnegatedOut()
 
       
  1676                 infos["connectors"]["output"]["edge"] = instance.getedgeOut()
 
       
  1677                 infos["connectors"]["input"]["position"] = instance.connectionPointIn.getrelPositionXY()
 
       
  1678                 infos["connectors"]["input"]["negated"] = instance.getnegatedIn()
 
       
  1679                 infos["connectors"]["input"]["edge"] = instance.getedgeIn()
 
       
  1680                 infos["connectors"]["input"]["links"] = []
 
       
  1681                 connections = instance.connectionPointIn.getconnections()
 
       
  1682                 if connections:
 
       
  1683                     for link in connections:
 
       
  1684                         dic = {"refLocalId":link.getrefLocalId(),"points":link.getpoints(),"formalParameter":link.getformalParameter()}
 
       
  1685                         infos["connectors"]["input"]["links"].append(dic)
 
       
  1686             elif isinstance(instance, plcopen.commonObjects_continuation):
 
       
  1687                 infos["name"] = instance.getname()
 
       
  1688                 infos["type"] = "continuation"
 
       
  1689                 infos["connector"] = {}
 
       
  1690                 infos["connector"]["position"] = instance.connectionPointOut.getrelPositionXY()
 
       
  1691             elif isinstance(instance, plcopen.commonObjects_connector):
 
       
  1692                 infos["name"] = instance.getname()
 
       
  1693                 infos["type"] = "connection"
 
       
  1694                 infos["connector"] = {}
 
       
  1695                 infos["connector"]["position"] = instance.connectionPointIn.getrelPositionXY()
 
       
  1696                 infos["connector"]["links"] = []
 
       
  1697                 connections = instance.connectionPointIn.getconnections()
 
       
  1698                 if connections:
 
       
  1699                     for link in connections:
 
       
  1700                         dic = {"refLocalId":link.getrefLocalId(),"points":link.getpoints(),"formalParameter":link.getformalParameter()}
 
       
  1701                         infos["connector"]["links"].append(dic)
 
       
  1702             elif isinstance(instance, plcopen.commonObjects_comment):
 
       
  1703                 infos["type"] = "comment"
 
       
  1704                 infos["content"] = instance.getcontentText()
 
       
  1705             elif isinstance(instance, plcopen.ldObjects_leftPowerRail):
 
       
  1706                 infos["type"] = "leftPowerRail"
 
       
  1707                 infos["connectors"] = []
 
       
  1708                 for connection in instance.getconnectionPointOut():
 
       
  1709                     connector = {}
 
       
  1710                     connector["position"] = connection.getrelPositionXY()
 
       
  1711                     infos["connectors"].append(connector)
 
       
  1712             elif isinstance(instance, plcopen.ldObjects_rightPowerRail):
 
       
  1713                 infos["type"] = "rightPowerRail"
 
       
  1714                 infos["connectors"] = []
 
       
  1715                 for connection in instance.getconnectionPointIn():
 
       
  1716                     connector = {}
 
       
  1717                     connector["position"] = connection.getrelPositionXY()
 
       
  1718                     connector["links"] = []
 
       
  1719                     connections = connection.getconnections()
 
       
  1720                     if connections:
 
       
  1721                         for link in connection.getconnections():
 
       
  1722                             dic = {"refLocalId":link.getrefLocalId(),"points":link.getpoints(),"formalParameter":link.getformalParameter()}
 
       
  1723                             connector["links"].append(dic)
 
       
  1724                     infos["connectors"].append(connector)
 
       
  1725             elif isinstance(instance, plcopen.ldObjects_contact):
 
       
  1726                 infos["name"] = instance.getvariable()
 
       
  1727                 infos["type"] = "contact"
 
       
  1728                 executionOrder = instance.getexecutionOrderId()
 
       
  1729                 if executionOrder is not None:
 
       
  1730                     infos["executionOrder"] = executionOrder
 
       
  1731                 else:
 
       
  1732                     infos["executionOrder"] = 0
 
       
  1733                 infos["negated"] = instance.getnegated()
 
       
  1734                 infos["edge"] = instance.getedge()
 
       
  1735                 infos["connectors"] = {"input":{},"output":{}}
 
       
  1736                 infos["connectors"]["input"]["position"] = instance.connectionPointIn.getrelPositionXY()
 
       
  1737                 infos["connectors"]["input"]["links"] = []
 
       
  1738                 connections = instance.connectionPointIn.getconnections()
 
       
  1739                 if connections:
 
       
  1740                     for link in connections:
 
       
  1741                         dic = {"refLocalId":link.getrefLocalId(),"points":link.getpoints(),"formalParameter":link.getformalParameter()}
 
       
  1742                         infos["connectors"]["input"]["links"].append(dic)
 
       
  1743                 infos["connectors"]["output"]["position"] = instance.connectionPointOut.getrelPositionXY()
 
       
  1744             elif isinstance(instance, plcopen.ldObjects_coil):
 
       
  1745                 infos["name"] = instance.getvariable()
 
       
  1746                 infos["type"] = "coil"
 
       
  1747                 executionOrder = instance.getexecutionOrderId()
 
       
  1748                 if executionOrder is not None:
 
       
  1749                     infos["executionOrder"] = executionOrder
 
       
  1750                 else:
 
       
  1751                     infos["executionOrder"] = 0
 
       
  1752                 infos["negated"] = instance.getnegated()
 
       
  1753                 infos["edge"] = instance.getedge()
 
       
  1754                 infos["storage"] = instance.getstorage()
 
       
  1755                 infos["connectors"] = {"input":{},"output":{}}
 
       
  1756                 infos["connectors"]["input"]["position"] = instance.connectionPointIn.getrelPositionXY()
 
       
  1757                 infos["connectors"]["input"]["links"] = []
 
       
  1758                 connections = instance.connectionPointIn.getconnections()
 
       
  1759                 if connections:
 
       
  1760                     for link in connections:
 
       
  1761                         dic = {"refLocalId":link.getrefLocalId(),"points":link.getpoints(),"formalParameter":link.getformalParameter()}
 
       
  1762                         infos["connectors"]["input"]["links"].append(dic)
 
       
  1763                 infos["connectors"]["output"]["position"] = instance.connectionPointOut.getrelPositionXY()
 
       
  1764             elif isinstance(instance, plcopen.sfcObjects_step):
 
       
  1765                 infos["name"] = instance.getname()
 
       
  1766                 infos["type"] = "step"
 
       
  1767                 infos["initial"] = instance.getinitialStep()
 
       
  1768                 infos["connectors"] = {}
 
       
  1769                 if instance.connectionPointIn:
 
       
  1770                     infos["connectors"]["input"] = {}
 
       
  1771                     infos["connectors"]["input"]["position"] = instance.connectionPointIn.getrelPositionXY()
 
       
  1772                     infos["connectors"]["input"]["links"] = []
 
       
  1773                     connections = instance.connectionPointIn.getconnections()
 
       
  1774                     if connections:
 
       
  1775                         for link in connections:
 
       
  1776                             dic = {"refLocalId":link.getrefLocalId(),"points":link.getpoints(),"formalParameter":link.getformalParameter()}
 
       
  1777                             infos["connectors"]["input"]["links"].append(dic)
 
       
  1778                 if instance.connectionPointOut:
 
       
  1779                     infos["connectors"]["output"] = {"position" : instance.connectionPointOut.getrelPositionXY()}
 
       
  1780                 if instance.connectionPointOutAction:
 
       
  1781                     infos["connectors"]["action"] = {"position" : instance.connectionPointOutAction.getrelPositionXY()}
 
       
  1782             elif isinstance(instance, plcopen.sfcObjects_transition):
 
       
  1783                 infos["type"] = "transition"
 
       
  1784                 condition = instance.getconditionContent()
 
       
  1785                 priority = instance.getpriority()
 
       
  1786                 if priority == None:
 
       
  1787                     infos["priority"] = 0
 
       
  1788                 else:
 
       
  1789                     infos["priority"] = priority
 
       
  1790                 infos["condition_type"] = condition["type"]
 
       
  1791                 infos["connectors"] = {"input":{},"output":{}}
 
       
  1792                 infos["connectors"]["input"]["position"] = instance.connectionPointIn.getrelPositionXY()
 
       
  1793                 infos["connectors"]["input"]["links"] = []
 
       
  1794                 connections = instance.connectionPointIn.getconnections()
 
       
  1795                 if connections:
 
       
  1796                     for link in connections:
 
       
  1797                         dic = {"refLocalId":link.getrefLocalId(),"points":link.getpoints(),"formalParameter":link.getformalParameter()}
 
       
  1798                         infos["connectors"]["input"]["links"].append(dic)
 
       
  1799                 infos["connectors"]["output"]["position"] = instance.connectionPointOut.getrelPositionXY()
 
       
  1800                 if infos["condition_type"] == "connection":
 
       
  1801                     infos["connectors"]["connection"] = {}
 
       
  1802                     infos["connectors"]["connection"]["links"] = []
 
       
  1803                     connections = instance.getconnections()
 
       
  1804                     if connections:
 
       
  1805                         for link in connections:
 
       
  1806                             dic = {"refLocalId":link.getrefLocalId(),"points":link.getpoints(),"formalParameter":link.getformalParameter()}
 
       
  1807                             infos["connectors"]["connection"]["links"].append(dic)
 
       
  1808                     infos["condition"] = None
 
       
  1809                 else:
 
       
  1810                     infos["condition"] = condition["value"]
 
       
  1811             elif isinstance(instance, (plcopen.sfcObjects_selectionDivergence, plcopen.sfcObjects_simultaneousDivergence)):
 
       
  1812                 if isinstance(instance, plcopen.sfcObjects_selectionDivergence):
 
       
  1813                     infos["type"] = "selectionDivergence"
 
       
  1814                 else:
 
       
  1815                     infos["type"] = "simultaneousDivergence"
 
       
  1816                 infos["connectors"] = {"inputs":[],"outputs":[]}
 
       
  1817                 connector = {}
 
       
  1818                 connector["position"] = instance.connectionPointIn.getrelPositionXY()
 
       
  1819                 connector["links"] = []
 
       
  1820                 connections = instance.connectionPointIn.getconnections()
 
       
  1821                 if connections:
 
       
  1822                     for link in connections:
 
       
  1823                         dic = {"refLocalId":link.getrefLocalId(),"points":link.getpoints(),"formalParameter":link.getformalParameter()}
 
       
  1824                         connector["links"].append(dic)
 
       
  1825                 infos["connectors"]["inputs"].append(connector)
 
       
  1826                 for sequence in instance.getconnectionPointOut():
 
       
  1827                     connector = {}
 
       
  1828                     connector["position"] = sequence.getrelPositionXY()
 
       
  1829                     infos["connectors"]["outputs"].append(connector)
 
       
  1830             elif isinstance(instance, (plcopen.sfcObjects_selectionConvergence, plcopen.sfcObjects_simultaneousConvergence)):
 
       
  1831                 if isinstance(instance, plcopen.sfcObjects_selectionConvergence):
 
       
  1832                     infos["type"] = "selectionConvergence"
 
       
  1833                 else:
 
       
  1834                     infos["type"] = "simultaneousConvergence"
 
       
  1835                 infos["connectors"] = {"inputs":[],"outputs":[]}
 
       
  1836                 for sequence in instance.getconnectionPointIn():
 
       
  1837                     connector = {}
 
       
  1838                     connector["position"] = sequence.getrelPositionXY()
 
       
  1839                     connector["links"] = []
 
       
  1840                     connections = sequence.getconnections()
 
       
  1841                     if connections:
 
       
  1842                         for link in connections:
 
       
  1843                             dic = {"refLocalId":link.getrefLocalId(),"points":link.getpoints(),"formalParameter":link.getformalParameter()}
 
       
  1844                             connector["links"].append(dic)
 
       
  1845                     infos["connectors"]["inputs"].append(connector)
 
       
  1846                 connector = {}
 
       
  1847                 connector["position"] = instance.connectionPointOut.getrelPositionXY()
 
       
  1848                 infos["connectors"]["outputs"].append(connector)
 
       
  1849             elif isinstance(instance, plcopen.sfcObjects_jumpStep):
 
       
  1850                 infos["type"] = "jump"
 
       
  1851                 infos["target"] = instance.gettargetName()
 
       
  1852                 infos["connector"] = {}
 
       
  1853                 infos["connector"]["position"] = instance.connectionPointIn.getrelPositionXY()
 
       
  1854                 infos["connector"]["links"] = []
 
       
  1855                 connections = instance.connectionPointIn.getconnections()
 
       
  1856                 if connections:
 
       
  1857                     for link in connections:
 
       
  1858                         dic = {"refLocalId":link.getrefLocalId(),"points":link.getpoints(),"formalParameter":link.getformalParameter()}
 
       
  1859                         infos["connector"]["links"].append(dic)
 
       
  1860             elif isinstance(instance, plcopen.commonObjects_actionBlock):
 
       
  1861                 infos["type"] = "actionBlock"
 
       
  1862                 infos["actions"] = instance.getactions()
 
       
  1863                 infos["connector"] = {}
 
       
  1864                 infos["connector"]["position"] = instance.connectionPointIn.getrelPositionXY()
 
       
  1865                 infos["connector"]["links"] = []
 
       
  1866                 connections = instance.connectionPointIn.getconnections()
 
       
  1867                 if connections:
 
       
  1868                     for link in connections:
 
       
  1869                         dic = {"refLocalId":link.getrefLocalId(),"points":link.getpoints(),"formalParameter":link.getformalParameter()}
 
       
  1870                         infos["connector"]["links"].append(dic)
 
       
  1871             return infos
 
  1599             return infos
 
  1872         return None
 
  1600         return None
 
  1873     
  1601     
  1874     def ClearEditedElementExecutionOrder(self, tagname):
 
  1602     def ClearEditedElementExecutionOrder(self, tagname):
 
  1875         element = self.GetEditedElement(tagname)
 
  1603         element = self.GetEditedElement(tagname)
 
  2065                 elif param == "x":
 
  1793                 elif param == "x":
 
  2066                     variable.setx(value)
 
  1794                     variable.setx(value)
 
  2067                 elif param == "y":
 
  1795                 elif param == "y":
 
  2068                     variable.sety(value)
 
  1796                     variable.sety(value)
 
  2069                 elif param == "connectors":
 
  1797                 elif param == "connectors":
 
  2070                     if isinstance(variable, plcopen.fbdObjects_inVariable):
 
  1798                     if len(value["outputs"]) > 0:
 
  2071                         if value["output"].IsNegated():
 
  1799                         output = value["outputs"][0]
 
  2072                             variable.setnegated(True)
 
  1800                         if len(value["inputs"]) > 0:
 
  2073                         if value["output"].GetEdge() != "none":
 
  1801                             variable.setnegatedOut(output.IsNegated())
 
  2074                             variable.setedge(value["output"].GetEdge())
 
  1802                             variable.setedgeOut(output.GetEdge())
 
  2075                         position = value["output"].GetRelPosition()
 
  1803                         else:
 
       
  1804                             variable.setnegated(output.IsNegated())
 
       
  1805                             variable.setedge(output.GetEdge())
 
       
  1806                         position = output.GetRelPosition()
 
  2076                         variable.addconnectionPointOut()
 
  1807                         variable.addconnectionPointOut()
 
  2077                         variable.connectionPointOut.setrelPositionXY(position.x, position.y)
 
  1808                         variable.connectionPointOut.setrelPositionXY(position.x, position.y)
 
  2078                     elif isinstance(variable, plcopen.fbdObjects_outVariable):
 
  1809                     if len(value["inputs"]) > 0:
 
  2079                         if value["input"].IsNegated():
 
  1810                         input = value["inputs"][0]
 
  2080                             variable.setnegated(True)
 
  1811                         if len(value["outputs"]) > 0:
 
  2081                         if value["input"].GetEdge() != "none":
 
  1812                             variable.setnegatedIn(input.IsNegated())
 
  2082                             variable.setedge(value["input"].GetEdge())
 
  1813                             variable.setedgeIn(input.GetEdge())
 
  2083                         position = value["input"].GetRelPosition()
 
  1814                         else:
 
       
  1815                             variable.setnegated(input.IsNegated())
 
       
  1816                             variable.setedge(input.GetEdge())
 
       
  1817                         position = input.GetRelPosition()
 
  2084                         variable.addconnectionPointIn()
 
  1818                         variable.addconnectionPointIn()
 
  2085                         variable.connectionPointIn.setrelPositionXY(position.x, position.y)
 
  1819                         variable.connectionPointIn.setrelPositionXY(position.x, position.y)
 
  2086                         self.SetConnectionWires(variable.connectionPointIn, value["input"])
 
  1820                         self.SetConnectionWires(variable.connectionPointIn, input)
 
  2087                     elif isinstance(variable, plcopen.fbdObjects_inOutVariable):
 
       
  2088                         if value["input"].IsNegated():
 
       
  2089                             variable.setnegatedIn(True)
 
       
  2090                         if value["input"].GetEdge() != "none":
 
       
  2091                             variable.setedgeIn(value["input"].GetEdge())
 
       
  2092                         if value["output"].IsNegated():
 
       
  2093                             variable.setnegatedOut(True)
 
       
  2094                         if value["output"].GetEdge() != "none":
 
       
  2095                             variable.setedgeOut(value["output"].GetEdge())
 
       
  2096                         position = value["output"].GetRelPosition()
 
       
  2097                         variable.addconnectionPointOut()
 
       
  2098                         variable.connectionPointOut.setrelPositionXY(position.x, position.y)
 
       
  2099                         position = value["input"].GetRelPosition()
 
       
  2100                         variable.addconnectionPointIn()
 
       
  2101                         variable.connectionPointIn.setrelPositionXY(position.x, position.y)
 
       
  2102                         self.SetConnectionWires(variable.connectionPointIn, value["input"])
 
       
  2103 
  1821 
  2104     def AddEditedElementConnection(self, tagname, id, type):
 
  1822     def AddEditedElementConnection(self, tagname, id, type):
 
  2105         element = self.GetEditedElement(tagname)
 
  1823         element = self.GetEditedElement(tagname)
 
  2106         if element is not None:
 
  1824         if element is not None:
 
  2107             if type == CONNECTOR:
 
  1825             if type == CONNECTOR:
 
  2191                 elif param == "y":
 
  1909                 elif param == "y":
 
  2192                     powerrail.sety(value)
 
  1910                     powerrail.sety(value)
 
  2193                 elif param == "connectors":
 
  1911                 elif param == "connectors":
 
  2194                     if isinstance(powerrail, plcopen.ldObjects_leftPowerRail):
 
  1912                     if isinstance(powerrail, plcopen.ldObjects_leftPowerRail):
 
  2195                         powerrail.setconnectionPointOut([])
 
  1913                         powerrail.setconnectionPointOut([])
 
  2196                         for connector in value:
 
  1914                         for connector in value["outputs"]:
 
  2197                             position = connector.GetRelPosition()
 
  1915                             position = connector.GetRelPosition()
 
  2198                             connection = plcopen.leftPowerRail_connectionPointOut()
 
  1916                             connection = plcopen.leftPowerRail_connectionPointOut()
 
  2199                             connection.setrelPositionXY(position.x, position.y)
 
  1917                             connection.setrelPositionXY(position.x, position.y)
 
  2200                             powerrail.connectionPointOut.append(connection)
 
  1918                             powerrail.connectionPointOut.append(connection)
 
  2201                     elif isinstance(powerrail, plcopen.ldObjects_rightPowerRail):
 
  1919                     elif isinstance(powerrail, plcopen.ldObjects_rightPowerRail):
 
  2202                         powerrail.setconnectionPointIn([])
 
  1920                         powerrail.setconnectionPointIn([])
 
  2203                         for connector in value:
 
  1921                         for connector in value["inputs"]:
 
  2204                             position = connector.GetRelPosition()
 
  1922                             position = connector.GetRelPosition()
 
  2205                             connection = plcopen.connectionPointIn()
 
  1923                             connection = plcopen.connectionPointIn()
 
  2206                             connection.setrelPositionXY(position.x, position.y)
 
  1924                             connection.setrelPositionXY(position.x, position.y)
 
  2207                             self.SetConnectionWires(connection, connector)
 
  1925                             self.SetConnectionWires(connection, connector)
 
  2208                             powerrail.connectionPointIn.append(connection)
 
  1926                             powerrail.connectionPointIn.append(connection)
 
  2243                 elif param == "x":
 
  1961                 elif param == "x":
 
  2244                     contact.setx(value)
 
  1962                     contact.setx(value)
 
  2245                 elif param == "y":
 
  1963                 elif param == "y":
 
  2246                     contact.sety(value)
 
  1964                     contact.sety(value)
 
  2247                 elif param == "connectors":
 
  1965                 elif param == "connectors":
 
  2248                     input_connector = value["input"]
 
  1966                     input_connector = value["inputs"][0]
 
  2249                     position = input_connector.GetRelPosition()
 
  1967                     position = input_connector.GetRelPosition()
 
  2250                     contact.addconnectionPointIn()
 
  1968                     contact.addconnectionPointIn()
 
  2251                     contact.connectionPointIn.setrelPositionXY(position.x, position.y)
 
  1969                     contact.connectionPointIn.setrelPositionXY(position.x, position.y)
 
  2252                     self.SetConnectionWires(contact.connectionPointIn, input_connector)
 
  1970                     self.SetConnectionWires(contact.connectionPointIn, input_connector)
 
  2253                     output_connector = value["output"]
 
  1971                     output_connector = value["outputs"][0]
 
  2254                     position = output_connector.GetRelPosition()
 
  1972                     position = output_connector.GetRelPosition()
 
  2255                     contact.addconnectionPointOut()
 
  1973                     contact.addconnectionPointOut()
 
  2256                     contact.connectionPointOut.setrelPositionXY(position.x, position.y)
 
  1974                     contact.connectionPointOut.setrelPositionXY(position.x, position.y)
 
  2257 
  1975 
  2258     def AddEditedElementCoil(self, tagname, id):
 
  1976     def AddEditedElementCoil(self, tagname, id):
 
  2303                 elif param == "x":
 
  2021                 elif param == "x":
 
  2304                     coil.setx(value)
 
  2022                     coil.setx(value)
 
  2305                 elif param == "y":
 
  2023                 elif param == "y":
 
  2306                     coil.sety(value)
 
  2024                     coil.sety(value)
 
  2307                 elif param == "connectors":
 
  2025                 elif param == "connectors":
 
  2308                     input_connector = value["input"]
 
  2026                     input_connector = value["inputs"][0]
 
  2309                     position = input_connector.GetRelPosition()
 
  2027                     position = input_connector.GetRelPosition()
 
  2310                     coil.addconnectionPointIn()
 
  2028                     coil.addconnectionPointIn()
 
  2311                     coil.connectionPointIn.setrelPositionXY(position.x, position.y)
 
  2029                     coil.connectionPointIn.setrelPositionXY(position.x, position.y)
 
  2312                     self.SetConnectionWires(coil.connectionPointIn, input_connector)
 
  2030                     self.SetConnectionWires(coil.connectionPointIn, input_connector)
 
  2313                     output_connector = value["output"]
 
  2031                     output_connector = value["outputs"][0]
 
  2314                     position = output_connector.GetRelPosition()
 
  2032                     position = output_connector.GetRelPosition()
 
  2315                     coil.addconnectionPointOut()
 
  2033                     coil.addconnectionPointOut()
 
  2316                     coil.connectionPointOut.setrelPositionXY(position.x, position.y)
 
  2034                     coil.connectionPointOut.setrelPositionXY(position.x, position.y)
 
  2317 
  2035 
  2318     def AddEditedElementStep(self, tagname, id):
 
  2036     def AddEditedElementStep(self, tagname, id):
 
  2340                 elif param == "x":
 
  2058                 elif param == "x":
 
  2341                     step.setx(value)
 
  2059                     step.setx(value)
 
  2342                 elif param == "y":
 
  2060                 elif param == "y":
 
  2343                     step.sety(value)
 
  2061                     step.sety(value)
 
  2344                 elif param == "connectors":
 
  2062                 elif param == "connectors":
 
  2345                     input_connector = value["input"]
 
  2063                     if len(value["inputs"]) > 0:
 
  2346                     if input_connector:
 
  2064                         input_connector = value["inputs"][0]
 
  2347                         position = input_connector.GetRelPosition()
 
  2065                         position = input_connector.GetRelPosition()
 
  2348                         step.addconnectionPointIn()
 
  2066                         step.addconnectionPointIn()
 
  2349                         step.connectionPointIn.setrelPositionXY(position.x, position.y)
 
  2067                         step.connectionPointIn.setrelPositionXY(position.x, position.y)
 
  2350                         self.SetConnectionWires(step.connectionPointIn, input_connector)
 
  2068                         self.SetConnectionWires(step.connectionPointIn, input_connector)
 
  2351                     else:
 
  2069                     else:
 
  2352                         step.deleteconnectionPointIn()
 
  2070                         step.deleteconnectionPointIn()
 
  2353                     output_connector = value["output"]
 
  2071                     if len(value["outputs"]) > 0:
 
  2354                     if output_connector:
 
  2072                         output_connector = value["outputs"][0]
 
  2355                         position = output_connector.GetRelPosition()
 
  2073                         position = output_connector.GetRelPosition()
 
  2356                         step.addconnectionPointOut()
 
  2074                         step.addconnectionPointOut()
 
  2357                         step.connectionPointOut.setrelPositionXY(position.x, position.y)
 
  2075                         step.connectionPointOut.setrelPositionXY(position.x, position.y)
 
  2358                     else:
 
  2076                     else:
 
  2359                         step.deleteconnectionPointOut()
 
  2077                         step.deleteconnectionPointOut()
 
  2360                     action_connector = value["action"]
 
  2078                 elif param == "action":
 
  2361                     if action_connector:
 
  2079                     if value:
 
  2362                         position = action_connector.GetRelPosition()
 
  2080                         position = value.GetRelPosition()
 
  2363                         step.addconnectionPointOutAction()
 
  2081                         step.addconnectionPointOutAction()
 
  2364                         step.connectionPointOutAction.setrelPositionXY(position.x, position.y)
 
  2082                         step.connectionPointOutAction.setrelPositionXY(position.x, position.y)
 
  2365                     else:
 
  2083                     else:
 
  2366                         step.deleteconnectionPointOutAction()
 
  2084                         step.deleteconnectionPointOutAction()
 
  2367     
  2085     
  2393                     if value != 0:
 
  2111                     if value != 0:
 
  2394                         transition.setpriority(value)
 
  2112                         transition.setpriority(value)
 
  2395                     else:
 
  2113                     else:
 
  2396                         transition.setpriority(None)
 
  2114                         transition.setpriority(None)
 
  2397                 elif param == "connectors":
 
  2115                 elif param == "connectors":
 
  2398                     input_connector = value["input"]
 
  2116                     input_connector = value["inputs"][0]
 
  2399                     position = input_connector.GetRelPosition()
 
  2117                     position = input_connector.GetRelPosition()
 
  2400                     transition.addconnectionPointIn()
 
  2118                     transition.addconnectionPointIn()
 
  2401                     transition.connectionPointIn.setrelPositionXY(position.x, position.y)
 
  2119                     transition.connectionPointIn.setrelPositionXY(position.x, position.y)
 
  2402                     self.SetConnectionWires(transition.connectionPointIn, input_connector)
 
  2120                     self.SetConnectionWires(transition.connectionPointIn, input_connector)
 
  2403                     output_connector = value["output"]
 
  2121                     output_connector = value["outputs"][0]
 
  2404                     position = output_connector.GetRelPosition()
 
  2122                     position = output_connector.GetRelPosition()
 
  2405                     transition.addconnectionPointOut()
 
  2123                     transition.addconnectionPointOut()
 
  2406                     transition.connectionPointOut.setrelPositionXY(position.x, position.y)
 
  2124                     transition.connectionPointOut.setrelPositionXY(position.x, position.y)
 
  2407                     if infos.get("type", None) == "connection":
 
  2125                 elif infos.get("type", None) == "connection" and param == "connection" and value:
 
  2408                         transition.setconditionContent("connection", None)
 
  2126                     transition.setconditionContent("connection", None)
 
  2409                         connection_connector = value["connection"]
 
  2127                     self.SetConnectionWires(transition, value)
 
  2410                         self.SetConnectionWires(transition, connection_connector)
 
       
  2411     
  2128     
  2412     def AddEditedElementDivergence(self, tagname, id, type):
 
  2129     def AddEditedElementDivergence(self, tagname, id, type):
 
  2413         element = self.GetEditedElement(tagname)
 
  2130         element = self.GetEditedElement(tagname)
 
  2414         if element is not None:
 
  2131         if element is not None:
 
  2415             if type == SELECTION_DIVERGENCE:
 
  2132             if type == SELECTION_DIVERGENCE:
plcopeneditor_history