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