GTK, desarrollo de interfaces gráficas (II)

    Para poder ahondar en la programación de interfaces gráficas con GTK es necesario tener un buen conocimiento de todos los objetos que podemos crear, sus características y todos las señales/eventos ante las cuales pueden reaccionar. Esta lista es muy extensa y únicamente te remito a la referencia de GTK2 para que puedas consultarlo segun tus necesidades.

    Sin embargo hay muchas mas características de las librerías que necesitamos conocer para realizar aplicaciones mas completas. Hare un pequeño resumen algunas de estas funciones.

boolean gtk_init_check(&argc, &argv)

    Te permite verificar antes de ejecutar gtk_init que se va poder inizializar sin problemas GTK, es decir que la llamada a gtk_init no fallara.

g_signal_handler_disconnect( gpointer object, gulong id);

    Elimina el registro de un determinado evento en tu aplicación. g_signal_connect y g_signal_connect_swapped retornan el valor id que se debe utilizar en esta función como parámetro.

    Tambien puedes deshabilitar y habilitar el registro de un evento utilizando estas funciones

g_signal_handler_block (gpointer object, gulong id);

g_signal_handler_block_by_func (gpointer object, GCallback func, gpointer data);

g_signal_handler_unblock (gpointer object, gulong id);

g_signal_handler_unblock_by_func (gpointer object, GCallback func, gpointer data);

    Para poder modificar el titulo de una ventana, suponiendo que window es una ventana:

gtk_window_set_title (GTK_WINDOW (window), “Nuevo titulo”);

    Creacion de una caja (elemento invisible que puede contener varios objetos)

GtkWidget *box;

    box es ahora un objeto

box = gtk_hbox_new (FALSE,0);

    box es ahora una objeto tipo caja horizontal, los objetos que contendrá se colocaran uno al lado del otro de izquierda a derecha o a la inversa segun los parámetros que se le pasen o:

gtk_vbox_new (FALSE,0);

    La caja vertical con los objetos uno encima del otro, de arriba a abajo o a la inversa.

    Siendo window un objeto ventana incluimos la caja en la ventana como siempre con:

gtk_container_add(GTK_CONTAINER (window,box);

    ahora creamos y asignamos las señales a los objetos que deseamos añadir a la caja cuando tengamos listo CADA objeto ejecutamos esto

gtk_box_pack_start (GTK_BOX(box), button, TRUE, TRUE, 0);

    suponindo que button es un objeto claro y:

gtk_widget_show(button);

    Atencion: Podemos reutilizar la variable button después de esto para definir otros objetos.

    Finalmente ejecutamos

gtk_windget_show(box);

    y

gtk_widget_show(window);

    Aqui tenemos un ejemplo completo:

#include

/* Our new improved callback. The data passed to this function
* is printed to stdout. */
static void callback( GtkWidget *widget,
gpointer data )
{
g_print (“Hello again – %s was pressed\n”, (gchar *) data);
}

/* another callback */
static gboolean delete_event( GtkWidget *widget,
GdkEvent *event,
gpointer data )
{
gtk_main_quit ();
return FALSE;
}

int main( int argc,
char *argv[] )
{
/* GtkWidget is the storage type for widgets */
GtkWidget *window;
GtkWidget *button;
GtkWidget *box1;

/* This is called in all GTK applications. Arguments are parsed
* from the command line and are returned to the application. */
gtk_init (&argc, &argv);

/* Create a new window */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

/* This is a new call, which just sets the title of our
* new window to “Hello Buttons!” */
gtk_window_set_title (GTK_WINDOW (window), “Hello Buttons!”);

/* Here we just set a handler for delete_event that immediately
* exits GTK. */
g_signal_connect (G_OBJECT (window), “delete_event”,
G_CALLBACK (delete_event), NULL);

/* Sets the border width of the window. */
gtk_container_set_border_width (GTK_CONTAINER (window), 10);

/* We create a box to pack widgets into. This is described in detail
* in the “packing” section. The box is not really visible, it
* is just used as a tool to arrange widgets. */
box1 = gtk_hbox_new (FALSE, 0);

/* Put the box into the main window. */
gtk_container_add (GTK_CONTAINER (window), box1);

/* Creates a new button with the label “Button 1”. */
button = gtk_button_new_with_label (“Button 1”);

/* Now when the button is clicked, we call the “callback” function
* with a pointer to “button 1” as its argument */
g_signal_connect (G_OBJECT (button), “clicked”,
G_CALLBACK (callback), (gpointer) “button 1”);

/* Instead of gtk_container_add, we pack this button into the invisible
* box, which has been packed into the window. */
gtk_box_pack_start (GTK_BOX(box1), button, TRUE, TRUE, 0);

/* Always remember this step, this tells GTK that our preparation for
* this button is complete, and it can now be displayed. */
gtk_widget_show (button);

/* Do these same steps again to create a second button */
button = gtk_button_new_with_label (“Button 2”);

/* Call the same callback function with a different argument,
* passing a pointer to “button 2” instead. */
g_signal_connect (G_OBJECT (button), “clicked”,
G_CALLBACK (callback), (gpointer) “button 2”);

gtk_box_pack_start(GTK_BOX (box1), button, TRUE, TRUE, 0);

/* The order in which we show the buttons is not really important, but I
* recommend showing the window last, so it all pops up at once. */
gtk_widget_show (button);

gtk_widget_show (box1);

gtk_widget_show (window);

/* Rest in gtk_main and wait for the fun to begin! */
gtk_main ();

return 0;
}

    Nos vemos …

GTK, desarrollo de interfaces gráficas (I)

    Este tutorial se basa en el que esta disponible en la pagina oficial de la GTK. Esta dedicado a la versión 2 de GTK+ que es la mas actual en el momento que escribo este mensaje (si lees esto después del 2010 no te olvides de actualizar tus conocimientos).

    Bueno para todos aquellos que nunca han programado en entorno gráfico les dedico el siguiente párrafo.

    Los sistemas gráficos están plagados de ventanas con botones, menús, imágenes, barras de scroll y demás objetos (en GTK todos estos elementos se llaman widgets – traducción cacharro, artilugio. Si, utilizare el termino ingles o la termino objeto) que pueden ser activados/utilizados en cualquier momento. Para poder tratar estos elementos GTK (y otros sistemas para la creación de interfaces gráficas) utiliza un sistema basados en señales/eventos que llaman a funciones que son los que realizan el comportamiento asociado a cada objeto (widget).

    Básicamente una aplicación gráfica en GTK inicia el sistema, crea cada uno de los objetos
que requiere la aplicación (ventanas, botones, etc), asigna los eventos asociados a cada objeto, los muestra por pantalla y deja la aplicación es estado de espera a la llegada de cada uno de esos eventos (también llamados señales aunque no tienen relación alguna con el sistema de señales de Unix).

    Veamos un ejemplo sencillo

#include

static void hello( GtkWidget *widget, gpointer data )
{
g_print (“¡Hola mundo!\n”);
}

static gboolean delete_event(GtkWidget *widget, GdkEvent *event, gpointer data )
{
g_print (“Evento de borrado detectado\n”);
return TRUE;
}

static void destroy(GtkWidget *widget, gpointer data)
{
gtk_main_quit ();
}

int main( int argc, char *argv[] )
{
GtkWidget *window;
GtkWidget *button;

gtk_init (&argc, &argv);

window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

g_signal_connect (G_OBJECT (window), “delete_event”, G_CALLBACK (delete_event), NULL);

g_signal_connect (G_OBJECT (window), “destroy”, G_CALLBACK (destroy), NULL);

gtk_container_set_border_width (GTK_CONTAINER (window), 10);

button = gtk_button_new_with_label (“Hello World”);

g_signal_connect (G_OBJECT (button), “clicked”, G_CALLBACK (hello), NULL);

g_signal_connect_swapped (G_OBJECT (button), “clicked”, G_CALLBACK (gtk_widget_destroy), G_OBJECT (window));

gtk_container_add (GTK_CONTAINER (window), button);

gtk_widget_show (button);

gtk_widget_show (window);

gtk_main ();

return 0;
}

    Para compilarlo en linux con gcc instalado ejecuta esto en una shell. Debes tener instaladas las librerias GTK+-2.0

# gcc hello_world.c `pkg-config –cflags –libs gtk+-2.0`

    Con el sistema X en ejecución puedes ver tu aplicación ejecutando:

#./a.out

    pkg-config es una herramienta que sirve para localizar los directorios donde están situados las librerías y los archivos necesarios para la compilación.

    El programa define 4 funciones, 3 de ellas hello, delete_event y destroy son las funciones que se llamaran cuando se dispare un evento dentro de nuestra ventana. Main es la cuarta funcion. Dentro de ella se crean los objetos (ventana y boton), se inicia el sistema (con gtk_init). GtkWidget declara las variables como objetos (widgets). gtk_window_new y gtk_button_new_with_label crean la ventana y el botón respectivamente.

    Las funciones g_signal_connect y g_signal_connect_swapped registran cada uno de los eventos que deseemos implementar e informan de cual es la función que se ejecutara en cada caso.

    Ademas debemos incluir el botón dentro de la ventana con:

gtk_container_add (GTK_CONTAINER (window), button);

    Finalmente se muestra los objetos utilizando gtk_widget_show

gtk_widget_show (button);

gtk_widget_show (window);

    La aplicación queda a la espera de los eventos con la linea

gtk_main ();

    Las señales que se registran son las siguientes

g_signal_connect (G_OBJECT (window), “delete_event”, G_CALLBACK (delete_event), NULL);

delete_event (ventana) — Se dispara cuando intentamos cerrar la ventana utilizando los controles que estan en la barra de titulo de la ventana (o el botón x de la esquina derecha o en el menú la opción cerrar). En nuestro programa se ejecuta la función “delete_event” que simplemente imprime en consola “Evento de borrado detectado”. En la función delete_event el return TRUE; informa que el evento no precisa llamar a otras funciones para completar su funcionalidad.

    El sistema GTK tiene una implementación por defecto para cada una de las señales/eventos que detecta. Si deseamos que ejecute su implementación por defecto tenemos que o bien no registrar en nuestro programa la señal o si lo hacemos debemos hacer que la función asignada a la señal devuelva TRUE para indicar que no deseamos ejecutar la implementación por defecto. FALSE en caso contrario.

destroy (ventana) — Se llama cuando se destruye el objeto, en nuestro caso la ventana. La función asociada ejecuta simplemente un:

gtk_main_quit ();

    que termina la ejecucion de espera de gtk_main ();

    clicked (botón) — Se ejecuta cuando se hace clic sobre el botón (obviamente) llama a la function hello que imprime el mensaje hola mundo por consola y ademas llama a la función gtk_widget_destroy de la ventana y no del boton, por eso utilizamos la funcion g_signal_connect_swapped en lugar de g_signal_connect ya que el objeto sobre el que actúa el evento no es el mismo que el que lo recibe.

    La función gtk_widget_destroy destruye el objeto ventana y emite la señal “destroy” que llama a nuestra función destroy que a su vez llama a gtk_main_quit (); que termina la ejecución del gtk_main(); en la función main.

    Bueno a partir de aquí y con alguna documentacion de referencia sobre los objetos y los eventos que tenemos a nuestra disposición ya podemos empezar a crear nuestras propias pequeñas aplicaciones.

    Animo y en breve seguire con la saga…

GTK, desarrollo de interfaces gráficas – Presentación

    Bueno este interesante proyecto de librería gráfica de código abierto te permite desarrollar interfaces en una buena cantidad de lenguajes entre los que se incluyen C/C++, perl y python aunque hay muchos mas como por ejemplo el php o C#. El siguiente enlace contiene una lista completa de lenguajes soportados por GTK.

    Su licencia es la LGPL ya que es un proyecto de la GNU (estos chicos son increíbles :D, no os olvideis de llamar GNU/Linux al sistema operativo y Linux al kernel que tiene). En principio GTK se diseño para el desarrollo de aplicaciones/plugins para el GIMP de hay la G que aparece en su nombre (GTK – GIMP toolkit).

    Ademas de para el GIMP GTK es utilizado por una gran cantidad de proyectos, sobre todo para aplicaciones a ejecutar en GNOME, si quieres saber de que es capaz mira una lista de proyectos que utilizan GTK. Aunque GTK también puede desarrollar aplicaciones gráficas para otros sistemas operativos (MAC, Windows …) e interfaces gráficas (como KDE).

    Bueno seguro que estas deseando aprenderlo todo (¡pues vete al siguiente post! ¡a que esperas!).