CanFestival: /home/epimerde/documents/tc11/CanFestival-3/objdictgen/nodemanager.py Source File

00001 #!/usr/bin/env python
+00002 # -*- coding: utf-8 -*-
+00003 
+00004 #This file is part of CanFestival, a library implementing CanOpen Stack. 
+00005 #
+00006 #Copyright (C): Edouard TISSERANT, Francis DUPIN and Laurent BESSARD
+00007 #
+00008 #See COPYING file for copyrights details.
+00009 #
+00010 #This library is free software; you can redistribute it and/or
+00011 #modify it under the terms of the GNU Lesser General Public
+00012 #License as published by the Free Software Foundation; either
+00013 #version 2.1 of the License, or (at your option) any later version.
+00014 #
+00015 #This library is distributed in the hope that it will be useful,
+00016 #but WITHOUT ANY WARRANTY; without even the implied warranty of
+00017 #MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+00018 #Lesser General Public License for more details.
+00019 #
+00020 #You should have received a copy of the GNU Lesser General Public
+00021 #License along with this library; if not, write to the Free Software
+00022 #Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+00023 
+00024 from gnosis.xml.pickle import *
+00025 from gnosis.xml.pickle.util import setParanoia
+00026 setParanoia(0)
+00027 
+00028 from node import *
+00029 import eds_utils, gen_cfile
+00030 
+00031 from types import *
+00032 import os, re
+00033 
+00034 UndoBufferLength = 20
+00035 
+00036 type_model = re.compile('([\_A-Z]*)([0-9]*)')
+00037 range_model = re.compile('([\_A-Z]*)([0-9]*)\[([\-0-9]*)-([\-0-9]*)\]')
+00038 
+00039 # ID for the file viewed
+00040 CurrentID = 0
+00041 
+00042 # Returns a new id
+00043 def GetNewId():
+00044     global CurrentID
+00045     CurrentID += 1
+00046     return CurrentID
+00047 
+00048 """
+00049 Class implementing a buffer of changes made on the current editing Object Dictionary
+00050 """
+00051 
+00052 class UndoBuffer:
+00053 
+00054     """
+00055     Constructor initialising buffer
+00056     """
+00057     def __init__(self, currentstate, issaved = False):
+00058         self.BufferBuffer = []
+00059         self.CurrentIndexCurrentIndex = -1
+00060         self.MinIndexMinIndex = -1
+00061         self.MaxIndexMaxIndex = -1
+00062         # if current state is defined
+00063         if currentstate:
+00064             self.CurrentIndexCurrentIndex = 0
+00065             self.MinIndexMinIndex = 0
+00066             self.MaxIndexMaxIndex = 0
+00067         # Initialising buffer with currentstate at the first place
+00068         for i in xrange(UndoBufferLength):
+00069             if i == 0:
+00070                 self.BufferBuffer.append(currentstate)
+00071             else:
+00072                 self.BufferBuffer.append(None)
+00073         # Initialising index of state saved
+00074         if issaved:
+00075             self.LastSaveLastSave = 0
+00076         else:
+00077             self.LastSaveLastSave = -1
+00078     
+00079     """
+00080     Add a new state in buffer
+00081     """
+00082     def Buffering(self, currentstate):
+00083         self.CurrentIndexCurrentIndex = (self.CurrentIndexCurrentIndex + 1) % UndoBufferLength
+00084         self.BufferBuffer[self.CurrentIndexCurrentIndex] = currentstate
+00085         # Actualising buffer limits
+00086         self.MaxIndexMaxIndex = self.CurrentIndexCurrentIndex
+00087         if self.MinIndexMinIndex == self.CurrentIndexCurrentIndex:
+00088             # If the removed state was the state saved, there is no state saved in the buffer
+00089             if self.LastSaveLastSave == self.MinIndexMinIndex:
+00090                 self.LastSaveLastSave = -1
+00091             self.MinIndexMinIndex = (self.MinIndexMinIndex + 1) % UndoBufferLength
+00092         self.MinIndexMinIndex = max(self.MinIndexMinIndex, 0)
+00093     
+00094     """
+00095     Return current state of buffer
+00096     """
+00097     def Current(self):
+00098         return self.BufferBuffer[self.CurrentIndexCurrentIndex]
+00099     
+00100     """
+00101     Change current state to previous in buffer and return new current state
+00102     """
+00103     def Previous(self):
+00104         if self.CurrentIndexCurrentIndex != self.MinIndexMinIndex:
+00105             self.CurrentIndexCurrentIndex = (self.CurrentIndexCurrentIndex - 1) % UndoBufferLength
+00106             return self.BufferBuffer[self.CurrentIndexCurrentIndex]
+00107         return None
+00108     
+00109     """
+00110     Change current state to next in buffer and return new current state
+00111     """
+00112     def Next(self):
+00113         if self.CurrentIndexCurrentIndex != self.MaxIndexMaxIndex:
+00114             self.CurrentIndexCurrentIndex = (self.CurrentIndexCurrentIndex + 1) % UndoBufferLength
+00115             return self.BufferBuffer[self.CurrentIndexCurrentIndex]
+00116         return None
+00117     
+00118     """
+00119     Return True if current state is the first in buffer
+00120     """
+00121     def IsFirst(self):
+00122         return self.CurrentIndexCurrentIndex == self.MinIndexMinIndex
+00123     
+00124     """
+00125     Return True if current state is the last in buffer
+00126     """
+00127     def IsLast(self):
+00128         return self.CurrentIndexCurrentIndex == self.MaxIndexMaxIndex
+00129 
+00130     """
+00131     Note that current state is saved
+00132     """
+00133     def CurrentSaved(self):
+00134         self.LastSaveLastSave = self.CurrentIndexCurrentIndex
+00135         
+00136     """
+00137     Return True if current state is saved
+00138     """
+00139     def IsCurrentSaved(self):
+00140         return self.LastSaveLastSave == self.CurrentIndexCurrentIndex
+00141 
+00142 
+00143 
+00144 """
+00145 Class which control the operations made on the node and answer to view requests
+00146 """
+00147 
+00148 class NodeManager:
+00149 
+00150     """
+00151     Constructor
+00152     """
+00153     def __init__(self, cwd):
+00154         self.LastNewIndexLastNewIndex = 0
+00155         self.FilePathsFilePaths = {}
+00156         self.FileNamesFileNames = {}
+00157         self.NodeIndexNodeIndex = None
+00158         self.CurrentNodeCurrentNode = None
+00159         self.ScriptDirectoryScriptDirectory = cwd
+00160         self.UndoBuffersUndoBuffers = {}
+00161 
+00162 #-------------------------------------------------------------------------------
+00163 #                         Type and Map Variable Lists
+00164 #-------------------------------------------------------------------------------
+00165     
+00166     """
+00167     Return the list of types defined for the current node
+00168     """
+00169     def GetCurrentTypeList(self):
+00170         if self.CurrentNodeCurrentNode:
+00171             return self.CurrentNodeCurrentNode.GetTypeList()
+00172         else:
+00173             return ""
+00174 
+00175     """
+00176     Return the list of variables that can be mapped for the current node
+00177     """
+00178     def GetCurrentMapList(self):
+00179         if self.CurrentNodeCurrentNode:
+00180             return self.CurrentNodeCurrentNode.GetMapList()
+00181         else:
+00182             return ""
+00183 
+00184 #-------------------------------------------------------------------------------
+00185 #                        Create Load and Save Functions
+00186 #-------------------------------------------------------------------------------
+00187 
+00188     """
+00189     Create a new node and add a new buffer for storing it
+00190     """
+00191     def CreateNewNode(self, name, id, type, description, profile, filepath, NMT, options):
+00192         # Create a new node
+00193         node = Node()
+00194         # Try to load profile given
+00195         result = self.LoadProfileLoadProfile(profile, filepath, node)
+00196         if not result:
+00197             # if success, initialising node
+00198             self.CurrentNodeCurrentNode = node
+00199             self.CurrentNodeCurrentNode.SetNodeName(name)
+00200             self.CurrentNodeCurrentNode.SetNodeID(id)
+00201             self.CurrentNodeCurrentNode.SetNodeType(type)
+00202             self.CurrentNodeCurrentNode.SetNodeDescription(description)
+00203             AddIndexList = self.GetMandatoryIndexesGetMandatoryIndexes()
+00204             if NMT == "NodeGuarding":
+00205                 AddIndexList.extend([0x100C, 0x100D])
+00206             elif NMT == "Heartbeat":
+00207                 AddIndexList.append(0x1017)
+00208             for option in options:
+00209                 if option == "DS302":
+00210                     DS302Path = os.path.join(self.ScriptDirectoryScriptDirectory, "config/DS-302.prf")
+00211                     # Charging DS-302 profile if choosen by user
+00212                     if os.path.isfile(DS302Path):
+00213                         try:
+00214                             execfile(DS302Path)
+00215                             self.CurrentNodeCurrentNode.SetDS302Profile(Mapping)
+00216                             self.CurrentNodeCurrentNode.ExtendSpecificMenu(AddMenuEntries)
+00217                         except:
+00218                             return "Problem with DS-302! Syntax Error."
+00219                     else:
+00220                         return "Couldn't find DS-302 in 'config' folder!"
+00221                 elif option == "GenSYNC":
+00222                     AddIndexList.extend([0x1005, 0x1006])
+00223                 elif option == "Emergency":
+00224                     AddIndexList.append(0x1014)
+00225                 elif option == "SaveConfig":
+00226                     AddIndexList.extend([0x1010, 0x1011, 0x1020])
+00227                 elif option == "StoreEDS":
+00228                     AddIndexList.extend([0x1021, 0x1022])
+00229             # Add a new buffer 
+00230             index = self.AddNodeBufferAddNodeBuffer()
+00231             self.SetCurrentFilePathSetCurrentFilePath("")
+00232             # Add Mandatory indexes
+00233             self.ManageEntriesOfCurrentManageEntriesOfCurrent(AddIndexList, [])
+00234             return index
+00235         else:
+00236             return result
+00237     
+00238     """
+00239     Load a profile in node
+00240     """
+00241     def LoadProfile(self, profile, filepath, node):
+00242         if profile != "None":
+00243             # Try to charge the profile given
+00244             try:
+00245                 execfile(filepath)
+00246                 node.SetProfileName(profile)
+00247                 node.SetProfile(Mapping)
+00248                 node.SetSpecificMenu(AddMenuEntries)
+00249                 return None
+00250             except:
+00251                 return "Syntax Error\nBad OD Profile file!."
+00252         else:
+00253             # Default profile
+00254             node.SetProfileName("None")
+00255             node.SetProfile({})
+00256             node.SetSpecificMenu([])
+00257             return None
+00258 
+00259     """
+00260     Open a file and store it in a new buffer
+00261     """
+00262     def OpenFileInCurrent(self, filepath):
+00263         # Open and load file
+00264         file = open(filepath, "r")
+00265         node = load(file)
+00266         file.close()
+00267         self.CurrentNodeCurrentNode = node
+00268         # Add a new buffer and defining current state
+00269         index = self.AddNodeBufferAddNodeBuffer(self.CurrentNodeCurrentNode.Copy(), True)
+00270         self.SetCurrentFilePathSetCurrentFilePath(filepath)
+00271         return index
+00272 
+00273     """
+00274     Save current node in  a file
+00275     """
+00276     def SaveCurrentInFile(self, filepath = None):
+00277         # if no filepath given, verify if current node has a filepath defined
+00278         if not filepath:
+00279             filepath = self.GetCurrentFilePathGetCurrentFilePath()
+00280             if filepath == "":
+00281                 return False
+00282         # Save node in file
+00283         file = open(filepath, "w")
+00284         dump(self.CurrentNodeCurrentNode, file)
+00285         file.close()
+00286         self.SetCurrentFilePathSetCurrentFilePath(filepath)
+00287         # Update saved state in buffer
+00288         self.UndoBuffersUndoBuffers[self.NodeIndexNodeIndex].CurrentSaved()
+00289         return True
+00290 
+00291     """
+00292     Close current state
+00293     """
+00294     def CloseCurrent(self, ignore = False):
+00295         # Verify if it's not forced that the current node is saved before closing it
+00296         if self.UndoBuffersUndoBuffers[self.NodeIndexNodeIndex].IsCurrentSaved() or ignore:
+00297             self.RemoveNodeBufferRemoveNodeBuffer(self.NodeIndexNodeIndex)
+00298             return True
+00299         return False
+00300 
+00301     """
+00302     Import an eds file and store it in a new buffer if no node edited
+00303     """
+00304     def ImportCurrentFromEDSFile(self, filepath):
+00305         # Generate node from definition in a xml file
+00306         result = eds_utils.GenerateNode(filepath, self.ScriptDirectoryScriptDirectory)
+00307         if isinstance(result, Node):
+00308             self.CurrentNodeCurrentNode = result
+00309             if len(self.UndoBuffersUndoBuffers) == 0:
+00310                 index = self.AddNodeBufferAddNodeBuffer()
+00311                 self.SetCurrentFilePathSetCurrentFilePath("")
+00312             self.BufferCurrentNodeBufferCurrentNode()
+00313             return index
+00314         else:
+00315             return result
+00316     
+00317     """
+00318     Export to an eds file and store it in a new buffer if no node edited
+00319     """
+00320     def ExportCurrentToEDSFile(self, filepath):
+00321         return eds_utils.GenerateEDSFile(filepath, self)
+00322     
+00323     """
+00324     Build the C definition of Object Dictionary for current node 
+00325     """
+00326     def ExportCurrentToCFile(self, filepath):
+00327         return gen_cfile.GenerateFile(filepath, self)
+00328 
+00329 #-------------------------------------------------------------------------------
+00330 #                        Add Entries to Current Functions
+00331 #-------------------------------------------------------------------------------
+00332 
+00333     """
+00334     Add the specified number of subentry for the given entry. Verify that total
+00335     number of subentry (except 0) doesn't exceed nbmax defined
+00336     """
+00337     def AddSubentriesToCurrent(self, index, number):
+00338         # Informations about entry
+00339         length = self.CurrentNodeCurrentNode.GetEntry(index, 0)
+00340         infos = self.GetEntryInfosGetEntryInfos(index)
+00341         subentry_infos = self.GetSubentryInfosGetSubentryInfos(index, 1)
+00342         # Get default value for subindex
+00343         if "default" in subentry_infos:
+00344             default = subentry_infos["default"]
+00345         else:
+00346             default = self.GetTypeDefaultValueGetTypeDefaultValue(subentry_infos["type"])   
+00347         # First case entry is record
+00348         if infos["struct"] & OD_IdenticalSubindexes:
+00349             for i in xrange(1, min(number,subentry_infos["nbmax"]-length) + 1):
+00350                 self.CurrentNodeCurrentNode.AddEntry(index, length + i, default)
+00351             self.BufferCurrentNodeBufferCurrentNode()
+00352         # Second case entry is array, only possible for manufacturer specific
+00353         elif infos["struct"] & OD_MultipleSubindexes and 0x2000 <= index <= 0x5FFF:
+00354             values = {"name" : "Undefined", "type" : 5, "access" : "rw", "pdo" : True}
+00355             for i in xrange(1, min(number,0xFE-length) + 1):
+00356                 self.CurrentNodeCurrentNode.AddMappingEntry(index, length + i, values = values.copy())
+00357                 self.CurrentNodeCurrentNode.AddEntry(index, length + i, 0)
+00358             self.BufferCurrentNodeBufferCurrentNode()
+00359 
+00360     """
+00361     Remove the specified number of subentry for the given entry. Verify that total
+00362     number of subentry (except 0) isn't less than 1
+00363     """
+00364     def RemoveSubentriesFromCurrent(self, index, number):
+00365         # Informations about entry
+00366         infos = self.GetEntryInfosGetEntryInfos(index)
+00367         length = self.CurrentNodeCurrentNode.GetEntry(index, 0)
+00368         # Entry is a record, or is an array of manufacturer specific
+00369         if infos["struct"] & OD_IdenticalSubindexes or 0x2000 <= index <= 0x5FFF and infos["struct"] & OD_IdenticalSubindexes:
+00370             for i in xrange(min(number, length - 1)):
+00371                 self.RemoveCurrentVariableRemoveCurrentVariable(index, length - i)
+00372             self.BufferCurrentNodeBufferCurrentNode()
+00373 
+00374     """
+00375     Add a SDO Server to current node
+00376     """
+00377     def AddSDOServerToCurrent(self):
+00378         # An SDO Server is already defined at index 0x1200
+00379         if self.CurrentNodeCurrentNode.IsEntry(0x1200):
+00380             indexlist = [self.GetLineFromIndexGetLineFromIndex(0x1201)]
+00381             if None not in indexlist:
+00382                 self.ManageEntriesOfCurrentManageEntriesOfCurrent(indexlist, [])
+00383         # Add an SDO Server at index 0x1200
+00384         else:
+00385             self.ManageEntriesOfCurrentManageEntriesOfCurrent([0x1200], [])
+00386         
+00387     """
+00388     Add a SDO Server to current node
+00389     """
+00390     def AddSDOClientToCurrent(self):
+00391         indexlist = [self.GetLineFromIndexGetLineFromIndex(0x1280)]
+00392         if None not in indexlist:
+00393             self.ManageEntriesOfCurrentManageEntriesOfCurrent(indexlist, [])
+00394 
+00395     """
+00396     Add a Transmit PDO to current node
+00397     """
+00398     def AddPDOTransmitToCurrent(self):
+00399         indexlist = [self.GetLineFromIndexGetLineFromIndex(0x1800),self.GetLineFromIndexGetLineFromIndex(0x1A00)]
+00400         if None not in indexlist:
+00401             self.ManageEntriesOfCurrentManageEntriesOfCurrent(indexlist, [])
+00402         
+00403     """
+00404     Add a Receive PDO to current node
+00405     """
+00406     def AddPDOReceiveToCurrent(self):
+00407         indexlist = [self.GetLineFromIndexGetLineFromIndex(0x1400),self.GetLineFromIndexGetLineFromIndex(0x1600)]
+00408         if None not in indexlist:
+00409             self.ManageEntriesOfCurrentManageEntriesOfCurrent(indexlist, [])
+00410 
+00411     """
+00412     Add a list of entries defined in profile for menu item selected to current node
+00413     """
+00414     def AddSpecificEntryToCurrent(self, menuitem):
+00415         indexlist = []
+00416         for menu, indexes in self.CurrentNodeCurrentNode.GetSpecificMenu():
+00417             if menuitem == menu:
+00418                 for index in indexes:
+00419                     indexlist.append(self.GetLineFromIndexGetLineFromIndex(index))
+00420         if None not in indexlist:
+00421             self.ManageEntriesOfCurrentManageEntriesOfCurrent(indexlist, [])
+00422 
+00423     """
+00424     Search the first index available for a pluri entry from base_index
+00425     """
+00426     def GetLineFromIndex(self, base_index):
+00427         found = False
+00428         index = base_index
+00429         infos = self.GetEntryInfosGetEntryInfos(base_index)
+00430         while index < base_index + infos["incr"]*infos["nbmax"] and not found:
+00431             if not self.CurrentNodeCurrentNode.IsEntry(index):
+00432                 found = True
+00433             else:
+00434                 index += infos["incr"]
+00435         if found:
+00436             return index
+00437         return None
+00438     
+00439     """
+00440     Add entries specified in addinglist and remove entries specified in removinglist
+00441     """
+00442     def ManageEntriesOfCurrent(self, addinglist, removinglist):
+00443         # Add all the entries in addinglist
+00444         for index in addinglist:
+00445             infos = self.GetEntryInfosGetEntryInfos(index)
+00446             if infos["struct"] & OD_MultipleSubindexes:
+00447                 # First case entry is a record
+00448                 if infos["struct"] & OD_IdenticalSubindexes:
+00449                     subentry_infos = self.GetSubentryInfosGetSubentryInfos(index, 1)
+00450                     if "default" in subentry_infos:
+00451                         default = subentry_infos["default"]
+00452                     else:
+00453                         default = self.GetTypeDefaultValueGetTypeDefaultValue(subentry_infos["type"])
+00454                     self.CurrentNodeCurrentNode.AddEntry(index, 1, default)
+00455                 # Second case entry is a record
+00456                 else:
+00457                     i = 1
+00458                     subentry_infos = self.GetSubentryInfosGetSubentryInfos(index, i)
+00459                     while subentry_infos:
+00460                         if "default" in subentry_infos:
+00461                             default = subentry_infos["default"]
+00462                         else:
+00463                             default = self.GetTypeDefaultValueGetTypeDefaultValue(subentry_infos["type"])
+00464                         self.CurrentNodeCurrentNode.AddEntry(index, i, default)
+00465                         i += 1
+00466                         subentry_infos = self.GetSubentryInfosGetSubentryInfos(index, i)
+00467             # Third case entry is a record
+00468             else:
+00469                 subentry_infos = self.GetSubentryInfosGetSubentryInfos(index, 0)
+00470                 if "default" in subentry_infos:
+00471                     default = subentry_infos["default"]
+00472                 else:
+00473                     default = self.GetTypeDefaultValueGetTypeDefaultValue(subentry_infos["type"])
+00474                 self.CurrentNodeCurrentNode.AddEntry(index, 0, default)
+00475         # Remove all the entries in removinglist
+00476         for index in removinglist:
+00477             self.RemoveCurrentVariableRemoveCurrentVariable(index)
+00478         self.BufferCurrentNodeBufferCurrentNode()
+00479 
+00480 
+00481     """
+00482     Remove an entry from current node. Analize the index to perform the correct
+00483     method
+00484     """
+00485     def RemoveCurrentVariable(self, index, subIndex = None):
+00486         Mappings = self.CurrentNodeCurrentNode.GetMappings()
+00487         if index < 0x1000 and subIndex == None:
+00488             type = self.CurrentNodeCurrentNode.GetEntry(index, 1)
+00489             for i in Mappings[-1]:
+00490                 for value in Mappings[-1][i]["values"]:
+00491                     if value["type"] == index:
+00492                         value["type"] = type
+00493             self.CurrentNodeCurrentNode.RemoveMappingEntry(index)
+00494             self.CurrentNodeCurrentNode.RemoveEntry(index)
+00495         elif index == 0x1200 and subIndex == None:
+00496             self.CurrentNodeCurrentNode.RemoveEntry(0x1200)
+00497         elif 0x1201 <= index <= 0x127F and subIndex == None:
+00498             self.CurrentNodeCurrentNode.RemoveLine(index, 0x127F)
+00499         elif 0x1280 <= index <= 0x12FF and subIndex == None:
+00500             self.CurrentNodeCurrentNode.RemoveLine(index, 0x12FF)
+00501         elif 0x1400 <= index <= 0x15FF or 0x1600 <= index <= 0x17FF and subIndex == None:
+00502             if 0x1600 <= index <= 0x17FF and subIndex == None:
+00503                 index -= 0x200
+00504             self.CurrentNodeCurrentNode.RemoveLine(index, 0x15FF)
+00505             self.CurrentNodeCurrentNode.RemoveLine(index + 0x200, 0x17FF)
+00506         elif 0x1800 <= index <= 0x19FF or 0x1A00 <= index <= 0x1BFF and subIndex == None:
+00507             if 0x1A00 <= index <= 0x1BFF:
+00508                 index -= 0x200
+00509             self.CurrentNodeCurrentNode.RemoveLine(index, 0x19FF)
+00510             self.CurrentNodeCurrentNode.RemoveLine(index + 0x200, 0x1BFF)
+00511         else:
+00512             found = False
+00513             for menu,list in self.CurrentNodeCurrentNode.GetSpecificMenu():
+00514                 for i in list:
+00515                     iinfos = self.GetEntryInfosGetEntryInfos(i)
+00516                     indexes = [i + incr * iinfos["incr"] for incr in xrange(iinfos["nbmax"])] 
+00517                     if index in indexes:
+00518                         found = True
+00519                         diff = index - i
+00520                         for j in list:
+00521                             jinfos = self.GetEntryInfosGetEntryInfos(j)
+00522                             self.CurrentNodeCurrentNode.RemoveLine(j + diff, j + jinfos["incr"]*jinfos["nbmax"], jinfos["incr"])
+00523             self.CurrentNodeCurrentNode.RemoveMapVariable(index, subIndex)
+00524             if not found:
+00525                 infos = self.GetEntryInfosGetEntryInfos(index)
+00526                 if not infos["need"]:
+00527                     self.CurrentNodeCurrentNode.RemoveEntry(index, subIndex)
+00528             if index in Mappings[-1]:
+00529                 self.CurrentNodeCurrentNode.RemoveMappingEntry(index, subIndex)
+00530 
+00531     def AddMapVariableToCurrent(self, index, name, struct, number):
+00532         if 0x2000 <= index <= 0x5FFF:
+00533             if not self.CurrentNodeCurrentNode.IsEntry(index):
+00534                 self.CurrentNodeCurrentNode.AddMappingEntry(index, name = name, struct = struct)
+00535                 if struct == var:
+00536                     values = {"name" : name, "type" : 0x05, "access" : "rw", "pdo" : True}
+00537                     self.CurrentNodeCurrentNode.AddMappingEntry(index, 0, values = values)
+00538                     self.CurrentNodeCurrentNode.AddEntry(index, 0, 0)
+00539                 else:
+00540                     values = {"name" : "Number of Entries", "type" : 0x05, "access" : "ro", "pdo" : False}
+00541                     self.CurrentNodeCurrentNode.AddMappingEntry(index, 0, values = values)
+00542                     if struct == rec:
+00543                         values = {"name" : name + " %d[(sub)]", "type" : 0x05, "access" : "rw", "pdo" : True, "nbmax" : 0xFE}
+00544                         self.CurrentNodeCurrentNode.AddMappingEntry(index, 1, values = values)
+00545                         for i in xrange(number):
+00546                             self.CurrentNodeCurrentNode.AddEntry(index, i + 1, 0)
+00547                     else:
+00548                         for i in xrange(number):
+00549                             values = {"name" : "Undefined", "type" : 0x05, "access" : "rw", "pdo" : True}
+00550                             self.CurrentNodeCurrentNode.AddMappingEntry(index, i + 1, values = values)
+00551                             self.CurrentNodeCurrentNode.AddEntry(index, i + 1, 0)
+00552                 self.BufferCurrentNodeBufferCurrentNode()
+00553                 return None
+00554             else:
+00555                 return "Index 0x%04X already defined!"%index
+00556         else:
+00557             return "Index 0x%04X isn't a valid index for Map Variable!"%index
+00558 
+00559     def AddUserTypeToCurrent(self, type, min, max, length):
+00560         index = 0xA0
+00561         while index < 0x100 and self.CurrentNodeCurrentNode.IsEntry(index):
+00562             index += 1
+00563         if index < 0x100:
+00564             customisabletypes = self.GetCustomisableTypesGetCustomisableTypes()
+00565             name, valuetype = customisabletypes[type]
+00566             size = self.GetEntryInfosGetEntryInfos(type)["size"]
+00567             default = self.GetTypeDefaultValueGetTypeDefaultValue(type)
+00568             if valuetype == 0:
+00569                 self.CurrentNodeCurrentNode.AddMappingEntry(index, name = "%s[%d-%d]"%(name, min, max), struct = 3, size = size, default = default)
+00570                 self.CurrentNodeCurrentNode.AddMappingEntry(index, 0, values = {"name" : "Number of Entries", "type" : 0x05, "access" : "ro", "pdo" : False})
+00571                 self.CurrentNodeCurrentNode.AddMappingEntry(index, 1, values = {"name" : "Type", "type" : 0x05, "access" : "ro", "pdo" : False})
+00572                 self.CurrentNodeCurrentNode.AddMappingEntry(index, 2, values = {"name" : "Minimum Value", "type" : type, "access" : "ro", "pdo" : False})
+00573                 self.CurrentNodeCurrentNode.AddMappingEntry(index, 3, values = {"name" : "Maximum Value", "type" : type, "access" : "ro", "pdo" : False})
+00574                 self.CurrentNodeCurrentNode.AddEntry(index, 1, type)
+00575                 self.CurrentNodeCurrentNode.AddEntry(index, 2, min)
+00576                 self.CurrentNodeCurrentNode.AddEntry(index, 3, max)
+00577             elif valuetype == 1:
+00578                 self.CurrentNodeCurrentNode.AddMappingEntry(index, name = "%s%d"%(name, length), struct = 3, size = length * size, default = default)
+00579                 self.CurrentNodeCurrentNode.AddMappingEntry(index, 0, values = {"name" : "Number of Entries", "type" : 0x05, "access" : "ro", "pdo" : False})
+00580                 self.CurrentNodeCurrentNode.AddMappingEntry(index, 1, values = {"name" : "Type", "type" : 0x05, "access" : "ro", "pdo" : False})
+00581                 self.CurrentNodeCurrentNode.AddMappingEntry(index, 2, values = {"name" : "Length", "type" : 0x05, "access" : "ro", "pdo" : False})
+00582                 self.CurrentNodeCurrentNode.AddEntry(index, 1, type)
+00583                 self.CurrentNodeCurrentNode.AddEntry(index, 2, length)
+00584             self.BufferCurrentNodeBufferCurrentNode()
+00585             return None
+00586         else:
+00587             return "Too many User Types have already been defined!"
+00588 
+00589 #-------------------------------------------------------------------------------
+00590 #                      Modify Entry and Mapping Functions
+00591 #-------------------------------------------------------------------------------
+00592 
+00593     def SetCurrentEntryCallbacks(self, index, value):
+00594         if self.CurrentNodeCurrentNode and self.CurrentNodeCurrentNode.IsEntry(index):
+00595             entry_infos = self.GetEntryInfosGetEntryInfos(index)
+00596             if "callback" not in entry_infos:
+00597                 self.CurrentNodeCurrentNode.SetParamsEntry(index, None, callback = value)
+00598                 self.BufferCurrentNodeBufferCurrentNode()
+00599 
+00600     def SetCurrentEntry(self, index, subIndex, value, name, editor):
+00601         if self.CurrentNodeCurrentNode and self.CurrentNodeCurrentNode.IsEntry(index):
+00602             if name == "value":
+00603                 if editor == "map":
+00604                     value = self.CurrentNodeCurrentNode.GetMapValue(value)
+00605                     if value:
+00606                         self.CurrentNodeCurrentNode.SetEntry(index, subIndex, value)
+00607                 elif editor == "bool":
+00608                     value = value == "True"
+00609                     self.CurrentNodeCurrentNode.SetEntry(index, subIndex, value)
+00610                 elif editor == "time":
+00611                     self.CurrentNodeCurrentNode.SetEntry(index, subIndex, value)
+00612                 elif editor == "number":
+00613                     try:
+00614                         self.CurrentNodeCurrentNode.SetEntry(index, subIndex, int(value))
+00615                     except:
+00616                         pass
+00617                 elif editor == "domain":
+00618                     try:
+00619                         if len(value) % 2 != 0:
+00620                             value = "0" + value
+00621                         value = value.decode('hex_codec')
+00622                         self.CurrentNodeCurrentNode.SetEntry(index, subIndex, value)
+00623                     except:
+00624                         pass
+00625                 else:
+00626                     subentry_infos = self.GetSubentryInfosGetSubentryInfos(index, subIndex)
+00627                     type = subentry_infos["type"]
+00628                     dic = {}
+00629                     for typeindex, typevalue in CustomisableTypes:
+00630                         dic[typeindex] = typevalue
+00631                     if type not in dic:
+00632                         type = self.CurrentNodeCurrentNode.GetEntry(type)[1]
+00633                     if dic[type] == 0:
+00634                         try:
+00635                             value = int(value, 16)
+00636                             self.CurrentNodeCurrentNode.SetEntry(index, subIndex, value)
+00637                         except:
+00638                             pass
+00639                     else:
+00640                         self.CurrentNodeCurrentNode.SetEntry(index, subIndex, value)
+00641             elif name in ["comment", "save"]:
+00642                 if editor == "option":
+00643                     value = value == "Yes"
+00644                 if name == "save":
+00645                     self.CurrentNodeCurrentNode.SetParamsEntry(index, subIndex, save = value)
+00646                 elif name == "comment":
+00647                     self.CurrentNodeCurrentNode.SetParamsEntry(index, subIndex, comment = value)
+00648             else:
+00649                 if editor == "type":
+00650                     value = self.GetTypeIndexGetTypeIndex(value)
+00651                     size = self.GetEntryInfosGetEntryInfos(value)["size"]
+00652                     self.CurrentNodeCurrentNode.UpdateMapVariable(index, subIndex, size)
+00653                 elif editor in ["access","raccess"]:
+00654                     dic = {}
+00655                     for abbrev,access in AccessType.iteritems():
+00656                         dic[access] = abbrev
+00657                     value = dic[value]
+00658                     if editor == "raccess" and not self.CurrentNodeCurrentNode.IsMappingEntry(index):
+00659                         entry_infos = self.GetEntryInfosGetEntryInfos(index)
+00660                         self.CurrentNodeCurrentNode.AddMappingEntry(index, name = entry_infos["name"], struct = 7)
+00661                         self.CurrentNodeCurrentNode.AddMappingEntry(index, 0, values = self.GetSubentryInfosGetSubentryInfos(index, 0, False).copy())
+00662                         self.CurrentNodeCurrentNode.AddMappingEntry(index, 1, values = self.GetSubentryInfosGetSubentryInfos(index, 1, False).copy())
+00663                 self.CurrentNodeCurrentNode.SetMappingEntry(index, subIndex, values = {name : value})
+00664             self.BufferCurrentNodeBufferCurrentNode()
+00665 
+00666     def SetCurrentEntryName(self, index, name):
+00667         self.CurrentNodeCurrentNode.SetMappingEntry(index, name=name)
+00668         self.BufferCurrentNodeBufferCurrentNode()
+00669 
+00670     def SetCurrentUserType(self, index, type, min, max, length):
+00671         customisabletypes = self.GetCustomisableTypesGetCustomisableTypes()
+00672         values, valuetype = self.GetCustomisedTypeValuesGetCustomisedTypeValues(index)
+00673         name, new_valuetype = customisabletypes[type]
+00674         size = self.GetEntryInfosGetEntryInfos(type)["size"]
+00675         default = self.GetTypeDefaultValueGetTypeDefaultValue(type)
+00676         if new_valuetype == 0:
+00677             self.CurrentNodeCurrentNode.SetMappingEntry(index, name = "%s[%d-%d]"%(name, min, max), struct = 3, size = size, default = default) 
+00678             if valuetype == 1:
+00679                 self.CurrentNodeCurrentNode.SetMappingEntry(index, 2, values = {"name" : "Minimum Value", "type" : type, "access" : "ro", "pdo" : False})
+00680                 self.CurrentNodeCurrentNode.AddMappingEntry(index, 3, values = {"name" : "Maximum Value", "type" : type, "access" : "ro", "pdo" : False})
+00681             self.CurrentNodeCurrentNode.SetEntry(index, 1, type)
+00682             self.CurrentNodeCurrentNode.SetEntry(index, 2, min)
+00683             if valuetype == 1:
+00684                 self.CurrentNodeCurrentNode.AddEntry(index, 3, max)
+00685             else:
+00686                 self.CurrentNodeCurrentNode.SetEntry(index, 3, max)
+00687         elif new_valuetype == 1:
+00688             self.CurrentNodeCurrentNode.SetMappingEntry(index, name = "%s%d"%(name, length), struct = 3, size = size, default = default)
+00689             if valuetype == 0:
+00690                 self.CurrentNodeCurrentNode.SetMappingEntry(index, 2, values = {"name" : "Length", "type" : 0x02, "access" : "ro", "pdo" : False})
+00691                 self.CurrentNodeCurrentNode.RemoveMappingEntry(index, 3)
+00692             self.CurrentNodeCurrentNode.SetEntry(index, 1, type)
+00693             self.CurrentNodeCurrentNode.SetEntry(index, 2, length)
+00694             if valuetype == 0:
+00695                 self.CurrentNodeCurrentNode.RemoveEntry(index, 3)
+00696         self.BufferCurrentNodeBufferCurrentNode()
+00697 
+00698 #-------------------------------------------------------------------------------
+00699 #                      Current Buffering Management Functions
+00700 #-------------------------------------------------------------------------------
+00701 
+00702     def BufferCurrentNode(self):
+00703         self.UndoBuffersUndoBuffers[self.NodeIndexNodeIndex].Buffering(self.CurrentNodeCurrentNode.Copy())
+00704 
+00705     def CurrentIsSaved(self):
+00706         return self.UndoBuffersUndoBuffers[self.NodeIndexNodeIndex].IsCurrentSaved()
+00707 
+00708     def OneFileHasChanged(self):
+00709         result = False
+00710         for buffer in self.UndoBuffersUndoBuffers.values():
+00711             result |= not buffer.IsCurrentSaved()
+00712         return result
+00713 
+00714     def GetBufferNumber(self):
+00715         return len(self.UndoBuffersUndoBuffers)
+00716 
+00717     def LoadCurrentPrevious(self):
+00718         self.CurrentNodeCurrentNode = self.UndoBuffersUndoBuffers[self.NodeIndexNodeIndex].Previous().Copy()
+00719     
+00720     def LoadCurrentNext(self):
+00721         self.CurrentNodeCurrentNode = self.UndoBuffersUndoBuffers[self.NodeIndexNodeIndex].Next().Copy()
+00722 
+00723     def AddNodeBuffer(self, currentstate = None, issaved = False):
+00724         self.NodeIndexNodeIndex = GetNewId()
+00725         self.UndoBuffersUndoBuffers[self.NodeIndexNodeIndex] = UndoBuffer(currentstate, issaved)
+00726         self.FilePathsFilePaths[self.NodeIndexNodeIndex] = ""
+00727         self.FileNamesFileNames[self.NodeIndexNodeIndex] = ""
+00728         return self.NodeIndexNodeIndex
+00729 
+00730     def ChangeCurrentNode(self, index):
+00731         if index in self.UndoBuffersUndoBuffers.keys():
+00732             self.NodeIndexNodeIndex = index
+00733             self.CurrentNodeCurrentNode = self.UndoBuffersUndoBuffers[self.NodeIndexNodeIndex].Current().Copy()
+00734     
+00735     def RemoveNodeBuffer(self, index):
+00736         self.UndoBuffersUndoBuffers.pop(index)
+00737         self.FilePathsFilePaths.pop(index)
+00738         self.FileNamesFileNames.pop(index)
+00739     
+00740     def GetCurrentNodeIndex(self):
+00741         return self.NodeIndexNodeIndex
+00742     
+00743     def GetCurrentFilename(self):
+00744         return self.GetFilenameGetFilename(self.NodeIndexNodeIndex)
+00745     
+00746     def GetAllFilenames(self):
+00747         indexes = self.UndoBuffersUndoBuffers.keys()
+00748         indexes.sort()
+00749         return [self.GetFilenameGetFilename(idx) for idx in indexes]
+00750     
+00751     def GetFilename(self, index):
+00752         if self.UndoBuffersUndoBuffers[index].IsCurrentSaved():
+00753             return self.FileNamesFileNames[index]
+00754         else:
+00755             return "~%s~"%self.FileNamesFileNames[index]
+00756     
+00757     def SetCurrentFilePath(self, filepath):
+00758         self.FilePathsFilePaths[self.NodeIndexNodeIndex] = filepath
+00759         if filepath == "":
+00760             self.LastNewIndexLastNewIndex += 1
+00761             self.FileNamesFileNames[self.NodeIndexNodeIndex] = "Unnamed%d"%self.LastNewIndexLastNewIndex
+00762         else:
+00763             self.FileNamesFileNames[self.NodeIndexNodeIndex] = os.path.splitext(os.path.basename(filepath))[0]
+00764                 
+00765     def GetCurrentFilePath(self):
+00766         if len(self.FilePathsFilePaths) > 0:
+00767             return self.FilePathsFilePaths[self.NodeIndexNodeIndex]
+00768         else:
+00769             return ""
+00770     
+00771     def GetCurrentBufferState(self):
+00772         first = self.UndoBuffersUndoBuffers[self.NodeIndexNodeIndex].IsFirst()
+00773         last = self.UndoBuffersUndoBuffers[self.NodeIndexNodeIndex].IsLast()
+00774         return not first, not last
+00775 
+00776 #-------------------------------------------------------------------------------
+00777 #                         Profiles Management Functions
+00778 #-------------------------------------------------------------------------------
+00779 
+00780     def GetCurrentCommunicationLists(self):
+00781         list = []
+00782         for index in MappingDictionary.iterkeys():
+00783             if 0x1000 <= index < 0x1200:
+00784                 list.append(index)
+00785         return self.GetProfileListsGetProfileLists(MappingDictionary, list)
+00786     
+00787     def GetCurrentDS302Lists(self):
+00788         return self.GetSpecificProfileListsGetSpecificProfileLists(self.CurrentNodeCurrentNode.GetDS302Profile())
+00789     
+00790     def GetCurrentProfileLists(self):
+00791         return self.GetSpecificProfileListsGetSpecificProfileLists(self.CurrentNodeCurrentNode.GetProfile())
+00792     
+00793     def GetSpecificProfileLists(self, mappingdictionary):
+00794         validlist = []
+00795         exclusionlist = []
+00796         for name, list in self.CurrentNodeCurrentNode.GetSpecificMenu():
+00797             exclusionlist.extend(list)
+00798         for index in mappingdictionary.iterkeys():
+00799             if index not in exclusionlist:
+00800                 validlist.append(index)
+00801         return self.GetProfileListsGetProfileLists(mappingdictionary, validlist)
+00802     
+00803     def GetProfileLists(self, mappingdictionary, list):
+00804         dictionary = {}
+00805         current = []
+00806         for index in list:
+00807             dictionary[index] = (mappingdictionary[index]["name"], mappingdictionary[index]["need"])
+00808             if self.CurrentNodeCurrentNode.IsEntry(index):
+00809                 current.append(index)
+00810         return dictionary, current
+00811 
+00812     def GetCurrentNextMapIndex(self):
+00813         if self.CurrentNodeCurrentNode:
+00814             index = 0x2000
+00815             while self.CurrentNodeCurrentNode.IsEntry(index) and index < 0x5FFF:
+00816                 index += 1
+00817             if index < 0x6000:
+00818                 return index
+00819             else:
+00820                 return None
+00821 
+00822     def CurrentDS302Defined(self):
+00823         if self.CurrentNodeCurrentNode:
+00824             return len(self.CurrentNodeCurrentNode.GetDS302Profile()) > 0
+00825         return False
+00826 
+00827 #-------------------------------------------------------------------------------
+00828 #                         Node State and Values Functions
+00829 #-------------------------------------------------------------------------------
+00830     
+00831     def GetCurrentNodeName(self):
+00832         if self.CurrentNodeCurrentNode:
+00833             return self.CurrentNodeCurrentNode.GetNodeName()
+00834         else:
+00835             return ""
+00836 
+00837     def GetCurrentNodeID(self):
+00838         if self.CurrentNodeCurrentNode:
+00839             return self.CurrentNodeCurrentNode.GetNodeID()
+00840         else:
+00841             return None
+00842 
+00843     def GetCurrentNodeInfos(self):
+00844         name = self.CurrentNodeCurrentNode.GetNodeName()
+00845         id = self.CurrentNodeCurrentNode.GetNodeID()
+00846         type = self.CurrentNodeCurrentNode.GetNodeType()
+00847         description = self.CurrentNodeCurrentNode.GetNodeDescription()
+00848         return name, id, type, description
+00849         
+00850     def SetCurrentNodeInfos(self, name, id, type, description):
+00851         self.CurrentNodeCurrentNode.SetNodeName(name)
+00852         self.CurrentNodeCurrentNode.SetNodeID(id)
+00853         self.CurrentNodeCurrentNode.SetNodeType(type)
+00854         self.CurrentNodeCurrentNode.SetNodeDescription(description)
+00855         self.BufferCurrentNodeBufferCurrentNode()
+00856 
+00857     def GetCurrentProfileName(self):
+00858         if self.CurrentNodeCurrentNode:
+00859             return self.CurrentNodeCurrentNode.GetProfileName()
+00860         return ""
+00861 
+00862     def IsCurrentEntry(self, index):
+00863         if self.CurrentNodeCurrentNode:
+00864             return self.CurrentNodeCurrentNode.IsEntry(index)
+00865         return False
+00866     
+00867     def GetCurrentEntry(self, index, subIndex = None):
+00868         if self.CurrentNodeCurrentNode:
+00869             return self.CurrentNodeCurrentNode.GetEntry(index, subIndex)
+00870         return None
+00871     
+00872     def GetCurrentParamsEntry(self, index, subIndex = None):
+00873         if self.CurrentNodeCurrentNode:
+00874             return self.CurrentNodeCurrentNode.GetParamsEntry(index, subIndex)
+00875         return None
+00876     
+00877     def GetCurrentValidIndexes(self, min, max):
+00878         validindexes = []
+00879         for index in self.CurrentNodeCurrentNode.GetIndexes():
+00880             if min <= index <= max:
+00881                 validindexes.append((self.GetEntryNameGetEntryName(index), index))
+00882         return validindexes
+00883         
+00884     def GetCurrentValidChoices(self, min, max):
+00885         validchoices = []
+00886         exclusionlist = []
+00887         for menu, indexes in self.CurrentNodeCurrentNode.GetSpecificMenu():
+00888             exclusionlist.extend(indexes)
+00889             good = True
+00890             for index in indexes:
+00891                 good &= min <= index <= max
+00892             if good:
+00893                 validchoices.append((menu, None))
+00894         list = [index for index in MappingDictionary.keys() if index >= 0x1000]
+00895         profiles = self.CurrentNodeCurrentNode.GetMappings(False)
+00896         for profile in profiles:
+00897             list.extend(profile.keys())
+00898         list.sort()
+00899         for index in list:
+00900             if min <= index <= max and not self.CurrentNodeCurrentNode.IsEntry(index) and index not in exclusionlist:
+00901                 validchoices.append((self.GetEntryNameGetEntryName(index), index))
+00902         return validchoices
+00903     
+00904     def HasCurrentEntryCallbacks(self, index):
+00905         if self.CurrentNodeCurrentNode and self.CurrentNodeCurrentNode.IsEntry(index):
+00906             entry_infos = self.GetEntryInfosGetEntryInfos(index)
+00907             if "callback" in entry_infos:
+00908                 return entry_infos["callback"]
+00909             return self.CurrentNodeCurrentNode.HasEntryCallbacks(index)
+00910         return False
+00911     
+00912     def GetCurrentEntryValues(self, index):
+00913         if self.CurrentNodeCurrentNode:
+00914             return self.GetNodeEntryValuesGetNodeEntryValues(self.CurrentNodeCurrentNode, index)
+00915     
+00916     def GetNodeEntryValues(self, node, index):
+00917         if node and node.IsEntry(index):
+00918             entry_infos = node.GetEntryInfos(index)
+00919             data = []
+00920             editors = []
+00921             values = node.GetEntry(index)
+00922             params = node.GetParamsEntry(index)
+00923             if type(values) == ListType:
+00924                 for i, value in enumerate(values):
+00925                     data.append({"value" : value})
+00926                     data[-1].update(params[i])      
+00927             else:
+00928                 data.append({"value" : values})
+00929                 data[-1].update(params)
+00930             for i, dic in enumerate(data):
+00931                 infos = node.GetSubentryInfos(index, i)
+00932                 dic["subindex"] = "0x%02X"%i
+00933                 dic["name"] = infos["name"]
+00934                 dic["type"] = node.GetTypeName(infos["type"])
+00935                 dic["access"] = AccessType[infos["access"]]
+00936                 dic["save"] = OptionType[dic["save"]]
+00937                 editor = {"subindex" : None, "save" : "option", "callback" : "option", "comment" : "string"}
+00938                 if type(values) == ListType and i == 0:
+00939                     editor["name"] = None
+00940                     editor["type"] = None
+00941                     if 0x1600 <= index <= 0x17FF or 0x1A00 <= index <= 0x1C00:
+00942                         editor["access"] = "raccess"
+00943                     else:
+00944                         editor["access"] = None
+00945                     editor["value"] = None
+00946                 else:
+00947                     if infos["user_defined"]:
+00948                         if entry_infos["struct"] & OD_IdenticalSubindexes:
+00949                             editor["name"] = None
+00950                             if i > 1:
+00951                                 editor["type"] = None
+00952                                 editor["access"] = None
+00953                             else:
+00954                                 editor["type"] = "type"
+00955                                 editor["access"] = "access"
+00956                         else:
+00957                             if entry_infos["struct"] & OD_MultipleSubindexes:
+00958                                 editor["name"] = "string"
+00959                             else:
+00960                                 editor["name"] = None
+00961                             editor["type"] = "type"
+00962                             editor["access"] = "access"
+00963                     else:
+00964                         editor["name"] = None
+00965                         editor["type"] = None
+00966                         editor["access"] = None
+00967                     if index < 0x260:
+00968                         editor["value"] = None
+00969                         if i == 1:
+00970                             dic["value"] = node.GetTypeName(dic["value"])
+00971                     elif 0x1600 <= index <= 0x17FF or 0x1A00 <= index <= 0x1C00:
+00972                         editor["value"] = "map"
+00973                         dic["value"] = node.GetMapName(dic["value"])
+00974                     else:
+00975                         if dic["type"].startswith("VISIBLE_STRING"):
+00976                             editor["value"] = "string"
+00977                         elif dic["type"] in ["TIME_OF_DAY","TIME_DIFFERENCE"]:
+00978                             editor["value"] = "time"
+00979                         elif dic["type"] == "DOMAIN":
+00980                             editor["value"] = "domain"
+00981                             dic["value"] = dic["value"].encode('hex_codec')
+00982                         elif dic["type"] == "BOOLEAN":
+00983                             editor["value"] = "bool"
+00984                             dic["value"] = BoolType[dic["value"]]
+00985                         result = type_model.match(dic["type"])
+00986                         if result:
+00987                             values = result.groups()
+00988                             if values[0] == "UNSIGNED":
+00989                                 format = "0x%0" + str(int(values[1])/4) + "X"
+00990                                 dic["value"] = format%dic["value"]
+00991                                 editor["value"] = "string"
+00992                             if values[0] == "INTEGER":
+00993                                 editor["value"] = "number"
+00994                             elif values[0] == "REAL":
+00995                                 editor["value"] = "float"
+00996                             elif values[0] == "VISIBLE_STRING":
+00997                                 editor["length"] = values[0]
+00998                         result = range_model.match(dic["type"])
+00999                         if result:
+01000                             values = result.groups()
+01001                             if values[0] in ["UNSIGNED", "INTEGER", "REAL"]:
+01002                                 editor["min"] = values[2]
+01003                                 editor["max"] = values[3]
+01004                 editors.append(editor)
+01005             return data, editors
+01006         else:
+01007             return None
+01008 
+01009 #-------------------------------------------------------------------------------
+01010 #                         Node Informations Functions
+01011 #-------------------------------------------------------------------------------
+01012 
+01013     def GetCustomisedTypeValues(self, index):
+01014         if self.CurrentNodeCurrentNode:
+01015             values = self.CurrentNodeCurrentNode.GetEntry(index)
+01016             customisabletypes = self.GetCustomisableTypesGetCustomisableTypes()
+01017             return values, customisabletypes[values[1]][1]
+01018         else:
+01019             return None, None
+01020 
+01021     def GetEntryName(self, index):
+01022         if self.CurrentNodeCurrentNode:
+01023             return self.CurrentNodeCurrentNode.GetEntryName(index)
+01024         else:
+01025             return FindEntryName(index, MappingDictionary)
+01026     
+01027     def GetEntryInfos(self, index):
+01028         if self.CurrentNodeCurrentNode:
+01029             return self.CurrentNodeCurrentNode.GetEntryInfos(index)
+01030         else:
+01031             return FindEntryInfos(index, MappingDictionary)
+01032     
+01033     def GetSubentryInfos(self, index, subindex):
+01034         if self.CurrentNodeCurrentNode:
+01035             return self.CurrentNodeCurrentNode.GetSubentryInfos(index, subindex)
+01036         else:
+01037             result = FindSubentryInfos(index, subindex, MappingDictionary)
+01038             if result:
+01039                 result["user_defined"] = False
+01040             return result
+01041     
+01042     def GetTypeIndex(self, typename):
+01043         if self.CurrentNodeCurrentNode:
+01044             return self.CurrentNodeCurrentNode.GetTypeIndex(typename)
+01045         else:
+01046             return FindTypeIndex(typename, MappingDictionary)
+01047     
+01048     def GetTypeName(self, typeindex):
+01049         if self.CurrentNodeCurrentNode:
+01050             return self.CurrentNodeCurrentNode.GetTypeName(typeindex)
+01051         else:
+01052             return FindTypeName(typeindex, MappingDictionary)
+01053     
+01054     def GetTypeDefaultValue(self, typeindex):
+01055         if self.CurrentNodeCurrentNode:
+01056             return self.CurrentNodeCurrentNode.GetTypeDefaultValue(typeindex)
+01057         else:
+01058             return FindTypeDefaultValue(typeindex, MappingDictionary)
+01059     
+01060     def GetMapVariableList(self):
+01061         if self.CurrentNodeCurrentNode:
+01062             return self.CurrentNodeCurrentNode.GetMapVariableList()
+01063         else:
+01064             return []
+01065 
+01066     def GetMandatoryIndexes(self, node = None):
+01067         if self.CurrentNodeCurrentNode:
+01068             return self.CurrentNodeCurrentNode.GetMapVariableList()
+01069         else:
+01070             return FindMandatoryIndexes(MappingDictionary)
+01071     
+01072     def GetCustomisableTypes(self):
+01073         dic = {}
+01074         for index, valuetype in CustomisableTypes:
+01075             name = self.GetTypeNameGetTypeName(index)
+01076             dic[index] = [name, valuetype]
+01077         return dic
+01078     
+01079     def GetCurrentSpecificMenu(self):
+01080         if self.CurrentNodeCurrentNode:
+01081             return self.CurrentNodeCurrentNode.GetSpecificMenu()
+01082         return []
+01083 
+