InterfaceQT4/editor.py

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