InterfaceQT4/editor.py

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