InterfaceTK/bureau.py

   1 # -*- coding: utf-8 -*-
   2 #            CONFIGURATION MANAGEMENT OF EDF VERSION
   3 # ======================================================================
   4 # COPYRIGHT (C) 1991 - 2002  EDF R&D                  WWW.CODE-ASTER.ORG
   5 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
   6 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
   7 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
   8 # (AT YOUR OPTION) ANY LATER VERSION.
   9 #
  10 # THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
  11 # WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
  12 # MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
  13 # GENERAL PUBLIC LICENSE FOR MORE DETAILS.
  14 #
  15 # YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
  16 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
  17 #    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
  18 #
  19 #
  20 # ======================================================================
  21 """
  22    Ce module contient la classe BUREAU qui gere les JDC ouverts
  23 """
  24 # Modules Python
  25 import os,string,sys,re
  26 import traceback
  27 import Pmw
  28 from widgets import askopenfilename,asksaveasfilename
  29 from widgets import showinfo,askyesno,showerror
  30
  31 # Modules Eficas
  32 import splash
  33 import prefs
  34 import convert
  35 import generator
  36 import AIDE
  37 import os
  38 from jdcdisplay import JDCDISPLAY
  39 from Editeur.utils import extension_fichier,stripPath,save_in_file
  40 from widgets import Fenetre,Ask_Format_Fichier,FenetreSurLigneWarning
  41 from fenetre_mc_inconnus import fenetre_mc_inconnus
  42 from Ihm import CONNECTOR
  43 try :
  44    from Traducteur import traduitV7V8
  45 except :
  46    pass
  47
  48 from Editeur import comploader
  49
  50 dict_defext = {"ASTER":".comm","HOMARD":".py","OPENTURNS":".comm"}
  51 dict_filtyp = {"ASTER":(("ASTER", ".comm"),),"HOMARD":(("HOMARD", ".py"),),"OPENTURNS":(("OPENTURNS", ".comm"),)}
  52
  53 class BUREAU:
  54    menu_defs=[
  55               ('Fichier',[
  56                            ('Nouveau','newJDC','<Control-n>'),
  57                            ('Ouvrir','openJDC','<Control-o>'),
  58                            ('Enregistrer','saveJDC','<Control-e>'),
  59                            ('Enregistrer sous','saveasJDC','<Control-s>'),
  60                            None,
  61                            ('Fermer','closeJDC','<Control-f>'),
  62                            ('Quitter','exitEFICAS','<Control-q>'),
  63                          ]
  64               ),
  65               ('Edition',[
  66                            ('Copier','copy','<Control-c>'),
  67                            ('Couper','cut','<Control-x>'),
  68                            ('Coller','paste','<Control-v>'),
  69                          ]
  70               ),
  71               ('Jeu de commandes',[
  72                                    ('Rapport de validation','visuCRJDC','<Control-r>'),
  73                                    ('Fichier a plat','visu_a_plat','<Control-p>'),
  74                                    ('Fichier .py','visuJDC_py'),
  75                                    ('Fichier source','visu_txt_brut_JDC','<Control-b>'),
  76                                    ('Parametres Eficas','affichage_fichier_ini'),
  77                                    ('Mots-cles inconnus','mc_inconnus'),
  78                                   ]
  79               ),
  80               ('Traduction',[
  81                              ('Traduction v7 en v8','TraduitFichier','<Control-t>','Ctrl+T')
  82                             ]
  83               ),
  84               ('Aide',[
  85                         ('Aide EFICAS','aideEFICAS','<Control-a>','Ctrl+A'),
  86                       ]
  87               ),
  88              ]
  89
  90    button_defs  =      (('New24',"newJDC","Creation d'un nouveau fichier",'always'),
  91                         ('Open24',"openJDC","Ouverture d'un fichier existant",'always'),
  92                         ('Save24',"saveJDC","Sauvegarde du fichier courant",'always'),
  93                         ('Fermer24',"closeJDC","Fermeture du fichier courant",'always'),
  94                         ('Zoom24',"visuJDC","Visualisation du fichier de commandes",'always'),
  95                         None,
  96                         ('Copy24',"copy","Copie l'objet courant",'jdc'),
  97                         ('Cut24',"cut","Coupe l'objet courant",'jdc'),
  98                         ('Paste24',"paste","Colle l'objet copie apres l'objet courant",'jdc'),
  99                         None,
 100                         ('Delete24',"delete","Supprime l'objet courant",'jdc'),
 101                         ('Help24',"view_doc","Documentation de l'objet courant",'jdc')
 102                        )
 103    try:
 104       menu_defs=prefs.menu_defs['bureau']
 105    except:
 106       pass
 107    try:
 108       button_defs=prefs.button_defs['bureau']
 109    except:
 110       pass
 111
 112    def __init__(self,appli,parent):
 113       self.parent=parent
 114       self.appli=appli
 115       if self.appli.test == 0 :
 116          splash._splash.configure(text = "Creation du bureau")
 117       self.nb = Pmw.NoteBook(self.parent,raisecommand=self.selectJDC)
 118       self.nb.pack(fill='both',expand=1)
 119       self.JDCDisplay_courant=None
 120       self.fileName=None
 121       self.liste_JDCDisplay=[]
 122       self.charger_composants()
 123       self.cree_cataitem()
 124       self.text_reel=""
 125       self.initialdir = self.appli.CONFIGURATION.initialdir
 126
 127    def charger_composants(self):
 128       comploader.charger_composants()
 129
 130    def cree_cataitem(self):
 131       """
 132           On recupere dans l'appli_composant readercata les variables
 133           qui servent par la suite pour la creation des JDC
 134       """
 135       self.cataitem=self.appli.readercata.cataitem
 136       self.cata=self.appli.readercata.cata
 137       self.cata_ordonne_dico=self.appli.readercata.cata_ordonne_dico
 138       self.code=self.appli.readercata.code
 139       self.version_code=self.appli.readercata.version_code
 140       self.fic_cata=self.appli.readercata.fic_cata
 141
 142    def selectJDC(self,event=None):
 143       """
 144           Cette methode est appelee chaque fois que l'on selectionne
 145           l'onglet d'un JDC dans le NoteBook des JDC.
 146           Elle permet de stocker dans les variable self.JDC et
 147           self.JDCDisplay_courant les valeurs concernant le JDC courant
 148       """
 149       if len(self.liste_JDCDisplay) == 0 : return
 150       #if self.JDCDisplay_courant : self.JDCDisplay_courant.jdc.unset_context()
 151       numero_jdc = self.nb.index(self.nb.getcurselection())
 152       self.JDCDisplay_courant.unselect()
 153       self.JDCDisplay_courant = self.liste_JDCDisplay[numero_jdc]
 154       self.JDC = self.JDCDisplay_courant.jdc
 155       self.JDCName = self.JDC.nom
 156       self.JDCDisplay_courant.select()
 157       #print "selectJDC",numero_jdc,self.JDCDisplay_courant,self.JDCName
 158
 159
 160    def newJDC_include(self,event=None):
 161       """
 162           Initialise un nouveau JDC include vierge
 163       """
 164       import Extensions.jdc_include
 165       JdC_aux=Extensions.jdc_include.JdC_include
 166
 167       self.appli.statusbar.reset_affichage_infos()
 168
 169       CONTEXT.unset_current_step()
 170       jaux=self.cata[0].JdC(procedure="",appli=self.appli,
 171                          cata=self.cata,cata_ord_dico=self.cata_ordonne_dico,
 172                          rep_mat=self.appli.CONFIGURATION.rep_mat,
 173                          )
 174       jaux.analyse()
 175
 176       J=JdC_aux(procedure="",appli=self.appli,
 177                          cata=self.cata,cata_ord_dico=self.cata_ordonne_dico,
 178                          jdc_pere=jaux,
 179                          rep_mat=self.appli.CONFIGURATION.rep_mat,
 180                          )
 181       J.analyse()
 182       self.JDCName=J.nom
 183       self.fileName=None
 184       self.ShowJDC(J,self.JDCName)
 185       self.appli.toolbar.active_boutons()
 186       return J
 187
 188    def newJDC(self,event=None):
 189       """
 190           Initialise un nouveau JDC vierge
 191       """
 192       self.appli.statusbar.reset_affichage_infos()
 193
 194       CONTEXT.unset_current_step()
 195       J=self.cata[0].JdC(procedure="",appli=self.appli,
 196                          cata=self.cata,cata_ord_dico=self.cata_ordonne_dico,
 197                          rep_mat=self.appli.CONFIGURATION.rep_mat,
 198                          )
 199       J.analyse()
 200       self.JDCName=J.nom
 201       self.fileName=None
 202       self.ShowJDC(J,self.JDCName)
 203       self.appli.toolbar.active_boutons()
 204       return J
 205
 206    def ShowJDC(self,JDC,nom,label_onglet=None,JDCDISPLAY=JDCDISPLAY,enregistre="non"):
 207       """
 208           Lance l'affichage du JDC cad creation du JDCDisplay
 209           Rajoute le JDCDisplay a la liste des JDCDisplay si label_onglet == None cad si on cree
 210           bien un nouveau JDCDisplay et non si on remplace (renommage de l'onglet)
 211       """
 212       self.JDC=JDC
 213       self.JDCName = self.JDC.nom = nom
 214       if label_onglet == None :
 215           # On veut un nouvel onglet
 216           label_onglet = self.GetLabelJDC()
 217           self.nb.add(label_onglet,tab_text = nom,tab_width=20)
 218           new = 'oui'
 219       else :
 220           new = 'non'
 221       self.JDCDisplay_courant=JDCDISPLAY(self.JDC,nom,appli=self.appli,parent=self.nb.page(label_onglet))
 222       if new == 'oui':
 223           self.liste_JDCDisplay.append(self.JDCDisplay_courant)
 224       self.JDCDisplay_courant.modified='n'
 225       if enregistre != "non" :
 226          self.JDCDisplay_courant.fichier=self.fileName
 227       else :
 228          self.initialdir = self.appli.CONFIGURATION.rep_user
 229       self.nb.selectpage(label_onglet)
 230       self.nb.setnaturalsize()
 231       self.nb.bind_all("<Key-Next>",lambda e,s=self:s.selectArbreDown())
 232       self.nb.bind_all("<Key-Prior>",lambda e,s=self:s.selectArbreUp())
 233       self.nb.bind_all("<Insert>",lambda e,s=self:s.deplieReplieNode())
 234       texte = "Jeu de commandes :" + self.JDCName+" ouvert"
 235       CONNECTOR.Connect(JDC,"close",self.onClose,(self.JDCDisplay_courant,))
 236       self.appli.affiche_infos(texte)
 237
 238    def onClose(self,jdcdisplay):
 239       #print "onClose",jdcdisplay
 240       self.closeJDCDISPLAY(jdcdisplay)
 241
 242    def closeJDCDISPLAY(self,jdc):
 243       """
 244         Ferme le jdcdisplay specifie par l'argument jdc
 245       """
 246       if jdc is self.JDCDisplay_courant:
 247          # on ferme le jdcdisplay courant
 248          self.closeSelectedJDC()
 249       else:
 250          # on ferme un autre jdcdisplay que le courant
 251          old_JDCDisplay=self.JDCDisplay_courant
 252          old_page=self.nb.getcurselection()
 253
 254          self.JDCDisplay_courant=jdc
 255          self.JDC=jdc.jdc
 256          numero_jdc=self.liste_JDCDisplay.index(jdc)
 257          self.nb.selectpage(numero_jdc)
 258          #print numero_jdc
 259
 260          self.closeSelectedJDC()
 261          self.JDCDisplay_courant=old_JDCDisplay
 262          self.JDC=old_JDCDisplay.jdc
 263          self.nb.selectpage(old_page)
 264
 265    def closeJDC (self,event=None) :
 266       """
 267           Ferme le JDC associe au JDCDISPLAY selectionne
 268       """
 269       if self.JDCDisplay_courant :
 270          self.JDCDisplay_courant.jdc.close()
 271
 272    def closeSelectedJDC (self) :
 273       """
 274       Ferme le JDC courant et detruit l'onglet associe dans le notebook self.nb
 275       """
 276       if self.JDCDisplay_courant.modified == 'o' :
 277           message = "Voulez-vous sauvegarder le jeu de commandes "+self.JDC.nom+" courant ?"
 278           reponse = askyesno(title="Sauvegarde du jdc courant",
 279                              message=message)
 280           if reponse :
 281               test = self.saveJDC()
 282               if test == 0 :
 283                   self.appli.affiche_infos("Sauvegarde impossible")
 284                   return
 285
 286       CONNECTOR.Disconnect(self.JDCDisplay_courant.jdc,"close",self.onClose,(self.JDCDisplay_courant,))
 287       self.JDCDisplay_courant.supprime()
 288       self.JDCDisplay_courant.jdc.supprime()
 289       self.liste_JDCDisplay.remove(self.JDCDisplay_courant)
 290       # Active le mecanisme de selection du notebook (selectJDC)
 291       self.nb.delete(self.nb.getcurselection())
 292
 293       try:
 294           index = self.nb.index(self.nb.getcurselection())
 295           self.JDCDisplay_courant = self.liste_JDCDisplay[index]
 296           self.JDC = self.JDCDisplay_courant.jdc
 297       except:
 298           self.JDC = None
 299           self.JDCDisplay_courant = None
 300           self.appli.toolbar.inactive_boutons()
 301
 302    def visuCRJDC(self,event=None):
 303       return self.visuCR(mode='JDC')
 304
 305    def visuCR(self,mode):
 306       """
 307       Methode permettant l'affichage du rapport de validation
 308       """
 309       if mode == 'JDC':
 310           if not hasattr(self,'JDC') : return
 311           if self.JDC == None : return
 312           titre="rapport de validation du jeu de commandes courant"
 313           cr = self.JDC.report()
 314           #self.update_jdc_courant()
 315       elif mode == 'CATA':
 316           from Noyau.N_CR import CR
 317           cr = CR()
 318           cr.debut = "Debut rapport de validation du catalogue"
 319           cr.fin = "Fin rapport de validation du catalogue"
 320           titre="rapport de validation du catalogue"
 321           if hasattr(self,'cata_ordonne_cr') :
 322               cr.add(self.cata_ordonne_cr)
 323           if hasattr(self,'cata_dev_ordonne_cr') :
 324               cr.add(self.cata_dev_ordonne_cr)
 325           for cata in self.cata:
 326               if hasattr(cata,'JdC'):
 327                   cr.add(cata.JdC.report())
 328       texte_cr = str(cr)
 329       self.visu_texte_cr = Fenetre(self.appli,titre=titre,texte=texte_cr)
 330
 331    def openJDC(self,event=None,file=None,units=None,enregistre="oui"):
 332       """
 333           Demande a l'utilisateur quel JDC existant il veut ouvrir
 334       """
 335       if self.code == 'ASTER':
 336           filetypes = ( ("format "+self.appli.format_fichier.get(), ".com*"),("Tous",'*'))
 337       elif self.code == 'HOMARD' :
 338           filetypes = ( ("format "+self.appli.format_fichier.get(), ".py"),("Tous",'*'))
 339       elif self.code == 'OPENTURNS' :
 340           filetypes = ( ("format "+self.appli.format_fichier.get(), ".com*"),("Tous",'*'))
 341       else:
 342           filetypes = ( ("format "+self.appli.format_fichier.get(), ".py"),)
 343       if not hasattr(self,'initialdir'):
 344          self.initialdir = self.appli.CONFIGURATION.initialdir
 345
 346       if not file :
 347           file = askopenfilename(title="Ouverture d'un fichier de commandes Aster",
 348                                  defaultextension=".comm",
 349                                  filetypes = filetypes,
 350                                  initialdir = self.initialdir)
 351       if file :
 352           self.fileName = file
 353           e=extension_fichier(file)
 354           self.JDCName=stripPath(file)
 355           self.initialdir = os.path.dirname(os.path.abspath(file))
 356       else :
 357           return
 358
 359       # Il faut convertir le contenu du fichier en fonction du format
 360       format=self.appli.format_fichier.get()
 361       if convert.plugins.has_key(format):
 362          # Le convertisseur existe on l'utilise
 363          p=convert.plugins[format]()
 364          p.readfile(file)
 365          text=p.convert('exec',self.appli)
 366          if not p.cr.estvide():
 367             self.appli.affiche_infos("Erreur a la conversion")
 368             Fenetre(self.appli,
 369                     titre="compte-rendu d'erreurs, EFICAS ne sait pas convertir ce fichier",
 370                     texte = str(p.cr)).wait()
 371             return
 372          if enregistre == "oui" :
 373             self.appli.listeFichiers.aOuvert(file)
 374       else:
 375          # Il n'existe pas c'est une erreur
 376          self.appli.affiche_infos("Type de fichier non reconnu")
 377          showerror("Type de fichier non reconnu","EFICAS ne sait pas ouvrir ce type de fichier")
 378          return
 379
 380       # On se met dans le repertoire ou se trouve le fichier de commandes
 381       # pour trouver les eventuels fichiers include ou autres
 382       # localises a cote du fichier de commandes
 383       os.chdir(self.initialdir)
 384       CONTEXT.unset_current_step()
 385       J=self.cata[0].JdC(procedure=text,appli=self.appli,
 386                          cata=self.cata,cata_ord_dico=self.cata_ordonne_dico,
 387                          nom = self.JDCName,
 388                          rep_mat=self.appli.CONFIGURATION.rep_mat,
 389                          )
 390       if units is not None:
 391          J.recorded_units=units
 392          J.old_recorded_units=units
 393
 394       J.analyse()
 395       txt_exception = J.cr.get_mess_exception()
 396       if txt_exception :
 397           # des exceptions ont ete levees a la creation du JDC
 398           # --> on affiche les erreurs mais pas le JDC
 399           self.JDC=J
 400           self.appli.affiche_infos("Erreur fatale au chargement de %s" %file)
 401           if self.appli.test == 0 :
 402              showerror("Erreur fatale au chargement d'un fichier",txt_exception)
 403       else:
 404           self.ShowJDC(J,self.JDCName,enregistre=enregistre)
 405           self.appli.toolbar.active_boutons()
 406           # si le JDC ne contient rien (vide), on retourne ici
 407           if len(self.JDC.etapes) == 0 : return
 408           # dans le cas ou le JDC est invalide, on affiche son CR
 409           if not self.JDC.isvalid():
 410              self.appli.top.update()
 411              self.visuCR(mode='JDC')
 412       return J
 413
 414    def deplieReplieNode(self):
 415        self.JDCDisplay_courant.tree.tree.deplieReplieNode()
 416
 417    def selectArbreDown(self):
 418        self.JDCDisplay_courant.tree.tree.canvas.focus_set()
 419        self.JDCDisplay_courant.tree.tree.mot_down_force()
 420
 421    def selectArbreUp(self):
 422        self.JDCDisplay_courant.tree.tree.canvas.focus_set()
 423        self.JDCDisplay_courant.tree.tree.mot_up_force()
 424
 425    def GetLabelJDC(self,nb_jdc = 'absent'):
 426       """
 427       Retourne le label de l'onglet du NoteBook associe au JDC a afficher
 428       """
 429       if nb_jdc == 'absent':
 430           nb_jdc = len(self.nb.pagenames())
 431       nb_jdc = nb_jdc+1
 432       label_onglet = 'JDC'+`nb_jdc`
 433       if label_onglet not in self.nb.pagenames() :
 434           return label_onglet
 435       else :
 436           return self.GetLabelJDC(nb_jdc)
 437
 438    def saveasJDC(self,event=None):
 439       """
 440            Sauvegarde le JDC courant en demandant imperativement a l'utilisateur de
 441            donner le nom du fichier de sauvegarde
 442       """
 443       self.saveJDC(echo='oui')
 444
 445    def saveJDC(self,echo='non'):
 446       """
 447           Sauvegarde le JDC courant.
 448           Retourne 1 si la sauvegarde s'est bien faite, 0 sinon.
 449
 450             - Si echo = 'oui' : interactif (l'utilisateur donne le nom sous lequel il
 451                             veut sauver le JDC
 452             - Si echo = 'non' : muet (sauvegarde le JDC dans JDC.procedure)
 453       """
 454       ok = 0
 455       if not hasattr(self,'JDC') : return 0
 456       format=self.appli.format_fichier.get()
 457       if generator.plugins.has_key(format):
 458          # Le generateur existe on l'utilise
 459          g=generator.plugins[format]()
 460          jdc_formate=g.gener(self.JDC,format='beautifie')
 461          if format == 'homard':
 462             self.jdc_homard=g.get_homard()
 463          elif format == 'openturns' :
 464             self.jdc_openturn_xml=g.getOpenturnsXML()
 465             self.jdc_openturn_std=g.getOpenturnsSTD()
 466          if not g.cr.estvide():
 467             self.appli.affiche_infos("Erreur a la generation")
 468             showerror("Erreur a la generation","EFICAS ne sait pas convertir ce JDC")
 469             return
 470       else:
 471          # Il n'existe pas c'est une erreur
 472          self.appli.affiche_infos("Format %s non reconnu" % format)
 473          showerror("Format %s non reconnu" % format,"EFICAS ne sait pas convertir le JDC")
 474          return
 475       self.jdc_fini = string.replace(jdc_formate,'\r\n','\n')
 476
 477       if echo =='oui' or self.JDCDisplay_courant.fichier == None:
 478          ok = self.asknomsauvegardeJDC()
 479       elif self.JDCDisplay_courant.fichier != None :
 480          # le JDC a deja un nom : on sauvegarde directement sans demander
 481          # un autre nom au developpeur
 482          if not save_in_file(self.JDCDisplay_courant.fichier,self.jdc_fini,self.appli.dir) :
 483               showinfo("Erreur","Probleme a la sauvegarde du fichier :" + `self.JDCDisplay_courant.fichier`)
 484               #return 0
 485               ok = 0
 486          else :
 487               if self.appli.format_fichier.get() == 'homard':
 488                   self.save_homard(self.JDCDisplay_courant.fichier,self.jdc_homard)
 489               elif self.appli.format_fichier.get() == 'openturns':
 490                   self.save_openturns(self.JDCDisplay_courant.fichier[0:-3],
 491                   self.jdc_openturn_xml,
 492                   self.jdc_openturn_std)
 493               self.JDCDisplay_courant.stop_modif()
 494               self.appli.affiche_infos("sauvegarde de "+`self.JDCDisplay_courant.fichier`+" effectuee")
 495               ok = 1
 496
 497       if ok and self.appli.salome:
 498          # eficas a ete lance a partir deSalome
 499          #1)ajout dans l'arbre d'etude du nom du jdc
 500          if self.appli.salome==0 : return 0
 501          ok, msg = self.appli.addJdcInSalome( self.JDCDisplay_courant.fichier )
 502
 503          #2)CS_pbruno ??
 504          from panelsSalome import SALOME_UNIQUE_BASE_Panel
 505          if len(SALOME_UNIQUE_BASE_Panel.dict_fichier_unite) > 0 :
 506             print 'CS_pbruno if len(SALOMchier_unite) > 0 :???????'
 507             self.appli.creeConfigTxt( self.appli.CONFIGURATION.initialdir, SALOME_UNIQUE_BASE_Panel.dict_fichier_unite )
 508
 509          #3)creation/mise a jours d'un maillage dans Salome
 510          if self.code == 'ASTER':
 511             self.appli.createOrUpdateMesh()
 512       return ok
 513
 514    def asknomsauvegardeJDC(self):
 515       """ Demande a l'utilsateur le nom sous lequel il veut sauvegarder le JDC courant """
 516       titre = "Sauvegarde d'un fichier de commandes "+self.code
 517       if dict_defext.has_key(self.code) :
 518           defext = dict_defext[self.code]
 519           filtyp = dict_filtyp[self.code]
 520       else :
 521           defext = ".py"
 522           filtyp = ( (self.code, ".py"),)
 523       sauvegarde = asksaveasfilename(title=titre,
 524                                      defaultextension=defext,
 525                                      filetypes = filtyp,
 526                                      initialdir = self.initialdir)
 527                             #initialdir = self.appli.CONFIGURATION.initialdir)
 528                             #initialdir = self.appli.CONFIGURATION.rep_user)
 529       if sauvegarde :
 530           if not save_in_file(sauvegarde,self.jdc_fini,None) :
 531               showinfo("Erreur","Probleme a la sauvegarde du fichier "+`sauvegarde`)
 532               return 0
 533           else :
 534               if self.appli.format_fichier.get() == 'homard':
 535                   self.save_homard(sauvegarde,self.jdc_homard)
 536               elif self.appli.format_fichier.get() == 'openturns':
 537                   self.save_openturns(sauvegarde,
 538                                       self.jdc_openturn_xml,
 539                                       self.jdc_openturn_std)
 540               self.JDCDisplay_courant.stop_modif()
 541               self.appli.affiche_infos("Sauvegarde effectuee")
 542               if sauvegarde != self.JDCDisplay_courant.fichier :
 543                   # l'utilisateur a sauvegarde le JDC sous un autre nom
 544                   self.JDCDisplay_courant.fichier = sauvegarde
 545                   self.JDCName = self.JDC.nom = stripPath(sauvegarde)
 546                   self.JDC.changefichier(sauvegarde)
 547                   self.changeNomPage()
 548               return 1
 549       else :
 550           return 0
 551
 552    def changeNomPage(self):
 553       """ Change le nom de l'onglet contenant le JDC courant : en fait detruit l'actuel
 554           et recree un autre onglet a la même place avec le bon nom
 555       """
 556       nom = self.JDCName
 557       self.JDCDisplay_courant.jdc.nom = nom
 558       nom_page = self.nb.getcurselection()
 559       num_page = self.nb.index(nom_page)
 560       tab = self.nb.tab(num_page)
 561       tab.configure(text = nom)
 562
 563    def exitEFICAS(self,event=None):
 564       """
 565           Permet de sortir d'EFICAS en demandant a l'utilisateur
 566           s'il veut sauvegarder les modifications en cours
 567       """
 568       liste = self.GetListeJDCaSauvegarder()
 569       if liste != [] :
 570           # Certains fichiers n'ont pas ete sauvegardes ...
 571           if askyesno("Enregistrer modifications","Enregistrer les modifications ?") :
 572               test = self.saveall(liste)
 573               if test != 1 :
 574                   return
 575       if askyesno ("Quitter","Voulez-vous vraiment quitter l'application ?") :
 576           for JDCDisplay in self.liste_JDCDisplay:
 577               JDCDisplay.jdc.supprime()
 578           self.appli.quit()
 579           return
 580
 581    def GetListeJDCaSauvegarder(self) :
 582       """ Retourne parmi la liste de tous les JDC ouverts la liste de ceux qui ont ete modifies """
 583       if not self.JDCDisplay_courant : return []
 584       if len(self.liste_JDCDisplay) == 0 : return l
 585       l = []
 586       for JDCDisplay in self.liste_JDCDisplay:
 587           if JDCDisplay.modified == 'o' :
 588               l.append(JDCDisplay)
 589       return l
 590
 591    def copy(self,event=None):
 592       """
 593           Lance la copie sur le JDC courant
 594       """
 595       if self.JDCDisplay_courant : self.JDCDisplay_courant.doCopy()
 596
 597    def paste(self,event=None):
 598       """
 599            Lance le collage sur le JDC courant
 600       """
 601       if self.JDCDisplay_courant : self.JDCDisplay_courant.doPaste()
 602
 603    def cut(self,event=None):
 604       """
 605          Lance le cut sur le JDC courant
 606       """
 607       if self.JDCDisplay_courant: self.JDCDisplay_courant.doCut()
 608
 609    def delete(self):
 610       """
 611           Lance la suppression du noeud courant
 612       """
 613       if not self.JDCDisplay_courant : return
 614       self.JDCDisplay_courant.init_modif()
 615       self.JDCDisplay_courant.node_selected.delete()
 616
 617    def visuJDC_py(self,event=None):
 618       """
 619           Methode permettant d'afficher dans une fenêtre a part l'echo au
 620           format python du jdc courant
 621       """
 622       if not hasattr(self,'JDC') : return
 623       jdc_fini = self.get_text_JDC('python')
 624       if jdc_fini == None : return
 625       Fenetre(self.appli,
 626               titre = 'fichier '+ self.JDCName + ' a la syntaxe Python',
 627               texte = jdc_fini)
 628
 629    def visuJDC(self):
 630       """
 631           Methode permettant d'afficher dans une fenêtre a part l'echo au
 632           format .comm ou .py du jdc courant
 633       """
 634       if not hasattr(self,'JDC') : return
 635       titre = 'fichier '+ self.JDCName + ' a la syntaxe '+ self.code
 636       format=self.appli.format_fichier.get()
 637       self.jdc_fini = self.get_text_JDC(format)
 638       if self.jdc_fini == None : return
 639       self.visu_fichier_cmd = Fenetre(self.appli,titre=titre,texte = self.jdc_fini)
 640
 641    def get_text_JDC(self,format):
 642       if generator.plugins.has_key(format):
 643          # Le generateur existe on l'utilise
 644          g=generator.plugins[format]()
 645          jdc_formate=g.gener(self.JDC,format='beautifie')
 646          if not g.cr.estvide():
 647             self.appli.affiche_infos("Erreur a la generation")
 648             showerror("Erreur a la generation","EFICAS ne sait pas convertir ce JDC")
 649             return
 650          else:
 651             return jdc_formate
 652       else:
 653          # Il n'existe pas c'est une erreur
 654          self.appli.affiche_infos("Format %s non reconnu" % format)
 655          showerror("Format %s non reconnu" % format,"EFICAS ne sait pas convertir le JDC en format %s "% format)
 656          return
 657
 658    def view_doc(self):
 659       """
 660           Permet d'ouvrir le fichier doc U de la commande au format pdf avec Acrobat Reader
 661           - Ne fonctionne pas sous UNIX (chemin d'acces Acrobat Reader)
 662           - indication du chemin d'acces aux fichiers pdf a revoir : trop statique
 663       """
 664       if not self.JDCDisplay_courant : return
 665       try:
 666           cle_doc = self.JDCDisplay_courant.node_selected.item.get_docu()
 667           if cle_doc == None : return
 668           cle_doc = string.replace(cle_doc,'.','')
 669           cle_doc = string.replace(cle_doc,'-','')
 670           commande = self.appli.CONFIGURATION.exec_acrobat
 671           nom_fichier = cle_doc+".pdf"
 672           fichier = os.path.abspath(os.path.join(self.appli.CONFIGURATION.path_doc,nom_fichier))
 673           if os.name == 'nt':
 674               os.spawnv(os.P_NOWAIT,commande,(commande,fichier,))
 675           elif os.name == 'posix':
 676               script ="#!/usr/bin/sh \n%s %s&" %(commande,fichier)
 677               pid = os.system(script)
 678       except AttributeError:
 679           traceback.print_exc()
 680           pass
 681
 682    def visu_a_plat(self,event=None):
 683       """
 684           Methode permettant d'afficher dans une fenêtre a part l'echo 'a plat' du jdc courant
 685       """
 686       if not hasattr(self,'JDC') : return
 687       titre = 'fichier '+ self.JDCName + ' a plat '
 688       self.jdc_fini = self.get_text_JDC('aplat')
 689       if self.jdc_fini == None : return
 690       self.visu_fichier_cmd = Fenetre(self.appli,titre=titre,texte = self.jdc_fini)
 691
 692    def visu_txt_brut_JDC(self,event=None):
 693       """
 694            Methode permettant d'afficher le jeu de commandes tel qu'il a ete passe au JDC
 695       """
 696       if not hasattr(self,'JDC') : return
 697       titre = "fichier de commandes utilisateur"
 698       #texte = self.JDC.procedure
 699       #if texte == None:
 700       if self.JDCDisplay_courant.fichier == None:
 701             self.appli.affiche_infos("Pas de fichier initial")
 702             showerror("Impossible de visualiser le fichier initial",
 703                       "EFICAS ne peut visualiser le fichier initial.\nIl s'agit d'un nouveau JDC")
 704             return
 705       os.chdir(self.appli.dir)
 706       f=open(self.JDCDisplay_courant.fichier,'r')
 707       texte=f.read()
 708       f.close()
 709       self.visu_texte_JDC = Fenetre(self.appli,titre=titre,texte=texte)
 710
 711    def affichage_fichier_ini(self):
 712       """
 713            Affichage des valeurs des parametres relus par Eficas
 714       """
 715       self.appli.CONFIGURATION.affichage_fichier_ini()
 716
 717    def saveall(self,liste):
 718       """
 719            Sauvegarde tous les JDC contenus dans liste
 720       """
 721       test = 1
 722       for JDCDisplay in liste :
 723           self.JDCDisplay_courant=JDCDisplay
 724           self.JDC = JDCDisplay.jdc
 725           test = test * self.saveJDC(echo = 'non')
 726       return test
 727
 728    def save_homard(self,nom,texte):
 729        file_homard=nom+'.conf_homard'
 730        try:
 731            f=open(file_homard,'w')
 732            for ligne in texte:
 733                f.write(ligne)
 734                f.write('\n')
 735            f.close()
 736        except:
 737            print "Pb a la sauvegarde sous le format homard"
 738        if self.appli.salome:
 739            import eficasEtude
 740            self.appli.salome.rangeInStudy(file_homard,"_CONF")
 741
 742    def save_openturns(self,nom,texteXML,texteSTD):
 743        nomSansSuf=nom[:nom.rfind(".")]
 744        fileXML=nomSansSuf + '.xml'
 745        fileSTD=nomSansSuf + '_Std.py'
 746        try:
 747            f=open(fileXML,'w')
 748            f.write(texteXML)
 749            f.close()
 750        except:
 751            print "Pb sauvegarde openturns pour le format xml"
 752        try:
 753            #print texteSTD
 754            if nomSansSuf.rfind("/") > 0 :
 755               nomSansSuf=nomSansSuf[nomSansSuf.rfind("/")+1:]
 756            texteSTD=re.sub('XXXXXX',nomSansSuf,texteSTD)
 757            #print texteSTD
 758            f=open(fileSTD,'w')
 759            f.write(texteSTD)
 760            f.close()
 761        except:
 762            print "Pb sauvegarde openturns pour le format STD"
 763        if self.appli.salome == 1:
 764            ok, msg = self.appli.addJdcInSalome( fileSTD )
 765            ok, msg = self.appli.addJdcInSalome( fileXML )
 766
 767 # ---------------------------------------------------------------------------
 768 #                             Methodes liees aux mots-cles inconnus
 769 # ---------------------------------------------------------------------------
 770
 771    def mc_inconnus(self):
 772       l_mc = self.JDCDisplay_courant.jdc.get_liste_mc_inconnus()
 773       o = fenetre_mc_inconnus(l_mc)
 774       l = o.wait_new_list()
 775       #print "mc_inconnus_new_list: ",l
 776       #CCAR: Il n' y a pas de retour vers le JDC
 777
 778    def aideEFICAS(self,event=None):
 779       AIDE.go(master=self.parent)
 780
 781    def update_jdc_courant(self):
 782       self.JDCDisplay_courant.update()
 783
 784    def TraduitFichier(self,event=None):
 785       directory = self.appli.CONFIGURATION.rep_user
 786       FichieraTraduire = askopenfilename(title="Nom du  Fichier a Traduire",
 787                                  defaultextension=".comm",
 788                                  initialdir = directory
 789                                  )
 790       if (FichieraTraduire == "" or FichieraTraduire == () ) : return
 791       i=FichieraTraduire.rfind(".")
 792       Feuille=FichieraTraduire[0:i]
 793       FichierTraduit=Feuille+"v8.comm"
 794       log=self.initialdir+"/convert.log"
 795       os.system("rm -rf "+log)
 796       os.system("rm -rf "+FichierTraduit)
 797       Pmw.showbusycursor()
 798       traduitV7V8.traduc(FichieraTraduire,FichierTraduit,log)
 799       Pmw.hidebusycursor()
 800       Entete="Fichier Traduit : "+FichierTraduit +"\n\n"
 801       titre = "conversion de "+ FichieraTraduire
 802
 803       if  os.stat(log)[6] != 0L :
 804           f=open(log)
 805           texte_cr= f.read()
 806           f.close()
 807       else :
 808           texte_cr = Entete
 809           commande="diff "+FichieraTraduire+" "+FichierTraduit+" >/dev/null"
 810           try :
 811             if os.system(commande) == 0 :
 812                texte_cr = texte_cr + "Pas de difference entre le fichier V7 et le fichier traduit"
 813           except :
 814                pass
 815
 816       cptrendu = FenetreSurLigneWarning(self.appli,titre=titre,texte=texte_cr)
 817