Fenêtres Toplevel en Tkinter

1 Tutoriel Vidéo et ce que vous allez construire

Ce guide montre comment créer et gérer des fenêtres Toplevel avec Tkinter. Vous créerez une fenêtre principale qui lancera quatre fenêtres enfants : basique, modale, positionnée et transitoire, afin de voir comment le contrôle, le focus et la superposition fonctionnent réellement.

Objectif : Lancer des fenêtres à la demande, décider quand elles sont modales, contrôler leurs positions et nettoyer en toute sécurité lorsqu'elles se ferment.

2 Code Complet : Exemples de Fenêtre Principale et Toplevel

Exécutez ce fichier pour voir les différents styles de fenêtres en action. Il utilise des widgets standard, une touche de style pour un look moderne et une logique simple pour suivre les fenêtres enfants et maintenir votre interface utilisateur propre.


# main.py
import tkinter as tk
from tkinter import ttk
import random

class MainApplication:
    def __init__(self, root):
        self.root = root
        self.root.title("Fenêtre Principale")
        self.root.geometry("400x300")

        # Style pour un look simple et moderne
        style = ttk.Style()
        style.configure('Modern.TButton',
                       padding=10,
                       font=('Helvetica', 10))

        self.header = ttk.Label(
            root,
            text="Démo des fenêtres Toplevel",
            font=('Helvetica', 16, 'bold'),
            padding=20
        )
        self.header.pack()

        self.create_buttons()
        self.child_windows = []
        self.center_window(self.root)

    def create_buttons(self):
        buttons_frame = ttk.Frame(self.root, padding="20")
        buttons_frame.pack(fill=tk.BOTH, expand=True)

        ttk.Button(
            buttons_frame,
            text="Ouvrir Fenêtre Basique",
            style='Modern.TButton',
            command=self.create_basic_window
        ).pack(pady=5, fill=tk.X)

        ttk.Button(
            buttons_frame,
            text="Ouvrir Fenêtre Modale",
            style='Modern.TButton',
            command=self.create_modal_window
        ).pack(pady=5, fill=tk.X)

        ttk.Button(
            buttons_frame,
            text="Ouvrir Fenêtre Positionnée",
            style='Modern.TButton',
            command=self.create_positioned_window
        ).pack(pady=5, fill=tk.X)

        ttk.Button(
            buttons_frame,
            text="Ouvrir Fenêtre Transitoire",
            style='Modern.TButton',
            command=self.create_transient_window
        ).pack(pady=5, fill=tk.X)

    def create_basic_window(self):
        window = tk.Toplevel(self.root)
        window.title("Fenêtre Basique")
        window.geometry("300x200")

        ttk.Label(
            window,
            text="Ceci est une fenêtre Toplevel basique",
            padding=20
        ).pack()

        ttk.Button(
            window,
            text="Fermer",
            command=window.destroy
        ).pack(pady=10)

        self.child_windows.append(window)
        window.protocol("WM_DELETE_WINDOW",
                       lambda: self.cleanup_window(window))

    def create_modal_window(self):
        window = tk.Toplevel(self.root)
        window.title("Fenêtre Modale")
        window.geometry("300x200")

        # La rendre modale
        window.grab_set()
        window.transient(self.root)

        ttk.Label(
            window,
            text="Cette fenêtre doit être fermée\navant d'utiliser la fenêtre principale",
            padding=20
        ).pack()

        ttk.Button(
            window,
            text="Fermer",
            command=window.destroy
        ).pack(pady=10)

    def create_positioned_window(self):
        window = tk.Toplevel(self.root)
        window.title("Fenêtre Positionnée")
        window.geometry("300x200")

        # Position aléatoire sur l'écran
        x = random.randint(0, self.root.winfo_screenwidth() - 300)
        y = random.randint(0, self.root.winfo_screenheight() - 200)
        window.geometry(f"+{x}+{y}")

        ttk.Label(
            window,
            text="Cette fenêtre apparaît à une position aléatoire",
            padding=20
        ).pack()

        ttk.Button(
            window,
            text="Fermer",
            command=window.destroy
        ).pack(pady=10)

        self.child_windows.append(window)
        window.protocol("WM_DELETE_WINDOW",
                       lambda: self.cleanup_window(window))

    def create_transient_window(self):
        window = tk.Toplevel(self.root)
        window.title("Fenêtre Transitoire")
        window.geometry("300x200")

        # La faire rester au-dessus de la fenêtre principale
        window.transient(self.root)

        ttk.Label(
            window,
            text="Cette fenêtre reste toujours\nau-dessus de la fenêtre principale",
            padding=20
        ).pack()

        ttk.Button(
            window,
            text="Fermer",
            command=window.destroy
        ).pack(pady=10)

        self.child_windows.append(window)
        window.protocol("WM_DELETE_WINDOW",
                       lambda: self.cleanup_window(window))

    def cleanup_window(self, window):
        if window in self.child_windows:
            self.child_windows.remove(window)
        window.destroy()

    def center_window(self, window):
        window.update_idletasks()
        width = window.winfo_width()
        height = window.winfo_height()
        x = (window.winfo_screenwidth() // 2) - (width // 2)
        y = (window.winfo_screenheight() // 2) - (height // 2)
        window.geometry(f'+{x}+{y}')

if __name__ == "__main__":
    root = tk.Tk()
    app = MainApplication(root)
    root.mainloop()

Enregistrez ceci sous le nom main.py et exécutez-le avec Python 3 pour essayer la démo.

3 Création d'une fenêtre Toplevel

Les fenêtres Toplevel sont des cadres indépendants qui se trouvent sur le bureau mais appartiennent à votre application. Elles existent aux côtés de la fenêtre principale et partagent la même boucle d'événements. Créez-en une avec un constructeur simple, définissez un titre et une taille.


window = tk.Toplevel(self.root)
window.title("Fenêtre Basique")
window.geometry("300x200")

À partir de là, vous pouvez utiliser pack ou grid pour placer des widgets, tout comme dans la fenêtre principale. La fermer avec window.destroy la supprime de l'écran et libère ses ressources.

4 Fenêtres Modales : Capturer les Entrées

Les fenêtres modales bloquent l'entrée vers le reste de votre application jusqu'à ce qu'elles soient fermées. Deux lignes suffisent :


window.grab_set()        # Capture les événements d'entrée dans cette fenêtre
window.transient(self.root)  # L'associe visuellement à la fenêtre principale

Lorsque grab_set est actif, l'utilisateur ne peut pas revenir à la fenêtre principale. Transient indique au gestionnaire de fenêtres de la garder au-dessus de la fenêtre parente et souvent de l'afficher sans sa propre entrée dans la barre des tâches.

5 Positionnement des Fenêtres à l'Écran

Utilisez la géométrie pour choisir un emplacement. Le suffixe "+X+Y" place le coin supérieur gauche aux coordonnées de l'écran. Une simple fonction utilitaire peut également centrer n'importe quelle fenêtre.


# Placer à des coordonnées aléatoires
x = random.randint(0, self.root.winfo_screenwidth() - 300)
y = random.randint(0, self.root.winfo_screenheight() - 200)
window.geometry(f"+{x}+{y}")

# Ou centrer n'importe quelle fenêtre
def center_window(self, window):
    window.update_idletasks()
    width = window.winfo_width()
    height = window.winfo_height()
    x = (window.winfo_screenwidth() // 2) - (width // 2)
    y = (window.winfo_screenheight() // 2) - (height // 2)
    window.geometry(f'+{x}+{y}')

Le placement aléatoire est utile pour les démos. En production, privilégiez le centrage des fenêtres ou la restauration de la dernière position utilisée afin que les utilisateurs ne perdent jamais de boîtes de dialogue.

6 Fenêtres Transitoires : Rester au-dessus

Transient associe une fenêtre enfant à la fenêtre principale afin qu'elle flotte au-dessus, mais sans bloquer les entrées. Couramment utilisé pour les palettes d'outils et les inspecteurs.


window.transient(self.root)

Sur de nombreux gestionnaires de fenêtres, les fenêtres transitoires disparaissent également lorsque la fenêtre parente est iconifiée et réapparaissent lorsque la fenêtre parente est restaurée.

7 Gestion et Nettoyage des Fenêtres Enfants

Conservez une liste des fenêtres enfants si vous prévoyez de les fermer en bloc. Interceptez WM_DELETE_WINDOW afin que le clic sur le X appelle votre nettoyage au lieu d'un gestionnaire par défaut qui ne fait que détruire la fenêtre.


self.child_windows = []

def create_basic_window(self):
    window = tk.Toplevel(self.root)
    # ...
    self.child_windows.append(window)
    window.protocol("WM_DELETE_WINDOW", lambda: self.cleanup_window(window))

def cleanup_window(self, window):
    if window in self.child_windows:
        self.child_windows.remove(window)
    window.destroy()

Ce modèle fonctionne également pour les temporisations et les routines de validation : vous pouvez suivre, annuler et supprimer les fenêtres de manière fiable.