InterfaceQT4/editor.pourCIST

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