Tkinter Toplevel Windows

1 Video Tutorial and What You Will Build

This guide shows how to create and manage Toplevel windows with Tkinter. You will make a main window that launches four child windows—basic, modal, positioned, and transient—so you can see how control, focus, and layering actually work.

Goal: Launch windows on demand, decide when they are modal, control their positions, and safely clean up when they close.

2 Full Code: Main Window and Toplevel Examples

Run this file to see the different window styles in action. It uses standard widgets, a style tweak for a modern look, and simple logic to track child windows and keep your UI tidy.


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

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

        # Style for a simple, modern look
        style = ttk.Style()
        style.configure('Modern.TButton',
                       padding=10,
                       font=('Helvetica', 10))

        self.header = ttk.Label(
            root,
            text="Toplevel Windows 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="Open Basic Window",
            style='Modern.TButton',
            command=self.create_basic_window
        ).pack(pady=5, fill=tk.X)

        ttk.Button(
            buttons_frame,
            text="Open Modal Window",
            style='Modern.TButton',
            command=self.create_modal_window
        ).pack(pady=5, fill=tk.X)

        ttk.Button(
            buttons_frame,
            text="Open Positioned Window",
            style='Modern.TButton',
            command=self.create_positioned_window
        ).pack(pady=5, fill=tk.X)

        ttk.Button(
            buttons_frame,
            text="Open Transient Window",
            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("Basic Window")
        window.geometry("300x200")

        ttk.Label(
            window,
            text="This is a basic Toplevel window",
            padding=20
        ).pack()

        ttk.Button(
            window,
            text="Close",
            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("Modal Window")
        window.geometry("300x200")

        # Make it modal
        window.grab_set()
        window.transient(self.root)

        ttk.Label(
            window,
            text="This window must be closed\nbefore using the main window",
            padding=20
        ).pack()

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

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

        # Random position on screen
        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="This window appears at a random position",
            padding=20
        ).pack()

        ttk.Button(
            window,
            text="Close",
            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("Transient Window")
        window.geometry("300x200")

        # Make it stay on top of the main window
        window.transient(self.root)

        ttk.Label(
            window,
            text="This window always stays\non top of the main window",
            padding=20
        ).pack()

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

Save this as main.py and run it with Python 3 to try the demo.

3 Creating a Toplevel Window

Toplevel windows are independent frames that sit on the desktop but belong to your application. They exist alongside the main window and share the same event loop. Create one with a simple constructor, set a title, and size.


window = tk.Toplevel(self.root)
window.title("Basic Window")
window.geometry("300x200")

From there, you can pack or grid widgets just like in the main window. Closing it with window.destroy removes it from the screen and frees its resources.

4 Modal Windows: Grabbing Input

Modal windows block input to the rest of your app until they are closed. Two lines make it happen:


window.grab_set()        # Capture input events in this window
window.transient(self.root)  # Associate it visually with the main window

When grab_set is active, the user cannot click back into the main window. Transient tells the window manager to keep it on top of the parent and often to show it without its own taskbar entry.

5 Positioning Windows on Screen

Use geometry to pick a spot. The "+X+Y" suffix places the top-left corner at screen coordinates. A simple helper can also center any window.


# Place at random coordinates
x = random.randint(0, self.root.winfo_screenwidth() - 300)
y = random.randint(0, self.root.winfo_screenheight() - 200)
window.geometry(f"+{x}+{y}")

# Or center any window
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}')

Random placement is useful for demos. In production, default to centering windows or restoring the last-used position so users never hunt for lost dialogs.

6 Transient Windows: Staying on Top

Transient pairs a child window with the main window so it floats above it but does not block input. Common for tool palettes and inspectors.


window.transient(self.root)

On many window managers transient windows also vanish when the parent is iconified and reappear when the parent is restored.

7 Managing and Cleaning Up Child Windows

Keep a list of child windows if you plan to close them in bulk. Hook into WM_DELETE_WINDOW so clicking the X calls your cleanup instead of a default handler that only destroys the window.


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

That pattern also works for timeouts and validation routines—you can track, cancel, and purge windows reliably.

Tutorial Progress