Utilizaremos tres archivos para organizar nuestras fuentes. Estos serán main.c, hello.c y hello.h. A continuación explicaremos lo que incluiremos en cada uno de estos archivos.
En este archivo incluiremos nuestra función main que dará inicio a la ejecución del programa.
Contendrá las funcionalidades de nuestro proyecto, que en este caso solo serán las que correspondan al botón, además de la función que crea la ventana de acuerdo a lo definido en la interfaz.
Corresponde a la cabecera de nuestro proyecto, donde definiremos las funciones que utilizaremos.
Comenzaremos escribiendo nuestro archivo hello.c. Lo primero que debemos hacer es incluir las bibliotecas que vamos a necesitar en el proyecto.
Luego definiremos la función que finalizará el loop principal de programa. Esta contiene
solo una llamada a gtk_main_quit()
. Eventualmente, para proyectos de
mayor envergadura, en esta función se pueden realizar todas las operaciones necesarias
antes de finalizar el programa. Es por eso que creamos esta función y no conectamos
directamente el botón con
gtk_main_quit ()
.
Ahora analizaremos la función que toma la ventana definida en el archivo hello.glade y la conecta con los objetos widgets que manejaremos utilizando libglade.
GtkWidget * hello_create_main (void) { GtkWidget *window_main; GtkWidget *button_close; GladeXML *xml_window_main; gchar *file_glade; file_glade = g_strdup_printf ("%s%c", HELLOLIBGLADE_DATA_DIR, G_DIR_SEPARATOR); file_glade = g_strconcat (file_glade, "hello.glade", NULL); xml_window_main = glade_xml_new (file_glade, "main", NULL); g_free (file_glade); glade_xml_signal_autoconnect (xml_window_main); window_main = glade_xml_get_widget (xml_window_main, "main"); button_close = glade_xml_get_widget (xml_window_main, "button_close"); g_signal_connect (G_OBJECT (window_main), "delete_event", G_CALLBACK (hello_quit_program), NULL); g_signal_connect (G_OBJECT (button_close), "clicked", G_CALLBACK (hello_quit_program), NULL); return window_main; }
Este proyecto tiene dos widgets que son de nuestro interés. La ventana principal, y el
botón window_main
nos permitirá vincular la
ventana main del archivo hello.glade con el programa, y
button_close
será utilizado para conectar el botón
con la función hello_quit_program ()
que
hemos definido anteriormente.
Para poder conectar el objeto window_main
con la ventana main definida
en el archivo hello.glade debemos crear un objeto GladeXML y
vincularlo con el respectivo archivo. Para eso usamos la función
fname
y en particular la ventana
root
, si es que se especifica una, y retorna un puntero al nuevo objeto
GladeXML (o NULL en caso de error) vinculado a dicha ventana.
En nuestra función, vinculamos el objeto xml_window_main
con la ventana
main en el archivo hola/src/glade/hello.glade. Con lo que ya tenemos
acceso directo a los componentes de dicha ventana.
Para aumentar la flexibilidad del programa, utilizamos una macro
HELLOLIBGLADE_DATA_DIR
para referirnos a la ubicación del archivo
hello.glade (esta macro está definida en el archivo
Makefile.am), junto con la macro G_DIR_SEPARATOR
,
que representa un '/' en sistemas basados en Unix, y un '\' en sistemas Windows. El uso de
estas macros es fundamental en la portabilidad del proyecto a distintas plataformas.
la función xml_signal_autoconnect()
busca coincidencias entre los
manejadores de señales definidos en la interfaz y los símbolos en la aplicación, para
luego conectar dichas señales con estos símbolos.
Luego conectamos mediante glade_xml_get_widget()
los objetos
GtkWidget del botón y de la ventana con los Widgets definidos en la interfaz. Aquí
utilizamos la referencia a la ventana main definida en la interfaz mediante el objeto
xml_window_main ()
.
Cuando una ventana es cerrada mediante una combinación de teclas o presionando el botón
hello_quit_program ()
.
Luego conectamos la señal 'clicked' del botón button_close
con la
función hello_quit_program ()
.
De este modo nuestra ventana principal es completamente funcional y está lista para ser
llamada. Ahora retornamos la ventana ya lista para ser levantada desde la función
main
, que a continuación explicaremos.
Este archivo fuente contendrá la función main
de nuestro proyecto,
que será la que dará inicio a la ejecución del programa.
Necesitaremos los siguientes bibliotecas:
#include <gtk/gtk.h> #include <gnome.h> #include <glade/glade.h> #include "hello.c" int main (int argc, char* argv[]) { GtkWidget *window_main; gtk_init(&argc, &argv); gnome_program_init ("hellolibglade", VERSION, LIBGNOMEUI_MODULE, argc, argv, GNOME_PARAM_APP_DATADIR, HELLOLIBGLADE_DATA_DIR, NULL); window_main = hello_create_main (); gtk_widget_show (window_main); gtk_main (); return 0; }
Antes que nada, llamamos a la función gtk_init ()
que se encarga de
inicializar todo lo necesario para utilizar las herramientas de GTK, y recibe algunos
argumentos estándares (como es común, en argc
y
argv[]
) que pudieran venir de la ejecución desde la linea de comandos,
por ejemplo, de nuestro programa.
Básicamente, lo que esta función hace es mostrar la ventana window_main
que es construida por la función hello_create_main ()
.
Una vez que esta ventana es mostrada, iniciamos el ciclo gtk_main ()
que solo se detendrá con una llamada a la función gtk_main_quit ()
.
Vagamente hablando, la ejecución de main
se mantendrá en
gtk_main ()
hasta que gtk_main_quit ()
sea
llamada, entonces seguirá con la ejecución para encontrarse con el
return 0;que finalizará la ejecución de nuestro programa.
En este archivo definiremos las funciones que hemos creado en hello.c. Obviamente, el contenido de este archivo es