commentaire

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

diff --git a/Ihm/I_ETAPE.py b/Ihm/I_ETAPE.py
index a4648fd2648279f9b7ee773c3e5a4681bbe535e2..7ece4b6f6d145eea0216487572b47b73d13bd19c 100644 (file)
--- a/Ihm/I_ETAPE.py
+++ b/Ihm/I_ETAPE.py
@@ -1,44 +1,48 @@
 # -*- 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 Validation
 import traceback
 import Noyau
 from Noyau import N_Exception
 from Noyau.N_Exception import AsException
 import Validation

-# fin import à résorber
+# 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):
 from Extensions import commande_comm
 
 class ETAPE(I_MCCOMPO.MCCOMPO):


@@ -47,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
 


@@ -66,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'


@@ -80,82 +86,72 @@ 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 self.nom == "DETRUIRE":
-         #Il n'est pas conseillé de mettre des traitements dans fin_modif. Ceci est une
-         # exception qu'il faut supprimer à terme.
-         #une commande DETRUIRE a été modifiée. Il faut verifier les commandes
-         #suivantes
-         #ATTENTION: aux eventuelles recursions
-         self.parent.control_context_apres(self)
-         pass
-

       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':
         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.definition.reentrant == 'o':
         self.sd = self.reuse = self.jdc.get_sd_avant_etape(nom,self)
         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()) :
              self.sd = self.reuse = sd
              self.sdnom = sd.nom
              self.fin_modif()
           if isinstance(sd,self.get_type_produit()) :
              self.sd = self.reuse = sd
              self.sdnom = sd.nom
              self.fin_modif()

-             return 1,"Opérateur facultativement réentrant et concept existant trouvé"
+             return 1, tr("Operateur reentrant et concept existant trouve")

           else:
           else:

-             return 0,"Concept déjà existant et de mauvais type"
+             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
+          # 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
              self.sd = self.reuse = self.sdnom = None
       #
           if self.reuse :
              old_reuse=self.reuse
              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 :
           #Pas de concept produit preexistant
       #
       if self.sd == None :
           #Pas de concept produit preexistant


@@ -165,11 +161,11 @@ class ETAPE(I_MCCOMPO.MCCOMPO):
             if old_reuse:
                self.sd=self.reuse=old_reuse
                self.sdnom=old_reuse.nom
             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()
                # Renommage du concept : Il suffit de changer son attribut nom pour le nommer
             try:
                self.get_sd_prod()
                # Renommage du concept : Il suffit de changer son attribut nom pour le nommer


@@ -177,41 +173,41 @@ class ETAPE(I_MCCOMPO.MCCOMPO):
                self.sdnom=nom
                self.parent.update_concept_after_etape(self,self.sd)
                self.fin_modif()
                self.sdnom=nom
                self.parent.update_concept_after_etape(self,self.sd)
                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 :
           #Un concept produit preexiste
           old_nom=self.sd.nom
       else :
           #Un concept produit preexiste
           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:
               # Renommage du concept : Il suffit de changer son attribut nom pour le nommer
               self.sd.nom=nom
               self.sdnom=nom
               self.parent.update_concept_after_etape(self,self.sd)
               self.fin_modif()
             else:
               # Renommage du concept : Il suffit de changer son attribut nom pour le nommer
               self.sd.nom=nom
               self.sdnom=nom
               self.parent.update_concept_after_etape(self,self.sd)
               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:
               # Renommage du concept : Il suffit de changer son attribut nom pour le nommer
               self.sd.nom=nom
               self.sdnom=nom
               self.parent.update_concept_after_etape(self,self.sd)
               self.fin_modif()
             else:
               # Renommage du concept : Il suffit de changer son attribut nom pour le nommer
               self.sd.nom=nom
               self.sdnom=nom
               self.parent.update_concept_after_etape(self,self.sd)
               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):
       """ 


@@ -225,7 +221,7 @@ 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


@@ -260,7 +256,7 @@ class ETAPE(I_MCCOMPO.MCCOMPO):
       """
       #print "control_sdprods",d.keys(),self.sd and self.sd.nom,self.nom
       if self.sd:
       """
       #print "control_sdprods",d.keys(),self.sd and self.sd.nom,self.nom
       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


@@ -292,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)


@@ -319,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
       """


@@ -350,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()


@@ -358,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:


@@ -368,17 +364,20 @@ 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 :
      """
      #print "verif_existence_sd",self.sd
      for motcle in self.mc_liste :


@@ -386,10 +385,10 @@ class ETAPE(I_MCCOMPO.MCCOMPO):
 
    def update_mc_global(self):
      """
 
    def update_mc_global(self):
      """

-        Met a jour les mots cles globaux enregistrés dans l'étape
+        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
         et dans le jdc parent.
         Une etape ne peut pas etre globale. Elle se contente de passer

-        la requete a ses fils apres avoir reinitialisé le dictionnaire 
+        la requete a ses fils apres avoir reinitialise le dictionnaire 

         des mots cles globaux.
      """
      self.mc_globaux={}
         des mots cles globaux.
      """
      self.mc_globaux={}


@@ -403,19 +402,20 @@ class ETAPE(I_MCCOMPO.MCCOMPO):
 
    def get_objet_commentarise(self,format):
       """
 
    def get_objet_commentarise(self,format):
       """

-          Cette méthode retourne un objet commande commentarisée
+          Cette methode retourne un objet commande commentarisee

           representant la commande self
       """
       import generator
       g=generator.plugins[format]()
       texte_commande = g.gener(self,format='beautifie')
           representant la commande self
       """
       import generator
       g=generator.plugins[format]()
       texte_commande = g.gener(self,format='beautifie')

-      # Il faut enlever la première ligne vide de texte_commande que
+      # Il faut enlever la premiere ligne vide de texte_commande que

       # rajoute le generator
       # rajoute le generator

-      #rebut,texte_commande = string.split(texte_commande,'\n',1)
-      # on construit l'objet COMMANDE_COMM repésentatif de self mais non
-      # enregistré dans le jdc (pas ajouté dans jdc.etapes)
+      # 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)
       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)
       commande_comment = commande_comm.COMMANDE_COMM(texte=texte_commande,
                                                      reg='non',
                                                      parent=parent)


@@ -424,6 +424,12 @@ class ETAPE(I_MCCOMPO.MCCOMPO):
 
       return commande_comment
 
 
       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):


@@ -433,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


@@ -447,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
       """


@@ -460,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:


@@ -477,7 +483,10 @@ class ETAPE(I_MCCOMPO.MCCOMPO):
 
    def report(self):
      cr= Validation.V_ETAPE.ETAPE.report(self)
 
    def report(self):
      cr= Validation.V_ETAPE.ETAPE.report(self)

-     #rafraichissement de la validité de l'etape (probleme avec l'ordre dans les macros : etape puis mots cles)
+     #rafraichisst de la validite de l'etape (probleme avec l'ordre dans les macros : etape puis mots cles)

      self.isvalid()
      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
 
      return cr