VirtualPolymer/editor.py.ssVP

   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 saveFileLeger(self, path = None, saveas= 0,formatLigne="beautifie"):
1209     #-----------------------------------------------------------------#
1210         extension='.casR'
1211         fn = self.fichier
1212         #saveas=True # Pour forcer le nom
1213         self.generator=generator.plugins[self.format]()
1214         if self.fichier is None or saveas:
1215           if path is None: path=self.CONFIGURATION.savedir
1216           bOK, fn=self.determineNomFichier(path,extension)
1217           if bOK == 0 : return (0, None)
1218           if fn == None : return (0, None)
1219           if fn== '' : return (0, None)
1220
1221           ulfile = os.path.abspath(six.text_type(fn))
1222           self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
1223           fn = six.text_type(QDir.toNativeSeparators(fn))
1224
1225         self.fichier = os.path.splitext(fn)[0]+extension
1226
1227         if hasattr(self.generator, "writeLeger"):
1228             self.generator.writeLeger(self.fichier,self.jdc,config=self.appliEficas.CONFIGURATION,appli=self.appliEficas)
1229
1230         if self.salome : self.appliEficas.addJdcInSalome( self.fichier)
1231
1232         self.modified = 0
1233         nouveauTitre=self.titre+"              "+str(os.path.basename(self.fichier))
1234         self.appliEficas.setWindowTitle(nouveauTitre)
1235         return (1, self.fichier)
1236
1237     #-----------------------------------------------------------------#
1238     def saveFile(self, path = None, saveas= 0,formatLigne="beautifie"):
1239     #-----------------------------------------------------------------#
1240         """
1241         Public slot to save the text to a file.
1242
1243         @param path directory to save the file in (string or QString)
1244         @return tuple of two values (boolean, string) giving a success indicator and
1245             the name of the saved file
1246         """
1247
1248         self.modified=1
1249         if not self.modified and not saveas:
1250             return (0, None)      # do nothing if text wasn't changed
1251
1252         if self.appli.code in DictExtensions :
1253            extension=DictExtensions[self.appli.code]
1254         else :
1255            extension='.comm'
1256
1257         newName = None
1258         fn = self.fichier
1259         if self.fichier is None or saveas:
1260           if path is None: path=self.CONFIGURATION.savedir
1261           bOK, fn=self.determineNomFichier(path,extension)
1262           if bOK == 0 : return (0, None)
1263           if fn == None : return (0, None)
1264           if fn== '' : return (0, None)
1265
1266           ulfile = os.path.abspath(six.text_type(fn))
1267           self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
1268           fn = six.text_type(QDir.toNativeSeparators(fn))
1269           newName = fn
1270
1271
1272         if not (self.writeFile(fn,formatLigne=formatLigne)): return (0, None)
1273         self.fichier = fn
1274         self.modified  = False
1275         if self.fileInfo is None or saveas:
1276            self.fileInfo = QFileInfo(self.fichier)
1277            self.fileInfo.setCaching(0)
1278         self.lastModified = self.fileInfo.lastModified()
1279         if newName is not None:
1280            self.appliEficas.addToRecentList(newName)
1281            self.tree.racine.item.getObject().nom=os.path.basename(newName)
1282            self.tree.racine.update_node_label()
1283
1284         if self.jdc.isvalid() != 0 and hasattr(self.generator, "writeDefault"):
1285             self.generator.writeDefault(fn)
1286         elif self.code=="TELEMAC" and hasattr(self.generator, "writeDefault"):
1287             self.generator.writeDefault(fn)
1288
1289         if self.salome :
1290                self.appliEficas.addJdcInSalome( self.fichier)
1291         self.modified = 0
1292         nouveauTitre=self.titre+"              "+str(os.path.basename(self.fichier))
1293         self.appliEficas.setWindowTitle(nouveauTitre)
1294
1295         return (1, self.fichier)
1296 #
1297
1298     #----------------------------------------------#
1299     def sauveLigneFile(self):
1300     #----------------------------------------------#
1301         self.modified=1
1302         return self.saveFile(formatLigne="Ligne")
1303
1304
1305     #----------------------------------------------#
1306     def saveFileAs(self, path = None,fileName=None):
1307     #----------------------------------------------#
1308         """
1309         Public slot to save a file with a new name.
1310
1311         @param path directory to save the file in (string or QString)
1312         @return tuple of two values (boolean, string) giving a success indicator and
1313             the name of the saved file
1314         """
1315         if fileName != None :
1316            self.fichier = fileName
1317            return self.saveFile()
1318         return self.saveFile(path,1,"beautifie")
1319
1320
1321
1322     #---------------------------------------------#
1323     def get_file(self,unite=None,fic_origine = ''):
1324     #---------------------------------------------#
1325     # appele par I_JDC
1326         ulfile  = None
1327         jdcText = ""
1328
1329         titre  = ""
1330
1331         if unite :
1332             titre = tr("Choix unite %d ", unite)
1333             texte = tr("Le fichier %s contient une commande INCLUDE \n",  str(fic_origine)) +"\n"
1334             texte = texte+ tr("Donnez le nom du fichier correspondant a l unite logique ") + repr(unite)
1335             labeltexte = tr('Fichier pour unite ') + repr( unite)
1336         else:
1337             titre = tr("Choix d'un fichier de poursuite")
1338             texte = tr("Le fichier %s contient une commande POURSUITE\n", fic_origine)
1339             texte = texte+tr('Donnez le nom du fichier dont vous \n voulez faire une poursuite')
1340
1341         QMessageBox.information( self, titre,texte)
1342         fn = QFileDialog.getOpenFileName(self.appliEficas,
1343                    titre,
1344                    self.appliEficas.CONFIGURATION.savedir)
1345
1346         # ce retour est impose par le get_file d'I_JDC
1347         if fn== '' : return None," "
1348         if not fn : return (0, " ")
1349         fn=fn[0]
1350
1351         ulfile = os.path.abspath(six.text_type(fn))
1352         self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
1353
1354         # On utilise le convertisseur defini par format_fichier
1355         source=self.get_source(ulfile)
1356         if source:
1357             # On a reussia convertir le fichier self.ulfile
1358             jdcText = source
1359         else:
1360             # Une erreur a ete rencontree
1361             jdcText = ''
1362         return ulfile, jdcText
1363
1364     #-------------------------------#
1365     def updateJdc(self, itemApres,texte):
1366     #--------------------------------#
1367         monItem=itemApres
1368         etape=monItem.item.object
1369
1370         CONTEXT.set_current_step(etape)
1371         etape.build_includeInclude(texte)
1372         self.tree.racine.build_children()
1373
1374     #-------------------------------------#
1375     def deleteEtape(self,etape):
1376     #-------------------------------------#
1377         self.jdc.suppentite(etape)
1378
1379     #-------------------------------------#
1380     def deleteMC(self,etape,MCFils,listeAvant=()):
1381     #-------------------------------------#
1382         ouChercher=etape
1383         for mot in listeAvant :
1384               ouChercher=ouChercher.get_child(mot,restreint="oui")
1385         monMC=ouChercher.get_child(MCFils,restreint="oui")
1386         if monMC != None :  ouChercher.suppentite(monMC)
1387         ouChercher.state='changed'
1388         ouChercher.isvalid()
1389
1390     #-------------------------------------#
1391     def ajoutMC(self,etape,MCFils,valeurs,listeAvant=()):
1392     #-------------------------------------#
1393         ouChercher=etape
1394         for mot in listeAvant :
1395               ouChercher=ouChercher.get_child(mot,restreint="oui")
1396         monMC=etape.get_child(ouChercher,restreint="oui")
1397         if monMC== None : monMC= ouChercher.addentite(MCFils)
1398         monMC.valeur=valeurs
1399         monMC.val=valeurs
1400         monMC.state='changed'
1401         monMC.isvalid()
1402
1403     #-------------------------------------#
1404     def getValeur(self,nomEtape,MCFils,listeAvant=()):
1405     #-------------------------------------#
1406
1407         ouChercher=None
1408         for e in self.jdc.etapes:
1409             if e.nom == nomEtape : ouChercher=e; break
1410         if ouChercher==None : return None
1411         for mot in listeAvant :
1412               ouChercher=ouChercher.get_child(mot,restreint="oui")
1413               if ouChercher==None : return None
1414         monMC=ouChercher.get_child(MCFils,restreint="oui")
1415         if monMC== None : return None
1416         return monMC.valeur
1417
1418     #-----------------------------------------------------------#
1419     def changeIntoMC(self,etape,MCFils,valeurs, listeAvant=()):
1420     #-----------------------------------------------------------#
1421         ouChercher=etape
1422         if isinstance (etape, str):
1423            ouChercher=None
1424            for e in self.jdc.etapes:
1425               if e.nom == etape : ouChercher=e; break
1426         if ouChercher==None : return
1427
1428         for mot in listeAvant :
1429               ouChercher=ouChercher.get_child(mot,restreint="oui")
1430               if ouChercher==None : return
1431         monMC=ouChercher.get_child(MCFils,restreint="oui")
1432         if monMC== None : monMC= ouChercher.addentite(MCFils)
1433
1434         monMC.definition.into=valeurs
1435         from Noyau.N_VALIDATOR import  IntoProtocol
1436         monMC.definition.intoProto = IntoProtocol("into", into=monMC.definition.into, val_min=monMC.definition.val_min, val_max=monMC.definition.val_max)
1437         monMC.state='changed'
1438         monMC.isvalid()
1439
1440     #-------------------------------------------------------------------#
1441     def reCalculeValiditeMCApresChgtInto(self,nomEtape,MCFils,listeAvant=()):
1442     #-------------------------------------------------------------------#
1443         for e in self.jdc.etapes:
1444             if e.nom == nomEtape : ouChercher=e; break
1445
1446         for mot in listeAvant :
1447             try :
1448               ouChercher=ouChercher.get_child(mot,restreint="oui")
1449             # Le mot clef n est pas la
1450             except : return 0
1451         try :
1452            monMC=ouChercher.get_child(MCFils,restreint="oui")
1453         # Le mot clef n est pas la
1454         except : return 0
1455         if monMC == None : return 0
1456
1457         if hasattr(monMC.definition,'into') :
1458            if type(monMC.definition.into) ==types.FunctionType : maListeDeValeur=monMC.definition.into()
1459            else : maListeDeValeur=monMC.definition.into
1460         else :
1461            return 0
1462
1463         monMC.state='changed'
1464         return 1
1465
1466     #-------------------------------------#
1467     def changeDefautDefMC(self,nomEtape,listeMC,valeurs):
1468     #-------------------------------------#
1469
1470         #if isinstance (etape, str):
1471         #  for e in self.jdc.etapes:
1472         #    if e.nom == etape : etape=e; break
1473         #if etape == None : return
1474         definitionEtape=getattr(self.jdc.cata[0],nomEtape)
1475         ouChercher=definitionEtape
1476         if len(listeMC) > 1 :
1477
1478            for mc in listeMC[0:-1]:
1479              mcfact=ouChercher.entites[mc]
1480              ouChercher=mcfact
1481
1482         mcAccas=ouChercher.entites[listeMC[-1]]
1483         mcAccas.defaut=valeurs
1484         return 1
1485
1486     #------------------------------------------------#
1487     def changeIntoDefMC(self,nomEtape,listeMC,valeurs):
1488     #------------------------------------------------#
1489         definitionEtape=getattr(self.jdc.cata[0],nomEtape)
1490         ouChercher=definitionEtape
1491
1492         if len(listeMC) > 1 :
1493            for mc in listeMC[0:-1]:
1494              mcfact=ouChercher.entites[mc]
1495              ouChercher=mcfact
1496         mcAccas=ouChercher.entites[listeMC[-1]]
1497
1498         if hasattr(mcAccas,'into') : oldValeurs=mcAccas.into
1499         else : oldValeurs=None
1500         if oldValeurs==valeurs : return 0
1501
1502         mcAccas.into=valeurs
1503         from Noyau.N_VALIDATOR import  IntoProtocol
1504         mcAccas.intoProto = IntoProtocol("into", into=valeurs, val_min=mcAccas.val_min, val_max=mcAccas.val_max)
1505         return 1
1506
1507     #-------------------------------------------------------------#
1508     def deleteDefinitionMC(self,etape,listeAvant,nomDuMC):
1509     #-------------------------------------------------------------#
1510         #print 'in deleteDefinitionMC', etape,listeAvant,nomDuMC
1511         if isinstance (etape, str):
1512           for e in self.jdc.etapes:
1513             if e.nom == etape : etape=e; break
1514         if etape == None : return
1515         definitionEtape=getattr(self.jdc.cata[0],etape)
1516         ouChercher=definitionEtape
1517         for k in listeAvant :
1518             ouChercher=ouChercher.entites[k]
1519         MCADetruire=ouChercher.entites[nomDuMC]
1520         ouChercher.ordre_mc.remove(nomDuMC)
1521         del ouChercher.entites[nomDuMC]
1522         del self.dicoNouveauxMC[nomDuMC]
1523
1524
1525     #-------------------------------------------------------------#
1526     def ajoutDefinitionMC(self,nomEtape,listeAvant,nomDuMC,typ,**args):
1527     #-------------------------------------------------------------#
1528         definitionEtape=getattr(self.jdc.cata[0],nomEtape)
1529         ouChercher=definitionEtape
1530         for k in listeAvant :
1531             ouChercher=ouChercher.entites[k]
1532         from Accas import A_SIMP
1533         Nouveau=A_SIMP.SIMP(typ,**args)
1534         Nouveau.pere=ouChercher
1535         Nouveau.nom=nomDuMC
1536         #Nouveau.ordre_mc=[]
1537         ouChercher.entites[nomDuMC]=Nouveau
1538         ouChercher.ordre_mc.append(nomDuMC)
1539         self.dicoNouveauxMC[nomDuMC]=('ajoutDefinitionMC',nomEtape,listeAvant,nomDuMC,typ,args)
1540         #print self.dicoNouveauxMC
1541
1542     #---------------------------------------------------------------------#
1543     def ajoutDefinitionMCFact(self,nomEtape,listeAvant,nomDuMC,listeMC,**args):
1544     #---------------------------------------------------------------------#
1545         print ('ajoutDefinitionMCFact', nomDuMC)
1546         definitionEtape=getattr(self.jdc.cata[0],nomEtape)
1547         ouChercher=definitionEtape
1548         for k in listeAvant :
1549             ouChercher=ouChercher.entites[k]
1550         from Accas import A_SIMP
1551         for mc in listeMC :
1552             nomMC=mc[0]
1553             typMC=mc[1]
1554             argsMC=mc[2]
1555             nouveauMC=A_SIMP.SIMP(typMC,**argsMC)
1556             nouveauMC.nom=nomMC
1557             args[nomMC]=nouveauMC
1558         from Accas import A_FACT
1559         nouveauFact=A_FACT.FACT(**args)
1560         nouveauFact.pere=ouChercher
1561         nouveauFact.nom=nomDuMC
1562         from Editeur.autre_analyse_cata import traite_entite
1563         traite_entite(nouveauFact,[])
1564         ouChercher.entites[nomDuMC]=nouveauFact
1565         ouChercher.ordre_mc.append(nomDuMC)
1566         self.dicoNouveauxFact[nomDuMC]=('ajoutDefinitionMC',nomEtape,listeAvant,nomDuMC,listeMC,args)
1567         #print self.dicoNouveauxMC
1568
1569     #----------------------------------------------------#
1570
1571     #----------------------------------------------------#
1572     def changeIntoMCandSet(self,etape,listeMC,into,valeurs):
1573     #----------------------------------------------------#
1574
1575         self.changeIntoDefMC(etape,listeMC,into)
1576
1577         if isinstance (etape, str):
1578           for e in self.jdc.etapes:
1579             if e.nom == etape : etape=e; break
1580         if etape == None : return
1581
1582         ouChercher = etape
1583         for mot in listeMC[:-1] :
1584             ouChercher=ouChercher.get_child(mot,restreint="oui")
1585             if ouChercher==None : return
1586         MCFils=listeMC[-1]
1587         print (MCFils)
1588         monMC=ouChercher.get_child(MCFils,restreint="oui")
1589         if monMC== None : monMC= etape.addentite(MCFils)
1590         print (monMC)
1591
1592         monMC.definition.into=into
1593         monMC.valeur=valeurs
1594         monMC.val=valeurs
1595         monMC.state='changed'
1596         monMC.isvalid()
1597
1598     #-------------------------------------#
1599     def ajoutVersionCataDsJDC(self,txt):
1600     #-------------------------------------#
1601         if not hasattr(self.readercata.cata[0],'VERSION_CATALOGUE'): return txt
1602         ligneVersion="#VERSION_CATALOGUE:"+self.readercata.cata[0].VERSION_CATALOGUE+":FIN VERSION_CATALOGUE\n"
1603         texte=txt+ligneVersion
1604         return texte
1605
1606     #-------------------------------------#
1607     def verifieVersionCataDuJDC(self,text):
1608     #-------------------------------------#
1609         memeVersion=False
1610         indexDeb=text.find("#VERSION_CATALOGUE:")
1611         indexFin=text.find(":FIN VERSION_CATALOGUE")
1612         if indexDeb < 0 :
1613            self.versionCataDuJDC="sans"
1614            textJDC=text
1615         else :
1616            self.versionCataDuJDC=text[indexDeb+19:indexFin]
1617            textJDC=text[0:indexDeb]+text[indexFin+23:-1]
1618
1619         self.versionCata="sans"
1620         if hasattr(self.readercata.cata[0],'VERSION_CATALOGUE'): self.versionCata=self.readercata.cata[0].VERSION_CATALOGUE
1621
1622         if self.versionCata==self.versionCataDuJDC : memeVersion=True
1623         return memeVersion,textJDC
1624
1625     #-------------------------------#
1626     def traduitCatalogue(self,texte):
1627     #-------------------------------#
1628         nomTraducteur="traduit"+self.readercata.code+self.versionCataDuJDC+"To"+self.versionCata
1629         sys.path.append(os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)),"../Traducteur")))
1630         try :
1631             traducteur=__import__(nomTraducteur)
1632             monTraducteur=traducteur.MonTraducteur(texte)
1633             nouveauTexte=monTraducteur.traduit()
1634             return nouveauTexte
1635         except :
1636             return texte
1637
1638
1639     #------------------------------#
1640     def verifieCHECKSUM(self,text):
1641     #------------------------------#
1642         indexDeb=text.find("#CHECKSUM:")
1643         if indexDeb < 0 :
1644            return 1, text
1645         indexFin=text.find(":FIN CHECKSUM")
1646         checkAvant=text[indexDeb:indexFin+13]
1647         textJDC=text[0:indexDeb]+text[indexFin+13:-1]
1648         checksum=self.get_checksum(textJDC)
1649         pareil=(checkAvant==checksum)
1650         return pareil, textJDC
1651
1652     #---------------------------#
1653     def get_checksum(self,texte):
1654     #---------------------------#
1655         newtexte=texte.replace('"','\\"')
1656         commande='echo "'+newtexte+'"|md5sum'
1657         a=os.popen(commande)
1658         checksum=a.read()
1659         a.close()
1660         ligne="#CHECKSUM:"+checksum[0:-1]+":FIN CHECKSUM"
1661         return ligne
1662
1663
1664     #---------------------------#
1665     def _new_CF(self):
1666     #---------------------------#
1667         texte="CONDUITE_FORCEE();"
1668         return texte
1669
1670
1671     #---------------------------#
1672     def _newTELEMAC(self):
1673     #---------------------------#
1674         #texte="INITIALIZATION();BOUNDARY_CONDITIONS();GENERAL_PARAMETERS();PHYSICAL_PARAMETERS();NUMERICAL_PARAMETERS();"
1675         texte="COMPUTATION_ENVIRONMENT();HYDRO();GENERAL_PARAMETERS();NUMERICAL_PARAMETERS()"
1676         #texte="TRACERS();"
1677         return texte
1678
1679     #---------------------------#
1680     def _newPSEN(self):
1681     #---------------------------#
1682         texte="DIRECTORY() ; PSSE_PARAMETERS() ; SIMULATION() ; sansnom=DISTRIBUTION() ; sansnom=DISTRIBUTION() ; CORRELATION() ;"
1683         #texte=""
1684         return texte
1685
1686     #---------------------------#
1687     def _newPSEN_N1(self):
1688     #---------------------------#
1689         texte="CASE_SELECTION();N_PROCESSING_OPTIONS();CONTINGENCY_OPTIONS();CONTINGENCY_SELECTION();\nCONTINGENCY_PROCESSING(); "
1690         texte="CONTINGENCY_SELECTION();\nCONTINGENCY_PROCESSING(); "
1691         return texte
1692
1693     #---------------------------#
1694
1695     #---------------------------#
1696     def _newZCRACKS(self):
1697     #---------------------------#
1698         texte="MAILLAGES();REMESHING();"
1699         return texte
1700
1701     #---------------------------#
1702     def _newJDCCND(self):
1703     #---------------------------#
1704       extensions=tr('Fichiers Med (*.med);;''Tous les Fichiers (*)')
1705
1706       #if self.salome == 0 :
1707       QMessageBox.information( self,
1708                       tr("Fichier Med"),
1709                       tr("Veuillez selectionner un fichier Med"))
1710       QSfichier = QFileDialog.getOpenFileName(self.appliEficas,
1711                         caption='Fichier Med',
1712                         filter=extensions)
1713       QSfichier=QSfichier[0]
1714       self.fichierMED=QSfichier
1715       from acquiertGroupes import getGroupes
1716       erreur,self.listeGroupes,self.nomMaillage,self.dicoCoord=getGroupes(self.fichierMED)
1717       if erreur != "" : print ("a traiter")
1718       texteComm="COMMENTAIRE(u'Cree - fichier : "+self.fichierMED +" - Nom Maillage : "+self.nomMaillage+"');\nPARAMETRES()\n"
1719       texteSources=""
1720       texteCond=""
1721       texteNoCond=""
1722       texteVcut=""
1723       texteZs=""
1724       for groupe in self.listeGroupes :
1725           if groupe[0:8]=='CURRENT_':
1726              texteSources +=groupe[8:]+"=SOURCE("
1727              texteSources +="VecteurDirecteur=(1.0,2.0,3.0,),);\n"
1728           if groupe[0:5]=='COND_':    texteCond    +=groupe[5:]+"=CONDUCTEUR();\n"
1729           if groupe[0:7]=='NOCOND_':  texteNoCond  +=groupe[7:]+"=NOCOND();\n"
1730           if groupe[0:5]=='VCUT_':    texteVcut    +='V_'+groupe[5:]+"=VCUT();\n"
1731           if groupe[0:3]=='ZS_':      texteZs      +=groupe[3:]+"=ZS();\n"
1732       texte=texteComm+texteSources+texteCond+texteNoCond+texteVcut+texteZs
1733       self.newTexteCND=texte
1734       self.modified=1
1735       return texte
1736
1737
1738     #---------------------------#
1739     def  BoutonFileSelected(self):
1740     #---------------------------#
1741
1742       QSfichier=self.openfile.selectedFiles()[0]
1743       self.fichierMED=str(QSfichier)
1744       from acquiertGroupes import getGroupes
1745       erreur,self.listeGroupes,self.nomMaillage=getGroupes(self.fichierMED)
1746       if erreur != "" : print ("a traiter")
1747
1748     #-----------------------------
1749     def BoutonSalomePressed(self):
1750     #----------------------------
1751       Msg,self.listeGroupes=self.appliEficas.ChercheGrpMailleInSalome()
1752       self.fichierMED="A_partir_de_SMESH"
1753       self.nomMaillage="A_partir_de_SMESH"
1754       self.openfile.close()
1755
1756
1757     #-----------------------------------------
1758     def initSplitterSizes(self, nbWidget=3):
1759     #-----------------------------------------
1760        #print ("je passe ds initSplitterSizes", nbWidget)
1761
1762        if   self.code in [ 'Adao', 'ADAO', ] : self.splitterSizes3=[1,1550,150]
1763        elif self.code in [ 'MAP']            : self.splitterSizes3=[700,300]
1764        else                                  : self.splitterSizes3=[150,1000,300]
1765
1766        if   self.code in [ 'Adao', 'ADAO', ] : self.splitterSizes2=[5,1500]
1767        else                                  : self.splitterSizes2=[300,1000]
1768
1769
1770
1771     #-----------------------------------------
1772     def restoreSplitterSizes(self,nbWidget=3):
1773     #----------------------------------------
1774
1775       #traceback.print_stack()
1776       #print ("je passe ds restoreSplitterSizes")
1777       if not(hasattr(self,'splitter')) : return
1778       if nbWidget==2  : newSizes=self.splitterSizes2
1779       if nbWidget==3  : newSizes=self.splitterSizes3
1780       #self.inhibeSplitter = 1
1781       self.splitter.setSizes(newSizes)
1782       #self.inhibeSplitter = 0
1783       QApplication.processEvents()
1784       # seule la fentetre du milieu est necessaire
1785       self.splitter.widget(1).resizeEvent=self.saveSplitterSizes
1786
1787     #-----------------------------------------
1788     def saveSplitterSizes(self,event):
1789     #-----------------------------------------
1790       #print ("je passe ds saveSplitterSizes")
1791       if self.inhibeSplitter : return
1792       if self.widgetOptionnel == None  : self.splitterSizes2 = self.splitter.sizes()[0:2]
1793       else                             : self.splitterSizes3 = self.splitter.sizes()[0:3]
1794
1795     #------------------------
1796     def fermeOptionnel(self):
1797     #------------------------
1798       if self.widgetOptionnel == None : return
1799
1800       self.inhibeSplitter=1
1801       self.widgetOptionnel.setParent(None)
1802       self.widgetOptionnel.close()
1803       self.widgetOptionnel.deleteLater()
1804       self.widgetOptionnel=None
1805       self.inhibeSplitter=0
1806       self.restoreSplitterSizes(2)
1807
1808     #------------------------
1809     def ajoutOptionnel(self):
1810     #------------------------
1811       #if len(self.splitterSizes) == 2 : self.splitterSizes.append(self.oldSizeWidgetOptionnel)
1812       #else : self.splitterSizes[2] = self.oldSizeWidgetOptionnel # ceinture pour les close bizarres
1813       #self.splitterSizes[1] = self.splitterSizes[1] - self.splitterSizes[2]
1814
1815       self.restoreSplitterSizes(3)
1816
1817
1818     #------------------------
1819     def fermeArbre(self):
1820     #------------------------
1821        #print (self.widgetTree)
1822        self.oldWidgetTree=self.widgetTree
1823        self.widgetTree.hide()
1824        #self.widgetTree=None
1825
1826     #------------------------
1827     def ouvreArbre(self):
1828     #------------------------
1829        #print ('je passe la')
1830        #print (self.widgetTree)
1831        #self.widgetTree=self.oldWidgetTree
1832        self.widgetTree.show()
1833        #self.restoreSplitterSizes(3)
1834
1835     #-----------------------------
1836     def getTreeIndex(self,noeud):
1837     #----------------------------
1838       indexNoeud=-1
1839       if noeud in noeud.treeParent.children :
1840           indexNoeud=noeud.treeParent.children.index(noeud)
1841       else :
1842           if hasattr(noeud,'vraiParent') :
1843               noeudVrai = noeud
1844               noeudVraiParent = noeud.vraiParent
1845               while noeudVraiParent != noeud.treeParent and hasattr(noeudVraiParent,'vraiParent') :
1846                   noeudVrai = noeudVraiParent
1847                   noeudVraiParent = noeudVraiParent.vraiParent
1848                   pass
1849               if noeudVraiParent == noeud.treeParent :
1850                   indexNoeud=noeud.treeParent.children.index(noeudVrai)
1851                   pass
1852               pass
1853           pass
1854       return indexNoeud
1855
1856 if __name__ == "__main__":
1857     self.code='ASTER'
1858     name='prefs_'+prefs.code
1859     prefsCode=__import__(name)
1860
1861
1862     if hasattr(prefsCode,'encoding'):
1863        # Hack pour changer le codage par defaut des strings
1864        import sys
1865        reload(sys)
1866        sys.setdefaultencoding(prefs.encoding)
1867        del sys.setdefaultencoding
1868        # Fin hack
1869
1870 #    code=options.code
1871 #
1872     app = QApplication(sys.argv)
1873     mw = JDCEditor(None,'azAster.comm')
1874     app.setMainWidget(mw)
1875     app.connect(app, SIGNAL("lastWindowClosed()"), app, SLOT("quit()"))
1876     mw.show()
1877
1878     res = app.exec_loop()
1879     sys.exit(res)