plcopeneditor_history: comparison PLCControler.py

equal deleted inserted replaced

-:b693147fb2c3
+:c141dad94ff4
 "Input" :    (plcopen.interface_inputVars,    ITEM_VAR_INPUT),
 "Output" :   (plcopen.interface_outputVars,   ITEM_VAR_OUTPUT),
 "InOut" :    (plcopen.interface_inOutVars,    ITEM_VAR_INOUT)
 }
-LOCATIONS_ITEMS = [LOCATION_PLUGIN,
+LOCATIONS_ITEMS = [LOCATION_CONFNODE,
 LOCATION_MODULE,
 LOCATION_GROUP,
 LOCATION_VAR_INPUT,
 LOCATION_VAR_OUTPUT,
 LOCATION_VAR_MEMORY] = range(6)
 self.FileName = ""
 self.ProgramChunks = []
 self.ProgramOffset = 0
 self.NextCompiledProject = None
 self.CurrentCompiledProject = None
-self.PluginTypes = []
+self.ConfNodeTypes = []
 self.ProgramFilePath = ""
 def GetQualifierTypes(self):
 return plcopen.QualifierList
 if not en:
 tree.insert(0, ("EN", "BOOL", ([], [])))
 return tree, []
 datatype = project.getdataType(typename)
 if datatype is None:
-datatype = self.GetPluginDataType(typename)
+datatype = self.GetConfNodeDataType(typename)
 if datatype is not None:
 tree = []
 basetype_content = datatype.baseType.getcontent()
 if basetype_content["name"] == "derived":
 return self.GenerateVarTree(basetype_content["value"].getname())
 return returntype_content["name"].upper()
 else:
 return returntype_content["name"]
 return None
-# Function that add a new plugin to the plugin list
+# Function that add a new confnode to the confnode list
-def AddPluginTypesList(self, typeslist):
+def AddConfNodeTypesList(self, typeslist):
-self.PluginTypes.extend(typeslist)
+self.ConfNodeTypes.extend(typeslist)
-# Function that clear the plugin list
+# Function that clear the confnode list
-def ClearPluginTypes(self):
+def ClearConfNodeTypes(self):
-for i in xrange(len(self.PluginTypes)):
+for i in xrange(len(self.ConfNodeTypes)):
-self.PluginTypes.pop(0)
+self.ConfNodeTypes.pop(0)
-def GetPluginBlockTypes(self):
+def GetConfNodeBlockTypes(self):
-return [{"name": _("%s POUs") % plugintypes["name"],
+return [{"name": _("%s POUs") % confnodetypes["name"],
-"list": plugintypes["types"].GetCustomBlockTypes()}
+"list": confnodetypes["types"].GetCustomBlockTypes()}
-for plugintypes in self.PluginTypes]
+for confnodetypes in self.ConfNodeTypes]
-def GetPluginDataTypes(self, exclude = ""):
+def GetConfNodeDataTypes(self, exclude = ""):
-return [{"name": _("%s Data Types") % plugintypes["name"],
+return [{"name": _("%s Data Types") % confnodetypes["name"],
-"list": [datatype["name"] for datatype in plugintypes["types"].GetCustomDataTypes(exclude)]}
+"list": [datatype["name"] for datatype in confnodetypes["types"].GetCustomDataTypes(exclude)]}
-for plugintypes in self.PluginTypes]
+for confnodetypes in self.ConfNodeTypes]
-def GetPluginDataType(self, type):
+def GetConfNodeDataType(self, type):
-for plugintype in self.PluginTypes:
+for confnodetype in self.ConfNodeTypes:
-datatype = plugintype["types"].getdataType(type)
+datatype = confnodetype["types"].getdataType(type)
 if datatype is not None:
 return datatype
 return None
 def GetVariableLocationTree(self):
 return []
 # Function that returns the block definition associated to the block type given
 def GetBlockType(self, type, inputs = None, debug = False):
 result_blocktype = None
-for category in BlockTypes + self.GetPluginBlockTypes():
+for category in BlockTypes + self.GetConfNodeBlockTypes():
 for blocktype in category["list"]:
 if blocktype["name"] == type:
 if inputs is not None and inputs != "undefined":
 block_inputs = tuple([var_type for name, var_type, modifier in blocktype["inputs"]])
 if reduce(lambda x, y: x and y, map(lambda x: x[0] == "ANY" or self.IsOfType(*x), zip(inputs, block_inputs)), True):
 if words[0] in ["P","T","A"]:
 name = words[1]
 type = self.GetPouType(name, debug)
 if type == "function" or words[0] == "T":
 blocktypes = []
-for category in BlockTypes + self.GetPluginBlockTypes():
+for category in BlockTypes + self.GetConfNodeBlockTypes():
 cat = {"name" : category["name"], "list" : []}
 for block in category["list"]:
 if block["type"] == "function":
 cat["list"].append(block)
 if len(cat["list"]) > 0:
 blocktypes.append(cat)
 else:
-blocktypes = [category for category in BlockTypes + self.GetPluginBlockTypes()]
+blocktypes = [category for category in BlockTypes + self.GetConfNodeBlockTypes()]
 project = self.GetProject(debug)
 if project is not None:
 blocktypes.append({"name" : USER_DEFINED_POUS, "list": project.GetCustomBlockTypes(name, type == "function" or words[0] == "T")})
 return blocktypes
 # Return Function Block types checking for recursion
 def GetFunctionBlockTypes(self, tagname = "", debug = False):
 blocktypes = []
-for category in BlockTypes + self.GetPluginBlockTypes():
+for category in BlockTypes + self.GetConfNodeBlockTypes():
 for block in category["list"]:
 if block["type"] == "functionBlock":
 blocktypes.append(block["name"])
 project = self.GetProject(debug)
 if project is not None:
 project = self.GetProject(debug)
 if project is not None:
 result = project.GetBaseType(type)
 if result is not None:
 return result
-for plugintype in self.PluginTypes:
+for confnodetype in self.ConfNodeTypes:
-result = plugintype["types"].GetBaseType(type)
+result = confnodetype["types"].GetBaseType(type)
 if result is not None:
 return result
 return None
 def GetBaseTypes(self):
 return self.IsOfType(TypeHierarchy[type], reference)
 else:
 project = self.GetProject(debug)
 if project is not None and project.IsOfType(type, reference):
 return True
-for plugintype in self.PluginTypes:
+for confnodetype in self.ConfNodeTypes:
-if plugintype["types"].IsOfType(type, reference):
+if confnodetype["types"].IsOfType(type, reference):
 return True
 return False
 def IsEndType(self, type):
 if type is not None:
 return False
 project = self.GetProject(debug)
 if project is not None:
 datatype = project.getdataType(type)
 if datatype is None:
-datatype = self.GetPluginDataType(type)
+datatype = self.GetConfNodeDataType(type)
 if datatype is not None:
 return project.IsLocatableType(datatype)
 return True
 def IsEnumeratedType(self, type, debug = False):
 project = self.GetProject(debug)
 if project is not None:
 datatype = project.getdataType(type)
 if datatype is None:
-datatype = self.GetPluginDataType(type)
+datatype = self.GetConfNodeDataType(type)
 if datatype is not None:
 basetype_content = datatype.baseType.getcontent()
 return basetype_content["name"] == "enum"
 return False
 project = self.GetProject(debug)
 if project is not None:
 result = project.GetDataTypeRange(type)
 if result is not None:
 return result
-for plugintype in self.PluginTypes:
+for confnodetype in self.ConfNodeTypes:
-result = plugintype["types"].GetDataTypeRange(type)
+result = confnodetype["types"].GetDataTypeRange(type)
 if result is not None:
 return result
 return None
 # Return Subrange types
 def GetSubrangeBaseTypes(self, exclude, debug = False):
 subrange_basetypes = []
 project = self.GetProject(debug)
 if project is not None:
 subrange_basetypes.extend(project.GetSubrangeBaseTypes(exclude))
-for plugintype in self.PluginTypes:
+for confnodetype in self.ConfNodeTypes:
-subrange_basetypes.extend(plugintype["types"].GetSubrangeBaseTypes(exclude))
+subrange_basetypes.extend(confnodetype["types"].GetSubrangeBaseTypes(exclude))
 return DataTypeRange.keys() + subrange_basetypes
 # Return Enumerated Values
 def GetEnumeratedDataValues(self, type = None, debug = False):
 values = []
 project = self.GetProject(debug)
 if project is not None:
 values.extend(project.GetEnumeratedDataTypeValues(type))
 if type is None and len(values) > 0:
 return values
-for plugintype in self.PluginTypes:
+for confnodetype in self.ConfNodeTypes:
-values.extend(plugintype["types"].GetEnumeratedDataTypeValues(type))
+values.extend(confnodetype["types"].GetEnumeratedDataTypeValues(type))
 if type is None and len(values) > 0:
 return values
 return values
 #-------------------------------------------------------------------------------

changeset 681	c141dad94ff4
parent 661	7891872e6fd7
child 684	f10449b18dbe