Salome HOME
pb de check box
[tools/eficas.git] / Ihm / I_MACRO_ETAPE.py
index 0ca98ea425baa380cbce7d1ce3db81d3232b598d..b3c03efb4153659ef73f53d381712c2c2fe86a55 100644 (file)
@@ -1,45 +1,60 @@
-# -*- 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.
+# -*- coding: iso-8859-1 -*-
+# 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
 import sys
-import traceback,types,string
+import os.path as osp
+import traceback,types
 
 # Modules Eficas
 
 # Modules Eficas
-import I_ETAPE
+from Extensions.i18n import tr
+from Extensions.eficas_exception import EficasException
+from . import I_ETAPE
+from . import I_ENTITE
+from . import I_OBJECT
 import Noyau
 from Noyau.N_ASSD import ASSD
 import Noyau
 from Noyau.N_ASSD import ASSD
+from Noyau import N__F
+import convert
+from Extensions import param2
 
 
-# import rajoutés suite à l'ajout de Build_sd --> à résorber
+# import rajoutes suite a l'ajout de Build_sd --> a resorber
 import Noyau, Validation.V_MACRO_ETAPE
 from Noyau import N_Exception
 from Noyau.N_Exception import AsException
 import Accas # attention aux imports circulaires
 import Noyau, Validation.V_MACRO_ETAPE
 from Noyau import N_Exception
 from Noyau.N_Exception import AsException
 import Accas # attention aux imports circulaires
-# fin import à résorber
+import six
+from six.moves import range
+# fin import a resorber
 
 class MACRO_ETAPE(I_ETAPE.ETAPE):
 
   def __init__(self):
       self.typret=None
 
 class MACRO_ETAPE(I_ETAPE.ETAPE):
 
   def __init__(self):
       self.typret=None
+      #indique si le jeu de commande inclus a pu etre analyse par convert
+      #pour etre editable (0=NON, 1=OUI)
+      self.text_converted=1
+      self.text_error=""
       self.recorded_units={}
 
   def get_sdprods(self,nom_sd):
       self.recorded_units={}
 
   def get_sdprods(self,nom_sd):
@@ -52,24 +67,25 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
       if co.nom == nom_sd:return co
     if type(self.definition.op_init) == types.FunctionType:
       d={}
       if co.nom == nom_sd:return co
     if type(self.definition.op_init) == types.FunctionType:
       d={}
-      apply(self.definition.op_init,(self,d))
+      self.definition.op_init(*(self,d))
       return d.get(nom_sd,None)
     return None
 
   def get_contexte_jdc(self,fichier,text):
     """ 
       return d.get(nom_sd,None)
     return None
 
   def get_contexte_jdc(self,fichier,text):
     """ 
-         Interprète text comme un texte de jdc et retourne le 
-         contexte final
-         cad le dictionnaire des sd disponibles à la dernière étape
+         Interprete text comme un texte de jdc et retourne le contexte final.
+
+         Le contexte final est le dictionnaire des sd disponibles a la derniere etape.
          Si text n'est pas un texte de jdc valide, retourne None
          ou leve une exception
          Si text n'est pas un texte de jdc valide, retourne None
          ou leve une exception
-         --> utilisée par ops.POURSUITE et INCLUDE
+         --> utilisee par ops.POURSUITE et INCLUDE
     """
     """
-    #print "get_contexte_jdc",self,self.nom
+    print ("get_contexte_jdc",self,self.nom)
     # On recupere l'etape courante
     step=CONTEXT.get_current_step()
     try:
     # On recupere l'etape courante
     step=CONTEXT.get_current_step()
     try:
-       # on essaie de créer un objet JDC auxiliaire avec un contexte initial
+    #if 1 :
+       # on essaie de creer un objet JDC auxiliaire avec un contexte initial
        # Attention get_contexte_avant retourne un dictionnaire qui contient
        # le contexte courant. Ce dictionnaire est reactualise regulierement.
        # Si on veut garder l'etat du contexte fige, il faut en faire une copie.
        # Attention get_contexte_avant retourne un dictionnaire qui contient
        # le contexte courant. Ce dictionnaire est reactualise regulierement.
        # Si on veut garder l'etat du contexte fige, il faut en faire une copie.
@@ -82,7 +98,7 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
        prefix_include=None
        if hasattr(self,'prefix'):
           prefix_include=self.prefix
        prefix_include=None
        if hasattr(self,'prefix'):
           prefix_include=self.prefix
-       # ATTENTION : le dictionnaire recorded_units sert à memoriser les unites des 
+       # ATTENTION : le dictionnaire recorded_units sert a memoriser les unites des 
        # fichiers inclus. Il est preferable de garder le meme dictionnaire pendant
        # tout le traitement et de ne pas le reinitialiser brutalement (utiliser 
        # clear plutot) si on ne veut pas perdre la memoire des unites.
        # fichiers inclus. Il est preferable de garder le meme dictionnaire pendant
        # tout le traitement et de ne pas le reinitialiser brutalement (utiliser 
        # clear plutot) si on ne veut pas perdre la memoire des unites.
@@ -90,7 +106,37 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
        # de prendre cette precaution mais ce n'est pas vrai partout.
        old_recorded_units=self.recorded_units.copy()
 
        # de prendre cette precaution mais ce n'est pas vrai partout.
        old_recorded_units=self.recorded_units.copy()
 
+       # on supprime l'ancien jdc_aux s'il existe
+       if hasattr(self,'jdc_aux') and self.jdc_aux:
+          self.jdc_aux.supprime_aux()
+
        if fichier is None:fichier="SansNom"
        if fichier is None:fichier="SansNom"
+
+       # Il faut convertir le texte inclus en fonction du format
+       # sauf les INCLUDE_MATERIAU
+       self.text_converted=0
+       self.text_error=""
+       if self.nom != "INCLUDE_MATERIAU":
+          if self.parent.appli.ihm == "QT" :
+              format=self.parent.appli.appliEficas.format_fichier
+          else :
+              format=self.jdc.appli.format_fichier.get()
+          #on force a python pour Carmel
+          if format=="CARMEL3D" : format="python"
+          if format in convert.plugins :
+              # Le convertisseur existe on l'utilise
+              p=convert.plugins[format]()
+              p.text=text
+              text=p.convert('exec',self.jdc.appli)
+              #Si le fichier ne peut pas etre converti, le cr n'est pas vide
+              #et le texte est retourne tel que
+              if not p.cr.estvide(): 
+                  self.text_converted=0
+                  self.text_error=str(p.cr)
+              else:
+                  self.text_converted=1
+
+
        j=self.JdC_aux( procedure=text, nom=fichier,
                                 appli=self.jdc.appli,
                                 cata=self.jdc.cata,
        j=self.JdC_aux( procedure=text, nom=fichier,
                                 appli=self.jdc.appli,
                                 cata=self.jdc.cata,
@@ -102,10 +148,14 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
                                 old_recorded_units=old_recorded_units,**args)
 
        j.analyse()
                                 old_recorded_units=old_recorded_units,**args)
 
        j.analyse()
-       # On récupère les étapes internes (pour validation)
+       # On recupere les etapes internes (pour validation)
        self.etapes=j.etapes
        self.jdc_aux=j
        self.etapes=j.etapes
        self.jdc_aux=j
+       self.jdc.jdcDict=self.jdc_aux
+
     except:
     except:
+    #else :
+       traceback.print_exc()
        # On retablit l'etape courante step
        CONTEXT.unset_current_step()
        CONTEXT.set_current_step(step)
        # On retablit l'etape courante step
        CONTEXT.unset_current_step()
        CONTEXT.set_current_step(step)
@@ -115,9 +165,12 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
        # Erreurs dans l'INCLUDE. On garde la memoire du fichier 
        # mais on n'insere pas les concepts
        # On retablit l'etape courante step
        # Erreurs dans l'INCLUDE. On garde la memoire du fichier 
        # mais on n'insere pas les concepts
        # On retablit l'etape courante step
+       #print j.cr
+       #print j.isvalid()
        CONTEXT.unset_current_step()
        CONTEXT.set_current_step(step)
        CONTEXT.unset_current_step()
        CONTEXT.set_current_step(step)
-       raise Exception("Impossible de relire le fichier\n"+str(j.cr))
+       raise EficasException(tr("Impossible de relire le fichier %s \n ")+ six.text_type(j.cr))
+
 
     if not j.isvalid():
        # L'INCLUDE n'est pas valide.
 
     if not j.isvalid():
        # L'INCLUDE n'est pas valide.
@@ -126,30 +179,52 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
        # On retablit l'etape courante step
        CONTEXT.unset_current_step()
        CONTEXT.set_current_step(step)
        # On retablit l'etape courante step
        CONTEXT.unset_current_step()
        CONTEXT.set_current_step(step)
-       raise Exception("Le fichier include contient des erreurs\n"+str(cr))
+       self.jdc.cr.fatal("Le fichier include contient des erreurs ")
+       raise EficasException(tr("Le fichier include contient des erreurs "))
 
 
-    # Si aucune erreur rencontrée
+
+    # Si aucune erreur rencontree
     # On recupere le contexte de l'include verifie
     try:
        j_context=j.get_verif_contexte()
     # On recupere le contexte de l'include verifie
     try:
        j_context=j.get_verif_contexte()
+       #print j_context.keys()
+       #print j.g_context.keys()
     except:
        # On retablit l'etape courante step
        CONTEXT.unset_current_step()
        CONTEXT.set_current_step(step)
     except:
        # On retablit l'etape courante step
        CONTEXT.unset_current_step()
        CONTEXT.set_current_step(step)
-       raise
+       raise EficasException(" ")
+
+    # Si on est arrive ici, le texte du fichier inclus (INCLUDE, POURSUITE, ...)
+    # est valide et inserable dans le JDC
 
     # On remplit le dictionnaire des concepts produits inclus
 
     # On remplit le dictionnaire des concepts produits inclus
-    # en retirant les concepts présents dans le  contexte initial
+    # en retirant les concepts presents dans le  contexte initial
     # On ajoute egalement le concept produit dans le sds_dict du parent
     # On ajoute egalement le concept produit dans le sds_dict du parent
-    # sans verification car on est sur (verification integrée) que 
+    # sans verification car on est sur (verification integree) que 
     # le nommage est possible
     self.g_context.clear()
     for k,v in j_context.items():
     # le nommage est possible
     self.g_context.clear()
     for k,v in j_context.items():
-       if not context_ini.has_key(k) or context_ini[k] != v:
+       if (not k in context_ini) or (context_ini[k] != v):
            self.g_context[k]=v
            self.parent.sds_dict[k]=v
 
            self.g_context[k]=v
            self.parent.sds_dict[k]=v
 
-
+    #Ce traitement n'est realise que dans les cas suivants:
+    #     - si convert n'a pas pu convertir le jeu de commandes
+    #     - et ce n'est pas un INCLUDE_MATERIAU
+    #On collecte les variables Python qui ne sont pas dans le contexte initial
+    #et dans le contexte valide et on en fait un pseudo-parametre (Variable)
+    if self.text_converted == 0 and self.nom != "INCLUDE_MATERIAU":
+        for k,v in j.g_context.items():
+            if k in context_ini:continue
+            if k in j_context:continue
+            if isinstance(v,ASSD):continue
+            if isinstance(v,I_ENTITE.ENTITE):continue
+            if isinstance(v,I_OBJECT.OBJECT):continue
+            if callable(v):continue
+            self.g_context[k]=param2.Variable(k,v)
+
+    print ('kljkljkljlkjklj')
     # On recupere le contexte courant
     self.current_context=j.current_context
     self.index_etape_courante=j.index_etape_courante
     # On recupere le contexte courant
     self.current_context=j.current_context
     self.index_etape_courante=j.index_etape_courante
@@ -159,12 +234,13 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
     CONTEXT.unset_current_step()
     CONTEXT.set_current_step(step)
 
     CONTEXT.unset_current_step()
     CONTEXT.set_current_step(step)
 
+    print ('kljkljkljlkjklj')
     return j_context
 
   def reevalue_sd_jdc(self):
      """
     return j_context
 
   def reevalue_sd_jdc(self):
      """
-         Avec la liste des SD qui ont été supprimées, propage la 
-         disparition de ces SD dans toutes les étapes et descendants
+         Avec la liste des SD qui ont ete supprimees, propage la 
+         disparition de ces SD dans toutes les etapes et descendants
      """
      #print "reevalue_sd_jdc"
      l_sd_supp,l_sd_repl = self.diff_contextes()
      """
      #print "reevalue_sd_jdc"
      l_sd_supp,l_sd_repl = self.diff_contextes()
@@ -175,7 +251,7 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
 
   def diff_contextes(self):
      """ 
 
   def diff_contextes(self):
      """ 
-         Réalise la différence entre les 2 contextes 
+         Realise la difference entre les 2 contextes 
          old_contexte_fichier_init et contexte_fichier_init
          cad retourne la liste des sd qui ont disparu ou ne derivent pas 
          de la meme classe et des sd qui ont ete remplacees
          old_contexte_fichier_init et contexte_fichier_init
          cad retourne la liste des sd qui ont disparu ou ne derivent pas 
          de la meme classe et des sd qui ont ete remplacees
@@ -183,8 +259,8 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
      if not hasattr(self,'old_contexte_fichier_init'):return [],[]
      l_sd_suppressed = []
      l_sd_replaced = []
      if not hasattr(self,'old_contexte_fichier_init'):return [],[]
      l_sd_suppressed = []
      l_sd_replaced = []
-     for old_key in self.old_contexte_fichier_init.keys():
-       if not self.contexte_fichier_init.has_key(old_key):
+     for old_key in self.old_contexte_fichier_init:
+       if not old_key in self.contexte_fichier_init:
          if isinstance(self.old_contexte_fichier_init[old_key],ASSD):
            l_sd_suppressed.append(self.old_contexte_fichier_init[old_key])
        else:
          if isinstance(self.old_contexte_fichier_init[old_key],ASSD):
            l_sd_suppressed.append(self.old_contexte_fichier_init[old_key])
        else:
@@ -208,7 +284,7 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
       """
       #print "I_MACRO_ETAPE.control_sdprods",d.keys(),self.nom,self.sd and self.sd.nom
       if self.sd:
       """
       #print "I_MACRO_ETAPE.control_sdprods",d.keys(),self.nom,self.sd and self.sd.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
@@ -228,8 +304,8 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
       sdprods=self.sdprods[:]
       self.sdprods=[]
       for co in sdprods:
       sdprods=self.sdprods[:]
       self.sdprods=[]
       for co in sdprods:
-        if d.has_key(co.nom) and co is not d[co.nom] :
-           #nettoie les mots cles de l'étape qui ont comme valeur co
+        if co.nom in d and co is not d[co.nom] :
+           #nettoie les mots cles de l'etape qui ont comme valeur co
            self.delete_concept(co)
            #supprime les references a co dans les etapes suivantes
            self.parent.delete_concept_after_etape(self,co)
            self.delete_concept(co)
            #supprime les references a co dans les etapes suivantes
            self.parent.delete_concept_after_etape(self,co)
@@ -264,19 +340,19 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
   def supprime_sdprods(self):
       """
           Fonction: Lors de la destruction de la macro-etape, detruit tous les concepts produits
   def supprime_sdprods(self):
       """
           Fonction: Lors de la destruction de la macro-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"
       if self.reuse is not self.sd :
       """
       #print "supprime_sdprods"
       if self.reuse is not self.sd :
-         # 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)
-      # On détruit les concepts à droite du signe =
+      # On detruit les concepts a droite du signe =
       for co in self.sdprods:
          self.parent.del_sdprod(co)
          self.parent.delete_concept(co)
       for co in self.sdprods:
          self.parent.del_sdprod(co)
          self.parent.delete_concept(co)
@@ -285,7 +361,7 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
          if not isinstance(co,ASSD):continue
          self.parent.del_sdprod(co)
          self.parent.delete_concept(co)
          if not isinstance(co,ASSD):continue
          self.parent.del_sdprod(co)
          self.parent.delete_concept(co)
-      # On met g_context à blanc
+      # On met g_context a blanc
       self.g_context={}
 
   def close(self):
       self.g_context={}
 
   def close(self):
@@ -307,7 +383,7 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
   def delete_concept(self,sd):
       """
           Fonction : Mettre a jour les mots cles de l etape et eventuellement
   def delete_concept(self,sd):
       """
           Fonction : Mettre a jour les mots cles de l etape et eventuellement
-          le concept produit si reuse suite à la disparition du concept sd
+          le concept produit si reuse 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
       """
@@ -328,10 +404,9 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
          
   def change_fichier_init(self,new_fic,text):
     """
          
   def change_fichier_init(self,new_fic,text):
     """
-       Tente de changer le fichier include. Le precedent include est conservé
+       Tente de changer le fichier include. Le precedent include est conserve
        dans old_xxx
     """
        dans old_xxx
     """
-    #print "change_fichier_init",new_fic
     if not hasattr(self,'fichier_ini'):
        self.fichier_ini=None
        self.fichier_text=None
     if not hasattr(self,'fichier_ini'):
        self.fichier_ini=None
        self.fichier_text=None
@@ -357,18 +432,18 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
     try:
        self.make_contexte_include(new_fic,text)
     except:
     try:
        self.make_contexte_include(new_fic,text)
     except:
-       l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
-       self.fichier_err=string.join(l)
-       raise
+       l=traceback.format_exception_only(tr("Fichier invalide %s", sys.exc_info()[1]))
+       self.fichier_err=''.join(l)
+       raise EficasException(self.fichier_err)
 
 
-    # L'evaluation de text dans un JDC auxiliaire s'est bien passé
+    # L'evaluation de text dans un JDC auxiliaire s'est bien passe
     # on peut poursuivre le traitement
     self.init_modif()
     self.state="undetermined"
     self.fichier_err=None
     # On enregistre la modification de fichier
     self.record_unite()
     # on peut poursuivre le traitement
     self.init_modif()
     self.state="undetermined"
     self.fichier_err=None
     # On enregistre la modification de fichier
     self.record_unite()
-    # Le contexte du parent doit etre reinitialise car les concepts produits ont changé
+    # Le contexte du parent doit etre reinitialise car les concepts produits ont change
     self.parent.reset_context()
 
     # Si des concepts ont disparu lors du changement de fichier, on demande leur suppression
     self.parent.reset_context()
 
     # Si des concepts ont disparu lors du changement de fichier, on demande leur suppression
@@ -398,15 +473,15 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
     # Reinitialisation complete du compte-rendu d'erreurs
     self.jdc_aux.cr=self.jdc_aux.CR()
     # On remplit le dictionnaire des concepts produits inclus
     # Reinitialisation complete du compte-rendu d'erreurs
     self.jdc_aux.cr=self.jdc_aux.CR()
     # On remplit le dictionnaire des concepts produits inclus
-    # en retirant les concepts présents dans le  contexte initial
+    # en retirant les concepts presents dans le  contexte initial
     # On ajoute egalement le concept produit dans le sds_dict du parent
     # On ajoute egalement le concept produit dans le sds_dict du parent
-    # sans verification car on est sur (verification integrée) que
+    # sans verification car on est sur (verification integree) que
     # le nommage est possible
     j_context=self.jdc_aux.get_contexte_avant(None)
     self.g_context.clear()
     context_ini=self.jdc_aux.context_ini
     for k,v in j_context.items():
     # le nommage est possible
     j_context=self.jdc_aux.get_contexte_avant(None)
     self.g_context.clear()
     context_ini=self.jdc_aux.context_ini
     for k,v in j_context.items():
-       if not context_ini.has_key(k) or context_ini[k] != v:
+       if not k in context_ini or context_ini[k] != v:
            self.g_context[k]=v
            self.parent.sds_dict[k]=v
     # On recupere le contexte courant
            self.g_context[k]=v
            self.parent.sds_dict[k]=v
     # On recupere le contexte courant
@@ -419,7 +494,7 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
     self.init_modif()
     self.state="undetermined"
     self.record_unite()
     self.init_modif()
     self.state="undetermined"
     self.record_unite()
-    # Le contexte du parent doit etre reinitialise car les concepts produits ont changé
+    # Le contexte du parent doit etre reinitialise car les concepts produits ont change
     self.parent.reset_context()
 
     # On remplace les anciens concepts par les nouveaux (y compris ajouts 
     self.parent.reset_context()
 
     # On remplace les anciens concepts par les nouveaux (y compris ajouts 
@@ -449,10 +524,34 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
     self.recorded_units={}
     self.build_jdcaux(fichier,text)
 
     self.recorded_units={}
     self.build_jdcaux(fichier,text)
 
+       
+
+  def build_includeInclude(self,text):
+    import Extensions.jdc_include
+    self.JdC_aux=Extensions.jdc_include.JdC_include
+    # un include partage la table des unites avec son parent (jdc)
+    self.build_jdcauxInclude(text)
+
+
+  def build_jdcauxInclude(self,text):
+       
+       try :
+         contexte = self.get_contexte_jdc(None,text)
+       except EficasException:
+         pass
+       index=self.jdc.etapes.index(self)
+       for e in self.etapes:
+           e.niveau=self.niveau
+       self.jdc.etapes=self.jdc.etapes[:index+1]+self.etapes+self.jdc.etapes[index+1:]
+       self.g_context={}
+       self.etapes=[]
+       self.jdc_aux=None
+       CONTEXT.unset_current_step()
+
   def build_jdcaux(self,fichier,text):
     """
          Cree un jdc auxiliaire initialise avec text. 
   def build_jdcaux(self,fichier,text):
     """
          Cree un jdc auxiliaire initialise avec text. 
-         Initialise le nom du fichier associé avec fichier
+         Initialise le nom du fichier associe avec fichier
          N'enregistre pas d'association unite <-> fichier
     """
     self.fichier_ini = fichier
          N'enregistre pas d'association unite <-> fichier
     """
     self.fichier_ini = fichier
@@ -464,47 +563,48 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
        if contexte is None :
           # Impossible de construire le jdc auxiliaire (sortie par None)
           # On simule une sortie par exception
        if contexte is None :
           # Impossible de construire le jdc auxiliaire (sortie par None)
           # On simule une sortie par exception
-          raise Exception("Impossible de construire le jeu de commandes correspondant au fichier")
+          raise EficasException(tr("Impossible de construire le jeu de commandes correspondant au fichier"))
        else:
        else:
-          # La construction du jdc auxiliaire est allée au bout
+          # La construction du jdc auxiliaire est allee au bout
           self.contexte_fichier_init = contexte
        self.init_modif()
        self.fin_modif()
     except:
        # Impossible de construire le jdc auxiliaire (sortie par exception)
        l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
           self.contexte_fichier_init = contexte
        self.init_modif()
        self.fin_modif()
     except:
        # Impossible de construire le jdc auxiliaire (sortie par exception)
        l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
-       if self.jdc.appli:
-          self.jdc.appli.affiche_alerte("Erreur lors de l'evaluation du fichier inclus",
-                                        message="Ce fichier ne sera pas pris en compte\n"+string.join(l)
-                                       )
+       if self.jdc.appli is not None:
+          self.jdc.appli.affiche_alerte(tr("Erreur lors de l'evaluation du fichier inclus"),
+                                       message= tr("Ce fichier ne sera pas pris en compte\n %s",''.join(l)))
+
        self.g_context={}
        self.etapes=[]
        self.jdc_aux=None
        self.g_context={}
        self.etapes=[]
        self.jdc_aux=None
-       self.fichier_err = string.join(l)
+       self.fichier_err = ''.join(l)
        self.contexte_fichier_init={}
        self.init_modif()
        self.fin_modif()
        self.contexte_fichier_init={}
        self.init_modif()
        self.fin_modif()
-       raise
+       raise EficasException(" ")
 
   def make_contexte_include(self,fichier,text):
     """
 
   def make_contexte_include(self,fichier,text):
     """
-        Cette méthode sert à créer un contexte en interprétant un texte source
-        Python
+        Cette methode sert a craer un contexte en interpratant un texte source Python.
     """
     """
-    #print "make_contexte_include"
-    # on récupère le contexte d'un nouveau jdc dans lequel on interprete text
+    print ("make_contexte_include",fichier)
+    # on recupere le contexte d'un nouveau jdc dans lequel on interprete text
     contexte = self.get_contexte_jdc(fichier,text)
     contexte = self.get_contexte_jdc(fichier,text)
+    print ("make_contexte_include",fichier)
     if contexte == None :
     if contexte == None :
-      raise Exception("Impossible de construire le jeu de commandes correspondant au fichier")
+      raise EficasException("Impossible de construire le jeu de commandes correspondant au fichier")
     else:
       # Pour les macros de type include : INCLUDE, INCLUDE_MATERIAU et POURSUITE
       # l'attribut g_context est un dictionnaire qui contient les concepts produits par inclusion
       # l'attribut contexte_fichier_init est un dictionnaire qui contient les concepts produits
       # en sortie de macro. g_context est obtenu en retirant de contexte_fichier_init les concepts
       # existants en debut de macro contenus dans context_ini (dans get_contexte_jdc)
     else:
       # Pour les macros de type include : INCLUDE, INCLUDE_MATERIAU et POURSUITE
       # l'attribut g_context est un dictionnaire qui contient les concepts produits par inclusion
       # l'attribut contexte_fichier_init est un dictionnaire qui contient les concepts produits
       # en sortie de macro. g_context est obtenu en retirant de contexte_fichier_init les concepts
       # existants en debut de macro contenus dans context_ini (dans get_contexte_jdc)
-      # g_context est utilisé pour avoir les concepts produits par la macro
-      # contexte_fichier_init est utilisé pour avoir les concepts supprimés par la macro
+      # g_context est utilise pour avoir les concepts produits par la macro
+      # contexte_fichier_init est utilise pour avoir les concepts supprimes par la macro
       self.contexte_fichier_init = contexte
       self.contexte_fichier_init = contexte
+    print ("fin make_contexte_include",fichier)
 
   def reevalue_fichier_init_OBSOLETE(self):
       """Recalcule les concepts produits par le fichier enregistre"""
 
   def reevalue_fichier_init_OBSOLETE(self):
       """Recalcule les concepts produits par le fichier enregistre"""
@@ -514,7 +614,7 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
          self.make_contexte_include(self.fichier_ini ,self.fichier_text)
       except:
          l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
          self.make_contexte_include(self.fichier_ini ,self.fichier_text)
       except:
          l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
-         self.fichier_err = string.join(l)
+         self.fichier_err = ''.join(l)
          self.g_context={}
          self.etapes=[]
          self.jdc_aux=None
          self.g_context={}
          self.etapes=[]
          self.jdc_aux=None
@@ -531,8 +631,8 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
   def update_fichier_init(self,unite):
       """Reevalue le fichier init sans demander (dans la mesure du possible) a l'utilisateur 
          les noms des fichiers
   def update_fichier_init(self,unite):
       """Reevalue le fichier init sans demander (dans la mesure du possible) a l'utilisateur 
          les noms des fichiers
-         Ceci suppose que les relations entre unites et noms ont été memorisees préalablement
-         L'include a été initialisé précédemment. Le jdc auxiliaire existe.
+         Ceci suppose que les relations entre unites et noms ont ete memorisees prealablement
+         L'include a ete initialise precedemment. Le jdc auxiliaire existe.
       """
       #print "update_fichier_init",unite,self.fichier_unite 
       self.old_contexte_fichier_init=self.contexte_fichier_init
       """
       #print "update_fichier_init",unite,self.fichier_unite 
       self.old_contexte_fichier_init=self.contexte_fichier_init
@@ -543,21 +643,21 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
       #print "update_fichier_init",self,self.parent,self.parent.recorded_units
 
       if self.fichier_unite is None:
       #print "update_fichier_init",self,self.parent,self.parent.recorded_units
 
       if self.fichier_unite is None:
-         # L'unité n'était pas définie précédemment. On ne change que l'unite
+         # L'unite n'etait pas definie precedemment. On ne change que l'unite
          #print "update_fichier_init","pas de changement dans include"
          self.fichier_unite=unite
          return
       elif unite == self.fichier_unite :
          #print "update_fichier_init","pas de changement dans include"
          self.fichier_unite=unite
          return
       elif unite == self.fichier_unite :
-         # L'unité n'a pas changé
+         # L'unite n'a pas change
          #print "update_fichier_init","pas de changement dans include 3"
          return
       elif unite != self.fichier_unite :
          #print "update_fichier_init","pas de changement dans include 3"
          return
       elif unite != self.fichier_unite :
-         # L'unité était définie précédemment. On remplace l'include 
+         # L'unite etait definie precedemment. On remplace l'include 
          #
          f,text=self.get_file_memo(unite=unite,fic_origine=self.parent.nom)
          if f is None:
          #
          f,text=self.get_file_memo(unite=unite,fic_origine=self.parent.nom)
          if f is None:
-            # Le fichier associé n'a pas pu etre defini
-            # on change l'unite associée mais pas l'include
+            # Le fichier associe n'a pas pu etre defini
+            # on change l'unite associee mais pas l'include
             #print "update_fichier_init","pas de changement dans include 2"
             self.fichier_unite=unite
             return
             #print "update_fichier_init","pas de changement dans include 2"
             self.fichier_unite=unite
             return
@@ -570,7 +670,7 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
       #print "update_fichier_init",self.fichier_ini,self.fichier_text,self.fichier_unite
 
       if old_fichier_ini == self.fichier_ini:
       #print "update_fichier_init",self.fichier_ini,self.fichier_text,self.fichier_unite
 
       if old_fichier_ini == self.fichier_ini:
-         # Le fichier inclus n'a pas changé. On ne recrée pas le contexte
+         # Le fichier inclus n'a pas change. On ne recree pas le contexte
          # mais on enregistre le changement d'association unite <-> fichier
          #print "update_fichier_init.fichier inchange",self.jdc_aux.context_ini
          self.parent.record_unit(unite,self)
          # mais on enregistre le changement d'association unite <-> fichier
          #print "update_fichier_init.fichier inchange",self.jdc_aux.context_ini
          self.parent.record_unit(unite,self)
@@ -586,8 +686,8 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
         l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
         # On conserve la memoire du nouveau fichier
         # mais on n'utilise pas les concepts crees par ce fichier
         l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
         # On conserve la memoire du nouveau fichier
         # mais on n'utilise pas les concepts crees par ce fichier
-        # on met l'etape en erreur : fichier_err=string.join(l)
-        self.fichier_err=string.join(l)
+        # on met l'etape en erreur : fichier_err=''.join(l)
+        self.fichier_err=''.join(l)
         self.g_context={}
         self.etapes=[]
         self.jdc_aux=None
         self.g_context={}
         self.etapes=[]
         self.jdc_aux=None
@@ -597,7 +697,7 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
          old_jdc_aux.close()
       self.parent.record_unit(unite,self)
       # Le contexte du parent doit etre reinitialise car les concepts 
          old_jdc_aux.close()
       self.parent.record_unit(unite,self)
       # Le contexte du parent doit etre reinitialise car les concepts 
-      # produits ont changé
+      # produits ont change
       self.parent.reset_context()
       # Si des concepts ont disparu lors du changement de fichier, on 
       # demande leur suppression
       self.parent.reset_context()
       # Si des concepts ont disparu lors du changement de fichier, on 
       # demande leur suppression
@@ -612,7 +712,7 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
          if hasattr(self,'fichier_unite') : 
             self.parent.record_unit(self.fichier_unite,self)
 
          if hasattr(self,'fichier_unite') : 
             self.parent.record_unit(self.fichier_unite,self)
 
-  def get_file_memo(self,unite=None,fic_origine=''):
+  def get_file_memo(self, unite=None, fname=None, fic_origine=''):
       """Retourne le nom du fichier et le source correspondant a l'unite unite
          Initialise en plus recorded_units
       """
       """Retourne le nom du fichier et le source correspondant a l'unite unite
          Initialise en plus recorded_units
       """
@@ -625,22 +725,28 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
          # On est dans le cas d'un include. On reutilise toutes les unites de parent
          units=self.parent.recorded_units
 
          # On est dans le cas d'un include. On reutilise toutes les unites de parent
          units=self.parent.recorded_units
 
-      if self.parent.recorded_units.has_key(unite):
+      if unite in self.parent.recorded_units:
          f,text,units=self.parent.recorded_units[unite]
       elif self.jdc :
          f,text,units=self.parent.recorded_units[unite]
       elif self.jdc :
-         f,text=self.jdc.get_file(unite=unite,fic_origine=fic_origine)
+         if fname:
+             if not osp.exists(fname):
+                raise AsException(fname + tr(" n'est pas un fichier existant"))
+             f = fname
+             text = open(fname, 'r').read()
+         else:
+             f,text=self.jdc.get_file(unite=unite, fic_origine=fic_origine)
       else:
          f,text=None,None
 
       self.recorded_units=units
       if f is None and self.jdc.appli:
       else:
          f,text=None,None
 
       self.recorded_units=units
       if f is None and self.jdc.appli:
-         self.jdc.appli.affiche_alerte("Erreur lors de l'evaluation du fichier inclus",
-                          message="Ce fichier ne sera pas pris en compte\n"+"Le fichier associé n'est pas défini")
+         self.jdc.appli.affiche_alerte(tr("Erreur lors de l'evaluation du fichier inclus"),
+               message= tr("Ce fichier ne sera pas pris en compte\nLe fichier associe n'est pas defini"))
       return f,text
 
   def update_context(self,d):
       """
       return f,text
 
   def update_context(self,d):
       """
-         Met à jour le contexte contenu dans le dictionnaire d
+         Met a jour le contexte contenu dans le dictionnaire d
          Une MACRO_ETAPE peut ajouter plusieurs concepts dans le contexte
          Une fonction enregistree dans op_init peut egalement modifier le contexte
       """
          Une MACRO_ETAPE peut ajouter plusieurs concepts dans le contexte
          Une fonction enregistree dans op_init peut egalement modifier le contexte
       """
@@ -653,7 +759,7 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
             self.jdc_aux.current_context={}
             self.jdc_aux.index_etape_courante=0
             #ATTENTION: il ne faut pas utiliser self.jdc_aux.get_contexte_avant
             self.jdc_aux.current_context={}
             self.jdc_aux.index_etape_courante=0
             #ATTENTION: il ne faut pas utiliser self.jdc_aux.get_contexte_avant
-            #car cet appel conduit a des remontées multiples incohérentes dans le
+            #car cet appel conduit a des remontees multiples incoherentes dans le
             # ou les parents. 
             #get_context_avant appelle update_context qui NE DOIT PAS appeler get_contexte_avant
             #On n'a besoin que d'un update local connaissant
             # ou les parents. 
             #get_context_avant appelle update_context qui NE DOIT PAS appeler get_contexte_avant
             #On n'a besoin que d'un update local connaissant
@@ -663,13 +769,21 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
             return
 
       if type(self.definition.op_init) == types.FunctionType:
             return
 
       if type(self.definition.op_init) == types.FunctionType:
-        apply(self.definition.op_init,(self,d))
+        self.definition.op_init(*(self,d))
       if self.sd != None:d[self.sd.nom]=self.sd
       for co in self.sdprods:
         d[co.nom]=co
       #print "update_context.fin",d.keys()
 
 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
       if self.sd != None:d[self.sd.nom]=self.sd
       for co in self.sdprods:
         d[co.nom]=co
       #print "update_context.fin",d.keys()
 
 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
+  def copy(self):
+      etape=Noyau.N_MACRO_ETAPE.MACRO_ETAPE.copy(self)
+      if hasattr(etape,"etapes") :etape.etapes=[]
+      if hasattr(etape,"jdc_aux") : 
+         etape.jdc_aux=None
+         del etape.fichier_ini
+      return etape
+
   def supprime(self):
       #print "supprime",self
       if hasattr(self,"jdc_aux") and self.jdc_aux:
   def supprime(self):
       #print "supprime",self
       if hasattr(self,"jdc_aux") and self.jdc_aux:
@@ -687,8 +801,224 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
          f,text=None,None
       return f,text
 
          f,text=None,None
       return f,text
 
+
+  def make_include3(self,fichier=None):
+      self.make_includeCarmel(fichier)
+
+
+  def make_includeCND(self,fichier=None):
+      unite=999
+      if fichier==None : return
+      if hasattr(self,'fichier_ini') : print((self.fichier_ini))
+      if hasattr(self,'fichier_ini') : return
+      self.fichier_ini=fichier
+      from acquiertGroupes import getGroupes
+      erreur,listeGroupes=getGroupes(fichier)
+      if erreur != "" : print ("a traiter")
+      texteSources=""
+      texteCond=""
+      texteNoCond=""
+      texteVcut=""
+      for groupe in listeGroupes :
+          if groupe[0:8]=='CURRENT_': texteSources +=groupe[8:]+"=SOURCE();\n"
+          if groupe[0:5]=='COND_':    texteCond    +=groupe[5:]+"=CONDUCTEUR();\n"
+          if groupe[0:7]=='NOCOND_':  texteNoCond  +=groupe[7:]+"=NOCOND();\n"
+          #if groupe[0:5]=='VCUT_':    texteVcut    +=groupe[5:]+"=VCUT();\n"
+          if groupe[0:5]=='VCUT_':    texteVcut    +='V_'+groupe[5:]+"=VCUT();\n"
+      texte=texteSources+texteCond+texteNoCond+texteVcut
+      #print (texte)
+      self.build_includeInclude(texte)
+      if CONTEXT.get_current_step()==None : CONTEXT.set_current_step(self)
+      reevalue=0
+
+  def make_includeCarmel(self,fichier=None):
+  # Pour Carmel
+      #print "je suis dans make_includeCarmel"
+      unite=999
+      if hasattr(self,'fichier_ini') : return
+      reevalue=0
+      if hasattr(self,'old_context_fichier_init' ):
+         reevalue=1
+         for concept in self.old_context_fichier_init.values():
+             self.jdc.delete_concept(concept)
+      if fichier == None :
+         fichier=str(self.jdc.appli.get_file_dictDonnees())
+         if fichier  == str("") : 
+           self.fichier_ini="badfile"
+           self.fichier_text=""
+           self.fichier_err=tr("Le fichier n est pas defini")
+           self.parent.record_unit(999,self)
+           try :
+              MCFils=self.get_child('FileName')
+              MCFils.set_valeur(None)
+           except :
+              pass
+           raise EficasException(self.fichier_err)
+      self.fichier_ini  = fichier
+      f=open(self.fichier_ini,'r')
+      self.fichier_text=f.read()
+      f.close()
+
+      self.contexte_fichier_init={}
+      self.fichier_unite=999
+      self.fichier_err=None
+
+      try:
+      #if 1 :
+         import Extensions.jdc_include
+         self.JdC_aux=Extensions.jdc_include.JdC_include
+      except:
+      #else:
+         traceback.print_exc()
+         self.make_incl2_except()
+         raise EficasException(" ")
+
+      try:
+      #if 1 :
+         self.make_contexte_include(self.fichier_ini ,self.fichier_text)
+         self.old_context_fichier_init=self.contexte_fichier_init
+         self.parent.record_unit(unite,self)
+         try :
+            MCFils=self.get_child('FileName')
+            #MCFils.set_valeur(fichier)
+            #on appelle pas set_valeur qui modifie le contexte ce qui fout le bazar
+            #pas de modification de bloc
+            MCFils.valeur=fichier
+            MCFils.val=fichier
+         except :
+            pass
+      except:
+      #else:
+         self.make_incl2_except()
+      # Cette P*** de ligne suivante ne fonctionne que pour Aster
+      # si quelqu un a une idee merci de m en parler
+      #CONTEXT.set_current_step(self)
+
+  def make_include2(self,fichier=None):
+  # Pour OT
+      # gestion de l unicite SVP
+      unite=999
+
+      if hasattr(self,'fichier_ini') : return
+      reevalue=0
+      if hasattr(self,'old_context_fichier_init' ):
+         reevalue=1
+         for concept in self.old_context_fichier_init.values():
+             self.jdc.delete_concept(concept)
+
+      if fichier == None :
+         fichier=str(self.jdc.appli.get_file_variable())
+         if fichier  == str("") : 
+           self.fichier_ini="badfile"
+           self.fichier_text=""
+           self.fichier_err=tr("Le fichier n est pas defini")
+           self.parent.record_unit(999,self)
+           try :
+              MCFils=self.get_child('FileName')
+              MCFils.set_valeur(None)
+           except :
+              pass
+           raise EficasException(self.fichier_err)
+
+      self.fichier_ini  = fichier
+      self.fichier_text = ""
+      self.contexte_fichier_init={}
+      self.fichier_unite=999
+      self.fichier_err=None
+      nbVariableOut=0
+      try :
+         from openturns import WrapperFile
+         monWrapper=WrapperFile(fichier)
+         data=monWrapper.getWrapperData()
+         maVariableListe=data.getVariableList()
+         nbVariables=maVariableListe.getSize()
+         for i in range(nbVariables) :
+             nom=maVariableListe[i].id_
+             type=maVariableListe[i].type_
+             if type :
+               #ligneTexte="%s=DETERMINISTICVARIABLE(N='%s',T='out',R=%d);\n" % (nom, nom, i)
+               ligneTexte=""
+               nbVariableOut=nbVariableOut+1
+             else :
+               ligneTexte="%s=DETERMINISTICVARIABLE(N='%s',T='in',R=%d);\n" % (nom, nom, i)
+             self.fichier_text = self.fichier_text + ligneTexte
+      except:
+         self.make_incl2_except()
+         raise EficasException(" ")
+
+      if nbVariableOut != 1 :
+         print((nbVariableOut ,"nbVariableOut"))
+         self.make_incl2_except(mess=tr("le fichier doit contenir une unique variable de sortie"))
+         raise EficasException(" ")
+
+      try:
+         import Extensions.jdc_include
+         self.JdC_aux=Extensions.jdc_include.JdC_include
+      except:
+         traceback.print_exc()
+         self.make_incl2_except()
+         raise EficasException(" ")
+      
+      try:
+         print((self.fichier_ini ,self.fichier_text))
+         self.make_contexte_include(self.fichier_ini ,self.fichier_text)
+         self.old_context_fichier_init=self.contexte_fichier_init
+         self.parent.record_unit(unite,self)
+         try :
+            MCFils=self.get_child('FileName')
+            MCFils.set_valeur(fichier)
+         except :
+            pass
+      except:
+         self.make_incl2_except()
+
+      # recalcul validite pour la matrice eventuelle
+      if reevalue :
+         for e in self.jdc.etapes:
+           if e.nom == "VARIABLE" :
+              e.state="modified"
+              try :
+                 mc=e.get_child('ModelVariable') 
+                 mc.state="modified"
+              except :
+                 pass
+           if e.nom == "CORRELATION" :
+              e.state="modified"
+              try :
+                 mc=e.get_child('Matrix') 
+                 mc.state="modified"
+                 mcFeuille=mc.get_child('CorrelationMatrix')
+                 mcFeuille.state="modified"
+              except :
+                 pass
+              e.isvalid()
+
+  def make_incl2_except(self,mess=None):
+         l=traceback.format_exception_only(tr("Fichier invalide"),sys.exc_info()[1])
+         if self.jdc.appli is not None:
+             if mess == None :
+                     self.jdc.appli.affiche_alerte(tr("Erreur lors de l'evaluation du fichier inclus"),
+                     message= tr("Le contenu de ce fichier ne sera pas pris en compte\n %s",\
+                                                                   ''.join(l)))
+
+             else :
+                     self.jdc.appli.affiche_alerte(tr("Erreur lors de l'evaluation du fichier inclus"),
+                                            message=tr(mess))
+         #self.parent.record_unit(unite,self)
+         self.g_context={}
+         self.etapes=[]
+         self.jdc_aux=None
+         self.fichier_err = ''.join(l)
+         self.contexte_fichier_init={}
+         try :
+            MCFils=self.get_child('FileName')
+            MCFils.set_valeur(None)
+         except :
+            pass
+
+
 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
-  def make_include(self,unite=None):
+  def make_include(self, unite=None, fname=None):
       """
           Inclut un fichier dont l'unite logique est unite
           Cette methode est appelee par la fonction sd_prod de la macro INCLUDE
       """
           Inclut un fichier dont l'unite logique est unite
           Cette methode est appelee par la fonction sd_prod de la macro INCLUDE
@@ -699,13 +1029,13 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
       #print "make_include",unite
       # On supprime l'attribut unite qui bloque l'evaluation du source de l'INCLUDE
       # car on ne s'appuie pas sur lui dans EFICAS mais sur l'attribut fichier_ini
       #print "make_include",unite
       # On supprime l'attribut unite qui bloque l'evaluation du source de l'INCLUDE
       # car on ne s'appuie pas sur lui dans EFICAS mais sur l'attribut fichier_ini
-      del self.unite
       # Si unite n'a pas de valeur, l'etape est forcement invalide. On peut retourner None
       # Si unite n'a pas de valeur, l'etape est forcement invalide. On peut retourner None
-      if not unite : return
+      if not unite and not fname:
+          return
 
       if not hasattr(self,'fichier_ini') : 
          # Si le fichier n'est pas defini on le demande
 
       if not hasattr(self,'fichier_ini') : 
          # Si le fichier n'est pas defini on le demande
-         f,text=self.get_file_memo(unite=unite,fic_origine=self.parent.nom)
+         f,text=self.get_file_memo(unite=unite, fname=fname, fic_origine=self.parent.nom)
          # On memorise le fichier retourne
          self.fichier_ini  = f
          self.fichier_text = text
          # On memorise le fichier retourne
          self.fichier_ini  = f
          self.fichier_text = text
@@ -716,75 +1046,87 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
            import Extensions.jdc_include
          except:
            traceback.print_exc()
            import Extensions.jdc_include
          except:
            traceback.print_exc()
-           raise
+           raise EficasException("pb import Extensions")
          self.JdC_aux=Extensions.jdc_include.JdC_include
 
          #print "make_include",self.fichier_ini,self.fichier_text 
          if f is None and not text:
          self.JdC_aux=Extensions.jdc_include.JdC_include
 
          #print "make_include",self.fichier_ini,self.fichier_text 
          if f is None and not text:
-             self.fichier_err="Le fichier INCLUDE n est pas defini"
+             self.fichier_err=tr("Le fichier INCLUDE n est pas defini")
              self.parent.record_unit(unite,self)
              self.parent.record_unit(unite,self)
-             raise Exception(self.fichier_err)
+             raise EficasException(self.fichier_err)
 
          try:
            self.make_contexte_include(self.fichier_ini ,self.fichier_text)
            self.parent.record_unit(unite,self)
 
          try:
            self.make_contexte_include(self.fichier_ini ,self.fichier_text)
            self.parent.record_unit(unite,self)
-           #print "make_include.context_ini",self.jdc_aux.context_ini
          except:
          except:
-           l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
+           l=traceback.format_exception_only(tr("Fichier invalide %s",sys.exc_info()[1]))
            if self.jdc.appli:
            if self.jdc.appli:
-              self.jdc.appli.affiche_alerte("Erreur lors de l'evaluation du fichier inclus",
-                                            message="Le contenu de ce fichier ne sera pas pris en compte\n"+string.join(l)
-                                           )
+              self.jdc.appli.affiche_alerte(tr("Erreur lors de l'evaluation du fichier inclus"),
+                                            message=tr("Le contenu de ce fichier ne sera pas pris en compte\n"+''.join(l)))
            self.parent.record_unit(unite,self)
            self.g_context={}
            self.etapes=[]
            self.jdc_aux=None
            self.parent.record_unit(unite,self)
            self.g_context={}
            self.etapes=[]
            self.jdc_aux=None
-           self.fichier_err = string.join(l)
+           self.fichier_err = ''.join(l)
            self.contexte_fichier_init={}
            self.contexte_fichier_init={}
-           raise
+           raise EficasException(" ")
 
       else:
          # Si le fichier est deja defini on ne reevalue pas le fichier
 
       else:
          # Si le fichier est deja defini on ne reevalue pas le fichier
-         # et on leve une exception si une erreur a été enregistrée
+         # et on leve une exception si une erreur a ete enregistree
          self.update_fichier_init(unite)
          self.fichier_unite=unite
          self.update_fichier_init(unite)
          self.fichier_unite=unite
-         if self.fichier_err is not None: raise Exception(self.fichier_err)
+         if self.fichier_err is not None: raise EficasException(self.fichier_err)
         
 
 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
   def make_contexte(self,fichier,text):
     """
         
 
 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
   def make_contexte(self,fichier,text):
     """
-        Cette méthode sert à créer un contexte pour INCLUDE_MATERIAU
-        en interprétant un texte source Python
-        Elle est appelee par la fonction sd_prd d'INCLUDE_MATERIAU
+        Cette methode sert a creer un contexte pour INCLUDE_MATERIAU
+        en interpretant un texte source Python
+        Elle est appelee par la fonction sd_prod d'INCLUDE_MATERIAU
     """
     """
+    #print "make_contexte",fichier
     # On supprime l'attribut mat qui bloque l'evaluation du source de l'INCLUDE_MATERIAU
     # car on ne s'appuie pas sur lui dans EFICAS mais sur l'attribut fichier_ini
     if hasattr(self,'mat'):del self.mat
     # On supprime l'attribut mat qui bloque l'evaluation du source de l'INCLUDE_MATERIAU
     # car on ne s'appuie pas sur lui dans EFICAS mais sur l'attribut fichier_ini
     if hasattr(self,'mat'):del self.mat
-    self.fichier_ini =fichier
-    self.fichier_unite =fichier
-    self.fichier_text=text
-    self.fichier_err=None 
-    self.contexte_fichier_init={}
-    # On specifie la classe a utiliser pour le JDC auxiliaire
-    try:
-      import Extensions.jdc_include
-    except:
-      traceback.print_exc()
-      raise
-    self.JdC_aux=Extensions.jdc_include.JdC_include
-    try:
-       self.make_contexte_include(self.fichier_ini ,self.fichier_text)
-       #self.parent.record_unit(self.fichier_unite,self)
-    except:
-       l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
-       self.fichier_err = string.join(l)
-       #self.parent.record_unit(self.fichier_unite,self)
-       self.g_context={}
-       self.etapes=[]
-       self.jdc_aux=None
+    if not hasattr(self,'fichier_ini') or self.fichier_ini != fichier or self.fichier_mater != self.nom_mater: 
+       # le fichier est nouveau ou change
+       self.fichier_ini =fichier
+       self.fichier_unite =fichier
+       self.fichier_mater=self.nom_mater
+       self.fichier_text=text
+       self.fichier_err=None 
        self.contexte_fichier_init={}
        self.contexte_fichier_init={}
-       raise
+       # On specifie la classe a utiliser pour le JDC auxiliaire
+       try:
+         import Extensions.jdc_include
+         self.JdC_aux=Extensions.jdc_include.JdC_include
+       except:
+         raise EficasException(" ")
+       try:
+          self.make_contexte_include(self.fichier_ini ,self.fichier_text)
+          if not self.nom_mater in self.g_context :
+             #Pour permettre de lire un jeu de commandes avec des INCLUDE_MATERIAU errones
+             self.g_context[self.nom_mater]=None
+             if self.parent: self.parent.g_context[self.nom_mater]=None
+       except:
+          l=traceback.format_exception_only(tr("Fichier invalide %s",sys.exc_info()[1]))
+          self.fichier_err = ''.join(l)
+          self.g_context={}
+          #Pour permettre de lire un jeu de commandes avec des INCLUDE_MATERIAU errones
+          if self.parent:
+              self.parent.g_context[self.nom_mater]=None
+          self.g_context[self.nom_mater]=None
+          #-------------
+          self.etapes=[]
+          self.jdc_aux=None
+          self.contexte_fichier_init={}
+          raise EficasException(" ")
+    else:
+       # le fichier est le meme on ne le reevalue pas
+       # et on leve une exception si une erreur a ete enregistree
+       if self.fichier_err is not None: raise EficasException(self.fichier_err)
 
 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
   def update_sdprod(self,cr='non'):
 
 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
   def update_sdprod(self,cr='non'):
@@ -806,11 +1148,13 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
       """
       try:
          sd=Noyau.N_MACRO_ETAPE.MACRO_ETAPE.Build_sd(self,nom)
       """
       try:
          sd=Noyau.N_MACRO_ETAPE.MACRO_ETAPE.Build_sd(self,nom)
-      except AsException,e:
+      except :
+      #   return None
+      #except AsException,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
          # On choisit de l'annuler
          # En plus il faut rendre coherents sdnom et sd.nom
          # 2. on la conserve mais il faut la retourner
          # On choisit de l'annuler
          # En plus il faut rendre coherents sdnom et sd.nom
@@ -823,7 +1167,7 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
 
 #ATTENTION SURCHARGE: cette methode surcharge celle de Noyau a garder en synchro 
   def make_poursuite(self):
 
 #ATTENTION SURCHARGE: cette methode surcharge celle de Noyau a garder en synchro 
   def make_poursuite(self):
-      """ Cette methode est appelée par la fonction sd_prod de la macro POURSUITE
+      """ Cette methode est appelee par la fonction sd_prod de la macro POURSUITE
       """
       #print "make_poursuite"
       if not hasattr(self,'fichier_ini') :
       """
       #print "make_poursuite"
       if not hasattr(self,'fichier_ini') :
@@ -838,7 +1182,7 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
            import Extensions.jdc_include
          except:
            traceback.print_exc()
            import Extensions.jdc_include
          except:
            traceback.print_exc()
-           raise
+           raise EficasException(" ")
          self.JdC_aux=Extensions.jdc_include.JdC_poursuite
          self.contexte_fichier_init={}
          #print "make_poursuite",self.fichier_ini,self.fichier_text
          self.JdC_aux=Extensions.jdc_include.JdC_poursuite
          self.contexte_fichier_init={}
          #print "make_poursuite",self.fichier_ini,self.fichier_text
@@ -847,7 +1191,7 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
              self.fichier_err="Le fichier POURSUITE n'est pas defini"
              self.jdc_aux=None
              self.parent.record_unit(None,self)
              self.fichier_err="Le fichier POURSUITE n'est pas defini"
              self.jdc_aux=None
              self.parent.record_unit(None,self)
-             raise Exception(self.fichier_err)
+             raise EficasException(self.fichier_err)
 
          try:
            self.make_contexte_include(self.fichier_ini,self.fichier_text)
 
          try:
            self.make_contexte_include(self.fichier_ini,self.fichier_text)
@@ -855,19 +1199,18 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
          except:
            l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
            if self.jdc.appli:
          except:
            l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
            if self.jdc.appli:
-              self.jdc.appli.affiche_alerte("Erreur lors de l'evaluation du fichier poursuite",
-                                            message="Ce fichier ne sera pas pris en compte\n"+string.join(l)
-                                           )
+              self.jdc.appli.affiche_alerte(tr("Erreur lors de l'evaluation du fichier poursuite"),
+                                            message=tr("Ce fichier ne sera pas pris en compte\n %s",''.join(l)))
            self.parent.record_unit(None,self)
            self.g_context={}
            self.etapes=[]
            self.jdc_aux=None
            self.parent.record_unit(None,self)
            self.g_context={}
            self.etapes=[]
            self.jdc_aux=None
-           self.fichier_err = string.join(l)
+           self.fichier_err = ''.join(l)
            self.contexte_fichier_init={}
            self.contexte_fichier_init={}
-           raise
+           raise EficasException(" ")
 
       else:
          # Si le fichier est deja defini on ne reevalue pas le fichier
 
       else:
          # Si le fichier est deja defini on ne reevalue pas le fichier
-         # et on leve une exception si une erreur a été enregistrée
+         # et on leve une exception si une erreur a ete enregistree
          self.update_fichier_init(None)
          self.update_fichier_init(None)
-         if self.fichier_err is not None: raise Exception(self.fichier_err)
+         if self.fichier_err is not None: raise EficasException(self.fichier_err)