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