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