Salome HOME
commentaire
[tools/eficas.git] / Ihm / I_ETAPE.py
index 4664252bc48c38ca47cd0e43067696e00e31a739..7ece4b6f6d145eea0216487572b47b73d13bd19c 100644 (file)
@@ -1,43 +1,49 @@
 # -*- 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-2013   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
 #
 #
-# ======================================================================
 """
 """
 # Modules Python
 """
 """
 # Modules Python
+from __future__ import absolute_import
+from __future__ import print_function
 import sys,re
 import sys,re
-import string,types
+import types
 from copy import copy
 
 from copy import copy
 
+from Extensions.i18n import tr
+from Extensions.eficas_exception import EficasException
+
 # Objet re pour controler les identificateurs Python
 concept_re=re.compile(r'[a-zA-Z_]\w*$')
 
 # Objet re pour controler les identificateurs Python
 concept_re=re.compile(r'[a-zA-Z_]\w*$')
 
-# import rajoutés suite à l'ajout de Build_sd --> à résorber
+# import rajoute suite a l'ajout de Build_sd --> a resorber
 import traceback
 import Noyau
 from Noyau import N_Exception
 from Noyau.N_Exception import AsException
 import traceback
 import Noyau
 from Noyau import N_Exception
 from Noyau.N_Exception import AsException
-# fin import à résorber
+import Validation
+# fin import a resorber
 
 # Modules EFICAS
 
 # Modules EFICAS
-import I_MCCOMPO
-import CONNECTOR
+from . import I_MCCOMPO
+from . import CONNECTOR
+from Extensions import commande_comm
 
 class ETAPE(I_MCCOMPO.MCCOMPO):
 
 
 class ETAPE(I_MCCOMPO.MCCOMPO):
 
@@ -45,14 +51,16 @@ class ETAPE(I_MCCOMPO.MCCOMPO):
       return self.nom
 
    def get_sdname(self):
       return self.nom
 
    def get_sdname(self):
-      if CONTEXT.debug : print "SDNAME ",self.reuse,self.sd,self.sd.get_name()
+      #print "SDNAME ",self.reuse,self.sd,self.sd.get_name()
+      if CONTEXT.debug : 
+          print(("SDNAME ",  self.reuse,  self.sd,  self.sd.get_name()))
       sdname=''
       if self.reuse != None:
         sdname= self.reuse.get_name()
       else:
         if self.sd:sdname=self.sd.get_name()
       sdname=''
       if self.reuse != None:
         sdname= self.reuse.get_name()
       else:
         if self.sd:sdname=self.sd.get_name()
-      if string.find(sdname,'sansnom') != -1 or string.find(sdname,'SD_') != -1:
-        # dans le cas où la SD est 'sansnom' ou 'SD_' on retourne la chaîne vide
+      if sdname.find('sansnom') != -1 or sdname.find('SD_') != -1:
+        # dans le cas ou la SD est 'sansnom' ou 'SD_' on retourne la chaine vide
         return ''
       return sdname
 
         return ''
       return sdname
 
@@ -64,12 +72,12 @@ class ETAPE(I_MCCOMPO.MCCOMPO):
 
    def init_modif(self):
       """
 
    def init_modif(self):
       """
-         Met l'état de l'étape à : modifié
+         Met l'etat de l'etape a : modifie
          Propage la modification au parent
       """
          Propage la modification au parent
       """
-      # init_modif doit etre appelé avant de réaliser une modification
-      # La validité devra etre recalculée apres cette modification
-      # mais dans l'appel à fin_modif pour préserver l'état modified
+      # init_modif doit etre appele avant de realiser une modification
+      # La validite devra etre recalculee apres cette modification
+      # mais dans l'appel a fin_modif pour preserver l'etat modified
       # de tous les objets entre temps
       #print "init_modif",self,self.parent
       self.state = 'modified'
       # de tous les objets entre temps
       #print "init_modif",self,self.parent
       self.state = 'modified'
@@ -78,128 +86,128 @@ class ETAPE(I_MCCOMPO.MCCOMPO):
 
    def fin_modif(self):
       """
 
    def fin_modif(self):
       """
-          Méthode appelée une fois qu'une modification a été faite afin de 
-          déclencher d'éventuels traitements post-modification
+          Methode appelee une fois qu'une modification a ete faite afin de 
+          declencher d'eventuels traitements post-modification
           ex : INCLUDE et POURSUITE
           ex : INCLUDE et POURSUITE
+          Ne pas mettre de traitement qui risque d'induire des recursions (soit a peu pres rien)
       """
       """
-      #print "fin_modif",self,self.parent
-      #if hasattr(self,'jdc_aux'):print "fin_modif",self.jdc_aux.context_ini
-      if self.isvalid() :
-         #if hasattr(self,'jdc_aux'):print "fin_modif",self.jdc_aux.context_ini
-         d=self.parent.get_contexte_apres(self)
-         #print d
-      #if hasattr(self,'jdc_aux'):print "fin_modif",self.jdc_aux.context_ini
       CONNECTOR.Emit(self,"valid")
       if self.parent:
         self.parent.fin_modif()
 
    def nomme_sd(self,nom) :
       """
       CONNECTOR.Emit(self,"valid")
       if self.parent:
         self.parent.fin_modif()
 
    def nomme_sd(self,nom) :
       """
-          Cette méthode a pour fonction de donner un nom (nom) au concept 
-          produit par l'étape (self).
-            - si le concept n'existe pas, on essaye de le créer (à condition que l'étape soit valide ET non réentrante)
-            - si il existe déjà, on le renomme et on répercute les changements dans les autres étapes    
+          Cette methode a pour fonction de donner un nom (nom) au concept 
+          produit par l'etape (self).
+            - si le concept n'existe pas, on essaye de le creer a condition que l'etape soit valide ET non reentrante)
+            - si il existe dea, on le renomme et on repercute les changements dans les autres etapes    
           Les valeurs de retour sont :
           Les valeurs de retour sont :
-            - 0 si le nommage n'a pas pu etre mené à son terme,
+            - 0 si le nommage n'a pas pu etre menea son terme,
             - 1 dans le cas contraire
       """
       # Le nom d'un concept doit etre un identificateur Python (toujours vrai ?)
       if not concept_re.match(nom):
             - 1 dans le cas contraire
       """
       # Le nom d'un concept doit etre un identificateur Python (toujours vrai ?)
       if not concept_re.match(nom):
-         return 0,"Un nom de concept doit etre un identificateur Python"
+         return 0, tr("Un nom de concept doit etre un identificateur Python")
 
 
-      if len(nom) > 8 and self.jdc.definition.code == 'ASTER':
-        return 0,"Nom de concept trop long (maxi 8 caractères)"
+      #if len(nom) > 8 and self.jdc.definition.code == 'ASTER':
+      #  return 0, tr("Nom de concept trop long (maxi 8 caracteres)")
 
       self.init_modif()
       #
       # On verifie d'abord si les mots cles sont valides
       #
 
       self.init_modif()
       #
       # On verifie d'abord si les mots cles sont valides
       #
-      if not self.isvalid(sd='non') : return 0,"Nommage du concept refusé : l'opérateur n'est pas valide"
+      if not self.isvalid(sd='non') : return 0,"Nommage du concept refuse : l'operateur n'est pas valide"
       #
       #
-      # Cas particulier des opérateurs obligatoirement réentrants
+      # Cas particulier des operateurs obligatoirement reentrants
       #
       if self.definition.reentrant == 'o':
       #
       if self.definition.reentrant == 'o':
-       self.sd = self.reuse = self.jdc.get_sd_avant_etape(nom,self)
+        self.sd = self.reuse = self.jdc.get_sd_avant_etape(nom,self)
         if self.sd != None :
           self.sdnom=self.sd.nom
           self.fin_modif()
         if self.sd != None :
           self.sdnom=self.sd.nom
           self.fin_modif()
-          return 1,"Concept existant"
+          return 1, tr("Concept existant")
         else:
         else:
-          return 0,"Opérateur réentrant mais concept non existant"
+          return 0, tr("Operateur reentrant mais concept non existant")
       #
       #
-      # Cas particulier des opérateurs facultativement réentrants
+      # Cas particulier des operateurs facultativement reentrants
       #
       old_reuse=None
       if self.definition.reentrant == 'f' :
         sd = self.jdc.get_sd_avant_etape(nom,self)
         if sd != None :
       #
       old_reuse=None
       if self.definition.reentrant == 'f' :
         sd = self.jdc.get_sd_avant_etape(nom,self)
         if sd != None :
-         # FR : il faut tester que la sd trouvée est du bon type !!!!!!!!!!!!!!!!!
-         if isinstance(sd,self.get_type_produit()) :
+          if isinstance(sd,self.get_type_produit()) :
              self.sd = self.reuse = sd
              self.sdnom = sd.nom
              self.fin_modif()
              self.sd = self.reuse = sd
              self.sdnom = sd.nom
              self.fin_modif()
-             return 1,"Opérateur facultativement réentrant et concept existant trouvé"
-         else:
-            return 0,"Concept déjà existant et de mauvais type"
+             return 1, tr("Operateur reentrant et concept existant trouve")
+          else:
+             return 0, tr("Concept deja existant et de mauvais type")
         else :
           # il faut enlever le lien vers une SD existante car si on passe ici
         else :
           # il faut enlever le lien vers une SD existante car si on passe ici
-         # cela signifie que l'opérateur n'est pas utilisé en mode réentrant.
-         # Si on ne fait pas cela, on risque de modifier une SD produite par un autre opérateur
-         if self.reuse :
+          # cela signifie que l'operateur n'est pas utilise en mode reentrant.
+          # Si on ne fait pas cela, on risque de modifier une SD produite par un autre operateur
+          if self.reuse :
              old_reuse=self.reuse
              old_reuse=self.reuse
-            self.sd = self.reuse = self.sdnom = None
+             self.sd = self.reuse = self.sdnom = None
       #
       #
-      # On est dans le cas ou l'opérateur n'est pas réentrant ou est facultativement reentrant
-      # mais est utilisé en mode non réentrant
+      # On est dans le cas ou l'operateur n'est pas reentrant ou est facultativement reentrant
+      # mais est utilise en mode non reentrant
       #
       if self.sd == None :
       #
       if self.sd == None :
+          #Pas de concept produit preexistant
           if self.parent.get_sd_autour_etape(nom,self):
             # Un concept de ce nom existe dans le voisinage de l'etape courante
             # On retablit l'ancien concept reentrant s'il existait
             if old_reuse:
                self.sd=self.reuse=old_reuse
                self.sdnom=old_reuse.nom
           if self.parent.get_sd_autour_etape(nom,self):
             # Un concept de ce nom existe dans le voisinage de l'etape courante
             # On retablit l'ancien concept reentrant s'il existait
             if old_reuse:
                self.sd=self.reuse=old_reuse
                self.sdnom=old_reuse.nom
-            return 0,"Nommage du concept refuse : un concept de meme nom existe deja"
+            return 0, tr("Nommage du concept refuse : un concept de meme nom existe deja")
           else:
             # Il n'existe pas de concept de ce nom dans le voisinage de l'etape courante
           else:
             # Il n'existe pas de concept de ce nom dans le voisinage de l'etape courante
-            # On peut donc créer le concept retourné.
-            # Il est créé sans nom mais enregistré dans la liste des concepts existants
+            # On peut donc creer le concept retourne
+            # Il est cree sans nom mais enregistre dans la liste des concepts existants
             try:
                self.get_sd_prod()
             try:
                self.get_sd_prod()
-               # Il suffit de changer son attribut nom pour le nommer
+               # Renommage du concept : Il suffit de changer son attribut nom pour le nommer
                self.sd.nom = nom
                self.sdnom=nom
                self.sd.nom = nom
                self.sdnom=nom
+               self.parent.update_concept_after_etape(self,self.sd)
                self.fin_modif()
                self.fin_modif()
-               return 1,"Nommage du concept effectué"
+               return 1, tr("Nommage du concept effectue")
             except:
             except:
-               return 0,"Nommage impossible"+str(sys.exc_info()[1])
+               return 0, tr("Nommage impossible %s", str(sys.exc_info()[1]))
       else :
       else :
+          #Un concept produit preexiste
           old_nom=self.sd.nom
           old_nom=self.sd.nom
-          if string.find(old_nom,'sansnom') :
-            # Dans le cas où old_nom == sansnom, isvalid retourne 0 alors que ...
-           # par contre si le concept existe et qu'il s'appelle sansnom c'est que l'étape est valide
-           # on peut donc le nommer sans test préalable
+          if old_nom.find('sansnom') :
+            # Dans le cas ou old_nom == sansnom, isvalid retourne 0 alors que ...
+            # par contre si le concept existe et qu'il s'appelle sansnom c'est que l'etape est valide
+            # on peut donc le nommer sans test prealable
             if self.parent.get_sd_autour_etape(nom,self):
             if self.parent.get_sd_autour_etape(nom,self):
-              return 0,"Nommage du concept refuse : un concept de meme nom existe deja"
+              return 0, tr("Nommage du concept refuse : un concept de meme nom existe deja")
             else:
             else:
-             self.sd.nom=nom
+              # Renommage du concept : Il suffit de changer son attribut nom pour le nommer
+              self.sd.nom=nom
               self.sdnom=nom
               self.sdnom=nom
+              self.parent.update_concept_after_etape(self,self.sd)
               self.fin_modif()
               self.fin_modif()
-              return 1,"Nommage du concept effectué"
+              return 1, tr("Nommage du concept effectue")
           if self.isvalid() :
             # Normalement l appel de isvalid a mis a jour le concept produit (son type)
           if self.isvalid() :
             # Normalement l appel de isvalid a mis a jour le concept produit (son type)
-            # Il suffit de spécifier l attribut nom de sd pour le nommer si le nom n est pas
-            # deja attribué
+            # Il suffit de specifier l attribut nom de sd pour le nommer si le nom n est pas
+            # deja attribue
             if self.parent.get_sd_autour_etape(nom,self):
             if self.parent.get_sd_autour_etape(nom,self):
-              return 0,"Nommage du concept refuse : un concept de meme nom existe deja"
+              return 0, tr("Nommage du concept refuse : un concept de meme nom existe deja")
             else:
             else:
+              # Renommage du concept : Il suffit de changer son attribut nom pour le nommer
               self.sd.nom=nom
               self.sdnom=nom
               self.sd.nom=nom
               self.sdnom=nom
+              self.parent.update_concept_after_etape(self,self.sd)
               self.fin_modif()
               self.fin_modif()
-              return 1,"Nommage du concept effectué"
+              return 1, tr("Nommage du concept effectue")
           else:
             # Normalement on ne devrait pas passer ici
           else:
             # Normalement on ne devrait pas passer ici
-            return 0,'Normalement on ne devrait pas passer ici'
+            return 0, 'Normalement on ne devrait pas passer ici'
 
    def get_sdprods(self,nom_sd):
       """ 
 
    def get_sdprods(self,nom_sd):
       """ 
@@ -213,10 +221,11 @@ class ETAPE(I_MCCOMPO.MCCOMPO):
       """
           Rend l'etape courante active.
           Il faut ajouter la sd si elle existe au contexte global du JDC
       """
           Rend l'etape courante active.
           Il faut ajouter la sd si elle existe au contexte global du JDC
-          et à la liste des sd
+          et a la liste des sd
       """
       if self.actif:return
       self.actif = 1
       """
       if self.actif:return
       self.actif = 1
+      self.init_modif()
       if self.sd :
         try:
           self.jdc.append_sdprod(self.sd)
       if self.sd :
         try:
           self.jdc.append_sdprod(self.sd)
@@ -232,6 +241,7 @@ class ETAPE(I_MCCOMPO.MCCOMPO):
           et de la liste des sd
       """
       self.actif = 0
           et de la liste des sd
       """
       self.actif = 0
+      self.init_modif()
       if self.sd :
          self.jdc.del_sdprod(self.sd)
          self.jdc.delete_concept_after_etape(self,self.sd)
       if self.sd :
          self.jdc.del_sdprod(self.sd)
          self.jdc.delete_concept_after_etape(self,self.sd)
@@ -240,20 +250,13 @@ class ETAPE(I_MCCOMPO.MCCOMPO):
 
    def control_sdprods(self,d):
       """
 
    def control_sdprods(self,d):
       """
-          Cette methode doit updater le contexte fournit par
-          l'appelant en argument (d) en fonction de sa definition
-          tout en verifiant que ses concepts produits ne sont pas 
+          Cette methode doit verifier que ses concepts produits ne sont pas
           deja definis dans le contexte
           deja definis dans le contexte
+          Si c'est le cas, les concepts produits doivent etre supprimes
       """
       """
-      if type(self.definition.op_init) == types.FunctionType:
-        try:
-           apply(self.definition.op_init,(self,d))
-        except:
-           #traceback.print_exc()
-           pass
-
+      #print "control_sdprods",d.keys(),self.sd and self.sd.nom,self.nom
       if self.sd:
       if self.sd:
-        if d.has_key(self.sd.nom):
+        if self.sd.nom in d :
            # Le concept est deja defini
            if self.reuse and self.reuse is d[self.sd.nom]:
               # Le concept est reutilise : situation normale
            # Le concept est deja defini
            if self.reuse and self.reuse is d[self.sd.nom]:
               # Le concept est reutilise : situation normale
@@ -262,11 +265,12 @@ class ETAPE(I_MCCOMPO.MCCOMPO):
               # Redefinition du concept, on l'annule
               #XXX on pourrait simplement annuler son nom pour conserver les objets
               # l'utilisateur n'aurait alors qu'a renommer le concept (faisable??)
               # Redefinition du concept, on l'annule
               #XXX on pourrait simplement annuler son nom pour conserver les objets
               # l'utilisateur n'aurait alors qu'a renommer le concept (faisable??)
-              self.sd=self.reuse=self.sdnom=None
               self.init_modif()
               self.init_modif()
-        else:
-           # Le concept n'est pas defini, on peut updater d
-           d[self.sd.nom]=self.sd
+              sd=self.sd
+              self.sd=self.reuse=self.sdnom=None
+              #supprime les references a sd dans les etapes suivantes
+              self.parent.delete_concept_after_etape(self,sd)
+              self.fin_modif()
 
    def supprime_sdprod(self,sd):
       """
 
    def supprime_sdprod(self,sd):
       """
@@ -284,15 +288,15 @@ class ETAPE(I_MCCOMPO.MCCOMPO):
       """ 
             Fonction:
             Lors d'une destruction d'etape, detruit tous les concepts produits
       """ 
             Fonction:
             Lors d'une destruction d'etape, detruit tous les concepts produits
-            Un opérateur n a qu un concept produit 
+            Un operateur n a qu un concept produit 
             Une procedure n'en a aucun
             Une procedure n'en a aucun
-            Une macro en a en général plus d'un
+            Une macro en a en general plus d'un
       """
       #print "supprime_sdprods",self
       if self.reuse is self.sd :return
       """
       #print "supprime_sdprods",self
       if self.reuse is self.sd :return
-      # l'étape n'est pas réentrante
-      # le concept retourné par l'étape est à supprimer car il était 
-      # créé par l'étape
+      # l'etape n'est pas reentrante
+      # le concept retourne par l'etape est a supprimer car il etait 
+      # cree par l'etape
       if self.sd != None :
          self.parent.del_sdprod(self.sd)
          self.parent.delete_concept(self.sd)
       if self.sd != None :
          self.parent.del_sdprod(self.sd)
          self.parent.delete_concept(self.sd)
@@ -300,6 +304,10 @@ class ETAPE(I_MCCOMPO.MCCOMPO):
    def close(self):
       return
 
    def close(self):
       return
 
+   def update_concept(self,sd):
+      for child in self.mc_liste :
+          child.update_concept(sd)
+
    def delete_concept(self,sd):
       """ 
           Inputs :
    def delete_concept(self,sd):
       """ 
           Inputs :
@@ -307,7 +315,7 @@ class ETAPE(I_MCCOMPO.MCCOMPO):
           Fonction :
           Mettre a jour les mots cles de l etape et eventuellement 
           le concept produit si reuse
           Fonction :
           Mettre a jour les mots cles de l etape et eventuellement 
           le concept produit si reuse
-          suite à la disparition du concept sd
+          suite a la disparition du concept sd
           Seuls les mots cles simples MCSIMP font un traitement autre 
           que de transmettre aux fils
       """
           Seuls les mots cles simples MCSIMP font un traitement autre 
           que de transmettre aux fils
       """
@@ -338,7 +346,7 @@ class ETAPE(I_MCCOMPO.MCCOMPO):
 
    def get_noms_sd_oper_reentrant(self):
       """ 
 
    def get_noms_sd_oper_reentrant(self):
       """ 
-          Retourne la liste des noms de concepts utilisés à l'intérieur de la commande
+          Retourne la liste des noms de concepts utilisesa l'interieur de la commande
           qui sont du type que peut retourner cette commande 
       """
       liste_sd = self.get_sd_utilisees()
           qui sont du type que peut retourner cette commande 
       """
       liste_sd = self.get_sd_utilisees()
@@ -346,7 +354,7 @@ class ETAPE(I_MCCOMPO.MCCOMPO):
       if type(self.definition.sd_prod) == types.FunctionType:
         d=self.cree_dict_valeurs(self.mc_liste)
         try:
       if type(self.definition.sd_prod) == types.FunctionType:
         d=self.cree_dict_valeurs(self.mc_liste)
         try:
-          classe_sd_prod = apply(self.definition.sd_prod,(),d)
+          classe_sd_prod = self.definition.sd_prod(*(), **d)
         except:
           return []
       else:
         except:
           return []
       else:
@@ -356,21 +364,72 @@ class ETAPE(I_MCCOMPO.MCCOMPO):
       l_noms.sort()
       return l_noms
 
       l_noms.sort()
       return l_noms
 
+   def get_genealogie_precise(self):
+      return [self.nom]
+
    def get_genealogie(self):
       """ 
           Retourne la liste des noms des ascendants de l'objet self
    def get_genealogie(self):
       """ 
           Retourne la liste des noms des ascendants de l'objet self
-          en s'arretant à la première ETAPE rencontrée
+          en s'arretant a la premiere ETAPE rencontree
       """
       return [self.nom]
 
    def verif_existence_sd(self):
      """
       """
       return [self.nom]
 
    def verif_existence_sd(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 referea ces concepts
      """
      #print "verif_existence_sd",self.sd
      for motcle in self.mc_liste :
          motcle.verif_existence_sd()
      """
      #print "verif_existence_sd",self.sd
      for motcle in self.mc_liste :
          motcle.verif_existence_sd()
+
+   def update_mc_global(self):
+     """
+        Met a jour les mots cles globaux enregistres dans l'etape
+        et dans le jdc parent.
+        Une etape ne peut pas etre globale. Elle se contente de passer
+        la requete a ses fils apres avoir reinitialise le dictionnaire 
+        des mots cles globaux.
+     """
+     self.mc_globaux={}
+     I_MCCOMPO.MCCOMPO.update_mc_global(self)
+
+   def update_condition_bloc(self):
+     """
+        Realise l'update des blocs conditionnels fils de self
+     """
+     self._update_condition_bloc()
+
+   def get_objet_commentarise(self,format):
+      """
+          Cette methode retourne un objet commande commentarisee
+          representant la commande self
+      """
+      import generator
+      g=generator.plugins[format]()
+      texte_commande = g.gener(self,format='beautifie')
+      # Il faut enlever la premiere ligne vide de texte_commande que
+      # rajoute le generator
+      # on construit l'objet COMMANDE_COMM repesentatif de self mais non
+      # enregistre dans le jdc (pas ajoute dans jdc.etapes)
+      parent=self.parent
+      pos=self.parent.etapes.index(self)
+      # on ajoute une fin à la commande pour pouvoir en commenter 2
+      texte_commande+='\nFin Commentaire'
+      commande_comment = commande_comm.COMMANDE_COMM(texte=texte_commande,
+                                                     reg='non',
+                                                     parent=parent)
+      self.parent.suppentite(self)
+      parent.addentite(commande_comment,pos)
+
+      return commande_comment
+
+   def modified(self):
+      """Le contenu de l'etape (mots cles, ...) a ete modifie"""
+      if self.nom=="DETRUIRE":
+        self.parent.control_context_apres(self)
+
+
      
 #ATTENTION SURCHARGE: a garder en synchro ou a reintegrer dans le Noyau
    def Build_sd(self,nom):
      
 #ATTENTION SURCHARGE: a garder en synchro ou a reintegrer dans le Noyau
    def Build_sd(self,nom):
@@ -380,11 +439,11 @@ class ETAPE(I_MCCOMPO.MCCOMPO):
       """
       try:
          sd=Noyau.N_ETAPE.ETAPE.Build_sd(self,nom)
       """
       try:
          sd=Noyau.N_ETAPE.ETAPE.Build_sd(self,nom)
-      except AsException,e:
+      except AsException as e :
          # Une erreur s'est produite lors de la construction du concept
          # Comme on est dans EFICAS, on essaie de poursuivre quand meme
          # Une erreur s'est produite lors de la construction du concept
          # Comme on est dans EFICAS, on essaie de poursuivre quand meme
-         # Si on poursuit, on a le choix entre deux possibilités :
-         # 1. on annule la sd associée à self
+         # Si on poursuit, on a le choix entre deux possibilites :
+         # 1. on annule la sd associee a self
          # 2. on la conserve mais il faut la retourner
          # En plus il faut rendre coherents sdnom et sd.nom
          self.sd=None
          # 2. on la conserve mais il faut la retourner
          # En plus il faut rendre coherents sdnom et sd.nom
          self.sd=None
@@ -394,11 +453,11 @@ class ETAPE(I_MCCOMPO.MCCOMPO):
 
       return self.sd
 
 
       return self.sd
 
-#ATTENTION SURCHARGE: cette methode doit etre gardée en synchronisation avec Noyau
+#ATTENTION SURCHARGE: cette methode doit etre gardee en synchronisation avec Noyau
    def make_register(self):
       """
    def make_register(self):
       """
-         Initialise les attributs jdc, id, niveau et réalise les
-         enregistrements nécessaires
+         Initialise les attributs jdc, id, niveau et realise les
+         enregistrements necessaires
          Pour EFICAS, on tient compte des niveaux
          Surcharge la methode make_register du package Noyau
       """
          Pour EFICAS, on tient compte des niveaux
          Surcharge la methode make_register du package Noyau
       """
@@ -407,13 +466,13 @@ class ETAPE(I_MCCOMPO.MCCOMPO):
          self.id=   self.parent.register(self)
          self.UserError=self.jdc.UserError
          if self.definition.niveau :
          self.id=   self.parent.register(self)
          self.UserError=self.jdc.UserError
          if self.definition.niveau :
-            # La définition est dans un niveau. En plus on
+            # La definition est dans un niveau. En plus on
             # l'enregistre dans le niveau
             self.nom_niveau_definition = self.definition.niveau.nom
             self.niveau = self.parent.dict_niveaux[self.nom_niveau_definition]
             self.niveau.register(self)
          else:
             # l'enregistre dans le niveau
             self.nom_niveau_definition = self.definition.niveau.nom
             self.niveau = self.parent.dict_niveaux[self.nom_niveau_definition]
             self.niveau.register(self)
          else:
-            # La définition est au niveau global
+            # La definition est au niveau global
             self.nom_niveau_definition = 'JDC'
             self.niveau=self.parent
       else:
             self.nom_niveau_definition = 'JDC'
             self.niveau=self.parent
       else:
@@ -422,3 +481,12 @@ class ETAPE(I_MCCOMPO.MCCOMPO):
          self.niveau=None
          self.UserError="UserError"
 
          self.niveau=None
          self.UserError="UserError"
 
+   def report(self):
+     cr= Validation.V_ETAPE.ETAPE.report(self)
+     #rafraichisst de la validite de l'etape (probleme avec l'ordre dans les macros : etape puis mots cles)
+     self.isvalid()
+     if not self.isvalid() and self.nom == "INCLUDE" :
+        self.cr.fatal(('Etape : %s ligne : %r  %s'),
+        self.nom, self.appel[0],  tr("\n   Include Invalide. \n  ne sera pas pris en compte"))
+     return cr
+