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