Cuadros de Diálogo ya Definidos.

Como vimos en el capítulo anterior, las ventanas de diálogo son aquellas ventanas hijas que surgen de la principal o ventana de la aplicación. Pueden ser modales (las que bloquean las demás hasta que se cierre el diálogo) o no Modales (Permanecen abiertas sin interferir con las demás y se puede interactuar independiente con ellas.

También vimos ejemplos de como crear ventanas de dialogo de cada tipo.

En este capitulo vamos a ver como usar ventanas de dialogo que ya están presentes en los sistemas operativos, como por ejemplo un cuadro de diálogo, y que a diferencia de lo que hicimos en el capítulo anterior ya están definidas con lo que solo nos queda utilizarlas a nuestro gusto.

1.- Cuadro de diálogo Estándar.

Un cuadro de diálogo es una ventana con un título, un mensaje, un ícono y uno o más botones. Se utilizan para informar al usuario sobre alguna cuestión o bien exhortarlo a que tome alguna decisión.

Las funciones para generar cuadros de diálogo en una aplicación Tkinter están en el módulo tkinter.messagebox y son las siguientes:

• showinfo()
• showwarning()
• showerror()
• askquestion()
• askyesno()
• askokcancel()
• askyesnocancel()
• askretrycancel()

Todos reciben los argumentos message y title, que indican el mensaje y el título del cuadro de diálogo.

Por ejemplo:

1. from tkinter import messagebox
3. messagebox.showinfo(message="Mensaje", title="Título")

En Guizero también podemos usar directamente estos módulos (si previamente has importado messsagebox) aunque también incorpora diferentes métodos propios en el menú del widget window que hacen lo mismo. Puedes encontrar una relación de todos (Pop-ups) los que se pueden usar, así como ejemplos en su manual.

Veamos un ejemplo en tkinter:

''' Cuadro de diálogo standard  con tkinter'''

from tkinter import *
from tkinter.messagebox import *

def callback():
    if askyesno('Confirmación', '¿Estás seguro de que quieres salir?'):
        showwarning('Si', 'Salir aún no esta implementado')
    else:
        showinfo('No', 'Salir ha sido cancelado')

msg_error = '¡Lo siento, no se permite el Spam!'
Button(text='Salir', command=callback).pack(fill=X)
Button(text='Spam', command=lambda: showerror('Error', msg_error)).pack(fill=X)
mainloop()

El cual muestra las siguientes ventanas de diálogo:

En Guizero.

''' Cuadro de diálogo standard con Guizero '''
# Importamos la librería Guizero
from guizero import *

def call_back():
    # Ventana de confirmación si o no
    if yesno('Confirmación', '¿Estás seguro de que quieres salir?'):
        # Ventana de advertencia
        warn('Si', 'Salir aún no esta implementado')
    else:
        # Ventana de información
        info('No', 'Salir ha sido cancelado')

raiz = App(height=100, width=60)

# Creamos una ventana principal con dos botones. (Salir y Error)
b1 = PushButton(raiz, command=call_back, text='Salir')
# Ventana de error
b2 = PushButton(raiz, text="Spam", command=lambda: raiz.error("Error", "¡Lo siento no se permite el Spam!"))

raiz.display()

Mientras que el cuadro de diálogo está abierto el resto de los widgets no responden a ningún evento, como por ejemplo pulsar un botón. (ventana modal)

El icono mostrado en cada ventana es provisto por el sistema operativo donde lo ejecutemos, aunque siempre está en relación con el mensaje que quiere mostrar el cuadro. Por ejemplo el icono de showinfo() es por lo general azul e indica información, el de showwarning() es amarillo o naranja denotando advertencia y el showerror() es rojo para mostrar un error.

En estas tres funciones showinfo(), showwarning() y showerror() el valor de retorno es siempre el string "ok", independientemente de si se presiono el botón o se cerró la ventana. 

Las funciones de interrogación retornan True o False dependiendo del botón que se pulse. Veámoslo con un ejemplo.

Tkinter.

from tkinter import *
from tkinter import messagebox

# Si no creas la ventana principal por defecto se utiliza la master en donde si no se 
especifica se colocan el resto de las ventanas de diálogo.

# Retornan True o False.
print(messagebox.askyesno(message="¿Desea continuar?", title="Título"))
print(messagebox.askokcancel(message="¿Desea continuar?", title="Título"))
print(messagebox.askretrycancel(message="¿Desea reintentar?", title="Título"))

Dará como resultado.

True
False
True

Guizero.

Para que veas que en Guizero se pueden usar los elementos de Tkinter vamos a usar el mismo código pero importando todos los elementos de Guizero (que en realidad importa todos los de Tkinter)

from guizero import *


# Retornan True o False.
print(messagebox.askyesno(message="¿Desea continuar?", title="Título"))
print(messagebox.askokcancel(message="¿Desea continuar?", title="Título"))
print(messagebox.askretrycancel(message="¿Desea reintentar?", title="Título"))

El resultado es el mismo.

askquestion es similar a askyesno(), pero el resultado al ejecutarse, dependiendo del botón que se pulse es "yes" or "no"

from guizero import *
# Retorna "yes" o "no".
print(messagebox.askquestion(message="¿Desea continuar?", title="Título"))

Dependiendo del botón pulsado la salida será "yes" or "no"

Por último, askyesnocancel() despliega los botones «Sí», «No» y «Cancelar», y los valores de retorno posibles son True, False y None, respectivamente.

from guizero import *
# Retorna "True" o "False" o "None".
print(messagebox.askyesnocancel(message="¿Desea continuar?", title="Título"))

Si cerramos la ventana el valor retornado será "None" ya que equivale al botón cancelar.

Otros Cuadros de diálogo de tkinter.

Como estos cuadros de dialogo se importan desde  librerías de Tkinter solo utilizaremos código de este.

Tkinter Open File.

- askopenfilename o Abrir Archivo:

from tkinter import *
from tkinter.filedialog import askopenfilename

print(askopenfilename(title='Abrir archivo', initialdir="/home/chema",
                      filetypes=[('All files', '*'),('jpeg files', '*.jpg')]))

Si seleccionamos un archivo y presionamos el botón Abrir nos devolverá la ruta completa del mismo. Por el contrario si presionamos cancelar nos devolverá una cadena vacía.

Algunas opciones que le podemos poner son:

initialdir -> Establece el directorio inicial que se mostrará en el cuadro de diálogo al ejecutarlo.

filetypes -> que archivos apararecerán en la casilla Archivos de Tipo. Es decir que tipo de archivos nos permitirá abrir. Se especifican en una lista con tuplas en su interior. Cada tupla tendrá dos string, el primero indicará el título y el segundo la extensión a buscar:

filetypes=[('All Filers', '*')] -> Para cualquier tipo de archivo

filetypes=[('jpeg files', '*,jpg')] -> Para archivos con formato jpg

Tkinter Save File.

- asksaveasfilename o Guardar Archivo.

from tkinter import *
from tkinter.filedialog import asksaveasfilename


print(asksaveasfilename(initialdir="/", title="Guardar Archivo", 
                    filetypes=[("jpeg files", "*.jpg"), ("all files", "*.*")]))

Muestra al usuario un cuadro clásico de guardar archivo.  Al introducir el nombre del archivo nos devolverá la ruta completa del mismo. Si le damos al botón cancelar nos devolverá una cadena vacia.

Tkinter Open Directory.

askdirectory o Selección de directorio.

Funciona igual que los cuadros anteriores. Las salida que nos devolverá es el directorio seleccionado.

from tkinter import filedialog
from tkinter import *

print(filedialog.askdirectory(initialdir = "/",title = "Selecciona Directorio"))

Tkinker, otras ventanas de diálogo.

Igual que hemos visto anteriormente, cada cuadro de diálogo hay que importarlo previamente usando la correspondiente librería. 

- askfloat, askinteger, askstring. 

askfloat nos muestra un cuadro de dialogo que permite introducir únicamente un número entero o flotante, ya que si no dará un error. La salida es un número de punto flotante.

from tkinter import *
from tkinter.simpledialog import askfloat

raiz=Tk()
print(askfloat('Entry', 'Introduce un número: '))

askinteger nos permite también mostrar una ventana de diálogo para introducir únicamente un número entero y devuelve un número entero.

from tkinter import *
from tkinter.simpledialog import askinteger

raiz=Tk()
print(askinteger('Entry', 'Introduce un número: '))

askstring,  muestra un cuadro de diálogo que nos permite introducir una cadena de caracteres y lo que nos devuelve es precisamente eso, un string de Python.

from tkinter import *
from tkinter.simpledialog import askstring

raiz=Tk()
# .withdraw() oculta la ventana.
raiz.withdraw()
print(askstring('Entry', 'Introduce una frase: '))

askcolor. Devuelve el color RGB y la cadena hexadecimal.

from tkinter import *
from tkinter.colorchooser import askcolor

raiz=Tk()
raiz.withdraw()
print(askcolor())

Salida:

((102, 153, 92), '#66995c')

Puedes encontrar el código de los ejemplos en el siguiente enlace.