cht version

[tools/eficas.git] / Editeur / Objecttreeitem.py

diff --git a/Editeur/Objecttreeitem.py b/Editeur/Objecttreeitem.py
index b805fed00c6d7a14f0dc2f96f3bb23128bc03213..8b6fbbd6835e944fa51ceb157ef6940b397aa041 100644 (file)
--- a/Editeur/Objecttreeitem.py
+++ b/Editeur/Objecttreeitem.py
@@ -1,35 +1,50 @@
 # -*- coding: utf-8 -*-
 # -*- coding: utf-8 -*-

-#            CONFIGURATION MANAGEMENT OF EDF VERSION
-# ======================================================================
-# COPYRIGHT (C) 1991 - 2002  EDF R&D                  WWW.CODE-ASTER.ORG
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
+# Copyright (C) 2007-2021   EDF R&D

 #
 #

-# THIS PROGRAM 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
-# GENERAL PUBLIC LICENSE FOR MORE 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.

 #
 #

-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+# 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
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com

 #
 #

-# ======================================================================

 """
 """
 """
 """

-# import généraux
-import types,string,os,glob,imp,sys
-from repr import Repr
+# import generaux
+from __future__ import absolute_import
+from __future__ import print_function
+try :
+    from builtins import str
+    from builtins import object
+except :
+    pass
+import types,os,glob,imp,sys

 from copy import copy,deepcopy
 
 from copy import copy,deepcopy
 

+# import du chargeur de composants
+from .comploader import makeObjecttreeitem
+from Ihm import CONNECTOR
+from Extensions.i18n import tr
+from Extensions.eficas_exception import EficasException
+
+try :
+    from repr import Repr
+except :
+    from reprlib import Repr

 myrepr = Repr()
 myrepr.maxstring = 100
 myrepr.maxother = 100
 
 myrepr = Repr()
 myrepr.maxstring = 100
 myrepr.maxother = 100
 

-class TreeItem:
+class TreeItem(object):

 
     """Abstract class representing tree items.
 
 
     """Abstract class representing tree items.
 


@@ -37,33 +52,43 @@ class TreeItem:
     is used.
 
     """
     is used.
 
     """

+    # itemNode est une factory qui doit retourner un objet de la classe Node
+    # ou derive de cette classe.
+    # Le widget arbre utilisera cet objet comme noeud associe au tree item.
+    # Par defaut, utilise la classe Node de base
+    # La signature de la factory est la suivante :
+    # itemNode(treeOrNode,item,command,rmenu)
+    # ou treeOrNode est le noeud parent, item est l'item associe
+    # command est une fonction python appelee sur selection graphique
+    # du noeud et rmenu est une fonction python appelee sur click droit sur le noeud
+    itemNode=None

 
     def __init__(self):
         """Constructor.  Do whatever you need to do."""
 
 
     def __init__(self):
         """Constructor.  Do whatever you need to do."""
 

-    def GetText(self):
+    def getText(self):

         """Return text string to display."""
 
         """Return text string to display."""
 

-    def GetLabelText(self):
+    def getLabelText(self):

         """Return label text string to display in front of text (if any)."""
 
     expandable = None
 
         """Return label text string to display in front of text (if any)."""
 
     expandable = None
 

-    def _IsExpandable(self):
+    def _isExpandable(self):

         """Do not override!  Called by TreeNode."""
         if self.expandable is None:
         """Do not override!  Called by TreeNode."""
         if self.expandable is None:

-            self.expandable = self.IsExpandable()
+            self.expandable = self.isExpandable()

         return self.expandable
 
         return self.expandable
 

-    def IsExpandable(self):
+    def isExpandable(self):

         """Return whether there are subitems."""
         return 1
 
         """Return whether there are subitems."""
         return 1
 

-    def _GetSubList(self):
+    def _getSubList(self):

         """Do not override!  Called by TreeNode."""
         """Do not override!  Called by TreeNode."""

-        if not self.IsExpandable():
+        if not self.isExpandable():

             return []
             return []

-        sublist = self.GetSubList()
+        sublist = self.getSubList()

         if not sublist:
             self.expandable = 0
         return sublist
         if not sublist:
             self.expandable = 0
         return sublist


@@ -74,28 +99,28 @@ class TreeItem:
     def SetText(self, text):
         """Change the item's text (if it is editable)."""
 
     def SetText(self, text):
         """Change the item's text (if it is editable)."""
 

-    def GetIconName(self):
+    def getIconName(self):

         """Return name of icon to be displayed normally."""
 
         """Return name of icon to be displayed normally."""
 

-    def GetSelectedIconName(self):
+    def getSelectedIconName(self):

         """Return name of icon to be displayed when selected."""
 
         """Return name of icon to be displayed when selected."""
 

-    def GetSubList(self):
+    def getSubList(self):

         """Return list of items forming sublist."""
 
         """Return list of items forming sublist."""
 

-    def OnDoubleClick(self):
+    def onDoubleClick(self):

         """Called on a double-click on the item."""
 
         """Called on a double-click on the item."""
 

-class Delegate:
+class Delegate(object):

     def __init__(self, delegate=None):
         self.object = delegate
         self.__cache = {}
 
     def __init__(self, delegate=None):
         self.object = delegate
         self.__cache = {}
 

-    def setdelegate(self, delegate):
+    def setDelegate(self, delegate):

         self.resetcache()
         self.object = delegate
 
         self.resetcache()
         self.object = delegate
 

-    def getdelegate(self):
+    def getDelegate(self):

         return self.object
 
     def __getattr__(self, name):
         return self.object
 
     def __getattr__(self, name):


@@ -105,7 +130,7 @@ class Delegate:
         return attr
 
     def resetcache(self):
         return attr
 
     def resetcache(self):

-        for key in self.__cache.keys():
+        for key in list(self.__cache.keys()):

             try:
                 delattr(self, key)
             except AttributeError:
             try:
                 delattr(self, key)
             except AttributeError:


@@ -113,243 +138,277 @@ class Delegate:
         self.__cache.clear()
 
     def cachereport(self):
         self.__cache.clear()
 
     def cachereport(self):

-        keys = self.__cache.keys()
+        keys = list(self.__cache.keys())

         keys.sort()
         keys.sort()

-        print keys
+        #print keys

 
 
 class ObjectTreeItem(TreeItem,Delegate):
 
 
 class ObjectTreeItem(TreeItem,Delegate):

-    def __init__(self, appli, labeltext, object, setfunction=None):
+    def __init__(self, appliEficas, labeltext, object, setFunction=None):

         self.labeltext = labeltext
         self.labeltext = labeltext

-        self.appli = appli
+        self.appliEficas = appliEficas
+        # L'objet delegue est stocke dans l'attribut object
+        # L'objet associe a l'item est stocke dans l'attribut _object
+        # Il peut etre obtenu par appel a la methode getObject
+        # Attention : le delegue peut etre different de l'objet associe (MCLIST)
+        # Dans le cas d'une MCListe de longueur 1, l'objet associe est la MCListe
+        # et l'objet delegue est le MCFACT (object = _object.data[0])

         Delegate.__init__(self,object)
         Delegate.__init__(self,object)

-        #self.object = object
-        self.setfunction = setfunction
+        # On cache l'objet initial (pour destruction eventuelle
+        # ulterieure)
+        self._object = object
+        self.setFunction = setFunction

         self.expandable = 1
         self.expandable = 1

+        self.sublist=[]

         self.init()
 
     def init(self):
         return
 
         self.init()
 
     def init(self):
         return
 

+    def getObject(self):
+        return self._object
+
+    def connect(self,channel,callable,args):
+        """ Connecte la fonction callable (avec arguments args) a l'item self sur le
+            canal channel
+        """
+        #print self,channel,callable,args
+        CONNECTOR.Connect(self._object,channel,callable,args)
+        CONNECTOR.Connect(self.object, channel,callable,args)
+

     def copy(self):
         """
     def copy(self):
         """

-        Crée un item copie de self
+        Cree un item copie de self

         """
         """

-        object = self.object.copy()
-        appli = copy(self.appli)
+        object = self._object.copy()
+        appliEficas = copy(self.appliEficas)

         labeltext = copy(self.labeltext)
         labeltext = copy(self.labeltext)

-        fonction = deepcopy(self.setfunction)
-        item = make_objecttreeitem(appli,labeltext,object,fonction)
+        fonction = deepcopy(self.setFunction)
+        item = makeObjecttreeitem(appliEficas,labeltext,object,fonction)

         return item
         return item

-    
-    def isactif(self):
+
+    def isActif(self):

         if hasattr(self.object,'actif'):
             return self.object.actif
         else:
             return 1
         if hasattr(self.object,'actif'):
             return self.object.actif
         else:
             return 1

-    
-    def GetLabelText(self):
+
+    def update(self,item):
+        """
+          Met a jour l'item courant a partir d'un autre item passe en argument
+          Ne fait rien par defaut
+        """
+        pass
+
+    def getLabelText(self):

         """ Retourne 3 valeurs :
         """ Retourne 3 valeurs :

-        - le texte à afficher dans le noeud représentant l'item
+        - le texte a afficher dans le noeud representant l'item

         - la fonte dans laquelle afficher ce texte
         - la couleur du texte
         """
         - la fonte dans laquelle afficher ce texte
         - la couleur du texte
         """

-        # None --> fonte et couleur par défaut
-        return self.labeltext,None,None
-
-    #def get_attribut(self,nom_attribut) :
-    #    """ 
-    #       Retourne l'attribut de nom nom_attribut de l'objet sur lequel
-    #       pointe self s'il existe, None sinon
-    #    """
-    #    return self.object.get_attribut(nom_attribut)
-
-    def get_nature(self) :
-        """ 
+        # None --> fonte et couleur par defaut
+        return tr(self.labeltext),None,None
+
+    def getNature(self) :
+        """

             Retourne la nature de l'item et de l'objet
             Retourne la nature de l'item et de l'objet

-        """ 
+        """

         return self.object.nature
 
         return self.object.nature
 

-    def get_regles(self):
-        """ retourne les règles de l'objet pointé par self """
-        return self.object.get_regles()
-    
-    def get_liste_mc_presents(self):
-        """ Retourne la liste des mots-clés fils de l'objet pointé par self """
-        return self.object.liste_mc_presents()
-    
-    def get_val(self):
-        """ Retourne le nom de la valeur de l'objet pointé par self dans le cas
-            où celle-ci est un objet (ASSD) """
-        return self.object.getval()
-    
+    def getRegles(self):
+        """ retourne les regles de l'objet pointe par self """
+        return self.object.getRegles()
+
+    def getListeMcPresents(self):
+        """ Retourne la liste des mots-cles fils de l'objet pointe par self """
+        return self.object.listeMcPresents()
+
+    def getVal(self):
+        """ Retourne le nom de la valeur de l'objet pointe par self dans le cas
+            ou celle-ci est un objet (ASSD) """
+        return self.object.getVal()
+

     def get_definition(self):
     def get_definition(self):

-        """ 
-           Retourne l'objet definition de l'objet pointé par self 
+        """
+           Retourne l'objet definition de l'objet pointe par self

         """
         return self.object.definition
 
         """
         return self.object.definition
 

-    def get_liste_mc_ordonnee(self,liste,dico):
-        """ retourne la liste ordonnée (suivant le catalogue) brute des mots-clés
-            d'une entité composée dont le chemin complet est donné sous forme
+    def getListeMcOrdonnee(self,liste,dico):
+        """ retourne la liste ordonnee (suivant le catalogue) brute des mots-cles
+            d'une entite composee dont le chemin complet est donne sous forme

             d'une liste du type :ETAPE + MCFACT ou MCBLOC + ...
             d'une liste du type :ETAPE + MCFACT ou MCBLOC + ...

-            il faut encore réarranger cette liste (certains mots-clés déjà
-            présents ne doivent plus être proposés, règles ...)"""
-        return self.object.get_liste_mc_ordonnee(liste,dico)
+            il faut encore rearranger cette liste (certains mots-cles deja
+            presents ne doivent plus etre proposes, regles ...)"""
+        return self.object.getListeMcOrdonnee(liste,dico)

 
 

-    def get_liste_mc_ordonnee_brute(self,liste,dico):
+    def getListeMcOrdonneeBrute(self,liste,dico):

         """
         """

-        retourne la liste ordonnée (suivant le catalogue) BRUTE des mots-clés
-        d'une entité composée dont le chemin complet est donné sous forme
+        retourne la liste ordonnee (suivant le catalogue) BRUTE des mots-cles
+        d'une entite composee dont le chemin complet est donne sous forme

         d'une liste du type :ETAPE + MCFACT ou MCBLOC + ...
         """
         d'une liste du type :ETAPE + MCFACT ou MCBLOC + ...
         """

-        return self.object.get_liste_mc_ordonnee_brute(liste,dico)
-   
-    def get_genealogie(self):
+        return self.object.getListeMcOrdonneeBrute(liste,dico)
+
+    def getGenealogie(self):

         """
         Retourne la liste des noms des ascendants (noms de MCSIMP,MCFACT,MCBLOC ou ETAPE)
         """
         Retourne la liste des noms des ascendants (noms de MCSIMP,MCFACT,MCBLOC ou ETAPE)

-        de l'objet pointé par self
+        de l'objet pointe par self

         """
         """

-        return self.object.get_genealogie()
+        return self.object.getGenealogie()

 
 

-    def get_index_child(self,nom_fils):
+    def getIndexChild(self,nom_fils):

         """
         Retourne l'index dans la liste des fils de self du nouveau fils de nom nom_fils
         """
         Retourne l'index dans la liste des fils de self du nouveau fils de nom nom_fils

-        Nécessaire pour savoir à quelle position dans la liste des fils il faut ajouter
-        le nouveau mot-clé
+        Necessaire pour savoir a quelle position dans la liste des fils il faut ajouter
+        le nouveau mot-cle

         """
         """

-        liste_noms_mc_ordonnee = self.get_liste_mc_ordonnee_brute(self.get_genealogie(),self.get_jdc().cata_ordonne_dico)
-        liste_noms_mc_presents = self.object.liste_mc_presents()
+        return self.object.getIndexChild(nom_fils)
+
+    def getIndexChild_old(self,nom_fils):
+        """
+        Retourne l'index dans la liste des fils de self du nouveau fils de nom nom_fils
+        Necessaire pour savoir a quelle position dans la liste des fils il faut ajouter
+        le nouveau mot-cle
+        """
+        liste_noms_mc_ordonnee = self.getListeMcOrdonneeBrute(self.getGenealogie(),self.getJdc().cata_ordonne_dico)
+        liste_noms_mc_presents = self.object.listeMcPresents()

         l=[]
         for nom in liste_noms_mc_ordonnee:
             if nom in liste_noms_mc_presents or nom == nom_fils:
                 l.append(nom)
         l=[]
         for nom in liste_noms_mc_ordonnee:
             if nom in liste_noms_mc_presents or nom == nom_fils:
                 l.append(nom)

-        # l contient les anciens mots-clés + le nouveau dans l'ordre
+        # l contient les anciens mots-cles + le nouveau dans l'ordre

         return l.index(nom_fils)
         return l.index(nom_fils)

-        
-    def get_nom_etape(self):
-        """Retourne le nom de self """
-        return self.object.get_nom_etape()

 
 

-    def get_copie_objet(self):
-        """ Retourne une copie de l'objet pointé par self """
+    def appendChild(self,name,pos=None):
+        """
+          Permet d'ajouter un item fils a self
+        """
+        if pos == 'first':
+            index = 0
+        elif pos == 'last':
+            index = len(self.listeMcPresents())
+        elif type(pos) == int :
+            # la position est fixee
+            index = pos
+        #elif type(pos) == types.InstanceType:
+        elif type(pos) == object :
+            # pos est un item. Il faut inserer name apres pos
+            index = self.getIndex(pos) +1
+        #elif type(name) == types.InstanceType:
+        elif type(name) == object :
+            index = self.getIndexChild(name.nom)
+        else:
+            index = self.getIndexChild(name)
+        return self.addobject(name,index)
+
+    def appendBrother(self,name,pos='after'):
+        """
+        Permet d'ajouter un frere a self
+        par defaut on l'ajoute apres self
+        """
+        index = self._object.parent.getIndex(self.getObject())
+        if pos == 'before':
+            index = index
+        elif pos == 'after':
+            index = index +1
+        else:
+            print((tr("%d n'est pas un index valide pour appendBrother", pos)))
+            return
+        return self.parent.addobject(name,index)
+
+    def getCopieObjet(self):
+        """ Retourne une copie de l'objet pointe par self """

         return self.object.copy()
         return self.object.copy()

-    
-    def get_position(self):
-        """ Retourne la valeur de l'attribut position de l'objet pointé par self """
+
+    def getPosition(self):
+        """ Retourne la valeur de l'attribut position de l'objet pointe par self """

         definition = self.get_definition()
         try:
             return getattr(definition,'position')
         except AttributeError:
             return 'local'
         definition = self.get_definition()
         try:
             return getattr(definition,'position')
         except AttributeError:
             return 'local'

-        
-    def get_nom(self):
-        """ Retourne le nom de l'objet pointé par self """
+
+    def getNom(self):
+        """ Retourne le nom de l'objet pointe par self """

         return self.object.nom
 
         return self.object.nom
 

-    def get_jdc(self):
-        """ Retourne le jdc auquel appartient l'objet pointé par self """
+    def getJdc(self):
+        """ Retourne le jdc auquel appartient l'objet pointe par self """

         return self.object.jdc
         return self.object.jdc

-        #return self.object.get_attribut('jdc')
-    
-    def get_valeur(self):
-        """ Retourne la valeur de l'objet pointé par self """
+
+    def getValeur(self):
+        """ Retourne la valeur de l'objet pointe par self """

         return self.object.valeur
 
         return self.object.valeur
 

-    def get_cr(self):
+    def getCr(self):

         """ Retourne le compte-rendu CR de self """
         return self.object.report()
 
         """ Retourne le compte-rendu CR de self """
         return self.object.report()
 

-    def get_objet_commentarise(self):
+    def getObjetCommentarise(self):

         """
         """

-        Cette méthode retourne un objet commentarisé
-        représentatif de self.object
-        --> à surcharger par les différents items
+        Cette methode retourne un objet commentarise
+        representatif de self.object
+        --> a surcharger par les differents items

         """
         """

-        raise Exception("MESSAGE AU DEVELOPPEUR : il faut surcharger la methode get_objet_commentarise() pour la classe "+self.__class__.__name__)
-        pass
-        
-    def isvalid(self):
-        """ Retourne 1 si l'objet pointé par self est valide, 0 sinon"""
-        return self.object.isvalid()
+        raise EficasException("MESSAGE AU DEVELOPPEUR : il faut \
+                                 surcharger la methode getObjetCommentarise() \
+                                 pour la classe %s", self.__class__.__name__)
+
+    def isValid(self):
+        """ Retourne 1 si l'objet pointe par self est valide, 0 sinon"""
+        return self.object.isValid()

 
 

-    def iscopiable(self):
+    def isCopiable(self):

         """
         Retourne 1 si l'objet est copiable, 0 sinon
         """
         Retourne 1 si l'objet est copiable, 0 sinon

-        Par défaut retourne 0
+        Par defaut retourne 0

         """
         return 0
         """
         return 0

-    
-    def isMCList(self):
-        """ Retourne 1 si l'objet pointé par self est une MClist, 0 sinon"""
-        #if isinstance(self.object,MCList) :
-        if self.object.__class__.__name__ == 'MCList':
-            return 1
-        else :
-            return 0

 
 

-    def isCommande(self):
-        """
-        Retourne 1 si l'objet pointé par self est une Commande, 0 sinon
-        """
-        return 0
+    def getMcPresents(self):
+        """ Retourne le dictionnaire des mots-cles presents de l'objet pointe par self """
+        return self.object.dictMcPresents()

 
 

-    def isJdc(self):
-        """
-        Retourne 1 si l'objet pointé par self est un JDC, 0 sinon
-        """
-        return 0
+    def verifConditionRegles(self,l_mc_presents):
+        return self.object.verifConditionRegles(l_mc_presents)

 
 

-    def isMCFact(self):
-        """
-        Retourne 1 si l'objet pointé par self est un MCFact, 0 sinon
-        """
-        return 0
-    
-    def get_mc_presents(self):
-        """ Retourne le dictionnaire des mots-clés présents de l'objet pointé par self """
-        return self.object.dict_mc_presents()
-
-    def verif_condition_regles(self,l_mc_presents):
-        return self.object.verif_condition_regles(l_mc_presents)
-
-    def get_fr(self):
-        """ Retourne le fr de l'objet pointé par self """
-        return self.object.get_fr()
-
-    def get_docu(self):
-        """ Retourne la clé de doc de l'objet pointé par self """
-        return self.object.get_docu()
-
-    def set_valeur(self,new_valeur):
-        """ Remplace la valeur de l'objet pointé par self par new_valeur """
-        return self.object.set_valeur(new_valeur)
-        
-    def GetText(self):
+    def getFr(self):
+        """ Retourne le fr de l'objet pointe par self """
+        try:
+            return self.object.getFr()
+        except:
+            return ""
+
+    def getDocu(self):
+        """ Retourne la cle de doc de l'objet pointe par self """
+        return self.object.getDocu()
+
+    def setValeur(self,new_valeur):
+        """ Remplace la valeur de l'objet pointe par self par new_valeur """
+        return self.object.setValeur(new_valeur)
+
+    def getText(self):

         return myrepr.repr(self.object)
         return myrepr.repr(self.object)

-    
-    def GetIconName(self):
-        if not self.IsExpandable():
+
+    def getIconName(self):
+        if not self.isExpandable():

             return "python"
 
     def IsEditable(self):
             return "python"
 
     def IsEditable(self):

-        return self.setfunction is not None
+        return self.setFunction is not None

 
     def SetText(self, text):
         try:
             value = eval(text)
 
     def SetText(self, text):
         try:
             value = eval(text)

-            self.setfunction(value)
+            self.setFunction(value)

         except:
             pass
         except:
             pass

-# Modif de ma part CCar : je ne comprend pas a quoi ca sert
-# ca parait meme incorrect
-      #  else:
-      #      self.object = value

 
 

-    def IsExpandable(self):
+    def isExpandable(self):

         return 1
         return 1

-        
-    def GetSubList(self):
+
+    def getSubList(self):

         keys = dir(self.object)
         sublist = []
         for key in keys:
         keys = dir(self.object)
         sublist = []
         for key in keys:


@@ -357,8 +416,8 @@ class ObjectTreeItem(TreeItem,Delegate):
                 value = getattr(self.object, key)
             except AttributeError:
                 continue
                 value = getattr(self.object, key)
             except AttributeError:
                 continue

-            item = make_objecttreeitem(
-                self.appli,
+            item = makeObjecttreeitem(
+                self.appliEficas,

                 str(key) + " =",
                 value,
                 lambda value, key=key, object=self.object:
                 str(key) + " =",
                 value,
                 lambda value, key=key, object=self.object:


@@ -366,118 +425,88 @@ class ObjectTreeItem(TreeItem,Delegate):
             sublist.append(item)
         return sublist
 
             sublist.append(item)
         return sublist
 

-    def wait_fichier_init(self):
-        """ Retourne 1 si l'object pointé par self attend un fichier d'initialisation
+    # a piori inutile PN 06 11 17
+    #def wait_fichier_init(self):
+        """ Retourne 1 si l'object pointe par self attend un fichier d'initialisation

         (ex: macros POURSUITE et INCLUDE de Code_Aster), 0 SINON """
         (ex: macros POURSUITE et INCLUDE de Code_Aster), 0 SINON """

-        return self.object.definition.fichier_ini
+    #    return self.object.definition.fichier_ini

 
 

-    def make_objecttreeitem(self,appli,labeltext, object, setfunction=None):
+    def makeObjecttreeitem(self,appliEficas,labeltext, object, setFunction=None):

         """
            Cette methode, globale pour les objets de type item, permet de construire et de retourner un objet
         """
            Cette methode, globale pour les objets de type item, permet de construire et de retourner un objet

-           de type item associé à l'object passé en argument.
+           de type item associe a l'object passe en argument.

         """
         """

-        c = gettreeitem(object)
-        return c(appli,labeltext, object, setfunction)
+        return makeObjecttreeitem(appliEficas,labeltext,object,setFunction)
+
+    #def __del__(self):
+    #    print "__del__",self

 
 class AtomicObjectTreeItem(ObjectTreeItem):
 
 class AtomicObjectTreeItem(ObjectTreeItem):

-    def IsExpandable(self):
+    def isExpandable(self):

         return 0
 
 class SequenceTreeItem(ObjectTreeItem):
         return 0
 
 class SequenceTreeItem(ObjectTreeItem):

-    def IsExpandable(self):
-        return len(self.object) > 0
+    def isExpandable(self):
+        return len(self._object) > 0

 
     def __len__(self) :
 
     def __len__(self) :

-        return len(self.object)
-   
+        return len(self._object)
+

     def keys(self):
     def keys(self):

-        return range(len(self.object))
+        return list(range(len(self._object)))

 
 

-    def GetIconName(self):
-        if self.object.isvalid():
-          return "ast-green-los"
-        elif self.object.isoblig():
-          return "ast-red-los"
+    def getIconName(self):
+        if self._object.isValid():
+            return "ast-green-los"
+        elif self._object.isOblig():
+            return "ast-red-los"

         else:
         else:

-          return "ast-yel-los"
+            return "ast-yel-los"

 
 

-    def ajout_possible(self):
-        return self.object.ajout_possible()
+    def ajoutPossible(self):
+        return self._object.ajoutPossible()

 
 

-    def get_index(self,child):
-        """ Retourne le numéro de child dans la liste des enfants de self """
-        return self.object.get_index(child.object)
+    def getIndex(self,child):
+        """ Retourne le numero de child dans la liste des enfants de self """
+        return self._object.getIndex(child.getObject())

 
 

-    def GetText(self):
-      return  "    "
+    def getText(self):
+        return  "    "

 
 

-    def additem(self,obj,pos):
-        # XXX Passer par addentite  de MCList ???
-        self.object.insert(pos,obj)
-        item = self.make_objecttreeitem(self.appli, obj.nom + ":", obj)
+    def addItem(self,obj,pos):
+        self._object.insert(pos,obj)
+        item = self.makeObjecttreeitem(self.appliEficas, obj.nom + ":", obj)

         return item
 
         return item
 

-    def suppitem(self,item):
-        if not self.object.isMCList():return 1
+    def suppItem(self,item):

         try :
         try :

-            self.object.remove(item.object)
-            # la liste peut être retournée vide !
-            message = "Mot-clé " + item.object.nom + " supprimé"
-            self.appli.affiche_infos(message)
+            self._object.remove(item.getObject())
+            # la liste peut etre retournee vide !
+            message = "Mot-clef " + item.getObject().nom + " supprime"
+            self.appliEficas.afficheInfos(message)

             return 1
         except:
             return 0
 
             return 1
         except:
             return 0
 

-    def GetSubList(self):
-        sublist = []
-        for obj in self.object.data:
-            def setfunction(value, object=obj):
-                object = value
-            item = make_objecttreeitem(self.appli, obj.nom + ":", obj, setfunction)
-            sublist.append(item)
-        return sublist
-
-def gettreeitem(object):
-    """
-       Cette fonction retourne la classe item associée à l'objet object.
-       Cette classe item dépend bien sûr de la nature de object, d'où
-       l'interrogation du dictionnaire composants
-    """
-    if type(object) == types.InstanceType:
-      # On cherche d abord dans les composants (plugins)
-      try:
-        return composants[object.__class__]
-      except:
-        # On cherche une eventuelle classe heritee (aleatoire car sans ordre)
-        for e in composants.keys():
-          if isinstance(object,e):return composants[e]
-    # On n'a rien trouve dans les composants
-    return ObjectTreeItem
-
-def charger_composants():
-    """
-        Cette fonction a pour but de charger tous les modules composants graphiques
-        (fichiers compo*.py dans le même répertoire que ce module )
-        et de remplir le dictionnaire composants utilisé par make_objecttreeitem
-    """
-    composants={}
-    repertoire=os.path.dirname(__file__)
-    listfich=glob.glob(os.path.join(repertoire, "compo*.py"))
-    for fichier in listfich:
-        m= os.path.basename(fichier)[:-3]
-        module=__import__(m,globals(),locals())
-        composants[module.objet]=module.treeitem
-    return composants
-
-def make_objecttreeitem(appli,labeltext, object, setfunction=None):
-    """
-       Cette fonction permet de construire et de retourner un objet
-       de type item associé à l'object passé en argument.
-    """
-    c = gettreeitem(object)
-    return c(appli,labeltext, object, setfunction)
-
-# Dictionnaire {object : item} permettant d'associer un item à un object
-# Ce dictionnaire est renseigné par la méthode charger_composants 
-composants = charger_composants()
-
+    def getSubList(self):
+        isublist=iter(self.sublist)
+        liste=self._object.data
+        iliste=iter(liste)
+        self.sublist=[]
+
+        while(1):
+            old_obj=obj=None
+            for item in isublist:
+                old_obj=item.getObject()
+                if old_obj in liste:break
+
+            for obj in iliste:
+                if obj is old_obj:break
+                # nouvel objet : on cree un nouvel item
+                def setFunction(value, object=obj):
+                    object=value
+                it = self.makeObjecttreeitem(self.appliEficas, obj.nom + " : ", obj, setFunction)
+                self.sublist.append(it)
+            if old_obj is None and obj is None:break
+            if old_obj is obj: self.sublist.append(item)
+        return self.sublist