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