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