Editeur/bureau.py

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