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