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