Cómo crear GUI en programación C usando GTK Toolkit

Introducción a GTK

Muchos lenguajes de programación refuerzan la mejora de la GUI como una de las piezas centrales de sus aspectos destacados del lenguaje. C no tiene una biblioteca conectada a él como la biblioteca de strings, la biblioteca IO, etc., que usamos de vez en cuando. Esta debilidad abrió el horizonte para que los ingenieros eligieran entre una amplia variedad de cajas de herramientas de la biblioteca GUI accesibles en C. GTK+ es una de ellas. Representa el kit de herramientas GIMP (Programa de manipulación de imágenes GNU) y se puede utilizar para programar interfaces GUI actuales.

Lo bueno de GTK+ es que es estable , está desarrollado y su punto de partida se remonta a los tiempos pasados ​​de X Windows que estructuran la disposición central de la GUI de Linux en la actualidad. GTK está completamente escrito en C y la programación GTK+ que usamos regularmente en Linux también está escrita en C. Los administradores de escritorio, como GNOME y XFCE , también están hechos con GTK.

Una aplicación GTK+ no se limita a la etapa Linux sino a nadie; es muy posible que también se transfiera a etapas que no sean UNIX/Linux.

Aquí, nos apegaremos al tipo básico de GTK+, que es su avatar C en el escenario de Linux. La página web oficial para descargar GTK+ es https://www.gtk.org . El sitio contiene documentación de API, ejercicios instructivos y otras bibliotecas de Gnome que se utilizan con frecuencia junto con GTK. A decir verdad, GTK se basa en bibliotecas, por ejemplo,

• ATK: esta biblioteca brinda ayuda para crear herramientas de accesibilidad, como teclas adhesivas, lectores de pantalla, etc.
• Glib: es una biblioteca de utilidad universalmente útil que ofrece ayuda para subprocesos, carga dinámica, bucles de eventos, estructuras de datos de bajo nivel, etc.
• GObject: esta biblioteca brinda ayuda orientada a objetos con todas las funciones en C, sin utilizar C++. Esta biblioteca fomenta el enlace de idioma realizado para diferentes idiomas para brindarle un acceso simple a las API de C.
• GdkPixBuf: esta biblioteca brinda capacidades de control de imágenes.
• GDK (GIMP Drawing Toolkit): esta es la biblioteca de diseños que brinda capacidades de dibujo de bajo nivel sobre Xlib.
• Pango: esta biblioteca ayuda en la representación de contenido y diseño.
• Xlib: esta biblioteca proporciona soporte de gráficos de bajo nivel para el sistema Linux

Al componer código con GTK, regularmente encontramos que un número significativo de los tipos de datos primitivos tienen el prefijo ‘ g ‘ como en

• ginebra,
• gchar,
• gcorto,
• puntero g,
• etc.

Estos tipos de datos garantizan que el código se puede volver a compilar en cualquier plataforma sin implementar ninguna mejora. Estos tipos de datos se caracterizan en estas bibliotecas para ayudar a que sea independiente de la plataforma .

Programación GUI inherentemente orientada a objetos, que es el problema principal. En esto, una cosmovisión procedimental no encaja perfectamente en este esquema. Por lo tanto, independientemente de que GTK esté escrito en C, brinda ayuda orientada a objetos a través de GObject . Tenga en cuenta que este elemento de ayuda organizada no tiene nada que ver con C++. C++ tiene su propia biblioteca GTK, llamada gtkmm . GObject fomenta una parte de los principios orientados a objetos, como el polimorfismo y la herencia con la ayuda de macros. El siguiente diagrama ilustra la relación jerárquica.

GtkWindow hereda GtkBin , que a su vez es hijo de GtkContainer ; de esta forma, un objeto de GtkWindow puede llamar a la función definida en GtkBin o GtkContainer. Este es un ejemplo de implementación orientada a objetos en C por GTK.

interfaz gráfica de usuario con GTK

Comprendamos un par de cosas de nuestro primer código GTK en C.

• Para empezar, incorporamos el archivo de cabecera . Esto incorpora todo el archivo que se necesita para crear una GUI, incluida la biblioteca Glib.

  #include <gtk/gtk.h>

• Actualmente, declaramos un puntero a GtkWidget , que es solo una ventana para nuestra situación. Además, otro puntero de GtkWidget será el botón. Revise que GtkWidget es un tipo de almacenamiento de nivel superior para widgets en la jerarquía.

  GtkWidget *window;
  GtkWidget *button;

• A continuación, invocamos la función gtk_init para inicializar las bibliotecas GTK+ pasando los parámetros de la línea de comandos de la función principal.

  gtk_init(&argc, &argv);

• Todas las aplicaciones GTK+ se instalan como tales; es una declaración de “ absoluta necesidad ”. Analiza la línea de argumentos del comando y regresa a la aplicación. En consecuencia, estos parámetros pueden utilizarse para modificar el comportamiento del tiempo de ejecución de la aplicación.
• Ahora, creamos la ventana y el botón.

  window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  button = gtk_button_new_with_label
     ("Click Me!");

• El valor de tipo de ventana GTK_WINDOW_TOPLEVEL implica que la ventana creada será una ventana con marco estándar. Otros valores de clasificación podrían ser GTK_WINDOW_POPUP, lo que implica que se creará una ventana de diálogo sin marco.
• Cuando creamos una ventana, debe poder cerrarse para que el cliente al menos esté listo para cerrar la aplicación porque el cliente presiona la esquina superior derecha para cerrar la ventana. Esto implica que la ventana debe tener la opción de reaccionar ante un evento (cerrar evento).
• Como todos los sistemas de ventanas, GTK+ también ejecuta eventos y controladores de eventos. Dado que el código que transmite la señal es interior a un objeto específico, tenemos que componer una función de devolución de llamada de interfaz.
• La organización de una función de devolución de llamada regular es:

  void my_callback_function(GtkWidget *widget, gpointer data);

• El parámetro principal representa el widget que produce la señal y el parámetro subsiguiente es un puntero vacío que puede utilizarse por cualquier motivo. En este sentido, la función de devolución de llamada para tratar los eventos de cierre de nuestra ventana será la siguiente:

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

• La función gtk_main_quit() cierra la aplicación. En este momento, deberíamos conectar el objeto de la ventana con la función de devolución de llamada.

  g_signal_connect (window, "destroy",
                    G_CALLBACK (destroy),
                    NULL);

• Del mismo modo, hacemos que la función de devolución de llamada se ocupe del evento del botón y lo asocie con el widget del botón.

  void greet( GtkWidget *widget, gpointer data )
  {
     g_print ("Welcome to GTK\n");
     g_print ("%s clicked %d times\n",
        (char*)data, ++counter);
  }
  g_signal_connect (GTK_OBJECT(button), "clicked",
     G_CALLBACK (greet), "button");

• Dado que el widget de botón está contenido dentro de la ventana, debemos agregarlo explícitamente al contenedor.

  gtk_container_add (GTK_CONTAINER (window), button);

• Además, por fin, mostramos los widgets hechos en memoria con la función gtk_widget_show_all() que hace referencia a la ventana que hemos hecho.
• Finalmente, se llama a la función gtk_main() para comenzar el procedimiento interactivo.

  gtk_widget_show_all(window);
  gtk_main();

• Esta es una función clave debido a que normalmente un programa en C finaliza después de ejecutar la última instrucción. Aquí, pasa el control del programa a GTK+ y se mantiene alejado por tiempo indefinido hasta que el cliente activa el evento gtk_main_quit al tocar el botón de cerrar para nuestra situación.

A continuación se muestra la implementación de los pasos anteriores:

#include <gtk/gtk.h>
  
static int counter = 0;
  
void greet(GtkWidget* widget, gpointer data)
{
    // printf equivalent in GTK+
    g_print("Welcome to GTK\n");
    g_print("%s clicked %d times\n",
            (char*)data, ++counter);
}
  
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(window, "destroy",
                     G_CALLBACK(destroy), NULL);
    /* Let's set the border width of the window to 20.
    * You may play with the value and see the
    * difference. */
    gtk_container_set_border_width(GTK_CONTAINER(window), 20);
  
    button = gtk_button_new_with_label("Click Me!");
  
    g_signal_connect(GTK_OBJECT(button),
                     "clicked", G_CALLBACK(greet),
                     "button");
  
    gtk_container_add(GTK_CONTAINER(window), button);
  
    gtk_widget_show_all(window);
  
    gtk_main();
  
    return 0;
}

• Para compilar escriba el siguiente comando (con GCC en Linux)

  gcc main.c -o p1
     `pkg-config --cflags --libs gtk+-2.0`

• Para ejecutarlo escribe el siguiente comando

  ./p1

Conclusión
GTK+ tiene todos los segmentos de GUI que uno necesita para hacer una interfaz de aspecto experto. La idea principal de la programación basada en eventos de GUI con GTK + no es muy diferente de la que aparece en la versión. Agrega algunos elementos más, usa varios tipos de compartimentos, juega con los diseños y, por supuesto, siempre recuerda consultar la documentación de GTK+. Los desarrolladores competentes utilizaban con frecuencia herramientas RAD, como Glade, para planificar rápidamente la interfaz GUI. Sea como fuere, en primer lugar, intente componer el código sin ninguna preparación para tener una idea de qué va, dónde y cómo se hace realmente. Te compensará más tarde.