Salome HOME
synchronisation avec Yoann
[tools/eficas.git] / InterfaceQT4 / editor.py
index 43865d7a584f75a10262be5c9b7a8c393ff37f51..ed534c90ba357b6457e7fbfaff9e8e7ad7cdb3be 100755 (executable)
 #
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
 #
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
+from __future__ import absolute_import
+from __future__ import print_function
+try :
+   from builtins import str
+   from builtins import range
+except : pass
+
 import types,sys,os, re
 import  subprocess
 import traceback
 
 import types,sys,os, re
 import  subprocess
 import traceback
 
-from determine import monEnvQT5
-if monEnvQT5:
-    from PyQt5.QtWidgets import QWidget, QMessageBox, QFileDialog, QApplication, QSplitter
-    from PyQt5.QtGui import QPalette
-    from PyQt5.QtCore import QProcess, QFileInfo, QTimer, Qt, QDir, QSize
-else :
-    from PyQt4.QtGui  import *
-    from PyQt4.QtCore import *
+import six
+from six.moves import range
+from PyQt5.QtWidgets import QWidget, QMessageBox, QFileDialog, QApplication, QSplitter
+from PyQt5.QtGui import QPalette
+from PyQt5.QtCore import QProcess, QFileInfo, QTimer, Qt, QDir, QSize
 import time
 import pdb
 from datetime import date
 from Extensions.i18n import tr
 
 import time
 import pdb
 from datetime import date
 from Extensions.i18n import tr
 
+import traceback
 
 # Modules Eficas
 
 
 # Modules Eficas
 
@@ -42,12 +47,12 @@ from Editeur        import session
 from Editeur        import comploader
 from Editeur        import Objecttreeitem
 from desBaseWidget  import Ui_baseWidget
 from Editeur        import comploader
 from Editeur        import Objecttreeitem
 from desBaseWidget  import Ui_baseWidget
-from monViewTexte   import ViewText 
+from InterfaceQT4.monViewTexte   import ViewText
 from monWidgetCreeParam import MonWidgetCreeParam 
 from monWidgetCreeParam import MonWidgetCreeParam 
-import browser
-import readercata
+from . import browser
+from . import readercata
 
 
-DictExtensions= {"MAP" : ".map"}
+DictExtensions= {"MAP" : ".map", "TELEMAC" : '.comm'}
 
     
 
 
     
 
@@ -78,15 +83,17 @@ class JDCEditor(Ui_baseWidget,QWidget):
         self.first      = True
         self.QWParent    = QWParent
         self.couleur     = Qt.black
         self.first      = True
         self.QWParent    = QWParent
         self.couleur     = Qt.black
+        self.nodeEnCours=None
          
         if appli != None :
            self.salome =  self.appliEficas.salome
         else :
            self.salome=0
          
         if appli != None :
            self.salome =  self.appliEficas.salome
         else :
            self.salome=0
-           print "dans JDC pas d appli ????????"
+           print ("dans JDC pas d appli ????????")
 
         # ces attributs sont mis a jour par definitCode appelee par newEditor
 
         # ces attributs sont mis a jour par definitCode appelee par newEditor
-        self.code = self.appliEficas.CONFIGURATION.code
+        self.code   = self.appliEficas.CONFIGURATION.code
+        self.initSplitterSizes()
 
         #self.afficheListesPliees=False
         self.afficheListesPliees=True
 
         #self.afficheListesPliees=False
         self.afficheListesPliees=True
@@ -96,18 +103,24 @@ class JDCEditor(Ui_baseWidget,QWidget):
         self.mode_nouv_commande=self.appliEficas.CONFIGURATION.mode_nouv_commande
         self.closeAutreCommande=self.appliEficas.CONFIGURATION.closeAutreCommande
         self.closeFrameRechercheCommande=self.appliEficas.CONFIGURATION.closeFrameRechercheCommande
         self.mode_nouv_commande=self.appliEficas.CONFIGURATION.mode_nouv_commande
         self.closeAutreCommande=self.appliEficas.CONFIGURATION.closeAutreCommande
         self.closeFrameRechercheCommande=self.appliEficas.CONFIGURATION.closeFrameRechercheCommande
+        self.closeArbre=self.appliEficas.CONFIGURATION.closeArbre
         self.affiche=self.appliEficas.CONFIGURATION.affiche
         self.affiche=self.appliEficas.CONFIGURATION.affiche
+        self.afficheOptionnelVide=self.appliEficas.CONFIGURATION.afficheOptionnelVide
+        self.nombreDeBoutonParLigne = self.appliEficas.CONFIGURATION.nombreDeBoutonParLigne
+        self.dicoImages = self.appliEficas.CONFIGURATION.dicoImages
+        self.simpleClic = self.appliEficas.CONFIGURATION.simpleClic
+        #self.taille = self.appliEficas.taille
+
         #if self.code in ['MAP','CARMELCND','PSEN'] : self.afficheCommandesPliees=False
         if self.code in ['MAP','CARMELCND'] : self.afficheCommandesPliees=False
         #if self.code in ['MAP','CARMELCND','PSEN'] : self.afficheCommandesPliees=False
         if self.code in ['MAP','CARMELCND'] : self.afficheCommandesPliees=False
-        if self.code in ['MAP',] : 
+        if self.code in ['MAP',]:
            self.widgetTree.close()
            self.widgetTree=None
            self.widgetTree.close()
            self.widgetTree=None
-           self.appliEficas.resize(1440,self.appliEficas.height())
-        else :
-           self.appliEficas.resize(1800,self.appliEficas.height())
+        if self.closeArbre: self.fermeArbre()
 
         self.version_code = session.d_env.cata
 
 
         self.version_code = session.d_env.cata
 
+
         if not hasattr ( self.appliEficas, 'readercata') or  self.appliEficas.multi==True:
            self.readercata  = readercata.READERCATA( self, self.appliEficas )
            self.appliEficas.readercata=self.readercata
         if not hasattr ( self.appliEficas, 'readercata') or  self.appliEficas.multi==True:
            self.readercata  = readercata.READERCATA( self, self.appliEficas )
            self.appliEficas.readercata=self.readercata
@@ -122,10 +135,10 @@ class JDCEditor(Ui_baseWidget,QWidget):
         self.format =  self.appliEficas.format_fichier
 
         self.dict_reels={}
         self.format =  self.appliEficas.format_fichier
 
         self.dict_reels={}
-        self.splitterSizes =  [320,1320,320]
-        self.oldSizeWidgetOptionnel = 320
         self.liste_simp_reel=[]
         self.ihm="QT"
         self.liste_simp_reel=[]
         self.ihm="QT"
+        self.dicoNouveauxMC={}
+        self.dicoNouveauxFact={}
 
         nameConf='configuration_'+self.code
         configuration=__import__(nameConf)
 
         nameConf='configuration_'+self.code
         configuration=__import__(nameConf)
@@ -142,7 +155,7 @@ class JDCEditor(Ui_baseWidget,QWidget):
 
         try:
           self.CONFIGURATION.convert_module
 
         try:
           self.CONFIGURATION.convert_module
-          print self.CONFIGURATION.convert_module
+          #print self.CONFIGURATION.convert_module
           _module = __import__(self.CONFIGURATION.convert_module)
           info = _module.entryPoint()
           convert.plugins.addEntryPoint(info)
           _module = __import__(self.CONFIGURATION.convert_module)
           info = _module.entryPoint()
           convert.plugins.addEntryPoint(info)
@@ -161,11 +174,11 @@ class JDCEditor(Ui_baseWidget,QWidget):
         self.node_selected = []
         self.deplier = True
         self.message=''
         self.node_selected = []
         self.deplier = True
         self.message=''
-        if self.code in ['Adao','MAP'] : self.afficheApresInsert=True
+        if self.code in ['Adao','ADAO','MAP'] : self.afficheApresInsert=True
         else :  self.afficheApresInsert=False
         if self.code in ['TELEMAC',] : self.enteteQTree='premier'
         else : self.enteteQTree='complet'
         else :  self.afficheApresInsert=False
         if self.code in ['TELEMAC',] : self.enteteQTree='premier'
         else : self.enteteQTree='complet'
-        if self.code in ['Adao','TELEMAC'] : self.affichePlie=True
+        if self.code in ['Adao','ADAO','TELEMAC'] : self.affichePlie=True
         else : self.affichePlie=False
 
         self.Commandes_Ordre_Catalogue =self.readercata.Commandes_Ordre_Catalogue
         else : self.affichePlie=False
 
         self.Commandes_Ordre_Catalogue =self.readercata.Commandes_Ordre_Catalogue
@@ -179,12 +192,10 @@ class JDCEditor(Ui_baseWidget,QWidget):
             self.fileInfo = QFileInfo(self.fichier)
             self.fileInfo.setCaching(0)
             if jdc==None :
             self.fileInfo = QFileInfo(self.fichier)
             self.fileInfo.setCaching(0)
             if jdc==None :
-              # try :
-              if 1:
+               try :
                    self.jdc = self.readFile(self.fichier)
                    self.jdc = self.readFile(self.fichier)
-               #except :
-              else :
-                   print "mauvaise lecture"
+               except :
+                   print ("mauvaise lecture")
             else :
                self.jdc=jdc
             if self.jdc is not None and units is not None:
             else :
                self.jdc=jdc
             if self.jdc is not None and units is not None:
@@ -199,7 +210,8 @@ class JDCEditor(Ui_baseWidget,QWidget):
                 self.nouveau=1
 
         if self.jdc:
                 self.nouveau=1
 
         if self.jdc:
-            self.jdc.appli = self
+            self.jdc.appli = self # a resorber
+            self.jdc.editor = self 
             self.jdc.lang    = self.appli.langue
             self.jdc.aReafficher=False
             txt_exception  = None
             self.jdc.lang    = self.appli.langue
             self.jdc.aReafficher=False
             txt_exception  = None
@@ -225,15 +237,15 @@ class JDCEditor(Ui_baseWidget,QWidget):
 
         
         #############
 
         
         #############
-        self.splitterSizes =  [320,1320,320]
-        self.splitter.setSizes(self.splitterSizes)
-        self.saveSplitterSizes()
+        self.adjustSize()
 
 
     #-------------------#  Pour execution avec output et error dans le bash
     def runPSEN(self):
     #-------------------#
 
 
     #-------------------#  Pour execution avec output et error dans le bash
     def runPSEN(self):
     #-------------------#
-      if self.modified or self.fichier==None  : self.saveFile()
+    
+      #if self.modified or self.fichier==None  : self.saveFile()
+      self.saveFile()
         
       #lancement avec le .bat
       path1 = os.path.abspath(os.path.join(os.path.abspath(__file__), '../','../','PSEN_Eficas','PSEN'))
         
       #lancement avec le .bat
       path1 = os.path.abspath(os.path.join(os.path.abspath(__file__), '../','../','PSEN_Eficas','PSEN'))
@@ -241,35 +253,96 @@ class JDCEditor(Ui_baseWidget,QWidget):
       import subprocess
       p = subprocess.Popen(['python',WrapperFilePath])
       (out,err)=p.communicate()        
       import subprocess
       p = subprocess.Popen(['python',WrapperFilePath])
       (out,err)=p.communicate()        
-      print out
-      print err
+      print (out)
+      print (err)
 
     #-------------------#  Pour execution avec output et error dans le bash
     def runPSEN_N1(self):
     #-------------------#
 
     #-------------------#  Pour execution avec output et error dans le bash
     def runPSEN_N1(self):
     #-------------------#
-      #cmd = os.path.abspath(os.path.join(os.path.abspath(__file__), '../','../','PSEN_N1','run.py'))
-      #cmd = "from run import runPSEN_N1; dico="+str(dico)
       
       
-      #textePython=("python "+ cmd + " "+ str(dico))
-      #print textePython
-      #self._viewTextExecute( textePython,"psen_run",".sh")
-      if generator.plugins.has_key('dicoImbrique'):
+
+      self.saveFile()
+      path1 = os.path.abspath(os.path.join(os.path.abspath(__file__), '../','../','ProcessOutputs_Eficas','TreatOutputs'))
+      sys.path.append(path1)
+
+      if not(self.jdc.isvalid()):
+         QMessageBox.information( self, tr( "Unvalid JDC"),tr("incorrect keywords will be ignored"))
+      if 'dicoImbrique' in generator.plugins:
          self.generator=generator.plugins['dicoImbrique']()
          jdc_formate=self.generator.gener(self.jdc)
          dico=self.generator.Dico 
          self.generator=generator.plugins['dicoImbrique']()
          jdc_formate=self.generator.gener(self.jdc)
          dico=self.generator.Dico 
-         from variablesPSENN1 import PSEN_N1_Variables
-         mesVariables= PSEN_N1_Variables()
-         mesVariables.raz()
-         mesVariables.setValues(dico)
-         mesVariables.imprime()
          
          
-      from eficas_go import getJdcParameters
-      from run import runPSEN_N1
-      res,txt_exception=runPSEN_N1(dico)
-      if res : QMessageBox.information( self, tr("fin de script run"), txt_exception)
-      else  : QMessageBox.critical( self, tr("Erreur fatale script run"), txt_exception)
-       
+         ###to delete
+         #fileDico =  r'C:\Logiciels DER\PSEN_V16\Code\ProcessOutputs_Eficas\TreatOutputs\dicoN1.py'
+         fileDico =  os.path.join(path1, 'dicoN1.py') #r'C:\Logiciels DER\PSEN_V16\Code\ProcessOutputs_Eficas\TreatOutputs\dicoN1.py'
+         f = open( str(fileDico), 'w')
+         f.write("Dico =" + str(dico) )
+         f.close()
+         ###
+         
       
       
+      #print ('in runPSEN_N1', dico)
+      from Run import run 
+      run(dico)
+      #res,txt_exception=run(dico)
+      #if res : QMessageBox.information( self, tr("fin de script run"), txt_exception)
+      #else  : QMessageBox.critical( self, tr("Erreur fatale script run"), txt_exception)
+       
+    #-------------------#  Pour execution avec output et error dans le bash
+    def process_N1(self):
+    #-------------------#
+
+      path1 = os.path.abspath(os.path.join(os.path.abspath(__file__), '../','../','ProcessOutputs_Eficas','TreatOutputs'))
+      sys.path.append(path1)
+
+
+      if 'dicoImbrique' in generator.plugins:
+         self.generator=generator.plugins['dicoImbrique']()
+         jdc_formate=self.generator.gener(self.jdc)
+         dico=self.get_Dico() #generator.Dico
+
+
+         for k in dico['CONTINGENCY_PROCESSING']:
+             #print (k)
+             if k[0:19] == 'Component_List_For_' or k[0:21] =='Contingency_List_For_' :
+                newK=k.replace('___',' ')
+                l="'"+str(newK)+"'"
+                dico['CONTINGENCY_PROCESSING'][l]=dico['CONTINGENCY_PROCESSING'][k]
+                del dico['CONTINGENCY_PROCESSING'][k]
+
+         ###to delete
+         fileDico =  os.path.join(path1, 'dicoN1_process.py')
+         f = open( str(fileDico), 'w')
+         f.write("Dico =" + str(dico) )
+         f.close()
+         ###
+         return dico
+
+        #return self.get_Dico()
+
+    #-------------------#  Pour execution avec output et error dans le bash
+    def process_VP(self):
+    #-------------------#
+      if 'dicoImbrique' in generator.plugins:
+         self.generator=generator.plugins['dicoImbrique']()
+         jdc_formate=self.generator.gener(self.jdc)
+         dico=self.get_Dico() #generator.Dico
+         return dico
+
+   
+    #--------------------------------#
+    def ajoutCommentaire(self):
+    #--------------------------------#
+        if self.tree.selectedItems()==[] :
+          QMessageBox.warning( self, tr("Pas de noeud selectionne"),tr("Selectionnez un Noeud \nLe commentaire sera place apres le noeud selectionne"))
+          return 
+        noeudAvantCommentaire=self.tree.selectedItems()[0]
+        if noeudAvantCommentaire ==self.tree.racine : 
+            self.tree.racine.append_child("COMMENTAIRE",pos=0)
+            return
+        noeudAvantCommentaire.addComment(True)
+        
+
 
     #--------------------------------#
     def _newJDC( self ,units = None):
 
     #--------------------------------#
     def _newJDC( self ,units = None):
@@ -284,8 +357,12 @@ class JDCEditor(Ui_baseWidget,QWidget):
         if self.code == "CARMELCND" : texte=self._newJDCCND()
         if self.code == "ZCRACKS" : texte=self._newZCRACKS()
         if self.code == "TELEMAC" : texte=self._newTELEMAC()
         if self.code == "CARMELCND" : texte=self._newJDCCND()
         if self.code == "ZCRACKS" : texte=self._newZCRACKS()
         if self.code == "TELEMAC" : texte=self._newTELEMAC()
-        if self.code == "PSEN" : texte = self._newPSEN()
+        if self.code == "PSEN"    : texte = self._newPSEN()
         if self.code == "PSEN_N1" : texte = self._newPSEN_N1()
         if self.code == "PSEN_N1" : texte = self._newPSEN_N1()
+
+        if hasattr(self.readercata.cata[0],'TEXTE_NEW_JDC') : texte=self.readercata.cata[0].TEXTE_NEW_JDC
+
+        #if self.code == "CF" : texte = self._new_CF()
         #   texte=self.newTexteCND
        
         jdc=self.readercata.cata[0].JdC( procedure =texte,
         #   texte=self.newTexteCND
        
         jdc=self.readercata.cata[0].JdC( procedure =texte,
@@ -341,7 +418,7 @@ class JDCEditor(Ui_baseWidget,QWidget):
         Public slot to read the text from a file.
         @param fn filename to read from (string or QString)
         """
         Public slot to read the text from a file.
         @param fn filename to read from (string or QString)
         """
-        fn = unicode(fn)
+        fn = six.text_type(fn)
 
         # ------------------------------------------------------------------------------------
         #                         charge le JDC
 
         # ------------------------------------------------------------------------------------
         #                         charge le JDC
@@ -349,7 +426,7 @@ class JDCEditor(Ui_baseWidget,QWidget):
 
         jdcName=os.path.basename(fn)
         # Il faut convertir le contenu du fichier en fonction du format
 
         jdcName=os.path.basename(fn)
         # Il faut convertir le contenu du fichier en fonction du format
-        if convert.plugins.has_key( self.appliEficas.format_fichier_in ):
+        if self.appliEficas.format_fichier_in in convert.plugins:
              # Le convertisseur existe on l'utilise
              #appli = self
              p=convert.plugins[self.appliEficas.format_fichier_in]()
              # Le convertisseur existe on l'utilise
              #appli = self
              p=convert.plugins[self.appliEficas.format_fichier_in]()
@@ -401,7 +478,7 @@ class JDCEditor(Ui_baseWidget,QWidget):
     #-----------------------#
 
         # Il faut convertir le contenu du fichier en fonction du format
     #-----------------------#
 
         # Il faut convertir le contenu du fichier en fonction du format
-        if convert.plugins.has_key(self.format):
+        if self.format in convert.plugins :
             # Le convertisseur existe on l'utilise
             p=convert.plugins[self.format]()
             p.readfile(file)
             # Le convertisseur existe on l'utilise
             p=convert.plugins[self.format]()
             p.readfile(file)
@@ -443,12 +520,8 @@ class JDCEditor(Ui_baseWidget,QWidget):
         f=open(nomFichier,'w')
         f.write(txt)
         f.close()
         f=open(nomFichier,'w')
         f.write(txt)
         f.close()
-        if monEnvQT5 :
-           self.monExe.readyReadStandardOutput.connect( self.readFromStdOut)
-           self.monExe.readyReadStandardError.connect( self.readFromStdErr)
-        else :
-           self.connect(self.monExe, SIGNAL("readyReadStandardOutput()"), self.readFromStdOutQT4 )
-           self.connect(self.monExe, SIGNAL("readyReadStandardError()"), self.readFromStdErrQT4 )
+        self.monExe.readyReadStandardOutput.connect( self.readFromStdOut)
+        self.monExe.readyReadStandardError.connect( self.readFromStdErr)
         exe='sh ' + nomFichier
         self.monExe.start(exe)
         self.monExe.closeWriteChannel()
         exe='sh ' + nomFichier
         self.monExe.start(exe)
         self.monExe.closeWriteChannel()
@@ -461,11 +534,11 @@ class JDCEditor(Ui_baseWidget,QWidget):
 
     def readFromStdErr(self):
         a=self.monExe.readAllStandardError()
 
     def readFromStdErr(self):
         a=self.monExe.readAllStandardError()
-        self.w.view.append(str(a.data(),len(a)))
+        self.w.view.append(str(a.data()))
 
 
-    def readFromStdErr(self) :
+    def readFromStdOut(self) :
         a=self.monExe.readAllStandardOutput()
         a=self.monExe.readAllStandardOutput()
-        self.w.view.append(str(a.data(),len(a)))
+        self.w.view.append(str(a.data()))
 
     def readFromStdErrQT4(self):
         a=self.monExe.readAllStandardError()
 
     def readFromStdErrQT4(self):
         a=self.monExe.readAllStandardError()
@@ -475,7 +548,14 @@ class JDCEditor(Ui_baseWidget,QWidget):
         a=self.monExe.readAllStandardOutput()
         self.w.view.append(QString.fromUtf8(a.data(),len(a))) ;
         
         a=self.monExe.readAllStandardOutput()
         self.w.view.append(QString.fromUtf8(a.data(),len(a))) ;
         
-
+    #-----------------------#
+    def generDico(self):
+    #-----------------------#
+       if 'dico' in generator.plugins:
+         self.generator=generator.plugins['dico']()
+         jdc_formate=self.generator.gener(self.jdc)
+         dico=self.generator.Dico
+         return dico
 
     #-----------------------#
     def gestionParam(self):
 
     #-----------------------#
     def gestionParam(self):
@@ -486,6 +566,7 @@ class JDCEditor(Ui_baseWidget,QWidget):
     #-----------------------#
     def viewJdcSource(self):
     #-----------------------#
     #-----------------------#
     def viewJdcSource(self):
     #-----------------------#
+        if self.fichier == None : return
         f=open(self.fichier,'r')
         texteSource=f.read()
         f.close()
         f=open(self.fichier,'r')
         texteSource=f.read()
         f.close()
@@ -500,7 +581,7 @@ class JDCEditor(Ui_baseWidget,QWidget):
     #-----------------------#
     def viewJdcRapport(self):
     #-----------------------#
     #-----------------------#
     def viewJdcRapport(self):
     #-----------------------#
-        strRapport = unicode( self.jdc.report() )
+        strRapport = six.text_type( self.jdc.report() )
         # on ajoute les regles
         
         self._viewText(strRapport, "JDC_RAPPORT")
         # on ajoute les regles
         
         self._viewText(strRapport, "JDC_RAPPORT")
@@ -581,7 +662,7 @@ class JDCEditor(Ui_baseWidget,QWidget):
     #---------------------#
     def handleRechercher(self):
     #---------------------#
     #---------------------#
     def handleRechercher(self):
     #---------------------#
-      from monRecherche import DRecherche
+      from .monRecherche import DRecherche
       monRechercheDialg=DRecherche(parent=self,fl=0)
       monRechercheDialg.show()
 
       monRechercheDialg=DRecherche(parent=self,fl=0)
       monRechercheDialg.show()
 
@@ -589,7 +670,7 @@ class JDCEditor(Ui_baseWidget,QWidget):
     #--------------------------------#
     def handleRechercherDsCatalogue(self):
     #-----------------------------#
     #--------------------------------#
     def handleRechercherDsCatalogue(self):
     #-----------------------------#
-      from monRechercheCatalogue import DRechercheCatalogue
+      from .monRechercheCatalogue import DRechercheCatalogue
       monRechercheDialg=DRechercheCatalogue(self.QWParent,self)
       monRechercheDialg.show()
 
       monRechercheDialg=DRechercheCatalogue(self.QWParent,self)
       monRechercheDialg.show()
 
@@ -655,34 +736,23 @@ class JDCEditor(Ui_baseWidget,QWidget):
                       tr("Copie impossible"),
                       tr("Veuillez selectionner un seul objet : la copie se fera apres le noeud selectionne"))
           return
                       tr("Copie impossible"),
                       tr("Veuillez selectionner un seul objet : la copie se fera apres le noeud selectionne"))
           return
+      noeudOuColler=self.node_selected[0]
 
       if len(self.QWParent.noeud_a_editer)!=1:
 
       if len(self.QWParent.noeud_a_editer)!=1:
-         self.handleEditPasteMultiple()
+         #self.handleEditPasteMultiple()
+         QMessageBox.information( self, tr("Copie impossible"), tr("Aucun Objet n a ete copie ou coupe"))
          return
 
          return
 
-      noeudOuColler=self.node_selected[0]
-      pos='after'
-      if noeudOuColler == self.tree.racine:
-         indexNoeudOuColler=0
-         pos='before'
-      else :
-         #indexNoeudOuColler=noeudOuColler.treeParent.children.index(noeudOuColler)
-         indexNoeudOuColler=self.getTreeIndex(noeudOuColler)
-
-      try :
-       noeudACopier=self.QWParent.noeud_a_editer[0]
-       #indexNoeudACopier=noeudACopier.treeParent.children.index(noeudACopier)
-       indexNoeudACopier=self.getTreeIndex(noeudACopier)
-      except :
-       QMessageBox.information( self, tr("Copie impossible"), tr("Aucun Objet n a ete copie ou coupe"))
-       return
+      noeudACopier=self.QWParent.noeud_a_editer[0]
 
       if (self.QWParent.edit != "couper"):
 
       if (self.QWParent.edit != "couper"):
+        #print   (noeudOuColler.item.parent.get_child(noeudOuColler.item.nom)) 
         try:
            if noeudOuColler == self.tree.racine :
         try:
            if noeudOuColler == self.tree.racine :
-              child=noeudOuColler.doPastePremier(noeudACopier)
+               child=noeudOuColler.doPastePremier(noeudACopier)
            else :
            else :
-              child=noeudACopier.doPaste(noeudOuColler,pos)
+               child=noeudACopier.doPaste(noeudOuColler,'after')
+
            if child==None or child==0:
                QMessageBox.critical( self,tr( "Copie refusee"),tr('Eficas n a pas reussi a copier l objet'))
                self.message = ''
            if child==None or child==0:
                QMessageBox.critical( self,tr( "Copie refusee"),tr('Eficas n a pas reussi a copier l objet'))
                self.message = ''
@@ -708,7 +778,7 @@ class JDCEditor(Ui_baseWidget,QWidget):
       # si possible on renomme l objet comme le noeud couper
 
       if (self.QWParent.edit == "couper"):
       # si possible on renomme l objet comme le noeud couper
 
       if (self.QWParent.edit == "couper"):
-         #try :
+         print ('je pass la')
          if noeudACopier.treeParent.editor != noeudOuColler.treeParent.editor:
            QMessageBox.critical( self, tr("Deplacement refuse"),tr('Deplacement refuse entre 2 fichiers. Seule la copie est autorisee '))
 
          if noeudACopier.treeParent.editor != noeudOuColler.treeParent.editor:
            QMessageBox.critical( self, tr("Deplacement refuse"),tr('Deplacement refuse entre 2 fichiers. Seule la copie est autorisee '))
 
@@ -828,7 +898,7 @@ class JDCEditor(Ui_baseWidget,QWidget):
         @return flag indicating success
         """
 
         @return flag indicating success
         """
 
-        fn = unicode(fn)
+        fn = six.text_type(fn)
        
         if txt == None :
             txt = self.get_text_JDC(self.format,formatLigne=formatLigne)
        
         if txt == None :
             txt = self.get_text_JDC(self.format,formatLigne=formatLigne)
@@ -841,32 +911,36 @@ class JDCEditor(Ui_baseWidget,QWidget):
             txt=self.ajoutVersionCataDsJDC(txt)
             checksum=self.get_checksum(txt)
             txt=txt+checksum
             txt=self.ajoutVersionCataDsJDC(txt)
             checksum=self.get_checksum(txt)
             txt=txt+checksum
+        if self.code=="TELEMAC" : return 1
         try:
         try:
-            f = open(fn, 'wb')
+            f = open(fn, 'w')
             f.write(txt)
             f.close()
             return 1
             f.write(txt)
             f.close()
             return 1
-        except IOError, why:
+        except IOError as why:
             if (self.appliEficas.ssIhm == False):
                 QMessageBox.critical(self, tr('Sauvegarde du Fichier'),
                 tr('Le fichier')+str(fn) + tr('n a pas pu etre sauvegarde : ') + str(why))
             else :
             if (self.appliEficas.ssIhm == False):
                 QMessageBox.critical(self, tr('Sauvegarde du Fichier'),
                 tr('Le fichier')+str(fn) + tr('n a pas pu etre sauvegarde : ') + str(why))
             else :
-                print why
+                print (why)
             return 0
 
     #-----------------------------------------------------------#
     def get_text_JDC(self,format,pourRun=0,formatLigne="beautifie"):
     #-----------------------------------------------------------#
             return 0
 
     #-----------------------------------------------------------#
     def get_text_JDC(self,format,pourRun=0,formatLigne="beautifie"):
     #-----------------------------------------------------------#
-      if self.code == "MAP" and not(generator.plugins.has_key(format)): format = "MAP"
-      if generator.plugins.has_key(format):
+      if self.code == "MAP" and not(format in generator.plugins): format = "MAP"
+      if format in generator.plugins:
          
          # Le generateur existe on l'utilise
          self.generator=generator.plugins[format]()
          try :
             jdc_formate=self.generator.gener(self.jdc,format=formatLigne,config=self.appliEficas.CONFIGURATION,appli=self.appliEficas)
             if pourRun : jdc_formate=self.generator.textePourRun
          
          # Le generateur existe on l'utilise
          self.generator=generator.plugins[format]()
          try :
             jdc_formate=self.generator.gener(self.jdc,format=formatLigne,config=self.appliEficas.CONFIGURATION,appli=self.appliEficas)
             if pourRun : jdc_formate=self.generator.textePourRun
-         except ValueError,e:
+            if self.code == 'TELEMAC' : jdc_formate=self.generator.texteDico
+         except ValueError as e:
             QMessageBox.critical(self, tr("Erreur a la generation"),str(e))
             QMessageBox.critical(self, tr("Erreur a la generation"),str(e))
+            return
+
          if not self.generator.cr.estvide():
             self.affiche_infos(tr("Erreur a la generation"),Qt.red)
             QMessageBox.critical( self, tr("Erreur a la generation"),tr("EFICAS ne sait pas convertir ce JDC"))
          if not self.generator.cr.estvide():
             self.affiche_infos(tr("Erreur a la generation"),Qt.red)
             QMessageBox.critical( self, tr("Erreur a la generation"),tr("EFICAS ne sait pas convertir ce JDC"))
@@ -879,19 +953,32 @@ class JDCEditor(Ui_baseWidget,QWidget):
          QMessageBox.critical( self, "Format  non reconnu" ,tr("EFICAS ne sait pas convertir le JDC selon le format "+ self.format))
          return ""
 
          QMessageBox.critical( self, "Format  non reconnu" ,tr("EFICAS ne sait pas convertir le JDC selon le format "+ self.format))
          return ""
 
+    #----------------------#
+    def get_Dico(self):
+    #---------------------#
+      if 'dicoImbrique' in generator.plugins:
+         self.generator=generator.plugins['dicoImbrique']()
+         jdc_formate=self.generator.gener(self.jdc)
+         dico=self.generator.Dico 
+         return dico
+      else : 
+         self.affiche_infos(tr("Format %s non reconnu" , self.format),Qt.red)
+         QMessageBox.critical( self, "Format  non reconnu" ,tr("EFICAS ne sait pas convertir le JDC selon le format "+ self.format))
+         return ""
+
+
     #------------#
     def run(self):
     #------------#
     #------------#
     def run(self):
     #------------#
-      print "kkkkkkkkkk"
       fonction="run"+self.code
       fonction="run"+self.code
-      print fonction
-      if fonction in JDCEditor.__dict__.keys(): apply(JDCEditor.__dict__[fonction],(self,))
+      #print fonction
+      if fonction in JDCEditor.__dict__: JDCEditor.__dict__[fonction](self,)
 
     #------------#
     def saveRun(self):
     #------------#
       fonction="saveRun"+self.code
 
     #------------#
     def saveRun(self):
     #------------#
       fonction="saveRun"+self.code
-      if fonction in JDCEditor.__dict__.keys(): apply(JDCEditor.__dict__[fonction],(self,))
+      if fonction in JDCEditor.__dict__: JDCEditor.__dict__[fonction](self,)
 
     #---------------#
     def runMAP(self):
 
     #---------------#
     def runMAP(self):
@@ -930,8 +1017,8 @@ class JDCEditor(Ui_baseWidget,QWidget):
           #   os.system(commande)
           #except :
           #   pass
           #   os.system(commande)
           #except :
           #   pass
-      except Exception, e:
-          print traceback.print_exc()
+      except Exception as e:
+          print((traceback.print_exc()))
 
     #-------------------#
     def runZCRACKS(self):
 
     #-------------------#
     def runZCRACKS(self):
@@ -951,8 +1038,8 @@ class JDCEditor(Ui_baseWidget,QWidget):
           commande="more "
           textePython=(commande + self.fichierZcracksInput)
           self._viewTextExecute( textePython,"run_zcracks",".sh")
           commande="more "
           textePython=(commande + self.fichierZcracksInput)
           self._viewTextExecute( textePython,"run_zcracks",".sh")
-      except Exception, e:
-          print traceback.print_exc()
+      except Exception as e:
+          print((traceback.print_exc()))
 
     #-------------------#
     def runCARMELCND(self):
 
     #-------------------#
     def runCARMELCND(self):
@@ -975,10 +1062,6 @@ class JDCEditor(Ui_baseWidget,QWidget):
       f.close()
       commande="xterm -e sh "+nomFichier +"\n"
       os.system(commande)
       f.close()
       commande="xterm -e sh "+nomFichier +"\n"
       os.system(commande)
-      #try :
-      #    self._viewTextExecute( textePython,"carmel_run",".sh")
-      #except Exception, e:
-      #    print traceback.print_exc()
 
     #-------------------#
     def runCarmelCS(self):
 
     #-------------------#
     def runCarmelCS(self):
@@ -986,13 +1069,13 @@ class JDCEditor(Ui_baseWidget,QWidget):
       try :
           commande="runSession pilotyacsCS.py"
           os.system(commande)
       try :
           commande="runSession pilotyacsCS.py"
           os.system(commande)
-      except Exception, e:
-          print traceback.print_exc()
+      except Exception as e:
+          print((traceback.print_exc()))
 
     #-----------------------------------------------------#
     def determineNomFichier(self,path,extension):
     #-----------------------------------------------------#
 
     #-----------------------------------------------------#
     def determineNomFichier(self,path,extension):
     #-----------------------------------------------------#
-      if DictExtensions.has_key(self.appli.code) :
+      if self.appli.code in DictExtensions:
          chaine1="JDC (*"+DictExtensions[self.appli.code]+");;"
          extensions= tr(chaine1+ "All Files (*)")
       else :
          chaine1="JDC (*"+DictExtensions[self.appli.code]+");;"
          extensions= tr(chaine1+ "All Files (*)")
       else :
@@ -1006,26 +1089,19 @@ class JDCEditor(Ui_baseWidget,QWidget):
              extensions,None,
              QFileDialog.DontConfirmOverwrite)
       if fn == None : return (0, None)
              extensions,None,
              QFileDialog.DontConfirmOverwrite)
       if fn == None : return (0, None)
-      if monEnvQT5 :  fn=fn[0]
+      fn=fn[0]
       if fn=='': return (0, None)
 
       ext = QFileInfo(fn).suffix()
       if ext == '': fn+=extension
 
       if QFileInfo(fn).exists():
       if fn=='': return (0, None)
 
       ext = QFileInfo(fn).suffix()
       if ext == '': fn+=extension
 
       if QFileInfo(fn).exists():
-           if monEnvQT5 :
-             msgBox = QMessageBox(self)
-             msgBox.setWindowTitle(tr("Sauvegarde du Fichier"))
-             msgBox.setText(tr("Le fichier <b>%s</b> existe deja.", unicode(fn)))
-             msgBox.addButton(tr("&Ecraser"),0)
-             msgBox.addButton(tr("&Abandonner"),1)
-             abort=msgBox.exec_()
-           else :
-             abort = QMessageBox.warning(self,
-                   tr("Sauvegarde du Fichier"),
-                   tr("Le fichier <b>%s</b> existe deja.",str(fn)),
-                   tr("&Ecraser"),
-                   tr("&Abandonner"))
+           msgBox = QMessageBox(self)
+           msgBox.setWindowTitle(tr("Sauvegarde du Fichier"))
+           msgBox.setText(tr("Le fichier <b>%s</b> existe deja.", six.text_type(fn)))
+           msgBox.addButton(tr("&Ecraser"),0)
+           msgBox.addButton(tr("&Abandonner"),1)
+           abort=msgBox.exec_()
            if abort == 1 :  return (0, "")
       return (1,fn)
 
            if abort == 1 :  return (0, "")
       return (1,fn)
 
@@ -1066,19 +1142,13 @@ class JDCEditor(Ui_baseWidget,QWidget):
                for b in c.children():
                   if isinstance(b,QPushButton):
                      avant=b.text()
                for b in c.children():
                   if isinstance(b,QPushButton):
                      avant=b.text()
-                     if (not monEnvQT5) and avant.toLatin1()=="&Open": b.setText("Save")
-                     if monEnvQT5 and avant=="&Open": b.setText("Save")
-        if monEnvQT5 :
-           mesFiltres= "input Map (*.input);;All Files (*)"
-        else :
-           mesFiltres=QStringList()
-           mesFiltres << "input Map (*.input)" << "All Files (*)"
+                     if avant=="&Open": b.setText("Save")
+        mesFiltres= "input Map (*.input);;All Files (*)"
         monDialog.setNameFilters(mesFiltres)
         if monNomFichier!="" : monDialog.selectFile(monNomFichier)
         BOk=monDialog.exec_()
         if BOk==0: return
         monDialog.setNameFilters(mesFiltres)
         if monNomFichier!="" : monDialog.selectFile(monNomFichier)
         BOk=monDialog.exec_()
         if BOk==0: return
-        if monEnvQT5 : fn=str(monDialog.selectedFiles()[0])
-        else : fn=str(monDialog.selectedFiles()[0].toLatin1())
+        fn=str(monDialog.selectedFiles()[0])
         if fn == "" or fn == None : return
         if not fn.endswith(".input"):
             fn += ".input"
         if fn == "" or fn == None : return
         if not fn.endswith(".input"):
             fn += ".input"
@@ -1097,36 +1167,8 @@ class JDCEditor(Ui_baseWidget,QWidget):
     #-----------------#
     def saveRunPSEN(self):
     #-----------------#
     #-----------------#
     def saveRunPSEN(self):
     #-----------------#
-        print "saveRunPSEN"
+        #print ("saveRunPSEN")
         self.saveFile()
         self.saveFile()
-        return
-        if not(self.jdc.isvalid()):
-           QMessageBox.critical( self, tr( "Sauvegarde de l'input impossible "),
-                                tr("Un JdC valide est necessaire pour creer un .input")
-                                 )
-           return
-
-        print generator.plugins.has_key(self.format)
-        if generator.plugins.has_key(self.format):
-             # Le generateur existe on l'utilise
-             self.generator=generator.plugins[self.format]()
-             try :
-                self.generator.gener(self.jdc)
-                self.generator.writeDefault('')
-             except ValueError,e:
-                QMessageBox.critical(self, tr("Erreur a la generation"),str(e))
-             if not self.generator.cr.estvide():
-                self.affiche_infos(tr("Erreur a la generation"),Qt.red)
-                QMessageBox.critical( self, tr("Erreur a la generation"),tr("EFICAS ne sait pas convertir ce JDC"))
-                return ""
-        else:
-             # Il n'existe pas c'est une erreur
-             self.affiche_infos(tr("Format %s non reconnu" , self.format),Qt.red)
-             QMessageBox.critical( self, "Format  non reconnu" ,tr("EFICAS ne sait pas convertir le JDC selon le format "+ self.format))
-             return ""
-        print "HELLO"
-        
-
 
 
     #-----------------------------------------#
 
 
     #-----------------------------------------#
@@ -1140,7 +1182,7 @@ class JDCEditor(Ui_baseWidget,QWidget):
     #-----------------------------------------#
         dicoCourant={}
         format =  self.appliEficas.format_fichier
     #-----------------------------------------#
         dicoCourant={}
         format =  self.appliEficas.format_fichier
-        if generator.plugins.has_key(format):
+        if format in generator.plugins:
            # Le generateur existe on l'utilise
            self.generator=generator.plugins[format]()
            jdc_formate=self.generator.gener(self.jdc,format='beautifie',config=self.appliEficas.CONFIGURATION)
            # Le generateur existe on l'utilise
            self.generator=generator.plugins[format]()
            jdc_formate=self.generator.gener(self.jdc,format='beautifie',config=self.appliEficas.CONFIGURATION)
@@ -1162,6 +1204,44 @@ class JDCEditor(Ui_baseWidget,QWidget):
         #else :
            pass
 
         #else :
            pass
 
+    #-----------------------------------------------------------------#
+    def saveFileLegerAs(self, fileName = None) :
+    #-----------------------------------------------------------------#
+        if fileName != None :
+           self.fichier = fileName
+           return self.saveFileLeger()
+        return self.saveFileLeger()
+
+    #-----------------------------------------------------------------#
+    def saveFileLeger(self, path = None, saveas= 0,formatLigne="beautifie"):
+    #-----------------------------------------------------------------#
+        extension='.casR'
+        fn = self.fichier
+        #saveas=True # Pour forcer le nom
+        self.generator=generator.plugins[self.format]()
+        if self.fichier is None or saveas:
+          if path is None: path=self.CONFIGURATION.savedir
+          bOK, fn=self.determineNomFichier(path,extension)
+          if bOK == 0 : return (0, None)
+          if fn == None : return (0, None)
+          if fn== '' : return (0, None)
+
+          ulfile = os.path.abspath(six.text_type(fn))
+          self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
+          fn = six.text_type(QDir.toNativeSeparators(fn))
+
+        self.fichier = os.path.splitext(fn)[0]+extension
+
+        if hasattr(self.generator, "writeLeger"):
+            self.generator.writeLeger(self.fichier,self.jdc,config=self.appliEficas.CONFIGURATION,appli=self.appliEficas)
+
+        if self.salome : self.appliEficas.addJdcInSalome( self.fichier)
+
+        self.modified = 0
+        nouveauTitre=self.titre+"              "+str(os.path.basename(self.fichier))
+        self.appliEficas.setWindowTitle(nouveauTitre)
+        return (1, self.fichier)
+
     #-----------------------------------------------------------------#
     def saveFile(self, path = None, saveas= 0,formatLigne="beautifie"):
     #-----------------------------------------------------------------#
     #-----------------------------------------------------------------#
     def saveFile(self, path = None, saveas= 0,formatLigne="beautifie"):
     #-----------------------------------------------------------------#
@@ -1177,8 +1257,7 @@ class JDCEditor(Ui_baseWidget,QWidget):
         if not self.modified and not saveas:
             return (0, None)      # do nothing if text wasn't changed
 
         if not self.modified and not saveas:
             return (0, None)      # do nothing if text wasn't changed
 
-        extension='.py'
-        if DictExtensions.has_key(self.appli.code) :
+        if self.appli.code in DictExtensions :
            extension=DictExtensions[self.appli.code]
         else :
            extension='.comm'
            extension=DictExtensions[self.appli.code]
         else :
            extension='.comm'
@@ -1192,9 +1271,9 @@ class JDCEditor(Ui_baseWidget,QWidget):
           if fn == None : return (0, None)
           if fn== '' : return (0, None)
 
           if fn == None : return (0, None)
           if fn== '' : return (0, None)
 
-          ulfile = os.path.abspath(unicode(fn))
+          ulfile = os.path.abspath(six.text_type(fn))
           self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
           self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
-          fn = unicode(QDir.toNativeSeparators(fn))
+          fn = six.text_type(QDir.toNativeSeparators(fn))
           newName = fn
 
 
           newName = fn
 
 
@@ -1212,7 +1291,7 @@ class JDCEditor(Ui_baseWidget,QWidget):
 
         if self.jdc.isvalid() != 0 and hasattr(self.generator, "writeDefault"):
             self.generator.writeDefault(fn)
 
         if self.jdc.isvalid() != 0 and hasattr(self.generator, "writeDefault"):
             self.generator.writeDefault(fn)
-        if self.code=="TELEMAC" and hasattr(self.generator, "writeDefault"):
+        elif self.code=="TELEMAC" and hasattr(self.generator, "writeDefault"):
             self.generator.writeDefault(fn)
 
         if self.salome :
             self.generator.writeDefault(fn)
 
         if self.salome :
@@ -1275,9 +1354,9 @@ class JDCEditor(Ui_baseWidget,QWidget):
         # ce retour est impose par le get_file d'I_JDC
         if fn== '' : return None," "
         if not fn : return (0, " ")
         # ce retour est impose par le get_file d'I_JDC
         if fn== '' : return None," "
         if not fn : return (0, " ")
-        if monEnvQT5 :  fn=fn[0]
+        fn=fn[0]
 
 
-        ulfile = os.path.abspath(unicode(fn))
+        ulfile = os.path.abspath(six.text_type(fn))
         self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
 
         # On utilise le convertisseur defini par format_fichier
         self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
 
         # On utilise le convertisseur defini par format_fichier
@@ -1290,73 +1369,288 @@ class JDCEditor(Ui_baseWidget,QWidget):
             jdcText = ''
         return ulfile, jdcText
 
             jdcText = ''
         return ulfile, jdcText
 
-    #-------------------------------#
+    #-----------------------------------#
     def updateJdc(self, itemApres,texte):
     def updateJdc(self, itemApres,texte):
-    #--------------------------------#
+    #------------------------------------#
+    # ajoute une etape  de JdC a partir d un texte
         monItem=itemApres
         etape=monItem.item.object
         monItem=itemApres
         etape=monItem.item.object
-
         CONTEXT.set_current_step(etape)
         etape.build_includeInclude(texte)
         self.tree.racine.build_children()
 
         CONTEXT.set_current_step(etape)
         etape.build_includeInclude(texte)
         self.tree.racine.build_children()
 
+    #-----------------------------------#
+    def updateJdcEtape(self, itemApres,texte):
+    #------------------------------------#
+    # ajoute une etape  de JdC a partir d un texte
+        monItem=itemApres
+        etape=monItem.item.object
+        CONTEXT.set_current_step(etape)
+        etape.build_includeEtape(texte)
+        self.tree.racine.build_children()
+
+
     #-------------------------------------#
     #-------------------------------------#
-    def deleteMC(self,etape,MCFils):
+    def deleteEtape(self,etape):
     #-------------------------------------#
     #-------------------------------------#
-        print "je passe dans deleteMC" 
-        monMC=etape.get_child(MCFils,restreint="oui")
-        if monMC != None : print etape.suppentite(monMC)
+    # dans le JDC
+        self.jdc.suppentite(etape)
 
 
+    #-------------------------------------#
+    def deleteMC(self,etape,MCFils,listeAvant=()):
+    #-------------------------------------#
+    # dans le JDC
+        ouChercher=etape
+        for mot in listeAvant :
+              ouChercher=ouChercher.get_child(mot,restreint="oui")
+        monMC=ouChercher.get_child(MCFils,restreint="oui")
+        if monMC != None :  ouChercher.suppentite(monMC)
+        ouChercher.state='changed'
+        ouChercher.isvalid()
 
     #-------------------------------------#
 
     #-------------------------------------#
-    def ajoutMC(self,etape,MCFils,valeurs):
+    def ajoutMC(self,etape,MCFils,valeurs,listeAvant=()):
     #-------------------------------------#
     #-------------------------------------#
-        print "je passe dans ajoutMC" 
-        monMC=etape.get_child(MCFils,restreint="oui")
-        if monMC== None : monMC= etape.addentite(MCFils)
+    # dans le JDC
+        ouChercher=etape
+        for mot in listeAvant :
+              ouChercher=ouChercher.get_child(mot,restreint="oui")
+        monMC=etape.get_child(ouChercher,restreint="oui")
+        if monMC== None : monMC= ouChercher.addentite(MCFils)
         monMC.valeur=valeurs
         monMC.val=valeurs
         monMC.state='changed'
         monMC.valeur=valeurs
         monMC.val=valeurs
         monMC.state='changed'
-        #print monMC.isvalid()
+        monMC.isvalid()
+
+    #----------------------------------------------#
+    def ajoutMCFact(self,etape,MCFils,listeAvant=()):
+    #----------------------------------------------#
+    # dans le JDC
+        print ('ajoutMCFact')
+        ouChercher=etape
+        print (ouChercher)
+        for mot in listeAvant :
+              ouChercher=ouChercher.get_child(mot,restreint="oui")
+              print (mot)
+              print (ouChercher)
+        monMC=etape.get_child(ouChercher,restreint="oui")
+        if monMC== None : monMC= ouChercher.addentite(MCFils)
+        monMC.isvalid()
 
     #-------------------------------------#
 
     #-------------------------------------#
-    def changeIntoMC(self,etape,MCFils,valeurs):
+    def getValeur(self,nomEtape,MCFils,listeAvant=()):
     #-------------------------------------#
     #-------------------------------------#
-        print "je passe dans changeIntoMC" 
-        monMC=etape.get_child(MCFils,restreint="oui")
-        if monMC== None : monMC= etape.addentite(MCFils)
+    # dans le JDC
+
+        ouChercher=None
+        for e in self.jdc.etapes:
+            if e.nom == nomEtape : ouChercher=e; break
+        if ouChercher==None : return None
+        for mot in listeAvant :
+              ouChercher=ouChercher.get_child(mot,restreint="oui")
+              #print (mot, ouChercher)
+              if ouChercher==None : return None
+        monMC=ouChercher.get_child(MCFils,restreint="oui")
+        if monMC== None : return None
+        return monMC.valeur
+
+    #-----------------------------------------------------------#
+    def setValeur(self,nomEtape,MCFils,valeur,listeAvant=()):
+    #--------------------------------------------------------#
+    # dans le JDC
+
+        ouChercher=None
+        for e in self.jdc.etapes:
+            if e.nom == nomEtape : ouChercher=e; break
+        if ouChercher==None : return None
+        for mot in listeAvant :
+              ouChercher=ouChercher.get_child(mot,restreint="oui")
+              #print (mot, ouChercher)
+              if ouChercher==None : return None
+        monMC=ouChercher.get_child(MCFils,restreint="oui")
+        monMC.set_valeur(valeur)
+        monMC.isvalid()
+
+    #-----------------------------------------------------------#
+    def changeIntoMC(self,etape,MCFils,valeurs, listeAvant=()):
+    #-----------------------------------------------------------#
+    # dans le JDC
+        ouChercher=etape
+        if isinstance (etape, str):
+           ouChercher=None
+           for e in self.jdc.etapes:
+              if e.nom == etape : ouChercher=e; break
+        if ouChercher==None : return
+        for mot in listeAvant :
+              ouChercher=ouChercher.get_child(mot,restreint="oui")
+              if ouChercher==None : return 
+        monMC=ouChercher.get_child(MCFils,restreint="oui")
+        if monMC== None : monMC= ouChercher.addentite(MCFils)
+
         monMC.definition.into=valeurs
         monMC.definition.into=valeurs
+        from Noyau.N_VALIDATOR import  IntoProtocol
+        monMC.definition.intoProto = IntoProtocol("into", into=monMC.definition.into, val_min=monMC.definition.val_min, val_max=monMC.definition.val_max)
+        monMC.state='changed'
+        monMC.isvalid()
+
+    #-------------------------------------------------------------------#
+    def reCalculeValiditeMCApresChgtInto(self,nomEtape,MCFils,listeAvant=()):
+    #-------------------------------------------------------------------#
+    # dans le JDC
+        for e in self.jdc.etapes:
+            if e.nom == nomEtape : ouChercher=e; break
+        
+        for mot in listeAvant :
+            try :
+              ouChercher=ouChercher.get_child(mot,restreint="oui")
+            # Le mot clef n est pas la
+            except : return 0
+        try :
+           monMC=ouChercher.get_child(MCFils,restreint="oui")
+        # Le mot clef n est pas la
+        except : return 0
+        if monMC == None : return 0
+
+        if hasattr(monMC.definition,'into') :
+           if type(monMC.definition.into) ==types.FunctionType : maListeDeValeur=monMC.definition.into()
+           else : maListeDeValeur=monMC.definition.into
+        else :
+           return 0
+        
+        monMC.state='changed'
+        return 1
 
     #-------------------------------------#
 
     #-------------------------------------#
-    def changeIntoDefMC(self,etape,listeMC,valeurs):
+    def changeDefautDefMC(self,nomEtape,listeMC,valeurs):
     #-------------------------------------#
     #-------------------------------------#
-        definitionEtape=getattr(self.jdc.cata[0],etape)
+    # dans le MDD
+
+        #if isinstance (etape, str):
+        #  for e in self.jdc.etapes:
+        #    if e.nom == etape : etape=e; break
+        #if etape == None : return
+        definitionEtape=getattr(self.jdc.cata[0],nomEtape)
         ouChercher=definitionEtape
         if len(listeMC) > 1 :
         ouChercher=definitionEtape
         if len(listeMC) > 1 :
+
            for mc in listeMC[0:-1]:
              mcfact=ouChercher.entites[mc]
              ouChercher=mcfact
            
         mcAccas=ouChercher.entites[listeMC[-1]]
            for mc in listeMC[0:-1]:
              mcfact=ouChercher.entites[mc]
              ouChercher=mcfact
            
         mcAccas=ouChercher.entites[listeMC[-1]]
-        mcAccas.into=valeurs
+        mcAccas.defaut=valeurs
+        return 1
+
+    #------------------------------------------------#
+    def changeIntoDefMC(self,nomEtape,listeMC,valeurs):
+    #------------------------------------------------#
+    # dans le MDD
+        definitionEtape=getattr(self.jdc.cata[0],nomEtape)
+        ouChercher=definitionEtape
 
 
-    #-----------------------------------------#
-    def ajoutDefinitionMC(self,etape,nomDuMC,typ,**args):
-    #-----------------------------------------#
+        if len(listeMC) > 1 :
+           for mc in listeMC[0:-1]:
+             mcfact=ouChercher.entites[mc]
+             ouChercher=mcfact
+        mcAccas=ouChercher.entites[listeMC[-1]]
+
+        if hasattr(mcAccas,'into') : oldValeurs=mcAccas.into
+        else : oldValeurs=None
+        if oldValeurs==valeurs : return 0
+
+        mcAccas.into=valeurs
+        from Noyau.N_VALIDATOR import  IntoProtocol
+        mcAccas.intoProto = IntoProtocol("into", into=valeurs, val_min=mcAccas.val_min, val_max=mcAccas.val_max)
+        return 1
+
+    #-------------------------------------------------------------#
+    def deleteDefinitionMC(self,etape,listeAvant,nomDuMC):
+    #-------------------------------------------------------------#
+    # dans le MDD
+        #print 'in deleteDefinitionMC', etape,listeAvant,nomDuMC
+        if isinstance (etape, str):
+          for e in self.jdc.etapes:
+            if e.nom == etape : etape=e; break
+        if etape == None : return
         definitionEtape=getattr(self.jdc.cata[0],etape)
         definitionEtape=getattr(self.jdc.cata[0],etape)
+        ouChercher=definitionEtape
+        for k in listeAvant : 
+            ouChercher=ouChercher.entites[k]
+        MCADetruire=ouChercher.entites[nomDuMC]
+        ouChercher.ordre_mc.remove(nomDuMC)
+        del ouChercher.entites[nomDuMC]
+        del self.dicoNouveauxMC[nomDuMC]
+
+
+    #-------------------------------------------------------------#
+    def ajoutDefinitionMC(self,nomEtape,listeAvant,nomDuMC,typ,**args):
+    #-------------------------------------------------------------#
+    # dans le MDD
+        definitionEtape=getattr(self.jdc.cata[0],nomEtape)
+        ouChercher=definitionEtape
+        for k in listeAvant : 
+            ouChercher=ouChercher.entites[k]
         from Accas import A_SIMP
         Nouveau=A_SIMP.SIMP(typ,**args)
         from Accas import A_SIMP
         Nouveau=A_SIMP.SIMP(typ,**args)
-        Nouveau.pere=definitionEtape
+        Nouveau.pere=ouChercher
         Nouveau.nom=nomDuMC
         Nouveau.nom=nomDuMC
-        Nouveau.ordre_mc=[]
-        definitionEtape.entites[nomDuMC]=Nouveau
-        definitionEtape.ordre_mc.append(nomDuMC)
+        #Nouveau.ordre_mc=[]
+        ouChercher.entites[nomDuMC]=Nouveau
+        ouChercher.ordre_mc.append(nomDuMC)
+        self.dicoNouveauxMC[nomDuMC]=('ajoutDefinitionMC',nomEtape,listeAvant,nomDuMC,typ,args)
+        #print self.dicoNouveauxMC
+
+    #---------------------------------------------------------------------#
+    def ajoutDefinitionMCFact(self,nomEtape,listeAvant,nomDuMC,listeMC,**args):
+    #---------------------------------------------------------------------#
+    # dans le MDD
+        print ('ajoutDefinitionMCFact', nomDuMC)
+        definitionEtape=getattr(self.jdc.cata[0],nomEtape)
+        ouChercher=definitionEtape
+        for k in listeAvant : 
+            ouChercher=ouChercher.entites[k]
+        from Accas import A_SIMP
+        for mc in listeMC :
+            nomMC=mc[0]
+            typMC=mc[1]
+            argsMC=mc[2]
+            nouveauMC=A_SIMP.SIMP(typMC,**argsMC)
+            nouveauMC.nom=nomMC
+            args[nomMC]=nouveauMC
+        from Accas import A_FACT
+        nouveauFact=A_FACT.FACT(**args)
+        nouveauFact.pere=ouChercher
+        nouveauFact.nom=nomDuMC
+        from Editeur.autre_analyse_cata import traite_entite
+        traite_entite(nouveauFact,[])
+        ouChercher.entites[nomDuMC]=nouveauFact
+        ouChercher.ordre_mc.append(nomDuMC)
+        self.dicoNouveauxFact[nomDuMC]=('ajoutDefinitionMC',nomEtape,listeAvant,nomDuMC,listeMC,args)
+        #print self.dicoNouveauxMC
 
     #----------------------------------------------------#
 
     #----------------------------------------------------#
-    def changeIntoMCandSet(self,etape,MCFils,into,valeurs):
+
+    #----------------------------------------------------#
+    def changeIntoMCandSet(self,etape,listeMC,into,valeurs):
     #----------------------------------------------------#
     #----------------------------------------------------#
-        monMC=etape.get_child(MCFils,restreint="oui")
+    # dans le MDD et le JDC
+
+        self.changeIntoDefMC(etape,listeMC,into)
+
+        if isinstance (etape, str):
+          for e in self.jdc.etapes:
+            if e.nom == etape : etape=e; break
+        if etape == None : return
+
+        ouChercher = etape
+        for mot in listeMC[:-1] :
+            ouChercher=ouChercher.get_child(mot,restreint="oui")
+            if ouChercher==None : return 
+        MCFils=listeMC[-1]
+        monMC=ouChercher.get_child(MCFils,restreint="oui")
         if monMC== None : monMC= etape.addentite(MCFils)
         if monMC== None : monMC= etape.addentite(MCFils)
+
         monMC.definition.into=into
         monMC.valeur=valeurs
         monMC.val=valeurs
         monMC.definition.into=into
         monMC.valeur=valeurs
         monMC.val=valeurs
@@ -1429,11 +1723,19 @@ class JDCEditor(Ui_baseWidget,QWidget):
         return ligne
 
 
         return ligne
 
 
+    #---------------------------#
+    def _new_CF(self):
+    #---------------------------#
+        texte="CONDUITE_FORCEE();"
+        return texte
+
+
     #---------------------------#
     def _newTELEMAC(self):
     #---------------------------#
         #texte="INITIALIZATION();BOUNDARY_CONDITIONS();GENERAL_PARAMETERS();PHYSICAL_PARAMETERS();NUMERICAL_PARAMETERS();"
     #---------------------------#
     def _newTELEMAC(self):
     #---------------------------#
         #texte="INITIALIZATION();BOUNDARY_CONDITIONS();GENERAL_PARAMETERS();PHYSICAL_PARAMETERS();NUMERICAL_PARAMETERS();"
-        texte=""
+        texte="COMPUTATION_ENVIRONMENT();HYDRO();GENERAL_PARAMETERS();NUMERICAL_PARAMETERS()"
+        #texte="TRACERS();"
         return texte
 
     #---------------------------#
         return texte
 
     #---------------------------#
@@ -1446,8 +1748,8 @@ class JDCEditor(Ui_baseWidget,QWidget):
     #---------------------------#
     def _newPSEN_N1(self):
     #---------------------------#
     #---------------------------#
     def _newPSEN_N1(self):
     #---------------------------#
-        #texte="CASE_SELECTION() ; CONTINGENCY_OPTIONS() ; OUTPUT_OPTIONS() ; "
-        texte=""
+        texte="CASE_SELECTION();N_PROCESSING_OPTIONS();CONTINGENCY_OPTIONS();CONTINGENCY_SELECTION();\nCONTINGENCY_PROCESSING(); "
+        texte="CONTINGENCY_SELECTION();\nCONTINGENCY_PROCESSING(); "
         return texte
 
     #---------------------------#
         return texte
 
     #---------------------------#
@@ -1470,11 +1772,11 @@ class JDCEditor(Ui_baseWidget,QWidget):
       QSfichier = QFileDialog.getOpenFileName(self.appliEficas,
                         caption='Fichier Med',
                         filter=extensions)
       QSfichier = QFileDialog.getOpenFileName(self.appliEficas,
                         caption='Fichier Med',
                         filter=extensions)
-      if monEnvQT5 : QSfichier=QSfichier[0]
+      QSfichier=QSfichier[0]
       self.fichierMED=QSfichier
       from acquiertGroupes import getGroupes
       erreur,self.listeGroupes,self.nomMaillage,self.dicoCoord=getGroupes(self.fichierMED)
       self.fichierMED=QSfichier
       from acquiertGroupes import getGroupes
       erreur,self.listeGroupes,self.nomMaillage,self.dicoCoord=getGroupes(self.fichierMED)
-      if erreur != "" : print "a traiter"
+      if erreur != "" : print ("a traiter")
       texteComm="COMMENTAIRE(u'Cree - fichier : "+self.fichierMED +" - Nom Maillage : "+self.nomMaillage+"');\nPARAMETRES()\n"
       texteSources=""
       texteCond=""
       texteComm="COMMENTAIRE(u'Cree - fichier : "+self.fichierMED +" - Nom Maillage : "+self.nomMaillage+"');\nPARAMETRES()\n"
       texteSources=""
       texteCond=""
@@ -1503,7 +1805,7 @@ class JDCEditor(Ui_baseWidget,QWidget):
       self.fichierMED=str(QSfichier)
       from acquiertGroupes import getGroupes
       erreur,self.listeGroupes,self.nomMaillage=getGroupes(self.fichierMED)
       self.fichierMED=str(QSfichier)
       from acquiertGroupes import getGroupes
       erreur,self.listeGroupes,self.nomMaillage=getGroupes(self.fichierMED)
-      if erreur != "" : print "a traiter"
+      if erreur != "" : print ("a traiter")
 
     #-----------------------------
     def BoutonSalomePressed(self):
 
     #-----------------------------
     def BoutonSalomePressed(self):
@@ -1513,61 +1815,85 @@ class JDCEditor(Ui_baseWidget,QWidget):
       self.nomMaillage="A_partir_de_SMESH"
       self.openfile.close()
 
       self.nomMaillage="A_partir_de_SMESH"
       self.openfile.close()
 
-    #-------------------------------------
-    def saveSplitterSizes(self,event=None):
-    #------------------------------------
-      if self.inhibeSplitter : return
-      if not hasattr(self,'splitter') : return
-      if self.splitterSizes[2] != 0 : self.oldSizeWidgetOptionnel = self.splitterSizes[2]
-      #print  self.splitterSizes
-      #print self.splitter.sizes()
-      # PNPNPNPN parfoir self.splitter.sizes() a une longueur de 4...
-      nbAGarder=len(self.splitter.sizes())
-      if nbAGarder > 3 : nbAGarder=3
-      for i in range(nbAGarder):
-         self.splitterSizes[i] = self.splitter.sizes()[i]
-         self.splitter.widget(i).resizeEvent=self.saveSplitterSizes
-      #print self.splitter.sizes()
+
+    #-----------------------------------------
+    def initSplitterSizes(self, nbWidget=3):
+    #-----------------------------------------
+       #print ("je passe ds initSplitterSizes", nbWidget)
+
+       if   self.code in [ 'Adao', 'ADAO', ] : self.splitterSizes3=[1,1550,150]
+       elif self.code in [ 'MAP']            : self.splitterSizes3=[700,300]
+       else                                  : self.splitterSizes3=[150,1000,300]
+
+       if   self.code in [ 'Adao', 'ADAO', ] : self.splitterSizes2=[5,1500]
+       else                                  : self.splitterSizes2=[300,1000]
+
 
 
     #-----------------------------------------
 
 
     #-----------------------------------------
-    def restoreSplitterSizes(self,nbWigdet=3):
+    def restoreSplitterSizes(self,nbWidget=3):
     #----------------------------------------
     #----------------------------------------
-      self.inhibeSplitter = 1
-      self.i+=1
+      
+      #traceback.print_stack()
+      #print ("je passe ds restoreSplitterSizes")
       if not(hasattr(self,'splitter')) : return
       if not(hasattr(self,'splitter')) : return
-      newSizes=self.splitterSizes[:nbWigdet]
+      if nbWidget==2  : newSizes=self.splitterSizes2
+      if nbWidget==3  : newSizes=self.splitterSizes3
+      #self.inhibeSplitter = 1
       self.splitter.setSizes(newSizes)
       self.splitter.setSizes(newSizes)
-      self.inhibeSplitter = 0
+      #self.inhibeSplitter = 0
+      QApplication.processEvents()
+      # seule la fentetre du milieu est necessaire
+      self.splitter.widget(1).resizeEvent=self.saveSplitterSizes
    
    
+    #-----------------------------------------
+    def saveSplitterSizes(self,event):
+    #-----------------------------------------
+      #print ("je passe ds saveSplitterSizes")
+      if self.inhibeSplitter : return
+      if self.widgetOptionnel == None  : self.splitterSizes2 = self.splitter.sizes()[0:2]
+      else                             : self.splitterSizes3 = self.splitter.sizes()[0:3]
+
     #------------------------
     def fermeOptionnel(self):
     #------------------------
       if self.widgetOptionnel == None : return
 
       self.inhibeSplitter=1
     #------------------------
     def fermeOptionnel(self):
     #------------------------
       if self.widgetOptionnel == None : return
 
       self.inhibeSplitter=1
-      self.splitterSizes[1] = self.splitterSizes[1] + self.splitterSizes[2]
-      if self.splitterSizes[2]!=0 : self.oldSizeWidgetOptionnel = self.splitterSizes[2]
-      self.splitterSizes[2]=0
-
       self.widgetOptionnel.setParent(None)
       self.widgetOptionnel.close()
       self.widgetOptionnel.deleteLater()
       self.widgetOptionnel=None
       self.inhibeSplitter=0
       self.restoreSplitterSizes(2)
       self.widgetOptionnel.setParent(None)
       self.widgetOptionnel.close()
       self.widgetOptionnel.deleteLater()
       self.widgetOptionnel=None
       self.inhibeSplitter=0
       self.restoreSplitterSizes(2)
-      
+
     #------------------------
     def ajoutOptionnel(self):
     #------------------------
     #------------------------
     def ajoutOptionnel(self):
     #------------------------
-      #print "ajoutOptionnel"
-      #print self.splitterSizes
-      self.splitterSizes[2] = self.oldSizeWidgetOptionnel
-      self.splitterSizes[1] = self.splitterSizes[1] - self.splitterSizes[2]
-      self.inhibeSplitter=0
+      #if len(self.splitterSizes) == 2 : self.splitterSizes.append(self.oldSizeWidgetOptionnel)
+      #else : self.splitterSizes[2] = self.oldSizeWidgetOptionnel # ceinture pour les close bizarres
+      #self.splitterSizes[1] = self.splitterSizes[1] - self.splitterSizes[2]
+      
       self.restoreSplitterSizes(3)
 
 
       self.restoreSplitterSizes(3)
 
 
+    #------------------------
+    def fermeArbre(self):
+    #------------------------
+       #print (self.widgetTree)
+       self.oldWidgetTree=self.widgetTree
+       self.widgetTree.hide()
+       #self.widgetTree=None
+
+    #------------------------
+    def ouvreArbre(self):
+    #------------------------
+       #print ('je passe la')
+       #print (self.widgetTree)
+       #self.widgetTree=self.oldWidgetTree
+       self.widgetTree.show()
+       #self.restoreSplitterSizes(3)
+
     #-----------------------------
     def getTreeIndex(self,noeud):
     #----------------------------
     #-----------------------------
     def getTreeIndex(self,noeud):
     #----------------------------