InterfaceQT4/editorJuillet.py

   1 # -*- coding: utf-8 -*-
   2 # Copyright (C) 2007-2017   EDF R&D
   3 #
   4 # This library is free software; you can redistribute it and/or
   5 # modify it under the terms of the GNU Lesser General Public
   6 # License as published by the Free Software Foundation; either
   7 # version 2.1 of the License.
   8 #
   9 # This library is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 # Lesser General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU Lesser General Public
  15 # License along with this library; if not, write to the Free Software
  16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17 #
  18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  19 #
  20 from __future__ import absolute_import
  21 from __future__ import print_function
  22 try :
  23    from builtins import str
  24    from builtins import range
  25 except : pass
  26
  27 import types,sys,os, re
  28 import  subprocess
  29 import traceback
  30 import six
  31
  32 from monCodeMeteoAppelRun import Profil_Neutre
  33
  34
  35 from PyQt5.QtWidgets import QWidget, QMessageBox, QFileDialog, QApplication, QSplitter, QLabel
  36 from PyQt5.QtGui     import QPalette
  37 from PyQt5.QtCore    import QProcess, QFileInfo, QTimer, Qt, QDir, QSize
  38
  39 import traceback
  40
  41 # Modules Eficas
  42 from Extensions.i18n import tr
  43
  44 from Editeur        import session
  45 from Editeur        import comploader
  46 from Editeur        import Objecttreeitem
  47 from InterfaceQT4   import browser
  48
  49 from desBaseWidget    import Ui_baseWidget
  50 from InterfaceQT4.monViewTexte   import ViewText
  51 from monWidgetCreeParam import MonWidgetCreeParam
  52
  53 DictExtensions= {"MAP" : ".map", "TELEMAC" : '.cas'}
  54 debug = False
  55
  56
  57 from InterfaceQT4.editorSsIhm    import JDCEditorSsIhm
  58
  59
  60 class JDCEditor(JDCEditorSsIhm,Ui_baseWidget,QWidget):
  61 # ----------------------------------------- #
  62     """
  63        Editeur de jdc
  64     """
  65
  66 # ----------------------------------------
  67 # Methodes faisant appel a ssIhm
  68 # ----------------------------------------
  69
  70     def __init__ (self,appli,fichier = None, jdc=None, QWParent=None, units = None, include=0):
  71     #------------------------------------------------------------------------------------------
  72
  73
  74         QWidget.__init__(self,None)
  75         self.setupUi(self)
  76
  77         self.inhibeSplitter=0
  78         self.widgetOptionnel=None
  79         self.fenetreCentraleAffichee=None
  80         self.dejaDansPlieTout=False
  81         self.listeDesListesOuvertes=set()
  82         self.afficheListesPliees=True
  83         if appli!=None and hasattr(appli,"statusBar"): self.sb = appli.statusBar()
  84         else : self.sb = None
  85         self.QWParent=QWParent
  86
  87         JDCEditorSsIhm. __init__ (self,appli,fichier, jdc,units,include)
  88
  89         # Particularites IHM : met la fenetre a jour
  90
  91         self.initSplitterSizes()
  92         if self.code == "ASTER" or self.code == "monCode" : self.afficheListesPliees =True
  93         if self.code == 'PSEN_N1' : self.afficheListesPliees = False
  94
  95         #self.affiche=self.appliEficas.maConfiguration.affiche
  96
  97         if self.code in ['MAP','CARMELCND','PSEN'] : self.maConfiguration.afficheCommandesPliees=False
  98         if self.code in ['MAP',]: self.fermeArbre()
  99         #   self.widgetTree.close()
 100         #   self.widgetTree=None
 101
 102         if self.maConfiguration.closeArbre: self.fermeArbre()
 103         if self.maConfiguration.boutonDsMenuBar : self.appliEficas.remplitIconesCommandes()
 104
 105         self.version_code = session.d_env.cata
 106
 107         self.format =  self.appliEficas.format_fichier
 108
 109         self.node_selected = []
 110         self.deplier = True
 111         self.message=''
 112         self.afficheApresInsert=False
 113         if self.maConfiguration.closeArbre    : self.afficheApresInsert=True
 114         if self.code in ['Adao','ADAO','MAP'] : self.afficheApresInsert=True
 115         if self.code in ['TELEMAC',]          : self.enteteQTree='premier'
 116         else                                  : self.enteteQTree='complet'
 117         if self.code in ['Adao','ADAO','TELEMAC'] : self.affichePlie=True
 118         else                                      : self.affichePlie=False
 119
 120         self.Commandes_Ordre_Catalogue =self.readercata.Commandes_Ordre_Catalogue
 121
 122         if self.appliEficas.readercata.demandeCatalogue==True  :
 123            nomFichierTranslation='translatorFichier'+'_'+str(self.appliEficas.readercata.versionCode)
 124            if hasattr(self.appliEficas.maConfiguration,nomFichierTranslation) :
 125               translatorFichier=getattr(self.appliEficas.maConfiguration,nomFichierTranslation)
 126               from Extensions import localisation
 127               localisation.localise(None,self.appliEficas.langue,translatorFichier=translatorFichier)
 128
 129
 130         if self.jdc_item and self.appliEficas.ssIhm==False :
 131             self.tree = browser.JDCTree( self.jdc_item,  self )
 132         self.appliEficas.construitMenu()
 133
 134         self.adjustSize()
 135
 136
 137     #-------------------------------#
 138     def readFile(self, fn):
 139     #--------------------------------#
 140         """
 141         Public slot to read the text from a file.
 142         @param fn filename to read from (string or QString)
 143         """
 144
 145         jdc=JDCEditorSsIhm.readFile(self, fn)
 146
 147         # Particularites IHM : met le titre de la fenetre a jour
 148 #        qApp.restoreOverrideCursor()
 149         if self.fileInfo!= None : self.lastModified = self.fileInfo.lastModified()
 150         nouveauTitre=self.titre+"              "+os.path.basename(self.fichier)
 151         self.appliEficas.setWindowTitle(nouveauTitre)
 152
 153         return jdc
 154
 155 # ---------------------------------------------
 156 # Methodes Inchangees
 157 # ---------------------------------------------
 158 #   _newJDC
 159 #   _newJDCInclude
 160 #   __generateTempFilename
 161 #   getSource
 162 #   generDico
 163 #   viewJdcSource
 164 #   viewJdcPy
 165 #   viewJdcRapport
 166 #   getFileName
 167 #   initModif
 168 #   writeFile
 169 #   getTextJDC
 170 #   verifieChecksum
 171 #   getChecksum
 172 #   getDico
 173 #   chercheGroupes
 174 #   chercheDico
 175 #   saveFileLegerAs
 176
 177 # ---------------------------------------------
 178 # Methodes Surchargees
 179 # ---------------------------------------------
 180
 181     #-----------------------------------------------------------------------#
 182     def _viewText(self, txt, caption = "FILE_VIEWER",largeur=1200,hauteur=600):
 183     #--------------------------------------------------------------------#
 184         w = ViewText( self.QWParent,self ,caption,txt,largeur,hauteur)
 185         w.show()
 186
 187     #--------------------------------#
 188     def informe(self,titre,txt,critique=True):
 189     #--------------------------------#
 190        if  critique :
 191            self.afficheInfos(tr(txt),Qt.red)
 192            QMessageBox.critical( self, tr(titre), tr(txt))
 193        else :
 194            QMessageBox.warning( self, tr(titre),tr(txt))
 195
 196     #--------------------------------#
 197     def ajoutCommentaire(self):
 198     #--------------------------------#
 199         if self.tree.selectedItems()==[] :
 200           QMessageBox.warning( self, tr("Pas de noeud selectionne"),tr("Selectionnez un Noeud \nLe commentaire sera place apres le noeud selectionne"))
 201           return
 202         noeudAvantCommentaire=self.tree.selectedItems()[0]
 203         if noeudAvantCommentaire ==self.tree.racine :
 204             self.tree.racine.appendChild("COMMENTAIRE",pos=0)
 205             return
 206         noeudAvantCommentaire.addComment(True)
 207
 208
 209     #----------------------------------------------#
 210     def _viewTextExecute(self, txt, prefix, suffix):
 211     #----------------------------------------------#
 212         self.w = ViewText( self.QWParent )
 213         self.w.setWindowTitle( "execution" )
 214         self.monExe=QProcess(self.w)
 215         pid=self.monExe.pid()
 216         nomFichier = self.__generateTempFilename(prefix, suffix = ".sh")
 217         f=open(nomFichier,'w')
 218         f.write(txt)
 219         f.close()
 220         self.monExe.readyReadStandardOutput.connect( self.readFromStdOut)
 221         self.monExe.readyReadStandardError.connect( self.readFromStdErr)
 222         exe='sh ' + nomFichier
 223         self.monExe.start(exe)
 224         self.monExe.closeWriteChannel()
 225         self.w.exec_()
 226         try:
 227           commande="rm  "+ nomFichier
 228           os.system(commande)
 229         except :
 230           pass
 231
 232     def readFromStdErr(self):
 233         a=self.monExe.readAllStandardError()
 234         self.w.view.append(str(a.data()))
 235
 236     def readFromStdOut(self) :
 237         a=self.monExe.readAllStandardOutput()
 238         self.w.view.append(str(a.data()))
 239
 240
 241     #-----------------------#
 242     def gestionParam(self):
 243     #-----------------------#
 244         w = MonWidgetCreeParam( self)
 245         w.show()
 246
 247
 248     #----------------#
 249     def closeIt(self):
 250     #----------------#
 251         """
 252         Public method called by the viewmanager to finally get rid of us.
 253         """
 254         if self.jdc: self.jdc.supprime()
 255         self.close()
 256
 257     #----------------------------------------------#
 258     def afficheInfos(self,message,couleur=Qt.black):
 259     #----------------------------------------------#
 260         if couleur=='red' : couleur = Qt.red
 261         if self.sb:
 262            mapalette=self.sb.palette()
 263            mapalette.setColor( QPalette.WindowText, couleur )
 264            self.sb.setPalette( mapalette );
 265            self.sb.showMessage(message,4000)
 266            self.couleur=couleur
 267
 268     #------------------------------#
 269     def afficheAlerte(self,titre,message):
 270     #------------------------------#
 271     # appele par I_MACRO_ETAPE
 272         QMessageBox.information( self, titre, message)
 273
 274     #-----------------------------------#
 275     def afficheCommentaire(self,message):
 276     #-----------------------------------#
 277         self.labelCommentaire.setText(message)
 278         QTimer.singleShot(6000, self.rendInvisible)
 279
 280     #----------------------#
 281     def rendInvisible(self):
 282     #----------------------#
 283         self.labelCommentaire.setText("")
 284
 285     #---------------------------------------#
 286     def chercheNoeudSelectionne(self,copie=1):
 287     #---------------------------------------#
 288       """
 289         appele par Cut et Copy pour positionner self.node_selected
 290       """
 291       self.node_selected=[]
 292       if len(self.tree.selectedItems()) == 0 : return
 293       self.node_selected=self.tree.selectedItems()
 294
 295
 296     #---------------------#
 297     def handleSupprimer(self):
 298     #---------------------#
 299       self.chercheNoeudSelectionne()
 300       if len(self.node_selected) == 0 : return
 301       self.QWParent.noeud_a_editer = []
 302       if self.node_selected[0]==self.tree.racine: return
 303       if len(self.node_selected) == 1 : self.node_selected[0].delete()
 304       else : self.node_selected[0].deleteMultiple(self.node_selected)
 305
 306     #---------------------#
 307     def handleRechercher(self):
 308     #---------------------#
 309       from .monRecherche import DRecherche
 310       monRechercheDialg=DRecherche(parent=self,fl=0)
 311       monRechercheDialg.show()
 312
 313
 314     #--------------------------------#
 315     def handleRechercherDsCatalogue(self):
 316     #-----------------------------#
 317       from .monRechercheCatalogue import DRechercheCatalogue
 318       monRechercheDialg=DRechercheCatalogue(self.QWParent,self)
 319       monRechercheDialg.show()
 320
 321     #---------------------#
 322     def handleDeplier(self):
 323     #---------------------#
 324        if self.tree == None : return
 325        #self.tree.collapseAll()
 326        if self.deplier :
 327           #print "je plie"
 328           self.tree.expandItem(self.tree.topLevelItem(0))
 329           self.deplier = False
 330           if self.fenetreCentraleAffichee != None  :
 331              if hasattr(self.fenetreCentraleAffichee.node,'plieToutEtReaffiche'):
 332                  self.fenetreCentraleAffichee.node.plieToutEtReaffiche()
 333        else:
 334           #print "je deplie"
 335           self.tree.expandItem(self.tree.topLevelItem(0))
 336           self.deplier = True
 337           if self.fenetreCentraleAffichee != None  :
 338              if hasattr(self.fenetreCentraleAffichee.node,'deplieToutEtReaffiche'):
 339                  self.fenetreCentraleAffichee.node.deplieToutEtReaffiche()
 340
 341     #---------------------#
 342     def handleEditCut(self):
 343     #---------------------#
 344       """
 345       Stocke dans Eficas.noeud_a_editer le noeud a couper
 346       """
 347       #print "handleEditCut"
 348       self.chercheNoeudSelectionne()
 349       self.QWParent.edit="couper"
 350       self.QWParent.noeud_a_editer = self.node_selected
 351
 352     #-----------------------#
 353     def handleEditCopy(self):
 354     #-----------------------#
 355       """
 356       Stocke dans Eficas.noeud_a_editer le noeud a copier
 357       """
 358       self.chercheNoeudSelectionne()
 359       if len(self.node_selected) == 0 : return
 360       if len(self.node_selected) == 1 : self.node_selected[0].updateNodeLabelInBlue()
 361       else :  self.node_selected[0].updatePlusieursNodeLabelInBlue(self.node_selected)
 362       self.QWParent.edit="copier"
 363       self.QWParent.noeud_a_editer = self.node_selected
 364
 365     #------------------------#
 366     def handleEditPaste(self):
 367     #------------------------#
 368       """
 369       Lance la copie de l'objet place dans self.QWParent.noeud_a_editer
 370       Ne permet que la copie d'objets de type Commande ou MCF
 371       """
 372       self.chercheNoeudSelectionne()
 373       if (not(hasattr(self.QWParent,'noeud_a_editer'))) or len(self.QWParent.noeud_a_editer)==0:
 374           QMessageBox.information( self,
 375                       tr("Copie impossible"),
 376                       tr("Veuillez selectionner un objet a copier"))
 377           return
 378       if len(self.node_selected) != 1 :
 379           QMessageBox.information( self,
 380                       tr("Copie impossible"),
 381                       tr("Veuillez selectionner un seul objet : la copie se fera apres le noeud selectionne"))
 382           return
 383       noeudOuColler=self.node_selected[0]
 384
 385       if len(self.QWParent.noeud_a_editer)!=1:
 386          #self.handleEditPasteMultiple()
 387          QMessageBox.information( self, tr("Copie impossible"), tr("Aucun Objet n a ete copie ou coupe"))
 388          return
 389
 390       noeudACopier=self.QWParent.noeud_a_editer[0]
 391
 392       if (self.QWParent.edit != "couper"):
 393         #print   (noeudOuColler.item.parent.getChild(noeudOuColler.item.nom))
 394         try:
 395            if noeudOuColler == self.tree.racine :
 396                child=noeudOuColler.doPastePremier(noeudACopier)
 397            else :
 398                child=noeudACopier.doPaste(noeudOuColler,'after')
 399
 400            if child==None or child==0:
 401                QMessageBox.critical( self,tr( "Copie refusee"),tr('Eficas n a pas reussi a copier l objet'))
 402                self.message = ''
 403                self.afficheInfos("Copie refusee",Qt.red)
 404            if noeudACopier.treeParent.editor != noeudOuColler.treeParent.editor:
 405                try :
 406                  nom=noeudACopier.item.sd.nom
 407                  child.item.nommeSd(nom)
 408                except :
 409                  pass
 410            return
 411            self.initModif()
 412            child.select()
 413         except  :
 414            traceback.print_exc()
 415            QMessageBox.critical( self,tr( "Copie refusee"),tr('Copie refusee pour ce type d objet'))
 416            self.message = ''
 417            self.afficheInfos("Copie refusee",Qt.red)
 418            return
 419
 420       # il faut declarer le JDCDisplay_courant modifie
 421       # suppression eventuelle du noeud selectionne
 422       # si possible on renomme l objet comme le noeud couper
 423
 424       if (self.QWParent.edit == "couper"):
 425          print ('je pass la')
 426          if noeudACopier.treeParent.editor != noeudOuColler.treeParent.editor:
 427            QMessageBox.critical( self, tr("Deplacement refuse"),tr('Deplacement refuse entre 2 fichiers. Seule la copie est autorisee '))
 428
 429          #if 1:
 430          try :
 431            # indexNoeudACopier=noeudACopier.treeParent.children.index(noeudACopier)
 432             indexNoeudACopier=self.getTreeIndex(noeudACopier)
 433             noeudACopier.treeParent.item.deplaceEntite(indexNoeudACopier,indexNoeudOuColler,pos)
 434             noeudACopier.treeParent.buildChildren()
 435
 436          #else:
 437          except:
 438             pass
 439          self.QWParent.noeud_a_editer=[]
 440
 441       # on rend la copie a nouveau possible en liberant le flag edit
 442       self.QWParent.edit="copier"
 443       noeudACopier.select()
 444
 445     #----------------------------------#
 446     def handleDeplaceMultiple(self):
 447     #----------------------------------#
 448        pass
 449
 450     #----------------------------------#
 451     def handleEditPasteMultiple(self):
 452     #----------------------------------#
 453
 454     # On ne garde que les niveaux "Etape"
 455     # On insere dans l'ordre du JDC
 456      listeNoeudsACouper=[]
 457      listeIndex=[]
 458      listeChild=[]
 459      listeItem=[]
 460      from InterfaceQT4 import compojdc
 461      noeudOuColler=self.node_selected[0]
 462      if not (isinstance(noeudOuColler.treeParent, compojdc.Node)):
 463         QMessageBox.information( self,
 464                   tr("Copie impossible a cet endroit",),
 465                   tr("Veuillez selectionner une commande, un parametre, un commentaire ou une macro"))
 466         return
 467      indexNoeudOuColler=noeudOuColler.treeParent.children.index(noeudOuColler)
 468
 469      for noeud in self.QWParent.noeud_a_editer :
 470         if not (isinstance(noeud.treeParent, compojdc.Node)): continue
 471         indexInTree=noeud.treeParent.children.index(noeud)
 472         indice = 0
 473         for index in listeIndex:
 474             if index < indexInTree : indice = indice +1
 475         listeIndex.insert(indice, indexInTree)
 476         listeNoeudsACouper.insert(indice, noeud)
 477
 478      noeudJdc=noeudOuColler.treeParent
 479      dejaCrees=0
 480      # on les cree a l'envers parcequ'on ajoute a NoeudOuColler
 481      listeIndex.reverse()
 482      for index in listeIndex:
 483          indexTravail=index
 484          if indexNoeudOuColler < index:
 485             indexTravail=indexTravail+dejaCrees
 486          noeudOuColler=noeudJdc.children[indexNoeudOuColler]
 487          noeud=noeudJdc.children[indexTravail]
 488          child=noeud.doPaste(noeudOuColler)
 489          listeChild.append(child)
 490          dejaCrees=dejaCrees+1
 491
 492      self.QWParent.noeud_a_editer = []
 493      for i in range(len(listeIndex)):
 494         noeud=noeudJdc.children[indexNoeudOuColler+1+i]
 495         self.QWParent.noeud_a_editer.append(noeud)
 496
 497      listeASupprimer=[]
 498      if self.QWParent.edit !="couper" : return
 499
 500      for index in listeIndex:
 501          indexTravail=index
 502          if indexNoeudOuColler < index:
 503             indexTravail=indexTravail+(len(listeIndex))
 504          noeud=noeudJdc.children[indexTravail]
 505
 506          listeItem.append(noeud.item)
 507          listeASupprimer.append(noeud)
 508
 509      for i in range(len(listeChild)):
 510          self.tree.item.suppItem(listeItem[i])
 511          listeChild[i].item.update(listeItem[i])
 512
 513      self.QWParent.noeud_a_editer = []
 514
 515     #----------------------------------#
 516     def handleAjoutEtape(self,nomEtape):
 517     #----------------------------------#
 518       self.chercheNoeudSelectionne()
 519       if len(self.node_selected) == 0 or self.node_selected[0] == self.tree.racine :
 520          nodeOuAjouter=self.tree.racine
 521          nouveau=nodeOuAjouter.appendChild(nomEtape,pos='first')
 522       else :
 523          nodeOuAjouter=self.node_selected[0]
 524          if nodeOuAjouter != self.tree.racine :
 525             while  nodeOuAjouter.treeParent != self.tree.racine:
 526                    print (nodeOuAjouter)
 527                    nodeOuAjouter=nodeOuAjouter.treeParent
 528                    print (nodeOuAjouter.parent == self.tree.racine)
 529          nouveau=nodeOuAjouter.appendBrother(nomEtape)
 530       try :
 531         self.node_selected[0].setSelected(False)
 532       except : pass
 533       nouveau.setSelected(True)
 534       nouveau.affichePanneau()
 535
 536
 537     #---------------------------#
 538     def getFileVariable(self) :
 539     #---------------------------#
 540      titre = tr("Choix d'un fichier XML")
 541      texte = tr("Le fichier contient une commande MODEL\n")
 542      texte = texte+tr('Donnez le nom du fichier XML qui contient la description des variables')
 543      QMessageBox.information( self, titre,tr(texte))
 544
 545      fichier = QFileDialog.getOpenFileName(self.appliEficas,
 546                    tr('Ouvrir Fichier'),
 547                    self.appliEficas.maConfiguration.savedir,
 548                    tr('Wrapper Files (*.xml);;''All Files (*)'))
 549      return  fichier
 550
 551     #------------#
 552     def run(self):
 553     #------------#
 554       fonction="run"+self.code
 555       #print fonction
 556       if fonction in JDCEditor.__dict__: JDCEditor.__dict__[fonction](self,)
 557
 558     #------------#
 559     def saveRun(self):
 560     #------------#
 561       fonction="saveRun"+self.code
 562       if fonction in JDCEditor.__dict__: JDCEditor.__dict__[fonction](self,)
 563
 564
 565 # ---------------------------------------------
 566 # Methodes Non Crees dans ssIHM
 567 # ---------------------------------------------
 568
 569     #---------------#
 570     def runMAP(self):
 571     #---------------#
 572
 573       if not(self.jdc.isValid()):
 574          QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution MAP"))
 575          return
 576       if len(self.jdc.etapes) != 1 :
 577          QMessageBox.critical( self, tr("Execution impossible "),tr("le JDC doit contenir un et un seul composant"))
 578          return
 579       if self.modified or self.fichier==None  :
 580          self.fichierMapInput = self.__generateTempFilename(prefix = "map_run", suffix = ".map")
 581          texte=self.getTextJDC("MAP")
 582          self.writeFile( self.fichierMapInput, txt = texte)
 583       else :
 584          self.fichierMapInput=self.fichier
 585       composant=self.jdc.etapes[0].nom.lower()[0:-5]
 586
 587
 588       # :TRICKY: to determine if a component requires SALOME, loads the component from Eficas catalog
 589       # then instantiate corresponding class and call getUseSalome() method
 590       try:
 591           from mapengine.spec import factory
 592           mapComponent = factory.new(composant)[0]
 593
 594           command = "map"
 595           if mapComponent.getUseSalome():
 596               command += " -r sappli"
 597           textePython=(command + " run -n "+composant +" -i "+self.fichierMapInput)
 598
 599           #textePython="ls -l"
 600           self._viewTextExecute( textePython,"map_run",".sh")
 601           #try:
 602           #  commande="rm  "+self.fichierMapInput
 603           #   os.system(commande)
 604           #except :
 605           #   pass
 606       except Exception as e:
 607           print((traceback.print_exc()))
 608
 609     #-------------------#
 610     def runZCRACKS(self):
 611     #-------------------#
 612       if not(self.jdc.isValid()):
 613          QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution "))
 614          return
 615       if self.modified or self.fichier==None  :
 616       #if 1:
 617          self.fichierZcracksInput = self.__generateTempFilename(prefix = "zcracks_run", suffix = ".z7p")
 618          texte=self.getTextJDC("ZCRACKS",pourRun=1)
 619          self.writeFile( self.fichierZcracksInput, txt = texte)
 620       else :
 621          self.fichierZcracksInput=self.fichier
 622       try :
 623           #commande ="Zrun -zp "
 624           commande="more "
 625           textePython=(commande + self.fichierZcracksInput)
 626           self._viewTextExecute( textePython,"run_zcracks",".sh")
 627       except Exception as e:
 628           print((traceback.print_exc()))
 629
 630     #-------------------#
 631     def runCARMELCND(self):
 632     #-------------------#
 633       #if not(self.jdc.isValid()):
 634       #   QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution "))
 635       #   return
 636       if self.modified or self.fichier==None  :
 637          QMessageBox.critical( self, tr( "Execution impossible "),tr("Sauvegarder SVP avant l'execution "))
 638          return
 639       if not hasattr(self,'generator'): texte=self.getTextJDC(self.format)
 640       from PrepareRunCarmel import prepareRunCarmel
 641       fichierGenerique=os.path.basename(self.fichier).split(".")[0]
 642       repMed=os.path.dirname(self.fichier)
 643       repExeCarmel=self.generator.get_repExeCarmel()
 644       textePython=prepareRunCarmel(repExeCarmel,repMed,fichierGenerique)
 645       nomFichier = self.__generateTempFilename("carmel_run", suffix = ".sh")
 646       f=open(nomFichier,'w')
 647       f.write(textePython)
 648       f.close()
 649       commande="xterm -e sh "+nomFichier +"\n"
 650       os.system(commande)
 651
 652     #-------------------#
 653     def runCarmelCS(self):
 654     #-------------------#
 655       try :
 656           commande="runSession pilotyacsCS.py"
 657           os.system(commande)
 658       except Exception as e:
 659           print((traceback.print_exc()))
 660
 661     #-----------------------------------------------------#
 662     def determineNomFichier(self,path,extension):
 663     #-----------------------------------------------------#
 664       if self.appli.code in DictExtensions:
 665          chaine1=DictExtensions[self.appli.code]+" (*."+DictExtensions[self.appli.code]+");;"
 666          extensions= tr(chaine1+ "All Files (*)")
 667       else :
 668          extensions= tr("JDC (*.comm);;" "All Files (*)")
 669
 670       if self.appli.code == "MAP" :
 671          extensions = extensions + ";; Run (*.input);;"
 672
 673       fn = QFileDialog.getSaveFileName( self,
 674              tr("sauvegarde"), path,
 675              extensions,None,
 676              QFileDialog.DontConfirmOverwrite)
 677       if fn == None : return (0, None)
 678       fn=fn[0]
 679       if fn=='': return (0, None)
 680
 681       ext = QFileInfo(fn).suffix()
 682       if ext == '': fn+=extension
 683
 684       if QFileInfo(fn).exists():
 685            msgBox = QMessageBox(self)
 686            msgBox.setWindowTitle(tr("Sauvegarde du Fichier"))
 687            msgBox.setText(tr("Le fichier <b>%s</b> existe deja.", six.text_type(fn)))
 688            msgBox.addButton(tr("&Ecraser"),0)
 689            msgBox.addButton(tr("&Abandonner"),1)
 690            abort=msgBox.exec_()
 691            if abort == 1 :  return (0, "")
 692       return (1,fn)
 693
 694     #-----------------#
 695     def saveRunMAP(self):
 696     #-----------------#
 697         extension=".input"
 698         if not(self.jdc.isValid()):
 699            QMessageBox.critical( self, tr( "Sauvegarde de l'input impossible "),
 700                                 tr("Un JdC valide est necessaire pour creer un .input")
 701                                  )
 702            return
 703         try :
 704           composant=self.jdc.etapes[0].nom.lower()[0:-5]
 705         except :
 706            QMessageBox.critical( self, tr( "Sauvegarde de l'input impossible "),
 707                                 tr("Choix du composant obligatoire")
 708                                  )
 709            return
 710         if hasattr(self.maConfiguration, "savedir"): path=self.maConfiguration.savedir
 711         else : path='C:/'
 712
 713         monNomFichier=""
 714         if self.fichier is not None and self.fichier != "" :
 715              maBase=str(QFileInfo(self.fichier).baseName())+".input"
 716              monPath=str(QFileInfo(self.fichier).absolutePath())
 717              monNomFichier=os.path.join(monPath,maBase)
 718         elif hasattr(self,'monNomFichierInput'):
 719             monNomFichier=self.monNomFichierInput
 720
 721
 722         monDialog=QFileDialog(self.appliEficas)
 723         monDialog.setDirectory (path)
 724         monDialog.setWindowTitle ("Save")
 725
 726         for c in monDialog.children():
 727             if isinstance(c,QDialogButtonBox):
 728                for b in c.children():
 729                   if isinstance(b,QPushButton):
 730                      avant=b.text()
 731                      if avant=="&Open": b.setText("Save")
 732         mesFiltres= "input Map (*.input);;All Files (*)"
 733         monDialog.setNameFilters(mesFiltres)
 734         if monNomFichier!="" : monDialog.selectFile(monNomFichier)
 735         BOk=monDialog.exec_()
 736         if BOk==0: return
 737         fn=str(monDialog.selectedFiles()[0])
 738         if fn == "" or fn == None : return
 739         if not fn.endswith(".input"):
 740             fn += ".input"
 741         self.monNomFichierInput=fn
 742
 743         if not hasattr(self, 'fichierMapInput') or not self.fichierMapInput or not os.path.exists(self.fichierMapInput):
 744             self.fichierMapInput = self.__generateTempFilename(prefix = "map_run", suffix = ".map")
 745             texte=self.getTextJDC("MAP")
 746             self.writeFile( self.fichierMapInput, txt = texte)
 747
 748         cmd = ("map gen -t dat -n " + composant + " -i " + self.fichierMapInput + " -o " + fn)
 749         p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE)
 750         (output, err) = p.communicate()
 751
 752
 753     #-----------------#
 754     def saveRunPSEN(self):
 755     #-----------------#
 756         #print ("saveRunPSEN")
 757         self.saveFile()
 758
 759
 760
 761     #-----------------------------------------#
 762     def handleAjoutGroup(self,listeGroup):
 763     #-----------------------------------------#
 764         try :
 765         #if 1:
 766            from ajoutGroupe import handleAjoutGroupFiltre
 767            #print listeGroup
 768            handleAjoutGroupFiltre(self,listeGroup)
 769            #print "apres handleAjoutGroupFiltre"
 770         except :
 771         #else :
 772            pass
 773
 774
 775     #-----------------------------------------------------------------#
 776     def saveCompleteFile(self, path = None, saveas= 0,formatLigne="beautifie"):
 777     #-----------------------------------------------------------------#
 778         extension='.casR'
 779         fn = self.fichierComplet
 780         #saveas=True # Pour forcer le nom
 781         self.generator=self.maConfiguration.mesGenerators.plugins[self.format]()
 782         if self.fichierComplet is None or saveas:
 783           if path is None: path=self.maConfiguration.savedir
 784           bOK, fn=self.determineNomFichier(path,extension)
 785           if bOK == 0 : return (0, None)
 786           if fn == None : return (0, None)
 787           if fn== '' : return (0, None)
 788
 789           ulfile = os.path.abspath(six.text_type(fn))
 790           self.appliEficas.maConfiguration.savedir=os.path.split(ulfile)[0]
 791           fn = six.text_type(QDir.toNativeSeparators(fn))
 792
 793         self.fichierComplet = os.path.splitext(fn)[0]+extension
 794
 795         if hasattr(self.generator, "writeComplet"):
 796             self.generator.writeComplet(self.fichierComplet,self.jdc,config=self.appliEficas.maConfiguration,appli=self.appliEficas)
 797
 798         if self.salome : self.appliEficas.addJdcInSalome( self.fichierComplet)
 799
 800         self.modified = 0
 801         nouveauTitre=self.titre+"              "+str(os.path.basename(self.fichierComplet))
 802         self.appliEficas.setWindowTitle(nouveauTitre)
 803         return (1, self.fichierComplet)
 804
 805     #-----------------------------------------------------------------#
 806     def saveFile(self, path = None, saveas= 0,formatLigne="beautifie"):
 807     #-----------------------------------------------------------------#
 808         """
 809         Public slot to save the text to a file.
 810
 811         @param path directory to save the file in (string or QString)
 812         @return tuple of two values (boolean, string) giving a success indicator and
 813             the name of the saved file
 814         """
 815
 816         self.modified=1
 817         if not self.modified and not saveas:
 818             return (0, None)      # do nothing if text wasn't changed
 819
 820         if self.appli.code in DictExtensions :
 821            extension=DictExtensions[self.appli.code]
 822         else :
 823            extension='.comm'
 824
 825         newName = None
 826         fn = self.fichier
 827         if self.fichier is None or saveas:
 828           if path is None: path=self.maConfiguration.savedir
 829           bOK, fn=self.determineNomFichier(path,extension)
 830           if bOK == 0 : return (0, None)
 831           if fn == None : return (0, None)
 832           if fn== '' : return (0, None)
 833
 834           ulfile = os.path.abspath(six.text_type(fn))
 835           self.appliEficas.maConfiguration.savedir=os.path.split(ulfile)[0]
 836           fn = six.text_type(QDir.toNativeSeparators(fn))
 837           newName = fn
 838
 839
 840         if not (self.writeFile(fn,formatLigne=formatLigne)): return (0, None)
 841         self.fichier = fn
 842         self.modified  = False
 843         if self.fileInfo is None or saveas:
 844            self.fileInfo = QFileInfo(self.fichier)
 845            self.fileInfo.setCaching(0)
 846         self.lastModified = self.fileInfo.lastModified()
 847         if newName is not None:
 848            self.appliEficas.addToRecentList(newName)
 849            self.tree.racine.item.getObject().nom=os.path.basename(newName)
 850            self.tree.racine.updateNodeLabel()
 851
 852         self.jdc.toXml()
 853
 854         if self.jdc.isValid() != 0 and hasattr(self.generator, "writeDefault"):
 855         #if hasattr(self.generator, "writeDefault"):
 856             self.generator.writeDefault(fn)
 857         elif self.code=="TELEMAC" and hasattr(self.generator, "writeDefault"):
 858             msgBox = QMessageBox(None)
 859             msgBox.setWindowTitle(tr("Fichier .cas invalide / incomplet"))
 860             msgBox.setText(tr("Le fichier .cas est invalide / incomplet"))
 861             msgBox.addButton(tr("&Sauvegarder"),1)
 862             msgBox.addButton(tr("&Quitter sans sauvegarder"),0)
 863             msgBox.addButton(tr("&Annuler"),2)
 864             res=msgBox.exec_()
 865             if res == 0 :
 866                self.generator.writeDefault(fn)
 867                return (1, self.fichier)
 868             if res == 2 : return (0, None)
 869             if self.appliEficas.salome : self.appliEficas.close()
 870             else : sys.exit(1)
 871
 872         if self.salome :
 873                self.appliEficas.addJdcInSalome( self.fichier)
 874         self.modified = 0
 875         nouveauTitre=self.titre+"              "+str(os.path.basename(self.fichier))
 876         self.appliEficas.setWindowTitle(nouveauTitre)
 877
 878         return (1, self.fichier)
 879 #
 880
 881     #----------------------------------------------#
 882     def sauveLigneFile(self):
 883     #----------------------------------------------#
 884         self.modified=1
 885         return self.saveFile(formatLigne="Ligne")
 886
 887
 888     #----------------------------------------------#
 889     def saveFileAs(self, path = None,fileName=None):
 890     #----------------------------------------------#
 891         """
 892         Public slot to save a file with a new name.
 893
 894         @param path directory to save the file in (string or QString)
 895         @return tuple of two values (boolean, string) giving a success indicator and
 896             the name of the saved file
 897         """
 898         if fileName != None :
 899            self.fichier = fileName
 900            return self.saveFile()
 901         return self.saveFile(path,1,"beautifie")
 902
 903
 904
 905     #---------------------------------------------#
 906     def getFile(self,unite=None,fic_origine = ''):
 907     #---------------------------------------------#
 908     # appele par I_JDC
 909         ulfile  = None
 910         jdcText = ""
 911
 912         titre  = ""
 913
 914         if unite :
 915             titre = tr("Choix unite %d ", unite)
 916             texte = tr("Le fichier %s contient une commande INCLUDE \n",  str(fic_origine)) +"\n"
 917             texte = texte+ tr("Donnez le nom du fichier correspondant a l unite logique ") + repr(unite)
 918             labeltexte = tr('Fichier pour unite ') + repr( unite)
 919         else:
 920             titre = tr("Choix d'un fichier de poursuite")
 921             texte = tr("Le fichier %s contient une commande POURSUITE\n", fic_origine)
 922             texte = texte+tr('Donnez le nom du fichier dont vous \n voulez faire une poursuite')
 923
 924         QMessageBox.information( self, titre,texte)
 925         fn = QFileDialog.getOpenFileName(self.appliEficas,
 926                    titre,
 927                    self.appliEficas.maConfiguration.savedir)
 928
 929         # ce retour est impose par le getFile d'I_JDC
 930         if fn== '' : return None," "
 931         if not fn : return (0, " ")
 932         fn=fn[0]
 933
 934         ulfile = os.path.abspath(six.text_type(fn))
 935         self.appliEficas.maConfiguration.savedir=os.path.split(ulfile)[0]
 936
 937         # On utilise le convertisseur defini par format_fichier
 938         source=self.getSource(ulfile)
 939         if source:
 940             # On a reussia convertir le fichier self.ulfile
 941             jdcText = source
 942         else:
 943             # Une erreur a ete rencontree
 944             jdcText = ''
 945         return ulfile, jdcText
 946
 947     #-----------------------------------#
 948     def updateJdc(self, etape,texte):
 949     #------------------------------------#
 950     # ajoute une etape  de JdC a partir d un texte
 951         CONTEXT.setCurrentStep(etape)
 952         etape.buildIncludeEtape(texte)
 953         self.tree.racine.buildChildren()
 954
 955     #-----------------------------------#
 956     def updateJdcEtape(self, itemApres,texte):
 957     #------------------------------------#
 958     # ajoute une etape  de JdC a partir d un texte
 959         monItem=itemApres
 960         etape=monItem.item.object
 961
 962         CONTEXT.setCurrentStep(etape)
 963         try :
 964           ok=etape.buildIncludeEtape(texte)
 965         except :
 966           ok=0
 967         if not ok :
 968            QMessageBox.information( self,
 969                       tr("Import texte"),
 970                       tr("Impossible d importer le texte"))
 971         self.tree.racine.buildChildren()
 972         return ok
 973
 974     #-------------------------------------------#
 975     def updateJdcAfterEtape(self, etape,texte):
 976     #--------------------------------------------#
 977     # ajoute une etape  de JdC a partir d un texte
 978         CONTEXT.setCurrentStep(etape)
 979         try :
 980           ok=etape.buildIncludeEtape(texte,doitEtreValide=0)
 981         except :
 982           ok=0
 983         if not ok :
 984            QMessageBox.information( self,
 985                       tr("Import texte"),
 986                       tr("Impossible d importer le texte"))
 987         self.tree.racine.buildChildren()
 988         return ok
 989
 990
 991     #-------------------------------------#
 992     def deleteEtape(self,etape):
 993     #-------------------------------------#
 994     # dans le JDC
 995         self.jdc.suppEntite(etape)
 996
 997     #-------------------------------------#
 998     def deleteMC(self,etape,MCFils,listeAvant=()):
 999     #-------------------------------------#
1000     # dans le JDC
1001         ouChercher=etape
1002         for mot in listeAvant :
1003               ouChercher=ouChercher.getChild(mot,restreint="oui")
1004         monMC=ouChercher.getChild(MCFils,restreint="oui")
1005         if monMC != None :  ouChercher.suppEntite(monMC)
1006         ouChercher.state='changed'
1007         ouChercher.isValid()
1008
1009     #-------------------------------------#
1010     def ajoutMC(self,etape,MCFils,valeurs,listeAvant=()):
1011     #-------------------------------------#
1012     # dans le JDC
1013         ouChercher=etape
1014         for mot in listeAvant :
1015               ouChercher=ouChercher.getChild(mot,restreint="oui")
1016         monMC=etape.getChild(ouChercher,restreint="oui")
1017         if monMC== None : monMC= ouChercher.addEntite(MCFils)
1018         monMC.valeur=valeurs
1019         monMC.val=valeurs
1020         monMC.state='changed'
1021         monMC.isValid()
1022
1023     #----------------------------------------------#
1024     def ajoutMCFact(self,etape,MCFils,listeAvant=()):
1025     #----------------------------------------------#
1026     # dans le JDC
1027         print ('ajoutMCFact')
1028         ouChercher=etape
1029         print (ouChercher)
1030         for mot in listeAvant :
1031               ouChercher=ouChercher.getChild(mot,restreint="oui")
1032               print (mot)
1033               print (ouChercher)
1034         monMC=etape.getChild(ouChercher,restreint="oui")
1035         if monMC== None : monMC= ouChercher.addEntite(MCFils)
1036         monMC.isValid()
1037
1038
1039     #-----------------------------------------
1040     def initSplitterSizes(self, nbWidget=3):
1041     #-----------------------------------------
1042        #print ("je passe ds initSplitterSizes", nbWidget)
1043
1044        if   self.code in [ 'Adao', 'ADAO','MAP' ] : self.splitterSizes3=[1,1550,150]
1045        #elif self.code in [ 'MAP']            : self.splitterSizes3=[700,300]
1046        else                                  : self.splitterSizes3=[150,1000,300]
1047
1048        if   self.code in [ 'Adao', 'ADAO','MAP' ] : self.splitterSizes2=[5,1500]
1049        else                                  : self.splitterSizes2=[300,1000]
1050
1051
1052     #-----------------------------------------
1053     def restoreSplitterSizes(self,nbWidget=3):
1054     #----------------------------------------
1055
1056       #traceback.print_stack()
1057       #print ("je passe ds restoreSplitterSizes")
1058       if not(hasattr(self,'splitter')) : return
1059       if nbWidget==2  : newSizes=self.splitterSizes2
1060       if nbWidget==3  : newSizes=self.splitterSizes3
1061       #self.inhibeSplitter = 1
1062       self.splitter.setSizes(newSizes)
1063       #self.inhibeSplitter = 0
1064       QApplication.processEvents()
1065       # seule la fentetre du milieu est necessaire
1066       self.splitter.widget(1).resizeEvent=self.saveSplitterSizes
1067
1068     #-----------------------------------------
1069     def saveSplitterSizes(self,event):
1070     #-----------------------------------------
1071       #print ("je passe ds saveSplitterSizes")
1072       if self.inhibeSplitter : return
1073       if self.widgetOptionnel == None  : self.splitterSizes2 = self.splitter.sizes()[0:2]
1074       else                             : self.splitterSizes3 = self.splitter.sizes()[0:3]
1075
1076     #------------------------
1077     def fermeOptionnel(self):
1078     #------------------------
1079       if self.widgetOptionnel == None : return
1080
1081       self.inhibeSplitter=1
1082       self.widgetOptionnel.setParent(None)
1083       self.widgetOptionnel.close()
1084       self.widgetOptionnel.deleteLater()
1085       self.widgetOptionnel=None
1086       self.inhibeSplitter=0
1087       self.restoreSplitterSizes(2)
1088
1089     #------------------------
1090     def ajoutOptionnel(self):
1091     #------------------------
1092       #if len(self.splitterSizes) == 2 : self.splitterSizes.append(self.oldSizeWidgetOptionnel)
1093       #else : self.splitterSizes[2] = self.oldSizeWidgetOptionnel # ceinture pour les close bizarres
1094       #self.splitterSizes[1] = self.splitterSizes[1] - self.splitterSizes[2]
1095
1096       self.restoreSplitterSizes(3)
1097
1098
1099     #------------------------
1100     def fermeArbre(self):
1101     #------------------------
1102        #print (self.widgetTree)
1103        self.oldWidgetTree=self.widgetTree
1104        self.widgetTree.hide()
1105        #self.widgetTree=None
1106
1107     #------------------------
1108     def ouvreArbre(self):
1109     #------------------------
1110        #print ('je passe la')
1111        #print (self.widgetTree)
1112        #self.widgetTree=self.oldWidgetTree
1113        self.widgetTree.show()
1114        #self.restoreSplitterSizes(3)
1115
1116     #-----------------------
1117     def getEtapeCourante(self) :
1118     #-----------------------
1119       print (self.tree.selectedItems())
1120       if len(self.tree.selectedItems()) != 1 : return None
1121       etape=self.tree.selectedItems()[0].item.object.getEtape()
1122       return etape
1123     #-----------------------------
1124     def getTreeIndex(self,noeud):
1125     #----------------------------
1126       indexNoeud=-1
1127       if noeud in noeud.treeParent.children :
1128           indexNoeud=noeud.treeParent.children.index(noeud)
1129       else :
1130           if hasattr(noeud,'vraiParent') :
1131               noeudVrai = noeud
1132               noeudVraiParent = noeud.vraiParent
1133               while noeudVraiParent != noeud.treeParent and hasattr(noeudVraiParent,'vraiParent') :
1134                   noeudVrai = noeudVraiParent
1135                   noeudVraiParent = noeudVraiParent.vraiParent
1136                   pass
1137               if noeudVraiParent == noeud.treeParent :
1138                   indexNoeud=noeud.treeParent.children.index(noeudVrai)
1139                   pass
1140               pass
1141           pass
1142       return indexNoeud
1143
1144     #-------------------#
1145     def runMeteo(self):
1146     #-------------------#
1147
1148       if not(self.jdc.isValid()):
1149          QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution Meteo"))
1150          return
1151       strSource = str( self.getTextJDC(self.format) )
1152       code = compile(strSource, strSource, 'exec')
1153       exec(code, globals(), {})
1154
1155
1156
1157     #-------------------#  Pour execution avec output et error dans le bash
1158     def runPSEN(self):
1159     #-------------------#
1160
1161       #if self.modified or self.fichier==None  : self.saveFile()
1162       self.saveFile()
1163
1164       #lancement avec le .bat
1165       path1 = os.path.abspath(os.path.join(os.path.abspath(__file__), '../','../','PSEN_Eficas','PSEN'))
1166       WrapperFilePath = os.path.join(path1, 'PSSEWrapper.py')
1167       import subprocess
1168       p = subprocess.Popen(['python',WrapperFilePath])
1169       (out,err)=p.communicate()
1170       print (out)
1171       print (err)
1172
1173     #-------------------#  Pour execution avec output et error dans le bash
1174     def runPSEN_N1(self):
1175     #-------------------#
1176
1177
1178       self.saveFile()
1179       path1 = os.path.abspath(os.path.join(os.path.abspath(__file__), '../','../','ProcessOutputs_Eficas','TreatOutputs'))
1180       sys.path.append(path1)
1181
1182       if not(self.jdc.isValid()):
1183          QMessageBox.information( self, tr( "Unvalid JDC"),tr("incorrect keywords will be ignored"))
1184       if 'dicoImbrique' in generator.plugins:
1185          self.generator=generator.plugins['dicoImbrique']()
1186          jdc_formate=self.generator.gener(self.jdc)
1187          dico=self.generator.Dico
1188
1189          ###to delete
1190          #fileDico =  r'C:\Logiciels DER\PSEN_V16\Code\ProcessOutputs_Eficas\TreatOutputs\dicoN1.py'
1191          fileDico =  os.path.join(path1, 'dicoN1.py') #r'C:\Logiciels DER\PSEN_V16\Code\ProcessOutputs_Eficas\TreatOutputs\dicoN1.py'
1192          f = open( str(fileDico), 'w')
1193          f.write("Dico =" + str(dico) )
1194          f.close()
1195          ###
1196
1197
1198       print ('in runPSEN_N1', dico)
1199       print (dico)
1200       from Run import run
1201       run(dico)
1202       #res,txt_exception=run(dico)
1203       #if res : QMessageBox.information( self, tr("fin de script run"), txt_exception)
1204       #else  : QMessageBox.critical( self, tr("Erreur fatale script run"), txt_exception)
1205
1206     #-------------------#  Pour execution avec output et error dans le bash
1207     def process_N1(self):
1208     #-------------------#
1209
1210       path1 = os.path.abspath(os.path.join(os.path.abspath(__file__), '../','../','ProcessOutputs_Eficas','TreatOutputs'))
1211       sys.path.append(path1)
1212
1213
1214       if 'dicoImbrique' in generator.plugins:
1215          self.generator=generator.plugins['dicoImbrique']()
1216          jdc_formate=self.generator.gener(self.jdc)
1217          dico=self.getDico() #generator.Dico
1218
1219
1220          for k in dico['CONTINGENCY_PROCESSING']:
1221              #print (k)
1222              if k[0:19] == 'Component_List_For_' or k[0:21] =='Contingency_List_For_' :
1223                 newK=k.replace('__',' ')
1224                 l="'"+str(newK)+"'"
1225                 dico['CONTINGENCY_PROCESSING'][l]=dico['CONTINGENCY_PROCESSING'][k]
1226                 del dico['CONTINGENCY_PROCESSING'][k]
1227
1228          ###to delete
1229          fileDico =  os.path.join(path1, 'dicoN1_process.py')
1230          f = open( str(fileDico), 'w')
1231          f.write("Dico =" + str(dico) )
1232          f.close()
1233          ###
1234          return dico
1235
1236         #return self.getDico()
1237
1238     #-------------------#  Pour execution avec output et error dans le bash
1239     def process_VP(self):
1240     #-------------------#
1241       if 'dicoImbrique' in generator.plugins:
1242          self.generator=generator.plugins['dicoImbrique']()
1243          jdc_formate=self.generator.gener(self.jdc)
1244          dico=self.getDico() #generator.Dico
1245          return dico
1246
1247
1248 if __name__ == "__main__":
1249     print ('in main')