Apprendre à programmer avec Python 3

• Ligne 3 : Cette fois encore, nous préférons construire notre petite application comme une classe dérivée de la classe Frame(), ce qui nous permettrait éventuellement de l'intégrer sans difficulté dans une application plus importante.
• Ligne 8 : En général, on applique les méthodes de positionnement des widgets (pack(), grid(), ou place()) après instanciation de ceux-ci, ce qui permet de choisir librement leur disposition à l'intérieur des fenêtres maîtresses. Comme nous le montrons ici, il est cependant tout à fait possible de déjà prévoir ce positionnement dans le constructeur du widget.
• Ligne 11 : Les widgets de la classe Entry disposent de plusieurs méthodes pour accéder à la chaîne de caractères affichée. La méthode get() permet de récupérer la chaîne entière. La méthode insert() permet d'insérer de nouveaux caractères à un emplacement quelconque (c'est-à-dire au début, à la fin, ou même à l'intérieur d'une chaîne préexistante éventuelle). Cette méthode s'utilise donc avec deux arguments, le premier indiquant l'emplacement de l'insertion (utilisez 0 pour insérer au début, END pour insérer à la fin, ou encore un indice numérique quelconque pour désigner un caractère dans la chaîne). La méthode delete() permet d'effacer tout ou partie de la chaîne. Elle s'utilise avec les mêmes arguments que la précédente (cf. projet « Code des couleurs », page ).
• Lignes 14-15 : Plutôt que de les instancier dans des instructions séparées, nous préférons créer nos quatre boutons à l'aide d'une boucle. Les options spécifiques à chacun d'eux sont d'abord préparées dans les deux listes stylePoliceFr et stylePoliceTk : la première contient les petits textes qui devront s'afficher en regard de chaque bouton, et la seconde les valeurs qui devront leur être associées.
• Lignes 17-18 : Comme expliqué à la page précédente, les quatre boutons forment un groupe autour d'une variable commune. Cette variable prendra la valeur associée au bouton radio que l'utilisateur décidera de choisir. Nous ne pouvons cependant pas utiliser une variable ordinaire pour remplir ce rôle, parce que les attributs internes des objets tkinter ne sont accessibles qu'au travers de méthodes spécifiques. Une fois de plus, nous utilisons donc ici un objet-variable tkinter, de type chaîne de caractères, que nous instancions à partir de la classe StringVar(), et auquel nous donnons une valeur par défaut à la ligne 18.
• Lignes 20 à 26 : Instanciation des quatre boutons radio. Chacun d'entre eux se voit attribuer une étiquette et une valeur différentes, mais tous sont associés à la même variable tkinter commune (self.choixPolice). Tous invoquent également la même méthode self.changePolice(), chaque fois que l'utilisateur effectue un clic de souris sur l'un ou l'autre.
• Lignes 28 à 31 : Le changement de police s'obtient par re-configuration de l'option font du widget Entry. Cette option attend un tuple contenant le nom de la police, sa taille, et éventuellement son style. Si le nom de la police ne contient pas d'espaces, le tuple peut aussi être remplacé par une chaîne de caractères. Exemples :
  ('Arial', 12, 'italic')
  ('Helvetica', 10)
  ('Times New Roman', 12, 'bold italic')
  "Verdana 14 bold"
  "President 18 italic" (Voyez également les exemples de la page ).

• Lignes 3 à 5 : Afin de simplifier au maximum la démonstration, nous ne programmons pas cet exemple comme une nouvelle classe. Remarquez à la ligne 5 l'utilité de la méthode geometry() pour fixer les dimensions de la fenêtre principale.
• Ligne 7 : Instanciation du cadre de gauche. La couleur de fond (une variété de bleu cyan) est déterminée par l'argument bg (background). Cette chaîne de caractères contient en notation hexadécimale la description des trois composantes rouge, verte et bleue de la teinte que l'on souhaite obtenir : après le caractère # signalant que ce qui suit est une valeur numérique hexadécimale, on trouve trois groupes de deux symboles alphanumériques. Chacun de ces groupes représente un nombre compris entre 1 et 255. Ainsi, 80 correspond à 128, et c0 correspond à 192 en notation décimale. Dans notre exemple, les composantes rouge, verte et bleue de la teinte à représenter valent donc respectivement 128, 192 et 192.
  En application de cette technique descriptive, le noir serait obtenu avec #000000, le blanc avec #ffffff, le rouge pur avec #ff0000, un bleu sombre avec #000050, etc.
• Ligne 8 : Puisque nous lui appliquons la méthode pack(), le cadre sera automatiquement dimensionné par son contenu. L'option side =LEFT le positionnera à gauche dans sa fenêtre maîtresse. L'option padx =5 ménagera un espace de 5 pixels à sa gauche et à sa droite (nous pouvons traduire « padx » par « espacement horizontal »).
• Ligne 10 : Dans le cadre f1 que nous venons de préparer, nous avons l'intention de regrouper 6 autres cadres similaires contenant chacun une étiquette. Le code correspondant sera plus simple et plus efficace si nous instancions ces widgets dans une liste plutôt que dans des variables indépendantes. Nous préparons donc cette liste avec 6 éléments que nous remplacerons plus loin.
• Lignes 11 à 16 : Pour construire nos 6 cadres similaires, nous allons parcourir une liste de 6 tuples contenant les caractéristiques particulières de chaque cadre. Chacun de ces tuples est constitué de 4 éléments : un indice, une constante tkinter définissant un type de relief, et deux chaînes de caractères décrivant respectivement la couleur et le texte de l'étiquette.
  La boucle for effectue 6 itérations pour parcourir les 6 éléments de la liste. À chaque itération, le contenu d'un des tuples est affecté aux variables n, col, rel et txt (et ensuite les instructions des lignes 17 à 20 sont exécutées).

Le parcours d'une liste de tuples à l'aide d'une boucle for constitue une construction particulièrement compacte, qui permet de réaliser de nombreuses affectations avec un très petit nombre d'instructions.

• Ligne 17 : Les 6 cadres sont instanciés comme des éléments de la liste fint. Chacun d'entre eux est agrémenté d'une bordure décorative de 2 pixels de large, avec un certain effet de relief.
• Lignes 18-20 : Les étiquettes ont toutes la même taille, mais leurs textes et leurs couleurs de fond diffèrent. Du fait de l'utilisation de la méthode pack(), c'est la dimension des étiquettes qui détermine la taille des petits cadres. Ceux-ci à leur tour déterminent la taille du cadre qui les regroupe (le cadre f1). Les options padx et pady permettent de réserver un petit espace autour de chaque étiquette, et un autre autour de chaque petit cadre. L'option side =TOP positionne les 6 petits cadres les uns en dessous des autres dans le cadre conteneur f1.
• Lignes 22-23 : Préparation du cadre f2 (cadre de droite). Sa couleur sera une variété de jaune, et nous l'entourerons d'une bordure décorative ayant l'aspect d'un sillon.
• Lignes 25 à 28 : Le cadre f2 contiendra un canevas et un bouton. Notez encore une fois l'utilisation des options padx et pady pour ménager des espaces autour des widgets (considérez par exemple le cas du bouton, pour lequel cette option n'a pas été utilisée : de ce fait, il entre en contact avec la bordure du cadre qui l'entoure). Comme nous l'avons fait pour les cadres, nous avons placé une bordure autour du canevas. Sachez que d'autres widgets acceptent également ce genre de décoration : boutons, champs d'entrée, etc.

Le script contient essentiellement la définition d'une classe graphique dérivée de Canvas().

Cette nouvelle classe étant susceptible d'être réutilisée dans d'autres projets, nous plaçons l'ensemble du programme de test de cette classe dans la structure désormais classique : if __name__ ="__main__": Ainsi le script peut être utilisé tel quel en tant que module à importer, pour d'autres applications à votre gré..

Le constructeur de notre nouveau widget Bac_a_sable() attend la référence du widget maître (boss) comme premier paramètre, suivant la convention habituelle. Il fait appel au constructeur de la classe parente, puis met en place des mécanismes locaux.

En l'occurrence, il s'agit d'associer les trois identificateurs d'événements <Button-1>, <Button1-Motion> et <Button1-ButtonRelease> aux noms des trois méthodes choisies comme gestionnaires de cesévénements(80).

Lorsque l'utilisateur enfonce le bouton gauche de sa souris, la méthode mouseDown() est donc activée, et le système d'exploitation lui transmet en argument un objet event, dont les attributs x et y contiennent les coordonnées du curseur souris dans le canevas, déterminées au moment du clic.

Nous mémorisons directement ces coordonnées dans les variables d'instance self.x1 et self.x2, car nous en aurons besoin par ailleurs. Ensuite, nous utilisons la méthode find_closest() du widget canevas, qui nous renvoie la référence du dessin le plus proche. Cette méthode bien pratique renvoie toujours une référence, même si le clic de souris n'a pas été effectué à l'intérieur du dessin.

Le reste est facile à comprendre : la référence du dessin sélectionné est mémorisée dans une variable d'instance, et nous pouvons faire appel à d'autres méthodes du canevas de base pour modifier ses caractéristiques. En l'occurrence, nous utilisons les méthodes itemconfig() et lift() pour épaissir son contour et le faire passer à l'avant-plan.

Le « transport » du dessin est assuré par la méthode mouseMove(), invoquée à chaque fois que la souris se déplace alors que son bouton gauche est resté enfoncé. L'objet event contient cette fois encore les coordonnées du curseur souris, au terme de ce déplacement. Nous nous en servons pour calculer les différences entre ces nouvelles coordonnées et les précédentes, afin de pouvoir les transmettre à la méthode move() du widget canevas, qui effectuera le transport proprement dit.

Nous ne pouvons cependant faire appel à cette méthode que s'il existe effectivement un objet sélectionné (c'est le rôle de la variable d'instance selObject), et il nous faut veiller également à mémoriser les nouvelles coordonnées acquises.

La méthode mouseUp() termine le travail. Lorsque le dessin transporté est arrivé à destination, il reste à annuler la sélection et rendre au contour son épaisseur initiale. Ceci ne peut être envisagé que s'il existe effectivement une sélection, bien entendu.

Dans le corps du programme de test, nous instancions 15 dessins sans nous préoccuper de conserver leurs références dans des variables. Nous pouvons procéder ainsi parce que tkinter conserve lui-même une référence interne pour chacun de ces objets (cf. page ; si vous travaillez avec d'autres bibliothèques graphiques, vous devrez probablement prévoir une mémorisation de ces références).

Les dessins sont de simples ellipses colorées. Leur couleur est choisie au hasard dans une liste de 8 possibilités, l'indice de la couleur choisie étant déterminé par la fonction randrange() importée du module random.

La petite application ci-après vous montre comment construire une nouvelle classe de widget de type Combo box. On appelle ainsi un widget qui associe un champ d'entrée à une boîte de liste : l'utilisateur de ce widget peut entrer dans le système, soit un des éléments de la liste proposée (en cliquant sur son nom), soit un élément non répertorié (en entrant un nouveau nom dans le champ d'entrée). Nous avons un peu simplifié le problème en laissant la liste visible en permanence, mais il est parfaitement possible de perfectionner ce widget pour qu'il prenne la forme classique d'un champ d'entrée assorti d'un petit bouton provoquant l'apparition de la liste, celle-ci étant cachée au départ. (Voir exercice 14.1, page ).

Tel que nous l'imaginons, notre widget combo va donc regrouper en une seule entité trois widgets de base tkinter : un champ d'entrée, une boîte de liste (listbox) et un « ascenseur » (barre de défilement vertical ou scrollbar).

La boîte de liste et son ascenseur seront étroitement associés, puisque l'ascenseur permet de faire défiler la liste dans sa boîte. Il faudra d'ailleurs s'assurer que l'ascenseur ait toujours la même hauteur que la boîte, quelle que soit la taille choisie pour celle-ci.

Pour tester celui-ci, nous l'incluons dans une petite application très simple : lorsque l'utilisateur choisit une couleur dans la liste (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).

from tkinter import *
 
class ComboBox(Frame):
  "Widget composite associant un champ d'entrée avec une boîte de liste"
  def __init__(self, boss, item='', items=[], command ='', width =10,
	listSize =5):
      Frame.__init__(self, boss)   # constructeur de la classe parente
		   # (<boss> est la réf. du widget 'maître')
      self.items =items       # items à placer dans la boîte de liste
      self.command =command	  # fonction à invoquer après clic ou <enter>
      self.item =item		# item entré ou sélectionné
 
      # Champ d'entrée :
      self.entree =Entry(self, width =width)	      # largeur en caractères
      self.entree.insert(END, item)
      self.entree.bind("<Return>", self.sortieE)
      self.entree.pack(side =TOP)
 
      # Boîte de liste, munie d'un 'ascenseur' (scroll bar) :
      cadreLB =Frame(self)	     # cadre pour l'ensemble des 2
      self.bListe =Listbox(cadreLB, height =listSize, width =width-1)
      scrol =Scrollbar(cadreLB, command =self.bListe.yview)
      self.bListe.config(yscrollcommand =scrol.set)
      self.bListe.bind("<ButtonRelease-1>", self.sortieL)
      self.bListe.pack(side =LEFT)
      scrol.pack(expand =YES, fill =Y)
      cadreLB.pack()
 
      # Remplissage de la boîte de liste avec les items fournis :
      for it in items:
      self.bListe.insert(END, it)
 
  def sortieL(self, event =None):
      # Extraire de la liste l'item qui a été sélectionné :
      index =self.bListe.curselection()      # renvoie un tuple d'index
      ind0 =int(index[0])	      # on ne garde que le premier
      self.item =self.items[ind0]
      # Actualiser le champ d'entrée avec l'item choisi :
      self.entree.delete(0, END)
      self.entree.insert(END, self.item)
      # Exécuter la commande indiquée, avec l'item choisi comme argument :
      self.command(self.item)
 
  def sortieE(self, event =None):
      # Exécuter la commande indiquée, avec l'argument-item encodé tel quel :
      self.command(self.entree.get())
 
  def get(self):
      # Renvoyer le dernier item sélectionné dans la boîte de liste
      return self.item
 
if __name__ =="__main__":	    # --- Programme de test ---
  def changeCoul(col):
      fen.configure(background = col)
 
  def changeLabel():
      lab.configure(text = combo.get())
 
  couleurs = ('navy', 'royal blue', 'steelblue1', 'cadet blue',
	  'lawn green', 'forest green', 'yellow', 'dark red',
	  'grey80','grey60', 'grey40', 'grey20', 'pink')
  fen =Tk()
  combo =ComboBox(fen, item ="néant", items =couleurs, command =changeCoul,
	  width =15, listSize =6)
  combo.grid(row =1, columnspan =2, padx =10, pady =10)
  bou = Button(fen, text ="Test", command =changeLabel)
  bou.grid(row =2, column =0, padx =8, pady =8)
  lab = Label(fen, text ="Bonjour", bg ="ivory", width =15)
  lab.grid(row =2, column =1, padx =8)
  fen.mainloop()

16-D-1-A. Commentaires▲

En procédant de la même manière que dans l'exemple précédent, vous pouvez associer les widgets standard tkinter de multiples façons. Ainsi nous vous présentons ci-après un widget composite qui pourrait vous servir à ébaucher un système de traitement de textes rudimentaire. Son principal composant est le widget Text standard, lequel peut afficher des textes formatés, c'est-à-dire des textes intégrant divers attributs de style, comme par exemple le gras, l'italique, l'exposant ..., ainsi que des polices de caractères différentes, de la couleur, et même des images. Nous l'avons simplement associé à une barre de défilement verticale pour vous montrer une fois de plus les interactions que vous pouvez créer entre ces composants.

Par exemple, dans l'application décrite ci-après, le fait de cliquer sur le nom « Jean de la Fontaine », à l'aide du bouton droit de la souris, provoque le défilement automatique du texte (scrolling), jusqu'à ce qu'une rubrique décrivant cet auteur devienne visible dans le widget (voir le script correspondant page suivante). D'autres fonctionnalités sont présentes, telles la possibilité de sélectionner à l'aide de la souris n'importe quelle portion du texte affiché pour lui faire subir un traitement quelconque, mais nous ne présenterons ici que les plus fondamentales. Veuillez donc consulter les ouvrages ou sites web spécialisés pour en savoir davantage.

16-D-2-A. Gestion du texte affiché▲

from tkinter import *
 
class ScrolledText(Frame):
  """Widget composite, associant un widget Text et une barre de défilement"""
  def __init__(self, boss, baseFont ="Times", width =50, height =25):
      Frame.__init__(self, boss, bd =2, relief =SUNKEN)
      self.text =Text(self, font =baseFont, bg ='ivory', bd =1,
	      width =width, height =height)
      scroll =Scrollbar(self, bd =1, command =self.text.yview)
      self.text.configure(yscrollcommand =scroll.set)
      self.text.pack(side =LEFT, expand =YES, fill =BOTH, padx =2, pady =2)
      scroll.pack(side =RIGHT, expand =NO, fill =Y, padx =2, pady =2)
 
  def importFichier(self, fichier, encodage ="Utf8"):
      "insertion d'un texte dans le widget, à partir d'un fichier"
      of =open(fichier, "r", encoding =encodage)
      lignes =of.readlines()
      of.close()
      for li in lignes:
      self.text.insert(END, li)
 
def chercheCible(event=None):
  "défilement du texte jusqu'à la balise <cible>, grâce à la méthode see()"
  index = st.text.tag_nextrange('cible', '0.0', END)
  st.text.see(index[0])
 
### Programme principal : fenêtre avec un libellé et un 'ScrolledText' ###
fen =Tk()
lib =Label(fen, text ="Widget composite : Text + Scrollbar",
     font ="Times 14 bold italic", fg ="navy")
lib.pack(padx =10, pady =4)
st =ScrolledText(fen, baseFont="Helvetica 12 normal", width =40, height =10)
st.pack(expand =YES, fill =BOTH, padx =8, pady =8)
 
# Définition de balises, liaison d'un événement <clic du bouton droit> :
st.text.tag_configure("titre", foreground ="brown",
	    font ="Helvetica 11 bold italic")
st.text.tag_configure("lien", foreground ="blue",
	    font ="Helvetica 11 bold")
st.text.tag_configure("cible", foreground ="forest green",
	    font ="Times 11 bold")
st.text.tag_bind("lien", "<Button-3>", chercheCible)
 
titre ="""Le Corbeau et le Renard
par Jean de la Fontaine, auteur français
\n"""
auteur ="""
Jean de la Fontaine
écrivain français (1621-1695)
célèbre pour ses Contes en vers,
et surtout ses Fables, publiées
de 1668 à 1694."""
 
# Remplissage du widget Text (2 techniques) :
st.importFichier("CorbRenard.txt", encodage ="Latin1")
st.text.insert("0.0", titre, "titre")
st.text.insert(END, auteur, "cible")
# Insertion d'une image :
photo =PhotoImage(file= "penguin.gif")
st.text.image_create("6.14", image =photo)
# Ajout d'une balise supplémentaire :
st.text.tag_add("lien", "2.4", "2.23")
 
fen.mainloop()

16-D-2-B. Commentaires▲

Nous avons déjà beaucoup exploité le widget Canvas, dont les possibilités sont extrêmement étendues. Nous avons déjà vu aussi comment nous pouvons encore enrichir cette classe par dérivation. C'est ce que nous allons faire une fois de plus dans l'exemple ci-après, avec la définition d'une nouvelle classe ScrolledCanvas, dans laquelle nous associerons au canevas standard deux barres de défilement (une verticale et une horizontale).

Afin de rendre l'exercice plus attrayant, nous nous servirons de notre nouvelle classe de widget pour réaliser un petit jeu d'adresse, dans lequel l'utilisateur devra 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 polyvalent : 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 base Tk(). Elle contient deux widgets : un simple libellé, et notre nouveau widget composite ScrolledCanvas. Celui-ci est une « vue » sur un espace de dessin beaucoup plus grand, dans lequel nous pourrons « voyager » grâce aux barres de défilement.

Afin que l'espace disponible soit bien repérable, nous commençons par y planter un décor simple, 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'œil sous la forme d'une image bitmap, destinée avant tout à vous rappeler comment vous pouvez gérer ce type de ressource.

Pour terminer, nous y installons aussi un véritable widget fonctionnel : en l'occurrence un simple bouton, mais la technique mise en œuvre 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, et l'animation s'arrête si on arrive à nouveau à cliquer dessus. 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.

from tkinter import *
from random import randrange
 
class ScrolledCanvas(Frame):
  """Canevas extensible avec barres de défilement"""
  def __init__(self, boss, width =100, height =100, bg="white", bd=2,
	scrollregion =(0, 0, 300, 300), relief=SUNKEN):
      Frame.__init__(self, boss, bd =bd, relief=relief)
      self.can =Canvas(self, width=width-20, height=height-20, bg=bg,
	    scrollregion =scrollregion, bd =1)
      self.can.grid(row =0, column =0)
      bdv =Scrollbar(self, orient =VERTICAL, command =self.can.yview, bd =1)
      bdh =Scrollbar(self, orient =HORIZONTAL, command =self.can.xview, bd =1)
      self.can.configure(xscrollcommand =bdh.set, yscrollcommand =bdv.set)
      bdv.grid(row =0, column =1, sticky = NS)	     # sticky =>
      bdh.grid(row =1, column =0, sticky = EW)	     # étirer la barre
      # Lier l'événement <redimensionnement> à un gestionnaire approprié :
      self.bind("<Configure>", self.redim)
      self.started =False
 
  def redim(self, event):
      "opérations à effectuer à chaque redimensionnement du widget"
      if not self.started:
      self.started =True       # Ne pas redimensionner dès la création
      return	       # du widget (sinon => bouclage)
      # À partir des nouvelles dimensions du cadre, redimensionner le canevas
      # (la diff. de 20 pixels sert à compenser l'épaisseur des scrollbars) :
      larg, haut = self.winfo_width()-20, self.winfo_height()-20
      self.can.config(width =larg, height =haut)
 
class FenPrinc(Tk):
  def __init__(self):
      Tk.__init__(self)
      self.libelle =Label(text ="Scroll game", font="Helvetica 14 bold")
      self.libelle.pack(pady =3)
      terrainJeu =ScrolledCanvas(self, width =500, height =300, relief=SOLID,
		 scrollregion =(-600,-600,600,600), bd =3)
      terrainJeu.pack(expand =YES, fill =BOTH, padx =6, pady =6)
      self.can =terrainJeu.can
      # Décor : tracé d'une série d'ellipses aléatoires :
      coul =('sienna','maroon','brown','pink','tan','wheat','gold','orange',
	 'plum','red','khaki','indian red','thistle','firebrick',
	 'salmon','coral','yellow','cyan','blue','green')
      for r in range(80):
      x1, y1 = randrange(-600,450), randrange(-600,450)
      x2, y2 = x1 +randrange(40,300), y1 +randrange(40,300)
      couleur = coul[randrange(20)]
      self.can.create_oval(x1, y1, x2, y2, fill=couleur, outline='black')
      # Ajout d'une petite image GIF :
      self.img = PhotoImage(file ='linux2.gif')
      self.can.create_image(50, 20, image =self.img)
      # Bouton à attraper :
      self.x, self.y = 50, 100
      self.bou = Button(self.can, text ="Start", command =self.start)
      self.fb = self.can.create_window(self.x, self.y, window =self.bou)
 
  def anim(self):
      if self.run ==0:
      return
      self.x += randrange(-60, 61)
      self.y += randrange(-60, 61)
      self.can.coords(self.fb, self.x, self.y)
      self.libelle.config(text = 'Cherchez en %s %s' % (self.x, self.y))
      self.after(250, self.anim)
 
  def stop(self):
      self.run =0
      self.bou.configure(text ="Start", command =self.start)
 
  def start(self):
      self.bou.configure(text ="Attrapez-moi !", command =self.stop)
      self.run =1
      self.anim()
 
if __name__ =="__main__":	   # --- Programme de test ---
  FenPrinc().mainloop()

16-D-3-A. Commentaires▲

• Lignes 3 à 8 : Si vous souhaitez pouvoir disposer du même style de boutons à différents endroits de votre projet, n'hésitez pas à créer une classe dérivée, comme nous l'avons fait ici. Cela vous évitera d'avoir à reprogrammer partout les mêmes options spécifiques.
  Notez bien les deux astérisques qui préfixent le nom du dernier paramètre du constructeur : **Arguments. Elles signifient que la variable correspondante sera en fait un dictionnaire, capable de réceptionner automatiquement n'importe quel ensemble d'arguments « avec étiquettes ». Ces arguments pourront alors être transmis tels quels au constructeur de la classe parente (à la ligne 8). Cela nous évite d'avoir à reproduire dans notre liste de paramètres toutes les options de paramétrage du bouton de base, qui sont fort nombreuses. Ainsi vous pourrez instancier ces boutons de fantaisie avec n'importe quelle combinaison d'options, du moment que celles-ci soient disponibles pour les boutons de base. On appelle ce qui précède un paramétrage implicite. Vous pouvez utiliser cette forme de paramétrage avec n'importe quelle fonction ou méthode.
• Lignes 10 à 24 : Le constructeur de notre widget SpinBox ne nécessite guère de commentaires. En fonction de l'orientation souhaitée, la méthode pack() disposera les boutons et le libellé de haut en bas ou de gauche à droite (arguments TOP ou RIGHT pour son option side).
• Lignes 26 à 38 : Ces deux méthodes ne font rien d'autre que de modifier la valeur affichée dans le libellé. Notez au passage que la classe Frame() dispose d'une méthode bell() pour provoquer l'émission d'un « bip » sonore.
• Lignes 43 à 53 : La première fenêtre satellite est définie ici. Remarquez à nouveau l'utilisation du paramétrage implicite du constructeur, à l'aide de la variable **Arguments. C'est lui qui nous permet d'instancier cette fenêtre (à la ligne 81) en spécifiant une couleur de fond. (Nous pourrions aussi demander une bordure, etc.). Les méthodes invoquées aux lignes 47 à 49 définissent quelques propriétés particulières (elles qui sont applicables à n'importe quelle fenêtre). La méthode geometry() permet de fixer à la fois les dimensions de la fenêtre et son emplacement à l'écran (l'indication +100+240 signifie que son coin supérieur gauche doit être décalé de 100 pixels vers la droite, et de 240 pixels vers le bas, par rapport au coin supérieur gauche de l'écran).
• Lignes 45 et 57 : Veuillez remarquer la petite différence entre les listes de paramètres de ces lignes. Dans le constructeur de FenDessin, nous avons omis le paramètre boss, qui est bien présent dans le constructeur de FenControle. Vous savez que ce paramètre sert à transmettre la référence du widget « maître » à son « esclave ». Il est très généralement nécessaire (à la ligne 67, par exemple, nous nous en servons pour référencer une méthode de l'application principale), mais il n'est pas absolument indispensable : dans FenDessin nous n'en avons aucune utilité. Vous retrouverez bien évidemment la différence correspondante dans les instructions d'instanciation de ces fenêtres, aux lignes 82 et 84.
• Lignes 55 à 67 : À l'exception de la différence mentionnée ci-dessus, la construction du widget FenControle est très similaire à celle de FenDessin. Remarquez à la ligne 60 la méthode permettant d'empêcher le redimensionnement d'une fenêtre (dans le cas d' une fenêtre sans bordure ni bandeau-titre, comme FenDessin, cette méthode est inutile).
• Lignes 73-74 (et 49) : Toutes les classes dérivées des widgets tkinter sont dotées automatiquement d'un attribut master, qui contient la référence de la classe parente. C'est ce qui nous permet ici d'accéder aux dimensions et à la couleur de fond de la fenêtre maîtresse.
• Lignes 86 à 88 : Cette méthode récupère les valeurs numériques affichées dans la fenêtre de contrôle (méthode get() de ce widget), pour redimensionner le canevas de la fenêtre de dessin. Cet exemple simple vous montre une fois de plus comment peuvent s'établir les communications entre divers composants de votre programme.

Vous savez qu'en règle générale, on associe à chaque bouton une commande, laquelle est la référence d'une méthode ou d'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 s'agit en fait de lui indiquer la référence d'une fonction, mais certainement pas d'invoquer la fonction à cet endroit avec des arguments (l'invocation ne pourra avoir lieu en effet que lorsque l'utilisateur cliquera sur le bouton : c'est alors le réceptionnaire d'événements de tkinter qui devra la provoquer). C'est la raison pour laquelle on indique seulement le nom de la fonction, sans 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 avec des paramètres, en indiquant pour chacun de ceux-ci une valeur par défaut, et de fournir ensuite la référence de cette fonction à l'option command. Puisque la fonction est définie en cours d'exécution, ces valeurs par défaut peuvent être les contenus de variables. Lorsque l'événement « clic sur le bouton » provoquera l'appel de la fonction, celle-ci utilisera donc les valeurs par défaut de ses paramètres, comme s'il s'agissait d'arguments. Le résultat de l'opération équivaut par conséquent à un transfert d'arguments classique.

Pour illustrer cette technique, remplacez les lignes 17 à 20 du script par les suivantes :

# 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(self, image = self.photoI[b], relief = GROOVE,
command = agir)

• Voilà pour le principe. Mais 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 objetfonction, 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'expression :

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

renvoie la référence d'une fonction anonyme créée à la volée, qui pourra elle-même invoquer 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 ar1 et ar2 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 :

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 arg (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.

Vous avez déjà rencontré de nombreux widgets comportant une telle option command, à laquelle il faut à chaque fois associer le nom d'une fonction (ou d'une méthode). En termes plus généraux, cela signifie donc qu'une fonction avec paramètres peut recevoir la référence d'une autre fonction comme argument, et l'utilité de la chose apparaît clairement ici.

Nous avons d'ailleurs programmé nous-même une fonctionnalité de ce genre dans notre nouvelle classe ToolBar(). Vous pouvez constater que nous avons inclus le nom command dans la liste de paramètres de son constructeur, à la ligne 6. Ce paramètre attend la référence d'une fonction ou d'une méthode comme argument. La dite référence est alors mémorisée dans une variable d'instance (à la ligne 9), de manière à être accessible depuis les autres méthodes de la classe. Celles-ci peuvent dès lors invoquer la fonction ou la méthode (au besoin en lui transmettant des arguments si nécessaire, suivant la technique expliquée à la rubrique précédente). C'est ce que fait donc notre méthode action(), à la ligne 25. En l'occurrence, la méthode ainsi transmise est la méthode transfert() de la classe Application (cf. ligne 34).

Nous sommes parvenus ainsi à développer une classe d'objets ToolBar parfaitement réutilisables dans d'autres contextes. Comme le montre notre petite application, il suffit en effet d'instancier ces objets en indiquant la référence d'une fonction quelconque en argument de l'option command. Cette fonction sera alors automatiquement appelée elle-même avec le numéro d'ordre du bouton cliqué par l'utilisateur.

Libre à vous d'imaginer à présent ce que la fonction devra effectuer !

Pour en terminer avec cet exemple, remarquons encore un petit détail : chacun de nos boutons apparaît entouré d'un sillon (option relief =GROOVE). Vous pouvez aisément obtenir d'autres aspects en choisissant judicieusement les options relief et bd (bordure) dans l'instruction d'instanciation de ces boutons. En particulier, vous pouvez choisir relief =FLAT et bd =0 pour obtenir des petits boutons « plats », sans aucun relief.

Notre application comportera simplement une barre de menus et un canevas. Les différentes rubriques et options des menus ne serviront qu'à faire apparaître des fragments de texte dans le canevas ou à modifier des détails de décoration, mais ce seront avant tout des exemples variés, destinés à donner un aperçu des nombreuses possibilités offertes par ce type de widget, accessoire indispensable de toute application moderne d'une certaine importance.

Nous souhaitons également que le code produit dans cet exercice soit bien structuré. Pour ce faire, nous ferons usage de deux classes : une classe pour l'application principale, et une autre pour la barre de menus. Nous voulons procéder ainsi afin de bien mettre en évidence la construction d'une application type incorporant plusieurs classes d'objets interactifs.

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 :

from tkinter import *
 
class MenuBar(Frame):
  """Barre de menus déroulants"""
  def __init__(self, boss =None):
      Frame.__init__(self, borderwidth =2)
 
      ##### Menu <Fichier> #####
      fileMenu = Menubutton(self, text ='Fichier')
      fileMenu.pack(side =LEFT)
      # Partie "déroulante" :
      me1 = Menu(fileMenu)
      me1.add_command(label ='Effacer', underline =0,
	      command = boss.effacer)
      me1.add_command(label ='Terminer', underline =0,
	      command = boss.quit)
      # Intégration du menu :
      fileMenu.configure(menu = me1)	
 
class Application(Frame):
  """Application principale"""
  def __init__(self, boss =None):
      Frame.__init__(self)
      self.master.title('Fenêtre avec menus')
      mBar = MenuBar(self)
      mBar.pack()
      self.can = Canvas(self, bg='light grey', height=190,
	     width=250, borderwidth =2)
      self.can.pack()
      self.pack()
 
  def effacer(self):
      self.can.delete(ALL)
 
if __name__ == '__main__':
  app = Application()
  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. À 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 plus loin à 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.

16-G-2-A. Analyse du script▲

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. À 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.

16-G-3-A. Analyse du script▲

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')

16-G-4-A. Analyse du script▲

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])

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 encoche. 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. Comme nous l'avons déjà expliqué plus haut, 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 un objet-interface, que nous appellerons variable tkinter pour simplifier(84).

C'est ainsi que dans notre exemple, nous utilisons la classe tkinterIntVar() pour créer des objets équivalents à des variables de type entier.

• Nous instancions donc un de ces objets-variables, que nous mémorisons comme attribut d'instance : 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.
• Il faut ensuite associer l'option variable de l'objet checkbutton à la variable tkinter ainsi définie :
  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 les méthodes spécifiques de cette classe d'objets : la méthode get() pour lire, et la méthode set() pour écrire :
  m = self.actMusi.get().
  Dans cette instruction, nous affectons à m (variable ordinaire de Python) le contenu de la variable tkinter self.actMusi (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.

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. À 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 tkinterself.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é). À 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 un exemple dans le paragraphe suivant. Tâchez cependant de garder à l'esprit cette règle essentielle : un bon programme doit avant tout rester très lisible et bien commenté.

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

À 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 : ».

À 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 :

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 efficace 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 ci-dessus, 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é peut se payer d'une certaine perte de lisibilité.

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.

Exercice

.Perfectionnez le widget « combo box simplifié » décrit à la page , de manière à ce que la liste soit cachée au départ, et qu'un petit bouton à droite du champ d'entrée en provoque l'apparition. Vous devrez pour ce faire placer la liste et son ascenseur dans une fenêtre satellite sans bordure (Cf. widget Toplevel, page ), positionner celle-ci correctement (il vous faudra probablement consulter les sites web traitant de Tkinter pour trouver les informations nécessaires, mais cela fait partie de votre apprentissage !), et vous assurer que cette fenêtre disparaisse après que l'utilisateur ait sélectionné un item dans la liste.