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