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 format == 'homard':
 343             self.jdc_homard=g.get_homard()
 344          if not g.cr.estvide():
 345             print g.cr
 346             self.appli.affiche_infos("Erreur à la generation")
 347             showerror("Erreur à la generation","EFICAS ne sait pas convertir ce JDC")
 348             return
 349       else:
 350          # Il n'existe pas c'est une erreur
 351          self.appli.affiche_infos("Format %s non reconnu" % format)
 352          showerror("Format %s non reconnu" % format,"EFICAS ne sait pas convertir le JDC")
 353          return
 354       self.jdc_fini = string.replace(jdc_formate,'\r\n','\n')
 355
 356       if echo =='oui' or self.JDCDisplay_courant.fichier == None:
 357           return self.asknomsauvegardeJDC()
 358       elif self.JDCDisplay_courant.fichier != None :
 359           #PN  Ajout --> Salome
 360           # Pour sauvegarde dans l etude si lancement depuis salome
 361           if self.appli.salome != 0:
 362              import eficas_etude
 363              self.appli.salome.rangeInStudy(self.JDCDisplay_courant.fichier)
 364              from panelsSalome import SALOME_UNIQUE_BASE_Panel
 365              if len(SALOME_UNIQUE_BASE_Panel.dict_fichier_unite) > 0 :
 366                 self.appli.salome.creeConfigTxt(self.appli.CONFIGURATION.initialdir,SALOME_UNIQUE_BASE_Panel.dict_fichier_unite)
 367           #PN  Fin Ajout --> Salome
 368           # le JDC a déjà un nom : on sauvegarde directement sans demander
 369           # un autre nom au développeur
 370           if not save_in_file(self.JDCDisplay_courant.fichier,self.jdc_fini) :
 371               showinfo("Erreur","Problème à la sauvegarde du fichier :" + `self.JDCDisplay_courant.fichier`)
 372               return 0
 373           else :
 374               if self.appli.format_fichier.get() == 'homard':
 375                   self.save_homard(self.JDCDisplay_courant.fichier,self.jdc_homard)
 376               self.JDCDisplay_courant.stop_modif()
 377               self.appli.affiche_infos("sauvegarde de "+`self.JDCDisplay_courant.fichier`+" effectuée")
 378               return 1
 379
 380    def asknomsauvegardeJDC(self):
 381       """ Demande à l'utilsateur le nom sous lequel il veut sauvegarder le JDC courant """
 382       titre = "Sauvegarde d'un fichier de commandes "+self.code
 383       if self.code == 'ASTER':
 384           defext = ".comm"
 385           filtyp = ( ("ASTER", ".comm"),)
 386       else :
 387           defext = ".py"
 388           filtyp = ( (self.code, ".py"),)
 389       sauvegarde = asksaveasfilename(title=titre,
 390                                      defaultextension=defext,
 391                                      filetypes = filtyp,
 392                                      initialdir = self.appli.CONFIGURATION.initialdir)
 393                                      #initialdir = self.appli.CONFIGURATION.rep_user)
 394       if sauvegarde :
 395           # PN ajout --> Salome
 396           # Pour sauvegarde dans l etude si lancement depuis salome
 397           if self.appli.salome != 0:
 398              import eficas_etude
 399              self.appli.salome.rangeInStudy(sauvegarde)
 400              from panelsSalome import SALOME_UNIQUE_BASE_Panel
 401              if len(SALOME_UNIQUE_BASE_Panel.dict_fichier_unite) > 0 :
 402                 self.appli.salome.creeConfigTxt(self.appli.CONFIGURATION.initialdir,SALOME_UNIQUE_BASE_Panel.dict_fichier_unite)
 403           # PN fin ajout --> Salome
 404           if not save_in_file(sauvegarde,self.jdc_fini) :
 405               showinfo("Erreur","Problème à la sauvegarde du fichier "+`sauvegarde`)
 406               return 0
 407           else :
 408               if self.appli.format_fichier.get() == 'homard':
 409                   self.save_homard(sauvegarde,self.jdc_homard)
 410               self.JDCDisplay_courant.stop_modif()
 411               self.appli.affiche_infos("Sauvegarde effectuée")
 412               if sauvegarde != self.JDCDisplay_courant.fichier :
 413                   # l'utilisateur a sauvegardé le JDC sous un autre nom
 414                   self.JDCDisplay_courant.fichier = sauvegarde
 415                   self.JDCName = self.JDC.nom = stripPath(sauvegarde)
 416                   self.changeNomPage()
 417               return 1
 418       else :
 419           return 0
 420
 421    def changeNomPage(self):
 422       """ Change le nom de l'onglet contenant le JDC courant : en fait détruit l'actuel
 423           et recrée un autre onglet à la même place avec le bon nom
 424       """
 425       nom = self.JDCName
 426       self.JDCDisplay_courant.jdc.nom = nom
 427       nom_page = self.nb.getcurselection()
 428       num_page = self.nb.index(nom_page)
 429       tab = self.nb.tab(num_page)
 430       tab.configure(text = nom)
 431
 432    def exitEFICAS(self,event=None):
 433       """
 434           Permet de sortir d'EFICAS en demandant à l'utilisateur
 435           s'il veut sauvegarder les modifications en cours
 436       """
 437       liste = self.GetListeJDCaSauvegarder()
 438       if liste != [] :
 439           # Certains fichiers n'ont pas été sauvegardés ...
 440           if askyesno("Enregistrer modifications","Enregister les modifications ?") :
 441               test = self.saveall(liste)
 442               if test != 1 :
 443                   return
 444       if askyesno ("Quitter","Voulez-vous vraiment quitter l'application ?") :
 445           for JDCDisplay in self.liste_JDCDisplay:
 446               JDCDisplay.jdc.supprime()
 447           self.appli.quit()
 448           return
 449
 450    def GetListeJDCaSauvegarder(self) :
 451       """ Retourne parmi la liste de tous les JDC ouverts la liste de ceux qui ont été modifiés """
 452       if not self.JDCDisplay_courant : return []
 453       if len(self.liste_JDCDisplay) == 0 : return l
 454       l = []
 455       for JDCDisplay in self.liste_JDCDisplay:
 456           if JDCDisplay.modified == 'o' :
 457               l.append(JDCDisplay)
 458       return l
 459
 460    def copy(self,event=None):
 461       """
 462           Lance la copie sur le JDC courant
 463       """
 464       if self.JDCDisplay_courant : self.JDCDisplay_courant.doCopy()
 465
 466    def paste(self,event=None):
 467       """
 468            Lance le collage sur le JDC courant
 469       """
 470       if self.JDCDisplay_courant : self.JDCDisplay_courant.doPaste()
 471
 472    def cut(self,event=None):
 473       """
 474          Lance le cut sur le JDC courant
 475       """
 476       if self.JDCDisplay_courant: self.JDCDisplay_courant.doCut()
 477
 478    def delete(self):
 479       """
 480           Lance la suppression du noeud courant
 481       """
 482       if not self.JDCDisplay_courant : return
 483       try:
 484           if self.JDCDisplay_courant.modified == 'n' :
 485              self.JDCDisplay_courant.init_modif()
 486           pere = self.JDCDisplay_courant.node_selected.parent
 487           # Le noeud n'est pas au 1er niveau
 488           if  pere.parent.parent != None:
 489               self.JDCDisplay_courant.node_selected.delete()
 490               pere.select()
 491           else:
 492               noeudselecte = self.JDCDisplay_courant.node_selected
 493               parent = noeudselecte.parent
 494               enfants = parent.children
 495               index = enfants.index(noeudselecte)
 496               self.JDCDisplay_courant.node_selected.delete()
 497               try:
 498                 enfants[index].select()
 499               except :
 500                 enfants[index-1].select()
 501       except AttributeError:
 502           pass
 503
 504    def visuJDC_py(self):
 505       """
 506           Méthode permettant d'afficher dans une fenêtre à part l'écho au
 507             format python du jdc courant
 508       """
 509       if not hasattr(self,'JDC') : return
 510       jdc_fini = self.get_text_JDC('python')
 511       if jdc_fini == None : return
 512       Fenetre(self.appli,
 513               titre = 'fichier '+ self.JDCName + ' à la syntaxe Python',
 514               texte = jdc_fini)
 515
 516    def visuJDC(self):
 517       """
 518           Méthode permettant d'afficher dans une fenêtre à part l'écho au
 519             format .comm ou .py du jdc courant
 520       """
 521       if not hasattr(self,'JDC') : return
 522       titre = 'fichier '+ self.JDCName + ' à la syntaxe '+ self.code
 523       format=self.appli.format_fichier.get()
 524       self.jdc_fini = self.get_text_JDC(format)
 525       if self.jdc_fini == None : return
 526       self.visu_fichier_cmd = Fenetre(self.appli,titre=titre,texte = self.jdc_fini)
 527
 528    def get_text_JDC(self,format):
 529       if generator.plugins.has_key(format):
 530          # Le generateur existe on l'utilise
 531          g=generator.plugins[format]()
 532          jdc_formate=g.gener(self.JDC,format='beautifie')
 533          if not g.cr.estvide():
 534             print g.cr
 535             self.appli.affiche_infos("Erreur à la generation")
 536             showerror("Erreur à la generation","EFICAS ne sait pas convertir ce JDC")
 537             return
 538          else:
 539             return jdc_formate
 540       else:
 541          # Il n'existe pas c'est une erreur
 542          self.appli.affiche_infos("Format %s non reconnu" % format)
 543          showerror("Format %s non reconnu" % format,"EFICAS ne sait pas convertir le JDC en format %s "% format)
 544          return
 545
 546    def view_doc(self):
 547       """
 548           Permet d'ouvrir le fichier doc U de la commande au format pdf avec Acrobat Reader
 549           - Ne fonctionne pas sous UNIX (chemin d'accès Acrobat Reader)
 550           - indication du chemin d'accès aux fichiers pdf à revoir : trop statique
 551       """
 552       if not self.JDCDisplay_courant : return
 553       try:
 554           cle_doc = self.JDCDisplay_courant.node_selected.item.get_docu()
 555           if cle_doc == None : return
 556           cle_doc = string.replace(cle_doc,'.','')
 557           cle_doc = string.replace(cle_doc,'-','')
 558           commande = self.appli.CONFIGURATION.exec_acrobat
 559           nom_fichier = cle_doc+".pdf"
 560           rep_fichier = cle_doc[0:2]
 561           fichier = os.path.abspath(os.path.join(self.appli.CONFIGURATION.path_doc,rep_fichier,nom_fichier))
 562           if os.name == 'nt':
 563               os.spawnv(os.P_NOWAIT,commande,(commande,fichier,))
 564           elif os.name == 'posix':
 565               script ="#!/usr/bin/sh \n%s %s&" %(commande,fichier)
 566               pid = os.system(script)
 567       except AttributeError:
 568           traceback.print_exc()
 569           pass
 570
 571    def visu_a_plat(self,event=None):
 572       """
 573           Méthode permettant d'afficher dans une fenêtre à part l'écho 'à plat' du jdc courant
 574       """
 575       if not hasattr(self,'JDC') : return
 576       titre = 'fichier '+ self.JDCName + ' à plat '
 577       self.jdc_fini = self.get_text_JDC('aplat')
 578       if self.jdc_fini == None : return
 579       self.visu_fichier_cmd = Fenetre(self.appli,titre=titre,texte = self.jdc_fini)
 580
 581    def visu_txt_brut_JDC(self,event=None):
 582       """
 583            Méthode permettant d'afficher le jeu de commandes tel qu'il a été passé au JDC
 584       """
 585       if not hasattr(self,'JDC') : return
 586       titre = "fichier de commandes utilisateur"
 587       #texte = self.JDC.procedure
 588       #if texte == None:
 589       if self.JDCDisplay_courant.fichier == None:
 590             self.appli.affiche_infos("Pas de fichier initial")
 591             showerror("Impossible de visualiser le fichier initial",
 592                       "EFICAS ne peut visualiser le fichier initial.\nIl s'agit d'un nouveau JDC")
 593             return
 594       f=open(self.JDCDisplay_courant.fichier,'r')
 595       texte=f.read()
 596       f.close()
 597       self.visu_texte_JDC = Fenetre(self.appli,titre=titre,texte=texte)
 598
 599    def affichage_fichier_ini(self):
 600       """
 601            Affichage des valeurs des paramètres relus par Eficas
 602       """
 603       self.appli.CONFIGURATION.affichage_fichier_ini()
 604
 605    def saveall(self,liste):
 606       """
 607            Sauvegarde tous les JDC contenus dans liste
 608       """
 609       test = 1
 610       for JDCDisplay in liste :
 611           self.JDC = JDCDisplay.jdc
 612           test = test * self.saveJDC(echo = 'non')
 613       return test
 614
 615    def save_homard(self,nom,texte):
 616        file_homard=nom+'.conf_homard'
 617        try:
 618            f=open(file_homard,'w')
 619            for ligne in texte:
 620                f.write(ligne)
 621                f.write('\n')
 622            f.close()
 623        except:
 624            print "Pb a la sauvegarde sous le format homard"
 625        if self.appli.salome != 0:
 626            import eficas_etude
 627            self.appli.salome.rangeInStudy(file_homard)
 628
 629 # ---------------------------------------------------------------------------
 630 #                       Méthodes liées aux mots-clés inconnus
 631 # ---------------------------------------------------------------------------
 632
 633    def mc_inconnus(self):
 634       l_mc = self.JDCDisplay_courant.jdc.get_liste_mc_inconnus()
 635       o = fenetre_mc_inconnus(l_mc)
 636       l = o.wait_new_list()
 637       #print "mc_inconnus_new_list: ",l
 638       #CCAR: Il n' y a pas de retour vers le JDC
 639
 640    def aideEFICAS(self,event=None):
 641       AIDE.go(master=self.parent)
 642
 643    def update_jdc_courant(self):
 644       self.JDCDisplay_courant.update()
 645
 646