| Capítulo 2. Primeros Pasos | ||
|---|---|---|
 | Parte I. Tutorial de PyGTK |  |
| Capítulo 2. Primeros Pasos | ||
|---|---|---|
| | Parte I. Tutorial de PyGTK | |
Tabla de contenidos
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 hay forma de salir excepto matándolo desde la consola.
1 #!/usr/bin/env python
2
3 # example base.py
4
5 import gtk
6
7 class Base:
8 def __init__(self):
9 self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
10 self.window.show()
11
12 def main(self):
13 gtk.main()
14
15 if __name__ == "__main__":
16 base = Base()
17 base.main()
|
Puedes ejecutar el programa anterior usando:
python base.py |
Si base.py es hecho ejecutable y se puede encontrar en la variable PATH, puede ser ejecutado usando:
base.py |
La línea 1 le pedirá a python que ejecute base.py en este caso. Las líneas 15-17 comprueban si la variable __name__ es "__main__", lo cual indica que el programa esta siendo ejecutado directamente por python y no está siendo importado en un intérprete python. En este caso el programa crea una nueva instancia de la clase Base y guarda una referencia a ella en la variable base. Después invoca la función main() para empezar el bucle de procesamiento de eventos de GTK.
Una ventana similar a Figura 2.1. Ventana Simple PyGTK debería aparecer en tu pantalla.
La primera línea permite al programa base.py ser invocado desde una consola Linux o Unix asumiendo que python se encuentre en tu PATH. Esta línea será la primera línea en todos los programas de ejemplo.
La línea 5 importa el módulo PyGTK e inicializa el entorno GTK+. El módulo PyGTK define los interfaces Python para las funciones GTK+ que se usarán en el programa. Para aquellos que estén familiarizados con GTK+, la inicialización incluye la llamada a la función gtk_init(). Este configura unas cuantas cosas por nosotros como el visual por defecto y el mapa de colores, manejadores de señales predeterminados, y comprueba los argumentos que se le pasan a tu programa desde la línea de comandos, buscando alguno de los siguientes:
Borra estos argumentos de la lista de argumentos, dejando todo lo que no reconoce para que tu programa lo procese o ignore. Este conjunto de argumentos estandard son los que aceptan todas los programas GTK+.
Las líneas 7-10 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 9) y ordena a GTK+ que la muestre (línea 10). La GtkWindow se crea en la línea 9 con el argumento gtk.WINDOW_TOPLEVEL que especifica que queremos 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 de 200x200 por defecto para que puedas manipularla.
Las líneas 12-13 definen el método main() que llama a la función PyGTK main(), la cual, 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 15-17 permiten al programa que comience 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 16-17 será ejecutado. Si el programa se carga en un intérprete de python que se esté ejecutando, las líneas 16-17 no serán ejecutadas.
La línea 16 crea una instancia de la clase Base llamada base. Una GtkWindow es creada y mostrada como resultado.
La línea 17 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á esperando que ocurran eventos X (como pulsaciones de teclas o botones), alarmas, o notificaciones de entrada/salida de ficheros. En nuestro ejemplo, sin embargo, los eventos son ignorados.
Ahora haremos 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 # example helloworld.py
4
5 import gtk
6
7 class HelloWorld:
8
9 # This is a callback function. The data arguments are ignored
10 # in this example. More on callbacks below.
11 def hello(self, widget, data=None):
12 print "Hello World"
13
14 def delete_event(self, widget, event, data=None):
15 # If you return FALSE in the "delete_event" signal handler,
16 # GTK will emit the "destroy" signal. Returning TRUE means
17 # you don't want the window to be destroyed.
18 # This is useful for popping up 'are you sure you want to quit?'
19 # type dialogs.
20 print "delete event occurred"
21
22 # Change TRUE to FALSE and the main window will be destroyed with
23 # a "delete_event".
24 return gtk.FALSE
25
26 # Another callback
27 def destroy(self, widget, data=None):
28 gtk.main_quit()
29
30 def __init__(self):
31 # create a new window
32 self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
33
34 # When the window is given the "delete_event" signal (this is given
35 # by the window manager, usually by the "close" option, or on the
36 # titlebar), we ask it to call the delete_event () function
37 # as defined above. The data passed to the callback
38 # function is NULL and is ignored in the callback function.
39 self.window.connect("delete_event", self.delete_event)
40
41 # Here we connect the "destroy" event to a signal handler.
42 # This event occurs when we call gtk_widget_destroy() on the window,
43 # or if we return FALSE in the "delete_event" callback.
44 self.window.connect("destroy", self.destroy)
45
46 # Sets the border width of the window.
47 self.window.set_border_width(10)
48
49 # Creates a new button with the label "Hello World".
50 self.button = gtk.Button("Hello World")
51
52 # When the button receives the "clicked" signal, it will call the
53 # function hello() passing it None as its argument. The hello()
54 # function is defined above.
55 self.button.connect("clicked", self.hello, None)
56
57 # This will cause the window to be destroyed by calling
58 # gtk_widget_destroy(window) when "clicked". Again, the destroy
59 # signal could come from here, or the window manager.
60 self.button.connect_object("clicked", gtk.Widget.destroy, self.window)
61
62 # This packs the button into the window (a GTK container).
63 self.window.add(self.button)
64
65 # The final step is to display this newly created widget.
66 self.button.show()
67
68 # and the window
69 self.window.show()
70
71 def main(self):
72 # All PyGTK applications must have a gtk.main(). Control ends here
73 # and waits for an event to occur (like a key press or mouse event).
74 gtk.main()
75
76 # If the program is run directly or passed as an argument to the python
77 # interpreter then create a HelloWorld instance and show it
78 if __name__ == "__main__":
79 hello = HelloWorld()
80 hello.main()
|
Figura 2.2. Programa de ejemplo Hola Mundo muestra la ventana creada por helloworld.py.
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 especificaré el prefijo del módulo gtk, pero se asumirá. Por supuesto, los programas de ejemplo usarán los prefijos del módulo.
| |  | |
| Capítulo 1. Introducción |  | 2.2. Teoría de Señales y Retrollamadas |
