Caja de texto (Entry) en Tcl/Tk (tkinter)

Caja de texto (Entry) en Tcl/Tk (tkinter)



Una caja de texto permite al usuario ingresar cualquier texto de una línea. En Tcl/Tk está representada a través de la clase ttk.Entry, que a su vez hereda la funcionalidad de un control más primitivo llamado tk.Entry.

Para crear una caja de texto, encontes, vamos a crear una instancia de la primera clase.

import tkinter as tk
from tkinter import ttk

root = tk.Tk()
root.config(width=300, height=200)
# Crear caja de texto.
entry = ttk.Entry(root)
# Posicionarla en la ventana.
entry.place(x=50, y=50)
root.mainloop()

Caja de texto en Tcl/Tk

Como todos los controles, el primer argumento indica el control padre; en este caso, la ventana (root).

Para especificar la justificación del texto, esto es, si debe alinearse a la izquierda, derecha o el centro, indicamos el parámetro justify, cuyos valores pueden ser, respectivamente, tk.LEFT (por defecto), tk.RIGHT y tk.CENTER.

# Justificar el texto a la derecha.
entry = ttk.Entry(root, justify=tk.RIGHT)

Podemos hacer que la caja de texto muestre un glifo en particular cuando queremos ocultar el texto a simple vista; por ejemplo, si el control es empleado para escribir una contraseña.

# Mostrar asteriscos en lugar del texto original.
entry = ttk.Entry(root, show="*")

A través del parámetro width indicamos el ancho del control, pero no en píxeles, sino en caracteres. Por ejemplo, el siguiente código establece un ancho suficiente para visualizar una línea de 10 caracteres completamente.

entry = ttk.Entry(root, width=10)

Si el texto excede la cantidad de caracteres especificados, el control siempre muestra una porción de él de dicho tamaño, según la posición del cursor. Puesto que el ancho de cada carácter puede variar aun en la misma fuente, el valor de width opera siempre como una aproximación y no como un valor absoluto.

La caja de texto puede iniciarse como deshabilitada (el usuario no podrá escribir en ella y aparecerá sombreada) usando el parámetro state.

entry = ttk.Entry(root, state=tk.DISABLED)

Luego podremos habilitarla nuevamente restableciendo este parámetro vía el método config().

entry.config(state=tk.NORMAL)

Un estado intermedio es "readonly" (solo lectura), en el que el usuario visualiza el control normalmente pero no puede escribir en él.

entry = ttk.Entry(root, state="readonly")

Esto es especialmente útil cuando se quiere prohibir la inserción de texto pero mantener la opción de copiado o los menús contextuales.

Operaciones principales

Ahora bien, una vez creado, las operaciones principales son las siguientes: inserción, obtención, selección y eliminación de texto. Y de éstas, la más frecuente es la segunda, por cuanto nos permite saber qué escribió el usuario de nuestra aplicación. Para las operaciones de copiar, cortar y pegar, véase este artículo.

Empecemos, entonces, por cómo obtener lo que el usuario ha escrito en la caja de texto llamando al método get().

print(entry.get())

Por ejemplo, el siguiente código imprime en la consola el texto ingresado al presionar un botón.

entry.insert(0, "Hola mundo!")
entry.place(x=50, y=50)
button = ttk.Button(root, text="Obtener texto",
    command=lambda: print(entry.get()))
button.place(x=50, y=100)

Para añadir un texto empleamos insert(), que toma como primer argumento una posición y como segundo una cadena.

entry.insert(0, "¡Hola, mundo!")

Este código es similar a:

entry.insert(0, "¡Hola,")
entry.insert(6, " mundo!")

Todas las operaciones en Tk que requieran una posición aceptan la constante tk.END, que representa el final del texto. En nuestro caso, tk.END es equivalente a len(entry.get()). Por esto, el siguiente código también consigue el mismo resultado que los dos anteriores.

entry.insert(0, "¡Hola,")
entry.insert(tk.END, " mundo!")

La eliminación de un texto o una parte de él se consigue a través del método delete(), pasándole como argumentos los índices de inicio y fin.

# Elimina el texto completo.
entry.delete(0, tk.END)

De forma análoga opera select_range(), que selecciona el texto desde una posición hasta otra. Por ejemplo, el siguiente código selecciona la palabra “mundo”.

entry.insert(0, "¡Hola, mundo!")
# Seleccionar desde el carácter 7 hasta el 12.
entry.select_range(7, 12)
# Enviar el foco a la caja de texto para hacer efectiva
# la selección.
entry.focus()

Para obtener la posición del cursor en la caja de texto, llamamos al método index() con la constante tk.INSERT.

print(entry.index(tk.INSERT))

Y para establecer la posición:

entry.insert(0, "¡Hola, mundo!")
# Ubica el cursor antes de la "m".
entry.icursor(7)
# Envía el foco.
entry.focus()

Tk no provee una función específica para retornar el texto seleccionado, pero haciendo uso del método index() junto con las constantes tk.SEL_FIRST y tk.SEL_LAST ─que retornan los índices de inicio y fin de la selección─ podemos construirla manualmente.

entry.insert(0, "¡Hola, mundo!")

def get_selection():
    # Comprobar primero que haya una selección.
    if entry.select_present():
        # Obtener los índices del inicio y fin de la selección
        first = entry.index(tk.SEL_FIRST)
        last = entry.index(tk.SEL_LAST)
        print(entry.get()[first:last])
    else:
        print("No hay selección.")

button = ttk.Button(root, text="Obtener selección",
                    command=get_selection)

(El método select_present() retorna True o False según haya un texto seleccionado o no).

Asociando una variable

Cuando una caja de texto es simplemente empleada para recibir un texto ingresado por el usuario, será suficiente con llamar al método get() para obtenerlo cuando sea necesario tal como lo expusimos anteriormente. Pero si nuestro programa requiere cierta funcionalidad bilateral ─se estará tanto insertando texto como obteniendo el ingresado por el usuario─ a menudo es más conveniente asociar una variable.

Tk nos provee la clase tk.StringVar() para crear objetos que actúan como una cadena, con la excepción que para asignarle un valor usamos el método set() y, para obtenerlo, get().

var = tk.StringVar()
var.set("¡Hola, mundo!")
print(var.get())

Ahora bien, podemos asociar una variable de estas características a una caja de texto al momento de su creación, vía el parámetro textvariable.

entry_var = tk.StringVar()
entry = ttk.Entry(root, textvariable=entry_var)

Así, llamadas a entry_var.set() modificarán el contenido de la caja de texto y, del mismo modo, los cambios efectuados por el usuario en el control afectarán el resultado de entry_var.get().



1 comentario.

  1. import tkinter as tk
    from tkinter import ttk
    root = tk.Tk()
    root.config(width=300, height=200)
    # Crear caja de texto.
    entry = ttk.Entry(root)
    # Posicionarla en la ventana.
    entry.place(x=50, y=50)
    root.mainloop()

    asi se puede acer tambine

Deja un comentario