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