changeset 1290 | 13ee5f4ab612 |
parent 1285 | fa77f3b8f182 |
child 1291 | 42ea51d083ce |
1286:adda406d3960 | 1290:13ee5f4ab612 |
---|---|
24 |
24 |
25 from xmlclass import * |
25 from xmlclass import * |
26 from structures import * |
26 from structures import * |
27 from types import * |
27 from types import * |
28 import os, re |
28 import os, re |
29 from lxml import etree |
|
29 from collections import OrderedDict |
30 from collections import OrderedDict |
30 """ |
31 """ |
31 Dictionary that makes the relation between var names in plcopen and displayed values |
32 Dictionary that makes the relation between var names in plcopen and displayed values |
32 """ |
33 """ |
33 VarTypes = {"Local" : "localVars", "Temp" : "tempVars", "Input" : "inputVars", |
34 VarTypes = {"Local" : "localVars", "Temp" : "tempVars", "Input" : "inputVars", |
120 end = TextLenInRowColumn(text[:result.end() - 1]) |
121 end = TextLenInRowColumn(text[:result.end() - 1]) |
121 test_result.append((start, end, "\n".join(lines[start[0]:end[0] + 1]))) |
122 test_result.append((start, end, "\n".join(lines[start[0]:end[0] + 1]))) |
122 result = criteria["pattern"].search(text, result.end()) |
123 result = criteria["pattern"].search(text, result.end()) |
123 return test_result |
124 return test_result |
124 |
125 |
125 PLCOpenClasses = GenerateClassesFromXSD(os.path.join(os.path.split(__file__)[0], "tc6_xml_v201.xsd")) |
126 PLCOpenParser = GenerateParserFromXSD(os.path.join(os.path.split(__file__)[0], "tc6_xml_v201.xsd")) |
126 |
127 |
127 ElementNameToClass = {} |
128 def LoadProject(filepath): |
128 |
129 project_file = open(filepath) |
129 cls = PLCOpenClasses.get("formattedText", None) |
130 project_xml = project_file.read()\ |
131 .replace("http://www.plcopen.org/xml/tc6.xsd", |
|
132 "http://www.plcopen.org/xml/tc6_0201")\ |
|
133 .replace("<![CDATA[", "<xhtml:p><![CDATA[")\ |
|
134 .replace("]]>", "]]></xhtml:p>") |
|
135 project_file.close() |
|
136 |
|
137 return etree.fromstring(project_xml, PLCOpenParser) |
|
138 |
|
139 def SaveProject(project, filepath): |
|
140 project_file = open(filepath, 'w') |
|
141 project_file.write(etree.tostring( |
|
142 project, |
|
143 pretty_print=True, |
|
144 xml_declaration=True, |
|
145 encoding='utf-8')) |
|
146 project_file.close() |
|
147 |
|
148 cls = PLCOpenParser.GetElementClass("formattedText") |
|
130 if cls: |
149 if cls: |
131 def updateElementName(self, old_name, new_name): |
150 def updateElementName(self, old_name, new_name): |
132 text = self.text |
151 text = self.text |
133 index = text.find(old_name) |
152 index = text.find(old_name) |
134 while index != -1: |
153 while index != -1: |
168 |
187 |
169 def Search(self, criteria, parent_infos): |
188 def Search(self, criteria, parent_infos): |
170 return [(tuple(parent_infos),) + result for result in TestTextElement(self.gettext(), criteria)] |
189 return [(tuple(parent_infos),) + result for result in TestTextElement(self.gettext(), criteria)] |
171 setattr(cls, "Search", Search) |
190 setattr(cls, "Search", Search) |
172 |
191 |
173 cls = PLCOpenClasses.get("project", None) |
192 cls = PLCOpenParser.GetElementClass("project") |
174 if cls: |
193 if cls: |
175 cls.singleLineAttributes = False |
|
176 cls.EnumeratedDataTypeValues = {} |
194 cls.EnumeratedDataTypeValues = {} |
177 cls.CustomDataTypeRange = {} |
195 cls.CustomDataTypeRange = {} |
178 cls.CustomTypeHierarchy = {} |
196 cls.CustomTypeHierarchy = {} |
179 cls.ElementUsingTree = {} |
197 cls.ElementUsingTree = {} |
180 cls.CustomBlockTypes = OrderedDict() |
198 cls.CustomBlockTypes = OrderedDict() |
322 |
340 |
323 def addconfiguration(self, name): |
341 def addconfiguration(self, name): |
324 for configuration in self.instances.configurations.getconfiguration(): |
342 for configuration in self.instances.configurations.getconfiguration(): |
325 if configuration.getname() == name: |
343 if configuration.getname() == name: |
326 raise ValueError, _("\"%s\" configuration already exists !!!")%name |
344 raise ValueError, _("\"%s\" configuration already exists !!!")%name |
327 new_configuration = PLCOpenClasses["configurations_configuration"]() |
345 new_configuration = PLCOpenParser.CreateElement("configuration", "configurations") |
328 new_configuration.setname(name) |
346 new_configuration.setname(name) |
329 self.instances.configurations.appendconfiguration(new_configuration) |
347 self.instances.configurations.appendconfiguration(new_configuration) |
330 setattr(cls, "addconfiguration", addconfiguration) |
348 setattr(cls, "addconfiguration", addconfiguration) |
331 |
349 |
332 def removeconfiguration(self, name): |
350 def removeconfiguration(self, name): |
353 configuration = self.getconfiguration(config_name) |
371 configuration = self.getconfiguration(config_name) |
354 if configuration: |
372 if configuration: |
355 for resource in configuration.getresource(): |
373 for resource in configuration.getresource(): |
356 if resource.getname() == name: |
374 if resource.getname() == name: |
357 raise ValueError, _("\"%s\" resource already exists in \"%s\" configuration !!!")%(name, config_name) |
375 raise ValueError, _("\"%s\" resource already exists in \"%s\" configuration !!!")%(name, config_name) |
358 new_resource = PLCOpenClasses["configuration_resource"]() |
376 new_resource = PLCOpenParser.CreateElement("resource", "configuration") |
359 new_resource.setname(name) |
377 new_resource.setname(name) |
360 configuration.appendresource(new_resource) |
378 configuration.appendresource(new_resource) |
361 setattr(cls, "addconfigurationResource", addconfigurationResource) |
379 setattr(cls, "addconfigurationResource", addconfigurationResource) |
362 |
380 |
363 def removeconfigurationResource(self, config_name, name): |
381 def removeconfigurationResource(self, config_name, name): |
414 setattr(cls, "RefreshDataTypeHierarchy", RefreshDataTypeHierarchy) |
432 setattr(cls, "RefreshDataTypeHierarchy", RefreshDataTypeHierarchy) |
415 |
433 |
416 def AddCustomDataType(self, datatype): |
434 def AddCustomDataType(self, datatype): |
417 name = datatype.getname() |
435 name = datatype.getname() |
418 basetype_content = datatype.getbaseType().getcontent() |
436 basetype_content = datatype.getbaseType().getcontent() |
419 if basetype_content["value"] is None: |
437 basetype_content_name = basetype_content.getLocalTag() |
420 self.CustomTypeHierarchy[name] = basetype_content["name"] |
438 if basetype_content.__class__ == DefaultElementClass: |
421 elif basetype_content["name"] in ["string", "wstring"]: |
439 self.CustomTypeHierarchy[name] = basetype_content_name |
422 self.CustomTypeHierarchy[name] = basetype_content["name"].upper() |
440 elif basetype_content_name in ["string", "wstring"]: |
423 elif basetype_content["name"] == "derived": |
441 self.CustomTypeHierarchy[name] = basetype_content_name.upper() |
424 self.CustomTypeHierarchy[name] = basetype_content["value"].getname() |
442 elif basetype_content_name == "derived": |
425 elif basetype_content["name"] in ["subrangeSigned", "subrangeUnsigned"]: |
443 self.CustomTypeHierarchy[name] = basetype_content.getname() |
426 range = (basetype_content["value"].range.getlower(), |
444 elif basetype_content_name in ["subrangeSigned", "subrangeUnsigned"]: |
427 basetype_content["value"].range.getupper()) |
445 range = (basetype_content.range.getlower(), |
446 basetype_content.range.getupper()) |
|
428 self.CustomDataTypeRange[name] = range |
447 self.CustomDataTypeRange[name] = range |
429 base_type = basetype_content["value"].baseType.getcontent() |
448 base_type = basetype_content.baseType.getcontent() |
430 if base_type["value"] is None: |
449 if base_type.__class__ == DefaultElementClass: |
431 self.CustomTypeHierarchy[name] = base_type["name"] |
450 self.CustomTypeHierarchy[name] = basetype.getLocalTag() |
432 else: |
451 else: |
433 self.CustomTypeHierarchy[name] = base_type["value"].getname() |
452 self.CustomTypeHierarchy[name] = base_type.getname() |
434 else: |
453 else: |
435 if basetype_content["name"] == "enum": |
454 if basetype_content_name == "enum": |
436 values = [] |
455 values = [] |
437 for value in basetype_content["value"].values.getvalue(): |
456 for value in basetype_content.xpath("ppx:values/ppx:value", namespaces=PLCOpenParser.NSMAP): |
438 values.append(value.getname()) |
457 values.append(value.getname()) |
439 self.EnumeratedDataTypeValues[name] = values |
458 self.EnumeratedDataTypeValues[name] = values |
440 self.CustomTypeHierarchy[name] = "ANY_DERIVED" |
459 self.CustomTypeHierarchy[name] = "ANY_DERIVED" |
441 setattr(cls, "AddCustomDataType", AddCustomDataType) |
460 setattr(cls, "AddCustomDataType", AddCustomDataType) |
442 |
461 |
456 "generate" : generate_block, "initialise" : initialise_block} |
475 "generate" : generate_block, "initialise" : initialise_block} |
457 if pou.getinterface(): |
476 if pou.getinterface(): |
458 return_type = pou.interface.getreturnType() |
477 return_type = pou.interface.getreturnType() |
459 if return_type: |
478 if return_type: |
460 var_type = return_type.getcontent() |
479 var_type = return_type.getcontent() |
461 if var_type["name"] == "derived": |
480 var_type_name = var_type.getLocalTag() |
462 block_infos["outputs"].append(("OUT", var_type["value"].getname(), "none")) |
481 if var_type_name == "derived": |
463 elif var_type["name"] in ["string", "wstring"]: |
482 block_infos["outputs"].append(("OUT", var_type.getname(), "none")) |
464 block_infos["outputs"].append(("OUT", var_type["name"].upper(), "none")) |
483 elif var_type_name in ["string", "wstring"]: |
484 block_infos["outputs"].append(("OUT", var_type_name.upper(), "none")) |
|
465 else: |
485 else: |
466 block_infos["outputs"].append(("OUT", var_type["name"], "none")) |
486 block_infos["outputs"].append(("OUT", var_type_name, "none")) |
467 for type, varlist in pou.getvars(): |
487 for type, varlist in pou.getvars(): |
468 if type == "InOut": |
488 if type == "InOut": |
469 for var in varlist.getvariable(): |
489 for var in varlist.getvariable(): |
470 var_type = var.type.getcontent() |
490 var_type = var.type.getcontent() |
471 if var_type["name"] == "derived": |
491 var_type_name = var_type.getLocalTag() |
472 block_infos["inputs"].append((var.getname(), var_type["value"].getname(), "none")) |
492 if var_type_name == "derived": |
473 block_infos["outputs"].append((var.getname(), var_type["value"].getname(), "none")) |
493 block_infos["inputs"].append((var.getname(), var_type.getname(), "none")) |
474 elif var_type["name"] in ["string", "wstring"]: |
494 block_infos["outputs"].append((var.getname(), var_type.getname(), "none")) |
475 block_infos["inputs"].append((var.getname(), var_type["name"].upper(), "none")) |
495 elif var_type_name in ["string", "wstring"]: |
476 block_infos["outputs"].append((var.getname(), var_type["name"].upper(), "none")) |
496 block_infos["inputs"].append((var.getname(), var_type_name.upper(), "none")) |
497 block_infos["outputs"].append((var.getname(), var_type_name.upper(), "none")) |
|
477 else: |
498 else: |
478 block_infos["inputs"].append((var.getname(), var_type["name"], "none")) |
499 block_infos["inputs"].append((var.getname(), var_type_name, "none")) |
479 block_infos["outputs"].append((var.getname(), var_type["name"], "none")) |
500 block_infos["outputs"].append((var.getname(), var_type_name, "none")) |
480 elif type == "Input": |
501 elif type == "Input": |
481 for var in varlist.getvariable(): |
502 for var in varlist.getvariable(): |
482 var_type = var.type.getcontent() |
503 var_type = var.type.getcontent() |
483 if var_type["name"] == "derived": |
504 var_type_name = var_type.getLocalTag() |
484 block_infos["inputs"].append((var.getname(), var_type["value"].getname(), "none")) |
505 if var_type_name == "derived": |
485 elif var_type["name"] in ["string", "wstring"]: |
506 block_infos["inputs"].append((var.getname(), var_type.getname(), "none")) |
486 block_infos["inputs"].append((var.getname(), var_type["name"].upper(), "none")) |
507 elif var_type_name in ["string", "wstring"]: |
508 block_infos["inputs"].append((var.getname(), var_type_name.upper(), "none")) |
|
487 else: |
509 else: |
488 block_infos["inputs"].append((var.getname(), var_type["name"], "none")) |
510 block_infos["inputs"].append((var.getname(), var_type_name, "none")) |
489 elif type == "Output": |
511 elif type == "Output": |
490 for var in varlist.getvariable(): |
512 for var in varlist.getvariable(): |
491 var_type = var.type.getcontent() |
513 var_type = var.type.getcontent() |
492 if var_type["name"] == "derived": |
514 var_type_name = var_type.getLocalTag() |
493 block_infos["outputs"].append((var.getname(), var_type["value"].getname(), "none")) |
515 if var_type_name == "derived": |
494 elif var_type["name"] in ["string", "wstring"]: |
516 block_infos["outputs"].append((var.getname(), var_type.getname(), "none")) |
495 block_infos["outputs"].append((var.getname(), var_type["name"].upper(), "none")) |
517 elif var_type_name in ["string", "wstring"]: |
518 block_infos["outputs"].append((var.getname(), var_type_name.upper(), "none")) |
|
496 else: |
519 else: |
497 block_infos["outputs"].append((var.getname(), var_type["name"], "none")) |
520 block_infos["outputs"].append((var.getname(), var_type_name, "none")) |
498 block_infos["usage"] = "\n (%s) => (%s)" % (", ".join(["%s:%s" % (input[1], input[0]) for input in block_infos["inputs"]]), |
521 block_infos["usage"] = "\n (%s) => (%s)" % (", ".join(["%s:%s" % (input[1], input[0]) for input in block_infos["inputs"]]), |
499 ", ".join(["%s:%s" % (output[1], output[0]) for output in block_infos["outputs"]])) |
522 ", ".join(["%s:%s" % (output[1], output[0]) for output in block_infos["outputs"]])) |
500 self.CustomBlockTypes[pou_name]=block_infos |
523 self.CustomBlockTypes[pou_name]=block_infos |
501 setattr(cls, "AddCustomBlockType", AddCustomBlockType) |
524 setattr(cls, "AddCustomBlockType", AddCustomBlockType) |
502 |
525 |
507 setattr(cls, "AddElementUsingTreeInstance", AddElementUsingTreeInstance) |
530 setattr(cls, "AddElementUsingTreeInstance", AddElementUsingTreeInstance) |
508 |
531 |
509 def RefreshElementUsingTree(self): |
532 def RefreshElementUsingTree(self): |
510 # Reset the tree of user-defined element cross-use |
533 # Reset the tree of user-defined element cross-use |
511 self.ElementUsingTree = {} |
534 self.ElementUsingTree = {} |
512 pous = self.getpous() |
535 |
513 datatypes = self.getdataTypes() |
|
514 # Analyze each datatype |
536 # Analyze each datatype |
515 for datatype in datatypes: |
537 for datatype in self.getdataTypes(): |
516 name = datatype.getname() |
538 name = datatype.getname() |
517 basetype_content = datatype.baseType.getcontent() |
539 basetype_content = datatype.baseType.getcontent() |
518 if basetype_content["name"] == "derived": |
540 basetype_content_name = basetype_content.getLocalTag() |
519 self.AddElementUsingTreeInstance(name, |
541 if basetype_content_name == "derived": |
520 basetype_content["value"]) |
542 self.AddElementUsingTreeInstance(name, basetype_content) |
521 elif basetype_content["name"] in ["subrangeSigned", "subrangeUnsigned", "array"]: |
543 elif basetype_content_name in ["subrangeSigned", "subrangeUnsigned", "array"]: |
522 base_type = basetype_content["value"].baseType.getcontent() |
544 base_type = basetype_content.baseType.getcontent() |
523 if base_type["name"] == "derived": |
545 if base_type.getLocalTag() == "derived": |
524 self.AddElementUsingTreeInstance(name, base_type["value"]) |
546 self.AddElementUsingTreeInstance(name, base_type) |
525 elif basetype_content["name"] == "struct": |
547 elif basetype_content_name == "struct": |
526 for element in basetype_content["value"].getvariable(): |
548 for element in basetype_content.getvariable(): |
527 type_content = element.type.getcontent() |
549 type_content = element.type.getcontent() |
528 if type_content["name"] == "derived": |
550 if type_content.getLocalTag() == "derived": |
529 self.AddElementUsingTreeInstance(name, type_content["value"]) |
551 self.AddElementUsingTreeInstance(name, type_content) |
552 |
|
530 # Analyze each pou |
553 # Analyze each pou |
531 for pou in pous: |
554 for pou in self.getpous(): |
532 name = pou.getname() |
555 name = pou.getname() |
533 if pou.interface: |
556 if pou.interface: |
534 # Extract variables from every varLists |
557 # Extract variables from every varLists |
535 for type, varlist in pou.getvars(): |
558 for varlist_type, varlist in pou.getvars(): |
536 for var in varlist.getvariable(): |
559 for var in varlist.getvariable(): |
537 vartype_content = var.gettype().getcontent() |
560 vartype_content = var.gettype().getcontent() |
538 if vartype_content["name"] == "derived": |
561 if vartype_content.getLocalTag() == "derived": |
539 self.AddElementUsingTreeInstance(name, vartype_content["value"]) |
562 self.AddElementUsingTreeInstance(name, vartype_content) |
540 |
563 |
541 setattr(cls, "RefreshElementUsingTree", RefreshElementUsingTree) |
564 setattr(cls, "RefreshElementUsingTree", RefreshElementUsingTree) |
542 |
565 |
543 def GetParentType(self, type): |
566 def GetParentType(self, type): |
544 if self.CustomTypeHierarchy.has_key(type): |
567 if self.CustomTypeHierarchy.has_key(type): |
687 setattr(cls, "GetCustomDataTypes", GetCustomDataTypes) |
710 setattr(cls, "GetCustomDataTypes", GetCustomDataTypes) |
688 |
711 |
689 # Return if Data Type can be used for located variables |
712 # Return if Data Type can be used for located variables |
690 def IsLocatableType(self, datatype): |
713 def IsLocatableType(self, datatype): |
691 basetype_content = datatype.baseType.getcontent() |
714 basetype_content = datatype.baseType.getcontent() |
692 if basetype_content["name"] in ["enum", "struct"]: |
715 basetype_content_name = basetype_content.getLocalTag() |
716 if basetype_content_name in ["enum", "struct"]: |
|
693 return False |
717 return False |
694 elif basetype_content["name"] == "derived": |
718 elif basetype_content_name == "derived": |
695 base_type = self.getdataType(basetype_content["value"].getname()) |
719 base_type = self.getdataType(basetype_content.getname()) |
696 if base_type is not None: |
720 if base_type is not None: |
697 return self.IsLocatableType(base_type) |
721 return self.IsLocatableType(base_type) |
698 elif basetype_content["name"] == "array": |
722 elif basetype_content_name == "array": |
699 array_base_type = basetype_content["value"].baseType.getcontent() |
723 array_base_type = basetype_content.baseType.getcontent() |
700 if array_base_type["value"] is not None and array_base_type["name"] not in ["string", "wstring"]: |
724 if array_base_type == DefaultElementClass and array_base_type.getLocalTag() not in ["string", "wstring"]: |
701 base_type = self.getdataType(array_base_type["value"].getname()) |
725 base_type = self.getdataType(array_base_type.getname()) |
702 if base_type is not None: |
726 if base_type is not None: |
703 return self.IsLocatableType(base_type) |
727 return self.IsLocatableType(base_type) |
704 return True |
728 return True |
705 setattr(cls, "IsLocatableType", IsLocatableType) |
729 setattr(cls, "IsLocatableType", IsLocatableType) |
706 |
730 |
709 for configuration in self.instances.configurations.getconfiguration(): |
733 for configuration in self.instances.configurations.getconfiguration(): |
710 result.extend(configuration.Search(criteria, parent_infos)) |
734 result.extend(configuration.Search(criteria, parent_infos)) |
711 return result |
735 return result |
712 setattr(cls, "Search", Search) |
736 setattr(cls, "Search", Search) |
713 |
737 |
714 cls = PLCOpenClasses.get("project_fileHeader", None) |
738 cls = PLCOpenParser.GetElementClass("contentHeader", "project") |
715 if cls: |
739 if cls: |
716 cls.singleLineAttributes = False |
|
717 |
|
718 cls = PLCOpenClasses.get("project_contentHeader", None) |
|
719 if cls: |
|
720 cls.singleLineAttributes = False |
|
721 |
740 |
722 def setpageSize(self, width, height): |
741 def setpageSize(self, width, height): |
723 self.coordinateInfo.setpageSize(width, height) |
742 self.coordinateInfo.setpageSize(width, height) |
724 setattr(cls, "setpageSize", setpageSize) |
743 setattr(cls, "setpageSize", setpageSize) |
725 |
744 |
738 scaling["LD"] = self.coordinateInfo.getscaling("LD") |
757 scaling["LD"] = self.coordinateInfo.getscaling("LD") |
739 scaling["SFC"] = self.coordinateInfo.getscaling("SFC") |
758 scaling["SFC"] = self.coordinateInfo.getscaling("SFC") |
740 return scaling |
759 return scaling |
741 setattr(cls, "getscaling", getscaling) |
760 setattr(cls, "getscaling", getscaling) |
742 |
761 |
743 cls = PLCOpenClasses.get("contentHeader_coordinateInfo", None) |
762 cls = PLCOpenParser.GetElementClass("coordinateInfo", "contentHeader") |
744 if cls: |
763 if cls: |
745 def setpageSize(self, width, height): |
764 def setpageSize(self, width, height): |
746 if width == 0 and height == 0: |
765 if width == 0 and height == 0: |
747 self.deletepageSize() |
766 self.deletepageSize() |
748 else: |
767 else: |
807 def _removeConfigurationResourceVariableByAddress(self, address): |
826 def _removeConfigurationResourceVariableByAddress(self, address): |
808 for varlist in self.getglobalVars(): |
827 for varlist in self.getglobalVars(): |
809 variables = varlist.getvariable() |
828 variables = varlist.getvariable() |
810 for i in xrange(len(variables)-1, -1, -1): |
829 for i in xrange(len(variables)-1, -1, -1): |
811 if variables[i].getaddress() == address: |
830 if variables[i].getaddress() == address: |
812 variables.pop(i) |
831 variables.remove(variables[i]) |
813 |
832 |
814 def _removeConfigurationResourceVariableByFilter(self, address_model): |
833 def _removeConfigurationResourceVariableByFilter(self, address_model): |
815 for varlist in self.getglobalVars(): |
834 for varlist in self.getglobalVars(): |
816 variables = varlist.getvariable() |
835 variables = varlist.getvariable() |
817 for i in xrange(len(variables)-1, -1, -1): |
836 for i in xrange(len(variables)-1, -1, -1): |
818 var_address = variables[i].getaddress() |
837 var_address = variables[i].getaddress() |
819 if var_address is not None: |
838 if var_address is not None: |
820 result = address_model.match(var_address) |
839 result = address_model.match(var_address) |
821 if result is not None: |
840 if result is not None: |
822 variables.pop(i) |
841 variables.remove(variables[i]) |
823 |
842 |
824 def _SearchInConfigurationResource(self, criteria, parent_infos=[]): |
843 def _SearchInConfigurationResource(self, criteria, parent_infos=[]): |
825 search_result = _Search([("name", self.getname())], criteria, parent_infos) |
844 search_result = _Search([("name", self.getname())], criteria, parent_infos) |
826 var_number = 0 |
845 var_number = 0 |
827 for varlist in self.getglobalVars(): |
846 for varlist in self.getglobalVars(): |
837 for variable in variables: |
856 for variable in variables: |
838 search_result.extend(variable.Search(criteria, parent_infos + [variable_type, var_number])) |
857 search_result.extend(variable.Search(criteria, parent_infos + [variable_type, var_number])) |
839 var_number += 1 |
858 var_number += 1 |
840 return search_result |
859 return search_result |
841 |
860 |
842 cls = PLCOpenClasses.get("configurations_configuration", None) |
861 cls = PLCOpenParser.GetElementClass("configuration", "configurations") |
843 if cls: |
862 if cls: |
844 |
863 |
845 def addglobalVar(self, type, name, location="", description=""): |
864 def addglobalVar(self, var_type, name, location="", description=""): |
846 globalvars = self.getglobalVars() |
865 globalvars = self.getglobalVars() |
847 if len(globalvars) == 0: |
866 if len(globalvars) == 0: |
848 globalvars.append(PLCOpenClasses["varList"]()) |
867 globalvars.append(PLCOpenParser.CreateElement("varList")) |
849 var = PLCOpenClasses["varListPlain_variable"]() |
868 var = PLCOpenParser.CreateElement("variable", "varListPlain") |
850 var.setname(name) |
869 var.setname(name) |
851 var_type = PLCOpenClasses["dataType"]() |
870 var_type_obj = PLCOpenParser.CreateElement("dataType") |
852 if type in [x for x,y in TypeHierarchy_list if not x.startswith("ANY")]: |
871 if var_type in [x for x,y in TypeHierarchy_list if not x.startswith("ANY")]: |
853 if type == "STRING": |
872 if var_type == "STRING": |
854 var_type.setcontent({"name" : "string", "value" : PLCOpenClasses["elementaryTypes_string"]()}) |
873 var_type_obj.setcontent(PLCOpenParser.CreateElement("string", "elementaryTypes")) |
855 elif type == "WSTRING": |
874 elif var_type == "WSTRING": |
856 var_type.setcontent({"name" : "wstring", "value" : PLCOpenClasses["elementaryTypes_wstring"]()}) |
875 var_type_obj.setcontent(PLCOpenParser.CreateElement("wstring", "elementaryTypes")) |
857 else: |
876 else: |
858 var_type.setcontent({"name" : type, "value" : None}) |
877 var_type_obj.setcontent(PLCOpenParser.CreateElement(var_type)) |
859 else: |
878 else: |
860 derived_type = PLCOpenClasses["derivedTypes_derived"]() |
879 derived_type = PLCOpenParser.CreateElement("derived", "derivedTypes") |
861 derived_type.setname(type) |
880 derived_type.setname(var_type) |
862 var_type.setcontent({"name" : "derived", "value" : derived_type}) |
881 var_type_obj.setcontent(derived_type) |
863 var.settype(var_type) |
882 var.settype(var_type_obj) |
864 if location != "": |
883 if location != "": |
865 var.setaddress(location) |
884 var.setaddress(location) |
866 if description != "": |
885 if description != "": |
867 ft = PLCOpenClasses["formattedText"]() |
886 ft = PLCOpenParser.CreateElementClass("formattedText") |
868 ft.settext(description) |
887 ft.settext(description) |
869 var.setdocumentation(ft) |
888 var.setdocumentation(ft) |
870 globalvars[-1].appendvariable(var) |
889 globalvars[-1].appendvariable(var) |
871 setattr(cls, "addglobalVar", addglobalVar) |
890 setattr(cls, "addglobalVar", addglobalVar) |
872 |
891 |
894 for resource in self.getresource(): |
913 for resource in self.getresource(): |
895 search_result.extend(resource.Search(criteria, parent_infos)) |
914 search_result.extend(resource.Search(criteria, parent_infos)) |
896 return search_result |
915 return search_result |
897 setattr(cls, "Search", Search) |
916 setattr(cls, "Search", Search) |
898 |
917 |
899 cls = PLCOpenClasses.get("configuration_resource", None) |
918 cls = PLCOpenParser.GetElementClass("resource", "configuration") |
900 if cls: |
919 if cls: |
901 def updateElementName(self, old_name, new_name): |
920 def updateElementName(self, old_name, new_name): |
902 _updateConfigurationResourceElementName(self, old_name, new_name) |
921 _updateConfigurationResourceElementName(self, old_name, new_name) |
903 for instance in self.getpouInstance(): |
922 for instance in self.getpouInstance(): |
904 instance.updateElementName(old_name, new_name) |
923 instance.updateElementName(old_name, new_name) |
935 search_result.extend(instance.Search(criteria, parent_infos + ["instance", instance_number])) |
954 search_result.extend(instance.Search(criteria, parent_infos + ["instance", instance_number])) |
936 instance_number += 1 |
955 instance_number += 1 |
937 return search_result |
956 return search_result |
938 setattr(cls, "Search", Search) |
957 setattr(cls, "Search", Search) |
939 |
958 |
940 cls = PLCOpenClasses.get("resource_task", None) |
959 cls = PLCOpenParser.GetElementClass("task", "resource") |
941 if cls: |
960 if cls: |
942 def compatibility(self, tree): |
961 def compatibility(self, tree): |
943 if tree.hasAttribute("interval"): |
962 if tree.hasAttribute("interval"): |
944 interval = GetAttributeValue(tree._attrs["interval"]) |
963 interval = GetAttributeValue(tree._attrs["interval"]) |
945 result = time_model.match(interval) |
964 result = time_model.match(interval) |
984 ("interval", self.getinterval()), |
1003 ("interval", self.getinterval()), |
985 ("priority", str(self.getpriority()))], |
1004 ("priority", str(self.getpriority()))], |
986 criteria, parent_infos) |
1005 criteria, parent_infos) |
987 setattr(cls, "Search", Search) |
1006 setattr(cls, "Search", Search) |
988 |
1007 |
989 cls = PLCOpenClasses.get("pouInstance", None) |
1008 cls = PLCOpenParser.GetElementClass("pouInstance") |
990 if cls: |
1009 if cls: |
991 def compatibility(self, tree): |
1010 def compatibility(self, tree): |
992 if tree.hasAttribute("type"): |
1011 if tree.hasAttribute("type"): |
993 NodeRenameAttr(tree, "type", "typeName") |
1012 NodeRenameAttr(tree, "type", "typeName") |
994 setattr(cls, "compatibility", compatibility) |
1013 setattr(cls, "compatibility", compatibility) |
1002 return _Search([("name", self.getname()), |
1021 return _Search([("name", self.getname()), |
1003 ("type", self.gettypeName())], |
1022 ("type", self.gettypeName())], |
1004 criteria, parent_infos) |
1023 criteria, parent_infos) |
1005 setattr(cls, "Search", Search) |
1024 setattr(cls, "Search", Search) |
1006 |
1025 |
1007 cls = PLCOpenClasses.get("varListPlain_variable", None) |
1026 cls = PLCOpenParser.GetElementClass("variable", "varListPlain") |
1008 if cls: |
1027 if cls: |
1009 def gettypeAsText(self): |
1028 def gettypeAsText(self): |
1010 vartype_content = self.gettype().getcontent() |
1029 vartype_content = self.gettype().getcontent() |
1030 vartype_content_name = vartype_content.getLocalTag() |
|
1011 # Variable type is a user data type |
1031 # Variable type is a user data type |
1012 if vartype_content["name"] == "derived": |
1032 if vartype_content_name == "derived": |
1013 return vartype_content["value"].getname() |
1033 return vartype_content.getname() |
1014 # Variable type is a string type |
1034 # Variable type is a string type |
1015 elif vartype_content["name"] in ["string", "wstring"]: |
1035 elif vartype_content_name in ["string", "wstring"]: |
1016 return vartype_content["name"].upper() |
1036 return vartype_content_name.upper() |
1017 # Variable type is an array |
1037 # Variable type is an array |
1018 elif vartype_content["name"] == "array": |
1038 elif vartype_content_name == "array": |
1019 base_type = vartype_content["value"].baseType.getcontent() |
1039 base_type = vartype_content.baseType.getcontent() |
1040 base_type_name = base_type.getLocalTag() |
|
1020 # Array derived directly from a user defined type |
1041 # Array derived directly from a user defined type |
1021 if base_type["name"] == "derived": |
1042 if base_type_name == "derived": |
1022 basetype_name = base_type["value"].getname() |
1043 basetype_name = base_type.getname() |
1023 # Array derived directly from a string type |
1044 # Array derived directly from a string type |
1024 elif base_type["name"] in ["string", "wstring"]: |
1045 elif base_type_name in ["string", "wstring"]: |
1025 basetype_name = base_type["name"].upper() |
1046 basetype_name = base_type_name.upper() |
1026 # Array derived directly from an elementary type |
1047 # Array derived directly from an elementary type |
1027 else: |
1048 else: |
1028 basetype_name = base_type["name"] |
1049 basetype_name = base_type_name |
1029 return "ARRAY [%s] OF %s" % (",".join(map(lambda x : "%s..%s" % (x.getlower(), x.getupper()), vartype_content["value"].getdimension())), basetype_name) |
1050 return "ARRAY [%s] OF %s" % (",".join(map(lambda x : "%s..%s" % (x.getlower(), x.getupper()), vartype_content.getdimension())), basetype_name) |
1030 # Variable type is an elementary type |
1051 # Variable type is an elementary type |
1031 return vartype_content["name"] |
1052 return vartype_content_name |
1032 setattr(cls, "gettypeAsText", gettypeAsText) |
1053 setattr(cls, "gettypeAsText", gettypeAsText) |
1033 |
1054 |
1034 def Search(self, criteria, parent_infos=[]): |
1055 def Search(self, criteria, parent_infos=[]): |
1035 search_result = _Search([("name", self.getname()), |
1056 search_result = _Search([("name", self.getname()), |
1036 ("type", self.gettypeAsText()), |
1057 ("type", self.gettypeAsText()), |
1043 if doc is not None: |
1064 if doc is not None: |
1044 search_result.extend(doc.Search(criteria, parent_infos + ["documentation"])) |
1065 search_result.extend(doc.Search(criteria, parent_infos + ["documentation"])) |
1045 return search_result |
1066 return search_result |
1046 setattr(cls, "Search", Search) |
1067 setattr(cls, "Search", Search) |
1047 |
1068 |
1048 cls = PLCOpenClasses.get("project_types", None) |
1069 cls = PLCOpenParser.GetElementClass("types", "project") |
1049 if cls: |
1070 if cls: |
1050 def getdataTypeElements(self): |
1071 def getdataTypeElements(self): |
1051 return self.dataTypes.getdataType() |
1072 return self.dataTypes.getdataType() |
1052 setattr(cls, "getdataTypeElements", getdataTypeElements) |
1073 setattr(cls, "getdataTypeElements", getdataTypeElements) |
1053 |
1074 |
1058 return element |
1079 return element |
1059 return None |
1080 return None |
1060 setattr(cls, "getdataTypeElement", getdataTypeElement) |
1081 setattr(cls, "getdataTypeElement", getdataTypeElement) |
1061 |
1082 |
1062 def appenddataTypeElement(self, name): |
1083 def appenddataTypeElement(self, name): |
1063 new_datatype = PLCOpenClasses["dataTypes_dataType"]() |
1084 new_datatype = PLCOpenParser.CreateElement("dataType", "dataTypes") |
1064 new_datatype.setname(name) |
1085 new_datatype.setname(name) |
1065 new_datatype.baseType.setcontent({"name" : "BOOL", "value" : None}) |
1086 new_datatype.baseType.setcontent(PLCOpenParser.CreateElement("BOOL")) |
1066 self.dataTypes.appenddataType(new_datatype) |
1087 self.dataTypes.appenddataType(new_datatype) |
1067 setattr(cls, "appenddataTypeElement", appenddataTypeElement) |
1088 setattr(cls, "appenddataTypeElement", appenddataTypeElement) |
1068 |
1089 |
1069 def insertdataTypeElement(self, index, dataType): |
1090 def insertdataTypeElement(self, index, dataType): |
1070 self.dataTypes.insertdataType(index, dataType) |
1091 self.dataTypes.insertdataType(index, dataType) |
1071 setattr(cls, "insertdataTypeElement", insertdataTypeElement) |
1092 setattr(cls, "insertdataTypeElement", insertdataTypeElement) |
1072 |
1093 |
1073 def removedataTypeElement(self, name): |
1094 def removedataTypeElement(self, name): |
1074 found = False |
1095 found = False |
1075 for idx, element in enumerate(self.dataTypes.getdataType()): |
1096 for element in self.dataTypes.getdataType(): |
1076 if element.getname() == name: |
1097 if element.getname() == name: |
1077 self.dataTypes.removedataType(idx) |
1098 self.dataTypes.remove(element) |
1078 found = True |
1099 found = True |
1079 break |
1100 break |
1080 if not found: |
1101 if not found: |
1081 raise ValueError, _("\"%s\" Data Type doesn't exist !!!")%name |
1102 raise ValueError, _("\"%s\" Data Type doesn't exist !!!")%name |
1082 setattr(cls, "removedataTypeElement", removedataTypeElement) |
1103 setattr(cls, "removedataTypeElement", removedataTypeElement) |
1095 |
1116 |
1096 def appendpouElement(self, name, pou_type, body_type): |
1117 def appendpouElement(self, name, pou_type, body_type): |
1097 for element in self.pous.getpou(): |
1118 for element in self.pous.getpou(): |
1098 if element.getname() == name: |
1119 if element.getname() == name: |
1099 raise ValueError, _("\"%s\" POU already exists !!!")%name |
1120 raise ValueError, _("\"%s\" POU already exists !!!")%name |
1100 new_pou = PLCOpenClasses["pous_pou"]() |
1121 new_pou = PLCOpenParser.CreateElement("pou", "pous") |
1101 new_pou.setname(name) |
1122 new_pou.setname(name) |
1102 new_pou.setpouType(pou_type) |
1123 new_pou.setpouType(pou_type) |
1103 new_pou.appendbody(PLCOpenClasses["body"]()) |
1124 new_pou.appendbody(PLCOpenParser.CreateElement("body")) |
1104 new_pou.setbodyType(body_type) |
1125 new_pou.setbodyType(body_type) |
1105 self.pous.appendpou(new_pou) |
1126 self.pous.appendpou(new_pou) |
1106 setattr(cls, "appendpouElement", appendpouElement) |
1127 setattr(cls, "appendpouElement", appendpouElement) |
1107 |
1128 |
1108 def insertpouElement(self, index, pou): |
1129 def insertpouElement(self, index, pou): |
1109 self.pous.insertpou(index, pou) |
1130 self.pous.insertpou(index, pou) |
1110 setattr(cls, "insertpouElement", insertpouElement) |
1131 setattr(cls, "insertpouElement", insertpouElement) |
1111 |
1132 |
1112 def removepouElement(self, name): |
1133 def removepouElement(self, name): |
1113 found = False |
1134 found = False |
1114 for idx, element in enumerate(self.pous.getpou()): |
1135 for element in self.pous.getpou(): |
1115 if element.getname() == name: |
1136 if element.getname() == name: |
1116 self.pous.removepou(idx) |
1137 self.pous.remove(element) |
1117 found = True |
1138 found = True |
1118 break |
1139 break |
1119 if not found: |
1140 if not found: |
1120 raise ValueError, _("\"%s\" POU doesn't exist !!!")%name |
1141 raise ValueError, _("\"%s\" POU doesn't exist !!!")%name |
1121 setattr(cls, "removepouElement", removepouElement) |
1142 setattr(cls, "removepouElement", removepouElement) |
1131 setattr(cls, "Search", Search) |
1152 setattr(cls, "Search", Search) |
1132 |
1153 |
1133 def _updateBaseTypeElementName(self, old_name, new_name): |
1154 def _updateBaseTypeElementName(self, old_name, new_name): |
1134 self.baseType.updateElementName(old_name, new_name) |
1155 self.baseType.updateElementName(old_name, new_name) |
1135 |
1156 |
1136 cls = PLCOpenClasses.get("dataTypes_dataType", None) |
1157 cls = PLCOpenParser.GetElementClass("dataType", "dataTypes") |
1137 if cls: |
1158 if cls: |
1138 setattr(cls, "updateElementName", _updateBaseTypeElementName) |
1159 setattr(cls, "updateElementName", _updateBaseTypeElementName) |
1139 |
1160 |
1140 def Search(self, criteria, parent_infos=[]): |
1161 def Search(self, criteria, parent_infos=[]): |
1141 search_result = [] |
1162 search_result = [] |
1147 if self.initialValue is not None: |
1168 if self.initialValue is not None: |
1148 search_result.extend(_Search([("initial", self.initialValue.getvalue())], criteria, parent_infos)) |
1169 search_result.extend(_Search([("initial", self.initialValue.getvalue())], criteria, parent_infos)) |
1149 return search_result |
1170 return search_result |
1150 setattr(cls, "Search", Search) |
1171 setattr(cls, "Search", Search) |
1151 |
1172 |
1152 cls = PLCOpenClasses.get("dataType", None) |
1173 cls = PLCOpenParser.GetElementClass("dataType") |
1153 if cls: |
1174 if cls: |
1154 |
1175 |
1155 def updateElementName(self, old_name, new_name): |
1176 def updateElementName(self, old_name, new_name): |
1156 if self.content["name"] in ["derived", "array", "subrangeSigned", "subrangeUnsigned"]: |
1177 content_name = self.content.getLocalTag() |
1157 self.content["value"].updateElementName(old_name, new_name) |
1178 if content_name in ["derived", "array", "subrangeSigned", "subrangeUnsigned"]: |
1158 elif self.content["name"] == "struct": |
1179 self.content.updateElementName(old_name, new_name) |
1159 for element in self.content["value"].getvariable(): |
1180 elif content_name == "struct": |
1181 for element in self.content.getvariable(): |
|
1160 element_type = element.type.updateElementName(old_name, new_name) |
1182 element_type = element.type.updateElementName(old_name, new_name) |
1161 setattr(cls, "updateElementName", updateElementName) |
1183 setattr(cls, "updateElementName", updateElementName) |
1162 |
1184 |
1163 def Search(self, criteria, parent_infos=[]): |
1185 def Search(self, criteria, parent_infos=[]): |
1164 search_result = [] |
1186 search_result = [] |
1165 if self.content["name"] in ["derived", "array", "enum", "subrangeSigned", "subrangeUnsigned"]: |
1187 content_name = self.content.getLocalTag() |
1188 if content_name in ["derived", "array", "enum", "subrangeSigned", "subrangeUnsigned"]: |
|
1166 search_result.extend(self.content["value"].Search(criteria, parent_infos)) |
1189 search_result.extend(self.content["value"].Search(criteria, parent_infos)) |
1167 elif self.content["name"] == "struct": |
1190 elif content_name == "struct": |
1168 for i, element in enumerate(self.content["value"].getvariable()): |
1191 for i, element in enumerate(self.content["value"].getvariable()): |
1169 search_result.extend(element.Search(criteria, parent_infos + ["struct", i])) |
1192 search_result.extend(element.Search(criteria, parent_infos + ["struct", i])) |
1170 else: |
1193 else: |
1171 basetype = self.content["name"] |
1194 if content_name in ["string", "wstring"]: |
1172 if basetype in ["string", "wstring"]: |
1195 content_name = content_name.upper() |
1173 basetype = basetype.upper() |
1196 search_result.extend(_Search([("base", content_name)], criteria, parent_infos)) |
1174 search_result.extend(_Search([("base", basetype)], criteria, parent_infos)) |
|
1175 return search_result |
1197 return search_result |
1176 setattr(cls, "Search", Search) |
1198 setattr(cls, "Search", Search) |
1177 |
1199 |
1178 cls = PLCOpenClasses.get("derivedTypes_array", None) |
1200 cls = PLCOpenParser.GetElementClass("array", "derivedTypes") |
1179 if cls: |
1201 if cls: |
1180 setattr(cls, "updateElementName", _updateBaseTypeElementName) |
1202 setattr(cls, "updateElementName", _updateBaseTypeElementName) |
1181 |
1203 |
1182 def Search(self, criteria, parent_infos=[]): |
1204 def Search(self, criteria, parent_infos=[]): |
1183 search_result = self.baseType.Search(criteria, parent_infos) |
1205 search_result = self.baseType.Search(criteria, parent_infos) |
1193 search_result.extend(_Search([("lower", self.range.getlower()), |
1215 search_result.extend(_Search([("lower", self.range.getlower()), |
1194 ("upper", self.range.getupper())], |
1216 ("upper", self.range.getupper())], |
1195 criteria, parent_infos)) |
1217 criteria, parent_infos)) |
1196 return search_result |
1218 return search_result |
1197 |
1219 |
1198 cls = PLCOpenClasses.get("derivedTypes_subrangeSigned", None) |
1220 cls = PLCOpenParser.GetElementClass("subrangeSigned", "derivedTypes") |
1199 if cls: |
1221 if cls: |
1200 setattr(cls, "updateElementName", _updateBaseTypeElementName) |
1222 setattr(cls, "updateElementName", _updateBaseTypeElementName) |
1201 setattr(cls, "Search", _SearchInSubrange) |
1223 setattr(cls, "Search", _SearchInSubrange) |
1202 |
1224 |
1203 cls = PLCOpenClasses.get("derivedTypes_subrangeUnsigned", None) |
1225 cls = PLCOpenParser.GetElementClass("subrangeUnsigned", "derivedTypes") |
1204 if cls: |
1226 if cls: |
1205 setattr(cls, "updateElementName", _updateBaseTypeElementName) |
1227 setattr(cls, "updateElementName", _updateBaseTypeElementName) |
1206 setattr(cls, "Search", _SearchInSubrange) |
1228 setattr(cls, "Search", _SearchInSubrange) |
1207 |
1229 |
1208 cls = PLCOpenClasses.get("derivedTypes_enum", None) |
1230 cls = PLCOpenParser.GetElementClass("enum", "derivedTypes") |
1209 if cls: |
1231 if cls: |
1210 |
1232 |
1211 def updateElementName(self, old_name, new_name): |
1233 def updateElementName(self, old_name, new_name): |
1212 pass |
1234 pass |
1213 setattr(cls, "updateElementName", updateElementName) |
1235 setattr(cls, "updateElementName", updateElementName) |
1218 for result in TestTextElement(value.getname(), criteria): |
1240 for result in TestTextElement(value.getname(), criteria): |
1219 search_result.append((tuple(parent_infos + ["value", i]),) + result) |
1241 search_result.append((tuple(parent_infos + ["value", i]),) + result) |
1220 return search_result |
1242 return search_result |
1221 setattr(cls, "Search", Search) |
1243 setattr(cls, "Search", Search) |
1222 |
1244 |
1223 cls = PLCOpenClasses.get("pous_pou", None) |
1245 cls = PLCOpenParser.GetElementClass("pou", "pous") |
1224 if cls: |
1246 if cls: |
1225 |
1247 |
1226 def setdescription(self, description): |
1248 def setdescription(self, description): |
1227 doc = self.getdocumentation() |
1249 doc = self.getdocumentation() |
1228 if doc is None: |
1250 if doc is None: |
1229 doc = PLCOpenClasses["formattedText"]() |
1251 doc = PLCOpenParser.CreateElement("formattedText") |
1230 self.setdocumentation(doc) |
1252 self.setdocumentation(doc) |
1231 doc.settext(description) |
1253 doc.settext(description) |
1232 setattr(cls, "setdescription", setdescription) |
1254 setattr(cls, "setdescription", setdescription) |
1233 |
1255 |
1234 def getdescription(self): |
1256 def getdescription(self): |
1236 if doc is not None: |
1258 if doc is not None: |
1237 return doc.gettext() |
1259 return doc.gettext() |
1238 return "" |
1260 return "" |
1239 setattr(cls, "getdescription", getdescription) |
1261 setattr(cls, "getdescription", getdescription) |
1240 |
1262 |
1241 def setbodyType(self, type): |
1263 def setbodyType(self, body_type): |
1242 if len(self.body) > 0: |
1264 if len(self.body) > 0: |
1243 if type == "IL": |
1265 if body_type in ["IL", "ST", "LD", "FBD", "SFC"]: |
1244 self.body[0].setcontent({"name" : "IL", "value" : PLCOpenClasses["formattedText"]()}) |
1266 self.body[0].setcontent(PLCOpenParser.CreateElementClass(body_type, "body")) |
1245 elif type == "ST": |
|
1246 self.body[0].setcontent({"name" : "ST", "value" : PLCOpenClasses["formattedText"]()}) |
|
1247 elif type == "LD": |
|
1248 self.body[0].setcontent({"name" : "LD", "value" : PLCOpenClasses["body_LD"]()}) |
|
1249 elif type == "FBD": |
|
1250 self.body[0].setcontent({"name" : "FBD", "value" : PLCOpenClasses["body_FBD"]()}) |
|
1251 elif type == "SFC": |
|
1252 self.body[0].setcontent({"name" : "SFC", "value" : PLCOpenClasses["body_SFC"]()}) |
|
1253 else: |
1267 else: |
1254 raise ValueError, "%s isn't a valid body type!"%type |
1268 raise ValueError, "%s isn't a valid body type!"%type |
1255 setattr(cls, "setbodyType", setbodyType) |
1269 setattr(cls, "setbodyType", setbodyType) |
1256 |
1270 |
1257 def getbodyType(self): |
1271 def getbodyType(self): |
1258 if len(self.body) > 0: |
1272 if len(self.body) > 0: |
1259 return self.body[0].getcontent()["name"] |
1273 return self.body[0].getcontent().getLocalTag() |
1260 setattr(cls, "getbodyType", getbodyType) |
1274 setattr(cls, "getbodyType", getbodyType) |
1261 |
1275 |
1262 def resetexecutionOrder(self): |
1276 def resetexecutionOrder(self): |
1263 if len(self.body) > 0: |
1277 if len(self.body) > 0: |
1264 self.body[0].resetexecutionOrder() |
1278 self.body[0].resetexecutionOrder() |
1324 if self.interface is not None: |
1338 if self.interface is not None: |
1325 reverse_types = {} |
1339 reverse_types = {} |
1326 for name, value in VarTypes.items(): |
1340 for name, value in VarTypes.items(): |
1327 reverse_types[value] = name |
1341 reverse_types[value] = name |
1328 for varlist in self.interface.getcontent(): |
1342 for varlist in self.interface.getcontent(): |
1329 vars.append((reverse_types[varlist["name"]], varlist["value"])) |
1343 vars.append((reverse_types[varlist.getLocalTag()], varlist)) |
1330 return vars |
1344 return vars |
1331 setattr(cls, "getvars", getvars) |
1345 setattr(cls, "getvars", getvars) |
1332 |
1346 |
1333 def setvars(self, vars): |
1347 def setvars(self, vars): |
1334 if self.interface is None: |
1348 if self.interface is None: |
1335 self.interface = PLCOpenClasses["pou_interface"]() |
1349 self.interface = PLCOpenParser.CreateElement("interface", "pou") |
1336 self.interface.setcontent([]) |
1350 self.interface.setcontent(vars) |
1337 for vartype, varlist in vars: |
|
1338 self.interface.appendcontent({"name" : VarTypes[vartype], "value" : varlist}) |
|
1339 setattr(cls, "setvars", setvars) |
1351 setattr(cls, "setvars", setvars) |
1340 |
1352 |
1341 def addpouLocalVar(self, type, name, location="", description=""): |
1353 def addpouLocalVar(self, var_type, name, location="", description=""): |
1342 self.addpouVar(type, name, location=location, description=description) |
1354 self.addpouVar(var_type, name, location=location, description=description) |
1343 setattr(cls, "addpouLocalVar", addpouLocalVar) |
1355 setattr(cls, "addpouLocalVar", addpouLocalVar) |
1344 |
1356 |
1345 def addpouExternalVar(self, type, name): |
1357 def addpouExternalVar(self, var_type, name): |
1346 self.addpouVar(type, name, "externalVars") |
1358 self.addpouVar(type, name, "externalVars") |
1347 setattr(cls, "addpouExternalVar", addpouExternalVar) |
1359 setattr(cls, "addpouExternalVar", addpouExternalVar) |
1348 |
1360 |
1349 def addpouVar(self, type, name, var_class="localVars", location="", description=""): |
1361 def addpouVar(self, var_type, name, var_class="localVars", location="", description=""): |
1350 if self.interface is None: |
1362 if self.interface is None: |
1351 self.interface = PLCOpenClasses["pou_interface"]() |
1363 self.interface = PLCOpenParser.CreateElement("interface", "pou") |
1352 content = self.interface.getcontent() |
1364 content = self.interface.getcontent() |
1353 if len(content) == 0 or content[-1]["name"] != var_class: |
1365 if len(content) == 0 or content[-1]["name"] != var_class: |
1354 content.append({"name" : var_class, "value" : PLCOpenClasses["interface_%s" % var_class]()}) |
1366 self.appendcontent(PLCOpenParser.CreateElement(var_class, "interface")) |
1355 else: |
1367 else: |
1356 varlist = content[-1]["value"] |
1368 varlist = content[-1]["value"] |
1357 variables = varlist.getvariable() |
1369 variables = varlist.getvariable() |
1358 if varlist.getconstant() or varlist.getretain() or len(variables) > 0 and variables[0].getaddress(): |
1370 if varlist.getconstant() or varlist.getretain() or len(variables) > 0 and variables[0].getaddress(): |
1359 content.append({"name" : var_class, "value" : PLCOpenClasses["interface_%s" % var_class]()}) |
1371 self.appendcontent(PLCOpenParser.CreateElementClass(var_class, "interface")) |
1360 var = PLCOpenClasses["varListPlain_variable"]() |
1372 var = PLCOpenParser.CreateElementClass("variable", "varListPlain") |
1361 var.setname(name) |
1373 var.setname(name) |
1362 var_type = PLCOpenClasses["dataType"]() |
1374 var_type_obj = PLCOpenParser.CreateElement("dataType") |
1363 if type in [x for x,y in TypeHierarchy_list if not x.startswith("ANY")]: |
1375 if var_type in [x for x,y in TypeHierarchy_list if not x.startswith("ANY")]: |
1364 if type == "STRING": |
1376 if var_type == "STRING": |
1365 var_type.setcontent({"name" : "string", "value" : PLCOpenClasses["elementaryTypes_string"]()}) |
1377 var_type_obj.setcontent(PLCOpenParser.CreateElement("string", "elementaryTypes")) |
1366 elif type == "WSTRING": |
1378 elif var_type == "WSTRING": |
1367 var_type.setcontent({"name" : "wstring", "value" : PLCOpenClasses["elementaryTypes_wstring"]()}) |
1379 var_type_obj.setcontent(PLCOpenParser.CreateElement("wstring", "elementaryTypes")) |
1368 else: |
1380 else: |
1369 var_type.setcontent({"name" : type, "value" : None}) |
1381 var_type_obj.setcontent(PLCOpenParser.CreateElement(var_type)) |
1370 else: |
1382 else: |
1371 derived_type = PLCOpenClasses["derivedTypes_derived"]() |
1383 derived_type = PLCOpenParser.CreateElement("derived", "derivedTypes") |
1372 derived_type.setname(type) |
1384 derived_type.setname(var_type) |
1373 var_type.setcontent({"name" : "derived", "value" : derived_type}) |
1385 var_type_obj.setcontent(derived_type) |
1374 var.settype(var_type) |
1386 var.settype(var_type_obj) |
1375 if location != "": |
1387 if location != "": |
1376 var.setaddress(location) |
1388 var.setaddress(location) |
1377 if description != "": |
1389 if description != "": |
1378 ft = PLCOpenClasses["formattedText"]() |
1390 ft = PLCOpenParser.GetElementClass("formattedText")() |
1379 ft.settext(description) |
1391 ft.settext(description) |
1380 var.setdocumentation(ft) |
1392 var.setdocumentation(ft) |
1381 |
1393 |
1382 content[-1]["value"].appendvariable(var) |
1394 content[-1]["value"].appendvariable(var) |
1383 setattr(cls, "addpouVar", addpouVar) |
1395 setattr(cls, "addpouVar", addpouVar) |
1388 for varlist in content: |
1400 for varlist in content: |
1389 variables = varlist["value"].getvariable() |
1401 variables = varlist["value"].getvariable() |
1390 for var in variables: |
1402 for var in variables: |
1391 if var.getname() == old_name: |
1403 if var.getname() == old_name: |
1392 vartype_content = var.gettype().getcontent() |
1404 vartype_content = var.gettype().getcontent() |
1393 if vartype_content["name"] == "derived" and vartype_content["value"].getname() == old_type: |
1405 if vartype_content.getLocalTag() == "derived" and vartype_content.getname() == old_type: |
1394 var.setname(new_name) |
1406 var.setname(new_name) |
1395 vartype_content["value"].setname(new_type) |
1407 vartype_content.setname(new_type) |
1396 return |
1408 return |
1397 setattr(cls, "changepouVar", changepouVar) |
1409 setattr(cls, "changepouVar", changepouVar) |
1398 |
1410 |
1399 def removepouVar(self, type, name): |
1411 def removepouVar(self, var_type, name): |
1400 if self.interface is not None: |
1412 if self.interface is not None: |
1401 content = self.interface.getcontent() |
1413 content = self.interface.getcontent() |
1402 for varlist in content: |
1414 for varlist in content: |
1403 variables = varlist["value"].getvariable() |
1415 for var in varlist.getvariable(): |
1404 for var in variables: |
|
1405 if var.getname() == name: |
1416 if var.getname() == name: |
1406 vartype_content = var.gettype().getcontent() |
1417 vartype_content = var.gettype().getcontent() |
1407 if vartype_content["name"] == "derived" and vartype_content["value"].getname() == type: |
1418 if vartype_content.getLocalTag() == "derived" and vartype_content.getname() == var_type: |
1408 variables.remove(var) |
1419 varlist.remove(var) |
1409 break |
1420 break |
1410 if len(varlist["value"].getvariable()) == 0: |
1421 if len(varlist.getvariable()) == 0: |
1411 content.remove(varlist) |
1422 content.remove(varlist) |
1412 break |
1423 break |
1413 setattr(cls, "removepouVar", removepouVar) |
1424 setattr(cls, "removepouVar", removepouVar) |
1414 |
1425 |
1415 def hasblock(self, name=None, block_type=None): |
1426 def hasblock(self, name=None, block_type=None): |
1416 if self.getbodyType() in ["FBD", "LD", "SFC"]: |
1427 if self.getbodyType() in ["FBD", "LD", "SFC"]: |
1417 for instance in self.getinstances(): |
1428 for instance in self.getinstances(): |
1418 if (isinstance(instance, PLCOpenClasses["fbdObjects_block"]) and |
1429 if (isinstance(instance, PLCOpenParser.GetElementClass("block", "fbdObjects")) and |
1419 (name and instance.getinstanceName() == name or |
1430 (name and instance.getinstanceName() == name or |
1420 block_type and instance.gettypeName() == block_type)): |
1431 block_type and instance.gettypeName() == block_type)): |
1421 return True |
1432 return True |
1422 if self.transitions: |
1433 if self.transitions: |
1423 for transition in self.transitions.gettransition(): |
1434 for transition in self.transitions.gettransition(): |
1432 elif block_type is not None and len(self.body) > 0: |
1443 elif block_type is not None and len(self.body) > 0: |
1433 return self.body[0].hasblock(block_type) |
1444 return self.body[0].hasblock(block_type) |
1434 return False |
1445 return False |
1435 setattr(cls, "hasblock", hasblock) |
1446 setattr(cls, "hasblock", hasblock) |
1436 |
1447 |
1437 def addtransition(self, name, type): |
1448 def addtransition(self, name, body_type): |
1438 if not self.transitions: |
1449 if not self.transitions: |
1439 self.addtransitions() |
1450 self.addtransitions() |
1440 self.transitions.settransition([]) |
1451 self.transitions.settransition([]) |
1441 transition = PLCOpenClasses["transitions_transition"]() |
1452 transition = PLCOpenParser.CreateElement("transition", "transitions") |
1442 transition.setname(name) |
1453 transition.setname(name) |
1443 transition.setbodyType(type) |
1454 transition.setbodyType(body_type) |
1444 if type == "ST": |
1455 if body_type == "ST": |
1445 transition.settext(":= ;") |
1456 transition.settext(":= ;") |
1446 elif type == "IL": |
1457 elif body_type == "IL": |
1447 transition.settext("\tST\t%s"%name) |
1458 transition.settext("\tST\t%s"%name) |
1448 self.transitions.appendtransition(transition) |
1459 self.transitions.appendtransition(transition) |
1449 setattr(cls, "addtransition", addtransition) |
1460 setattr(cls, "addtransition", addtransition) |
1450 |
1461 |
1451 def gettransition(self, name): |
1462 def gettransition(self, name): |
1462 return [] |
1473 return [] |
1463 setattr(cls, "gettransitionList", gettransitionList) |
1474 setattr(cls, "gettransitionList", gettransitionList) |
1464 |
1475 |
1465 def removetransition(self, name): |
1476 def removetransition(self, name): |
1466 if self.transitions: |
1477 if self.transitions: |
1467 transitions = self.transitions.gettransition() |
|
1468 i = 0 |
|
1469 removed = False |
1478 removed = False |
1470 while i < len(transitions) and not removed: |
1479 for transition in self.transitions.gettransition(): |
1471 if transitions[i].getname() == name: |
1480 if transition.getname() == name: |
1472 if transitions[i].getbodyType() in ["FBD", "LD", "SFC"]: |
1481 if transition.getbodyType() in ["FBD", "LD", "SFC"]: |
1473 for instance in transitions[i].getinstances(): |
1482 for instance in transition.getinstances(): |
1474 if isinstance(instance, PLCOpenClasses["fbdObjects_block"]): |
1483 if isinstance(instance, PLCOpenParser.GetElementClass("block", "fbdObjects")): |
1475 self.removepouVar(instance.gettypeName(), |
1484 self.removepouVar(instance.gettypeName(), |
1476 instance.getinstanceName()) |
1485 instance.getinstanceName()) |
1477 transitions.pop(i) |
1486 self.transitions.remove(transition) |
1478 removed = True |
1487 removed = True |
1479 i += 1 |
1488 break |
1480 if not removed: |
1489 if not removed: |
1481 raise ValueError, _("Transition with name %s doesn't exist!")%name |
1490 raise ValueError, _("Transition with name %s doesn't exist!")%name |
1482 setattr(cls, "removetransition", removetransition) |
1491 setattr(cls, "removetransition", removetransition) |
1483 |
1492 |
1484 def addaction(self, name, type): |
1493 def addaction(self, name, body_type): |
1485 if not self.actions: |
1494 if not self.actions: |
1486 self.addactions() |
1495 self.addactions() |
1487 self.actions.setaction([]) |
1496 self.actions.setaction([]) |
1488 action = PLCOpenClasses["actions_action"]() |
1497 action = PLCOpenParser.CreateElement("action", "actions") |
1489 action.setname(name) |
1498 action.setname(name) |
1490 action.setbodyType(type) |
1499 action.setbodyType(body_type) |
1491 self.actions.appendaction(action) |
1500 self.actions.appendaction(action) |
1492 setattr(cls, "addaction", addaction) |
1501 setattr(cls, "addaction", addaction) |
1493 |
1502 |
1494 def getaction(self, name): |
1503 def getaction(self, name): |
1495 if self.actions: |
1504 if self.actions: |
1505 return [] |
1514 return [] |
1506 setattr(cls, "getactionList", getactionList) |
1515 setattr(cls, "getactionList", getactionList) |
1507 |
1516 |
1508 def removeaction(self, name): |
1517 def removeaction(self, name): |
1509 if self.actions: |
1518 if self.actions: |
1510 actions = self.actions.getaction() |
|
1511 i = 0 |
|
1512 removed = False |
1519 removed = False |
1513 while i < len(actions) and not removed: |
1520 for action in self.actions.getaction(): |
1514 if actions[i].getname() == name: |
1521 if action.getname() == name: |
1515 if actions[i].getbodyType() in ["FBD", "LD", "SFC"]: |
1522 if action.getbodyType() in ["FBD", "LD", "SFC"]: |
1516 for instance in actions[i].getinstances(): |
1523 for instance in action.getinstances(): |
1517 if isinstance(instance, PLCOpenClasses["fbdObjects_block"]): |
1524 if isinstance(instance, PLCOpenParser.GetElementClass("block", "fbdObjects")): |
1518 self.removepouVar(instance.gettypeName(), |
1525 self.removepouVar(instance.gettypeName(), |
1519 instance.getinstanceName()) |
1526 instance.getinstanceName()) |
1520 actions.pop(i) |
1527 self.actions.remove(action) |
1521 removed = True |
1528 removed = True |
1522 i += 1 |
1529 break |
1523 if not removed: |
1530 if not removed: |
1524 raise ValueError, _("Action with name %s doesn't exist!")%name |
1531 raise ValueError, _("Action with name %s doesn't exist!")%name |
1525 setattr(cls, "removeaction", removeaction) |
1532 setattr(cls, "removeaction", removeaction) |
1526 |
1533 |
1527 def updateElementName(self, old_name, new_name): |
1534 def updateElementName(self, old_name, new_name): |
1528 if self.interface: |
1535 if self.interface: |
1529 for content in self.interface.getcontent(): |
1536 for content in self.interface.getcontent(): |
1530 for var in content["value"].getvariable(): |
1537 for var in content.getvariable(): |
1531 var_address = var.getaddress() |
1538 var_address = var.getaddress() |
1532 if var_address is not None: |
1539 if var_address is not None: |
1533 if var_address == old_name: |
1540 if var_address == old_name: |
1534 var.setaddress(new_name) |
1541 var.setaddress(new_name) |
1535 if var.getname() == old_name: |
1542 if var.getname() == old_name: |
1536 var.setname(new_name) |
1543 var.setname(new_name) |
1537 var_type_content = var.gettype().getcontent() |
1544 var_type_content = var.gettype().getcontent() |
1538 if var_type_content["name"] == "derived": |
1545 if var_type_content.getLocalTag() == "derived": |
1539 if var_type_content["value"].getname() == old_name: |
1546 if var_type_content.getname() == old_name: |
1540 var_type_content["value"].setname(new_name) |
1547 var_type_content.setname(new_name) |
1541 self.body[0].updateElementName(old_name, new_name) |
1548 self.body[0].updateElementName(old_name, new_name) |
1542 for action in self.getactionList(): |
1549 for action in self.getactionList(): |
1543 action.updateElementName(old_name, new_name) |
1550 action.updateElementName(old_name, new_name) |
1544 for transition in self.gettransitionList(): |
1551 for transition in self.gettransitionList(): |
1545 transition.updateElementName(old_name, new_name) |
1552 transition.updateElementName(old_name, new_name) |
1546 setattr(cls, "updateElementName", updateElementName) |
1553 setattr(cls, "updateElementName", updateElementName) |
1547 |
1554 |
1548 def updateElementAddress(self, address_model, new_leading): |
1555 def updateElementAddress(self, address_model, new_leading): |
1549 if self.interface: |
1556 if self.interface: |
1550 for content in self.interface.getcontent(): |
1557 for content in self.interface.getcontent(): |
1551 for var in content["value"].getvariable(): |
1558 for var in content.getvariable(): |
1552 var_address = var.getaddress() |
1559 var_address = var.getaddress() |
1553 if var_address is not None: |
1560 if var_address is not None: |
1554 var.setaddress(update_address(var_address, address_model, new_leading)) |
1561 var.setaddress(update_address(var_address, address_model, new_leading)) |
1555 self.body[0].updateElementAddress(address_model, new_leading) |
1562 self.body[0].updateElementAddress(address_model, new_leading) |
1556 for action in self.getactionList(): |
1563 for action in self.getactionList(): |
1560 setattr(cls, "updateElementAddress", updateElementAddress) |
1567 setattr(cls, "updateElementAddress", updateElementAddress) |
1561 |
1568 |
1562 def removeVariableByAddress(self, address): |
1569 def removeVariableByAddress(self, address): |
1563 if self.interface: |
1570 if self.interface: |
1564 for content in self.interface.getcontent(): |
1571 for content in self.interface.getcontent(): |
1565 variables = content["value"].getvariable() |
1572 for variable in content.getvariable(): |
1566 for i in xrange(len(variables)-1, -1, -1): |
1573 if variable.getaddress() == address: |
1567 if variables[i].getaddress() == address: |
1574 content.remove(variable) |
1568 variables.pop(i) |
|
1569 setattr(cls, "removeVariableByAddress", removeVariableByAddress) |
1575 setattr(cls, "removeVariableByAddress", removeVariableByAddress) |
1570 |
1576 |
1571 def removeVariableByFilter(self, address_model): |
1577 def removeVariableByFilter(self, address_model): |
1572 if self.interface: |
1578 if self.interface: |
1573 for content in self.interface.getcontent(): |
1579 for content in self.interface.getcontent(): |
1574 variables = content["value"].getvariable() |
1580 for variable in content.getvariable(): |
1575 for i in xrange(len(variables)-1, -1, -1): |
1581 var_address = variable.getaddress() |
1576 var_address = variables[i].getaddress() |
|
1577 if var_address is not None: |
1582 if var_address is not None: |
1578 result = address_model.match(var_address) |
1583 result = address_model.match(var_address) |
1579 if result is not None: |
1584 if result is not None: |
1580 variables.pop(i) |
1585 content.remove(variable) |
1581 setattr(cls, "removeVariableByFilter", removeVariableByFilter) |
1586 setattr(cls, "removeVariableByFilter", removeVariableByFilter) |
1582 |
1587 |
1583 def Search(self, criteria, parent_infos=[]): |
1588 def Search(self, criteria, parent_infos=[]): |
1584 search_result = [] |
1589 search_result = [] |
1585 filter = criteria["filter"] |
1590 filter = criteria["filter"] |
1587 parent_infos = parent_infos + ["P::%s" % self.getname()] |
1592 parent_infos = parent_infos + ["P::%s" % self.getname()] |
1588 search_result.extend(_Search([("name", self.getname())], criteria, parent_infos)) |
1593 search_result.extend(_Search([("name", self.getname())], criteria, parent_infos)) |
1589 if self.interface is not None: |
1594 if self.interface is not None: |
1590 var_number = 0 |
1595 var_number = 0 |
1591 for content in self.interface.getcontent(): |
1596 for content in self.interface.getcontent(): |
1592 variable_type = searchResultVarTypes.get(content["value"], "var_local") |
1597 variable_type = searchResultVarTypes.get(content, "var_local") |
1593 variables = content["value"].getvariable() |
1598 variables = content.getvariable() |
1594 for modifier, has_modifier in [("constant", content["value"].getconstant()), |
1599 for modifier, has_modifier in [("constant", content.getconstant()), |
1595 ("retain", content["value"].getretain()), |
1600 ("retain", content.getretain()), |
1596 ("non_retain", content["value"].getnonretain())]: |
1601 ("non_retain", content.getnonretain())]: |
1597 if has_modifier: |
1602 if has_modifier: |
1598 for result in TestTextElement(modifier, criteria): |
1603 for result in TestTextElement(modifier, criteria): |
1599 search_result.append((tuple(parent_infos + [variable_type, (var_number, var_number + len(variables)), modifier]),) + result) |
1604 search_result.append((tuple(parent_infos + [variable_type, (var_number, var_number + len(variables)), modifier]),) + result) |
1600 break |
1605 break |
1601 for variable in variables: |
1606 for variable in variables: |
1608 for transition in self.gettransitionList(): |
1613 for transition in self.gettransitionList(): |
1609 search_result.extend(transition.Search(criteria, parent_infos)) |
1614 search_result.extend(transition.Search(criteria, parent_infos)) |
1610 return search_result |
1615 return search_result |
1611 setattr(cls, "Search", Search) |
1616 setattr(cls, "Search", Search) |
1612 |
1617 |
1613 def setbodyType(self, type): |
1618 def setbodyType(self, body_type): |
1614 if type == "IL": |
1619 if body_type in ["IL", "ST", "LD", "FBD", "SFC"]: |
1615 self.body.setcontent({"name" : "IL", "value" : PLCOpenClasses["formattedText"]()}) |
1620 self.body.setcontent(PLCOpenParser.CreateElement(body_type, "body")) |
1616 elif type == "ST": |
|
1617 self.body.setcontent({"name" : "ST", "value" : PLCOpenClasses["formattedText"]()}) |
|
1618 elif type == "LD": |
|
1619 self.body.setcontent({"name" : "LD", "value" : PLCOpenClasses["body_LD"]()}) |
|
1620 elif type == "FBD": |
|
1621 self.body.setcontent({"name" : "FBD", "value" : PLCOpenClasses["body_FBD"]()}) |
|
1622 elif type == "SFC": |
|
1623 self.body.setcontent({"name" : "SFC", "value" : PLCOpenClasses["body_SFC"]()}) |
|
1624 else: |
1621 else: |
1625 raise ValueError, "%s isn't a valid body type!"%type |
1622 raise ValueError, "%s isn't a valid body type!"%type |
1626 |
1623 |
1627 def getbodyType(self): |
1624 def getbodyType(self): |
1628 return self.body.getcontent()["name"] |
1625 return self.body.getcontent().getLocalTag() |
1629 |
1626 |
1630 def resetexecutionOrder(self): |
1627 def resetexecutionOrder(self): |
1631 self.body.resetexecutionOrder() |
1628 self.body.resetexecutionOrder() |
1632 |
1629 |
1633 def compileexecutionOrder(self): |
1630 def compileexecutionOrder(self): |
1661 return self.body.gettext() |
1658 return self.body.gettext() |
1662 |
1659 |
1663 def hasblock(self, name=None, block_type=None): |
1660 def hasblock(self, name=None, block_type=None): |
1664 if self.getbodyType() in ["FBD", "LD", "SFC"]: |
1661 if self.getbodyType() in ["FBD", "LD", "SFC"]: |
1665 for instance in self.getinstances(): |
1662 for instance in self.getinstances(): |
1666 if (isinstance(instance, PLCOpenClasses["fbdObjects_block"]) and |
1663 if (isinstance(instance, PLCOpenParser.GetElementClass("block", "fbdObjects")) and |
1667 (name and instance.getinstanceName() == name or |
1664 (name and instance.getinstanceName() == name or |
1668 block_type and instance.gettypeName() == block_type)): |
1665 block_type and instance.gettypeName() == block_type)): |
1669 return True |
1666 return True |
1670 elif block_type is not None: |
1667 elif block_type is not None: |
1671 return self.body.hasblock(block_type) |
1668 return self.body.hasblock(block_type) |
1676 |
1673 |
1677 def updateElementAddress(self, address_model, new_leading): |
1674 def updateElementAddress(self, address_model, new_leading): |
1678 self.body.updateElementAddress(address_model, new_leading) |
1675 self.body.updateElementAddress(address_model, new_leading) |
1679 |
1676 |
1680 |
1677 |
1681 cls = PLCOpenClasses.get("transitions_transition", None) |
1678 cls = PLCOpenParser.GetElementClass("transition", "transitions") |
1682 if cls: |
1679 if cls: |
1683 setattr(cls, "setbodyType", setbodyType) |
1680 setattr(cls, "setbodyType", setbodyType) |
1684 setattr(cls, "getbodyType", getbodyType) |
1681 setattr(cls, "getbodyType", getbodyType) |
1685 setattr(cls, "resetexecutionOrder", resetexecutionOrder) |
1682 setattr(cls, "resetexecutionOrder", resetexecutionOrder) |
1686 setattr(cls, "compileexecutionOrder", compileexecutionOrder) |
1683 setattr(cls, "compileexecutionOrder", compileexecutionOrder) |
1704 search_result.append((tuple(parent_infos + ["name"]),) + result) |
1701 search_result.append((tuple(parent_infos + ["name"]),) + result) |
1705 search_result.extend(self.body.Search(criteria, parent_infos)) |
1702 search_result.extend(self.body.Search(criteria, parent_infos)) |
1706 return search_result |
1703 return search_result |
1707 setattr(cls, "Search", Search) |
1704 setattr(cls, "Search", Search) |
1708 |
1705 |
1709 cls = PLCOpenClasses.get("actions_action", None) |
1706 cls = PLCOpenParser.GetElementClass("action", "actions") |
1710 if cls: |
1707 if cls: |
1711 setattr(cls, "setbodyType", setbodyType) |
1708 setattr(cls, "setbodyType", setbodyType) |
1712 setattr(cls, "getbodyType", getbodyType) |
1709 setattr(cls, "getbodyType", getbodyType) |
1713 setattr(cls, "resetexecutionOrder", resetexecutionOrder) |
1710 setattr(cls, "resetexecutionOrder", resetexecutionOrder) |
1714 setattr(cls, "compileexecutionOrder", compileexecutionOrder) |
1711 setattr(cls, "compileexecutionOrder", compileexecutionOrder) |
1732 search_result.append((tuple(parent_infos + ["name"]),) + result) |
1729 search_result.append((tuple(parent_infos + ["name"]),) + result) |
1733 search_result.extend(self.body.Search(criteria, parent_infos)) |
1730 search_result.extend(self.body.Search(criteria, parent_infos)) |
1734 return search_result |
1731 return search_result |
1735 setattr(cls, "Search", Search) |
1732 setattr(cls, "Search", Search) |
1736 |
1733 |
1737 cls = PLCOpenClasses.get("body", None) |
1734 cls = PLCOpenParser.GetElementClass("body") |
1738 if cls: |
1735 if cls: |
1739 cls.currentExecutionOrderId = 0 |
1736 cls.currentExecutionOrderId = 0 |
1740 cls.instances_dict = {} |
|
1741 |
|
1742 setattr(cls, "_init_", getattr(cls, "__init__")) |
|
1743 |
|
1744 def __init__(self, *args, **kwargs): |
|
1745 self._init_(*args, **kwargs) |
|
1746 self.instances_dict = {} |
|
1747 setattr(cls, "__init__", __init__) |
|
1748 |
|
1749 setattr(cls, "_loadXMLTree", getattr(cls, "loadXMLTree")) |
|
1750 |
|
1751 def loadXMLTree(self, *args, **kwargs): |
|
1752 self._loadXMLTree(*args, **kwargs) |
|
1753 if self.content["name"] in ["LD","FBD","SFC"]: |
|
1754 self.instances_dict = dict( |
|
1755 [(element["value"].getlocalId(), element) |
|
1756 for element in self.content["value"].getcontent()]) |
|
1757 setattr(cls, "loadXMLTree", loadXMLTree) |
|
1758 |
1737 |
1759 def resetcurrentExecutionOrderId(self): |
1738 def resetcurrentExecutionOrderId(self): |
1760 object.__setattr__(self, "currentExecutionOrderId", 0) |
1739 object.__setattr__(self, "currentExecutionOrderId", 0) |
1761 setattr(cls, "resetcurrentExecutionOrderId", resetcurrentExecutionOrderId) |
1740 setattr(cls, "resetcurrentExecutionOrderId", resetcurrentExecutionOrderId) |
1762 |
1741 |
1764 object.__setattr__(self, "currentExecutionOrderId", self.currentExecutionOrderId + 1) |
1743 object.__setattr__(self, "currentExecutionOrderId", self.currentExecutionOrderId + 1) |
1765 return self.currentExecutionOrderId |
1744 return self.currentExecutionOrderId |
1766 setattr(cls, "getnewExecutionOrderId", getnewExecutionOrderId) |
1745 setattr(cls, "getnewExecutionOrderId", getnewExecutionOrderId) |
1767 |
1746 |
1768 def resetexecutionOrder(self): |
1747 def resetexecutionOrder(self): |
1769 if self.content["name"] == "FBD": |
1748 if self.content.getLocalTag() == "FBD": |
1770 for element in self.content["value"].getcontent(): |
1749 for element in self.content.getcontent(): |
1771 if not isinstance(element["value"], (PLCOpenClasses.get("commonObjects_comment", None), |
1750 if not isinstance(element, (PLCOpenParser.GetElementClass("comment", "commonObjects"), |
1772 PLCOpenClasses.get("commonObjects_connector", None), |
1751 PLCOpenParser.GetElementClass("connector", "commonObjects"), |
1773 PLCOpenClasses.get("commonObjects_continuation", None))): |
1752 PLCOpenParser.GetElementClass("continuation", "commonObjects"))): |
1774 element["value"].setexecutionOrderId(0) |
1753 element.setexecutionOrderId(0) |
1775 else: |
1754 else: |
1776 raise TypeError, _("Can only generate execution order on FBD networks!") |
1755 raise TypeError, _("Can only generate execution order on FBD networks!") |
1777 setattr(cls, "resetexecutionOrder", resetexecutionOrder) |
1756 setattr(cls, "resetexecutionOrder", resetexecutionOrder) |
1778 |
1757 |
1779 def compileexecutionOrder(self): |
1758 def compileexecutionOrder(self): |
1780 if self.content["name"] == "FBD": |
1759 if self.content.getLocalTag() == "FBD": |
1781 self.resetexecutionOrder() |
1760 self.resetexecutionOrder() |
1782 self.resetcurrentExecutionOrderId() |
1761 self.resetcurrentExecutionOrderId() |
1783 for element in self.content["value"].getcontent(): |
1762 for element in self.content.getcontent(): |
1784 if isinstance(element["value"], PLCOpenClasses.get("fbdObjects_outVariable", None)) and element["value"].getexecutionOrderId() == 0: |
1763 if isinstance(element, PLCOpenParser.GetElementClass("outVariable", "fbdObjects")) and element.getexecutionOrderId() == 0: |
1785 connections = element["value"].connectionPointIn.getconnections() |
1764 connections = element.connectionPointIn.getconnections() |
1786 if connections and len(connections) == 1: |
1765 if connections and len(connections) == 1: |
1787 self.compileelementExecutionOrder(connections[0]) |
1766 self.compileelementExecutionOrder(connections[0]) |
1788 element["value"].setexecutionOrderId(self.getnewExecutionOrderId()) |
1767 element.setexecutionOrderId(self.getnewExecutionOrderId()) |
1789 else: |
1768 else: |
1790 raise TypeError, _("Can only generate execution order on FBD networks!") |
1769 raise TypeError, _("Can only generate execution order on FBD networks!") |
1791 setattr(cls, "compileexecutionOrder", compileexecutionOrder) |
1770 setattr(cls, "compileexecutionOrder", compileexecutionOrder) |
1792 |
1771 |
1793 def compileelementExecutionOrder(self, link): |
1772 def compileelementExecutionOrder(self, link): |
1794 if self.content["name"] == "FBD": |
1773 if self.content.getLocalTag() == "FBD": |
1795 localid = link.getrefLocalId() |
1774 localid = link.getrefLocalId() |
1796 instance = self.getcontentInstance(localid) |
1775 instance = self.getcontentInstance(localid) |
1797 if isinstance(instance, PLCOpenClasses.get("fbdObjects_block", None)) and instance.getexecutionOrderId() == 0: |
1776 if isinstance(instance, PLCOpenParser.GetElementClass("block", "fbdObjects")) and instance.getexecutionOrderId() == 0: |
1798 for variable in instance.inputVariables.getvariable(): |
1777 for variable in instance.inputVariables.getvariable(): |
1799 connections = variable.connectionPointIn.getconnections() |
1778 connections = variable.connectionPointIn.getconnections() |
1800 if connections and len(connections) == 1: |
1779 if connections and len(connections) == 1: |
1801 self.compileelementExecutionOrder(connections[0]) |
1780 self.compileelementExecutionOrder(connections[0]) |
1802 instance.setexecutionOrderId(self.getnewExecutionOrderId()) |
1781 instance.setexecutionOrderId(self.getnewExecutionOrderId()) |
1803 elif isinstance(instance, PLCOpenClasses.get("commonObjects_continuation", None)) and instance.getexecutionOrderId() == 0: |
1782 elif isinstance(instance, PLCOpenParser.GetElementClass("continuation", "commonObjects")) and instance.getexecutionOrderId() == 0: |
1804 name = instance.getname() |
1783 name = instance.getname() |
1805 for tmp_instance in self.getcontentInstances(): |
1784 for tmp_instance in self.getcontentInstances(): |
1806 if isinstance(tmp_instance, PLCOpenClasses.get("commonObjects_connector", None)) and tmp_instance.getname() == name and tmp_instance.getexecutionOrderId() == 0: |
1785 if isinstance(tmp_instance, PLCOpenParser.GetElementClass("connector", "commonObjects")) and tmp_instance.getname() == name and tmp_instance.getexecutionOrderId() == 0: |
1807 connections = tmp_instance.connectionPointIn.getconnections() |
1786 connections = tmp_instance.connectionPointIn.getconnections() |
1808 if connections and len(connections) == 1: |
1787 if connections and len(connections) == 1: |
1809 self.compileelementExecutionOrder(connections[0]) |
1788 self.compileelementExecutionOrder(connections[0]) |
1810 else: |
1789 else: |
1811 raise TypeError, _("Can only generate execution order on FBD networks!") |
1790 raise TypeError, _("Can only generate execution order on FBD networks!") |
1812 setattr(cls, "compileelementExecutionOrder", compileelementExecutionOrder) |
1791 setattr(cls, "compileelementExecutionOrder", compileelementExecutionOrder) |
1813 |
1792 |
1814 def setelementExecutionOrder(self, instance, new_executionOrder): |
1793 def setelementExecutionOrder(self, instance, new_executionOrder): |
1815 if self.content["name"] == "FBD": |
1794 if self.contentLgetLocalTag() == "FBD": |
1816 old_executionOrder = instance.getexecutionOrderId() |
1795 old_executionOrder = instance.getexecutionOrderId() |
1817 if old_executionOrder is not None and old_executionOrder != 0 and new_executionOrder != 0: |
1796 if old_executionOrder is not None and old_executionOrder != 0 and new_executionOrder != 0: |
1818 for element in self.content["value"].getcontent(): |
1797 for element in self.content.getcontent(): |
1819 if element["value"] != instance and not isinstance(element["value"], PLCOpenClasses.get("commonObjects_comment", None)): |
1798 if element != instance and not isinstance(element, PLCOpenParser.GetElementClass("comment", "commonObjects")): |
1820 element_executionOrder = element["value"].getexecutionOrderId() |
1799 element_executionOrder = element.getexecutionOrderId() |
1821 if old_executionOrder <= element_executionOrder <= new_executionOrder: |
1800 if old_executionOrder <= element_executionOrder <= new_executionOrder: |
1822 element["value"].setexecutionOrderId(element_executionOrder - 1) |
1801 element.setexecutionOrderId(element_executionOrder - 1) |
1823 if new_executionOrder <= element_executionOrder <= old_executionOrder: |
1802 if new_executionOrder <= element_executionOrder <= old_executionOrder: |
1824 element["value"].setexecutionOrderId(element_executionOrder + 1) |
1803 element.setexecutionOrderId(element_executionOrder + 1) |
1825 instance.setexecutionOrderId(new_executionOrder) |
1804 instance.setexecutionOrderId(new_executionOrder) |
1826 else: |
1805 else: |
1827 raise TypeError, _("Can only generate execution order on FBD networks!") |
1806 raise TypeError, _("Can only generate execution order on FBD networks!") |
1828 setattr(cls, "setelementExecutionOrder", setelementExecutionOrder) |
1807 setattr(cls, "setelementExecutionOrder", setelementExecutionOrder) |
1829 |
1808 |
1830 def appendcontentInstance(self, name, instance): |
1809 def appendcontentInstance(self, name, instance): |
1831 if self.content["name"] in ["LD","FBD","SFC"]: |
1810 if self.content.getLocalTag() in ["LD","FBD","SFC"]: |
1832 element = {"name" : name, "value" : instance} |
1811 self.content.appendcontent(instance) |
1833 self.content["value"].appendcontent(element) |
|
1834 self.instances_dict[instance.getlocalId()] = element |
|
1835 else: |
1812 else: |
1836 raise TypeError, _("%s body don't have instances!")%self.content["name"] |
1813 raise TypeError, _("%s body don't have instances!")%self.content["name"] |
1837 setattr(cls, "appendcontentInstance", appendcontentInstance) |
1814 setattr(cls, "appendcontentInstance", appendcontentInstance) |
1838 |
1815 |
1839 def getcontentInstances(self): |
1816 def getcontentInstances(self): |
1840 if self.content["name"] in ["LD","FBD","SFC"]: |
1817 if self.content.getLocalTag() in ["LD","FBD","SFC"]: |
1841 instances = [] |
1818 return self.content.getcontent() |
1842 for element in self.content["value"].getcontent(): |
|
1843 instances.append(element["value"]) |
|
1844 return instances |
|
1845 else: |
1819 else: |
1846 raise TypeError, _("%s body don't have instances!")%self.content["name"] |
1820 raise TypeError, _("%s body don't have instances!")%self.content["name"] |
1847 setattr(cls, "getcontentInstances", getcontentInstances) |
1821 setattr(cls, "getcontentInstances", getcontentInstances) |
1848 |
1822 |
1849 def getcontentInstance(self, id): |
1823 def getcontentInstance(self, local_id): |
1850 if self.content["name"] in ["LD","FBD","SFC"]: |
1824 if self.content.getLocalTag() in ["LD","FBD","SFC"]: |
1851 instance = self.instances_dict.get(id, None) |
1825 instance = self.content.xpath("*[@localId=%d]" % local_id) |
1852 if instance is not None: |
1826 if len(instance) > 0: |
1853 return instance["value"] |
1827 return instance[0] |
1854 return None |
1828 return None |
1855 else: |
1829 else: |
1856 raise TypeError, _("%s body don't have instances!")%self.content["name"] |
1830 raise TypeError, _("%s body don't have instances!")%self.content["name"] |
1857 setattr(cls, "getcontentInstance", getcontentInstance) |
1831 setattr(cls, "getcontentInstance", getcontentInstance) |
1858 |
1832 |
1859 def getcontentRandomInstance(self, exclude): |
1833 def getcontentRandomInstance(self, exclude): |
1860 if self.content["name"] in ["LD","FBD","SFC"]: |
1834 if self.content.getLocalTag() in ["LD","FBD","SFC"]: |
1861 ids = self.instances_dict.viewkeys() - exclude |
1835 instance = self.content.xpath("*[regexp:test(@localId,'(%s)')]" % "|".join(map(str, exclude))) |
1862 if len(ids) > 0: |
1836 if len(instance) > 0: |
1863 return self.instances_dict[ids.pop()]["value"] |
1837 return instance[0] |
1864 return None |
1838 return None |
1865 else: |
1839 else: |
1866 raise TypeError, _("%s body don't have instances!")%self.content["name"] |
1840 raise TypeError, _("%s body don't have instances!")%self.content["name"] |
1867 setattr(cls, "getcontentRandomInstance", getcontentRandomInstance) |
1841 setattr(cls, "getcontentRandomInstance", getcontentRandomInstance) |
1868 |
1842 |
1869 def getcontentInstanceByName(self, name): |
1843 def getcontentInstanceByName(self, name): |
1870 if self.content["name"] in ["LD","FBD","SFC"]: |
1844 if self.content.getLocalTag() in ["LD","FBD","SFC"]: |
1871 for element in self.content["value"].getcontent(): |
1845 instance = self.content.xpath("ppx:block[@instanceName=%s]" % name, namespaces=PLCOpenParser.NSMAP) |
1872 if isinstance(element["value"], PLCOpenClasses.get("fbdObjects_block", None)) and element["value"].getinstanceName() == name: |
1846 if len(instance) > 0: |
1873 return element["value"] |
1847 return instance[0] |
1848 return None |
|
1874 else: |
1849 else: |
1875 raise TypeError, _("%s body don't have instances!")%self.content["name"] |
1850 raise TypeError, _("%s body don't have instances!")%self.content["name"] |
1876 setattr(cls, "getcontentInstanceByName", getcontentInstanceByName) |
1851 setattr(cls, "getcontentInstanceByName", getcontentInstanceByName) |
1877 |
1852 |
1878 def removecontentInstance(self, id): |
1853 def removecontentInstance(self, local_id): |
1879 if self.content["name"] in ["LD","FBD","SFC"]: |
1854 if self.content.getLocalTag() in ["LD","FBD","SFC"]: |
1880 element = self.instances_dict.pop(id, None) |
1855 instance = self.content.xpath("*[@localId=%d]" % local_id) |
1881 if element is not None: |
1856 if len(instance) > 0: |
1882 self.content["value"].getcontent().remove(element) |
1857 self.content.remove(instance[0]) |
1883 else: |
1858 else: |
1884 raise ValueError, _("Instance with id %d doesn't exist!")%id |
1859 raise ValueError, _("Instance with id %d doesn't exist!")%id |
1885 else: |
1860 else: |
1886 raise TypeError, "%s body don't have instances!"%self.content["name"] |
1861 raise TypeError, "%s body don't have instances!"%self.content["name"] |
1887 setattr(cls, "removecontentInstance", removecontentInstance) |
1862 setattr(cls, "removecontentInstance", removecontentInstance) |
1888 |
1863 |
1889 def settext(self, text): |
1864 def settext(self, text): |
1890 if self.content["name"] in ["IL","ST"]: |
1865 if self.content.getLocalTag() in ["IL","ST"]: |
1891 self.content["value"].settext(text) |
1866 self.content.settext(text) |
1892 else: |
1867 else: |
1893 raise TypeError, _("%s body don't have text!")%self.content["name"] |
1868 raise TypeError, _("%s body don't have text!")%self.content["name"] |
1894 setattr(cls, "settext", settext) |
1869 setattr(cls, "settext", settext) |
1895 |
1870 |
1896 def gettext(self): |
1871 def gettext(self): |
1897 if self.content["name"] in ["IL","ST"]: |
1872 if self.content.getLocalTag() in ["IL","ST"]: |
1898 return self.content["value"].gettext() |
1873 return self.content.gettext() |
1899 else: |
1874 else: |
1900 raise TypeError, _("%s body don't have text!")%self.content["name"] |
1875 raise TypeError, _("%s body don't have text!")%self.content["name"] |
1901 setattr(cls, "gettext", gettext) |
1876 setattr(cls, "gettext", gettext) |
1902 |
1877 |
1903 def hasblock(self, block_type): |
1878 def hasblock(self, block_type): |
1904 if self.content["name"] in ["IL","ST"]: |
1879 if self.content.getLocalTag() in ["IL","ST"]: |
1905 return self.content["value"].hasblock(block_type) |
1880 return self.content.hasblock(block_type) |
1906 else: |
1881 else: |
1907 raise TypeError, _("%s body don't have text!")%self.content["name"] |
1882 raise TypeError, _("%s body don't have text!")%self.content["name"] |
1908 setattr(cls, "hasblock", hasblock) |
1883 setattr(cls, "hasblock", hasblock) |
1909 |
1884 |
1910 def updateElementName(self, old_name, new_name): |
1885 def updateElementName(self, old_name, new_name): |
1911 if self.content["name"] in ["IL", "ST"]: |
1886 if self.content.getLocalTag() in ["IL", "ST"]: |
1912 self.content["value"].updateElementName(old_name, new_name) |
1887 self.content.updateElementName(old_name, new_name) |
1913 else: |
1888 else: |
1914 for element in self.content["value"].getcontent(): |
1889 for element in self.content.getcontent(): |
1915 element["value"].updateElementName(old_name, new_name) |
1890 element.updateElementName(old_name, new_name) |
1916 setattr(cls, "updateElementName", updateElementName) |
1891 setattr(cls, "updateElementName", updateElementName) |
1917 |
1892 |
1918 def updateElementAddress(self, address_model, new_leading): |
1893 def updateElementAddress(self, address_model, new_leading): |
1919 if self.content["name"] in ["IL", "ST"]: |
1894 if self.content.getLocalTag() in ["IL", "ST"]: |
1920 self.content["value"].updateElementAddress(address_model, new_leading) |
1895 self.content.updateElementAddress(address_model, new_leading) |
1921 else: |
1896 else: |
1922 for element in self.content["value"].getcontent(): |
1897 for element in self.content.getcontent(): |
1923 element["value"].updateElementAddress(address_model, new_leading) |
1898 element.updateElementAddress(address_model, new_leading) |
1924 setattr(cls, "updateElementAddress", updateElementAddress) |
1899 setattr(cls, "updateElementAddress", updateElementAddress) |
1925 |
1900 |
1926 def Search(self, criteria, parent_infos=[]): |
1901 def Search(self, criteria, parent_infos=[]): |
1927 if self.content["name"] in ["IL", "ST"]: |
1902 if self.content.getLocalTag() in ["IL", "ST"]: |
1928 search_result = self.content["value"].Search(criteria, parent_infos + ["body", 0]) |
1903 search_result = self.content.Search(criteria, parent_infos + ["body", 0]) |
1929 else: |
1904 else: |
1930 search_result = [] |
1905 search_result = [] |
1931 for element in self.content["value"].getcontent(): |
1906 for element in self.content.getcontent(): |
1932 search_result.extend(element["value"].Search(criteria, parent_infos)) |
1907 search_result.extend(element.Search(criteria, parent_infos)) |
1933 return search_result |
1908 return search_result |
1934 setattr(cls, "Search", Search) |
1909 setattr(cls, "Search", Search) |
1935 |
1910 |
1936 def getx(self): |
1911 def getx(self): |
1937 return self.position.getx() |
1912 return self.position.getx() |
1970 return bbox |
1945 return bbox |
1971 |
1946 |
1972 def _filterConnections(connectionPointIn, localId, connections): |
1947 def _filterConnections(connectionPointIn, localId, connections): |
1973 in_connections = connectionPointIn.getconnections() |
1948 in_connections = connectionPointIn.getconnections() |
1974 if in_connections is not None: |
1949 if in_connections is not None: |
1975 to_delete = [] |
1950 for connection in in_connections: |
1976 for i, connection in enumerate(in_connections): |
|
1977 connected = connection.getrefLocalId() |
1951 connected = connection.getrefLocalId() |
1978 if not connections.has_key((localId, connected)) and \ |
1952 if not connections.has_key((localId, connected)) and \ |
1979 not connections.has_key((connected, localId)): |
1953 not connections.has_key((connected, localId)): |
1980 to_delete.append(i) |
1954 connectionPointIn.remove(connection) |
1981 to_delete.reverse() |
|
1982 for i in to_delete: |
|
1983 connectionPointIn.removeconnection(i) |
|
1984 |
1955 |
1985 def _filterConnectionsSingle(self, connections): |
1956 def _filterConnectionsSingle(self, connections): |
1986 if self.connectionPointIn is not None: |
1957 if self.connectionPointIn is not None: |
1987 _filterConnections(self.connectionPointIn, self.localId, connections) |
1958 _filterConnections(self.connectionPointIn, self.localId, connections) |
1988 |
1959 |
1989 def _filterConnectionsMultiple(self, connections): |
1960 def _filterConnectionsMultiple(self, connections): |
1990 for connectionPointIn in self.getconnectionPointIn(): |
1961 for connectionPointIn in self.getconnectionPointIn(): |
1991 _filterConnections(connectionPointIn, self.localId, connections) |
1962 _filterConnections(connectionPointIn, self.localId, connections) |
1992 |
1963 |
1993 def _getconnectionsdefinition(instance, connections_end): |
1964 def _getconnectionsdefinition(instance, connections_end): |
1994 id = instance.getlocalId() |
1965 local_id = instance.getlocalId() |
1995 return dict([((id, end), True) for end in connections_end]) |
1966 return dict([((local_id, end), True) for end in connections_end]) |
1996 |
1967 |
1997 def _updateConnectionsId(connectionPointIn, translation): |
1968 def _updateConnectionsId(connectionPointIn, translation): |
1998 connections_end = [] |
1969 connections_end = [] |
1999 connections = connectionPointIn.getconnections() |
1970 connections = connectionPointIn.getconnections() |
2000 if connections is not None: |
1971 if connections is not None: |
2061 "update": {"none": lambda self, translation: {}, |
2032 "update": {"none": lambda self, translation: {}, |
2062 "single": _updateConnectionsIdSingle, |
2033 "single": _updateConnectionsIdSingle, |
2063 "multiple": _updateConnectionsIdMultiple}, |
2034 "multiple": _updateConnectionsIdMultiple}, |
2064 } |
2035 } |
2065 |
2036 |
2066 def _initElementClass(name, classname, connectionPointInType="none"): |
2037 def _initElementClass(name, parent, connectionPointInType="none"): |
2067 ElementNameToClass[name] = classname |
2038 cls = PLCOpenParser.GetElementClass(name, parent) |
2068 cls = PLCOpenClasses.get(classname, None) |
|
2069 if cls: |
2039 if cls: |
2070 setattr(cls, "getx", getx) |
2040 setattr(cls, "getx", getx) |
2071 setattr(cls, "gety", gety) |
2041 setattr(cls, "gety", gety) |
2072 setattr(cls, "setx", setx) |
2042 setattr(cls, "setx", setx) |
2073 setattr(cls, "sety", sety) |
2043 setattr(cls, "sety", sety) |
2208 infos["outputs"].append(_getconnectioninfos(self, self.connectionPointOut)) |
2178 infos["outputs"].append(_getconnectioninfos(self, self.connectionPointOut)) |
2209 infos["specific_values"]["connectors"] = len(infos["inputs"]) |
2179 infos["specific_values"]["connectors"] = len(infos["inputs"]) |
2210 return infos |
2180 return infos |
2211 return getdivergenceinfos |
2181 return getdivergenceinfos |
2212 |
2182 |
2213 cls = _initElementClass("comment", "commonObjects_comment") |
2183 cls = _initElementClass("comment", "commonObjects") |
2214 if cls: |
2184 if cls: |
2215 def getinfos(self): |
2185 def getinfos(self): |
2216 infos = _getelementinfos(self) |
2186 infos = _getelementinfos(self) |
2217 infos["type"] = "comment" |
2187 infos["type"] = "comment" |
2218 infos["specific_values"]["content"] = self.getcontentText() |
2188 infos["specific_values"]["content"] = self.getcontentText() |
2237 |
2207 |
2238 def Search(self, criteria, parent_infos=[]): |
2208 def Search(self, criteria, parent_infos=[]): |
2239 return self.content.Search(criteria, parent_infos + ["comment", self.getlocalId(), "content"]) |
2209 return self.content.Search(criteria, parent_infos + ["comment", self.getlocalId(), "content"]) |
2240 setattr(cls, "Search", Search) |
2210 setattr(cls, "Search", Search) |
2241 |
2211 |
2242 cls = _initElementClass("block", "fbdObjects_block") |
2212 cls = _initElementClass("block", "fbdObjects") |
2243 if cls: |
2213 if cls: |
2244 def getBoundingBox(self): |
2214 def getBoundingBox(self): |
2245 bbox = _getBoundingBox(self) |
2215 bbox = _getBoundingBox(self) |
2246 for input in self.inputVariables.getvariable(): |
2216 for input in self.inputVariables.getvariable(): |
2247 bbox.union(_getConnectionsBoundingBox(input.connectionPointIn)) |
2217 bbox.union(_getConnectionsBoundingBox(input.connectionPointIn)) |
2296 for result in TestTextElement(variable.getformalParameter(), criteria): |
2266 for result in TestTextElement(variable.getformalParameter(), criteria): |
2297 search_result.append((tuple(parent_infos + ["output", i]),) + result) |
2267 search_result.append((tuple(parent_infos + ["output", i]),) + result) |
2298 return search_result |
2268 return search_result |
2299 setattr(cls, "Search", Search) |
2269 setattr(cls, "Search", Search) |
2300 |
2270 |
2301 cls = _initElementClass("leftPowerRail", "ldObjects_leftPowerRail") |
2271 cls = _initElementClass("leftPowerRail", "ldObjects") |
2302 if cls: |
2272 if cls: |
2303 setattr(cls, "getinfos", _getpowerrailinfosFunction("leftPowerRail")) |
2273 setattr(cls, "getinfos", _getpowerrailinfosFunction("leftPowerRail")) |
2304 |
2274 |
2305 cls = _initElementClass("rightPowerRail", "ldObjects_rightPowerRail", "multiple") |
2275 cls = _initElementClass("rightPowerRail", "ldObjects", "multiple") |
2306 if cls: |
2276 if cls: |
2307 setattr(cls, "getinfos", _getpowerrailinfosFunction("rightPowerRail")) |
2277 setattr(cls, "getinfos", _getpowerrailinfosFunction("rightPowerRail")) |
2308 |
2278 |
2309 cls = _initElementClass("contact", "ldObjects_contact", "single") |
2279 cls = _initElementClass("contact", "ldObjects", "single") |
2310 if cls: |
2280 if cls: |
2311 setattr(cls, "getinfos", _getldelementinfosFunction("contact")) |
2281 setattr(cls, "getinfos", _getldelementinfosFunction("contact")) |
2312 |
2282 |
2313 def updateElementName(self, old_name, new_name): |
2283 def updateElementName(self, old_name, new_name): |
2314 if self.variable == old_name: |
2284 if self.variable == old_name: |
2321 |
2291 |
2322 def Search(self, criteria, parent_infos=[]): |
2292 def Search(self, criteria, parent_infos=[]): |
2323 return _Search([("reference", self.getvariable())], criteria, parent_infos + ["contact", self.getlocalId()]) |
2293 return _Search([("reference", self.getvariable())], criteria, parent_infos + ["contact", self.getlocalId()]) |
2324 setattr(cls, "Search", Search) |
2294 setattr(cls, "Search", Search) |
2325 |
2295 |
2326 cls = _initElementClass("coil", "ldObjects_coil", "single") |
2296 cls = _initElementClass("coil", "ldObjects", "single") |
2327 if cls: |
2297 if cls: |
2328 setattr(cls, "getinfos", _getldelementinfosFunction("coil")) |
2298 setattr(cls, "getinfos", _getldelementinfosFunction("coil")) |
2329 |
2299 |
2330 def updateElementName(self, old_name, new_name): |
2300 def updateElementName(self, old_name, new_name): |
2331 if self.variable == old_name: |
2301 if self.variable == old_name: |
2338 |
2308 |
2339 def Search(self, criteria, parent_infos=[]): |
2309 def Search(self, criteria, parent_infos=[]): |
2340 return _Search([("reference", self.getvariable())], criteria, parent_infos + ["coil", self.getlocalId()]) |
2310 return _Search([("reference", self.getvariable())], criteria, parent_infos + ["coil", self.getlocalId()]) |
2341 setattr(cls, "Search", Search) |
2311 setattr(cls, "Search", Search) |
2342 |
2312 |
2343 cls = _initElementClass("step", "sfcObjects_step", "single") |
2313 cls = _initElementClass("step", "sfcObjects", "single") |
2344 if cls: |
2314 if cls: |
2345 def getinfos(self): |
2315 def getinfos(self): |
2346 infos = _getelementinfos(self) |
2316 infos = _getelementinfos(self) |
2347 infos["type"] = "step" |
2317 infos["type"] = "step" |
2348 specific_values = infos["specific_values"] |
2318 specific_values = infos["specific_values"] |
2359 |
2329 |
2360 def Search(self, criteria, parent_infos=[]): |
2330 def Search(self, criteria, parent_infos=[]): |
2361 return _Search([("name", self.getname())], criteria, parent_infos + ["step", self.getlocalId()]) |
2331 return _Search([("name", self.getname())], criteria, parent_infos + ["step", self.getlocalId()]) |
2362 setattr(cls, "Search", Search) |
2332 setattr(cls, "Search", Search) |
2363 |
2333 |
2364 cls = PLCOpenClasses.get("transition_condition", None) |
2334 cls = PLCOpenParser.GetElementClass("condition", "transition") |
2365 if cls: |
2335 if cls: |
2366 def compatibility(self, tree): |
2336 def compatibility(self, tree): |
2367 connections = [] |
2337 connections = [] |
2368 for child in tree.childNodes: |
2338 for child in tree.childNodes: |
2369 if child.nodeName == "connection": |
2339 if child.nodeName == "connection": |
2376 node.childNodes.append(relPosition) |
2346 node.childNodes.append(relPosition) |
2377 node.childNodes.extend(connections) |
2347 node.childNodes.extend(connections) |
2378 tree.childNodes = [node] |
2348 tree.childNodes = [node] |
2379 setattr(cls, "compatibility", compatibility) |
2349 setattr(cls, "compatibility", compatibility) |
2380 |
2350 |
2381 cls = _initElementClass("transition", "sfcObjects_transition") |
2351 cls = _initElementClass("transition", "sfcObjects") |
2382 if cls: |
2352 if cls: |
2383 def getinfos(self): |
2353 def getinfos(self): |
2384 infos = _getelementinfos(self) |
2354 infos = _getelementinfos(self) |
2385 infos["type"] = "transition" |
2355 infos["type"] = "transition" |
2386 specific_values = infos["specific_values"] |
2356 specific_values = infos["specific_values"] |
2397 infos["inputs"].append(_getconnectioninfos(self, self.connectionPointIn, True)) |
2367 infos["inputs"].append(_getconnectioninfos(self, self.connectionPointIn, True)) |
2398 infos["outputs"].append(_getconnectioninfos(self, self.connectionPointOut)) |
2368 infos["outputs"].append(_getconnectioninfos(self, self.connectionPointOut)) |
2399 return infos |
2369 return infos |
2400 setattr(cls, "getinfos", getinfos) |
2370 setattr(cls, "getinfos", getinfos) |
2401 |
2371 |
2402 def setconditionContent(self, type, value): |
2372 def setconditionContent(self, condition_type, value): |
2403 if not self.condition: |
2373 if not self.condition: |
2404 self.addcondition() |
2374 self.addcondition() |
2405 if type == "reference": |
2375 if condition_type == "reference": |
2406 condition = PLCOpenClasses["condition_reference"]() |
2376 condition = PLCOpenParser.CreateElement("reference", "condition") |
2407 condition.setname(value) |
2377 condition.setname(value) |
2408 elif type == "inline": |
2378 elif condition_type == "inline": |
2409 condition = PLCOpenClasses["condition_inline"]() |
2379 condition = PLCOpenParser.CreateElement("inline", "condition") |
2410 condition.setcontent({"name" : "ST", "value" : PLCOpenClasses["formattedText"]()}) |
2380 condition.setcontent(PLCOpenParser.GetElementClass("ST", "inline")) |
2411 condition.settext(value) |
2381 condition.settext(value) |
2412 elif type == "connection": |
2382 elif condition_type == "connection": |
2413 type = "connectionPointIn" |
2383 condition = PLCOpenParser.CreateElementClass("connectionPointIn") |
2414 condition = PLCOpenClasses["connectionPointIn"]() |
2384 self.condition.setcontent(condition) |
2415 self.condition.setcontent({"name" : type, "value" : condition}) |
|
2416 setattr(cls, "setconditionContent", setconditionContent) |
2385 setattr(cls, "setconditionContent", setconditionContent) |
2417 |
2386 |
2418 def getconditionContent(self): |
2387 def getconditionContent(self): |
2419 if self.condition: |
2388 if self.condition: |
2420 content = self.condition.getcontent() |
2389 content = self.condition.getcontent() |
2421 values = {"type" : content["name"]} |
2390 values = {"type" : content.getLocalTag()} |
2422 if values["type"] == "reference": |
2391 if values["type"] == "reference": |
2423 values["value"] = content["value"].getname() |
2392 values["value"] = content.getname() |
2424 elif values["type"] == "inline": |
2393 elif values["type"] == "inline": |
2425 values["value"] = content["value"].gettext() |
2394 values["value"] = content.gettext() |
2426 elif values["type"] == "connectionPointIn": |
2395 elif values["type"] == "connectionPointIn": |
2427 values["type"] = "connection" |
2396 values["type"] = "connection" |
2428 values["value"] = content["value"] |
2397 values["value"] = content |
2429 return values |
2398 return values |
2430 return "" |
2399 return "" |
2431 setattr(cls, "getconditionContent", getconditionContent) |
2400 setattr(cls, "getconditionContent", getconditionContent) |
2432 |
2401 |
2433 def getconditionConnection(self): |
2402 def getconditionConnection(self): |
2434 if self.condition: |
2403 if self.condition: |
2435 content = self.condition.getcontent() |
2404 content = self.condition.getcontent() |
2436 if content["name"] == "connectionPointIn": |
2405 if content.getLocalTag() == "connectionPointIn": |
2437 return content["value"] |
2406 return content |
2438 return None |
2407 return None |
2439 setattr(cls, "getconditionConnection", getconditionConnection) |
2408 setattr(cls, "getconditionConnection", getconditionConnection) |
2440 |
2409 |
2441 def getBoundingBox(self): |
2410 def getBoundingBox(self): |
2442 bbox = _getBoundingBoxSingle(self) |
2411 bbox = _getBoundingBoxSingle(self) |
2471 setattr(cls, "updateConnectionsId", updateConnectionsId) |
2440 setattr(cls, "updateConnectionsId", updateConnectionsId) |
2472 |
2441 |
2473 def updateElementName(self, old_name, new_name): |
2442 def updateElementName(self, old_name, new_name): |
2474 if self.condition: |
2443 if self.condition: |
2475 content = self.condition.getcontent() |
2444 content = self.condition.getcontent() |
2476 if content["name"] == "reference": |
2445 content_name = content.getLocalTag() |
2477 if content["value"].getname() == old_name: |
2446 if content_name == "reference": |
2478 content["value"].setname(new_name) |
2447 if content.getname() == old_name: |
2479 elif content["name"] == "inline": |
2448 content.setname(new_name) |
2480 content["value"].updateElementName(old_name, new_name) |
2449 elif content_name == "inline": |
2450 content.updateElementName(old_name, new_name) |
|
2481 setattr(cls, "updateElementName", updateElementName) |
2451 setattr(cls, "updateElementName", updateElementName) |
2482 |
2452 |
2483 def updateElementAddress(self, address_model, new_leading): |
2453 def updateElementAddress(self, address_model, new_leading): |
2484 if self.condition: |
2454 if self.condition: |
2485 content = self.condition.getcontent() |
2455 content = self.condition.getcontent() |
2486 if content["name"] == "reference": |
2456 content_name = content.getLocalTag() |
2487 content["value"].setname(update_address(content["value"].getname(), address_model, new_leading)) |
2457 if content_name == "reference": |
2488 elif content["name"] == "inline": |
2458 content.setname(update_address(content.getname(), address_model, new_leading)) |
2489 content["value"].updateElementAddress(address_model, new_leading) |
2459 elif content_name == "inline": |
2460 content.updateElementAddress(address_model, new_leading) |
|
2490 setattr(cls, "updateElementAddress", updateElementAddress) |
2461 setattr(cls, "updateElementAddress", updateElementAddress) |
2491 |
2462 |
2492 def getconnections(self): |
2463 def getconnections(self): |
2493 condition_connection = self.getconditionConnection() |
2464 condition_connection = self.getconditionConnection() |
2494 if condition_connection: |
2465 if condition_connection: |
2498 |
2469 |
2499 def Search(self, criteria, parent_infos=[]): |
2470 def Search(self, criteria, parent_infos=[]): |
2500 parent_infos = parent_infos + ["transition", self.getlocalId()] |
2471 parent_infos = parent_infos + ["transition", self.getlocalId()] |
2501 search_result = [] |
2472 search_result = [] |
2502 content = self.condition.getcontent() |
2473 content = self.condition.getcontent() |
2503 if content["name"] == "reference": |
2474 content_name = content.getLocalTag() |
2504 search_result.extend(_Search([("reference", content["value"].getname())], criteria, parent_infos)) |
2475 if content_name == "reference": |
2505 elif content["name"] == "inline": |
2476 search_result.extend(_Search([("reference", content.getname())], criteria, parent_infos)) |
2506 search_result.extend(content["value"].Search(criteria, parent_infos + ["inline"])) |
2477 elif content_name == "inline": |
2478 search_result.extend(content.Search(criteria, parent_infos + ["inline"])) |
|
2507 return search_result |
2479 return search_result |
2508 setattr(cls, "Search", Search) |
2480 setattr(cls, "Search", Search) |
2509 |
2481 |
2510 cls = _initElementClass("selectionDivergence", "sfcObjects_selectionDivergence", "single") |
2482 cls = _initElementClass("selectionDivergence", "sfcObjects_selectionDivergence", "single") |
2511 if cls: |
2483 if cls: |
2535 |
2507 |
2536 def Search(self, criteria, parent_infos): |
2508 def Search(self, criteria, parent_infos): |
2537 return _Search([("target", self.gettargetName())], criteria, parent_infos + ["jump", self.getlocalId()]) |
2509 return _Search([("target", self.gettargetName())], criteria, parent_infos + ["jump", self.getlocalId()]) |
2538 setattr(cls, "Search", Search) |
2510 setattr(cls, "Search", Search) |
2539 |
2511 |
2540 cls = PLCOpenClasses.get("actionBlock_action", None) |
2512 cls = PLCOpenParser.GetElementClass("action", "actionBlock") |
2541 if cls: |
2513 if cls: |
2542 def compatibility(self, tree): |
2514 def compatibility(self, tree): |
2543 relPosition = reduce(lambda x, y: x | (y.nodeName == "relPosition"), tree.childNodes, False) |
2515 relPosition = reduce(lambda x, y: x | (y.nodeName == "relPosition"), tree.childNodes, False) |
2544 if not tree.hasAttribute("localId"): |
2516 if not tree.hasAttribute("localId"): |
2545 NodeSetAttr(tree, "localId", "0") |
2517 NodeSetAttr(tree, "localId", "0") |
2561 return None |
2533 return None |
2562 setattr(cls, "getreferenceName", getreferenceName) |
2534 setattr(cls, "getreferenceName", getreferenceName) |
2563 |
2535 |
2564 def setinlineContent(self, content): |
2536 def setinlineContent(self, content): |
2565 if self.inline: |
2537 if self.inline: |
2566 self.inline.setcontent({"name" : "ST", "value" : PLCOpenClasses["formattedText"]()}) |
2538 self.inline.setcontent(PLCOpenParser.CreateElementClass("ST", "action")) |
2567 self.inline.settext(content) |
2539 self.inline.settext(content) |
2568 setattr(cls, "setinlineContent", setinlineContent) |
2540 setattr(cls, "setinlineContent", setinlineContent) |
2569 |
2541 |
2570 def getinlineContent(self): |
2542 def getinlineContent(self): |
2571 if self.inline: |
2543 if self.inline: |
2616 setattr(cls, "getinfos", getinfos) |
2588 setattr(cls, "getinfos", getinfos) |
2617 |
2589 |
2618 def setactions(self, actions): |
2590 def setactions(self, actions): |
2619 self.action = [] |
2591 self.action = [] |
2620 for params in actions: |
2592 for params in actions: |
2621 action = PLCOpenClasses["actionBlock_action"]() |
2593 action = PLCOpenParser.GetElementClass("action", "actionBlock")() |
2622 action.setqualifier(params["qualifier"]) |
2594 action.setqualifier(params["qualifier"]) |
2623 if params["type"] == "reference": |
2595 if params["type"] == "reference": |
2624 action.addreference() |
2596 action.addreference() |
2625 action.setreferenceName(params["value"]) |
2597 action.setreferenceName(params["value"]) |
2626 else: |
2598 else: |
2744 def updateElementName(self, old_name, new_name): |
2716 def updateElementName(self, old_name, new_name): |
2745 if self.name == old_name: |
2717 if self.name == old_name: |
2746 self.name = new_name |
2718 self.name = new_name |
2747 setattr(cls, "updateElementName", updateElementName) |
2719 setattr(cls, "updateElementName", updateElementName) |
2748 |
2720 |
2749 cls = PLCOpenClasses.get("connection", None) |
2721 cls = PLCOpenParser.GetElementClass("connection") |
2750 if cls: |
2722 if cls: |
2751 def setpoints(self, points): |
2723 def setpoints(self, points): |
2752 self.position = [] |
2724 positions = [] |
2753 for point in points: |
2725 for point in points: |
2754 position = PLCOpenClasses["position"]() |
2726 position = PLCOpenParser.CreateElement("position") |
2755 position.setx(point.x) |
2727 position.setx(point.x) |
2756 position.sety(point.y) |
2728 position.sety(point.y) |
2757 self.position.append(position) |
2729 positions.append(position) |
2730 self.positions = positions |
|
2758 setattr(cls, "setpoints", setpoints) |
2731 setattr(cls, "setpoints", setpoints) |
2759 |
2732 |
2760 def getpoints(self): |
2733 def getpoints(self): |
2761 points = [] |
2734 points = [] |
2762 for position in self.position: |
2735 for position in self.position: |
2763 points.append((position.getx(),position.gety())) |
2736 points.append((position.getx(),position.gety())) |
2764 return points |
2737 return points |
2765 setattr(cls, "getpoints", getpoints) |
2738 setattr(cls, "getpoints", getpoints) |
2766 |
2739 |
2767 cls = PLCOpenClasses.get("connectionPointIn", None) |
2740 cls = PLCOpenParser.GetElementClass("connectionPointIn") |
2768 if cls: |
2741 if cls: |
2769 def setrelPositionXY(self, x, y): |
2742 def setrelPositionXY(self, x, y): |
2770 self.relPosition = PLCOpenClasses["position"]() |
2743 self.relPosition = PLCOpenParser.CreateElement("position") |
2771 self.relPosition.setx(x) |
2744 self.relPosition.setx(x) |
2772 self.relPosition.sety(y) |
2745 self.relPosition.sety(y) |
2773 setattr(cls, "setrelPositionXY", setrelPositionXY) |
2746 setattr(cls, "setrelPositionXY", setrelPositionXY) |
2774 |
2747 |
2775 def getrelPositionXY(self): |
2748 def getrelPositionXY(self): |
2778 else: |
2751 else: |
2779 return self.relPosition |
2752 return self.relPosition |
2780 setattr(cls, "getrelPositionXY", getrelPositionXY) |
2753 setattr(cls, "getrelPositionXY", getrelPositionXY) |
2781 |
2754 |
2782 def addconnection(self): |
2755 def addconnection(self): |
2783 if not self.content: |
2756 self.appendcontent(PLCOpenParser.CreateElement("connection")) |
2784 self.content = {"name" : "connection", "value" : [PLCOpenClasses["connection"]()]} |
|
2785 else: |
|
2786 self.content["value"].append(PLCOpenClasses["connection"]()) |
|
2787 setattr(cls, "addconnection", addconnection) |
2757 setattr(cls, "addconnection", addconnection) |
2788 |
2758 |
2789 def removeconnection(self, idx): |
2759 def removeconnection(self, idx): |
2790 if self.content: |
2760 if len(self.content) > idx: |
2791 self.content["value"].pop(idx) |
2761 self.remove(self.content[idx]) |
2792 if len(self.content["value"]) == 0: |
|
2793 self.content = None |
|
2794 setattr(cls, "removeconnection", removeconnection) |
2762 setattr(cls, "removeconnection", removeconnection) |
2795 |
2763 |
2796 def removeconnections(self): |
2764 def removeconnections(self): |
2797 if self.content: |
2765 self.content = None |
2798 self.content = None |
|
2799 setattr(cls, "removeconnections", removeconnections) |
2766 setattr(cls, "removeconnections", removeconnections) |
2800 |
2767 |
2801 def getconnections(self): |
2768 def getconnections(self): |
2802 if self.content: |
2769 return self.content |
2803 return self.content["value"] |
|
2804 return [] |
|
2805 setattr(cls, "getconnections", getconnections) |
2770 setattr(cls, "getconnections", getconnections) |
2806 |
2771 |
2807 def setconnectionId(self, idx, id): |
2772 def setconnectionId(self, idx, local_id): |
2808 if self.content: |
2773 if len(self.content) > idx: |
2809 self.content["value"][idx].setrefLocalId(id) |
2774 self.content[idx].setrefLocalId(local_id) |
2810 setattr(cls, "setconnectionId", setconnectionId) |
2775 setattr(cls, "setconnectionId", setconnectionId) |
2811 |
2776 |
2812 def getconnectionId(self, idx): |
2777 def getconnectionId(self, idx): |
2813 if self.content: |
2778 if len(self.content) > idx: |
2814 return self.content["value"][idx].getrefLocalId() |
2779 return self.content[idx].getrefLocalId() |
2815 return None |
2780 return None |
2816 setattr(cls, "getconnectionId", getconnectionId) |
2781 setattr(cls, "getconnectionId", getconnectionId) |
2817 |
2782 |
2818 def setconnectionPoints(self, idx, points): |
2783 def setconnectionPoints(self, idx, points): |
2819 if self.content: |
2784 if len(self.content) > idx: |
2820 self.content["value"][idx].setpoints(points) |
2785 self.content[idx].setpoints(points) |
2821 setattr(cls, "setconnectionPoints", setconnectionPoints) |
2786 setattr(cls, "setconnectionPoints", setconnectionPoints) |
2822 |
2787 |
2823 def getconnectionPoints(self, idx): |
2788 def getconnectionPoints(self, idx): |
2824 if self.content: |
2789 if len(self.content) > idx: |
2825 return self.content["value"][idx].getpoints() |
2790 return self.content[idx].getpoints() |
2826 return [] |
2791 return [] |
2827 setattr(cls, "getconnectionPoints", getconnectionPoints) |
2792 setattr(cls, "getconnectionPoints", getconnectionPoints) |
2828 |
2793 |
2829 def setconnectionParameter(self, idx, parameter): |
2794 def setconnectionParameter(self, idx, parameter): |
2830 if self.content: |
2795 if len(self.content) > idx: |
2831 self.content["value"][idx].setformalParameter(parameter) |
2796 self.content[idx].setformalParameter(parameter) |
2832 setattr(cls, "setconnectionParameter", setconnectionParameter) |
2797 setattr(cls, "setconnectionParameter", setconnectionParameter) |
2833 |
2798 |
2834 def getconnectionParameter(self, idx): |
2799 def getconnectionParameter(self, idx): |
2835 if self.content: |
2800 if len(self.content) > idx: |
2836 return self.content["value"][idx].getformalParameter() |
2801 return self.content[idx].getformalParameter() |
2837 return None |
2802 return None |
2838 setattr(cls, "getconnectionParameter", getconnectionParameter) |
2803 setattr(cls, "getconnectionParameter", getconnectionParameter) |
2839 |
2804 |
2840 cls = PLCOpenClasses.get("connectionPointOut", None) |
2805 cls = PLCOpenParser.GetElementClass("connectionPointOut") |
2841 if cls: |
2806 if cls: |
2842 def setrelPositionXY(self, x, y): |
2807 def setrelPositionXY(self, x, y): |
2843 self.relPosition = PLCOpenClasses["position"]() |
2808 self.relPosition = PLCOpenParser.CreateElement("position") |
2844 self.relPosition.setx(x) |
2809 self.relPosition.setx(x) |
2845 self.relPosition.sety(y) |
2810 self.relPosition.sety(y) |
2846 setattr(cls, "setrelPositionXY", setrelPositionXY) |
2811 setattr(cls, "setrelPositionXY", setrelPositionXY) |
2847 |
2812 |
2848 def getrelPositionXY(self): |
2813 def getrelPositionXY(self): |
2849 if self.relPosition: |
2814 if self.relPosition: |
2850 return self.relPosition.getx(), self.relPosition.gety() |
2815 return self.relPosition.getx(), self.relPosition.gety() |
2851 return self.relPosition |
2816 return self.relPosition |
2852 setattr(cls, "getrelPositionXY", getrelPositionXY) |
2817 setattr(cls, "getrelPositionXY", getrelPositionXY) |
2853 |
2818 |
2854 cls = PLCOpenClasses.get("value", None) |
2819 cls = PLCOpenParser.GetElementClass("value") |
2855 if cls: |
2820 if cls: |
2856 def setvalue(self, value): |
2821 def setvalue(self, value): |
2857 value = value.strip() |
2822 value = value.strip() |
2858 if value.startswith("[") and value.endswith("]"): |
2823 if value.startswith("[") and value.endswith("]"): |
2859 arrayValue = PLCOpenClasses["value_arrayValue"]() |
2824 self.content = PLCOpenParser.CreateElement("arrayValue", "value") |
2860 self.content = {"name" : "arrayValue", "value" : arrayValue} |
|
2861 elif value.startswith("(") and value.endswith(")"): |
2825 elif value.startswith("(") and value.endswith(")"): |
2862 structValue = PLCOpenClasses["value_structValue"]() |
2826 self.content = PLCOpenParser.CreateElement("structValue", "value") |
2863 self.content = {"name" : "structValue", "value" : structValue} |
|
2864 else: |
2827 else: |
2865 simpleValue = PLCOpenClasses["value_simpleValue"]() |
2828 self.content = PLCOpenParser.CreateElement("simpleValue", "value") |
2866 self.content = {"name" : "simpleValue", "value": simpleValue} |
2829 self.content.setvalue(value) |
2867 self.content["value"].setvalue(value) |
|
2868 setattr(cls, "setvalue", setvalue) |
2830 setattr(cls, "setvalue", setvalue) |
2869 |
2831 |
2870 def getvalue(self): |
2832 def getvalue(self): |
2871 return self.content["value"].getvalue() |
2833 return self.content.getvalue() |
2872 setattr(cls, "getvalue", getvalue) |
2834 setattr(cls, "getvalue", getvalue) |
2873 |
2835 |
2874 def extractValues(values): |
2836 def extractValues(values): |
2875 items = values.split(",") |
2837 items = values.split(",") |
2876 i = 1 |
2838 i = 1 |
2883 i += 1 |
2845 i += 1 |
2884 else: |
2846 else: |
2885 raise ValueError, _("\"%s\" is an invalid value!")%value |
2847 raise ValueError, _("\"%s\" is an invalid value!")%value |
2886 return items |
2848 return items |
2887 |
2849 |
2888 cls = PLCOpenClasses.get("value_arrayValue", None) |
2850 cls = PLCOpenParser.GetElementClass("arrayValue", "value") |
2889 if cls: |
2851 if cls: |
2890 arrayValue_model = re.compile("([0-9]*)\((.*)\)$") |
2852 arrayValue_model = re.compile("([0-9]*)\((.*)\)$") |
2891 |
2853 |
2892 def setvalue(self, value): |
2854 def setvalue(self, value): |
2893 self.value = [] |
2855 elements = [] |
2894 for item in extractValues(value[1:-1]): |
2856 for item in extractValues(value[1:-1]): |
2895 item = item.strip() |
2857 item = item.strip() |
2896 element = PLCOpenClasses["arrayValue_value"]() |
2858 element = PLCOpenParser.CreateElement("value", "arrayValue") |
2897 result = arrayValue_model.match(item) |
2859 result = arrayValue_model.match(item) |
2898 if result is not None: |
2860 if result is not None: |
2899 groups = result.groups() |
2861 groups = result.groups() |
2900 element.setrepetitionValue(groups[0]) |
2862 element.setrepetitionValue(groups[0]) |
2901 element.setvalue(groups[1].strip()) |
2863 element.setvalue(groups[1].strip()) |
2902 else: |
2864 else: |
2903 element.setvalue(item) |
2865 element.setvalue(item) |
2904 self.value.append(element) |
2866 elements.append(element) |
2867 self.value = elements |
|
2905 setattr(cls, "setvalue", setvalue) |
2868 setattr(cls, "setvalue", setvalue) |
2906 |
2869 |
2907 def getvalue(self): |
2870 def getvalue(self): |
2908 values = [] |
2871 values = [] |
2909 for element in self.value: |
2872 for element in self.value: |
2916 else: |
2879 else: |
2917 values.append(element.getvalue()) |
2880 values.append(element.getvalue()) |
2918 return "[%s]"%", ".join(values) |
2881 return "[%s]"%", ".join(values) |
2919 setattr(cls, "getvalue", getvalue) |
2882 setattr(cls, "getvalue", getvalue) |
2920 |
2883 |
2921 cls = PLCOpenClasses.get("value_structValue", None) |
2884 cls = PLCOpenParser.GetElementClass("structValue", "value") |
2922 if cls: |
2885 if cls: |
2923 structValue_model = re.compile("(.*):=(.*)") |
2886 structValue_model = re.compile("(.*):=(.*)") |
2924 |
2887 |
2925 def setvalue(self, value): |
2888 def setvalue(self, value): |
2926 self.value = [] |
2889 elements = [] |
2927 for item in extractValues(value[1:-1]): |
2890 for item in extractValues(value[1:-1]): |
2928 result = structValue_model.match(item) |
2891 result = structValue_model.match(item) |
2929 if result is not None: |
2892 if result is not None: |
2930 groups = result.groups() |
2893 groups = result.groups() |
2931 element = PLCOpenClasses["structValue_value"]() |
2894 element = PLCOpenParser.CreateElement("value", "structValue") |
2932 element.setmember(groups[0].strip()) |
2895 element.setmember(groups[0].strip()) |
2933 element.setvalue(groups[1].strip()) |
2896 element.setvalue(groups[1].strip()) |
2934 self.value.append(element) |
2897 elements.append(element) |
2898 self.value = elements |
|
2935 setattr(cls, "setvalue", setvalue) |
2899 setattr(cls, "setvalue", setvalue) |
2936 |
2900 |
2937 def getvalue(self): |
2901 def getvalue(self): |
2938 values = [] |
2902 values = [] |
2939 for element in self.value: |
2903 for element in self.value: |
2940 values.append("%s := %s"%(element.getmember(), element.getvalue())) |
2904 values.append("%s := %s"%(element.getmember(), element.getvalue())) |
2941 return "(%s)"%", ".join(values) |
2905 return "(%s)"%", ".join(values) |
2942 setattr(cls, "getvalue", getvalue) |
2906 setattr(cls, "getvalue", getvalue) |
2907 |