beremiz: comparison PLCControler.py

equal deleted inserted replaced

-:fcca121a000f
+:7856cd7767d6
 var_type = vartype_content.getname()
 if var_type == pou_type:
 instances.append(var_path)
 else:
 pou = project.getpou(var_type)
-if pou is not None and project.ElementIsUsedBy(pou_type, var_type):
+if pou is not None:# and project.ElementIsUsedBy(pou_type, var_type):
 instances.extend(
 self.RecursiveSearchPouInstances(
 project, pou_type, var_path,
 [varlist for type, varlist in pou.getvars()],
 debug))
 pou_path = "%s.%s" % (res_path, pou_instance.getname())
 pou_type = pou_instance.gettypeName()
 if pou_type == words[1]:
 instances.append(pou_path)
 pou = project.getpou(pou_type)
-if pou is not None and project.ElementIsUsedBy(words[1], pou_type):
+if pou is not None:# and project.ElementIsUsedBy(words[1], pou_type):
 instances.extend(
 self.RecursiveSearchPouInstances(
 project, words[1], pou_path,
 [varlist for type, varlist in pou.getvars()],
 debug))
 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)
+#project = self.GetProject(debug)
-if project is not None:
+#if project is not None:
-return project.ElementIsUsed(name)
+#    return project.ElementIsUsed(name)
 return False
 # Return if pou given by name is used by another pou
 def PouIsUsed(self, name, debug = False):
-project = self.GetProject(debug)
+#project = self.GetProject(debug)
-if project is not None:
+#if project is not None:
-return project.ElementIsUsed(name)
+#    return project.ElementIsUsed(name)
 return False
 # Return if pou given by name is directly or undirectly used by the reference pou
 def PouIsUsedBy(self, name, reference, debug = False):
-project = self.GetProject(debug)
+#project = self.GetProject(debug)
-if project is not None:
+#if project is not None:
-return project.ElementIsUsedBy(name, reference)
+#    return project.ElementIsUsedBy(name, reference)
 return False
 def GenerateProgram(self, filepath=None):
 errors = []
 warnings = []
 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.Project.RefreshCustomBlockTypes()
 self.BufferProject()
 def GetPouXml(self, pou_name):
 if self.Project is not None:
 pou = self.Project.getpou(pou_name)
 # 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.Project.RefreshElementUsingTree()
 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.Project.RefreshElementUsingTree()
-self.Project.RefreshCustomBlockTypes()
 self.BufferProject()
 # Change the name of a pou transition
 def ChangePouTransitionName(self, pou_name, old_name, new_name):
 if self.Project is not None:
 if pou is not None:
 for type, varlist in pou.getvars():
 for var in varlist.getvariable():
 if var.getname() == old_name:
 var.setname(new_name)
-self.Project.RefreshCustomBlockTypes()
 self.BufferProject()
 # Change the name of a configuration
 def ChangeConfigurationName(self, old_name, new_name):
 if self.Project is not None:
 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)
-project.RefreshCustomBlockTypes()
 self.BufferProject()
 # Return the type of the pou given by its name
 def GetPouType(self, name, debug = False):
 project = self.GetProject(debug)
 if not eno:
 tree.insert(0, ("ENO", "BOOL", ([], [])))
 if not en:
 tree.insert(0, ("EN", "BOOL", ([], [])))
 return tree, []
-datatype = project.getdataType(typename)
+datatype = self.GetDataType(typename)
-if datatype is None:
-datatype = self.GetConfNodeDataType(typename)
 if datatype is not None:
 tree = []
 basetype_content = datatype.baseType.getcontent()
 basetype_content_type = basetype_content.getLocalTag()
 if basetype_content_type == "derived":
 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)])
-self.Project.RefreshElementUsingTree()
-self.Project.RefreshCustomBlockTypes()
 # 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)
-self.Project.RefreshElementUsingTree()
-self.Project.RefreshCustomBlockTypes()
 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):
 # Function that add a new confnode to the confnode list
 def AddConfNodeTypesList(self, typeslist):
 self.ConfNodeTypes.extend(typeslist)
 addedcat = [{"name": _("%s POUs") % confnodetypes["name"],
-"list": confnodetypes["types"].GetCustomBlockTypes()}
+"list": [pou.getblockInfos()
+for pou in confnodetypes["types"].getpous()]}
 for confnodetypes in typeslist]
 self.TotalTypes.extend(addedcat)
 for cat in addedcat:
 for desc in cat["list"]:
 BlkLst = self.TotalTypesDict.setdefault(desc["name"],[])
 def ClearConfNodeTypes(self):
 self.ConfNodeTypes = []
 self.TotalTypesDict = StdBlckDct.copy()
 self.TotalTypes = StdBlckLst[:]
-def GetConfNodeBlockTypes(self):
-return [{"name": _("%s POUs") % confnodetypes["name"],
-"list": confnodetypes["types"].GetCustomBlockTypes()}
-for confnodetypes in self.ConfNodeTypes]
 def GetConfNodeDataTypes(self, exclude = None, only_locatables = False):
 return [{"name": _("%s Data Types") % confnodetypes["name"],
-"list": [datatype["name"] for datatype in confnodetypes["types"].GetCustomDataTypes(exclude, only_locatables)]}
+"list": [
+datatype.getname()
+for datatype in confnodetypes["types"].getdataTypes()
+if not only_locatables or self.IsLocatableDataType(datatype, debug)]}
 for confnodetypes in self.ConfNodeTypes]
-def GetConfNodeDataType(self, typename):
-for confnodetype in self.ConfNodeTypes:
-datatype = confnodetype["types"].getdataType(typename)
-if datatype is not None:
-return datatype
-return None
 def GetVariableLocationTree(self):
 return []
 def GetConfNodeGlobalInstances(self):
 result_blocktype = blocktype.copy()
 if result_blocktype is not None:
 return result_blocktype
 project = self.GetProject(debug)
 if project is not None:
-return project.GetCustomBlockType(typename, inputs)
+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
 name = None
 project = self.GetProject(debug)
 if project is not None:
 pou_type = None
 if words[0] in ["P","T","A"]:
-blocktypes = []
 name = words[1]
 pou_type = self.GetPouType(name, debug)
-if pou_type == "function":
+filter = (["function"]
-for category in self.TotalTypes:
+if pou_type == "function" or words[0] == "T"
-cat = {"name" : category["name"], "list" : []}
+else ["functionBlock", "function"])
-for block in category["list"]:
+blocktypes = [
-if block["type"] == "function":
+{"name": category["name"],
-cat["list"].append(block)
+"list": [block for block in category["list"]
-if len(cat["list"]) > 0:
+if block["type"] in filter]}
-blocktypes.append(cat)
+for category in self.TotalTypes]
-else:
-blocktypes = [category for category in self.TotalTypes]
 blocktypes.append({"name" : USER_DEFINED_POUS,
-"list": project.GetCustomBlockTypes(name,
+"list": [pou.getblockInfos()
-pou_type == "function" or words[0] == "T")})
+for pou in project.getpous(name, filter)]})
 return blocktypes
 return self.TotalTypes
 # Return Function Block types checking for recursion
 def GetFunctionBlockTypes(self, tagname = "", debug = False):
 for sectioname,block in blocks:
 if block["type"] == "functionBlock":
 blocktypes.append(block["name"])
 project = self.GetProject(debug)
 if project is not None:
-name = ""
 words = tagname.split("::")
-if words[0] in ["P","T","A"]:
+blocktypes.extend([pou.getname()
-name = words[1]
+for pou in project.getpous(
-blocktypes.extend(project.GetCustomFunctionBlockTypes(name))
+words[1] if words[0] in ["P","T","A"] else None,
+["functionBlock"])])
 return blocktypes
 # Return Block types checking for recursion
 def GetBlockResource(self, debug = False):
 blocktypes = []
 for blocktype in category["list"]:
 if blocktype["type"] == "program":
 blocktypes.append(blocktype["name"])
 project = self.GetProject(debug)
 if project is not None:
-blocktypes.extend(project.GetCustomBlockResource())
+blocktypes.extend(
+[pou.getblockInfos()
+for pou in project.getpous(filter=["program"])])
 return blocktypes
 # Return Data Types checking for recursion
 def GetDataTypes(self, tagname = "", basetypes = True, confnodetypes = True, only_locatables = False, debug = False):
 if basetypes:
 name = None
 if project is not None:
 words = tagname.split("::")
 if words[0] in ["D"]:
 name = words[1]
-datatypes.extend([datatype["name"] for datatype in project.GetCustomDataTypes(name, only_locatables)])
+datatypes.extend([
+datatype.getname()
+for datatype in project.getdataTypes(name)
+if not only_locatables or self.IsLocatableDataType(datatype, debug)])
 if confnodetypes:
 for category in self.GetConfNodeDataTypes(name, only_locatables):
 datatypes.extend(category["list"])
 return datatypes
 def IsEndType(self, typename):
 if typename is not None:
 return not typename.startswith("ANY")
 return True
+def IsLocatableDataType(self, datatype, debug = False):
+basetype_content = datatype.baseType.getcontent()
+basetype_content_type = basetype_content.getLocalTag()
+if basetype_content_type in ["enum", "struct"]:
+return False
+elif basetype_content_type == "derived":
+return self.IsLocatableType(basetype_content.getname())
+elif basetype_content_name == "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(type) is not None:
+if isinstance(typename, TupleType) or self.GetBlockType(typename) is not None:
 return False
 datatype = self.GetDataType(typename, debug)
 if datatype is not None:
-basetype_content = datatype.baseType.getcontent()
+return self.IsLocatableDataType(datatype)
-basetype_content_type = basetype_content.getLocalTag()
-if basetype_content_type in ["enum", "struct"]:
-return False
-elif basetype_content_type == "derived":
-return self.IsLocatableType(basetype_content.getname())
-elif basetype_content_name == "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 IsEnumeratedType(self, typename, debug = False):
 datatype = self.GetDataType(typename, debug)
 if datatype is not None:
 if datatype.initialValue is None:
 datatype.initialValue = PLCOpenParser.CreateElement("initialValue", "dataType")
 datatype.initialValue.setvalue(infos["initial"])
 else:
 datatype.initialValue = None
-self.Project.RefreshElementUsingTree()
 self.BufferProject()
 #-------------------------------------------------------------------------------
 #                       Project opened Pous management functions
 #-------------------------------------------------------------------------------
 def SetEditedElementText(self, tagname, text):
 if self.Project is not None:
 element = self.GetEditedElement(tagname)
 if element is not None:
 element.settext(text)
-self.Project.RefreshElementUsingTree()
 # Return the edited element text
 def GetEditedElementText(self, tagname, debug = False):
 element = self.GetEditedElement(tagname, debug)
 if element is not None:
 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)
-self.Project.RefreshElementUsingTree()
 def SetEditedElementBlockInfos(self, tagname, id, infos):
 element = self.GetEditedElement(tagname)
 if element is not None:
 block = element.getinstance(id)
 variable.setedge(connector.GetEdge())
 position = connector.GetRelPosition()
 variable.addconnectionPointOut()
 variable.connectionPointOut.setrelPositionXY(position.x, position.y)
 block.tostring()
-self.Project.RefreshElementUsingTree()
 def AddEditedElementVariable(self, tagname, id, var_type):
 element = self.GetEditedElement(tagname)
 if element is not None:
 variable = PLCOpenParser.CreateElement(
 if element is not None:
 instance = element.getinstance(id)
 if isinstance(instance, PLCOpenParser.GetElementClass("block", "fbdObjects")):
 self.RemoveEditedElementPouVar(tagname, instance.gettypeName(), instance.getinstanceName())
 element.removeinstance(id)
-self.Project.RefreshElementUsingTree()
 def GetEditedResourceVariables(self, tagname, debug = False):
 varlist = []
 words = tagname.split("::")
 for var in self.GetConfigurationGlobalVars(words[1], debug):
 try:
 self.Project = LoadProject(filepath)
 except Exception, e:
 return _("Project file syntax error:\n\n") + str(e)
 self.SetFilePath(filepath)
-self.Project.RefreshElementUsingTree()
-self.Project.RefreshCustomBlockTypes()
 ## To remove when project buffering ready
 self.ProjectBufferEnabled = False
 self.CreateProjectBuffer(True)

changeset 1302	7856cd7767d6
parent 1301	fcca121a000f
child 1304	6be6c1e0e4d0