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