beremiz: comparison PLCControler.py

equal deleted inserted replaced

-:0d34b69cc9b5
+:805d13d216c0
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 #This file is part of PLCOpenEditor, a library implementing an IEC 61131-3 editor
 #based on the plcopen standard.
 #
 #Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD
 #
 #See COPYING file for copyrights details.
 #
 ITEM_ACTIONS,
 ITEM_CONFIGURATIONS,
 ITEM_RESOURCES,
 ITEM_PROPERTIES
 ] = range(8, 17)
 ITEMS_VARIABLE = [ITEM_VAR_LOCAL,
 ITEM_VAR_GLOBAL,
 ITEM_VAR_EXTERNAL,
 ITEM_VAR_TEMP,
 ITEM_VAR_INPUT,
 ScriptDirectory = os.path.split(os.path.realpath(__file__))[0]
 def GetUneditableNames():
 _ = lambda x:x
 return [_("User-defined POUs"), _("Functions"), _("Function Blocks"),
 _("Programs"), _("Data Types"), _("Transitions"), _("Actions"),
 _("Configurations"), _("Resources"), _("Properties")]
 UNEDITABLE_NAMES = GetUneditableNames()
 [USER_DEFINED_POUS, FUNCTIONS, FUNCTION_BLOCKS, PROGRAMS,
 DATA_TYPES, TRANSITIONS, ACTIONS, CONFIGURATIONS,
 RESOURCES, PROPERTIES] = UNEDITABLE_NAMES
 #-------------------------------------------------------------------------------
 #                 Helper object for loading library in xslt stylesheets
 #-------------------------------------------------------------------------------
 _StringValue = lambda x: x
 _BoolValue = lambda x: x in ["true", "0"]
 def _translate_args(translations, args):
 return [translate(arg[0]) if len(arg) > 0 else None
 for translate, arg in
 zip(translations, args)]
 #-------------------------------------------------------------------------------
 #                 Helpers object for generating pou var list
 #-------------------------------------------------------------------------------
 class _VariableInfos(object):
 __slots__ = ["Name", "Class", "Option", "Location", "InitialValue",
 "Edit", "Documentation", "Type", "Tree", "Number"]
 def __init__(self, *args):
 for attr, value in zip(self.__slots__, args):
 setattr(self, attr, value if value is not None else "")
 def copy(self):
 return _VariableInfos(*[getattr(self, attr) for attr in self.__slots__])
 class VariablesInfosFactory:
 def __init__(self, variables):
 self.Variables = variables
 self.TreeStack = []
 self.Type = None
 self.Dimensions = None
 def SetType(self, context, *args):
 self.Type = args[0][0]
 def GetType(self):
 if len(self.Dimensions) > 0:
 return ("array", self.Type, self.Dimensions)
 return self.Type
 def GetTree(self):
 return (self.TreeStack.pop(-1), self.Dimensions)
 def AddDimension(self, context, *args):
 self.Dimensions.append(tuple(
 _translate_args([_StringValue] * 2, args)))
 def AddTree(self, context, *args):
 self.TreeStack.append([])
 self.Dimensions = []
 def AddVarToTree(self, context, *args):
 var = (args[0][0], self.Type, self.GetTree())
 self.TreeStack[-1].append(var)
 def AddVariable(self, context, *args):
 self.Variables.append(_VariableInfos(*(_translate_args(
 [_StringValue] * 5 + [_BoolValue] + [_StringValue], args) +
 [self.GetType(), self.GetTree()])))
 #-------------------------------------------------------------------------------
 #            Helpers object for generating pou variable instance list
 #-------------------------------------------------------------------------------
 "action": ITEM_ACTION,
 "transition": ITEM_TRANSITION,
 "program": ITEM_PROGRAM}.get(value)
 if class_type is not None:
 return class_type
 pou_type = POU_TYPES.get(value)
 if pou_type is not None:
 return pou_type
 var_type = VAR_CLASS_INFOS.get(value)
 if var_type is not None:
 return var_type[1]
 return None
 class _VariablesTreeItemInfos(object):
 __slots__ = ["name", "var_class", "type", "edit", "debug", "variables"]
 def __init__(self, *args):
 setattr(self, attr, value if value is not None else "")
 def copy(self):
 return _VariableTreeItem(*[getattr(self, attr) for attr in self.__slots__])
 class VariablesTreeInfosFactory:
 def __init__(self):
 self.Root = None
 def GetRoot(self):
 return self.Root
 def SetRoot(self, context, *args):
 self.Root = _VariablesTreeItemInfos(
 *([''] + _translate_args(
 [class_extraction, _StringValue] + [_BoolValue] * 2,
 args) + [[]]))
 def AddVariable(self, context, *args):
 if self.Root is not None:
 self.Root.variables.append(_VariablesTreeItemInfos(
 *(_translate_args(
 [_StringValue, class_extraction, _StringValue] +
 [_BoolValue] * 2, args) + [[]])))
 #-------------------------------------------------------------------------------
 #            Helpers object for generating instances path list
 #-------------------------------------------------------------------------------
 class InstancesPathFactory:
 def __init__(self, instances):
 self.Instances = instances
 def AddInstance(self, context, *args):
 self.Instances.append(args[0][0])
 #-------------------------------------------------------------------------------
 #            Helpers object for generating instance tagname
 class InstanceTagName:
 def __init__(self, controller):
 self.Controller = controller
 self.TagName = None
 def GetTagName(self):
 return self.TagName
 def ConfigTagName(self, context, *args):
 self.TagName = self.Controller.ComputeConfigurationName(args[0][0])
 def ResourceTagName(self, context, *args):
 self.TagName = self.Controller.ComputeConfigurationResourceName(args[0][0], args[1][0])
 def PouTagName(self, context, *args):
 self.TagName = self.Controller.ComputePouName(args[0][0])
 #           Helpers object for generating pou block instances list
 #-------------------------------------------------------------------------------
 _Point = namedtuple("Point", ["x", "y"])
 _BlockInstanceInfos = namedtuple("BlockInstanceInfos",
 ["type", "id", "x", "y", "width", "height", "specific_values", "inputs", "outputs"])
 _BlockSpecificValues = (
 namedtuple("BlockSpecificValues",
 ["name", "execution_order"]),
 [_StringValue, int])
 _VariableSpecificValues = (
 namedtuple("VariableSpecificValues",
 ["name", "value_type", "execution_order"]),
 [_StringValue, _StringValue, int])
 _ConnectionSpecificValues = (
 namedtuple("ConnectionSpecificValues", ["name"]),
 [_StringValue])
 _PowerRailSpecificValues = (
 namedtuple("PowerRailSpecificValues", ["connectors"]),
 [int])
 _LDElementSpecificValues = (
 namedtuple("LDElementSpecificValues",
 ["name", "negated", "edge", "storage", "execution_order"]),
 [_StringValue, _BoolValue, _StringValue, _StringValue, int])
 _DivergenceSpecificValues = (
 namedtuple("DivergenceSpecificValues", ["connectors"]),
 "coil": _LDElementSpecificValues,
 "step": (
 namedtuple("StepSpecificValues", ["name", "initial", "action"]),
 [_StringValue, _BoolValue, lambda x: x]),
 "transition": (
 namedtuple("TransitionSpecificValues",
 ["priority", "condition_type", "condition", "connection"]),
 [int, _StringValue, _StringValue, lambda x: x]),
 "selectionDivergence": _DivergenceSpecificValues,
 "selectionConvergence": _DivergenceSpecificValues,
 "simultaneousDivergence": _DivergenceSpecificValues,
 setattr(self, attr, value if value is not None else "")
 def copy(self):
 return _ActionInfos(*[getattr(self, attr) for attr in self.__slots__])
 class BlockInstanceFactory:
 def __init__(self, block_instances):
 self.BlockInstances = block_instances
 self.CurrentInstance = None
 self.SpecificValues = None
 self.CurrentConnection = None
 self.CurrentLink = None
 def SetSpecificValues(self, context, *args):
 self.SpecificValues = list(args)
 self.CurrentInstance = None
 self.CurrentConnection = None
 self.CurrentLink = None
 def AddBlockInstance(self, context, *args):
 specific_values_tuple, specific_values_translation = \
 _SpecificValuesTuples.get(args[0][0], _BlockSpecificValues)
 if (args[0][0] == "step" and len(self.SpecificValues) < 3 or
 args[0][0] == "transition" and len(self.SpecificValues) < 4):
 self.SpecificValues.append([None])
 elif args[0][0] == "actionBlock" and len(self.SpecificValues) < 1:
 self.SpecificValues.append([[]])
 specific_values = specific_values_tuple(*_translate_args(
 specific_values_translation, self.SpecificValues))
 self.SpecificValues = None
 self.CurrentInstance = _BlockInstanceInfos(
 *(_translate_args([_StringValue, int] + [float] * 4, args) +
 [specific_values, [], []]))
 self.BlockInstances[self.CurrentInstance.id] = self.CurrentInstance
 def AddInstanceConnection(self, context, *args):
 connection_args = _translate_args(
 [_StringValue] * 2 + [_BoolValue, _StringValue] + [float] * 2, args)
 self.CurrentConnection = _InstanceConnectionInfos(
 *(connection_args[1:4] + [
 _Point(*connection_args[4:6]), []]))
 if self.CurrentInstance is not None:
 if connection_args[0] == "input":
 self.CurrentInstance.inputs.append(self.CurrentConnection)
 else:
 self.CurrentInstance.outputs.append(self.CurrentConnection)
 else:
 self.SpecificValues.append([self.CurrentConnection])
 def AddConnectionLink(self, context, *args):
 self.CurrentLink = _ConnectionLinkInfos(
 *(_translate_args([int, _StringValue], args) + [[]]))
 self.CurrentConnection.links.append(self.CurrentLink)
 def AddLinkPoint(self, context, *args):
 self.CurrentLink.points.append(_Point(
 *_translate_args([float] * 2, args)))
 def AddAction(self, context, *args):
 if len(self.SpecificValues) == 0:
 self.SpecificValues.append([[]])
 translated_args = _translate_args([_StringValue] * 5, args)
 self.SpecificValues[0][0].append(_ActionInfos(*translated_args))
 pou_block_instances_xslt = etree.parse(
 os.path.join(ScriptDirectory, "plcopen", "pou_block_instances.xslt"))
 #-------------------------------------------------------------------------------
 #                         Undo Buffer for PLCOpenEditor
 # Initialising index of state saved
 if issaved:
 self.LastSave = 0
 else:
 self.LastSave = -1
 # Add a new state in buffer
 def Buffering(self, currentstate):
 self.CurrentIndex = (self.CurrentIndex + 1) % UNDO_BUFFER_LENGTH
 self.Buffer[self.CurrentIndex] = currentstate
 # Actualising buffer limits
 # If the removed state was the state saved, there is no state saved in the buffer
 if self.LastSave == self.MinIndex:
 self.LastSave = -1
 self.MinIndex = (self.MinIndex + 1) % UNDO_BUFFER_LENGTH
 self.MinIndex = max(self.MinIndex, 0)
 # Return current state of buffer
 def Current(self):
 return self.Buffer[self.CurrentIndex]
 # Change current state to previous in buffer and return new current state
 def Previous(self):
 if self.CurrentIndex != self.MinIndex:
 self.CurrentIndex = (self.CurrentIndex - 1) % UNDO_BUFFER_LENGTH
 return self.Buffer[self.CurrentIndex]
 return None
 # Change current state to next in buffer and return new current state
 def Next(self):
 if self.CurrentIndex != self.MaxIndex:
 self.CurrentIndex = (self.CurrentIndex + 1) % UNDO_BUFFER_LENGTH
 return self.Buffer[self.CurrentIndex]
 return None
 # Return True if current state is the first in buffer
 def IsFirst(self):
 return self.CurrentIndex == self.MinIndex
 # Return True if current state is the last in buffer
 def IsLast(self):
 return self.CurrentIndex == self.MaxIndex
 # Note that current state is saved
 def CurrentSaved(self):
 self.LastSave = self.CurrentIndex
 # Return True if current state is saved
 def IsCurrentSaved(self):
 return self.LastSave == self.CurrentIndex
 """
 Class which controls the operations made on the plcopen model and answers to view requests
 """
 class PLCControler:
 # Create a new PLCControler
 def __init__(self):
 self.LastNewIndex = 0
 self.Reset()
 # Reset PLCControler internal variables
 def Reset(self):
 self.Project = None
 self.ProjectBufferEnabled = True
 self.ProjectBuffer = None
 self.CurrentCompiledProject = None
 self.ConfNodeTypes = []
 self.TotalTypesDict = StdBlckDct.copy()
 self.TotalTypes = StdBlckLst[:]
 self.ProgramFilePath = ""
 def GetQualifierTypes(self):
 return QualifierList
 def GetProject(self, debug = False):
 if debug and self.CurrentCompiledProject is not None:
 self.Project = PLCOpenParser.CreateRoot()
 properties["creationDateTime"] = datetime.datetime(*localtime()[:6])
 self.Project.setfileHeader(properties)
 self.Project.setcontentHeader(properties)
 self.SetFilePath("")
 # Initialize the project buffer
 self.CreateProjectBuffer(False)
 self.ProgramChunks = []
 self.ProgramOffset = 0
 self.NextCompiledProject = self.Copy(self.Project)
 self.CurrentCompiledProject = None
 self.Buffering = False
 # Return project data type names
 def GetProjectDataTypeNames(self, debug = False):
 project = self.GetProject(debug)
 if project is not None:
 return [datatype.getname() for datatype in project.getdataTypes()]
 return []
 # Return project pou names
 def GetProjectPouNames(self, debug = False):
 project = self.GetProject(debug)
 if project is not None:
 return [pou.getname() for pou in project.getpous()]
 return []
 # Return project pou names
 def GetProjectConfigNames(self, debug = False):
 project = self.GetProject(debug)
 if project is not None:
 return [config.getname() for config in project.getconfigurations()]
 return []
 # Return project pou variable names
 def GetProjectPouVariableNames(self, pou_name = None, debug = False):
 variables = []
 project = self.GetProject(debug)
 if project is not None:
 for transition in pou.gettransitionList():
 variables.append(transition.getname())
 for action in pou.getactionList():
 variables.append(action.getname())
 return variables
 # Return file path if project is an open file
 def GetFilePath(self):
 return self.FilePath
 # Return file path if project is an open file
 def GetProgramFilePath(self):
 return self.ProgramFilePath
 # Return file name and point out if file is up to date
 def GetFilename(self):
 if self.Project is not None:
 if self.ProjectIsSaved():
 return self.FileName
 else:
 return "~%s~"%self.FileName
 return ""
 # Change file path and save file name or create a default one if file path not defined
 def SetFilePath(self, filepath):
 self.FilePath = filepath
 if filepath == "":
 self.LastNewIndex += 1
 self.FileName = _("Unnamed%d")%self.LastNewIndex
 else:
 self.FileName = os.path.splitext(os.path.basename(filepath))[0]
 # Change project properties
 def SetProjectProperties(self, name = None, properties = None, buffer = True):
 if self.Project is not None:
 if name is not None:
 self.Project.setname(name)
 if properties is not None:
 self.Project.setfileHeader(properties)
 self.Project.setcontentHeader(properties)
 if buffer and (name is not None or properties is not None):
 self.BufferProject()
 # Return project name
 def GetProjectName(self, debug=False):
 project = self.GetProject(debug)
 if project is not None:
 return project.getname()
 return None
 # Return project properties
 def GetProjectProperties(self, debug = False):
 project = self.GetProject(debug)
 if project is not None:
 properties = project.getfileHeader()
 properties.update(project.getcontentHeader())
 return properties
 return None
 # Return project informations
 def GetProjectInfos(self, debug = False):
 project = self.GetProject(debug)
 if project is not None:
 infos = {"name": project.getname(), "type": ITEM_PROJECT}
 datatypes = {"name": DATA_TYPES, "type": ITEM_DATATYPES, "values":[]}
 for datatype in project.getdataTypes():
 datatypes["values"].append({"name": datatype.getname(), "type": ITEM_DATATYPE,
 "tagname": self.ComputeDataTypeName(datatype.getname()), "values": []})
 pou_types = {"function": {"name": FUNCTIONS, "type": ITEM_FUNCTION, "values":[]},
 "functionBlock": {"name": FUNCTION_BLOCKS, "type": ITEM_FUNCTIONBLOCK, "values":[]},
 "program": {"name": PROGRAMS, "type": ITEM_PROGRAM, "values":[]}}
 for pou in project.getpous():
 "tagname": self.ComputePouName(pou.getname())}
 pou_values = []
 if pou.getbodyType() == "SFC":
 transitions = []
 for transition in pou.gettransitionList():
 transitions.append({"name": transition.getname(), "type": ITEM_TRANSITION,
 "tagname": self.ComputePouTransitionName(pou.getname(), transition.getname()),
 "values": []})
 pou_values.append({"name": TRANSITIONS, "type": ITEM_TRANSITIONS, "values": transitions})
 actions = []
 for action in pou.getactionList():
 actions.append({"name": action.getname(), "type": ITEM_ACTION,
 "tagname": self.ComputePouActionName(pou.getname(), action.getname()),
 "values": []})
 pou_values.append({"name": ACTIONS, "type": ITEM_ACTIONS, "values": actions})
 if pou_type in pou_types:
 pou_infos["values"] = pou_values
 pou_types[pou_type]["values"].append(pou_infos)
 configurations = {"name": CONFIGURATIONS, "type": ITEM_CONFIGURATIONS, "values": []}
 for config in project.getconfigurations():
 config_name = config.getname()
 config_infos = {"name": config_name, "type": ITEM_CONFIGURATION,
 "tagname": self.ComputeConfigurationName(config.getname()),
 "values": []}
 resources = {"name": RESOURCES, "type": ITEM_RESOURCES, "values": []}
 for resource in config.getresource():
 resource_name = resource.getname()
 resource_infos = {"name": resource_name, "type": ITEM_RESOURCE,
 "tagname": self.ComputeConfigurationResourceName(config.getname(), resource.getname()),
 "values": []}
 resources["values"].append(resource_infos)
 config_infos["values"] = [resources]
 configurations["values"].append(config_infos)
 infos["values"] = [datatypes, pou_types["function"], pou_types["functionBlock"],
 pou_types["program"], configurations]
 return infos
 return None
 def GetPouVariables(self, tagname, debug = False):
 pou_type = None
 project = self.GetProject(debug)
 if project is not None:
 factory = VariablesTreeInfosFactory()
 parser = etree.XMLParser()
 parser.resolvers.add(LibraryResolver(self, debug))
 pou_variable_xslt_tree = etree.XSLT(
 etree.parse(
 os.path.join(ScriptDirectory, "plcopen", "pou_variables.xslt"),
 parser),
 extensions = {("pou_vars_ns", name): getattr(factory, name)
 for name in ["SetRoot", "AddVariable"]})
 obj = None
 words = tagname.split("::")
 if words[0] == "P":
 obj = self.GetPou(words[1], debug)
 elif words[0] != "D":
 obj = self.GetEditedElement(tagname, debug)
 if obj is not None:
 pou_variable_xslt_tree(obj)
 return factory.GetRoot()
 return None
 def GetInstanceList(self, root, name, debug = False):
 instances = []
 project = self.GetProject(debug)
 if project is not None:
 factory = InstancesPathFactory(instances)
 parser = etree.XMLParser()
 parser.resolvers.add(LibraryResolver(self, debug))
 instances_path_xslt_tree = etree.XSLT(
 etree.parse(
 os.path.join(ScriptDirectory, "plcopen", "instances_path.xslt"),
 parser),
 extensions = {
 ("instances_ns", "AddInstance"): factory.AddInstance})
 instances_path_xslt_tree(root,
 instance_type=etree.XSLT.strparam(name))
 return instances
 def SearchPouInstances(self, tagname, debug = False):
 project = self.GetProject(debug)
 if project is not None:
 words = tagname.split("::")
 if words[0] == "P":
 elif words[0] in ['T', 'A']:
 return ["%s.%s" % (instance, words[2])
 for instance in self.SearchPouInstances(
 self.ComputePouName(words[1]), debug)]
 return []
 def GetPouInstanceTagName(self, instance_path, debug = False):
 project = self.GetProject(debug)
 factory = InstanceTagName(self)
 parser = etree.XMLParser()
 parser.resolvers.add(LibraryResolver(self, debug))
 instance_tagname_xslt_tree = etree.XSLT(
 etree.parse(
 os.path.join(ScriptDirectory, "plcopen", "instance_tagname.xslt"),
 parser),
 extensions = {("instance_tagname_ns", name): getattr(factory, name)
 for name in ["ConfigTagName", "ResourceTagName",
 "PouTagName", "ActionTagName",
 "TransitionTagName"]})
 instance_tagname_xslt_tree(project,
 instance_path=etree.XSLT.strparam(instance_path))
 return factory.GetTagName()
 def GetInstanceInfos(self, instance_path, debug = False):
 tagname = self.GetPouInstanceTagName(instance_path)
 if tagname is not None:
 infos = self.GetPouVariables(tagname, debug)
 infos.type = tagname
 pou_infos = self.GetPouVariables(tagname, debug)
 for var_infos in pou_infos.variables:
 if var_infos.name == var_name:
 return var_infos
 return None
 # Return if data type given by name is used by another data type or pou
 def DataTypeIsUsed(self, name, debug = False):
 project = self.GetProject(debug)
 if project is not None:
 return len(self.GetInstanceList(project, name, debug)) > 0
 infos.append((chunk_infos, (row, col)))
 if next_row == to_location[0] and next_col > to_location[1] or next_row > to_location[0]:
 return infos
 row, col = next_row, next_col
 return infos
 #-------------------------------------------------------------------------------
 #                        Project Pous management functions
 #-------------------------------------------------------------------------------
 # Add a Data Type to Project
 def ProjectAddDataType(self, datatype_name=None):
 if self.Project is not None:
 if datatype_name is None:
 datatype_name = self.GenerateNewName(None, None, "datatype%d")
 # Add the datatype to project
 self.Project.appenddataType(datatype_name)
 self.BufferProject()
 return self.ComputeDataTypeName(datatype_name)
 return None
 # Remove a Data Type from project
 def ProjectRemoveDataType(self, datatype_name):
 if self.Project is not None:
 self.Project.removedataType(datatype_name)
 self.BufferProject()
 # Add a Pou to Project
 def ProjectAddPou(self, pou_name, pou_type, body_type):
 if self.Project is not None:
 # Add the pou to project
 self.Project.appendpou(pou_name, pou_type, body_type)
 if pou_type == "function":
 self.SetPouInterfaceReturnType(pou_name, "BOOL")
 self.BufferProject()
 return self.ComputePouName(pou_name)
 return None
 def ProjectChangePouType(self, name, pou_type):
 if self.Project is not None:
 pou = self.Project.getpou(name)
 if pou is not None:
 pou.setpouType(pou_type)
 self.BufferProject()
 def GetPouXml(self, pou_name):
 if self.Project is not None:
 pou = self.Project.getpou(pou_name)
 if pou is not None:
 return pou.tostring()
 return None
 def PastePou(self, pou_type, pou_xml):
 '''
 Adds the POU defined by 'pou_xml' to the current project with type 'pou_type'
 '''
 try:
 new_pou, error = LoadPou(pou_xml)
 except:
 error = ""
 if error is not None:
 return _("Couldn't paste non-POU object.")
 name = new_pou.getname()
 idx = 0
 new_name = name
-while self.Project.getpou(new_name):
+while self.Project.getpou(new_name) is not None:
 # a POU with that name already exists.
 # make a new name and test if a POU with that name exists.
 # append an incrementing numeric suffix to the POU name.
 idx += 1
 new_name = "%s%d" % (name, idx)
 # we've found a name that does not already exist, use it
 new_pou.setname(new_name)
 if pou_type is not None:
 orig_type = new_pou.getpouType()
 # prevent violations of POU content restrictions:
 # function blocks cannot be pasted as functions,
 # programs cannot be pasted as functions or function blocks
 if orig_type == 'functionBlock' and pou_type == 'function' or \
 orig_type == 'program' and pou_type in ['function', 'functionBlock']:
 return _('''%s "%s" can't be pasted as a %s.''') % (orig_type, name, pou_type)
 new_pou.setpouType(pou_type)
-self.Project.insertpou(-1, new_pou)
+self.Project.insertpou(0, new_pou)
 self.BufferProject()
 return self.ComputePouName(new_name),
 # Remove a Pou from project
 def ProjectRemovePou(self, pou_name):
 if self.Project is not None:
 self.Project.removepou(pou_name)
 self.BufferProject()
 # Return the name of the configuration if only one exist
 def GetProjectMainConfigurationName(self):
 if self.Project is not None:
 # Found the configuration corresponding to old name and change its name to new name
 configurations = self.Project.getconfigurations()
 if len(configurations) == 1:
 return configurations[0].getname()
 return None
 # Add a configuration to Project
 def ProjectAddConfiguration(self, config_name=None):
 if self.Project is not None:
 if config_name is None:
 config_name = self.GenerateNewName(None, None, "configuration%d")
 self.Project.addconfiguration(config_name)
 self.BufferProject()
 return self.ComputeConfigurationName(config_name)
 return None
 # Remove a configuration from project
 def ProjectRemoveConfiguration(self, config_name):
 if self.Project is not None:
 self.Project.removeconfiguration(config_name)
 self.BufferProject()
 # Add a resource to a configuration of the Project
 def ProjectAddConfigurationResource(self, config_name, resource_name=None):
 if self.Project is not None:
 if resource_name is None:
 resource_name = self.GenerateNewName(None, None, "resource%d")
 self.Project.addconfigurationResource(config_name, resource_name)
 self.BufferProject()
 return self.ComputeConfigurationResourceName(config_name, resource_name)
 return None
 # Remove a resource from a configuration of the project
 def ProjectRemoveConfigurationResource(self, config_name, resource_name):
 if self.Project is not None:
 self.Project.removeconfigurationResource(config_name, resource_name)
 self.BufferProject()
 # Add a Transition to a Project Pou
 def ProjectAddPouTransition(self, pou_name, transition_name, transition_type):
 if self.Project is not None:
 pou = self.Project.getpou(pou_name)
 if pou is not None:
 pou.addtransition(transition_name, transition_type)
 self.BufferProject()
 return self.ComputePouTransitionName(pou_name, transition_name)
 return None
 # Remove a Transition from a Project Pou
 def ProjectRemovePouTransition(self, pou_name, transition_name):
 # Search if the pou removed is currently opened
 if self.Project is not None:
 pou = self.Project.getpou(pou_name)
 if pou is not None:
 pou.removetransition(transition_name)
 self.BufferProject()
 # Add an Action to a Project Pou
 def ProjectAddPouAction(self, pou_name, action_name, action_type):
 if self.Project is not None:
 pou = self.Project.getpou(pou_name)
 if pou is not None:
 pou.addaction(action_name, action_type)
 self.BufferProject()
 return self.ComputePouActionName(pou_name, action_name)
 return None
 # Remove an Action from a Project Pou
 def ProjectRemovePouAction(self, pou_name, action_name):
 # Search if the pou removed is currently opened
 if self.Project is not None:
 pou = self.Project.getpou(pou_name)
 if pou is not None:
 pou.removeaction(action_name)
 self.BufferProject()
 # Change the name of a pou
 def ChangeDataTypeName(self, old_name, new_name):
 if self.Project is not None:
 # Found the pou corresponding to old name and change its name to new name
 datatype = self.Project.getdataType(old_name)
 if datatype is not None:
 datatype.setname(new_name)
 self.Project.updateElementName(old_name, new_name)
 self.BufferProject()
 # Change the name of a pou
 def ChangePouName(self, old_name, new_name):
 if self.Project is not None:
 # Found the pou corresponding to old name and change its name to new name
 pou = self.Project.getpou(old_name)
 if pou is not None:
 pou.setname(new_name)
 self.Project.updateElementName(old_name, new_name)
 self.BufferProject()
 # Change the name of a pou transition
 def ChangePouTransitionName(self, pou_name, old_name, new_name):
 if self.Project is not None:
 # Found the pou transition corresponding to old name and change its name to new name
 pou = self.Project.getpou(pou_name)
 transition = pou.gettransition(old_name)
 if transition is not None:
 transition.setname(new_name)
 pou.updateElementName(old_name, new_name)
 self.BufferProject()
 # Change the name of a pou action
 def ChangePouActionName(self, pou_name, old_name, new_name):
 if self.Project is not None:
 # Found the pou action corresponding to old name and change its name to new name
 pou = self.Project.getpou(pou_name)
 action = pou.getaction(old_name)
 if action is not None:
 action.setname(new_name)
 pou.updateElementName(old_name, new_name)
 self.BufferProject()
 # Change the name of a pou variable
 def ChangePouVariableName(self, pou_name, old_name, new_name):
 if self.Project is not None:
 # Found the pou action corresponding to old name and change its name to new name
 pou = self.Project.getpou(pou_name)
 for type, varlist in pou.getvars():
 for var in varlist.getvariable():
 if var.getname() == old_name:
 var.setname(new_name)
 self.BufferProject()
 # Change the name of a configuration
 def ChangeConfigurationName(self, old_name, new_name):
 if self.Project is not None:
 # Found the configuration corresponding to old name and change its name to new name
 configuration = self.Project.getconfiguration(old_name)
 if configuration is not None:
 configuration.setname(new_name)
 self.BufferProject()
 # Change the name of a configuration resource
 def ChangeConfigurationResourceName(self, config_name, old_name, new_name):
 if self.Project is not None:
 # Found the resource corresponding to old name and change its name to new name
 resource = self.Project.getconfigurationResource(config_name, old_name)
 if resource is not None:
 resource.setname(new_name)
 self.BufferProject()
 # Return the description of the pou given by its name
 def GetPouDescription(self, name, debug = False):
 project = self.GetProject(debug)
 if project is not None:
 # Found the pou correponding to name and return its type
 pou = project.getpou(name)
 if pou is not None:
 return pou.getdescription()
 return ""
 # Return the description of the pou given by its name
 def SetPouDescription(self, name, description, debug = False):
 project = self.GetProject(debug)
 if project is not None:
 # Found the pou correponding to name and return its type
 pou = project.getpou(name)
 if pou is not None:
 pou.setdescription(description)
 self.BufferProject()
 # Return the type of the pou given by its name
 def GetPouType(self, name, debug = False):
 project = self.GetProject(debug)
 if project is not None:
 # Found the pou correponding to name and return its type
 pou = project.getpou(name)
 if pou is not None:
 return pou.getpouType()
 return None
 # Return pous with SFC language
 def GetSFCPous(self, debug = False):
 list = []
 project = self.GetProject(debug)
 if project is not None:
 for pou in project.getpous():
 if pou.getBodyType() == "SFC":
 list.append(pou.getname())
 return list
 # Return the body language of the pou given by its name
 def GetPouBodyType(self, name, debug = False):
 project = self.GetProject(debug)
 if project is not None:
 # Found the pou correponding to name and return its body language
 pou = project.getpou(name)
 if pou is not None:
 return pou.getbodyType()
 return None
 # Return the actions of a pou
 def GetPouTransitions(self, pou_name, debug = False):
 transitions = []
 project = self.GetProject(debug)
 if project is not None:
 pou = project.getpou(pou_name)
 if pou is not None and pou.getbodyType() == "SFC":
 for transition in pou.gettransitionList():
 transitions.append(transition.getname())
 return transitions
 # Return the body language of the transition given by its name
 def GetTransitionBodyType(self, pou_name, pou_transition, debug = False):
 project = self.GetProject(debug)
 if project is not None:
 # Found the pou correponding to name
 # Found the pou transition correponding to name and return its body language
 transition = pou.gettransition(pou_transition)
 if transition is not None:
 return transition.getbodyType()
 return None
 # Return the actions of a pou
 def GetPouActions(self, pou_name, debug = False):
 actions = []
 project = self.GetProject(debug)
 if project is not None:
 pou = project.getpou(pou_name)
 if pou.getbodyType() == "SFC":
 for action in pou.getactionList():
 actions.append(action.getname())
 return actions
 # Return the body language of the pou given by its name
 def GetActionBodyType(self, pou_name, pou_action, debug = False):
 project = self.GetProject(debug)
 if project is not None:
 # Found the pou correponding to name and return its body language
 if pou is not None:
 action = pou.getaction(pou_action)
 if action is not None:
 return action.getbodyType()
 return None
 # Extract varlists from a list of vars
 def ExtractVarLists(self, vars):
 varlist_list = []
 current_varlist = None
 current_type = None
 for var in vars:
 next_type = (var.Class,
 var.Option,
 var.Location in ["", None] or
 # When declaring globals, located
 # and not located variables are
 # in the same declaration block
 var.Class == "Global")
 if current_type != next_type:
 current_type = next_type
 infos = VAR_CLASS_INFOS.get(var.Class, None)
 elif var.Option == "Non-Retain":
 current_varlist.setnonretain(True)
 # Create variable and change its properties
 tempvar = PLCOpenParser.CreateElement("variable", "varListPlain")
 tempvar.setname(var.Name)
 var_type = PLCOpenParser.CreateElement("type", "variable")
 if isinstance(var.Type, TupleType):
 if var.Type[0] == "array":
 array_type, base_type_name, dimensions = var.Type
 array = PLCOpenParser.CreateElement("array", "dataType")
 tempvar.setdocumentation(ft)
 # Add variable to varList
 current_varlist.appendvariable(tempvar)
 return varlist_list
 def GetVariableDictionary(self, object_with_vars, tree=False, debug=False):
 variables = []
 factory = VariablesInfosFactory(variables)
 parser = etree.XMLParser()
 parser.resolvers.add(LibraryResolver(self, debug))
 variables_infos_xslt_tree = etree.XSLT(
 etree.parse(
 os.path.join(ScriptDirectory, "plcopen", "variables_infos.xslt"),
 parser),
 extensions = {("var_infos_ns", name): getattr(factory, name)
 for name in ["SetType", "AddDimension", "AddTree",
 "AddVarToTree", "AddVariable"]})
 variables_infos_xslt_tree(object_with_vars,
 tree=etree.XSLT.strparam(str(tree)))
 return variables
 # Add a global var to configuration to configuration
 def AddConfigurationGlobalVar(self, config_name, var_type, var_name,
 location="", description=""):
 if self.Project is not None:
 # Found the configuration corresponding to name
 configuration = self.Project.getconfiguration(config_name)
 if configuration is not None:
 # Set configuration global vars
 configuration.addglobalVar(
 self.GetVarTypeObject(var_type),
 var_name, location, description)
 # Replace the configuration globalvars by those given
 def SetConfigurationGlobalVars(self, name, vars):
 if self.Project is not None:
 if configuration is not None:
 # Set configuration global vars
 configuration.setglobalVars([
 varlist for vartype, varlist
 in self.ExtractVarLists(vars)])
 # Return the configuration globalvars
 def GetConfigurationGlobalVars(self, name, debug = False):
 project = self.GetProject(debug)
 if project is not None:
 # Found the configuration corresponding to name
 configuration = project.getconfiguration(name)
 if configuration is not None:
 # Extract variables defined in configuration
 return self.GetVariableDictionary(configuration, debug)
 return []
 # Return configuration variable names
 def GetConfigurationVariableNames(self, config_name = None, debug = False):
 variables = []
 if project is not None:
 for configuration in self.Project.getconfigurations():
 if config_name is None or config_name == configuration.getname():
 variables.extend(
 [var.getname() for var in reduce(
 lambda x, y: x + y, [varlist.getvariable()
 for varlist in configuration.globalVars],
 [])])
 return variables
 # Replace the resource globalvars by those given
 # Set resource global vars
 if resource is not None:
 resource.setglobalVars([
 varlist for vartype, varlist
 in self.ExtractVarLists(vars)])
 # Return the resource globalvars
 def GetConfigurationResourceGlobalVars(self, config_name, name, debug = False):
 project = self.GetProject(debug)
 if project is not None:
 # Found the resource corresponding to name
 resource = project.getconfigurationResource(config_name, name)
 if resource is not None:
 # Extract variables defined in configuration
 return self.GetVariableDictionary(resource, debug)
 return []
 # Return resource variable names
 def GetConfigurationResourceVariableNames(self,
 config_name = None, resource_name = None, debug = False):
 variables = []
 project = self.GetProject(debug)
 if project is not None:
 for configuration in self.Project.getconfigurations():
 if config_name is None or config_name == configuration.getname():
 for resource in configuration.getresource():
 if resource_name is None or resource.getname() == resource_name:
 variables.extend(
 [var.getname() for var in reduce(
 lambda x, y: x + y, [varlist.getvariable()
 for varlist in resource.globalVars],
 [])])
 return variables
 # Return the interface for the given pou
 if pou is not None:
 if pou.interface is None:
 pou.interface = PLCOpenParser.CreateElement("interface", "pou")
 # Set Pou interface
 pou.setvars([varlist for varlist_type, varlist in self.ExtractVarLists(vars)])
 # Replace the return type of the pou given by its name (only for functions)
 def SetPouInterfaceReturnType(self, name, return_type):
 if self.Project is not None:
 pou = self.Project.getpou(name)
 if pou is not None:
 else return_type, "dataType"))
 else:
 derived_type = PLCOpenParser.CreateElement("derived", "dataType")
 derived_type.setname(return_type)
 return_type.setcontent(derived_type)
 def UpdateProjectUsedPous(self, old_name, new_name):
 if self.Project is not None:
 self.Project.updateElementName(old_name, new_name)
 def UpdateEditedElementUsedVariable(self, tagname, old_name, new_name):
 pou = self.GetEditedElement(tagname)
 if pou is not None:
 pou.updateElementName(old_name, new_name)
 # Return the return type of the given pou
 def GetPouInterfaceReturnType(self, pou, tree=False, debug=False):
 # Verify that the pou has an interface
 if pou.interface is not None:
 # Return the return type if there is one
 return_type = pou.interface.getreturnType()
 if return_type is not None:
 factory = VariablesInfosFactory([])
 parser = etree.XMLParser()
 parser.resolvers.add(LibraryResolver(self))
 return_type_infos_xslt_tree = etree.XSLT(
 etree.parse(
 os.path.join(ScriptDirectory, "plcopen", "variables_infos.xslt"),
 parser),
 extensions = {("var_infos_ns", name): getattr(factory, name)
 for name in ["SetType", "AddDimension",
 "AddTree", "AddVarToTree"]})
 return_type_infos_xslt_tree(return_type,
 tree=etree.XSLT.strparam(str(tree)))
 if tree:
 return [factory.GetType(), factory.GetTree()]
 return factory.GetType()
 if tree:
 return [None, ([], [])]
 return None
 # Function that add a new confnode to the confnode list
 self.TotalTypes.extend(addedcat)
 for cat in addedcat:
 for desc in cat["list"]:
 BlkLst = self.TotalTypesDict.setdefault(desc["name"],[])
 BlkLst.append((section["name"], desc))
 # Function that clear the confnode list
 def ClearConfNodeTypes(self):
 self.ConfNodeTypes = []
 self.TotalTypesDict = StdBlckDct.copy()
 self.TotalTypes = StdBlckLst[:]
 def GetConfNodeDataTypes(self, exclude = None, only_locatables = False):
 return [{"name": _("%s Data Types") % confnodetypes["name"],
 "list": [
 datatype.getname()
 for datatype in confnodetypes["types"].getdataTypes()
 if not only_locatables or self.IsLocatableDataType(datatype, debug)]}
 for confnodetypes in self.ConfNodeTypes]
 def GetVariableLocationTree(self):
 return []
 def GetConfNodeGlobalInstances(self):
 return []
 def GetConfigurationExtraVariables(self):
 global_vars = []
 for var_name, var_type, var_initial in self.GetConfNodeGlobalInstances():
 tempvar = PLCOpenParser.CreateElement("variable", "globalVars")
 tempvar.setname(var_name)
 tempvartype = PLCOpenParser.CreateElement("type", "variable")
 if var_type in self.GetBaseTypes():
 tempvartype.setcontent(PLCOpenParser.CreateElement(
 var_type.lower()
 if var_type in ["STRING", "WSTRING"]
 else:
 tempderivedtype = PLCOpenParser.CreateElement("derived", "dataType")
 tempderivedtype.setname(var_type)
 tempvartype.setcontent(tempderivedtype)
 tempvar.settype(tempvartype)
 if var_initial != "":
 value = PLCOpenParser.CreateElement("initialValue", "variable")
 value.setvalue(var_initial)
 tempvar.setinitialValue(value)
 global_vars.append(tempvar)
 return global_vars
 # Function that returns the block definition associated to the block type given
 def GetBlockType(self, typename, inputs = None, debug = False):
 blocktype = project.getpou(typename)
 if blocktype is not None:
 blocktype_infos = blocktype.getblockInfos()
 if inputs in [None, "undefined"]:
 return blocktype_infos
 if inputs == tuple([var_type
 for name, var_type, modifier in blocktype_infos["inputs"]]):
 return blocktype_infos
 return None
 # Return Block types checking for recursion
 def GetBlockTypes(self, tagname = "", debug = False):
 typename = None
 if project is not None:
 pou_type = None
 if words[0] in ["P","T","A"]:
 name = words[1]
 pou_type = self.GetPouType(name, debug)
 filter = (["function"]
 if pou_type == "function" or words[0] == "T"
 else ["functionBlock", "function"])
 blocktypes = [
 {"name": category["name"],
 "list": [block for block in category["list"]
 if block["type"] in filter]}
 for category in self.TotalTypes]
 blocktypes.append({"name" : USER_DEFINED_POUS,
 "list": [pou.getblockInfos()
 for pou in project.getpous(name, filter)
 if (name is None or
 len(self.GetInstanceList(pou, name, debug)) == 0)]})
 return blocktypes
 return self.TotalTypes
 # Return Function Block types checking for recursion
 if block["type"] == "functionBlock":
 blocktypes.append(block["name"])
 if project is not None:
 blocktypes.extend([pou.getname()
 for pou in project.getpous(name, ["functionBlock"])
 if (name is None or
 len(self.GetInstanceList(pou, name, debug)) == 0)])
 return blocktypes
 # Return Block types checking for recursion
 def GetBlockResource(self, debug = False):
 if project is not None:
 words = tagname.split("::")
 if words[0] in ["D"]:
 name = words[1]
 datatypes.extend([
 datatype.getname()
 for datatype in project.getdataTypes(name)
 if (not only_locatables or self.IsLocatableDataType(datatype, debug))
 and (name is None or
 len(self.GetInstanceList(datatype, name, debug)) == 0)])
 if confnodetypes:
 for category in self.GetConfNodeDataTypes(name, only_locatables):
 datatypes.extend(category["list"])
 return datatypes
 # Return Base Type of given possible derived type
 def GetBaseType(self, typename, debug = False):
 if TypeHierarchy.has_key(typename):
 return typename
 datatype = self.GetDataType(typename, debug)
 if datatype is not None:
 basetype = self.GetDataTypeBaseType(datatype)
 if basetype is not None:
 return self.GetBaseType(basetype, debug)
 return typename
 return None
 def GetBaseTypes(self):
 '''
 return the list of datatypes defined in IEC 61131-3.
 return [x for x,y in TypeHierarchy_list if not x.startswith("ANY")]
 def IsOfType(self, typename, reference, debug = False):
 if reference is None or typename == reference:
 return True
 basetype = TypeHierarchy.get(typename)
 if basetype is not None:
 return self.IsOfType(basetype, reference)
 datatype = self.GetDataType(typename, debug)
 if datatype is not None:
 basetype = self.GetDataTypeBaseType(datatype)
 if basetype is not None:
 return self.IsOfType(basetype, reference, debug)
 return False
 def IsEndType(self, typename):
 if typename is not None:
 return not typename.startswith("ANY")
 return True
 elif basetype_content_type == "array":
 array_base_type = basetype_content.baseType.getcontent()
 if array_base_type.getLocalTag() == "derived":
 return self.IsLocatableType(array_base_type.getname(), debug)
 return True
 def IsLocatableType(self, typename, debug = False):
 if isinstance(typename, TupleType) or self.GetBlockType(typename) is not None:
 return False
 datatype = self.GetDataType(typename, debug)
 if datatype is not None:
 return self.IsLocatableDataType(datatype)
 return True
 def IsEnumeratedType(self, typename, debug = False):
 if isinstance(typename, TupleType):
 typename = typename[1]
 datatype = self.GetDataType(typename, debug)
 if datatype is not None:
 return False
 def IsNumType(self, typename, debug = False):
 return self.IsOfType(typename, "ANY_NUM", debug) or\
 self.IsOfType(typename, "ANY_BIT", debug)
 def GetDataTypeRange(self, typename, debug = False):
 range = DataTypeRange.get(typename)
 if range is not None:
 return range
 datatype = self.GetDataType(typename, debug)
 return (basetype_content.range.getlower(),
 basetype_content.range.getupper())
 elif basetype_content_type == "derived":
 return self.GetDataTypeRange(basetype_content.getname(), debug)
 return None
 # Return Subrange types
 def GetSubrangeBaseTypes(self, exclude, debug = False):
 subrange_basetypes = DataTypeRange.keys()
 project = self.GetProject(debug)
 if project is not None:
 for confnodetype in self.ConfNodeTypes:
 subrange_basetypes.extend(
 [datatype.getname() for datatype in confnodetype["types"].getdataTypes()
 if self.IsSubrangeType(datatype.getname(), exclude, debug)])
 return subrange_basetypes
 # Return Enumerated Values
 def GetEnumeratedDataValues(self, typename = None, debug = False):
 values = []
 if typename is not None:
 datatype_obj = self.GetDataType(typename, debug)
 if datatype_obj is not None:
 basetype_content = datatype_obj.baseType.getcontent()
 basetype_content_type = basetype_content.getLocalTag()
 if basetype_content_type == "enum":
 return [value.getname()
 for value in basetype_content.xpath(
 "ppx:values/ppx:value",
 namespaces=PLCOpenParser.NSMAP)]
 elif basetype_content_type == "derived":
 return self.GetEnumeratedDataValues(basetype_content.getname(), debug)
 return values
 #-------------------------------------------------------------------------------
 #                   Project Element tag name computation functions
 #-------------------------------------------------------------------------------
 # Compute a data type name
 def ComputeDataTypeName(self, datatype):
 return "D::%s" % datatype
 # Compute a pou name
 def ComputePouName(self, pou):
 return "P::%s" % pou
 # Compute a pou transition name
 def ComputePouTransitionName(self, pou, transition):
 return "T::%s::%s" % (pou, transition)
 # Compute a pou action name
 def ComputePouActionName(self, pou, action):
 return "A::%s::%s" % (pou, action)
 # Compute a pou  name
 def ComputeConfigurationResourceName(self, config, resource):
 return "R::%s::%s" % (config, resource)
 def GetElementType(self, tagname):
 words = tagname.split("::")
 return {"D" : ITEM_DATATYPE, "P" : ITEM_POU,
 "T" : ITEM_TRANSITION, "A" : ITEM_ACTION,
 "C" : ITEM_CONFIGURATION, "R" : ITEM_RESOURCE}[words[0]]
 #-------------------------------------------------------------------------------
 #                    Project opened Data types management functions
 dimensions = []
 for dimension in element_type.getdimension():
 dimensions.append((dimension.getlower(), dimension.getupper()))
 base_type = element_type.baseType.getcontent()
 base_type_type = element_type.getLocalTag()
 element_infos["Type"] = ("array",
 base_type.getname()
 if base_type_type == "derived"
 else base_type_type.upper(), dimensions)
 elif element_type_type == "derived":
 element_infos["Type"] = element_type.getname()
 else:
 infos["type"] = "Directly"
 infos["base_type"] = (basetype_content.getname()
 if basetype_content_type == "derived"
 else basetype_content_type.upper())
 if datatype.initialValue is not None:
 infos["initial"] = str(datatype.initialValue.getvalue())
 else:
 infos["initial"] = ""
 return infos
 return None
 # Change the data type informations
 def SetDataTypeInfos(self, tagname, infos):
 words = tagname.split("::")
 if self.Project is not None and words[0] == "D":
 datatype = self.Project.getdataType(words[1])
 derived_datatype = PLCOpenParser.CreateElement("derived", "dataType")
 derived_datatype.setname(infos["base_type"])
 datatype.baseType.setcontent(derived_datatype)
 elif infos["type"] == "Subrange":
 subrange = PLCOpenParser.CreateElement(
 "subrangeUnsigned"
 if infos["base_type"] in GetSubTypes("ANY_UINT")
 else "subrangeSigned", "dataType")
 datatype.baseType.setcontent(subrange)
 subrange.range.setlower(infos["min"])
 subrange.range.setupper(infos["max"])
 datatype.initialValue = PLCOpenParser.CreateElement("initialValue", "dataType")
 datatype.initialValue.setvalue(infos["initial"])
 else:
 datatype.initialValue = None
 self.BufferProject()
 #-------------------------------------------------------------------------------
 #                       Project opened Pous management functions
 #-------------------------------------------------------------------------------
 # Return edited element
 elif words[0] == 'C':
 return project.getconfiguration(words[1])
 elif words[0] == 'R':
 return project.getconfigurationResource(words[1], words[2])
 return None
 # Return edited element name
 def GetEditedElementName(self, tagname):
 words = tagname.split("::")
 if words[0] in ["P","C","D"]:
 return words[1]
 else:
 return words[2]
 return None
 # Return edited element name and type
 def GetEditedElementType(self, tagname, debug = False):
 words = tagname.split("::")
 if words[0] in ["P","T","A"]:
 return words[1], self.GetPouType(words[1], debug)
 if pou is not None:
 return self.GetPouInterfaceReturnType(pou, tree, debug)
 elif words[0] == 'T':
 return "BOOL"
 return None
 # Change the edited element text
 def SetEditedElementText(self, tagname, text):
 if self.Project is not None:
 element = self.GetEditedElement(tagname)
 if element is not None:
 element.settext(text)
 # Return the edited element text
 def GetEditedElementText(self, tagname, debug = False):
 element = self.GetEditedElement(tagname, debug)
 if element is not None:
 return element.gettext()
 def GetEditedElementCopy(self, tagname, debug = False):
 element = self.GetEditedElement(tagname, debug)
 if element is not None:
 return element.tostring()
 return ""
 def GetEditedElementInstancesCopy(self, tagname, blocks_id = None, wires = None, debug = False):
 element = self.GetEditedElement(tagname, debug)
 text = ""
 if element is not None:
 wires = dict([(wire, True)
 for wire in wires
 if wire[0] in blocks_id and wire[1] in blocks_id])
 copy_body = PLCOpenParser.CreateElement("body", "pou")
 element.append(copy_body)
 copy_body.setcontent(
 PLCOpenParser.CreateElement(element.getbodyType(), "body"))
 instance_copy = copy_body.getcontentInstance(id)
 instance_copy.filterConnections(wires)
 text += instance_copy.tostring()
 element.remove(copy_body)
 return text
 def GenerateNewName(self, tagname, name, format, start_idx=0, exclude={}, debug=False):
 names = exclude.copy()
 if tagname is not None:
 names.update(dict([(varname.upper(), True)
 for varname in self.GetEditedElementVariables(tagname, debug)]))
 words = tagname.split("::")
 if words[0] in ["P","T","A"]:
 element = self.GetEditedElement(tagname, debug)
 if element is not None and element.getbodyType() not in ["ST", "IL"]:
 for instance in element.getinstances():
 if isinstance(instance,
 (PLCOpenParser.GetElementClass("step", "sfcObjects"),
 PLCOpenParser.GetElementClass("connector", "commonObjects"),
 PLCOpenParser.GetElementClass("continuation", "commonObjects"))):
 names[instance.getname().upper()] = True
 else:
 project = self.GetProject(debug)
 if project is not None:
 names[action.getname().upper()] = True
 for config in project.getconfigurations():
 names[config.getname().upper()] = True
 for resource in config.getresource():
 names[resource.getname().upper()] = True
 i = start_idx
 while name is None or names.get(name.upper(), False):
 name = (format%i)
 i += 1
 return name
 def PasteEditedElementInstances(self, tagname, text, new_pos, middle=False, debug=False):
 element = self.GetEditedElement(tagname, debug)
 element_name, element_type = self.GetEditedElementType(tagname, debug)
 if element is not None:
 bodytype = element.getbodyType()
 # Get edited element type scaling
 scaling = None
 project = self.GetProject(debug)
 if project is not None:
 properties = project.getcontentHeader()
 scaling = properties["scaling"][bodytype]
 # Get ids already by all the instances in edited element
 used_id = dict([(instance.getlocalId(), True) for instance in element.getinstances()])
 new_id = {}
 try:
 instances, error = LoadPouInstances(text.encode("utf-8"), bodytype)
 except:
 instances, error = [], ""
 if error is not None or len(instances) == 0:
 return _("Invalid plcopen element(s)!!!")
 exclude = {}
 for instance in instances:
 element.addinstance(instance)
 instance_type = instance.getLocalTag()
 if instance_type == "block":
 blocktype_infos = self.GetBlockType(blocktype)
 blockname = instance.getinstanceName()
 if blocktype_infos["type"] != "function" and blockname is not None:
 if element_type == "function":
 return _("FunctionBlock \"%s\" can't be pasted in a Function!!!")%blocktype
 blockname = self.GenerateNewName(tagname,
 blockname,
 "%s%%d"%blocktype,
 debug=debug)
 exclude[blockname] = True
 instance.setinstanceName(blockname)
 self.AddEditedElementPouVar(tagname, blocktype, blockname)
 elif instance_type == "step":
 stepname = self.GenerateNewName(tagname,
 instance.getname(),
 "Step%d",
 exclude=exclude,
 debug=debug)
 exclude[stepname] = True
 instance.setname(stepname)
 localid = instance.getlocalId()
 if not used_id.has_key(localid):
 new_id[localid] = True
 idx = 1
 translate_id = {}
 bbox = rect()
 for instance in instances:
 localId = instance.getlocalId()
 while used_id.has_key(idx) or new_id.has_key(idx):
 idx += 1
 new_id[idx] = True
 instance.setlocalId(idx)
 translate_id[localId] = idx
 x, y, width, height = bbox.bounding_box()
 if middle:
 new_pos[0] -= width / 2
 new_pos[1] -= height / 2
 else:
 new_pos = (max(minx, round(new_pos[0] / scaling[0]) * scaling[0]),
 max(miny, round(new_pos[1] / scaling[1]) * scaling[1]))
 else:
 new_pos = (max(30, new_pos[0]), max(30, new_pos[1]))
 diff = (int(new_pos[0] - x), int(new_pos[1] - y))
 connections = {}
 for instance in instances:
 connections.update(instance.updateConnectionsId(translate_id))
 if getattr(instance, "setexecutionOrderId", None) is not None:
 instance.setexecutionOrderId(0)
 instance.translate(*diff)
 return new_id, connections
 def GetEditedElementInstancesInfos(self, tagname, debug = False):
 element_instances = OrderedDict()
 element = self.GetEditedElement(tagname, debug)
 if element is not None:
 factory = BlockInstanceFactory(element_instances)
 pou_block_instances_xslt_tree = etree.XSLT(
 pou_block_instances_xslt,
 extensions = {
 ("pou_block_instances_ns", name): getattr(factory, name)
 for name in ["AddBlockInstance", "SetSpecificValues",
 "AddInstanceConnection", "AddConnectionLink",
 "AddLinkPoint", "AddAction"]})
 pou_block_instances_xslt_tree(element)
 return element_instances
 def ClearEditedElementExecutionOrder(self, tagname):
 element = self.GetEditedElement(tagname)
 if element is not None:
 element.resetexecutionOrder()
 def ResetEditedElementExecutionOrder(self, tagname):
 element = self.GetEditedElement(tagname)
 if element is not None:
 element.compileexecutionOrder()
 def SetConnectionWires(self, connection, connector):
 wires = connector.GetWires()
 idx = 0
 for wire, handle in wires:
 points = wire.GetPoints(handle != 0)
 if formalParameter != "":
 connection.setconnectionParameter(idx, formalParameter)
 else:
 connection.setconnectionParameter(idx, None)
 idx += 1
 def GetVarTypeObject(self, var_type):
 var_type_obj = PLCOpenParser.CreateElement("type", "variable")
 if not var_type.startswith("ANY") and TypeHierarchy.get(var_type):
 var_type_obj.setcontent(PLCOpenParser.CreateElement(
 var_type.lower() if var_type in ["STRING", "WSTRING"]
 else:
 derived_type = PLCOpenParser.CreateElement("derived", "dataType")
 derived_type.setname(var_type)
 var_type_obj.setcontent(derived_type)
 return var_type_obj
 def AddEditedElementPouVar(self, tagname, var_type, name,**args):
 if self.Project is not None:
 words = tagname.split("::")
 if words[0] in ['P', 'T', 'A']:
 pou = self.Project.getpou(words[1])
 if pou is not None:
 pou.addpouLocalVar(
 self.GetVarTypeObject(var_type),
 name, **args)
 def AddEditedElementPouExternalVar(self, tagname, var_type, name):
 if self.Project is not None:
 words = tagname.split("::")
 if words[0] in ['P', 'T', 'A']:
 pou = self.Project.getpou(words[1])
 if pou is not None:
 pou.addpouExternalVar(
 self.GetVarTypeObject(var_type), name)
 def ChangeEditedElementPouVar(self, tagname, old_type, old_name, new_type, new_name):
 if self.Project is not None:
 words = tagname.split("::")
 if words[0] in ['P', 'T', 'A']:
 pou = self.Project.getpou(words[1])
 if pou is not None:
 pou.changepouVar(old_type, old_name, new_type, new_name)
 def RemoveEditedElementPouVar(self, tagname, type, name):
 if self.Project is not None:
 words = tagname.split("::")
 if words[0] in ['P', 'T', 'A']:
 pou = self.Project.getpou(words[1])
 if pou is not None:
 pou.removepouVar(type, name)
 def AddEditedElementBlock(self, tagname, id, blocktype, blockname = None):
 element = self.GetEditedElement(tagname)
 if element is not None:
 block = PLCOpenParser.CreateElement("block", "fbdObjects")
 block.setlocalId(id)
 blocktype_infos = self.GetBlockType(blocktype)
 if blocktype_infos["type"] != "function" and blockname is not None:
 block.setinstanceName(blockname)
 self.AddEditedElementPouVar(tagname, blocktype, blockname)
 element.addinstance(block)
 def SetEditedElementBlockInfos(self, tagname, id, infos):
 element = self.GetEditedElement(tagname)
 if element is not None:
 block = element.getinstance(id)
 if block is None:
 return
 old_name = block.getinstanceName()
 old_type = block.gettypeName()
 new_name = infos.get("name", old_name)
 new_type = infos.get("type", old_type)
 if new_type != old_type:
 variable.setedge(connector.GetEdge())
 position = connector.GetRelPosition()
 variable.addconnectionPointOut()
 variable.connectionPointOut.setrelPositionXY(position.x, position.y)
 block.tostring()
 def AddEditedElementVariable(self, tagname, id, var_type):
 element = self.GetEditedElement(tagname)
 if element is not None:
 variable = PLCOpenParser.CreateElement(
 {INPUT: "inVariable",
 OUTPUT: "outVariable",
 INOUT: "inOutVariable"}[var_type], "fbdObjects")
 variable.setlocalId(id)
 element.addinstance(variable)
 def SetEditedElementVariableInfos(self, tagname, id, infos):
 element = self.GetEditedElement(tagname)
 if element is not None:
 variable = element.getinstance(id)
 if variable is None:
 return
 for param, value in infos.items():
 if param == "name":
 variable.setexpression(value)
 elif param == "executionOrder" and variable.getexecutionOrderId() != value:
 element.setelementExecutionOrder(variable, value)
 connection = PLCOpenParser.CreateElement(
 {CONNECTOR: "connector",
 CONTINUATION: "continuation"}[connection_type], "commonObjects")
 connection.setlocalId(id)
 element.addinstance(connection)
 def SetEditedElementConnectionInfos(self, tagname, id, infos):
 element = self.GetEditedElement(tagname)
 if element is not None:
 connection = element.getinstance(id)
 if connection is None:
 return
 for param, value in infos.items():
 if param == "name":
 connection.setname(value)
 elif param == "height":
 connection.setheight(value)
 elif param == "width":
 connection.setwidth(value)
 elif param == "x":
 element = self.GetEditedElement(tagname)
 if element is not None:
 comment = PLCOpenParser.CreateElement("comment", "commonObjects")
 comment.setlocalId(id)
 element.addinstance(comment)
 def SetEditedElementCommentInfos(self, tagname, id, infos):
 element = self.GetEditedElement(tagname)
 if element is not None:
 comment = element.getinstance(id)
 for param, value in infos.items():
 powerrail = PLCOpenParser.CreateElement(
 {LEFTRAIL: "leftPowerRail",
 RIGHTRAIL: "rightPowerRail"}[powerrail_type], "ldObjects")
 powerrail.setlocalId(id)
 element.addinstance(powerrail)
 def SetEditedElementPowerRailInfos(self, tagname, id, infos):
 element = self.GetEditedElement(tagname)
 if element is not None:
 powerrail = element.getinstance(id)
 if powerrail is None:
 position = connector.GetRelPosition()
 connection = PLCOpenParser.CreateElement("connectionPointIn", "rightPowerRail")
 powerrail.appendconnectionPointIn(connection)
 connection.setrelPositionXY(position.x, position.y)
 self.SetConnectionWires(connection, connector)
 def AddEditedElementContact(self, tagname, id):
 element = self.GetEditedElement(tagname)
 if element is not None:
 contact = PLCOpenParser.CreateElement("contact", "ldObjects")
 contact.setlocalId(id)
 element = self.GetEditedElement(tagname)
 if element is not None:
 step = PLCOpenParser.CreateElement("step", "sfcObjects")
 step.setlocalId(id)
 element.addinstance(step)
 def SetEditedElementStepInfos(self, tagname, id, infos):
 element = self.GetEditedElement(tagname)
 if element is not None:
 step = element.getinstance(id)
 if step is None:
 position = value.GetRelPosition()
 step.addconnectionPointOutAction()
 step.connectionPointOutAction.setrelPositionXY(position.x, position.y)
 else:
 step.deleteconnectionPointOutAction()
 def AddEditedElementTransition(self, tagname, id):
 element = self.GetEditedElement(tagname)
 if element is not None:
 transition = PLCOpenParser.CreateElement("transition", "sfcObjects")
 transition.setlocalId(id)
 element.addinstance(transition)
 def SetEditedElementTransitionInfos(self, tagname, id, infos):
 element = self.GetEditedElement(tagname)
 if element is not None:
 transition = element.getinstance(id)
 if transition is None:
 transition.addconnectionPointOut()
 transition.connectionPointOut.setrelPositionXY(position.x, position.y)
 elif infos.get("type", None) == "connection" and param == "connection" and value:
 transition.setconditionContent("connection", None)
 self.SetConnectionWires(transition.condition.content, value)
 def AddEditedElementDivergence(self, tagname, id, divergence_type):
 element = self.GetEditedElement(tagname)
 if element is not None:
 divergence = PLCOpenParser.CreateElement(
 {SELECTION_DIVERGENCE: "selectionDivergence",
 SIMULTANEOUS_DIVERGENCE: "simultaneousDivergence",
 SIMULTANEOUS_CONVERGENCE: "simultaneousConvergence"}.get(
 divergence_type), "sfcObjects")
 divergence.setlocalId(id)
 element.addinstance(divergence)
 DivergenceTypes = [
 (divergence_type,
 PLCOpenParser.GetElementClass(divergence_type, "sfcObjects"))
 for divergence_type in ["selectionDivergence", "simultaneousDivergence",
 "selectionConvergence", "simultaneousConvergence"]]
 def GetDivergenceType(self, divergence):
 for divergence_type, divergence_class in self.DivergenceTypes:
 if isinstance(divergence, divergence_class):
 return divergence_type
 return None
 def SetEditedElementDivergenceInfos(self, tagname, id, infos):
 element = self.GetEditedElement(tagname)
 if element is not None:
 divergence = element.getinstance(id)
 if divergence is None:
 for output_connector in output_connectors:
 position = output_connector.GetRelPosition()
 connection = PLCOpenParser.CreateElement("connectionPointOut", divergence_type)
 divergence.appendconnectionPointOut(connection)
 connection.setrelPositionXY(position.x, position.y)
 def AddEditedElementJump(self, tagname, id):
 element = self.GetEditedElement(tagname)
 if element is not None:
 jump = PLCOpenParser.CreateElement("jumpStep", "sfcObjects")
 jump.setlocalId(id)
 element.addinstance(jump)
 def SetEditedElementJumpInfos(self, tagname, id, infos):
 element = self.GetEditedElement(tagname)
 if element is not None:
 jump = element.getinstance(id)
 if jump is None:
 elif param == "connector":
 position = value.GetRelPosition()
 jump.addconnectionPointIn()
 jump.connectionPointIn.setrelPositionXY(position.x, position.y)
 self.SetConnectionWires(jump.connectionPointIn, value)
 def AddEditedElementActionBlock(self, tagname, id):
 element = self.GetEditedElement(tagname)
 if element is not None:
 actionBlock = PLCOpenParser.CreateElement("actionBlock", "commonObjects")
 actionBlock.setlocalId(id)
 element.addinstance(actionBlock)
 def SetEditedElementActionBlockInfos(self, tagname, id, infos):
 element = self.GetEditedElement(tagname)
 if element is not None:
 actionBlock = element.getinstance(id)
 if actionBlock is None:
 elif param == "connector":
 position = value.GetRelPosition()
 actionBlock.addconnectionPointIn()
 actionBlock.connectionPointIn.setrelPositionXY(position.x, position.y)
 self.SetConnectionWires(actionBlock.connectionPointIn, value)
 def RemoveEditedElementInstance(self, tagname, id):
 element = self.GetEditedElement(tagname)
 if element is not None:
 instance = element.getinstance(id)
 if isinstance(instance, PLCOpenParser.GetElementClass("block", "fbdObjects")):
 self.NextCompiledProject = self.Copy(self.Project)
 self.CurrentCompiledProject = None
 self.Buffering = False
 self.CurrentElementEditing = None
 return error
 def SaveXMLFile(self, filepath = None):
 if not filepath and self.FilePath == "":
 return False
 else:
 contentheader = {"modificationDateTime": datetime.datetime(*localtime()[:6])}
 self.Project.setcontentHeader(contentheader)
 if filepath:
 SaveProject(self.Project, filepath)
 else:
 SaveProject(self.Project, self.FilePath)
 self.MarkProjectAsSaved()
 if filepath:
 self.SetFilePath(filepath)
 return True
 def StartBuffering(self):
 if self.ProjectBuffer is not None:
 self.Buffering = True
 else:
 self.ProjectSaved = False
 def EndBuffering(self):
 if self.ProjectBuffer is not None and self.Buffering:
 self.ProjectBuffer.Buffering(PLCOpenParser.Dumps(self.Project))
 self.Buffering = False
 self.EndBuffering()
 if self.ProjectBuffer is not None:
 self.ProjectBuffer.CurrentSaved()
 else:
 self.ProjectSaved = True
 # Return if project is saved
 def ProjectIsSaved(self):
 if self.ProjectBuffer is not None:
 return self.ProjectBuffer.IsCurrentSaved() and not self.Buffering
 else:
 def LoadPrevious(self):
 self.EndBuffering()
 if self.ProjectBuffer is not None:
 self.Project = PLCOpenParser.Loads(self.ProjectBuffer.Previous())
 def LoadNext(self):
 if self.ProjectBuffer is not None:
 self.Project = PLCOpenParser.Loads(self.ProjectBuffer.Next())
 def GetBufferState(self):
 if self.ProjectBuffer is not None:
 first = self.ProjectBuffer.IsFirst() and not self.Buffering
 last = self.ProjectBuffer.IsLast()
 return not first, not last

changeset 1411	805d13d216c0
parent 1406	82db84fe88ea
child 1418	c97dc5281419