Teclado y ratón en detalle

campo.bind("<Key>", cualquier_tecla)        # todas
campo.bind("<Key-a>", solo_la_a)            # una concreta
campo.bind("<a>", solo_la_a)                # lo mismo, forma corta
campo.bind("<Control-Key-s>", guardar)      # con modificador
campo.bind("<Control-s>", guardar)          # lo mismo, forma corta

>>> para nombre in ("period", "comma", "minus", "plus", "slash", "question",
...                 "exclam", "parenleft", "bracketleft", "braceleft",
...                 "asterisk", "percent"):   →  todos válidos

>>> ventana.bind("<Key-Retorno>", manejador)
_tkinter.TclError: bad event type or keysym "Retorno"
>>> ventana.bind("<Ctrl-s>", manejador)
_tkinter.TclError: bad event type or keysym "Ctrl"
>>> ventana.bind("<control-s>", manejador)
_tkinter.TclError: bad event type or keysym "control"

>>> evento.state
5

if evento.state & 4:
        ...     # Control estaba pulsado

lienzo.bind("<Button-1>", empezar)          # botón izquierdo
lienzo.bind("<ButtonRelease-1>", soltar)
lienzo.bind("<B1-Motion>", arrastrar)       # mover CON el botón pulsado
lienzo.bind("<Motion>", mover)              # mover sin pulsar nada
lienzo.bind("<Enter>", entrar)
lienzo.bind("<Leave>", salir)
lienzo.bind("<MouseWheel>", rueda)          # lección 24, con sus diferencias

campo.focus_set()          # pídelo cuando puedas
campo.focus_force()        # quítaselo a quien lo tenga (casi nunca)
ventana.focus_get()        # quién lo tiene ahora, o None

>>> ttk.Entry(ventana).cget("takefocus")      →  'ttk::takefocus'
>>> ttk.Button(ventana).cget("takefocus")     →  'ttk::takefocus'
>>> ttk.Treeview(ventana).cget("takefocus")   →  'ttk::takefocus'
>>> ttk.Label(ventana).cget("takefocus")      →  ''
>>> ttk.Frame(ventana).cget("takefocus")      →  ''

>>> primero.tk_focusNext()
.!entry2
>>> segundo.tk_focusPrev()
.!entry

>>> ventana.event_info("<<NextWindow>>")
('<Key-Tab>',)
>>> ventana.event_info("<<PrevWindow>>")
('<Shift-Key-Tab>',)

def siguiente(evento):
        evento.widget.tk_focusNext().focus_set()
    return "break"      # que el Enter no llegue al nivel de clase

for campo in campos:
        campo.bind("<Return>", siguiente)

>>> marco.cget("cursor")
''
>>> marco.configure(cursor="inventado")
_tkinter.TclError: bad cursor spec "inventado" ...

"""Teclado y ratón: navegación con Enter, arrastre y modificadores."""

import tkinter as tk
from tkinter import ttk

MARGEN = 12
AIRE = 4

GRIS = "#8E8E93"
AZUL = "#1565C0"
ROSA = "#C2185B"

LADO = 40
PASO = 10

# Máscaras de bits de evento.state. Mod1 es Alt en Windows y Linux, y
# Command en macOS, como se vio en la lección 31.
MODIFICADORES = ((1, "Shift"), (2, "Bloq Mayús"), (4, "Control"),
                 (8, "Mod1 (Alt/Cmd)"), (256, "Botón 1"))


def centrar(ventana: tk.Misc) -> None:
        """Coloca la ventana en el centro de la pantalla."""
    ventana.update_idletasks()
    ancho = ventana.winfo_width()
    alto = ventana.winfo_height()
    x = (ventana.winfo_screenwidth() - ancho) // 2
    y = (ventana.winfo_screenheight() - alto) // 2
    ventana.geometry(f"+{x}+{y}")


def pulsados(state):
        """Los modificadores de un evento, que vienen como un solo entero."""
    return [nombre for bit, nombre in MODIFICADORES if state & bit]


def siguiente(evento):
        """Que Enter avance al campo siguiente, lo que más se pide de un formulario.

    El "break" es necesario: sin él el Enter sigue por la cadena de la
    lección 34 y llega al comportamiento de fábrica del widget.
    """
    evento.widget.tk_focusNext().focus_set()
    return "break"


def anterior(evento):
        evento.widget.tk_focusPrev().focus_set()
    return "break"


def crear_formulario(contenedor):
        """Tres campos donde Enter avanza y Shift+Enter retrocede."""
    marco = ttk.Labelframe(contenedor, text="Enter avanza de campo",
                           padding=MARGEN)
    marco.pack(fill="x")

    primero = None
    for etiqueta, variable in (("Nombre", nombre), ("Ciudad", ciudad),
                               ("Correo", correo)):
                fila = ttk.Frame(marco)
        fila.pack(fill="x", pady=AIRE)
        ttk.Label(fila, text=f"{etiqueta}:", width=10,
                  anchor="w").pack(side="left")
        campo = ttk.Entry(fila, textvariable=variable)
        campo.pack(side="left", fill="x", expand=True)
        campo.bind("<Return>", siguiente)
        campo.bind("<Shift-Return>", anterior)
        if primero is None:
                        primero = campo

    ttk.Label(marco, foreground=GRIS, text="Shift+Enter retrocede. El "
              "tabulador funciona solo: es el evento virtual "
              "<<NextWindow>>.").pack(anchor="w", pady=(AIRE, 0))
    return marco, primero


def crear_lienzo(contenedor):
        """El Canvas, que sí necesita takefocus para recibir el teclado.

    Un Canvas no está en el recorrido del tabulador de fábrica.
    """
    marco = ttk.Labelframe(contenedor, text="Teclado, ratón y modificadores",
                           padding=MARGEN)
    marco.pack(fill="both", expand=True, pady=(MARGEN, 0))

    lienzo = tk.Canvas(marco, height=200, background="white",
                       highlightthickness=1, takefocus=True,
                       cursor="crosshair")
    lienzo.pack(fill="both", expand=True)
    lienzo.create_rectangle(80, 80, 80 + LADO, 80 + LADO, fill=AZUL,
                            outline="", tags="caja")
    return lienzo


def mover(dx, dy):
        """Mueve la caja y actualiza el rótulo."""
    lienzo.move("caja", dx, dy)
    x1, y1, x2, y2 = lienzo.coords("caja")
    posicion.set(f"Caja en ({x1:.0f}, {y1:.0f})")


def tecla(evento):
        """keysym para decidir, no char: las flechas no producen carácter."""
    # El paso depende de Shift, que es un modificador de un gesto que ya
    # estamos atendiendo: aquí sí hace falta mirar evento.state.
    paso = PASO * (5 if evento.state & 1 else 1)
    direcciones = {"Left": (-paso, 0), "Right": (paso, 0),
                   "Up": (0, -paso), "Down": (0, paso)}
    if evento.keysym in direcciones:
                mover(*direcciones[evento.keysym])
        apuntar(f"keysym={evento.keysym} char={evento.char!r} "
                f"modificadores={pulsados(evento.state) or 'ninguno'}")
        return "break"
    if evento.keysym == "Home":
                lienzo.coords("caja", 80, 80, 80 + LADO, 80 + LADO)
        mover(0, 0)
        apuntar("keysym=Home: la caja vuelve al origen")
        return "break"
    # Cualquier otra tecla: aquí sí se usa char, que es para escribir.
    if evento.char and evento.char != "??" and evento.char.isprintable():
                apuntar(f"char={evento.char!r} keysym={evento.keysym!r}")
    else:
                apuntar(f"keysym={evento.keysym!r} sin carácter "
                f"(char vale {evento.char!r})")


def empezar(evento):
        """El arrastre, lección 26. focus_set para que el Canvas oiga el teclado."""
    lienzo.focus_set()
    arrastre["x"] = lienzo.canvasx(evento.x)
    arrastre["y"] = lienzo.canvasy(evento.y)
    arrastre["activo"] = bool(lienzo.find_withtag("current"))
    apuntar(f"Button-{evento.num} en ({evento.x}, {evento.y}) "
            f"— sobre la caja: {arrastre['activo']}")


def arrastrar(evento):
        """B1-Motion: mover con el botón pulsado. Shift restringe a un eje."""
    if not arrastre["activo"]:
                return
    x = lienzo.canvasx(evento.x)
    y = lienzo.canvasy(evento.y)
    dx, dy = x - arrastre["x"], y - arrastre["y"]
    if evento.state & 1:                 # Shift: solo el eje que más se mueve
                if abs(dx) > abs(dy):
                        dy = 0
        else:
                        dx = 0
    lienzo.move("caja", dx, dy)
    if not (evento.state & 1) or dx:
                arrastre["x"] = x
    if not (evento.state & 1) or dy:
                arrastre["y"] = y
    x1, y1, _, _ = lienzo.coords("caja")
    posicion.set(f"Caja en ({x1:.0f}, {y1:.0f})")


def soltar(evento):
        arrastre["activo"] = False
    apuntar(f"ButtonRelease-{evento.num}: soltado")


def entrar(evento):
        """<Enter> es el PUNTERO entrando, no la tecla Enter."""
    lienzo.configure(background="#F5F9FF")
    apuntar("<Enter>: el puntero ha entrado en el lienzo")


def salir(evento):
        lienzo.configure(background="white")
    apuntar("<Leave>: el puntero ha salido")


def doble(evento):
        """Ojo: el clic simple ya se ha disparado antes de llegar aquí.

    Por eso el simple y el doble son la misma acción a distinta
    intensidad, y no dos cosas incompatibles.
    """
    lienzo.itemconfigure("caja", fill=ROSA if lienzo.itemcget("caja", "fill")
                         == AZUL else AZUL)
    apuntar("Double-Button-1: cambia el color. El simple ya se disparó.")


def apuntar(mensaje):
        ultimo.set(mensaje)


ventana = tk.Tk()
ventana.title("Teclado y ratón")
ventana.minsize(600, 520)

# Variables sueltas y global: en el bloque E esto pasa a ser una clase.
nombre = tk.StringVar()
ciudad = tk.StringVar()
correo = tk.StringVar()
posicion = tk.StringVar(value="Caja en (80, 80)")
ultimo = tk.StringVar(value="Pulsa en el lienzo y usa las flechas.")
arrastre = {"x": 0, "y": 0, "activo": False}

cuerpo = ttk.Frame(ventana, padding=MARGEN)
cuerpo.pack(fill="both", expand=True)

formulario, primer_campo = crear_formulario(cuerpo)
lienzo = crear_lienzo(cuerpo)

pie = ttk.Frame(cuerpo)
pie.pack(fill="x", pady=(MARGEN, 0))
ttk.Label(pie, textvariable=posicion).pack(side="left")
ttk.Label(cuerpo, textvariable=ultimo, foreground=GRIS, wraplength=560,
          justify="left").pack(anchor="w", pady=(AIRE, 0))

# add="+" en todos, que es la regla de la lección 34 cuando hay varios
# bind sobre el mismo widget.
lienzo.bind("<Key>", tecla, add="+")
lienzo.bind("<Button-1>", empezar, add="+")
lienzo.bind("<B1-Motion>", arrastrar, add="+")
lienzo.bind("<ButtonRelease-1>", soltar, add="+")
lienzo.bind("<Double-Button-1>", doble, add="+")
lienzo.bind("<Enter>", entrar, add="+")
lienzo.bind("<Leave>", salir, add="+")

primer_campo.focus_set()      # el cursor donde se va a escribir
centrar(ventana)
ventana.mainloop()