| 10.12. Fichas | ||
|---|---|---|
 | Capítulo 10. Controles Contenedores |  |
| 10.12. Fichas | ||
|---|---|---|
| | Capítulo 10. Controles Contenedores | |
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 al mismo 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 necesitas saber, como probablemente adivines, se usa para crear un nuevo control de fichas.
notebook = gtk.Notebook() |
Una vez que has creado las fichas, hay unos cuantos métodos que manipulan el control de fichas. Veámoslos individualmente.
El primero que trataremos especifica cómo colocar los indicadores de página. Estos indicadores o "pestañas" como se les 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, 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 te 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 alante o hacia atrás. Simplemente utilizalos en el control de fichas sobre el que quieras operar.
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.
notebook.next_page() notebook.prev_page() |
Este método fija la página "activa". Si quieres que las fichas comiencen con la página 5 activa, usarás este método. Si no lo usas, el valor 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 tienes un gran número de páginas, y las pestañas no caben en la página. Te permite desplazar 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, está ampliado a partir del código testgtk.py que viene con la distribución PyGTK. 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 principio, en medio o al final. Los botones te 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 # example notebook.py
4
5 import gtk
6
7 class NotebookExample:
8 # This method rotates the position of the tabs
9 def rotate_book(self, button, notebook):
10 notebook.set_tab_pos((notebook.get_tab_pos()+1) %4)
11
12 # Add/Remove the page tabs and the borders
13 def tabsborder_book(self, button, notebook):
14 tval = gtk.FALSE
15 bval = gtk.FALSE
16 if self.show_tabs == gtk.FALSE:
17 tval = gtk.TRUE
18 if self.show_border == gtk.FALSE:
19 bval = gtk.TRUE
20
21 notebook.set_show_tabs(tval)
22 self.show_tabs = tval
23 notebook.set_show_border(bval)
24 self.show_border = bval
25
26 # Remove a page from the notebook
27 def remove_book(self, button, notebook):
28 page = notebook.get_current_page()
29 notebook.remove_page(page)
30 # Need to refresh the widget --
31 # This forces the widget to redraw itself.
32 notebook.draw((0,0,-1,-1))
33
34 def delete(self, widget, event=None):
35 gtk.mainquit()
36 return gtk.FALSE
37
38 def __init__(self):
39 window = gtk.Window(gtk.WINDOW_TOPLEVEL)
40 window.connect("delete_event", self.delete)
41 window.set_border_width(10)
42
43 table = gtk.Table(3,6,gtk.FALSE)
44 window.add(table)
45
46 # Create a new notebook, place the position of the tabs
47 notebook = gtk.Notebook()
48 notebook.set_tab_pos(gtk.POS_TOP)
49 table.attach(notebook, 0,6,0,1)
50 notebook.show()
51 self.show_tabs = gtk.TRUE
52 self.show_border = gtk.TRUE
53
54 # Let's append a bunch of pages to the notebook
55 for i in range(5):
56 bufferf = "Append Frame %d" % (i+1)
57 bufferl = "Page %d" % (i+1)
58
59 frame = gtk.Frame(bufferf)
60 frame.set_border_width(10)
61 frame.set_size_request(100, 75)
62 frame.show()
63
64 label = gtk.Label(bufferf)
65 frame.add(label)
66 label.show()
67
68 label = gtk.Label(bufferl)
69 notebook.append_page(frame, label)
70
71 # Now let's add a page to a specific spot
72 checkbutton = gtk.CheckButton("Check me please!")
73 checkbutton.set_size_request(100, 75)
74 checkbutton.show ()
75
76 label = gtk.Label("Add page")
77 notebook.insert_page(checkbutton, label, 2)
78
79 # Now finally let's prepend pages to the notebook
80 for i in range(5):
81 bufferf = "Prepend Frame %d" % (i+1)
82 bufferl = "PPage %d" % (i+1)
83
84 frame = gtk.Frame(bufferf)
85 frame.set_border_width(10)
86 frame.set_size_request(100, 75)
87 frame.show()
88
89 label = gtk.Label(bufferf)
90 frame.add(label)
91 label.show()
92
93 label = gtk.Label(bufferl)
94 notebook.prepend_page(frame, label)
95
96 # Set what page to start at (page 4)
97 notebook.set_current_page(3)
98
99 # Create a bunch of buttons
100 button = gtk.Button("close")
101 button.connect("clicked", self.delete)
102 table.attach(button, 0,1,1,2)
103 button.show()
104
105 button = gtk.Button("next page")
106 button.connect("clicked", lambda w: notebook.next_page())
107 table.attach(button, 1,2,1,2)
108 button.show()
109
110 button = gtk.Button("prev page")
111 button.connect("clicked", lambda w: notebook.prev_page())
112 table.attach(button, 2,3,1,2)
113 button.show()
114
115 button = gtk.Button("tab position")
116 button.connect("clicked", self.rotate_book, notebook)
117 table.attach(button, 3,4,1,2)
118 button.show()
119
120 button = gtk.Button("tabs/border on/off")
121 button.connect("clicked", self.tabsborder_book, notebook)
122 table.attach(button, 4,5,1,2)
123 button.show()
124
125 button = gtk.Button("remove page")
126 button.connect("clicked", self.remove_book, notebook)
127 table.attach(button, 5,6,1,2)
128 button.show()
129
130 table.show()
131 window.show()
132
133 def main():
134 gtk.main()
135 return 0
136
137 if __name__ == "__main__":
138 NotebookExample()
139 main()
|
Espero que esto te ayude en tu camino para crear fichas en tus programas PyGTK.
| |  | |
| 10.11. Barra de Herramientas |  | Capítulo 11. Control Menú |
