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