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