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