3. Archivos Fuente

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.

main.c

En este archivo incluiremos nuestra función main que dará inicio a la ejecución del programa.

hello.c

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.

hello.h

Corresponde a la cabecera de nuestro proyecto, donde definiremos las funciones que utilizaremos.

3.1. hello.c

Comenzaremos escribiendo nuestro archivo hello.c. Lo primero que debemos hacer es incluir las bibliotecas que vamos a necesitar en el proyecto.


	#include <gtk/gtk.h>
	#include <glade/glade.h>
	#include "hello.h"
	

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 close con gtk_main_quit ().


	void
	hello_quit_program (void)
	{
		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 close. Es por eso que definimos dos objetos para manejar cada uno de estos. En particular, 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 close 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

GladeXML* glade_xml_new(const char *fname, const char *root, const char *domain);

que se encarga de abrir el archivo 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 X en la parte superior derecha de ésta, se activa su señal 'delete_event'. Para especificar que queremos finalizar la ejecución del programa cuando esto suceda, conectamos esta señal con la funció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.

3.2. main.c

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.

3.3. hello.h

En este archivo definiremos las funciones que hemos creado en hello.c. Obviamente, el contenido de este archivo es


	GtkWidget *hello_create_main(void);
	void hello_quit_program(void);