Cómo crear una ventana de pantalla completa en Tkinter

Para mostrar una ventana de Tkinter en pantalla completa, establece el atributo -fullscreen en True. El ejemplo para Windows también asigna F11 para alternar el modo y Escape para salir. En Ubuntu, usa -zoomed para maximizar la ventana. Si quieres que la ventana ocupe toda la pantalla y conserve la barra de título y los bordes, establece su geometría con las dimensiones del monitor.

Ejecuta este ejemplo:

El código y las etiquetas o salidas visibles de esta sección se mantienen en inglés.

is_fullscreen = True
is_fullscreen = not is_fullscreen
print(is_fullscreen)

False

Esta pequeña transición de estado ilustra el cambio que usa el ejemplo para Windows: cada vez que se pulsa F11, cambia el estado actual. Los ejemplos de interfaz gráfica están pensados para sesiones de escritorio interactivas. Capturan tk.TclError si no se puede abrir una pantalla, de modo que un entorno sin interfaz gráfica pueda finalizar sin fingir que se mostró una ventana. Ejecútalos en la plataforma indicada para observar el comportamiento de la ventana.

Mostrar una ventana de Tkinter en pantalla completa en Windows

tk.Tk.attributes acepta atributos de ventana específicos de cada plataforma. En Windows, establece -fullscreen en True al crear la ventana raíz para iniciarla sin las decoraciones habituales. Mantén el estado almacenado en consonancia con ese valor inicial; de lo contrario, la primera pulsación de F11 podría asignar al atributo el valor que ya tiene. Escape establece en False tanto el estado almacenado como el atributo de la ventana.

El código y las etiquetas o salidas visibles de esta sección se mantienen en inglés.

import os
import tkinter as tk


class FullscreenExample:
    def __init__(self):
        self.window = tk.Tk()
        self.window.attributes("-fullscreen", True)
        self.fullscreen = True
        self.window.bind("<F11>", self.toggle_fullscreen)
        self.window.bind("<Escape>", self.leave_fullscreen)
        self.window.mainloop()

    def toggle_fullscreen(self, event=None):
        self.fullscreen = not self.fullscreen
        self.window.attributes("-fullscreen", self.fullscreen)

    def leave_fullscreen(self, event=None):
        self.fullscreen = False
        self.window.attributes("-fullscreen", False)


if __name__ == "__main__":
    try:
        FullscreenExample()
    except tk.TclError as error:
        display_error = str(error)

El parámetro event permite que Tkinter pase el evento de tecla a cada controlador. Si prefieres no guardar una variable de estado aparte, una lambda puede leer el valor actual del atributo e invertirlo:

import os
import tkinter as tk

try:
    window = tk.Tk()
    window.attributes("-fullscreen", True)
    window.bind(
        "<F11>",
        lambda event: window.attributes(
            "-fullscreen", not window.attributes("-fullscreen")
        ),
    )
    window.bind("<Escape>", lambda event: window.attributes("-fullscreen", False))
    window.mainloop()
except tk.TclError as error:
    display_error = str(error)

La forma de attributes("-fullscreen") sin argumentos lee el valor actual. Así evitas tener que mantener sincronizadas dos copias del estado. En una aplicación más grande, asigna a Escape tu controlador habitual de cierre si salir del modo de pantalla completa también debe cerrar la ventana.

Usar el atributo de ventana maximizada en Ubuntu

El administrador de ventanas de Tk en Ubuntu admite el atributo -zoomed para maximizar una ventana. Su comportamiento no es igual al de -fullscreen, que oculta los bordes; elige esta opción cuando quieras el tratamiento habitual de una ventana maximizada en el escritorio. Usa este ejemplo en Ubuntu y confirma el comportamiento por separado antes de aplicarlo a otra distribución de Linux o a macOS.

El código y las etiquetas o salidas visibles de esta sección se mantienen en inglés.

import os
import tkinter as tk


class UbuntuZoomedExample:
    def __init__(self):
        self.window = tk.Tk()
        self.window.attributes("-zoomed", True)
        self.zoomed = True
        self.window.bind("<F11>", self.toggle_zoomed)
        self.window.bind("<Escape>", self.leave_zoomed)
        self.window.mainloop()

    def toggle_zoomed(self, event=None):
        self.zoomed = not self.zoomed
        self.window.attributes("-zoomed", self.zoomed)

    def leave_zoomed(self, event=None):
        self.zoomed = False
        self.window.attributes("-zoomed", False)


if __name__ == "__main__":
    try:
        UbuntuZoomedExample()
    except tk.TclError as error:
        display_error = str(error)

Al igual que en el ejemplo para Windows, inicializa el estado almacenado en True porque la ventana comienza maximizada. La primera vez que pulses F11, se restaurará la ventana; la siguiente, volverá a maximizarse. Escape restaura el estado normal de la ventana. Si el administrador de ventanas de tu entorno no admite este atributo, usa el método siguiente para crear una ventana con el tamaño de la pantalla y decoraciones, o comprueba su comportamiento en el escritorio de Ubuntu de destino.

Ocupar toda la pantalla y conservar las decoraciones de la ventana

Para conservar la barra de título y los bordes, establece el ancho y el alto solicitados para la ventana a partir de winfo_screenwidth() y winfo_screenheight(). El método geometry usa un tamaño como 1440x900; al añadir +0+0, coloca la ventana en la esquina superior izquierda de la pantalla. Las decoraciones del administrador de ventanas ocupan espacio adicional, por lo que el contorno exterior podría extenderse un poco más allá de la pantalla aunque el área de contenido solicitada coincida con las dimensiones del monitor. Este método no usa -fullscreen ni ofrece un control para alternar el modo de pantalla completa.

El código y las etiquetas o salidas visibles de esta sección se mantienen en inglés.

import os
import tkinter as tk

try:
    window = tk.Tk()
    width = window.winfo_screenwidth()
    height = window.winfo_screenheight()
    window.geometry(f"{width}x{height}+0+0")
    window.mainloop()
except tk.TclError as error:
    display_error = str(error)

Los métodos de dimensiones de pantalla devuelven medidas en píxeles para la pantalla que detecta Tkinter. Si la ventana debe ajustarse al área de trabajo, que excluye paneles o bases, usa las dimensiones de esa área en vez del tamaño total de la pantalla. Para una introducción a Tkinter, consulta Tkinter; para el método geometry, consulta Administradores de geometría de Tkinter.