Programación GNOME en Linux usando

GTK+
Por Subhasísh Ghosh

Traducción al español por Fernando Frias

el día 30 de Junio 2002, para La Gaceta de Linux

Revisado y corregido por David Sánchez el 4 de Enero de 2003 para Linux-España

Este artículo proporciona una visión general de la programación GNOME en Linux

usando el toolkit GTK+. Nota Importante: se asume que el lector tiene el conocimiento
básico para moverse dentro de Linux, sabe como usar el escritorio GNOME y posee el
nivel y experiencia requeridos de programación C y/o C++.

El código fuente incluido junto con el texto, ha sido probado en una computadora con la
siguiente configuración: Compaq Presario 4010 Series system, 15.5 GB de espacio en
disco duro, 96 MB RAM, procesador Intel Celeron a 400 MHz, Red Hat Linux 7.1
kernel: 2.4.2-2

Este artículo ha sido dividido en las siguientes secciones para un fácil entendimiento:

1. ¿Que es GNOME? una introduccion..

2. La arquitectura GNOME.
3. GTK+ - una introducción.
4. Un programa básico.
5. Señales y Callbacks
6. Contenedores.
7. Botones.
8. Widgets de entrada.
9. Listas y Combos
10. menús y barras de herramientas.
11. Cajas de diálogo.
12. Conclusiones y enlaces para estudio posterior.

1. ¿Que es GNOME? Introducción.

Antes de entrar en el excitante mundo de la programación GNOME en Linux,
intentemos entender a que se refiere GNOME. GNOME es el acrónimo para "GNU's
Not Unix Network Object Model Environment ". Aunque esto suena un poco
complicado, GNOME es un proyecto de software con un objetivo simple: proveer a
todos los usuarios de Linux, un extremadamente amigable, no obstante poderoso y
completo ambiente de programación. GNOME es actualmente el escritorio por defecto
instalado en las últimas versiones de las distribuciones Linux Red Hat y Debian.
Para información mas específica sobre GNOME y sus varias maravillosas
características, asegúrate de revisar el proyecto GNOME en la página
http://www.gnome.org/ la cual proporciona a los lectores abundante información sobre
GNOME, incluyendo documentación en línea, noticias y también descargas de archivos
binarios así como código fuente de GNOME compatible con la mayoría de los sistemas
Linux.

Ahora miremos a GNOME desde "el punto de vista del programador", así como desde
"el punto de vista del administrador del sistema”. La pregunta básica que viene a la
mente es: ¿piensan y sienten lo mismo cuando hablan acerca de GNOME?, esto no es
fácil de responder, la mayoría de los administradores Linux, son o han sido
programadores Linux en el pasado, lo cual, hace bastante difícil el responder a esta
pregunta. Para la mayoría de los administradores de sistemas Linux, el ambiente
GNOME provee abundantes herramientas que hacen que el trabajo de administración
sea muy simple. Por lo pronto, el programador GNOME tiene la responsabilidad de
continuar abasteciendo esas facilidades diseñando programas aún mejores. Entonces,
están en una perfecta armonía el uno con el otro al grado de que sus respectivas labores
se afectan entre sí.

Ahora echemos un vistazo mas de cerca a la funcionalidad de Gnome. GNOME es

realmente una capa de programación que esta situada entre el sistema X Window(o X) y
el software manejador de ventanas. De tal forma que, como se menciono antes, provee a
los programadores GUI Linux una enorme funcionalidad a tal grado que pueden diseñar
programas basados en Linux. Pero lo mas significante de todo, la razón por la que
GNOME es casi indispensable para todos los desarrolladores Linux/Unix, es que
GNOME provee a esos desarrolladores, un entorno integrado el cual fue
específicamente diseñado para construir aplicaciones de código abierto(open source)
con una consistente interfaz gráfica de usuario.

El proyecto GNOME comenzó en agosto de 1997. Algunos de los fundadores incluidos,

entre otros, Peter Mattis, Spencer Kimball, Richard Stallman, y Erik Troan y Mark
Ewing de Red Hat, Inc.

2. La arquitectura GNOME.
La extremadamente poderosa, sin embargo, flexible arquitectura de GNOME, es lo que
proporciona a GNOME su estupenda funcionalidad. El conjunto de herramientas base
en GNOME es llamado GTK+(the GIMP toolkit). Fue originalmente escrito para usarse
en GIMP (GNU Image Manipulation Program). La adecuada comprensión de GTK+ es
extremadamente necesaria para la asimilación de la programación GNOME. GTK+ es
un conjunto de herramientas orientadas a objetos, de plataforma cruzada y
lenguaje neutral, que es ante todo, usada para crear aplicaciones independientes de
GNOME. Entonces la pregunta que viene es: ¿por que fue GTK+ elegido como el
conjunto de herramientas(toolkit) para GNOME?, la respuesta es simple, fue por su
soporte a muchos lenguajes de programación incluidos C, C++, PERL, Python, ADA
etc. Sin embargo, es útil siempre tener en cuenta que GNOME, al igual que GTK+, fue
escrito usando C; de tal forma que aquí estaríamos tratando con C únicamente.

Otra pregunta que debe surgir en la mente del lector es: ¿que es lo que contienen esas
cosas llamadas "Toolkits"?, los toolkits como GTK o Qt(el ambiente KDE esta basado
en Qt), son colecciones de widgets. Lo cual nos trae la pregunta ¿que son los
"Widgets"?

Los Widgets son controles GUI como botones, menús, cajas de diálogo y otros como
los objetos relacionados a funciones generales. Esto puede ser comparado con la Active
Template Library (ATL 3.0) sobre la plataforma Microsoft, la cual proporciona a los
desarrolladores COM(Component Onject Model) con un armazón listo y hecho para
crear objetos y componentes COM(ActiveX, EXE's y ActiveX DLL's).

3. GTK+ - Introducción.
Ahora demos un vistazo más de cerca a algunas de las características de GTK+:

1. El conjunto de librerías usadas por GTK+: GLIB(libreria GIMP) y GDK(GIMP

Drawing toolkit).
2. GLIB define tipos de datos y suministra funciones que tratan con el manejo de
errores y rutinas de memoria.
3. GDK es la plataforma dependiente del estrato que esta presente entre la API de
gráficos nativa y GTK+.
4. Eso no es todo. GNOME agrega funcionalidad adicional al GTK+ añadiendo un
estrato separado de widgets y librerías específicas de GNOME.
5. De este modo, GNOME viene con una arquitectura habilitada con un amplio
conjunto de widgets orientados a objetos y llenos de características.
6. Además de la funcionalidad de GTK+, también tenemos los beneficios
agregados de una implementación del sistema COBRA llamada ORBit en la
arquitectura GNOME, permitiendo que la comunicación de los objetos de
software sea fácil y efectiva.
7. GLIB define su propio conjunto de datos básicos. La mayoría son equivalentes a
los datos estándar en C.

Datos tipo GLIB Datos tipo C

gchar char

gshort short

glong long

gint int

gboolean boolean

gpointer void*

8. Un requerimiento vital para la adecuada comprensión de GTK+, es el concepto de

"herencia de widgets". Los widgets en GTK+, pertenecen a una herencia, así que las
funciones que son comunes a un conjunto de widgets, necesitan únicamente ser
implementados una vez.
Por ejemplo, la función gtk_widget_show, esta dirigida a la eliminación de código
duplicado, de modo que conduce a un mejor y mas rápido desarrollo de programas. Los
nuevos widgets son derivados de los widgets existentes de mayor nivel, de este modo,
solo las características únicas de este widget deberán ser escritas por el programador.
Por ejemplo, miremos de cerca a esta particular herencia de objetos:

GtkObject --> GtkWidget --> GtkContainer --> GtkBin --> GtkWindow --> GnomeApp

Así, si miras cuidadosamente, puedes ver que el widget GnomeApp es derivado del de
mayor nivel GtkWindow, el cual en sí mismo ha sido derivado del de mayor nivel
GtkBin y así sucesivamente. Si tomamos en cuenta las características esenciales de la
programación en lenguaje C++, esto nos trae a la memoria el concepto de "Herencia".
¿no es así?, seguramente lo es. Y es en este aspecto de la "herencia de widgets" en el
que se incorpora la funcionalidad derivada en GTK+.

Demos ahora una breve mirada a las funciones de creación de widgets. Para que estas
funciones operen correctamente, primero debemos asegurarnos de tener todas las
librerías GTK+ y GNOME instaladas correctamente, otra cosa importante a tomar en
cuenta es que la ruta de las librerías debe de ser correcta, hazlo antes de intentar
compilar cualquier código fuente.

Primero consideremos la función de creación de un widget, gnome_app_new(), esta

función, como se muestra, regresa un puntero a GtkWidget, el cual es un widget
genérico. Esto posiblemente se muestra como:

GtkWidget *ghosh;
ghosh = gnome_app_new(………);

Debemos notar que esto significa que si queremos llamar a una función especifica de
GnomeApp como gnome_app_set_menús(), entonces tenemos que usar una macro para
realizar el enlace de desde el tipo GtkWidget a el tipo GnomeApp; lo cual solo es
posible ya que GnomeApp es derivada de GtkWidget (observa la herencia mostrada
anteriormente).

4. Un programa básico.
La mejor forma de aprender la programación Linux es entender el trabajo interno del
kernel y haciendo programas por tí mismo. así que, ahora miremos un pequeño
programa para entender mejor el tema.

Arranca tu sistema en Linux, si estas en el modo CLI(interfaz de linea de comandos),

cambia a gnome usando el comando "switchdesk gnome", y el comando "startx" para
arrancar en el sistema GUI X window. Una vez dentro del ambiente GNOME, abre una
terminal GNOME, crea un archivo llamado myapp.c usando el editor vi y teclea lo
siguiente:

/* A sample GNOME program

Created By: Subhasísh Ghosh
Date: 8th August, 2001
*/
#include <gnome.h>

int main(int argc, char *argv[ ])

{

GtkWidget *ghosh;
gnome_init("sample", "0.1", argc, argv);
ghosh = gnome_app_new("sample", "My Window");
gtk_widget_show(ghosh);

gtk_main();
return 0;

Ahora, para compilar el programa myapp.c, asegúrate de teclear bien (toma en cuenta
las comillas simples):

# gcc myapp.c -o myapp `gnome-config --cflags --libs gnomeui`

GNOME viene con un shell script llamado gnome-config que proporciona al

compilador los argumentos correctos para la compilación. Una vez compilado, ejecuta
el programa usando el comando:

# ./myapp &
y presiona enter.

Una ventana vacía aparecerá en la pantalla, la cual puedes mover, ajustar el tamaño, así
como cerrar. Ahora miremos detenidamente el código. Al principio, introducimos
algunas líneas de comentarios, describiendo el programa, su creador y la fecha de
creación, aunque no es necesario, es una buena práctica de programación incluir
comentarios a cada programa. Después, incluimos el archivo de cabecera gnome.h, que
se encarga de todas las librerías GTK+ y GNOME así como de las funciónes y
definiciones necesarias, luego viene "gosh", que es un puntero a GtkWidget, este
apuntara a nuestro nuevo objeto ventana. La función gnome_init es entonces llamada,
esta inicializa librerías y es usada para un correcto manejo de sesión. La identificación
que se le pasa a la función gnome_init es "sample", el número de versión es "0.1" y la
usual línea de argumentos de la función main, estos son necesarios para el trabajo
interno de GNOME. Luego viene la función gnome_app_new(), que cuando es
ejecutada, crea nuestra ventana, esta toma dos argumentos, como se muestra en el
código: "sample" y "My Window". "Sample" es el nombre de la aplicacion y "My
Window" es el titulo de la ventana. Pero hay que notar que: aunque el nombre de esta
función es gnome_app_new(); esta NO crea ningún tipo de nueva aplicación o algo así;
crea una ventana top-level, eso es todo. La siguiente función llamada es
gtk_widget_show(), la cual hace visible nuestra ventana. Luego viene gtk_main(), la
cual es una función muy importante, ya que asegura que funciónes GNOME como son
los eventos y pulsaciones de botones sean ejecutados mediante el paso de funcionalidad
a GNOME.

De esta forma, este es el trabajo interno de nuestro primer programa GNOME.

5. Señales y Callbacks.
Ahora demos un profundo vistazo dentro del ambiente de programación GNOME:
"Señales" y "Callbacks". ¿Que son y para que se usan?, ¿realmente los necesitamos?,
cada vez que el ratón se mueve, entra y sale de widgets, cuando botones son pulsados, o
activados y acciones como estas son realizadas, una señal (signal) es enviada a la
aplicación. Esta señal puede ser pasada a una función callback. De esta forma, aunque
no siempre, las aplicaciones necesitan conectar esos eventos para tomar ciertas
acciones. En GTK+/GNOME, llamamos la una función gtk_signal_connect para
conectar señales y manejar funciones.

La función gtk_signal_connect tiene los siguientes 4 parámetros:

1. GtkObject *object -- El widget al cual un callback es asociado.

2. const gchar *name -- La señal a ser tratada.
3. GtkSignalFunc func -- La función que es llamada cuando la señal es enviada.
4. gpointer data -- Cualquier dato arbitrario que es dado a la función que maneja la
señal.

Se debe notar que distintos tipos de widgets emiten señales diferentes. Las señales de
los botones son:

1. clicked -- botón pulsado (pulsado y liberado).

2. pressed -- botón presionado hacia abajo por el ratón.
3. released -- botón liberado.
4. enter -- Movimiento del ratón dentro del área del botón.
5. leave -- Movimiento del ratón fuera del área del botón.

Examinaremos que las Señales y Callbacks juegan un rol vital en las aplicaciones que
desarrollaremos mas tarde.

6. Contenedores.
A continuación, veremos otro componente vital de la programación GNOME:
contenedores. GTK+ utiliza una gran cantidad de contenedores, debido a que GTK+ es
realmente un conjunto de herramientas basado en contenedores, lo que significa que
tenemos un contenedor padre dentro del cual tenemos que ubicar nuestros widgets. Las
ventanas son simples contenedores de widgets. De tal manera que, el punto importante a
tomar en cuenta es que GTK+ utiliza "cajas empaquetadas" invisibles las cuales pueden
contener múltiples widgets para crear diseños de ventana. Estas "cajas empaquetadas"
son de dos tipos: horizontales y verticales, creadas usando la funcionalidad de las
funciónes gtk_hbox_new y gtk_vbox_new, respectivamente. Pronto veremos que estas
funciones en acción, en las aplicaciones que crearemos mas tarde. Por ahora,
examinemos los parámetros de estas dos funciones:

1. homogeneous : tipo --> gboolean : Obliga a todos los widgets en la caja a

ocupar la misma area de acuerdo al widget mas grande en la caja.
2. spacing : tipo --> gint : Determina el espacio entre widgets adyacentes.
 3. expand : tipo --> gboolean : Permite que la caja empaquetada se expanda para
llenar el espacio restante.
4. fill : tipo --> gboolean : Permite que un widget en particular se expanda para
ocupar el espacio restante.
5. padding : tipo --> gint : Determina el ancho de un marco que rodea a un widget.

7. Botones.
Ahora viene otro componente vital: botones. GTK+ proporciona 4 diferentes tipos de
botones:

1. botones simples --> Para realizar una acción al hacer click.

2. botones Toggle --> Con un estado particular activado/desactivado
3. Casillas de verificacion --> Con un estado particular activado/desactivado.
4. botones de selección --> Para marcar solo una opción de entre un grupo de
varias.

Crear botones de selección es muy similar a las casillas de verificación, y lo que

necesitamos hacer extra es especificar un grupo de botones de selección al que
pertenece. Los botones de selección son derivados de los botones de verificación, los
cuales son derivados de los botones toggle, lo cual significa que tenemos el mismo
conjunto de funciones para leer y modificar su estado y también usan los mismos
eventos. nota: Para mas información sobre funciones especificas, consulta GTK+
Reference Documentation disponible en: http://www.gtk.org/

8. Widgets de entrada.
Para crear widgets de texto de una sola línea, que son comúnmente llamados "widgets
de entrada", utilizamos una función llamada gtk_entry_new(). Los widgets de entrada
son principalmente usados para introducir pequeñas cantidades de información.
Miremos ahora un programa que crea una "ventana de acceso", y despliega el campo
password, la señal activa ocurre, cuando el botón ha sido pulsado. Teclea lo siguiente y
ejecuta el programa como ha sido explicado.

/* Creating a Login GNOME-style using GTK+ Toolkit:

Created By: Subhasísh Ghosh
Date: Wednesday, August 8, 2001
*/

#include <gnome.h>

static void enter_pressed(GtkWidget *button, gpointer data)

{
GtkWidget *text_entry = data;
char *string = gtk_entry_get_text(GTK_ENTRY(text_entry));
g_print(string);
}
int main(int argc, char *argv[])
{
GtkWidget *app;
GtkWidget *text_entry;
GtkWidget *label;
GtkWidget *hbox; gchar *text;

gnome_init("example", "0.1", argc, argv);

app = gnome_app_new("example", "entry widget");
gtk_container_border_width(GTK_CONTAINER(app), 5);

hbox = gtk_hbox_new(FALSE, 0);

/* we now create a Label: */

label = gtk_label_new("Password: ");
gtk_misc_set_alignment(GTK_MISC(label), 0, 1.0);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);

text_entry = gtk_entry_new();
gtk_entry_set_visibility(GTK_ENTRY(text_entry), FALSE);
gtk_box_pack_start(GTK_BOX(hbox), text_entry, FALSE, FALSE, 0);

gtk_signal_connect(GTK_OBJECT(app), "delete_event",
GTK_SIGNAL_FUNC(gtk_main_quit), NULL);
gtk_signal_connect(GTK_OBJECT(text_entry), "activate",
GTK_SIGNAL_FUNC(enter_pressed), text_entry);

gnome_app_set_contents(GNOME_APP(app), hbox);
gtk_widget_show_all(app);
gtk_main( );
return 0;
}

Cuando este programa es ejecutado, una ventana de acceso debe de aparecer en la

pantalla. Teclea cualquier texto (asumiendo que es un password), presiona enter y
observa que es los que sucede.

9. Lista y combos.
Las listas y combos juegan el mismo papel que desempeñan en la plataforma Microsoft.
Los widgets lista agrupan una lista de cadenas de caracteres que permiten a los usuarios
seleccionar una o mas entradas; involucrados en esto, los widgets son así configurados.
Las listas son widgets de entrada con un menú emergente agregado que permite a los
usuarios seleccionar las opciones disponibles.

10. menús y barras de herramientas.

Los varios widgets con los que nos hemos encontrado hasta ahora, son simples widgets
que no proveen alguna funcionalidad extraordinaria. Ahora veremos algunas librerías
especificas de programación GNOME que ofrecen widgets mas complicados con una
rica funcionalidad..

Solo espera un segundo, alguien puede preguntar: "Hey, lo estábamos haciendo bastante
bien con código ordinario y todas esas cosas con las que tratamos anteriormente. ¿Cual
es el uso de eso llamado "librerías especificas de programación GNOME"?, ¿son de
verdad útiles? o ¿estas solo incluyéndolas aquí para hacer tu artículo mas grande?"

Bien, esta es la razón para considerar las librerías específicas de programación

GNOME. Con código plano de GTK+, aunque aproximadamente todo puede ser hecho,
y lo cual usualmente se haría usando las librerías especificas de programación GNOME,
pero usando simple y plano código GTK+, a menudo conduce a mucho más código,
repetición y bloques ineficientes entre otras cosas, haciendo que toda la programación
se infle. Ahora, para prevenir que esto suceda, usamos las librerías especificas de
programación GNOME que proveen una gran cantidad de funcionalidades extras y un
mucho menor costo de programación.

Así, hablemos entonces de "menús" y "Barras de herramientas". GNOME nos permite

crear menús y barras de herramientas para nuestros widgets GnomeApp que pueden ser
conectados y desconectados de la ventana. En primer lugar tu llenas arreglos con la
información necesaria, entonces llamas a nome_app_create_menús o
gnome_app_create_toolbar.

Los menús y barras de herramientas tienen cada uno sus propiedades definidas en
arreglos. Algunas de estas propiedades incluyen tipo, string, callback ponter, etc. La
mayor parte del tiempo las entradas a los menús son bastante simples, y podemos usar
una o un conjunto de macros suministradas por GNOME que creara la estructura por
nosotros; Revisemos algunas de las macros mas utilizadas.

NOTA: estas macros son las que crean menús de nivel superior cuando un arreglo es
transmitido conteniendo algunas o todas las siguientes estructuras GnomeUIInfo.

menú Macro

File GNOMEUIINFO_menú_FILE_TREE(tree)

Edit GNOMEUIINFO_menú_EDIT_TREE(tree)

View GNOMEUIINFO_menú_VIEW_TREE(tree)

Settings GNOMEUIINFO_menú_SETTINGS_TREE(tree)

Windows GNOMEUIINFO_menú_WINDOWS_TREE(tree)

Help GNOMEUIINFO_menú_HELP_TREE(tree)

Game GNOMEUIINFO_menú_GAME_TREE(tree)

Dentro de los menús de nivel superior existen más de treinta macros para crear menús
comunes. Las macros asocian pequeñas imágenes (pixmaps) y combinaciones de teclas
para cada opción del menú. Una función Callback es requerida para ser llamada cuando
la opción es seleccionada y un apuntador de datos es pasado a la función.

Miremos algunas de estas opciones comunes y sus respectivas macros.

File -->>
New --> GNOMEUIINFO_menú_NEW_ITEM (label, hint, cb, data)
Open --> GNOMEUIINFO_menú_OPEN_ITEM (cb, data)
Save --> GNOMEUIINFO_menú_SAVE_ITEM (cb, data)
Print --> GNOMEUIINFO_menú_PRINT_ITEM (cb, data)
Exit --> GNOMEUIINFO_menú_EXIT_ITEM (cb, data)

Edit -->>
Cut --> GNOMEUIINFO_menú_CUT_ITEM (cb, data)
Copy --> GNOMEUIINFO_menú_COPY_ITEM (cb, data)
Paste --> GNOMEUIINFO_menú_PASTE_ITEM (cb, data)

Settings -->>
Preferences --> GNOMEUIINFO_menú_PREFERENCES_ITEM (cb, data)

Help -->>
About --> GNOMEUIINFO_menú_ABOUT_ITEM (cb, data)

Al igual que los menús, las barras de herramientas requieren de un arreglo usando la
macro GNOMEUIINFO_ITEM_STOCK (label, tooltip, callback, stock_id). Aquí,
"stock_id" es le identificador de un icono predefinido utilizado para esta opción.

Veamos este sencillo ejemplo, y observa como trabajan los arreglos y macros en
realidad.

#include <gnome.h>

static void callback (GtkWidget *button, gpointer data)

{
g_print("Item Selected");
}

GnomeUIInfo file_menú[ ] = {
GNOMEUIINFO_ITEM_NONE ("A menú item", "This is the Status bar info",
callback),
GNOMEUIINFO_menú_EXIT_ITEM (gtk_main_quit, NULL),
GNOMEUIINFO_END
};

GnomeUIInfo menúbar[ ] = {
GNOMEUIINFO_menú_FILE_TREE (file_menú),
GNOMEUIINFO_END
};
GnomeUIInfo toolbar[ ] = {
GNOMEUIINFO_ITEM_STOCK ("Print", "This is another tooltip", callback,
GNOME_STOCK_PIXMAP_PRINT),
GNOMEUIINFO_ ITEM_STOCK ("Exit", "Exit the application", gtk_main_quit,
GNOME_STOCK_PIXMAP_EXIT),
GNOMEUIINFO_END
};

int main (int argc, char *argv[ ])

{

GtkWidget *app;

gnome_init ("example", "0.1", argc, argv);

app = gnome_app_new ("example", "A Sample Toolbar and menú");

gnome_app_create_menús (GNOME_APP (app), menúbar);

gnome_app_create_toolbar (GNOME_APP (app), toolbar);

gtk_widget_show_all (app);
gtk_main();
return 0;

Este programa crea una pequeña ventana con un menú empotrado y una barra de
herramientas. Puedes hacerle click, fijarlo, liberarlo y arrastrarlo por la pantalla.

11. Cajas de diálogo.

Ahora veamos el widget que despliega información textual a el usuario en el ambiente
GNOME. Si, nos estamos refiriendo a la caja de diálogo. Cuando necesitamos crear
cajas de diálogo, llamamos a la función gnome_message_box_new y le pasamos el
mensaje, también le indicamos el tipo de caja de diálogo que necesitamos, y los botones
que queremos sobre ella. Todo esto es indicado en una lista terminada en NULL.
Entonces ligamos el "click" de la señal del widget de diálogo que hemos creado para
manejar la función que es transmitida a el botón que el usuario ha pulsado como un
entero. Finalmente, llamamos a la función gtk_widget_show para desplegar una caja no
modal.

Veamos este extracto de código de un programa, el cual crea una simple caja de
diálogo, agrega tres botones y responde a el código del usuario..

static void messagebox_clicked(GnomeDialog *dlg, gint button, gpointer data)

{

switch (button)
{
case 1: /* user pressed apply */
return;

case 0: /* user pressed ok */

case 2: /* user pressed close */

gnome_dialog_close(dlg);

GtkWidget *dlg;

dlg = gnome_message_box_new("Hi, pal, how are you doing??? I am fine!",

GNOME_MESSAGE_BOX_QUESTION,
GNOME_STOCK_BUTTON_OK,
GNOME_STOCK_BUTTON_APPLY,
GNOME_STOCK_BUTTON_CLOSE,
NULL);

gtk_signal_connect (GTK_OBJECT(dlg), "clicked",

GTK_SIGNAL_FUNC(messagebox_clicked), NULL);

gtk_widget_show (dlg);

12. Conclusiones y enlaces para estudio posterior.

Esto resume nuestro viaje en el excitante mundo de la programación GNOME usando el
conjunto de herramientas GTK+.

NOTA: la programación GNOME no es en absoluto difícil. Una vez que tienes un poco
de conocimiento, es realmente sencilla de comprender. Aun hay mucho más por
aprender después de este artículo, pero terminado diligentemente, puede ser
definitivamente dominado.

Para más información y cobertura detallada de este tópico, revisa las siguientes
direcciones:

http://www.linuxheadquarters.com/howto/programming/gtk_examples/index.shtml

http://www.ibiblio.org/pub/Linux/docs/HOWTO/mini/other-
formats/html_single/Programming-Languages.html

http://linuxheadquarters.com/howto/programming/gtk_examples/window/window.shtml

http://developer.gnome.org/doc/GGAD/ggad.html

http://wolfpack.twu.net/docs/gtkdnd/index.html
 Subhasísh Ghosh

Tengo 20 años, actualmente estudiante de ingeniería en sistemas computacionales en la

India, soy profesional certificado Microsoft (MCP), MSCD, MCP certificado en NT 4.0
recientemente complete la certificación en ingeniería red hat linux (RHCE). He estado
trabajando con Linux por mucho tiempo, he programado usando C, C++, VC++, VB,
COM, DCOM, MFC, ATL 3.0, Perl, Python y programación Linux usando GTK+.
Actualmente aprendiendo la arquitectura del kernel Linux a detalle y haciendo
programación Linux kernel.