Las Toolbars (Barras de Herramientas) se
usan normalmente para agrupar un número de controles y simplificar la
personalización de su apariencia y disposición. Típicamente una barra de
herramientas consiste en botones con iconos, etiquetas y pistas, pero
se puede poner cualquier otro control en una barra de herramientas. Finalmente, los
elementos se pueden colocar horizontal o verticalmente y se pueden ver los
botones con iconos, texto, o ambos.
La creación de una barra de herramientas se consigue (como uno podría sospechar) con la siguiente función:
toolbar = gtk.Toolbar()
Después de crear una barra de herramientas uno puede añadir al principio, al final o en otro posición, items (textos simples) o elementos (cualquier tipo de control) en la barra de herramientas. Para describir un item necesitamos un texto, un texto para la pista, un texto privado para la pista, un icono para el botón y una retrollamada. Por ejemplo, para añadir al principio o al final un item se pueden usar los siguientes métodos:
toolbar.append_item(text,tooltip_text,tooltip_private_text,icon,callback,user_data=None) toolbar.prepend_item(text,tooltip_text,tooltip_private_text,icon,callback,user_data)
Si se quiere usar el método insert_item(), el
único parámetro adicional que debe especificarse, es la posición en la cual
el elemento se debe insertar. Así:
toolbar.insert_item(text,tooltip_text,tooltip_private_text,icon,callback,user_data,position)
Para añadir de forma sencilla espacios entre items de la barra de herramientas se pueden usar los siguientes métodos:
toolbar.append_space()
toolbar.prepend_space()
toolbar.insert_space(position)
Si es necesario, la orientación de una barra de herramientas, su estilo y el hecho de que las pistas estén disponibles, se puede cambiar sobre la marcha usando los siguientes métodos:
toolbar.set_orientation(orientation) toolbar.set_style(style) toolbar.set_tooltips(enable)
Donde la orientation puede ser
ORIENTATION_HORIZONTAL u
ORIENTATION_VERTICAL. El style se
usa para especificar la apariencia de la barra de herramientas y puede ser
TOOLBAR_ICONS (iconos), TOOLBAR_TEXT (texto),
o TOOLBAR_BOTH (ambos). El
argumento enable puede ser o TRUE o
FALSE.
Para mostrar algunas otras cosas que se pueden hacer con una barra de herramientas veamos el siguiente programa de ejemplo toolbar.py (interrumpiremos el listado con explicaciones adicionales):
1 #!/usr/bin/env python
2
3 # ejemplo toolbar.py
4
5 import pygtk
6 pygtk.require('2.0')
7 import gtk
8
9 class ToolbarExample:
10 # Este método se conecta al botón Close o
11 # al cierre de la ventana desde el Gestor de Ventanas
12 def delete_event(self, widget, event=None):
13 gtk.main_quit()
14 return gtk.FALSE
15
Este principio debería resultar familiar si no es el primer
programa PyGTK. No obstante hay una cosa más, vamos a importar un bonito dibujo
XPM (gtk.xpm) para
que nos sirva de icono para todos los botones. La linea 10 empieza la clase de
ejemplo ToolbarExample y las lineas 12-14 definen el
método de retrollamada que finalizará el programa.
16 # es fácil... cuando se conmuta uno de los botones, simplemente 17 # comprobamos cuál está activo y cambiamos el estilo de la barra de herramientas 18 # de acuerdo con ello 19 def radio_event(self, widget, toolbar): 20 if self.text_button.get_active(): 21 toolbar.set_style(gtk.TOOLBAR_TEXT) 22 elif self.icon_button.get_active(): 23 toolbar.set_style(gtk.TOOLBAR_ICONS) 24 elif self.both_button.get_active(): 25 toolbar.set_style(gtk.TOOLBAR_BOTH) 26 27 # incluso más fácil, comprobamos la conmutación del botón 28 # y activamos/desactivamos las pistas 29 def toggle_event(self, widget, toolbar): 30 toolbar.set_tooltips(widget.get_active()) 31
Las lineas 19-30 son dos métodos de retrollamada que se llamarán cuando uno de los botones de la barra de herramientas se active. Estas cosas resultan familiares si ya se han usado botones biestado (y botones de exclusión mútua).
32 def __init__(self):
33 # Aquí está la ventana principal (un diálogo) y el asa
34 # necesitamos una barra de herramientas, un icono con máscara (uno para todos
35 # los botones) y un control de icono en el que ponerlo (aunque crearemos
36 # un control aparte para cada botón)
37 # creamos una nueva ventana con su título y un tamaño adecuado
38 dialog = gtk.Dialog()
39 dialog.set_title("GTKToolbar Tutorial")
40 dialog.set_size_request(450, 250)
41 dialog.set_resizable(gtk.TRUE)
42
43 # generalmente querremos salir si cierran la ventana
44 dialog.connect("delete_event", self.delete_event)
45
46 # para que tenga mejor aspecto ponemos la barra en la caja con asa
47 # de manera que se pueda separar de la ventana principal
48 handlebox = gtk.HandleBox()
49 dialog.vbox.pack_start(handlebox, gtk.FALSE, gtk.FALSE, 5)
50
Lo anterior debería ser común a cualquier otra aplicación PyGTK.
Inicialización de una instancia de ToolbarExample,
creación de la ventana, etc. Sólo hay una cosa que probablemente necesite más
explicación: una caja con mango (asa) (HandleBox). Una caja con mango es simplemente
otra caja cualquiera que puede usarse para meter controles dentro. La
diferencia entre ella y las cajas típicas es que puede despegarse de la ventana
padre (o, de hecho, la caja con mango permanece en el padre, pero se reduce a
un rectángulo muy pequeño, mientras que todos sus contenidos cambian de padre
a una nueva ventana flotante). Normalmente es bueno tener una barra de
herramientas separable, por lo que estos dos controles suelen ir juntos
normalmente.
51 # la barra de herramientas será horizontal, con iconos y texto, y 52 # con espacios de 5pxl entre elementos y, finalmente, 53 # la insertaremos en la caja con asa 54 toolbar = gtk.Toolbar() 55 toolbar.set_orientation(gtk.ORIENTATION_HORIZONTAL) 56 toolbar.set_style(gtk.TOOLBAR_BOTH) 57 toolbar.set_border_width(5) 58 handlebox.add(toolbar) 59
Bien, lo que hacemos arriba es una simple inicialización del control de la barra de herramientas.
60 # nuestro primer elemento es el botón <close>
61 iconw = gtk.Image() # control de icono
62 iconw.set_from_file("gtk.xpm")
63 close_button = toolbar.append_item(
64 "Close", # etiqueta de botón
65 "Closes this app", # la pista del botón
66 "Private", # información privada de la pista
67 iconw, # control icono
68 self.delete_event) # una señal
69 toolbar.append_space() # espacio tras el elemento
70
En el código anterior se puede ver el caso más simple: añadir un botón
a la barra de herramientas. Justo antes de añadir el nuevo elemento, tenemos que
construir un control de imágen que servirá como icono para este elemento; este paso
tiene que repetirse para cada nuevo elemento. Justo después del elemento añadimos
también espacio, para que los elementos siguientes no se toquen unos a otros. Como
se puede ver, el método append_item() devuelve una
referencia al control de botón recién creado, para que se pueda trabajar con él de
la forma habitual.
71 # ahora, hagamos el grupo de botones de exclusión...
72 iconw = gtk.Image() # control de icono
73 iconw.set_from_file("gtk.xpm")
74 icon_button = toolbar.append_element(
75 gtk.TOOLBAR_CHILD_RADIOBUTTON, # type of element
76 None, # control
77 "Icon", # etiqueta
78 "Only icons in toolbar", # pista
79 "Private", # cadena privada de pista
80 iconw, # icono
81 self.radio_event, # señal
82 toolbar) # datos para la señal
83 toolbar.append_space()
84 self.icon_button = icon_button
85
Aqui empezamos a crear un grupo de botones de exclusión mútua. Para
hacer esto usamos el método append_element() . De hecho,
usando este método, uno puede también puede añadir items normales o incluso
espacios (type = gtk.TOOLBAR_CHILD_SPACE
(espacio) o gtk.TOOLBAR_CHILD_BUTTON (botón)). En el ejemplo
anterior hemos empezado a crear un grupo de botones de exclusión mútua. Cuando se crean
otros botones de exclusión mútua se necesita una referencia al botón anterior en el grupo,
para que se pueda construir una lista de botones fácilmente (mira la sección RadioButtons
de este tutorial). También tenemos una referencia al botón en la instancia de
ToolbarExample para acceder a él más tare.
86 # los siguientes botones de exclusión se refieren a los anteriores
87 iconw = gtk.Image() # control de icono
88 iconw.set_from_file("gtk.xpm")
89 text_button = toolbar.append_element(
90 gtk.TOOLBAR_CHILD_RADIOBUTTON,
91 icon_button,
92 "Text",
93 "Only texts in toolbar",
94 "Private",
95 iconw,
96 self.radio_event,
97 toolbar)
98 toolbar.append_space()
99 self.text_button = text_button
100
101 iconw = gtk.Image() # control de icono
102 iconw.set_from_file("gtk.xpm")
103 both_button = toolbar.append_element(
104 gtk.TOOLBAR_CHILD_RADIOBUTTON,
105 text_button,
106 "Both",
107 "Icons and text in toolbar",
108 "Private",
109 iconw,
110 self.radio_event,
111 toolbar)
112 toolbar.append_space()
113 self.both_button = both_button
114 both_button.set_active(gtk.TRUE)
115
Creamos otros botones de exclusión mútua de la misma forma excepto
que le pasamos uno de los botones creados al método
append_element() para especificar el grupo.
Al final tenemos que establecer el estado de uno de los botones manualmente (si no todos tienen el estado activo, impidiéndonos que los vayamos intercambiando).
116 # aquí ponemos simplemente un botón biestado
117 iconw = gtk.Image() # control de icono
118 iconw.set_from_file("gtk.xpm")
119 tooltips_button = toolbar.append_element(
120 gtk.TOOLBAR_CHILD_TOGGLEBUTTON,
121 None,
122 "Tooltips",
123 "Toolbar with or without tips",
124 "Private",
125 iconw,
126 self.toggle_event,
127 toolbar)
128 toolbar.append_space()
129 tooltips_button.set_active(gtk.TRUE)
130
Un botón biestado se puede crear de la forma obvia (si ya se han creado botones de exclusión mútua alguna vez).
131 # para empaquetar un control en la barra, solamente tenemos 132 # crearlo y añadirlo con una pista apropiada 133 entry = gtk.Entry() 134 toolbar.append_widget(entry, "This is just an entry", "Private") 135 136 # bien, no está creada dentro de la barra, así que tenemos que mostrarla 137 entry.show() 138
Como se puede ver, añadir cualquier tipo de control a una barra de herramientas es fácil. La única cosa que se tiene que recordar es que este control debe mostrarse manualmente (al contrario que los elementos, que se mostrarán de golpe con la barra de herramientas).
139 # ¡ya está! Mostremos todo. 140 toolbar.show() 141 handlebox.show() 142 dialog.show() 143 144 def main(): 145 # nos quedamos en gtk_main y ¡esperamos que empiece la diversión! 146 gtk.main() 147 return 0 148 149 if __name__ == "__main__": 150 ToolbarExample() 151 main()
La linea 142 termina la definición de la clase
ToolbarExample. Las lineas 144-147 definen la función
main() que simplemente llama a la función
gtk.main() para iniciar el bucle de procesamiento de
eventos. Las lineas 149-151 crean una instancia de
ToolbarExample y luego entran en el bucle de
procesamiento de eventos. Así termina el tutorial de la barra de herramientas.
Por supuesto, para apreciarla en su máximo esplendor se necesita también el
icono XPM, gtk.xpm.
La figura Figura 10.8, “Ejemplo de Barra de Herramientas” muestar la ventana resultante:
