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