Menu, MenuBar, MenuItem y TextView en PyGTK

Si no sabes muy bien de qué va todo esto, deberías echar un vistazo primero a este post de hace unos días en el que nos familiarizamos con PyGTK; ya que vamos a usar aquel código como base para este nuevo programa.
La misión para hoy es bastante sencilla: crear un programa con el que podamos introducir texto de forma gráfica, crear un texto vacío nuevo y salir. Las opciones de “Nuevo” y “Salir” estarán ubicadas en el menú “Archivo”. ¡Go, Johnny, Go!

El punto de partida
El código que se muestra a continuación solo crea una ventana vacía con el título “Mi Programa”, con un tamaño determinado. Al pulsar el botón de cierre, desaparece y se descarga de memoria la aplicación:
#!/usr/bin/env python
# -*- coding:utf-8 -*-

import pygtk
pygtk.require ('2.0')
import gtk

w=gtk.Window(gtk.WINDOW_TOPLEVEL)
w.connect("destroy", gtk.main_quit)
w.set_title("Mi Programa")
w.set_default_size(300,200)

w.show_all()
gtk.main()

El cuadro de edición TextView
Un cuadro de texto TextView que sea editable se puede crear muy fácilmente en PyGTK:
tv=gtk.TextView()
tv.set_editable(True)

Sin embargo resultará poco práctico por sí solo, ya que si excedemos el tamaño que ocupa, no podremos ver el texto que quede oculto a no ser que podamos aumentar el tamaño de la ventana. Para hacerlo más útil, embeberemos este cuadro en una ventana de scroll, es decir, una ventana con barras de desplazamiento laterales y verticales.
sw=gtk.ScrolledWindow()
sw.add(tv)

Los menús (MenuBar, MenuItem, Menu)
Un menú en GTK se construye con tres elementos fundamentales:
– La barra que los contiene
– Los items (que a su vez pueden contener submenús)
– Los menús, que son los widgets desplegables de opciones
Esto se entiende mejor con la siguiente imagen:

De modo que comenzaremos por crear una barra de menú (variable mb) con el widget MenuBar, y un item (variable mi) con el widget MenuItem al que llamaremos “Archivo”. Una vez creados, hacemos que el menu “Archivo” (mi) cuelgue de la barra (mb):
mb=gtk.MenuBar()
mi=gtk.MenuItem("Archivo")
mb.add(mi)

De “Archivo”, queremos que cuelgue un menú desplegable (variable m) que crearemos con el widget Menu que también necesitamos crear:
m=gtk.Menu()
mi.set_submenu(m)

Con esto ya tenemos el menú “Archivo” (algo casi universal) en nuestra barra de menús. Ahora debemos añadir items; y lo bueno es que podemos reutilizar el identificador “mi” porque los items estarán dentro del menú que se despliega (m), ya que no necesitaremos referirnos nunca más al item “Archivo”.

Para la opción “Nuevo”, necesitamos crear una función que recupere de el buffer del cuadro de texto (que era la variable tv) y lo sustituya por una cadena vacía:
def nuevo(self):
  b=tv.get_buffer
  b.set_text("")

Sencilla, ¿verdad?

Ahora ya podemos crear opción que limpia el cuadro de texto. El evento de pulsar esta opción se llama “activate” y lo conectaré a la función que acabamos de crear. Por último, la añado al menú (m).
mi=gtk.MenuItem("Nuevo")
mi.connect("activate", nuevo)
m.append(mi)

Por último, agregamos la opción de “Salir”, la conectamos a la función de salida del programa (igual que el botón de cierre) y la colgamos del menú:
mi=gtk.MenuItem("Salir")
mi.connect("activate", gtk.main_quit)
m.append(mi)

Aclaro que el motivo de crear los menús en segundo lugar se debe a la necesidad de referirnos al objeto “tv”; cosa que no podría haber hecho antes de crearlo. Esto conduce, en códigos más grandes, a una desestructuración del mismo; cosa que se puede salvar utilizando la orientación a objetos, de la que hablaré en otro post.

Layout (disposición de los elementos) mediante el sistema de cajas
Ahora que tenemos los ladrillos, vamos a colocarlos en orden para montar el aspecto final de nuestra ventana. Algo curioso que sucedes es que no los podemos añadir sin más. Las ventanas son un widget en el que solo puede anidarse otro widget. La clave es pensar en dos tipos de cajas donde situaremos los elementos:
– Cajas verticales: agregan nuevas filas en las que podemos anidar otros widgets para que queden unos sobre otros.
– Cajas horizontales: agregan nuevas columnas en las que podemos anidar otros widgets para que queden unos al lado de otros.

Si vuelves a mirar la imagen del principio, verás claramente que necesitamos una caja vertical. En la primera fila se situará la barra de menu y en la segunda, el cuadro de scroll que contiene nuestro TextView. De modo que…
vbox=gtk.VBox()
Para añadir los widgets utilizamos el método “pack_start” y los añadimos en el orden en el que queramos que aparezcan. La firma de esta función es la siguiente:
pack_start( child , expand =True, fill =True, padding =0)
Es decir, el primer parámetro es el nombre del widget. A continuación decimos si el widget debe expandirse al redimensionar la ventana y si debe ocupar todo el espacio de la caja. El padding nos servirá para establecer una separación (en píxeles) entre esta fila y las que la rodean.
Para nuestro caso, decidiremos los siguientes valores…
vbox.pack_start(mb, False, False, 00)
vbox.pack_start(sw, True, True, 00)

Y para terminar ya podemos añadir a la ventana nuestra caja vertical:
w.add(vbox)

Descárgate TextView.py.tar.gz y descomprímelo para poder ver el código fuente completo.
Por último, ten en cuenta que si estás usando Unity como escritorio, los menús se situarán en la barra superior, y tendrán el aspecto de la imagen de abajo. No obstante, no habrá que cambiar ni un ápice el código de la aplicación…

Anuncios

Un comentario sobre “Menu, MenuBar, MenuItem y TextView en PyGTK

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s