InterfaceQT4/editor.py

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