InterfaceQT4/editor.py

   1 # -*- coding: utf-8 -*-
   2 # Copyright (C) 2007-2021   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
  31
  32 from PyQt5.QtWidgets import QWidget, QMessageBox, QFileDialog, QApplication, QSplitter, QLabel
  33 from PyQt5.QtGui     import QPalette
  34 from PyQt5.QtCore    import QProcess, QFileInfo, QTimer, Qt, QDir, QSize
  35
  36 import traceback
  37
  38 # Modules Eficas
  39 from Extensions.i18n import tr
  40
  41 from Editeur        import session
  42 from Editeur        import comploader
  43 from Editeur        import Objecttreeitem
  44 from InterfaceQT4   import browser
  45
  46 from desBaseWidget    import Ui_baseWidget
  47 from InterfaceQT4.monViewTexte   import ViewText
  48 from monWidgetCreeParam import MonWidgetCreeParam
  49
  50 DictExtensions= {"MAP" : ".map", "TELEMAC" : '.cas'}
  51 debug = False
  52
  53
  54 from InterfaceQT4.editorSsIhm    import JDCEditorSsIhm
  55
  56
  57 class JDCEditor(JDCEditorSsIhm,Ui_baseWidget,QWidget):
  58 # ----------------------------------------- #
  59     """
  60        Editeur de jdc
  61     """
  62
  63 # ----------------------------------------
  64 # Methodes faisant appel a ssIhm
  65 # ----------------------------------------
  66
  67     def __init__ (self,appliEficas,fichier = None, jdc=None, QWParent=None, units = None, include=0):
  68     #------------------------------------------------------------------------------------------------
  69
  70
  71         QWidget.__init__(self,None)
  72         self.setupUi(self)
  73
  74         self.inhibeSplitter=0
  75         self.widgetOptionnel=None
  76         self.fenetreCentraleAffichee=None
  77         self.dejaDansPlieTout=False
  78         self.listeDesListesOuvertes=set()
  79         if appliEficas!=None and hasattr(appliEficas,"statusBar"): self.sb = appliEficas.statusBar()
  80         else : self.sb = None
  81         self.QWParent=QWParent
  82
  83         JDCEditorSsIhm. __init__ (self,appliEficas,fichier, jdc,units,include)
  84         if self.jdc:
  85             comploader.chargerComposants()
  86             self.jdc_item=Objecttreeitem.makeObjecttreeitem( self, "nom", self.jdc )
  87
  88
  89         # Particularites IHM : met la fenetre a jour
  90
  91         self.initSplitterSizes()
  92
  93         #self.affiche=self.appliEficas.maConfiguration.affiche
  94
  95         self.afficheListesPliees=self.maConfiguration.afficheListesPliees
  96         if self.code in ['MAP','CARMELCND','PSEN'] : self.maConfiguration.afficheCommandesPliees=False
  97         if self.code in ['MAP',]: self.fermeArbre()
  98         #   self.widgetTree.close()
  99         #   self.widgetTree=None
 100
 101         if self.maConfiguration.closeArbre      : self.fermeArbre()
 102         if self.maConfiguration.closeOptionnel  : self.fermeOptionnel()
 103         if self.maConfiguration.boutonDsMenuBar : self.appliEficas.remplitIconesCommandes()
 104
 105
 106         self.formatFichierOut =  self.appliEficas.formatFichierOut
 107         self.formatFichierIn  =  self.appliEficas.formatFichierIn
 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','VP'] : 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.labelCode)
 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             if noeudACopier.treeParent.editor != noeudOuColler.treeParent.editor:
 426                 QMessageBox.critical( self, tr("Deplacement refuse"),tr('Deplacement refuse entre 2 fichiers. Seule la copie est autorisee '))
 427
 428             #if 1:
 429             try :
 430                 # indexNoeudACopier=noeudACopier.treeParent.children.index(noeudACopier)
 431                 indexNoeudACopier=self.getTreeIndex(noeudACopier)
 432                 noeudACopier.treeParent.item.deplaceEntite(indexNoeudACopier,indexNoeudOuColler,pos)
 433                 noeudACopier.treeParent.buildChildren()
 434
 435             #else:
 436             except:
 437                 pass
 438             self.QWParent.noeud_a_editer=[]
 439
 440         # on rend la copie a nouveau possible en liberant le flag edit
 441         self.QWParent.edit="copier"
 442         noeudACopier.select()
 443
 444     #----------------------------------#
 445     def handleDeplaceMultiple(self):
 446     #----------------------------------#
 447         pass
 448
 449     #----------------------------------#
 450     def handleEditPasteMultiple(self):
 451     #----------------------------------#
 452
 453     # On ne garde que les niveaux "Etape"
 454     # On insere dans l'ordre du JDC
 455         listeNoeudsACouper=[]
 456         listeIndex=[]
 457         listeChild=[]
 458         listeItem=[]
 459         from InterfaceQT4 import compojdc
 460         noeudOuColler=self.node_selected[0]
 461         if not (isinstance(noeudOuColler.treeParent, compojdc.Node)):
 462             QMessageBox.information( self,
 463                       tr("Copie impossible a cet endroit",),
 464                       tr("Veuillez selectionner une commande, un parametre, un commentaire ou une macro"))
 465             return
 466         indexNoeudOuColler=noeudOuColler.treeParent.children.index(noeudOuColler)
 467
 468         for noeud in self.QWParent.noeud_a_editer :
 469             if not (isinstance(noeud.treeParent, compojdc.Node)): continue
 470             indexInTree=noeud.treeParent.children.index(noeud)
 471             indice = 0
 472             for index in listeIndex:
 473                 if index < indexInTree : indice = indice +1
 474             listeIndex.insert(indice, indexInTree)
 475             listeNoeudsACouper.insert(indice, noeud)
 476
 477         noeudJdc=noeudOuColler.treeParent
 478         dejaCrees=0
 479         # on les cree a l'envers parcequ'on ajoute a NoeudOuColler
 480         listeIndex.reverse()
 481         for index in listeIndex:
 482             indexTravail=index
 483             if indexNoeudOuColler < index:
 484                 indexTravail=indexTravail+dejaCrees
 485             noeudOuColler=noeudJdc.children[indexNoeudOuColler]
 486             noeud=noeudJdc.children[indexTravail]
 487             child=noeud.doPaste(noeudOuColler)
 488             listeChild.append(child)
 489             dejaCrees=dejaCrees+1
 490
 491         self.QWParent.noeud_a_editer = []
 492         for i in range(len(listeIndex)):
 493             noeud=noeudJdc.children[indexNoeudOuColler+1+i]
 494             self.QWParent.noeud_a_editer.append(noeud)
 495
 496         listeASupprimer=[]
 497         if self.QWParent.edit !="couper" : return
 498
 499         for index in listeIndex:
 500             indexTravail=index
 501             if indexNoeudOuColler < index:
 502                 indexTravail=indexTravail+(len(listeIndex))
 503             noeud=noeudJdc.children[indexTravail]
 504
 505             listeItem.append(noeud.item)
 506             listeASupprimer.append(noeud)
 507
 508         for i in range(len(listeChild)):
 509             self.tree.item.suppItem(listeItem[i])
 510             listeChild[i].item.update(listeItem[i])
 511
 512         self.QWParent.noeud_a_editer = []
 513
 514     #----------------------------------#
 515     def handleAjoutEtape(self,nomEtape):
 516     #----------------------------------#
 517         self.chercheNoeudSelectionne()
 518         if len(self.node_selected) == 0 or self.node_selected[0] == self.tree.racine :
 519             nodeOuAjouter=self.tree.racine
 520             nouveau=nodeOuAjouter.appendChild(nomEtape,pos='first')
 521         else :
 522             nodeOuAjouter=self.node_selected[0]
 523             if nodeOuAjouter != self.tree.racine :
 524                 while  nodeOuAjouter.treeParent != self.tree.racine:
 525                     nodeOuAjouter=nodeOuAjouter.treeParent
 526             nouveau=nodeOuAjouter.appendBrother(nomEtape)
 527         try :
 528             self.node_selected[0].setSelected(False)
 529         except : pass
 530         nouveau.setSelected(True)
 531         nouveau.affichePanneau()
 532
 533
 534     #---------------------------#
 535     def getFileVariable(self) :
 536     #---------------------------#
 537         titre = tr("Choix d'un fichier XML")
 538         texte = tr("Le fichier contient une commande MODEL\n")
 539         texte = texte+tr('Donnez le nom du fichier XML qui contient la description des variables')
 540         QMessageBox.information( self, titre,tr(texte))
 541
 542         fichier = QFileDialog.getOpenFileName(self.appliEficas,
 543                       tr('Ouvrir Fichier'),
 544                       self.appliEficas.maConfiguration.savedir,
 545                       tr('Wrapper Files (*.xml);;''All Files (*)'))
 546         return  fichier
 547
 548     #------------#
 549     def run(self):
 550     #------------#
 551         fonction="run"+self.code
 552         if fonction in JDCEditor.__dict__: JDCEditor.__dict__[fonction](self,)
 553
 554     #------------#
 555     def saveRun(self):
 556     #------------#
 557         fonction="saveRun"+self.code
 558         if fonction in JDCEditor.__dict__: JDCEditor.__dict__[fonction](self,)
 559
 560
 561 # ---------------------------------------------
 562 # Methodes Non Crees dans ssIHM
 563 # ---------------------------------------------
 564     #---------------#
 565     def runVP(self):
 566     #---------------#
 567         texte=self.getTextJDC("MAPVp",pourRun=1)
 568         print (texte)
 569
 570     #---------------#
 571     def runMAP(self):
 572     #---------------#
 573
 574         if not(self.jdc.isValid()):
 575             QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution MAP"))
 576             return
 577         if len(self.jdc.etapes) != 1 :
 578             QMessageBox.critical( self, tr("Execution impossible "),tr("le JDC doit contenir un et un seul composant"))
 579             return
 580         if self.modified or self.fichier==None  :
 581             self.fichierMapInput = self.__generateTempFilename(prefix = "map_run", suffix = ".map")
 582             texte=self.getTextJDC("MAP")
 583             self.writeFile( self.fichierMapInput, txt = texte)
 584         else :
 585             self.fichierMapInput=self.fichier
 586         composant=self.jdc.etapes[0].nom.lower()[0:-5]
 587
 588
 589         # :TRICKY: to determine if a component requires SALOME, loads the component from Eficas catalog
 590         # then instantiate corresponding class and call getUseSalome() method
 591         try:
 592             from mapengine.spec import factory
 593             mapComponent = factory.new(composant)[0]
 594
 595             command = "map"
 596             if mapComponent.getUseSalome():
 597                 command += " -r sappli"
 598             textePython=(command + " run -n "+composant +" -i "+self.fichierMapInput)
 599
 600             #textePython="ls -l"
 601             self._viewTextExecute( textePython,"map_run",".sh")
 602             #try:
 603             #  commande="rm  "+self.fichierMapInput
 604             #   os.system(commande)
 605             #except :
 606             #   pass
 607         except Exception as e:
 608             print((traceback.print_exc()))
 609
 610     #-------------------#
 611     def runZCRACKS(self):
 612     #-------------------#
 613         if not(self.jdc.isValid()):
 614             QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution "))
 615             return
 616         if self.modified or self.fichier==None  :
 617         #if 1:
 618             self.fichierZcracksInput = self.__generateTempFilename(prefix = "zcracks_run", suffix = ".z7p")
 619             texte=self.getTextJDC("ZCRACKS",pourRun=1)
 620             self.writeFile( self.fichierZcracksInput, txt = texte)
 621         else :
 622             self.fichierZcracksInput=self.fichier
 623         try :
 624             #commande ="Zrun -zp "
 625             commande="more "
 626             textePython=(commande + self.fichierZcracksInput)
 627             self._viewTextExecute( textePython,"run_zcracks",".sh")
 628         except Exception as e:
 629             print((traceback.print_exc()))
 630
 631     #-------------------#
 632     def runCARMELCND(self):
 633     #-------------------#
 634         #if not(self.jdc.isValid()):
 635         #   QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution "))
 636         #   return
 637         if self.modified or self.fichier==None  :
 638             QMessageBox.critical( self, tr( "Execution impossible "),tr("Sauvegarder SVP avant l'execution "))
 639             return
 640         if not hasattr(self,'generator'): texte=self.getTextJDC(self.formatFichierOut)
 641         from PrepareRunCarmel import prepareRunCarmel
 642         fichierGenerique=os.path.basename(self.fichier).split(".")[0]
 643         repMed=os.path.dirname(self.fichier)
 644         repExeCarmel=self.generator.get_repExeCarmel()
 645         textePython=prepareRunCarmel(repExeCarmel,repMed,fichierGenerique)
 646         nomFichier = self.__generateTempFilename("carmel_run", suffix = ".sh")
 647         f=open(nomFichier,'w')
 648         f.write(textePython)
 649         f.close()
 650         commande="xterm -e sh "+nomFichier +"\n"
 651         os.system(commande)
 652
 653     #-------------------#
 654     def runCarmelCS(self):
 655     #-------------------#
 656         try :
 657             commande="runSession pilotyacsCS.py"
 658             os.system(commande)
 659         except Exception as e:
 660             print((traceback.print_exc()))
 661
 662     #-----------------------------------------------------#
 663     def determineNomFichier(self,path,extension):
 664     #-----------------------------------------------------#
 665         if self.appliEficas.code in DictExtensions:
 666             chaine1=DictExtensions[self.appliEficas.code]+" (*."+DictExtensions[self.appliEficas.code]+");;"
 667             extensions= tr(chaine1+ "All Files (*)")
 668         else :
 669             extensions= tr("JDC (*.comm);;" "All Files (*)")
 670
 671         if self.appliEficas.code == "MAP" :
 672             extensions = extensions + ";; Run (*.input);;"
 673
 674         fn = QFileDialog.getSaveFileName( self,
 675                tr("sauvegarde"), path,
 676                extensions,None,
 677                QFileDialog.DontConfirmOverwrite)
 678         if fn == None : return (0, None)
 679         fn=fn[0]
 680         if fn=='': return (0, None)
 681
 682         ext = QFileInfo(fn).suffix()
 683         if ext == '': fn+=extension
 684
 685         if QFileInfo(fn).exists():
 686             msgBox = QMessageBox(self)
 687             msgBox.setWindowTitle(tr("Sauvegarde du Fichier"))
 688             msgBox.setText(tr("Le fichier")+ "  "+str(fn)+ "  " +tr("existe deja"))
 689             msgBox.addButton(tr("&Ecraser"),0)
 690             msgBox.addButton(tr("&Abandonner"),1)
 691             abort=msgBox.exec_()
 692             if abort == 1 :  return (0, "")
 693         return (1,fn)
 694
 695     #-----------------#
 696     def saveRunMAP(self):
 697     #-----------------#
 698         extension=".input"
 699         if not(self.jdc.isValid()):
 700             QMessageBox.critical( self, tr( "Sauvegarde de l'input impossible "),
 701                                  tr("Un JdC valide est necessaire pour creer un .input")
 702                                   )
 703             return
 704         try :
 705             composant=self.jdc.etapes[0].nom.lower()[0:-5]
 706         except :
 707             QMessageBox.critical( self, tr( "Sauvegarde de l'input impossible "),
 708                                  tr("Choix du composant obligatoire")
 709                                   )
 710             return
 711         if hasattr(self.maConfiguration, "savedir"): path=self.maConfiguration.savedir
 712         else : path='C:/'
 713
 714         monNomFichier=""
 715         if self.fichier is not None and self.fichier != "" :
 716             maBase=str(QFileInfo(self.fichier).baseName())+".input"
 717             monPath=str(QFileInfo(self.fichier).absolutePath())
 718             monNomFichier=os.path.join(monPath,maBase)
 719         elif hasattr(self,'monNomFichierInput'):
 720             monNomFichier=self.monNomFichierInput
 721
 722
 723         monDialog=QFileDialog(self.appliEficas)
 724         monDialog.setDirectory (path)
 725         monDialog.setWindowTitle ("Save")
 726
 727         for c in monDialog.children():
 728             if isinstance(c,QDialogButtonBox):
 729                 for b in c.children():
 730                     if isinstance(b,QPushButton):
 731                         avant=b.text()
 732                         if avant=="&Open": b.setText("Save")
 733         mesFiltres= "input Map (*.input);;All Files (*)"
 734         monDialog.setNameFilters(mesFiltres)
 735         if monNomFichier!="" : monDialog.selectFile(monNomFichier)
 736         BOk=monDialog.exec_()
 737         if BOk==0: return
 738         fn=str(monDialog.selectedFiles()[0])
 739         if fn == "" or fn == None : return
 740         if not fn.endswith(".input"):
 741             fn += ".input"
 742         self.monNomFichierInput=fn
 743
 744         if not hasattr(self, 'fichierMapInput') or not self.fichierMapInput or not os.path.exists(self.fichierMapInput):
 745             self.fichierMapInput = self.__generateTempFilename(prefix = "map_run", suffix = ".map")
 746             texte=self.getTextJDC("MAP")
 747             self.writeFile( self.fichierMapInput, txt = texte)
 748
 749         cmd = ("map gen -t dat -n " + composant + " -i " + self.fichierMapInput + " -o " + fn)
 750         p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE)
 751         (output, err) = p.communicate()
 752
 753
 754     #-----------------#
 755     def saveRunPSEN(self):
 756     #-----------------#
 757         #print ("saveRunPSEN")
 758         self.saveFile()
 759
 760
 761
 762     #-----------------------------------------#
 763     def handleAjoutGroup(self,listeGroup):
 764     #-----------------------------------------#
 765         try :
 766         #if 1:
 767             from ajoutGroupe import handleAjoutGroupFiltre
 768             #print listeGroup
 769             handleAjoutGroupFiltre(self,listeGroup)
 770             #print "apres handleAjoutGroupFiltre"
 771         except :
 772         #else :
 773             pass
 774
 775
 776     #-----------------------------------------------------------------#
 777     def saveCompleteFile(self, path = None, saveas= 0,formatLigne="beautifie"):
 778     #-----------------------------------------------------------------#
 779         extension='.casR'
 780         fn = self.fichierComplet
 781         #saveas=True # Pour forcer le nom
 782         self.generator=self.maConfiguration.mesGenerators.plugins[self.formatFichierOut]()
 783         if self.fichierComplet is None or saveas:
 784             if path is None: path=self.maConfiguration.savedir
 785             bOK, fn=self.determineNomFichier(path,extension)
 786             if bOK == 0 : return (0, None)
 787             if fn == None : return (0, None)
 788             if fn== '' : return (0, None)
 789
 790             ulfile = os.path.abspath(fn)
 791             self.appliEficas.maConfiguration.savedir=os.path.split(ulfile)[0]
 792             fn = QDir.toNativeSeparators(fn)
 793
 794         self.fichierComplet = os.path.splitext(fn)[0]+extension
 795
 796         if hasattr(self.generator, "writeComplet"):
 797             self.generator.writeComplet(self.fichierComplet,self.jdc,config=self.appliEficas.maConfiguration,appliEficas=self.appliEficas)
 798
 799         if self.salome : self.appliEficas.addJdcInSalome( self.fichierComplet)
 800
 801         self.modified = 0
 802         nouveauTitre=self.titre+"              "+str(os.path.basename(self.fichierComplet))
 803         self.appliEficas.setWindowTitle(nouveauTitre)
 804         return (1, self.fichierComplet)
 805
 806     #-----------------------------------------------------------------#
 807     def saveFile(self, path = None, saveas= 0,formatLigne="beautifie"):
 808     #-----------------------------------------------------------------#
 809         """
 810         Public slot to save the text to a file.
 811
 812         @param path directory to save the file in (string or QString)
 813         @return tuple of two values (boolean, string) giving a success indicator and
 814             the name of the saved file
 815         """
 816
 817         self.modified=1
 818         if not self.modified and not saveas:
 819             return (0, None)      # do nothing if text wasn't changed
 820
 821         if self.appliEficas.code in DictExtensions :
 822             extension=DictExtensions[self.appliEficas.code]
 823         else :
 824             extension='.comm'
 825
 826         newName = None
 827         fn = self.fichier
 828         if self.fichier is None or saveas:
 829             if path is None: path=self.maConfiguration.savedir
 830             bOK, fn=self.determineNomFichier(path,extension)
 831             if bOK == 0 : return (0, None)
 832             if fn == None : return (0, None)
 833             if fn== '' : return (0, None)
 834
 835             ulfile = os.path.abspath(fn)
 836             self.appliEficas.maConfiguration.savedir=os.path.split(ulfile)[0]
 837             fn = QDir.toNativeSeparators(fn)
 838             newName = fn
 839
 840
 841         if not (self.writeFile(fn,formatLigne=formatLigne)): return (0, None)
 842         self.fichier = fn
 843         self.modified  = False
 844         if self.fileInfo is None or saveas:
 845             self.fileInfo = QFileInfo(self.fichier)
 846             self.fileInfo.setCaching(0)
 847         self.lastModified = self.fileInfo.lastModified()
 848         if newName is not None:
 849             self.appliEficas.addToRecentList(newName)
 850             self.tree.racine.item.getObject().nom=os.path.basename(newName)
 851             self.tree.racine.updateNodeLabel()
 852
 853
 854         if  self.jdc.cata.modeleMetier:self.jdc.toXml(self.fichier)
 855         if  self.jdc.cata.modeleMetier and self.jdc.isValid():
 856             if self.generator != self.XMLgenerator :
 857                 self.XMLgenerator.gener(self.jdc)
 858                 self.XMLgenerator.writeDefault(fn)
 859
 860         if self.jdc.isValid() != 0 and hasattr(self.generator, "writeDefault"):
 861         #if hasattr(self.generator, "writeDefault"):
 862             self.generator.writeDefault(fn)
 863         elif self.code=="TELEMAC" and hasattr(self.generator, "writeDefault"):
 864             msgBox = QMessageBox(None)
 865             msgBox.setWindowTitle(tr("Fichier .cas invalide / incomplet"))
 866             msgBox.setText(tr("Le fichier .cas est invalide / incomplet"))
 867             msgBox.addButton(tr("&Sauvegarder"),1)
 868             msgBox.addButton(tr("&Quitter sans sauvegarder"),0)
 869             msgBox.addButton(tr("&Annuler"),2)
 870             res=msgBox.exec_()
 871             if res == 0 :
 872                 self.generator.writeDefault(fn)
 873                 return (1, self.fichier)
 874             if res == 2 : return (0, None)
 875             if self.appliEficas.salome : self.appliEficas.close()
 876             else : sys.exit(1)
 877
 878         if self.salome :
 879             self.appliEficas.addJdcInSalome( self.fichier)
 880         self.modified = 0
 881         nouveauTitre=self.titre+"              "+str(os.path.basename(self.fichier))
 882         self.appliEficas.setWindowTitle(nouveauTitre)
 883
 884         return (1, self.fichier)
 885 #
 886
 887     #----------------------------------------------#
 888     def sauveLigneFile(self):
 889     #----------------------------------------------#
 890         self.modified=1
 891         return self.saveFile(formatLigne="Ligne")
 892
 893
 894     #----------------------------------------------#
 895     def saveFileAs(self, path = None,fileName=None):
 896     #----------------------------------------------#
 897         """
 898         Public slot to save a file with a new name.
 899
 900         @param path directory to save the file in (string or QString)
 901         @return tuple of two values (boolean, string) giving a success indicator and
 902             the name of the saved file
 903         """
 904         if fileName != None :
 905             self.fichier = fileName
 906             return self.saveFile()
 907         return self.saveFile(path,1,"beautifie")
 908
 909
 910
 911     #---------------------------------------------#
 912     def getFile(self,unite=None,fic_origine = ''):
 913     #---------------------------------------------#
 914     # appele par I_JDC
 915         ulfile  = None
 916         jdcText = ""
 917
 918         titre  = ""
 919
 920         if unite :
 921             titre = tr("Choix unite %d ", unite)
 922             texte = tr("Le fichier %s contient une commande INCLUDE \n",  str(fic_origine)) +"\n"
 923             texte = texte+ tr("Donnez le nom du fichier correspondant a l unite logique ") + repr(unite)
 924             labeltexte = tr('Fichier pour unite ') + repr( unite)
 925         else:
 926             titre = tr("Choix d'un fichier de poursuite")
 927             texte = tr("Le fichier %s contient une commande POURSUITE\n", fic_origine)
 928             texte = texte+tr('Donnez le nom du fichier dont vous \n voulez faire une poursuite')
 929
 930         QMessageBox.information( self, titre,texte)
 931         fn = QFileDialog.getOpenFileName(self.appliEficas,
 932                    titre,
 933                    self.appliEficas.maConfiguration.savedir)
 934
 935         # ce retour est impose par le getFile d'I_JDC
 936         if fn== '' : return None," "
 937         if not fn : return (0, " ")
 938         fn=fn[0]
 939
 940         ulfile = os.path.abspath(fn)
 941         self.appliEficas.maConfiguration.savedir=os.path.split(ulfile)[0]
 942
 943         # On utilise le convertisseur defini par formatFichierIn
 944         source=self.getSource(ulfile)
 945         if source:
 946             # On a reussia convertir le fichier self.ulfile
 947             jdcText = source
 948         else:
 949             # Une erreur a ete rencontree
 950             jdcText = ''
 951         return ulfile, jdcText
 952
 953     #-----------------------------------#
 954     def updateJdc(self, etape,texte):
 955     #------------------------------------#
 956     # ajoute une etape  de JdC a partir d un texte
 957         CONTEXT.setCurrentStep(etape)
 958         etape.buildIncludeEtape(texte)
 959         if not (etape.text_included_converted) :
 960             QMessageBox.information( self,
 961                        tr("Impossible d importer le texte"),
 962                        etape.text_included_error)
 963
 964         self.tree.racine.buildChildren()
 965
 966     #-----------------------------------#
 967     def updateJdcEtape(self, itemApres,texte):
 968     #------------------------------------#
 969     # ajoute une etape  de JdC a partir d un texte
 970         monItem=itemApres
 971         etape=monItem.item.object
 972
 973         CONTEXT.setCurrentStep(etape)
 974         try :
 975             ok=etape.buildIncludeEtape(texte)
 976         except :
 977             ok=0
 978         if not ok :
 979             QMessageBox.information( self,
 980                        tr("Import texte"),
 981                        tr("Impossible d importer le texte"))
 982         self.tree.racine.buildChildren()
 983         return ok
 984
 985     #-------------------------------------------#
 986     def updateJdcAfterEtape(self, etape,texte):
 987     #--------------------------------------------#
 988     # ajoute une etape  de JdC a partir d un texte
 989         CONTEXT.setCurrentStep(etape)
 990         try :
 991             ok=etape.buildIncludeEtape(texte,doitEtreValide=0)
 992         except :
 993             ok=0
 994         if not ok :
 995             QMessageBox.information( self,
 996                        tr("Import texte"),
 997                        tr("Impossible d importer le texte"))
 998         self.tree.racine.buildChildren()
 999         return ok
1000
1001
1002     #-------------------------------------#
1003     def deleteEtape(self,etape):
1004     #-------------------------------------#
1005     # dans le JDC
1006         self.jdc.suppEntite(etape)
1007
1008
1009     #-----------------------------------------
1010     def initSplitterSizes(self, nbWidget=3):
1011     #-----------------------------------------
1012         #print ("je passe ds initSplitterSizes", nbWidget)
1013
1014         if   self.code in [ 'Adao', 'ADAO','MAP' ] : self.splitterSizes3=[1,1550,300]
1015         #elif self.code in [ 'MAP']            : self.splitterSizes3=[700,300]
1016         else                                  : self.splitterSizes3=[150,1000,300]
1017
1018         if   self.code in [ 'Adao', 'ADAO','MAP' ] : self.splitterSizes2=[5,1500]
1019         else                                  : self.splitterSizes2=[300,1000]
1020
1021
1022     #-----------------------------------------
1023     def restoreSplitterSizes(self,nbWidget=3):
1024     #----------------------------------------
1025
1026         #traceback.print_stack()
1027         #print ("je passe ds restoreSplitterSizes")
1028         if not(hasattr(self,'splitter')) : return
1029         if nbWidget==2  : newSizes=self.splitterSizes2
1030         if nbWidget==3  : newSizes=self.splitterSizes3
1031         #self.inhibeSplitter = 1
1032         #print (newSizes)
1033         self.splitter.setSizes(newSizes)
1034         #self.inhibeSplitter = 0
1035         QApplication.processEvents()
1036         # seule la fentetre du milieu est necessaire
1037         self.splitter.widget(1).resizeEvent=self.saveSplitterSizes
1038
1039     #-----------------------------------------
1040     def saveSplitterSizes(self,event):
1041     #-----------------------------------------
1042         #print ("je passe ds saveSplitterSizes")
1043         if self.inhibeSplitter : return
1044         if self.widgetOptionnel == None  : self.splitterSizes2 = self.splitter.sizes()[0:2]
1045         else                             : self.splitterSizes3 = self.splitter.sizes()[0:3]
1046
1047     #------------------------
1048     def fermeOptionnel(self):
1049     #------------------------
1050         if self.widgetOptionnel == None : return
1051
1052         self.inhibeSplitter=1
1053         self.widgetOptionnel.setParent(None)
1054         self.widgetOptionnel.close()
1055         self.widgetOptionnel.deleteLater()
1056         self.widgetOptionnel=None
1057         self.inhibeSplitter=0
1058         self.restoreSplitterSizes(2)
1059
1060     #------------------------
1061     def ajoutOptionnel(self):
1062     #------------------------
1063         #if len(self.splitterSizes) == 2 : self.splitterSizes.append(self.oldSizeWidgetOptionnel)
1064         #else : self.splitterSizes[2] = self.oldSizeWidgetOptionnel # ceinture pour les close bizarres
1065         #self.splitterSizes[1] = self.splitterSizes[1] - self.splitterSizes[2]
1066
1067         self.restoreSplitterSizes(3)
1068
1069
1070     #------------------------
1071     def fermeArbre(self):
1072     #------------------------
1073         #print (self.widgetTree)
1074         self.oldWidgetTree=self.widgetTree
1075         self.widgetTree.hide()
1076         #self.widgetTree=None
1077
1078     #------------------------
1079     def ouvreArbre(self):
1080     #------------------------
1081         #print ('je passe la')
1082         #print (self.widgetTree)
1083         #self.widgetTree=self.oldWidgetTree
1084         self.widgetTree.show()
1085         #self.restoreSplitterSizes(3)
1086
1087     #-----------------------
1088     def getEtapeCourante(self) :
1089     #-----------------------
1090         if len(self.tree.selectedItems()) != 1 : return None
1091         etape=self.tree.selectedItems()[0].item.object.getEtape()
1092         return etape
1093     #-----------------------------
1094     def getTreeIndex(self,noeud):
1095     #----------------------------
1096         indexNoeud=-1
1097         if noeud in noeud.treeParent.children :
1098             indexNoeud=noeud.treeParent.children.index(noeud)
1099         else :
1100             if hasattr(noeud,'vraiParent') :
1101                 noeudVrai = noeud
1102                 noeudVraiParent = noeud.vraiParent
1103                 while noeudVraiParent != noeud.treeParent and hasattr(noeudVraiParent,'vraiParent') :
1104                     noeudVrai = noeudVraiParent
1105                     noeudVraiParent = noeudVraiParent.vraiParent
1106                     pass
1107                 if noeudVraiParent == noeud.treeParent :
1108                     indexNoeud=noeud.treeParent.children.index(noeudVrai)
1109                     pass
1110                 pass
1111             pass
1112         return indexNoeud
1113
1114     #-------------------#  Pour execution avec output et error dans le bash
1115     def runPSEN(self):
1116     #-------------------#
1117
1118         #if self.modified or self.fichier==None  : self.saveFile()
1119         self.saveFile()
1120
1121         #lancement avec le .bat
1122         path1 = os.path.abspath(os.path.join(os.path.abspath(__file__), '../','../','PSEN_Eficas','PSEN'))
1123         WrapperFilePath = os.path.join(path1, 'PSSEWrapper.py')
1124         import subprocess
1125         p = subprocess.Popen(['python',WrapperFilePath])
1126         (out,err)=p.communicate()
1127         print (out)
1128         print (err)
1129
1130     #-------------------#  Pour execution avec output et error dans le bash
1131     def runPSEN_N1(self):
1132     #-------------------#
1133
1134
1135         self.saveFile()
1136         path1 = os.path.abspath(os.path.join(os.path.abspath(__file__), '../','../','ProcessOutputs_Eficas','TreatOutputs'))
1137         sys.path.append(path1)
1138
1139         if not(self.jdc.isValid()):
1140             QMessageBox.information( self, tr( "Unvalid JDC"),tr("incorrect keywords will be ignored"))
1141         if 'dicoImbrique' in generator.plugins:
1142             self.generator=generator.plugins['dicoImbrique']()
1143             jdc_formate=self.generator.gener(self.jdc)
1144             dico=self.generator.Dico
1145
1146             ###to delete
1147             #fileDico =  r'C:\Logiciels DER\PSEN_V16\Code\ProcessOutputs_Eficas\TreatOutputs\dicoN1.py'
1148             fileDico =  os.path.join(path1, 'dicoN1.py') #r'C:\Logiciels DER\PSEN_V16\Code\ProcessOutputs_Eficas\TreatOutputs\dicoN1.py'
1149             f = open( str(fileDico), 'w')
1150             f.write("Dico =" + str(dico) )
1151             f.close()
1152             ###
1153
1154
1155         print ('in runPSEN_N1', dico)
1156         print (dico)
1157         from Run import run
1158         run(dico)
1159         #res,txt_exception=run(dico)
1160         #if res : QMessageBox.information( self, tr("fin de script run"), txt_exception)
1161         #else  : QMessageBox.critical( self, tr("Erreur fatale script run"), txt_exception)
1162
1163     #-------------------#  Pour execution avec output et error dans le bash
1164     def process_N1(self):
1165     #-------------------#
1166
1167         path1 = os.path.abspath(os.path.join(os.path.abspath(__file__), '../','../','ProcessOutputs_Eficas','TreatOutputs'))
1168         sys.path.append(path1)
1169
1170
1171         if 'dicoImbrique' in generator.plugins:
1172             self.generator=generator.plugins['dicoImbrique']()
1173             jdc_formate=self.generator.gener(self.jdc)
1174             dico=self.getDico() #generator.Dico
1175
1176
1177             for k in dico['CONTINGENCY_PROCESSING']:
1178             #print (k)
1179                 if k[0:19] == 'Component_List_For_' or k[0:21] =='Contingency_List_For_' :
1180                     newK=k.replace('__',' ')
1181                     l="'"+str(newK)+"'"
1182                     dico['CONTINGENCY_PROCESSING'][l]=dico['CONTINGENCY_PROCESSING'][k]
1183                     del dico['CONTINGENCY_PROCESSING'][k]
1184
1185             ###to delete
1186             fileDico =  os.path.join(path1, 'dicoN1_process.py')
1187             f = open( str(fileDico), 'w')
1188             f.write("Dico =" + str(dico) )
1189             f.close()
1190             ###
1191             return dico
1192
1193         #return self.getDico()
1194
1195     #-------------------#  Pour execution avec output et error dans le bash
1196     def process_VP(self):
1197     #-------------------#
1198         if 'dicoImbrique' in generator.plugins:
1199             self.generator=generator.plugins['dicoImbrique']()
1200             jdc_formate=self.generator.gener(self.jdc)
1201             dico=self.getDico() #generator.Dico
1202             return dico
1203
1204 if __name__ == "__main__":
1205     print ('in main')