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