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