Ventanas Toplevel en Tkinter

1 Tutorial en Video y Qué Construirás

Esta guía muestra cómo crear y gestionar ventanas Toplevel con Tkinter. Crearás una ventana principal que lanzará cuatro ventanas secundarias (básica, modal, posicionada y transitoria) para que puedas ver cómo funcionan realmente el control, el foco y la superposición.

Objetivo: Lanzar ventanas bajo demanda, decidir cuándo son modales, controlar sus posiciones y limpiar de forma segura al cerrarlas.

2 Código Completo: Ejemplos de Ventana Principal y Toplevel

Ejecuta este archivo para ver los diferentes estilos de ventana en acción. Utiliza widgets estándar, un ajuste de estilo para un aspecto moderno y lógica simple para rastrear ventanas secundarias y mantener tu interfaz de usuario ordenada.


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

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

        # Estilo para un aspecto simple y moderno
        style = ttk.Style()
        style.configure('Modern.TButton',
                       padding=10,
                       font=('Helvetica', 10))

        self.header = ttk.Label(
            root,
            text="Demostración de Ventanas 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="Abrir Ventana Básica",
            style='Modern.TButton',
            command=self.create_basic_window
        ).pack(pady=5, fill=tk.X)

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

        ttk.Button(
            buttons_frame,
            text="Abrir Ventana Posicionada",
            style='Modern.TButton',
            command=self.create_positioned_window
        ).pack(pady=5, fill=tk.X)

        ttk.Button(
            buttons_frame,
            text="Abrir Ventana Transitoria",
            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("Ventana Básica")
        window.geometry("300x200")

        ttk.Label(
            window,
            text="Esta es una ventana Toplevel básica",
            padding=20
        ).pack()

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

        # Hacerla modal
        window.grab_set()
        window.transient(self.root)

        ttk.Label(
            window,
            text="Esta ventana debe cerrarse\nantes de usar la ventana principal",
            padding=20
        ).pack()

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

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

        # Posición aleatoria en la pantalla
        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="Esta ventana aparece en una posición aleatoria",
            padding=20
        ).pack()

        ttk.Button(
            window,
            text="Cerrar",
            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("Ventana Transitoria")
        window.geometry("300x200")

        # Hacer que permanezca encima de la ventana principal
        window.transient(self.root)

        ttk.Label(
            window,
            text="Esta ventana siempre permanece\nencima de la ventana principal",
            padding=20
        ).pack()

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

Guarda esto como main.py y ejecútalo con Python 3 para probar la demostración.

3 Creando una Ventana Toplevel

Las ventanas Toplevel son marcos independientes que se colocan en el escritorio pero pertenecen a tu aplicación. Existen junto a la ventana principal y comparten el mismo bucle de eventos. Crea una con un constructor simple, establece un título y un tamaño.


window = tk.Toplevel(self.root)
window.title("Ventana Básica")
window.geometry("300x200")

A partir de ahí, puedes empaquetar o colocar widgets como en la ventana principal. Cerrarla con window.destroy la elimina de la pantalla y libera sus recursos.

4 Ventanas Modales: Capturando Entrada

Las ventanas modales bloquean la entrada al resto de tu aplicación hasta que se cierran. Dos líneas lo hacen posible:


window.grab_set()        # Captura eventos de entrada en esta ventana
window.transient(self.root)  # La asocia visualmente con la ventana principal

Cuando grab_set está activo, el usuario no puede hacer clic en la ventana principal. Transient le dice al gestor de ventanas que la mantenga encima del padre y, a menudo, que la muestre sin su propia entrada en la barra de tareas.

5 Posicionando Ventanas en la Pantalla

Usa geometry para elegir una ubicación. El sufijo "+X+Y" coloca la esquina superior izquierda en las coordenadas de la pantalla. Una ayuda simple también puede centrar cualquier ventana.


# Colocar en coordenadas aleatorias
x = random.randint(0, self.root.winfo_screenwidth() - 300)
y = random.randint(0, self.root.winfo_screenheight() - 200)
window.geometry(f"+{x}+{y}")

# O centrar cualquier ventana
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}')

La colocación aleatoria es útil para demostraciones. En producción, usa el centrado de ventanas por defecto o restaura la última posición utilizada para que los usuarios nunca tengan que buscar diálogos perdidos.

6 Ventanas Transitorias: Permanecer Encima

Transitory vincula una ventana secundaria con la ventana principal para que flote sobre ella pero no bloquee la entrada. Común para paletas de herramientas e inspectores.


window.transient(self.root)

En muchos gestores de ventanas, las ventanas transitorias también desaparecen cuando el padre se minimiza y reaparecen cuando el padre se restaura.

7 Gestión y Limpieza de Ventanas Secundarias

Mantén una lista de ventanas secundarias si planeas cerrarlas en bloque. Engancha WM_DELETE_WINDOW para que al hacer clic en la X llame a tu limpieza en lugar de a un manejador por defecto que solo destruye la ventana.


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

Ese patrón también funciona para tiempos de espera y rutinas de validación: puedes rastrear, cancelar y depurar ventanas de manera confiable.