10.12. Fichas (Notebook)

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:

Figura 10.9. Ejemplo de Fichas

Ejemplo de Fichas

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.