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