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