PyGTK - Clase TreeView

El widget Treeview muestra el contenido de un modelo que implementa la interfaz gtk.TreeModel. PyGTK proporciona los siguientes tipos de modelos:

gtk.ListStore
gtk.TreeStore
gtk.TreeModelSort

ListStore es un modelo de lista. Cuando se asocia con un widget gtk.TreeView, produce un cuadro de lista que contiene los elementos que se seleccionarán. Un objeto gtk.ListStore se declara con la siguiente sintaxis:

store = gtk.ListStore(column_type)

Una lista puede tener varias columnas, las constantes de tipo predefinidas son:

gobject.TYPE_BOOLEAN
gobject.TYPE_BOXED
gobject.TYPE_CHAR
gobject.TYPE_DOUBLE
gobject.TYPE_ENUM
gobject.TYPE_FLOAT
gobject.TYPE_INT
gobject.TYPE_LONG
gobject.TYPE_NONE
gobject.TYPE_OBJECT
gobject.TYPE_STRING
gobject.TYPE_UCHAR
gobject.TYPE_UINT
gobject.TYPE_ULONG
gtk.gdk.pixbuf etc.

Por ejemplo, un objeto ListStore para almacenar elementos de cadena se declara como:

store = gtk.ListStore(gobject.TYPE_STRING

Para agregar artículos en la tienda, se utilizan los métodos append ():

store.append (["item 1"])

TreeStore es un modelo para el widget de árbol de varias columnas. Por ejemplo, la siguiente declaración crea una tienda con una columna que tiene un elemento de cadena.

Store = gtk.TreeStore(gobject.TYPE_STRING)

Para agregar elementos en un TreeStore, use el método append (). El método append () tiene dos parámetros, padre y fila. Para agregar un elemento de nivel superior, el elemento principal es Ninguno.

row1 = store.append(None, ['row1'])

Debe repetir esta declaración para agregar varias filas.

Para agregar filas secundarias, pase la fila de nivel superior como parámetro principal al método append () -

childrow = store.append(row1, ['child1'])

Debe repetir esta declaración para agregar varias filas secundarias.

Ahora, cree un widget TreeView y use el objeto TreeStore anterior como modelo.

treeview = gtk.TreeView(store)

Ahora tenemos que crear TreeViewColumn para mostrar los datos de la tienda. El objeto de gtk.TreeViewColumn administra el encabezado y las celdas usando gtk.CelRenderer. El objeto TreeViewColumn se crea utilizando el siguiente constructor:

gtk.TreeViewColumn(title, cell_renderer,…)

Además del título y el renderizador, se necesitan cero o más pares atributo = columna para especificar de qué columna del modelo de árbol se va a recuperar el valor del atributo. Estos parámetros también se pueden configurar utilizando los métodos de la clase TreeViewColumn que se indican a continuación.

Un gtk.CellRenderer es una clase base para un conjunto de objetos para representar diferentes tipos de datos. Las clases derivadas son CellRendererText, CellRendererPixBuf y CellRendererToggle.

Los siguientes métodos de la clase TreeViewColumn se utilizan para configurar su objeto:

TreeViewColumn.pack_start (celda, expandir = True): este método empaqueta el objeto CellRenderer en la columna inicial. Si el parámetro de expansión se establece en Verdadero, todo el espacio asignado de las columnas se asigna a la celda.
TreeViewColumn.add_attribute (celda, atributo, columna): este método agrega una asignación de atributos a la lista en la columna del árbol. loscolumn es la columna del modelo de árbol.
TreeViewColumn.set_attributes (): este método establece las ubicaciones de los atributos del renderer utilizando el attribute = column pares
TreeViewColumn.set_visible () - Si True, la columna de vista de árbol es visible
TreeViewColumn.set_title (): este método establece la propiedad "title" en el valor especificado.
TreeViewColumn.set_lickable (): si se establece en True, el encabezado puede tomar el foco del teclado y hacer clic.
TreeViewColumn.set_alignment (xalign): este método establece la propiedad "alineación" en el valor de xalign.

La señal de "clic" se emite cuando el usuario hace clic en el botón del encabezado de la columna de vista de árbol .

Después de haber configurado el objeto TreeViewColumn, se agrega al widget TreeView usando el método append_column ().

Los siguientes son los métodos importantes de la clase TreeView:

TreevVew.set_model (): establece la propiedad "modelo" para la vista de árbol. Si la vista de árbol ya tiene un modelo establecido, este método lo eliminará antes de configurar el nuevo modelo. Simodel es None, desarmará el modelo antiguo.
TreeView.set_header_clickable (): si se establece en True, se puede hacer clic en los botones de título de la columna.
TreeView.append_column () - Esto agrega el especificado TreeViewColumn a la lista de columnas.
TreeView.remove_column (): esto elimina la columna especificada de la vista de árbol.
TreeView.insert_column (): inserta el column en la vista de árbol en la ubicación especificada por position.

El widget TreeView emite las siguientes señales:

cursor cambiado	Se emite cuando el cursor se mueve o se fija.
expand-collapse-cursor-row	Se emite cuando es necesario expandir o contraer la fila en el cursor.
activado por fila	Esto se emite cuando el usuario hace doble clic en un treeview fila
fila-colapsada	Se emite cuando el usuario o la acción programática contraen una fila.
fila expandida	Se emite cuando se expande una fila a través del usuario o la acción programática.

A continuación se ofrecen dos ejemplos del widget TreeView. El primer ejemplo usa un ListStore para producir un ListView simple.

Aquí se crea un objeto ListStore y se le agregan elementos de cadena. Este objeto ListStore se utiliza como modelo para el objeto TreeView -

store = gtk.ListStore(str)

treeView = gtk.TreeView()
treeView.set_model(store)

Luego, se agrega un CellRendererText a un objeto TreeViewColumn y el mismo se agrega a TreeView.

rendererText = gtk.CellRendererText()
column = gtk.TreeViewColumn("Name", rendererText, text = 0)
treeView.append_column(column)

El objeto TreeView se coloca en la ventana de nivel superior agregándolo a un contenedor fijo.

Ejemplo 1

Observe el siguiente código:

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

class PyApp(gtk.Window):
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("TreeView with ListStore")
      self.set_default_size(250, 200)
      self.set_position(gtk.WIN_POS_CENTER)
		
      store = gtk.ListStore(str)
      store.append (["PyQt"])
      store.append (["Tkinter"])
      store.append (["WxPython"])
      store.append (["PyGTK"])
      store.append (["PySide"])
      
      treeView = gtk.TreeView()
      treeView.set_model(store)
		
      rendererText = gtk.CellRendererText()
      column = gtk.TreeViewColumn("Python GUI Libraries", rendererText, text=0)
      treeView.append_column(column)
      
      fixed = gtk.Fixed()
      lbl = gtk.Label("select a GUI toolkit")
      fixed.put(lbl, 25,75)
      fixed.put(treeView, 125,15)
		
      lbl2 = gtk.Label("Your choice is:")
      fixed.put(lbl2, 25,175)
      self.label = gtk.Label("")
		
      fixed.put(self.label, 125,175)
      self.add(fixed)
      
      treeView.connect("row-activated", self.on_activated)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
		
   def on_activated(self, widget, row, col):
      
	  model = widget.get_model()
      text = model[row][0]
      self.label.set_text(text)
		
def main():
   gtk.main()
   return

if __name__ == "__main__":
   bcb = PyApp()
   main()

El elemento seleccionado por el usuario se muestra en una etiqueta en la ventana como el on_activated callback se invoca la función.

Ejemplo 2

El segundo ejemplo crea un TreeView jerárquico a partir de un TreeStore. Este programa sigue la misma secuencia de construcción de la tienda, configurándola como modelo para TreeView, diseñando una TreeViewColumn y añadiéndola a TreeView.

import gtk

class PyApp(gtk.Window):
   
   def __init__(self):
      super(PyApp, self).__init__()
      
	  self.set_title("TreeView with TreeStore")
      self.set_size_request(400,200)
      self.set_position(gtk.WIN_POS_CENTER)
      vbox = gtk.VBox(False, 5)
      
      # create a TreeStore with one string column to use as the model
      store = gtk.TreeStore(str)
      
      # add row
      row1 = store.append(None, ['JAVA'])
      
      #add child rows
      store.append(row1,['AWT'])
      store.append(row1,['Swing'])
      store.append(row1,['JSF'])
      
      # add another row
      row2 = store.append(None, ['Python'])
      store.append(row2,['PyQt'])
      store.append(row2,['WxPython'])
      store.append(row2,['PyGTK'])
      
      # create the TreeView using treestore
      treeview = gtk.TreeView(store)
      tvcolumn = gtk.TreeViewColumn('GUI Toolkits')
      treeview.append_column(tvcolumn)
		
      cell = gtk.CellRendererText()
      tvcolumn.pack_start(cell, True)
      tvcolumn.add_attribute(cell, 'text', 0)
      vbox.add(treeview)
		
      self.add(vbox)
      
	  self.connect("destroy", gtk.main_quit)
      self.show_all()

PyApp()
gtk.main()

El siguiente TreeView se muestra como una salida: