Tkinter Toplevel-Fenster

1 Video-Tutorial und was Sie bauen werden

Diese Anleitung zeigt, wie man Toplevel-Fenster mit Tkinter erstellt und verwaltet. Sie erstellen ein Hauptfenster, das vier Kindfenster startet – ein einfaches, ein modales, ein positioniertes und ein transientes – damit Sie sehen können, wie Steuerung, Fokus und Schichten tatsächlich funktionieren.

Ziel: Fenster nach Bedarf starten, entscheiden, wann sie modal sind, ihre Positionen steuern und sie beim Schließen sicher bereinigen.

2 Vollständiger Code: Hauptfenster und Toplevel-Beispiele

Führen Sie diese Datei aus, um die verschiedenen Fensterstile in Aktion zu sehen. Sie verwendet Standard-Widgets, eine Stiländerung für einen modernen Look und einfache Logik zur Nachverfolgung von Kindfenstern, um Ihre Benutzeroberfläche ordentlich zu halten.


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

class MainApplication:
    def __init__(self, root):
        self.root = root
        self.root.title("Hauptfenster")
        self.root.geometry("400x300")

        # Stil für ein einfaches, modernes Aussehen
        style = ttk.Style()
        style.configure('Modern.TButton',
                       padding=10,
                       font=('Helvetica', 10))

        self.header = ttk.Label(
            root,
            text="Toplevel-Fenster Demo",
            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="Einfaches Fenster öffnen",
            style='Modern.TButton',
            command=self.create_basic_window
        ).pack(pady=5, fill=tk.X)

        ttk.Button(
            buttons_frame,
            text="Modales Fenster öffnen",
            style='Modern.TButton',
            command=self.create_modal_window
        ).pack(pady=5, fill=tk.X)

        ttk.Button(
            buttons_frame,
            text="Positioniertes Fenster öffnen",
            style='Modern.TButton',
            command=self.create_positioned_window
        ).pack(pady=5, fill=tk.X)

        ttk.Button(
            buttons_frame,
            text="Transientes Fenster öffnen",
            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("Einfaches Fenster")
        window.geometry("300x200")

        ttk.Label(
            window,
            text="Dies ist ein einfaches Toplevel-Fenster",
            padding=20
        ).pack()

        ttk.Button(
            window,
            text="Schließen",
            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("Modales Fenster")
        window.geometry("300x200")

        # Modal machen
        window.grab_set()
        window.transient(self.root)

        ttk.Label(
            window,
            text="Dieses Fenster muss geschlossen werden,\nbevor das Hauptfenster verwendet werden kann",
            padding=20
        ).pack()

        ttk.Button(
            window,
            text="Schließen",
            command=window.destroy
        ).pack(pady=10)

    def create_positioned_window(self):
        window = tk.Toplevel(self.root)
        window.title("Positioniertes Fenster")
        window.geometry("300x200")

        # Zufällige Position auf dem Bildschirm
        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="Dieses Fenster erscheint an einer zufälligen Position",
            padding=20
        ).pack()

        ttk.Button(
            window,
            text="Schließen",
            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("Transientes Fenster")
        window.geometry("300x200")

        # Über dem Hauptfenster halten
        window.transient(self.root)

        ttk.Label(
            window,
            text="Dieses Fenster bleibt immer\nüber dem Hauptfenster",
            padding=20
        ).pack()

        ttk.Button(
            window,
            text="Schließen",
            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()

Speichern Sie dies als main.py und führen Sie es mit Python 3 aus, um die Demo auszuprobieren.

3 Erstellen eines Toplevel-Fensters

Toplevel-Fenster sind unabhängige Rahmen, die auf dem Desktop sitzen, aber zu Ihrer Anwendung gehören. Sie existieren neben dem Hauptfenster und teilen sich denselben Event-Loop. Erstellen Sie eines mit einem einfachen Konstruktor, legen Sie einen Titel und eine Größe fest.


window = tk.Toplevel(self.root)
window.title("Einfaches Fenster")
window.geometry("300x200")

Von dort aus können Sie Widgets wie im Hauptfenster packen oder gitten. Das Schließen mit window.destroy entfernt es vom Bildschirm und gibt seine Ressourcen frei.

4 Modale Fenster: Eingaben abfangen

Modale Fenster blockieren die Eingabe für den Rest Ihrer App, bis sie geschlossen werden. Zwei Zeilen erledigen das:


window.grab_set()        # Erfasst Eingabeereignisse in diesem Fenster
window.transient(self.root)  # Ordnet es visuell dem Hauptfenster zu

Wenn grab_set aktiv ist, kann der Benutzer nicht zurück in das Hauptfenster klicken. Transient weist den Fenstermanager an, es über dem Elternfenster zu halten und oft, es ohne eigenen Taskleisteneintrag anzuzeigen.

5 Fenster auf dem Bildschirm positionieren

Verwenden Sie die Geometrie, um eine Stelle auszuwählen. Der Suffix "+X+Y" platziert die obere linke Ecke an den Bildschirmkoordinaten. Ein einfacher Helfer kann auch jedes Fenster zentrieren.


# An zufälligen Koordinaten platzieren
x = random.randint(0, self.root.winfo_screenwidth() - 300)
y = random.randint(0, self.root.winfo_screenheight() - 200)
window.geometry(f"+{x}+{y}")

# Oder jedes Fenster zentrieren
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}')

Zufällige Platzierung ist nützlich für Demos. In der Produktion sollten Sie Fenster standardmäßig zentrieren oder die zuletzt verwendete Position wiederherstellen, damit Benutzer niemals nach verlorenen Dialogen suchen müssen.

6 Transiente Fenster: Oben bleiben

Transient koppelt ein Kindfenster mit dem Hauptfenster, sodass es darüber schwebt, aber keine Eingaben blockiert. Üblich für Werkzeugpaletten und Inspektoren.


window.transient(self.root)

Auf vielen Fenstermanagern verschwinden transiente Fenster auch, wenn das Elternfenster minimiert wird, und erscheinen wieder, wenn das Elternfenster wiederhergestellt wird.

7 Kindfenster verwalten und bereinigen

Führen Sie eine Liste der Kindfenster, wenn Sie sie gesammelt schließen möchten. Haken Sie WM_DELETE_WINDOW ein, damit das Klicken auf das X Ihre Bereinigung aufruft, anstatt eines Standardhandlers, der nur das Fenster zerstört.


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

Dieses Muster funktioniert auch für Zeitüberschreitungen und Validierungsroutinen – Sie können Fenster zuverlässig verfolgen, abbrechen und bereinigen.

Tutorial-Fortschritt