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

Go to the documentation of this file.

#!/usr/bin/env python
# -*- coding: utf-8 -*-

#This file is part of CanFestival, a library implementing CanOpen Stack. 
#
#Copyright (C): Edouard TISSERANT, Francis DUPIN and Laurent BESSARD
#
#See COPYING file for copyrights details.
#
#This library is free software; you can redistribute it and/or
#modify it under the terms of the GNU Lesser General Public
#License as published by the Free Software Foundation; either
#version 2.1 of the License, or (at your option) any later version.
#
#This library is distributed in the hope that it will be useful,
#but WITHOUT ANY WARRANTY; without even the implied warranty of
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
#Lesser General Public License for more details.
#
#You should have received a copy of the GNU Lesser General Public
#License along with this library; if not, write to the Free Software
#Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

from gnosis.xml.pickle import *
from gnosis.xml.pickle.util import setParanoia
setParanoia(0)

from node import *
import eds_utils, gen_cfile

from types import *
import os, re

UndoBufferLength = 20

type_model = re.compile('([\_A-Z]*)([0-9]*)')
range_model = re.compile('([\_A-Z]*)([0-9]*)\[([\-0-9]*)-([\-0-9]*)\]')

# ID for the file viewed
CurrentID = 0

# Returns a new id
def GetNewId():
    global CurrentID
    CurrentID += 1
    return CurrentID

"""
Class implementing a buffer of changes made on the current editing Object Dictionary
"""

class UndoBuffer:

    """
    Constructor initialising buffer
    """
    def __init__(self, currentstate, issaved = False):
        self.BufferBuffer = []
        self.CurrentIndexCurrentIndex = -1
        self.MinIndexMinIndex = -1
        self.MaxIndexMaxIndex = -1
        # if current state is defined
        if currentstate:
            self.CurrentIndexCurrentIndex = 0
            self.MinIndexMinIndex = 0
            self.MaxIndexMaxIndex = 0
        # Initialising buffer with currentstate at the first place
        for i in xrange(UndoBufferLength):
            if i == 0:
                self.BufferBuffer.append(currentstate)
            else:
                self.BufferBuffer.append(None)
        # Initialising index of state saved
        if issaved:
            self.LastSaveLastSave = 0
        else:
            self.LastSaveLastSave = -1
    
    """
    Add a new state in buffer
    """
    def Buffering(self, currentstate):
        self.CurrentIndexCurrentIndex = (self.CurrentIndexCurrentIndex + 1) % UndoBufferLength
        self.BufferBuffer[self.CurrentIndexCurrentIndex] = currentstate
        # Actualising buffer limits
        self.MaxIndexMaxIndex = self.CurrentIndexCurrentIndex
        if self.MinIndexMinIndex == self.CurrentIndexCurrentIndex:
            # If the removed state was the state saved, there is no state saved in the buffer
            if self.LastSaveLastSave == self.MinIndexMinIndex:
                self.LastSaveLastSave = -1
            self.MinIndexMinIndex = (self.MinIndexMinIndex + 1) % UndoBufferLength
        self.MinIndexMinIndex = max(self.MinIndexMinIndex, 0)
    
    """
    Return current state of buffer
    """
    def Current(self):
        return self.BufferBuffer[self.CurrentIndexCurrentIndex]
    
    """
    Change current state to previous in buffer and return new current state
    """
    def Previous(self):
        if self.CurrentIndexCurrentIndex != self.MinIndexMinIndex:
            self.CurrentIndexCurrentIndex = (self.CurrentIndexCurrentIndex - 1) % UndoBufferLength
            return self.BufferBuffer[self.CurrentIndexCurrentIndex]
        return None
    
    """
    Change current state to next in buffer and return new current state
    """
    def Next(self):
        if self.CurrentIndexCurrentIndex != self.MaxIndexMaxIndex:
            self.CurrentIndexCurrentIndex = (self.CurrentIndexCurrentIndex + 1) % UndoBufferLength
            return self.BufferBuffer[self.CurrentIndexCurrentIndex]
        return None
    
    """
    Return True if current state is the first in buffer
    """
    def IsFirst(self):
        return self.CurrentIndexCurrentIndex == self.MinIndexMinIndex
    
    """
    Return True if current state is the last in buffer
    """
    def IsLast(self):
        return self.CurrentIndexCurrentIndex == self.MaxIndexMaxIndex

    """
    Note that current state is saved
    """
    def CurrentSaved(self):
        self.LastSaveLastSave = self.CurrentIndexCurrentIndex
        
    """
    Return True if current state is saved
    """
    def IsCurrentSaved(self):
        return self.LastSaveLastSave == self.CurrentIndexCurrentIndex



"""
Class which control the operations made on the node and answer to view requests
"""

class NodeManager:

    """
    Constructor
    """
    def __init__(self, cwd):
        self.LastNewIndexLastNewIndex = 0
        self.FilePathsFilePaths = {}
        self.FileNamesFileNames = {}
        self.NodeIndexNodeIndex = None
        self.CurrentNodeCurrentNode = None
        self.ScriptDirectoryScriptDirectory = cwd
        self.UndoBuffersUndoBuffers = {}

#-------------------------------------------------------------------------------
#                         Type and Map Variable Lists
#-------------------------------------------------------------------------------
    
    """
    Return the list of types defined for the current node
    """
    def GetCurrentTypeList(self):
        if self.CurrentNodeCurrentNode:
            return self.CurrentNodeCurrentNode.GetTypeList()
        else:
            return ""

    """
    Return the list of variables that can be mapped for the current node
    """
    def GetCurrentMapList(self):
        if self.CurrentNodeCurrentNode:
            return self.CurrentNodeCurrentNode.GetMapList()
        else:
            return ""

#-------------------------------------------------------------------------------
#                        Create Load and Save Functions
#-------------------------------------------------------------------------------

    """
    Create a new node and add a new buffer for storing it
    """
    def CreateNewNode(self, name, id, type, description, profile, filepath, NMT, options):
        # Create a new node
        node = Node()
        # Try to load profile given
        result = self.LoadProfileLoadProfile(profile, filepath, node)
        if not result:
            # if success, initialising node
            self.CurrentNodeCurrentNode = node
            self.CurrentNodeCurrentNode.SetNodeName(name)
            self.CurrentNodeCurrentNode.SetNodeID(id)
            self.CurrentNodeCurrentNode.SetNodeType(type)
            self.CurrentNodeCurrentNode.SetNodeDescription(description)
            AddIndexList = self.GetMandatoryIndexesGetMandatoryIndexes()
            if NMT == "NodeGuarding":
                AddIndexList.extend([0x100C, 0x100D])
            elif NMT == "Heartbeat":
                AddIndexList.append(0x1017)
            for option in options:
                if option == "DS302":
                    DS302Path = os.path.join(self.ScriptDirectoryScriptDirectory, "config/DS-302.prf")
                    # Charging DS-302 profile if choosen by user
                    if os.path.isfile(DS302Path):
                        try:
                            execfile(DS302Path)
                            self.CurrentNodeCurrentNode.SetDS302Profile(Mapping)
                            self.CurrentNodeCurrentNode.ExtendSpecificMenu(AddMenuEntries)
                        except:
                            return "Problem with DS-302! Syntax Error."
                    else:
                        return "Couldn't find DS-302 in 'config' folder!"
                elif option == "GenSYNC":
                    AddIndexList.extend([0x1005, 0x1006])
                elif option == "Emergency":
                    AddIndexList.append(0x1014)
                elif option == "SaveConfig":
                    AddIndexList.extend([0x1010, 0x1011, 0x1020])
                elif option == "StoreEDS":
                    AddIndexList.extend([0x1021, 0x1022])
            # Add a new buffer 
            index = self.AddNodeBufferAddNodeBuffer()
            self.SetCurrentFilePathSetCurrentFilePath("")
            # Add Mandatory indexes
            self.ManageEntriesOfCurrentManageEntriesOfCurrent(AddIndexList, [])
            return index
        else:
            return result
    
    """
    Load a profile in node
    """
    def LoadProfile(self, profile, filepath, node):
        if profile != "None":
            # Try to charge the profile given
            try:
                execfile(filepath)
                node.SetProfileName(profile)
                node.SetProfile(Mapping)
                node.SetSpecificMenu(AddMenuEntries)
                return None
            except:
                return "Syntax Error\nBad OD Profile file!."
        else:
            # Default profile
            node.SetProfileName("None")
            node.SetProfile({})
            node.SetSpecificMenu([])
            return None

    """
    Open a file and store it in a new buffer
    """
    def OpenFileInCurrent(self, filepath):
        # Open and load file
        file = open(filepath, "r")
        node = load(file)
        file.close()
        self.CurrentNodeCurrentNode = node
        # Add a new buffer and defining current state
        index = self.AddNodeBufferAddNodeBuffer(self.CurrentNodeCurrentNode.Copy(), True)
        self.SetCurrentFilePathSetCurrentFilePath(filepath)
        return index

    """
    Save current node in  a file
    """
    def SaveCurrentInFile(self, filepath = None):
        # if no filepath given, verify if current node has a filepath defined
        if not filepath:
            filepath = self.GetCurrentFilePathGetCurrentFilePath()
            if filepath == "":
                return False
        # Save node in file
        file = open(filepath, "w")
        dump(self.CurrentNodeCurrentNode, file)
        file.close()
        self.SetCurrentFilePathSetCurrentFilePath(filepath)
        # Update saved state in buffer
        self.UndoBuffersUndoBuffers[self.NodeIndexNodeIndex].CurrentSaved()
        return True

    """
    Close current state
    """
    def CloseCurrent(self, ignore = False):
        # Verify if it's not forced that the current node is saved before closing it
        if self.UndoBuffersUndoBuffers[self.NodeIndexNodeIndex].IsCurrentSaved() or ignore:
            self.RemoveNodeBufferRemoveNodeBuffer(self.NodeIndexNodeIndex)
            return True
        return False

    """
    Import an eds file and store it in a new buffer if no node edited
    """
    def ImportCurrentFromEDSFile(self, filepath):
        # Generate node from definition in a xml file
        result = eds_utils.GenerateNode(filepath, self.ScriptDirectoryScriptDirectory)
        if isinstance(result, Node):
            self.CurrentNodeCurrentNode = result
            if len(self.UndoBuffersUndoBuffers) == 0:
                index = self.AddNodeBufferAddNodeBuffer()
                self.SetCurrentFilePathSetCurrentFilePath("")
            self.BufferCurrentNodeBufferCurrentNode()
            return index
        else:
            return result
    
    """
    Export to an eds file and store it in a new buffer if no node edited
    """
    def ExportCurrentToEDSFile(self, filepath):
        return eds_utils.GenerateEDSFile(filepath, self)
    
    """
    Build the C definition of Object Dictionary for current node 
    """
    def ExportCurrentToCFile(self, filepath):
        return gen_cfile.GenerateFile(filepath, self)

#-------------------------------------------------------------------------------
#                        Add Entries to Current Functions
#-------------------------------------------------------------------------------

    """
    Add the specified number of subentry for the given entry. Verify that total
    number of subentry (except 0) doesn't exceed nbmax defined
    """
    def AddSubentriesToCurrent(self, index, number):
        # Informations about entry
        length = self.CurrentNodeCurrentNode.GetEntry(index, 0)
        infos = self.GetEntryInfosGetEntryInfos(index)
        subentry_infos = self.GetSubentryInfosGetSubentryInfos(index, 1)
        # Get default value for subindex
        if "default" in subentry_infos:
            default = subentry_infos["default"]
        else:
            default = self.GetTypeDefaultValueGetTypeDefaultValue(subentry_infos["type"])   
        # First case entry is record
        if infos["struct"] & OD_IdenticalSubindexes:
            for i in xrange(1, min(number,subentry_infos["nbmax"]-length) + 1):
                self.CurrentNodeCurrentNode.AddEntry(index, length + i, default)
            self.BufferCurrentNodeBufferCurrentNode()
        # Second case entry is array, only possible for manufacturer specific
        elif infos["struct"] & OD_MultipleSubindexes and 0x2000 <= index <= 0x5FFF:
            values = {"name" : "Undefined", "type" : 5, "access" : "rw", "pdo" : True}
            for i in xrange(1, min(number,0xFE-length) + 1):
                self.CurrentNodeCurrentNode.AddMappingEntry(index, length + i, values = values.copy())
                self.CurrentNodeCurrentNode.AddEntry(index, length + i, 0)
            self.BufferCurrentNodeBufferCurrentNode()

    """
    Remove the specified number of subentry for the given entry. Verify that total
    number of subentry (except 0) isn't less than 1
    """
    def RemoveSubentriesFromCurrent(self, index, number):
        # Informations about entry
        infos = self.GetEntryInfosGetEntryInfos(index)
        length = self.CurrentNodeCurrentNode.GetEntry(index, 0)
        # Entry is a record, or is an array of manufacturer specific
        if infos["struct"] & OD_IdenticalSubindexes or 0x2000 <= index <= 0x5FFF and infos["struct"] & OD_IdenticalSubindexes:
            for i in xrange(min(number, length - 1)):
                self.RemoveCurrentVariableRemoveCurrentVariable(index, length - i)
            self.BufferCurrentNodeBufferCurrentNode()

    """
    Add a SDO Server to current node
    """
    def AddSDOServerToCurrent(self):
        # An SDO Server is already defined at index 0x1200
        if self.CurrentNodeCurrentNode.IsEntry(0x1200):
            indexlist = [self.GetLineFromIndexGetLineFromIndex(0x1201)]
            if None not in indexlist:
                self.ManageEntriesOfCurrentManageEntriesOfCurrent(indexlist, [])
        # Add an SDO Server at index 0x1200
        else:
            self.ManageEntriesOfCurrentManageEntriesOfCurrent([0x1200], [])
        
    """
    Add a SDO Server to current node
    """
    def AddSDOClientToCurrent(self):
        indexlist = [self.GetLineFromIndexGetLineFromIndex(0x1280)]
        if None not in indexlist:
            self.ManageEntriesOfCurrentManageEntriesOfCurrent(indexlist, [])

    """
    Add a Transmit PDO to current node
    """
    def AddPDOTransmitToCurrent(self):
        indexlist = [self.GetLineFromIndexGetLineFromIndex(0x1800),self.GetLineFromIndexGetLineFromIndex(0x1A00)]
        if None not in indexlist:
            self.ManageEntriesOfCurrentManageEntriesOfCurrent(indexlist, [])
        
    """
    Add a Receive PDO to current node
    """
    def AddPDOReceiveToCurrent(self):
        indexlist = [self.GetLineFromIndexGetLineFromIndex(0x1400),self.GetLineFromIndexGetLineFromIndex(0x1600)]
        if None not in indexlist:
            self.ManageEntriesOfCurrentManageEntriesOfCurrent(indexlist, [])

    """
    Add a list of entries defined in profile for menu item selected to current node
    """
    def AddSpecificEntryToCurrent(self, menuitem):
        indexlist = []
        for menu, indexes in self.CurrentNodeCurrentNode.GetSpecificMenu():
            if menuitem == menu:
                for index in indexes:
                    indexlist.append(self.GetLineFromIndexGetLineFromIndex(index))
        if None not in indexlist:
            self.ManageEntriesOfCurrentManageEntriesOfCurrent(indexlist, [])

    """
    Search the first index available for a pluri entry from base_index
    """
    def GetLineFromIndex(self, base_index):
        found = False
        index = base_index
        infos = self.GetEntryInfosGetEntryInfos(base_index)
        while index < base_index + infos["incr"]*infos["nbmax"] and not found:
            if not self.CurrentNodeCurrentNode.IsEntry(index):
                found = True
            else:
                index += infos["incr"]
        if found:
            return index
        return None
    
    """
    Add entries specified in addinglist and remove entries specified in removinglist
    """
    def ManageEntriesOfCurrent(self, addinglist, removinglist):
        # Add all the entries in addinglist
        for index in addinglist:
            infos = self.GetEntryInfosGetEntryInfos(index)
            if infos["struct"] & OD_MultipleSubindexes:
                # First case entry is a record
                if infos["struct"] & OD_IdenticalSubindexes:
                    subentry_infos = self.GetSubentryInfosGetSubentryInfos(index, 1)
                    if "default" in subentry_infos:
                        default = subentry_infos["default"]
                    else:
                        default = self.GetTypeDefaultValueGetTypeDefaultValue(subentry_infos["type"])
                    self.CurrentNodeCurrentNode.AddEntry(index, 1, default)
                # Second case entry is a record
                else:
                    i = 1
                    subentry_infos = self.GetSubentryInfosGetSubentryInfos(index, i)
                    while subentry_infos:
                        if "default" in subentry_infos:
                            default = subentry_infos["default"]
                        else:
                            default = self.GetTypeDefaultValueGetTypeDefaultValue(subentry_infos["type"])
                        self.CurrentNodeCurrentNode.AddEntry(index, i, default)
                        i += 1
                        subentry_infos = self.GetSubentryInfosGetSubentryInfos(index, i)
            # Third case entry is a record
            else:
                subentry_infos = self.GetSubentryInfosGetSubentryInfos(index, 0)
                if "default" in subentry_infos:
                    default = subentry_infos["default"]
                else:
                    default = self.GetTypeDefaultValueGetTypeDefaultValue(subentry_infos["type"])
                self.CurrentNodeCurrentNode.AddEntry(index, 0, default)
        # Remove all the entries in removinglist
        for index in removinglist:
            self.RemoveCurrentVariableRemoveCurrentVariable(index)
        self.BufferCurrentNodeBufferCurrentNode()


    """
    Remove an entry from current node. Analize the index to perform the correct
    method
    """
    def RemoveCurrentVariable(self, index, subIndex = None):
        Mappings = self.CurrentNodeCurrentNode.GetMappings()
        if index < 0x1000 and subIndex == None:
            type = self.CurrentNodeCurrentNode.GetEntry(index, 1)
            for i in Mappings[-1]:
                for value in Mappings[-1][i]["values"]:
                    if value["type"] == index:
                        value["type"] = type
            self.CurrentNodeCurrentNode.RemoveMappingEntry(index)
            self.CurrentNodeCurrentNode.RemoveEntry(index)
        elif index == 0x1200 and subIndex == None:
            self.CurrentNodeCurrentNode.RemoveEntry(0x1200)
        elif 0x1201 <= index <= 0x127F and subIndex == None:
            self.CurrentNodeCurrentNode.RemoveLine(index, 0x127F)
        elif 0x1280 <= index <= 0x12FF and subIndex == None:
            self.CurrentNodeCurrentNode.RemoveLine(index, 0x12FF)
        elif 0x1400 <= index <= 0x15FF or 0x1600 <= index <= 0x17FF and subIndex == None:
            if 0x1600 <= index <= 0x17FF and subIndex == None:
                index -= 0x200
            self.CurrentNodeCurrentNode.RemoveLine(index, 0x15FF)
            self.CurrentNodeCurrentNode.RemoveLine(index + 0x200, 0x17FF)
        elif 0x1800 <= index <= 0x19FF or 0x1A00 <= index <= 0x1BFF and subIndex == None:
            if 0x1A00 <= index <= 0x1BFF:
                index -= 0x200
            self.CurrentNodeCurrentNode.RemoveLine(index, 0x19FF)
            self.CurrentNodeCurrentNode.RemoveLine(index + 0x200, 0x1BFF)
        else:
            found = False
            for menu,list in self.CurrentNodeCurrentNode.GetSpecificMenu():
                for i in list:
                    iinfos = self.GetEntryInfosGetEntryInfos(i)
                    indexes = [i + incr * iinfos["incr"] for incr in xrange(iinfos["nbmax"])] 
                    if index in indexes:
                        found = True
                        diff = index - i
                        for j in list:
                            jinfos = self.GetEntryInfosGetEntryInfos(j)
                            self.CurrentNodeCurrentNode.RemoveLine(j + diff, j + jinfos["incr"]*jinfos["nbmax"], jinfos["incr"])
            self.CurrentNodeCurrentNode.RemoveMapVariable(index, subIndex)
            if not found:
                infos = self.GetEntryInfosGetEntryInfos(index)
                if not infos["need"]:
                    self.CurrentNodeCurrentNode.RemoveEntry(index, subIndex)
            if index in Mappings[-1]:
                self.CurrentNodeCurrentNode.RemoveMappingEntry(index, subIndex)

    def AddMapVariableToCurrent(self, index, name, struct, number):
        if 0x2000 <= index <= 0x5FFF:
            if not self.CurrentNodeCurrentNode.IsEntry(index):
                self.CurrentNodeCurrentNode.AddMappingEntry(index, name = name, struct = struct)
                if struct == var:
                    values = {"name" : name, "type" : 0x05, "access" : "rw", "pdo" : True}
                    self.CurrentNodeCurrentNode.AddMappingEntry(index, 0, values = values)
                    self.CurrentNodeCurrentNode.AddEntry(index, 0, 0)
                else:
                    values = {"name" : "Number of Entries", "type" : 0x05, "access" : "ro", "pdo" : False}
                    self.CurrentNodeCurrentNode.AddMappingEntry(index, 0, values = values)
                    if struct == rec:
                        values = {"name" : name + " %d[(sub)]", "type" : 0x05, "access" : "rw", "pdo" : True, "nbmax" : 0xFE}
                        self.CurrentNodeCurrentNode.AddMappingEntry(index, 1, values = values)
                        for i in xrange(number):
                            self.CurrentNodeCurrentNode.AddEntry(index, i + 1, 0)
                    else:
                        for i in xrange(number):
                            values = {"name" : "Undefined", "type" : 0x05, "access" : "rw", "pdo" : True}
                            self.CurrentNodeCurrentNode.AddMappingEntry(index, i + 1, values = values)
                            self.CurrentNodeCurrentNode.AddEntry(index, i + 1, 0)
                self.BufferCurrentNodeBufferCurrentNode()
                return None
            else:
                return "Index 0x%04X already defined!"%index
        else:
            return "Index 0x%04X isn't a valid index for Map Variable!"%index

    def AddUserTypeToCurrent(self, type, min, max, length):
        index = 0xA0
        while index < 0x100 and self.CurrentNodeCurrentNode.IsEntry(index):
            index += 1
        if index < 0x100:
            customisabletypes = self.GetCustomisableTypesGetCustomisableTypes()
            name, valuetype = customisabletypes[type]
            size = self.GetEntryInfosGetEntryInfos(type)["size"]
            default = self.GetTypeDefaultValueGetTypeDefaultValue(type)
            if valuetype == 0:
                self.CurrentNodeCurrentNode.AddMappingEntry(index, name = "%s[%d-%d]"%(name, min, max), struct = 3, size = size, default = default)
                self.CurrentNodeCurrentNode.AddMappingEntry(index, 0, values = {"name" : "Number of Entries", "type" : 0x05, "access" : "ro", "pdo" : False})
                self.CurrentNodeCurrentNode.AddMappingEntry(index, 1, values = {"name" : "Type", "type" : 0x05, "access" : "ro", "pdo" : False})
                self.CurrentNodeCurrentNode.AddMappingEntry(index, 2, values = {"name" : "Minimum Value", "type" : type, "access" : "ro", "pdo" : False})
                self.CurrentNodeCurrentNode.AddMappingEntry(index, 3, values = {"name" : "Maximum Value", "type" : type, "access" : "ro", "pdo" : False})
                self.CurrentNodeCurrentNode.AddEntry(index, 1, type)
                self.CurrentNodeCurrentNode.AddEntry(index, 2, min)
                self.CurrentNodeCurrentNode.AddEntry(index, 3, max)
            elif valuetype == 1:
                self.CurrentNodeCurrentNode.AddMappingEntry(index, name = "%s%d"%(name, length), struct = 3, size = length * size, default = default)
                self.CurrentNodeCurrentNode.AddMappingEntry(index, 0, values = {"name" : "Number of Entries", "type" : 0x05, "access" : "ro", "pdo" : False})
                self.CurrentNodeCurrentNode.AddMappingEntry(index, 1, values = {"name" : "Type", "type" : 0x05, "access" : "ro", "pdo" : False})
                self.CurrentNodeCurrentNode.AddMappingEntry(index, 2, values = {"name" : "Length", "type" : 0x05, "access" : "ro", "pdo" : False})
                self.CurrentNodeCurrentNode.AddEntry(index, 1, type)
                self.CurrentNodeCurrentNode.AddEntry(index, 2, length)
            self.BufferCurrentNodeBufferCurrentNode()
            return None
        else:
            return "Too many User Types have already been defined!"

#-------------------------------------------------------------------------------
#                      Modify Entry and Mapping Functions
#-------------------------------------------------------------------------------

    def SetCurrentEntryCallbacks(self, index, value):
        if self.CurrentNodeCurrentNode and self.CurrentNodeCurrentNode.IsEntry(index):
            entry_infos = self.GetEntryInfosGetEntryInfos(index)
            if "callback" not in entry_infos:
                self.CurrentNodeCurrentNode.SetParamsEntry(index, None, callback = value)
                self.BufferCurrentNodeBufferCurrentNode()

    def SetCurrentEntry(self, index, subIndex, value, name, editor):
        if self.CurrentNodeCurrentNode and self.CurrentNodeCurrentNode.IsEntry(index):
            if name == "value":
                if editor == "map":
                    value = self.CurrentNodeCurrentNode.GetMapValue(value)
                    if value:
                        self.CurrentNodeCurrentNode.SetEntry(index, subIndex, value)
                elif editor == "bool":
                    value = value == "True"
                    self.CurrentNodeCurrentNode.SetEntry(index, subIndex, value)
                elif editor == "time":
                    self.CurrentNodeCurrentNode.SetEntry(index, subIndex, value)
                elif editor == "number":
                    try:
                        self.CurrentNodeCurrentNode.SetEntry(index, subIndex, int(value))
                    except:
                        pass
                elif editor == "domain":
                    try:
                        if len(value) % 2 != 0:
                            value = "0" + value
                        value = value.decode('hex_codec')
                        self.CurrentNodeCurrentNode.SetEntry(index, subIndex, value)
                    except:
                        pass
                else:
                    subentry_infos = self.GetSubentryInfosGetSubentryInfos(index, subIndex)
                    type = subentry_infos["type"]
                    dic = {}
                    for typeindex, typevalue in CustomisableTypes:
                        dic[typeindex] = typevalue
                    if type not in dic:
                        type = self.CurrentNodeCurrentNode.GetEntry(type)[1]
                    if dic[type] == 0:
                        try:
                            value = int(value, 16)
                            self.CurrentNodeCurrentNode.SetEntry(index, subIndex, value)
                        except:
                            pass
                    else:
                        self.CurrentNodeCurrentNode.SetEntry(index, subIndex, value)
            elif name in ["comment", "save"]:
                if editor == "option":
                    value = value == "Yes"
                if name == "save":
                    self.CurrentNodeCurrentNode.SetParamsEntry(index, subIndex, save = value)
                elif name == "comment":
                    self.CurrentNodeCurrentNode.SetParamsEntry(index, subIndex, comment = value)
            else:
                if editor == "type":
                    value = self.GetTypeIndexGetTypeIndex(value)
                    size = self.GetEntryInfosGetEntryInfos(value)["size"]
                    self.CurrentNodeCurrentNode.UpdateMapVariable(index, subIndex, size)
                elif editor in ["access","raccess"]:
                    dic = {}
                    for abbrev,access in AccessType.iteritems():
                        dic[access] = abbrev
                    value = dic[value]
                    if editor == "raccess" and not self.CurrentNodeCurrentNode.IsMappingEntry(index):
                        entry_infos = self.GetEntryInfosGetEntryInfos(index)
                        self.CurrentNodeCurrentNode.AddMappingEntry(index, name = entry_infos["name"], struct = 7)
                        self.CurrentNodeCurrentNode.AddMappingEntry(index, 0, values = self.GetSubentryInfosGetSubentryInfos(index, 0, False).copy())
                        self.CurrentNodeCurrentNode.AddMappingEntry(index, 1, values = self.GetSubentryInfosGetSubentryInfos(index, 1, False).copy())
                self.CurrentNodeCurrentNode.SetMappingEntry(index, subIndex, values = {name : value})
            self.BufferCurrentNodeBufferCurrentNode()

    def SetCurrentEntryName(self, index, name):
        self.CurrentNodeCurrentNode.SetMappingEntry(index, name=name)
        self.BufferCurrentNodeBufferCurrentNode()

    def SetCurrentUserType(self, index, type, min, max, length):
        customisabletypes = self.GetCustomisableTypesGetCustomisableTypes()
        values, valuetype = self.GetCustomisedTypeValuesGetCustomisedTypeValues(index)
        name, new_valuetype = customisabletypes[type]
        size = self.GetEntryInfosGetEntryInfos(type)["size"]
        default = self.GetTypeDefaultValueGetTypeDefaultValue(type)
        if new_valuetype == 0:
            self.CurrentNodeCurrentNode.SetMappingEntry(index, name = "%s[%d-%d]"%(name, min, max), struct = 3, size = size, default = default) 
            if valuetype == 1:
                self.CurrentNodeCurrentNode.SetMappingEntry(index, 2, values = {"name" : "Minimum Value", "type" : type, "access" : "ro", "pdo" : False})
                self.CurrentNodeCurrentNode.AddMappingEntry(index, 3, values = {"name" : "Maximum Value", "type" : type, "access" : "ro", "pdo" : False})
            self.CurrentNodeCurrentNode.SetEntry(index, 1, type)
            self.CurrentNodeCurrentNode.SetEntry(index, 2, min)
            if valuetype == 1:
                self.CurrentNodeCurrentNode.AddEntry(index, 3, max)
            else:
                self.CurrentNodeCurrentNode.SetEntry(index, 3, max)
        elif new_valuetype == 1:
            self.CurrentNodeCurrentNode.SetMappingEntry(index, name = "%s%d"%(name, length), struct = 3, size = size, default = default)
            if valuetype == 0:
                self.CurrentNodeCurrentNode.SetMappingEntry(index, 2, values = {"name" : "Length", "type" : 0x02, "access" : "ro", "pdo" : False})
                self.CurrentNodeCurrentNode.RemoveMappingEntry(index, 3)
            self.CurrentNodeCurrentNode.SetEntry(index, 1, type)
            self.CurrentNodeCurrentNode.SetEntry(index, 2, length)
            if valuetype == 0:
                self.CurrentNodeCurrentNode.RemoveEntry(index, 3)
        self.BufferCurrentNodeBufferCurrentNode()

#-------------------------------------------------------------------------------
#                      Current Buffering Management Functions
#-------------------------------------------------------------------------------

    def BufferCurrentNode(self):
        self.UndoBuffersUndoBuffers[self.NodeIndexNodeIndex].Buffering(self.CurrentNodeCurrentNode.Copy())

    def CurrentIsSaved(self):
        return self.UndoBuffersUndoBuffers[self.NodeIndexNodeIndex].IsCurrentSaved()

    def OneFileHasChanged(self):
        result = False
        for buffer in self.UndoBuffersUndoBuffers.values():
            result |= not buffer.IsCurrentSaved()
        return result

    def GetBufferNumber(self):
        return len(self.UndoBuffersUndoBuffers)

    def LoadCurrentPrevious(self):
        self.CurrentNodeCurrentNode = self.UndoBuffersUndoBuffers[self.NodeIndexNodeIndex].Previous().Copy()
    
    def LoadCurrentNext(self):
        self.CurrentNodeCurrentNode = self.UndoBuffersUndoBuffers[self.NodeIndexNodeIndex].Next().Copy()

    def AddNodeBuffer(self, currentstate = None, issaved = False):
        self.NodeIndexNodeIndex = GetNewId()
        self.UndoBuffersUndoBuffers[self.NodeIndexNodeIndex] = UndoBuffer(currentstate, issaved)
        self.FilePathsFilePaths[self.NodeIndexNodeIndex] = ""
        self.FileNamesFileNames[self.NodeIndexNodeIndex] = ""
        return self.NodeIndexNodeIndex

    def ChangeCurrentNode(self, index):
        if index in self.UndoBuffersUndoBuffers.keys():
            self.NodeIndexNodeIndex = index
            self.CurrentNodeCurrentNode = self.UndoBuffersUndoBuffers[self.NodeIndexNodeIndex].Current().Copy()
    
    def RemoveNodeBuffer(self, index):
        self.UndoBuffersUndoBuffers.pop(index)
        self.FilePathsFilePaths.pop(index)
        self.FileNamesFileNames.pop(index)
    
    def GetCurrentNodeIndex(self):
        return self.NodeIndexNodeIndex
    
    def GetCurrentFilename(self):
        return self.GetFilenameGetFilename(self.NodeIndexNodeIndex)
    
    def GetAllFilenames(self):
        indexes = self.UndoBuffersUndoBuffers.keys()
        indexes.sort()
        return [self.GetFilenameGetFilename(idx) for idx in indexes]
    
    def GetFilename(self, index):
        if self.UndoBuffersUndoBuffers[index].IsCurrentSaved():
            return self.FileNamesFileNames[index]
        else:
            return "~%s~"%self.FileNamesFileNames[index]
    
    def SetCurrentFilePath(self, filepath):
        self.FilePathsFilePaths[self.NodeIndexNodeIndex] = filepath
        if filepath == "":
            self.LastNewIndexLastNewIndex += 1
            self.FileNamesFileNames[self.NodeIndexNodeIndex] = "Unnamed%d"%self.LastNewIndexLastNewIndex
        else:
            self.FileNamesFileNames[self.NodeIndexNodeIndex] = os.path.splitext(os.path.basename(filepath))[0]
                
    def GetCurrentFilePath(self):
        if len(self.FilePathsFilePaths) > 0:
            return self.FilePathsFilePaths[self.NodeIndexNodeIndex]
        else:
            return ""
    
    def GetCurrentBufferState(self):
        first = self.UndoBuffersUndoBuffers[self.NodeIndexNodeIndex].IsFirst()
        last = self.UndoBuffersUndoBuffers[self.NodeIndexNodeIndex].IsLast()
        return not first, not last

#-------------------------------------------------------------------------------
#                         Profiles Management Functions
#-------------------------------------------------------------------------------

    def GetCurrentCommunicationLists(self):
        list = []
        for index in MappingDictionary.iterkeys():
            if 0x1000 <= index < 0x1200:
                list.append(index)
        return self.GetProfileListsGetProfileLists(MappingDictionary, list)
    
    def GetCurrentDS302Lists(self):
        return self.GetSpecificProfileListsGetSpecificProfileLists(self.CurrentNodeCurrentNode.GetDS302Profile())
    
    def GetCurrentProfileLists(self):
        return self.GetSpecificProfileListsGetSpecificProfileLists(self.CurrentNodeCurrentNode.GetProfile())
    
    def GetSpecificProfileLists(self, mappingdictionary):
        validlist = []
        exclusionlist = []
        for name, list in self.CurrentNodeCurrentNode.GetSpecificMenu():
            exclusionlist.extend(list)
        for index in mappingdictionary.iterkeys():
            if index not in exclusionlist:
                validlist.append(index)
        return self.GetProfileListsGetProfileLists(mappingdictionary, validlist)
    
    def GetProfileLists(self, mappingdictionary, list):
        dictionary = {}
        current = []
        for index in list:
            dictionary[index] = (mappingdictionary[index]["name"], mappingdictionary[index]["need"])
            if self.CurrentNodeCurrentNode.IsEntry(index):
                current.append(index)
        return dictionary, current

    def GetCurrentNextMapIndex(self):
        if self.CurrentNodeCurrentNode:
            index = 0x2000
            while self.CurrentNodeCurrentNode.IsEntry(index) and index < 0x5FFF:
                index += 1
            if index < 0x6000:
                return index
            else:
                return None

    def CurrentDS302Defined(self):
        if self.CurrentNodeCurrentNode:
            return len(self.CurrentNodeCurrentNode.GetDS302Profile()) > 0
        return False

#-------------------------------------------------------------------------------
#                         Node State and Values Functions
#-------------------------------------------------------------------------------
    
    def GetCurrentNodeName(self):
        if self.CurrentNodeCurrentNode:
            return self.CurrentNodeCurrentNode.GetNodeName()
        else:
            return ""

    def GetCurrentNodeID(self):
        if self.CurrentNodeCurrentNode:
            return self.CurrentNodeCurrentNode.GetNodeID()
        else:
            return None

    def GetCurrentNodeInfos(self):
        name = self.CurrentNodeCurrentNode.GetNodeName()
        id = self.CurrentNodeCurrentNode.GetNodeID()
        type = self.CurrentNodeCurrentNode.GetNodeType()
        description = self.CurrentNodeCurrentNode.GetNodeDescription()
        return name, id, type, description
        
    def SetCurrentNodeInfos(self, name, id, type, description):
        self.CurrentNodeCurrentNode.SetNodeName(name)
        self.CurrentNodeCurrentNode.SetNodeID(id)
        self.CurrentNodeCurrentNode.SetNodeType(type)
        self.CurrentNodeCurrentNode.SetNodeDescription(description)
        self.BufferCurrentNodeBufferCurrentNode()

    def GetCurrentProfileName(self):
        if self.CurrentNodeCurrentNode:
            return self.CurrentNodeCurrentNode.GetProfileName()
        return ""

    def IsCurrentEntry(self, index):
        if self.CurrentNodeCurrentNode:
            return self.CurrentNodeCurrentNode.IsEntry(index)
        return False
    
    def GetCurrentEntry(self, index, subIndex = None):
        if self.CurrentNodeCurrentNode:
            return self.CurrentNodeCurrentNode.GetEntry(index, subIndex)
        return None
    
    def GetCurrentParamsEntry(self, index, subIndex = None):
        if self.CurrentNodeCurrentNode:
            return self.CurrentNodeCurrentNode.GetParamsEntry(index, subIndex)
        return None
    
    def GetCurrentValidIndexes(self, min, max):
        validindexes = []
        for index in self.CurrentNodeCurrentNode.GetIndexes():
            if min <= index <= max:
                validindexes.append((self.GetEntryNameGetEntryName(index), index))
        return validindexes
        
    def GetCurrentValidChoices(self, min, max):
        validchoices = []
        exclusionlist = []
        for menu, indexes in self.CurrentNodeCurrentNode.GetSpecificMenu():
            exclusionlist.extend(indexes)
            good = True
            for index in indexes:
                good &= min <= index <= max
            if good:
                validchoices.append((menu, None))
        list = [index for index in MappingDictionary.keys() if index >= 0x1000]
        profiles = self.CurrentNodeCurrentNode.GetMappings(False)
        for profile in profiles:
            list.extend(profile.keys())
        list.sort()
        for index in list:
            if min <= index <= max and not self.CurrentNodeCurrentNode.IsEntry(index) and index not in exclusionlist:
                validchoices.append((self.GetEntryNameGetEntryName(index), index))
        return validchoices
    
    def HasCurrentEntryCallbacks(self, index):
        if self.CurrentNodeCurrentNode and self.CurrentNodeCurrentNode.IsEntry(index):
            entry_infos = self.GetEntryInfosGetEntryInfos(index)
            if "callback" in entry_infos:
                return entry_infos["callback"]
            return self.CurrentNodeCurrentNode.HasEntryCallbacks(index)
        return False
    
    def GetCurrentEntryValues(self, index):
        if self.CurrentNodeCurrentNode:
            return self.GetNodeEntryValuesGetNodeEntryValues(self.CurrentNodeCurrentNode, index)
    
    def GetNodeEntryValues(self, node, index):
        if node and node.IsEntry(index):
            entry_infos = node.GetEntryInfos(index)
            data = []
            editors = []
            values = node.GetEntry(index)
            params = node.GetParamsEntry(index)
            if type(values) == ListType:
                for i, value in enumerate(values):
                    data.append({"value" : value})
                    data[-1].update(params[i])      
            else:
                data.append({"value" : values})
                data[-1].update(params)
            for i, dic in enumerate(data):
                infos = node.GetSubentryInfos(index, i)
                dic["subindex"] = "0x%02X"%i
                dic["name"] = infos["name"]
                dic["type"] = node.GetTypeName(infos["type"])
                dic["access"] = AccessType[infos["access"]]
                dic["save"] = OptionType[dic["save"]]
                editor = {"subindex" : None, "save" : "option", "callback" : "option", "comment" : "string"}
                if type(values) == ListType and i == 0:
                    editor["name"] = None
                    editor["type"] = None
                    if 0x1600 <= index <= 0x17FF or 0x1A00 <= index <= 0x1C00:
                        editor["access"] = "raccess"
                    else:
                        editor["access"] = None
                    editor["value"] = None
                else:
                    if infos["user_defined"]:
                        if entry_infos["struct"] & OD_IdenticalSubindexes:
                            editor["name"] = None
                            if i > 1:
                                editor["type"] = None
                                editor["access"] = None
                            else:
                                editor["type"] = "type"
                                editor["access"] = "access"
                        else:
                            if entry_infos["struct"] & OD_MultipleSubindexes:
                                editor["name"] = "string"
                            else:
                                editor["name"] = None
                            editor["type"] = "type"
                            editor["access"] = "access"
                    else:
                        editor["name"] = None
                        editor["type"] = None
                        editor["access"] = None
                    if index < 0x260:
                        editor["value"] = None
                        if i == 1:
                            dic["value"] = node.GetTypeName(dic["value"])
                    elif 0x1600 <= index <= 0x17FF or 0x1A00 <= index <= 0x1C00:
                        editor["value"] = "map"
                        dic["value"] = node.GetMapName(dic["value"])
                    else:
                        if dic["type"].startswith("VISIBLE_STRING"):
                            editor["value"] = "string"
                        elif dic["type"] in ["TIME_OF_DAY","TIME_DIFFERENCE"]:
                            editor["value"] = "time"
                        elif dic["type"] == "DOMAIN":
                            editor["value"] = "domain"
                            dic["value"] = dic["value"].encode('hex_codec')
                        elif dic["type"] == "BOOLEAN":
                            editor["value"] = "bool"
                            dic["value"] = BoolType[dic["value"]]
                        result = type_model.match(dic["type"])
                        if result:
                            values = result.groups()
                            if values[0] == "UNSIGNED":
                                format = "0x%0" + str(int(values[1])/4) + "X"
                                dic["value"] = format%dic["value"]
                                editor["value"] = "string"
                            if values[0] == "INTEGER":
                                editor["value"] = "number"
                            elif values[0] == "REAL":
                                editor["value"] = "float"
                            elif values[0] == "VISIBLE_STRING":
                                editor["length"] = values[0]
                        result = range_model.match(dic["type"])
                        if result:
                            values = result.groups()
                            if values[0] in ["UNSIGNED", "INTEGER", "REAL"]:
                                editor["min"] = values[2]
                                editor["max"] = values[3]
                editors.append(editor)
            return data, editors
        else:
            return None

#-------------------------------------------------------------------------------
#                         Node Informations Functions
#-------------------------------------------------------------------------------

    def GetCustomisedTypeValues(self, index):
        if self.CurrentNodeCurrentNode:
            values = self.CurrentNodeCurrentNode.GetEntry(index)
            customisabletypes = self.GetCustomisableTypesGetCustomisableTypes()
            return values, customisabletypes[values[1]][1]
        else:
            return None, None

    def GetEntryName(self, index):
        if self.CurrentNodeCurrentNode:
            return self.CurrentNodeCurrentNode.GetEntryName(index)
        else:
            return FindEntryName(index, MappingDictionary)
    
    def GetEntryInfos(self, index):
        if self.CurrentNodeCurrentNode:
            return self.CurrentNodeCurrentNode.GetEntryInfos(index)
        else:
            return FindEntryInfos(index, MappingDictionary)
    
    def GetSubentryInfos(self, index, subindex):
        if self.CurrentNodeCurrentNode:
            return self.CurrentNodeCurrentNode.GetSubentryInfos(index, subindex)
        else:
            result = FindSubentryInfos(index, subindex, MappingDictionary)
            if result:
                result["user_defined"] = False
            return result
    
    def GetTypeIndex(self, typename):
        if self.CurrentNodeCurrentNode:
            return self.CurrentNodeCurrentNode.GetTypeIndex(typename)
        else:
            return FindTypeIndex(typename, MappingDictionary)
    
    def GetTypeName(self, typeindex):
        if self.CurrentNodeCurrentNode:
            return self.CurrentNodeCurrentNode.GetTypeName(typeindex)
        else:
            return FindTypeName(typeindex, MappingDictionary)
    
    def GetTypeDefaultValue(self, typeindex):
        if self.CurrentNodeCurrentNode:
            return self.CurrentNodeCurrentNode.GetTypeDefaultValue(typeindex)
        else:
            return FindTypeDefaultValue(typeindex, MappingDictionary)
    
    def GetMapVariableList(self):
        if self.CurrentNodeCurrentNode:
            return self.CurrentNodeCurrentNode.GetMapVariableList()
        else:
            return []

    def GetMandatoryIndexes(self, node = None):
        if self.CurrentNodeCurrentNode:
            return self.CurrentNodeCurrentNode.GetMapVariableList()
        else:
            return FindMandatoryIndexes(MappingDictionary)
    
    def GetCustomisableTypes(self):
        dic = {}
        for index, valuetype in CustomisableTypes:
            name = self.GetTypeNameGetTypeName(index)
            dic[index] = [name, valuetype]
        return dic
    
    def GetCurrentSpecificMenu(self):
        if self.CurrentNodeCurrentNode:
            return self.CurrentNodeCurrentNode.GetSpecificMenu()
        return []

---