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