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