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