Editeur/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
  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 from jdcdisplay import JDCDISPLAY
  38 from utils import extension_fichier,stripPath,save_in_file
  39 from widgets import Fenetre,Ask_Format_Fichier
  40 from fenetre_mc_inconnus import fenetre_mc_inconnus
  41 from Ihm import CONNECTOR
  42
  43 import comploader
  44
  45 class BUREAU:
  46    menu_defs=[
  47               ('Fichier',[
  48                            ('Nouveau','newJDC','<Control-n>'),
  49                            ('Ouvrir','openJDC','<Control-o>'),
  50                            ('Enregistrer','saveJDC','<Control-e>'),
  51                            ('Enregistrer sous','saveasJDC','<Control-s>'),
  52                            None,
  53                            ('Fermer','closeJDC','<Control-f>'),
  54                            ('Quitter','exitEFICAS','<Control-q>'),
  55                          ]
  56               ),
  57               ('Edition',[
  58                            ('Copier','copy','<Control-c>'),
  59                            ('Couper','cut','<Control-x>'),
  60                            ('Coller','paste','<Control-v>'),
  61                          ]
  62               ),
  63               ('Jeu de commandes',[
  64                                    ('Rapport de validation','visuCRJDC','<Control-r>'),
  65                                    ('Fichier à plat','visu_a_plat','<Control-p>'),
  66                                    ('Fichier .py','visuJDC_py'),
  67                                    ('Fichier source','visu_txt_brut_JDC','<Control-b>'),
  68                                    ('Paramètres Eficas','affichage_fichier_ini'),
  69                                    ('Mots-clés inconnus','mc_inconnus'),
  70                                   ]
  71               ),
  72               ('Aide',[
  73                         ('Aide EFICAS','aideEFICAS'),
  74                       ]
  75               ),
  76              ]
  77
  78    button_defs  =      (('New24',"newJDC","Création d'un nouveau fichier",'always'),
  79                         ('Open24',"openJDC","Ouverture d'un fichier existant",'always'),
  80                         ('Save24',"saveJDC","Sauvegarde du fichier courant",'always'),
  81                         ('Zoom24',"visuJDC","Visualisation du fichier de commandes",'always'),
  82                         None,
  83                         ('Copy24',"copy","Copie l'objet courant",'jdc'),
  84                         ('Cut24',"cut","Coupe l'objet courant",'jdc'),
  85                         ('Paste24',"paste","Colle l'objet copié après l'objet courant",'jdc'),
  86                         None,
  87                         ('Delete24',"delete","Supprime l'objet courant",'jdc'),
  88                         ('Help24',"view_doc","Documentation de l'objet courant",'jdc')
  89                        )
  90    try:
  91       menu_defs=prefs.menu_defs['bureau']
  92    except:
  93       pass
  94    try:
  95       button_defs=prefs.button_defs['bureau']
  96    except:
  97       pass
  98
  99    def __init__(self,appli,parent):
 100       self.parent=parent
 101       self.appli=appli
 102       if self.appli.test == 0 :
 103          splash._splash.configure(text = "Création du bureau")
 104       self.nb = Pmw.NoteBook(self.parent,raisecommand=self.selectJDC)
 105       self.nb.pack(fill='both',expand=1)
 106       self.JDCDisplay_courant=None
 107       self.fileName=None
 108       self.liste_JDCDisplay=[]
 109       comploader.charger_composants()
 110       self.cree_cataitem()
 111       self.text_reel=""
 112
 113    def cree_cataitem(self):
 114       """
 115           On récupère dans l'appli_composant readercata les variables
 116           qui servent par la suite pour la création des JDC
 117       """
 118       self.cataitem=self.appli.readercata.cataitem
 119       self.cata=self.appli.readercata.cata
 120       self.cata_ordonne_dico=self.appli.readercata.cata_ordonne_dico
 121       self.code=self.appli.readercata.code
 122       self.version_code=self.appli.readercata.version_code
 123       self.fic_cata=self.appli.readercata.fic_cata
 124
 125    def selectJDC(self,event=None):
 126       """
 127           Cette méthode est appelée chaque fois que l'on sélectionne
 128           l'onglet d'un JDC dans le NoteBook des JDC.
 129           Elle permet de stocker dans les variable self.JDC et
 130           self.JDCDisplay_courant les valeurs concernant le JDC courant
 131       """
 132       if len(self.liste_JDCDisplay) == 0 : return
 133       #if self.JDCDisplay_courant : self.JDCDisplay_courant.jdc.unset_context()
 134       numero_jdc = self.nb.index(self.nb.getcurselection())
 135       self.JDCDisplay_courant.unselect()
 136       self.JDCDisplay_courant = self.liste_JDCDisplay[numero_jdc]
 137       self.JDC = self.JDCDisplay_courant.jdc
 138       self.JDCName = self.JDC.nom
 139       self.JDCDisplay_courant.select()
 140       #print "selectJDC",numero_jdc,self.JDCDisplay_courant,self.JDCName
 141
 142    def newJDC_include(self,event=None):
 143       """
 144           Initialise un nouveau JDC vierge
 145       """
 146       import Extensions.jdc_include
 147       JdC_aux=Extensions.jdc_include.JdC_include
 148
 149       self.appli.statusbar.reset_affichage_infos()
 150
 151       CONTEXT.unset_current_step()
 152       jaux=self.cata[0].JdC(procedure="",appli=self.appli,
 153                          cata=self.cata,cata_ord_dico=self.cata_ordonne_dico,
 154                          rep_mat=self.appli.CONFIGURATION.rep_mat,
 155                          )
 156       jaux.analyse()
 157
 158       J=JdC_aux(procedure="",appli=self.appli,
 159                          cata=self.cata,cata_ord_dico=self.cata_ordonne_dico,
 160                          jdc_pere=jaux,
 161                          rep_mat=self.appli.CONFIGURATION.rep_mat,
 162                          )
 163       J.analyse()
 164       self.JDCName=J.nom
 165       self.fileName=None
 166       self.ShowJDC(J,self.JDCName)
 167       self.appli.toolbar.active_boutons()
 168
 169    def newJDC(self,event=None):
 170       """
 171           Initialise un nouveau JDC include vierge
 172       """
 173       self.appli.statusbar.reset_affichage_infos()
 174
 175       CONTEXT.unset_current_step()
 176       J=self.cata[0].JdC(procedure="",appli=self.appli,
 177                          cata=self.cata,cata_ord_dico=self.cata_ordonne_dico,
 178                          rep_mat=self.appli.CONFIGURATION.rep_mat,
 179                          )
 180       J.analyse()
 181       self.JDCName=J.nom
 182       self.fileName=None
 183       self.ShowJDC(J,self.JDCName)
 184       self.appli.toolbar.active_boutons()
 185
 186    def ShowJDC(self,JDC,nom,label_onglet=None,JDCDISPLAY=JDCDISPLAY):
 187       """
 188           Lance l'affichage du JDC cad création du JDCDisplay
 189           Rajoute le JDCDisplay à la liste des JDCDisplay si label_onglet == None cad si on crée
 190           bien un nouveau JDCDisplay et non si on remplace (renommage de l'onglet)
 191       """
 192       self.JDC=JDC
 193       self.JDCName = self.JDC.nom = nom
 194       if label_onglet == None :
 195           # On veut un nouvel onglet
 196           label_onglet = self.GetLabelJDC()
 197           self.nb.add(label_onglet,tab_text = nom,tab_width=20)
 198           new = 'oui'
 199       else :
 200           new = 'non'
 201       self.JDCDisplay_courant=JDCDISPLAY(self.JDC,nom,appli=self.appli,parent=self.nb.page(label_onglet))
 202       if new == 'oui':
 203           self.liste_JDCDisplay.append(self.JDCDisplay_courant)
 204       self.JDCDisplay_courant.modified='n'
 205       self.JDCDisplay_courant.fichier=self.fileName
 206       self.nb.selectpage(label_onglet)
 207       self.nb.setnaturalsize()
 208       texte = "Jeu de commandes :" + self.JDCName+" ouvert"
 209       CONNECTOR.Connect(JDC,"close",self.onClose,(self.JDCDisplay_courant,))
 210       self.appli.affiche_infos(texte)
 211
 212    def onClose(self,jdcdisplay):
 213       #print "onClose",jdcdisplay
 214       CONNECTOR.Disconnect(jdcdisplay.jdc,"close",self.onClose,(jdcdisplay,))
 215       self.closeJDCDISPLAY(jdcdisplay)
 216
 217    def closeJDCDISPLAY(self,jdc):
 218       """
 219         Ferme le jdcdisplay spécifié par l'argument jdc
 220       """
 221       if jdc is self.JDCDisplay_courant:
 222          # on ferme le jdcdisplay courant
 223          self.closeSelectedJDC()
 224       else:
 225          # on ferme un autre jdcdisplay que le courant
 226          old_JDCDisplay=self.JDCDisplay_courant
 227          old_page=self.nb.getcurselection()
 228
 229          self.JDCDisplay_courant=jdc
 230          self.JDC=jdc.jdc
 231          numero_jdc=self.liste_JDCDisplay.index(jdc)
 232          self.nb.selectpage(numero_jdc)
 233          #print numero_jdc
 234
 235          self.closeSelectedJDC()
 236          self.JDCDisplay_courant=old_JDCDisplay
 237          self.JDC=old_JDCDisplay.jdc
 238          self.nb.selectpage(old_page)
 239
 240    def closeJDC (self,event=None) :
 241       """
 242           Ferme le JDC associé au JDCDISPLAY selectionné
 243       """
 244       if self.JDCDisplay_courant :
 245          self.JDCDisplay_courant.jdc.close()
 246
 247    def closeSelectedJDC (self) :
 248       """
 249       Ferme le JDC courant et détruit l'onglet associé dans le notebook self.nb
 250       """
 251       if self.JDCDisplay_courant.modified == 'o' :
 252           message = "Voulez-vous sauvegarder le jeu de commandes "+self.JDC.nom+" courant ?"
 253           reponse = askyesno(title="Sauvegarde du jdc courant",
 254                              message=message)
 255           if reponse :
 256               test = self.saveJDC()
 257               if test == 0 :
 258                   self.appli.affiche_infos("Sauvegarde impossible")
 259                   return
 260       self.JDCDisplay_courant.jdc.supprime()
 261       self.liste_JDCDisplay.remove(self.JDCDisplay_courant)
 262       self.nb.delete(self.nb.getcurselection())
 263       #XXX CCAR: pour le moment mis en commentaire
 264       #self.JDC.unset_context()
 265       self.JDC = None
 266       try:
 267           index = self.nb.index(self.nb.getcurselection())
 268           self.JDCDisplay_courant = self.liste_JDCDisplay[index]
 269           self.JDC = self.JDCDisplay_courant.jdc
 270       except:
 271           self.JDCDisplay_courant = None
 272           self.appli.toolbar.inactive_boutons()
 273
 274    def visuCRJDC(self,event=None):
 275       return self.visuCR(mode='JDC')
 276
 277    def visuCR(self,mode):
 278       """
 279       Méthode permettant l'affichage du rapport de validation
 280       """
 281       if mode == 'JDC':
 282           if not hasattr(self,'JDC') : return
 283           titre="rapport de validation du jeu de commandes courant"
 284           cr = self.JDC.report()
 285           #self.update_jdc_courant()
 286       elif mode == 'CATA':
 287           from Noyau.N_CR import CR
 288           cr = CR()
 289           cr.debut = "Début rapport de validation du catalogue"
 290           cr.fin = "Fin rapport de validation du catalogue"
 291           titre="rapport de validation du catalogue"
 292           if hasattr(self,'cata_ordonne_cr') :
 293               cr.add(self.cata_ordonne_cr)
 294           if hasattr(self,'cata_dev_ordonne_cr') :
 295               cr.add(self.cata_dev_ordonne_cr)
 296           for cata in self.cata:
 297               if hasattr(cata,'JdC'):
 298                   cr.add(cata.JdC.report())
 299       texte_cr = str(cr)
 300       self.visu_texte_cr = Fenetre(self.appli,titre=titre,texte=texte_cr)
 301
 302    def openJDC(self,event=None,file=None,units=None):
 303       """
 304           Demande à l'utilisateur quel JDC existant il veut ouvrir
 305       """
 306       if self.code == 'ASTER':
 307           filetypes = ( ("format "+self.appli.format_fichier.get(), ".comm"),("Tous",'*'))
 308       elif self.code == 'HOMARD' :
 309           filetypes = ( ("format "+self.appli.format_fichier.get(), ".py"),("Tous",'*'))
 310       else:
 311           filetypes = ( ("format "+self.appli.format_fichier.get(), ".py"),)
 312       if not hasattr(self,'initialdir'):
 313          self.initialdir = self.appli.CONFIGURATION.initialdir
 314
 315       if not file :
 316           file = askopenfilename(title="Ouverture d'un fichier de commandes Aster",
 317                                  defaultextension=".comm",
 318                                  filetypes = filetypes,
 319                                  initialdir = self.initialdir)
 320       if file :
 321           self.fileName = file
 322           e=extension_fichier(file)
 323           self.JDCName=stripPath(file)
 324           self.initialdir = os.path.dirname(os.path.abspath(file))
 325       else :
 326           return
 327
 328       format=self.appli.format_fichier.get()
 329       # Il faut convertir le contenu du fichier en fonction du format
 330       if convert.plugins.has_key(format):
 331          # Le convertisseur existe on l'utilise
 332          p=convert.plugins[format]()
 333          p.readfile(file)
 334          text=p.convert('exec',self.appli)
 335          if not p.cr.estvide():
 336             self.appli.affiche_infos("Erreur à la conversion")
 337             Fenetre(self.appli,
 338                     titre="compte-rendu d'erreurs, EFICAS ne sait pas convertir ce fichier",
 339                     texte = str(p.cr)).wait()
 340             return
 341       else:
 342          # Il n'existe pas c'est une erreur
 343          self.appli.affiche_infos("Type de fichier non reconnu")
 344          showerror("Type de fichier non reconnu","EFICAS ne sait pas ouvrir ce type de fichier")
 345          return
 346
 347       # On se met dans le repertoire ou se trouve le fichier de commandes
 348       # pour trouver les eventuels fichiers include ou autres
 349       # localises a cote du fichier de commandes
 350       os.chdir(self.initialdir)
 351       CONTEXT.unset_current_step()
 352       J=self.cata[0].JdC(procedure=text,appli=self.appli,
 353                          cata=self.cata,cata_ord_dico=self.cata_ordonne_dico,
 354                          nom = self.JDCName,
 355                          rep_mat=self.appli.CONFIGURATION.rep_mat,
 356                          )
 357       if units is not None:
 358          J.recorded_units=units
 359          J.old_recorded_units=units
 360
 361       J.analyse()
 362       txt_exception = J.cr.get_mess_exception()
 363       if txt_exception :
 364           # des exceptions ont été levées à la création du JDC
 365           # --> on affiche les erreurs mais pas le JDC
 366           self.JDC=J
 367           self.appli.affiche_infos("Erreur fatale au chargement de %s" %file)
 368           if self.appli.test == 0 :
 369              showerror("Erreur fatale au chargement d'un fichier",txt_exception)
 370       else:
 371           self.ShowJDC(J,self.JDCName)
 372           self.appli.toolbar.active_boutons()
 373           # si le JDC ne contient rien (vide), on retourne ici
 374           if len(self.JDC.etapes) == 0 : return
 375           # dans le cas où le JDC est invalide, on affiche son CR
 376           if not self.JDC.isvalid():
 377              self.appli.top.update()
 378              self.visuCR(mode='JDC')
 379
 380    def GetLabelJDC(self,nb_jdc = 'absent'):
 381       """
 382       Retourne le label de l'onglet du NoteBook associé au JDC à afficher
 383       """
 384       if nb_jdc == 'absent':
 385           nb_jdc = len(self.nb.pagenames())
 386       nb_jdc = nb_jdc+1
 387       label_onglet = 'JDC'+`nb_jdc`
 388       if label_onglet not in self.nb.pagenames() :
 389           return label_onglet
 390       else :
 391           return self.GetLabelJDC(nb_jdc)
 392
 393    def saveasJDC(self,event=None):
 394       """
 395            Sauvegarde le JDC courant en demandant impérativement à l'utilisateur de
 396            donner le nom du fichier de sauvegarde
 397       """
 398       self.saveJDC(echo='oui')
 399
 400    def saveJDC(self,echo='non'):
 401       """
 402           Sauvegarde le JDC courant.
 403           Retourne 1 si la sauvegarde s'est bien faite, 0 sinon.
 404           Si echo = 'oui' : interactif (l'utilisateur donne le nom sous lequel il
 405                             veut sauver le JDC
 406           Si echo = 'non' : muet (sauvegarde le JDC dans JDC.procedure)
 407       """
 408       if not hasattr(self,'JDC') : return 0
 409       format=self.appli.format_fichier.get()
 410       if generator.plugins.has_key(format):
 411          # Le generateur existe on l'utilise
 412          g=generator.plugins[format]()
 413          jdc_formate=g.gener(self.JDC,format='beautifie')
 414          if format == 'homard':
 415             self.jdc_homard=g.get_homard()
 416          if not g.cr.estvide():
 417             self.appli.affiche_infos("Erreur à la generation")
 418             showerror("Erreur à la generation","EFICAS ne sait pas convertir ce JDC")
 419             return
 420       else:
 421          # Il n'existe pas c'est une erreur
 422          self.appli.affiche_infos("Format %s non reconnu" % format)
 423          showerror("Format %s non reconnu" % format,"EFICAS ne sait pas convertir le JDC")
 424          return
 425       self.jdc_fini = string.replace(jdc_formate,'\r\n','\n')
 426
 427       if echo =='oui' or self.JDCDisplay_courant.fichier == None:
 428           return self.asknomsauvegardeJDC()
 429       elif self.JDCDisplay_courant.fichier != None :
 430           #PN  Ajout --> Salome
 431           # Pour sauvegarde dans l etude si lancement depuis salome
 432           if self.appli.salome != 0:
 433              import eficasEtude
 434              self.appli.salome.rangeInStudy(self.JDCDisplay_courant.fichier)
 435              from panelsSalome import SALOME_UNIQUE_BASE_Panel
 436              if len(SALOME_UNIQUE_BASE_Panel.dict_fichier_unite) > 0 :
 437                 self.appli.salome.creeConfigTxt(self.appli.CONFIGURATION.initialdir,SALOME_UNIQUE_BASE_Panel.dict_fichier_unite)
 438              try :
 439              #if ( 1 == 1 ) :
 440                 import eficasCL
 441                 MyCLinit=eficasCL.CLinit()
 442                 MyCLinit.traiteCL()
 443              except :
 444              #else :
 445                 pass
 446           #PN  Fin Ajout --> Salome
 447           # le JDC a déjà un nom : on sauvegarde directement sans demander
 448           # un autre nom au développeur
 449           if not save_in_file(self.JDCDisplay_courant.fichier,self.jdc_fini) :
 450               showinfo("Erreur","Problème à la sauvegarde du fichier :" + `self.JDCDisplay_courant.fichier`)
 451               return 0
 452           else :
 453               if self.appli.format_fichier.get() == 'homard':
 454                   self.save_homard(self.JDCDisplay_courant.fichier,self.jdc_homard)
 455               self.JDCDisplay_courant.stop_modif()
 456               self.appli.affiche_infos("sauvegarde de "+`self.JDCDisplay_courant.fichier`+" effectuée")
 457               return 1
 458
 459    def asknomsauvegardeJDC(self):
 460       """ Demande à l'utilsateur le nom sous lequel il veut sauvegarder le JDC courant """
 461       titre = "Sauvegarde d'un fichier de commandes "+self.code
 462       if self.code == 'ASTER':
 463           defext = ".comm"
 464           filtyp = ( ("ASTER", ".comm"),)
 465       else :
 466           defext = ".py"
 467           filtyp = ( (self.code, ".py"),)
 468       sauvegarde = asksaveasfilename(title=titre,
 469                                      defaultextension=defext,
 470                                      filetypes = filtyp,
 471                                      initialdir = self.appli.CONFIGURATION.initialdir)
 472                                      #initialdir = self.appli.CONFIGURATION.rep_user)
 473       if sauvegarde :
 474           # PN ajout --> Salome
 475           # Pour sauvegarde dans l etude si lancement depuis salome
 476           if self.appli.salome != 0:
 477              import eficasEtude
 478              self.appli.salome.rangeInStudy(sauvegarde)
 479              from panelsSalome import SALOME_UNIQUE_BASE_Panel
 480              if len(SALOME_UNIQUE_BASE_Panel.dict_fichier_unite) > 0 :
 481                 self.appli.salome.creeConfigTxt(self.appli.CONFIGURATION.initialdir,SALOME_UNIQUE_BASE_Panel.dict_fichier_unite)
 482              #try :
 483              if ( 1 == 1 ):
 484                 import eficasCL
 485                 MyCLinit=eficasCL.CLinit()
 486                 MyCLinit.traiteCL()
 487              #except :
 488              else :
 489                 pass
 490           # PN fin ajout --> Salome
 491           if not save_in_file(sauvegarde,self.jdc_fini) :
 492               showinfo("Erreur","Problème à la sauvegarde du fichier "+`sauvegarde`)
 493               return 0
 494           else :
 495               if self.appli.format_fichier.get() == 'homard':
 496                   self.save_homard(sauvegarde,self.jdc_homard)
 497               self.JDCDisplay_courant.stop_modif()
 498               self.appli.affiche_infos("Sauvegarde effectuée")
 499               if sauvegarde != self.JDCDisplay_courant.fichier :
 500                   # l'utilisateur a sauvegardé le JDC sous un autre nom
 501                   self.JDCDisplay_courant.fichier = sauvegarde
 502                   self.JDCName = self.JDC.nom = stripPath(sauvegarde)
 503                   self.JDC.changefichier(sauvegarde)
 504                   self.changeNomPage()
 505               return 1
 506       else :
 507           return 0
 508
 509    def changeNomPage(self):
 510       """ Change le nom de l'onglet contenant le JDC courant : en fait détruit l'actuel
 511           et recrée un autre onglet à la même place avec le bon nom
 512       """
 513       nom = self.JDCName
 514       self.JDCDisplay_courant.jdc.nom = nom
 515       nom_page = self.nb.getcurselection()
 516       num_page = self.nb.index(nom_page)
 517       tab = self.nb.tab(num_page)
 518       tab.configure(text = nom)
 519
 520    def exitEFICAS(self,event=None):
 521       """
 522           Permet de sortir d'EFICAS en demandant à l'utilisateur
 523           s'il veut sauvegarder les modifications en cours
 524       """
 525       liste = self.GetListeJDCaSauvegarder()
 526       if liste != [] :
 527           # Certains fichiers n'ont pas été sauvegardés ...
 528           if askyesno("Enregistrer modifications","Enregistrer les modifications ?") :
 529               test = self.saveall(liste)
 530               if test != 1 :
 531                   return
 532       if askyesno ("Quitter","Voulez-vous vraiment quitter l'application ?") :
 533           for JDCDisplay in self.liste_JDCDisplay:
 534               JDCDisplay.jdc.supprime()
 535           self.appli.quit()
 536           return
 537
 538    def GetListeJDCaSauvegarder(self) :
 539       """ Retourne parmi la liste de tous les JDC ouverts la liste de ceux qui ont été modifiés """
 540       if not self.JDCDisplay_courant : return []
 541       if len(self.liste_JDCDisplay) == 0 : return l
 542       l = []
 543       for JDCDisplay in self.liste_JDCDisplay:
 544           if JDCDisplay.modified == 'o' :
 545               l.append(JDCDisplay)
 546       return l
 547
 548    def copy(self,event=None):
 549       """
 550           Lance la copie sur le JDC courant
 551       """
 552       if self.JDCDisplay_courant : self.JDCDisplay_courant.doCopy()
 553
 554    def paste(self,event=None):
 555       """
 556            Lance le collage sur le JDC courant
 557       """
 558       if self.JDCDisplay_courant : self.JDCDisplay_courant.doPaste()
 559
 560    def cut(self,event=None):
 561       """
 562          Lance le cut sur le JDC courant
 563       """
 564       if self.JDCDisplay_courant: self.JDCDisplay_courant.doCut()
 565
 566    def delete(self):
 567       """
 568           Lance la suppression du noeud courant
 569       """
 570       if not self.JDCDisplay_courant : return
 571       self.JDCDisplay_courant.init_modif()
 572       self.JDCDisplay_courant.node_selected.delete()
 573
 574    def visuJDC_py(self,event=None):
 575       """
 576           Méthode permettant d'afficher dans une fenêtre à part l'écho au
 577             format python du jdc courant
 578       """
 579       if not hasattr(self,'JDC') : return
 580       jdc_fini = self.get_text_JDC('python')
 581       if jdc_fini == None : return
 582       Fenetre(self.appli,
 583               titre = 'fichier '+ self.JDCName + ' à la syntaxe Python',
 584               texte = jdc_fini)
 585
 586    def visuJDC(self):
 587       """
 588           Méthode permettant d'afficher dans une fenêtre à part l'écho au
 589             format .comm ou .py du jdc courant
 590       """
 591       if not hasattr(self,'JDC') : return
 592       titre = 'fichier '+ self.JDCName + ' à la syntaxe '+ self.code
 593       format=self.appli.format_fichier.get()
 594       self.jdc_fini = self.get_text_JDC(format)
 595       if self.jdc_fini == None : return
 596       self.visu_fichier_cmd = Fenetre(self.appli,titre=titre,texte = self.jdc_fini)
 597
 598    def get_text_JDC(self,format):
 599       if generator.plugins.has_key(format):
 600          # Le generateur existe on l'utilise
 601          g=generator.plugins[format]()
 602          jdc_formate=g.gener(self.JDC,format='beautifie')
 603          if not g.cr.estvide():
 604             self.appli.affiche_infos("Erreur à la generation")
 605             showerror("Erreur à la generation","EFICAS ne sait pas convertir ce JDC")
 606             return
 607          else:
 608             return jdc_formate
 609       else:
 610          # Il n'existe pas c'est une erreur
 611          self.appli.affiche_infos("Format %s non reconnu" % format)
 612          showerror("Format %s non reconnu" % format,"EFICAS ne sait pas convertir le JDC en format %s "% format)
 613          return
 614
 615    def view_doc(self):
 616       """
 617           Permet d'ouvrir le fichier doc U de la commande au format pdf avec Acrobat Reader
 618           - Ne fonctionne pas sous UNIX (chemin d'accès Acrobat Reader)
 619           - indication du chemin d'accès aux fichiers pdf à revoir : trop statique
 620       """
 621       if not self.JDCDisplay_courant : return
 622       try:
 623           cle_doc = self.JDCDisplay_courant.node_selected.item.get_docu()
 624           if cle_doc == None : return
 625           cle_doc = string.replace(cle_doc,'.','')
 626           cle_doc = string.replace(cle_doc,'-','')
 627           commande = self.appli.CONFIGURATION.exec_acrobat
 628           nom_fichier = cle_doc+".pdf"
 629           rep_fichier = cle_doc[0:2]
 630           fichier = os.path.abspath(os.path.join(self.appli.CONFIGURATION.path_doc,rep_fichier,nom_fichier))
 631           if os.name == 'nt':
 632               os.spawnv(os.P_NOWAIT,commande,(commande,fichier,))
 633           elif os.name == 'posix':
 634               script ="#!/usr/bin/sh \n%s %s&" %(commande,fichier)
 635               pid = os.system(script)
 636       except AttributeError:
 637           traceback.print_exc()
 638           pass
 639
 640    def visu_a_plat(self,event=None):
 641       """
 642           Méthode permettant d'afficher dans une fenêtre à part l'écho 'à plat' du jdc courant
 643       """
 644       if not hasattr(self,'JDC') : return
 645       titre = 'fichier '+ self.JDCName + ' à plat '
 646       self.jdc_fini = self.get_text_JDC('aplat')
 647       if self.jdc_fini == None : return
 648       self.visu_fichier_cmd = Fenetre(self.appli,titre=titre,texte = self.jdc_fini)
 649
 650    def visu_txt_brut_JDC(self,event=None):
 651       """
 652            Méthode permettant d'afficher le jeu de commandes tel qu'il a été passé au JDC
 653       """
 654       if not hasattr(self,'JDC') : return
 655       titre = "fichier de commandes utilisateur"
 656       #texte = self.JDC.procedure
 657       #if texte == None:
 658       if self.JDCDisplay_courant.fichier == None:
 659             self.appli.affiche_infos("Pas de fichier initial")
 660             showerror("Impossible de visualiser le fichier initial",
 661                       "EFICAS ne peut visualiser le fichier initial.\nIl s'agit d'un nouveau JDC")
 662             return
 663       f=open(self.JDCDisplay_courant.fichier,'r')
 664       texte=f.read()
 665       f.close()
 666       self.visu_texte_JDC = Fenetre(self.appli,titre=titre,texte=texte)
 667
 668    def affichage_fichier_ini(self):
 669       """
 670            Affichage des valeurs des paramètres relus par Eficas
 671       """
 672       self.appli.CONFIGURATION.affichage_fichier_ini()
 673
 674    def saveall(self,liste):
 675       """
 676            Sauvegarde tous les JDC contenus dans liste
 677       """
 678       test = 1
 679       for JDCDisplay in liste :
 680           self.JDCDisplay_courant=JDCDisplay
 681           self.JDC = JDCDisplay.jdc
 682           test = test * self.saveJDC(echo = 'non')
 683       return test
 684
 685    def save_homard(self,nom,texte):
 686        file_homard=nom+'.conf_homard'
 687        try:
 688            f=open(file_homard,'w')
 689            for ligne in texte:
 690                f.write(ligne)
 691                f.write('\n')
 692            f.close()
 693        except:
 694            print "Pb a la sauvegarde sous le format homard"
 695        if self.appli.salome != 0:
 696            import eficasEtude
 697            self.appli.salome.rangeInStudy(file_homard,"_CONF")
 698
 699 # ---------------------------------------------------------------------------
 700 #                       Méthodes liées aux mots-clés inconnus
 701 # ---------------------------------------------------------------------------
 702
 703    def mc_inconnus(self):
 704       l_mc = self.JDCDisplay_courant.jdc.get_liste_mc_inconnus()
 705       o = fenetre_mc_inconnus(l_mc)
 706       l = o.wait_new_list()
 707       #print "mc_inconnus_new_list: ",l
 708       #CCAR: Il n' y a pas de retour vers le JDC
 709
 710    def aideEFICAS(self,event=None):
 711       AIDE.go(master=self.parent)
 712
 713    def update_jdc_courant(self):
 714       self.JDCDisplay_courant.update()
 715