Hola de nuevo, les dejo un código basico para entender las bases de la programación de aplicaciones en GTK+, es un típico "Hola Mundo". Viene comentado explicitamente (...).
#include "gtk/gtk.h"
/* Esta es una funcion callback que sera llamada cuando el
boton de nuestra ventana sea presionado, los parametros
no se usaran propiamente dentro de la funcion, pero el
argumento "data" sera usada pasa saber que boton se
presiona */
static void hello( GtkWidget *widget, gpointer data )
{
g_print ("Hola mundo\n");
}
/* La siguiente funcion se usa cuando el manejador de
ventanas envia este evento (delete_event) a la aplicacion.
Nosotros podemos decidir que hara la aplicacion cuando se
llame este evento, se puede ignorar, agregar algun mensaje
de respuesta o simplemente cerrar la aplicacion.
El valor que regrese esta funcion le hara saber a GTK que
accion tomar. Si regresa TRUE le haremos saber que no
queremos que la senal "destroy" sea emitida, manteniendo
la aplicacion corriendo. Regresando FALSE emitimos la senal
"destroy" que sera enviada al manejador de seniales.
Esto puede ser util para mandar mensajes antes de cerrar la
aplicacion. */
static gboolean delete_event(GtkWidget *widget,
GdkEvent *event,
gpointer data )
{
g_print ("delete event occurred\n");
/* Podemos cambiar FALSE a TRUE y ver los resultados. */
return FALSE;
}
/* Otra funcion callback que hace que la aplicacion se cierre
llamando a gtk_main_quit(). */
static void destroy( GtkWidget *widget, gpointer data )
{
gtk_main_quit ();
}
/* Como en todos los programas, en GTK tambien debe haber una
funcion main. */
int main( int argc, char *argv[] )
{
/* Esta parte declara apuntadores a estructuras del tipo
GtkWIdget, que seran usadas para crear nuestra ventana y
nuestro boton. */
GtkWidget *window;
GtkWidget *button;
/* La funcion gtk_init() inicializa el toolkit, y pasa los
argumentos de la linea de comandos. */
gtk_init (&argc, &argv);
/* Creamos una ventana. La memoria se reserva para la
estructura GtkWIdget *window. Prepara la ventana pero no
la despliega aun. La ventana se mostrara cuando se llame
gtk_widget_show(). */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
/* En la siguiente parte se muestran dos maneras de conectar
un manejador de se;ales a un objeto, para el siguiente
caso "window". Aqui "delete_event y "destroy" son
captados. El primero se emite cuando usamos el manejador
de ventana para cerrar la ventana, o cuando usamos la
llamada gtk_widget_destroy() pasando el widget window
como el objeto a destruir. La segunda es emitida cuando
en delete_event regresamos FALSE. G_OBJECT y G_CALLBACK
son macros que realizan un casting, asi como tambien
agregan legibilidad al codigo. */
g_signal_connect (G_OBJECT (window), "delete_event",
G_CALLBACK (delete_event), NULL);
g_signal_connect (G_OBJECT (window), "destroy",
G_CALLBACK (destroy), NULL);
/* La siguiente funcion se usa para definir los atributos
del contenedor de objetos. Solamente fija una ventana
sin contenido con una anchura de 10 pixeles. */
gtk_container_set_border_width(GTK_CONTAINER (window),10);
/* Creamos un boton. Reserva espacio para una nueva
estructura GtkWidget en memoria, la inicializa y hace que
el puntero apunte a ella. Tendra la leyenda "Hola Mundo".
*/
button = gtk_button_new_with_label ("Hola Mundo");
/* Tomamos el boton y hacemos que haga algo cuando se
presiona, se le agrega un manejador de seniales y cuando
emita la senial "clicked" llamara la funcion hello(). */
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (hello), NULL);
/* Tambien usaremos este boton para salir del programa.
Esto muestra como la senial "destroy" se puede enviar por
el manejador de ventana o de nuestro programa. Cuando el
boton se presiona, primero se llama hello(), y despues
esta siguiente en el orden que se coloquen. Se pueden
tener tantas funciones callback como se deseen, y todas
se ejecutaran en el orden que se conecten. Debido a que
gtk_widget_destroy() acepta solamente GtkWidget *widget
como argumento, ussamos g_signal_connect_swapped() en
lugar de g_signal_connect(). */
g_signal_connect_swapped (G_OBJECT (button), "clicked",
G_CALLBACK (gtk_widget_destroy),
G_OBJECT (window));
/* Esta parte le dice a GTK que "button" sera puesto en la
ventana donde deberia ir. Observe que el contenedor GTK
solo puede contener un widget. */
gtk_container_add (GTK_CONTAINER (window), button);
/* Ahora que todo esta fijado de la forma que queremos, con
todos los manejadores de seniales en su lugar, pediremos
a GTK que muestre los widgets en pantalla. El widget
window se desplegara al final de manera que toda la
ventana se desplegara al mismo tiempo, en lugar de ver
primero la ventana y despues el boton en su interior. A
pesar de que esto sucede en realidad, primero despliega
una y despues otra, en este ejemplo no lo notara.*/
gtk_widget_show (button);
gtk_widget_show (window);
/* Por supuesto agregamos la llamada a gtk_main() que espera
eventos del X server y en los widgets esperara que emitan
seniales cuando ciertos eventos ocurran. */
gtk_main ();
/* El regreso final. Se regresa el control despues de que
gtk_main_quit() es llamado. */
return 0;
}
Para compilar este código lo haremos de la siguiente manera:
$ gcc -Wall -g holaMundo.c -o holaMundo `pkg-config --cflags gtk+-2.0` `pkg-config --libs gtk+-2.0`
Cualquier duda, comentario o reclamo, por favor háganmelo saber...Hasta pronto.
