TypeInstance and basestring

[tools/eficas.git] / Ihm / I_MCCOMPO.py

diff --git a/Ihm/I_MCCOMPO.py b/Ihm/I_MCCOMPO.py
index 8d76911f6ca087c10bdf4488d84072965909c92b..a9976a1ce0cee12c8d5750e7c0bfb123b926112c 100644 (file)
--- a/Ihm/I_MCCOMPO.py
+++ b/Ihm/I_MCCOMPO.py
@@ -1,60 +1,62 @@
 # -*- 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-2017   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

 #
 #

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

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

+from __future__ import absolute_import
+from __future__ import print_function

 import string,types,sys
 from copy import copy
 import traceback
 
 import string,types,sys
 from copy import copy
 import traceback
 

-from Noyau.N_MCLIST import MCList
+import Validation
+from Extensions.i18n import tr

 from Noyau.N_MCSIMP import MCSIMP
 from Noyau.N_MCFACT import MCFACT
 from Noyau.N_MCBLOC import MCBLOC
 from Noyau.N_MCSIMP import MCSIMP
 from Noyau.N_MCFACT import MCFACT
 from Noyau.N_MCBLOC import MCBLOC

-import I_OBJECT
-import Validation
+from Noyau.N_MCLIST import MCList
+from . import I_OBJECT

 
 

-import CONNECTOR
+from . import CONNECTOR

 
 class MCCOMPO(I_OBJECT.OBJECT):
 
 class MCCOMPO(I_OBJECT.OBJECT):

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

     """ 
        Retourne le label de self 
     """ 
        Retourne le label de self 

-       utilisé pour l'affichage dans l'arbre
+       utilise pour l'affichage dans l'arbre

     """
     return self.nom
 
     """
     return self.nom
 

-  def get_liste_mc_ordonnee(self,liste,dico):
+  def getListeMcOrdonnee(self,liste,dico):

     """
     """

-       Retourne la liste ordonnée (suivant le catalogue) des mots-clés
-       d'une entité composée dont le chemin complet est donné sous forme
+       Retourne la liste ordonnee (suivant le catalogue) 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 ...)
+       il faut encore rearranger cette liste (certains mots-cles deja
+       presents ne doivent plus etre proposes, regles ...)

     """
     """

-    return self.filtre_liste_mc(self.get_liste_mc_ordonnee_brute(liste,dico))
+    return self.filtreListeMc(self.getListeMcOrdonneeBrute(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 + ...
     """
     for arg in liste:
        d'une liste du type :ETAPE + MCFACT ou MCBLOC + ...
     """
     for arg in liste:


@@ -62,7 +64,7 @@ class MCCOMPO(I_OBJECT.OBJECT):
         dico=objet_cata.entites
         l=[]
         specifique=0
         dico=objet_cata.entites
         l=[]
         specifique=0

-        for obj in dico.keys() :
+        for obj in list(dico.keys()) :

             if not(hasattr(dico[obj],'cache')) or dico[obj].cache==0 :
                l.append(obj)
             else :
             if not(hasattr(dico[obj],'cache')) or dico[obj].cache==0 :
                l.append(obj)
             else :


@@ -70,37 +72,37 @@ class MCCOMPO(I_OBJECT.OBJECT):
         if specifique == 1 : return l    
     return objet_cata.ordre_mc
 
         if specifique == 1 : return l    
     return objet_cata.ordre_mc
 

-  def filtre_liste_mc(self,liste_brute):
+  def filtreListeMc(self,liste_brute):

     """ 
     """ 

-       Cette méthode est appelée par EFICAS afin de présenter à 
-       l'utilisateur la liste des enfants possibles de self actualisée 
-       en fonction du contexte de self. En clair, sont supprimés de la
-       liste des possibles (fournie par la définition), les mots-clés
-       exclus par les règles de self et les mots-clés ne pouvant plus 
-       être répétés
+       Cette methode est appelee par EFICAS afin de presenter a 
+       l'utilisateur la liste des enfants possibles de self actualisee 
+       en fonction du contexte de self. En clair, sont supprimes de la
+       liste des possibles (fournie par la definition), les mots-cles
+       exclus par les regles de self et les mots-cles ne pouvant plus 
+       etre repetes

     """
     liste = copy(liste_brute)
     """
     liste = copy(liste_brute)

-    liste_mc_presents = self.liste_mc_presents()
-    # on enlève les mots-clés non permis par les règles
+    listeMcPresents = self.listeMcPresents()
+    # on enleve les mots-cles non permis par les regles

     for regle in self.definition.regles:
     for regle in self.definition.regles:

-       # la méthode purge_liste est à développer pour chaque règle qui
-       # influe sur la liste de choix à proposer à l'utilisateur
+       # la methode purgeListe est a developper pour chaque regle qui
+       # influe sur la liste de choix a proposer a l'utilisateur

        # --> EXCLUS,UN_PARMI,PRESENT_ABSENT
        # --> EXCLUS,UN_PARMI,PRESENT_ABSENT

-       liste = regle.purge_liste(liste,liste_mc_presents)
-    # on enlève les mots-clés dont l'occurrence est déjà atteinte
+       liste = regle.purgeListe(liste,listeMcPresents)
+    # on enleve les mots-cles dont l'occurrence est deja atteinte

     liste_copy = copy(liste)
     for k in liste_copy:
     liste_copy = copy(liste)
     for k in liste_copy:

-      objet = self.get_child(k,restreint = 'oui')
+      objet = self.getChild(k,restreint = 'oui')

       if objet != None :
       if objet != None :

-        # l'objet est déjà présent : il faut distinguer plusieurs cas
+        # l'objet est deja present : il faut distinguer plusieurs cas

         if isinstance(objet,MCSIMP):
         if isinstance(objet,MCSIMP):

-          # un mot-clé simple ne peut pas être répété
+          # un mot-cle simple ne peut pas etre repete

           liste.remove(k)
         elif isinstance(objet,MCBLOC):
           liste.remove(k)
         elif isinstance(objet,MCBLOC):

-          # un bloc conditionnel ne doit pas apparaître dans la liste de choix
+          # un bloc conditionnel ne doit pas apparaitre dans la liste de choix

           liste.remove(k)
         elif isinstance(objet,MCFACT):
           liste.remove(k)
         elif isinstance(objet,MCFACT):

-          # un mot-clé facteur ne peut pas être répété plus de self.max fois
+          # un mot-cle facteur ne peut pas etre repete plus de self.max fois

           if objet.definition.max == 1:
             liste.remove(k)
         elif isinstance(objet,MCList):
           if objet.definition.max == 1:
             liste.remove(k)
         elif isinstance(objet,MCList):


@@ -111,22 +113,22 @@ class MCCOMPO(I_OBJECT.OBJECT):
           except:
             pass
         else :
           except:
             pass
         else :

-          #XXX CCAR : les MCNUPLET ne sont pas traités
-          if CONTEXT.debug : print '   ',k,' est un objet de type inconnu :',type(objet)
+          #XXX CCAR : les MCNUPLET ne sont pas traites
+          if CONTEXT.debug : print('   ',k,' est un objet de type inconnu :',type(objet))

       else :
       else :

-        # l'objet est absent : on enlève de la liste les blocs
+        # l'objet est absent : on enleve de la liste les blocs

         if self.definition.entites[k].statut=='c' :
           liste.remove(k)
         if self.definition.entites[k].label=='BLOC':
           liste.remove(k)
         if self.definition.entites[k].statut=='c' :
           liste.remove(k)
         if self.definition.entites[k].label=='BLOC':
           liste.remove(k)

-    # Pour corriger les exces qui pourraient etre commis dans la methode purge_liste
+    # Pour corriger les exces qui pourraient etre commis dans la methode purgeListe

     # des regles, on essaie de compenser comme suit :
     # on ajoute les mots cles facteurs presents dont l'occurence n'est pas atteinte
     # des regles, on essaie de compenser comme suit :
     # on ajoute les mots cles facteurs presents dont l'occurence n'est pas atteinte

-    for k in liste_mc_presents:
+    for k in listeMcPresents:

       if k in liste:continue
       if k in liste:continue

-      objet = self.get_child(k,restreint = 'oui')
+      objet = self.getChild(k,restreint = 'oui')

       if isinstance(objet,MCFACT):
       if isinstance(objet,MCFACT):

-          # un mot-clé facteur ne peut pas être répété plus de self.max fois
+          # un mot-cle facteur ne peut pas etre repete plus de self.max fois

           if objet.definition.max > 1:
              liste.append(k)
       elif isinstance(objet,MCList):
           if objet.definition.max > 1:
              liste.append(k)
       elif isinstance(objet,MCList):


@@ -135,25 +137,25 @@ class MCCOMPO(I_OBJECT.OBJECT):
               liste.append(k)
     return liste
 
               liste.append(k)
     return liste
 

-  def liste_mc_presents(self):
+  def listeMcPresents(self):

     """ 
     """ 

-       Retourne la liste des noms des mots-clés fils de self présents construite
-       à partir de self.mc_liste 
+       Retourne la liste des noms des mots-cles fils de self presents construite
+       a partir de self.mcListe 

     """
     l=[]
     """
     l=[]

-    for v in self.mc_liste:
+    for v in self.mcListe:

       k=v.nom
       l.append(k)
     return l
 
       k=v.nom
       l.append(k)
     return l
 

-  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

-        Permet de savoir à quelle position il faut ajouter un nouveau mot-clé
+        Permet de savoir a quelle position il faut ajouter un nouveau mot-cle

       """
       cata_ordonne = self.jdc.cata_ordonne_dico
       """
       cata_ordonne = self.jdc.cata_ordonne_dico

-      liste_noms_mc_ordonnee = self.get_liste_mc_ordonnee_brute(self.get_genealogie(),cata_ordonne)
-      liste_noms_mc_presents = self.liste_mc_presents()
+      liste_noms_mc_ordonnee = self.getListeMcOrdonneeBrute(self.getGenealogie(),cata_ordonne)
+      liste_noms_mc_presents = self.listeMcPresents()

       index=0
       for nom in liste_noms_mc_ordonnee:
           if nom == nom_fils:break
       index=0
       for nom in liste_noms_mc_ordonnee:
           if nom == nom_fils:break


@@ -161,146 +163,161 @@ class MCCOMPO(I_OBJECT.OBJECT):
           index=index+1
       return index
           
           index=index+1
       return index
           

-  def ordonne_liste_mc(self,liste_mc_a_ordonner,liste_noms_mc_ordonnee):
+  def findRangObjetDsArbre(self,objet) :
+  # uniquement pour Pyxb
+  # parcourt les Blocs
+      leRang=0
+      pos=self.mcListe.index(objet)
+      i=0
+      while (i+1) < pos :
+        leRang= leRang + self.mcListe[i].longueurDsArbre()
+        i=i+1
+      return leRang
+ 
+
+  def ordonneListeMc(self,listeMc_a_ordonner,liste_noms_mc_ordonnee):

     """
     """

-        Retourne liste_mc_a_ordonner ordonnée suivant l'ordre 
-        donné par liste_noms_mc_ordonnee
+        Retourne listeMc_a_ordonner ordonnee suivant l'ordre 
+        donne par liste_noms_mc_ordonnee

     """
     liste = []
     """
     liste = []

-    # on transforme liste_a_ordonner en un dictionnaire (plus facile à consulter)
+    # on transforme liste_a_ordonner en un dictionnaire (plus facile a consulter)

     d_mc = {}
     d_mc = {}

-    for mc in liste_mc_a_ordonner:
+    for mc in listeMc_a_ordonner:

       d_mc[mc.nom]=mc
       d_mc[mc.nom]=mc

-    # on construit la liste des objets ordonnés
+    # on construit la liste des objets ordonnes

     for nom_mc in liste_noms_mc_ordonnee:
     for nom_mc in liste_noms_mc_ordonnee:

-      if d_mc.has_key(nom_mc):
+      if nom_mc in d_mc:

         liste.append(d_mc.get(nom_mc))
     # on la retourne
     return liste
 
         liste.append(d_mc.get(nom_mc))
     # on la retourne
     return liste
 

-  def suppentite(self,objet) :
+  def suppEntite(self,objet) :

     """ 
         Supprime le fils 'objet' de self : 
     """ 
         Supprime le fils 'objet' de self : 

-        Retourne 1 si la suppression a pu être effectuée,
+        Retourne 1 si la suppression a pu etre effectuee,

         Retourne 0 dans le cas contraire
     """
         Retourne 0 dans le cas contraire
     """

-    if not objet in self.mc_liste:
-       # Impossible de supprimer objet. Il n'est pas dans mc_liste
+    if not objet in self.mcListe:
+       # Impossible de supprimer objet. Il n'est pas dans mcListe

        return 0
 
        return 0
 

-    self.init_modif()
-    self.mc_liste.remove(objet)
+    self.initModif()
+    #objet.deletePyxbObject()
+    self.mcListe.remove(objet)

     CONNECTOR.Emit(self,"supp",objet)
     CONNECTOR.Emit(self,"supp",objet)

-    objet.delete_mc_global()
-    objet.update_condition_bloc()
+    objet.deleteMcGlobal()
+    objet.updateConditionBloc()

     objet.supprime()
     self.etape.modified()
     objet.supprime()
     self.etape.modified()

-    self.fin_modif()
+    self.finModif()

     return 1
 
     return 1
 

-  def isoblig(self):
+  def isOblig(self):

       return 0
 
       return 0
 

-  def addentite(self,name,pos=None):
+  def addEntite(self,name,pos=None):

       """ 
       """ 

-          Ajoute le mot-cle name à la liste des mots-cles de
+          Ajoute le mot-cle name a la liste des mots-cles de

           l'objet MCCOMPOSE
       """
           l'objet MCCOMPOSE
       """

-      self.init_modif()
-      if type(name)==types.StringType :
-        # on est en mode création d'un motcle 
+      self.initModif()
+      if type(name)==bytes or type(name) == str :
+        # on est en mode creation d'un motcle 

         if self.ispermis(name) == 0 : return 0
         objet=self.definition.entites[name](val=None,nom=name,parent=self)
       else :
         # dans ce cas on est en mode copie d'un motcle
         if self.ispermis(name) == 0 : return 0
         objet=self.definition.entites[name](val=None,nom=name,parent=self)
       else :
         # dans ce cas on est en mode copie d'un motcle

-        objet = name

         # Appel de la methode qui fait le menage dans les references
         # sur les concepts produits (verification que les concepts existent
         # dans le contexte de la commande courante).
         # Appel de la methode qui fait le menage dans les references
         # sur les concepts produits (verification que les concepts existent
         # dans le contexte de la commande courante).

-        objet.verif_existence_sd()
+        objet.verifExistenceSd()

 
       # On verifie que l'ajout d'objet est autorise
       if self.ispermis(objet) == 0:
 
       # On verifie que l'ajout d'objet est autorise
       if self.ispermis(objet) == 0:

-        self.jdc.appli.affiche_alerte("Erreur","L'objet %s ne peut être un fils de %s" %(objet.nom,
-                                                                        self.nom))
-        self.fin_modif()
+        self.jdc.appli.afficheAlerte(tr("Erreur"),
+                                      tr("L'objet %(v_1)s ne peut  etre un fils de %(v_2)s",\
+                                      {'v_1': objet.nom, 'v_2': self.nom}))
+        self.finModif()

         return 0
 
       # On cherche s'il existe deja un mot cle de meme nom
         return 0
 
       # On cherche s'il existe deja un mot cle de meme nom

-      old_obj = self.get_child(objet.nom,restreint = 'oui')
+      old_obj = self.getChild(objet.nom,restreint = 'oui')

       if not old_obj :
          # on normalize l'objet
          objet=objet.normalize()
          # Le mot cle n'existe pas encore. On l'ajoute a la position
          # demandee (pos)
          if pos == None :
       if not old_obj :
          # on normalize l'objet
          objet=objet.normalize()
          # Le mot cle n'existe pas encore. On l'ajoute a la position
          # demandee (pos)
          if pos == None :

-           self.mc_liste.append(objet)
+           self.mcListe.append(objet)

          else :
          else :

-           self.mc_liste.insert(pos,objet)
+           self.mcListe.insert(pos,objet)

          # Il ne faut pas oublier de reaffecter le parent d'obj (si copie)
          objet.reparent(self)
          # Il ne faut pas oublier de reaffecter le parent d'obj (si copie)
          objet.reparent(self)

+         #objet.addPyxbObject(self.findRangObjetDsArbre(objet))

          CONNECTOR.Emit(self,"add",objet)
          CONNECTOR.Emit(self,"add",objet)

-         objet.update_mc_global()
-         objet.update_condition_bloc()
-         self.fin_modif()
+         objet.updateMcGlobal()
+         objet.updateConditionBloc()
+         self.finModif()

          return objet
       else:
          # Le mot cle existe deja. Si le mot cle est repetable,
          # on cree une liste d'objets. Dans le cas contraire,
          # on emet un message d'erreur.
          return objet
       else:
          # Le mot cle existe deja. Si le mot cle est repetable,
          # on cree une liste d'objets. Dans le cas contraire,
          # on emet un message d'erreur.

-         if not old_obj.isrepetable():
-            self.jdc.appli.affiche_alerte("Erreur","L'objet %s ne peut pas être répété" %objet.nom)
-            self.fin_modif()
+         if not old_obj.isRepetable():
+            self.jdc.appli.afficheAlerte(tr("Erreur"),tr("L'objet %s ne peut pas etre repete", objet.nom))
+            self.finModif()

             return 0
          else:
             return 0
          else:

-            # une liste d'objets de même type existe déjà
-            old_obj.addentite(objet)
-            self.fin_modif()
+            # une liste d'objets de meme type existe deja
+            old_obj.addEntite(objet)
+            self.finModif()

             return old_obj
 
   def ispermis(self,fils):
     """ 
         Retourne 1 si l'objet de nom nom_fils 
             return old_obj
 
   def ispermis(self,fils):
     """ 
         Retourne 1 si l'objet de nom nom_fils 

-        est bien permis, cad peut bien être un fils de self, 
+        est bien permis, cad peut bien etre un fils de self, 

         Retourne 0 sinon 
     """
         Retourne 0 sinon 
     """

-    if type(fils) == types.StringType :
+    if type(fils) == bytes or type(fils) == str :

       # on veut juste savoir si self peut avoir un fils de nom 'fils'
       # on veut juste savoir si self peut avoir un fils de nom 'fils'

-      if self.definition.entites.has_key(fils):
+      if fils in self.definition.entites:

         return 1
       else :
         return 0
         return 1
       else :
         return 0

-    elif type(fils) == types.InstanceType:
+    #elif type(fils) == types.InstanceType:
+    elif isinstance(fils,object):

       # fils est un objet (commande,mcf,mclist)
       # on est dans le cas d'une tentative de copie de l'objet
       # fils est un objet (commande,mcf,mclist)
       # on est dans le cas d'une tentative de copie de l'objet

-      # on veut savoir si l'objet peut bien être un fils de self :
-      # la vérification du nom de suffit pas (plusieurs commandes
-      # ont le même mot-clé facteur AFFE ... et c'est l'utilisateur
-      # qui choisit le père d'où un risque d'erreur)
-      if not self.definition.entites.has_key(fils.nom):
+      # on veut savoir si l'objet peut bien etre un fils de self :
+      # la verification du nom de suffit pas (plusieurs commandes
+      # ont le meme mot-cle facteur AFFE ... et c'est l'utilisateur
+      # qui choisit le pere d'ou un risque d'erreur)
+      if not fils.nom in self.definition.entites:

         return 0
       else:
         if fils.parent.nom != self.nom : return 0
       return 1
 
         return 0
       else:
         if fils.parent.nom != self.nom : return 0
       return 1
 

-  def update_concept(self,sd):
-    for child in self.mc_liste :
-        child.update_concept(sd)
+  def updateConcept(self,sd):
+    for child in self.mcListe :
+        child.updateConcept(sd)

 
 

-  def delete_concept(self,sd):
+  def deleteConcept(self,sd):

     """ 
         Inputs :
            - sd=concept detruit
         Fonction :
     """ 
         Inputs :
            - sd=concept detruit
         Fonction :

-        Mettre a jour les fils de l objet suite à la disparition du
+        Mettre a jour les fils de l objet suite a la disparition du

         concept sd
         Seuls les mots cles simples MCSIMP font un traitement autre que 
         de transmettre aux fils
     """
         concept sd
         Seuls les mots cles simples MCSIMP font un traitement autre que 
         de transmettre aux fils
     """

-    for child in self.mc_liste :
-      child.delete_concept(sd)
+    for child in self.mcListe :
+      child.deleteConcept(sd)

 
 

-  def replace_concept(self,old_sd,sd):
+  def replaceConcept(self,old_sd,sd):

     """
         Inputs :
            - old_sd=concept remplace
     """
         Inputs :
            - old_sd=concept remplace


@@ -309,119 +326,119 @@ class MCCOMPO(I_OBJECT.OBJECT):
         Mettre a jour les fils de l objet suite au remplacement  du
         concept old_sd
     """
         Mettre a jour les fils de l objet suite au remplacement  du
         concept old_sd
     """

-    for child in self.mc_liste :
-      child.replace_concept(old_sd,sd)
+    for child in self.mcListe :
+      child.replaceConcept(old_sd,sd)

 
 

-  def get_liste_mc_inconnus(self):
+  def getListeMcInconnus(self):

      """
      """

-     Retourne la liste des mots-clés inconnus dans self
+     Retourne la liste des mots-cles inconnus dans self

      """
      l_mc = []
      if self.reste_val != {}:
         for k,v in self.reste_val.items() :
             l_mc.append([self,k,v])
      """
      l_mc = []
      if self.reste_val != {}:
         for k,v in self.reste_val.items() :
             l_mc.append([self,k,v])

-     for child in self.mc_liste :
-        if child.isvalid() : continue
-        l_child = child.get_liste_mc_inconnus()
+     for child in self.mcListe :
+        if child.isValid() : continue
+        l_child = child.getListeMcInconnus()

         for mc in l_child:
            l = [self]
            l.extend(mc)
            l_mc.append(l)
      return l_mc
 
         for mc in l_child:
            l = [self]
            l.extend(mc)
            l_mc.append(l)
      return l_mc
 

-  def deep_update_condition_bloc(self):
+  def deepUpdateConditionBloc(self):

      """
         Parcourt l'arborescence des mcobject et realise l'update 
      """
         Parcourt l'arborescence des mcobject et realise l'update 

-        des blocs conditionnels par appel de la methode update_condition_bloc
+        des blocs conditionnels par appel de la methode updateConditionBloc

      """
      """

-     self._update_condition_bloc()
-     for mcobj in self.mc_liste:
-        if hasattr(mcobj,"deep_update_condition_bloc"):
-           mcobj.deep_update_condition_bloc()
+     self._updateConditionBloc()
+     for mcobj in self.mcListe:
+        if hasattr(mcobj,"deepUpdateConditionBloc"):
+           mcobj.deepUpdateConditionBloc()

 
 

-  def update_condition_bloc(self):
+  def updateConditionBloc(self):

      """
         Realise l'update des blocs conditionnels fils de self
         et propage au parent
      """
      """
         Realise l'update des blocs conditionnels fils de self
         et propage au parent
      """

-     self._update_condition_bloc()
-     if self.parent:self.parent.update_condition_bloc()
+     self._updateConditionBloc()
+     if self.parent:self.parent.updateConditionBloc()

 
 

-  def _update_condition_bloc(self):
+  def _updateConditionBloc(self):

      """
         Realise l'update des blocs conditionnels fils de self
      """
      """
         Realise l'update des blocs conditionnels fils de self
      """

-     dict = self.cree_dict_condition(self.mc_liste,condition=1)
+     dict = self.creeDictCondition(self.mcListe,condition=1)

      for k,v in self.definition.entites.items():
         if v.label != 'BLOC' :continue
         globs= self.jdc and self.jdc.condition_context or {}
      for k,v in self.definition.entites.items():
         if v.label != 'BLOC' :continue
         globs= self.jdc and self.jdc.condition_context or {}

-        bloc=self.get_child(k,restreint = 'oui')
-        presence=v.verif_presence(dict,globs)
+        bloc=self.getChild(k,restreint = 'oui')
+        presence=v.verifPresence(dict,globs)

         if presence and not bloc:
         if presence and not bloc:

-           # le bloc doit être présent
-           # mais le bloc n'est pas présent et il doit être créé
+           # le bloc doit etre present
+           # mais le bloc n'est pas present et il doit etre cree

            #print "AJOUT BLOC",k
            #print "AJOUT BLOC",k

-           pos=self.get_index_child(k)
-           self.addentite(k,pos)
+           pos=self.getIndexChild(k)
+           self.addEntite(k,pos)

         if not presence and bloc:
         if not presence and bloc:

-           # le bloc devrait être absent
-           # le bloc est présent : il faut l'enlever
+           # le bloc devrait etre absent
+           # le bloc est present : il faut l'enlever

            #print "SUPPRESSION BLOC",k,bloc
            #print "SUPPRESSION BLOC",k,bloc

-           self.suppentite(bloc)
+           self.suppEntite(bloc)

 
 

-  def verif_condition_bloc(self):
+  def verifConditionBloc(self):

     """ 
         Evalue les conditions de tous les blocs fils possibles 
     """ 
         Evalue les conditions de tous les blocs fils possibles 

-        (en fonction du catalogue donc de la définition) de self
+        (en fonction du catalogue donc de la definition) de self

         et retourne deux listes :
         et retourne deux listes :

-          - la première contient les noms des blocs à rajouter
-          - la seconde contient les noms des blocs à supprimer
+          - la premiere contient les noms des blocs a rajouter
+          - la seconde contient les noms des blocs a supprimer

     """
     liste_ajouts = []
     liste_retraits = []
     """
     liste_ajouts = []
     liste_retraits = []

-    dict = self.cree_dict_condition(self.mc_liste,condition=1)
+    dict = self.creeDictCondition(self.mcListe,condition=1)

     for k,v in self.definition.entites.items():
       if v.label=='BLOC' :
         globs= self.jdc and self.jdc.condition_context or {}
     for k,v in self.definition.entites.items():
       if v.label=='BLOC' :
         globs= self.jdc and self.jdc.condition_context or {}

-        if v.verif_presence(dict,globs):
-          # le bloc doit être présent
-          if not self.get_child(k,restreint = 'oui'):
-            # le bloc n'est pas présent et il doit être créé
+        if v.verifPresence(dict,globs):
+          # le bloc doit etre present
+          if not self.getChild(k,restreint = 'oui'):
+            # le bloc n'est pas present et il doit etre cree

             liste_ajouts.append(k)
         else :
             liste_ajouts.append(k)
         else :

-          # le bloc doit être absent
-          if self.get_child(k,restreint = 'oui'):
-            # le bloc est présent : il faut l'enlever
+          # le bloc doit etre absent
+          if self.getChild(k,restreint = 'oui'):
+            # le bloc est present : il faut l'enlever

             liste_retraits.append(k)
     return liste_ajouts,liste_retraits
 
             liste_retraits.append(k)
     return liste_ajouts,liste_retraits
 

-  def verif_existence_sd(self):
+  def verifExistenceSd(self):

      """
      """

-        Vérifie que les structures de données utilisées dans self existent bien dans le contexte
-        avant étape, sinon enlève la référence à ces concepts
+        Verifie que les structures de donnees utilisees dans self existent bien dans le contexte
+        avant etape, sinon enleve la reference a ces concepts

      """
      """

-     for motcle in self.mc_liste :
-         motcle.verif_existence_sd()
+     for motcle in self.mcListe :
+         motcle.verifExistenceSd()

 
 

-  def update_mc_global(self):
+  def updateMcGlobal(self):

      """
      """

-        Met a jour les mots cles globaux enregistrés dans l'étape parente 
+        Met a jour les mots cles globaux enregistres dans l'etape parente 

         et dans le jdc parent.
         Un mot cle compose ne peut pas etre global. Il se contente de passer
         la requete a ses fils.
      """
         et dans le jdc parent.
         Un mot cle compose ne peut pas etre global. Il se contente de passer
         la requete a ses fils.
      """

-     for motcle in self.mc_liste :
-         motcle.update_mc_global()
+     for motcle in self.mcListe :
+         motcle.updateMcGlobal()

 
 

-  def delete_mc_global(self):
-     for motcle in self.mc_liste :
-         motcle.delete_mc_global()
+  def deleteMcGlobal(self):
+     for motcle in self.mcListe :
+         motcle.deleteMcGlobal()

      try :
      try :

-         motcle.update_mc_global()
+         motcle.updateMcGlobal()

      except :
      except :

-       pass
+         pass

 
 

-  def init_modif_up(self):
-    Validation.V_MCCOMPO.MCCOMPO.init_modif_up(self)
+  def initModifUp(self):
+    Validation.V_MCCOMPO.MCCOMPO.initModifUp(self)

     CONNECTOR.Emit(self,"valid")
 
     CONNECTOR.Emit(self,"valid")