InterfaceQT4/editor.py

   1 # -*- coding: utf-8 -*-
   2 # Copyright (C) 2007-2013   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 import six
  32 from six.moves import range
  33 from PyQt5.QtWidgets import QWidget, QMessageBox, QFileDialog, QApplication, QSplitter
  34 from PyQt5.QtGui import QPalette
  35 from PyQt5.QtCore import QProcess, QFileInfo, QTimer, Qt, QDir, QSize
  36 import time
  37 import pdb
  38 from datetime import date
  39 from Extensions.i18n import tr
  40
  41 import traceback
  42
  43 # Modules Eficas
  44
  45 import convert, generator
  46 from Editeur        import session
  47 from Editeur        import comploader
  48 from Editeur        import Objecttreeitem
  49 from desBaseWidget  import Ui_baseWidget
  50 from InterfaceQT4.monViewTexte   import ViewText
  51 from monWidgetCreeParam import MonWidgetCreeParam
  52 from . import browser
  53 from . import readercata
  54
  55 DictExtensions= {"MAP" : ".map", "TELEMAC" : '.comm'}
  56
  57
  58
  59
  60 class JDCEditor(Ui_baseWidget,QWidget):
  61 # ----------------------------------------- #
  62     """
  63        Editeur de jdc
  64     """
  65
  66     def __init__ (self,appli,fichier = None, jdc = None, QWParent=None, units = None, include=0 , vm=None):
  67     #----------------------------------------------------------------------------------------------------------#
  68
  69         QWidget.__init__(self,None)
  70         self.i=0
  71         self.setupUi(self)
  72         self.inhibeSplitter=0
  73         self.widgetOptionnel=None
  74         self.fenetreCentraleAffichee=None
  75         self.dejaDansPlieTout=False
  76         self.afficheCommandesPliees = True
  77         self.listeDesListesOuvertes=set()
  78         self.appliEficas = appli
  79         self.appli       = appli  #---- attendu par IHM
  80         self.vm          = vm
  81         self.fichier     = fichier
  82         self.jdc         = jdc
  83         self.first       = True
  84         self.QWParent    = QWParent
  85         self.couleur     = Qt.black
  86         self.nodeEnCours=None
  87
  88         if appli != None :
  89            self.salome =  self.appliEficas.salome
  90         else :
  91            self.salome=0
  92            print ("dans JDC pas d appli ????????")
  93
  94         # ces attributs sont mis a jour par definitCode appelee par newEditor
  95         self.code   = self.appliEficas.CONFIGURATION.code
  96         self.initSplitterSizes()
  97
  98         #self.afficheListesPliees=False
  99         self.afficheListesPliees=True
 100         if self.code == "ASTER" or self.code == "monCode" : self.afficheListesPliees =True
 101         if self.code == 'PSEN_N1' : self.afficheListesPliees = False
 102
 103         self.mode_nouv_commande=self.appliEficas.CONFIGURATION.mode_nouv_commande
 104         self.closeAutreCommande=self.appliEficas.CONFIGURATION.closeAutreCommande
 105         self.closeFrameRechercheCommande=self.appliEficas.CONFIGURATION.closeFrameRechercheCommande
 106         self.closeArbre=self.appliEficas.CONFIGURATION.closeArbre
 107         self.affiche=self.appliEficas.CONFIGURATION.affiche
 108         self.nombreDeBoutonParLigne = self.appliEficas.CONFIGURATION.nombreDeBoutonParLigne
 109         #self.taille = self.appliEficas.taille
 110
 111         #if self.code in ['MAP','CARMELCND','PSEN'] : self.afficheCommandesPliees=False
 112         if self.code in ['MAP','CARMELCND'] : self.afficheCommandesPliees=False
 113         if self.code in ['MAP',]:
 114            self.widgetTree.close()
 115            self.widgetTree=None
 116         if self.closeArbre: self.fermeArbre()
 117
 118         self.version_code = session.d_env.cata
 119
 120
 121         if not hasattr ( self.appliEficas, 'readercata') or  self.appliEficas.multi==True:
 122            self.readercata  = readercata.READERCATA( self, self.appliEficas )
 123            self.appliEficas.readercata=self.readercata
 124            self.appliEficas.code=self.code
 125         else :
 126            self.readercata=self.appliEficas.readercata
 127         if self.readercata.fic_cata == None : return    #Sortie Salome
 128         self.titre=self.readercata.titre
 129         self.Ordre_Des_Commandes=self.readercata.Ordre_Des_Commandes
 130         self.Classement_Commandes_Ds_Arbre=self.readercata.Classement_Commandes_Ds_Arbre
 131
 132         self.format =  self.appliEficas.format_fichier
 133
 134         self.dict_reels={}
 135         self.liste_simp_reel=[]
 136         self.ihm="QT"
 137         self.dicoNouveauxMC={}
 138
 139         nameConf='configuration_'+self.code
 140         configuration=__import__(nameConf)
 141         self.CONFIGURATION = self.appliEficas.CONFIGURATION
 142         self.CONFIGStyle =   self.appliEficas.CONFIGStyle
 143
 144         try:
 145           self.CONFIGURATION.generator_module
 146           _module = __import__(self.CONFIGURATION.generator_module)
 147           info = _module.entryPoint()
 148           generator.plugins.addEntryPoint(info)
 149         except:
 150           pass
 151
 152         try:
 153           self.CONFIGURATION.convert_module
 154           #print self.CONFIGURATION.convert_module
 155           _module = __import__(self.CONFIGURATION.convert_module)
 156           info = _module.entryPoint()
 157           convert.plugins.addEntryPoint(info)
 158         except :
 159           pass
 160
 161         self.sb = None
 162         if hasattr(self.appliEficas,"statusBar"):
 163            self.sb = self.appliEficas.statusBar()
 164
 165         self.fileInfo       = None
 166         self.lastModified   = 0
 167
 168         self.modified   = False
 169         self.isReadOnly = False
 170         self.node_selected = []
 171         self.deplier = True
 172         self.message=''
 173         if self.code in ['Adao','ADAO','MAP'] : self.afficheApresInsert=True
 174         else :  self.afficheApresInsert=False
 175         if self.code in ['TELEMAC',] : self.enteteQTree='premier'
 176         else : self.enteteQTree='complet'
 177         if self.code in ['Adao','ADAO','TELEMAC'] : self.affichePlie=True
 178         else : self.affichePlie=False
 179
 180         self.Commandes_Ordre_Catalogue =self.readercata.Commandes_Ordre_Catalogue
 181
 182         #------- construction du jdc --------------
 183
 184         jdc_item = None
 185
 186         self.nouveau=0
 187         if self.fichier is not None:        #  fichier jdc fourni
 188             self.fileInfo = QFileInfo(self.fichier)
 189             self.fileInfo.setCaching(0)
 190             if jdc==None :
 191                #try :
 192                    self.jdc = self.readFile(self.fichier)
 193                #except :
 194                #    print ("mauvaise lecture")
 195             else :
 196                self.jdc=jdc
 197             if self.jdc is not None and units is not None:
 198                self.jdc.recorded_units=units
 199                self.jdc.old_recorded_units=units
 200         else:
 201             if not self.jdc:                   #  nouveau jdc
 202                 if not include :
 203                    self.jdc = self._newJDC(units=units)
 204                 else :
 205                    self.jdc = self._newJDCInclude(units=units)
 206                 self.nouveau=1
 207
 208         if self.jdc:
 209             self.jdc.appli = self # a resorber
 210             self.jdc.editor = self
 211             self.jdc.lang    = self.appli.langue
 212             self.jdc.aReafficher=False
 213             txt_exception  = None
 214             if not jdc:
 215                 self.jdc.analyse()
 216                 txt_exception = self.jdc.cr.get_mess_exception()
 217             if txt_exception:
 218                 self.jdc = None
 219                 QApplication.restoreOverrideCursor()
 220                 self.affiche_infos(tr("Erreur fatale au chargement de %s",str(fichier)),Qt.red)
 221                 if (self.appliEficas.ssIhm == False) : QMessageBox.critical( self, tr("Erreur fatale au chargement d'un fichier"), txt_exception)
 222             else:
 223                 comploader.charger_composants("QT")
 224                 jdc_item=Objecttreeitem.make_objecttreeitem( self, "nom", self.jdc )
 225                 if (not self.jdc.isvalid()) and (not self.nouveau) and (self.appliEficas.ssIhm == False):
 226                     self.viewJdcRapport()
 227
 228
 229
 230         if jdc_item and self.appliEficas.ssIhm==False:
 231             self.tree = browser.JDCTree( jdc_item,  self )
 232         self.appliEficas.construitMenu()
 233
 234
 235         #############
 236         self.adjustSize()
 237
 238
 239     #-------------------#  Pour execution avec output et error dans le bash
 240     def runPSEN(self):
 241     #-------------------#
 242
 243       #if self.modified or self.fichier==None  : self.saveFile()
 244       self.saveFile()
 245
 246       #lancement avec le .bat
 247       path1 = os.path.abspath(os.path.join(os.path.abspath(__file__), '../','../','PSEN_Eficas','PSEN'))
 248       WrapperFilePath = os.path.join(path1, 'PSSEWrapper.py')
 249       import subprocess
 250       p = subprocess.Popen(['python',WrapperFilePath])
 251       (out,err)=p.communicate()
 252       print (out)
 253       print (err)
 254
 255     #-------------------#  Pour execution avec output et error dans le bash
 256     def runPSEN_N1(self):
 257     #-------------------#
 258
 259
 260       self.saveFile()
 261       path1 = os.path.abspath(os.path.join(os.path.abspath(__file__), '../','../','ProcessOutputs_Eficas','TreatOutputs'))
 262       sys.path.append(path1)
 263
 264       if not(self.jdc.isvalid()):
 265          QMessageBox.information( self, tr( "Unvalid JDC"),tr("incorrect keywords will be ignored"))
 266       if 'dicoImbrique' in generator.plugins:
 267          self.generator=generator.plugins['dicoImbrique']()
 268          jdc_formate=self.generator.gener(self.jdc)
 269          dico=self.generator.Dico
 270
 271          ###to delete
 272          #fileDico =  r'C:\Logiciels DER\PSEN_V16\Code\ProcessOutputs_Eficas\TreatOutputs\dicoN1.py'
 273          fileDico =  os.path.join(path1, 'dicoN1.py') #r'C:\Logiciels DER\PSEN_V16\Code\ProcessOutputs_Eficas\TreatOutputs\dicoN1.py'
 274          f = open( str(fileDico), 'w')
 275          f.write("Dico =" + str(dico) )
 276          f.close()
 277          ###
 278
 279
 280       #print ('in runPSEN_N1', dico)
 281       from Run import run
 282       run(dico)
 283       #res,txt_exception=run(dico)
 284       #if res : QMessageBox.information( self, tr("fin de script run"), txt_exception)
 285       #else  : QMessageBox.critical( self, tr("Erreur fatale script run"), txt_exception)
 286
 287     #-------------------#  Pour execution avec output et error dans le bash
 288     def process_N1(self):
 289     #-------------------#
 290
 291       path1 = os.path.abspath(os.path.join(os.path.abspath(__file__), '../','../','ProcessOutputs_Eficas','TreatOutputs'))
 292       sys.path.append(path1)
 293
 294
 295       if 'dicoImbrique' in generator.plugins:
 296          self.generator=generator.plugins['dicoImbrique']()
 297          jdc_formate=self.generator.gener(self.jdc)
 298          dico=self.get_Dico() #generator.Dico
 299
 300
 301          for k in dico['CONTINGENCY_PROCESSING']:
 302              #print (k)
 303              if k[0:19] == 'Component_List_For_' or k[0:21] =='Contingency_List_For_' :
 304                 newK=k.replace('___',' ')
 305                 l="'"+str(newK)+"'"
 306                 dico['CONTINGENCY_PROCESSING'][l]=dico['CONTINGENCY_PROCESSING'][k]
 307                 del dico['CONTINGENCY_PROCESSING'][k]
 308
 309          ###to delete
 310          fileDico =  os.path.join(path1, 'dicoN1_process.py')
 311          f = open( str(fileDico), 'w')
 312          f.write("Dico =" + str(dico) )
 313          f.close()
 314          ###
 315          return dico
 316
 317         #return self.get_Dico()
 318
 319
 320
 321     #--------------------------------#
 322     def _newJDC( self ,units = None):
 323     #--------------------------------#
 324         """
 325         Initialise un nouveau JDC vierge
 326         """
 327         self.modified=1
 328         CONTEXT.unset_current_step()
 329
 330         texte=""
 331         if self.code == "CARMELCND" : texte=self._newJDCCND()
 332         if self.code == "ZCRACKS" : texte=self._newZCRACKS()
 333         if self.code == "TELEMAC" : texte=self._newTELEMAC()
 334         if self.code == "PSEN"    : texte = self._newPSEN()
 335         if self.code == "PSEN_N1" : texte = self._newPSEN_N1()
 336
 337         if hasattr(self.readercata.cata[0],'TEXTE_NEW_JDC') : texte=self.readercata.cata[0].TEXTE_NEW_JDC
 338
 339         #if self.code == "CF" : texte = self._new_CF()
 340         #   texte=self.newTexteCND
 341
 342         jdc=self.readercata.cata[0].JdC( procedure =texte,
 343                                          appli=self,
 344                                          cata=self.readercata.cata,
 345                                          cata_ord_dico=self.readercata.cata_ordonne_dico,
 346                                          rep_mat=self.CONFIGURATION.rep_mat
 347                                         )
 348         jdc.lang    = self.appli.langue
 349         if units is not None:
 350            jdc.recorded_units=units
 351            jdc.old_recorded_units=units
 352         ## PNPN est ce que la ligne suivante est bien utile ?
 353         if texte == "" :jdc.analyse()
 354         return jdc
 355
 356     #--------------------------------#
 357     def _newJDCInclude( self ,units = None):
 358     #--------------------------------#
 359         """
 360         Initialise un nouveau JDC vierge
 361         """
 362         import Extensions.jdc_include
 363         JdC_aux=Extensions.jdc_include.JdC_include
 364         CONTEXT.unset_current_step()
 365
 366         jaux=self.readercata.cata[0].JdC( procedure="",
 367                                appli=self,
 368                                cata=self.readercata.cata,
 369                                cata_ord_dico=self.readercata.cata_ordonne_dico,
 370                                rep_mat=self.CONFIGURATION.rep_mat,
 371                               )
 372         jaux.analyse()
 373
 374         J=JdC_aux( procedure="",
 375                    appli=self,
 376                    cata=self.readercata.cata,
 377                    cata_ord_dico=self.readercata.cata_ordonne_dico,
 378                    jdc_pere=jaux,
 379                    rep_mat=self.CONFIGURATION.rep_mat,
 380                    )
 381         J.analyse()
 382         if units is not None:
 383            J.recorded_units=units
 384            J.old_recorded_units=units
 385         return J
 386
 387
 388     #-------------------------------#
 389     def readFile(self, fn):
 390     #--------------------------------#
 391         """
 392         Public slot to read the text from a file.
 393         @param fn filename to read from (string or QString)
 394         """
 395         fn = six.text_type(fn)
 396
 397         # ------------------------------------------------------------------------------------
 398         #                         charge le JDC
 399         # ------------------------------------------------------------------------------------
 400
 401         jdcName=os.path.basename(fn)
 402         # Il faut convertir le contenu du fichier en fonction du format
 403         if self.appliEficas.format_fichier_in in convert.plugins:
 404              # Le convertisseur existe on l'utilise
 405              #appli = self
 406              p=convert.plugins[self.appliEficas.format_fichier_in]()
 407              p.readfile(fn)
 408              if p.text=="" : self.nouveau=1
 409              pareil,texteNew=self.verifieCHECKSUM(p.text)
 410              #if texteNew == ""
 411              if pareil == False and (self.appliEficas.ssIhm == False) :
 412                 QMessageBox.warning( self, tr("fichier modifie"),tr("Attention! fichier change hors EFICAS"))
 413              p.text=texteNew
 414              memeVersion,texteNew=self.verifieVersionCataDuJDC(p.text)
 415              if memeVersion == 0 : texteNew=self.traduitCatalogue(texteNew)
 416              p.text=texteNew
 417              text=p.convert('exec',self.appliEficas)
 418              if not p.cr.estvide():
 419                 self.affiche_infos("Erreur a la conversion",Qt.red)
 420         else :
 421             self.affiche_infos("Type de fichier non reconnu",Qt.red)
 422             if self.appliEficas.ssIhm == False:
 423                     QMessageBox.critical( self, tr("Type de fichier non reconnu"),
 424                     tr("EFICAS ne sait pas ouvrir le type de fichier %s" ,self.appliEficas.format_fichier_in))
 425             return None
 426
 427         CONTEXT.unset_current_step()
 428         jdc=self.readercata.cata[0].JdC(procedure=text,
 429                                     appli=self,
 430                                     cata=self.readercata.cata,
 431                                     cata_ord_dico=self.readercata.cata_ordonne_dico,
 432                                     nom=jdcName,
 433                                     rep_mat=self.CONFIGURATION.rep_mat
 434                                    )
 435         # ----------------------------------------------------
 436         #      charge le JDC fin
 437         # ----------------------------------------------------
 438         self.modified = False
 439
 440 #        qApp.restoreOverrideCursor()
 441         if self.fileInfo!= None :
 442            self.lastModified = self.fileInfo.lastModified()
 443         else :
 444            self.lastModified = 1
 445         nouveauTitre=self.titre+"              "+str(os.path.basename(self.fichier))
 446         self.appliEficas.setWindowTitle(nouveauTitre)
 447         return jdc
 448
 449
 450     #-----------------------#
 451     def get_source(self,file):
 452     #-----------------------#
 453
 454         # Il faut convertir le contenu du fichier en fonction du format
 455         if self.format in convert.plugins :
 456             # Le convertisseur existe on l'utilise
 457             p=convert.plugins[self.format]()
 458             p.readfile(file)
 459             text=p.convert('execnoparseur')
 460             if not p.cr.estvide():
 461                 self.affiche_infos("Erreur a la conversion",Qt.red)
 462             return text
 463         else:
 464             # Il n'existe pas c'est une erreur
 465             self.affiche_infos("Type de fichier non reconnu",Qt.red)
 466             QMessageBox.critical( self, tr("Type de fichier non reconnu"),tr("EFICAS ne sait pas ouvrir ce type de fichier"))
 467             return None
 468
 469     #-----------------------------------------------------------------------#
 470     def _viewText(self, txt, caption = "FILE_VIEWER",largeur=1200,hauteur=600):
 471     #--------------------------------------------------------------------#
 472         w = ViewText( self.QWParent,self ,caption,txt,largeur,hauteur)
 473         w.show()
 474     #
 475
 476     #----------------------------------------------#
 477     def __generateTempFilename(self, prefix, suffix):
 478     #----------------------------------------------#
 479         import tempfile
 480         (fd, filename) = tempfile.mkstemp(prefix=prefix, suffix=suffix)
 481         os.close(fd)
 482         return filename
 483     #
 484
 485
 486     #----------------------------------------------#
 487     def _viewTextExecute(self, txt, prefix, suffix):
 488     #----------------------------------------------#
 489         self.w = ViewText( self.QWParent )
 490         self.w.setWindowTitle( "execution" )
 491         self.monExe=QProcess(self.w)
 492         pid=self.monExe.pid()
 493         nomFichier = self.__generateTempFilename(prefix, suffix = ".sh")
 494         f=open(nomFichier,'w')
 495         f.write(txt)
 496         f.close()
 497         self.monExe.readyReadStandardOutput.connect( self.readFromStdOut)
 498         self.monExe.readyReadStandardError.connect( self.readFromStdErr)
 499         exe='sh ' + nomFichier
 500         self.monExe.start(exe)
 501         self.monExe.closeWriteChannel()
 502         self.w.exec_()
 503         try:
 504           commande="rm  "+ nomFichier
 505           os.system(commande)
 506         except :
 507           pass
 508
 509     def readFromStdErr(self):
 510         a=self.monExe.readAllStandardError()
 511         self.w.view.append(str(a.data(),len(a)))
 512
 513     def readFromStdErr(self) :
 514         a=self.monExe.readAllStandardOutput()
 515         self.w.view.append(str(a.data(),len(a)))
 516
 517     def readFromStdErrQT4(self):
 518         a=self.monExe.readAllStandardError()
 519         self.w.view.append(QString.fromUtf8(a.data(),len(a))) ;
 520
 521     def readFromStdOutQT4(self) :
 522         a=self.monExe.readAllStandardOutput()
 523         self.w.view.append(QString.fromUtf8(a.data(),len(a))) ;
 524
 525     #-----------------------#
 526     def generDico(self):
 527     #-----------------------#
 528        if 'dico' in generator.plugins:
 529          self.generator=generator.plugins['dico']()
 530          jdc_formate=self.generator.gener(self.jdc)
 531          dico=self.generator.Dico
 532          return dico
 533
 534     #-----------------------#
 535     def gestionParam(self):
 536     #-----------------------#
 537         w = MonWidgetCreeParam( self)
 538         w.show()
 539
 540     #-----------------------#
 541     def viewJdcSource(self):
 542     #-----------------------#
 543         if self.fichier == None : return
 544         f=open(self.fichier,'r')
 545         texteSource=f.read()
 546         f.close()
 547         self._viewText(texteSource, "JDC_SOURCE")
 548
 549     #-----------------------#
 550     def viewJdcPy(self):
 551     #-----------------------#
 552         strSource = str( self.get_text_JDC(self.format) )
 553         self._viewText(strSource, "JDC_RESULTAT")
 554
 555     #-----------------------#
 556     def viewJdcRapport(self):
 557     #-----------------------#
 558         strRapport = six.text_type( self.jdc.report() )
 559         # on ajoute les regles
 560
 561         self._viewText(strRapport, "JDC_RAPPORT")
 562
 563     #-----------------------#
 564     def viewJdcRegles(self):
 565     #-----------------------#
 566         if self.tree :self.tree.AppelleBuildLBRegles()
 567
 568
 569     #----------------#
 570     def closeIt(self):
 571     #----------------#
 572         """
 573         Public method called by the viewmanager to finally get rid of us.
 574         """
 575         if self.jdc:
 576             self.jdc.supprime()
 577         self.close()
 578
 579     #----------------------------------------------#
 580     def affiche_infos(self,message,couleur=Qt.black):
 581     #----------------------------------------------#
 582         if self.sb:
 583            mapalette=self.sb.palette()
 584            mapalette.setColor( QPalette.WindowText, couleur )
 585            self.sb.setPalette( mapalette );
 586            self.sb.showMessage(message,4000)
 587            self.couleur=couleur
 588
 589     #------------------------------#
 590     def affiche_alerte(self,titre,message):
 591     #------------------------------#
 592     # appele par I_MACRO_ETAPE
 593         QMessageBox.information( self, titre, message)
 594
 595     #-----------------------------------#
 596     def affiche_commentaire(self,message):
 597     #-----------------------------------#
 598         self.labelCommentaire.setText(message)
 599         QTimer.singleShot(6000, self.rendInvisible)
 600
 601     #----------------------#
 602     def rendInvisible(self):
 603     #----------------------#
 604         self.labelCommentaire.setText("")
 605
 606     #-------------------#
 607     def init_modif(self):
 608     #-------------------#
 609       """
 610           Met l'attribut modified a 'o' : utilise par Eficas pour savoir
 611           si un JDC doit etre sauvegarde avant destruction ou non
 612       """
 613       self.modified = True
 614
 615     #---------------------------------------#
 616     def chercheNoeudSelectionne(self,copie=1):
 617     #---------------------------------------#
 618       """
 619         appele par Cut et Copy pour positionner self.node_selected
 620       """
 621       self.node_selected=[]
 622       if len(self.tree.selectedItems()) == 0 : return
 623       self.node_selected=self.tree.selectedItems()
 624
 625
 626     #---------------------#
 627     def handleSupprimer(self):
 628     #---------------------#
 629       self.chercheNoeudSelectionne()
 630       if len(self.node_selected) == 0 : return
 631       self.QWParent.noeud_a_editer = []
 632       if self.node_selected[0]==self.tree.racine: return
 633       if len(self.node_selected) == 1 : self.node_selected[0].delete()
 634       else : self.node_selected[0].deleteMultiple(self.node_selected)
 635
 636     #---------------------#
 637     def handleRechercher(self):
 638     #---------------------#
 639       from .monRecherche import DRecherche
 640       monRechercheDialg=DRecherche(parent=self,fl=0)
 641       monRechercheDialg.show()
 642
 643
 644     #--------------------------------#
 645     def handleRechercherDsCatalogue(self):
 646     #-----------------------------#
 647       from .monRechercheCatalogue import DRechercheCatalogue
 648       monRechercheDialg=DRechercheCatalogue(self.QWParent,self)
 649       monRechercheDialg.show()
 650
 651     #---------------------#
 652     def handleDeplier(self):
 653     #---------------------#
 654        if self.tree == None : return
 655        #self.tree.collapseAll()
 656        if self.deplier :
 657           #print "je plie"
 658           self.tree.expandItem(self.tree.topLevelItem(0))
 659           self.deplier = False
 660           if self.fenetreCentraleAffichee != None  :
 661              if hasattr(self.fenetreCentraleAffichee.node,'plieToutEtReaffiche'):
 662                  self.fenetreCentraleAffichee.node.plieToutEtReaffiche()
 663        else:
 664           #print "je deplie"
 665           self.tree.expandItem(self.tree.topLevelItem(0))
 666           self.deplier = True
 667           if self.fenetreCentraleAffichee != None  :
 668              if hasattr(self.fenetreCentraleAffichee.node,'deplieToutEtReaffiche'):
 669                  self.fenetreCentraleAffichee.node.deplieToutEtReaffiche()
 670
 671     #---------------------#
 672     def handleEditCut(self):
 673     #---------------------#
 674       """
 675       Stocke dans Eficas.noeud_a_editer le noeud a couper
 676       """
 677       #print "handleEditCut"
 678       self.chercheNoeudSelectionne()
 679       self.QWParent.edit="couper"
 680       self.QWParent.noeud_a_editer = self.node_selected
 681
 682     #-----------------------#
 683     def handleEditCopy(self):
 684     #-----------------------#
 685       """
 686       Stocke dans Eficas.noeud_a_editer le noeud a copier
 687       """
 688       self.chercheNoeudSelectionne()
 689       if len(self.node_selected) == 0 : return
 690       if len(self.node_selected) == 1 : self.node_selected[0].update_node_label_in_blue()
 691       else :  self.node_selected[0].update_plusieurs_node_label_in_blue(self.node_selected)
 692       self.QWParent.edit="copier"
 693       self.QWParent.noeud_a_editer = self.node_selected
 694
 695     #------------------------#
 696     def handleEditPaste(self):
 697     #------------------------#
 698       """
 699       Lance la copie de l'objet place dans self.QWParent.noeud_a_editer
 700       Ne permet que la copie d'objets de type Commande ou MCF
 701       """
 702       self.chercheNoeudSelectionne()
 703       if (not(hasattr(self.QWParent,'noeud_a_editer'))) or len(self.QWParent.noeud_a_editer)==0:
 704           QMessageBox.information( self,
 705                       tr("Copie impossible"),
 706                       tr("Veuillez selectionner un objet a copier"))
 707           return
 708       if len(self.node_selected) != 1 :
 709           QMessageBox.information( self,
 710                       tr("Copie impossible"),
 711                       tr("Veuillez selectionner un seul objet : la copie se fera apres le noeud selectionne"))
 712           return
 713
 714       if len(self.QWParent.noeud_a_editer)!=1:
 715          self.handleEditPasteMultiple()
 716          return
 717
 718       noeudOuColler=self.node_selected[0]
 719       pos='after'
 720       if noeudOuColler == self.tree.racine:
 721          indexNoeudOuColler=0
 722          pos='before'
 723       else :
 724          indexNoeudOuColler=noeudOuColler.treeParent.children.index(noeudOuColler)
 725          indexNoeudOuColler=self.getTreeIndex(noeudOuColler)
 726
 727       try :
 728        noeudACopier=self.QWParent.noeud_a_editer[0]
 729        indexNoeudACopier=noeudACopier.treeParent.children.index(noeudACopier)
 730        indexNoeudACopier=self.getTreeIndex(noeudACopier)
 731       except :
 732        QMessageBox.information( self, tr("Copie impossible"), tr("Aucun Objet n a ete copie ou coupe"))
 733        return
 734
 735       if (self.QWParent.edit != "couper"):
 736         try:
 737            if noeudOuColler == self.tree.racine :
 738                child=noeudOuColler.doPastePremier(noeudACopier)
 739            else :
 740                child=noeudACopier.doPaste(noeudOuColler,pos)
 741            if child==None or child==0:
 742                QMessageBox.critical( self,tr( "Copie refusee"),tr('Eficas n a pas reussi a copier l objet'))
 743                self.message = ''
 744                self.affiche_infos("Copie refusee",Qt.red)
 745            if noeudACopier.treeParent.editor != noeudOuColler.treeParent.editor:
 746                try :
 747                  nom=noeudACopier.item.sd.nom
 748                  child.item.nomme_sd(nom)
 749                except :
 750                  pass
 751            return
 752            self.init_modif()
 753            child.select()
 754         except  :
 755            traceback.print_exc()
 756            QMessageBox.critical( self,tr( "Copie refusee"),tr('Copie refusee pour ce type d objet'))
 757            self.message = ''
 758            self.affiche_infos("Copie refusee",Qt.red)
 759            return
 760
 761       # il faut declarer le JDCDisplay_courant modifie
 762       # suppression eventuelle du noeud selectionne
 763       # si possible on renomme l objet comme le noeud couper
 764
 765       if (self.QWParent.edit == "couper"):
 766          if noeudACopier.treeParent.editor != noeudOuColler.treeParent.editor:
 767            QMessageBox.critical( self, tr("Deplacement refuse"),tr('Deplacement refuse entre 2 fichiers. Seule la copie est autorisee '))
 768
 769          #if 1:
 770          try :
 771            # indexNoeudACopier=noeudACopier.treeParent.children.index(noeudACopier)
 772             indexNoeudACopier=self.getTreeIndex(noeudACopier)
 773             noeudACopier.treeParent.item.deplaceEntite(indexNoeudACopier,indexNoeudOuColler,pos)
 774             noeudACopier.treeParent.build_children()
 775
 776          #else:
 777          except:
 778             pass
 779          self.QWParent.noeud_a_editer=[]
 780
 781       # on rend la copie a nouveau possible en liberant le flag edit
 782       self.QWParent.edit="copier"
 783       noeudACopier.select()
 784
 785     #----------------------------------#
 786     def handleDeplaceMultiple(self):
 787     #----------------------------------#
 788        pass
 789
 790     #----------------------------------#
 791     def handleEditPasteMultiple(self):
 792     #----------------------------------#
 793
 794     # On ne garde que les niveaux "Etape"
 795     # On insere dans l'ordre du JDC
 796      listeNoeudsACouper=[]
 797      listeIndex=[]
 798      listeChild=[]
 799      listeItem=[]
 800      from InterfaceQT4 import compojdc
 801      noeudOuColler=self.node_selected[0]
 802      if not (isinstance(noeudOuColler.treeParent, compojdc.Node)):
 803         QMessageBox.information( self,
 804                   tr("Copie impossible a cet endroit",),
 805                   tr("Veuillez selectionner une commande, un parametre, un commentaire ou une macro"))
 806         return
 807      indexNoeudOuColler=noeudOuColler.treeParent.children.index(noeudOuColler)
 808
 809      for noeud in self.QWParent.noeud_a_editer :
 810         if not (isinstance(noeud.treeParent, compojdc.Node)): continue
 811         indexInTree=noeud.treeParent.children.index(noeud)
 812         indice = 0
 813         for index in listeIndex:
 814             if index < indexInTree : indice = indice +1
 815         listeIndex.insert(indice, indexInTree)
 816         listeNoeudsACouper.insert(indice, noeud)
 817
 818      noeudJdc=noeudOuColler.treeParent
 819      dejaCrees=0
 820      # on les cree a l'envers parcequ'on ajoute a NoeudOuColler
 821      listeIndex.reverse()
 822      for index in listeIndex:
 823          indexTravail=index
 824          if indexNoeudOuColler < index:
 825             indexTravail=indexTravail+dejaCrees
 826          noeudOuColler=noeudJdc.children[indexNoeudOuColler]
 827          noeud=noeudJdc.children[indexTravail]
 828          child=noeud.doPaste(noeudOuColler)
 829          listeChild.append(child)
 830          dejaCrees=dejaCrees+1
 831
 832      self.QWParent.noeud_a_editer = []
 833      for i in range(len(listeIndex)):
 834         noeud=noeudJdc.children[indexNoeudOuColler+1+i]
 835         self.QWParent.noeud_a_editer.append(noeud)
 836
 837      listeASupprimer=[]
 838      if self.QWParent.edit !="couper" : return
 839
 840      for index in listeIndex:
 841          indexTravail=index
 842          if indexNoeudOuColler < index:
 843             indexTravail=indexTravail+(len(listeIndex))
 844          noeud=noeudJdc.children[indexTravail]
 845
 846          listeItem.append(noeud.item)
 847          listeASupprimer.append(noeud)
 848
 849      for i in range(len(listeChild)):
 850          self.tree.item.suppitem(listeItem[i])
 851          listeChild[i].item.update(listeItem[i])
 852
 853      self.QWParent.noeud_a_editer = []
 854
 855
 856     #---------------------#
 857     def getFileName(self):
 858     #---------------------#
 859       return self.fichier
 860
 861     #---------------------------#
 862     def get_file_variable(self) :
 863     #---------------------------#
 864      titre = tr("Choix d'un fichier XML")
 865      texte = tr("Le fichier contient une commande MODEL\n")
 866      texte = texte+tr('Donnez le nom du fichier XML qui contient la description des variables')
 867      QMessageBox.information( self, titre,tr(texte))
 868
 869      fichier = QFileDialog.getOpenFileName(self.appliEficas,
 870                    tr('Ouvrir Fichier'),
 871                    self.appliEficas.CONFIGURATION.savedir,
 872                    tr('Wrapper Files (*.xml);;''All Files (*)'))
 873      return  fichier
 874
 875     #--------------------------------------------------#
 876     def writeFile(self, fn, txt = None,formatLigne="beautifie"):
 877     #--------------------------------------------------#
 878         """
 879         Public slot to write the text to a file.
 880
 881         @param fn filename to write to string
 882         @return flag indicating success
 883         """
 884
 885         fn = six.text_type(fn)
 886
 887         if txt == None :
 888             txt = self.get_text_JDC(self.format,formatLigne=formatLigne)
 889             eol = '\n'
 890             if len(txt) >= len(eol):
 891                if txt[-len(eol):] != eol:
 892                   txt += eol
 893             else:
 894                 txt += eol
 895             txt=self.ajoutVersionCataDsJDC(txt)
 896             checksum=self.get_checksum(txt)
 897             txt=txt+checksum
 898         if self.code=="TELEMAC" : return 1
 899         try:
 900             f = open(fn, 'w')
 901             f.write(txt)
 902             f.close()
 903             return 1
 904         except IOError as why:
 905             if (self.appliEficas.ssIhm == False):
 906                 QMessageBox.critical(self, tr('Sauvegarde du Fichier'),
 907                 tr('Le fichier')+str(fn) + tr('n a pas pu etre sauvegarde : ') + str(why))
 908             else :
 909                 print (why)
 910             return 0
 911
 912     #-----------------------------------------------------------#
 913     def get_text_JDC(self,format,pourRun=0,formatLigne="beautifie"):
 914     #-----------------------------------------------------------#
 915       if self.code == "MAP" and not(format in generator.plugins): format = "MAP"
 916       if format in generator.plugins:
 917
 918          # Le generateur existe on l'utilise
 919          self.generator=generator.plugins[format]()
 920          try :
 921             jdc_formate=self.generator.gener(self.jdc,format=formatLigne,config=self.appliEficas.CONFIGURATION,appli=self.appliEficas)
 922             if pourRun : jdc_formate=self.generator.textePourRun
 923          except ValueError as e:
 924             QMessageBox.critical(self, tr("Erreur a la generation"),str(e))
 925             return
 926
 927          if not self.generator.cr.estvide():
 928             self.affiche_infos(tr("Erreur a la generation"),Qt.red)
 929             QMessageBox.critical( self, tr("Erreur a la generation"),tr("EFICAS ne sait pas convertir ce JDC"))
 930             return ""
 931          else:
 932             return jdc_formate
 933       else:
 934          # Il n'existe pas c'est une erreur
 935          self.affiche_infos(tr("Format %s non reconnu" , self.format),Qt.red)
 936          QMessageBox.critical( self, "Format  non reconnu" ,tr("EFICAS ne sait pas convertir le JDC selon le format "+ self.format))
 937          return ""
 938
 939     #----------------------#
 940     def get_Dico(self):
 941     #---------------------#
 942       if 'dicoImbrique' in generator.plugins:
 943          self.generator=generator.plugins['dicoImbrique']()
 944          jdc_formate=self.generator.gener(self.jdc)
 945          dico=self.generator.Dico
 946          return dico
 947       else :
 948          self.affiche_infos(tr("Format %s non reconnu" , self.format),Qt.red)
 949          QMessageBox.critical( self, "Format  non reconnu" ,tr("EFICAS ne sait pas convertir le JDC selon le format "+ self.format))
 950          return ""
 951
 952
 953     #------------#
 954     def run(self):
 955     #------------#
 956       fonction="run"+self.code
 957       #print fonction
 958       if fonction in JDCEditor.__dict__: JDCEditor.__dict__[fonction],(self,)
 959
 960     #------------#
 961     def saveRun(self):
 962     #------------#
 963       fonction="saveRun"+self.code
 964       if fonction in JDCEditor.__dict__: JDCEditor.__dict__[fonction],(self,)
 965
 966     #---------------#
 967     def runMAP(self):
 968     #---------------#
 969
 970       if not(self.jdc.isvalid()):
 971          QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution MAP"))
 972          return
 973       if len(self.jdc.etapes) != 1 :
 974          QMessageBox.critical( self, tr("Execution impossible "),tr("le JDC doit contenir un et un seul composant"))
 975          return
 976       if self.modified or self.fichier==None  :
 977          self.fichierMapInput = self.__generateTempFilename(prefix = "map_run", suffix = ".map")
 978          texte=self.get_text_JDC("MAP")
 979          self.writeFile( self.fichierMapInput, txt = texte)
 980       else :
 981          self.fichierMapInput=self.fichier
 982       composant=self.jdc.etapes[0].nom.lower()[0:-5]
 983
 984
 985       # :TRICKY: to determine if a component requires SALOME, loads the component from Eficas catalog
 986       # then instantiate corresponding class and call getUseSalome() method
 987       try:
 988           from mapengine.spec import factory
 989           mapComponent = factory.new(composant)[0]
 990
 991           command = "map"
 992           if mapComponent.getUseSalome():
 993               command += " -r sappli"
 994           textePython=(command + " run -n "+composant +" -i "+self.fichierMapInput)
 995
 996           #textePython="ls -l"
 997           self._viewTextExecute( textePython,"map_run",".sh")
 998           #try:
 999           #  commande="rm  "+self.fichierMapInput
1000           #   os.system(commande)
1001           #except :
1002           #   pass
1003       except Exception as e:
1004           print((traceback.print_exc()))
1005
1006     #-------------------#
1007     def runZCRACKS(self):
1008     #-------------------#
1009       if not(self.jdc.isvalid()):
1010          QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution "))
1011          return
1012       if self.modified or self.fichier==None  :
1013       #if 1:
1014          self.fichierZcracksInput = self.__generateTempFilename(prefix = "zcracks_run", suffix = ".z7p")
1015          texte=self.get_text_JDC("ZCRACKS",pourRun=1)
1016          self.writeFile( self.fichierZcracksInput, txt = texte)
1017       else :
1018          self.fichierZcracksInput=self.fichier
1019       try :
1020           #commande ="Zrun -zp "
1021           commande="more "
1022           textePython=(commande + self.fichierZcracksInput)
1023           self._viewTextExecute( textePython,"run_zcracks",".sh")
1024       except Exception as e:
1025           print((traceback.print_exc()))
1026
1027     #-------------------#
1028     def runCARMELCND(self):
1029     #-------------------#
1030       #if not(self.jdc.isvalid()):
1031       #   QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution "))
1032       #   return
1033       if self.modified or self.fichier==None  :
1034          QMessageBox.critical( self, tr( "Execution impossible "),tr("Sauvegarder SVP avant l'execution "))
1035          return
1036       if not hasattr(self,'generator'): texte=self.get_text_JDC(self.format)
1037       from PrepareRunCarmel import prepareRunCarmel
1038       fichierGenerique=os.path.basename(self.fichier).split(".")[0]
1039       repMed=os.path.dirname(self.fichier)
1040       repExeCarmel=self.generator.get_repExeCarmel()
1041       textePython=prepareRunCarmel(repExeCarmel,repMed,fichierGenerique)
1042       nomFichier = self.__generateTempFilename("carmel_run", suffix = ".sh")
1043       f=open(nomFichier,'w')
1044       f.write(textePython)
1045       f.close()
1046       commande="xterm -e sh "+nomFichier +"\n"
1047       os.system(commande)
1048
1049     #-------------------#
1050     def runCarmelCS(self):
1051     #-------------------#
1052       try :
1053           commande="runSession pilotyacsCS.py"
1054           os.system(commande)
1055       except Exception as e:
1056           print((traceback.print_exc()))
1057
1058     #-----------------------------------------------------#
1059     def determineNomFichier(self,path,extension):
1060     #-----------------------------------------------------#
1061       if self.appli.code in DictExtensions:
1062          chaine1="JDC (*"+DictExtensions[self.appli.code]+");;"
1063          extensions= tr(chaine1+ "All Files (*)")
1064       else :
1065          extensions= tr("JDC (*.comm);;" "All Files (*)")
1066
1067       if self.appli.code == "MAP" :
1068          extensions = extensions + ";; Run (*.input);;"
1069
1070       fn = QFileDialog.getSaveFileName( self,
1071              tr("sauvegarde"), path,
1072              extensions,None,
1073              QFileDialog.DontConfirmOverwrite)
1074       if fn == None : return (0, None)
1075       fn=fn[0]
1076       if fn=='': return (0, None)
1077
1078       ext = QFileInfo(fn).suffix()
1079       if ext == '': fn+=extension
1080
1081       if QFileInfo(fn).exists():
1082            msgBox = QMessageBox(self)
1083            msgBox.setWindowTitle(tr("Sauvegarde du Fichier"))
1084            msgBox.setText(tr("Le fichier <b>%s</b> existe deja.", six.text_type(fn)))
1085            msgBox.addButton(tr("&Ecraser"),0)
1086            msgBox.addButton(tr("&Abandonner"),1)
1087            abort=msgBox.exec_()
1088            if abort == 1 :  return (0, "")
1089       return (1,fn)
1090
1091     #-----------------#
1092     def saveRunMAP(self):
1093     #-----------------#
1094         extension=".input"
1095         if not(self.jdc.isvalid()):
1096            QMessageBox.critical( self, tr( "Sauvegarde de l'input impossible "),
1097                                 tr("Un JdC valide est necessaire pour creer un .input")
1098                                  )
1099            return
1100         try :
1101           composant=self.jdc.etapes[0].nom.lower()[0:-5]
1102         except :
1103            QMessageBox.critical( self, tr( "Sauvegarde de l'input impossible "),
1104                                 tr("Choix du composant obligatoire")
1105                                  )
1106            return
1107         if hasattr(self.CONFIGURATION, "savedir"): path=self.CONFIGURATION.savedir
1108         else : path='C:/'
1109
1110         monNomFichier=""
1111         if self.fichier is not None and self.fichier != "" :
1112              maBase=str(QFileInfo(self.fichier).baseName())+".input"
1113              monPath=str(QFileInfo(self.fichier).absolutePath())
1114              monNomFichier=os.path.join(monPath,maBase)
1115         elif hasattr(self,'monNomFichierInput'):
1116             monNomFichier=self.monNomFichierInput
1117
1118
1119         monDialog=QFileDialog(self.appliEficas)
1120         monDialog.setDirectory (path)
1121         monDialog.setWindowTitle ("Save")
1122
1123         for c in monDialog.children():
1124             if isinstance(c,QDialogButtonBox):
1125                for b in c.children():
1126                   if isinstance(b,QPushButton):
1127                      avant=b.text()
1128                      if avant=="&Open": b.setText("Save")
1129         mesFiltres= "input Map (*.input);;All Files (*)"
1130         monDialog.setNameFilters(mesFiltres)
1131         if monNomFichier!="" : monDialog.selectFile(monNomFichier)
1132         BOk=monDialog.exec_()
1133         if BOk==0: return
1134         fn=str(monDialog.selectedFiles()[0])
1135         if fn == "" or fn == None : return
1136         if not fn.endswith(".input"):
1137             fn += ".input"
1138         self.monNomFichierInput=fn
1139
1140         if not hasattr(self, 'fichierMapInput') or not self.fichierMapInput or not os.path.exists(self.fichierMapInput):
1141             self.fichierMapInput = self.__generateTempFilename(prefix = "map_run", suffix = ".map")
1142             texte=self.get_text_JDC("MAP")
1143             self.writeFile( self.fichierMapInput, txt = texte)
1144
1145         cmd = ("map gen -t dat -n " + composant + " -i " + self.fichierMapInput + " -o " + fn)
1146         p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE)
1147         (output, err) = p.communicate()
1148
1149
1150     #-----------------#
1151     def saveRunPSEN(self):
1152     #-----------------#
1153         #print ("saveRunPSEN")
1154         self.saveFile()
1155
1156
1157     #-----------------------------------------#
1158     def cherche_Groupes(self):
1159     #-----------------------------------------#
1160         listeMA,listeNO=self.get_text_JDC("GroupMA")
1161         return listeMA,listeNO
1162
1163     #-----------------------------------------#
1164     def cherche_Dico(self):
1165     #-----------------------------------------#
1166         dicoCourant={}
1167         format =  self.appliEficas.format_fichier
1168         if format in generator.plugins:
1169            # Le generateur existe on l'utilise
1170            self.generator=generator.plugins[format]()
1171            jdc_formate=self.generator.gener(self.jdc,format='beautifie',config=self.appliEficas.CONFIGURATION)
1172            dicoCourant=self.generator.dico
1173         return dicoCourant
1174
1175
1176
1177     #-----------------------------------------#
1178     def handleAjoutGroup(self,listeGroup):
1179     #-----------------------------------------#
1180         try :
1181         #if 1:
1182            from ajoutGroupe import handleAjoutGroupFiltre
1183            #print listeGroup
1184            handleAjoutGroupFiltre(self,listeGroup)
1185            #print "apres handleAjoutGroupFiltre"
1186         except :
1187         #else :
1188            pass
1189
1190     #-----------------------------------------------------------------#
1191     def saveFileLeger(self, path = None, saveas= 0,formatLigne="beautifie"):
1192     #-----------------------------------------------------------------#
1193         extension='.casR'
1194         fn = self.fichier
1195         #saveas=True # Pour forcer le nom
1196         self.generator=generator.plugins[self.format]()
1197         if self.fichier is None or saveas:
1198           if path is None: path=self.CONFIGURATION.savedir
1199           bOK, fn=self.determineNomFichier(path,extension)
1200           if bOK == 0 : return (0, None)
1201           if fn == None : return (0, None)
1202           if fn== '' : return (0, None)
1203
1204           ulfile = os.path.abspath(six.text_type(fn))
1205           self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
1206           fn = six.text_type(QDir.toNativeSeparators(fn))
1207
1208         self.fichier = os.path.splitext(fn)[0]+extension
1209
1210         if hasattr(self.generator, "writeLeger"):
1211             self.generator.writeLeger(self.fichier,self.jdc,config=self.appliEficas.CONFIGURATION,appli=self.appliEficas)
1212
1213         if self.salome : self.appliEficas.addJdcInSalome( self.fichier)
1214
1215         self.modified = 0
1216         nouveauTitre=self.titre+"              "+str(os.path.basename(self.fichier))
1217         self.appliEficas.setWindowTitle(nouveauTitre)
1218         return (1, self.fichier)
1219
1220     #-----------------------------------------------------------------#
1221     def saveFile(self, path = None, saveas= 0,formatLigne="beautifie"):
1222     #-----------------------------------------------------------------#
1223         """
1224         Public slot to save the text to a file.
1225
1226         @param path directory to save the file in (string or QString)
1227         @return tuple of two values (boolean, string) giving a success indicator and
1228             the name of the saved file
1229         """
1230
1231         print (self.generDico())
1232         self.modified=1
1233         if not self.modified and not saveas:
1234             return (0, None)      # do nothing if text wasn't changed
1235
1236         if self.appli.code in DictExtensions :
1237            extension=DictExtensions[self.appli.code]
1238         else :
1239            extension='.comm'
1240
1241         newName = None
1242         fn = self.fichier
1243         if self.fichier is None or saveas:
1244           if path is None: path=self.CONFIGURATION.savedir
1245           bOK, fn=self.determineNomFichier(path,extension)
1246           if bOK == 0 : return (0, None)
1247           if fn == None : return (0, None)
1248           if fn== '' : return (0, None)
1249
1250           ulfile = os.path.abspath(six.text_type(fn))
1251           self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
1252           fn = six.text_type(QDir.toNativeSeparators(fn))
1253           newName = fn
1254
1255
1256         if not (self.writeFile(fn,formatLigne=formatLigne)): return (0, None)
1257         self.fichier = fn
1258         self.modified  = False
1259         if self.fileInfo is None or saveas:
1260            self.fileInfo = QFileInfo(self.fichier)
1261            self.fileInfo.setCaching(0)
1262         self.lastModified = self.fileInfo.lastModified()
1263         if newName is not None:
1264            self.appliEficas.addToRecentList(newName)
1265            self.tree.racine.item.getObject().nom=os.path.basename(newName)
1266            self.tree.racine.update_node_label()
1267
1268         if self.jdc.isvalid() != 0 and hasattr(self.generator, "writeDefault"):
1269             self.generator.writeDefault(fn)
1270         elif self.code=="TELEMAC" and hasattr(self.generator, "writeDefault"):
1271             self.generator.writeDefault(fn)
1272
1273         if self.salome :
1274                self.appliEficas.addJdcInSalome( self.fichier)
1275         self.modified = 0
1276         nouveauTitre=self.titre+"              "+str(os.path.basename(self.fichier))
1277         self.appliEficas.setWindowTitle(nouveauTitre)
1278
1279         return (1, self.fichier)
1280 #
1281
1282     #----------------------------------------------#
1283     def sauveLigneFile(self):
1284     #----------------------------------------------#
1285         self.modified=1
1286         return self.saveFile(formatLigne="Ligne")
1287
1288
1289     #----------------------------------------------#
1290     def saveFileAs(self, path = None,fileName=None):
1291     #----------------------------------------------#
1292         """
1293         Public slot to save a file with a new name.
1294
1295         @param path directory to save the file in (string or QString)
1296         @return tuple of two values (boolean, string) giving a success indicator and
1297             the name of the saved file
1298         """
1299         if fileName != None :
1300            self.fichier = fileName
1301            return self.saveFile()
1302         return self.saveFile(path,1,"beautifie")
1303
1304
1305
1306     #---------------------------------------------#
1307     def get_file(self,unite=None,fic_origine = ''):
1308     #---------------------------------------------#
1309     # appele par I_JDC
1310         ulfile  = None
1311         jdcText = ""
1312
1313         titre  = ""
1314
1315         if unite :
1316             titre = tr("Choix unite %d ", unite)
1317             texte = tr("Le fichier %s contient une commande INCLUDE \n",  str(fic_origine)) +"\n"
1318             texte = texte+ tr("Donnez le nom du fichier correspondant a l unite logique ") + repr(unite)
1319             labeltexte = tr('Fichier pour unite ') + repr( unite)
1320         else:
1321             titre = tr("Choix d'un fichier de poursuite")
1322             texte = tr("Le fichier %s contient une commande POURSUITE\n", fic_origine)
1323             texte = texte+tr('Donnez le nom du fichier dont vous \n voulez faire une poursuite')
1324
1325         QMessageBox.information( self, titre,texte)
1326         fn = QFileDialog.getOpenFileName(self.appliEficas,
1327                    titre,
1328                    self.appliEficas.CONFIGURATION.savedir)
1329
1330         # ce retour est impose par le get_file d'I_JDC
1331         if fn== '' : return None," "
1332         if not fn : return (0, " ")
1333         fn=fn[0]
1334
1335         ulfile = os.path.abspath(six.text_type(fn))
1336         self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
1337
1338         # On utilise le convertisseur defini par format_fichier
1339         source=self.get_source(ulfile)
1340         if source:
1341             # On a reussia convertir le fichier self.ulfile
1342             jdcText = source
1343         else:
1344             # Une erreur a ete rencontree
1345             jdcText = ''
1346         return ulfile, jdcText
1347
1348     #-------------------------------#
1349     def updateJdc(self, itemApres,texte):
1350     #--------------------------------#
1351         monItem=itemApres
1352         etape=monItem.item.object
1353
1354         CONTEXT.set_current_step(etape)
1355         etape.build_includeInclude(texte)
1356         self.tree.racine.build_children()
1357
1358     #-------------------------------------#
1359     def deleteEtape(self,etape):
1360     #-------------------------------------#
1361         self.jdc.suppentite(etape)
1362
1363     #-------------------------------------#
1364     def deleteMC(self,etape,MCFils,listeAvant=()):
1365     #-------------------------------------#
1366         ouChercher=etape
1367         for mot in listeAvant :
1368               ouChercher=ouChercher.get_child(mot,restreint="oui")
1369         monMC=ouChercher.get_child(MCFils,restreint="oui")
1370         if monMC != None :  ouChercher.suppentite(monMC)
1371         ouChercher.state='changed'
1372         ouChercher.isvalid()
1373
1374     #-------------------------------------#
1375     def ajoutMC(self,etape,MCFils,valeurs,listeAvant=()):
1376     #-------------------------------------#
1377         ouChercher=etape
1378         for mot in listeAvant :
1379               ouChercher=ouChercher.get_child(mot,restreint="oui")
1380         monMC=etape.get_child(ouChercher,restreint="oui")
1381         if monMC== None : monMC= ouChercher.addentite(MCFils)
1382         monMC.valeur=valeurs
1383         monMC.val=valeurs
1384         monMC.state='changed'
1385         monMC.isvalid()
1386
1387     #-----------------------------------------------------------#
1388     def changeIntoMC(self,etape,MCFils,valeurs, listeAvant=()):
1389     #-----------------------------------------------------------#
1390         ouChercher=etape
1391         for mot in listeAvant :
1392               ouChercher=ouChercher.get_child(mot,restreint="oui")
1393         if ouChercher ==None : print ('SOUCI'); return
1394         monMC=ouChercher.get_child(MCFils,restreint="oui")
1395         if monMC== None : monMC= ouChercher.addentite(MCFils)
1396         monMC.definition.into=valeurs
1397         monMC.state='changed'
1398         monMC.isvalid()
1399
1400     #-------------------------------------#
1401     def changeIntoDefMC(self,etape,listeMC,valeurs):
1402     #-------------------------------------#
1403         definitionEtape=getattr(self.jdc.cata[0],etape)
1404         ouChercher=definitionEtape
1405         if len(listeMC) > 1 :
1406            for mc in listeMC[0:-1]:
1407              mcfact=ouChercher.entites[mc]
1408              ouChercher=mcfact
1409
1410         mcAccas=ouChercher.entites[listeMC[-1]]
1411         mcAccas.into=valeurs
1412
1413     #-------------------------------------------------------------#
1414     def deleteDefinitionMC(self,etape,listeAvant,nomDuMC):
1415     #-------------------------------------------------------------#
1416         #print 'in deleteDefinitionMC', etape,listeAvant,nomDuMC
1417         definitionEtape=getattr(self.jdc.cata[0],etape)
1418         ouChercher=definitionEtape
1419         for k in listeAvant :
1420             ouChercher=ouChercher.entites[k]
1421         MCADetruire=ouChercher.entites[nomDuMC]
1422         ouChercher.ordre_mc.remove(nomDuMC)
1423         del ouChercher.entites[nomDuMC]
1424         del self.dicoNouveauxMC[nomDuMC]
1425
1426
1427     #-------------------------------------------------------------#
1428     def ajoutDefinitionMC(self,etape,listeAvant,nomDuMC,typ,**args):
1429     #-------------------------------------------------------------#
1430         definitionEtape=getattr(self.jdc.cata[0],etape)
1431         ouChercher=definitionEtape
1432         for k in listeAvant :
1433             ouChercher=ouChercher.entites[k]
1434         from Accas import A_SIMP
1435         Nouveau=A_SIMP.SIMP(typ,**args)
1436         Nouveau.pere=ouChercher
1437         Nouveau.nom=nomDuMC
1438         Nouveau.ordre_mc=[]
1439         ouChercher.entites[nomDuMC]=Nouveau
1440         ouChercher.ordre_mc.append(nomDuMC)
1441         self.dicoNouveauxMC[nomDuMC]=('ajoutDefinitionMC',etape,listeAvant,nomDuMC,typ,args)
1442         #print self.dicoNouveauxMC
1443
1444     #----------------------------------------------------#
1445     def changeIntoMCandSet(self,etape,MCFils,into,valeurs):
1446     #----------------------------------------------------#
1447         monMC=etape.get_child(MCFils,restreint="oui")
1448         if monMC== None : monMC= etape.addentite(MCFils)
1449         monMC.definition.into=into
1450         monMC.valeur=valeurs
1451         monMC.val=valeurs
1452         monMC.state='changed'
1453         monMC.isvalid()
1454
1455     #-------------------------------------#
1456     def ajoutVersionCataDsJDC(self,txt):
1457     #-------------------------------------#
1458         if not hasattr(self.readercata.cata[0],'VERSION_CATALOGUE'): return txt
1459         ligneVersion="#VERSION_CATALOGUE:"+self.readercata.cata[0].VERSION_CATALOGUE+":FIN VERSION_CATALOGUE\n"
1460         texte=txt+ligneVersion
1461         return texte
1462
1463     #-------------------------------------#
1464     def verifieVersionCataDuJDC(self,text):
1465     #-------------------------------------#
1466         memeVersion=False
1467         indexDeb=text.find("#VERSION_CATALOGUE:")
1468         indexFin=text.find(":FIN VERSION_CATALOGUE")
1469         if indexDeb < 0 :
1470            self.versionCataDuJDC="sans"
1471            textJDC=text
1472         else :
1473            self.versionCataDuJDC=text[indexDeb+19:indexFin]
1474            textJDC=text[0:indexDeb]+text[indexFin+23:-1]
1475
1476         self.versionCata="sans"
1477         if hasattr(self.readercata.cata[0],'VERSION_CATALOGUE'): self.versionCata=self.readercata.cata[0].VERSION_CATALOGUE
1478
1479         if self.versionCata==self.versionCataDuJDC : memeVersion=True
1480         return memeVersion,textJDC
1481
1482     #-------------------------------#
1483     def traduitCatalogue(self,texte):
1484     #-------------------------------#
1485         nomTraducteur="traduit"+self.readercata.code+self.versionCataDuJDC+"To"+self.versionCata
1486         sys.path.append(os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)),"../Traducteur")))
1487         try :
1488             traducteur=__import__(nomTraducteur)
1489             monTraducteur=traducteur.MonTraducteur(texte)
1490             nouveauTexte=monTraducteur.traduit()
1491             return nouveauTexte
1492         except :
1493             return texte
1494
1495
1496     #------------------------------#
1497     def verifieCHECKSUM(self,text):
1498     #------------------------------#
1499         indexDeb=text.find("#CHECKSUM:")
1500         if indexDeb < 0 :
1501            return 1, text
1502         indexFin=text.find(":FIN CHECKSUM")
1503         checkAvant=text[indexDeb:indexFin+13]
1504         textJDC=text[0:indexDeb]+text[indexFin+13:-1]
1505         checksum=self.get_checksum(textJDC)
1506         pareil=(checkAvant==checksum)
1507         return pareil, textJDC
1508
1509     #---------------------------#
1510     def get_checksum(self,texte):
1511     #---------------------------#
1512         newtexte=texte.replace('"','\\"')
1513         commande='echo "'+newtexte+'"|md5sum'
1514         a=os.popen(commande)
1515         checksum=a.read()
1516         a.close()
1517         ligne="#CHECKSUM:"+checksum[0:-1]+":FIN CHECKSUM"
1518         return ligne
1519
1520
1521     #---------------------------#
1522     def _new_CF(self):
1523     #---------------------------#
1524         texte="CONDUITE_FORCEE();"
1525         return texte
1526
1527
1528     #---------------------------#
1529     def _newTELEMAC(self):
1530     #---------------------------#
1531         #texte="INITIALIZATION();BOUNDARY_CONDITIONS();GENERAL_PARAMETERS();PHYSICAL_PARAMETERS();NUMERICAL_PARAMETERS();"
1532         texte="COMPUTATION_ENVIRONMENT();HYDRO();GENERAL_PARAMETERS();NUMERICAL_PARAMETERS()"
1533         #texte="TRACERS();"
1534         return texte
1535
1536     #---------------------------#
1537     def _newPSEN(self):
1538     #---------------------------#
1539         texte="DIRECTORY() ; PSSE_PARAMETERS() ; SIMULATION() ; sansnom=DISTRIBUTION() ; sansnom=DISTRIBUTION() ; CORRELATION() ;"
1540         #texte=""
1541         return texte
1542
1543     #---------------------------#
1544     def _newPSEN_N1(self):
1545     #---------------------------#
1546         texte="CASE_SELECTION();N_PROCESSING_OPTIONS();CONTINGENCY_OPTIONS();CONTINGENCY_SELECTION();\nCONTINGENCY_PROCESSING(); "
1547         texte="CONTINGENCY_SELECTION();\nCONTINGENCY_PROCESSING(); "
1548         return texte
1549
1550     #---------------------------#
1551
1552     #---------------------------#
1553     def _newZCRACKS(self):
1554     #---------------------------#
1555         texte="MAILLAGES();REMESHING();"
1556         return texte
1557
1558     #---------------------------#
1559     def _newJDCCND(self):
1560     #---------------------------#
1561       extensions=tr('Fichiers Med (*.med);;''Tous les Fichiers (*)')
1562
1563       #if self.salome == 0 :
1564       QMessageBox.information( self,
1565                       tr("Fichier Med"),
1566                       tr("Veuillez selectionner un fichier Med"))
1567       QSfichier = QFileDialog.getOpenFileName(self.appliEficas,
1568                         caption='Fichier Med',
1569                         filter=extensions)
1570       QSfichier=QSfichier[0]
1571       self.fichierMED=QSfichier
1572       from acquiertGroupes import getGroupes
1573       erreur,self.listeGroupes,self.nomMaillage,self.dicoCoord=getGroupes(self.fichierMED)
1574       if erreur != "" : print ("a traiter")
1575       texteComm="COMMENTAIRE(u'Cree - fichier : "+self.fichierMED +" - Nom Maillage : "+self.nomMaillage+"');\nPARAMETRES()\n"
1576       texteSources=""
1577       texteCond=""
1578       texteNoCond=""
1579       texteVcut=""
1580       texteZs=""
1581       for groupe in self.listeGroupes :
1582           if groupe[0:8]=='CURRENT_':
1583              texteSources +=groupe[8:]+"=SOURCE("
1584              texteSources +="VecteurDirecteur=(1.0,2.0,3.0,),);\n"
1585           if groupe[0:5]=='COND_':    texteCond    +=groupe[5:]+"=CONDUCTEUR();\n"
1586           if groupe[0:7]=='NOCOND_':  texteNoCond  +=groupe[7:]+"=NOCOND();\n"
1587           if groupe[0:5]=='VCUT_':    texteVcut    +='V_'+groupe[5:]+"=VCUT();\n"
1588           if groupe[0:3]=='ZS_':      texteZs      +=groupe[3:]+"=ZS();\n"
1589       texte=texteComm+texteSources+texteCond+texteNoCond+texteVcut+texteZs
1590       self.newTexteCND=texte
1591       self.modified=1
1592       return texte
1593
1594
1595     #---------------------------#
1596     def  BoutonFileSelected(self):
1597     #---------------------------#
1598
1599       QSfichier=self.openfile.selectedFiles()[0]
1600       self.fichierMED=str(QSfichier)
1601       from acquiertGroupes import getGroupes
1602       erreur,self.listeGroupes,self.nomMaillage=getGroupes(self.fichierMED)
1603       if erreur != "" : print ("a traiter")
1604
1605     #-----------------------------
1606     def BoutonSalomePressed(self):
1607     #----------------------------
1608       Msg,self.listeGroupes=self.appliEficas.ChercheGrpMailleInSalome()
1609       self.fichierMED="A_partir_de_SMESH"
1610       self.nomMaillage="A_partir_de_SMESH"
1611       self.openfile.close()
1612
1613
1614     #-----------------------------------------
1615     def initSplitterSizes(self, nbWidget=3):
1616     #-----------------------------------------
1617        #print ("je passe ds initSplitterSizes", nbWidget)
1618
1619        if   self.code in [ 'Adao', 'ADAO', ] : self.splitterSizes3=[1,1550,150]
1620        elif self.code in [ 'MAP']            : self.splitterSizes3=[700,300]
1621        else                                  : self.splitterSizes3=[150,1000,300]
1622
1623        if   self.code in [ 'Adao', 'ADAO', ] : self.splitterSizes2=[5,1500]
1624        else                                  : self.splitterSizes2=[300,1000]
1625
1626
1627
1628     #-----------------------------------------
1629     def restoreSplitterSizes(self,nbWidget=3):
1630     #----------------------------------------
1631
1632       #traceback.print_stack()
1633       #print ("je passe ds restoreSplitterSizes")
1634       if not(hasattr(self,'splitter')) : return
1635       if nbWidget==2  : newSizes=self.splitterSizes2
1636       if nbWidget==3  : newSizes=self.splitterSizes3
1637       #self.inhibeSplitter = 1
1638       self.splitter.setSizes(newSizes)
1639       #self.inhibeSplitter = 0
1640       QApplication.processEvents()
1641       # seule la fentetre du milieu est necessaire
1642       self.splitter.widget(1).resizeEvent=self.saveSplitterSizes
1643
1644     #-----------------------------------------
1645     def saveSplitterSizes(self,event):
1646     #-----------------------------------------
1647       #print ("je passe ds saveSplitterSizes")
1648       if self.inhibeSplitter : return
1649       if self.widgetOptionnel == None  : self.splitterSizes2 = self.splitter.sizes()[0:2]
1650       else                             : self.splitterSizes3 = self.splitter.sizes()[0:3]
1651
1652     #------------------------
1653     def fermeOptionnel(self):
1654     #------------------------
1655       if self.widgetOptionnel == None : return
1656
1657       self.inhibeSplitter=1
1658       self.widgetOptionnel.setParent(None)
1659       self.widgetOptionnel.close()
1660       self.widgetOptionnel.deleteLater()
1661       self.widgetOptionnel=None
1662       self.inhibeSplitter=0
1663       self.restoreSplitterSizes(2)
1664
1665     #------------------------
1666     def ajoutOptionnel(self):
1667     #------------------------
1668       #if len(self.splitterSizes) == 2 : self.splitterSizes.append(self.oldSizeWidgetOptionnel)
1669       #else : self.splitterSizes[2] = self.oldSizeWidgetOptionnel # ceinture pour les close bizarres
1670       #self.splitterSizes[1] = self.splitterSizes[1] - self.splitterSizes[2]
1671
1672       self.restoreSplitterSizes(3)
1673
1674
1675     #------------------------
1676     def fermeArbre(self):
1677     #------------------------
1678        #print (self.widgetTree)
1679        self.oldWidgetTree=self.widgetTree
1680        self.widgetTree.hide()
1681        #self.widgetTree=None
1682
1683     #------------------------
1684     def ouvreArbre(self):
1685     #------------------------
1686        #print ('je passe la')
1687        #print (self.widgetTree)
1688        #self.widgetTree=self.oldWidgetTree
1689        self.widgetTree.show()
1690        #self.restoreSplitterSizes(3)
1691
1692     #-----------------------------
1693     def getTreeIndex(self,noeud):
1694     #----------------------------
1695       indexNoeud=-1
1696       if noeud in noeud.treeParent.children :
1697           indexNoeud=noeud.treeParent.children.index(noeud)
1698       else :
1699           if hasattr(noeud,'vraiParent') :
1700               noeudVrai = noeud
1701               noeudVraiParent = noeud.vraiParent
1702               while noeudVraiParent != noeud.treeParent and hasattr(noeudVraiParent,'vraiParent') :
1703                   noeudVrai = noeudVraiParent
1704                   noeudVraiParent = noeudVraiParent.vraiParent
1705                   pass
1706               if noeudVraiParent == noeud.treeParent :
1707                   indexNoeud=noeud.treeParent.children.index(noeudVrai)
1708                   pass
1709               pass
1710           pass
1711       return indexNoeud
1712
1713 if __name__ == "__main__":
1714     self.code='ASTER'
1715     name='prefs_'+prefs.code
1716     prefsCode=__import__(name)
1717
1718
1719     if hasattr(prefsCode,'encoding'):
1720        # Hack pour changer le codage par defaut des strings
1721        import sys
1722        reload(sys)
1723        sys.setdefaultencoding(prefs.encoding)
1724        del sys.setdefaultencoding
1725        # Fin hack
1726
1727 #    code=options.code
1728 #
1729     app = QApplication(sys.argv)
1730     mw = JDCEditor(None,'azAster.comm')
1731     app.setMainWidget(mw)
1732     app.connect(app, SIGNAL("lastWindowClosed()"), app, SLOT("quit()"))
1733     mw.show()
1734
1735     res = app.exec_loop()
1736     sys.exit(res)