Janelas Toplevel no Tkinter

1 Tutorial em Vídeo e o Que Você Construirá

Este guia mostra como criar e gerenciar janelas Toplevel com Tkinter. Você criará uma janela principal que abrirá quatro janelas filhas — básica, modal, posicionada e transitória — para que você possa ver como o controle, o foco e a sobreposição funcionam na prática.

Objetivo: Abrir janelas sob demanda, decidir quando elas são modais, controlar suas posições e limpar com segurança quando elas fecharem.

2 Código Completo: Exemplos de Janela Principal e Toplevel

Execute este arquivo para ver os diferentes estilos de janela em ação. Ele usa widgets padrão, um ajuste de estilo para um visual moderno e lógica simples para rastrear janelas filhas e manter sua UI organizada.


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

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

        # Estilo para um visual simples e moderno
        style = ttk.Style()
        style.configure('Modern.TButton',
                       padding=10,
                       font=('Helvetica', 10))

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

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

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

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

        ttk.Label(
            window,
            text="Esta é uma janela Toplevel básica",
            padding=20
        ).pack()

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

        # Torná-la modal
        window.grab_set()
        window.transient(self.root)

        ttk.Label(
            window,
            text="Esta janela deve ser fechada\nantes de usar a janela principal",
            padding=20
        ).pack()

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

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

        # Posição aleatória na tela
        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 janela aparece em uma posição aleatória",
            padding=20
        ).pack()

        ttk.Button(
            window,
            text="Fechar",
            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("Janela Transitória")
        window.geometry("300x200")

        # Mantê-la no topo da janela principal
        window.transient(self.root)

        ttk.Label(
            window,
            text="Esta janela sempre fica\nacima da janela principal",
            padding=20
        ).pack()

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

Salve isso como main.py e execute com Python 3 para experimentar a demonstração.

3 Criando uma Janela Toplevel

Janelas Toplevel são frames independentes que ficam na área de trabalho, mas pertencem à sua aplicação. Elas existem ao lado da janela principal e compartilham o mesmo loop de eventos. Crie uma com um construtor simples, defina um título e um tamanho.


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

A partir daí, você pode usar pack ou grid para colocar widgets, assim como na janela principal. Fechá-la com window.destroy a remove da tela e libera seus recursos.

4 Janelas Modais: Capturando Entrada

Janelas modais bloqueiam a entrada para o resto do seu aplicativo até que sejam fechadas. Duas linhas fazem isso acontecer:


window.grab_set()        # Captura eventos de entrada nesta janela
window.transient(self.root)  # Associa visualmente com a janela principal

Quando grab_set está ativo, o usuário não pode clicar de volta na janela principal. Transient diz ao gerenciador de janelas para mantê-la acima da janela pai e, muitas vezes, para mostrá-la sem uma entrada própria na barra de tarefas.

5 Posicionando Janelas na Tela

Use a geometria para escolher um local. O sufixo "+X+Y" coloca o canto superior esquerdo nas coordenadas da tela. Um helper simples também pode centralizar qualquer janela.


# Coloca em coordenadas aleatórias
x = random.randint(0, self.root.winfo_screenwidth() - 300)
y = random.randint(0, self.root.winfo_screenheight() - 200)
window.geometry(f"+{x}+{y}")

# Ou centraliza qualquer janela
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}')

O posicionamento aleatório é útil para demonstrações. Em produção, use a centralização de janelas por padrão ou restaure a última posição usada para que os usuários nunca procurem por diálogos perdidos.

6 Janelas Transitórias: Permanecendo no Topo

Transiente associa uma janela filha com a janela principal para que ela flutue acima dela, mas não bloqueie a entrada. Comum para paletas de ferramentas e inspetores.


window.transient(self.root)

Em muitos gerenciadores de janelas, janelas transitórias também desaparecem quando a janela pai é minimizada e reaparecem quando a janela pai é restaurada.

7 Gerenciando e Limpando Janelas Filhas

Mantenha uma lista de janelas filhas se você planeja fechá-las em massa. Conecte-se a WM_DELETE_WINDOW para que clicar no X chame sua limpeza em vez de um manipulador padrão que apenas destrói a janela.


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

Esse padrão também funciona para timeouts e rotinas de validação — você pode rastrear, cancelar e purgar janelas de forma confiável.