El control NoteBook (Fichas) es una colección de "páginas" que se solapan unas con otras. Cada página contiene información diferente y sólo una es visible a un tiempo. Este control se ha hecho muy popular últimamente en la programación de interfaces gráficas de usuario, y es una buena manera de mostrar bloques de información similar que guardan una separación en la pantalla.
La primera función que se necesita saber, como probablemente se adivine, se usa para crear un nuevo control de fichas.
notebook = gtk.Notebook() |
Una vez que se han creado las fichas, hay unos cuantos métodos que manipulan el control. Veámoslos uno a uno.
El primero que trataremos especifica cómo colocar los indicadores de página. Estos indicadores o "pestañas" como se las conoce, se pueden colocar de cuatro maneras: arriba, abajo, izquierda o derecha.
notebook.set_tab_pos(pos) |
pos será uno de las siguientes, que son bastante descriptivas:
POS_LEFT # izquierda POS_RIGHT # derecha POS_TOP # arriba POS_BOTTOM # abajo |
POS_TOP es el valor predeterminado.
Lo siguiente que trataremos será cómo añadir páginas a las fichas. Hay tres formas de añadir páginas a un NoteBook. Veamos las dos primeras, ya que son bastante similares.
notebook.append_page(child, tab_label) notebook.prepend_page(child, tab_label) |
Estos métodos añaden páginas a las fichas insertándolas al final (append), o al principio (prepend). child es el control que se colocará dentro de la página en cuestión, y tab_label es el título para la página que se está añadiendo. El control child debe crearse por separado, y normalmente es un conjunto de opciones de configuración dentro de otro control contenedor, tal como una tabla.
El último método para añadir una página a las fichas contiene todas las propiedades de los otros dos, y además permite especificar en qué posición se insertará la página en las fichas.
notebook.insert_page(child, tab_label, position) |
Los parámetros son los mismos que en append() y prepend() excepto en que contiene un parámetro extra, position. Este parámetro se usa para especificar en qué lugar la página se insertará; la primera página está en la posición cero.
Ahora que sabemos cómo añadir una página, veamos cómo podemos borrar una página de las fichas.
notebook.remove_page(page_num) |
Este método borra la página especificada por page_num de las fichas contenidas en la variable notebook.
Para saber cuál es la página actual de las fichas utiliza el método:
page = notebook.get_current_page() |
Los próximos dos métodos son simples llamadas para mover la página hacia adelante o hacia atrás. Simplemente se utilizan en el control de fichas sobre el que se quiera operar.
notebook.next_page() notebook.prev_page() |
Nota
Cuando el notebook tiene como página actual la última página, y se llama a next_page() , no ocurre nada. De forma análoga, si el notebook está en la primera página, y se llama a prev_page(), no pasa nada.
Este método fija la página "activa". Si se quiere que las fichas comiencen con la página 5 activa, se usará este método. Si no se usa, el comportamiento predeterminado de las fichas es mostrar la primera página.
notebook.set_current_page(page_num) |
Los siguientes dos métodos añaden o borran las pestañas y el borde respectivamente.
notebook.set_show_tabs(show_tabs) notebook.set_show_border(show_border) |
El siguiente método es útil cuando se tiene un gran número de páginas, y las pestañas no caben en la página. Permite desplazarse por las pestañas usando dos botones de flechas.
notebook.set_scrollable(scrollable) |
show_tabs (mostrar pestañas), show_border (mostrar border) y scrollable (desplazable) pueden ser TRUE o FALSE.
Ahora veamos un ejemplo. El programa notebook.py crea una ventana con unas fichas y seis botones. Las fichas contienen 11 páginas, añadidas de tres formas diferentes, al final, en medio y al principio. Los botones permiten rotar la posición de las pestañas, añadir o borrar las pestañas y el borde, borrar una página, cambiar las páginas hacia delante y hacia atrás, y salir del programa. La figura Figura 10.9, “Ejemplo de Fichas” muestra la ventana del programa:
El código fuente de notebook.py es:
1 #!/usr/bin/env python
2
3 # ejemplo notebook.py
4
5 import pygtk
6 pygtk.require('2.0')
7 import gtk
8
9 class NotebookExample:
10 # Este método rota la posición de las pestañas
11 def rotate_book(self, button, notebook):
12 notebook.set_tab_pos((notebook.get_tab_pos()+1) %4)
13
14 # Añadir/Eliminar las pestañas de página y los bordes
15 def tabsborder_book(self, button, notebook):
16 tval = gtk.FALSE
17 bval = gtk.FALSE
18 if self.show_tabs == gtk.FALSE:
19 tval = gtk.TRUE
20 if self.show_border == gtk.FALSE:
21 bval = gtk.TRUE
22
23 notebook.set_show_tabs(tval)
24 self.show_tabs = tval
25 notebook.set_show_border(bval)
26 self.show_border = bval
27
28 # Eliminar una página de las fichas
29 def remove_book(self, button, notebook):
30 page = notebook.get_current_page()
31 notebook.remove_page(page)
32 # Need to refresh the widget --
33 # This forces the widget to redraw itself.
34 notebook.queue_draw_area(0,0,-1,-1)
35
36 def delete(self, widget, event=None):
37 gtk.main_quit()
38 return gtk.FALSE
39
40 def __init__(self):
41 window = gtk.Window(gtk.WINDOW_TOPLEVEL)
42 window.connect("delete_event", self.delete)
43 window.set_border_width(10)
44
45 table = gtk.Table(3,6,gtk.FALSE)
46 window.add(table)
47
48 # Crear unas nuevas fichas, definir la posición de las pestañas
49 notebook = gtk.Notebook()
50 notebook.set_tab_pos(gtk.POS_TOP)
51 table.attach(notebook, 0,6,0,1)
52 notebook.show()
53 self.show_tabs = gtk.TRUE
54 self.show_border = gtk.TRUE
55
56 # Añadimos unas cuantas páginas a las fichas
57 for i in range(5):
58 bufferf = "Append Frame %d" % (i+1)
59 bufferl = "Page %d" % (i+1)
60
61 frame = gtk.Frame(bufferf)
62 frame.set_border_width(10)
63 frame.set_size_request(100, 75)
64 frame.show()
65
66 label = gtk.Label(bufferf)
67 frame.add(label)
68 label.show()
69
70 label = gtk.Label(bufferl)
71 notebook.append_page(frame, label)
72
73 # Ahora añadimos una página en un punto determinado
74 checkbutton = gtk.CheckButton("Check me please!")
75 checkbutton.set_size_request(100, 75)
76 checkbutton.show ()
77
78 label = gtk.Label("Add page")
79 notebook.insert_page(checkbutton, label, 2)
80
81 # Finalmente añadimos una página delante
82 for i in range(5):
83 bufferf = "Prepend Frame %d" % (i+1)
84 bufferl = "PPage %d" % (i+1)
85
86 frame = gtk.Frame(bufferf)
87 frame.set_border_width(10)
88 frame.set_size_request(100, 75)
89 frame.show()
90
91 label = gtk.Label(bufferf)
92 frame.add(label)
93 label.show()
94
95 label = gtk.Label(bufferl)
96 notebook.prepend_page(frame, label)
97
98 # Establecer en qué página empezamos (página 4)
99 notebook.set_current_page(3)
100
101 # Creamos unos cuantos botones
102 button = gtk.Button("close")
103 button.connect("clicked", self.delete)
104 table.attach(button, 0,1,1,2)
105 button.show()
106
107 button = gtk.Button("next page")
108 button.connect("clicked", lambda w: notebook.next_page())
109 table.attach(button, 1,2,1,2)
110 button.show()
111
112 button = gtk.Button("prev page")
113 button.connect("clicked", lambda w: notebook.prev_page())
114 table.attach(button, 2,3,1,2)
115 button.show()
116
117 button = gtk.Button("tab position")
118 button.connect("clicked", self.rotate_book, notebook)
119 table.attach(button, 3,4,1,2)
120 button.show()
121
122 button = gtk.Button("tabs/border on/off")
123 button.connect("clicked", self.tabsborder_book, notebook)
124 table.attach(button, 4,5,1,2)
125 button.show()
126
127 button = gtk.Button("remove page")
128 button.connect("clicked", self.remove_book, notebook)
129 table.attach(button, 5,6,1,2)
130 button.show()
131
132 table.show()
133 window.show()
134
135 def main():
136 gtk.main()
137 return 0
138
139 if __name__ == "__main__":
140 NotebookExample()
141 main()
|
Espero que esto ayude en el camino para crear fichas en los programas PyGTK.