beremiz: comparison ConfigTree.py

equal deleted inserted replaced

-:1c23952dbde1
+:5d4dc150b956
 class MiniTextControler:
 def __init__(self, filepath):
 self.FilePath = filepath
-def PlugFullName(self):
+def CTNFullName(self):
 return ""
 def SetEditedElementText(self, tagname, text):
 file = open(self.FilePath, "w")
 file.write(text)
 """
 This class is the one that define confnodes.
 """
 XSD = None
-PlugChildsTypes = []
+CTNChildrenTypes = []
-PlugMaxCount = None
+CTNMaxCount = None
 ConfNodeMethods = []
 LibraryControler = None
 EditorType = None
 def _AddParamsMembers(self):
-self.PlugParams = None
+self.CTNParams = None
 if self.XSD:
 self.Classes = GenerateClassesFromXSDstring(self.XSD)
 Classes = [(name, XSDclass) for name, XSDclass in self.Classes.items() if XSDclass.IsBaseClass]
 if len(Classes) == 1:
 name, XSDclass = Classes[0]
 obj = XSDclass()
-self.PlugParams = (name, obj)
+self.CTNParams = (name, obj)
 setattr(self, name, obj)
 def __init__(self):
 # Create BaseParam
 self.BaseParams = _BaseParamsClass()
 self.MandatoryParams = ("BaseParams", self.BaseParams)
 self._AddParamsMembers()
-self.PluggedChilds = {}
+self.Children = {}
 self._View = None
 # copy ConfNodeMethods so that it can be later customized
 self.ConfNodeMethods = [dic.copy() for dic in self.ConfNodeMethods]
 self.LoadSTLibrary()
-def ConfNodeBaseXmlFilePath(self, PlugName=None):
+def ConfNodeBaseXmlFilePath(self, CTNName=None):
-return os.path.join(self.PlugPath(PlugName), "baseconfnode.xml")
+return os.path.join(self.CTNPath(CTNName), "baseconfnode.xml")
-def ConfNodeXmlFilePath(self, PlugName=None):
+def ConfNodeXmlFilePath(self, CTNName=None):
-return os.path.join(self.PlugPath(PlugName), "confnode.xml")
+return os.path.join(self.CTNPath(CTNName), "confnode.xml")
 def ConfNodeLibraryFilePath(self):
 return os.path.join(self.ConfNodePath(), "pous.xml")
 def ConfNodePath(self):
-return os.path.join(self.PlugParent.ConfNodePath(), self.PlugType)
+return os.path.join(self.CTNParent.ConfNodePath(), self.CTNType)
-def PlugPath(self,PlugName=None):
+def CTNPath(self,CTNName=None):
-if not PlugName:
+if not CTNName:
-PlugName = self.PlugName()
+CTNName = self.CTNName()
-return os.path.join(self.PlugParent.PlugPath(),
+return os.path.join(self.CTNParent.CTNPath(),
-PlugName + NameTypeSeparator + self.PlugType)
+CTNName + NameTypeSeparator + self.CTNType)
-def PlugName(self):
+def CTNName(self):
 return self.BaseParams.getName()
-def PlugEnabled(self):
+def CTNEnabled(self):
 return self.BaseParams.getEnabled()
-def PlugFullName(self):
+def CTNFullName(self):
-parent = self.PlugParent.PlugFullName()
+parent = self.CTNParent.CTNFullName()
 if parent != "":
-return parent + "." + self.PlugName()
+return parent + "." + self.CTNName()
 return self.BaseParams.getName()
 def GetIconPath(self, name):
 return opjimg(name)
-def PlugTestModified(self):
+def CTNTestModified(self):
 return self.ChangesToSave
 def ProjectTestModified(self):
 """
 recursively check modified status
 """
-if self.PlugTestModified():
+if self.CTNTestModified():
 return True
-for PlugChild in self.IterChilds():
+for CTNChild in self.IterChildren():
-if PlugChild.ProjectTestModified():
+if CTNChild.ProjectTestModified():
 return True
 return False
 def RemoteExec(self, script, **kwargs):
-return self.PlugParent.RemoteExec(script, **kwargs)
+return self.CTNParent.RemoteExec(script, **kwargs)
-def OnPlugSave(self):
+def OnCTNSave(self):
 #Default, do nothing and return success
 return True
 def GetParamsAttributes(self, path = None):
 if path:
 parts = path.split(".", 1)
 if self.MandatoryParams and parts[0] == self.MandatoryParams[0]:
 return self.MandatoryParams[1].getElementInfos(parts[0], parts[1])
-elif self.PlugParams and parts[0] == self.PlugParams[0]:
+elif self.CTNParams and parts[0] == self.CTNParams[0]:
-return self.PlugParams[1].getElementInfos(parts[0], parts[1])
+return self.CTNParams[1].getElementInfos(parts[0], parts[1])
 else:
 params = []
 if wx.VERSION < (2, 8, 0) and self.MandatoryParams:
 params.append(self.MandatoryParams[1].getElementInfos(self.MandatoryParams[0]))
-if self.PlugParams:
+if self.CTNParams:
-params.append(self.PlugParams[1].getElementInfos(self.PlugParams[0]))
+params.append(self.CTNParams[1].getElementInfos(self.CTNParams[0]))
 return params
 def SetParamsAttribute(self, path, value):
 self.ChangesToSave = True
 # Filter IEC_Channel and Name, that have specific behavior
 if path == "BaseParams.IEC_Channel":
 old_leading = ".".join(map(str, self.GetCurrentLocation()))
 new_value = self.FindNewIEC_Channel(value)
-new_leading = ".".join(map(str, self.PlugParent.GetCurrentLocation() + (new_value,)))
+new_leading = ".".join(map(str, self.CTNParent.GetCurrentLocation() + (new_value,)))
-self.GetPlugRoot().UpdateProjectVariableLocation(old_leading, new_leading)
+self.GetCTRoot().UpdateProjectVariableLocation(old_leading, new_leading)
 return new_value, True
 elif path == "BaseParams.Name":
 res = self.FindNewName(value)
-self.PlugRequestSave()
+self.CTNRequestSave()
 return res, True
 parts = path.split(".", 1)
 if self.MandatoryParams and parts[0] == self.MandatoryParams[0]:
 self.MandatoryParams[1].setElementValue(parts[1], value)
-elif self.PlugParams and parts[0] == self.PlugParams[0]:
+elif self.CTNParams and parts[0] == self.CTNParams[0]:
-self.PlugParams[1].setElementValue(parts[1], value)
+self.CTNParams[1].setElementValue(parts[1], value)
 return value, False
-def PlugMakeDir(self):
+def CTNMakeDir(self):
-os.mkdir(self.PlugPath())
+os.mkdir(self.CTNPath())
-def PlugRequestSave(self):
+def CTNRequestSave(self):
-if self.GetPlugRoot().CheckProjectPathPerm(False):
+if self.GetCTRoot().CheckProjectPathPerm(False):
 # If confnode do not have corresponding directory
-plugpath = self.PlugPath()
+ctnpath = self.CTNPath()
-if not os.path.isdir(plugpath):
+if not os.path.isdir(ctnpath):
 # Create it
-os.mkdir(plugpath)
+os.mkdir(ctnpath)
 # generate XML for base XML parameters controller of the confnode
 if self.MandatoryParams:
 BaseXMLFile = open(self.ConfNodeBaseXmlFilePath(),'w')
 BaseXMLFile.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n")
 BaseXMLFile.write(self.MandatoryParams[1].generateXMLText(self.MandatoryParams[0], 0).encode("utf-8"))
 BaseXMLFile.close()
 # generate XML for XML parameters controller of the confnode
-if self.PlugParams:
+if self.CTNParams:
 XMLFile = open(self.ConfNodeXmlFilePath(),'w')
 XMLFile.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n")
-XMLFile.write(self.PlugParams[1].generateXMLText(self.PlugParams[0], 0).encode("utf-8"))
+XMLFile.write(self.CTNParams[1].generateXMLText(self.CTNParams[0], 0).encode("utf-8"))
 XMLFile.close()
-# Call the confnode specific OnPlugSave method
+# Call the confnode specific OnCTNSave method
-result = self.OnPlugSave()
+result = self.OnCTNSave()
 if not result:
-return _("Error while saving \"%s\"\n")%self.PlugPath()
+return _("Error while saving \"%s\"\n")%self.CTNPath()
 # mark confnode as saved
 self.ChangesToSave = False
-# go through all childs and do the same
+# go through all children and do the same
-for PlugChild in self.IterChilds():
+for CTNChild in self.IterChildren():
-result = PlugChild.PlugRequestSave()
+result = CTNChild.CTNRequestSave()
 if result:
 return result
 return None
-def PlugImport(self, src_PlugPath):
+def CTNImport(self, src_CTNPath):
-shutil.copytree(src_PlugPath, self.PlugPath)
+shutil.copytree(src_CTNPath, self.CTNPath)
 return True
-def PlugGenerate_C(self, buildpath, locations):
+def CTNGenerate_C(self, buildpath, locations):
 """
 Generate C code
 @param locations: List of complete variables locations \
 [{"IEC_TYPE" : the IEC type (i.e. "INT", "STRING", ...)
 "NAME" : name of the variable (generally "__IW0_1_2" style)
 "SIZE" : size "X", "B", "W", "D", "L"
 "LOC" : tuple of interger for IEC location (0,1,2,...)
 }, ...]
 @return: [(C_file_name, CFLAGS),...] , LDFLAGS_TO_APPEND
 """
-self.GetPlugRoot().logger.write_warning(".".join(map(lambda x:str(x), self.GetCurrentLocation())) + " -> Nothing to do\n")
+self.GetCTRoot().logger.write_warning(".".join(map(lambda x:str(x), self.GetCurrentLocation())) + " -> Nothing to do\n")
 return [],"",False
 def _Generate_C(self, buildpath, locations):
 # Generate confnodes [(Cfiles, CFLAGS)], LDFLAGS, DoCalls, extra_files
 # extra_files = [(fname,fobject), ...]
-gen_result = self.PlugGenerate_C(buildpath, locations)
+gen_result = self.CTNGenerate_C(buildpath, locations)
-PlugCFilesAndCFLAGS, PlugLDFLAGS, DoCalls = gen_result[:3]
+CTNCFilesAndCFLAGS, CTNLDFLAGS, DoCalls = gen_result[:3]
 extra_files = gen_result[3:]
 # if some files have been generated put them in the list with their location
-if PlugCFilesAndCFLAGS:
+if CTNCFilesAndCFLAGS:
-LocationCFilesAndCFLAGS = [(self.GetCurrentLocation(), PlugCFilesAndCFLAGS, DoCalls)]
+LocationCFilesAndCFLAGS = [(self.GetCurrentLocation(), CTNCFilesAndCFLAGS, DoCalls)]
 else:
 LocationCFilesAndCFLAGS = []
 # confnode asks for some LDFLAGS
-if PlugLDFLAGS:
+if CTNLDFLAGS:
 # LDFLAGS can be either string
-if type(PlugLDFLAGS)==type(str()):
+if type(CTNLDFLAGS)==type(str()):
-LDFLAGS=[PlugLDFLAGS]
+LDFLAGS=[CTNLDFLAGS]
 #or list of strings
-elif type(PlugLDFLAGS)==type(list()):
+elif type(CTNLDFLAGS)==type(list()):
-LDFLAGS=PlugLDFLAGS[:]
+LDFLAGS=CTNLDFLAGS[:]
 else:
 LDFLAGS=[]
-# recurse through all childs, and stack their results
+# recurse through all children, and stack their results
-for PlugChild in self.IECSortedChilds():
+for CTNChild in self.IECSortedChildren():
-new_location = PlugChild.GetCurrentLocation()
+new_location = CTNChild.GetCurrentLocation()
 # How deep are we in the tree ?
 depth=len(new_location)
 _LocationCFilesAndCFLAGS, _LDFLAGS, _extra_files = \
-PlugChild._Generate_C(
+CTNChild._Generate_C(
 #keep the same path
 buildpath,
 # filter locations that start with current IEC location
 [loc for loc in locations if loc["LOC"][0:depth] == new_location ])
 # stack the result
 return LocationCFilesAndCFLAGS, LDFLAGS, extra_files
 def ConfNodeTypesFactory(self):
 if self.LibraryControler is not None:
-return [{"name" : self.PlugType, "types": self.LibraryControler.Project}]
+return [{"name" : self.CTNType, "types": self.LibraryControler.Project}]
 return []
 def ParentsTypesFactory(self):
-return self.PlugParent.ParentsTypesFactory() + self.ConfNodeTypesFactory()
+return self.CTNParent.ParentsTypesFactory() + self.ConfNodeTypesFactory()
 def ConfNodesTypesFactory(self):
 list = self.ConfNodeTypesFactory()
-for PlugChild in self.IterChilds():
+for CTNChild in self.IterChildren():
-list += PlugChild.ConfNodesTypesFactory()
+list += CTNChild.ConfNodesTypesFactory()
 return list
 def STLibraryFactory(self):
 if self.LibraryControler is not None:
 program, errors, warnings = self.LibraryControler.GenerateProgram()
 return program + "\n"
 return ""
 def ConfNodesSTLibraryFactory(self):
 program = self.STLibraryFactory()
-for PlugChild in self.IECSortedChilds():
+for CTNChild in self.IECSortedChildren():
-program += PlugChild.ConfNodesSTLibraryFactory()
+program += CTNChild.ConfNodesSTLibraryFactory()
 return program
-def IterChilds(self):
+def IterChildren(self):
-for PlugType, PluggedChilds in self.PluggedChilds.items():
+for CTNType, Children in self.Children.items():
-for PlugInstance in PluggedChilds:
+for CTNInstance in Children:
-yield PlugInstance
+yield CTNInstance
-def IECSortedChilds(self):
+def IECSortedChildren(self):
-# reorder childs by IEC_channels
+# reorder children by IEC_channels
-ordered = [(chld.BaseParams.getIEC_Channel(),chld) for chld in self.IterChilds()]
+ordered = [(chld.BaseParams.getIEC_Channel(),chld) for chld in self.IterChildren()]
 if ordered:
 ordered.sort()
 return zip(*ordered)[1]
 else:
 return []
 def _GetChildBySomething(self, something, toks):
-for PlugInstance in self.IterChilds():
+for CTNInstance in self.IterChildren():
 # if match component of the name
-if getattr(PlugInstance.BaseParams, something) == toks[0]:
+if getattr(CTNInstance.BaseParams, something) == toks[0]:
 # if Name have other components
 if len(toks) >= 2:
 # Recurse in order to find the latest object
-return PlugInstance._GetChildBySomething( something, toks[1:])
+return CTNInstance._GetChildBySomething( something, toks[1:])
 # No sub name -> found
-return PlugInstance
+return CTNInstance
 # Not found
 return None
 def GetChildByName(self, Name):
 if Name:
 def GetCurrentLocation(self):
 """
 @return:  Tupple containing confnode IEC location of current confnode : %I0.0.4.5 => (0,0,4,5)
 """
-return self.PlugParent.GetCurrentLocation() + (self.BaseParams.getIEC_Channel(),)
+return self.CTNParent.GetCurrentLocation() + (self.BaseParams.getIEC_Channel(),)
 def GetCurrentName(self):
 """
 @return:  String "ParentParentName.ParentName.Name"
 """
-return  self.PlugParent._GetCurrentName() + self.BaseParams.getName()
+return  self.CTNParent._GetCurrentName() + self.BaseParams.getName()
 def _GetCurrentName(self):
 """
 @return:  String "ParentParentName.ParentName.Name."
 """
-return  self.PlugParent._GetCurrentName() + self.BaseParams.getName() + "."
+return  self.CTNParent._GetCurrentName() + self.BaseParams.getName() + "."
-def GetPlugRoot(self):
+def GetCTRoot(self):
-return self.PlugParent.GetPlugRoot()
+return self.CTNParent.GetCTRoot()
 def GetFullIEC_Channel(self):
 return ".".join([str(i) for i in self.GetCurrentLocation()]) + ".x"
 def GetLocations(self):
 location = self.GetCurrentLocation()
-return [loc for loc in self.PlugParent.GetLocations() if loc["LOC"][0:len(location)] == location]
+return [loc for loc in self.CTNParent.GetLocations() if loc["LOC"][0:len(location)] == location]
 def GetVariableLocationTree(self):
 '''
 This function is meant to be overridden by confnodes.
 - IEC_type is an IEC type like BOOL/BYTE/SINT/...
 - location is a string of this variable's location, like "%IX0.0.0"
 '''
 children = []
-for child in self.IECSortedChilds():
+for child in self.IECSortedChildren():
 children.append(child.GetVariableLocationTree())
 return {"name": self.BaseParams.getName(),
 "type": LOCATION_CONFNODE,
 "location": self.GetFullIEC_Channel(),
 "children": children}
 """
 # Get Current Name
 CurrentName = self.BaseParams.getName()
 # Do nothing if no change
 #if CurrentName == DesiredName: return CurrentName
-# Build a list of used Name out of parent's PluggedChilds
+# Build a list of used Name out of parent's Children
 AllNames=[]
-for PlugInstance in self.PlugParent.IterChilds():
+for CTNInstance in self.CTNParent.IterChildren():
-if PlugInstance != self:
+if CTNInstance != self:
-AllNames.append(PlugInstance.BaseParams.getName())
+AllNames.append(CTNInstance.BaseParams.getName())
 # Find a free name, eventually appending digit
 res = DesiredName
 suffix = 1
 while res in AllNames:
 res = "%s-%d"%(DesiredName, suffix)
 suffix += 1
 # Get old path
-oldname = self.PlugPath()
+oldname = self.CTNPath()
 # Check previous confnode existance
 dontexist = self.BaseParams.getName() == "__unnamed__"
 # Set the new name
 self.BaseParams.setName(res)
 # Rename confnode dir if exist
 if not dontexist:
-shutil.move(oldname, self.PlugPath())
+shutil.move(oldname, self.CTNPath())
 # warn user he has two left hands
 if DesiredName != res:
-self.GetPlugRoot().logger.write_warning(_("A child names \"%s\" already exist -> \"%s\"\n")%(DesiredName,res))
+self.GetCTRoot().logger.write_warning(_("A child names \"%s\" already exist -> \"%s\"\n")%(DesiredName,res))
 return res
 def GetAllChannels(self):
 AllChannels=[]
-for PlugInstance in self.PlugParent.IterChilds():
+for CTNInstance in self.CTNParent.IterChildren():
-if PlugInstance != self:
+if CTNInstance != self:
-AllChannels.append(PlugInstance.BaseParams.getIEC_Channel())
+AllChannels.append(CTNInstance.BaseParams.getIEC_Channel())
 AllChannels.sort()
 return AllChannels
 def FindNewIEC_Channel(self, DesiredChannel):
 """
 """
 # Get Current IEC channel
 CurrentChannel = self.BaseParams.getIEC_Channel()
 # Do nothing if no change
 #if CurrentChannel == DesiredChannel: return CurrentChannel
-# Build a list of used Channels out of parent's PluggedChilds
+# Build a list of used Channels out of parent's Children
 AllChannels = self.GetAllChannels()
 # Now, try to guess the nearest available channel
 res = DesiredChannel
 while res in AllChannels: # While channel not free
 if res < CurrentChannel: # Want to go down ?
 res -=  1 # Test for n-1
 if res < 0 :
-self.GetPlugRoot().logger.write_warning(_("Cannot find lower free IEC channel than %d\n")%CurrentChannel)
+self.GetCTRoot().logger.write_warning(_("Cannot find lower free IEC channel than %d\n")%CurrentChannel)
 return CurrentChannel # Can't go bellow 0, do nothing
 else : # Want to go up ?
 res +=  1 # Test for n-1
 # Finally set IEC Channel
 self.BaseParams.setIEC_Channel(res)
 return res
 def _OpenView(self, name=None):
 if self.EditorType is not None and self._View is None:
-app_frame = self.GetPlugRoot().AppFrame
+app_frame = self.GetCTRoot().AppFrame
 self._View = self.EditorType(app_frame.TabsOpened, self, app_frame)
-app_frame.EditProjectElement(self._View, self.PlugName())
+app_frame.EditProjectElement(self._View, self.CTNName())
 return self._View
 return None
 def OnCloseEditor(self, view):
 if self._View == view:
 self._View = None
-def OnPlugClose(self):
+def OnCTNClose(self):
 if self._View is not None:
-app_frame = self.GetPlugRoot().AppFrame
+app_frame = self.GetCTRoot().AppFrame
 if app_frame is not None:
 app_frame.DeletePage(self._View)
 return True
-def _doRemoveChild(self, PlugInstance):
+def _doRemoveChild(self, CTNInstance):
-# Remove all childs of child
+# Remove all children of child
-for SubPlugInstance in PlugInstance.IterChilds():
+for SubCTNInstance in CTNInstance.IterChildren():
-PlugInstance._doRemoveChild(SubPlugInstance)
+CTNInstance._doRemoveChild(SubCTNInstance)
 # Call the OnCloseMethod
-PlugInstance.OnPlugClose()
+CTNInstance.OnCTNClose()
 # Delete confnode dir
-shutil.rmtree(PlugInstance.PlugPath())
+shutil.rmtree(CTNInstance.CTNPath())
-# Remove child of PluggedChilds
+# Remove child of Children
-self.PluggedChilds[PlugInstance.PlugType].remove(PlugInstance)
+self.Children[CTNInstance.CTNType].remove(CTNInstance)
 # Forget it... (View have to refresh)
-def PlugRemove(self):
+def CTNRemove(self):
 # Fetch the confnode
-#PlugInstance = self.GetChildByName(PlugName)
+#CTNInstance = self.GetChildByName(CTNName)
 # Ask to his parent to remove it
-self.PlugParent._doRemoveChild(self)
+self.CTNParent._doRemoveChild(self)
-def PlugAddChild(self, PlugName, PlugType, IEC_Channel=0):
+def CTNAddChild(self, CTNName, CTNType, IEC_Channel=0):
 """
 Create the confnodes that may be added as child to this node self
-@param PlugType: string desining the confnode class name (get name from PlugChildsTypes)
+@param CTNType: string desining the confnode class name (get name from CTNChildrenTypes)
-@param PlugName: string for the name of the confnode instance
+@param CTNName: string for the name of the confnode instance
 """
-# reorgabize self.PlugChildsTypes tuples from (name, PlugClass, Help)
+# reorgabize self.CTNChildrenTypes tuples from (name, CTNClass, Help)
-# to ( name, (PlugClass, Help)), an make a dict
+# to ( name, (CTNClass, Help)), an make a dict
-transpose = zip(*self.PlugChildsTypes)
+transpose = zip(*self.CTNChildrenTypes)
-PlugChildsTypes = dict(zip(transpose[0],zip(transpose[1],transpose[2])))
+CTNChildrenTypes = dict(zip(transpose[0],zip(transpose[1],transpose[2])))
 # Check that adding this confnode is allowed
 try:
-PlugClass, PlugHelp = PlugChildsTypes[PlugType]
+CTNClass, CTNHelp = CTNChildrenTypes[CTNType]
 except KeyError:
-raise Exception, _("Cannot create child %s of type %s ")%(PlugName, PlugType)
+raise Exception, _("Cannot create child %s of type %s ")%(CTNName, CTNType)
-# if PlugClass is a class factory, call it. (prevent unneeded imports)
+# if CTNClass is a class factory, call it. (prevent unneeded imports)
-if type(PlugClass) == types.FunctionType:
+if type(CTNClass) == types.FunctionType:
-PlugClass = PlugClass()
+CTNClass = CTNClass()
 # Eventualy Initialize child instance list for this class of confnode
-PluggedChildsWithSameClass = self.PluggedChilds.setdefault(PlugType, list())
+ChildrenWithSameClass = self.Children.setdefault(CTNType, list())
 # Check count
-if getattr(PlugClass, "PlugMaxCount", None) and len(PluggedChildsWithSameClass) >= PlugClass.PlugMaxCount:
+if getattr(CTNClass, "CTNMaxCount", None) and len(ChildrenWithSameClass) >= CTNClass.CTNMaxCount:
-raise Exception, _("Max count (%d) reached for this confnode of type %s ")%(PlugClass.PlugMaxCount, PlugType)
+raise Exception, _("Max count (%d) reached for this confnode of type %s ")%(CTNClass.CTNMaxCount, CTNType)
 # create the final class, derived of provided confnode and template
-class FinalPlugClass(PlugClass, ConfigTreeNode):
+class FinalCTNClass(CTNClass, ConfigTreeNode):
 """
-ConfNode class is derivated into FinalPlugClass before being instanciated
+ConfNode class is derivated into FinalCTNClass before being instanciated
 This way __init__ is overloaded to ensure ConfigTreeNode.__init__ is called
-before PlugClass.__init__, and to do the file related stuff.
+before CTNClass.__init__, and to do the file related stuff.
 """
 def __init__(_self):
 # self is the parent
-_self.PlugParent = self
+_self.CTNParent = self
 # Keep track of the confnode type name
-_self.PlugType = PlugType
+_self.CTNType = CTNType
 # remind the help string, for more fancy display
-_self.PlugHelp = PlugHelp
+_self.CTNHelp = CTNHelp
 # Call the base confnode template init - change XSD into class members
 ConfigTreeNode.__init__(_self)
 # check name is unique
-NewPlugName = _self.FindNewName(PlugName)
+NewCTNName = _self.FindNewName(CTNName)
 # If dir have already be made, and file exist
-if os.path.isdir(_self.PlugPath(NewPlugName)): #and os.path.isfile(_self.ConfNodeXmlFilePath(PlugName)):
+if os.path.isdir(_self.CTNPath(NewCTNName)): #and os.path.isfile(_self.ConfNodeXmlFilePath(CTNName)):
 #Load the confnode.xml file into parameters members
-_self.LoadXMLParams(NewPlugName)
+_self.LoadXMLParams(NewCTNName)
 # Basic check. Better to fail immediately.
-if (_self.BaseParams.getName() != NewPlugName):
+if (_self.BaseParams.getName() != NewCTNName):
-raise Exception, _("Project tree layout do not match confnode.xml %s!=%s ")%(NewPlugName, _self.BaseParams.getName())
+raise Exception, _("Project tree layout do not match confnode.xml %s!=%s ")%(NewCTNName, _self.BaseParams.getName())
-# Now, self.PlugPath() should be OK
+# Now, self.CTNPath() should be OK
 # Check that IEC_Channel is not already in use.
 _self.FindNewIEC_Channel(_self.BaseParams.getIEC_Channel())
 # Call the confnode real __init__
-if getattr(PlugClass, "__init__", None):
+if getattr(CTNClass, "__init__", None):
-PlugClass.__init__(_self)
+CTNClass.__init__(_self)
-#Load and init all the childs
+#Load and init all the children
-_self.LoadChilds()
+_self.LoadChildren()
 #just loaded, nothing to saved
 _self.ChangesToSave = False
 else:
 # If confnode do not have corresponding file/dirs - they will be created on Save
-_self.PlugMakeDir()
+_self.CTNMakeDir()
 # Find an IEC number
 _self.FindNewIEC_Channel(IEC_Channel)
 # Call the confnode real __init__
-if getattr(PlugClass, "__init__", None):
+if getattr(CTNClass, "__init__", None):
-PlugClass.__init__(_self)
+CTNClass.__init__(_self)
-_self.PlugRequestSave()
+_self.CTNRequestSave()
 #just created, must be saved
 _self.ChangesToSave = True
 def _getBuildPath(_self):
 return self._getBuildPath()
 # Create the object out of the resulting class
-newConfNodeOpj = FinalPlugClass()
+newConfNodeOpj = FinalCTNClass()
-# Store it in PluggedChils
+# Store it in CTNgedChils
-PluggedChildsWithSameClass.append(newConfNodeOpj)
+ChildrenWithSameClass.append(newConfNodeOpj)
 return newConfNodeOpj
-def ClearPluggedChilds(self):
+def ClearChildren(self):
-for child in self.IterChilds():
+for child in self.IterChildren():
-child.ClearPluggedChilds()
+child.ClearChildren()
-self.PluggedChilds = {}
+self.Children = {}
 def LoadSTLibrary(self):
 # Get library blocks if plcopen library exist
 library_path = self.ConfNodeLibraryFilePath()
 if os.path.isfile(library_path):
 self.LibraryControler = PLCControler()
 self.LibraryControler.OpenXMLFile(library_path)
 self.LibraryControler.ClearConfNodeTypes()
 self.LibraryControler.AddConfNodeTypesList(self.ParentsTypesFactory())
-def LoadXMLParams(self, PlugName = None):
+def LoadXMLParams(self, CTNName = None):
-methode_name = os.path.join(self.PlugPath(PlugName), "methods.py")
+methode_name = os.path.join(self.CTNPath(CTNName), "methods.py")
 if os.path.isfile(methode_name):
 execfile(methode_name)
 # Get the base xml tree
 if self.MandatoryParams:
 try:
-basexmlfile = open(self.ConfNodeBaseXmlFilePath(PlugName), 'r')
+basexmlfile = open(self.ConfNodeBaseXmlFilePath(CTNName), 'r')
 basetree = minidom.parse(basexmlfile)
 self.MandatoryParams[1].loadXMLTree(basetree.childNodes[0])
 basexmlfile.close()
 except Exception, exc:
-self.GetPlugRoot().logger.write_error(_("Couldn't load confnode base parameters %s :\n %s") % (PlugName, str(exc)))
+self.GetCTRoot().logger.write_error(_("Couldn't load confnode base parameters %s :\n %s") % (CTNName, str(exc)))
-self.GetPlugRoot().logger.write_error(traceback.format_exc())
+self.GetCTRoot().logger.write_error(traceback.format_exc())
 # Get the xml tree
-if self.PlugParams:
+if self.CTNParams:
 try:
-xmlfile = open(self.ConfNodeXmlFilePath(PlugName), 'r')
+xmlfile = open(self.ConfNodeXmlFilePath(CTNName), 'r')
 tree = minidom.parse(xmlfile)
-self.PlugParams[1].loadXMLTree(tree.childNodes[0])
+self.CTNParams[1].loadXMLTree(tree.childNodes[0])
 xmlfile.close()
 except Exception, exc:
-self.GetPlugRoot().logger.write_error(_("Couldn't load confnode parameters %s :\n %s") % (PlugName, str(exc)))
+self.GetCTRoot().logger.write_error(_("Couldn't load confnode parameters %s :\n %s") % (CTNName, str(exc)))
-self.GetPlugRoot().logger.write_error(traceback.format_exc())
+self.GetCTRoot().logger.write_error(traceback.format_exc())
-def LoadChilds(self):
+def LoadChildren(self):
-# Iterate over all PlugName@PlugType in confnode directory, and try to open them
+# Iterate over all CTNName@CTNType in confnode directory, and try to open them
-for PlugDir in os.listdir(self.PlugPath()):
+for CTNDir in os.listdir(self.CTNPath()):
-if os.path.isdir(os.path.join(self.PlugPath(), PlugDir)) and \
+if os.path.isdir(os.path.join(self.CTNPath(), CTNDir)) and \
-PlugDir.count(NameTypeSeparator) == 1:
+CTNDir.count(NameTypeSeparator) == 1:
-pname, ptype = PlugDir.split(NameTypeSeparator)
+pname, ptype = CTNDir.split(NameTypeSeparator)
 try:
-self.PlugAddChild(pname, ptype)
+self.CTNAddChild(pname, ptype)
 except Exception, exc:
-self.GetPlugRoot().logger.write_error(_("Could not add child \"%s\", type %s :\n%s\n")%(pname, ptype, str(exc)))
+self.GetCTRoot().logger.write_error(_("Could not add child \"%s\", type %s :\n%s\n")%(pname, ptype, str(exc)))
-self.GetPlugRoot().logger.write_error(traceback.format_exc())
+self.GetCTRoot().logger.write_error(traceback.format_exc())
 def EnableMethod(self, method, value):
 for d in self.ConfNodeMethods:
 if d["method"]==method:
 d["enabled"]=value
 This class define Root object of the confnode tree.
 It is responsible of :
 - Managing project directory
 - Building project
 - Handling PLCOpenEditor controler and view
-- Loading user confnodes and instanciante them as childs
+- Loading user confnodes and instanciante them as children
 - ...
 """
-# For root object, available Childs Types are modules of the confnode packages.
+# For root object, available Children Types are modules of the confnode packages.
-PlugChildsTypes = [(name, _GetClassFunction(name), help) for name, help in zip(confnodes.__all__,confnodes.helps)]
+CTNChildrenTypes = [(name, _GetClassFunction(name), help) for name, help in zip(confnodes.__all__,confnodes.helps)]
 XSD = """<?xml version="1.0" encoding="ISO-8859-1" ?>
 <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
 <xsd:element name="BeremizRoot">
 <xsd:complexType>
 self.DebugTimer=None
 self.ResetIECProgramsAndVariables()
 #This method are not called here... but in NewProject and OpenProject
 #self._AddParamsMembers()
-#self.PluggedChilds = {}
+#self.Children = {}
 # In both new or load scenario, no need to save
 self.ChangesToSave = False
 # root have no parent
-self.PlugParent = None
+self.CTNParent = None
 # Keep track of the confnode type name
-self.PlugType = "Beremiz"
+self.CTNType = "Beremiz"
-self.PluggedChilds = {}
+self.Children = {}
 # After __init__ root confnode is not valid
 self.ProjectPath = None
 self._setBuildPath(None)
 self.DebugThread = None
 self.debug_break = False
 self.logger = logger
 def ConfNodeLibraryFilePath(self):
 return os.path.join(os.path.split(__file__)[0], "pous.xml")
-def PlugTestModified(self):
+def CTNTestModified(self):
 return self.ChangesToSave or not self.ProjectIsSaved()
-def PlugFullName(self):
+def CTNFullName(self):
 return ""
-def GetPlugRoot(self):
+def GetCTRoot(self):
 return self
 def GetIECLibPath(self):
 return self.ieclib_path
 # Create PLCOpen program
 self.CreateNewProject(values)
 # Change XSD into class members
 self._AddParamsMembers()
-self.PluggedChilds = {}
+self.Children = {}
 # Keep track of the root confnode (i.e. project path)
 self.ProjectPath = ProjectPath
 self._setBuildPath(BuildPath)
 # get confnodes bloclist (is that usefull at project creation?)
 self.RefreshConfNodesBlockLists()
 result = self.OpenXMLFile(plc_file)
 if result:
 return result
 # Change XSD into class members
 self._AddParamsMembers()
-self.PluggedChilds = {}
+self.Children = {}
 # Keep track of the root confnode (i.e. project path)
 self.ProjectPath = ProjectPath
 self._setBuildPath(BuildPath)
 # If dir have already be made, and file exist
-if os.path.isdir(self.PlugPath()) and os.path.isfile(self.ConfNodeXmlFilePath()):
+if os.path.isdir(self.CTNPath()) and os.path.isfile(self.ConfNodeXmlFilePath()):
 #Load the confnode.xml file into parameters members
 result = self.LoadXMLParams()
 if result:
 return result
-#Load and init all the childs
+#Load and init all the children
-self.LoadChilds()
+self.LoadChildren()
 self.RefreshConfNodesBlockLists()
 if os.path.exists(self._getBuildPath()):
 self.EnableMethod("_Clean", True)
 self.ShowMethod("_showIECcode", True)
 return None
 def CloseProject(self):
-self.ClearPluggedChilds()
+self.ClearChildren()
 self.ResetAppFrame(None)
 def SaveProject(self):
 if self.CheckProjectPathPerm(False):
 self.SaveXMLFile(os.path.join(self.ProjectPath, 'plc.xml'))
-result = self.PlugRequestSave()
+result = self.CTNRequestSave()
 if result:
 self.logger.write_error(result)
 def SaveProjectAs(self, dosave=True):
 # Ask user to choose a path with write permissions
 return True
 return False
 # Update PLCOpenEditor ConfNode Block types from loaded confnodes
 def RefreshConfNodesBlockLists(self):
-if getattr(self, "PluggedChilds", None) is not None:
+if getattr(self, "Children", None) is not None:
 self.ClearConfNodeTypes()
 self.AddConfNodeTypesList(self.ConfNodesTypesFactory())
 if self.AppFrame is not None:
 self.AppFrame.RefreshLibraryPanel()
 self.AppFrame.RefreshEditor()
 - IEC_type is an IEC type like BOOL/BYTE/SINT/...
 - location is a string of this variable's location, like "%IX0.0.0"
 '''
 children = []
-for child in self.IECSortedChilds():
+for child in self.IECSortedChildren():
 children.append(child.GetVariableLocationTree())
 return children
 def ConfNodePath(self):
 return os.path.join(os.path.split(__file__)[0], "confnodes")
-def PlugPath(self, PlugName=None):
+def CTNPath(self, CTNName=None):
 return self.ProjectPath
-def ConfNodeXmlFilePath(self, PlugName=None):
+def ConfNodeXmlFilePath(self, CTNName=None):
-return os.path.join(self.PlugPath(PlugName), "beremiz.xml")
+return os.path.join(self.CTNPath(CTNName), "beremiz.xml")
 def ParentsTypesFactory(self):
 return self.ConfNodeTypesFactory()
 def _setBuildPath(self, buildpath):
 # define name for IEC generated code file
 return os.path.join(self._getBuildPath(), "generated_plc.st")
 def _getIECrawcodepath(self):
 # define name for IEC raw code file
-return os.path.join(self.PlugPath(), "raw_plc.st")
+return os.path.join(self.CTNPath(), "raw_plc.st")
 def GetLocations(self):
 locations = []
 filepath = os.path.join(self._getBuildPath(),"LOCATED_VARIABLES.h")
 if os.path.isfile(filepath):
 # transform those base names to full names with path
 C_files = map(lambda filename:os.path.join(buildpath, filename), C_files)
 self.logger.write(_("Extracting Located Variables...\n"))
 # Keep track of generated located variables for later use by self._Generate_C
 self.PLCGeneratedLocatedVars = self.GetLocations()
-# Keep track of generated C files for later use by self.PlugGenerate_C
+# Keep track of generated C files for later use by self.CTNGenerate_C
 self.PLCGeneratedCFiles = C_files
 # compute CFLAGS for plc
 self.plcCFLAGS = "\"-I"+self.ieclib_path+"\""
 return True
 #
 #                C CODE GENERATION METHODS
 #
 #######################################################################
-def PlugGenerate_C(self, buildpath, locations):
+def CTNGenerate_C(self, buildpath, locations):
 """
 Return C code generated by iec2c compiler
 when _generate_softPLC have been called
 @param locations: ignored
 @return: [(C_file_name, CFLAGS),...] , LDFLAGS_TO_APPEND

changeset 718	5d4dc150b956
parent 717	1c23952dbde1
child 720	6be032177e2a