Mercurial Mercurial > plcopeneditor_history / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
plcopen/plcopen.py
changeset 58 39cd981ff242
parent 47 2b2f8d88e6d3
child 63 04a02b4b2a57
equal deleted inserted replaced
57:9bf197698af0 58:39cd981ff242 
     2 # -*- coding: utf-8 -*-
 
     2 # -*- coding: utf-8 -*-
 
     3 
     3 
     4 #This file is part of PLCOpenEditor, a library implementing an IEC 61131-3 editor
 
     4 #This file is part of PLCOpenEditor, a library implementing an IEC 61131-3 editor
 
     5 #based on the plcopen standard. 
     5 #based on the plcopen standard. 
     6 #
 
     6 #
 
     7 #Copyright (C): Edouard TISSERANT and Laurent BESSARD
 
     7 #Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD
 
     8 #
 
     8 #
 
     9 #See COPYING file for copyrights details.
 
     9 #See COPYING file for copyrights details.
 
    10 #
 
    10 #
 
    11 #This library is free software; you can redistribute it and/or
 
    11 #This library is free software; you can redistribute it and/or
 
    12 #modify it under the terms of the GNU General Public
 
    12 #modify it under the terms of the GNU General Public
 
    14 #version 2.1 of the License, or (at your option) any later version.
 
    14 #version 2.1 of the License, or (at your option) any later version.
 
    15 #
 
    15 #
 
    16 #This library is distributed in the hope that it will be useful,
 
    16 #This library is distributed in the hope that it will be useful,
 
    17 #but WITHOUT ANY WARRANTY; without even the implied warranty of
 
    17 #but WITHOUT ANY WARRANTY; without even the implied warranty of
 
    18 #MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
    18 #MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
    19 #Lesser General Public License for more details.
 
    19 #General Public License for more details.
 
    20 #
 
    20 #
 
    21 #You should have received a copy of the GNU General Public
 
    21 #You should have received a copy of the GNU General Public
 
    22 #License along with this library; if not, write to the Free Software
 
    22 #License along with this library; if not, write to the Free Software
 
    23 #Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
    23 #Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
    24 
    24 
   103             text += ind1 + "</%s>\n"%name
 
   103             text += ind1 + "</%s>\n"%name
 
   104             return text
 
   104             return text
 
   105         else:
 
   105         else:
 
   106             return ind1 + "<%s>%s</%s>\n"%(name, self.text, name)
 
   106             return ind1 + "<%s>%s</%s>\n"%(name, self.text, name)
 
   107     setattr(cls, "generateXMLText", generateXMLText)
 
   107     setattr(cls, "generateXMLText", generateXMLText)
 
       
   108     
       
   109     def updateElementName(self, old_name, new_name):
 
       
   110         index = self.text.find(old_name)
 
       
   111         while index != -1:
 
       
   112             if index > 0 and (self.text[index - 1].isalnum() or self.text[index - 1] == "_"):
 
       
   113                 index = self.text.find(old_name, index + len(old_name))
 
       
   114             elif index < len(self.text) - len(old_name) and (self.text[index + len(old_name)].isalnum() or self.text[index + len(old_name)] == "_"):
 
       
   115                 index = self.text.find(old_name, index + len(old_name))
 
       
   116             else:
 
       
   117                 self.text = self.text[:index] + new_name + self.text[index + len(old_name):]
 
       
   118                 index = self.text.find(old_name, index + len(new_name))
 
       
   119     setattr(cls, "updateElementName", updateElementName)
 
   108     
   120     
   109 if "project" in PLCOpenClasses:
 
   121 if "project" in PLCOpenClasses:
 
   110     cls = PLCOpenClasses["project"]
 
   122     cls = PLCOpenClasses["project"]
 
   111     cls.singleLineAttributes = False
 
   123     cls.singleLineAttributes = False
 
   112     
   124     
   231                     break
 
   243                     break
 
   232             if not found:
 
   244             if not found:
 
   233                 raise ValueError, "\"%s\" resource doesn't exist in \"%s\" configuration !!!"%(name, config_name)
 
   245                 raise ValueError, "\"%s\" resource doesn't exist in \"%s\" configuration !!!"%(name, config_name)
 
   234     setattr(cls, "removeConfigurationResource", removeConfigurationResource)
 
   246     setattr(cls, "removeConfigurationResource", removeConfigurationResource)
 
   235 
   247 
       
   248     def updateElementName(self, old_name, new_name):
 
       
   249         for pou in self.types.getPouElements():
 
       
   250             pou.updateElementName(old_name, new_name)
 
       
   251         for configuration in self.instances.configurations.getConfiguration():
 
       
   252             configuration.updateElementName(old_name, new_name)
 
       
   253     setattr(cls, "updateElementName", updateElementName)
 
       
   254 
   236 PLCOpenClasses["project_fileHeader"].singleLineAttributes = False
 
   255 PLCOpenClasses["project_fileHeader"].singleLineAttributes = False
 
       
   256 
       
   257 if "configurations_configuration" in PLCOpenClasses:
 
       
   258     cls = PLCOpenClasses["configurations_configuration"]
 
       
   259     
       
   260     def updateElementName(self, old_name, new_name):
 
       
   261         for resource in self.getResource():
 
       
   262             resource.updateElementName(old_name, new_name)
 
       
   263     setattr(cls, "updateElementName", updateElementName)
 
       
   264 
       
   265 
       
   266 if "configuration_resource" in PLCOpenClasses:
 
       
   267     cls = PLCOpenClasses["configuration_resource"]
 
       
   268     
       
   269     def updateElementName(self, old_name, new_name):
 
       
   270         for instance in self.getPouInstance():
 
       
   271             instance.updateElementName(old_name, new_name)
 
       
   272         for task in self.getTask():
 
       
   273             task.updateElementName(old_name, new_name)
 
       
   274     setattr(cls, "updateElementName", updateElementName)
 
       
   275 
       
   276 if "resource_task" in PLCOpenClasses:
 
       
   277     cls = PLCOpenClasses["resource_task"]
 
       
   278     
       
   279     def updateElementName(self, old_name, new_name):
 
       
   280         if self.single == old_name:
 
       
   281             self.single = new_name
 
       
   282         for instance in self.getPouInstance():
 
       
   283             instance.updateElementName(old_name, new_name)
 
       
   284     setattr(cls, "updateElementName", updateElementName)
 
       
   285 
       
   286 if "pouInstance" in PLCOpenClasses:
 
       
   287     cls = PLCOpenClasses["pouInstance"]
 
       
   288     
       
   289     def updateElementName(self, old_name, new_name):
 
       
   290         if self.type == old_name:
 
       
   291             self.type = new_name
 
       
   292     setattr(cls, "updateElementName", updateElementName)
 
   237 
   293 
   238 if "project_types" in PLCOpenClasses:
 
   294 if "project_types" in PLCOpenClasses:
 
   239     cls = PLCOpenClasses["project_types"]
 
   295     cls = PLCOpenClasses["project_types"]
 
   240 
   296 
   241     def getPouElements(self):
 
   297     def getPouElements(self):
 
   423                 i += 1
 
   479                 i += 1
 
   424             if not removed:
 
   480             if not removed:
 
   425                 raise ValueError, "Action with name %s doesn't exists!"%name
 
   481                 raise ValueError, "Action with name %s doesn't exists!"%name
 
   426     setattr(cls, "removeAction", removeAction)
 
   482     setattr(cls, "removeAction", removeAction)
 
   427 
   483 
       
   484     def updateElementName(self, old_name, new_name):
 
       
   485         self.body.updateElementName(old_name, new_name)
 
       
   486         for action in self.getActionList():
 
       
   487             action.updateElementName(old_name, new_name)
 
       
   488         for transition in self.getTransitionList():
 
       
   489             transition.updateElementName(old_name, new_name)
 
       
   490     setattr(cls, "updateElementName", updateElementName)
 
       
   491 
   428 if "transitions_transition" in PLCOpenClasses:
 
   492 if "transitions_transition" in PLCOpenClasses:
 
   429     cls = PLCOpenClasses["transitions_transition"]
 
   493     cls = PLCOpenClasses["transitions_transition"]
 
   430 
   494 
   431     setattr(cls, "setBodyType", setBodyType)
 
   495     setattr(cls, "setBodyType", setBodyType)
 
   432     setattr(cls, "getBodyType", getBodyType)
 
   496     setattr(cls, "getBodyType", getBodyType)
 
   437     setattr(cls, "getInstanceByName", getInstanceByName)
 
   501     setattr(cls, "getInstanceByName", getInstanceByName)
 
   438     setattr(cls, "removeInstance", removeInstance)
 
   502     setattr(cls, "removeInstance", removeInstance)
 
   439     setattr(cls, "setText", setText)
 
   503     setattr(cls, "setText", setText)
 
   440     setattr(cls, "getText", getText)
 
   504     setattr(cls, "getText", getText)
 
   441 
   505 
       
   506     def updateElementName(self, old_name, new_name):
 
       
   507         self.body.updateElementName(old_name, new_name)
 
       
   508     setattr(cls, "updateElementName", updateElementName)
 
       
   509 
   442 if "actions_action" in PLCOpenClasses:
 
   510 if "actions_action" in PLCOpenClasses:
 
   443     cls = PLCOpenClasses["actions_action"]
 
   511     cls = PLCOpenClasses["actions_action"]
 
   444 
   512 
   445     setattr(cls, "setBodyType", setBodyType)
 
   513     setattr(cls, "setBodyType", setBodyType)
 
   446     setattr(cls, "getBodyType", getBodyType)
 
   514     setattr(cls, "getBodyType", getBodyType)
 
   450     setattr(cls, "getRandomInstance", getRandomInstance)
 
   518     setattr(cls, "getRandomInstance", getRandomInstance)
 
   451     setattr(cls, "getInstanceByName", getInstanceByName)
 
   519     setattr(cls, "getInstanceByName", getInstanceByName)
 
   452     setattr(cls, "removeInstance", removeInstance)
 
   520     setattr(cls, "removeInstance", removeInstance)
 
   453     setattr(cls, "setText", setText)
 
   521     setattr(cls, "setText", setText)
 
   454     setattr(cls, "getText", getText)
 
   522     setattr(cls, "getText", getText)
 
       
   523 
       
   524     def updateElementName(self, old_name, new_name):
 
       
   525         self.body.updateElementName(old_name, new_name)
 
       
   526     setattr(cls, "updateElementName", updateElementName)
 
   455 
   527 
   456 if "body" in PLCOpenClasses:
 
   528 if "body" in PLCOpenClasses:
 
   457     cls = PLCOpenClasses["body"]
 
   529     cls = PLCOpenClasses["body"]
 
   458     
   530     
   459     def appendContentInstance(self, name, instance):
 
   531     def appendContentInstance(self, name, instance):
 
   529         if self.content["name"] in ["IL","ST"]:
 
   601         if self.content["name"] in ["IL","ST"]:
 
   530             return self.content["value"].getText()
 
   602             return self.content["value"].getText()
 
   531         else:
 
   603         else:
 
   532             raise TypeError, "%s body don't have text!"%self.content["name"]
 
   604             raise TypeError, "%s body don't have text!"%self.content["name"]
 
   533     setattr(cls, "getText", getText)
 
   605     setattr(cls, "getText", getText)
 
       
   606     
       
   607     def updateElementName(self, old_name, new_name):
 
       
   608         if self.content["name"] in ["IL", "ST"]:
 
       
   609             self.content["value"].updateElementName(old_name, new_name)
 
       
   610         else:
 
       
   611             for element in self.content["value"].getContent():
 
       
   612                 element["value"].updateElementName(old_name, new_name)
 
       
   613     setattr(cls, "updateElementName", updateElementName)
 
   534 
   614 
   535 def getX(self):
 
   615 def getX(self):
 
   536     return self.position.getX()
 
   616     return self.position.getX()
 
   537 
   617 
   538 def getY(self):
 
   618 def getY(self):
 
   556     setattr(cls, "setContentText", setContentText)
 
   636     setattr(cls, "setContentText", setContentText)
 
   557         
   637         
   558     def getContentText(self):
 
   638     def getContentText(self):
 
   559         return self.content.getText()
 
   639         return self.content.getText()
 
   560     setattr(cls, "getContentText", getContentText)
 
   640     setattr(cls, "getContentText", getContentText)
 
       
   641     
       
   642     def updateElementName(self, old_name, new_name):
 
       
   643         self.content.updateElementName(old_name, new_name)
 
       
   644     setattr(cls, "updateElementName", updateElementName)
 
   561 
   645 
   562 if "block" in PLCOpenClasses:
 
   646 if "block" in PLCOpenClasses:
 
   563     cls = PLCOpenClasses["block"]
 
   647     cls = PLCOpenClasses["block"]
 
   564     setattr(cls, "getX", getX)
 
   648     setattr(cls, "getX", getX)
 
   565     setattr(cls, "getY", getY)
 
   649     setattr(cls, "getY", getY)
 
   566     setattr(cls, "setX", setX)
 
   650     setattr(cls, "setX", setX)
 
   567     setattr(cls, "setY", setY)
 
   651     setattr(cls, "setY", setY)
 
       
   652 
       
   653     def updateElementName(self, old_name, new_name):
 
       
   654         if self.typeName == old_name:
 
       
   655             self.typeName = new_name
 
       
   656     setattr(cls, "updateElementName", updateElementName)
 
   568 
   657 
   569 if "inputVariables_variable" in PLCOpenClasses:
 
   658 if "inputVariables_variable" in PLCOpenClasses:
 
   570     cls = PLCOpenClasses["inputVariables_variable"]
 
   659     cls = PLCOpenClasses["inputVariables_variable"]
 
   571 
   660 
   572     def setConnectorEdge(self, edge):
 
   661     def setConnectorEdge(self, edge):
 
   601     setattr(cls, "getX", getX)
 
   690     setattr(cls, "getX", getX)
 
   602     setattr(cls, "getY", getY)
 
   691     setattr(cls, "getY", getY)
 
   603     setattr(cls, "setX", setX)
 
   692     setattr(cls, "setX", setX)
 
   604     setattr(cls, "setY", setY)
 
   693     setattr(cls, "setY", setY)
 
   605 
   694 
       
   695     def updateElementName(self, old_name, new_name):
 
       
   696         pass
 
       
   697     setattr(cls, "updateElementName", updateElementName)
 
       
   698 
   606 if "contact" in PLCOpenClasses:
 
   699 if "contact" in PLCOpenClasses:
 
   607     cls = PLCOpenClasses["contact"]
 
   700     cls = PLCOpenClasses["contact"]
 
   608     setattr(cls, "getX", getX)
 
   701     setattr(cls, "getX", getX)
 
   609     setattr(cls, "getY", getY)
 
   702     setattr(cls, "getY", getY)
 
   610     setattr(cls, "setX", setX)
 
   703     setattr(cls, "setX", setX)
 
   620         if self.edge:
 
   713         if self.edge:
 
   621             return self.edge.getValue()
 
   714             return self.edge.getValue()
 
   622         return None
 
   715         return None
 
   623     setattr(cls, "getContactEdge", getContactEdge)
 
   716     setattr(cls, "getContactEdge", getContactEdge)
 
   624 
   717 
       
   718     def updateElementName(self, old_name, new_name):
 
       
   719         if self.variable == old_name:
 
       
   720             self.variable = new_name
 
       
   721     setattr(cls, "updateElementName", updateElementName)
 
       
   722 
   625 if "coil" in PLCOpenClasses:
 
   723 if "coil" in PLCOpenClasses:
 
   626     cls = PLCOpenClasses["coil"]
 
   724     cls = PLCOpenClasses["coil"]
 
   627     setattr(cls, "getX", getX)
 
   725     setattr(cls, "getX", getX)
 
   628     setattr(cls, "getY", getY)
 
   726     setattr(cls, "getY", getY)
 
   629     setattr(cls, "setX", setX)
 
   727     setattr(cls, "setX", setX)
 
   639         if self.storage:
 
   737         if self.storage:
 
   640             return self.storage.getValue()
 
   738             return self.storage.getValue()
 
   641         return None
 
   739         return None
 
   642     setattr(cls, "getCoilStorage", getCoilStorage)
 
   740     setattr(cls, "getCoilStorage", getCoilStorage)
 
   643 
   741 
       
   742     def updateElementName(self, old_name, new_name):
 
       
   743         if self.variable == old_name:
 
       
   744             self.variable = new_name
 
       
   745     setattr(cls, "updateElementName", updateElementName)
 
       
   746 
   644 if "rightPowerRail" in PLCOpenClasses:
 
   747 if "rightPowerRail" in PLCOpenClasses:
 
   645     cls = PLCOpenClasses["rightPowerRail"]
 
   748     cls = PLCOpenClasses["rightPowerRail"]
 
   646     setattr(cls, "getX", getX)
 
   749     setattr(cls, "getX", getX)
 
   647     setattr(cls, "getY", getY)
 
   750     setattr(cls, "getY", getY)
 
   648     setattr(cls, "setX", setX)
 
   751     setattr(cls, "setX", setX)
 
   649     setattr(cls, "setY", setY)
 
   752     setattr(cls, "setY", setY)
 
       
   753     
       
   754     def updateElementName(self, old_name, new_name):
 
       
   755         pass
 
       
   756     setattr(cls, "updateElementName", updateElementName)
 
   650 
   757 
   651 if "step" in PLCOpenClasses:
 
   758 if "step" in PLCOpenClasses:
 
   652     cls = PLCOpenClasses["step"]
 
   759     cls = PLCOpenClasses["step"]
 
   653     setattr(cls, "getX", getX)
 
   760     setattr(cls, "getX", getX)
 
   654     setattr(cls, "getY", getY)
 
   761     setattr(cls, "getY", getY)
 
   655     setattr(cls, "setX", setX)
 
   762     setattr(cls, "setX", setX)
 
   656     setattr(cls, "setY", setY)
 
   763     setattr(cls, "setY", setY)
 
       
   764 
       
   765     def updateElementName(self, old_name, new_name):
 
       
   766         pass
 
       
   767     setattr(cls, "updateElementName", updateElementName)
 
   657 
   768 
   658 if "transition" in PLCOpenClasses:
 
   769 if "transition" in PLCOpenClasses:
 
   659     cls = PLCOpenClasses["transition"]
 
   770     cls = PLCOpenClasses["transition"]
 
   660     setattr(cls, "getX", getX)
 
   771     setattr(cls, "getX", getX)
 
   661     setattr(cls, "getY", getY)
 
   772     setattr(cls, "getY", getY)
 
   685                 values["value"] = content["value"].getText()
 
   796                 values["value"] = content["value"].getText()
 
   686             return values
 
   797             return values
 
   687         return ""
 
   798         return ""
 
   688     setattr(cls, "getConditionContent", getConditionContent)
 
   799     setattr(cls, "getConditionContent", getConditionContent)
 
   689 
   800 
       
   801     def updateElementName(self, old_name, new_name):
 
       
   802         if self.condition:
 
       
   803             content = self.condition.getContent()
 
       
   804             if content["name"] == "reference":
 
       
   805                 if content["value"].getName() == old_name:
 
       
   806                     content["value"].setName(new_name)
 
       
   807             elif content["name"] == "inline":
 
       
   808                 content["value"].updateElementName(old_name, new_name)
 
       
   809     setattr(cls, "updateElementName", updateElementName)
 
       
   810 
   690 if "selectionDivergence" in PLCOpenClasses:
 
   811 if "selectionDivergence" in PLCOpenClasses:
 
   691     cls = PLCOpenClasses["selectionDivergence"]
 
   812     cls = PLCOpenClasses["selectionDivergence"]
 
   692     setattr(cls, "getX", getX)
 
   813     setattr(cls, "getX", getX)
 
   693     setattr(cls, "getY", getY)
 
   814     setattr(cls, "getY", getY)
 
   694     setattr(cls, "setX", setX)
 
   815     setattr(cls, "setX", setX)
 
   695     setattr(cls, "setY", setY)
 
   816     setattr(cls, "setY", setY)
 
   696 
   817 
       
   818     def updateElementName(self, old_name, new_name):
 
       
   819         pass
 
       
   820     setattr(cls, "updateElementName", updateElementName)
 
       
   821 
   697 if "selectionConvergence" in PLCOpenClasses:
 
   822 if "selectionConvergence" in PLCOpenClasses:
 
   698     cls = PLCOpenClasses["selectionConvergence"]
 
   823     cls = PLCOpenClasses["selectionConvergence"]
 
   699     setattr(cls, "getX", getX)
 
   824     setattr(cls, "getX", getX)
 
   700     setattr(cls, "getY", getY)
 
   825     setattr(cls, "getY", getY)
 
   701     setattr(cls, "setX", setX)
 
   826     setattr(cls, "setX", setX)
 
   702     setattr(cls, "setY", setY)
 
   827     setattr(cls, "setY", setY)
 
   703     
   828     
       
   829     def updateElementName(self, old_name, new_name):
 
       
   830         pass
 
       
   831     setattr(cls, "updateElementName", updateElementName)
 
       
   832     
   704 if "simultaneousDivergence" in PLCOpenClasses:
 
   833 if "simultaneousDivergence" in PLCOpenClasses:
 
   705     cls = PLCOpenClasses["simultaneousDivergence"]
 
   834     cls = PLCOpenClasses["simultaneousDivergence"]
 
   706     setattr(cls, "getX", getX)
 
   835     setattr(cls, "getX", getX)
 
   707     setattr(cls, "getY", getY)
 
   836     setattr(cls, "getY", getY)
 
   708     setattr(cls, "setX", setX)
 
   837     setattr(cls, "setX", setX)
 
   709     setattr(cls, "setY", setY)
 
   838     setattr(cls, "setY", setY)
 
   710     
   839     
       
   840     def updateElementName(self, old_name, new_name):
 
       
   841         pass
 
       
   842     setattr(cls, "updateElementName", updateElementName)
 
       
   843     
   711 if "simultaneousDivergence" in PLCOpenClasses:
 
   844 if "simultaneousDivergence" in PLCOpenClasses:
 
   712     cls = PLCOpenClasses["simultaneousConvergence"]
 
   845     cls = PLCOpenClasses["simultaneousConvergence"]
 
   713     setattr(cls, "getX", getX)
 
   846     setattr(cls, "getX", getX)
 
   714     setattr(cls, "getY", getY)
 
   847     setattr(cls, "getY", getY)
 
   715     setattr(cls, "setX", setX)
 
   848     setattr(cls, "setX", setX)
 
   716     setattr(cls, "setY", setY)
 
   849     setattr(cls, "setY", setY)
 
       
   850     
       
   851     def updateElementName(self, old_name, new_name):
 
       
   852         pass
 
       
   853     setattr(cls, "updateElementName", updateElementName)
 
   717 
   854 
   718 if "jumpStep" in PLCOpenClasses:
 
   855 if "jumpStep" in PLCOpenClasses:
 
   719     cls = PLCOpenClasses["jumpStep"]
 
   856     cls = PLCOpenClasses["jumpStep"]
 
   720     setattr(cls, "getX", getX)
 
   857     setattr(cls, "getX", getX)
 
   721     setattr(cls, "getY", getY)
 
   858     setattr(cls, "getY", getY)
 
   722     setattr(cls, "setX", setX)
 
   859     setattr(cls, "setX", setX)
 
   723     setattr(cls, "setY", setY)
 
   860     setattr(cls, "setY", setY)
 
       
   861     
       
   862     def updateElementName(self, old_name, new_name):
 
       
   863         pass
 
       
   864     setattr(cls, "updateElementName", updateElementName)
 
       
   865 
   724 
   866 
   725 if "actionBlock_action" in PLCOpenClasses:
 
   867 if "actionBlock_action" in PLCOpenClasses:
 
   726     cls = PLCOpenClasses["actionBlock_action"]
 
   868     cls = PLCOpenClasses["actionBlock_action"]
 
   727     
   869     
   728     def setQualifierValue(self, value):
 
   870     def setQualifierValue(self, value):
 
   756     def getInlineContent(self):
 
   898     def getInlineContent(self):
 
   757         if self.inline:
 
   899         if self.inline:
 
   758             return self.inline.getText()
 
   900             return self.inline.getText()
 
   759         return None
 
   901         return None
 
   760     setattr(cls, "getInlineContent", getInlineContent)
 
   902     setattr(cls, "getInlineContent", getInlineContent)
 
       
   903 
       
   904     def updateElementName(self, old_name, new_name):
 
       
   905         if self.reference and self.reference.getName() == old_name:
 
       
   906             self.reference.setName(new_name)
 
       
   907         if self.inline:
 
       
   908             self.inline.updateElementName(old_name, new_name)
 
       
   909     setattr(cls, "updateElementName", updateElementName)
 
   761 
   910 
   762 if "actionBlock" in PLCOpenClasses:
 
   911 if "actionBlock" in PLCOpenClasses:
 
   763     cls = PLCOpenClasses["actionBlock"]
 
   912     cls = PLCOpenClasses["actionBlock"]
 
   764     setattr(cls, "getX", getX)
 
   913     setattr(cls, "getX", getX)
 
   765     setattr(cls, "getY", getY)
 
   914     setattr(cls, "getY", getY)
 
   804                 params["indicator"] = indicator
 
   953                 params["indicator"] = indicator
 
   805             actions.append(params)
 
   954             actions.append(params)
 
   806         return actions
 
   955         return actions
 
   807     setattr(cls, "getActions", getActions)
 
   956     setattr(cls, "getActions", getActions)
 
   808 
   957 
       
   958     def updateElementName(self, old_name, new_name):
 
       
   959         for action in self.action:
 
       
   960             action.updateElementName(old_name, new_name)
 
       
   961     setattr(cls, "updateElementName", updateElementName)
 
       
   962 
   809 if "inVariable" in PLCOpenClasses:
 
   963 if "inVariable" in PLCOpenClasses:
 
   810     cls = PLCOpenClasses["inVariable"]
 
   964     cls = PLCOpenClasses["inVariable"]
 
   811     setattr(cls, "getX", getX)
 
   965     setattr(cls, "getX", getX)
 
   812     setattr(cls, "getY", getY)
 
   966     setattr(cls, "getY", getY)
 
   813     setattr(cls, "setX", setX)
 
   967     setattr(cls, "setX", setX)
 
   822     def getConnectorEdge(self):
 
   976     def getConnectorEdge(self):
 
   823         if self.edge:
 
   977         if self.edge:
 
   824             return self.edge.getValue()
 
   978             return self.edge.getValue()
 
   825         return None
 
   979         return None
 
   826     setattr(cls, "getConnectorEdge", getConnectorEdge)
 
   980     setattr(cls, "getConnectorEdge", getConnectorEdge)
 
       
   981     
       
   982     def updateElementName(self, old_name, new_name):
 
       
   983         if self.expression == old_name:
 
       
   984             self.expression = new_name
 
       
   985     setattr(cls, "updateElementName", updateElementName)
 
   827 
   986 
   828 if "outVariable" in PLCOpenClasses:
 
   987 if "outVariable" in PLCOpenClasses:
 
   829     cls = PLCOpenClasses["outVariable"]
 
   988     cls = PLCOpenClasses["outVariable"]
 
   830     setattr(cls, "getX", getX)
 
   989     setattr(cls, "getX", getX)
 
   831     setattr(cls, "getY", getY)
 
   990     setattr(cls, "getY", getY)
 
   842         if self.edge:
 
  1001         if self.edge:
 
   843             return self.edge.getValue()
 
  1002             return self.edge.getValue()
 
   844         return None
 
  1003         return None
 
   845     setattr(cls, "getConnectorEdge", getConnectorEdge)
 
  1004     setattr(cls, "getConnectorEdge", getConnectorEdge)
 
   846 
  1005 
       
  1006     def updateElementName(self, old_name, new_name):
 
       
  1007         if self.expression == old_name:
 
       
  1008             self.expression = new_name
 
       
  1009     setattr(cls, "updateElementName", updateElementName)
 
       
  1010 
   847 if "inOutVariable" in PLCOpenClasses:
 
  1011 if "inOutVariable" in PLCOpenClasses:
 
   848     cls = PLCOpenClasses["inOutVariable"]
 
  1012     cls = PLCOpenClasses["inOutVariable"]
 
   849     setattr(cls, "getX", getX)
 
  1013     setattr(cls, "getX", getX)
 
   850     setattr(cls, "getY", getY)
 
  1014     setattr(cls, "getY", getY)
 
   851     setattr(cls, "setX", setX)
 
  1015     setattr(cls, "setX", setX)
 
   873         if self.edgeOut:
 
  1037         if self.edgeOut:
 
   874             return self.edgeOut.getValue()
 
  1038             return self.edgeOut.getValue()
 
   875         return None
 
  1039         return None
 
   876     setattr(cls, "getOutputEdge", getOutputEdge)
 
  1040     setattr(cls, "getOutputEdge", getOutputEdge)
 
   877 
  1041 
       
  1042     def updateElementName(self, old_name, new_name):
 
       
  1043         if self.expression == old_name:
 
       
  1044             self.expression = new_name
 
       
  1045     setattr(cls, "updateElementName", updateElementName)
 
       
  1046 
   878 if "continuation" in PLCOpenClasses:
 
  1047 if "continuation" in PLCOpenClasses:
 
   879     cls = PLCOpenClasses["continuation"]
 
  1048     cls = PLCOpenClasses["continuation"]
 
   880     setattr(cls, "getX", getX)
 
  1049     setattr(cls, "getX", getX)
 
   881     setattr(cls, "getY", getY)
 
  1050     setattr(cls, "getY", getY)
 
   882     setattr(cls, "setX", setX)
 
  1051     setattr(cls, "setX", setX)
 
   883     setattr(cls, "setY", setY)
 
  1052     setattr(cls, "setY", setY)
 
       
  1053     
       
  1054     def updateElementName(self, old_name, new_name):
 
       
  1055         pass
 
       
  1056     setattr(cls, "updateElementName", updateElementName)
 
   884 
  1057 
   885 if "connector" in PLCOpenClasses:
 
  1058 if "connector" in PLCOpenClasses:
 
   886     cls = PLCOpenClasses["connector"]
 
  1059     cls = PLCOpenClasses["connector"]
 
   887     setattr(cls, "getX", getX)
 
  1060     setattr(cls, "getX", getX)
 
   888     setattr(cls, "getY", getY)
 
  1061     setattr(cls, "getY", getY)
 
   889     setattr(cls, "setX", setX)
 
  1062     setattr(cls, "setX", setX)
 
   890     setattr(cls, "setY", setY)
 
  1063     setattr(cls, "setY", setY)
 
       
  1064     
       
  1065     def updateElementName(self, old_name, new_name):
 
       
  1066         pass
 
       
  1067     setattr(cls, "updateElementName", updateElementName)
 
   891 
  1068 
   892 if "connection" in PLCOpenClasses:
 
  1069 if "connection" in PLCOpenClasses:
 
   893     cls = PLCOpenClasses["connection"]
 
  1070     cls = PLCOpenClasses["connection"]
 
   894     
  1071     
   895     def setPoints(self, points):
 
  1072     def setPoints(self, points):
plcopeneditor_history