[LinuxFocus-icon]
Hogar  |  Mapa  |  Indice  |  Busqueda

Noticias | Arca | Enlaces | Sobre LF
Este documento está disponible en los siguientes idiomas: English  Castellano  ChineseGB  Deutsch  Francais  Nederlands  Portugues  Turkce  

convert to palmConvert to GutenPalm
or to PalmDoc

Hilaire Fernandes
por Hilaire Fernandes
<hilaire(at)ofset.org>

Sobre el autor:

Hilaire Fernandes es vicepresidente de OFSET, una organización que promueve y desarrolla software libre educativo para el proyecto GNOME. El escribió el paquete Dr. Geo, un software para geometria dinámica. Actualmente está trabajando en Dr. Genius, un software matemático para propósitos educativos del proyecto GNOME.


Contenidos:

 

Desarrollando aplicaciones GNOME con Python (segunda parte)

Gnome

Resumen:

Esta serie de artículos está dirigida principalmente para los programadores que acaban de iniciarce en el área de Gnome y GNU/Linux. Python es el lenguaje de programación que he escogido, ya que es un lenguaje mucho más rápido de asimilar que lenguajes compilados como C. Para poder comprender este artículo necesitarás conocer las bases de programación en Python.



Herramientas necesarias

El software necesario para ejecutar el programa descrito fue mencionado en el primer arctículo de esta serie.

Necesitarás:

el archivo .glade, original [ drill.glade ] ;

el código fuente de drill, en Python [ drill.py ].

El procedimiento de instalación y el uso de Python-Gnome con LibGlade, fueron descritos en la primera parte de esta serie de arctículos.

 

Drill, nuestro soporte

La meta del primer artículo fue demostrar el mecanismo y los modos de interacción entre los diferentes componentes de un programa escrito para una configuración que utiliza Gnome, Glade, LibGlade y Python.

El ejemplo usaba el widget GnomeCanvas. Este ejemplo nos proporcionó una presentación colorida y nos mostró lo fácil que es desarrollar aplicaciones con esta configuración.

Para las siguientes secciones, sugiero utilizar un ambiente de trabajo (framework) en el cual podamos explicar los diferentes widgets de Gnome. Este artículo se concentra en la configuración de dicho ambiente de trabajo. Futuros artículos usarán este ambiente adicionando más características para ilustrar otros Gnome widgets.

Nuestro ambiente de trabajo (framework) es llamado Drill. Esta es una plataforma para propósitos educacionales, la cual será usada para nuestros ejemplos y ejercicios. Estos ejemplos son solamente con intenciones educativas para demostrar el uso de widgets.



Creando una interface con Glade

Los widgets

La ventana de la aplicación es creada con Glade. Como en los artículos anteriores, primero crearás una ventana para una aplicación Gnome. Estando en esa ventana necesitarás borrar los íconos y menús inútiles

La parte principal de Drill deberá ser dividida en dos espacios de trabajo (workspaces) usando el GtkPaned widget.

[Drill window]
Fig. 1 – Ventana principal de Drill

Ambos espacios de trabajo (workspaces) son separados verticalmente con un manejador usado para ajustar la medida de cada uno. El espacio de trabajo izquierdo contienen el tree widget (GtkTree), en el cual las diferentes partes del ejercicio deberán almacenadas por categoría.

El espacio de trabajo derecho está vacío, aquí es donde adicionaremos los ejercicios de acuerdo a los deseos del usuario.

Desde Glade, viendo la interfáz de Drill, nos muestra la estructura de sus componentes.

[widgets in

tree]
Fig. 2 – Vista del arbol de Drill

Puedes ver en la figura 2 que el widget hpanedTree (del tipo GtkPaned), solamente contieene un widget, frame2 (del tipo GtkFrame), el que está a la izquierda. frame2 cotiene el widget exerciceTree. Es preferible, primero insertar un widget GtkFrame con una sombra del tipo GTK_SHADOW_IN dentro de un GtkPaned widget. Esto evita enmascarar el manejo.

Por último , la caja de diálogo de Gnome “About Drill” puede parecer como está:

[Dialog window]
Fig. 3 – Caja de diálogo "About" Drill

Los diversos items son editados con Glade en la hoja de Widget de la ventana de características

Los widgets y los nombre de las funciones de procesos

Use los siguientes nombres de los widgets para manipularlos bajo los nombres desde Python.

Ventana de la aplicación Gnome:

drillApp

Separador que maneja el árbol de ejercicios :
hpanedTree

Arbol de ejercicios:
exerciceTree

Caja de diálogo de Gnome:
about



Puedes ver estos nombres de widgets en la Fig. 2.

Mostramos aquí rápidamente los nombres de las funciones de proceso. Si necesitas más información sobre estos puedes leer la parte I de esta serie de artículos.

Nombre del widget

Señal (Signal)

Proceso (Proccesing)

about

clicked

gtk_widget_destroy

about

close

gtk_widget_destroy

about

destroy

gtk_widget_destroy

button1 (Icon New in the
tool bar)

clicked

on_new_activate

new

activate

on_new_activate

drillApp

destroy

on_exit_activate

exit

activate

on_exit_activate

about

activate

on_about_activate



Ajustes finales

Desde Glade es posible especificar la geometría de los widgets. En nuestro caso, podrás ajustar la medida del drillApp a 400 y 300 desde el Common tab en el panel de propiedades ( properties). También podrás especificar la posición del divididor horizontal en 100 en vez de 1.

Ahora el widget exerciceTree necesita ser ajustado para solamente permitir una selección a la vez. De hecho, solamente un ejercicio puede ser seleccionado a la vez. Desde el panel de propiedades (properties) selecciona Selection->Single. Las otras opciones para este widget son menos importantes.

Voilà, esto es todo lo que haremos en lo que a Drill concierne. Iniciaremos desarrollando ejercicios en el siguiente artículo. Por ahora, veremos como usar la interface desde Python y como manipular el GtkTree widget.

 

El código en Python

El codigo fuente completo puede ser encontrado al final de este documento. Necesitarás guardarlo en el mismo directorio enel que se encuentra el archivo drill.glade.

 

Los módulos requeridos

from gtk import *
from gnome.ui import *
from GDK import *
from libglade import *

 

La interface gráfica con LibGlade

La creación de la interface gráfica y la conección de las funciones de procesamiento con LibGlade se termina de la misma forma que en ejemplo anterior. No queremos regresar a ese aspecto en aprticular.

En el programa de Python definiremos las siguientes variables globales:



El árbol es creado desde LibGlade, este puntero se obtiene via la siguiente llamada:

exerciceTree = wTree.get_widget ("exerciceTree")

Necesitaremos el puntero para los paneles horizontales, en este caso el contenedor de referencia (GtkPaned) de los dos paneles horizontales separados por un manejador (handle). El que está en la izquierda contiene el árbol; el de la derecha contiene los ejercicios; por ahora localizaremos la etiqueta allí:

   paned = wTree.get_widget ("hpanedTree")
   label = GtkLabel ("No exercise selected")
   label.show ()
   paned.pack2 (label)



De nuevo, el uso de GTK+ Reference manual – sobre los objetos GtkLabel y GtkPaned – y el código fuente de Python /usr/lib/python1.5/site-packages/gtk.py te proporcionarán toda la información necesaria para el empleo correcto de los objetos .

El widget GtkTree

Esta es la parte más popular del artículo: cómo usar un árbol del tipo GtkTree?

El árbol es llenado con llamadas consecutivas a las funciones:

addMathExercices(), addFrenchExercices(), addHistoryExercices() y addGeographyExercices()

Estas funciones son muy similares entre sí. Cada una de estas adiciona una nueva subcategoría (un subarbol) como pueden ser los títulos de los ejercicios (items) :

def addMathExercices ():
   subtree = addSubtree ("Mathematics")
   addExercice (subtree, "Exercise 1", "Math. Ex1")
   addExercice (subtree, "Exercise 2", "Math. Ex2")



El subarbol

def addSubtree (name):
   global exerciceTree
   subTree = GtkTree ()
   item = GtkTreeItem (name)
   exerciceTree.append (item)
   item.set_subtree (subTree)
   item.show ()
   item.connect ("select", selectSubtree)
   return subTree



Para crear un subarbol en un árbol existente necesitarás hacer dos cosas: Generar un árbol del tipo GtkTree y un item del tipo GtkTreeItem, con el nombre del subarbol. Después, el item es adicionado al árbol raíz (el árbol que contiene todas las categorías), y adicionaremos el subarbol al item usando el método set_subtree(). Finalmente el evento select es conectado al item, entonces, cuandp la categoría es seleccionada, la función selectSubtree() es llamada.

GtkTreeItem

def addExercice (category, title, idValue):
item = GtkTreeItem (title)
item.set_data ("id", idValue)
category.append (item)
item.show ()
item.connect ("select", selectTreeItem)
item.connect ("deselect", deselectTreeItem)



Los items tienen los nombres de los ejercicios como su títutlo, aquí solo Excercice 1, Excercice 2... Para cada item asociaremos un ID atributo adicional. GTK+ tiene la posibilidad para adicionar algún objeto del tipo GtkObject (todos los widgets GTK+ vienen de ahy) los mismos atributos. Para hacer esto existen dos métodos, set_data (key, value) y get_data (key) para inicializar y obtener los valores de un atributo. El item entonces es adicionado a esta categoría (un subarbol). El método show() es llamado desde que es requerido para mostrarse. Por último, los métodos select y deselect son conectados. El evento deselect se llega a activar cuando el item pierde la selección. Cronológicamnete, el método deselectTreeItem() es llamado cuando el item está perdiendo su selección, continuando, el método selectTreeItem() es llamado cuando el item está tomando la selección.

 

Las funciones de procesado

Tenemos definidas tres funciones de procesado selectTreeItem(), deselectTreeItem() y selectSubtree(). Estas actualizan la etiqueta de texto (sobre el lado derecho) con el valor del atributo ID (id). Esto es todo por ahora...

 

La palabra final

Solo ajustaremos la infraestructura en la cual adicionaremos los ejercicios (como hemos descubierto nuevamente... los widgets) Hemos discutido el widget GtkTree y como asociamos atributos a los widgets. Este mecanismo es utilizado para obtener información adicional desde las funciones de procesamiento, que tenemos finalizadas aquí. Hasta el siguiente artículo; puedes tratar de transformar el juego Couler, que se utilizó en la parte I, como un ejercicio en Drill.



 

Apéndice: El código fuente completo

#!/usr/bin/python
# Drill - Teo Serie

#Cuestiones de licencia...
# Copyright Hilaire Fernandes 2001
# Release under the terms of the GPL licence
# You can get a copy of the license at http://www.gnu.org from gtk import *
from gnome.ui import *
from GDK import *
from libglade import * exerciceTree = currentExercice = label = None



def on_about_activate(obj):
"display the about dialog"
about = GladeXML ("drill.glade", "about").get_widget ("about")
about.show ()



def deselectTreeItem (item):
global label
label.set_text ("Léxercice " + item.get_data ("id") + "est désélectionné.")



def selectSubtree (subtree):
global label
label.set_text ("No selected exercise")



def addExercice (category, title, id):
item = GtkTreeItem (title)
item.set_data ("id", id)
category.append (item)
item.show ()
item.connect ("select", selectTreeItem)
item.connect ("deselect", deselectTreeItem)



def addMathExercices ():
subtree = addSubtree ("Mathématiques")
addExercice (subtree, "Exercice 1", "Math. Ex1")
addExercice (subtree, "Exercice 2", "Math. Ex2")



def addFrenchExercices ():
subtree = addSubtree ("Français")
addExercice (subtree, "Exercice 1", "Français Ex1")
addExercice (subtree, "Exercice 2", "Français Ex2")



def addHistoryExercices ():
subtree = addSubtree ("Histoire")
addExercice (subtree, "Exercice 1", "Histoire Ex1")
addExercice (subtree, "Exercice 2", "Histoire Ex2")



def addGeographyExercices ():
subtree = addSubtree ("Géographie")
addExercice (subtree, "Exercice 1", "Géographie Ex1")
addExercice (subtree, "Exercice 2", "Géographie Ex2")



def initDrill ():
global exerciceTree, label
wTree = GladeXML ("drill.glade", "drillApp")
dic = {"on_about_activate": on_about_activate,
    "on_exit_activate": mainquit,
     "on_new_activate": on_new_activate}
wTree.signal_autoconnect (dic)
exerciceTree = wTree.get_widget ("exerciceTree")

paned = wTree.get_widget ("hpanedTree")
label = GtkLabel ("No selected exercise")
label.show ()
paned.pack2 (label)


#Liberar el árbol GladeXML
wTree.destroy ()


# Adicionar ejercicios
addMathExercices ()
addFrenchExercices ()
addHistoryExercices ()
addGeographyExercices ()


#Temporalmente hasta que implementemos un ejercicio real

initDrill ()
mainloop ()

 

Formulario de "talkback" para este artículo

Cada artículo tiene su propia página de "talkback". A través de esa página puedes enviar un comentario o consultar los comentarios de otros lectores
 Ir a la página de "talkback" 

Contactar con el equipo de LinuFocus
© Hilaire Fernandes, FDL
LinuxFocus.org

Pinchar aquí para informar de algún problema o enviar comentarios a LinuxFocus
Información sobre la traducción:
fr --> -- : Hilaire Fernandes <hilaire(at)ofset.org>
fr --> de: Günther Socher <gsocher(at)web.de>
de --> en: Mario Santés <msantes(at)yahoo.com>

2002-02-08, generated by lfparser version 2.21