author  Andrey Skvortsov <andrej.skvortzov@gmail.com> 
Mon, 28 Nov 2016 16:47:01 +0300  
changeset 1581  2295fdc5c271 
parent 1571  486f94a8032c 
child 1611  5e64d552b25a 
permissions  rwrr 
814  1 
#!/usr/bin/env python 
2 
# * coding: utf8 * 

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 611313 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 021101301, 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 speedup loading of graphic POU tabs
Laurent Bessard
parents:
1330
diff
changeset

29 
from collections import OrderedDict 
38c5de794e62
Added support for speedup 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)((?:\.[09]+)*)" 

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 

1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

132 
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

133 
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

134 

1299
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset

135 
LOAD_POU_PROJECT_TEMPLATE = """ 
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset

136 
<project xmlns:ns1="http://www.plcopen.org/xml/tc6_0201" 
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset

137 
xmlns:xhtml="http://www.w3.org/1999/xhtml" 
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset

138 
xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset

139 
xmlns="http://www.plcopen.org/xml/tc6_0201"> 
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset

140 
<fileHeader companyName="" productName="" productVersion="" 
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset

141 
creationDateTime="19700101T00:00:00"/> 
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset

142 
<contentHeader name="paste_project"> 
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset

143 
<coordinateInfo> 
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset

144 
<fbd><scaling x="0" y="0"/></fbd> 
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset

145 
<ld><scaling x="0" y="0"/></ld> 
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset

146 
<sfc><scaling x="0" y="0"/></sfc> 
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset

147 
</coordinateInfo> 
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset

148 
</contentHeader> 
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset

149 
<types> 
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset

150 
<dataTypes/> 
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset

151 
<pous>%s</pous> 
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 
<instances> 
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset

154 
<configurations/> 
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset

155 
</instances> 
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset

156 
</project> 
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset

157 
""" 
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset

158 

9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset

159 
def LOAD_POU_INSTANCES_PROJECT_TEMPLATE(body_type): 
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset

160 
return LOAD_POU_PROJECT_TEMPLATE % """ 
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset

161 
<pou name="paste_pou" pouType="program"> 
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset

162 
<body> 
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset

163 
<%(body_type)s>%%s</%(body_type)s> 
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset

164 
</body> 
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset

165 
</pou>""" % locals() 
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset

166 

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

167 
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

168 
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

169 
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

170 
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

171 
"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

172 
"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

173 
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

174 

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 
# 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

176 
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

177 
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

178 
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

179 
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

180 
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

181 
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

182 

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

183 
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

184 
project_xml = project_xml.replace( 
1294
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset

185 
"http://www.plcopen.org/xml/tc6.xsd", 
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset

186 
"http://www.plcopen.org/xml/tc6_0201") 
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset

187 
for cre, repl in [ 
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset

188 
(re.compile("(?<!<xhtml:p>)(?:<!\[CDATA\[)"), "<xhtml:p><![CDATA["), 
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset

189 
(re.compile("(?:]]>)(?!</xhtml:p>)"), "]]></xhtml:p>")]: 
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset

190 
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

191 

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

192 
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

193 
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

194 
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

195 
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

196 

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 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

198 
# 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

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 
# 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

201 
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

202 
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

203 
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

204 
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

205 
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

206 
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

207 
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

208 
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

209 
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

210 
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

211 
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

212 
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

213 
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

214 
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

215 
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

216 
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

217 
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

218 
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

219 
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

220 
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

221 
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

222 
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

223 
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

224 

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 
# 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

226 
for pouInstance in ResourceInstancesXpath(resource): 
1339  227 
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

228 
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

229 
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

230 

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 
# 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

232 
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

233 
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

234 
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

235 
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

236 
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

237 
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

238 
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

239 
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

240 

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 
# 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

242 
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

243 
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

244 
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

245 

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 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

247 
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

248 
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

249 
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

250 
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

251 
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

252 

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 
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

254 

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 
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

256 

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

257 
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

258 
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

259 

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 
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

261 
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

262 
project_xml = project_file.read() 
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

263 
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

264 
return LoadProjectXML(project_xml) 
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

265 

1305
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset

266 
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

267 
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

268 
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

269 
return project_pou_xpath(root)[0], error 
1305
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset

270 

714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset

271 
project_pou_instances_xpath = { 
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset

272 
body_type: PLCOpen_XPath( 
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset

273 
"/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

274 
for body_type in ["FBD", "LD", "SFC"]} 
1299
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset

275 
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

276 
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

277 
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

278 
return project_pou_instances_xpath[body_type](root), error 
1299
9ffc49bfdf9d
Fixed copy/paste with xmlclass refactoring
Laurent Bessard
parents:
1298
diff
changeset

279 

1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

280 
def SaveProject(project, filepath): 
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

281 
project_file = open(filepath, 'w') 
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

282 
project_file.write(etree.tostring( 
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

283 
project, 
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

284 
pretty_print=True, 
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

285 
xml_declaration=True, 
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

286 
encoding='utf8')) 
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

287 
project_file.close() 
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

288 

13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

289 
cls = PLCOpenParser.GetElementClass("formattedText") 
814  290 
if cls: 
291 
def updateElementName(self, old_name, new_name): 

1294
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset

292 
text = self.getanyText() 
814  293 
index = text.find(old_name) 
294 
while index != 1: 

295 
if index > 0 and (text[index  1].isalnum() or text[index  1] == "_"): 

296 
index = text.find(old_name, index + len(old_name)) 

297 
elif index < len(text)  len(old_name) and (text[index + len(old_name)].isalnum() or text[index + len(old_name)] == "_"): 

298 
index = text.find(old_name, index + len(old_name)) 

299 
else: 

300 
text = text[:index] + new_name + text[index + len(old_name):] 

301 
index = text.find(old_name, index + len(new_name)) 

1294
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset

302 
self.setanyText(text) 
814  303 
setattr(cls, "updateElementName", updateElementName) 
304 

305 
def updateElementAddress(self, address_model, new_leading): 

1294
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset

306 
text = self.getanyText() 
814  307 
startpos = 0 
308 
result = address_model.search(text, startpos) 

309 
while result is not None: 

310 
groups = result.groups() 

311 
new_address = groups[0] + new_leading + groups[2] 

312 
text = text[:result.start()] + new_address + text[result.end():] 

313 
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

314 
result = address_model.search(text, startpos) 
1294
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset

315 
self.setanyText(text) 
814  316 
setattr(cls, "updateElementAddress", updateElementAddress) 
317 

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 
def hasblock(self, block_type): 
1294
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset

319 
text = self.getanyText().upper() 
1142
8ded55ada6d6
Fixed functions used by one or more POU not showing question dialog when trying to delete
Laurent Bessard
parents:
990
diff
changeset

320 
index = text.find(block_type.upper()) 
8ded55ada6d6
Fixed functions used by one or more POU not showing question dialog when trying to delete
Laurent Bessard
parents:
990
diff
changeset

321 
while index != 1: 
8ded55ada6d6
Fixed functions used by one or more POU not showing question dialog when trying to delete
Laurent Bessard
parents:
990
diff
changeset

322 
if (not (index > 0 and (text[index  1].isalnum() or text[index  1] == "_")) and 
8ded55ada6d6
Fixed functions used by one or more POU not showing question dialog when trying to delete
Laurent Bessard
parents:
990
diff
changeset

323 
not (index < len(text)  len(block_type) and text[index + len(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

324 
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

325 
index = text.find(block_type.upper(), index + len(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

326 
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

327 
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

328 

814  329 
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

330 
return [(tuple(parent_infos),) + result for result in TestTextElement(self.getanyText(), criteria)] 
814  331 
setattr(cls, "Search", Search) 
332 

1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

333 
cls = PLCOpenParser.GetElementClass("project") 
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

334 
if cls: 
814  335 

336 
def setname(self, name): 

337 
self.contentHeader.setname(name) 

338 
setattr(cls, "setname", setname) 

339 

340 
def getname(self): 

341 
return self.contentHeader.getname() 

342 
setattr(cls, "getname", getname) 

343 

344 
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

345 
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

346 
return { 
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset

347 
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

348 
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

349 
("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

350 
("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

351 
("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

352 
("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

353 
("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

354 
("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

355 
("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

356 
} 
814  357 
setattr(cls, "getfileHeader", getfileHeader) 
358 

359 
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

360 
fileheader_obj = self.fileHeader 
1309
85ce56758900
Fixed bug when modifying project properties
Laurent Bessard
parents:
1307
diff
changeset

361 
for attr in ["companyName", "companyURL", "productName", 
85ce56758900
Fixed bug when modifying project properties
Laurent Bessard
parents:
1307
diff
changeset

362 
"productVersion", "productRelease", "creationDateTime", 
85ce56758900
Fixed bug when modifying project properties
Laurent Bessard
parents:
1307
diff
changeset

363 
"contentDescription"]: 
85ce56758900
Fixed bug when modifying project properties
Laurent Bessard
parents:
1307
diff
changeset

364 
value = fileheader.get(attr) 
85ce56758900
Fixed bug when modifying project properties
Laurent Bessard
parents:
1307
diff
changeset

365 
if value is not None: 
85ce56758900
Fixed bug when modifying project properties
Laurent Bessard
parents:
1307
diff
changeset

366 
setattr(fileheader_obj, attr, value) 
814  367 
setattr(cls, "setfileHeader", setfileHeader) 
368 

369 
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

370 
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

371 
contentheader = { 
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset

372 
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

373 
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

374 
("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

375 
("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

376 
("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

377 
("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

378 
("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

379 
("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

380 
} 
814  381 
contentheader["pageSize"] = self.contentHeader.getpageSize() 
382 
contentheader["scaling"] = self.contentHeader.getscaling() 

383 
return contentheader 

384 
setattr(cls, "getcontentHeader", getcontentHeader) 

385 

386 
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

387 
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

388 
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

389 
func = {"projectName": contentheader_obj.setname, 
85c167bfff93
Replaced standard function blocks library definition from dictionary to plcopen xml files
Laurent Bessard
parents:
1310
diff
changeset

390 
"projectVersion": contentheader_obj.setversion, 
85c167bfff93
Replaced standard function blocks library definition from dictionary to plcopen xml files
Laurent Bessard
parents:
1310
diff
changeset

391 
"authorName": contentheader_obj.setauthor, 
85c167bfff93
Replaced standard function blocks library definition from dictionary to plcopen xml files
Laurent Bessard
parents:
1310
diff
changeset

392 
"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

393 
"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

394 
if func is not None: 
85c167bfff93
Replaced standard function blocks library definition from dictionary to plcopen xml files
Laurent Bessard
parents:
1310
diff
changeset

395 
func(value) 
1309
85ce56758900
Fixed bug when modifying project properties
Laurent Bessard
parents:
1307
diff
changeset

396 
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

397 
setattr(contentheader_obj, attr, value) 
814  398 
setattr(cls, "setcontentHeader", setcontentHeader) 
399 

1305
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset

400 
def gettypeElementFunc(element_type): 
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset

401 
elements_xpath = PLCOpen_XPath( 
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset

402 
"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

403 
def gettypeElement(self, name): 
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset

404 
elements = elements_xpath(self, name=name) 
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset

405 
if len(elements) == 1: 
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset

406 
return elements[0] 
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset

407 
return None 
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset

408 
return gettypeElement 
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset

409 

714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset

410 
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

411 
filtered_datatypes_xpath = PLCOpen_XPath( 
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset

412 
"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

413 
def getdataTypes(self, exclude=None): 
1305
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset

414 
if exclude is not None: 
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset

415 
return filtered_datatypes_xpath(self, exclude=exclude) 
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset

416 
return datatypes_xpath(self) 
814  417 
setattr(cls, "getdataTypes", getdataTypes) 
418 

1305
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset

419 
setattr(cls, "getdataType", gettypeElementFunc("dataType")) 
814  420 

421 
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

422 
if self.getdataType(name) is not None: 
814  423 
raise ValueError, "\"%s\" Data Type already exists !!!"%name 
424 
self.types.appenddataTypeElement(name) 

425 
setattr(cls, "appenddataType", appenddataType) 

426 

427 
def insertdataType(self, index, datatype): 

428 
self.types.insertdataTypeElement(index, datatype) 

429 
setattr(cls, "insertdataType", insertdataType) 

430 

431 
def removedataType(self, name): 

432 
self.types.removedataTypeElement(name) 

433 
setattr(cls, "removedataType", removedataType) 

434 

1305
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset

435 
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

436 
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

437 
"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

438 
(("[@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

439 
("[%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

440 
map(lambda x: "@pouType='%s'" % x, filter))) 
1305
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset

441 
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

442 
namespaces=PLCOpenParser.NSMAP) 
814  443 
setattr(cls, "getpous", getpous) 
444 

1305
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset

445 
setattr(cls, "getpou", gettypeElementFunc("pou")) 
814  446 

447 
def appendpou(self, name, pou_type, body_type): 

448 
self.types.appendpouElement(name, pou_type, body_type) 

449 
setattr(cls, "appendpou", appendpou) 

450 

451 
def insertpou(self, index, pou): 

452 
self.types.insertpouElement(index, pou) 

453 
setattr(cls, "insertpou", insertpou) 

454 

455 
def removepou(self, name): 

456 
self.types.removepouElement(name) 

457 
setattr(cls, "removepou", removepou) 

458 

1305
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset

459 
configurations_xpath = PLCOpen_XPath( 
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset

460 
"ppx:instances/ppx:configurations/ppx:configuration") 
814  461 
def getconfigurations(self): 
1305
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset

462 
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

463 
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

464 

1305
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset

465 
configuration_xpath = PLCOpen_XPath( 
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset

466 
"ppx:instances/ppx:configurations/ppx:configuration[@name=$name]") 
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset

467 
def getconfiguration(self, name): 
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset

468 
configurations = configuration_xpath(self, name=name) 
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset

469 
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

470 
return configurations[0] 
814  471 
return None 
472 
setattr(cls, "getconfiguration", getconfiguration) 

473 

474 
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

475 
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

476 
raise ValueError, _("\"%s\" configuration already exists !!!") % name 
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

477 
new_configuration = PLCOpenParser.CreateElement("configuration", "configurations") 
814  478 
new_configuration.setname(name) 
479 
self.instances.configurations.appendconfiguration(new_configuration) 

480 
setattr(cls, "addconfiguration", addconfiguration) 

481 

482 
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

483 
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

484 
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

485 
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

486 
self.instances.configurations.remove(configuration) 
814  487 
setattr(cls, "removeconfiguration", removeconfiguration) 
1305
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset

488 

714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset

489 
resources_xpath = PLCOpen_XPath( 
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset

490 
"ppx:instances/ppx:configurations/ppx:configuration[@name=$configname]/ppx:resource[@name=$name]") 
814  491 
def getconfigurationResource(self, config_name, name): 
1305
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset

492 
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

493 
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

494 
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

495 
return None 
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset

496 
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

497 

fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset

498 
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

499 
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

500 
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

501 
raise ValueError, msg 
814  502 
configuration = self.getconfiguration(config_name) 
1294
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset

503 
if configuration is not None: 
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

504 
new_resource = PLCOpenParser.CreateElement("resource", "configuration") 
814  505 
new_resource.setname(name) 
506 
configuration.appendresource(new_resource) 

507 
setattr(cls, "addconfigurationResource", addconfigurationResource) 

508 

509 
def removeconfigurationResource(self, config_name, name): 

510 
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

511 
found = False 
1294
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset

512 
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

513 
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

514 
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

515 
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

516 
found = True 
fcca121a000f
Removed dictionaries storing enumerated datatypes values, subrange datatypes range and project datatype hierarchy from model
Laurent Bessard
parents:
1299
diff
changeset

517 
if not found: 
1581
2295fdc5c271
fix translation strings with multiple parameters
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1571
diff
changeset

518 
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

519 
raise ValueError, msg 
814  520 
setattr(cls, "removeconfigurationResource", removeconfigurationResource) 
521 

522 
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

523 
for datatype in self.getdataTypes(): 
814  524 
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

525 
for pou in self.getpous(): 
814  526 
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

527 
for configuration in self.getconfigurations(): 
814  528 
configuration.updateElementName(old_name, new_name) 
529 
setattr(cls, "updateElementName", updateElementName) 

530 

531 
def updateElementAddress(self, old_leading, new_leading): 

532 
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

533 
for pou in self.getpous(): 
814  534 
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

535 
for configuration in self.getconfigurations(): 
814  536 
configuration.updateElementAddress(address_model, new_leading) 
537 
setattr(cls, "updateElementAddress", updateElementAddress) 

538 

539 
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

540 
for pou in self.getpous(): 
814  541 
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

542 
for configuration in self.getconfigurations(): 
814  543 
configuration.removeVariableByAddress(address) 
544 
setattr(cls, "removeVariableByAddress", removeVariableByAddress) 

545 

546 
def removeVariableByFilter(self, leading): 

547 
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

548 
for pou in self.getpous(): 
814  549 
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

550 
for configuration in self.getconfigurations(): 
814  551 
configuration.removeVariableByFilter(address_model) 
552 
setattr(cls, "removeVariableByFilter", removeVariableByFilter) 

553 

1305
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset

554 
enumerated_values_xpath = PLCOpen_XPath( 
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset

555 
"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

556 
def GetEnumeratedDataTypeValues(self): 
1305
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset

557 
return [value.getname() for value in enumerated_values_xpath(self)] 
814  558 
setattr(cls, "GetEnumeratedDataTypeValues", GetEnumeratedDataTypeValues) 
559 

560 
def Search(self, criteria, parent_infos=[]): 

561 
result = self.types.Search(criteria, parent_infos) 

562 
for configuration in self.instances.configurations.getconfiguration(): 

563 
result.extend(configuration.Search(criteria, parent_infos)) 

564 
return result 

565 
setattr(cls, "Search", Search) 

566 

1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

567 
cls = PLCOpenParser.GetElementClass("contentHeader", "project") 
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

568 
if cls: 
814  569 

570 
def setpageSize(self, width, height): 

571 
self.coordinateInfo.setpageSize(width, height) 

572 
setattr(cls, "setpageSize", setpageSize) 

573 

574 
def getpageSize(self): 

575 
return self.coordinateInfo.getpageSize() 

576 
setattr(cls, "getpageSize", getpageSize) 

577 

578 
def setscaling(self, scaling): 

579 
for language, (x, y) in scaling.items(): 

580 
self.coordinateInfo.setscaling(language, x, y) 

581 
setattr(cls, "setscaling", setscaling) 

582 

583 
def getscaling(self): 

584 
scaling = {} 

585 
scaling["FBD"] = self.coordinateInfo.getscaling("FBD") 

586 
scaling["LD"] = self.coordinateInfo.getscaling("LD") 

587 
scaling["SFC"] = self.coordinateInfo.getscaling("SFC") 

588 
return scaling 

589 
setattr(cls, "getscaling", getscaling) 

590 

1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

591 
cls = PLCOpenParser.GetElementClass("coordinateInfo", "contentHeader") 
814  592 
if cls: 
593 
def setpageSize(self, width, height): 

594 
if width == 0 and height == 0: 

595 
self.deletepageSize() 

596 
else: 

597 
if self.pageSize is None: 

598 
self.addpageSize() 

599 
self.pageSize.setx(width) 

600 
self.pageSize.sety(height) 

601 
setattr(cls, "setpageSize", setpageSize) 

602 

603 
def getpageSize(self): 

604 
if self.pageSize is not None: 

605 
return self.pageSize.getx(), self.pageSize.gety() 

606 
return 0, 0 

607 
setattr(cls, "getpageSize", getpageSize) 

608 

609 
def setscaling(self, language, x, y): 

610 
if language == "FBD": 

611 
self.fbd.scaling.setx(x) 

612 
self.fbd.scaling.sety(y) 

613 
elif language == "LD": 

614 
self.ld.scaling.setx(x) 

615 
self.ld.scaling.sety(y) 

616 
elif language == "SFC": 

617 
self.sfc.scaling.setx(x) 

618 
self.sfc.scaling.sety(y) 

619 
setattr(cls, "setscaling", setscaling) 

620 

621 
def getscaling(self, language): 

622 
if language == "FBD": 

623 
return self.fbd.scaling.getx(), self.fbd.scaling.gety() 

624 
elif language == "LD": 

625 
return self.ld.scaling.getx(), self.ld.scaling.gety() 

626 
elif language == "SFC": 

627 
return self.sfc.scaling.getx(), self.sfc.scaling.gety() 

628 
return 0, 0 

629 
setattr(cls, "getscaling", getscaling) 

630 

631 
def _Search(attributes, criteria, parent_infos): 

632 
search_result = [] 

633 
for attr, value in attributes: 

634 
if value is not None: 

635 
search_result.extend([(tuple(parent_infos + [attr]),) + result for result in TestTextElement(value, criteria)]) 

636 
return search_result 

637 

638 
def _updateConfigurationResourceElementName(self, old_name, new_name): 

639 
for varlist in self.getglobalVars(): 

640 
for var in varlist.getvariable(): 

641 
var_address = var.getaddress() 

642 
if var_address is not None: 

643 
if var_address == old_name: 

644 
var.setaddress(new_name) 

645 
if var.getname() == old_name: 

646 
var.setname(new_name) 

647 

648 
def _updateConfigurationResourceElementAddress(self, address_model, new_leading): 

649 
for varlist in self.getglobalVars(): 

650 
for var in varlist.getvariable(): 

651 
var_address = var.getaddress() 

652 
if var_address is not None: 

653 
var.setaddress(update_address(var_address, address_model, new_leading)) 

654 

655 
def _removeConfigurationResourceVariableByAddress(self, address): 

656 
for varlist in self.getglobalVars(): 

657 
variables = varlist.getvariable() 

658 
for i in xrange(len(variables)1, 1, 1): 

659 
if variables[i].getaddress() == address: 

1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

660 
variables.remove(variables[i]) 
814  661 

662 
def _removeConfigurationResourceVariableByFilter(self, address_model): 

663 
for varlist in self.getglobalVars(): 

664 
variables = varlist.getvariable() 

665 
for i in xrange(len(variables)1, 1, 1): 

666 
var_address = variables[i].getaddress() 

667 
if var_address is not None: 

668 
result = address_model.match(var_address) 

669 
if result is not None: 

1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

670 
variables.remove(variables[i]) 
814  671 

672 
def _SearchInConfigurationResource(self, criteria, parent_infos=[]): 

673 
search_result = _Search([("name", self.getname())], criteria, parent_infos) 

674 
var_number = 0 

675 
for varlist in self.getglobalVars(): 

676 
variable_type = searchResultVarTypes.get("globalVars", "var_local") 

677 
variables = varlist.getvariable() 

678 
for modifier, has_modifier in [("constant", varlist.getconstant()), 

679 
("retain", varlist.getretain()), 

680 
("non_retain", varlist.getnonretain())]: 

681 
if has_modifier: 

682 
for result in TestTextElement(modifier, criteria): 

683 
search_result.append((tuple(parent_infos + [variable_type, (var_number, var_number + len(variables)), modifier]),) + result) 

684 
break 

685 
for variable in variables: 

686 
search_result.extend(variable.Search(criteria, parent_infos + [variable_type, var_number])) 

687 
var_number += 1 

688 
return search_result 

689 

1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

690 
cls = PLCOpenParser.GetElementClass("configuration", "configurations") 
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

691 
if cls: 
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

692 

13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

693 
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

694 
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

695 
if len(globalvars) == 0: 
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

696 
globalvars.append(PLCOpenParser.CreateElement("varList")) 
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

697 
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

698 
var.setname(name) 
1313
85c167bfff93
Replaced standard function blocks library definition from dictionary to plcopen xml files
Laurent Bessard
parents:
1310
diff
changeset

699 
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

700 
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

701 
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

702 
if description != "": 
1294
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset

703 
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

704 
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

705 
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

706 
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

707 
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

708 

814  709 
def updateElementName(self, old_name, new_name): 
710 
_updateConfigurationResourceElementName(self, old_name, new_name) 

711 
for resource in self.getresource(): 

712 
resource.updateElementName(old_name, new_name) 

713 
setattr(cls, "updateElementName", updateElementName) 

714 

715 
def updateElementAddress(self, address_model, new_leading): 

716 
_updateConfigurationResourceElementAddress(self, address_model, new_leading) 

717 
for resource in self.getresource(): 

718 
resource.updateElementAddress(address_model, new_leading) 

719 
setattr(cls, "updateElementAddress", updateElementAddress) 

720 

721 
setattr(cls, "removeVariableByAddress", _removeConfigurationResourceVariableByAddress) 

722 
setattr(cls, "removeVariableByFilter", _removeConfigurationResourceVariableByFilter) 

723 

724 
def Search(self, criteria, parent_infos=[]): 

725 
search_result = [] 

726 
parent_infos = parent_infos + ["C::%s" % self.getname()] 

727 
filter = criteria["filter"] 

728 
if filter == "all" or "configuration" in filter: 

729 
search_result = _SearchInConfigurationResource(self, criteria, parent_infos) 

730 
for resource in self.getresource(): 

731 
search_result.extend(resource.Search(criteria, parent_infos)) 

732 
return search_result 

733 
setattr(cls, "Search", Search) 

734 

1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

735 
cls = PLCOpenParser.GetElementClass("resource", "configuration") 
814  736 
if cls: 
737 
def updateElementName(self, old_name, new_name): 

738 
_updateConfigurationResourceElementName(self, old_name, new_name) 

739 
for instance in self.getpouInstance(): 

740 
instance.updateElementName(old_name, new_name) 

741 
for task in self.gettask(): 

742 
task.updateElementName(old_name, new_name) 

743 
setattr(cls, "updateElementName", updateElementName) 

744 

745 
def updateElementAddress(self, address_model, new_leading): 

746 
_updateConfigurationResourceElementAddress(self, address_model, new_leading) 

747 
for task in self.gettask(): 

748 
task.updateElementAddress(address_model, new_leading) 

749 
setattr(cls, "updateElementAddress", updateElementAddress) 

750 

751 
setattr(cls, "removeVariableByAddress", _removeConfigurationResourceVariableByAddress) 

752 
setattr(cls, "removeVariableByFilter", _removeConfigurationResourceVariableByFilter) 

753 

754 
def Search(self, criteria, parent_infos=[]): 

755 
parent_infos = parent_infos[:1] + ["R::%s::%s" % (parent_infos[1].split("::")[1], self.getname())] 

756 
search_result = _SearchInConfigurationResource(self, criteria, parent_infos) 

757 
task_number = 0 

758 
instance_number = 0 

759 
for task in self.gettask(): 

760 
results = TestTextElement(task.getname(), criteria) 

761 
for result in results: 

762 
search_result.append((tuple(parent_infos + ["task", task_number, "name"]),) + result) 

763 
search_result.extend(task.Search(criteria, parent_infos + ["task", task_number])) 

764 
task_number += 1 

765 
for instance in task.getpouInstance(): 

766 
search_result.extend(task.Search(criteria, parent_infos + ["instance", instance_number])) 

767 
for result in results: 

768 
search_result.append((tuple(parent_infos + ["instance", instance_number, "task"]),) + result) 

769 
instance_number += 1 

770 
for instance in self.getpouInstance(): 

771 
search_result.extend(instance.Search(criteria, parent_infos + ["instance", instance_number])) 

772 
instance_number += 1 

773 
return search_result 

774 
setattr(cls, "Search", Search) 

775 

1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

776 
cls = PLCOpenParser.GetElementClass("task", "resource") 
814  777 
if cls: 
778 
def updateElementName(self, old_name, new_name): 

779 
if self.single == old_name: 

780 
self.single = new_name 

781 
if self.interval == old_name: 

782 
self.interval = new_name 

783 
for instance in self.getpouInstance(): 

784 
instance.updateElementName(old_name, new_name) 

785 
setattr(cls, "updateElementName", updateElementName) 

786 

787 
def updateElementAddress(self, address_model, new_leading): 

788 
if self.single is not None: 

789 
self.single = update_address(self.single, address_model, new_leading) 

790 
if self.interval is not None: 

791 
self.interval = update_address(self.interval, address_model, new_leading) 

792 
setattr(cls, "updateElementAddress", updateElementAddress) 

793 

794 
def Search(self, criteria, parent_infos=[]): 

795 
return _Search([("single", self.getsingle()), 

796 
("interval", self.getinterval()), 

797 
("priority", str(self.getpriority()))], 

798 
criteria, parent_infos) 

799 
setattr(cls, "Search", Search) 

800 

1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

801 
cls = PLCOpenParser.GetElementClass("pouInstance") 
814  802 
if cls: 
803 
def updateElementName(self, old_name, new_name): 

804 
if self.typeName == old_name: 

805 
self.typeName = new_name 

806 
setattr(cls, "updateElementName", updateElementName) 

807 

808 
def Search(self, criteria, parent_infos=[]): 

809 
return _Search([("name", self.getname()), 

810 
("type", self.gettypeName())], 

811 
criteria, parent_infos) 

812 
setattr(cls, "Search", Search) 

813 

1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

814 
cls = PLCOpenParser.GetElementClass("variable", "varListPlain") 
814  815 
if cls: 
816 
def gettypeAsText(self): 

817 
vartype_content = self.gettype().getcontent() 

1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

818 
vartype_content_name = vartype_content.getLocalTag() 
814  819 
# Variable type is a user data type 
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

820 
if vartype_content_name == "derived": 
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

821 
return vartype_content.getname() 
814  822 
# Variable type is a string type 
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

823 
elif vartype_content_name in ["string", "wstring"]: 
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

824 
return vartype_content_name.upper() 
814  825 
# Variable type is an array 
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

826 
elif vartype_content_name == "array": 
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

827 
base_type = vartype_content.baseType.getcontent() 
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

828 
base_type_name = base_type.getLocalTag() 
814  829 
# Array derived directly from a user defined type 
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

830 
if base_type_name == "derived": 
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

831 
basetype_name = base_type.getname() 
814  832 
# Array derived directly from a string type 
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

833 
elif base_type_name in ["string", "wstring"]: 
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

834 
basetype_name = base_type_name.upper() 
814  835 
# Array derived directly from an elementary type 
836 
else: 

1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

837 
basetype_name = base_type_name 
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

838 
return "ARRAY [%s] OF %s" % (",".join(map(lambda x : "%s..%s" % (x.getlower(), x.getupper()), vartype_content.getdimension())), basetype_name) 
814  839 
# Variable type is an elementary type 
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

840 
return vartype_content_name 
814  841 
setattr(cls, "gettypeAsText", gettypeAsText) 
842 

843 
def Search(self, criteria, parent_infos=[]): 

844 
search_result = _Search([("name", self.getname()), 

845 
("type", self.gettypeAsText()), 

846 
("location", self.getaddress())], 

847 
criteria, parent_infos) 

848 
initial = self.getinitialValue() 

849 
if initial is not None: 

850 
search_result.extend(_Search([("initial value", initial.getvalue())], criteria, parent_infos)) 

851 
doc = self.getdocumentation() 

852 
if doc is not None: 

853 
search_result.extend(doc.Search(criteria, parent_infos + ["documentation"])) 

854 
return search_result 

855 
setattr(cls, "Search", Search) 

856 

1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

857 
cls = PLCOpenParser.GetElementClass("types", "project") 
814  858 
if cls: 
859 
def getdataTypeElements(self): 

860 
return self.dataTypes.getdataType() 

861 
setattr(cls, "getdataTypeElements", getdataTypeElements) 

862 

863 
def getdataTypeElement(self, name): 

864 
elements = self.dataTypes.getdataType() 

865 
for element in elements: 

866 
if element.getname() == name: 

867 
return element 

868 
return None 

869 
setattr(cls, "getdataTypeElement", getdataTypeElement) 

870 

871 
def appenddataTypeElement(self, name): 

1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

872 
new_datatype = PLCOpenParser.CreateElement("dataType", "dataTypes") 
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset

873 
self.dataTypes.appenddataType(new_datatype) 
814  874 
new_datatype.setname(name) 
1294
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset

875 
new_datatype.baseType.setcontent(PLCOpenParser.CreateElement("BOOL", "dataType")) 
814  876 
setattr(cls, "appenddataTypeElement", appenddataTypeElement) 
877 

878 
def insertdataTypeElement(self, index, dataType): 

879 
self.dataTypes.insertdataType(index, dataType) 

880 
setattr(cls, "insertdataTypeElement", insertdataTypeElement) 

881 

882 
def removedataTypeElement(self, name): 

883 
found = False 

1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

884 
for element in self.dataTypes.getdataType(): 
814  885 
if element.getname() == name: 
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

886 
self.dataTypes.remove(element) 
814  887 
found = True 
888 
break 

889 
if not found: 

890 
raise ValueError, _("\"%s\" Data Type doesn't exist !!!")%name 

891 
setattr(cls, "removedataTypeElement", removedataTypeElement) 

892 

893 
def getpouElements(self): 

894 
return self.pous.getpou() 

895 
setattr(cls, "getpouElements", getpouElements) 

896 

897 
def getpouElement(self, name): 

898 
elements = self.pous.getpou() 

899 
for element in elements: 

900 
if element.getname() == name: 

901 
return element 

902 
return None 

903 
setattr(cls, "getpouElement", getpouElement) 

904 

905 
def appendpouElement(self, name, pou_type, body_type): 

906 
for element in self.pous.getpou(): 

907 
if element.getname() == name: 

908 
raise ValueError, _("\"%s\" POU already exists !!!")%name 

1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

909 
new_pou = PLCOpenParser.CreateElement("pou", "pous") 
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset

910 
self.pous.appendpou(new_pou) 
814  911 
new_pou.setname(name) 
912 
new_pou.setpouType(pou_type) 

1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset

913 
new_pou.appendbody(PLCOpenParser.CreateElement("body", "pou")) 
814  914 
new_pou.setbodyType(body_type) 
915 
setattr(cls, "appendpouElement", appendpouElement) 

916 

917 
def insertpouElement(self, index, pou): 

918 
self.pous.insertpou(index, pou) 

919 
setattr(cls, "insertpouElement", insertpouElement) 

920 

921 
def removepouElement(self, name): 

922 
found = False 

1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

923 
for element in self.pous.getpou(): 
814  924 
if element.getname() == name: 
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

925 
self.pous.remove(element) 
814  926 
found = True 
927 
break 

928 
if not found: 

929 
raise ValueError, _("\"%s\" POU doesn't exist !!!")%name 

930 
setattr(cls, "removepouElement", removepouElement) 

931 

932 
def Search(self, criteria, parent_infos=[]): 

933 
search_result = [] 

934 
filter = criteria["filter"] 

935 
for datatype in self.dataTypes.getdataType(): 

936 
search_result.extend(datatype.Search(criteria, parent_infos)) 

937 
for pou in self.pous.getpou(): 

938 
search_result.extend(pou.Search(criteria, parent_infos)) 

939 
return search_result 

940 
setattr(cls, "Search", Search) 

941 

942 
def _updateBaseTypeElementName(self, old_name, new_name): 

943 
self.baseType.updateElementName(old_name, new_name) 

944 

1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

945 
cls = PLCOpenParser.GetElementClass("dataType", "dataTypes") 
814  946 
if cls: 
947 
setattr(cls, "updateElementName", _updateBaseTypeElementName) 

948 

949 
def Search(self, criteria, parent_infos=[]): 

950 
search_result = [] 

951 
filter = criteria["filter"] 

952 
if filter == "all" or "datatype" in filter: 

953 
parent_infos = parent_infos + ["D::%s" % self.getname()] 

954 
search_result.extend(_Search([("name", self.getname())], criteria, parent_infos)) 

955 
search_result.extend(self.baseType.Search(criteria, parent_infos)) 

956 
if self.initialValue is not None: 

957 
search_result.extend(_Search([("initial", self.initialValue.getvalue())], criteria, parent_infos)) 

958 
return search_result 

959 
setattr(cls, "Search", Search) 

960 

1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

961 
cls = PLCOpenParser.GetElementClass("dataType") 
814  962 
if cls: 
963 

964 
def updateElementName(self, old_name, new_name): 

1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

965 
content_name = self.content.getLocalTag() 
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

966 
if content_name in ["derived", "array", "subrangeSigned", "subrangeUnsigned"]: 
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

967 
self.content.updateElementName(old_name, new_name) 
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

968 
elif content_name == "struct": 
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

969 
for element in self.content.getvariable(): 
814  970 
element_type = element.type.updateElementName(old_name, new_name) 
971 
setattr(cls, "updateElementName", updateElementName) 

972 

973 
def Search(self, criteria, parent_infos=[]): 

974 
search_result = [] 

1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

975 
content_name = self.content.getLocalTag() 
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

976 
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

977 
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

978 
elif content_name == "struct": 
1294
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset

979 
for i, element in enumerate(self.content.getvariable()): 
814  980 
search_result.extend(element.Search(criteria, parent_infos + ["struct", i])) 
981 
else: 

1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

982 
if content_name in ["string", "wstring"]: 
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

983 
content_name = content_name.upper() 
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

984 
search_result.extend(_Search([("base", content_name)], criteria, parent_infos)) 
814  985 
return search_result 
986 
setattr(cls, "Search", Search) 

987 

1294
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset

988 
cls = PLCOpenParser.GetElementClass("derived", "dataType") 
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset

989 
if cls: 
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset

990 
def updateElementName(self, old_name, new_name): 
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset

991 
if self.name == old_name: 
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset

992 
self.name = new_name 
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset

993 
setattr(cls, "updateElementName", updateElementName) 
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset

994 

f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset

995 
def Search(self, criteria, parent_infos=[]): 
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset

996 
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

997 
setattr(cls, "Search", Search) 
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset

998 

1291
42ea51d083ce
Second stage of xmlclass refactoring using lxml , project are loaded and displayed successfully
Laurent Bessard
parents:
1290
diff
changeset

999 
cls = PLCOpenParser.GetElementClass("array", "dataType") 
814  1000 
if cls: 
1001 
setattr(cls, "updateElementName", _updateBaseTypeElementName) 

1002 

1003 
def Search(self, criteria, parent_infos=[]): 

1004 
search_result = self.baseType.Search(criteria, parent_infos) 

1005 
for i, dimension in enumerate(self.getdimension()): 

1006 
search_result.extend(_Search([("lower", dimension.getlower()), 

1007 
("upper", dimension.getupper())], 

1008 
criteria, parent_infos + ["range", i])) 

1009 
return search_result 

1010 
setattr(cls, "Search", Search) 

1011 

1012 
def _SearchInSubrange(self, criteria, parent_infos=[]): 

1013 
search_result = self.baseType.Search(criteria, parent_infos) 

1014 
search_result.extend(_Search([("lower", self.range.getlower()), 

1015 
("upper", self.range.getupper())], 

1016 
criteria, parent_infos)) 

1017 
return search_result 

1018 

1291
42ea51d083ce
Second stage of xmlclass refactoring using lxml , project are loaded and displayed successfully
Laurent Bessard
parents:
1290
diff
changeset

1019 
cls = PLCOpenParser.GetElementClass("subrangeSigned", "dataType") 
814  1020 
if cls: 
1021 
setattr(cls, "updateElementName", _updateBaseTypeElementName) 

1022 
setattr(cls, "Search", _SearchInSubrange) 

1023 

1291
42ea51d083ce
Second stage of xmlclass refactoring using lxml , project are loaded and displayed successfully
Laurent Bessard
parents:
1290
diff
changeset

1024 
cls = PLCOpenParser.GetElementClass("subrangeUnsigned", "dataType") 
814  1025 
if cls: 
1026 
setattr(cls, "updateElementName", _updateBaseTypeElementName) 

1027 
setattr(cls, "Search", _SearchInSubrange) 

1028 

1291
42ea51d083ce
Second stage of xmlclass refactoring using lxml , project are loaded and displayed successfully
Laurent Bessard
parents:
1290
diff
changeset

1029 
cls = PLCOpenParser.GetElementClass("enum", "dataType") 
814  1030 
if cls: 
1031 

1032 
def updateElementName(self, old_name, new_name): 

1033 
pass 

1034 
setattr(cls, "updateElementName", updateElementName) 

1035 

1305
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset

1036 
enumerated_datatype_values_xpath = PLCOpen_XPath("ppx:values/ppx:value") 
814  1037 
def Search(self, criteria, parent_infos=[]): 
1038 
search_result = [] 

1305
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset

1039 
for i, value in enumerate(enumerated_datatype_values_xpath(self)): 
814  1040 
for result in TestTextElement(value.getname(), criteria): 
1041 
search_result.append((tuple(parent_infos + ["value", i]),) + result) 

1042 
return search_result 

1043 
setattr(cls, "Search", Search) 

1044 

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

1045 
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

1046 
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

1047 
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

1048 
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

1049 
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

1050 
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

1051 

1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

1052 
cls = PLCOpenParser.GetElementClass("pou", "pous") 
814  1053 
if cls: 
1054 

1305
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset

1055 
block_inputs_xpath = PLCOpen_XPath( 
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset

1056 
"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

1057 
block_outputs_xpath = PLCOpen_XPath( 
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset

1058 
"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

1059 
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

1060 
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

1061 
"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

1062 
"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

1063 
"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

1064 
"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

1065 
"outputs" : [], 
1310
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1309
diff
changeset

1066 
"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

1067 
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

1068 
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

1069 
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

1070 
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

1071 
("OUT", _getvariableTypeinfos(return_type), "none")) 
1305
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset

1072 
block_infos["inputs"].extend( 
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset

1073 
[(var.getname(), _getvariableTypeinfos(var.type), "none") 
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset

1074 
for var in block_inputs_xpath(self)]) 
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset

1075 
block_infos["outputs"].extend( 
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset

1076 
[(var.getname(), _getvariableTypeinfos(var.type), "none") 
714f1381a09a
Fixed xmlclass and plcopen using precompile xpath where possible
Laurent Bessard
parents:
1302
diff
changeset

1077 
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

1078 

7856cd7767d6
Removed dictionaries storing datatypes and pous defined in project and pou and datatype using tree from model
Laurent Bessard
parents:
1301
diff
changeset

1079 
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

1080 
(", ".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

1081 
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

1082 
", ".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

1083 
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

1084 
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

1085 
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

1086 

814  1087 
def setdescription(self, description): 
1088 
doc = self.getdocumentation() 

1089 
if doc is None: 

1294
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset

1090 
doc = PLCOpenParser.CreateElement("documentation", "pou") 
814  1091 
self.setdocumentation(doc) 
1291
42ea51d083ce
Second stage of xmlclass refactoring using lxml , project are loaded and displayed successfully
Laurent Bessard
parents:
1290
diff
changeset

1092 
doc.setanyText(description) 
814  1093 
setattr(cls, "setdescription", setdescription) 
1094 

1095 
def getdescription(self): 

1096 
doc = self.getdocumentation() 

1097 
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

1098 
return doc.getanyText() 
814  1099 
return "" 
1100 
setattr(cls, "getdescription", getdescription) 

1101 

1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

1102 
def setbodyType(self, body_type): 
814  1103 
if len(self.body) > 0: 
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

1104 
if body_type in ["IL", "ST", "LD", "FBD", "SFC"]: 
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset

1105 
self.body[0].setcontent(PLCOpenParser.CreateElement(body_type, "body")) 
814  1106 
else: 
1107 
raise ValueError, "%s isn't a valid body type!"%type 

1108 
setattr(cls, "setbodyType", setbodyType) 

1109 

1110 
def getbodyType(self): 

1111 
if len(self.body) > 0: 

1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

1112 
return self.body[0].getcontent().getLocalTag() 
814  1113 
setattr(cls, "getbodyType", getbodyType) 
1114 

1115 
def resetexecutionOrder(self): 

1116 
if len(self.body) > 0: 

1117 
self.body[0].resetexecutionOrder() 

1118 
setattr(cls, "resetexecutionOrder", resetexecutionOrder) 

1119 

1120 
def compileexecutionOrder(self): 

1121 
if len(self.body) > 0: 

1122 
self.body[0].compileexecutionOrder() 

1123 
setattr(cls, "compileexecutionOrder", compileexecutionOrder) 

1124 

1125 
def setelementExecutionOrder(self, instance, new_executionOrder): 

1126 
if len(self.body) > 0: 

1127 
self.body[0].setelementExecutionOrder(instance, new_executionOrder) 

1128 
setattr(cls, "setelementExecutionOrder", setelementExecutionOrder) 

1129 

1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset

1130 
def addinstance(self, instance): 
814  1131 
if len(self.body) > 0: 
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset

1132 
self.body[0].appendcontentInstance(instance) 
814  1133 
setattr(cls, "addinstance", addinstance) 
1134 

1135 
def getinstances(self): 

1136 
if len(self.body) > 0: 

1137 
return self.body[0].getcontentInstances() 

1138 
return [] 

1139 
setattr(cls, "getinstances", getinstances) 

1140 

1141 
def getinstance(self, id): 

1142 
if len(self.body) > 0: 

1143 
return self.body[0].getcontentInstance(id) 

1144 
return None 

1145 
setattr(cls, "getinstance", getinstance) 

1146 

1331
38c5de794e62
Added support for speedup loading of graphic POU tabs
Laurent Bessard
parents:
1330
diff
changeset

1147 
def getinstancesIds(self): 
814  1148 
if len(self.body) > 0: 
1331
38c5de794e62
Added support for speedup loading of graphic POU tabs
Laurent Bessard
parents:
1330
diff
changeset

1149 
return self.body[0].getcontentInstancesIds() 
38c5de794e62
Added support for speedup loading of graphic POU tabs
Laurent Bessard
parents:
1330
diff
changeset

1150 
return [] 
38c5de794e62
Added support for speedup loading of graphic POU tabs
Laurent Bessard
parents:
1330
diff
changeset

1151 
setattr(cls, "getinstancesIds", getinstancesIds) 
814  1152 

1153 
def getinstanceByName(self, name): 

1154 
if len(self.body) > 0: 

1155 
return self.body[0].getcontentInstanceByName(name) 

1156 
return None 

1157 
setattr(cls, "getinstanceByName", getinstanceByName) 

1158 

1159 
def removeinstance(self, id): 

1160 
if len(self.body) > 0: 

1161 
self.body[0].removecontentInstance(id) 

1162 
setattr(cls, "removeinstance", removeinstance) 

1163 

1164 
def settext(self, text): 

1165 
if len(self.body) > 0: 

1166 
self.body[0].settext(text) 

1167 
setattr(cls, "settext", settext) 

1168 

1169 
def gettext(self): 

1170 
if len(self.body) > 0: 

1171 
return self.body[0].gettext() 

1172 
return "" 

1173 
setattr(cls, "gettext", gettext) 

1174 

1175 
def getvars(self): 

1176 
vars = [] 

1177 
if self.interface is not None: 

1178 
reverse_types = {} 

1179 
for name, value in VarTypes.items(): 

1180 
reverse_types[value] = name 

1181 
for varlist in self.interface.getcontent(): 

1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

1182 
vars.append((reverse_types[varlist.getLocalTag()], varlist)) 
814  1183 
return vars 
1184 
setattr(cls, "getvars", getvars) 

1185 

1186 
def setvars(self, vars): 

1187 
if self.interface is None: 

1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

1188 
self.interface = PLCOpenParser.CreateElement("interface", "pou") 
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

1189 
self.interface.setcontent(vars) 
814  1190 
setattr(cls, "setvars", setvars) 
1191 

1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

1192 
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

1193 
self.addpouVar(var_type, name, "externalVars") 
814  1194 
setattr(cls, "addpouExternalVar", addpouExternalVar) 
1195 

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

1196 
def addpouVar(self, var_type, name, var_class="localVars", location="", description="", initval=""): 
814  1197 
if self.interface is None: 
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

1198 
self.interface = PLCOpenParser.CreateElement("interface", "pou") 
814  1199 
content = self.interface.getcontent() 
1294
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset

1200 
if len(content) == 0: 
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 
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

1203 
elif content[1].getLocalTag() != var_class: 
1294
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset

1204 
varlist = PLCOpenParser.CreateElement(var_class, "interface") 
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset

1205 
content[1].addnext(varlist) 
814  1206 
else: 
1294
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset

1207 
varlist = content[1] 
814  1208 
variables = varlist.getvariable() 
1209 
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

1210 
varlist = PLCOpenParser.CreateElement(var_class, "interface") 
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset

1211 
content[1].addnext(varlist) 
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset

1212 
var = PLCOpenParser.CreateElement("variable", "varListPlain") 
814  1213 
var.setname(name) 
1313
85c167bfff93
Replaced standard function blocks library definition from dictionary to plcopen xml files
Laurent Bessard
parents:
1310
diff
changeset

1214 
var.settype(var_type) 
814  1215 
if location != "": 
1216 
var.setaddress(location) 

1217 
if description != "": 

1294
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset

1218 
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

1219 
ft.setanyText(description) 
814  1220 
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

1221 
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

1222 
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

1223 
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

1224 
var.setinitialValue(el) 
814  1225 

1294
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset

1226 
varlist.appendvariable(var) 
814  1227 
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

1228 
setattr(cls, "addpouLocalVar", addpouVar) 
814  1229 

1230 
def changepouVar(self, old_type, old_name, new_type, new_name): 

1231 
if self.interface is not None: 

1232 
content = self.interface.getcontent() 

1233 
for varlist in content: 

1294
f02ba5b83811
Fixed datatype and configuration editing in xmlclass refactoring
Laurent Bessard
parents:
1293
diff
changeset

1234 
variables = varlist.getvariable() 
814  1235 
for var in variables: 
1236 
if var.getname() == old_name: 

1237 
vartype_content = var.gettype().getcontent() 

1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

1238 
if vartype_content.getLocalTag() == "derived" and vartype_content.getname() == old_type: 
814  1239 
var.setname(new_name) 
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

1240 
vartype_content.setname(new_type) 
814  1241 
return 
1242 
setattr(cls, "changepouVar", changepouVar) 

1243 

1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

1244 
def removepouVar(self, var_type, name): 
814  1245 
if self.interface is not None: 
1246 
content = self.interface.getcontent() 

1247 
for varlist in content: 

1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

1248 
for var in varlist.getvariable(): 
814  1249 
if var.getname() == name: 
1250 
vartype_content = var.gettype().getcontent() 

1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

1251 
if vartype_content.getLocalTag() == "derived" and vartype_content.getname() == var_type: 
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

1252 
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

1253 
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

1254 
self.interface.remove(varlist) 
814  1255 
break 
1256 
setattr(cls, "removepouVar", removepouVar) 

1257 

1142
8ded55ada6d6
Fixed functions used by one or more POU not showing question dialog when trying to delete
Laurent Bessard
parents:
990
diff
changeset

1258 
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

1259 
if self.getbodyType() in ["FBD", "LD", "SFC"]: 
814  1260 
for instance in self.getinstances(): 
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

1261 
if (isinstance(instance, PLCOpenParser.GetElementClass("block", "fbdObjects")) and 
1142
8ded55ada6d6
Fixed functions used by one or more POU not showing question dialog when trying to delete
Laurent Bessard
parents:
990
diff
changeset

1262 
(name and instance.getinstanceName() == name or 
8ded55ada6d6
Fixed functions used by one or more POU not showing question dialog when trying to delete
Laurent Bessard
parents:
990
diff
changeset

1263 
block_type and instance.gettypeName() == block_type)): 
814  1264 
return True 
1265 
if self.transitions: 

1266 
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

1267 
result = transition.hasblock(name, block_type) 
814  1268 
if result: 
1269 
return result 

1270 
if self.actions: 

1271 
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

1272 
result = action.hasblock(name, block_type) 
814  1273 
if result: 
1274 
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

1275 
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

1276 
return self.body[0].hasblock(block_type) 
814  1277 
return False 
1278 
setattr(cls, "hasblock", hasblock) 

1279 

1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

1280 
def addtransition(self, name, body_type): 
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset

1281 
if self.transitions is None: 
814  1282 
self.addtransitions() 
1283 
self.transitions.settransition([]) 

1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

1284 
transition = PLCOpenParser.CreateElement("transition", "transitions") 
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset

1285 
self.transitions.appendtransition(transition) 
814  1286 
transition.setname(name) 
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

1287 
transition.setbodyType(body_type) 
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

1288 
if body_type == "ST": 
1291
42ea51d083ce
Second stage of xmlclass refactoring using lxml , project are loaded and displayed successfully
Laurent Bessard
parents:
1290
diff
changeset

1289 
transition.setanyText(":= ;") 
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

1290 
elif body_type == "IL": 
1291
42ea51d083ce
Second stage of xmlclass refactoring using lxml , project are loaded and displayed successfully
Laurent Bessard
parents:
1290
diff
changeset

1291 
transition.setanyText("\tST\t%s"%name) 
814  1292 
setattr(cls, "addtransition", addtransition) 
1293 

1294 
def gettransition(self, name): 

1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset

1295 
if self.transitions is not None: 
814  1296 
for transition in self.transitions.gettransition(): 
1297 
if transition.getname() == name: 

1298 
return transition 

1299 
return None 

1300 
setattr(cls, "gettransition", gettransition) 

1301 

1302 
def gettransitionList(self): 

1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset

1303 
if self.transitions is not None: 
814  1304 
return self.transitions.gettransition() 
1305 
return [] 

1306 
setattr(cls, "gettransitionList", gettransitionList) 

1307 

1308 
def removetransition(self, name): 

1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset

1309 
if self.transitions is not None: 
814  1310 
removed = False 
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

1311 
for transition in self.transitions.gettransition(): 
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

1312 
if transition.getname() == name: 
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

1313 
if transition.getbodyType() in ["FBD", "LD", "SFC"]: 
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

1314 
for instance in transition.getinstances(): 
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

1315 
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

1316 
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

1317 
instance.getinstanceName()) 
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

1318 
self.transitions.remove(transition) 
814  1319 
removed = True 
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

1320 
break 
814  1321 
if not removed: 
1322 
raise ValueError, _("Transition with name %s doesn't exist!")%name 

1323 
setattr(cls, "removetransition", removetransition) 

1324 

1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

1325 
def addaction(self, name, body_type): 
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset

1326 
if self.actions is None: 
814  1327 
self.addactions() 
1328 
self.actions.setaction([]) 

1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

1329 
action = PLCOpenParser.CreateElement("action", "actions") 
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset

1330 
self.actions.appendaction(action) 
814  1331 
action.setname(name) 
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

1332 
action.setbodyType(body_type) 
814  1333 
setattr(cls, "addaction", addaction) 
1334 

1335 
def getaction(self, name): 

1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset

1336 
if self.actions is not None: 
814  1337 
for action in self.actions.getaction(): 
1338 
if action.getname() == name: 

1339 
return action 

1340 
return None 

1341 
setattr(cls, "getaction", getaction) 

1342 

1343 
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

1344 
if self.actions is not None: 
814  1345 
return self.actions.getaction() 
1346 
return [] 

1347 
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

1348 

814  1349 
def removeaction(self, name): 
1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset

1350 
if self.actions is not None: 
814  1351 
removed = False 
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

1352 
for action in self.actions.getaction(): 
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

1353 
if action.getname() == name: 
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

1354 
if action.getbodyType() in ["FBD", "LD", "SFC"]: 
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

1355 
for instance in action.getinstances(): 
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

1356 
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

1357 
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

1358 
instance.getinstanceName()) 
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

1359 
self.actions.remove(action) 
814  1360 
removed = True 
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

1361 
break 
814  1362 
if not removed: 
1363 
raise ValueError, _("Action with name %s doesn't exist!")%name 

1364 
setattr(cls, "removeaction", removeaction) 

1365 

1366 
def updateElementName(self, old_name, new_name): 

1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset

1367 
if self.interface is not None: 
814  1368 
for content in self.interface.getcontent(): 
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

1369 
for var in content.getvariable(): 
814  1370 
var_address = var.getaddress() 
1371 
if var_address is not None: 

1372 
if var_address == old_name: 

1373 
var.setaddress(new_name) 

1374 
if var.getname() == old_name: 

1375 
var.setname(new_name) 

1376 
var_type_content = var.gettype().getcontent() 

1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

1377 
if var_type_content.getLocalTag() == "derived": 
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

1378 
if var_type_content.getname() == old_name: 
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

1379 
var_type_content.setname(new_name) 
814  1380 
self.body[0].updateElementName(old_name, new_name) 
1381 
for action in self.getactionList(): 

1382 
action.updateElementName(old_name, new_name) 

1383 
for transition in self.gettransitionList(): 

1384 
transition.updateElementName(old_name, new_name) 

1385 
setattr(cls, "updateElementName", updateElementName) 

1386 

1387 
def updateElementAddress(self, address_model, new_leading): 

1293
40117d02601b
Fixed diagram editing in xmlclass refactoring
Laurent Bessard
parents:
1291
diff
changeset

1388 
if self.interface is not None: 
814  1389 
for content in self.interface.getcontent(): 
1290
13ee5f4ab612
First stage of xmlclass refactoring using lxml
Laurent Bessard
parents:
1285
diff
changeset

1390 
for var in content.getvariable(): 
814  1391 
var_address = var.getaddress() 
1392 
if var_address is not None: 

1393 
var.setaddress(update_address(var_address, address_model, new_leading)) 
