InterfaceTK/panels.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 import string
  22 import os
  23 from Tkinter import *
  24 import Pmw
  25 import time
  26 import traceback
  27
  28 import widgets
  29 from widgets import ListeChoix, showerror
  30 from widgets import ListeChoixParGroupes
  31 import prefs
  32 name='prefs_'+prefs.code
  33 prefsCode=__import__(name)
  34 import options
  35
  36 SEPARATEUR = '-'*30
  37
  38
  39 class Panel(Frame) :
  40   """
  41   Classe servant de classe mère à toutes celles représentant les
  42   panneaux à afficher en fonction de la nature de l'objet en cours
  43   Elle est toujours dérivée.
  44   """
  45   def __init__(self,parent,panneau,node) :
  46       # Le parent d'un panel est un objet de la classe JDCDISPLAY ou derivee
  47       # ou un objet qui a les attributs : appli (de classe APPLI ou derivee),
  48       # modified et la methode init_modif
  49       self.parent=parent
  50       self.panneau = panneau
  51       self.node=node
  52       Frame.__init__(self,self.panneau)
  53       self.place(x=0,y=0,relheight=1,relwidth=1)
  54       self.creer_boutons()
  55       self.init()
  56       global panneauCommande
  57       panneauCommande=self
  58
  59   #def __del__(self):
  60   #    print "__del__",self
  61
  62   def update_panel(self):
  63       """Methode appele pour demander une mise a jour du panneau"""
  64
  65   def destroy(self):
  66       Frame.destroy(self)
  67       self.panneau=None
  68       self.parent=None
  69       # Because on herite de Frame
  70       self.master=None
  71       # On supprime explicitement les references aux objets Tk
  72       self.nb=None
  73       self.fr_but=None
  74       self.bouton_cata=None
  75       self.bouton_doc=None
  76       self.bouton_com=None
  77       self.bouton_sup=None
  78       #self.frame_eval=None
  79       self.label=None
  80       self.frame_boutons=None
  81       self.frame_comment=None
  82       self.frame_param=None
  83       # On termine la suppression de facon brutale (objets Tk et non Tk)
  84       for k in self.__dict__.keys():
  85          # il est plus prudent de ne pas détruire le lien sur le Node
  86          # si on voulait mettre l'attribut node à None, il faudrait
  87          # que tous les appels à node.parent.select() apparaissent après
  88          # toutes les autres actions liées au panel (node.item.isglobal(), ...)
  89          if k != 'node' : setattr(self,k,None)
  90
  91   def creer_boutons(self):
  92       """
  93       Méthode créant les boutons se trouvant dans la partie contextuelle d'EFICAS
  94       (à droite sous les onglets )
  95       """
  96       self.fr_but = Frame(self,height=30)
  97       self.fr_but.pack(side='bottom')
  98       self.bouton_com = Button(self.fr_but, text = 'Commentariser', command = self.ajout_commentaire)
  99       self.bouton_sup = Button(self.fr_but, text = "Supprimer", command=self.supprimer)
 100       self.bouton_doc = Button(self.fr_but, text="Documentation", command=self.visu_doc)
 101       self.bouton_cata = Button(self.fr_but, text = "Catalogue", command = self.show_catalogue)
 102
 103       if self.parent.appli.CONFIGURATION.isdeveloppeur == 'OUI':
 104           self.bouton_sup.pack(side='left',padx=5, pady=5)
 105           self.bouton_cata.pack(side='left',padx=5, pady=5)
 106           self.bouton_doc.pack(side='right',padx=5, pady=5)
 107           #self.bouton_sup.place(relx=0.25,rely = 0.5,relheight = 0.8,anchor='center')
 108           #self.bouton_cata.place(relx=0.5,rely = 0.5,relheight = 0.8,anchor='center')
 109           #self.bouton_doc.place(relx=0.75,rely = 0.5,relheight = 0.8,anchor='center')
 110       else:
 111           self.bouton_sup.pack(side='left',padx=5, pady=5)
 112           self.bouton_doc.pack(side='right',padx=5, pady=5)
 113           #self.bouton_sup.place(relx=0.3,rely = 0.5,relheight = 0.8,anchor='center')
 114           #self.bouton_doc.place(relx=0.7,rely = 0.5,relheight = 0.8,anchor='center')
 115
 116   def show_catalogue(self):
 117       try:
 118           genea = self.node.item.get_genealogie()
 119           self.parent.appli.browser_catalogue_objet(genea)
 120       except Exception,e:
 121           traceback.print_exc()
 122
 123   def efface(self):
 124       self.node.efface()
 125
 126 # ------------------------------------------------------------------------
 127 #     Méthodes permettant d'ajouter des commentaires, des paramètres
 128 #                     et des objets EVAL.
 129 #       Ces méthodes sont utilisées par les panneaux des JDC,ETAPE,
 130 #                 COMMENTAIRE et PARAMETRE
 131 # ------------------------------------------------------------------------
 132
 133   def ajout_commentaire(self,ind='after'):
 134       """
 135       Ajoute un commentaire à l'intérieur du JDC :
 136       - si ind='after'  : l'ajoute après l'objet courant
 137       - si ind='before' : l'ajoute avant.
 138       """
 139       if self.parent.modified == 'n' : self.parent.init_modif()
 140       return self.node.append_brother("COMMENTAIRE",ind)
 141
 142   def ajout_commentaire_first(self):
 143       """
 144       Ajoute un commentaire en début de JDC
 145       """
 146       if self.parent.modified == 'n' : self.parent.init_modif()
 147       return self.node.append_child("COMMENTAIRE",'first')
 148
 149   def ajout_parametre(self,ind='after'):
 150       """
 151       Ajoute un parametre à l'intérieur du JDC :
 152       - si ind='after'  : l'ajoute après l'objet courant
 153       - si ind='before' : l'ajoute avant.
 154       """
 155       if self.parent.modified == 'n' : self.parent.init_modif()
 156       return self.node.append_brother("PARAMETRE",ind)
 157
 158   def ajout_parametre_first(self):
 159       """
 160       Ajoute un parametre en début de JDC
 161       """
 162       if self.parent.modified == 'n' : self.parent.init_modif()
 163       return self.node.append_child("PARAMETRE",'first')
 164
 165 #  def ajout_parametre_eval(self,ind='after'):
 166 #      """
 167 #      Ajoute un paramètre EVAL à l'intérieur du JDC :
 168 #      - si ind='after'  : l'ajoute après l'objet courant
 169 #      - si ind='before' : l'ajoute avant.
 170 #      """
 171 #      if self.parent.modified == 'n' : self.parent.init_modif()
 172 #      return self.node.append_brother("PARAMETRE_EVAL",ind)
 173
 174 #  def ajout_parametre_eval_first(self):
 175 #      """
 176 #      Ajoute un paramètre EVAL en début de JDC
 177 #      """
 178 #      if self.parent.modified == 'n' : self.parent.init_modif()
 179 #      return self.node.append_child("PARAMETRE_EVAL",'first')
 180
 181 # ------------------------------------------------------------------------
 182
 183   def visu_doc(self):
 184       """ Permet d'ouvrir le fichier doc U de la commande au format pdf avec Acrobat Reader
 185         - Ne fonctionne pas sous UNIX (chemin d'accès Acrobat Reader)
 186         - indication du chemin d'accès aux fichiers pdf à revoir : trop statique"""
 187       cle_doc = self.node.item.get_docu()
 188       if cle_doc == None : return
 189       #cle_doc = string.replace(cle_doc,'.','')
 190       #cle_doc = string.replace(cle_doc,'-','')
 191       commande = self.parent.appli.CONFIGURATION.exec_acrobat
 192       nom_fichier = cle_doc
 193       fichier = os.path.abspath(os.path.join(self.parent.appli.CONFIGURATION.path_doc,
 194                                        nom_fichier))
 195       if os.path.isfile(fichier) == 0:
 196            showerror("Pas de Documentation", "Eficas ne trouve pas de fichier documentation associe a cette commande")
 197            return
 198       if os.name == 'nt':
 199           os.spawnv(os.P_NOWAIT,commande,(commande,fichier,))
 200       elif os.name == 'posix':
 201           script ="#!/usr/bin/sh \n%s %s&" %(commande,fichier)
 202           pid = os.system(script)
 203
 204   def supprimer(self):
 205       """
 206       Suppression du noeud courant
 207       """
 208       # On signale au parent du panel (le JDCDisplay) une modification
 209       self.parent.init_modif()
 210       self.node.delete()
 211
 212   def affiche(self):
 213       """ Force l'affichage des fenêtres en cours """
 214       self.tkraise()
 215
 216   def selectMC(self,name):
 217       """ On retrouve le mot-clé sous le curseur pour affichage du fr """
 218       cmd=self.node.item.get_definition()
 219       texte_infos = ''
 220       for e in cmd.entites.keys() :
 221           if e == name :
 222               texte_infos=getattr(cmd.entites[e],prefsCode.lang)
 223               break
 224       if texte_infos == '' : texte_infos="Pas d'infos disponibles"
 225       self.parent.appli.affiche_infos(texte_infos)
 226
 227   def defMC(self,name):
 228       """ On ajoute un mot-clé à la commande : subnode """
 229       if name == SEPARATEUR:return
 230       if self.parent.modified == 'n' : self.parent.init_modif()
 231       if name != "COMMENTAIRE":
 232           self.node.append_child(name)
 233       else :
 234           self.ajout_commentaire()
 235
 236   def selectCmd(self,name):
 237       """ On retrouve la commande sous le curseur pour affichage du fr """
 238       if name != 'COMMENTAIRE' and name != SEPARATEUR:
 239           texte_infos=getattr(self.parent.jdc.get_cmd(name),prefsCode.lang)
 240           self.parent.appli.affiche_infos(texte_infos)
 241
 242   def defCmd(self,name):
 243       """
 244       On ajoute une commande après la commande selectionnée : after
 245       ou bien on ajoute un commentaire
 246       """
 247       if name == SEPARATEUR:return
 248       if self.parent.modified == 'n' : self.parent.init_modif()
 249       if name != "COMMENTAIRE":
 250           #parent=self.node.parent
 251           #new_obj = parent.item.append_child(name,self.node.item.getObject())
 252           #parent.children[parent.children.index(self.node)+1].select()
 253           new_node = self.node.append_brother(name,'after')
 254       else :
 255           new_node = self.ajout_commentaire()
 256
 257   def defCmdFirst(self,name):
 258       """ On ajoute une commande ou un commentaire au début du fichier de commandes """
 259       if name == SEPARATEUR:return
 260       if self.parent.modified == 'n' : self.parent.init_modif()
 261       if name != "COMMENTAIRE":
 262           #new_obj = self.node.item.append_child(name,'first')
 263           #self.node.children[0].select()
 264           new_node = self.node.append_child(name,'first')
 265       else :
 266           new_node = self.ajout_commentaire_first()
 267
 268 class OngletPanel(Panel) :
 269   """ Cette classe est virtuelle et doit être dérivée
 270       Elle contient les principales méthodes d'affichage des différents onglets"""
 271
 272   global panelbind
 273
 274   def raisecmd(self,page):
 275       self.nb.page(page).focus_set()
 276       if page == 'Concept':
 277           try:
 278               self._any.focus()
 279           except:
 280               pass
 281       elif page == 'Commande':
 282           try:
 283               self.command_entry.component('entry').focus()
 284           except:
 285               pass
 286
 287   def creebind(self):
 288        self.nb.bind_all("<F1>",lambda e,s=self,num=0:s.commande_up(num))
 289        self.nb.bind_all("<F2>",lambda e,s=self,num=1:s.commande_up(num))
 290        self.nb.bind_all("<F3>",lambda e,s=self,num=2:s.commande_up(num))
 291        self.nb.bind_all("<F4>",lambda e,s=self,num=3:s.commande_up(num))
 292        OngletPanel.panelbind=self.nb
 293
 294   def enlevebind(self):
 295        if not hasattr(OngletPanel,"panelbind"):
 296           return
 297        if OngletPanel.panelbind == None:
 298           return
 299        try:
 300            OngletPanel.panelbind.unbind_all("<F1>")
 301            OngletPanel.panelbind.unbind_all("<F2>")
 302            OngletPanel.panelbind.unbind_all("<F3>")
 303            OngletPanel.panelbind.unbind_all("<F4>")
 304        except:
 305            pass
 306        OngletPanel.panelbind = None
 307
 308   def commande_up(self,num):
 309       #print "commande_up de panels pour ", num
 310       try :
 311         OngletPanel.panelbind.selectpage(num)
 312         pageNew=OngletPanel.panelbind.page(num)
 313         pageNew.focus_set()
 314       except :
 315         pass
 316
 317   def affiche(self):
 318       page=self.nb.getcurselection()
 319       self.nb.page(page).focus_set()
 320       if page == 'Concept':
 321           try:
 322 #              _any est un pointeur sur entry
 323 #              component est une methode de pmw
 324 #              a priori, jamais ok
 325               self._any.component('entry').focus_set()
 326           except:
 327               pass
 328       self.tkraise()
 329
 330 # ------------------------------------------------------------------------
 331 #     Méthodes permettant d'afficher des pages partagées par différents
 332 #           types d'objets (règles,mots-clés,concept,...)
 333 # ------------------------------------------------------------------------
 334
 335   def makeConceptPage(self,page):
 336       """
 337       Crée la page de saisie du nom du concept
 338       """
 339       self.label = Label(page,text='Nom du concept :',justify=LEFT)
 340       self.label.grid(row=0,sticky=W,padx=5,pady=10)
 341       self._any = Entry(page,relief='sunken')
 342       self._any.grid(row=0,column=1,padx=5,pady=10)
 343       self._any.bind("<Return>",lambda e,s=self:s.execConcept())
 344       self._any.bind("<KP_Enter>",lambda e,s=self:s.execConcept())
 345       self._any.insert(0,self.node.item.GetText())
 346       self.but_ok=Button(page,text = "Valider",command=self.execConcept)
 347       type_sd = self.node.item.get_type_sd_prod()
 348       row=1
 349       if type_sd :
 350           txt = "L'opérateur courant retourne un objet de type:\n%s" %type_sd
 351           self.label = Label(page, text = txt)
 352           self.label.grid(row=1,columnspan=2,padx=5,pady=10,sticky=W)
 353           row=2
 354       self.but_ok.grid(row=row,columnspan=2,padx=5,pady=10)
 355       self._any.focus()
 356       # aide associée au panneau
 357       bulle_aide="""Tapez dans la zone de saisie le nom que vous voulez donner
 358       au concept retounré par l'opérateur courant et pressez <Return> pour valider"""
 359       page.bind("<Button-3>", lambda e,s=self,a=bulle_aide : s.parent.appli.affiche_aide(e,a))
 360       page.bind("<ButtonRelease-3>",self.parent.appli.efface_aide)
 361
 362   def makeMoclesPage(self,page):
 363       """
 364       Crée la page qui affiche la liste des mots-clés que l'on peut
 365       encore ajouter
 366       """
 367       genea =self.node.item.get_genealogie()
 368       jdc = self.node.item.get_jdc()
 369       liste_mc=self.node.item.get_liste_mc_ordonnee(genea,jdc.cata_ordonne_dico)
 370       liste_commandes = (("<Enter>",self.selectMC),
 371                          ("<Leave>",self.deselectMC),
 372                          ("<Double-Button-1>",self.defMC))
 373       Liste = ListeChoix(self,page,liste_mc,liste_commandes = liste_commandes,titre = "Mots-clés permis",optionReturn="oui")
 374       Liste.affiche_liste()
 375       # aide associée au panneau
 376       bulle_aide="""Double-cliquez sur le mot-clé que vous voulez ajouter à
 377       la commande en cours d'édition"""
 378       Liste.MCbox.bind("<Button-3>", lambda e,s=self,a=bulle_aide : s.parent.appli.affiche_aide(e,a))
 379       Liste.MCbox.bind("<ButtonRelease-3>",self.parent.appli.efface_aide)
 380       if len(liste_mc) > 0 :
 381          Liste.surligne(liste_mc[0])
 382       self.Liste=Liste
 383
 384   def makeCommentairePage(self,page):
 385       label = Label(page,text = "Insérer un commentaire :")
 386       label.grid(column = 0, row = 2)
 387       but_avant = Button(page,text = "AVANT",command = lambda s=self :s.ajout_commentaire(ind = 'before'))
 388       but_apres = Button(page,text = "APRES",command = self.ajout_commentaire)
 389       but_avant.grid(column = 1,row =2)
 390       but_apres.grid(column = 1,row =3)
 391
 392   def makeCommandePage(self,page):
 393       """
 394          Cree l'onglet
 395       """
 396       frame1 = Frame(page,height = 20)
 397       frame1.pack(side='top',fill='x')
 398       label = Label(frame1,text ="La commande choisie sera ajoutée\n APRES la commande courante")
 399       label.pack(side='top')
 400       frame2 = Frame(page)
 401       frame2.pack(side='top',fill='both',expand=1)
 402       liste_commandes = (("<Enter>",self.selectCmd),
 403                          ("<Leave>",self.deselectCmd),
 404                          ("<Double-Button-1>",self.defCmd))
 405       if options.affichage_commandes == "alphabetic":
 406          liste_cmd = self.get_liste_cmd()
 407          Liste = ListeChoix(self,frame2,liste_cmd,liste_commandes = liste_commandes,
 408                                    filtre='oui',titre = "Commandes",optionReturn="oui")
 409       else:
 410          liste_commandes=liste_commandes+(("<Return>",self.defCmd),)
 411          liste_groupes,dict_groupes=self.get_groups()
 412          Liste = ListeChoixParGroupes(self,frame2,liste_groupes,dict_groupes,
 413                                       liste_commandes = liste_commandes,
 414                                       filtre='oui',titre = "Commandes",optionReturn="oui")
 415       Liste.affiche_liste()
 416       self.command_entry=Liste.entry
 417       # aide associée au panneau
 418       bulle_aide="""Double-cliquez sur la commande que vous voulez ajouter au jeu de commandes"""
 419       Liste.MCbox.bind("<Button-3>", lambda e,s=self,a=bulle_aide : s.parent.appli.affiche_aide(e,a))
 420       Liste.MCbox.bind("<ButtonRelease-3>",self.parent.appli.efface_aide)
 421       self.liste_command=Liste
 422       global panneauCommande
 423       panneauCommande=self
 424
 425   def makeJDCPage(self,page):
 426       """
 427       Crée la page correspondant à un objet de type JDC
 428       """
 429       liste_commandes = (("<Enter>",self.selectCmd),
 430                          ("<Leave>",self.deselectCmd),
 431                          ("<Double-Button-1>",self.defCmdFirst))
 432       if options.affichage_commandes == "alphabetic":
 433          liste_cmd = self.get_liste_cmd()
 434          Liste = ListeChoix(self,page,liste_cmd,liste_commandes = liste_commandes,
 435                             filtre='oui',titre = "Commandes",optionReturn="oui")
 436       else:
 437          liste_commandes=liste_commandes+(("<Return>",self.defCmdFirst),)
 438          liste_groupes,dict_groupes=self.get_groups()
 439          Liste = ListeChoixParGroupes(self,page,liste_groupes,dict_groupes,
 440                                       liste_commandes = liste_commandes,
 441                                       filtre='oui',titre = "Commandes",optionReturn="oui")
 442       Liste.affiche_liste()
 443        # aide associée au panneau
 444       bulle_aide="""Double-cliquez sur la commande que vous voulez ajouter au jeu de commandes"""
 445       Liste.MCbox.bind("<Button-3>", lambda e,s=self,a=bulle_aide : s.parent.appli.affiche_aide(e,a))
 446       Liste.MCbox.bind("<ButtonRelease-3>",self.parent.appli.efface_aide)
 447
 448   def makeReglesPage(self,page) :
 449       """
 450       Crée la page qui affiche la liste des règles avec celle qui ne sont
 451       pas respectées en rouge
 452       """
 453       regles = []
 454       regles = self.node.item.get_regles()
 455       dictionnaire = self.node.item.get_mc_presents()
 456       texte_regles = []
 457       l_regles_en_defaut=[]
 458       if len(regles) > 0:
 459         i = 0
 460         for regle in regles :
 461           texte_regles.append(regle.gettext())
 462           texte,test = regle.verif(dictionnaire)
 463           if test == 0 : l_regles_en_defaut.append(i)
 464           i = i+1
 465       Liste = ListeChoix(self,page,texte_regles,liste_marques=l_regles_en_defaut,active='non',titre="Règles")
 466       Liste.affiche_liste()
 467       # aide associée au panneau
 468       bulle_aide="""Ce panneau contient la liste des règles qui s'appliquent à l'objet
 469       en cours d'édition.
 470       - en noir : règles valides
 471       - en rouge : règles violées"""
 472       Liste.MCbox.bind("<Button-3>", lambda e,s=self,a=bulle_aide : s.parent.appli.affiche_aide(e,a))
 473       Liste.MCbox.bind("<ButtonRelease-3>",self.parent.appli.efface_aide)
 474
 475   def makeParamCommentPage_for_etape(self,page):
 476       """
 477       Crée la page qui offre le choix à l'utilisateur d'ajouter un commentaire
 478       ou un paramètre, avant ou après le noeud courant dans l'arbre.
 479       Cette page est destinée aux objets de niveau ETAPE cad à toutes les CMD,
 480       les commentaires inter commandes et les paramètres
 481       """
 482       # les frame ...
 483       self.frame_comment = Frame(page,bd=1,relief='raised')
 484       self.frame_param   = Frame(page,bd=1,relief='raised')
 485       self.frame_boutons = Frame(page,bd=1,relief='raised')
 486       # remplissage de la frame commentaire
 487       Label(self.frame_comment,text = "Insérer un commentaire :",justify=LEFT).grid(row=0,rowspan=2,sticky=W,padx=5, pady=5)
 488       but_comment_avant = Button(self.frame_comment,
 489                                  text = "AVANT "+self.node.item.get_nom(),
 490                                  command = lambda s=self :s.ajout_commentaire(ind = 'before'))
 491       but_comment_apres = Button(self.frame_comment,
 492                                  text = "APRES "+self.node.item.get_nom(),
 493                                  command = self.ajout_commentaire)
 494       but_comment_avant.grid(row=0,column=1,padx=5, pady=5)
 495       but_comment_apres.grid(row=1,column=1,padx=5, pady=5)
 496       self.frame_comment.pack(side='top',fill='both',padx=5, pady=5)
 497       # remplissage de la frame paramètre
 498       Label(self.frame_param,text = "Insérer un paramètre :",justify=LEFT).grid(row=0,rowspan=2,sticky=W,padx=5, pady=5)
 499       but_param_avant = Button(self.frame_param,
 500                                  text = "AVANT "+self.node.item.get_nom(),
 501                                  command = lambda s=self :s.ajout_parametre(ind = 'before'))
 502       but_param_apres = Button(self.frame_param,
 503                                  text = "APRES "+self.node.item.get_nom(),
 504                                  command = self.ajout_parametre)
 505       but_param_avant.grid(row=0,column=1,padx=5, pady=5)
 506       but_param_apres.grid(row=1,column=1,padx=5, pady=5)
 507       self.frame_param.pack(side='top',fill='both',padx=5, pady=5)
 508       # remplissage de la frame boutons
 509       Button(self.frame_boutons,
 510              text="Commentariser toute la commande",
 511              command = self.comment_commande).pack(side='top',padx=5, pady=5)
 512       self.frame_boutons.pack(side='top',fill='both',padx=5, pady=5)
 513
 514   def deselectMC(self,name):
 515       self.parent.appli.affiche_infos('')
 516
 517   def get_groups(self):
 518       jdc=self.node.item.object.get_jdc_root()
 519       return jdc.get_groups()
 520
 521   def get_liste_cmd(self):
 522       #print "get_liste_cmd",self.node.item.object
 523       jdc=self.node.item.object.get_jdc_root()
 524       listeCmd = jdc.get_liste_cmd()
 525       return listeCmd
 526
 527   def deselectCmd(self,name):
 528       self.parent.appli.affiche_infos('')
 529
 530   def execConcept(self):
 531       """
 532       Nomme le concept SD retourné par l'étape
 533       """
 534       if not hasattr(self,'valeur_choisie'):
 535           nom = self._any.get()
 536       else:
 537           nom = self.valeur_choisie.get()
 538       nom = string.strip(nom)
 539       if nom == '' : return # si pas de nom, on ressort sans rien faire ...
 540       if self.parent.modified == 'n' : self.parent.init_modif()
 541       test,mess = self.node.item.nomme_sd(nom)
 542       #self.node.verif()
 543       #self.node.racine.update()
 544       self.parent.appli.affiche_infos(mess)
 545
 546   def changed(self):
 547       pass
 548
 549   def comment_commande(self):
 550     """
 551     Cette méthode a pour but de commentariser la commande pointée par self.node
 552     """
 553     # On traite par une exception le cas où l'utilisateur final cherche à désactiver
 554     # (commentariser) un commentaire.
 555     try :
 556         pos=self.node.parent.children.index(self.node)
 557         commande_comment = self.node.item.get_objet_commentarise()
 558         # On signale au parent du panel (le JDCDisplay) une modification
 559         self.parent.init_modif()
 560         self.node.parent.children[pos].select()
 561     except Exception,e:
 562         traceback.print_exc()
 563         widgets.showerror("TOO BAD",str(e))
 564     return
 565
 566
 567 class Panel_Inactif(Panel):
 568   """
 569      Cette classe sert à définir un panneau dans lequel on dit que le noeud
 570      sélectionné n'est pas actif
 571   """
 572   def __init__(self,parent,panneau,node) :
 573       self.parent=parent
 574       self.panneau = panneau
 575       self.node=node
 576       Frame.__init__(self,self.panneau)
 577       self.place(x=0,y=0,relheight=1,relwidth=1)
 578       self.creer_texte()
 579
 580   def creer_texte(self):
 581       texte = "Le noeud sélectionné ne correspond pas à un objet actif\n"
 582       texte = texte + "Seules les commandes placées entre \nDEBUT/POURSUITE et FIN sont actives"
 583       longueur = int(self.panneau.winfo_width()*0.8)
 584       self.label = Label(self,text=texte,wraplength=longueur,justify='center')
 585       self.label.place(relx=0.5,rely=0.4,relwidth=0.8,anchor='center')
 586       self.bouton_sup = Button(self,
 587                                text = "Supprimer",
 588                                command=self.supprimer,
 589                                width=14)
 590       self.bouton_sup.place(relx=0.5,rely=0.8,anchor='center')
 591
 592
 593 if __name__ == "__main__" : pass