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