"tkinter" --- Interface de Python para Tcl/Tk
*********************************************

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

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

El paquete "tkinter" ("interfaz Tk") es la interfaz por defecto de
Python para el toolkit de la GUI Tk. Tanto Tk como "tkinter" están
disponibles en la mayoría de las plataformas Unix, así como en
sistemas Windows (Tk en sí no es parte de Python, es mantenido por
ActiveState).

Ejecutar "python -m tkinter" desde la línea de comandos debería abrir
una ventana que demuestre una interfaz Tk simple para saber si
"tkinter" está instalado correctamente en su sistema. También muestra
qué versión de Tcl/Tk está instalada para que pueda leer la
documentación de Tcl/Tk específica de esa versión.

Ver también:

  Documentación Tkinter:

  Recursos de Python Tkinter
     La Guía de temas de Python Tkinter proporciona una gran cantidad
     de información sobre cómo usar Tk desde Python y enlaces a otras
     fuentes de información sobre Tk.

  TKDocs
     Extensive tutorial plus friendlier widget pages for some of the
     widgets.

  Tkinter 8.5 reference: a GUI for Python
     Material online de referencia.

  Documentos de Tkinter de effbot
     Referencia en línea para Tkinter producida por effbot.org.

  Programming Python
     Libro de Mark Lutz, que cubre Tkinter excelentemente bien.

  Modern Tkinter for Busy Python Developers
     Libro de Mark Roseman sobre la construcción de interfaces
     gráficas de usuario atractivas y modernas con Python y Tkinter.

  Python and Tkinter Programming
     Libro de John Grayson (ISBN 1-884777-81-3).

  Documentación de Tcl/Tk:

  Comandos Tk
     La mayoría de los comandos están disponibles como "tkinter" o
     "tkinter.ttk". Cambie a '8.6' para que coincida con la versión de
     su instalación Tcl/Tk.

  Páginas recientes del manual de Tcl/Tk
     Manual reciente de Tcl/Tk en www.tcl.tk.

  Página de Inicio de ActiveState Tcl
     El desarrollo de Tk/Tcl se está llevando a cabo en gran medida en
     ActiveState.

  Tcl and the Tk Toolkit
     Libro de John Ousterhout, el inventor de Tcl.

  Practical Programming in Tcl and Tk
     Enciclopedia de Brent Welch.


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

La mayoría de las veces "tkinter" es todo lo que realmente necesita,
pero también hay disponible varios módulos adicionales. La interfaz Tk
se encuentra en un módulo binario llamado "_tkinter". Este módulo
contiene la interfaz de bajo nivel para Tk, y nunca debe ser utilizado
directamente por los desarrolladores. Por lo general, es una
biblioteca compartida (o DLL), pero en algunos casos puede estar
vinculada estáticamente con el intérprete de Python.

Además del módulo de interfaz Tk, "tkinter" incluye varios módulos de
Python, "tkinter.constants" es uno de los más importantes. Al Importar
"tkinter" importará automáticamente "tkinter.constants", por lo tanto,
para usar Tkinter todo lo que se necesita es una simple declaración
import:

   import tkinter

O, más a menudo:

   from tkinter import *

class tkinter.Tk(screenName=None, baseName=None, className='Tk', useTk=1)

   La clase "Tk" se instancia sin argumentos. 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.

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

   The "Tcl()" function is a factory function which creates an object
   much like that created by the "Tk" class, except that it does not
   initialize the Tk subsystem.  This is most often useful when
   driving the Tcl interpreter in an environment where one doesn't
   want to create extraneous toplevel windows, or where one cannot
   (such as Unix/Linux systems without an X server).  An object
   created by the "Tcl()" object can have a Toplevel window created
   (and the Tk subsystem initialized) by calling its "loadtk()"
   method.

Otros módulos que proporcionan soporte Tk incluyen:

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

"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.simpledialog"
   Cuadros de diálogo simples y funciones útiles.

"tkinter.dnd"
   Soporte de arrastrar y soltar (*drag-and-drop*) para "tkinter".
   Esto es experimental y ya no se mantendrá cuando sea reemplazado
   por Tk DND.

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


Tkinter Life Preserver
======================

Esta sección no está diseñada para ser un tutorial exhaustivo sobre Tk
o Tkinter. Más bien, está pensado como un espacio intermedio que
proporciona una orientación introductoria en el sistema.

Créditos:

* Tk fue escrito por John Ousterhout mientras estaba en Berkeley.

* Tkinter fue escrito por Steen Lumholt y Guido van Rossum.

* Esta guía de supervivencia fue escrita por Matt Conway en la
  Universidad de Virginia.

* The HTML rendering, and some liberal editing, was produced from a
  FrameMaker version by Ken Manheimer.

* Fredrik Lundh elaboró ​​y revisó las descripciones de la interfaz de
  clase para actualizarlas con Tk 4.2.

* Mike Clarkson convirtió la documentación a LaTeX y compiló el
  capítulo de Interfaz de usuario del manual de referencia.


Cómo usar esta sección
----------------------

This section is designed in two parts: the first half (roughly) covers
background material, while the second half can be taken to the
keyboard as a handy reference.

Al tratar de responder preguntas sobre cómo hacer "esto o aquello", a
menudo es mejor descubrir cómo hacerlo en Tk y luego convertirlo a la
función correspondiente "tkinter". Los programadores de Python a
menudo pueden adivinar el comando Python correcto consultando la
documentación de Tk. Esto significa que para usar Tkinter deberá
conocer un poco sobre Tk. Este documento no puede cumplir esa función,
por lo que lo mejor que podemos hacer es señalarle la mejor
documentación que existe. Aquí hay algunos consejos:

* Los autores sugieren encarecidamente obtener una copia de las
  páginas del manual de Tk. Específicamente, las páginas del
  directorio "manN" son las más útiles. Las páginas del manual "man3"
  describen la interfaz C para la biblioteca Tk y, por lo tanto, no
  son especialmente útiles para los desarrolladores de scripts.

* Addison-Wesley publica un libro llamado *"Tcl and the Tk Toolkit"*
  de John Ousterhout (ISBN 0-201-63337-X) que es una buena
  introducción a Tcl y Tk para novatos. El libro no es exhaustivo y
  para muchos detalles difiere de las páginas del manual.

* "tkinter/__init__.py" es el último recurso para la mayoría, pero
  puede ser un buen lugar para ir cuando nada más tiene sentido.


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

   import tkinter as tk

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

       def create_widgets(self):
           self.hi_there = tk.Button(self)
           self.hi_there["text"] = "Hello World\n(click me)"
           self.hi_there["command"] = self.say_hi
           self.hi_there.pack(side="top")

           self.quit = tk.Button(self, text="QUIT", fg="red",
                                 command=self.master.destroy)
           self.quit.pack(side="bottom")

       def say_hi(self):
           print("hi there, everyone!")

   root = tk.Tk()
   app = Application(master=root)
   app.mainloop()


Una (muy) rápida mirada a Tcl/Tk
================================

La jerarquía de clases parece complicada, pero en la práctica, los
programadores de aplicaciones casi siempre se refieren a las clases en
la parte inferior de la jerarquía.

Notas:

* Estas clases se proporcionan con el propósito de organizar ciertas
  funciones en un solo un espacio de nombres. No están destinadas a
  ser instanciadas independientemente.

* La clase "Tk" está destinada a ser instanciada solo una vez en una
  aplicación. Los desarrolladores no necesitan crear una instancia
  explícitamente. El sistema crea una cada vez que se instancia
  cualquiera de las otras clases.

* The "Widget" class is not meant to be instantiated, it is meant only
  for subclassing to make "real" widgets (in C++, this is called an
  'abstract class').

Para hacer uso de este material de referencia, habrá momentos en los
que necesitará saber cómo leer pasajes cortos de Tk y cómo identificar
las diversas partes de un comando Tk. Consulte la sección Mapeo básico
de Tk en Tkinter para los equivalentes "tkinter" de lo que se muestra
a continuación.

Los scripts Tk son programas Tcl. Como todos los programas Tcl, los
scripts Tk son solo listas de tokens separados por espacios. Un widget
Tk es solo su *clase*, las *opciones* que ayudan a configurarlo y las
*acciones* que lo hacen hacer cosas útiles.

Para hacer un widget en Tk, el comando siempre tiene la siguiente
forma:

   classCommand newPathname options

*classCommand*
   denota qué tipo de widget hacer (un botón, una etiqueta, un
   menú...)

*newPathname*
   es el nuevo nombre para este widget. Todos los nombres en Tk deben
   ser únicos. Para ayudar a aplicar esto, los widgets en Tk se
   nombran con *rutas*, al igual que los archivos en un sistema de
   archivos. El widget de nivel superior, el *root*, se llama "."
   (punto) y los elementos secundarios están delimitados por más
   puntos. Por ejemplo, ".myApp.controlPanel.okButton" podría ser el
   nombre de un widget.

*options*
   configurar la apariencia del widget y, en algunos casos, su
   comportamiento. Las opciones vienen en forma de una lista de
   parámetros y valores. Los parámetros están precedidas por un '-',
   como los parámetros en una shell de Unix, y los valores se ponen
   entre comillas si son más de una palabra.

Por ejemplo:

   button   .fred   -fg red -text "hi there"
      ^       ^     \______________________/
      |       |                |
    class    new            options
   command  widget  (-opt val -opt val ...)

Una vez creado, la ruta de acceso al widget se convierte en un nuevo
comando. Este nuevo *comando de widget* es el identificador para que
el nuevo widget realice alguna *acción*. En C, expresarías esto como
*someAction(fred, someOptions)*; en C++, expresarías esto como
*fred.someAction(someOptions)*, y en Tk:

   .fred someAction someOptions

Tenga en cuenta que el nombre del objeto, ".fred", comienza con un
punto.

Como era de esperar, los valores legales para *someAction* dependerán
de la clase del widget: ".fred disable" funciona si *fred* es un botón
(se atenúa), pero no funciona si *fred* es una etiqueta (la
desactivación de etiquetas no es compatible con Tk).

Los valores legales de *someOptions* dependen de la acción. Algunas
acciones, como "disable", no requieren argumentos; otras, como el
comando "delete" de un cuadro de entrada de texto, necesitarían
argumentos para especificar qué rango de texto eliminar.


Mapeo básico de Tk en Tkinter
=============================

Los comandos de clase en Tk corresponden a constructores de clase en
Tkinter.:

   button .fred                =====>  fred = Button()

The master of an object is implicit in the new name given to it at
creation time.  In Tkinter, masters are specified explicitly.

   button .panel.fred          =====>  fred = Button(panel)

The configuration options in Tk are given in lists of hyphened tags
followed by values.  In Tkinter, options are specified as keyword-
arguments in the instance constructor, and keyword-args for configure
calls or as instance indices, in dictionary style, for established
instances.  See section Configuración de opciones on setting options.

   button .fred -fg red        =====>  fred = Button(panel, fg="red")
   .fred configure -fg red     =====>  fred["fg"] = red
                               OR ==>  fred.config(fg="red")

In Tk, to perform an action on a widget, use the widget name as a
command, and follow it with an action name, possibly with arguments
(options).  In Tkinter, you call methods on the class instance to
invoke actions on the widget.  The actions (methods) that a given
widget can perform are listed in "tkinter/__init__.py".

   .fred invoke                =====>  fred.invoke()

Para pasar el widget al empaquetador (que administra el diseño de la
pantalla) en Tk, llame al comando *pack* con argumentos opcionales. En
Tkinter, la clase *Pack* tiene todas estas funcionalidades y las
diferentes formas del comando *pack* se implementan como métodos.
Todos los widgets en "tkinter" son subclases del empaquetador, por lo
que heredan todos los métodos de empaquetado. Consulte la
documentación del módulo "tkinter.tix" para obtener más información
sobre el administrador de diseño de formularios.

   pack .fred -side left       =====>  fred.pack(side="left")


Cómo se relacionan Tk y Tkinter
===============================

De arriba para abajo:

Tu aplicación (Python)
   Una aplicación Python hace una llamada "tkinter".

tkinter (paquete de Python)
   Esta llamada (por ejemplo, crear un widget de botón) se implementa
   en el paquete "tkinter", que está escrito en Python. Esta función
   de Python analizará los comandos y los argumentos y los convertirá
   en una forma que los haga ver como si vinieran de un script Tk en
   lugar de un script Python.

_tkinter (C)
   Estos comandos y sus argumentos se pasarán a una función C en el
   módulo de extensión "_tkinter" -obsérvese el guión bajo-.

Tk Widgets (C y Tcl)
   Esta función en C puede realizar llamadas a otros módulos C,
   incluidas las funciones de C que forman la biblioteca Tk. Tk se
   implementa usando C y un poco de Tcl. La parte Tcl de los widgets
   Tk se usa para vincular ciertos comportamientos predeterminados de
   los widgets, y se ejecuta una vez cuando se importa el paquete
   Python "tkinter" (el usuario nunca ve esta etapa).

Tk (C)
   La parte Tk de los widgets Tk implementa el mapeo final a...

Xlib (C)
   la biblioteca Xlib para dibujar elementos gráficos en la pantalla.


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       | option name for database lookup   | "'relief'"     |
+---------+-----------------------------------+----------------+
| 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 - their mutual *master*.  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.

El tamaño de cualquier widget *master* está determinado por el tamaño
del "widget esclavo" interno. El empaquetador se usa para controlar
dónde se colocará el widget esclavo en el widget *maestro* de destino.
Para lograr el diseño deseado, puede empaquetar el widget en un marco
y luego empaquetar ese marco en otro. Además, una vez empaquetado, la
disposición se ajusta dinámicamente de acuerdo con los cambios de
configuración posteriores.

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*
   Tipo de anclaje. Indica dónde debe colocar el empaquetador a cada
   esclavo en su espacio.

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

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

*ipadx* y *ipady*
   Una distancia que designa el relleno interno a cada lado del widget
   esclavo.

*padx* y *pady*
   Una distancia que designa el relleno externo a cada lado del widget
   esclavo.

*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.

Desafortunadamente, en la implementación actual de "tkinter" no es
posible entregar una variable arbitraria de Python a un widget a
través de una opción "variable" o "textvariable" . Los únicos tipos de
variables para las cuales esto funciona son variables que son
subclases de la clase Variable, definida en "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
---------------------

En Tk hay un comando útil, "wm", para interactuar con el gestor de
ventanas. Las opciones del comando "wm" le permiten controlar cosas
como títulos, ubicación, iconos de ventana y similares. En "tkinter",
estos comandos se han implementado como métodos de la clase "Wm". Los
widgets de *Toplevel* son subclases de "Wm", por lo que se puede
llamar directamente a los métodos de "Wm".

Para acceder a la ventana *Toplevel* que contiene un objeto gráfico
dado, a menudo puede simplemente referirse al padre de este objeto
gráfico. Por supuesto, si el objeto gráfico fue empaquetado dentro de
un marco, el padre no representará la ventana de nivel superior. Para
acceder a la ventana de nivel superior que contiene un objeto gráfico
arbitrario, puede llamar al método "_root()" . Este método comienza
con un subrayado para indicar que esta función es parte de la
implementación y no de una interfaz a la funcionalidad Tk.

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
   There are eight built-in, named bitmaps: "'error'", "'gray25'",
   "'gray50'", "'hourglass'", "'info'", "'questhead'", "'question'",
   "'warning'".  To specify an X bitmap filename, give the full path
   to the file, preceded with an "@", as in
   ""@/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
   Colors can be given as the names of X colors in the rgb.txt file,
   or as strings representing RGB values in 4 bit: ""#RGB"", 8 bit:
   ""#RRGGBB"", 12 bit" ""#RRRGGGBBB"", or 16 bit ""#RRRRGGGGBBBB""
   ranges, where R,G,B here represent any legal hex digit.  See page
   160 of Ousterhout's book for details.

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
   Screen distances can be specified in either pixels or absolute
   distances. Pixels are given as numbers and absolute distances as
   strings, with the trailing character denoting units: "c" for
   centimetres, "i" for inches, "m" for millimetres, "p" for printer's
   points.  For example, 3.5 inches is expressed as ""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
   Los valores legales son las cadenas de caracteres: ""left"",
   ""center"", ""right"", y ""fill"".

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
   is a Python function, taking one argument, to be invoked when the
   event occurs. An Event instance will be passed as the argument.
   (Functions deployed this way are commonly known as *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)

Notice how the widget field of the event is being accessed in the
"turn_red()" callback.  This field contains the widget that caught the
X event.  The following table lists the other event fields you can
access, and how they are denoted in Tk, which can be useful when
referring to the Tk man pages.

+------+-----------------------+------+-----------------------+
| 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 *índice*. 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.)
   El widget entrada tiene una opción para referirse a la posición de
   los caracteres del texto que se muestra. Puede acceder a estos
   puntos especiales en un widget de texto utilizando la siguiente
   función de "tkinter":

Í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).

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 allows you to register and unregister a callback function which
will be called from the Tk mainloop when I/O is possible on a file
descriptor. Only one handler may be registered per file descriptor.
Example code:

   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*.
