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