PDF de programación - Tutorial wxPython + wxGlace

Tutorial wxPython + wxGlade

John Alexis Guerra Gómez

Tutorial wxPython + wxGlade
por John Alexis Guerra Gómez

Tabla de contenidos

1. Introducción ...........................................................................................................................................1
2. ¿Cómo empezar? ...................................................................................................................................2
2.1. Nuestra primer ventana ...............................................................................................................3
3. Simplificando el trabajo con el wxGlade .............................................................................................5
3.1. Iniciando el wxGlade ..................................................................................................................5
3.2. Nuestra primer ventana ...............................................................................................................5
3.3. Cambiando parámetros ...............................................................................................................6
3.4. Generar Código ...........................................................................................................................6
3.5. Entendiendo el código generado .................................................................................................7
4. ¿Cómo organizar los widgets?, una introducción a los sizers ............................................................9
4.1. Estático vs. Dinámico .................................................................................................................9
4.2. Los sizers.....................................................................................................................................9
4.3. Los sizers en wxGlade...............................................................................................................10
4.4. ¿Cómo hacer que la aplicación haga algo? ...............................................................................12
4.4.1. Agregando eventos al código........................................................................................12
4.4.2. Saludando con ventanas................................................................................................15

iii

Lista de figuras

2-1. Mira mamá una ventana que saluda!....................................................................................................4
3-1. El inicio del wxGlade, ventana de íconos (arriba a la izquierda), ventana de propiedades (abajo),

ventana de árbol (derecha) .................................................................................................................5
3-2. Crear una ventana.................................................................................................................................5
3-3. Cambiar el título de la ventana.............................................................................................................6
3-4. Generar Código ....................................................................................................................................6
4-1. Un cuadro de texto .............................................................................................................................10
4-2. VentanaSaludona con un cuadro de texto y un botón.........................................................................11
4-3. Un saludo para tí.................................................................................................................................17

iv

Capítulo 1. Introducción

El objetivo de este tutorial es sentar las bases para el desarrollo de aplicaciones GUI (Graphic User
Interface) usando la librería wxPython (http://www.wxpython.org) y el lenguaje de programación Python
(http://www.python.org), utilizando la ayuda del diseñador de interfaces wxGlade
(http://wxglade.sourceforge.net).

Se espera que el lector tenga conocimientos básicos en Python, y en caso de que aún no los tenga, le
recomendamos revisar el tutorial oficial de python (http://www.python.org/doc/).

Este tutorial fue diseñado para realizarse utilizando Python >2.3, wxPython >2.6 y wxGlade >0.4.

1

Capítulo 2. ¿Cómo empezar?

Para empezar a realizar una aplicación con wxwindows necesitamos seguir los siguientes pasos:

•

Incluir la librería, para esto bastará agregar el siguiente fragmento de código:

import wx

Aviso

Al realizar esta instrucción estamos incluyendo un módulo completo que
incluye todos los elementos del wxpython, esta característica es
relativamente reciente y en internet aún se encuentran tutoriales que utilizan
widgets cómo wxApp o wx.wxApp, este modo de utilizar ha quedado en
desuso y se recomienda utilizar los widgets usando el nuevo módulo, es decir
que por ejemplo para acceder a la clase App que en C++ sería wxApp se
debería usar wx.App

• La librería wxPython está completamente basada en la teoría de programación orientada objetos, es

por esto que para poder crear cualquier programa siempre se necesita “sobrecargar” el “método”
OnInit de una clase clase de tipo wx.App (es decir que puede ser de una clase que herede de ella, para
hacer esto basta con escribir esto:

class MiApp(wx.App):
def OnInit(self):

return True

Este fragmento de código crea una clase llamada MiApp, que hereda de la clase wx.App cuyo único
método, por el momento es OnInit, método éste que será llamado en el momento que iniciemos
nuestra aplicación, es importante tener en cuenta que este método debe retornar True.

Aviso

Todo programa en wxPython debe tener por lo menos una instancia de la
clase wx.App, que puede ser una clase que herede de ella, o por ejemplo
una creada con el método wx.PySimpleApp, que crea una wx.App sencilla.

• Una vez esté lista la clase debemos instanciarla, y hacer un llamado al método MainLoop, que es

heredado de la clase wx.App. Este método se encargará de entregarle el control de programa al
wxPython permitiendo la captura de eventos (más sobre esto más adelante) entre otras cosas. Es decir
que necesitamos un código cómo:

app=MiApp()
app.MainLoop()

2

Capítulo 2. ¿Cómo empezar?

Aviso

No se debe colocar código después de un MainLoop, ya que este llamado
bloque la aplicación al entregarle el control al wxPython, y cualquier
instrucción que se coloque luego de este llamado será ejecutada solo
cuando termine la aplicación.

Hasta el acá ya tendríamos una aplicación en wxPython completa, pero aunque la ejecutáramos, y no
saliera ningún error, no aparecería nada en la pantalla, y ¿qué pasó con el “hola mundo”?, pues bueno,
para poder que nuestra aplicación muestre algo necesitamos crear una ventana

2.1. Nuestra primer ventana

Para crear ventanas debemos crear instancias de la clase wx.Frame, un ejemplo de un programa que
muestre una ventana sencilla que salude en su título sería el siguiente:

ventana_saludona.py (ejemplos/ventana_saludona.py)

#-*- coding: iso8859-1 -*-
import wx

class VentanaSaludona(wx.Frame):

def __init__(self):

#Llamo al constructor de wx.Frame
wx.Frame.__init__(self,

None, #El padre de esta ventana
-1, #Un número para identificarla
u"Hola ¿cómo estás?" #El título de la ventana
)

#Le digo a la ventana que se muestre
self.Show(True)

class MiApp(wx.App):

def OnInit(self):

#Creo una instancia de la ventana como atributo de miApp
self.ventana=VentanaSaludona()
#Le digo a miApp quien es la Ventana Principal
self.SetTopWindow(self.ventana)
return True

app=MiApp()
app.MainLoop()

Este programa crea una nueva clase llamada VentanaSaludona que hereda de la clase wx.Frame, de esta
clase solo hemos definido su constructor, que lo único que hace es llamar al constructor de la clase

3

Capítulo 2. ¿Cómo empezar?

wx.Frame, pasándole 3 parámetros: el primero es el padre de la ventana, en wxPython todo widget tiene
una ventana padre, pero como esta es nuestra ventana padre será la excepción (None será su padre); el
segundo parámetro es un número que usaremos para identificar la ventana, como tampoco necesitamos
identificarla por ahora le asignaremos -1 y por último recibe una cadena (unicode, por eso tiene una u
antes de las comillas) que será el título. Para conocer más datos de los parámetros del constructor de la
clase wxFrame se puede consultar la documentación oficial del wxPython, este debe ser el procedimiento
a seguir cada que queramos conocer algo más de la librería. Por último le decimos a la ventana que se
muestre utilizando el método Show con un parámetro True, si este método es llamado con un valor False
la ventana se ocultará (no se destruirá, eso es otra cosa) y saldrá de la vista del usuario aunque estará
disponible con todos los valores que tenía al desaparecer para cuando la vuelvan a llamar con Show

Más adelante en el código hay que notar que estamos creando una instancia de la clase VentanaSaludona
y la estamos guardando como un atributo de la clase MiApp, de esta manera podremos usarla más
adelante, luego le decimos a MiApp que ella será su ventana principal

Importante: Una aplicación puede tener muchas ventanas, pero debe tener siempre una que sea la
principal, cuando la ventana principal de una aplicación se cierra, la aplicación termina sin importar
si hay más ventanas abiertas.

De igual manera trabajan las ventanas entre ellas, si una ventana es padre (o madre) de otras,
cuando ella se cierre se cerraran todas sus hijas.

Figura 2-1. Mira mamá una ventana que saluda!

4

Capítulo 3. Simplificando el trabajo con el
wxGlade

Este tutorial podría continuar mostrando como construir aplicaciones directamente en el código
utilizando cualquier editor, y es completamente factible, sin embargo, desde el punto de vista del autor, el
proceso de creación de aplicaciones con wxPython sin ayuda de un diseñador puede ser bastante
traumático. Es por esto que apartir de este punto empezaremos a utilizar el diseñador de interfaces (no un
I