Interfaces graphiques en Python et Tkinter

Il y a de nombreuses bibliothèques pour créer des interfaces graphiques: Gtk+, Qt, wxWidgets, qui sont utilisables en Python. Cela fonctionne toujours un peu pareil, même si chacune a ses spécificités. Ici, on utilisera la bibliothèque tkinter, qui est la présentation en Python de la bibliothèque Tcl/Tk. La raison principale est qu'elle fait partie des bibliothèques standard de Python et qu'à ce titre elle est installée d'office et interagit bien avec les environnements de développement comme Idle.

/!\ La documentation standard de tkinter est assez succinte: elle se limite à une introduction et ne donne pas une liste exhaustive de toutes les classes et de toutes les options. Il faut se reporter aux documentations portant sur Tk pour en savoir plus.

Démarrage

L'incontournable premier programme avec tkinter ressemble à ceci:

   1 from tkinter import *
   2 fenetre = Frame()
   3 fenetre.pack()
   4 texte = Label(fenetre, text="Salut!")
   5 texte.pack()
   6 fenetre.mainloop()

Tapez ce programme et lancez-le, vous verrez apparaître une fenêtre qui dit juste "Salut". Le programme se terminera quand vous fermerez la fenêtre.

Quelques explications:

Actions et réactions

Ajoutons un bouton à la fenêtre: avant l'appel à mainloop, on ajoute

   1 bouton = Button(fenetre, text="Hop")
   2 bouton.pack()

Et on a un bouton en dessous du message, mais ce bouton ne fait rien.

Pour ajouter une action, on utilise le paramètre command qui attend comme valeur une fonction. On remplace alors les deux lignes précédentes par:

   1 def action():
   2     print("Clic.")
   3 
   4 bouton = Button(fenetre, text="Hop", command=action)
   5 bouton.pack()

Cette fonction est l'action à exécuter lorsque le bouton est cliqué. Ici elle se contente d'afficher un message dans le terminal où a été lancé le programme, ce qui n'est pas très utile pour une interface graphique. On peut modifier la définition de la fonction action pour qu'elle change le texte affiché dans le Label:

   1 def action():
   2     texte['text'] = "Message reçu!"

L'affectation qui a lieu dans cette fonction modifie les propriétés de l'object texte, en changeant le texte affiché. On parle de configuration d'un objet, dans le jargon de Tk.

Exercice

Adapter ce programme pour que le texte affiché indique combien de fois le bouton a été cliqué depuis le début.

Utilisation de classes

L'exemple du bouton qui modifie le message, et plus encore l'exercice qui compte le nombre de clics, montrent qu'il est nécessaire de maintenir un état et utilise pour cela des variables globales. Cela fonctionne, mais ce n'est pas très modulaire et cela peut être source d'erreurs. Pour améliorer la situation, la bonne méthode est d'utiliser la programmation par objets en définissant une classe pour notre boîte de dialogue. On peut procéder comme ceci:

   1 from tkinter import *
   2 
   3 class Dialogue (Frame):
   4     def __init__(self):
   5         Frame.__init__(self)
   6 
   7         self.texte = Label(self, text="Salut!")
   8         self.texte.pack()
   9 
  10         bouton = Button(self, text="Hop", command=self.action)
  11         bouton.pack()
  12 
  13     def action(self):
  14         self.texte['text'] = "Message reçu!"
  15 
  16 dialogue = Dialogue()
  17 dialogue.pack()
  18 dialogue.mainloop()

La classe de notre boîte de dialogue dérive de la classe Frame de tkinter: une boîte de dialogue est uen fenêtre principale (Frame) avec des propriétés supplémentaires. La méthode __init__ sert à effectuer les opérations nécessaires à la construction du dialogue:

La fonction qui correspond à l'action à effectuer est maintenant self.action: c'est la méthode action de l'objet qui correspond au dialogue. C'est ici que l'on a gagné quelque chose: self.action connaît l'objet (c'est son premier argument, self) et elle peut donc accéder au champ texte, sans avoir besoin d'une variable globale.

Les trois dernières lignes de cette version illustrent que notre classe Dialogue peut être utilisée à peu près comme une classe standard de tkinter: on crée un objet, on le place avec pack() et on lui passe la main avec mainloop. Ces méthodes existent parce que Dialogue dérive de Frame.

Exercice

Refaire l'exemple du compteur en style objet.

Exercice

Étendre ce programme pour réaliser une calculatrice avec les quatre opérations!

Pour démarrer, le code suivant dispose les 10 chiffres et donne un bouton + et un bouton = et fait des additions:

   1 from tkinter import *
   2 
   3 class Chiffre (Button):
   4     def __init__(self, master, val):
   5         Button.__init__(self, master, text=val, command=self.clic)
   6         self.val = val
   7         self.dialogue = master
   8 
   9     def clic(self):
  10         self.dialogue.chiffre(self.val)
  11 
  12 class Dialogue (Frame):
  13     def __init__(self):
  14         Frame.__init__(self)
  15 
  16         self.nombre = 0
  17         self.memoire = 0
  18 
  19         self.texte = Label(self, text="0")
  20         self.texte.grid(row=0, column=0)
  21 
  22         bouton = Chiffre(self, 0)
  23         bouton.grid(row=4, column=1)
  24         for i in range(1, 10):
  25             bouton = Chiffre(self, i)
  26             bouton.grid(row=3-(i-1)//3, column=(i-1)%3)
  27 
  28         add = Button(self, text="+", command=self.plus)
  29         add.grid(row=1, column=4)
  30 
  31         egal = Button(self, text="=", command=self.egal)
  32         egal.grid(row=2, column=4)
  33 
  34     def chiffre(self, val):
  35         self.nombre = self.nombre * 10 + val
  36         self.texte['text'] = self.nombre
  37 
  38     def plus(self):
  39         self.memoire += self.nombre
  40         self.nombre = 0
  41         self.texte['text'] = self.memoire
  42 
  43     def egal(self):
  44         self.plus()
  45 
  46 dialogue = Dialogue()
  47 dialogue.pack()
  48 dialogue.mainloop()

Ce n'est pas encore une calculatrice totalement satisfaisante! À vous de l'améliorer...

EnsInfo: Interfaces graphiques (last edited 2017-11-30 23:10:27 by LionelVaux)