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