Les méga-widgets s'utilisent aisément. La petite application ci-après vous montre comment mettre en oeuvre un widget de type ComboBox (boîte de liste combinée à un champ d'entrée). Nous l'avons configuré de la manière la plus habituelle (avec une boîte de liste déroulante). Lorsque l'utilisateur de notre petit programme choisit une couleur dans la liste déroulante (il peut aussi entrer un nom de couleur directement dans le champ d'entrée), cette couleur devient automatiquement la couleur de fond pour la fenêtre maîtresse. Dans cette fenêtre maîtresse, nous avons ajouté un libellé et un bouton, afin de vous montrer comment vous pouvez accéder à la sélection opérée précédemment dans le ComboBox lui-même (le bouton provoque l'affichage du nom de la dernière couleur choisie).

1. from Tkinter import *
2. import Pmw          
3.
4. def changeCoul(col):
5.     fen.configure(background = col)
6.
7. def changeLabel():
8.     lab.configure(text = combo.get())
9.
10.couleurs = ('navy', 'royal blue', 'steelblue1', 'cadet blue',
11.            'lawn green', 'forest green', 'dark red',
12.            'grey80','grey60', 'grey40', 'grey20')
13.    
14.fen = Pmw.initialise()
15.bou = Button(fen, text ="Test", command =changeLabel)
16.bou.grid(row =1, column =0, padx =8, pady =6)
17.lab = Label(fen, text ='néant', bg ='ivory')
18.lab.grid(row =1, column =1, padx =8)
19.
20.combo = Pmw.ComboBox(fen, labelpos = NW,
21.                     label_text = 'Choisissez la couleur :',
22.                     scrolledlist_items = couleurs,
23.                     listheight = 150,
24.                     selectioncommand = changeCoul)
25.combo.grid(row =2, columnspan =2, padx =10, pady =10)
26.
27.fen.mainloop()

Commentaires :

• Lignes 1 & 2 : On commence par importer les composants habituels de Tkinter, ainsi que le module Pmw.
  
• Ligne 14 : Pour créer la fenêtre maîtresse, il faut utiliser de préférence la méthode Pmw.initialise(), plutôt que d'instancier directement un objet de la classe Tk(). Cette méthode veille en effet à mettre en place tout ce qui est nécessaire afin que les widgets esclaves de cette fenêtre puissent être détruits correctement lorsque la fenêtre elle-même sera détruite. Cette méthode installe également un meilleur gestionnaire des messages d'erreurs.
  
• Ligne 12 : L'option labelpos détermine l'emplacement du libellé qui accompagne le champ d'entrée. Dans notre exemple, nous l'avons placé au-dessus, mais vous pourriez préférer le placer ailleurs, à gauche par exemple (labelpos = W). Notez que cette option est indispensable si vous souhaitez un libellé (pas de valeur par défaut).
  
• Ligne 14 : L'option selectioncommand transmet un argument à la fonction invoquée : l'item sélectionné dans la boîte de liste. Vous pourrez également retrouver cette sélection à l'aide de la méthode get(), comme nous le faisons à la ligne 8 pour actualiser le libellé.

Nous vous avons déjà signalé précédemment que Python est tout à fait capable de prendre en charge les alphabets du monde entier (grec, cyrillique, arabe, japonais, etc. - voir notamment page 40). Il en va de même pour Tkinter. En tant que francophone, vous souhaiterez certainement que les utilisateurs de vos scripts puissent entrer des caractères accentués dans les widgets Entry, Text et leurs dérivés (ComboBox, ScrolledText).

Veuillez donc prendre bonne note que lorsque vous entrez dans l'un de ces widgets une chaîne contenant un ou plusieurs caractères non-ASCII (tel qu'une lettre accentuée, par exemple), Tkinter encode cette chaîne suivant la norme UTF-8. Si votre ordinateur utilise plutôt le codage Latin-1 par défaut (ce qui est très souvent le cas), vous devrez convertir la chaîne avant de pouvoir l'afficher.

Cela peut se faire très aisément en utilisant la fonction intégrée encode(). Exemple :

 -*- coding: Latin-1 -*-
 
from Tkinter import *
 
def imprimer():
    ch1 = e.get()                 # le widget Entry renvoie une chaîne utf8
    ch2 = ch1.encode("Latin-1")   # conversion utf8 -> Latin-1
    print ch2
 
f = Tk()
e = Entry(f)
e.pack()
Button(f, text ="afficher", command =imprimer).pack()
f.mainloop()

Essayez ce petit script en entrant des chaînes avec caractères accentués dans le champ d'entrée.

Essayez encore, mais en remplaçant l'instruction « print ch2 » par « print ch1 ». Concluez.

Ce méga-widget étend les possibilités du widget Text sandard, en lui associant un cadre, un libellé (titre) et des barres de défilement. Comme le démontrera le petit script ci-dessous, il sert fondamentalement à afficher des textes, mais ceux-ci peuvent être mis en forme et intégrer des images. Vous pouvez également rendre « cliquables » les éléments affichés (textes ou images), et vous en servir pour déclencher toutes sortes de mécanismes.

Dans l'application qui génère la figure ci-dessus, par exemple, le fait de cliquer sur le nom « Jean de la Fontaine » provoque le défilement automatique du texte (scrolling), jusqu'à ce qu'une rubrique décrivant cet auteur devienne visible dans le widget (Voir page suivante le script correspondant).

D'autres fonctionnalités sont présentes, mais nous ne présenterons ici que les plus fondamentales. Veuillez donc consulter les démos et exemples accompagnant Pmw pour en savoir davantage.

Gestion du texte affiché : Vous pouvez accéder à n'importe quelle portion du texte pris en charge par le widget grâce à deux concepts complémentaires, les index et les balises :

• Chaque caractère du texte affiché est référencé par un index, lequel doit être une chaîne de caractères contenant deux valeurs numériques reliées par un point (ex : "5.2"). Ces deux valeurs indiquent respectivement le numéro de ligne et le numéro de colonne où se situe le caractère.
  
• N'importe quelle portion du texte peut être associée à une ou plusieurs balise(s), dont vous choisissez librement le nom et les propriétés. Celles-ci vous permettent de définir la police, les couleurs d'avant- et d'arrière-plan, les événements associés, etc.

Note : Pour la bonne compréhension du script ci-dessous, veuillez considérer que le texte de la fable traitée doit être accessible, dans un fichier nommé « CorbRenard.txt ».

1. from Tkinter import *
2. import Pmw          
3.
4. def action(event=None):
5.     """défilement du texte jusqu'à la balise <cible>"""
6.     index = st.tag_nextrange('cible', '0.0', END)
7.     st.see(index[0])
8.
9. # Instanciation d'une fenêtre contenant un widget ScrolledText :  
10.fen = Pmw.initialise()
11.st = Pmw.ScrolledText(fen,
12.                      labelpos =N,
13.                      label_text ="Petite démo du widget ScrolledText",
14.                      label_font ='Times 14 bold italic',
15.                      label_fg = 'navy', label_pady =5,
16.                      text_font='Helvetica 11 normal', text_bg ='ivory',
17.                      text_padx =10, text_pady =10, text_wrap ='none', 
18.                      borderframe =1,
19.                      borderframe_borderwidth =3,
20.                      borderframe_relief =SOLID,
21.                      usehullsize =1,
22.                      hull_width =370, hull_height =240)
23.st.pack(expand =YES, fill =BOTH, padx =8, pady =8)
24.
25.# Définition de balises, liaison d'un gestionnaire d'événement au clic de souris : 
26.st.tag_configure('titre', foreground ='brown', font ='Helvetica 11 bold italic')
27.st.tag_configure('lien', foreground ='blue', font ='Helvetica 11 bold')
28.st.tag_configure('cible', foreground ='forest green', font ='Times 11 bold')
29.st.tag_bind('lien', '<Button-1>', action)
30.
31.titre ="""Le Corbeau et le Renard
32.par Jean de la Fontaine, auteur français
33.\n"""
34.auteur ="""
35.Jean de la Fontaine
36.écrivain français (1621-1695)
37.célèbre pour ses Contes en vers,
38.et surtout ses Fables, publiées
39.de 1668 à 1694."""
40.
41.# Remplissage du widget Text (2 techniques) :
42.st.importfile('CorbRenard.txt')
43.st.insert('0.0', titre, 'titre')
44.st.insert(END, auteur, 'cible')
45.# Insertion d'une image :
46.photo =PhotoImage(file= 'Penguin.gif')
47.st.image_create('6.14', image =photo)
48.# Mise en oeuvre dynamique d'une balise :
49.st.tag_add('lien', '2.4', '2.23')
50.
51.fen.mainloop()

Commentaires :

• Lignes 4-7 : Cette fonction est un gestionnaire d'événement, qui est appelé lorsque l'utilisateur effectue un clic de souris sur le nom de l'auteur (cfr. lignes 27 & 29). A la ligne 6, on utilise la méthode tag_nextrange() du widget pour trouver les index de la portion de texte associée à la balise « cible ». La recherche de ces index est limitée au domaine défini par les 2^e & 3^e arguments (dans notre exemple, on recherche du début à la fin du texte entier). La méthode tag_nextrange() renvoie une liste de deux index (ceux des premier et dernier caractères de la portion de texte associée à la balise « cible »). A la ligne 7, nous nous servons d'un seul de ces index (le premier) pour activer la méthode see(). Celle-ci provoque un défilement automatique du texte (scrolling), de telle manière que le caractère correspondant à l'index transmis devienne visible dans le widget (avec en général un certain nombre des caractères qui suivent).
  
• Lignes 9 à 23 : Construction classique d'une fenêtre destinée à afficher un seul widget. Dans le code d'instanciation du widget, nous avons inclus un certain nombre d'options destinées à vous montrer une petite partie des nombreuses possibilités de configuration.
  
• Ligne 12 : L'option labelpos détermine l'emplacement du libellé (titre) par rapport à la fenêtre de texte. Les valeurs acceptées s'inspirent des lettres utilisées pour désigner les points cardinaux (N, S, E, W, ou encore NE, NW, SE, SW). Si vous ne souhaitez pas afficher un libellé, il vous suffit tout simplement de ne pas utiliser cette option.
  
• Lignes 13 à 15 : Le libellé n'est rien d'autre qu'un widget Label standard, intégré dans le widget composite ScrolledText. On peut accéder à toutes ses options de configuration, en utilisant la syntaxe qui est présentée dans ces lignes : on y voit qu'il suffit d'associer le préfixe label_ au nom de l'option que l'on souhaite activer, pour définir aisément les couleurs d'avant- et d'arrièreplans, la police, la taille, et même l'espacement à réserver autour du widget (option pady).
  
• Lignes 16-17 : En utilisant une technique similaire à celle qui est décrite ci-dessus pour le libellé, on peut accéder aux options de configuration du widget Text intégré dans ScrolledText. Il suffit cette fois d'associer aux noms d'option le préfixe text_.
  
• Lignes 18 à 20 : Il est prévu un cadre (un widget Frame) autour du widget Text. L'option borderframe = 1 permet de le faire apparaître. On accède ensuite à ses options de configuration d'une manière similaire à celle qui a été décrite ci-dessus pour label_ et text_.
  
• Lignes 21-22 : Ces options permettent de fixer globalement les dimensions du widget. Une autre possibilité serait de définir plutôt les dimensions de son composant Text (par exemple à l'aide d'options telles que text_width et text_height), mais alors les dimensions globales du widget risqueraient de changer en fonction du contenu (apparition/disparition automatique de barres de défilement). Note : le mot hull désigne le contenant global, c.à.d. le méga-widget lui-même.
  
• Ligne 23 : Les options expand = YES et fill = BOTH de la méthode pack() indiquent que le widget concerné pourra être redimensionné à volonté, dans ses 2 dimensions horiz. et verticale.
  
• Lignes 26 à 29 : Ces lignes définissent les trois balises « titre », « lien » et « cible » ainsi que le formatage du texte qui leur sera associé. La ligne 29 précise en outre que le texte associé à la balise « lien » sera « cliquable », avec indication du gestionnaire d'événement correspondant.
  
• Ligne 42 : Importation de texte à partir d'un fichier. Note : Il est possible de préciser l'endroit exact où devra se faire l'insertion, en fournissant un index comme second argument.
  
• Lignes 43-44 : Ces instructions insèrent des fragments de texte (respectivement au début et à la fin du texte préexistant), en associant une balise à chacun d'eux.
  
• Ligne 49 : L'association des balises au texte est dynamique. A tout moment, vous pouvez activer une nouvelle association (comme nous le faisons ici en rattachant la balise « lien » à une portion de texte préexistante). Note : pour « détacher » une balise, utilisez la méthode tag_delete().

Le script ci-après vous montre comment vous pouvez exploiter le méga-widget ScrolledCanvas, lequel étend les possibilités du widget Canvas standard en lui associant des barres de défilement, un libellé et un cadre. Notre exemple constitue en fait un petit jeu d'adresse, dans lequel l'utilisateur doit réussir à cliquer sur un bouton qui s'esquive sans cesse. (Note : si vous éprouvez vraiment des difficultés pour l'attraper, commencez d'abord par dilater la fenêtre).

Le widget Canvas est très versatile : il vous permet de combiner à volonté des dessins, des images bitmap, des fragments de texte, et même d'autres widgets, dans un espace parfaitement extensible. Si vous souhaitez développer l'un ou l'autre jeu graphique, c'est évidemment le widget qu'il vous faut apprendre à maîtriser en priorité.

Comprenez bien cependant que les indications que nous vous fournissons à ce sujet dans les présentes notes sont forcément très incomplètes. Leur objectif est seulement de vous aider à comprendre quelques concepts de base, afin que vous puissiez ensuite consulter les ouvrages de référence spécialisés dans de bonnes conditions.

Notre petite application se présente comme une nouvelle classe FenPrinc(), obtenue par dérivation à partir de la classe de méga-widgets Pmw.ScrolledCanvas(). Elle contient donc un grand canevas muni de barres de défilement, dans lequel nous commençons par planter un décor constitué de 80 ellipses de couleur dont l'emplacement et les dimensions sont tirés au hasard.

Nous y ajoutons également un petit clin d'oeil sous la forme d'une image bitmap, destinée avant tout à vous rappeler comment vous pouvez gérer ce type de ressource.

Nous y installons enfin un véritable widget : un simple bouton, en l'occurrence, mais la technique mise en oeuvre pourrait s'appliquer à n'importe quel autre type de widget, y compris un gros widget composite comme ceux que nous avons développés précédemment. Cette grande souplesse dans le développement d'applications complexes est l'un des principaux bénéfices apportés par le mode de programmation « orientée objet ».

Le bouton s'anime dès qu'on l'a enfoncé une première fois. Dans votre analyse du script ci-après, soyez attentifs aux méthodes utilisées pour modifier les propriétés d'un objet existant.

1. from Tkinter import *
2. import Pmw
3. from random import randrange
4.
5. Pmw.initialise()
6. coul =['sienna','maroon','brown','pink','tan','wheat','gold','orange','plum',
7.        'red','khaki','indian red','thistle','firebrick','salmon','coral']
8. 
9. class FenPrinc(Pmw.ScrolledCanvas):
10.    """Fenêtre principale : canevas extensible avec barres de défilement"""
11.    def __init__(self):
12.        Pmw.ScrolledCanvas.__init__(self,
13.                 usehullsize =1, hull_width =500, hull_height =300,
14.                 canvas_bg ='grey40', canvasmargin =10,                 
15.                 labelpos =N, label_text ='Attrapez le bouton !',
16.                 borderframe =1,
17.                 borderframe_borderwidth =3)
18.        # Les options ci-dessous doivent être précisées après initialisation :         
19.        self.configure(vscrollmode ='dynamic', hscrollmode ='dynamic')        
20.        self.pack(padx =5, pady =5, expand =YES, fill =BOTH)
21.        
22.        self.can = self.interior()        # accès au composant canevas
23.        # Décor : tracé d'une série d'ellipses aléatoires :
24.        for r in range(80):
25.            x1, y1 = randrange(-800,800), randrange(-800,800) 
26.            x2, y2 = x1 + randrange(40,300), y1 + randrange(40,300)
27.            couleur = coul[randrange(0,16)]
28.            self.can.create_oval(x1, y1, x2, y2, fill=couleur, outline='black')
29.        # Ajout d'une petite image GIF :    
30.        self.img = PhotoImage(file ='linux2.gif')    
31.        self.can.create_image(50, 20, image =self.img)    
32.        # Dessin du bouton à attraper :    
33.        self.x, self.y = 50, 100
34.        self.bou = Button(self.can, text ="Start", command =self.start)
35.        self.fb = self.can.create_window(self.x, self.y, window =self.bou)
36.        self.resizescrollregion()
37.            
38.    def anim(self):
39.        if self.run ==0:
40.            return
41.        self.x += randrange(-60, 61)
42.        self.y += randrange(-60, 61)
43.        self.can.coords(self.fb, self.x, self.y)
44.        self.configure(label_text = 'Cherchez en %s %s' % (self.x, self.y))
45.        self.resizescrollregion()
46.        self.after(250, self.anim)
47.        
48.    def stop(self):
49.        self.run =0   
50.        self.bou.configure(text ="Restart", command =self.start)   
51.    
52.    def start(self):
53.        self.bou.configure(text ="Attrapez-moi !", command =self.stop)   
54.        self.run =1
55.        self.anim()    
56.        
57.##### Main Program ##############
58.
59.if __name__ == '__main__':
60.    FenPrinc().mainloop()

Commentaires :

• Ligne 6 : Tous ces noms de couleurs sont acceptés par Tkinter. Vous pourriez bien évidemment les remplacer par des descriptions hexadécimales, comme nous l'avons expliqué page 201.
  
• Lignes 12 à 17 : Ces options sont très similaires à celles que nous avons décrites plus haut pour le widget ScrolledText. Le présent méga-widget intègre un composant Frame, un composant Label, un composant Canvas et deux composants Scrollbar. On accède aux options de configuration de ces composants à l'aide d'une syntaxe qui relie le nom du composant et celui de l'option par l'intermédiaire d'un caractère « souligné ».
  
• Ligne 19 : Ces options définissent le mode d'apparition des barres de défilement. En mode « static », elles sont toujours présentes. En mode « dynamic », elles disparaissent si les dimensions du canevas deviennent inférieures à celles de la fenêtre de visualisation.
  
• Ligne 22 : La méthode interior() renvoie la référence du composant Canvas intégré dans le méga-widget ScrolledCanvas. Les instructions suivantes (lignes 23 à 35) installent ensuite toute une série d'éléments dans ce canevas : des dessins, une image et un bouton.
  
• Lignes 25 à 27 : La fonction randrange() permet de tirer au hasard un nombre entier compris dans un certain intervalle (Veuillez vous référer aux explications de la page 142).
  
• Ligne 35 : C'est la méthode create_window() du widget Canvas qui permet d'y insérer n'importe quel autre widget (y compris un widget composite). Le widget à insérer doit cependant avoir été défini lui-même au préalable comme un esclave du canevas ou de sa fenêtre maîtresse. La méthode create_window() attend trois arguments : les coordonnées X et Y du point où l'on souhaite insérer le widget, et la référence de ce widget.
  
• Ligne 36 : La méthode resizescrollregion() réajuste la situation des barres de défilement de manière à ce qu'elles soient en accord avec la portion du canevas actuellement affichée.
  
• Lignes 38 à 46 : Cette méthode est utilisée pour l'animation du bouton. Après avoir repositionné le bouton au hasard à une certaine distance de sa position précédente, elle se ré-appelle ellemême après une pause de 250 millisecondes. Ce bouclage s'effectue sans cesse, aussi longtemps que la variable self.run contient une valeur non-nulle.
  
• Lignes 48 à 55 : Ces deux gestionnaires d'événement sont associés au bouton en alternance. Ils servent évidemment à démarrer et à arrêter l'animation.

De nombreux programmes comportent une ou plusieurs « barres d'outils » (toolbar) constituées de petits boutons sur lesquels sont représentés des pictogrammes (icônes). Cette façon de faire permet de proposer à l'utilisateur un grand nombre de commandes spécialisées, sans que celles-ci n'occupent une place excessive à l'écran (un petit dessin vaut mieux qu'un long discours, dit-on).

La signification de ces pictogrammes n'est cependant pas toujours évidente, surtout pour les utilisateurs néophytes. Il est donc vivement conseillé de compléter les barres d'outils à l'aide d'un système de bulles d'aide (tool tips), qui sont des petits messages explicatifs apparaissant automatiquement lorsque la souris survole les boutons concernés.

L'application décrite ci-après comporte une barre d'outils et un canevas. Lorsque l'utilisateur clique sur l'un des boutons de la barre, le pictogramme qu'il porte est recopié dans le canevas, à un emplacement choisi au hasard :

Dans notre exemple, chaque bouton apparaît entouré d'un sillon. Vous pouvez aisément obtenir d'autres aspects en choisissant judicieusement les options relief et bd (bordure) dans l'instruction d'instanciation des boutons. En particulier, vous pouvez choisir relief = FLAT et bd =0 pour obtenir des petits boutons « plats », sans aucun relief.

La mise en place des bulles d'aide est un jeu d'enfant. Il suffit d'instancier un seul objet Pmw.Balloon pour l'ensemble de l'application, puis d'associer un texte à chacun des widgets auxquels on souhaite associer une bulle d'aide, en faisant appel autant de fois que nécessaire à la méthode bind() de cet objet.

1. from Tkinter import *
2. import Pmw
3. from random import randrange
4.
5. # noms des fichiers contenant les icônes (format GIF):
6. images =('floppy_2','papi2','pion_1','pion_2','help_4')
7. textes =('sauvegarde','papillon','joueur 1','joueur 2','Aide')
8.
9. class Application(Frame):
10.    def __init__(self):
11.        Frame.__init__(self)
12.        # Création d'un objet <bulle d'aide> (un seul suffit) :
13.        tip = Pmw.Balloon(self)
14.        # Création de la barre d'outils (c'est un simple cadre) :
15.        toolbar = Frame(self, bd =1)
16.        toolbar.pack(expand =YES, fill =X)
17.        # Nombre de boutons à construire : 
18.        nBou = len(images)
19.        # Les icônes des boutons doivent être placées dans des variables
20.        # persistantes. Une liste fera l'affaire :
21.        self.photoI =[None]*nBou
22.        
23.        for b in range(nBou):
24.            # Création de l'icône (objet PhotoImage Tkinter) :
25.            self.photoI[b] =PhotoImage(file = images[b] +'.gif')
26.            
27.            # Création du bouton.:
28.            # On utilise une expression "lambda" pour transmettre
29.            # un argument à la méthode invoquée comme commande :
30.            bou = Button(toolbar, image =self.photoI[b], relief =GROOVE,
31.                         command = lambda arg =b: self.action(arg))
32.            bou.pack(side =LEFT)
33.            
34.            # association du bouton avec un texte d'aide (bulle) :
35.            tip.bind(bou, textes[b])    
36.
37.        self.ca = Canvas(self, width =400, height =200, bg ='orange')
38.        self.ca.pack()
39.        self.pack()
40.
41.    def action(self, b):
42.        "l'icône du bouton b est recopiée dans le canevas"
43.        x, y = randrange(25,375), randrange(25,175)
44.        self.ca.create_image(x, y, image =self.photoI[b])
45.        
46.Application().mainloop()

Métaprogrammation. Expressions lambda :

Vous savez qu'en règle générale, on associe à chaque bouton une commande, laquelle est une méthode ou une fonction particulière qui se charge d'effectuer le travail lorsque le bouton est activé. Or dans l'application présente, tous les boutons doivent faire à peu près la même chose (recopier un dessin dans le canevas), la seule différence entre eux étant le dessin concerné.

Pour simplifier notre code, nous voudrions donc pouvoir associer l'option command de tous nos boutons avec une seule et même méthode (ce sera la méthode action() ), mais en lui transmettant à chaque fois la référence du bouton particulier utilisé, de manière à ce que l'action accomplie puisse être différente pour chacun d'eux.

Une difficulté se présente, cependant, parce que l'option command du widget Button accepte seulement une valeur ou une expression, et non une instruction. Il est donc permis de lui indiquer la référence d'une fonction, mais pas de l'invoquer véritablement en lui transmettant des arguments éventuels (c'est la raison pour laquelle on indique le nom de cette fonction sans lui adjoindre de parenthèses).

On peut résoudre cette difficulté de deux manières :

• Du fait de son caractère dynamique, Python accepte qu'un programme puisse se modifier lui-même, par exemple en définissant de nouvelles fonctions au cours de son exécution (c'est le concept de métaprogrammation).
  
  Il est donc possible de définir à la volée une fonction qui utilise des paramètres, en indiquant pour chacun de ceux-ci une valeur par défaut, et ensuite d'invoquer cette même fonction sans arguments là où ceux-ci ne sont pas autorisés. Puisque la fonction est définie en cours d'exécution, les valeurs par défaut peuvent être les contenus de variables, et le résultat de l'opération est un véritable transfert d'arguments.
  
  Pour illustrer cette technique, remplacez les lignes 27 à 31 du script par les suivantes :

   

  Sélectionnez

  
  # Création du bouton.:
  # On définit à la volée une fonction avec un paramètre, dont
  # la valeur par défaut est l'argument à transmettre.
  # Cette fonction appelle la méthode qui nécessite un argument :
   
  def agir(arg = b):
      self.action(arg)
   
  # La commande associée au bouton appelle la fonction ci-dessus :
  bou = Button(toolbar, image =self.photoI[b], relief =GROOVE,
               command = agir)
  

• Tout ce qui précède peut être simplifié en faisant appel à une expression lambda. Ce mot réservé Python désigne une expression qui renvoie un objet fonction, similaire à ceux que vous créez avec l'instruction def, mais avec la différence que lambda étant une expression et non une instruction, on peut l'utiliser comme interface afin d'invoquer une fonction (avec passage d'arguments) là où ce n'est normalement pas possible. Notez au passage qu'une telle fonction est anonyme (elle ne possède pas de nom).
  
  Par exemple, l'instruction :

   

  Sélectionnez

  
  lambda ar1=b, ar2=c : bidule(ar1,ar2)
  

  renvoie la référence d'une fonction anonyme qui aura elle-même invoqué la fonction bidule() en lui transmettant les arguments b et c , ceux-ci étant utilisés comme valeurs par défaut dans la définition des paramètres de la fonction.
  
  Cette technique utilise finalement le même principe que la précédente, mais elle présente l'avantage d'être plus concise, raison pour laquelle nous l'avons utilisée dans notre script. En revanche, elle est un peu plus difficile à comprendre :

   

  Sélectionnez

  
  command = lambda arg =b: self.action(arg)
  

  Dans cette portion d'instruction, la commande associée au bouton se réfère à une fonction anonyme dont le paramètre arg possède une valeur par défaut : la valeur de l'argument b.
  Invoquée sans argument par la commande, cette fonction anonyme peut tout de même utiliser son paramètre (avec la valeur par défaut) pour faire appel à la méthode cible self.action(), et l'on obtient ainsi un véritable transfert d'argument vers cette méthode .

Nous ne détaillerons pas davantage ici la question des expressions lambda, car elle déborde du cadre que nous nous sommes fixés pour cet ouvrage d'initiation. Si vous souhaitez en savoir plus, veuillez donc consulter l'un ou l'autre des ouvrages de référence cités dans la bibliographie.

Lorsque l'on construit l'ébauche d'un programme, il faut tâcher d'y faire apparaître le plus tôt possible la structure d'ensemble, avec les relations entre les principaux blocs qui constitueront l'application définitive. C'est ce que nous nous sommes efforcés de faire dans l'exemple ci-dessous :

1. from Tkinter import *
2.
3. class MenuBar(Frame):
4.     """Barre de menus déroulants"""
5.     def __init__(self, boss =None):
6.         Frame.__init__(self, borderwidth =2)
7.        
8.         ##### Menu <Fichier> #####
9.         fileMenu = Menubutton(self, text ='Fichier')
10.        fileMenu.pack(side =LEFT)
11.        # Partie "déroulante" :
12.        me1 = Menu(fileMenu)
13.        me1.add_command(label ='Effacer', underline =0,
14.                        command = boss.effacer)
15.        me1.add_command(label ='Terminer', underline =0,
16.                        command = boss.quit)
17.        # Intégration du menu :
18.        fileMenu.configure(menu = me1)    
19.
20.class Application(Frame):
21.    """Application principale"""
22.    def __init__(self, boss =None):
23.        Frame.__init__(self)
24.        self.master.title('Fenêtre avec menus')
25.        mBar = MenuBar(self)
26.        mBar.pack()
27.        self.can = Canvas(self, bg='light grey', height=190,
28.                          width=250, borderwidth =2)
29.        self.can.pack()
30.        self.pack()
31.
32.    def effacer(self):
33.        self.can.delete(ALL)
34.
35.if __name__ == '__main__':
36.    app = Application()
37.    app.mainloop()

Veuillez donc encoder ces lignes et en tester l'exécution. Vous devriez obtenir une fenêtre avec un canevas gris clair surmonté d'une barre de menus. A ce stade, la barre de menus ne comporte encore que la seule rubrique « Fichier ». Cliquez sur la rubrique « fichier » pour faire apparaître le menu correspondant : l'option « Effacer » n'est pas encore fonctionnelle (elle servira à effacer le contenu du canevas), mais l'option « Terminer » devrait déjà vous permettre de fermer proprement l'application.

Comme tous les menus gérés par Tkinter, le menu que vous avez créé peut être converti en menu « flottant » : il suffit de cliquer sur la ligne pointillée apparaissant en-tête de menu. Vous obtenez ainsi une petite fenêtre satellite, que vous pouvez alors positionner où bon vous semble sur le bureau.

Analyse du script :

La structure de ce petit programme devrait désormais vous apparaître familière : afin que les classes définies dans ce script puissent éventuellement être (ré)utilisées dans d'autres projets par importation, comme nous l'avons déjà expliqué précédemment⁵⁶, le corps principal du programme (lignes 35 à 37) comporte l'instruction classique : if __name__ == '__main__':

Les deux instructions qui suivent consistent seulement à instancier un objet app et à faire fonctionner sa méthode mainloop(). Comme vous le savez certainement, nous aurions pu également condenser ces deux instructions en une seule.

L'essentiel du du programme se trouve cependant dans les définitions de classes qui précèdent :

La classe MenuBar() contient la description de la barre de menus. Dans l'état présent du script, elle se résume à une ébauche de constructeur.

• Ligne 5 : Le paramètre boss réceptionne la référence de la fenêtre maîtresse du widget au moment de son instanciation. Cette référence va nous permettre d'invoquer les méthodes associées à cette fenêtre maîtresse, aux lignes 14 & 16.
  
• Ligne 6 : Activation obligatoire du constructeur de la classe parente.
  
• Ligne 9 : Instanciation d'un widget de la classe Menubutton(), défini comme un « esclave » de self (c'est-à-dire l'objet composite « barre de menus » dont nous sommes occupés à définir la classe). Comme l'indique son nom, ce type de widget se comporte un peu comme un bouton : une action se produit lorsque l'on clique dessus.
  
• Ligne 12 : Afin que cette action consiste en l'apparition véritable d'un menu, il reste encore à définir celui-ci : ce sera encore un nouveau widget, de la classe Menu() cette fois, défini luimême comme un « esclave » du widget Menubutton instancié à la ligne 9.
  
• Lignes 13 à 16 : On peut appliquer aux widgets de la classe Menu() un certain nombre de méthodes spécifiques, chacune d'elles acceptant de nombreuses options. Nous utilisons ici la méthode add_command() pour installer dans le menu les deux items « Effacer » et « Terminer ». Nous y intégrons tout de suite l'option underline, qui sert à définir un raccourci clavier : cette option indique en effet lequel des caractères de l'item doit apparaître souligné à l'écran. L'utilisateur sait alors qu'il lui suffit de frapper ce caractère au clavier pour que l'action correspondant à cet item soit activée (comme s'il avait cliqué dessus à l'aide de la souris).
  L'action à déclencher lorsque l'utilisateur sélectionne l'item est désignée par l'option command. Dans notre script, les commandes invoquées sont toutes les deux des méthodes de la fenêtre maîtresse, dont la référence aura été transmise au présent widget au moment de son instanciation par l'intermédiaire du paramètre boss. La méthode effacer(), que nous définissons nous-même plus loin, servira à vider le canevas. La méthode prédéfinie quit() provoque la sortie de la boucle mainloop() et donc l'arrêt du réceptionnaire d'événements associé à la fenêtre d'application.
  
• Ligne 18 : Lorsque les items du menu ont été définis, il reste encore à reconfigurer le widget maître Menubutton de manière à ce que son option « menu » désigne effectivement le Menu que nous venons de construire. En effet, nous ne pouvions pas déjà préciser cette option lors de la définition initiale du widget Menubutton, puisqu'à ce stade le Menu n'existait pas encore. Nous ne pouvions pas non plus définir le widget Menu en premier lieu, puisque celui-ci doit être défini comme un « esclave » du widget Menubutton. Il faut donc bien procéder en trois étapes comme nous l'avons fait, en faisant appel à la méthode configure(). (Cette méthode peut être appliquée à n'importe quel widget préexistant pour en modifier l'une ou l'autre option).

La classe Application() contient la description de la fenêtre principale du programme ainsi que les méthodes gestionnaires d'événements qui lui sont associées.

• Ligne 20 : Nous préférons faire dériver notre application de la classe Frame(), qui présente de nombreuses options, plutôt que de la classe primordiale Tk(). De cette manière, l'application toute entière est encapsulée dans un widget, lequel pourra éventuellement être intégré par la suite dans une application plus importante. Rappelons que de toute manière, Tkinter instanciera automatiquement une fenêtre maîtresse de type Tk() pour contenir de cette Frame.
  
• Lignes 23-24 : Après l'indispensable activation du constructeur de la classe parente, nous utilisons l'attribut master que Tkinter associe automatiquement à chaque widget, pour référencer la fenêtre principale de l'application (la fenêtre maîtresse dont nous venons de parler au paragraphe précédent) et en redéfinir le bandeau-titre.
  
• Lignes 25 à 29 : Instanciation de deux widgets esclaves pour notre Frame principale.
  La « barre de menus » est évidemment le widget défini dans l'autre classe.
  
• Ligne 30 : Comme n'importe quel autre widget, notre Frame principale doit être mise en place.
  
• Lignes 32-33 : La méthode servant à effacer le canevas est définie dans la classe présente (puisque l'objet canevas en fait partie), mais elle est invoquée par l'option command d'un widget esclave défini dans l'autre classe. Comme nous l'avons expliqué plus haut, ce widget esclave reçoit la référence de son widget maître par l'intermédiaire du paramètre boss.
  Toutes ces références sont hiérarchisées à l'aide de la qualification des noms par points.

56 Voir page 172: Modules contenant des bibliothèques de classes

Continuez le développement de ce petit programme, en ajoutant les lignes suivantes dans le constructeur de la classe MenuBar() (après la ligne 18) :

##### Menu <Musiciens> #####
self.musi = Menubutton(self, text ='Musiciens')
self.musi.pack(side =LEFT, padx ='3')
# Partie "déroulante" du menu <Musiciens> :
me1 = Menu(self.musi)
me1.add_command(label ='17e siècle', underline =1,
                foreground ='red', background ='yellow',
                font =('Comic Sans MS', 11),
                command = boss.showMusi17)
me1.add_command(label ='18e siècle', underline =1,
                foreground='royal blue', background ='white',
                font =('Comic Sans MS', 11, 'bold'),
                command = boss.showMusi18)
# Intégration du menu :
self.musi.configure(menu = me1)

... ainsi que les définitions de méthodes suivantes à la classe Application() (après la ligne 33) :

def showMusi17(self):
    self.can.create_text(10, 10, anchor =NW, text ='H. Purcell',
                         font=('Times', 20, 'bold'), fill ='yellow')
 
def showMusi18(self):
    self.can.create_text(245, 40, anchor =NE, text ="W. A. Mozart",
                         font =('Times', 20, 'italic'), fill ='dark green')

Lorsque vous y aurez ajouté toutes ces lignes, sauvegardez le script et exécutez-le.

Votre barre de menus comporte à présent une rubrique supplémentaire : la rubrique « Musiciens ». Le menu correspondant propose deux items qui sont affichés avec des couleurs et des polices personnalisées. Vous pourrez vous inspirer de ces techniques décoratives pour vos projets personnels. A utiliser avec modération ! Les commandes que nous avons associées à ces items sont évidemment simplifiées afin de ne pas alourdir l'exercice : elles provoquent l'affichage de petits textes sur le canevas.

Analyse du script

Les seules nouveautés introduites dans ces lignes concernent l'utilisation de polices de caractères bien déterminées (option font), ainsi que de couleurs pour l'avant-plan (option foreground) et le fond (option background) des textes affichés.

Veuillez noter encore une fois l'utilisation de l'option underline pour désigner les caractères correspondant à des raccourcis claviers (en n'oubliant pas que la numérotation des caractères d'une chaîne commence à partir de zéro), et surtout que l'option command de ces widgets accède aux méthodes de l'autre classe, par l'intermédiaire de la référence mémorisée dans l'attribut boss.

La méthode create_text() du canevas doit être utilisée avec deux arguments numériques, qui sont les coordonnées X et Y d'un point dans le canevas. Le texte transmis sera positionné par rapport à ce point, en fonction de la valeur choisie pour l'option anchor : Celle-ci détermine comment le fragment de texte doit être « ancré » au point choisi dans le canevas, par son centre, par son coin supérieur gauche, etc., en fonction d'une syntaxe qui utilise l'analogie des points cardinaux géographiques (NW = angle supérieur gauche, SE = angle inférieur droit, CENTER = centre, etc.)

Cette nouvelle rubrique est construite d'une manière assez semblable à la précédente, mais nous lui avons ajouté une fonctionnalité supplémentaire : des menus « en cascade ». Veuillez donc ajouter les lignes suivantes dans le constructeur de la classe MenuBar() :

##### Menu <Peintres> #####
self.pein = Menubutton(self, text ='Peintres')
self.pein.pack(side =LEFT, padx='3')
# Partie "déroulante" :
me1 = Menu(self.pein)
me1.add_command(label ='classiques', state=DISABLED)
me1.add_command(label ='romantiques', underline =0,
                command = boss.showRomanti)
# Sous-menu pour les peintres impressionistes :
me2 = Menu(me1)
me2.add_command(label ='Claude Monet', underline =7,
                command = boss.tabMonet)
me2.add_command(label ='Auguste Renoir', underline =8,
                command = boss.tabRenoir)
me2.add_command(label ='Edgar Degas', underline =6,
                command = boss.tabDegas)
# Intégration du sous-menu :
me1.add_cascade(label ='impressionistes', underline=0, menu =me2)
# Intégration du menu :
self.pein.configure(menu =me1)

... et les définitions suivantes dans la classe Application() :

def showRomanti(self):
    self.can.create_text(245, 70, anchor =NE, text = "E. Delacroix",
                         font =('Times', 20, 'bold italic'), fill ='blue')
 
def tabMonet(self):
    self.can.create_text(10, 100, anchor =NW, text = 'Nymphéas à Giverny',
                         font =('Technical', 20), fill ='red')
 
def tabRenoir(self):
    self.can.create_text(10, 130, anchor =NW,
                         text = 'Le moulin de la galette',
                         font =('Dom Casual BT', 20), fill ='maroon')
 
def tabDegas(self):
    self.can.create_text(10, 160, anchor =NW, text = 'Danseuses au repos',
                         font =('President', 20), fill ='purple')

Analyse du script :

Vous pouvez réaliser aisément des menus en cascade, en enchaînant des sous-menus les uns aux autres jusqu'à un niveau quelconque (il vous est cependant déconseillé d'aller au-delà de 5 niveaux successifs : vos utilisateurs s'y perdraient).

Un sous-menu est défini comme un menu « esclave » du menu de niveau précédent (dans notre exemple, me2 est défini comme un menu « esclave » de me1). L'intégration est assurée ensuite à l'aide de la méthode add_cascade().

L'un des items est désactivé (option state = DISABLED). L'exemple suivant vous montrera comment vous pouvez activer ou désactiver à volonté des items, par programme.

La définition de cette rubrique est un peu plus compliquée, parce que nous allons y intégrer l'utilisation de variables internes à Tkinter. Les fonctionnalités de ce menu sont cependant beaucoup plus élaborées : les options ajoutées permettent en effet d'activer ou de désactiver à volonté les rubriques « Musiciens » et « Peintres », et vous pouvez également modifier à volonté l'aspect de la barre de menus elle-même. Veuillez donc ajouter les lignes suivantes dans le constructeur de la classe MenuBar() :

##### Menu <Options> #####
optMenu = Menubutton(self, text ='Options')
optMenu.pack(side =LEFT, padx ='3')
# Variables Tkinter :
self.relief = IntVar()
self.actPein = IntVar()
self.actMusi = IntVar()
# Partie "déroulante" du menu :
self.mo = Menu(optMenu)
self.mo.add_command(label = 'Activer :', foreground ='blue')
self.mo.add_checkbutton(label ='musiciens',
                        command = self.choixActifs, variable =self.actMusi)
self.mo.add_checkbutton(label ='peintres',
                        command = self.choixActifs, variable =self.actPein)
self.mo.add_separator()
self.mo.add_command(label = 'Relief :', foreground ='blue')
for (v, lab) in [(0,'aucun'), (1,'sorti'), (2,'rentré'),
                 (3,'sillon'), (4,'crête'), (5,'bordure')]:
    self.mo.add_radiobutton(label =lab, variable =self.relief,
                            value =v, command =self.reliefBarre)
# Intégration du menu :
optMenu.configure(menu = self.mo)

... ainsi que les définitions de méthodes suivantes (toujours dans la classe MenuBar()) :

def reliefBarre(self):
    choix = self.relief.get()
    self.configure(relief =[FLAT,RAISED,SUNKEN,GROOVE,RIDGE,SOLID][choix])
 
def choixActifs(self):
    p = self.actPein.get()
    m = self.actMusi.get()
    self.pein.configure(state =[DISABLED, NORMAL][p])
    self.musi.configure(state =[DISABLED, NORMAL][m])

Analyse du script

a) Menu avec « cases à cocher »

Notre nouveau menu déroulant comporte deux parties. Afin de bien les mettre en évidence, nous avons inséré une ligne de séparation ainsi que deux « faux items » (« Activer : » et « Relief : ») qui servent simplement de titres. Nous faisons apparaître ceux-ci en couleur pour que l'utilisateur ne les confonde pas avec de véritables commandes.

Les items de la première partie sont dotées de « cases à cocher ». Lorsque l'utilisateur effectue un clic de souris sur l'un ou l'autre de ces items, les options correspondantes sont activées ou désactivées, et ces états « actif / inactif » sont affichés sous la forme d'une coche. Les instructions qui servent à mettre en place ce type de rubrique sont assez explicites. Elles présentent en effet ces items comme des widgets de type « chekbutton » :

self.mo.add_checkbutton(label = 'musiciens', command = choixActifs,
                        variable = mbu.me1.music)

Il est important de comprendre ici que ce type de widget comporte nécessairement une variable interne, destinée à mémoriser l'état « actif / inactif » du widget. Cette variable ne peut pas être une variable Python ordinaire, parce que les classes de la bibliothèque Tkinter sont écrites dans un autre langage. Et par conséquent, on ne pourra accéder à une telle variable interne qu'à travers une interface. Cette interface, appelée « variable Tkinter », est en fait un objet, que l'on crée à partir d'une classe particulière, qui fait partie du module Tkinter au même titre que les classes de widgets. L'utilisation de ces « objets-variables » est relativement simple :

• La classe IntVar() permet de créer des objets équivalents à des variables de type entier. On commence donc par créer un ou plusieurs de ces objets-variables, que l'on mémorise dans notre exemple comme de nouveaux attribiuts d'instance :

   

  Sélectionnez

  
  self.actMusi =IntVar()
  

  Après cette affectation, l'objet référencé dans self.actMusi contient désormais l'équivalent d'une variable de type entier, dans un format spécifique à Tkinter.
  

• Ensuite, on associe l'option « variable » de l'objet checkbutton à la variable Tkinter ainsi définie :

   

  Sélectionnez

  
  self.mo.add_checkbutton(label ='musiciens', variable =self.actMusi)
  

• Il est nécessaire de procéder ainsi en deux étapes, parce que Tkinter ne peut pas directement assigner des valeurs aux variables Python. Pour une raison similaire, il n'est pas possible à Python de lire directement le contenu d'une variable Tkinter. Il faut utiliser pour cela une méthode spécifique de cette classe d'objets : la méthode get()⁵⁷ :

   

  Sélectionnez

  
  m = self.actMusi.get()
  

  Dans cette instruction, nous affectons à m (variable ordinaire de Python) le contenu d'une variable Tkinter (laquelle est elle-même associée à un widget bien déterminé).

Tout ce qui précède peut vous paraître un peu compliqué. Considérez simplement qu'il s'agit de votre première rencontre avec les problèmes d'interfaçage entre deux langages de programmation différents, utilisés ensemble dans un projet composite.


b) Menu avec choix exclusifs

La deuxième partie du menu « Options » permet à l'utilisateur de choisir l'aspect que prendra la barre de menus, parmi six possibilités. Il va de soi que l'on ne peut activer qu'une seule de ces possibilités à la fois. Pour mettre en place ce genre de fonctionnalité, on fait classiquement appel appel à des widgets de type « boutons radio ». La caractéristique essentielle de ces widgets est que plusieurs d'entre eux doivent être associés à une seule et même variable Tkinter. A chaque bouton radio correspond alors une valeur particulière, et c'est cette valeur qui est affectée à la variable lorsque l'utilisateur sélectionne le bouton.

Ainsi, l'instruction :

self.mo.add_radiobutton(label ='sillon', variable =self.relief,
                        value =3, command =self.reliefBarre)

configure un item du menu «Options» de telle manière qu'il se comporte comme un bouton radio.

Lorsque l'utilisateur sélectionne cet item, la valeur 3 est affectée à la variable Tkinter self.relief (celle-ci étant désignée à l'aide de l'option variable du widget), et un appel est lancé en direction de la méthode reliefBarre(). Celle-ci récupère alors la valeur mémorisée dans la variable Tkinter pour effectuer son travail.

Dans le contexte particulier de ce menu, nous souhaitons proposer 6 possibilités différentes à l'utilisateur. Il nous faut donc six « boutons radio », pour lesquels nous pourrions encoder six instructions similaires à celle que nous avons reproduite ci-dessus, chacune d'elles ne différant des cinq autres que par ses options value et label. Dans une situation de ce genre, la bonne pratique de programmation consiste à placer les valeurs de ces options dans une liste, et à parcourir ensuite cette liste à l'aide d'une boucle for, afin d'instancier les widgets avec une instruction commune :

for (v, lab) in [(0,'aucun'), (1,'sorti'), (2,'rentré'),
                 (3,'sillon'), (4,'crête'), (5,'bordure')]:
    self.mo.add_radiobutton(label =lab, variable =self.relief,
                            value =v, command =self.reliefBarre

La liste utilisée est une liste de 6 tuples (valeur, libellé). A chacune des 6 itérations de la boucle, un nouvel item radiobutton est instancié, dont les options label et value sont extraites de la liste par l'intermédiaire des variables lab et v.


Dans vos projets personnels, il vous arrivera fréquemment de constater que vous pouvez ainsi remplacer des suites d'instructions similaires, par une structure de programmation plus compacte (en général, la combinaison d'une liste et d'une boucle, comme dans l'exemple ci-dessus).

Vous découvrirez petit à petit encore d'autres techniques pour alléger votre code : nous en fournissons encore un exemple dans le paragraphe suivant. Tâchez cependant de garder à l'esprit cette règle essentielle, qu'un bon programme doit avant tout rester lisible et commenté.


c) Contrôle du flux d'exécution à l'aide d'une liste

Veuillez à présent considérer la définition de la méthode reliefBarre() :

A la première ligne, la méthode get() nous permet de récupérer l'état d'une variable Tkinter qui contient le numéro du choix opéré par l'utilisateur dans le sous-menu « Relief : ».

A la seconde ligne, nous utilisons le contenu de la variable choix pour extraire d'une liste de six éléments celui qui nous intéresse. Par exemple, si choix contient la valeur 2, c'est l'option SUNKEN qui sera utilisée pour reconfigurer le widget.

La variable choix est donc utilisée ici comme un index, servant à désigner un élément de la liste. En lieu et place de cette construction compacte, nous aurions pu programmer une série de tests conditionnels, comme par exemple :

if choix ==0:
    self.configure(relief =FLAT)
elif choix ==1:
    self.configure(relief =RAISED)
elif choix ==2:
    self.configure(relief =SUNKEN)
...
etc.

D'un point de vue strictement fonctionnel, le résultat serait exactement le même. Vous admettrez cependant que la construction que nous avons choisie est d'autant plus efficiente, que le nombre de possibilités de choix est élevé. Imaginez par exemple que l'un de vos programmes personnels doive effectuer une sélection dans un très grand nombre d'éléments : avec une construction du type cidessus, vous seriez peut-être amené à encoder plusieurs pages de « elif » !


Nous utilisons encore la même technique dans la méthode choixActifs(). Ainsi l'instruction :

self.pein.configure(state =[DISABLED, NORMAL][p])

utilise le contenu de la variable p comme index pour désigner lequel des deux états DISABLED, NORMAL doit être sélectionné pour reconfigurer le menu « Peintres ».

Lorsqu'elle est appelée, la méthode choixActifs() reconfigure donc les deux rubriques « Peintres » et « Musiciens » de la barre de menus, pour les faire apparaître « normales » ou « désactivées » en fonction de l'état des variables m et p, lesquelles sont elles-mêmes le reflet de variables Tkinter.

Ces variables intermédiaires m et p ne servent en fait qu'à clarifier le script. Il serait en effet parfaitement possible de les éliminer, et de rendre le script encore plus compact, en utilisant la composition d'instructions. On pourrait par exemple remplacer les deux instructions :

m = self.actMusi.get()
self.musi.configure(state =[DISABLED, NORMAL][m])

par une seule, telle que :

self.musi.configure(state =[DISABLED, NORMAL][self.actMusi.get()])

Notez cependant que ce que l'on gagne en compacité se paie d'une certaine perte de lisibilité.


d) Pré-sélection d'une rubrique

Pour terminer cet exercice, voyons encore comment vous pouvez déterminer à l'avance certaines sélections, ou bien les modifier par programme.

Veuillez donc ajouter l'instruction suivante dans le constructeur de la classe Application() (juste avant l'instruction self.pack() ,par exemple) :

mBar.mo.invoke(2)

Lorsque vous exécutez le script ainsi modifié, vous constatez qu'au départ la rubrique « Musiciens » de la barre de menus est active, alors que la rubrique « Peintres » ne l'est pas. Programmées comme elles le sont, ces deux rubriques devraient être actives toutes deux par défaut. Et c'est effectivement ce qui se passe si nous supprimons l'instruction :

mBar.mo.invoke(2)

Nous vous avons suggéré d'ajouter cette instruction au script, pour vous montrer comment vous pouvez effectuer par programme la même opération que celle que l'on obtient normalement avec un clic de souris.

L'instruction ci-dessus invoque le widget mBar.mo en actionnant la commande associée au deuxième item de ce widget. En consultant le listing, vous pouvez vérifier que ce deuxième item est bien l'objet de type checkbutton qui active/désactive le menu « Peintres » (Rappelons encore une fois que l'on numérote toujours à partir de zéro).

Au démarrage du programme, tout se passe donc comme si l'utilisateur effectuait tout de suite un premier clic sur la rubrique « Peintres » du menu « Options », ce qui a pour effet de désactiver le menu correspondant.

57 Pour écrire dans une variable Tkinter, il faudrait utiliser la méthode set() . Exemple :
self.actMusi.set(45)