Python-Gtk-Gnome con libglade

Introducción

No quiero entrar en esta mini-guía a hablar sobre si debemos elegir Perl o Python
como nuestro "lenguaje-script". A cada uno el que más le guste (a mi me gustan los dos). Tampoco me voy
a extender demasiado en lo básico de python (los paquetes, los de debian por
lo menos, vienen con una documentación muy, muy buena).

Para el que aún no lo sepa Python es un lenguaje interpretado (como Tcl, Perl, etc)
que se puede ejecutar tanto en Windows (aghhhhhhhh!!) como en Linux. Sin embargo
Python es mucho más valioso en una máquina con Linux que con Windows.¿Por qué?
Pues porque en un sistema linux puedes realizar toda la administración del sistema a
través de comandos y estos comandos son accesibles a través de Python (esto que acabo de
decir es una de las mejores razones que hay para usar linux u otro sistema UN*X). En windows, sin embargo,
esto no es posible (lástima.... jeje).

Con Python puedes programar con un paradigma orientado a objetos o procedimental, dependiendo
de lo que necesitemos. Normalmente para un script sencillo de administración no hace falta
montarnos follones de clases ni objetos....., sin embargo si vamos a meternos en un proyecto mas grande
nos conviene utilizar orientación a objetos.

Python provee facilidades para organizar los fuentes mediante módulos que puedes incluir en tus
scripts. Actualmente existen un montón de módulos disponibles: smtplib, httplib,pop,gtk,gnome,etc...
La mayoría de los módulos están muy bien documentados salvo el de gtk y gnome. Me las he visto p..
para encontrar cositas...

1. Creando el interfaz

Para crear el interfaz del programade ejemplo que vamos a hacer utilizaremos Glade. Glade
es el mejor generador de interfaces que he encontrado hasta el momento. Una de las cosas que
más me gustan de glade es que puedes generar el código en XML (nada de formatos
propietarios) y, a partir del fichero en XML (que normalmente tiene extension .glade) puedes
pasar el código a lo que te de la real gana( python, perl, C, C++, etc). Sin embargo existe otra
forma de utilizar el fichero XML para utilizar los "widgets" que creemos con el interfaz: libglade.

Mediante libglade podemos acceder al árbol de widgets que hemos creado con Glade a través del
fichero XML.

2. Primer ejemplo de código

	1	#!/usr/bin/env python
	2	from gtk import *
	3	import libglade
	4	
	5	arbol = libglade.GladeXML('holamundo.glade')
	6	boton = arbol.get_widget('BotonHola')
	7	ventana = arbol.get_widget('Ventana')
	8	
	9	ventana.connect('destroy',mainquit)
   	10	mainloop()		

Línea 1: Hay que incluirlo en cualquier script Python. Carga el intérprete

Línea 2: Importamos el módulo de gtk donde están definidos los objetos.

Línea 3:Importamos la libreía libglade que nos permite obtener "referencias" a los
objetos de nuestro arbol. Importante:Es diferente hacer: import libreria que: from librería
import *. Cuando utilizas el from incluyes todas las funciones del módulo en el espacio de nombres
de tu script, por lo que puedes utilizar esas funciones sin poner el nombre de la librería delante.

Cuando se utiliza simplemente import, al utilizar una funcion de ese módulo tienes que poner el
nombre de la libreríaantes, de la forma: NombreLibreria.funcion()

Línea 5: La función GladeXML del módulo libglade
devuelve un objeto a través del cual podemos acceder a los widgets que hemos definido. A
get_widget le pasamos como argumento el nombre del objeto que queremos tomar. Para ver los widgets que vamos a
tomar es muy útil tener a la vista el arbol de contenedores y elementos
de glade (la imagen de la derecha de arriba).

Línea 6: En esta línea lo que estamos haciendo
es crear un objeto de tipo Button a través del arbol que hemos
generado con GladeXML. Como véis simplemente utilizamos el método
get_widget del arbol con el nombre del objeto a tomar.

Línea 7: Hacemos lo mismo para obtener un
objeto de tipo Window

Línea 9: En esta línea vemos algo nuevo.
Conectamos un evento a una señal. La sintaxis como véis es muy sencilla:
NombreInstanciaObjeto.connect('Evento',señal) . En este caso
hemos conectado el evento destroy con la señal
mainquit. Esta señal no esta definida en ningún sitio porque es
parte de la libreria de gtk y es la que termina un programa. El
evento destroy es el que se genera cuando pichas para cerrar la ventana.

Línea 10: Como en todo programa desarrollado
con gtk para que empiece a ejecutarse realmente la aplicación es
necesario llamar a mainloop

Creando un manejador de señal

Para demostrar como podemos crear un manejador de señal vamos a hacer que al
pulsar el botón Hola se imprima en la consola:"Hola Mundo".

Antes de nada el código:

	def saluda(self, *args):
		print "Hola mundo"

Incluimos este código antes de que generemos el árbol deobjetos. Para
conectar este manejador con un evento:

	8	boton.connect('clicked',saluda)	

De esta forma estamos diciendo que cuando pulsemos el botón se ejecute el
manejador saluda. Como véis es muy fácil.

Una nota sobre el
manejador de señal:

1. Todas las funciones en Python tienen implícito un argumento
   self que se referencia a sí mismo.

2. Los manejadores de señal en GTK han de llevar un argumento donde pasarle
   al manejador datos a cerca de la señal (qué evento la recibe, etc...).

5. El mismo ejemplo orientado a objetos

	#!/usr/bin/env python

	from gtk import *
	import libglade

	class Hola:
		def __init__(self): # constructor de la clase
			self.Saludo = "Hola Mundo"

		def Saluda(self):
			print self.Saludo

	class App:
		def __init__(self): # constructor
			self.ObjHola = Hola() # Creamos una instancia del
			objeto hola
			self.Arbol = libglade.GladeXML('holamundo.glade')
			self.Ventana = self.Arbol.get_widget('Ventana')
			self.Boton = self.Arbol.get_widget('BotonHola')

			self.Ventana.connect('destroy', mainquit)
			self.Boton.connect('clicked',self.Saludin)

		def Saludin(self, *args):
			self.ObjHola.Saluda()

	# Esto es nuevo. Python mantiene constantemente un diccionario en el
	# que almacena el curso de ejecución del script. Si __name__ (el
	# diccionario) es igual a main quiere decir que acabamos de iniciar el
	# script, entonces creamos una instancia de nuestra clase App y
	# llamamos a mainloop
	
	if __name__ == '__main__':
		app = App()
		mainloop()
	

6. Final

Bueno, pues como véis es muy fácil generar un interfaz con Glade y hacerlo
usable mediante Python. Espero hacer más secciones sobre esta miniguía con
información a cerca de objetos GTK definidos en el módulo de Python y sus
métodos. El problema es que hay muy poca documentación y la cosa va lenta pero
todo se andará. De momento creo que lo básico está cubierto.

Suerte y un saludo.