"tkinter" --- Python interface to Tcl/Tk
****************************************

**Código fuente:** Lib/tkinter/__init__.py

======================================================================

The "tkinter" package ("Tk interface") is the standard Python
interface to the Tcl/Tk GUI toolkit.  Both Tk and "tkinter" are
available on most Unix platforms, including macOS, as well as on
Windows systems.

Running "python -m tkinter" from the command line should open a window
demonstrating a simple Tk interface, letting you know that "tkinter"
is properly installed on your system, and also showing what version of
Tcl/Tk is installed, so you can read the Tcl/Tk documentation specific
to that version.

Tkinter soporta un amplio rango de versiones TCL/TK, construidos con o
sin soporte de hilo. La versión oficial del binario de python incluye
Tcl/Tk 8.6 con subprocesos. Vea el código fuente para el módulo
"_tkinter"  para mayor información acerca de las versiones soportadas.

Tkinter no es un subproceso liviano pero agrega una buena cantidad de
su propia lógica para hacer la experiencia mas pythónico. Esta
documentación se concentrará en estas adiciones y cambios,
refiriéndose sobre la documentación oficial de Tcl-Tk para los
detalles que no han sido cambiados.

Nota:

  Tcl/Tk 8.5 (2007) introdujo un moderno conjunto de componentes
  temáticos de interfaz de usuario en conjunto con una nueva API para
  ser usada. Ambas API tanto la antigua como la nueva están
  disponibles. La mayor parte de la documentación que podrá encontrar
  en línea aún usa la antigua versión de la API y por lo tanto podría
  estar desactualizada.

This is an *optional module*. If it is missing from your copy of
CPython, look for documentation from your distributor (that is,
whoever provided Python to you). If you are the distributor, see
Requirements for optional modules.

Ver también:

  * TkDocs
       Es un extenso tutorial sobre como crear interfaces de usuario
       con Tkinter. Explica conceptos clave y muestra enfoques
       recomendados para usar la API moderna.

  * Tkinter 8.5 reference: a GUI for Python
       Documentación de referencia sobre Tkinter 8.5 donde se detallan
       clases disponibles, métodos y opciones.

  Recursos de Tcl/Tk:

  * Comandos Tk
       Referencia exhaustiva para cada uno de los comandos subyacentes
       utilizados por Tkinter.

  * Tcl/Tk Home Page
       Documentación adicional y enlaces al núcleo de desarrollo de
       Tcl/Tk.

  Libros:

  * Modern Tkinter for Busy Python Developers
       Escrito por Mark Roseman (ISBN 978-1999149567)

  * Python GUI programming with Tkinter
       By Alan D. Moore. (ISBN 978-1788835886)

  * Programming Python
       Escrito por Mark Lutz, que cubre los tópicos de Tkinter de
       forma excelente. (ISBN 978-0596158101)

  * Tcl and the Tk Toolkit
       Escrito por John Ousterhout, creador de Tcl/Tk y Kevin Jones,
       el cual no cubre Tkinter. (ISBN 978-0321336330)


Arquitectura
============

Tcl/Tk no es una biblioteca única mas bien consiste en unos pocos
módulos distintivos entre si. cada uno separados por funcionalidades y
que poseen su documentación oficial. Las versiones del binario de
Python también incluyen un módulo adicional con esto.

Tcl
   Tcl es un lenguaje de programación interpretado y dinámico, tal
   como Python. Aunque puede ser usado en si mismo como un lenguaje de
   programación de uso general, lo más común es que se utilice en
   aplicaciones del lenguaje C como un motor de secuencias de comandos
   o como una interfaz hacia el kit de herramientas de Tk. La librería
   TCL contiene una interfaz con C que crea y gestiona una o más
   instancias del intérprete de TCL, corre los comandos en TCL en esas
   instancias y agrega comandos personalizados tanto en Tcl o C. Cada
   intérprete tiene su cola de eventos y entrega facilidades para
   enviar procesos a la cola y procesarlos. A diferencia de Python, el
   modelo de ejecución en Tcl es diseñado alrededor de cooperar en
   múltiples asignaciones y Tkinter ayuda a salvar estas diferencias
   (ver Threading model para más detalles).

Tk
   Tk es un paquete de Tcl implementado en C que agrega comandos
   personalizados que permiten manipular widget en la GUI. Cada objeto
   de la clase "Tk" agrega su instancia de interprete Tcl con Tk
   cargado en el. Los widget de Tk son muy personalizables, aunque a
   costa de una apariencia anticuada. Tk usa eventos de la cola de Tcl
   para generar y procesar eventos de la GUI.

Ttk
   El nuevo tema Tk (Ttk) es una nueva familia de widgets de Tk que
   proveen una mejor apariencia en diferentes plataformas mas que
   varios de los widgets clásicos de Tk. Ttk es distribuido como parte
   de Tk estando disponible a partir de la versión 8.5. Enlaces para
   Python son entregados en un módulo aparte, "tkinter.ttk".

Internamente, Tk y Ttk usan funcionalidades del sistema operativo
subyacente, en otras palabras, Xlib en Unix/X11, Cocoa en macOS o GDI
en Windows.

When your Python application uses a class in Tkinter, e.g., to create
a widget, the "tkinter" module first assembles a Tcl/Tk command
string. It passes that Tcl command string to an internal "_tkinter"
binary module, which then calls the Tcl interpreter to evaluate it.
The Tcl interpreter will then call into the Tk and/or Ttk packages,
which will in turn make calls to Xlib, Cocoa, or GDI.


Módulos Tkinter
===============

Support for Tkinter is spread across several modules. Most
applications will need the main "tkinter" module, as well as the
"tkinter.ttk" module, which provides the modern themed widget set and
API:

   from tkinter import *
   from tkinter import ttk

class tkinter.Tk(screenName=None, baseName=None, className='Tk', useTk=True, sync=False, use=None)

   Esto crea un widget de nivel superior de Tk que generalmente es la
   ventana principal de una aplicación. Cada instancia tiene su propio
   intérprete Tcl asociado.

   La clase "Tk" normalmente se instancia utilizando los valores
   predeterminados. No obstante, se reconocen los siguientes
   argumentos de palabra clave:

   *screenName*
      Cuando se proporciona (como cadena de caracteres), establece la
      variable de entorno "DISPLAY". (solo X11)

   *baseName*
      Nombre del archivo de perfil. De forma predeterminada,
      *baseName* se deriva del nombre del programa ("sys.argv[0]").

   *className*
      Nombre de la clase del widget. Se utiliza como archivo de perfil
      y como nombre con el que se invoca a Tcl (*argv0* en *interp*).

   *useTk*
      Si es *True*, inicializa el subsistema Tk. La función
      "tkinter.Tcl()" se establece en *False*.

   *sync*
      Si es "True", ejecuta todos los comandos del servidor X de forma
      síncrona, por lo tanto, los errores se notifican inmediatamente.
      Se puede utilizar en el proceso de depuración. (solo X11)

   *use*
      Especifica el *id* de la ventana en la que se incrustar la
      aplicación, en lugar de crearla como una ventana independiente
      de nivel superior. El *id* debe especificarse de la misma manera
      que el valor para la opción -use de los widgets de nivel
      superior (es decir, emplea el formato de retorno de
      "winfo_id()").

      Hay que tener en cuenta que en algunas plataformas, esto solo
      funcionará correctamente si el *id* se refiere a un marco Tk o a
      un nivel superior que tenga habilitada la opción -container.

   "Tk" lee e interpreta los archivos de perfil, nombrados
   ".*className*.tcl" y ". *baseName*.tcl", en  el intérprete Tcl y
   llama a "exec()" sobre el contenido de ".*className*.py" y
   ".*baseName*.py". La ruta de los archivos de perfil se encuentra en
   la variable de entorno "HOME" o, si no está definida, en
   "os.curdir".

   tk

      El objeto de la aplicación Tk creado al instanciar "Tk". Esto
      proporciona acceso al intérprete de Tcl. Todos los widget que se
      adjuntan a la misma instancia de "Tk" tienen el mismo valor para
      el atributo "tk".

   master

      The widget object that contains this widget.  For "Tk", the
      "master" is "None" because it is the main window.  The terms
      *master* and *parent* are similar and sometimes used
      interchangeably as argument names; however, calling
      "winfo_parent()" returns a string of the widget name whereas
      "master" returns the object. *parent*/*child* reflects the tree-
      like relationship while *master* (or *container*)/*content*
      reflects the container structure.

   children

      Los descendientes directos de este widget como "dict" con los
      nombres del widget secundario como clave y los objetos de
      instancia secundarios como valor.

tkinter.Tcl(screenName=None, baseName=None, className='Tk', useTk=False)

   La función "Tcl()" es una función de fábrica que crea un objeto muy
   similar al creado por la clase "Tk", excepto que no inicializa el
   subsistema Tk. Esto suele ser útil cuando se maneja el intérprete
   de Tcl en un entorno en el que no se desean crear ventanas de nivel
   superior extrañas o donde no se puede (como los sistemas Unix/Linux
   sin un servidor X). Un objeto creado por el objeto "Tcl()" puede
   tener una ventana *Toplevel* creada (y el subsistema Tk
   inicializado) llamando a su método "loadtk()".

Otros módulos que proporcionan soporte a Tk incluyen:

"tkinter"
   Módulos de Tkinter.

"tkinter.colorchooser"
   Cuadro de diálogo que permite al usuario elegir un color.

"tkinter.commondialog"
   Clase base para cuadros de diálogo definidos en los otros módulos
   listados aquí.

"tkinter.filedialog"
   Cuadros de diálogo por defecto que permiten al usuario especificar
   un archivo para abrir o guardar.

"tkinter.font"
   Utilidades para ayudar a trabajar con fuentes.

"tkinter.messagebox"
   Acceso a cuadros de diálogo estándar de Tk.

"tkinter.scrolledtext"
   Widget de texto con una barra de desplazamiento vertical integrada.

"tkinter.simpledialog"
   Cuadros de diálogo simples y funciones útiles.

"tkinter.ttk"
   Themed widget set introduced in Tk 8.5, providing modern
   alternatives for many of the classic widgets in the main "tkinter"
   module.

Módulos adicionales:

"_tkinter"
   A binary module that contains the low-level interface to Tcl/Tk. It
   is automatically imported by the main "tkinter" module, and should
   never be used directly by application programmers. It is usually a
   shared library (or DLL), but might in some cases be statically
   linked with the Python interpreter.

"idlelib"
   Python's Integrated Development and Learning Environment (IDLE).
   Based on "tkinter".

"tkinter.constants"
   Symbolic constants that can be used in place of strings when
   passing various parameters to Tkinter calls. Automatically imported
   by the main "tkinter" module.

"tkinter.dnd"
   (experimental) Drag-and-drop support for "tkinter". This will
   become deprecated when it is replaced with the Tk DND.

"turtle"
   Gráficos de tortuga en una ventana Tk.


Guía de supervivencia de Tkinter
================================

Esta sección no fue pensada en ser un tutorial exhaustivo sobre cada
tópico de Tk o Tkinter. Para esto, puede consultar en alguno de los
recursos externos que fueron presentados anteriormente. En vez de eso,
esta apartado entrega una orientación breve sobre como es ve una
aplicación en Tkinter, identifica conceptos claves de Tk y explica
como el empaquetador de Tkinter está estructurado.

Es resto de esta sección lo ayudará a identificar las clases, métodos
y opciones que necesitará en una aplicación de Tkinter y donde se
puede encontrar documentación más detallada sobre esto, incluida en la
guía de referencia oficial de Tcl/Tk.


Un programa simple de Hola Mundo
--------------------------------

Comenzaremos a explorar Tkinter a través de una simple aplicación
"Hola Mundo". Esta no es la aplicación mas pequeña que podríamos
escribir, pero es suficiente para ilustrar algunos conceptos claves
que necesitará saber.

   from tkinter import *
   from tkinter import ttk
   root = Tk()
   frm = ttk.Frame(root, padding=10)
   frm.grid()
   ttk.Label(frm, text="Hello World!").grid(column=0, row=0)
   ttk.Button(frm, text="Quit", command=root.destroy).grid(column=1, row=0)
   root.mainloop()

Después de las declaraciones de import, la línea siguiente será la de
crear la instancia de la clase "Tk" la cual iniciativa Tk y crea el
interprete asociado a Tcl. Esto también crea una ventana de nivel
superior, conocida como la ventana raíz la cual sirve como la ventana
principal de la aplicación.

En la siguiente línea se crea el marco del widget, el cual en este
caso contendrá la etiqueta y el botón que crearemos después. El marco
encaja dentro de la ventana raíz.

La próxima línea crea una etiqueta para el widget que contiene una
cadena de texto estática. El método "grid()" es usado para especificar
la posición del diseño de la etiqueta que está dentro del marco del
widget, similar a como trabajan las tablas en HTML.

Es entonces cuando el botón del widget es creado y dejado a la derecha
de la etiqueta. Una vez pulsado llamará al método "destroy()" de la
ventana raíz.

Finalmente el método "mainloop()" muestra todo en pantalla y responde
a la entrada del usuario hasta que el programa termina.


Conceptos importantes de Tk
---------------------------

Incluso con este sencillo programa se pueden mostrar conceptos claves
de Tk:

widgets
   Una interfaz de usuario de Tkinter está compuesta de varios
   *widgets* individuales. Cada widget es representado como un objeto
   de Python, instanciado desde clases tales como "ttk.Frame",
   "ttk.Label" y "ttk.Button".

jerarquía de los widgets
   Los widgets se organizan en *jerarquías*. La etiqueta y el botón
   estaban dentro del marco el que a su vez estaba contenido dentro
   del marco raíz. Cuando se crea cada *child* del widget su *parent*
   es pasado como el primer argumento del constructor del widget.

opciones de configuración
   Los widgets tienen *opciones de configuración* los cuales modifican
   su apariencia y comportamiento, como el texto que se despliega en
   la etiqueta o el botón. Diferentes clases de widgets tendrán
   diferentes conjuntos de opciones.

gestión del diseño de formularios
   Los widgets no son añadidos automáticamente a la interfaz de
   usuario una vez que han sido creados. Un *administrador de
   geometrías* como "grid" controla donde la interfaz de usuario es
   colocada.

ejecución del evento
   Tkinter reacciona a la entrada del usuario, realiza los cambios del
   programa e incluso actualiza lo que se muestra en pantalla solo
   cuando se ejecuta activamente un *event loop*. Si el programa no
   esta ejecutando el evento, su interfaz de usuario no se
   actualizará.


Entendiendo como funcionan los empaquetadores de Tcl/Tk
-------------------------------------------------------

Cuando su aplicación utiliza las clases y métodos de Tkinter,
internamente Tkinter está ensamblando cadenas que representan comandos
Tcl/Tk, y ejecutando esos comandos en el intérprete Tcl adjunto a la
instancia "Tk" de su aplicación.

Tanto si se está intentando navegar en la documentación de referencia
o intentando encontrar el método u opción correcta o adaptando algún
código ya existente o depurando su aplicación en Tkinter, hay veces
que es útil entender como son esos comandos subyacentes de Tcl/Tk.

Para ilustrar, aquí se tiene un equivalente en Tcl/Tk de la parte
principal del script Tkinter anterior.

   ttk::frame .frm -padding 10
   grid .frm
   grid [ttk::label .frm.lbl -text "Hello World!"] -column 0 -row 0
   grid [ttk::button .frm.btn -text "Quit" -command "destroy ."] -column 1 -row 0

La sintaxis es similar a varios lenguajes de línea de comandos, donde
la primera palabra es el comando que debe ser ejecutado con los
argumentos que le siguen al comando, separados por espacios, Sin
entrar en demasiados detalles, note lo siguiente:

* Los comandos usados para crear widgets (tales como "ttk::frame")
  corresponden a las clases de widgets en Tkinter.

* Opciones de widget en Tcl (por ejemplo "-text") corresponden a
  argumentos clave en Tkinter.

* Los widgets son reverenciados con un *pathname* in Tcl (por ejemplo
  ".frm.btn") mientras que Tkinter no usa nombres sino que referencia
  a objetos.

* El lugar del widget en la jerarquía es codificada (jerárquicamente)
  en nombre de archivo, usando un "." (punto) como separador de
  búsqueda. El nombre de ruta del archivo para la ventana raíz es un
  "." (punto), la jerarquía no es definida por la ruta del archivo
  pero si por la especificación del widget padre cuando se crea cada
  widget hijo.

* Operations which are implemented as separate *commands* in Tcl (like
  "grid" or "destroy") are represented as *methods* on Tkinter widget
  objects. As you'll see shortly, at other times Tcl uses what appear
  to be method calls on widget objects, which more closely mirror what
  is used in Tkinter.


¿Cómo lo hago?, ¿Cómo funciona?
-------------------------------

Si no esta seguro sobre como realizar ciertas acciones en Tkinter y no
se puede encontrar información de forma rápida en el tutorial o en la
documentación de referencias que estas usando, aquí hay varias
estrategias que pueden ser de mucha ayuda.

Primero, recordar que los detalles sobre como cada widget trabaja en
las diferentes versiones de Tcl/Tk pueden variar según la versión. Si
está buscando información, asegúrese de que corresponde a la versión
tanto de Python como de Tcl/Tk instaladas en su sistema.

Cuando se busca sobre como usar una API, puede ser muy útil el saber
exactamente el nombre de la clase, opción o método que está
utilizando. Tener esto en cuenta de antemano, ya sea en un shell de
Python interactivo o con "print()", puede ayudar a identificar lo que
necesitas.

Para encontrar que opciones de configuración están disponibles en cada
widget, se utiliza la llamada al método "configure()", el cual retorna
un diccionario que contiene una gran variedad de información sobre
cada objeto, incluyendo valores por defecto y actuales. Utilice el
"keys()" para saber los nombres de cada opción.

   btn = ttk.Button(frm, ...)
   print(btn.configure().keys())

La mayoría de los widgets tienen varias opciones de configuraciones en
común, puede ser útil averiguar cuales son específicos de una clase de
widget en particular. Comparando la lista de opciones de un widget
sencillo como por ejemplo un frame es una de las formas de hacerlo.

   print(set(btn.configure().keys()) - set(frm.configure().keys()))

De manera similar se pueden encontrar los métodos disponibles para un
objeto de un widget utilizando la función standard "dir()". Si lo
intentas podrás ver alrededor de 200 métodos comunes para los widgets
por lo que de nuevo, es muy importante identificar las
especificaciones de un widget.

   print(dir(btn))
   print(set(dir(btn)) - set(dir(frm)))


Navegando en el manual de referencia de Tcl/Tk
----------------------------------------------

Como se ha señalado, el manual oficial de referencia de Tk commands
(en las páginas del manual) es a menudo la descripción mas precisa
sobre que hacen las operaciones especificas de los widgets. Incluso
sabiendo el nombre de la opción o método que necesitas, es posible que
puedas encontrar información adicional.

Mientras todas las operaciones en Tkinter son implementadas como
llamadas de método sobre objetos del widget, se puede ver cuantas
operaciones de Tcl/Tk aparecen como comandos que toman el nombre de
ruta del widget como el primer parámetro, seguido de parámetros
opcionales, por ejemplo.

   destroy .
   grid .frm.btn -column 0 -row 0

Otros, sin embargo, se parecen más a métodos llamados en un objeto del
widget (de hecho, cuando se crea un widget en Tcl / Tk, este a su vez
crea un comando Tcl con el nombre de la ruta del widget, siendo el
primer parámetro de ese comando el nombre de un método para llamar).

   .frm.btn invoke
   .frm.lbl configure -text "Goodbye"

En la documentación oficial de referencia para Tcl/Tk, se podrán
encontrar mas operaciones que son similares a las llamadas a métodos
de la pagina principal de un widget en especifico ( p.ej., se podrá
encontrar el método "invoke()" en la página principal de ttk::button )
mientras que las funciones que toman un widget como un parámetro a
menudo tienen su propia página principal (p.ej., grid).

Se podrán encontrar varias opciones en común y metidos en las páginas
del manual options o ttk::widget, mientras que otras opciones se
encuentran en las páginas del manual de una clase de widget
específica.

También se puede encontrar cuantos métodos de Tkinter poseen nombres
compuestos, p.ej, "winfo_x()", "winfo_height()", "winfo_viewable()".
Usted también encuentra información para todo esto en las páginas del
manual en winfo <https://www.tcl.tk/man/tcl8.6/TkCmd/winfo.htm>`_.

Nota:

  Puede ser algo confuso, pero también hay métodos en todos los
  widgets de Tkinter los cuales no operan directamente en el widget
  pero operan a nivel global, independiente del widget. Ejemplos de
  esto son los métodos para acceder al portapapeles o a llamados del
  sistema. (Ellos aparecen al ser implementados como métodos en la
  clase base "Widget" clase que todos los widgets en Tkinter heredan).


Modelo de subprocesamiento
==========================

Python and Tcl/Tk have very different threading models, which
"tkinter" tries to bridge. If you use threads, you may need to be
aware of this.

Un interprete de Python puede tener varios hilos asociados. En Tcl,
diferentes hilos pueden ser creados, pero cada hilo tiene una
instancia del interprete de Tcl asociada por separado. Los hilos
también pueden crear mas de una instancia del interprete, aunque cada
instancia del intérprete puede ser usada solo por el hilo que ha sido
creado.

Each "Tk" object created by "tkinter" contains a Tcl interpreter. It
also keeps track of which thread created that interpreter. Calls to
"tkinter" can be made from any Python thread. Internally, if a call
comes from a thread other than the one that created the "Tk" object,
an event is posted to the interpreter's event queue, and when
executed, the result is returned to the calling Python thread.

Las aplicaciones de Tcl/Tk son normalmente basados en eventos, lo que
significa que después de la inicialización, el interprete corre un
bucle de eventos (p.ej. "Tk.mainloop()") que responde a los eventos.
Al ser un evento de un solo proceso, los controladores responden
rápidamente, en caso contrario ellos bloquearán el procesamiento de
otros eventos. Para evitar esto, cualquier procesamiento de larga
duración no deben ser procesados en el controlador de eventos, o en
caso contrario ser separados en pequeñas piezas usando temporizadores
o correr el proceso en otro hilo. Esto es diferente a muchos kits de
herramientas de GUI donde GUI se ejecuta en un hilo completamente
separado del código de la aplicación, incluido el controlador de
eventos.

If the Tcl interpreter is not running the event loop and processing
events, any "tkinter" calls made from threads other than the one
running the Tcl interpreter will fail.

Existen varios casos especiales:

* Tcl/Tk libraries can be built so they are not thread-aware. In this
  case, "tkinter" calls the library from the originating Python
  thread, even if this is different than the thread that created the
  Tcl interpreter. A global lock ensures only one call occurs at a
  time.

* While "tkinter" allows you to create more than one instance of a
  "Tk" object (with its own interpreter), all interpreters that are
  part of the same thread share a common event queue, which gets ugly
  fast. In practice, don't create more than one instance of "Tk" at a
  time. Otherwise, it's best to create them in separate threads and
  ensure you're running a thread-aware Tcl/Tk build.

* Bloquear los controladores de eventos no son la única manera de
  prevenir que el intérprete de Tcl reingrese al bucle de eventos. Es
  incluso posible ejecutar una cantidad de bucles de eventos anidados
  o abandonar el bucle de forma completa, Si está realizando alguna
  tarea complicada cuando se trata de eventos o hilos hay que tener en
  cuenta estas posibilidades.

* There are a few select "tkinter" functions that presently work only
  when called from the thread that created the Tcl interpreter.


Guía práctica
=============


Configuración de opciones
-------------------------

Las opciones controlan parámetros como el color y el ancho del borde
de un widget. Las opciones se pueden configurar de tres maneras:

En el momento de la creación del objeto, utilizando argumentos de
palabras clave
      fred = Button(self, fg="red", bg="blue")

Después de la creación del objeto, tratando el nombre de la opción
como un índice de diccionario
      fred["fg"] = "red"
      fred["bg"] = "blue"

Usando el método *config()* para actualizar múltiples atributos
después de la creación del objeto
      fred.config(fg="red", bg="blue")

Para obtener una explicación completa de las opciones y su
comportamiento, consulte las páginas de manual de Tk para el widget en
cuestión.

Tenga en cuenta que las páginas del manual enumeran "OPCIONES
ESTÁNDAR" y "OPCIONES ESPECÍFICAS DE WIDGET" para cada widget. La
primera es una lista de opciones que son comunes a muchos widgets, la
segunda son las opciones que son específicas para ese widget en
particular. Las opciones estándar están documentadas en la página del
manual *options(3)*.

No se hace distinción entre las opciones estándar y las opciones
específicas del widget en este documento. Algunas opciones no se
aplican a algunos tipos de widgets. Si un determinado widget responde
a una opción particular depende de la clase del widget. Los botones
tienen la opción "command", las etiquetas no.

Las opciones admitidas por un widget dado se enumeran en la página de
manual de ese widget, o se pueden consultar en tiempo de ejecución
llamando al método "config()" sin argumentos, o llamando al método
"keys()" en ese widget. El valor retornado en esas llamadas es un
diccionario cuya clave es el nombre de la opción como una cadena (por
ejemplo, "'relief'") y cuyo valor es una tupla de 5 elementos.

Algunas opciones, como "bg", son sinónimos de opciones comunes con
nombres largos ("bg" es la abreviatura de *"background"*). Al pasar el
método "config()", el nombre de una opción abreviada retornará una
tupla de 2 elementos (en lugar de 5). Esta tupla contiene nombres de
sinónimos y nombres de opciones "reales" (como "('bg',
'background')").

+---------+-----------------------------------+----------------+
| Índice  | Significado                       | Ejemplo        |
|=========|===================================|================|
| 0       | nombre de la opción               | "'relief'"     |
+---------+-----------------------------------+----------------+
| 1       | nombre de la opción para la       | "'relief'"     |
|         | búsqueda en la base de datos      |                |
+---------+-----------------------------------+----------------+
| 2       | clase de la opción para la        | "'Relief'"     |
|         | consulta de base de datos         |                |
+---------+-----------------------------------+----------------+
| 3       | valor por defecto                 | "'raised'"     |
+---------+-----------------------------------+----------------+
| 4       | valor actual                      | "'groove'"     |
+---------+-----------------------------------+----------------+

Ejemplo:

   >>> print(fred.config())
   {'relief': ('relief', 'relief', 'Relief', 'raised', 'groove')}

Por supuesto, el diccionario impreso incluirá todas las opciones
disponibles y sus valores. Esto es solo un ejemplo.


El empaquetador
---------------

The packer is one of Tk's geometry-management mechanisms.    Geometry
managers are used to specify the relative positioning of widgets
within their container. In contrast to the more cumbersome *placer*
(which is used less commonly, and we do not cover here), the packer
takes qualitative relationship specification - *above*, *to the left
of*, *filling*, etc - and works everything out to determine the exact
placement coordinates for you.

The size of any container widget is determined by the size of the
"content widgets" inside.  The packer is used to control where content
widgets appear inside the container into which they are packed.  You
can pack widgets into frames, and frames into other frames, in order
to achieve the kind of layout you desire. Additionally, the
arrangement is dynamically adjusted to accommodate incremental changes
to the configuration, once it is packed.

Tenga en cuenta que los widgets no aparecen hasta que su geometría no
se haya especificado con un administrador de diseño de pantalla. Es un
error común de principiante ignorar la especificación de la geometría,
y luego sorprenderse cuando se crea el widget pero no aparece nada. Un
objeto gráfico solo aparece después que, por ejemplo, se le haya
aplicado el método "pack()" del empaquetador.

Se puede llamar al método *pack()* con pares palabra-clave/valor que
controlan dónde debe aparecer el widget dentro de su contenedor y cómo
se comportará cuando se cambie el tamaño de la ventana principal de la
aplicación. Aquí hay unos ejemplos:

   fred.pack()                     # defaults to side = "top"
   fred.pack(side="left")
   fred.pack(expand=1)


Opciones del empaquetador
-------------------------

Para obtener más información sobre el empaquetador y las opciones que
puede tomar, consulte el manual y la página 183 del libro de John
Ousterhout.

*anchor*
   Anchor type.  Denotes where the packer is to place each content in
   its parcel.

*expand*
   Un valor booleano, "0" o "1".

*fill*
   Los valores legales son: "'x'", "'y'", "'both'", "'none'".

*ipadx* y *ipady*
   A distance - designating internal padding on each side of the
   content.

*padx* y *pady*
   A distance - designating external padding on each side of the
   content.

*side*
   Los valores legales son: "'left'", "'right'", "'top'", "'bottom'".


Asociación de variables de widget
---------------------------------

La asignación de un valor a ciertos objetos gráficos (como los widgets
de entrada de texto) se puede vincular directamente a variables en su
aplicación utilizando opciones especiales. Estas opciones son
"variable", "textvariable", "onvalue", "offvalue", y "value". Esta
conexión funciona en ambos sentidos: si la variable cambia por algún
motivo, el widget al que está conectado se actualizará para reflejar
el nuevo valor.

Unfortunately, in the current implementation of "tkinter" it is not
possible to hand over an arbitrary Python variable to a widget through
a "variable" or "textvariable" option.  The only kinds of variables
for which this works are variables that are subclassed from a class
called Variable, defined in "tkinter".

Hay muchas subclases útiles de Variable ya definidas: "StringVar",
"IntVar", "DoubleVar", and "BooleanVar". Para leer el valor actual de
dicha variable, es necesario llamar al método "get()", y para cambiar
su valor, al método "set()". Si se sigue este protocolo, el widget
siempre rastreará el valor de la variable, sin ser necesaria ninguna
otra intervención.

Por ejemplo:

   import tkinter as tk

   class App(tk.Frame):
       def __init__(self, master):
           super().__init__(master)
           self.pack()

           self.entrythingy = tk.Entry()
           self.entrythingy.pack()

           # Create the application variable.
           self.contents = tk.StringVar()
           # Set it to some value.
           self.contents.set("this is a variable")
           # Tell the entry widget to watch this variable.
           self.entrythingy["textvariable"] = self.contents

           # Define a callback for when the user hits return.
           # It prints the current value of the variable.
           self.entrythingy.bind('<Key-Return>',
                                self.print_contents)

       def print_contents(self, event):
           print("Hi. The current entry content is:",
                 self.contents.get())

   root = tk.Tk()
   myapp = App(root)
   myapp.mainloop()


El gestor de ventanas
---------------------

In Tk, there is a utility command, "wm", for interacting with the
window manager.  Options to the "wm" command allow you to control
things like titles, placement, icon bitmaps, and the like.  In
"tkinter", these commands have been implemented as methods on the "Wm"
class.  Toplevel widgets are subclassed from the "Wm" class, and so
can call the "Wm" methods directly.

To get at the toplevel window that contains a given widget, you can
often just refer to the widget's "master".  Of course if the widget
has been packed inside of a frame, the "master" won't represent a
toplevel window.  To get at the toplevel window that contains an
arbitrary widget, you can call the "_root()" method. This method
begins with an underscore to denote the fact that this function is
part of the implementation, and not an interface to Tk functionality.

Aquí hay algunos ejemplos típicos:

   import tkinter as tk

   class App(tk.Frame):
       def __init__(self, master=None):
           super().__init__(master)
           self.pack()

   # create the application
   myapp = App()

   #
   # here are method calls to the window manager class
   #
   myapp.master.title("My Do-Nothing Application")
   myapp.master.maxsize(1000, 400)

   # start the program
   myapp.mainloop()


Tipos de datos de opciones Tk
-----------------------------

*anchor*
   Los valores legales son los puntos de la brújula: ""n"", ""ne"",
   ""e"", ""se"", ""s"", ""sw"", ""w"", ""nw"", y también ""center"".

*bitmap*
   Hay ocho nombres de *bitmaps* integrados: "'error'", "'gray25'",
   "'gray50'", "'hourglass'", "'info'", "'questhead'", "'question'",
   "'warning'". Para especificar un nombre de archivo de mapa de bits
   de X, indique la ruta completa del archivo, precedida por una "@",
   como en ""@/usr/contrib/bitmap/gumby.bit"".

*boolean*
   Se puede pasar enteros 0 o 1 o las cadenas ""yes"" or ""no"".

*callback*
   Esto es cualquier función de Python que no toma argumentos. Por
   ejemplo:

      def print_it():
          print("hi there")
      fred["command"] = print_it

*color*
   Los colores se pueden dar como nombres de colores de X en el
   archivo "rgb.txt", o como cadenas que representan valores RGB. La
   cadena que representa el valor RGB toma un rango de 4
   bits:""#RGB"", 8 bits: ""#RRGGBB"", 12 bits" ""#RRRGGGBBB"", o 16
   bits ""#RRRRGGGGBBBB"" donde R, G, B representan cualquier dígito
   hexadecimal legal. Consulte la página 160 del libro de Ousterhout
   para más detalles.

*cursor*
   Los nombres estándar del cursor X de "cursorfont.h" se pueden usar
   sin el prefijo "XC_". Por ejemplo, para obtener un cursor de mano
   ("XC_hand2"), use la cadena ""hand2"". También se puede especificar
   su propio mapa de bits y archivo de máscara. Ver página 179 del
   libro de Ousterhout.

*distance*
   Las distancias de pantalla se pueden especificar tanto en píxeles
   como en distancias absolutas. Los píxeles se dan como números y las
   distancias absolutas como cadenas con el carácter final que indica
   unidades: "c" para centímetros, "i" para pulgadas, "m" para
   milímetros, "p" para puntos de impresora. Por ejemplo, 3.5 pulgadas
   se expresa como ""3.5i"".

*font*
   Tk usa un formato de lista para los nombres de fuentes, como
   "{courier 10 bold}". Los tamaños de fuente expresados en números
   positivos se miden en puntos, mientras que los tamaños con números
   negativos se miden en píxeles.

geometry
   Es una cadena de caracteres del estilo "widthxheight", donde el
   ancho y la altura se miden en píxeles para la mayoría de los
   widgets (en caracteres para widgets que muestran texto). Por
   ejemplo: "fred["geometry"] = "200x100"".

justify
   Legal values are the strings: ""left"", ""center"", and ""right"".

region
   Es una cadena de caracteres con cuatro elementos delimitados por
   espacios, cada uno de ellos es una distancia legal (ver arriba).
   Por ejemplo: ""2 3 4 5"" , ""3i 2i 4.5i 2i"" y ""3c 2c 4c 10.43c""
   son todas regiones legales.

relief
   Determina cuál será el estilo de borde de un widget. Los valores
   legales son: ""raised"", ""sunken"", ""flat"", ""groove"", y
   ""ridge"".

scrollcommand
   Este es casi siempre el método "set()" de algún widget de barra de
   desplazamiento, pero puede ser cualquier método de un widget que
   tome un solo argumento.

wrap
   Debe ser uno de estos: ""none"", ""char"", o ""word"".


Enlaces y eventos
-----------------

El método de enlace (*binding*) del comando del widget le permite
observar ciertos eventos y hacer que la función de devolución de
llamada se active cuando se produce ese tipo de evento. La forma del
método de enlace es:

   def bind(self, sequence, func, add=''):

donde:

sequence
   es una cadena que denota el tipo de evento objetivo. Para obtener
   más información, consulte la página del manual de Bind y la página
   201 del libro de John Ousterhout.

func
   es una función de Python que toma un argumento y se llama cuando
   ocurre el evento. La instancia del evento se pasa como el argumento
   mencionado. (Las funciones implementadas de esta manera a menudo se
   llaman *callbacks*.)

add
   es opcional, ya sea "''" o "'+'". Pasar una cadena de caracteres
   vacía indica que este enlace anulará cualquier otro enlace asociado
   con este evento. Pasar "'+'" agrega esta función a la lista de
   funciones vinculadas a este tipo de evento.

Por ejemplo:

   def turn_red(self, event):
       event.widget["activeforeground"] = "red"

   self.button.bind("<Enter>", self.turn_red)

Observe cómo se accede al campo del widget del evento en la devolución
de llamada "turn_red()". Este campo contiene el widget que capturó el
evento de X. La siguiente tabla enumera los otros campos de eventos a
los que puede acceder y cómo se indican en Tk, lo que puede ser útil
cuando se hace referencia a las páginas del manual de Tk.

+------+-----------------------+------+-----------------------+
| Tk   | Campo evento de       | Tk   | Campo evento de       |
|      | Tkinter               |      | Tkinter               |
|======|=======================|======|=======================|
| %f   | focus                 | %A   | char                  |
+------+-----------------------+------+-----------------------+
| %h   | height                | %E   | send_event            |
+------+-----------------------+------+-----------------------+
| %k   | keycode               | %K   | keysym                |
+------+-----------------------+------+-----------------------+
| %s   | state                 | %N   | keysym_num            |
+------+-----------------------+------+-----------------------+
| %t   | time                  | %T   | type                  |
+------+-----------------------+------+-----------------------+
| %w   | width                 | %W   | widget                |
+------+-----------------------+------+-----------------------+
| %x   | x                     | %X   | x_root                |
+------+-----------------------+------+-----------------------+
| %y   | y                     | %Y   | y_root                |
+------+-----------------------+------+-----------------------+


El parámetro índice
-------------------

Muchos widgets requieren que se pase un parámetro  de tipo índice.
Esto se utiliza para señalar ubicaciones específicas en el widget de
texto, caracteres específicos en el widget de entrada, o elementos
particulares en el widget de menú.

Índice de widget de entrada (índice, índice de vista, etc.)
   Entry widgets have options that refer to character positions in the
   text being displayed.  You can use these "tkinter" functions to
   access these special points in text widgets:

Índice de widget de texto
   La notación de índice del widget de texto es muy rica y se detalla
   mejor en las páginas del manual de Tk.

Índices de menú (*menu.invoke()*, *menu.entryconfig()*, etc.)
   Algunas opciones y métodos para menús manipulan entradas de menú
   específicas. Cada vez que se necesita un índice de menú para una
   opción o un parámetro, se puede pasar:

   * un número entero que se refiere a la posición numérica de la
     entrada en el widget, contada desde arriba, comenzando con 0;

   * la cadena ""active"", que se refiere a la posición del menú que
     está actualmente debajo del cursor;

   * la cadena de caracteres ""last"" que se refiere al último
     elemento del menú;

   * Un número entero precedido por "@", como en "@6", donde el entero
     es interpretado como una coordenada *y* de píxeles en el sistema
     de coordenadas del menú;

   * la cadena de caracteres ""none"", que indica que no hay entrada
     de menú, usado frecuentemente con *menu.activate()* para
     desactivar todas las entradas; y, finalmente,

   * una cadena de texto cuyo patrón coincide con la etiqueta de la
     entrada del menú, tal como se explora desde la parte superior del
     menú hasta la parte inferior. Tenga en cuenta que este tipo de
     índice se considera después de todos los demás, lo que significa
     que las coincidencias para los elementos del menú etiquetados
     "last", "active", o "none" pueden interpretarse de hecho como los
     literales anteriores.


Imágenes
--------

Se pueden crear imágenes de diferentes formatos a través de la
correspondiente subclase de "tkinter.Image":

* "BitmapImage" para imágenes en formato XBM.

* "PhotoImage" para imágenes en formatos PGM, PPM, GIF y PNG. Este
  último es compatible a partir de Tk 8.6.

Cualquier tipo de imagen se crea a través de la opción "file" o "data"
(también hay otras opciones disponibles).

Distinto en la versión 3.13: Added the "PhotoImage" method
"copy_replace()" to copy a region from one image to other image,
possibly with pixel zooming and/or subsampling. Add *from_coords*
parameter to "PhotoImage" methods "copy()", "zoom()" and
"subsample()". Add *zoom* and *subsample* parameters to "PhotoImage"
method "copy()".

El objeto imagen se puede usar siempre que algún widget admita una
opción de "image" (por ejemplo, etiquetas, botones, menús). En estos
casos, Tk no mantendrá una referencia a la imagen. Cuando se elimina
la última referencia de Python al objeto de imagen, los datos de la
imagen también se eliminan, y Tk mostrará un cuadro vacío donde se
utilizó la imagen.

Ver también:

  El paquete Pillow añade soporte para los formatos del tipo BMP,
  JPEG, TIFF, y WebP, entre otros.


Gestor de archivos
==================

Tk permite registrar y anular el registro de una función de devolución
de llamada que se llamará desde el mainloop de Tk cuando la E/S sea
posible en un descriptor de archivo. Solo se puede registrar un
controlador por descriptor de archivo. Código de ejemplo:

   import tkinter
   widget = tkinter.Tk()
   mask = tkinter.READABLE | tkinter.WRITABLE
   widget.tk.createfilehandler(file, mask, callback)
   ...
   widget.tk.deletefilehandler(file)

Esta función no está disponible en Windows.

Dado que no se sabe cuántos bytes están disponibles para su lectura,
no use métodos de "BufferedIOBase" o "TextIOBase" "read()" o
"readline()", ya que estos requieren leer un número predefinido de
bytes. Para *sockets*, los métodos "recv()" o "recvfrom()" trabajan
bien; para otros archivos, use lectura sin formato o
"os.read(file.fileno(), maxbytecount)".

Widget.tk.createfilehandler(file, mask, func)

   Registra la función *callback* gestor de archivos *func*. El
   argumento *file* puede ser un objeto con un método "fileno()" (como
   un archivo u objeto de socket), o un descriptor de archivo entero.
   El argumento *mask* es una combinación ORed de cualquiera de las
   tres constantes que siguen. La retrollamada se llama de la
   siguiente manera:

      callback(file, mask)

Widget.tk.deletefilehandler(file)

   Anula el registro de un gestor de archivos.

_tkinter.READABLE
_tkinter.WRITABLE
_tkinter.EXCEPTION

   Constantes utilizadas en los argumentos *mask*.
