author | Surkov Sergey <surkovsv93@gmail.com> |
Mon, 06 Feb 2017 20:23:45 +0300 | |
changeset 1652 | be605b2e6e3a |
parent 1629 | 80eee3c5a057 |
child 1680 | 6db967480b7d |
permissions | -rw-r--r-- |
814 | 1 |
#!/usr/bin/env python |
2 |
# -*- coding: utf-8 -*- |
|
3 |
||
1571
486f94a8032c
fix license notices in source files and license files under GPLv2+
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1556
diff
changeset
|
4 |
# This file is part of Beremiz, a Integrated Development Environment for |
486f94a8032c
fix license notices in source files and license files under GPLv2+
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1556
diff
changeset
|
5 |
# programming IEC 61131-3 automates supporting plcopen standard and CanFestival. |
814 | 6 |
# |
1571
486f94a8032c
fix license notices in source files and license files under GPLv2+
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1556
diff
changeset
|
7 |
# Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD |
814 | 8 |
# |
1571
486f94a8032c
fix license notices in source files and license files under GPLv2+
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1556
diff
changeset
|
9 |
# See COPYING file for copyrights details. |
814 | 10 |
# |
1571
486f94a8032c
fix license notices in source files and license files under GPLv2+
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1556
diff
changeset
|
11 |
# This program is free software; you can redistribute it and/or |
486f94a8032c
fix license notices in source files and license files under GPLv2+
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1556
diff
changeset
|
12 |
# modify it under the terms of the GNU General Public License |
486f94a8032c
fix license notices in source files and license files under GPLv2+
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1556
diff
changeset
|
13 |
# as published by the Free Software Foundation; either version 2 |
486f94a8032c
fix license notices in source files and license files under GPLv2+
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1556
diff
changeset
|
14 |
# of the License, or (at your option) any later version. |
814 | 15 |
# |
1571
486f94a8032c
fix license notices in source files and license files under GPLv2+
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1556
diff
changeset
|
16 |
# This program is distributed in the hope that it will be useful, |
486f94a8032c
fix license notices in source files and license files under GPLv2+
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1556
diff
changeset
|
17 |
# but WITHOUT ANY WARRANTY; without even the implied warranty of |
486f94a8032c
fix license notices in source files and license files under GPLv2+
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1556
diff
changeset
|
18 |
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
486f94a8032c
fix license notices in source files and license files under GPLv2+
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1556
diff
changeset
|
19 |
# GNU General Public License for more details. |
814 | 20 |
# |
1571
486f94a8032c
fix license notices in source files and license files under GPLv2+
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1556
diff
changeset
|
21 |
# You should have received a copy of the GNU General Public License |
486f94a8032c
fix license notices in source files and license files under GPLv2+
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1556
diff
changeset
|
22 |
# along with this program; if not, write to the Free Software |
486f94a8032c
fix license notices in source files and license files under GPLv2+
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1556
diff
changeset
|
23 |
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. |
814 | 24 |
|
25 |
from xmlclass import * |
|
26 |
from types import * |
|
27 |
import os, re |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
28 |
from lxml import etree |
1331
38c5de794e62
Added support for speed-up loading of graphic POU tabs
Laurent Bessard
parents:
1330
diff
changeset
|
29 |
from collections import OrderedDict |
38c5de794e62
Added support for speed-up loading of graphic POU tabs
Laurent Bessard
parents:
1330
diff
changeset
|
30 |
|
814 | 31 |
""" |
32 |
Dictionary that makes the relation between var names in plcopen and displayed values |
|
33 |
""" |
|
34 |
VarTypes = {"Local" : "localVars", "Temp" : "tempVars", "Input" : "inputVars", |
|
35 |
"Output" : "outputVars", "InOut" : "inOutVars", "External" : "externalVars", |
|
36 |
"Global" : "globalVars", "Access" : "accessVars"} |
|
37 |
||
38 |
searchResultVarTypes = { |
|
39 |
"inputVars": "var_input", |
|
40 |
"outputVars": "var_output", |
|
41 |
"inOutVars": "var_inout" |
|
42 |
} |
|
43 |
||
44 |
""" |
|
45 |
Define in which order var types must be displayed |
|
46 |
""" |
|
47 |
VarOrder = ["Local","Temp","Input","Output","InOut","External","Global","Access"] |
|
48 |
||
49 |
""" |
|
50 |
Define which action qualifier must be associated with a duration |
|
51 |
""" |
|
1339 | 52 |
QualifierList = OrderedDict([("N", False), ("R", False), ("S", False), |
53 |
("L", True), ("D", True), ("P", False), ("P0", False), |
|
54 |
("P1", False), ("SD", True), ("DS", True), ("SL", True)]) |
|
814 | 55 |
|
56 |
||
57 |
FILTER_ADDRESS_MODEL = "(%%[IQM](?:[XBWDL])?)(%s)((?:\.[0-9]+)*)" |
|
58 |
||
59 |
def update_address(address, address_model, new_leading): |
|
60 |
result = address_model.match(address) |
|
61 |
if result is None: |
|
62 |
return address |
|
63 |
groups = result.groups() |
|
64 |
return groups[0] + new_leading + groups[2] |
|
65 |
||
66 |
def _init_and_compare(function, v1, v2): |
|
67 |
if v1 is None: |
|
68 |
return v2 |
|
69 |
if v2 is not None: |
|
70 |
return function(v1, v2) |
|
71 |
return v1 |
|
72 |
||
73 |
""" |
|
74 |
Helper class for bounding_box calculation |
|
75 |
""" |
|
76 |
class rect: |
|
77 |
||
78 |
def __init__(self, x=None, y=None, width=None, height=None): |
|
79 |
self.x_min = x |
|
80 |
self.x_max = None |
|
81 |
self.y_min = y |
|
82 |
self.y_max = None |
|
83 |
if width is not None and x is not None: |
|
84 |
self.x_max = x + width |
|
85 |
if height is not None and y is not None: |
|
86 |
self.y_max = y + height |
|
87 |
||
88 |
def update(self, x, y): |
|
89 |
self.x_min = _init_and_compare(min, self.x_min, x) |
|
90 |
self.x_max = _init_and_compare(max, self.x_max, x) |
|
91 |
self.y_min = _init_and_compare(min, self.y_min, y) |
|
92 |
self.y_max = _init_and_compare(max, self.y_max, y) |
|
93 |
||
94 |
def union(self, rect): |
|
95 |
self.x_min = _init_and_compare(min, self.x_min, rect.x_min) |
|
96 |
self.x_max = _init_and_compare(max, self.x_max, rect.x_max) |
|
97 |
self.y_min = _init_and_compare(min, self.y_min, rect.y_min) |
|
98 |
self.y_max = _init_and_compare(max, self.y_max, rect.y_max) |
|
99 |
||
100 |
def bounding_box(self): |
|
101 |
width = height = None |
|
102 |
if self.x_min is not None and self.x_max is not None: |
|
103 |
width = self.x_max - self.x_min |
|
104 |
if self.y_min is not None and self.y_max is not None: |
|
105 |
height = self.y_max - self.y_min |
|
106 |
return self.x_min, self.y_min, width, height |
|
107 |
||
108 |
def TextLenInRowColumn(text): |
|
109 |
if text == "": |
|
110 |
return (0, 0) |
|
111 |
lines = text.split("\n") |
|
112 |
return len(lines) - 1, len(lines[-1]) |
|
113 |
||
1556
32e9d0ef30dc
fix major bugs in Find and Search in Project functionality.
Sergey Surkov <surkovsv93@gmail.com>
parents:
1534
diff
changeset
|
114 |
def CompilePattern(criteria): |
32e9d0ef30dc
fix major bugs in Find and Search in Project functionality.
Sergey Surkov <surkovsv93@gmail.com>
parents:
1534
diff
changeset
|
115 |
flag = 0 if criteria["case_sensitive"] else re.IGNORECASE |
32e9d0ef30dc
fix major bugs in Find and Search in Project functionality.
Sergey Surkov <surkovsv93@gmail.com>
parents:
1534
diff
changeset
|
116 |
find_pattern = criteria["find_pattern"] |
32e9d0ef30dc
fix major bugs in Find and Search in Project functionality.
Sergey Surkov <surkovsv93@gmail.com>
parents:
1534
diff
changeset
|
117 |
if not criteria["regular_expression"]: |
32e9d0ef30dc
fix major bugs in Find and Search in Project functionality.
Sergey Surkov <surkovsv93@gmail.com>
parents:
1534
diff
changeset
|
118 |
find_pattern = re.escape(find_pattern) |
32e9d0ef30dc
fix major bugs in Find and Search in Project functionality.
Sergey Surkov <surkovsv93@gmail.com>
parents:
1534
diff
changeset
|
119 |
criteria["pattern"] = re.compile(find_pattern, flag) |
32e9d0ef30dc
fix major bugs in Find and Search in Project functionality.
Sergey Surkov <surkovsv93@gmail.com>
parents:
1534
diff
changeset
|
120 |
|
814 | 121 |
def TestTextElement(text, criteria): |
122 |
lines = text.splitlines() |
|
123 |
test_result = [] |
|
124 |
result = criteria["pattern"].search(text) |
|
125 |
while result is not None: |
|
126 |
start = TextLenInRowColumn(text[:result.start()]) |
|
127 |
end = TextLenInRowColumn(text[:result.end() - 1]) |
|
128 |
test_result.append((start, end, "\n".join(lines[start[0]:end[0] + 1]))) |
|
129 |
result = criteria["pattern"].search(text, result.end()) |
|
130 |
return test_result |
|
131 |
||
1611
5e64d552b25a
make renames caseinsensitive
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1581
diff
changeset
|
132 |
def TextMatched(str1, str2): |
5e64d552b25a
make renames caseinsensitive
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1581
diff
changeset
|
133 |
return str1 and str2 and (str1.upper() == str2.upper()) |
5e64d552b25a
make renames caseinsensitive
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1581
diff
changeset
|
134 |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
135 |
PLCOpenParser = GenerateParserFromXSD(os.path.join(os.path.split(__file__)[0], "tc6_xml_v201.xsd")) |
1305
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
136 |
PLCOpen_XPath = lambda xpath: etree.XPath(xpath, namespaces=PLCOpenParser.NSMAP) |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
137 |
|
1299
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset
|
138 |
LOAD_POU_PROJECT_TEMPLATE = """ |
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset
|
139 |
<project xmlns:ns1="http://www.plcopen.org/xml/tc6_0201" |
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset
|
140 |
xmlns:xhtml="http://www.w3.org/1999/xhtml" |
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset
|
141 |
xmlns:xsd="http://www.w3.org/2001/XMLSchema" |
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset
|
142 |
xmlns="http://www.plcopen.org/xml/tc6_0201"> |
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset
|
143 |
<fileHeader companyName="" productName="" productVersion="" |
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset
|
144 |
creationDateTime="1970-01-01T00:00:00"/> |
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset
|
145 |
<contentHeader name="paste_project"> |
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset
|
146 |
<coordinateInfo> |
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset
|
147 |
<fbd><scaling x="0" y="0"/></fbd> |
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset
|
148 |
<ld><scaling x="0" y="0"/></ld> |
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset
|
149 |
<sfc><scaling x="0" y="0"/></sfc> |
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset
|
150 |
</coordinateInfo> |
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset
|
151 |
</contentHeader> |
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset
|
152 |
<types> |
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset
|
153 |
<dataTypes/> |
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset
|
154 |
<pous>%s</pous> |
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset
|
155 |
</types> |
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset
|
156 |
<instances> |
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset
|
157 |
<configurations/> |
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset
|
158 |
</instances> |
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset
|
159 |
</project> |
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset
|
160 |
""" |
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset
|
161 |
|
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset
|
162 |
def LOAD_POU_INSTANCES_PROJECT_TEMPLATE(body_type): |
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset
|
163 |
return LOAD_POU_PROJECT_TEMPLATE % """ |
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset
|
164 |
<pou name="paste_pou" pouType="program"> |
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset
|
165 |
<body> |
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset
|
166 |
<%(body_type)s>%%s</%(body_type)s> |
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset
|
167 |
</body> |
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset
|
168 |
</pou>""" % locals() |
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset
|
169 |
|
1334
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
170 |
PLCOpen_v1_file = open(os.path.join(os.path.split(__file__)[0], "TC6_XML_V10_B.xsd")) |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
171 |
PLCOpen_v1_xml = PLCOpen_v1_file.read() |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
172 |
PLCOpen_v1_file.close() |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
173 |
PLCOpen_v1_xml = PLCOpen_v1_xml.replace( |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
174 |
"http://www.plcopen.org/xml/tc6.xsd", |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
175 |
"http://www.plcopen.org/xml/tc6_0201") |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
176 |
PLCOpen_v1_xsd = etree.XMLSchema(etree.fromstring(PLCOpen_v1_xml)) |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
177 |
|
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
178 |
# XPath for file compatibility process |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
179 |
ProjectResourcesXPath = PLCOpen_XPath("ppx:instances/ppx:configurations/ppx:configuration/ppx:resource") |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
180 |
ResourceInstancesXpath = PLCOpen_XPath("ppx:pouInstance | ppx:task/ppx:pouInstance") |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
181 |
TransitionsConditionXPath = PLCOpen_XPath("ppx:types/ppx:pous/ppx:pou/ppx:body/*/ppx:transition/ppx:condition") |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
182 |
ConditionConnectionsXPath = PLCOpen_XPath("ppx:connection") |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
183 |
ActionBlocksXPath = PLCOpen_XPath("ppx:types/ppx:pous/ppx:pou/ppx:body/*/ppx:actionBlock") |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
184 |
ActionBlocksConnectionPointOutXPath = PLCOpen_XPath("ppx:connectionPointOut") |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
185 |
|
1330
96b242e4c59d
Added support for loading XML file even if not following XSD schema (but still following XML syntax), warning user of errors in XML file
Laurent Bessard
parents:
1322
diff
changeset
|
186 |
def LoadProjectXML(project_xml): |
96b242e4c59d
Added support for loading XML file even if not following XSD schema (but still following XML syntax), warning user of errors in XML file
Laurent Bessard
parents:
1322
diff
changeset
|
187 |
project_xml = project_xml.replace( |
1294
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset
|
188 |
"http://www.plcopen.org/xml/tc6.xsd", |
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset
|
189 |
"http://www.plcopen.org/xml/tc6_0201") |
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset
|
190 |
for cre, repl in [ |
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset
|
191 |
(re.compile("(?<!<xhtml:p>)(?:<!\[CDATA\[)"), "<xhtml:p><![CDATA["), |
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset
|
192 |
(re.compile("(?:]]>)(?!</xhtml:p>)"), "]]></xhtml:p>")]: |
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset
|
193 |
project_xml = cre.sub(repl, project_xml) |
1330
96b242e4c59d
Added support for loading XML file even if not following XSD schema (but still following XML syntax), warning user of errors in XML file
Laurent Bessard
parents:
1322
diff
changeset
|
194 |
|
96b242e4c59d
Added support for loading XML file even if not following XSD schema (but still following XML syntax), warning user of errors in XML file
Laurent Bessard
parents:
1322
diff
changeset
|
195 |
try: |
96b242e4c59d
Added support for loading XML file even if not following XSD schema (but still following XML syntax), warning user of errors in XML file
Laurent Bessard
parents:
1322
diff
changeset
|
196 |
tree, error = PLCOpenParser.LoadXMLString(project_xml) |
1334
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
197 |
if error is None: |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
198 |
return tree, None |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
199 |
|
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
200 |
if PLCOpen_v1_xsd.validate(tree): |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
201 |
# Make file compatible with PLCOpen v2 |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
202 |
|
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
203 |
# Update resource interval value |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
204 |
for resource in ProjectResourcesXPath(tree): |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
205 |
for task in resource.gettask(): |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
206 |
interval = task.get("interval") |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
207 |
if interval is not None: |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
208 |
result = time_model.match(interval) |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
209 |
if result is not None: |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
210 |
values = result.groups() |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
211 |
time_values = [int(v) for v in values[:2]] |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
212 |
seconds = float(values[2]) |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
213 |
time_values.extend([int(seconds), int((seconds % 1) * 1000000)]) |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
214 |
text = "T#" |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
215 |
if time_values[0] != 0: |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
216 |
text += "%dh"%time_values[0] |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
217 |
if time_values[1] != 0: |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
218 |
text += "%dm"%time_values[1] |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
219 |
if time_values[2] != 0: |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
220 |
text += "%ds"%time_values[2] |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
221 |
if time_values[3] != 0: |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
222 |
if time_values[3] % 1000 != 0: |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
223 |
text += "%.3fms"%(float(time_values[3]) / 1000) |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
224 |
else: |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
225 |
text += "%dms"%(time_values[3] / 1000) |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
226 |
task.set("interval", text) |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
227 |
|
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
228 |
# Update resources pou instance attributes |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
229 |
for pouInstance in ResourceInstancesXpath(resource): |
1339 | 230 |
type_name = pouInstance.attrib.pop("type") |
1334
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
231 |
if type_name is not None: |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
232 |
pouInstance.set("typeName", type_name) |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
233 |
|
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
234 |
# Update transitions condition |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
235 |
for transition_condition in TransitionsConditionXPath(tree): |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
236 |
connections = ConditionConnectionsXPath(transition_condition) |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
237 |
if len(connections) > 0: |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
238 |
connectionPointIn = PLCOpenParser.CreateElement("connectionPointIn", "condition") |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
239 |
transition_condition.setcontent(connectionPointIn) |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
240 |
connectionPointIn.setrelPositionXY(0, 0) |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
241 |
for connection in connections: |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
242 |
connectionPointIn.append(connection) |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
243 |
|
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
244 |
# Update actionBlocks |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
245 |
for actionBlock in ActionBlocksXPath(tree): |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
246 |
for connectionPointOut in ActionBlocksConnectionPointOutXPath(actionBlock): |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
247 |
actionBlock.remove(connectionPointOut) |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
248 |
|
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
249 |
for action in actionBlock.getaction(): |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
250 |
action.set("localId", "0") |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
251 |
relPosition = PLCOpenParser.CreateElement("relPosition", "action") |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
252 |
relPosition.set("x", "0") |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
253 |
relPosition.set("y", "0") |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
254 |
action.setrelPosition(relPosition) |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
255 |
|
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
256 |
return tree, None |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
257 |
|
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
258 |
return tree, error |
b0c2c4e1c1f1
Added support for loading PLCOpen v1 files and modify their content to be compatible with PLCOpen v2
Laurent Bessard
parents:
1331
diff
changeset
|
259 |
|
1330
96b242e4c59d
Added support for loading XML file even if not following XSD schema (but still following XML syntax), warning user of errors in XML file
Laurent Bessard
parents:
1322
diff
changeset
|
260 |
except Exception, e: |
96b242e4c59d
Added support for loading XML file even if not following XSD schema (but still following XML syntax), warning user of errors in XML file
Laurent Bessard
parents:
1322
diff
changeset
|
261 |
return None, e.message |
96b242e4c59d
Added support for loading XML file even if not following XSD schema (but still following XML syntax), warning user of errors in XML file
Laurent Bessard
parents:
1322
diff
changeset
|
262 |
|
96b242e4c59d
Added support for loading XML file even if not following XSD schema (but still following XML syntax), warning user of errors in XML file
Laurent Bessard
parents:
1322
diff
changeset
|
263 |
def LoadProject(filepath): |
96b242e4c59d
Added support for loading XML file even if not following XSD schema (but still following XML syntax), warning user of errors in XML file
Laurent Bessard
parents:
1322
diff
changeset
|
264 |
project_file = open(filepath) |
96b242e4c59d
Added support for loading XML file even if not following XSD schema (but still following XML syntax), warning user of errors in XML file
Laurent Bessard
parents:
1322
diff
changeset
|
265 |
project_xml = project_file.read() |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
266 |
project_file.close() |
1330
96b242e4c59d
Added support for loading XML file even if not following XSD schema (but still following XML syntax), warning user of errors in XML file
Laurent Bessard
parents:
1322
diff
changeset
|
267 |
return LoadProjectXML(project_xml) |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
268 |
|
1305
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
269 |
project_pou_xpath = PLCOpen_XPath("/ppx:project/ppx:types/ppx:pous/ppx:pou") |
1299
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset
|
270 |
def LoadPou(xml_string): |
1330
96b242e4c59d
Added support for loading XML file even if not following XSD schema (but still following XML syntax), warning user of errors in XML file
Laurent Bessard
parents:
1322
diff
changeset
|
271 |
root, error = LoadProjectXML(LOAD_POU_PROJECT_TEMPLATE % xml_string) |
96b242e4c59d
Added support for loading XML file even if not following XSD schema (but still following XML syntax), warning user of errors in XML file
Laurent Bessard
parents:
1322
diff
changeset
|
272 |
return project_pou_xpath(root)[0], error |
1305
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
273 |
|
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
274 |
project_pou_instances_xpath = { |
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
275 |
body_type: PLCOpen_XPath( |
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
276 |
"/ppx:project/ppx:types/ppx:pous/ppx:pou[@name='paste_pou']/ppx:body/ppx:%s/*" % body_type) |
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
277 |
for body_type in ["FBD", "LD", "SFC"]} |
1299
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset
|
278 |
def LoadPouInstances(xml_string, body_type): |
1330
96b242e4c59d
Added support for loading XML file even if not following XSD schema (but still following XML syntax), warning user of errors in XML file
Laurent Bessard
parents:
1322
diff
changeset
|
279 |
root, error = LoadProjectXML( |
96b242e4c59d
Added support for loading XML file even if not following XSD schema (but still following XML syntax), warning user of errors in XML file
Laurent Bessard
parents:
1322
diff
changeset
|
280 |
LOAD_POU_INSTANCES_PROJECT_TEMPLATE(body_type) % xml_string) |
96b242e4c59d
Added support for loading XML file even if not following XSD schema (but still following XML syntax), warning user of errors in XML file
Laurent Bessard
parents:
1322
diff
changeset
|
281 |
return project_pou_instances_xpath[body_type](root), error |
1299
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset
|
282 |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
283 |
def SaveProject(project, filepath): |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
284 |
project_file = open(filepath, 'w') |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
285 |
project_file.write(etree.tostring( |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
286 |
project, |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
287 |
pretty_print=True, |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
288 |
xml_declaration=True, |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
289 |
encoding='utf-8')) |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
290 |
project_file.close() |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
291 |
|
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
292 |
cls = PLCOpenParser.GetElementClass("formattedText") |
814 | 293 |
if cls: |
294 |
def updateElementName(self, old_name, new_name): |
|
1294
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset
|
295 |
text = self.getanyText() |
1611
5e64d552b25a
make renames caseinsensitive
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1581
diff
changeset
|
296 |
pattern = re.compile('\\b' + old_name + '\\b', re.IGNORECASE) |
5e64d552b25a
make renames caseinsensitive
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1581
diff
changeset
|
297 |
text = pattern.sub(new_name, text) |
1294
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset
|
298 |
self.setanyText(text) |
814 | 299 |
setattr(cls, "updateElementName", updateElementName) |
300 |
||
301 |
def updateElementAddress(self, address_model, new_leading): |
|
1294
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset
|
302 |
text = self.getanyText() |
814 | 303 |
startpos = 0 |
304 |
result = address_model.search(text, startpos) |
|
305 |
while result is not None: |
|
306 |
groups = result.groups() |
|
307 |
new_address = groups[0] + new_leading + groups[2] |
|
308 |
text = text[:result.start()] + new_address + text[result.end():] |
|
309 |
startpos = result.start() + len(new_address) |
|
1322
0a9227f743b3
Fixed xmlclass for working with included files, adding support for SimpleType elements and solving ambiguity in extension class when different elements share the same name and parent name
Laurent Bessard
parents:
1318
diff
changeset
|
310 |
result = address_model.search(text, startpos) |
1294
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset
|
311 |
self.setanyText(text) |
814 | 312 |
setattr(cls, "updateElementAddress", updateElementAddress) |
313 |
||
1142
8ded55ada6d6
Fixed functions used by one or more POU not showing question dialog when trying to delete
Laurent Bessard
parents:
990
diff
changeset
|
314 |
def hasblock(self, block_type): |
1611
5e64d552b25a
make renames caseinsensitive
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1581
diff
changeset
|
315 |
text = self.getanyText() |
5e64d552b25a
make renames caseinsensitive
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1581
diff
changeset
|
316 |
pattern = re.compile('\\b' + block_type + '\\b', re.IGNORECASE) |
5e64d552b25a
make renames caseinsensitive
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1581
diff
changeset
|
317 |
return pattern.search(text) is not None |
1142
8ded55ada6d6
Fixed functions used by one or more POU not showing question dialog when trying to delete
Laurent Bessard
parents:
990
diff
changeset
|
318 |
setattr(cls, "hasblock", hasblock) |
8ded55ada6d6
Fixed functions used by one or more POU not showing question dialog when trying to delete
Laurent Bessard
parents:
990
diff
changeset
|
319 |
|
814 | 320 |
def Search(self, criteria, parent_infos): |
1291
42ea51d083ce
Second stage of xmlclass refactoring using lxml , project are loaded and displayed successfully
Laurent Bessard
parents:
1290
diff
changeset
|
321 |
return [(tuple(parent_infos),) + result for result in TestTextElement(self.getanyText(), criteria)] |
814 | 322 |
setattr(cls, "Search", Search) |
323 |
||
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
324 |
cls = PLCOpenParser.GetElementClass("project") |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
325 |
if cls: |
814 | 326 |
|
327 |
def setname(self, name): |
|
328 |
self.contentHeader.setname(name) |
|
329 |
setattr(cls, "setname", setname) |
|
330 |
||
331 |
def getname(self): |
|
332 |
return self.contentHeader.getname() |
|
333 |
setattr(cls, "getname", getname) |
|
334 |
||
335 |
def getfileHeader(self): |
|
1301
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
336 |
fileheader_obj = self.fileHeader |
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
337 |
return { |
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
338 |
attr: value if value is not None else "" |
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
339 |
for attr, value in [ |
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
340 |
("companyName", fileheader_obj.getcompanyName()), |
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
341 |
("companyURL", fileheader_obj.getcompanyURL()), |
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
342 |
("productName", fileheader_obj.getproductName()), |
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
343 |
("productVersion", fileheader_obj.getproductVersion()), |
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
344 |
("productRelease", fileheader_obj.getproductRelease()), |
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
345 |
("creationDateTime", fileheader_obj.getcreationDateTime()), |
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
346 |
("contentDescription", fileheader_obj.getcontentDescription())] |
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
347 |
} |
814 | 348 |
setattr(cls, "getfileHeader", getfileHeader) |
349 |
||
350 |
def setfileHeader(self, fileheader): |
|
1301
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
351 |
fileheader_obj = self.fileHeader |
1309
85ce56758900
Fixed bug when modifying project properties
Laurent Bessard
parents:
1307
diff
changeset
|
352 |
for attr in ["companyName", "companyURL", "productName", |
85ce56758900
Fixed bug when modifying project properties
Laurent Bessard
parents:
1307
diff
changeset
|
353 |
"productVersion", "productRelease", "creationDateTime", |
85ce56758900
Fixed bug when modifying project properties
Laurent Bessard
parents:
1307
diff
changeset
|
354 |
"contentDescription"]: |
85ce56758900
Fixed bug when modifying project properties
Laurent Bessard
parents:
1307
diff
changeset
|
355 |
value = fileheader.get(attr) |
85ce56758900
Fixed bug when modifying project properties
Laurent Bessard
parents:
1307
diff
changeset
|
356 |
if value is not None: |
85ce56758900
Fixed bug when modifying project properties
Laurent Bessard
parents:
1307
diff
changeset
|
357 |
setattr(fileheader_obj, attr, value) |
814 | 358 |
setattr(cls, "setfileHeader", setfileHeader) |
359 |
||
360 |
def getcontentHeader(self): |
|
1301
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
361 |
contentheader_obj = self.contentHeader |
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
362 |
contentheader = { |
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
363 |
attr: value if value is not None else "" |
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
364 |
for attr, value in [ |
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
365 |
("projectName", contentheader_obj.getname()), |
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
366 |
("projectVersion", contentheader_obj.getversion()), |
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
367 |
("modificationDateTime", contentheader_obj.getmodificationDateTime()), |
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
368 |
("organization", contentheader_obj.getorganization()), |
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
369 |
("authorName", contentheader_obj.getauthor()), |
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
370 |
("language", contentheader_obj.getlanguage())] |
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
371 |
} |
814 | 372 |
contentheader["pageSize"] = self.contentHeader.getpageSize() |
373 |
contentheader["scaling"] = self.contentHeader.getscaling() |
|
374 |
return contentheader |
|
375 |
setattr(cls, "getcontentHeader", getcontentHeader) |
|
376 |
||
377 |
def setcontentHeader(self, contentheader): |
|
1301
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
378 |
contentheader_obj = self.contentHeader |
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
379 |
for attr, value in contentheader.iteritems(): |
1313
85c167bfff93
Replaced standard function blocks library definition from dictionary to plcopen xml files
Laurent Bessard
parents:
1310
diff
changeset
|
380 |
func = {"projectName": contentheader_obj.setname, |
85c167bfff93
Replaced standard function blocks library definition from dictionary to plcopen xml files
Laurent Bessard
parents:
1310
diff
changeset
|
381 |
"projectVersion": contentheader_obj.setversion, |
85c167bfff93
Replaced standard function blocks library definition from dictionary to plcopen xml files
Laurent Bessard
parents:
1310
diff
changeset
|
382 |
"authorName": contentheader_obj.setauthor, |
85c167bfff93
Replaced standard function blocks library definition from dictionary to plcopen xml files
Laurent Bessard
parents:
1310
diff
changeset
|
383 |
"pageSize": lambda v: contentheader_obj.setpageSize(*v), |
85c167bfff93
Replaced standard function blocks library definition from dictionary to plcopen xml files
Laurent Bessard
parents:
1310
diff
changeset
|
384 |
"scaling": contentheader_obj.setscaling}.get(attr) |
85c167bfff93
Replaced standard function blocks library definition from dictionary to plcopen xml files
Laurent Bessard
parents:
1310
diff
changeset
|
385 |
if func is not None: |
85c167bfff93
Replaced standard function blocks library definition from dictionary to plcopen xml files
Laurent Bessard
parents:
1310
diff
changeset
|
386 |
func(value) |
1309
85ce56758900
Fixed bug when modifying project properties
Laurent Bessard
parents:
1307
diff
changeset
|
387 |
elif attr in ["modificationDateTime", "organization", "language"]: |
1301
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
388 |
setattr(contentheader_obj, attr, value) |
814 | 389 |
setattr(cls, "setcontentHeader", setcontentHeader) |
390 |
||
1305
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
391 |
def gettypeElementFunc(element_type): |
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
392 |
elements_xpath = PLCOpen_XPath( |
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
393 |
"ppx:types/ppx:%(element_type)ss/ppx:%(element_type)s[@name=$name]" % locals()) |
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
394 |
def gettypeElement(self, name): |
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
395 |
elements = elements_xpath(self, name=name) |
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
396 |
if len(elements) == 1: |
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
397 |
return elements[0] |
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
398 |
return None |
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
399 |
return gettypeElement |
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
400 |
|
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
401 |
datatypes_xpath = PLCOpen_XPath("ppx:types/ppx:dataTypes/ppx:dataType") |
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
402 |
filtered_datatypes_xpath = PLCOpen_XPath( |
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
403 |
"ppx:types/ppx:dataTypes/ppx:dataType[@name!=$exclude]") |
1302
7856cd7767d6
Removed dictionaries storing datatypes and pous defined in project and pou and datatype using tree from model
Laurent Bessard
parents:
1301
diff
changeset
|
404 |
def getdataTypes(self, exclude=None): |
1305
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
405 |
if exclude is not None: |
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
406 |
return filtered_datatypes_xpath(self, exclude=exclude) |
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
407 |
return datatypes_xpath(self) |
814 | 408 |
setattr(cls, "getdataTypes", getdataTypes) |
409 |
||
1305
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
410 |
setattr(cls, "getdataType", gettypeElementFunc("dataType")) |
814 | 411 |
|
412 |
def appenddataType(self, name): |
|
1301
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
413 |
if self.getdataType(name) is not None: |
814 | 414 |
raise ValueError, "\"%s\" Data Type already exists !!!"%name |
415 |
self.types.appenddataTypeElement(name) |
|
416 |
setattr(cls, "appenddataType", appenddataType) |
|
417 |
||
418 |
def insertdataType(self, index, datatype): |
|
419 |
self.types.insertdataTypeElement(index, datatype) |
|
420 |
setattr(cls, "insertdataType", insertdataType) |
|
421 |
||
422 |
def removedataType(self, name): |
|
423 |
self.types.removedataTypeElement(name) |
|
424 |
setattr(cls, "removedataType", removedataType) |
|
425 |
||
1305
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
426 |
def getpous(self, exclude=None, filter=[]): |
1302
7856cd7767d6
Removed dictionaries storing datatypes and pous defined in project and pou and datatype using tree from model
Laurent Bessard
parents:
1301
diff
changeset
|
427 |
return self.xpath( |
7856cd7767d6
Removed dictionaries storing datatypes and pous defined in project and pou and datatype using tree from model
Laurent Bessard
parents:
1301
diff
changeset
|
428 |
"ppx:types/ppx:pous/ppx:pou%s%s" % |
7856cd7767d6
Removed dictionaries storing datatypes and pous defined in project and pou and datatype using tree from model
Laurent Bessard
parents:
1301
diff
changeset
|
429 |
(("[@name!='%s']" % exclude) if exclude is not None else '', |
7856cd7767d6
Removed dictionaries storing datatypes and pous defined in project and pou and datatype using tree from model
Laurent Bessard
parents:
1301
diff
changeset
|
430 |
("[%s]" % " or ".join( |
7856cd7767d6
Removed dictionaries storing datatypes and pous defined in project and pou and datatype using tree from model
Laurent Bessard
parents:
1301
diff
changeset
|
431 |
map(lambda x: "@pouType='%s'" % x, filter))) |
1305
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
432 |
if len(filter) > 0 else ""), |
1302
7856cd7767d6
Removed dictionaries storing datatypes and pous defined in project and pou and datatype using tree from model
Laurent Bessard
parents:
1301
diff
changeset
|
433 |
namespaces=PLCOpenParser.NSMAP) |
814 | 434 |
setattr(cls, "getpous", getpous) |
435 |
||
1305
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
436 |
setattr(cls, "getpou", gettypeElementFunc("pou")) |
814 | 437 |
|
438 |
def appendpou(self, name, pou_type, body_type): |
|
439 |
self.types.appendpouElement(name, pou_type, body_type) |
|
440 |
setattr(cls, "appendpou", appendpou) |
|
441 |
||
442 |
def insertpou(self, index, pou): |
|
443 |
self.types.insertpouElement(index, pou) |
|
444 |
setattr(cls, "insertpou", insertpou) |
|
445 |
||
446 |
def removepou(self, name): |
|
447 |
self.types.removepouElement(name) |
|
448 |
setattr(cls, "removepou", removepou) |
|
449 |
||
1305
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
450 |
configurations_xpath = PLCOpen_XPath( |
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
451 |
"ppx:instances/ppx:configurations/ppx:configuration") |
814 | 452 |
def getconfigurations(self): |
1305
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
453 |
return configurations_xpath(self) |
1301
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
454 |
setattr(cls, "getconfigurations", getconfigurations) |
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
455 |
|
1305
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
456 |
configuration_xpath = PLCOpen_XPath( |
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
457 |
"ppx:instances/ppx:configurations/ppx:configuration[@name=$name]") |
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
458 |
def getconfiguration(self, name): |
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
459 |
configurations = configuration_xpath(self, name=name) |
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
460 |
if len(configurations) == 1: |
1301
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
461 |
return configurations[0] |
814 | 462 |
return None |
463 |
setattr(cls, "getconfiguration", getconfiguration) |
|
464 |
||
465 |
def addconfiguration(self, name): |
|
1301
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
466 |
if self.getconfiguration(name) is not None: |
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
467 |
raise ValueError, _("\"%s\" configuration already exists !!!") % name |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
468 |
new_configuration = PLCOpenParser.CreateElement("configuration", "configurations") |
814 | 469 |
new_configuration.setname(name) |
470 |
self.instances.configurations.appendconfiguration(new_configuration) |
|
471 |
setattr(cls, "addconfiguration", addconfiguration) |
|
472 |
||
473 |
def removeconfiguration(self, name): |
|
1301
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
474 |
configuration = self.getconfiguration(name) |
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
475 |
if configuration is None: |
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
476 |
raise ValueError, ("\"%s\" configuration doesn't exist !!!") % name |
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
477 |
self.instances.configurations.remove(configuration) |
814 | 478 |
setattr(cls, "removeconfiguration", removeconfiguration) |
1305
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
479 |
|
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
480 |
resources_xpath = PLCOpen_XPath( |
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
481 |
"ppx:instances/ppx:configurations/ppx:configuration[@name=$configname]/ppx:resource[@name=$name]") |
814 | 482 |
def getconfigurationResource(self, config_name, name): |
1305
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
483 |
resources = resources_xpath(self, configname=config_name, name=name) |
1301
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
484 |
if len(resources) == 1: |
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
485 |
return resources[0] |
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
486 |
return None |
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
487 |
setattr(cls, "getconfigurationResource", getconfigurationResource) |
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
488 |
|
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
489 |
def addconfigurationResource(self, config_name, name): |
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
490 |
if self.getconfigurationResource(config_name, name) is not None: |
1581
2295fdc5c271
fix translation strings with multiple parameters
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1571
diff
changeset
|
491 |
msg = _("\"{a1}\" resource already exists in \"{a2}\" configuration !!!").format(a1 = name, a2 = config_name) |
2295fdc5c271
fix translation strings with multiple parameters
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1571
diff
changeset
|
492 |
raise ValueError, msg |
814 | 493 |
configuration = self.getconfiguration(config_name) |
1294
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset
|
494 |
if configuration is not None: |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
495 |
new_resource = PLCOpenParser.CreateElement("resource", "configuration") |
814 | 496 |
new_resource.setname(name) |
497 |
configuration.appendresource(new_resource) |
|
498 |
setattr(cls, "addconfigurationResource", addconfigurationResource) |
|
499 |
||
500 |
def removeconfigurationResource(self, config_name, name): |
|
501 |
configuration = self.getconfiguration(config_name) |
|
1301
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
502 |
found = False |
1294
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset
|
503 |
if configuration is not None: |
1301
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
504 |
resource = self.getconfigurationResource(config_name, name) |
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
505 |
if resource is not None: |
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
506 |
configuration.remove(resource) |
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
507 |
found = True |
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
508 |
if not found: |
1581
2295fdc5c271
fix translation strings with multiple parameters
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1571
diff
changeset
|
509 |
msg = _("\"{a1}\" resource doesn't exist in \"{a2}\" configuration !!!").format(a1 = name, a2 = config_name) |
2295fdc5c271
fix translation strings with multiple parameters
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1571
diff
changeset
|
510 |
raise ValueError, msg |
814 | 511 |
setattr(cls, "removeconfigurationResource", removeconfigurationResource) |
512 |
||
513 |
def updateElementName(self, old_name, new_name): |
|
1301
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
514 |
for datatype in self.getdataTypes(): |
814 | 515 |
datatype.updateElementName(old_name, new_name) |
1301
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
516 |
for pou in self.getpous(): |
814 | 517 |
pou.updateElementName(old_name, new_name) |
1301
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
518 |
for configuration in self.getconfigurations(): |
814 | 519 |
configuration.updateElementName(old_name, new_name) |
520 |
setattr(cls, "updateElementName", updateElementName) |
|
521 |
||
522 |
def updateElementAddress(self, old_leading, new_leading): |
|
523 |
address_model = re.compile(FILTER_ADDRESS_MODEL % old_leading) |
|
1301
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
524 |
for pou in self.getpous(): |
814 | 525 |
pou.updateElementAddress(address_model, new_leading) |
1301
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
526 |
for configuration in self.getconfigurations(): |
814 | 527 |
configuration.updateElementAddress(address_model, new_leading) |
528 |
setattr(cls, "updateElementAddress", updateElementAddress) |
|
529 |
||
530 |
def removeVariableByAddress(self, address): |
|
1301
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
531 |
for pou in self.getpous(): |
814 | 532 |
pou.removeVariableByAddress(address) |
1301
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
533 |
for configuration in self.getconfigurations(): |
814 | 534 |
configuration.removeVariableByAddress(address) |
535 |
setattr(cls, "removeVariableByAddress", removeVariableByAddress) |
|
536 |
||
537 |
def removeVariableByFilter(self, leading): |
|
538 |
address_model = re.compile(FILTER_ADDRESS_MODEL % leading) |
|
1301
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
539 |
for pou in self.getpous(): |
814 | 540 |
pou.removeVariableByFilter(address_model) |
1301
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
541 |
for configuration in self.getconfigurations(): |
814 | 542 |
configuration.removeVariableByFilter(address_model) |
543 |
setattr(cls, "removeVariableByFilter", removeVariableByFilter) |
|
544 |
||
1305
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
545 |
enumerated_values_xpath = PLCOpen_XPath( |
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
546 |
"ppx:types/ppx:dataTypes/ppx:dataType/ppx:baseType/ppx:enum/ppx:values/ppx:value") |
1301
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
547 |
def GetEnumeratedDataTypeValues(self): |
1305
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
548 |
return [value.getname() for value in enumerated_values_xpath(self)] |
814 | 549 |
setattr(cls, "GetEnumeratedDataTypeValues", GetEnumeratedDataTypeValues) |
550 |
||
551 |
def Search(self, criteria, parent_infos=[]): |
|
552 |
result = self.types.Search(criteria, parent_infos) |
|
553 |
for configuration in self.instances.configurations.getconfiguration(): |
|
554 |
result.extend(configuration.Search(criteria, parent_infos)) |
|
555 |
return result |
|
556 |
setattr(cls, "Search", Search) |
|
557 |
||
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
558 |
cls = PLCOpenParser.GetElementClass("contentHeader", "project") |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
559 |
if cls: |
814 | 560 |
|
561 |
def setpageSize(self, width, height): |
|
562 |
self.coordinateInfo.setpageSize(width, height) |
|
563 |
setattr(cls, "setpageSize", setpageSize) |
|
564 |
||
565 |
def getpageSize(self): |
|
566 |
return self.coordinateInfo.getpageSize() |
|
567 |
setattr(cls, "getpageSize", getpageSize) |
|
568 |
||
569 |
def setscaling(self, scaling): |
|
570 |
for language, (x, y) in scaling.items(): |
|
571 |
self.coordinateInfo.setscaling(language, x, y) |
|
572 |
setattr(cls, "setscaling", setscaling) |
|
573 |
||
574 |
def getscaling(self): |
|
575 |
scaling = {} |
|
576 |
scaling["FBD"] = self.coordinateInfo.getscaling("FBD") |
|
577 |
scaling["LD"] = self.coordinateInfo.getscaling("LD") |
|
578 |
scaling["SFC"] = self.coordinateInfo.getscaling("SFC") |
|
579 |
return scaling |
|
580 |
setattr(cls, "getscaling", getscaling) |
|
581 |
||
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
582 |
cls = PLCOpenParser.GetElementClass("coordinateInfo", "contentHeader") |
814 | 583 |
if cls: |
584 |
def setpageSize(self, width, height): |
|
585 |
if width == 0 and height == 0: |
|
586 |
self.deletepageSize() |
|
587 |
else: |
|
588 |
if self.pageSize is None: |
|
589 |
self.addpageSize() |
|
590 |
self.pageSize.setx(width) |
|
591 |
self.pageSize.sety(height) |
|
592 |
setattr(cls, "setpageSize", setpageSize) |
|
593 |
||
594 |
def getpageSize(self): |
|
595 |
if self.pageSize is not None: |
|
596 |
return self.pageSize.getx(), self.pageSize.gety() |
|
597 |
return 0, 0 |
|
598 |
setattr(cls, "getpageSize", getpageSize) |
|
599 |
||
600 |
def setscaling(self, language, x, y): |
|
601 |
if language == "FBD": |
|
602 |
self.fbd.scaling.setx(x) |
|
603 |
self.fbd.scaling.sety(y) |
|
604 |
elif language == "LD": |
|
605 |
self.ld.scaling.setx(x) |
|
606 |
self.ld.scaling.sety(y) |
|
607 |
elif language == "SFC": |
|
608 |
self.sfc.scaling.setx(x) |
|
609 |
self.sfc.scaling.sety(y) |
|
610 |
setattr(cls, "setscaling", setscaling) |
|
611 |
||
612 |
def getscaling(self, language): |
|
613 |
if language == "FBD": |
|
614 |
return self.fbd.scaling.getx(), self.fbd.scaling.gety() |
|
615 |
elif language == "LD": |
|
616 |
return self.ld.scaling.getx(), self.ld.scaling.gety() |
|
617 |
elif language == "SFC": |
|
618 |
return self.sfc.scaling.getx(), self.sfc.scaling.gety() |
|
619 |
return 0, 0 |
|
620 |
setattr(cls, "getscaling", getscaling) |
|
621 |
||
622 |
def _Search(attributes, criteria, parent_infos): |
|
623 |
search_result = [] |
|
624 |
for attr, value in attributes: |
|
625 |
if value is not None: |
|
626 |
search_result.extend([(tuple(parent_infos + [attr]),) + result for result in TestTextElement(value, criteria)]) |
|
627 |
return search_result |
|
628 |
||
629 |
def _updateConfigurationResourceElementName(self, old_name, new_name): |
|
630 |
for varlist in self.getglobalVars(): |
|
631 |
for var in varlist.getvariable(): |
|
632 |
var_address = var.getaddress() |
|
633 |
if var_address is not None: |
|
1611
5e64d552b25a
make renames caseinsensitive
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1581
diff
changeset
|
634 |
if TextMatched(var_address, old_name): |
814 | 635 |
var.setaddress(new_name) |
1611
5e64d552b25a
make renames caseinsensitive
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1581
diff
changeset
|
636 |
if TextMatched(var.getname(), old_name): |
814 | 637 |
var.setname(new_name) |
638 |
||
639 |
def _updateConfigurationResourceElementAddress(self, address_model, new_leading): |
|
640 |
for varlist in self.getglobalVars(): |
|
641 |
for var in varlist.getvariable(): |
|
642 |
var_address = var.getaddress() |
|
643 |
if var_address is not None: |
|
644 |
var.setaddress(update_address(var_address, address_model, new_leading)) |
|
645 |
||
646 |
def _removeConfigurationResourceVariableByAddress(self, address): |
|
647 |
for varlist in self.getglobalVars(): |
|
648 |
variables = varlist.getvariable() |
|
649 |
for i in xrange(len(variables)-1, -1, -1): |
|
650 |
if variables[i].getaddress() == address: |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
651 |
variables.remove(variables[i]) |
814 | 652 |
|
653 |
def _removeConfigurationResourceVariableByFilter(self, address_model): |
|
654 |
for varlist in self.getglobalVars(): |
|
655 |
variables = varlist.getvariable() |
|
656 |
for i in xrange(len(variables)-1, -1, -1): |
|
657 |
var_address = variables[i].getaddress() |
|
658 |
if var_address is not None: |
|
659 |
result = address_model.match(var_address) |
|
660 |
if result is not None: |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
661 |
variables.remove(variables[i]) |
814 | 662 |
|
663 |
def _SearchInConfigurationResource(self, criteria, parent_infos=[]): |
|
664 |
search_result = _Search([("name", self.getname())], criteria, parent_infos) |
|
665 |
var_number = 0 |
|
666 |
for varlist in self.getglobalVars(): |
|
667 |
variable_type = searchResultVarTypes.get("globalVars", "var_local") |
|
668 |
variables = varlist.getvariable() |
|
669 |
for modifier, has_modifier in [("constant", varlist.getconstant()), |
|
670 |
("retain", varlist.getretain()), |
|
671 |
("non_retain", varlist.getnonretain())]: |
|
672 |
if has_modifier: |
|
673 |
for result in TestTextElement(modifier, criteria): |
|
674 |
search_result.append((tuple(parent_infos + [variable_type, (var_number, var_number + len(variables)), modifier]),) + result) |
|
675 |
break |
|
676 |
for variable in variables: |
|
677 |
search_result.extend(variable.Search(criteria, parent_infos + [variable_type, var_number])) |
|
678 |
var_number += 1 |
|
679 |
return search_result |
|
680 |
||
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
681 |
cls = PLCOpenParser.GetElementClass("configuration", "configurations") |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
682 |
if cls: |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
683 |
|
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
684 |
def addglobalVar(self, var_type, name, location="", description=""): |
1171
a506e4de8f84
Add support for Drag'n dropping located variables to function block creating global located variable in configuration and external variable in function block
Laurent Bessard
parents:
1142
diff
changeset
|
685 |
globalvars = self.getglobalVars() |
a506e4de8f84
Add support for Drag'n dropping located variables to function block creating global located variable in configuration and external variable in function block
Laurent Bessard
parents:
1142
diff
changeset
|
686 |
if len(globalvars) == 0: |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
687 |
globalvars.append(PLCOpenParser.CreateElement("varList")) |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
688 |
var = PLCOpenParser.CreateElement("variable", "varListPlain") |
1171
a506e4de8f84
Add support for Drag'n dropping located variables to function block creating global located variable in configuration and external variable in function block
Laurent Bessard
parents:
1142
diff
changeset
|
689 |
var.setname(name) |
1313
85c167bfff93
Replaced standard function blocks library definition from dictionary to plcopen xml files
Laurent Bessard
parents:
1310
diff
changeset
|
690 |
var.settype(var_type) |
1171
a506e4de8f84
Add support for Drag'n dropping located variables to function block creating global located variable in configuration and external variable in function block
Laurent Bessard
parents:
1142
diff
changeset
|
691 |
if location != "": |
a506e4de8f84
Add support for Drag'n dropping located variables to function block creating global located variable in configuration and external variable in function block
Laurent Bessard
parents:
1142
diff
changeset
|
692 |
var.setaddress(location) |
a506e4de8f84
Add support for Drag'n dropping located variables to function block creating global located variable in configuration and external variable in function block
Laurent Bessard
parents:
1142
diff
changeset
|
693 |
if description != "": |
1294
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset
|
694 |
ft = PLCOpenParser.CreateElement("documentation", "variable") |
1291
42ea51d083ce
Second stage of xmlclass refactoring using lxml , project are loaded and displayed successfully
Laurent Bessard
parents:
1290
diff
changeset
|
695 |
ft.setanyText(description) |
1171
a506e4de8f84
Add support for Drag'n dropping located variables to function block creating global located variable in configuration and external variable in function block
Laurent Bessard
parents:
1142
diff
changeset
|
696 |
var.setdocumentation(ft) |
a506e4de8f84
Add support for Drag'n dropping located variables to function block creating global located variable in configuration and external variable in function block
Laurent Bessard
parents:
1142
diff
changeset
|
697 |
globalvars[-1].appendvariable(var) |
a506e4de8f84
Add support for Drag'n dropping located variables to function block creating global located variable in configuration and external variable in function block
Laurent Bessard
parents:
1142
diff
changeset
|
698 |
setattr(cls, "addglobalVar", addglobalVar) |
a506e4de8f84
Add support for Drag'n dropping located variables to function block creating global located variable in configuration and external variable in function block
Laurent Bessard
parents:
1142
diff
changeset
|
699 |
|
814 | 700 |
def updateElementName(self, old_name, new_name): |
701 |
_updateConfigurationResourceElementName(self, old_name, new_name) |
|
702 |
for resource in self.getresource(): |
|
703 |
resource.updateElementName(old_name, new_name) |
|
704 |
setattr(cls, "updateElementName", updateElementName) |
|
705 |
||
706 |
def updateElementAddress(self, address_model, new_leading): |
|
707 |
_updateConfigurationResourceElementAddress(self, address_model, new_leading) |
|
708 |
for resource in self.getresource(): |
|
709 |
resource.updateElementAddress(address_model, new_leading) |
|
710 |
setattr(cls, "updateElementAddress", updateElementAddress) |
|
711 |
||
712 |
setattr(cls, "removeVariableByAddress", _removeConfigurationResourceVariableByAddress) |
|
713 |
setattr(cls, "removeVariableByFilter", _removeConfigurationResourceVariableByFilter) |
|
714 |
||
715 |
def Search(self, criteria, parent_infos=[]): |
|
716 |
search_result = [] |
|
717 |
parent_infos = parent_infos + ["C::%s" % self.getname()] |
|
718 |
filter = criteria["filter"] |
|
719 |
if filter == "all" or "configuration" in filter: |
|
720 |
search_result = _SearchInConfigurationResource(self, criteria, parent_infos) |
|
721 |
for resource in self.getresource(): |
|
722 |
search_result.extend(resource.Search(criteria, parent_infos)) |
|
723 |
return search_result |
|
724 |
setattr(cls, "Search", Search) |
|
725 |
||
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
726 |
cls = PLCOpenParser.GetElementClass("resource", "configuration") |
814 | 727 |
if cls: |
728 |
def updateElementName(self, old_name, new_name): |
|
729 |
_updateConfigurationResourceElementName(self, old_name, new_name) |
|
730 |
for instance in self.getpouInstance(): |
|
731 |
instance.updateElementName(old_name, new_name) |
|
732 |
for task in self.gettask(): |
|
733 |
task.updateElementName(old_name, new_name) |
|
734 |
setattr(cls, "updateElementName", updateElementName) |
|
735 |
||
736 |
def updateElementAddress(self, address_model, new_leading): |
|
737 |
_updateConfigurationResourceElementAddress(self, address_model, new_leading) |
|
738 |
for task in self.gettask(): |
|
739 |
task.updateElementAddress(address_model, new_leading) |
|
740 |
setattr(cls, "updateElementAddress", updateElementAddress) |
|
741 |
||
742 |
setattr(cls, "removeVariableByAddress", _removeConfigurationResourceVariableByAddress) |
|
743 |
setattr(cls, "removeVariableByFilter", _removeConfigurationResourceVariableByFilter) |
|
744 |
||
745 |
def Search(self, criteria, parent_infos=[]): |
|
746 |
parent_infos = parent_infos[:-1] + ["R::%s::%s" % (parent_infos[-1].split("::")[1], self.getname())] |
|
747 |
search_result = _SearchInConfigurationResource(self, criteria, parent_infos) |
|
748 |
task_number = 0 |
|
749 |
instance_number = 0 |
|
750 |
for task in self.gettask(): |
|
751 |
results = TestTextElement(task.getname(), criteria) |
|
752 |
for result in results: |
|
753 |
search_result.append((tuple(parent_infos + ["task", task_number, "name"]),) + result) |
|
754 |
search_result.extend(task.Search(criteria, parent_infos + ["task", task_number])) |
|
755 |
task_number += 1 |
|
756 |
for instance in task.getpouInstance(): |
|
757 |
search_result.extend(task.Search(criteria, parent_infos + ["instance", instance_number])) |
|
758 |
for result in results: |
|
759 |
search_result.append((tuple(parent_infos + ["instance", instance_number, "task"]),) + result) |
|
760 |
instance_number += 1 |
|
761 |
for instance in self.getpouInstance(): |
|
762 |
search_result.extend(instance.Search(criteria, parent_infos + ["instance", instance_number])) |
|
763 |
instance_number += 1 |
|
764 |
return search_result |
|
765 |
setattr(cls, "Search", Search) |
|
766 |
||
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
767 |
cls = PLCOpenParser.GetElementClass("task", "resource") |
814 | 768 |
if cls: |
769 |
def updateElementName(self, old_name, new_name): |
|
1611
5e64d552b25a
make renames caseinsensitive
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1581
diff
changeset
|
770 |
if TextMatched(self.single, old_name): |
814 | 771 |
self.single = new_name |
1611
5e64d552b25a
make renames caseinsensitive
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1581
diff
changeset
|
772 |
if TextMatched(self.interval, old_name): |
814 | 773 |
self.interval = new_name |
774 |
for instance in self.getpouInstance(): |
|
775 |
instance.updateElementName(old_name, new_name) |
|
776 |
setattr(cls, "updateElementName", updateElementName) |
|
777 |
||
778 |
def updateElementAddress(self, address_model, new_leading): |
|
779 |
if self.single is not None: |
|
780 |
self.single = update_address(self.single, address_model, new_leading) |
|
781 |
if self.interval is not None: |
|
782 |
self.interval = update_address(self.interval, address_model, new_leading) |
|
783 |
setattr(cls, "updateElementAddress", updateElementAddress) |
|
784 |
||
785 |
def Search(self, criteria, parent_infos=[]): |
|
786 |
return _Search([("single", self.getsingle()), |
|
787 |
("interval", self.getinterval()), |
|
788 |
("priority", str(self.getpriority()))], |
|
789 |
criteria, parent_infos) |
|
790 |
setattr(cls, "Search", Search) |
|
791 |
||
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
792 |
cls = PLCOpenParser.GetElementClass("pouInstance") |
814 | 793 |
if cls: |
794 |
def updateElementName(self, old_name, new_name): |
|
1611
5e64d552b25a
make renames caseinsensitive
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1581
diff
changeset
|
795 |
if TextMatched(self.typeName, old_name): |
814 | 796 |
self.typeName = new_name |
797 |
setattr(cls, "updateElementName", updateElementName) |
|
798 |
||
799 |
def Search(self, criteria, parent_infos=[]): |
|
800 |
return _Search([("name", self.getname()), |
|
801 |
("type", self.gettypeName())], |
|
802 |
criteria, parent_infos) |
|
803 |
setattr(cls, "Search", Search) |
|
804 |
||
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
805 |
cls = PLCOpenParser.GetElementClass("variable", "varListPlain") |
814 | 806 |
if cls: |
807 |
def gettypeAsText(self): |
|
808 |
vartype_content = self.gettype().getcontent() |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
809 |
vartype_content_name = vartype_content.getLocalTag() |
814 | 810 |
# Variable type is a user data type |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
811 |
if vartype_content_name == "derived": |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
812 |
return vartype_content.getname() |
814 | 813 |
# Variable type is a string type |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
814 |
elif vartype_content_name in ["string", "wstring"]: |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
815 |
return vartype_content_name.upper() |
814 | 816 |
# Variable type is an array |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
817 |
elif vartype_content_name == "array": |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
818 |
base_type = vartype_content.baseType.getcontent() |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
819 |
base_type_name = base_type.getLocalTag() |
814 | 820 |
# Array derived directly from a user defined type |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
821 |
if base_type_name == "derived": |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
822 |
basetype_name = base_type.getname() |
814 | 823 |
# Array derived directly from a string type |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
824 |
elif base_type_name in ["string", "wstring"]: |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
825 |
basetype_name = base_type_name.upper() |
814 | 826 |
# Array derived directly from an elementary type |
827 |
else: |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
828 |
basetype_name = base_type_name |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
829 |
return "ARRAY [%s] OF %s" % (",".join(map(lambda x : "%s..%s" % (x.getlower(), x.getupper()), vartype_content.getdimension())), basetype_name) |
814 | 830 |
# Variable type is an elementary type |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
831 |
return vartype_content_name |
814 | 832 |
setattr(cls, "gettypeAsText", gettypeAsText) |
833 |
||
834 |
def Search(self, criteria, parent_infos=[]): |
|
835 |
search_result = _Search([("name", self.getname()), |
|
836 |
("type", self.gettypeAsText()), |
|
837 |
("location", self.getaddress())], |
|
838 |
criteria, parent_infos) |
|
839 |
initial = self.getinitialValue() |
|
840 |
if initial is not None: |
|
841 |
search_result.extend(_Search([("initial value", initial.getvalue())], criteria, parent_infos)) |
|
842 |
doc = self.getdocumentation() |
|
843 |
if doc is not None: |
|
844 |
search_result.extend(doc.Search(criteria, parent_infos + ["documentation"])) |
|
845 |
return search_result |
|
846 |
setattr(cls, "Search", Search) |
|
847 |
||
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
848 |
cls = PLCOpenParser.GetElementClass("types", "project") |
814 | 849 |
if cls: |
850 |
def getdataTypeElements(self): |
|
851 |
return self.dataTypes.getdataType() |
|
852 |
setattr(cls, "getdataTypeElements", getdataTypeElements) |
|
853 |
||
854 |
def getdataTypeElement(self, name): |
|
855 |
elements = self.dataTypes.getdataType() |
|
856 |
for element in elements: |
|
1611
5e64d552b25a
make renames caseinsensitive
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1581
diff
changeset
|
857 |
if TextMatched(element.getname(), name): |
814 | 858 |
return element |
859 |
return None |
|
860 |
setattr(cls, "getdataTypeElement", getdataTypeElement) |
|
861 |
||
862 |
def appenddataTypeElement(self, name): |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
863 |
new_datatype = PLCOpenParser.CreateElement("dataType", "dataTypes") |
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
864 |
self.dataTypes.appenddataType(new_datatype) |
814 | 865 |
new_datatype.setname(name) |
1294
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset
|
866 |
new_datatype.baseType.setcontent(PLCOpenParser.CreateElement("BOOL", "dataType")) |
814 | 867 |
setattr(cls, "appenddataTypeElement", appenddataTypeElement) |
868 |
||
869 |
def insertdataTypeElement(self, index, dataType): |
|
870 |
self.dataTypes.insertdataType(index, dataType) |
|
871 |
setattr(cls, "insertdataTypeElement", insertdataTypeElement) |
|
872 |
||
873 |
def removedataTypeElement(self, name): |
|
874 |
found = False |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
875 |
for element in self.dataTypes.getdataType(): |
1611
5e64d552b25a
make renames caseinsensitive
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1581
diff
changeset
|
876 |
if TextMatched(element.getname(), name): |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
877 |
self.dataTypes.remove(element) |
814 | 878 |
found = True |
879 |
break |
|
880 |
if not found: |
|
881 |
raise ValueError, _("\"%s\" Data Type doesn't exist !!!")%name |
|
882 |
setattr(cls, "removedataTypeElement", removedataTypeElement) |
|
883 |
||
884 |
def getpouElements(self): |
|
885 |
return self.pous.getpou() |
|
886 |
setattr(cls, "getpouElements", getpouElements) |
|
887 |
||
888 |
def getpouElement(self, name): |
|
889 |
elements = self.pous.getpou() |
|
890 |
for element in elements: |
|
1611
5e64d552b25a
make renames caseinsensitive
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1581
diff
changeset
|
891 |
if TextMatched(element.getname(), name): |
814 | 892 |
return element |
893 |
return None |
|
894 |
setattr(cls, "getpouElement", getpouElement) |
|
895 |
||
896 |
def appendpouElement(self, name, pou_type, body_type): |
|
897 |
for element in self.pous.getpou(): |
|
1611
5e64d552b25a
make renames caseinsensitive
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1581
diff
changeset
|
898 |
if TextMatched(element.getname(), name): |
814 | 899 |
raise ValueError, _("\"%s\" POU already exists !!!")%name |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
900 |
new_pou = PLCOpenParser.CreateElement("pou", "pous") |
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
901 |
self.pous.appendpou(new_pou) |
814 | 902 |
new_pou.setname(name) |
903 |
new_pou.setpouType(pou_type) |
|
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
904 |
new_pou.appendbody(PLCOpenParser.CreateElement("body", "pou")) |
814 | 905 |
new_pou.setbodyType(body_type) |
906 |
setattr(cls, "appendpouElement", appendpouElement) |
|
907 |
||
908 |
def insertpouElement(self, index, pou): |
|
909 |
self.pous.insertpou(index, pou) |
|
910 |
setattr(cls, "insertpouElement", insertpouElement) |
|
911 |
||
912 |
def removepouElement(self, name): |
|
913 |
found = False |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
914 |
for element in self.pous.getpou(): |
1611
5e64d552b25a
make renames caseinsensitive
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1581
diff
changeset
|
915 |
if TextMatched(element.getname(), name): |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
916 |
self.pous.remove(element) |
814 | 917 |
found = True |
918 |
break |
|
919 |
if not found: |
|
920 |
raise ValueError, _("\"%s\" POU doesn't exist !!!")%name |
|
921 |
setattr(cls, "removepouElement", removepouElement) |
|
922 |
||
923 |
def Search(self, criteria, parent_infos=[]): |
|
924 |
search_result = [] |
|
925 |
filter = criteria["filter"] |
|
926 |
for datatype in self.dataTypes.getdataType(): |
|
927 |
search_result.extend(datatype.Search(criteria, parent_infos)) |
|
928 |
for pou in self.pous.getpou(): |
|
929 |
search_result.extend(pou.Search(criteria, parent_infos)) |
|
930 |
return search_result |
|
931 |
setattr(cls, "Search", Search) |
|
932 |
||
933 |
def _updateBaseTypeElementName(self, old_name, new_name): |
|
934 |
self.baseType.updateElementName(old_name, new_name) |
|
935 |
||
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
936 |
cls = PLCOpenParser.GetElementClass("dataType", "dataTypes") |
814 | 937 |
if cls: |
938 |
setattr(cls, "updateElementName", _updateBaseTypeElementName) |
|
939 |
||
940 |
def Search(self, criteria, parent_infos=[]): |
|
941 |
search_result = [] |
|
942 |
filter = criteria["filter"] |
|
943 |
if filter == "all" or "datatype" in filter: |
|
944 |
parent_infos = parent_infos + ["D::%s" % self.getname()] |
|
945 |
search_result.extend(_Search([("name", self.getname())], criteria, parent_infos)) |
|
946 |
search_result.extend(self.baseType.Search(criteria, parent_infos)) |
|
947 |
if self.initialValue is not None: |
|
948 |
search_result.extend(_Search([("initial", self.initialValue.getvalue())], criteria, parent_infos)) |
|
949 |
return search_result |
|
950 |
setattr(cls, "Search", Search) |
|
951 |
||
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
952 |
cls = PLCOpenParser.GetElementClass("dataType") |
814 | 953 |
if cls: |
954 |
||
955 |
def updateElementName(self, old_name, new_name): |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
956 |
content_name = self.content.getLocalTag() |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
957 |
if content_name in ["derived", "array", "subrangeSigned", "subrangeUnsigned"]: |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
958 |
self.content.updateElementName(old_name, new_name) |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
959 |
elif content_name == "struct": |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
960 |
for element in self.content.getvariable(): |
814 | 961 |
element_type = element.type.updateElementName(old_name, new_name) |
962 |
setattr(cls, "updateElementName", updateElementName) |
|
963 |
||
964 |
def Search(self, criteria, parent_infos=[]): |
|
965 |
search_result = [] |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
966 |
content_name = self.content.getLocalTag() |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
967 |
if content_name in ["derived", "array", "enum", "subrangeSigned", "subrangeUnsigned"]: |
1294
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset
|
968 |
search_result.extend(self.content.Search(criteria, parent_infos + ["base"])) |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
969 |
elif content_name == "struct": |
1294
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset
|
970 |
for i, element in enumerate(self.content.getvariable()): |
814 | 971 |
search_result.extend(element.Search(criteria, parent_infos + ["struct", i])) |
972 |
else: |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
973 |
if content_name in ["string", "wstring"]: |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
974 |
content_name = content_name.upper() |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
975 |
search_result.extend(_Search([("base", content_name)], criteria, parent_infos)) |
814 | 976 |
return search_result |
977 |
setattr(cls, "Search", Search) |
|
978 |
||
1294
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset
|
979 |
cls = PLCOpenParser.GetElementClass("derived", "dataType") |
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset
|
980 |
if cls: |
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset
|
981 |
def updateElementName(self, old_name, new_name): |
1611
5e64d552b25a
make renames caseinsensitive
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1581
diff
changeset
|
982 |
if TextMatched(self.name, old_name): |
1294
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset
|
983 |
self.name = new_name |
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset
|
984 |
setattr(cls, "updateElementName", updateElementName) |
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset
|
985 |
|
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset
|
986 |
def Search(self, criteria, parent_infos=[]): |
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset
|
987 |
return [(tuple(parent_infos),) + result for result in TestTextElement(self.name, criteria)] |
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset
|
988 |
setattr(cls, "Search", Search) |
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset
|
989 |
|
1291
42ea51d083ce
Second stage of xmlclass refactoring using lxml , project are loaded and displayed successfully
Laurent Bessard
parents:
1290
diff
changeset
|
990 |
cls = PLCOpenParser.GetElementClass("array", "dataType") |
814 | 991 |
if cls: |
992 |
setattr(cls, "updateElementName", _updateBaseTypeElementName) |
|
993 |
||
994 |
def Search(self, criteria, parent_infos=[]): |
|
995 |
search_result = self.baseType.Search(criteria, parent_infos) |
|
996 |
for i, dimension in enumerate(self.getdimension()): |
|
997 |
search_result.extend(_Search([("lower", dimension.getlower()), |
|
998 |
("upper", dimension.getupper())], |
|
999 |
criteria, parent_infos + ["range", i])) |
|
1000 |
return search_result |
|
1001 |
setattr(cls, "Search", Search) |
|
1002 |
||
1003 |
def _SearchInSubrange(self, criteria, parent_infos=[]): |
|
1004 |
search_result = self.baseType.Search(criteria, parent_infos) |
|
1005 |
search_result.extend(_Search([("lower", self.range.getlower()), |
|
1006 |
("upper", self.range.getupper())], |
|
1007 |
criteria, parent_infos)) |
|
1008 |
return search_result |
|
1009 |
||
1291
42ea51d083ce
Second stage of xmlclass refactoring using lxml , project are loaded and displayed successfully
Laurent Bessard
parents:
1290
diff
changeset
|
1010 |
cls = PLCOpenParser.GetElementClass("subrangeSigned", "dataType") |
814 | 1011 |
if cls: |
1012 |
setattr(cls, "updateElementName", _updateBaseTypeElementName) |
|
1013 |
setattr(cls, "Search", _SearchInSubrange) |
|
1014 |
||
1291
42ea51d083ce
Second stage of xmlclass refactoring using lxml , project are loaded and displayed successfully
Laurent Bessard
parents:
1290
diff
changeset
|
1015 |
cls = PLCOpenParser.GetElementClass("subrangeUnsigned", "dataType") |
814 | 1016 |
if cls: |
1017 |
setattr(cls, "updateElementName", _updateBaseTypeElementName) |
|
1018 |
setattr(cls, "Search", _SearchInSubrange) |
|
1019 |
||
1291
42ea51d083ce
Second stage of xmlclass refactoring using lxml , project are loaded and displayed successfully
Laurent Bessard
parents:
1290
diff
changeset
|
1020 |
cls = PLCOpenParser.GetElementClass("enum", "dataType") |
814 | 1021 |
if cls: |
1022 |
||
1023 |
def updateElementName(self, old_name, new_name): |
|
1024 |
pass |
|
1025 |
setattr(cls, "updateElementName", updateElementName) |
|
1026 |
||
1305
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
1027 |
enumerated_datatype_values_xpath = PLCOpen_XPath("ppx:values/ppx:value") |
814 | 1028 |
def Search(self, criteria, parent_infos=[]): |
1029 |
search_result = [] |
|
1305
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
1030 |
for i, value in enumerate(enumerated_datatype_values_xpath(self)): |
814 | 1031 |
for result in TestTextElement(value.getname(), criteria): |
1032 |
search_result.append((tuple(parent_infos + ["value", i]),) + result) |
|
1033 |
return search_result |
|
1034 |
setattr(cls, "Search", Search) |
|
1035 |
||
1302
7856cd7767d6
Removed dictionaries storing datatypes and pous defined in project and pou and datatype using tree from model
Laurent Bessard
parents:
1301
diff
changeset
|
1036 |
def _getvariableTypeinfos(variable_type): |
7856cd7767d6
Removed dictionaries storing datatypes and pous defined in project and pou and datatype using tree from model
Laurent Bessard
parents:
1301
diff
changeset
|
1037 |
type_content = variable_type.getcontent() |
7856cd7767d6
Removed dictionaries storing datatypes and pous defined in project and pou and datatype using tree from model
Laurent Bessard
parents:
1301
diff
changeset
|
1038 |
type_content_type = type_content.getLocalTag() |
7856cd7767d6
Removed dictionaries storing datatypes and pous defined in project and pou and datatype using tree from model
Laurent Bessard
parents:
1301
diff
changeset
|
1039 |
if type_content_type == "derived": |
7856cd7767d6
Removed dictionaries storing datatypes and pous defined in project and pou and datatype using tree from model
Laurent Bessard
parents:
1301
diff
changeset
|
1040 |
return type_content.getname() |
7856cd7767d6
Removed dictionaries storing datatypes and pous defined in project and pou and datatype using tree from model
Laurent Bessard
parents:
1301
diff
changeset
|
1041 |
return type_content_type.upper() |
7856cd7767d6
Removed dictionaries storing datatypes and pous defined in project and pou and datatype using tree from model
Laurent Bessard
parents:
1301
diff
changeset
|
1042 |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1043 |
cls = PLCOpenParser.GetElementClass("pou", "pous") |
814 | 1044 |
if cls: |
1045 |
||
1305
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
1046 |
block_inputs_xpath = PLCOpen_XPath( |
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
1047 |
"ppx:interface/*[self::ppx:inputVars or self::ppx:inOutVars]/ppx:variable") |
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
1048 |
block_outputs_xpath = PLCOpen_XPath( |
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
1049 |
"ppx:interface/*[self::ppx:outputVars or self::ppx:inOutVars]/ppx:variable") |
1302
7856cd7767d6
Removed dictionaries storing datatypes and pous defined in project and pou and datatype using tree from model
Laurent Bessard
parents:
1301
diff
changeset
|
1050 |
def getblockInfos(self): |
7856cd7767d6
Removed dictionaries storing datatypes and pous defined in project and pou and datatype using tree from model
Laurent Bessard
parents:
1301
diff
changeset
|
1051 |
block_infos = { |
7856cd7767d6
Removed dictionaries storing datatypes and pous defined in project and pou and datatype using tree from model
Laurent Bessard
parents:
1301
diff
changeset
|
1052 |
"name" : self.getname(), |
7856cd7767d6
Removed dictionaries storing datatypes and pous defined in project and pou and datatype using tree from model
Laurent Bessard
parents:
1301
diff
changeset
|
1053 |
"type" : self.getpouType(), |
7856cd7767d6
Removed dictionaries storing datatypes and pous defined in project and pou and datatype using tree from model
Laurent Bessard
parents:
1301
diff
changeset
|
1054 |
"extensible" : False, |
7856cd7767d6
Removed dictionaries storing datatypes and pous defined in project and pou and datatype using tree from model
Laurent Bessard
parents:
1301
diff
changeset
|
1055 |
"inputs" : [], |
7856cd7767d6
Removed dictionaries storing datatypes and pous defined in project and pou and datatype using tree from model
Laurent Bessard
parents:
1301
diff
changeset
|
1056 |
"outputs" : [], |
1310
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1309
diff
changeset
|
1057 |
"comment" : self.getdescription()} |
1302
7856cd7767d6
Removed dictionaries storing datatypes and pous defined in project and pou and datatype using tree from model
Laurent Bessard
parents:
1301
diff
changeset
|
1058 |
if self.interface is not None: |
7856cd7767d6
Removed dictionaries storing datatypes and pous defined in project and pou and datatype using tree from model
Laurent Bessard
parents:
1301
diff
changeset
|
1059 |
return_type = self.interface.getreturnType() |
7856cd7767d6
Removed dictionaries storing datatypes and pous defined in project and pou and datatype using tree from model
Laurent Bessard
parents:
1301
diff
changeset
|
1060 |
if return_type is not None: |
7856cd7767d6
Removed dictionaries storing datatypes and pous defined in project and pou and datatype using tree from model
Laurent Bessard
parents:
1301
diff
changeset
|
1061 |
block_infos["outputs"].append( |
7856cd7767d6
Removed dictionaries storing datatypes and pous defined in project and pou and datatype using tree from model
Laurent Bessard
parents:
1301
diff
changeset
|
1062 |
("OUT", _getvariableTypeinfos(return_type), "none")) |
1305
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
1063 |
block_infos["inputs"].extend( |
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
1064 |
[(var.getname(), _getvariableTypeinfos(var.type), "none") |
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
1065 |
for var in block_inputs_xpath(self)]) |
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
1066 |
block_infos["outputs"].extend( |
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
1067 |
[(var.getname(), _getvariableTypeinfos(var.type), "none") |
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
1068 |
for var in block_outputs_xpath(self)]) |
1302
7856cd7767d6
Removed dictionaries storing datatypes and pous defined in project and pou and datatype using tree from model
Laurent Bessard
parents:
1301
diff
changeset
|
1069 |
|
7856cd7767d6
Removed dictionaries storing datatypes and pous defined in project and pou and datatype using tree from model
Laurent Bessard
parents:
1301
diff
changeset
|
1070 |
block_infos["usage"] = ("\n (%s) => (%s)" % |
7856cd7767d6
Removed dictionaries storing datatypes and pous defined in project and pou and datatype using tree from model
Laurent Bessard
parents:
1301
diff
changeset
|
1071 |
(", ".join(["%s:%s" % (input[1], input[0]) |
7856cd7767d6
Removed dictionaries storing datatypes and pous defined in project and pou and datatype using tree from model
Laurent Bessard
parents:
1301
diff
changeset
|
1072 |
for input in block_infos["inputs"]]), |
7856cd7767d6
Removed dictionaries storing datatypes and pous defined in project and pou and datatype using tree from model
Laurent Bessard
parents:
1301
diff
changeset
|
1073 |
", ".join(["%s:%s" % (output[1], output[0]) |
7856cd7767d6
Removed dictionaries storing datatypes and pous defined in project and pou and datatype using tree from model
Laurent Bessard
parents:
1301
diff
changeset
|
1074 |
for output in block_infos["outputs"]]))) |
7856cd7767d6
Removed dictionaries storing datatypes and pous defined in project and pou and datatype using tree from model
Laurent Bessard
parents:
1301
diff
changeset
|
1075 |
return block_infos |
7856cd7767d6
Removed dictionaries storing datatypes and pous defined in project and pou and datatype using tree from model
Laurent Bessard
parents:
1301
diff
changeset
|
1076 |
setattr(cls, "getblockInfos", getblockInfos) |
7856cd7767d6
Removed dictionaries storing datatypes and pous defined in project and pou and datatype using tree from model
Laurent Bessard
parents:
1301
diff
changeset
|
1077 |
|
814 | 1078 |
def setdescription(self, description): |
1079 |
doc = self.getdocumentation() |
|
1080 |
if doc is None: |
|
1294
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset
|
1081 |
doc = PLCOpenParser.CreateElement("documentation", "pou") |
814 | 1082 |
self.setdocumentation(doc) |
1291
42ea51d083ce
Second stage of xmlclass refactoring using lxml , project are loaded and displayed successfully
Laurent Bessard
parents:
1290
diff
changeset
|
1083 |
doc.setanyText(description) |
814 | 1084 |
setattr(cls, "setdescription", setdescription) |
1085 |
||
1086 |
def getdescription(self): |
|
1087 |
doc = self.getdocumentation() |
|
1088 |
if doc is not None: |
|
1291
42ea51d083ce
Second stage of xmlclass refactoring using lxml , project are loaded and displayed successfully
Laurent Bessard
parents:
1290
diff
changeset
|
1089 |
return doc.getanyText() |
814 | 1090 |
return "" |
1091 |
setattr(cls, "getdescription", getdescription) |
|
1092 |
||
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1093 |
def setbodyType(self, body_type): |
814 | 1094 |
if len(self.body) > 0: |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1095 |
if body_type in ["IL", "ST", "LD", "FBD", "SFC"]: |
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
1096 |
self.body[0].setcontent(PLCOpenParser.CreateElement(body_type, "body")) |
814 | 1097 |
else: |
1098 |
raise ValueError, "%s isn't a valid body type!"%type |
|
1099 |
setattr(cls, "setbodyType", setbodyType) |
|
1100 |
||
1101 |
def getbodyType(self): |
|
1102 |
if len(self.body) > 0: |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1103 |
return self.body[0].getcontent().getLocalTag() |
814 | 1104 |
setattr(cls, "getbodyType", getbodyType) |
1105 |
||
1106 |
def resetexecutionOrder(self): |
|
1107 |
if len(self.body) > 0: |
|
1108 |
self.body[0].resetexecutionOrder() |
|
1109 |
setattr(cls, "resetexecutionOrder", resetexecutionOrder) |
|
1110 |
||
1111 |
def compileexecutionOrder(self): |
|
1112 |
if len(self.body) > 0: |
|
1113 |
self.body[0].compileexecutionOrder() |
|
1114 |
setattr(cls, "compileexecutionOrder", compileexecutionOrder) |
|
1115 |
||
1116 |
def setelementExecutionOrder(self, instance, new_executionOrder): |
|
1117 |
if len(self.body) > 0: |
|
1118 |
self.body[0].setelementExecutionOrder(instance, new_executionOrder) |
|
1119 |
setattr(cls, "setelementExecutionOrder", setelementExecutionOrder) |
|
1120 |
||
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
1121 |
def addinstance(self, instance): |
814 | 1122 |
if len(self.body) > 0: |
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
1123 |
self.body[0].appendcontentInstance(instance) |
814 | 1124 |
setattr(cls, "addinstance", addinstance) |
1125 |
||
1126 |
def getinstances(self): |
|
1127 |
if len(self.body) > 0: |
|
1128 |
return self.body[0].getcontentInstances() |
|
1129 |
return [] |
|
1130 |
setattr(cls, "getinstances", getinstances) |
|
1131 |
||
1132 |
def getinstance(self, id): |
|
1133 |
if len(self.body) > 0: |
|
1134 |
return self.body[0].getcontentInstance(id) |
|
1135 |
return None |
|
1136 |
setattr(cls, "getinstance", getinstance) |
|
1137 |
||
1331
38c5de794e62
Added support for speed-up loading of graphic POU tabs
Laurent Bessard
parents:
1330
diff
changeset
|
1138 |
def getinstancesIds(self): |
814 | 1139 |
if len(self.body) > 0: |
1331
38c5de794e62
Added support for speed-up loading of graphic POU tabs
Laurent Bessard
parents:
1330
diff
changeset
|
1140 |
return self.body[0].getcontentInstancesIds() |
38c5de794e62
Added support for speed-up loading of graphic POU tabs
Laurent Bessard
parents:
1330
diff
changeset
|
1141 |
return [] |
38c5de794e62
Added support for speed-up loading of graphic POU tabs
Laurent Bessard
parents:
1330
diff
changeset
|
1142 |
setattr(cls, "getinstancesIds", getinstancesIds) |
814 | 1143 |
|
1144 |
def getinstanceByName(self, name): |
|
1145 |
if len(self.body) > 0: |
|
1146 |
return self.body[0].getcontentInstanceByName(name) |
|
1147 |
return None |
|
1148 |
setattr(cls, "getinstanceByName", getinstanceByName) |
|
1149 |
||
1150 |
def removeinstance(self, id): |
|
1151 |
if len(self.body) > 0: |
|
1152 |
self.body[0].removecontentInstance(id) |
|
1153 |
setattr(cls, "removeinstance", removeinstance) |
|
1154 |
||
1155 |
def settext(self, text): |
|
1156 |
if len(self.body) > 0: |
|
1157 |
self.body[0].settext(text) |
|
1158 |
setattr(cls, "settext", settext) |
|
1159 |
||
1160 |
def gettext(self): |
|
1161 |
if len(self.body) > 0: |
|
1162 |
return self.body[0].gettext() |
|
1163 |
return "" |
|
1164 |
setattr(cls, "gettext", gettext) |
|
1165 |
||
1166 |
def getvars(self): |
|
1167 |
vars = [] |
|
1168 |
if self.interface is not None: |
|
1169 |
reverse_types = {} |
|
1170 |
for name, value in VarTypes.items(): |
|
1171 |
reverse_types[value] = name |
|
1172 |
for varlist in self.interface.getcontent(): |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1173 |
vars.append((reverse_types[varlist.getLocalTag()], varlist)) |
814 | 1174 |
return vars |
1175 |
setattr(cls, "getvars", getvars) |
|
1176 |
||
1177 |
def setvars(self, vars): |
|
1178 |
if self.interface is None: |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1179 |
self.interface = PLCOpenParser.CreateElement("interface", "pou") |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1180 |
self.interface.setcontent(vars) |
814 | 1181 |
setattr(cls, "setvars", setvars) |
1182 |
||
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1183 |
def addpouExternalVar(self, var_type, name): |
1406
82db84fe88ea
Added 'NamedConstant' drag'n'drop in programs. It does create a simple variable with initial value and is usefull for drag'n'drop constants from extensions while keeping a name associated with constant
Edouard Tisserant
parents:
1400
diff
changeset
|
1184 |
self.addpouVar(var_type, name, "externalVars") |
814 | 1185 |
setattr(cls, "addpouExternalVar", addpouExternalVar) |
1186 |
||
1406
82db84fe88ea
Added 'NamedConstant' drag'n'drop in programs. It does create a simple variable with initial value and is usefull for drag'n'drop constants from extensions while keeping a name associated with constant
Edouard Tisserant
parents:
1400
diff
changeset
|
1187 |
def addpouVar(self, var_type, name, var_class="localVars", location="", description="", initval=""): |
814 | 1188 |
if self.interface is None: |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1189 |
self.interface = PLCOpenParser.CreateElement("interface", "pou") |
814 | 1190 |
content = self.interface.getcontent() |
1294
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset
|
1191 |
if len(content) == 0: |
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset
|
1192 |
varlist = PLCOpenParser.CreateElement(var_class, "interface") |
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset
|
1193 |
self.interface.setcontent([varlist]) |
1371
3c55c99b10ab
Fixed bug when adding and removing function block in graphic viewer. In some cases, the associated variable could stay in the variable panel.
Laurent Bessard
parents:
1355
diff
changeset
|
1194 |
elif content[-1].getLocalTag() != var_class: |
1294
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset
|
1195 |
varlist = PLCOpenParser.CreateElement(var_class, "interface") |
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset
|
1196 |
content[-1].addnext(varlist) |
814 | 1197 |
else: |
1294
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset
|
1198 |
varlist = content[-1] |
814 | 1199 |
variables = varlist.getvariable() |
1200 |
if varlist.getconstant() or varlist.getretain() or len(variables) > 0 and variables[0].getaddress(): |
|
1294
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset
|
1201 |
varlist = PLCOpenParser.CreateElement(var_class, "interface") |
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset
|
1202 |
content[-1].addnext(varlist) |
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
1203 |
var = PLCOpenParser.CreateElement("variable", "varListPlain") |
814 | 1204 |
var.setname(name) |
1313
85c167bfff93
Replaced standard function blocks library definition from dictionary to plcopen xml files
Laurent Bessard
parents:
1310
diff
changeset
|
1205 |
var.settype(var_type) |
814 | 1206 |
if location != "": |
1207 |
var.setaddress(location) |
|
1208 |
if description != "": |
|
1294
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset
|
1209 |
ft = PLCOpenParser.CreateElement("documentation", "variable") |
1291
42ea51d083ce
Second stage of xmlclass refactoring using lxml , project are loaded and displayed successfully
Laurent Bessard
parents:
1290
diff
changeset
|
1210 |
ft.setanyText(description) |
814 | 1211 |
var.setdocumentation(ft) |
1406
82db84fe88ea
Added 'NamedConstant' drag'n'drop in programs. It does create a simple variable with initial value and is usefull for drag'n'drop constants from extensions while keeping a name associated with constant
Edouard Tisserant
parents:
1400
diff
changeset
|
1212 |
if initval != "": |
82db84fe88ea
Added 'NamedConstant' drag'n'drop in programs. It does create a simple variable with initial value and is usefull for drag'n'drop constants from extensions while keeping a name associated with constant
Edouard Tisserant
parents:
1400
diff
changeset
|
1213 |
el = PLCOpenParser.CreateElement("initialValue", "variable") |
82db84fe88ea
Added 'NamedConstant' drag'n'drop in programs. It does create a simple variable with initial value and is usefull for drag'n'drop constants from extensions while keeping a name associated with constant
Edouard Tisserant
parents:
1400
diff
changeset
|
1214 |
el.setvalue(initval) |
82db84fe88ea
Added 'NamedConstant' drag'n'drop in programs. It does create a simple variable with initial value and is usefull for drag'n'drop constants from extensions while keeping a name associated with constant
Edouard Tisserant
parents:
1400
diff
changeset
|
1215 |
var.setinitialValue(el) |
814 | 1216 |
|
1294
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset
|
1217 |
varlist.appendvariable(var) |
814 | 1218 |
setattr(cls, "addpouVar", addpouVar) |
1406
82db84fe88ea
Added 'NamedConstant' drag'n'drop in programs. It does create a simple variable with initial value and is usefull for drag'n'drop constants from extensions while keeping a name associated with constant
Edouard Tisserant
parents:
1400
diff
changeset
|
1219 |
setattr(cls, "addpouLocalVar", addpouVar) |
814 | 1220 |
|
1221 |
def changepouVar(self, old_type, old_name, new_type, new_name): |
|
1222 |
if self.interface is not None: |
|
1223 |
content = self.interface.getcontent() |
|
1224 |
for varlist in content: |
|
1294
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset
|
1225 |
variables = varlist.getvariable() |
814 | 1226 |
for var in variables: |
1611
5e64d552b25a
make renames caseinsensitive
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1581
diff
changeset
|
1227 |
if TextMatched(var.getname(), old_name): |
814 | 1228 |
vartype_content = var.gettype().getcontent() |
1611
5e64d552b25a
make renames caseinsensitive
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1581
diff
changeset
|
1229 |
if vartype_content.getLocalTag() == "derived" and TextMatched(vartype_content.getname(), old_type): |
814 | 1230 |
var.setname(new_name) |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1231 |
vartype_content.setname(new_type) |
814 | 1232 |
return |
1233 |
setattr(cls, "changepouVar", changepouVar) |
|
1234 |
||
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1235 |
def removepouVar(self, var_type, name): |
814 | 1236 |
if self.interface is not None: |
1237 |
content = self.interface.getcontent() |
|
1238 |
for varlist in content: |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1239 |
for var in varlist.getvariable(): |
1611
5e64d552b25a
make renames caseinsensitive
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1581
diff
changeset
|
1240 |
if TextMatched(var.getname(), name): |
814 | 1241 |
vartype_content = var.gettype().getcontent() |
1611
5e64d552b25a
make renames caseinsensitive
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1581
diff
changeset
|
1242 |
if vartype_content.getLocalTag() == "derived" and TextMatched(vartype_content.getname(), var_type): |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1243 |
varlist.remove(var) |
1371
3c55c99b10ab
Fixed bug when adding and removing function block in graphic viewer. In some cases, the associated variable could stay in the variable panel.
Laurent Bessard
parents:
1355
diff
changeset
|
1244 |
if len(varlist.getvariable()) == 0: |
3c55c99b10ab
Fixed bug when adding and removing function block in graphic viewer. In some cases, the associated variable could stay in the variable panel.
Laurent Bessard
parents:
1355
diff
changeset
|
1245 |
self.interface.remove(varlist) |
814 | 1246 |
break |
1247 |
setattr(cls, "removepouVar", removepouVar) |
|
1626
0779c1b18c01
check before program generation whether SFC step, that is referenced
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1619
diff
changeset
|
1248 |
|
0779c1b18c01
check before program generation whether SFC step, that is referenced
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1619
diff
changeset
|
1249 |
def hasstep(self, name=None): |
0779c1b18c01
check before program generation whether SFC step, that is referenced
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1619
diff
changeset
|
1250 |
if self.getbodyType() in ["SFC"]: |
0779c1b18c01
check before program generation whether SFC step, that is referenced
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1619
diff
changeset
|
1251 |
for instance in self.getinstances(): |
0779c1b18c01
check before program generation whether SFC step, that is referenced
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1619
diff
changeset
|
1252 |
if isinstance(instance, PLCOpenParser.GetElementClass("step", "sfcObjects")) and TextMatched(instance.getname(), name): |
0779c1b18c01
check before program generation whether SFC step, that is referenced
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1619
diff
changeset
|
1253 |
return True |
0779c1b18c01
check before program generation whether SFC step, that is referenced
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1619
diff
changeset
|
1254 |
return False |
0779c1b18c01
check before program generation whether SFC step, that is referenced
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1619
diff
changeset
|
1255 |
setattr(cls, "hasstep", hasstep) |
814 | 1256 |
|
1142
8ded55ada6d6
Fixed functions used by one or more POU not showing question dialog when trying to delete
Laurent Bessard
parents:
990
diff
changeset
|
1257 |
def hasblock(self, name=None, block_type=None): |
8ded55ada6d6
Fixed functions used by one or more POU not showing question dialog when trying to delete
Laurent Bessard
parents:
990
diff
changeset
|
1258 |
if self.getbodyType() in ["FBD", "LD", "SFC"]: |
814 | 1259 |
for instance in self.getinstances(): |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1260 |
if (isinstance(instance, PLCOpenParser.GetElementClass("block", "fbdObjects")) and |
1611
5e64d552b25a
make renames caseinsensitive
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1581
diff
changeset
|
1261 |
(TextMatched(instance.getinstanceName(), name) or TextMatched(instance.gettypeName(), block_type))): |
814 | 1262 |
return True |
1263 |
if self.transitions: |
|
1264 |
for transition in self.transitions.gettransition(): |
|
1142
8ded55ada6d6
Fixed functions used by one or more POU not showing question dialog when trying to delete
Laurent Bessard
parents:
990
diff
changeset
|
1265 |
result = transition.hasblock(name, block_type) |
814 | 1266 |
if result: |
1267 |
return result |
|
1268 |
if self.actions: |
|
1269 |
for action in self.actions.getaction(): |
|
1142
8ded55ada6d6
Fixed functions used by one or more POU not showing question dialog when trying to delete
Laurent Bessard
parents:
990
diff
changeset
|
1270 |
result = action.hasblock(name, block_type) |
814 | 1271 |
if result: |
1272 |
return result |
|
1142
8ded55ada6d6
Fixed functions used by one or more POU not showing question dialog when trying to delete
Laurent Bessard
parents:
990
diff
changeset
|
1273 |
elif block_type is not None and len(self.body) > 0: |
8ded55ada6d6
Fixed functions used by one or more POU not showing question dialog when trying to delete
Laurent Bessard
parents:
990
diff
changeset
|
1274 |
return self.body[0].hasblock(block_type) |
814 | 1275 |
return False |
1276 |
setattr(cls, "hasblock", hasblock) |
|
1277 |
||
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1278 |
def addtransition(self, name, body_type): |
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
1279 |
if self.transitions is None: |
814 | 1280 |
self.addtransitions() |
1281 |
self.transitions.settransition([]) |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1282 |
transition = PLCOpenParser.CreateElement("transition", "transitions") |
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
1283 |
self.transitions.appendtransition(transition) |
814 | 1284 |
transition.setname(name) |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1285 |
transition.setbodyType(body_type) |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1286 |
if body_type == "ST": |
1616
3638463d6e02
fix issue with creating SFC transitions using ST and IL
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1611
diff
changeset
|
1287 |
transition.settext(":= ;") |
814 | 1288 |
setattr(cls, "addtransition", addtransition) |
1289 |
||
1290 |
def gettransition(self, name): |
|
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
1291 |
if self.transitions is not None: |
814 | 1292 |
for transition in self.transitions.gettransition(): |
1611
5e64d552b25a
make renames caseinsensitive
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1581
diff
changeset
|
1293 |
if TextMatched(transition.getname(), name): |
814 | 1294 |
return transition |
1295 |
return None |
|
1296 |
setattr(cls, "gettransition", gettransition) |
|
1297 |
||
1298 |
def gettransitionList(self): |
|
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
1299 |
if self.transitions is not None: |
814 | 1300 |
return self.transitions.gettransition() |
1301 |
return [] |
|
1302 |
setattr(cls, "gettransitionList", gettransitionList) |
|
1303 |
||
1304 |
def removetransition(self, name): |
|
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
1305 |
if self.transitions is not None: |
814 | 1306 |
removed = False |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1307 |
for transition in self.transitions.gettransition(): |
1611
5e64d552b25a
make renames caseinsensitive
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1581
diff
changeset
|
1308 |
if TextMatched(transition.getname(), name): |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1309 |
if transition.getbodyType() in ["FBD", "LD", "SFC"]: |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1310 |
for instance in transition.getinstances(): |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1311 |
if isinstance(instance, PLCOpenParser.GetElementClass("block", "fbdObjects")): |
824
be669f4c51c4
Fix bug in SFC function block declarations from transition and action not removed when transition or action is deleted
laurent
parents:
814
diff
changeset
|
1312 |
self.removepouVar(instance.gettypeName(), |
be669f4c51c4
Fix bug in SFC function block declarations from transition and action not removed when transition or action is deleted
laurent
parents:
814
diff
changeset
|
1313 |
instance.getinstanceName()) |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1314 |
self.transitions.remove(transition) |
814 | 1315 |
removed = True |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1316 |
break |
814 | 1317 |
if not removed: |
1318 |
raise ValueError, _("Transition with name %s doesn't exist!")%name |
|
1319 |
setattr(cls, "removetransition", removetransition) |
|
1320 |
||
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1321 |
def addaction(self, name, body_type): |
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
1322 |
if self.actions is None: |
814 | 1323 |
self.addactions() |
1324 |
self.actions.setaction([]) |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1325 |
action = PLCOpenParser.CreateElement("action", "actions") |
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
1326 |
self.actions.appendaction(action) |
814 | 1327 |
action.setname(name) |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1328 |
action.setbodyType(body_type) |
814 | 1329 |
setattr(cls, "addaction", addaction) |
1330 |
||
1331 |
def getaction(self, name): |
|
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
1332 |
if self.actions is not None: |
814 | 1333 |
for action in self.actions.getaction(): |
1611
5e64d552b25a
make renames caseinsensitive
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1581
diff
changeset
|
1334 |
if TextMatched(action.getname(), name): |
814 | 1335 |
return action |
1336 |
return None |
|
1337 |
setattr(cls, "getaction", getaction) |
|
1338 |
||
1339 |
def getactionList(self): |
|
1382
675a6229fc60
Fixed bugs in SFC when loading transition condition and referenced transition or action body
Laurent Bessard
parents:
1371
diff
changeset
|
1340 |
if self.actions is not None: |
814 | 1341 |
return self.actions.getaction() |
1342 |
return [] |
|
1343 |
setattr(cls, "getactionList", getactionList) |
|
824
be669f4c51c4
Fix bug in SFC function block declarations from transition and action not removed when transition or action is deleted
laurent
parents:
814
diff
changeset
|
1344 |
|
814 | 1345 |
def removeaction(self, name): |
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
1346 |
if self.actions is not None: |
814 | 1347 |
removed = False |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1348 |
for action in self.actions.getaction(): |
1611
5e64d552b25a
make renames caseinsensitive
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1581
diff
changeset
|
1349 |
if TextMatched(action.getname(), name): |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1350 |
if action.getbodyType() in ["FBD", "LD", "SFC"]: |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1351 |
for instance in action.getinstances(): |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1352 |
if isinstance(instance, PLCOpenParser.GetElementClass("block", "fbdObjects")): |
824
be669f4c51c4
Fix bug in SFC function block declarations from transition and action not removed when transition or action is deleted
laurent
parents:
814
diff
changeset
|
1353 |
self.removepouVar(instance.gettypeName(), |
be669f4c51c4
Fix bug in SFC function block declarations from transition and action not removed when transition or action is deleted
laurent
parents:
814
diff
changeset
|
1354 |
instance.getinstanceName()) |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1355 |
self.actions.remove(action) |
814 | 1356 |
removed = True |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1357 |
break |
814 | 1358 |
if not removed: |
1359 |
raise ValueError, _("Action with name %s doesn't exist!")%name |
|
1360 |
setattr(cls, "removeaction", removeaction) |
|
1361 |
||
1362 |
def updateElementName(self, old_name, new_name): |
|
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
1363 |
if self.interface is not None: |
814 | 1364 |
for content in self.interface.getcontent(): |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1365 |
for var in content.getvariable(): |
814 | 1366 |
var_address = var.getaddress() |
1367 |
if var_address is not None: |
|
1611
5e64d552b25a
make renames caseinsensitive
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1581
diff
changeset
|
1368 |
if TextMatched(var_address, old_name): |
814 | 1369 |
var.setaddress(new_name) |
1611
5e64d552b25a
make renames caseinsensitive
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1581
diff
changeset
|
1370 |
if TextMatched(var.getname(), old_name): |
814 | 1371 |
var.setname(new_name) |
1372 |
var_type_content = var.gettype().getcontent() |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1373 |
if var_type_content.getLocalTag() == "derived": |
1611
5e64d552b25a
make renames caseinsensitive
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1581
diff
changeset
|
1374 |
if TextMatched(var_type_content.getname(), old_name): |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1375 |
var_type_content.setname(new_name) |
814 | 1376 |
self.body[0].updateElementName(old_name, new_name) |
1377 |
for action in self.getactionList(): |
|
1378 |
action.updateElementName(old_name, new_name) |
|
1379 |
for transition in self.gettransitionList(): |
|
1380 |
transition.updateElementName(old_name, new_name) |
|
1381 |
setattr(cls, "updateElementName", updateElementName) |
|
1382 |
||
1383 |
def updateElementAddress(self, address_model, new_leading): |
|
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
1384 |
if self.interface is not None: |
814 | 1385 |
for content in self.interface.getcontent(): |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1386 |
for var in content.getvariable(): |
814 | 1387 |
var_address = var.getaddress() |
1388 |
if var_address is not None: |
|
1389 |
var.setaddress(update_address(var_address, address_model, new_leading)) |
|
1390 |
self.body[0].updateElementAddress(address_model, new_leading) |
|
1391 |
for action in self.getactionList(): |
|
1392 |
action.updateElementAddress(address_model, new_leading) |
|
1393 |
for transition in self.gettransitionList(): |
|
1394 |
transition.updateElementAddress(address_model, new_leading) |
|
1395 |
setattr(cls, "updateElementAddress", updateElementAddress) |
|
1396 |
||
1397 |
def removeVariableByAddress(self, address): |
|
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
1398 |
if self.interface is not None: |
814 | 1399 |
for content in self.interface.getcontent(): |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1400 |
for variable in content.getvariable(): |
1611
5e64d552b25a
make renames caseinsensitive
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1581
diff
changeset
|
1401 |
if TextMatched(variable.getaddress(), address): |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1402 |
content.remove(variable) |
814 | 1403 |
setattr(cls, "removeVariableByAddress", removeVariableByAddress) |
1404 |
||
1405 |
def removeVariableByFilter(self, address_model): |
|
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
1406 |
if self.interface is not None: |
814 | 1407 |
for content in self.interface.getcontent(): |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1408 |
for variable in content.getvariable(): |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1409 |
var_address = variable.getaddress() |
814 | 1410 |
if var_address is not None: |
1411 |
result = address_model.match(var_address) |
|
1412 |
if result is not None: |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1413 |
content.remove(variable) |
814 | 1414 |
setattr(cls, "removeVariableByFilter", removeVariableByFilter) |
1415 |
||
1416 |
def Search(self, criteria, parent_infos=[]): |
|
1417 |
search_result = [] |
|
1418 |
filter = criteria["filter"] |
|
1419 |
if filter == "all" or self.getpouType() in filter: |
|
1619
163d3a883575
fix local search in actions and transitions
Surkov Sergey <surkovsv93@gmail.com>
parents:
1616
diff
changeset
|
1420 |
if parent_infos == []: |
163d3a883575
fix local search in actions and transitions
Surkov Sergey <surkovsv93@gmail.com>
parents:
1616
diff
changeset
|
1421 |
parent_infos = parent_infos + ["P::%s" % self.getname()] |
814 | 1422 |
search_result.extend(_Search([("name", self.getname())], criteria, parent_infos)) |
1423 |
if self.interface is not None: |
|
1424 |
var_number = 0 |
|
1425 |
for content in self.interface.getcontent(): |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1426 |
variable_type = searchResultVarTypes.get(content, "var_local") |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1427 |
variables = content.getvariable() |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1428 |
for modifier, has_modifier in [("constant", content.getconstant()), |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1429 |
("retain", content.getretain()), |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1430 |
("non_retain", content.getnonretain())]: |
814 | 1431 |
if has_modifier: |
1432 |
for result in TestTextElement(modifier, criteria): |
|
1433 |
search_result.append((tuple(parent_infos + [variable_type, (var_number, var_number + len(variables)), modifier]),) + result) |
|
1434 |
break |
|
1435 |
for variable in variables: |
|
1436 |
search_result.extend(variable.Search(criteria, parent_infos + [variable_type, var_number])) |
|
1437 |
var_number += 1 |
|
1438 |
if len(self.body) > 0: |
|
1439 |
search_result.extend(self.body[0].Search(criteria, parent_infos)) |
|
1440 |
for action in self.getactionList(): |
|
1441 |
search_result.extend(action.Search(criteria, parent_infos)) |
|
1442 |
for transition in self.gettransitionList(): |
|
1443 |
search_result.extend(transition.Search(criteria, parent_infos)) |
|
1444 |
return search_result |
|
1445 |
setattr(cls, "Search", Search) |
|
1446 |
||
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1447 |
def setbodyType(self, body_type): |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1448 |
if body_type in ["IL", "ST", "LD", "FBD", "SFC"]: |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1449 |
self.body.setcontent(PLCOpenParser.CreateElement(body_type, "body")) |
814 | 1450 |
else: |
1451 |
raise ValueError, "%s isn't a valid body type!"%type |
|
1452 |
||
1453 |
def getbodyType(self): |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1454 |
return self.body.getcontent().getLocalTag() |
814 | 1455 |
|
1456 |
def resetexecutionOrder(self): |
|
1457 |
self.body.resetexecutionOrder() |
|
1458 |
||
1459 |
def compileexecutionOrder(self): |
|
1460 |
self.body.compileexecutionOrder() |
|
1461 |
||
1462 |
def setelementExecutionOrder(self, instance, new_executionOrder): |
|
1463 |
self.body.setelementExecutionOrder(instance, new_executionOrder) |
|
1464 |
||
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
1465 |
def addinstance(self, instance): |
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
1466 |
self.body.appendcontentInstance(instance) |
814 | 1467 |
|
1468 |
def getinstances(self): |
|
1469 |
return self.body.getcontentInstances() |
|
1470 |
||
1471 |
def getinstance(self, id): |
|
1472 |
return self.body.getcontentInstance(id) |
|
1473 |
||
1474 |
def getrandomInstance(self, exclude): |
|
1475 |
return self.body.getcontentRandomInstance(exclude) |
|
1476 |
||
1477 |
def getinstanceByName(self, name): |
|
1478 |
return self.body.getcontentInstanceByName(name) |
|
1479 |
||
1480 |
def removeinstance(self, id): |
|
1481 |
self.body.removecontentInstance(id) |
|
1482 |
||
1483 |
def settext(self, text): |
|
1484 |
self.body.settext(text) |
|
1485 |
||
1486 |
def gettext(self): |
|
1487 |
return self.body.gettext() |
|
1488 |
||
1142
8ded55ada6d6
Fixed functions used by one or more POU not showing question dialog when trying to delete
Laurent Bessard
parents:
990
diff
changeset
|
1489 |
def hasblock(self, name=None, block_type=None): |
8ded55ada6d6
Fixed functions used by one or more POU not showing question dialog when trying to delete
Laurent Bessard
parents:
990
diff
changeset
|
1490 |
if self.getbodyType() in ["FBD", "LD", "SFC"]: |
8ded55ada6d6
Fixed functions used by one or more POU not showing question dialog when trying to delete
Laurent Bessard
parents:
990
diff
changeset
|
1491 |
for instance in self.getinstances(): |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1492 |
if (isinstance(instance, PLCOpenParser.GetElementClass("block", "fbdObjects")) and |
1611
5e64d552b25a
make renames caseinsensitive
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1581
diff
changeset
|
1493 |
(TextMatched(instance.getinstanceName(), name) or TextMatched(instance.gettypeName(), block_type))): |
1142
8ded55ada6d6
Fixed functions used by one or more POU not showing question dialog when trying to delete
Laurent Bessard
parents:
990
diff
changeset
|
1494 |
return True |
8ded55ada6d6
Fixed functions used by one or more POU not showing question dialog when trying to delete
Laurent Bessard
parents:
990
diff
changeset
|
1495 |
elif block_type is not None: |
8ded55ada6d6
Fixed functions used by one or more POU not showing question dialog when trying to delete
Laurent Bessard
parents:
990
diff
changeset
|
1496 |
return self.body.hasblock(block_type) |
8ded55ada6d6
Fixed functions used by one or more POU not showing question dialog when trying to delete
Laurent Bessard
parents:
990
diff
changeset
|
1497 |
return False |
8ded55ada6d6
Fixed functions used by one or more POU not showing question dialog when trying to delete
Laurent Bessard
parents:
990
diff
changeset
|
1498 |
|
8ded55ada6d6
Fixed functions used by one or more POU not showing question dialog when trying to delete
Laurent Bessard
parents:
990
diff
changeset
|
1499 |
def updateElementName(self, old_name, new_name): |
8ded55ada6d6
Fixed functions used by one or more POU not showing question dialog when trying to delete
Laurent Bessard
parents:
990
diff
changeset
|
1500 |
self.body.updateElementName(old_name, new_name) |
8ded55ada6d6
Fixed functions used by one or more POU not showing question dialog when trying to delete
Laurent Bessard
parents:
990
diff
changeset
|
1501 |
|
8ded55ada6d6
Fixed functions used by one or more POU not showing question dialog when trying to delete
Laurent Bessard
parents:
990
diff
changeset
|
1502 |
def updateElementAddress(self, address_model, new_leading): |
8ded55ada6d6
Fixed functions used by one or more POU not showing question dialog when trying to delete
Laurent Bessard
parents:
990
diff
changeset
|
1503 |
self.body.updateElementAddress(address_model, new_leading) |
8ded55ada6d6
Fixed functions used by one or more POU not showing question dialog when trying to delete
Laurent Bessard
parents:
990
diff
changeset
|
1504 |
|
8ded55ada6d6
Fixed functions used by one or more POU not showing question dialog when trying to delete
Laurent Bessard
parents:
990
diff
changeset
|
1505 |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1506 |
cls = PLCOpenParser.GetElementClass("transition", "transitions") |
814 | 1507 |
if cls: |
1508 |
setattr(cls, "setbodyType", setbodyType) |
|
1509 |
setattr(cls, "getbodyType", getbodyType) |
|
1510 |
setattr(cls, "resetexecutionOrder", resetexecutionOrder) |
|
1511 |
setattr(cls, "compileexecutionOrder", compileexecutionOrder) |
|
1512 |
setattr(cls, "setelementExecutionOrder", setelementExecutionOrder) |
|
1513 |
setattr(cls, "addinstance", addinstance) |
|
1514 |
setattr(cls, "getinstances", getinstances) |
|
1515 |
setattr(cls, "getinstance", getinstance) |
|
1516 |
setattr(cls, "getrandomInstance", getrandomInstance) |
|
1517 |
setattr(cls, "getinstanceByName", getinstanceByName) |
|
1518 |
setattr(cls, "removeinstance", removeinstance) |
|
1519 |
setattr(cls, "settext", settext) |
|
1520 |
setattr(cls, "gettext", gettext) |
|
1142
8ded55ada6d6
Fixed functions used by one or more POU not showing question dialog when trying to delete
Laurent Bessard
parents:
990
diff
changeset
|
1521 |
setattr(cls, "hasblock", hasblock) |
814 | 1522 |
setattr(cls, "updateElementName", updateElementName) |
1523 |
setattr(cls, "updateElementAddress", updateElementAddress) |
|
1142
8ded55ada6d6
Fixed functions used by one or more POU not showing question dialog when trying to delete
Laurent Bessard
parents:
990
diff
changeset
|
1524 |
|
814 | 1525 |
def Search(self, criteria, parent_infos): |
1526 |
search_result = [] |
|
1527 |
parent_infos = parent_infos[:-1] + ["T::%s::%s" % (parent_infos[-1].split("::")[1], self.getname())] |
|
1528 |
for result in TestTextElement(self.getname(), criteria): |
|
1529 |
search_result.append((tuple(parent_infos + ["name"]),) + result) |
|
1530 |
search_result.extend(self.body.Search(criteria, parent_infos)) |
|
1531 |
return search_result |
|
1532 |
setattr(cls, "Search", Search) |
|
1533 |
||
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1534 |
cls = PLCOpenParser.GetElementClass("action", "actions") |
814 | 1535 |
if cls: |
1536 |
setattr(cls, "setbodyType", setbodyType) |
|
1537 |
setattr(cls, "getbodyType", getbodyType) |
|
1538 |
setattr(cls, "resetexecutionOrder", resetexecutionOrder) |
|
1539 |
setattr(cls, "compileexecutionOrder", compileexecutionOrder) |
|
1540 |
setattr(cls, "setelementExecutionOrder", setelementExecutionOrder) |
|
1541 |
setattr(cls, "addinstance", addinstance) |
|
1542 |
setattr(cls, "getinstances", getinstances) |
|
1543 |
setattr(cls, "getinstance", getinstance) |
|
1544 |
setattr(cls, "getrandomInstance", getrandomInstance) |
|
1545 |
setattr(cls, "getinstanceByName", getinstanceByName) |
|
1546 |
setattr(cls, "removeinstance", removeinstance) |
|
1547 |
setattr(cls, "settext", settext) |
|
1548 |
setattr(cls, "gettext", gettext) |
|
1142
8ded55ada6d6
Fixed functions used by one or more POU not showing question dialog when trying to delete
Laurent Bessard
parents:
990
diff
changeset
|
1549 |
setattr(cls, "hasblock", hasblock) |
814 | 1550 |
setattr(cls, "updateElementName", updateElementName) |
1551 |
setattr(cls, "updateElementAddress", updateElementAddress) |
|
1142
8ded55ada6d6
Fixed functions used by one or more POU not showing question dialog when trying to delete
Laurent Bessard
parents:
990
diff
changeset
|
1552 |
|
814 | 1553 |
def Search(self, criteria, parent_infos): |
1554 |
search_result = [] |
|
1555 |
parent_infos = parent_infos[:-1] + ["A::%s::%s" % (parent_infos[-1].split("::")[1], self.getname())] |
|
1556 |
for result in TestTextElement(self.getname(), criteria): |
|
1557 |
search_result.append((tuple(parent_infos + ["name"]),) + result) |
|
1558 |
search_result.extend(self.body.Search(criteria, parent_infos)) |
|
1559 |
return search_result |
|
1560 |
setattr(cls, "Search", Search) |
|
1561 |
||
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1562 |
cls = PLCOpenParser.GetElementClass("body") |
814 | 1563 |
if cls: |
1564 |
cls.currentExecutionOrderId = 0 |
|
1629
80eee3c5a057
attach checkedBlockDict variable to the body object
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1626
diff
changeset
|
1565 |
cls.checkedBlocksDict = {} |
814 | 1566 |
def resetcurrentExecutionOrderId(self): |
1567 |
object.__setattr__(self, "currentExecutionOrderId", 0) |
|
1568 |
setattr(cls, "resetcurrentExecutionOrderId", resetcurrentExecutionOrderId) |
|
1569 |
||
1570 |
def getnewExecutionOrderId(self): |
|
1571 |
object.__setattr__(self, "currentExecutionOrderId", self.currentExecutionOrderId + 1) |
|
1572 |
return self.currentExecutionOrderId |
|
1573 |
setattr(cls, "getnewExecutionOrderId", getnewExecutionOrderId) |
|
1574 |
||
1575 |
def resetexecutionOrder(self): |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1576 |
if self.content.getLocalTag() == "FBD": |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1577 |
for element in self.content.getcontent(): |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1578 |
if not isinstance(element, (PLCOpenParser.GetElementClass("comment", "commonObjects"), |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1579 |
PLCOpenParser.GetElementClass("connector", "commonObjects"), |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1580 |
PLCOpenParser.GetElementClass("continuation", "commonObjects"))): |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1581 |
element.setexecutionOrderId(0) |
1629
80eee3c5a057
attach checkedBlockDict variable to the body object
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1626
diff
changeset
|
1582 |
self.checkedBlocksDict.clear() |
814 | 1583 |
else: |
1584 |
raise TypeError, _("Can only generate execution order on FBD networks!") |
|
1585 |
setattr(cls, "resetexecutionOrder", resetexecutionOrder) |
|
1586 |
||
1587 |
def compileexecutionOrder(self): |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1588 |
if self.content.getLocalTag() == "FBD": |
814 | 1589 |
self.resetexecutionOrder() |
1590 |
self.resetcurrentExecutionOrderId() |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1591 |
for element in self.content.getcontent(): |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1592 |
if isinstance(element, PLCOpenParser.GetElementClass("outVariable", "fbdObjects")) and element.getexecutionOrderId() == 0: |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1593 |
connections = element.connectionPointIn.getconnections() |
814 | 1594 |
if connections and len(connections) == 1: |
1595 |
self.compileelementExecutionOrder(connections[0]) |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1596 |
element.setexecutionOrderId(self.getnewExecutionOrderId()) |
814 | 1597 |
else: |
1598 |
raise TypeError, _("Can only generate execution order on FBD networks!") |
|
1599 |
setattr(cls, "compileexecutionOrder", compileexecutionOrder) |
|
1600 |
||
1601 |
def compileelementExecutionOrder(self, link): |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1602 |
if self.content.getLocalTag() == "FBD": |
814 | 1603 |
localid = link.getrefLocalId() |
1604 |
instance = self.getcontentInstance(localid) |
|
1629
80eee3c5a057
attach checkedBlockDict variable to the body object
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1626
diff
changeset
|
1605 |
self.checkedBlocksDict[localid] = True |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1606 |
if isinstance(instance, PLCOpenParser.GetElementClass("block", "fbdObjects")) and instance.getexecutionOrderId() == 0: |
814 | 1607 |
for variable in instance.inputVariables.getvariable(): |
1608 |
connections = variable.connectionPointIn.getconnections() |
|
1609 |
if connections and len(connections) == 1: |
|
1629
80eee3c5a057
attach checkedBlockDict variable to the body object
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1626
diff
changeset
|
1610 |
if (self.checkedBlocksDict.has_key(connections[0].getrefLocalId()) == False): |
1534
d2abe4109467
fix infinite recursion in 'Reset Execution Order' functionality if FBD body contains feedback connections
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1406
diff
changeset
|
1611 |
self.compileelementExecutionOrder(connections[0]) |
d2abe4109467
fix infinite recursion in 'Reset Execution Order' functionality if FBD body contains feedback connections
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1406
diff
changeset
|
1612 |
if instance.getexecutionOrderId() == 0: |
d2abe4109467
fix infinite recursion in 'Reset Execution Order' functionality if FBD body contains feedback connections
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1406
diff
changeset
|
1613 |
instance.setexecutionOrderId(self.getnewExecutionOrderId()) |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1614 |
elif isinstance(instance, PLCOpenParser.GetElementClass("continuation", "commonObjects")) and instance.getexecutionOrderId() == 0: |
814 | 1615 |
for tmp_instance in self.getcontentInstances(): |
1611
5e64d552b25a
make renames caseinsensitive
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1581
diff
changeset
|
1616 |
if (isinstance(tmp_instance, PLCOpenParser.GetElementClass("connector", "commonObjects")) and |
5e64d552b25a
make renames caseinsensitive
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1581
diff
changeset
|
1617 |
TextMatched(tmp_instance.getname(), instance.getname()) and tmp_instance.getexecutionOrderId() == 0): |
814 | 1618 |
connections = tmp_instance.connectionPointIn.getconnections() |
1619 |
if connections and len(connections) == 1: |
|
1620 |
self.compileelementExecutionOrder(connections[0]) |
|
1621 |
else: |
|
1622 |
raise TypeError, _("Can only generate execution order on FBD networks!") |
|
1623 |
setattr(cls, "compileelementExecutionOrder", compileelementExecutionOrder) |
|
1624 |
||
1625 |
def setelementExecutionOrder(self, instance, new_executionOrder): |
|
1294
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset
|
1626 |
if self.content.getLocalTag() == "FBD": |
814 | 1627 |
old_executionOrder = instance.getexecutionOrderId() |
1628 |
if old_executionOrder is not None and old_executionOrder != 0 and new_executionOrder != 0: |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1629 |
for element in self.content.getcontent(): |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1630 |
if element != instance and not isinstance(element, PLCOpenParser.GetElementClass("comment", "commonObjects")): |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1631 |
element_executionOrder = element.getexecutionOrderId() |
814 | 1632 |
if old_executionOrder <= element_executionOrder <= new_executionOrder: |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1633 |
element.setexecutionOrderId(element_executionOrder - 1) |
814 | 1634 |
if new_executionOrder <= element_executionOrder <= old_executionOrder: |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1635 |
element.setexecutionOrderId(element_executionOrder + 1) |
814 | 1636 |
instance.setexecutionOrderId(new_executionOrder) |
1637 |
else: |
|
1638 |
raise TypeError, _("Can only generate execution order on FBD networks!") |
|
1639 |
setattr(cls, "setelementExecutionOrder", setelementExecutionOrder) |
|
1640 |
||
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
1641 |
def appendcontentInstance(self, instance): |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1642 |
if self.content.getLocalTag() in ["LD","FBD","SFC"]: |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1643 |
self.content.appendcontent(instance) |
814 | 1644 |
else: |
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
1645 |
raise TypeError, _("%s body don't have instances!")%self.content.getLocalTag() |
814 | 1646 |
setattr(cls, "appendcontentInstance", appendcontentInstance) |
1647 |
||
1648 |
def getcontentInstances(self): |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1649 |
if self.content.getLocalTag() in ["LD","FBD","SFC"]: |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1650 |
return self.content.getcontent() |
814 | 1651 |
else: |
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
1652 |
raise TypeError, _("%s body don't have instances!")%self.content.getLocalTag() |
814 | 1653 |
setattr(cls, "getcontentInstances", getcontentInstances) |
1305
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
1654 |
|
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
1655 |
instance_by_id_xpath = PLCOpen_XPath("*[@localId=$localId]") |
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
1656 |
instance_by_name_xpath = PLCOpen_XPath("ppx:block[@instanceName=$name]") |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1657 |
def getcontentInstance(self, local_id): |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1658 |
if self.content.getLocalTag() in ["LD","FBD","SFC"]: |
1305
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
1659 |
instance = instance_by_id_xpath(self.content, localId=local_id) |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1660 |
if len(instance) > 0: |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1661 |
return instance[0] |
814 | 1662 |
return None |
1663 |
else: |
|
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
1664 |
raise TypeError, _("%s body don't have instances!")%self.content.getLocalTag() |
814 | 1665 |
setattr(cls, "getcontentInstance", getcontentInstance) |
1666 |
||
1331
38c5de794e62
Added support for speed-up loading of graphic POU tabs
Laurent Bessard
parents:
1330
diff
changeset
|
1667 |
def getcontentInstancesIds(self): |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1668 |
if self.content.getLocalTag() in ["LD","FBD","SFC"]: |
1331
38c5de794e62
Added support for speed-up loading of graphic POU tabs
Laurent Bessard
parents:
1330
diff
changeset
|
1669 |
return OrderedDict([(instance.getlocalId(), True) |
38c5de794e62
Added support for speed-up loading of graphic POU tabs
Laurent Bessard
parents:
1330
diff
changeset
|
1670 |
for instance in self.content]) |
814 | 1671 |
else: |
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
1672 |
raise TypeError, _("%s body don't have instances!")%self.content.getLocalTag() |
1331
38c5de794e62
Added support for speed-up loading of graphic POU tabs
Laurent Bessard
parents:
1330
diff
changeset
|
1673 |
setattr(cls, "getcontentInstancesIds", getcontentInstancesIds) |
814 | 1674 |
|
1675 |
def getcontentInstanceByName(self, name): |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1676 |
if self.content.getLocalTag() in ["LD","FBD","SFC"]: |
1305
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
1677 |
instance = instance_by_name_xpath(self.content) |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1678 |
if len(instance) > 0: |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1679 |
return instance[0] |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1680 |
return None |
814 | 1681 |
else: |
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
1682 |
raise TypeError, _("%s body don't have instances!")%self.content.getLocalTag() |
814 | 1683 |
setattr(cls, "getcontentInstanceByName", getcontentInstanceByName) |
1684 |
||
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1685 |
def removecontentInstance(self, local_id): |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1686 |
if self.content.getLocalTag() in ["LD","FBD","SFC"]: |
1318 | 1687 |
instance = instance_by_id_xpath(self.content, localId=local_id) |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1688 |
if len(instance) > 0: |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1689 |
self.content.remove(instance[0]) |
1232
b6894285d4cc
Added support for speed up loading graphic viewers
Laurent Bessard
parents:
1171
diff
changeset
|
1690 |
else: |
814 | 1691 |
raise ValueError, _("Instance with id %d doesn't exist!")%id |
1692 |
else: |
|
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
1693 |
raise TypeError, "%s body don't have instances!"%self.content.getLocalTag() |
814 | 1694 |
setattr(cls, "removecontentInstance", removecontentInstance) |
1695 |
||
1696 |
def settext(self, text): |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1697 |
if self.content.getLocalTag() in ["IL","ST"]: |
1291
42ea51d083ce
Second stage of xmlclass refactoring using lxml , project are loaded and displayed successfully
Laurent Bessard
parents:
1290
diff
changeset
|
1698 |
self.content.setanyText(text) |
814 | 1699 |
else: |
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
1700 |
raise TypeError, _("%s body don't have text!")%self.content.getLocalTag() |
814 | 1701 |
setattr(cls, "settext", settext) |
1702 |
||
1703 |
def gettext(self): |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1704 |
if self.content.getLocalTag() in ["IL","ST"]: |
1291
42ea51d083ce
Second stage of xmlclass refactoring using lxml , project are loaded and displayed successfully
Laurent Bessard
parents:
1290
diff
changeset
|
1705 |
return self.content.getanyText() |
814 | 1706 |
else: |
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
1707 |
raise TypeError, _("%s body don't have text!")%self.content.getLocalTag() |
814 | 1708 |
setattr(cls, "gettext", gettext) |
1709 |
||
1142
8ded55ada6d6
Fixed functions used by one or more POU not showing question dialog when trying to delete
Laurent Bessard
parents:
990
diff
changeset
|
1710 |
def hasblock(self, block_type): |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1711 |
if self.content.getLocalTag() in ["IL","ST"]: |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1712 |
return self.content.hasblock(block_type) |
1142
8ded55ada6d6
Fixed functions used by one or more POU not showing question dialog when trying to delete
Laurent Bessard
parents:
990
diff
changeset
|
1713 |
else: |
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
1714 |
raise TypeError, _("%s body don't have text!")%self.content.getLocalTag() |
1142
8ded55ada6d6
Fixed functions used by one or more POU not showing question dialog when trying to delete
Laurent Bessard
parents:
990
diff
changeset
|
1715 |
setattr(cls, "hasblock", hasblock) |
8ded55ada6d6
Fixed functions used by one or more POU not showing question dialog when trying to delete
Laurent Bessard
parents:
990
diff
changeset
|
1716 |
|
814 | 1717 |
def updateElementName(self, old_name, new_name): |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1718 |
if self.content.getLocalTag() in ["IL", "ST"]: |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1719 |
self.content.updateElementName(old_name, new_name) |
814 | 1720 |
else: |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1721 |
for element in self.content.getcontent(): |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1722 |
element.updateElementName(old_name, new_name) |
814 | 1723 |
setattr(cls, "updateElementName", updateElementName) |
1724 |
||
1725 |
def updateElementAddress(self, address_model, new_leading): |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1726 |
if self.content.getLocalTag() in ["IL", "ST"]: |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1727 |
self.content.updateElementAddress(address_model, new_leading) |
814 | 1728 |
else: |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1729 |
for element in self.content.getcontent(): |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1730 |
element.updateElementAddress(address_model, new_leading) |
814 | 1731 |
setattr(cls, "updateElementAddress", updateElementAddress) |
1732 |
||
1733 |
def Search(self, criteria, parent_infos=[]): |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1734 |
if self.content.getLocalTag() in ["IL", "ST"]: |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1735 |
search_result = self.content.Search(criteria, parent_infos + ["body", 0]) |
814 | 1736 |
else: |
1737 |
search_result = [] |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1738 |
for element in self.content.getcontent(): |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1739 |
search_result.extend(element.Search(criteria, parent_infos)) |
814 | 1740 |
return search_result |
1741 |
setattr(cls, "Search", Search) |
|
1742 |
||
1743 |
def getx(self): |
|
1744 |
return self.position.getx() |
|
1745 |
||
1746 |
def gety(self): |
|
1747 |
return self.position.gety() |
|
1748 |
||
1749 |
def setx(self, x): |
|
1750 |
self.position.setx(x) |
|
1751 |
||
1752 |
def sety(self, y): |
|
1753 |
self.position.sety(y) |
|
1754 |
||
1755 |
def _getBoundingBox(self): |
|
1756 |
return rect(self.getx(), self.gety(), self.getwidth(), self.getheight()) |
|
1757 |
||
1758 |
def _getConnectionsBoundingBox(connectionPointIn): |
|
1759 |
bbox = rect() |
|
1760 |
connections = connectionPointIn.getconnections() |
|
1761 |
if connections is not None: |
|
1762 |
for connection in connections: |
|
1763 |
for x, y in connection.getpoints(): |
|
1764 |
bbox.update(x, y) |
|
1765 |
return bbox |
|
1766 |
||
1767 |
def _getBoundingBoxSingle(self): |
|
1768 |
bbox = _getBoundingBox(self) |
|
1769 |
if self.connectionPointIn is not None: |
|
1770 |
bbox.union(_getConnectionsBoundingBox(self.connectionPointIn)) |
|
1771 |
return bbox |
|
1772 |
||
1773 |
def _getBoundingBoxMultiple(self): |
|
1774 |
bbox = _getBoundingBox(self) |
|
1775 |
for connectionPointIn in self.getconnectionPointIn(): |
|
1776 |
bbox.union(_getConnectionsBoundingBox(connectionPointIn)) |
|
1777 |
return bbox |
|
1778 |
||
1779 |
def _filterConnections(connectionPointIn, localId, connections): |
|
1780 |
in_connections = connectionPointIn.getconnections() |
|
1781 |
if in_connections is not None: |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1782 |
for connection in in_connections: |
814 | 1783 |
connected = connection.getrefLocalId() |
1784 |
if not connections.has_key((localId, connected)) and \ |
|
1785 |
not connections.has_key((connected, localId)): |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1786 |
connectionPointIn.remove(connection) |
814 | 1787 |
|
1788 |
def _filterConnectionsSingle(self, connections): |
|
1789 |
if self.connectionPointIn is not None: |
|
1790 |
_filterConnections(self.connectionPointIn, self.localId, connections) |
|
1791 |
||
1792 |
def _filterConnectionsMultiple(self, connections): |
|
1793 |
for connectionPointIn in self.getconnectionPointIn(): |
|
1794 |
_filterConnections(connectionPointIn, self.localId, connections) |
|
1795 |
||
1796 |
def _getconnectionsdefinition(instance, connections_end): |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1797 |
local_id = instance.getlocalId() |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1798 |
return dict([((local_id, end), True) for end in connections_end]) |
814 | 1799 |
|
1800 |
def _updateConnectionsId(connectionPointIn, translation): |
|
1801 |
connections_end = [] |
|
1802 |
connections = connectionPointIn.getconnections() |
|
1803 |
if connections is not None: |
|
1804 |
for connection in connections: |
|
1805 |
refLocalId = connection.getrefLocalId() |
|
1806 |
new_reflocalId = translation.get(refLocalId, refLocalId) |
|
1807 |
connection.setrefLocalId(new_reflocalId) |
|
1808 |
connections_end.append(new_reflocalId) |
|
1809 |
return connections_end |
|
1810 |
||
1811 |
def _updateConnectionsIdSingle(self, translation): |
|
1812 |
connections_end = [] |
|
1813 |
if self.connectionPointIn is not None: |
|
1814 |
connections_end = _updateConnectionsId(self.connectionPointIn, translation) |
|
1815 |
return _getconnectionsdefinition(self, connections_end) |
|
1816 |
||
1817 |
def _updateConnectionsIdMultiple(self, translation): |
|
1818 |
connections_end = [] |
|
1819 |
for connectionPointIn in self.getconnectionPointIn(): |
|
1820 |
connections_end.extend(_updateConnectionsId(connectionPointIn, translation)) |
|
1821 |
return _getconnectionsdefinition(self, connections_end) |
|
1822 |
||
1823 |
def _translate(self, dx, dy): |
|
1824 |
self.setx(self.getx() + dx) |
|
1825 |
self.sety(self.gety() + dy) |
|
1826 |
||
1827 |
def _translateConnections(connectionPointIn, dx, dy): |
|
1828 |
connections = connectionPointIn.getconnections() |
|
1829 |
if connections is not None: |
|
1830 |
for connection in connections: |
|
1831 |
for position in connection.getposition(): |
|
1832 |
position.setx(position.getx() + dx) |
|
1833 |
position.sety(position.gety() + dy) |
|
1834 |
||
1835 |
def _translateSingle(self, dx, dy): |
|
1836 |
_translate(self, dx, dy) |
|
1837 |
if self.connectionPointIn is not None: |
|
1838 |
_translateConnections(self.connectionPointIn, dx, dy) |
|
1839 |
||
1840 |
def _translateMultiple(self, dx, dy): |
|
1841 |
_translate(self, dx, dy) |
|
1842 |
for connectionPointIn in self.getconnectionPointIn(): |
|
1843 |
_translateConnections(connectionPointIn, dx, dy) |
|
1844 |
||
1845 |
def _updateElementName(self, old_name, new_name): |
|
1846 |
pass |
|
1847 |
||
1848 |
def _updateElementAddress(self, address_model, new_leading): |
|
1849 |
pass |
|
1850 |
||
1851 |
def _SearchInElement(self, criteria, parent_infos=[]): |
|
1852 |
return [] |
|
1853 |
||
1854 |
_connectionsFunctions = { |
|
1855 |
"bbox": {"none": _getBoundingBox, |
|
1856 |
"single": _getBoundingBoxSingle, |
|
1857 |
"multiple": _getBoundingBoxMultiple}, |
|
1858 |
"translate": {"none": _translate, |
|
1859 |
"single": _translateSingle, |
|
1860 |
"multiple": _translateMultiple}, |
|
1861 |
"filter": {"none": lambda self, connections: None, |
|
1862 |
"single": _filterConnectionsSingle, |
|
1863 |
"multiple": _filterConnectionsMultiple}, |
|
1864 |
"update": {"none": lambda self, translation: {}, |
|
1865 |
"single": _updateConnectionsIdSingle, |
|
1866 |
"multiple": _updateConnectionsIdMultiple}, |
|
1867 |
} |
|
1868 |
||
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1869 |
def _initElementClass(name, parent, connectionPointInType="none"): |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1870 |
cls = PLCOpenParser.GetElementClass(name, parent) |
814 | 1871 |
if cls: |
1872 |
setattr(cls, "getx", getx) |
|
1873 |
setattr(cls, "gety", gety) |
|
1874 |
setattr(cls, "setx", setx) |
|
1875 |
setattr(cls, "sety", sety) |
|
1876 |
setattr(cls, "updateElementName", _updateElementName) |
|
1877 |
setattr(cls, "updateElementAddress", _updateElementAddress) |
|
1878 |
setattr(cls, "getBoundingBox", _connectionsFunctions["bbox"][connectionPointInType]) |
|
1879 |
setattr(cls, "translate", _connectionsFunctions["translate"][connectionPointInType]) |
|
1880 |
setattr(cls, "filterConnections", _connectionsFunctions["filter"][connectionPointInType]) |
|
1881 |
setattr(cls, "updateConnectionsId", _connectionsFunctions["update"][connectionPointInType]) |
|
1882 |
setattr(cls, "Search", _SearchInElement) |
|
1883 |
return cls |
|
1884 |
||
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1885 |
cls = _initElementClass("comment", "commonObjects") |
814 | 1886 |
if cls: |
1887 |
def setcontentText(self, text): |
|
1291
42ea51d083ce
Second stage of xmlclass refactoring using lxml , project are loaded and displayed successfully
Laurent Bessard
parents:
1290
diff
changeset
|
1888 |
self.content.setanyText(text) |
814 | 1889 |
setattr(cls, "setcontentText", setcontentText) |
1890 |
||
1891 |
def getcontentText(self): |
|
1291
42ea51d083ce
Second stage of xmlclass refactoring using lxml , project are loaded and displayed successfully
Laurent Bessard
parents:
1290
diff
changeset
|
1892 |
return self.content.getanyText() |
814 | 1893 |
setattr(cls, "getcontentText", getcontentText) |
1894 |
||
1895 |
def updateElementName(self, old_name, new_name): |
|
1896 |
self.content.updateElementName(old_name, new_name) |
|
1897 |
setattr(cls, "updateElementName", updateElementName) |
|
1898 |
||
1899 |
def updateElementAddress(self, address_model, new_leading): |
|
1900 |
self.content.updateElementAddress(address_model, new_leading) |
|
1901 |
setattr(cls, "updateElementAddress", updateElementAddress) |
|
1902 |
||
1903 |
def Search(self, criteria, parent_infos=[]): |
|
1904 |
return self.content.Search(criteria, parent_infos + ["comment", self.getlocalId(), "content"]) |
|
1905 |
setattr(cls, "Search", Search) |
|
1906 |
||
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1907 |
cls = _initElementClass("block", "fbdObjects") |
814 | 1908 |
if cls: |
1909 |
def getBoundingBox(self): |
|
1910 |
bbox = _getBoundingBox(self) |
|
1911 |
for input in self.inputVariables.getvariable(): |
|
1912 |
bbox.union(_getConnectionsBoundingBox(input.connectionPointIn)) |
|
1913 |
return bbox |
|
1914 |
setattr(cls, "getBoundingBox", getBoundingBox) |
|
1915 |
||
1916 |
def updateElementName(self, old_name, new_name): |
|
1611
5e64d552b25a
make renames caseinsensitive
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1581
diff
changeset
|
1917 |
if TextMatched(self.typeName, old_name): |
814 | 1918 |
self.typeName = new_name |
1919 |
setattr(cls, "updateElementName", updateElementName) |
|
1920 |
||
1921 |
def filterConnections(self, connections): |
|
1922 |
for input in self.inputVariables.getvariable(): |
|
1923 |
_filterConnections(input.connectionPointIn, self.localId, connections) |
|
1924 |
setattr(cls, "filterConnections", filterConnections) |
|
1925 |
||
1926 |
def updateConnectionsId(self, translation): |
|
1927 |
connections_end = [] |
|
1928 |
for input in self.inputVariables.getvariable(): |
|
1929 |
connections_end.extend(_updateConnectionsId(input.connectionPointIn, translation)) |
|
1930 |
return _getconnectionsdefinition(self, connections_end) |
|
1931 |
setattr(cls, "updateConnectionsId", updateConnectionsId) |
|
1932 |
||
1933 |
def translate(self, dx, dy): |
|
1934 |
_translate(self, dx, dy) |
|
1935 |
for input in self.inputVariables.getvariable(): |
|
1936 |
_translateConnections(input.connectionPointIn, dx, dy) |
|
1937 |
setattr(cls, "translate", translate) |
|
1938 |
||
1939 |
def Search(self, criteria, parent_infos=[]): |
|
1940 |
parent_infos = parent_infos + ["block", self.getlocalId()] |
|
1941 |
search_result = _Search([("name", self.getinstanceName()), |
|
1942 |
("type", self.gettypeName())], |
|
1943 |
criteria, parent_infos) |
|
1944 |
for i, variable in enumerate(self.inputVariables.getvariable()): |
|
1945 |
for result in TestTextElement(variable.getformalParameter(), criteria): |
|
1946 |
search_result.append((tuple(parent_infos + ["input", i]),) + result) |
|
1947 |
for i, variable in enumerate(self.outputVariables.getvariable()): |
|
1948 |
for result in TestTextElement(variable.getformalParameter(), criteria): |
|
1949 |
search_result.append((tuple(parent_infos + ["output", i]),) + result) |
|
1950 |
return search_result |
|
1951 |
setattr(cls, "Search", Search) |
|
1952 |
||
1355
9183fb765f16
Fixed bug when modifying power rail in LD Viewer
Laurent Bessard
parents:
1346
diff
changeset
|
1953 |
_initElementClass("leftPowerRail", "ldObjects") |
9183fb765f16
Fixed bug when modifying power rail in LD Viewer
Laurent Bessard
parents:
1346
diff
changeset
|
1954 |
_initElementClass("rightPowerRail", "ldObjects", "multiple") |
9183fb765f16
Fixed bug when modifying power rail in LD Viewer
Laurent Bessard
parents:
1346
diff
changeset
|
1955 |
|
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
1956 |
def _UpdateLDElementName(self, old_name, new_name): |
1611
5e64d552b25a
make renames caseinsensitive
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1581
diff
changeset
|
1957 |
if TextMatched(self.variable, old_name): |
1322
0a9227f743b3
Fixed xmlclass for working with included files, adding support for SimpleType elements and solving ambiguity in extension class when different elements share the same name and parent name
Laurent Bessard
parents:
1318
diff
changeset
|
1958 |
self.variable = new_name |
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
1959 |
|
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
1960 |
def _UpdateLDElementAddress(self, address_model, new_leading): |
1322
0a9227f743b3
Fixed xmlclass for working with included files, adding support for SimpleType elements and solving ambiguity in extension class when different elements share the same name and parent name
Laurent Bessard
parents:
1318
diff
changeset
|
1961 |
self.variable = update_address(self.variable, address_model, new_leading) |
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
1962 |
|
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
1963 |
def _getSearchInLDElement(ld_element_type): |
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
1964 |
def SearchInLDElement(self, criteria, parent_infos=[]): |
1322
0a9227f743b3
Fixed xmlclass for working with included files, adding support for SimpleType elements and solving ambiguity in extension class when different elements share the same name and parent name
Laurent Bessard
parents:
1318
diff
changeset
|
1965 |
return _Search([("reference", self.variable)], criteria, parent_infos + [ld_element_type, self.getlocalId()]) |
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
1966 |
return SearchInLDElement |
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
1967 |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1968 |
cls = _initElementClass("contact", "ldObjects", "single") |
814 | 1969 |
if cls: |
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
1970 |
setattr(cls, "updateElementName", _UpdateLDElementName) |
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
1971 |
setattr(cls, "updateElementAddress", _UpdateLDElementAddress) |
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
1972 |
setattr(cls, "Search", _getSearchInLDElement("contact")) |
814 | 1973 |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1974 |
cls = _initElementClass("coil", "ldObjects", "single") |
814 | 1975 |
if cls: |
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
1976 |
setattr(cls, "updateElementName", _UpdateLDElementName) |
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
1977 |
setattr(cls, "updateElementAddress", _UpdateLDElementAddress) |
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
1978 |
setattr(cls, "Search", _getSearchInLDElement("coil")) |
814 | 1979 |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1980 |
cls = _initElementClass("step", "sfcObjects", "single") |
814 | 1981 |
if cls: |
1982 |
def Search(self, criteria, parent_infos=[]): |
|
1983 |
return _Search([("name", self.getname())], criteria, parent_infos + ["step", self.getlocalId()]) |
|
1984 |
setattr(cls, "Search", Search) |
|
1985 |
||
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1986 |
cls = _initElementClass("transition", "sfcObjects") |
814 | 1987 |
if cls: |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1988 |
def setconditionContent(self, condition_type, value): |
1298
f034fb2b1aab
Fixed SFC block edition and SFC to SFC_textual code generating
Laurent Bessard
parents:
1294
diff
changeset
|
1989 |
if self.condition is None: |
814 | 1990 |
self.addcondition() |
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
1991 |
if condition_type == "connection": |
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
1992 |
condition = PLCOpenParser.CreateElement("connectionPointIn", "condition") |
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
1993 |
else: |
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
1994 |
condition = PLCOpenParser.CreateElement(condition_type, "condition") |
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
1995 |
self.condition.setcontent(condition) |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1996 |
if condition_type == "reference": |
814 | 1997 |
condition.setname(value) |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
1998 |
elif condition_type == "inline": |
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
1999 |
condition.setcontent(PLCOpenParser.CreateElement("ST", "inline")) |
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
2000 |
condition.settext(value) |
814 | 2001 |
setattr(cls, "setconditionContent", setconditionContent) |
2002 |
||
2003 |
def getconditionContent(self): |
|
1298
f034fb2b1aab
Fixed SFC block edition and SFC to SFC_textual code generating
Laurent Bessard
parents:
1294
diff
changeset
|
2004 |
if self.condition is not None: |
814 | 2005 |
content = self.condition.getcontent() |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
2006 |
values = {"type" : content.getLocalTag()} |
814 | 2007 |
if values["type"] == "reference": |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
2008 |
values["value"] = content.getname() |
814 | 2009 |
elif values["type"] == "inline": |
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
2010 |
values["value"] = content.gettext() |
814 | 2011 |
elif values["type"] == "connectionPointIn": |
2012 |
values["type"] = "connection" |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
2013 |
values["value"] = content |
814 | 2014 |
return values |
2015 |
return "" |
|
2016 |
setattr(cls, "getconditionContent", getconditionContent) |
|
2017 |
||
891
39f355a535d8
Fix bug when copying transition and the connected FBD or LD diagram
Laurent Bessard
parents:
854
diff
changeset
|
2018 |
def getconditionConnection(self): |
1298
f034fb2b1aab
Fixed SFC block edition and SFC to SFC_textual code generating
Laurent Bessard
parents:
1294
diff
changeset
|
2019 |
if self.condition is not None: |
891
39f355a535d8
Fix bug when copying transition and the connected FBD or LD diagram
Laurent Bessard
parents:
854
diff
changeset
|
2020 |
content = self.condition.getcontent() |
1299
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset
|
2021 |
if content.getLocalTag() == "connectionPointIn": |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
2022 |
return content |
891
39f355a535d8
Fix bug when copying transition and the connected FBD or LD diagram
Laurent Bessard
parents:
854
diff
changeset
|
2023 |
return None |
39f355a535d8
Fix bug when copying transition and the connected FBD or LD diagram
Laurent Bessard
parents:
854
diff
changeset
|
2024 |
setattr(cls, "getconditionConnection", getconditionConnection) |
39f355a535d8
Fix bug when copying transition and the connected FBD or LD diagram
Laurent Bessard
parents:
854
diff
changeset
|
2025 |
|
39f355a535d8
Fix bug when copying transition and the connected FBD or LD diagram
Laurent Bessard
parents:
854
diff
changeset
|
2026 |
def getBoundingBox(self): |
39f355a535d8
Fix bug when copying transition and the connected FBD or LD diagram
Laurent Bessard
parents:
854
diff
changeset
|
2027 |
bbox = _getBoundingBoxSingle(self) |
39f355a535d8
Fix bug when copying transition and the connected FBD or LD diagram
Laurent Bessard
parents:
854
diff
changeset
|
2028 |
condition_connection = self.getconditionConnection() |
1302
7856cd7767d6
Removed dictionaries storing datatypes and pous defined in project and pou and datatype using tree from model
Laurent Bessard
parents:
1301
diff
changeset
|
2029 |
if condition_connection is not None: |
891
39f355a535d8
Fix bug when copying transition and the connected FBD or LD diagram
Laurent Bessard
parents:
854
diff
changeset
|
2030 |
bbox.union(_getConnectionsBoundingBox(condition_connection)) |
39f355a535d8
Fix bug when copying transition and the connected FBD or LD diagram
Laurent Bessard
parents:
854
diff
changeset
|
2031 |
return bbox |
39f355a535d8
Fix bug when copying transition and the connected FBD or LD diagram
Laurent Bessard
parents:
854
diff
changeset
|
2032 |
setattr(cls, "getBoundingBox", getBoundingBox) |
39f355a535d8
Fix bug when copying transition and the connected FBD or LD diagram
Laurent Bessard
parents:
854
diff
changeset
|
2033 |
|
39f355a535d8
Fix bug when copying transition and the connected FBD or LD diagram
Laurent Bessard
parents:
854
diff
changeset
|
2034 |
def translate(self, dx, dy): |
39f355a535d8
Fix bug when copying transition and the connected FBD or LD diagram
Laurent Bessard
parents:
854
diff
changeset
|
2035 |
_translateSingle(self, dx, dy) |
39f355a535d8
Fix bug when copying transition and the connected FBD or LD diagram
Laurent Bessard
parents:
854
diff
changeset
|
2036 |
condition_connection = self.getconditionConnection() |
1299
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset
|
2037 |
if condition_connection is not None: |
891
39f355a535d8
Fix bug when copying transition and the connected FBD or LD diagram
Laurent Bessard
parents:
854
diff
changeset
|
2038 |
_translateConnections(condition_connection, dx, dy) |
39f355a535d8
Fix bug when copying transition and the connected FBD or LD diagram
Laurent Bessard
parents:
854
diff
changeset
|
2039 |
setattr(cls, "translate", translate) |
39f355a535d8
Fix bug when copying transition and the connected FBD or LD diagram
Laurent Bessard
parents:
854
diff
changeset
|
2040 |
|
39f355a535d8
Fix bug when copying transition and the connected FBD or LD diagram
Laurent Bessard
parents:
854
diff
changeset
|
2041 |
def filterConnections(self, connections): |
39f355a535d8
Fix bug when copying transition and the connected FBD or LD diagram
Laurent Bessard
parents:
854
diff
changeset
|
2042 |
_filterConnectionsSingle(self, connections) |
39f355a535d8
Fix bug when copying transition and the connected FBD or LD diagram
Laurent Bessard
parents:
854
diff
changeset
|
2043 |
condition_connection = self.getconditionConnection() |
1301
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
2044 |
if condition_connection is not None: |
891
39f355a535d8
Fix bug when copying transition and the connected FBD or LD diagram
Laurent Bessard
parents:
854
diff
changeset
|
2045 |
_filterConnections(condition_connection, self.localId, connections) |
39f355a535d8
Fix bug when copying transition and the connected FBD or LD diagram
Laurent Bessard
parents:
854
diff
changeset
|
2046 |
setattr(cls, "filterConnections", filterConnections) |
39f355a535d8
Fix bug when copying transition and the connected FBD or LD diagram
Laurent Bessard
parents:
854
diff
changeset
|
2047 |
|
39f355a535d8
Fix bug when copying transition and the connected FBD or LD diagram
Laurent Bessard
parents:
854
diff
changeset
|
2048 |
def updateConnectionsId(self, translation): |
39f355a535d8
Fix bug when copying transition and the connected FBD or LD diagram
Laurent Bessard
parents:
854
diff
changeset
|
2049 |
connections_end = [] |
39f355a535d8
Fix bug when copying transition and the connected FBD or LD diagram
Laurent Bessard
parents:
854
diff
changeset
|
2050 |
if self.connectionPointIn is not None: |
39f355a535d8
Fix bug when copying transition and the connected FBD or LD diagram
Laurent Bessard
parents:
854
diff
changeset
|
2051 |
connections_end = _updateConnectionsId(self.connectionPointIn, translation) |
39f355a535d8
Fix bug when copying transition and the connected FBD or LD diagram
Laurent Bessard
parents:
854
diff
changeset
|
2052 |
condition_connection = self.getconditionConnection() |
1301
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
2053 |
if condition_connection is not None: |
891
39f355a535d8
Fix bug when copying transition and the connected FBD or LD diagram
Laurent Bessard
parents:
854
diff
changeset
|
2054 |
connections_end.extend(_updateConnectionsId(condition_connection, translation)) |
39f355a535d8
Fix bug when copying transition and the connected FBD or LD diagram
Laurent Bessard
parents:
854
diff
changeset
|
2055 |
return _getconnectionsdefinition(self, connections_end) |
39f355a535d8
Fix bug when copying transition and the connected FBD or LD diagram
Laurent Bessard
parents:
854
diff
changeset
|
2056 |
setattr(cls, "updateConnectionsId", updateConnectionsId) |
39f355a535d8
Fix bug when copying transition and the connected FBD or LD diagram
Laurent Bessard
parents:
854
diff
changeset
|
2057 |
|
814 | 2058 |
def updateElementName(self, old_name, new_name): |
1301
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
2059 |
if self.condition is not None: |
814 | 2060 |
content = self.condition.getcontent() |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
2061 |
content_name = content.getLocalTag() |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
2062 |
if content_name == "reference": |
1611
5e64d552b25a
make renames caseinsensitive
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1581
diff
changeset
|
2063 |
if TextMatched(content.getname(), old_name): |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
2064 |
content.setname(new_name) |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
2065 |
elif content_name == "inline": |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
2066 |
content.updateElementName(old_name, new_name) |
814 | 2067 |
setattr(cls, "updateElementName", updateElementName) |
2068 |
||
2069 |
def updateElementAddress(self, address_model, new_leading): |
|
1301
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
2070 |
if self.condition is not None: |
814 | 2071 |
content = self.condition.getcontent() |
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
2072 |
content_name = content.getLocalTag() |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
2073 |
if content_name == "reference": |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
2074 |
content.setname(update_address(content.getname(), address_model, new_leading)) |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
2075 |
elif content_name == "inline": |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
2076 |
content.updateElementAddress(address_model, new_leading) |
814 | 2077 |
setattr(cls, "updateElementAddress", updateElementAddress) |
2078 |
||
2079 |
def getconnections(self): |
|
891
39f355a535d8
Fix bug when copying transition and the connected FBD or LD diagram
Laurent Bessard
parents:
854
diff
changeset
|
2080 |
condition_connection = self.getconditionConnection() |
1301
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset
|
2081 |
if condition_connection is not None: |
891
39f355a535d8
Fix bug when copying transition and the connected FBD or LD diagram
Laurent Bessard
parents:
854
diff
changeset
|
2082 |
return condition_connection.getconnections() |
39f355a535d8
Fix bug when copying transition and the connected FBD or LD diagram
Laurent Bessard
parents:
854
diff
changeset
|
2083 |
return None |
814 | 2084 |
setattr(cls, "getconnections", getconnections) |
2085 |
||
2086 |
def Search(self, criteria, parent_infos=[]): |
|
2087 |
parent_infos = parent_infos + ["transition", self.getlocalId()] |
|
2088 |
search_result = [] |
|
2089 |
content = self.condition.getcontent() |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
2090 |
content_name = content.getLocalTag() |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
2091 |
if content_name == "reference": |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
2092 |
search_result.extend(_Search([("reference", content.getname())], criteria, parent_infos)) |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
2093 |
elif content_name == "inline": |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
2094 |
search_result.extend(content.Search(criteria, parent_infos + ["inline"])) |
814 | 2095 |
return search_result |
2096 |
setattr(cls, "Search", Search) |
|
1346 | 2097 |
|
2098 |
_initElementClass("selectionDivergence", "sfcObjects", "single") |
|
2099 |
_initElementClass("selectionConvergence", "sfcObjects", "multiple") |
|
2100 |
_initElementClass("simultaneousDivergence", "sfcObjects", "single") |
|
2101 |
_initElementClass("simultaneousConvergence", "sfcObjects", "multiple") |
|
814 | 2102 |
|
1291
42ea51d083ce
Second stage of xmlclass refactoring using lxml , project are loaded and displayed successfully
Laurent Bessard
parents:
1290
diff
changeset
|
2103 |
cls = _initElementClass("jumpStep", "sfcObjects", "single") |
814 | 2104 |
if cls: |
2105 |
def Search(self, criteria, parent_infos): |
|
2106 |
return _Search([("target", self.gettargetName())], criteria, parent_infos + ["jump", self.getlocalId()]) |
|
2107 |
setattr(cls, "Search", Search) |
|
2108 |
||
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
2109 |
cls = PLCOpenParser.GetElementClass("action", "actionBlock") |
814 | 2110 |
if cls: |
2111 |
def setreferenceName(self, name): |
|
1298
f034fb2b1aab
Fixed SFC block edition and SFC to SFC_textual code generating
Laurent Bessard
parents:
1294
diff
changeset
|
2112 |
if self.reference is not None: |
814 | 2113 |
self.reference.setname(name) |
2114 |
setattr(cls, "setreferenceName", setreferenceName) |
|
2115 |
||
2116 |
def getreferenceName(self): |
|
1298
f034fb2b1aab
Fixed SFC block edition and SFC to SFC_textual code generating
Laurent Bessard
parents:
1294
diff
changeset
|
2117 |
if self.reference is not None: |
814 | 2118 |
return self.reference.getname() |
2119 |
return None |
|
2120 |
setattr(cls, "getreferenceName", getreferenceName) |
|
2121 |
||
2122 |
def setinlineContent(self, content): |
|
1298
f034fb2b1aab
Fixed SFC block edition and SFC to SFC_textual code generating
Laurent Bessard
parents:
1294
diff
changeset
|
2123 |
if self.inline is not None: |
f034fb2b1aab
Fixed SFC block edition and SFC to SFC_textual code generating
Laurent Bessard
parents:
1294
diff
changeset
|
2124 |
self.inline.setcontent(PLCOpenParser.CreateElement("ST", "inline")) |
f034fb2b1aab
Fixed SFC block edition and SFC to SFC_textual code generating
Laurent Bessard
parents:
1294
diff
changeset
|
2125 |
self.inline.settext(content) |
814 | 2126 |
setattr(cls, "setinlineContent", setinlineContent) |
2127 |
||
2128 |
def getinlineContent(self): |
|
1298
f034fb2b1aab
Fixed SFC block edition and SFC to SFC_textual code generating
Laurent Bessard
parents:
1294
diff
changeset
|
2129 |
if self.inline is not None: |
f034fb2b1aab
Fixed SFC block edition and SFC to SFC_textual code generating
Laurent Bessard
parents:
1294
diff
changeset
|
2130 |
return self.inline.gettext() |
814 | 2131 |
return None |
2132 |
setattr(cls, "getinlineContent", getinlineContent) |
|
2133 |
||
2134 |
def updateElementName(self, old_name, new_name): |
|
1611
5e64d552b25a
make renames caseinsensitive
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1581
diff
changeset
|
2135 |
if self.reference is not None and TextMatched(self.reference.getname(), old_name): |
814 | 2136 |
self.reference.setname(new_name) |
1298
f034fb2b1aab
Fixed SFC block edition and SFC to SFC_textual code generating
Laurent Bessard
parents:
1294
diff
changeset
|
2137 |
if self.inline is not None: |
814 | 2138 |
self.inline.updateElementName(old_name, new_name) |
2139 |
setattr(cls, "updateElementName", updateElementName) |
|
2140 |
||
2141 |
def updateElementAddress(self, address_model, new_leading): |
|
1298
f034fb2b1aab
Fixed SFC block edition and SFC to SFC_textual code generating
Laurent Bessard
parents:
1294
diff
changeset
|
2142 |
if self.reference is not None: |
814 | 2143 |
self.reference.setname(update_address(self.reference.getname(), address_model, new_leading)) |
1298
f034fb2b1aab
Fixed SFC block edition and SFC to SFC_textual code generating
Laurent Bessard
parents:
1294
diff
changeset
|
2144 |
if self.inline is not None: |
814 | 2145 |
self.inline.updateElementAddress(address_model, new_leading) |
2146 |
setattr(cls, "updateElementAddress", updateElementAddress) |
|
2147 |
||
2148 |
def Search(self, criteria, parent_infos=[]): |
|
2149 |
qualifier = self.getqualifier() |
|
2150 |
if qualifier is None: |
|
2151 |
qualifier = "N" |
|
2152 |
return _Search([("inline", self.getinlineContent()), |
|
2153 |
("reference", self.getreferenceName()), |
|
2154 |
("qualifier", qualifier), |
|
2155 |
("duration", self.getduration()), |
|
2156 |
("indicator", self.getindicator())], |
|
2157 |
criteria, parent_infos) |
|
2158 |
setattr(cls, "Search", Search) |
|
2159 |
||
1291
42ea51d083ce
Second stage of xmlclass refactoring using lxml , project are loaded and displayed successfully
Laurent Bessard
parents:
1290
diff
changeset
|
2160 |
cls = _initElementClass("actionBlock", "commonObjects", "single") |
814 | 2161 |
if cls: |
2162 |
def setactions(self, actions): |
|
2163 |
self.action = [] |
|
2164 |
for params in actions: |
|
1298
f034fb2b1aab
Fixed SFC block edition and SFC to SFC_textual code generating
Laurent Bessard
parents:
1294
diff
changeset
|
2165 |
action = PLCOpenParser.CreateElement("action", "actionBlock") |
f034fb2b1aab
Fixed SFC block edition and SFC to SFC_textual code generating
Laurent Bessard
parents:
1294
diff
changeset
|
2166 |
self.appendaction(action) |
1339 | 2167 |
action.setqualifier(params.qualifier) |
2168 |
if params.type == "reference": |
|
814 | 2169 |
action.addreference() |
1339 | 2170 |
action.setreferenceName(params.value) |
814 | 2171 |
else: |
2172 |
action.addinline() |
|
1339 | 2173 |
action.setinlineContent(params.value) |
2174 |
if params.duration != "": |
|
2175 |
action.setduration(params.duration) |
|
2176 |
if params.indicator != "": |
|
2177 |
action.setindicator(params.indicator) |
|
814 | 2178 |
setattr(cls, "setactions", setactions) |
2179 |
||
2180 |
def getactions(self): |
|
2181 |
actions = [] |
|
2182 |
for action in self.action: |
|
2183 |
params = {} |
|
2184 |
params["qualifier"] = action.getqualifier() |
|
2185 |
if params["qualifier"] is None: |
|
2186 |
params["qualifier"] = "N" |
|
1298
f034fb2b1aab
Fixed SFC block edition and SFC to SFC_textual code generating
Laurent Bessard
parents:
1294
diff
changeset
|
2187 |
if action.getreference() is not None: |
814 | 2188 |
params["type"] = "reference" |
2189 |
params["value"] = action.getreferenceName() |
|
1298
f034fb2b1aab
Fixed SFC block edition and SFC to SFC_textual code generating
Laurent Bessard
parents:
1294
diff
changeset
|
2190 |
elif action.getinline() is not None: |
814 | 2191 |
params["type"] = "inline" |
2192 |
params["value"] = action.getinlineContent() |
|
2193 |
duration = action.getduration() |
|
2194 |
if duration: |
|
2195 |
params["duration"] = duration |
|
2196 |
indicator = action.getindicator() |
|
1298
f034fb2b1aab
Fixed SFC block edition and SFC to SFC_textual code generating
Laurent Bessard
parents:
1294
diff
changeset
|
2197 |
if indicator is not None: |
814 | 2198 |
params["indicator"] = indicator |
2199 |
actions.append(params) |
|
2200 |
return actions |
|
2201 |
setattr(cls, "getactions", getactions) |
|
2202 |
||
2203 |
def updateElementName(self, old_name, new_name): |
|
2204 |
for action in self.action: |
|
2205 |
action.updateElementName(old_name, new_name) |
|
2206 |
setattr(cls, "updateElementName", updateElementName) |
|
2207 |
||
2208 |
def updateElementAddress(self, address_model, new_leading): |
|
2209 |
for action in self.action: |
|
2210 |
action.updateElementAddress(address_model, new_leading) |
|
2211 |
setattr(cls, "updateElementAddress", updateElementAddress) |
|
2212 |
||
2213 |
def Search(self, criteria, parent_infos=[]): |
|
2214 |
parent_infos = parent_infos + ["action_block", self.getlocalId()] |
|
2215 |
search_result = [] |
|
2216 |
for idx, action in enumerate(self.action): |
|
2217 |
search_result.extend(action.Search(criteria, parent_infos + ["action", idx])) |
|
2218 |
return search_result |
|
2219 |
setattr(cls, "Search", Search) |
|
2220 |
||
2221 |
def _SearchInIOVariable(self, criteria, parent_infos=[]): |
|
1322
0a9227f743b3
Fixed xmlclass for working with included files, adding support for SimpleType elements and solving ambiguity in extension class when different elements share the same name and parent name
Laurent Bessard
parents:
1318
diff
changeset
|
2222 |
return _Search([("expression", self.expression)], criteria, parent_infos + ["io_variable", self.getlocalId()]) |
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
2223 |
|
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
2224 |
def _UpdateIOElementName(self, old_name, new_name): |
1611
5e64d552b25a
make renames caseinsensitive
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1581
diff
changeset
|
2225 |
if TextMatched(self.expression, old_name): |
1322
0a9227f743b3
Fixed xmlclass for working with included files, adding support for SimpleType elements and solving ambiguity in extension class when different elements share the same name and parent name
Laurent Bessard
parents:
1318
diff
changeset
|
2226 |
self.expression = new_name |
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
2227 |
|
1400 | 2228 |
def _UpdateIOElementAddress(self, address_model, new_leading): |
1322
0a9227f743b3
Fixed xmlclass for working with included files, adding support for SimpleType elements and solving ambiguity in extension class when different elements share the same name and parent name
Laurent Bessard
parents:
1318
diff
changeset
|
2229 |
self.expression = update_address(self.expression, address_model, new_leading) |
814 | 2230 |
|
1291
42ea51d083ce
Second stage of xmlclass refactoring using lxml , project are loaded and displayed successfully
Laurent Bessard
parents:
1290
diff
changeset
|
2231 |
cls = _initElementClass("inVariable", "fbdObjects") |
814 | 2232 |
if cls: |
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
2233 |
setattr(cls, "updateElementName", _UpdateIOElementName) |
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
2234 |
setattr(cls, "updateElementAddress", _UpdateIOElementAddress) |
814 | 2235 |
setattr(cls, "Search", _SearchInIOVariable) |
2236 |
||
1291
42ea51d083ce
Second stage of xmlclass refactoring using lxml , project are loaded and displayed successfully
Laurent Bessard
parents:
1290
diff
changeset
|
2237 |
cls = _initElementClass("outVariable", "fbdObjects", "single") |
814 | 2238 |
if cls: |
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
2239 |
setattr(cls, "updateElementName", _UpdateIOElementName) |
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
2240 |
setattr(cls, "updateElementAddress", _UpdateIOElementAddress) |
814 | 2241 |
setattr(cls, "Search", _SearchInIOVariable) |
2242 |
||
1291
42ea51d083ce
Second stage of xmlclass refactoring using lxml , project are loaded and displayed successfully
Laurent Bessard
parents:
1290
diff
changeset
|
2243 |
cls = _initElementClass("inOutVariable", "fbdObjects", "single") |
814 | 2244 |
if cls: |
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
2245 |
setattr(cls, "updateElementName", _UpdateIOElementName) |
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
2246 |
setattr(cls, "updateElementAddress", _UpdateIOElementAddress) |
814 | 2247 |
setattr(cls, "Search", _SearchInIOVariable) |
2248 |
||
2249 |
||
2250 |
def _SearchInConnector(self, criteria, parent_infos=[]): |
|
2251 |
return _Search([("name", self.getname())], criteria, parent_infos + ["connector", self.getlocalId()]) |
|
2252 |
||
1291
42ea51d083ce
Second stage of xmlclass refactoring using lxml , project are loaded and displayed successfully
Laurent Bessard
parents:
1290
diff
changeset
|
2253 |
cls = _initElementClass("continuation", "commonObjects") |
814 | 2254 |
if cls: |
2255 |
setattr(cls, "Search", _SearchInConnector) |
|
2256 |
||
2257 |
def updateElementName(self, old_name, new_name): |
|
1611
5e64d552b25a
make renames caseinsensitive
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1581
diff
changeset
|
2258 |
if TextMatched(self.name, old_name): |
814 | 2259 |
self.name = new_name |
2260 |
setattr(cls, "updateElementName", updateElementName) |
|
2261 |
||
1291
42ea51d083ce
Second stage of xmlclass refactoring using lxml , project are loaded and displayed successfully
Laurent Bessard
parents:
1290
diff
changeset
|
2262 |
cls = _initElementClass("connector", "commonObjects", "single") |
814 | 2263 |
if cls: |
2264 |
setattr(cls, "Search", _SearchInConnector) |
|
2265 |
||
2266 |
def updateElementName(self, old_name, new_name): |
|
1611
5e64d552b25a
make renames caseinsensitive
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1581
diff
changeset
|
2267 |
if TextMatched(self.name, old_name): |
814 | 2268 |
self.name = new_name |
2269 |
setattr(cls, "updateElementName", updateElementName) |
|
2270 |
||
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
2271 |
cls = PLCOpenParser.GetElementClass("connection") |
814 | 2272 |
if cls: |
2273 |
def setpoints(self, points): |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
2274 |
positions = [] |
814 | 2275 |
for point in points: |
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
2276 |
position = PLCOpenParser.CreateElement("position", "connection") |
814 | 2277 |
position.setx(point.x) |
2278 |
position.sety(point.y) |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
2279 |
positions.append(position) |
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
2280 |
self.position = positions |
814 | 2281 |
setattr(cls, "setpoints", setpoints) |
2282 |
||
2283 |
def getpoints(self): |
|
2284 |
points = [] |
|
2285 |
for position in self.position: |
|
2286 |
points.append((position.getx(),position.gety())) |
|
2287 |
return points |
|
2288 |
setattr(cls, "getpoints", getpoints) |
|
2289 |
||
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
2290 |
cls = PLCOpenParser.GetElementClass("connectionPointIn") |
814 | 2291 |
if cls: |
2292 |
def setrelPositionXY(self, x, y): |
|
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
2293 |
self.relPosition = PLCOpenParser.CreateElement("relPosition", "connectionPointIn") |
814 | 2294 |
self.relPosition.setx(x) |
2295 |
self.relPosition.sety(y) |
|
2296 |
setattr(cls, "setrelPositionXY", setrelPositionXY) |
|
2297 |
||
2298 |
def getrelPositionXY(self): |
|
1291
42ea51d083ce
Second stage of xmlclass refactoring using lxml , project are loaded and displayed successfully
Laurent Bessard
parents:
1290
diff
changeset
|
2299 |
if self.relPosition is not None: |
814 | 2300 |
return self.relPosition.getx(), self.relPosition.gety() |
1291
42ea51d083ce
Second stage of xmlclass refactoring using lxml , project are loaded and displayed successfully
Laurent Bessard
parents:
1290
diff
changeset
|
2301 |
return self.relPosition |
814 | 2302 |
setattr(cls, "getrelPositionXY", getrelPositionXY) |
2303 |
||
2304 |
def addconnection(self): |
|
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
2305 |
self.append(PLCOpenParser.CreateElement("connection", "connectionPointIn")) |
814 | 2306 |
setattr(cls, "addconnection", addconnection) |
2307 |
||
2308 |
def removeconnection(self, idx): |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
2309 |
if len(self.content) > idx: |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
2310 |
self.remove(self.content[idx]) |
814 | 2311 |
setattr(cls, "removeconnection", removeconnection) |
2312 |
||
2313 |
def removeconnections(self): |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
2314 |
self.content = None |
814 | 2315 |
setattr(cls, "removeconnections", removeconnections) |
2316 |
||
1305
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
2317 |
connection_xpath = PLCOpen_XPath("ppx:connection") |
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
2318 |
connection_by_position_xpath = PLCOpen_XPath("ppx:connection[position()=$pos]") |
814 | 2319 |
def getconnections(self): |
1305
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
2320 |
return connection_xpath(self) |
814 | 2321 |
setattr(cls, "getconnections", getconnections) |
2322 |
||
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
2323 |
def getconnection(self, idx): |
1305
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset
|
2324 |
connection = connection_by_position_xpath(self, pos=idx+1) |
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
2325 |
if len(connection) > 0: |
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
2326 |
return connection[0] |
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
2327 |
return None |
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
2328 |
setattr(cls, "getconnection", getconnection) |
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
2329 |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
2330 |
def setconnectionId(self, idx, local_id): |
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
2331 |
connection = self.getconnection(idx) |
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
2332 |
if connection is not None: |
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
2333 |
connection.setrefLocalId(local_id) |
814 | 2334 |
setattr(cls, "setconnectionId", setconnectionId) |
2335 |
||
2336 |
def getconnectionId(self, idx): |
|
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
2337 |
connection = self.getconnection(idx) |
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
2338 |
if connection is not None: |
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
2339 |
return connection.getrefLocalId() |
814 | 2340 |
return None |
2341 |
setattr(cls, "getconnectionId", getconnectionId) |
|
2342 |
||
2343 |
def setconnectionPoints(self, idx, points): |
|
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
2344 |
connection = self.getconnection(idx) |
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
2345 |
if connection is not None: |
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
2346 |
connection.setpoints(points) |
814 | 2347 |
setattr(cls, "setconnectionPoints", setconnectionPoints) |
2348 |
||
2349 |
def getconnectionPoints(self, idx): |
|
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
2350 |
connection = self.getconnection(idx) |
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
2351 |
if connection is not None: |
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
2352 |
return connection.getpoints() |
1285
fa77f3b8f182
Fixed bug when no connection defined for connectionPointIn
Laurent Bessard
parents:
1283
diff
changeset
|
2353 |
return [] |
814 | 2354 |
setattr(cls, "getconnectionPoints", getconnectionPoints) |
2355 |
||
2356 |
def setconnectionParameter(self, idx, parameter): |
|
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
2357 |
connection = self.getconnection(idx) |
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
2358 |
if connection is not None: |
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
2359 |
connection.setformalParameter(parameter) |
814 | 2360 |
setattr(cls, "setconnectionParameter", setconnectionParameter) |
2361 |
||
2362 |
def getconnectionParameter(self, idx): |
|
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
2363 |
connection = self.getconnection(idx) |
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
2364 |
if connection is not None: |
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
2365 |
return connection.getformalParameter() |
814 | 2366 |
return None |
2367 |
setattr(cls, "getconnectionParameter", getconnectionParameter) |
|
2368 |
||
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
2369 |
cls = PLCOpenParser.GetElementClass("connectionPointOut") |
814 | 2370 |
if cls: |
2371 |
def setrelPositionXY(self, x, y): |
|
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
2372 |
self.relPosition = PLCOpenParser.CreateElement("relPosition", "connectionPointOut") |
814 | 2373 |
self.relPosition.setx(x) |
2374 |
self.relPosition.sety(y) |
|
2375 |
setattr(cls, "setrelPositionXY", setrelPositionXY) |
|
2376 |
||
2377 |
def getrelPositionXY(self): |
|
1291
42ea51d083ce
Second stage of xmlclass refactoring using lxml , project are loaded and displayed successfully
Laurent Bessard
parents:
1290
diff
changeset
|
2378 |
if self.relPosition is not None: |
814 | 2379 |
return self.relPosition.getx(), self.relPosition.gety() |
2380 |
return self.relPosition |
|
2381 |
setattr(cls, "getrelPositionXY", getrelPositionXY) |
|
2382 |
||
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
2383 |
cls = PLCOpenParser.GetElementClass("value") |
814 | 2384 |
if cls: |
2385 |
def setvalue(self, value): |
|
2386 |
value = value.strip() |
|
2387 |
if value.startswith("[") and value.endswith("]"): |
|
1291
42ea51d083ce
Second stage of xmlclass refactoring using lxml , project are loaded and displayed successfully
Laurent Bessard
parents:
1290
diff
changeset
|
2388 |
content = PLCOpenParser.CreateElement("arrayValue", "value") |
814 | 2389 |
elif value.startswith("(") and value.endswith(")"): |
1291
42ea51d083ce
Second stage of xmlclass refactoring using lxml , project are loaded and displayed successfully
Laurent Bessard
parents:
1290
diff
changeset
|
2390 |
content = PLCOpenParser.CreateElement("structValue", "value") |
814 | 2391 |
else: |
1291
42ea51d083ce
Second stage of xmlclass refactoring using lxml , project are loaded and displayed successfully
Laurent Bessard
parents:
1290
diff
changeset
|
2392 |
content = PLCOpenParser.CreateElement("simpleValue", "value") |
42ea51d083ce
Second stage of xmlclass refactoring using lxml , project are loaded and displayed successfully
Laurent Bessard
parents:
1290
diff
changeset
|
2393 |
content.setvalue(value) |
42ea51d083ce
Second stage of xmlclass refactoring using lxml , project are loaded and displayed successfully
Laurent Bessard
parents:
1290
diff
changeset
|
2394 |
self.setcontent(content) |
814 | 2395 |
setattr(cls, "setvalue", setvalue) |
2396 |
||
2397 |
def getvalue(self): |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
2398 |
return self.content.getvalue() |
814 | 2399 |
setattr(cls, "getvalue", getvalue) |
2400 |
||
2401 |
def extractValues(values): |
|
2402 |
items = values.split(",") |
|
2403 |
i = 1 |
|
2404 |
while i < len(items): |
|
2405 |
opened = items[i - 1].count("(") + items[i - 1].count("[") |
|
2406 |
closed = items[i - 1].count(")") + items[i - 1].count("]") |
|
2407 |
if opened > closed: |
|
2408 |
items[i - 1] = ','.join([items[i - 1], items.pop(i)]) |
|
2409 |
elif opened == closed: |
|
2410 |
i += 1 |
|
2411 |
else: |
|
2412 |
raise ValueError, _("\"%s\" is an invalid value!")%value |
|
2413 |
return items |
|
2414 |
||
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
2415 |
cls = PLCOpenParser.GetElementClass("arrayValue", "value") |
814 | 2416 |
if cls: |
2417 |
arrayValue_model = re.compile("([0-9]*)\((.*)\)$") |
|
2418 |
||
2419 |
def setvalue(self, value): |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
2420 |
elements = [] |
814 | 2421 |
for item in extractValues(value[1:-1]): |
2422 |
item = item.strip() |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
2423 |
element = PLCOpenParser.CreateElement("value", "arrayValue") |
814 | 2424 |
result = arrayValue_model.match(item) |
2425 |
if result is not None: |
|
2426 |
groups = result.groups() |
|
2427 |
element.setrepetitionValue(groups[0]) |
|
2428 |
element.setvalue(groups[1].strip()) |
|
2429 |
else: |
|
2430 |
element.setvalue(item) |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
2431 |
elements.append(element) |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
2432 |
self.value = elements |
814 | 2433 |
setattr(cls, "setvalue", setvalue) |
2434 |
||
2435 |
def getvalue(self): |
|
2436 |
values = [] |
|
2437 |
for element in self.value: |
|
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
2438 |
try: |
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
2439 |
repetition = int(element.getrepetitionValue()) |
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
2440 |
except: |
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
2441 |
repetition = 1 |
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset
|
2442 |
if repetition > 1: |
814 | 2443 |
value = element.getvalue() |
2444 |
if value is None: |
|
2445 |
value = "" |
|
2446 |
values.append("%s(%s)"%(repetition, value)) |
|
2447 |
else: |
|
2448 |
values.append(element.getvalue()) |
|
2449 |
return "[%s]"%", ".join(values) |
|
2450 |
setattr(cls, "getvalue", getvalue) |
|
2451 |
||
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
2452 |
cls = PLCOpenParser.GetElementClass("structValue", "value") |
814 | 2453 |
if cls: |
2454 |
structValue_model = re.compile("(.*):=(.*)") |
|
2455 |
||
2456 |
def setvalue(self, value): |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
2457 |
elements = [] |
814 | 2458 |
for item in extractValues(value[1:-1]): |
2459 |
result = structValue_model.match(item) |
|
2460 |
if result is not None: |
|
2461 |
groups = result.groups() |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
2462 |
element = PLCOpenParser.CreateElement("value", "structValue") |
814 | 2463 |
element.setmember(groups[0].strip()) |
2464 |
element.setvalue(groups[1].strip()) |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
2465 |
elements.append(element) |
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
2466 |
self.value = elements |
814 | 2467 |
setattr(cls, "setvalue", setvalue) |
2468 |
||
2469 |
def getvalue(self): |
|
2470 |
values = [] |
|
2471 |
for element in self.value: |
|
2472 |
values.append("%s := %s"%(element.getmember(), element.getvalue())) |
|
2473 |
return "(%s)"%", ".join(values) |
|
2474 |
setattr(cls, "getvalue", getvalue) |
|
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset
|
2475 |