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