Capítulo 2. Primeros Pasos

Tabla de contenidos

2.1. Hola Mundo en PyGTK
2.2. Teoría de Señales y Retrollamadas
2.3. Eventos
2.4. Hola Mundo Paso a Paso

Para empezar nuestra introducción a PyGTK, comenzaremos con el programa más simple posible. Este programa (base.py) creará una ventana de 200x200 píxeles y no es posible salir de él excepto terminando el proceso desde la consola.

    1   #!/usr/bin/env python
    2
    3   # example base.py
    4
    5   import pygtk
    6   pygtk.require('2.0')
    7   import gtk
    8
    9   class Base:
   10       def __init__(self):
   11           self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
   12           self.window.show()
   13
   14       def main(self):
   15           gtk.main()
   16
   17   print __name__
   18   if __name__ == "__main__":
   19       base = Base()
   20       base.main()

Se puede ejecutar el programa anterior escribiendo en la línea de órdenes:

  python base.py

Si base.py es hecho ejecutable y se puede encontrar en la variable PATH, es posible ejecutarlo usando:

  base.py

En este caso, la línea 1 pedirá al intérprete de Python que ejecute base.py. Las líneas 5-6 ayudan a diferenciar entre las distintas versiones de PyGTK que puedan estar instaladas en el equipo. Estas líneas indican que se desea usar la versión 2.0 de PyGTK, que comprende todas las versiones de PyGTK con 2 como número principal. Ello impide que el programa utilice versiones anteriores de PyGTK, en caso de que se encuentren instaladas en el sistema. Las líneas 18-20 comprueban si la variable __name__ es "__main__", lo cual indica que el programa está siendo ejecutado directamente por python y no está siendo importado en un intérprete Python. En el primer caso el programa crea una nueva instancia de la clase Base y guarda una referencia a ella en la variable base. Después llama la función main() para iniciar el bucle de procesamiento de eventos de GTK.

Una ventana similar a Figura 2.1, “Ventana Simple PyGTK” debería aparecer en tu pantalla.

Figura 2.1. Ventana Simple PyGTK

Ventana Simple PyGTK

La primera línea permite al programa base.py ser invocado desde una consola Linux o Unix asumiendo que python se encuentre en el PATH. Esta línea aparecerá como primera línea en todos los programas de ejemplo.

Las líneas 5-7 importan el módulo PyGTK 2 e inicializan el entorno GTK+. El módulo PyGTK define las interfaces Python de las funciones GTK+ que se usarán en el programa. Para quienes estén familiarizados con GTK+ hay que advertir que la inicialización incluye la llamada a la función gtk_init(). También se configuran algunas cosas por nosotros, tales como el visual por defecto, el mapa de colores, manejadores de señales predeterminados. Asimismo comprueba los argumentos que se pasan al programa desde la línea de comandos, en busca de alguno entre:

En este caso, los borra de la lista de argumentos y deja los no coincidentes que no reconoce para que el programa lo procese o ignore. El anterior conjunto de argumentos son los que aceptan de forma estándar todos los programas GTK+.

Las líneas 9-15 definen una clase de Python llamada Base que define un método de inicialización de instancia __init__(). La función __init__() crea una ventana de nivel superior (línea 11) y ordena a GTK+ que la muestre (línea 12). La gtk.Window se crea en la línea 11 con el argumento gtk.WINDOW_TOPLEVEL que indica que se desea una ventana sometida a las decoraciones y posicionamiento del manejador de ventanas. En vez de crear una ventana de tamaño 0x0, una ventana sin hijos tiene un tamaño predeterminado de 200x200 de forma que se pueda manipular.

Las líneas 14-15 definen el método main() que llama a la función PyGTK main(), que invoca el bucle principal de procesamiento de eventos de GTK+ para manejar eventos de ratón y de teclado, así como eventos de ventana.

Las líneas 18-20 permiten al programa comenzar automáticamente si es llamado directamente o pasado como argumento al intérprete de Python. En estos casos, el nombre de programa que hay en la variable __name__ será la cadena "__main__" y el código entre las líneas 18-20 se ejecutará. Si el programa se carga en un intérprete de Python en ejecución, las líneas 18-20 no serán ejecutadas.

La línea 19 crea una instancia de la clase Base llamada base. Crea una gtk.Window y la muestra como resultado.

La línea 20 llama al método main() de la clase Base, la cual comienza el bucle de procesamiento de eventos de GTK+. Cuando el control llega a este punto, GTK+ se dormirá a la espera de eventos de las X (como pulsaciones de teclas o botones), alarmas, o notificaciones de entrada/salida de ficheros. En el ejemplo, sin embargo, los eventos son ignorados.

2.1. Hola Mundo en PyGTK

Ahora seguimos con un programa con un control (un botón). Es la versión PyGTK del clásico programa hola mundo (helloworld.py ).

    1   #!/usr/bin/env python
    2
    3   # ejemplo helloworld.py
    4
    5   import pygtk
    6   pygtk.require('2.0')
    7   import gtk
    8
    9   class HelloWorld:
   10
   11       # Esta es una función de retrollamada. Se ignoran los argumentos de datos
   12       # en este ejemplo. Más sobre retrollamadas más abajo.
   13       def hello(self, widget, data=None):
   14           print "Hello World"
   15
   16       def delete_event(self, widget, event, data=None):
   17           # Si se devuelve FALSE en el gestor de la señal "delete_event",
   18           # GTK emitirá la señal "destroy". La devolución de TRUE significa
   19           # que no se desea la destrucción de la ventana.
   20           # Esto sirve para presentar diálogos como: '¿Está seguro de que desea salir?'
   21           # 
   22           print "delete event occurred"
   23
   24           # Si se cambia FALSE a TRUE la ventana principal no se
   25           # destruirá con "delete_event".
   26           return gtk.FALSE
   27
   28       # Otra retrollamada
   29       def destroy(self, widget, data=None):
   30           gtk.main_quit()
   31
   32       def __init__(self):
   33           # se crea una ventana nueva
   34           self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
   35
   36           # Cuando se envía a una ventana la señal "delete_event" (esto lo hace
   37           # generalmente el gestor de ventanas, usualmente con "cerrar", o con el icono
   38           # de la ventana de título), pedimos que llame la función delete_event ()
   39           # definida arriba. Los datos pasados a la retrollamada son
   40           # NULL y se ignoran en la función de retrollamada.
   41           self.window.connect("delete_event", self.delete_event)
   42
   43           # Conectamos el evento "destroy" a un manejador de señal.
   44           # Este evento sucede cuando llamamos gtk_widget_destroy() para la ventana,
   45           # o si devolvemos FALSE en la retrollamada "delete_event".
   46           self.window.connect("destroy", self.destroy)
   47
   48           # Establece el grosor del borde de la ventana.
   49           self.window.set_border_width(10)
   50
   51           # Crea un nuevo botón con la etiqueta "Hello World".
   52           self.button = gtk.Button("Hello World")
   53
   54           # Cuando el botón recibe la señal "clicked", llamará la
   55           # función hello() a la que pasa None como argumento.  La función hello()
   56           # se define más arriba.
   57           self.button.connect("clicked", self.hello, None)
   58
   59           # Esto causará la destrucción de la ventana al llamar a
   60           # gtk_widget_destroy(window) cuando se produzca "clicked".  De nuevo,
   61           # la señal podría venir de aquí o del gestor de ventanas.
   62           self.button.connect_object("clicked", gtk.Widget.destroy, self.window)
   63
   64           # Esto empaqueta el botón en la ventana (un contenedor de GTK+).
   65           self.window.add(self.button)
   66
   67           # El paso final es mostrar el control recién creado.
   68           self.button.show()
   69
   70           # y la ventana
   71           self.window.show()
   72
   73       def main(self):
   74           # Todas las aplicaciones de PyGTK deben tener una llamada a gtk.main(). Aquí se deja
   75           # el control y se espera que suceda un evento (como un evento de teclado o ratón).
   76           gtk.main()
   77
   78   # Si el programa se ejecuta directamente o se pasa como argumento al intérprete
   79   # de Python, entonces se crea una instancia de HelloWorld y se muestra
   80   if __name__ == "__main__":
   81       hello = HelloWorld()
   82       hello.main()

Figura 2.2, “Programa de ejemplo: Hola Mundo” muestra la ventana creada por helloworld.py.

Figura 2.2. Programa de ejemplo: Hola Mundo

Programa de ejemplo: Hola Mundo

Las variables y funciones que se definen en el módulo PyGTK se llaman de la forma gtk.*. Por ejemplo, el programa helloworld.py usa:

  gtk.FALSE
  gtk.mainquit()
  gtk.Window()
  gtk.Button()

del módulo PyGTK. En futuras secciones no se especificará el prefijo del módulo gtk, pero se dará por asumido. Naturalmente, los programas de ejemplo usarán los prefijos del módulo.