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(), ".comm"),("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       else:
 345          # Il n'existe pas c'est une erreur
 346          self.appli.affiche_infos("Type de fichier non reconnu")
 347          showerror("Type de fichier non reconnu","EFICAS ne sait pas ouvrir ce type de fichier")
 348          return
 349
 350       # On se met dans le repertoire ou se trouve le fichier de commandes
 351       # pour trouver les eventuels fichiers include ou autres
 352       # localises a cote du fichier de commandes
 353       os.chdir(self.initialdir)
 354       CONTEXT.unset_current_step()
 355       J=self.cata[0].JdC(procedure=text,appli=self.appli,
 356                          cata=self.cata,cata_ord_dico=self.cata_ordonne_dico,
 357                          nom = self.JDCName,
 358                          rep_mat=self.appli.CONFIGURATION.rep_mat,
 359                          )
 360       if units is not None:
 361          J.recorded_units=units
 362          J.old_recorded_units=units
 363
 364       J.analyse()
 365       txt_exception = J.cr.get_mess_exception()
 366       if txt_exception :
 367           # des exceptions ont été levées à la création du JDC
 368           # --> on affiche les erreurs mais pas le JDC
 369           self.JDC=J
 370           self.appli.affiche_infos("Erreur fatale au chargement de %s" %file)
 371           if self.appli.test == 0 :
 372              showerror("Erreur fatale au chargement d'un fichier",txt_exception)
 373       else:
 374           self.ShowJDC(J,self.JDCName)
 375           self.appli.toolbar.active_boutons()
 376           # si le JDC ne contient rien (vide), on retourne ici
 377           if len(self.JDC.etapes) == 0 : return
 378           # dans le cas où le JDC est invalide, on affiche son CR
 379           if not self.JDC.isvalid():
 380              self.appli.top.update()
 381              self.visuCR(mode='JDC')
 382
 383    def GetLabelJDC(self,nb_jdc = 'absent'):
 384       """
 385       Retourne le label de l'onglet du NoteBook associé au JDC à afficher
 386       """
 387       if nb_jdc == 'absent':
 388           nb_jdc = len(self.nb.pagenames())
 389       nb_jdc = nb_jdc+1
 390       label_onglet = 'JDC'+`nb_jdc`
 391       if label_onglet not in self.nb.pagenames() :
 392           return label_onglet
 393       else :
 394           return self.GetLabelJDC(nb_jdc)
 395
 396    def saveasJDC(self,event=None):
 397       """
 398            Sauvegarde le JDC courant en demandant impérativement à l'utilisateur de
 399            donner le nom du fichier de sauvegarde
 400       """
 401       self.saveJDC(echo='oui')
 402
 403    def saveJDC(self,echo='non'):
 404       """
 405           Sauvegarde le JDC courant.
 406           Retourne 1 si la sauvegarde s'est bien faite, 0 sinon.
 407           Si echo = 'oui' : interactif (l'utilisateur donne le nom sous lequel il
 408                             veut sauver le JDC
 409           Si echo = 'non' : muet (sauvegarde le JDC dans JDC.procedure)
 410       """
 411       if not hasattr(self,'JDC') : return 0
 412       format=self.appli.format_fichier.get()
 413       if generator.plugins.has_key(format):
 414          # Le generateur existe on l'utilise
 415          g=generator.plugins[format]()
 416          jdc_formate=g.gener(self.JDC,format='beautifie')
 417          if format == 'homard':
 418             self.jdc_homard=g.get_homard()
 419          if not g.cr.estvide():
 420             self.appli.affiche_infos("Erreur à la generation")
 421             showerror("Erreur à la generation","EFICAS ne sait pas convertir ce JDC")
 422             return
 423       else:
 424          # Il n'existe pas c'est une erreur
 425          self.appli.affiche_infos("Format %s non reconnu" % format)
 426          showerror("Format %s non reconnu" % format,"EFICAS ne sait pas convertir le JDC")
 427          return
 428       self.jdc_fini = string.replace(jdc_formate,'\r\n','\n')
 429
 430       if echo =='oui' or self.JDCDisplay_courant.fichier == None:
 431           return self.asknomsauvegardeJDC()
 432       elif self.JDCDisplay_courant.fichier != None :
 433           #PN  Ajout --> Salome
 434           # Pour sauvegarde dans l etude si lancement depuis salome
 435           if self.appli.salome != 0:
 436              import eficasEtude
 437              self.appli.salome.rangeInStudy(self.JDCDisplay_courant.fichier)
 438              from panelsSalome import SALOME_UNIQUE_BASE_Panel
 439              if len(SALOME_UNIQUE_BASE_Panel.dict_fichier_unite) > 0 :
 440                 self.appli.salome.creeConfigTxt(self.appli.CONFIGURATION.initialdir,SALOME_UNIQUE_BASE_Panel.dict_fichier_unite)
 441              try :
 442              #if ( 1 == 1 ) :
 443                 import eficasCL
 444                 MyCLinit=eficasCL.CLinit()
 445                 MyCLinit.traiteCL()
 446                 MyCLinit.clean()
 447              except :
 448              #else :
 449                 pass
 450           #PN  Fin Ajout --> Salome
 451           # le JDC a déjà un nom : on sauvegarde directement sans demander
 452           # un autre nom au développeur
 453           if not save_in_file(self.JDCDisplay_courant.fichier,self.jdc_fini,self.appli.dir) :
 454               showinfo("Erreur","Problème à la sauvegarde du fichier :" + `self.JDCDisplay_courant.fichier`)
 455               return 0
 456           else :
 457               if self.appli.format_fichier.get() == 'homard':
 458                   self.save_homard(self.JDCDisplay_courant.fichier,self.jdc_homard)
 459               self.JDCDisplay_courant.stop_modif()
 460               self.appli.affiche_infos("sauvegarde de "+`self.JDCDisplay_courant.fichier`+" effectuée")
 461               return 1
 462
 463    def asknomsauvegardeJDC(self):
 464       """ Demande à l'utilsateur le nom sous lequel il veut sauvegarder le JDC courant """
 465       titre = "Sauvegarde d'un fichier de commandes "+self.code
 466       if self.code == 'ASTER':
 467           defext = ".comm"
 468           filtyp = ( ("ASTER", ".comm"),)
 469       else :
 470           defext = ".py"
 471           filtyp = ( (self.code, ".py"),)
 472       sauvegarde = asksaveasfilename(title=titre,
 473                                      defaultextension=defext,
 474                                      filetypes = filtyp,
 475                                      initialdir = self.appli.CONFIGURATION.initialdir)
 476                                      #initialdir = self.appli.CONFIGURATION.rep_user)
 477       if sauvegarde :
 478           # PN ajout --> Salome
 479           # Pour sauvegarde dans l etude si lancement depuis salome
 480           if self.appli.salome != 0:
 481              import eficasEtude
 482              self.appli.salome.rangeInStudy(sauvegarde)
 483              from panelsSalome import SALOME_UNIQUE_BASE_Panel
 484              if len(SALOME_UNIQUE_BASE_Panel.dict_fichier_unite) > 0 :
 485                 self.appli.salome.creeConfigTxt(self.appli.CONFIGURATION.initialdir,SALOME_UNIQUE_BASE_Panel.dict_fichier_unite)
 486              #try :
 487              if ( 1 == 1 ):
 488                 import eficasCL
 489                 MyCLinit=eficasCL.CLinit()
 490                 MyCLinit.traiteCL()
 491                 MyCLinit.clean()
 492              #except :
 493              else :
 494                 pass
 495           # PN fin ajout --> Salome
 496           if not save_in_file(sauvegarde,self.jdc_fini,None) :
 497               showinfo("Erreur","Problème à la sauvegarde du fichier "+`sauvegarde`)
 498               return 0
 499           else :
 500               if self.appli.format_fichier.get() == 'homard':
 501                   self.save_homard(sauvegarde,self.jdc_homard)
 502               self.JDCDisplay_courant.stop_modif()
 503               self.appli.affiche_infos("Sauvegarde effectuée")
 504               if sauvegarde != self.JDCDisplay_courant.fichier :
 505                   # l'utilisateur a sauvegardé le JDC sous un autre nom
 506                   self.JDCDisplay_courant.fichier = sauvegarde
 507                   self.JDCName = self.JDC.nom = stripPath(sauvegarde)
 508                   self.JDC.changefichier(sauvegarde)
 509                   self.changeNomPage()
 510               return 1
 511       else :
 512           return 0
 513
 514    def changeNomPage(self):
 515       """ Change le nom de l'onglet contenant le JDC courant : en fait détruit l'actuel
 516           et recrée un autre onglet à la même place avec le bon nom
 517       """
 518       nom = self.JDCName
 519       self.JDCDisplay_courant.jdc.nom = nom
 520       nom_page = self.nb.getcurselection()
 521       num_page = self.nb.index(nom_page)
 522       tab = self.nb.tab(num_page)
 523       tab.configure(text = nom)
 524
 525    def exitEFICAS(self,event=None):
 526       """
 527           Permet de sortir d'EFICAS en demandant à l'utilisateur
 528           s'il veut sauvegarder les modifications en cours
 529       """
 530       liste = self.GetListeJDCaSauvegarder()
 531       if liste != [] :
 532           # Certains fichiers n'ont pas été sauvegardés ...
 533           if askyesno("Enregistrer modifications","Enregistrer les modifications ?") :
 534               test = self.saveall(liste)
 535               if test != 1 :
 536                   return
 537       if askyesno ("Quitter","Voulez-vous vraiment quitter l'application ?") :
 538           for JDCDisplay in self.liste_JDCDisplay:
 539               JDCDisplay.jdc.supprime()
 540           self.appli.quit()
 541           return
 542
 543    def GetListeJDCaSauvegarder(self) :
 544       """ Retourne parmi la liste de tous les JDC ouverts la liste de ceux qui ont été modifiés """
 545       if not self.JDCDisplay_courant : return []
 546       if len(self.liste_JDCDisplay) == 0 : return l
 547       l = []
 548       for JDCDisplay in self.liste_JDCDisplay:
 549           if JDCDisplay.modified == 'o' :
 550               l.append(JDCDisplay)
 551       return l
 552
 553    def copy(self,event=None):
 554       """
 555           Lance la copie sur le JDC courant
 556       """
 557       if self.JDCDisplay_courant : self.JDCDisplay_courant.doCopy()
 558
 559    def paste(self,event=None):
 560       """
 561            Lance le collage sur le JDC courant
 562       """
 563       if self.JDCDisplay_courant : self.JDCDisplay_courant.doPaste()
 564
 565    def cut(self,event=None):
 566       """
 567          Lance le cut sur le JDC courant
 568       """
 569       if self.JDCDisplay_courant: self.JDCDisplay_courant.doCut()
 570
 571    def delete(self):
 572       """
 573           Lance la suppression du noeud courant
 574       """
 575       if not self.JDCDisplay_courant : return
 576       self.JDCDisplay_courant.init_modif()
 577       self.JDCDisplay_courant.node_selected.delete()
 578
 579    def visuJDC_py(self,event=None):
 580       """
 581           Méthode permettant d'afficher dans une fenêtre à part l'écho au
 582             format python du jdc courant
 583       """
 584       if not hasattr(self,'JDC') : return
 585       jdc_fini = self.get_text_JDC('python')
 586       if jdc_fini == None : return
 587       Fenetre(self.appli,
 588               titre = 'fichier '+ self.JDCName + ' à la syntaxe Python',
 589               texte = jdc_fini)
 590
 591    def visuJDC(self):
 592       """
 593           Méthode permettant d'afficher dans une fenêtre à part l'écho au
 594             format .comm ou .py du jdc courant
 595       """
 596       if not hasattr(self,'JDC') : return
 597       titre = 'fichier '+ self.JDCName + ' à la syntaxe '+ self.code
 598       format=self.appli.format_fichier.get()
 599       self.jdc_fini = self.get_text_JDC(format)
 600       if self.jdc_fini == None : return
 601       self.visu_fichier_cmd = Fenetre(self.appli,titre=titre,texte = self.jdc_fini)
 602
 603    def get_text_JDC(self,format):
 604       if generator.plugins.has_key(format):
 605          # Le generateur existe on l'utilise
 606          g=generator.plugins[format]()
 607          jdc_formate=g.gener(self.JDC,format='beautifie')
 608          if not g.cr.estvide():
 609             self.appli.affiche_infos("Erreur à la generation")
 610             showerror("Erreur à la generation","EFICAS ne sait pas convertir ce JDC")
 611             return
 612          else:
 613             return jdc_formate
 614       else:
 615          # Il n'existe pas c'est une erreur
 616          self.appli.affiche_infos("Format %s non reconnu" % format)
 617          showerror("Format %s non reconnu" % format,"EFICAS ne sait pas convertir le JDC en format %s "% format)
 618          return
 619
 620    def view_doc(self):
 621       """
 622           Permet d'ouvrir le fichier doc U de la commande au format pdf avec Acrobat Reader
 623           - Ne fonctionne pas sous UNIX (chemin d'accès Acrobat Reader)
 624           - indication du chemin d'accès aux fichiers pdf à revoir : trop statique
 625       """
 626       if not self.JDCDisplay_courant : return
 627       try:
 628           cle_doc = self.JDCDisplay_courant.node_selected.item.get_docu()
 629           if cle_doc == None : return
 630           cle_doc = string.replace(cle_doc,'.','')
 631           cle_doc = string.replace(cle_doc,'-','')
 632           commande = self.appli.CONFIGURATION.exec_acrobat
 633           nom_fichier = cle_doc+".pdf"
 634           fichier = os.path.abspath(os.path.join(self.appli.CONFIGURATION.path_doc,nom_fichier))
 635           if os.name == 'nt':
 636               os.spawnv(os.P_NOWAIT,commande,(commande,fichier,))
 637           elif os.name == 'posix':
 638               script ="#!/usr/bin/sh \n%s %s&" %(commande,fichier)
 639               pid = os.system(script)
 640       except AttributeError:
 641           traceback.print_exc()
 642           pass
 643
 644    def visu_a_plat(self,event=None):
 645       """
 646           Méthode permettant d'afficher dans une fenêtre à part l'écho 'à plat' du jdc courant
 647       """
 648       if not hasattr(self,'JDC') : return
 649       titre = 'fichier '+ self.JDCName + ' à plat '
 650       self.jdc_fini = self.get_text_JDC('aplat')
 651       if self.jdc_fini == None : return
 652       self.visu_fichier_cmd = Fenetre(self.appli,titre=titre,texte = self.jdc_fini)
 653
 654    def visu_txt_brut_JDC(self,event=None):
 655       """
 656            Méthode permettant d'afficher le jeu de commandes tel qu'il a été passé au JDC
 657       """
 658       if not hasattr(self,'JDC') : return
 659       titre = "fichier de commandes utilisateur"
 660       #texte = self.JDC.procedure
 661       #if texte == None:
 662       if self.JDCDisplay_courant.fichier == None:
 663             self.appli.affiche_infos("Pas de fichier initial")
 664             showerror("Impossible de visualiser le fichier initial",
 665                       "EFICAS ne peut visualiser le fichier initial.\nIl s'agit d'un nouveau JDC")
 666             return
 667       f=open(self.JDCDisplay_courant.fichier,'r')
 668       texte=f.read()
 669       f.close()
 670       self.visu_texte_JDC = Fenetre(self.appli,titre=titre,texte=texte)
 671
 672    def affichage_fichier_ini(self):
 673       """
 674            Affichage des valeurs des paramètres relus par Eficas
 675       """
 676       self.appli.CONFIGURATION.affichage_fichier_ini()
 677
 678    def saveall(self,liste):
 679       """
 680            Sauvegarde tous les JDC contenus dans liste
 681       """
 682       test = 1
 683       for JDCDisplay in liste :
 684           self.JDCDisplay_courant=JDCDisplay
 685           self.JDC = JDCDisplay.jdc
 686           test = test * self.saveJDC(echo = 'non')
 687       return test
 688
 689    def save_homard(self,nom,texte):
 690        file_homard=nom+'.conf_homard'
 691        try:
 692            f=open(file_homard,'w')
 693            for ligne in texte:
 694                f.write(ligne)
 695                f.write('\n')
 696            f.close()
 697        except:
 698            print "Pb a la sauvegarde sous le format homard"
 699        if self.appli.salome != 0:
 700            import eficasEtude
 701            self.appli.salome.rangeInStudy(file_homard,"_CONF")
 702
 703 # ---------------------------------------------------------------------------
 704 #                       Méthodes liées aux mots-clés inconnus
 705 # ---------------------------------------------------------------------------
 706
 707    def mc_inconnus(self):
 708       l_mc = self.JDCDisplay_courant.jdc.get_liste_mc_inconnus()
 709       o = fenetre_mc_inconnus(l_mc)
 710       l = o.wait_new_list()
 711       #print "mc_inconnus_new_list: ",l
 712       #CCAR: Il n' y a pas de retour vers le JDC
 713
 714    def aideEFICAS(self,event=None):
 715       AIDE.go(master=self.parent)
 716
 717    def update_jdc_courant(self):
 718       self.JDCDisplay_courant.update()
 719