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