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