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