InterfaceQT4/editor.py

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