Editeur/bureau.py

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