GNOME - Infraestructura de desarrollo

GNOME es un entorno de escritorio y una infraestructura de desarrollo para sistemas operativos GNU/Linux, Unix y derivados compuesto enteramente de software libre. El proyecto se inició el 15 de agosto de 1997 de la mano de Miguel de Icaza y Federico Mena con el objetivo de crear un entorno de escritorio y aplicaciones compuesto enteramente de software libre.

Por aquel entonces, existía un entorno de escritorio, KDE que estaba basado en el kit de herramientas Qt. El problema es que este kit de herramientas utilizaban una licencia de software propietaria, lo que generaba muchas incertidumbres. Había una preocupación legítima de que la empresa propietaria de Qt, Troll Tech podía cambiar la licencia en cualquier momento y habría dejado a KDE sin una biblioteca base para usar. Los desarrolladores de GNOME contactaron con Troll Tech para proponer un esquema de licencia alternativo para Qt que diera ciertas garantías al usuario mientras mantenía los intereses de su empresa, pero no obtuvieron respuesta.

Este fue uno de los principales motivos por el que los desarrolladores de GNOME decidieron usar GTK+ como base de su desarrollo. GTK+ fue desarrollada inicialmente para implementar la interfaz gráfica del programa de edición de imágenes GIMP, desarrollado por Spencer Kimball, Peter Mattis y Josh MacDonald, estudiantes por aquel entonces de la Universidad de Berkeley en California.

En 2019 GTK+ paso a llamarse GTK.

GTK usa la Licencia Pública General Reducida (LGPL) de GNU, una licencia de software libre que permite que el software que se vincule con ella utilice un conjunto mucho más amplio de licencias, incluidas licencias de software propietario. GNOME está autorizado bajo la LGPL para sus bibliotecas, y la Licencia Pública General de GNU (GPL) para sus aplicaciones.

Librerías GTK/GNOME

Librerías GTK

GTK es una interfaz de programación de aplicaciones (API) orientada a objetos programada en C. Esta implementada con el concepto de clases en mente para crear un sistema extensible que se construya sobre si mismo. Las librerías principales que componen la infraestructura de desarrollo son:

  • GLib es una librería de propósito general que implementa muchas utilidades como manejo de estructuras complejas de datos para C, portabilidad, interfaces para funcionalidades de tiempo de ejecución como ciclos, programación multihilo o carga dinámica entre otras. Entre las estructuras definidas en GLib se incluyen:
    • Fragmentos de memoria
    • Listas vinculadas individualmente
    • Listas doblemente vinculadas
    • Tablas hash
    • Strings (que pueden crecer dinámicamente)
    • Fragmentos de Strings (grupos de strings)
    • Matrices (que pueden crecer en tamaño a medida que se agregan elementos)
    • Árboles binarios balanceados
    • árboles N-ary
    • Quarks (una asociación bidireccional de una cadena (string) y un identificador entero único)
    • Listas de datos con clave (listas de elementos de datos accesibles por una cadena o ID de entero)
    • Relaciones y tuplas (tablas de datos que pueden indexarse en cualquier número de campos)
    • Cachés
  • GObject implementa una interfaz orientada a objetos con todas las funciones en C y permite un fácil acceso a los objetos desde otros lenguajes de programación. Esta librería se distribuye junto a GLib. El sistema orientado a objetos de GObject se implementa en parte por un sistema de tipo genérico y dinámico llamado GType. GType permite a los programadores implementar muchos tipos de datos dinámicos diferentes a través de una estructura de clase de herencia única. GObject proporciona también un sistema de señales, un sistema de propiedades de objetos y gestión de memoria.
  • GIO proporciona varias API para leer y escribir archivos y otros flujos de datos de manera asíncrona. Permite acceso a archivos sobre SFTP, FTP, WebDAV, SMB y otros protocolos. La API esta diseñada para ser usada en interfaces gráficas controladas por eventos. El diseño asíncrono, no bloqueante, significa que su interfaz de usuario no se bloquea esperando un archivo. GIO también proporciona rutinas para gestionar dispositivos y volúmenes, consultar tipos de archivos e iconos y encontrar aplicaciones para abrir archivos. Actualmente también ofrece un API de alto nivel para D-Bus: GDBus.
  • GDK. La GIMP Drawing Kit es una librería de gráficos que encapsula el entorno gráfico de bajo nivel y actúa de intermediario entre X Window/Wayland y GTK. Renderiza dibujos, gráficos raster, cursores y fuentes en todas las aplicaciones GTK. También, como se implementa en todos los programas GTK, GDK proporciona soporte 'arrastrar y soltar' y eventos de ventanas. GDK proporciona a los widgets de GTK la habilidad de dibujar en la pantalla. Los widgets tienen asociado un objeto GdkWindow, que es esencialmente un área rectangular localizada en la pantalla en la que el widget puede dibujar.
  • GdkPixbuf es una pequeña librería que proporciona funciones para la manipulación de imágenes. Las imágenes se pueden cargar desde ficheros o se puede alimentar directamente a las funciones de la librería. GdkPixbuf utiliza un sistema de conteo de referencias, una imagen se puede visualizar en múltiples localizaciones aunque solo esta almacenada una vez en memoria. La librería GdkPixbuf utiliza la librería Libart lo que proporciona la capacidad de cortar, escalar y rotar las imágenes según las necesidades.
  • ATK. La librería Accessibility Toolkit provee a los widgets de GTK con características de facilidad y accesibilidad teniendo en cuenta a las personas con discapacidades o minusvalías. Algunos ejemplos de las capacidades que añade ATK son lectores de pantalla, lupas de aumento, temas de alto contraste, o entradas de datos alternativas al clásico teclado o ratón.
  • Pango. Mientras GDK se encarga de renderizar las imágenes y las ventanas, Pango es la librería encargada del diseño y renderizado de texto. El nombre se origina de la palabra Griega pan que significa 'todo' y la palabra japonesa go que significa 'lenguaje'. Estas fueren escogidas para destacar el objetivo del diseño de Pango de soportar todos los lenguajes creando un sistema de renderizado de fuentes completamente internacional. Todo el texto en Pango se representa internamente en codificación UTF-8. Esta codificación se usa porque es compatible con todo el software mayormente usado en los entornos UNIX. Pango soporta una amplia variedad de atributos de texto, como familia de fuente, estilo, tamaño, anchura, fuerza, color de fondo, color de texto, subrayado, tachado, aumento, forma y escala entre otros.
  • Cairo es una biblioteca gráfica vectorial 2D que soporta múltiples dispositivos de salida. Está diseñada para producir una salida consistente entre plataformas y sistemas. También permite al gestor de ventanas utilizar las ventajas de la aceleración hardware del dispositivo cuando esta disponible.
  • GTK es la librería que contiene los objetos y funciones para crear la interfaz de usuario. Cada interfaz de usuario creada por GTK consta de elementos de la interfaz de usuario conocidos como widgets. Como ya he comentado, la interfaz de programación GTK se basa en la orientación de objetos, los widgets están organizados en una jerarquía de clases. Cada interfaz de usuario se crea agregando botones, etiquetas de texto, campos de entrada, menús desplegables y otros widgets a una ventana. Es posible crear todo el entorno gráfico en formato XML y cargarlo desde la aplicación, lo que permite separar completamente la parte de presentación gráfica de las aplicaciones.

Existen también otras librerías que facilitan el uso de algunas tareas, ofrecen funcionalidad especifica o actúan de API de alto nivel, como:

  • libsoup que es una librería HTTP cliente/servidor
  • WebKitGTK que es un port con todas las funciones del motor de renderizado WebKit adecuado para proyectos que requieren cualquier tipo de integración web
  • EDS (Evolution Data Server): Libreta de direcciones del escritorio para contactos y calendario
  • libsecret para la gestión segura de contraseñas

Para ver una lista más detallada del conjunto de librerías que componen el proyecto visitar Referencias de la API.

Aplicaciones de desarrollo GTK/GNOME

Además de las librerías, el entorno de desarrollo incluye aplicaciones especificas para desarrolladores entre las que se incluyen:

Aplicación GTK/GNOME

Para finalizar vamos a ver un programa básico desarrollado en GTK/GNOME. Una versión de escritorio del clásico 'hola mundo'. Primero vemos la versión en C utilizando las librerías GTK:

/*  
 * holagtkc.c 
 * 
 * (c) Author: David Quiroga 
 * e-mail: david [at] clibre [dot] io 
 *  
 **************************************************************** 
 * Descripción: 
 * 
 * 'Hola mundo' en GTK  
 *  
 * SPDX-License-Identifier: GPL-3.0 
 */ 
 
#include <gtk/gtk.h> 
 
static void 
funcion_button (GtkWidget *widget, 
             gpointer data) 
{ 
    static gboolean hola = TRUE; 
    if(hola == TRUE) { 
        gtk_button_set_label (GTK_BUTTON(widget), "Hola Mundo!"); 
        hola = FALSE; 
    } else { 
        gtk_button_set_label (GTK_BUTTON(widget), "Desde clibre.io"); 
        hola = TRUE;  
    }  
} 
 
static void 
activate (GtkApplication *app, 
            gpointer user_data) 
{ 
    GtkWidget *window; 
    GtkWidget *button; 
    GtkWidget *btsalir;  
    GtkWidget *button_box; 
 
    window = gtk_application_window_new (app); 
    gtk_window_set_title (GTK_WINDOW (window), "Hola GTK"); 
    gtk_window_set_default_size (GTK_WINDOW (window), 350, 140); 
 
    button_box = gtk_button_box_new (GTK_ORIENTATION_VERTICAL); 
    gtk_button_box_set_layout (GTK_BUTTON_BOX(button_box), GTK_BUTTONBOX_EXPAND); 
    gtk_container_add (GTK_CONTAINER (window), button_box); 
 
    button = gtk_button_new_with_label ("Desde clibre.io"); 
    btsalir = gtk_button_new_with_label ("Salir"); 
    g_signal_connect (button, "clicked", G_CALLBACK (funcion_button), NULL); 
    g_signal_connect_swapped (btsalir, "clicked", G_CALLBACK (gtk_widget_destroy), window); 
    gtk_container_add (GTK_CONTAINER (button_box), button); 
    gtk_container_add (GTK_CONTAINER (button_box), btsalir);  
 
    gtk_widget_show_all (window); 
} 
 
int 
main (int argc, 
        char **argv) 
{ 
    GtkApplication *app; 
    int status; 
 
    app = gtk_application_new ("org.comunidadlibre.appc", G_APPLICATION_FLAGS_NONE); 
    g_signal_connect (app, "activate", G_CALLBACK (activate), NULL); 
    status = g_application_run (G_APPLICATION (app), argc, argv); 
    g_object_unref (app); 
 
    return status; 
} 

Para construir la aplicación:

$ gcc -Wall -g `pkg-config --cflags gtk+-3.0` holagtkc.c -o holagtkc `pkg-config --libs gtk+-3.0`

Ahora vamos a utiliar Vala. Vala es un lenguaje de programación compilado, orientado a objetos y centrado en los objetos de la biblioteca GObject. Su diseño permite crear aplicaciones GTK/GNOME de forma rápida y sencilla, sin imponer requisitos de tiempo de ejecución adicionales y sin usar un ABI diferente en comparación con las aplicaciones y bibliotecas escritas en C. Veamos la versión en Vala:

/*  
 * holagtkvala.vala  
 *  
 * (c) Author: David Quiroga  
 * e-mail: david [at] clibre [dot] io  
 *  
 ****************************************************************  
 * Descripción:  
 *  
 * 'Hola mundo' en GTK  
 *  
 * SPDX-License-Identifier: GPL-3.0  
 */ 
 
public class HolaMundo.Window : Gtk.ApplicationWindow { 
    public Window (Gtk.Application app) { 
        Object (application: app); 
 
        this.default_height = 140; 
        this.default_width = 350; 
        this.title = "Hola GTK"; 
        bool hola = true; 
 
        // El contenedor buttonbox 
        Gtk.ButtonBox box = new Gtk.ButtonBox (Gtk.Orientation.VERTICAL); 
        box.set_layout (Gtk.ButtonBoxStyle.EXPAND); 
        this.add (box); 
 
        // Creamos los botones 
        var button = new Gtk.Button.with_label ("Desde clibre.io"); 
        var salir = new Gtk.Button.with_label ("Salir"); 
 
        // Conectamos las acciones al pulsar los botones 
        button.clicked.connect (() => { 
            if (hola == true) { 
                button.label = "Hola Mundo!"; 
                hola = false; 
            } else { 
                button.label = "Desde clibre.io"; 
                hola = true; 
            } 
        }); 
        // y el boton salir 
        salir.clicked.connect (() => { 
            this.destroy (); 
        }); 
 
        box.add (button); 
        box.add (salir); 
 
        this.show_all (); 
    } 
} 
 
int main (string[] args) { 
    var app = new Gtk.Application ("org.comunidadlibre.appvala", ApplicationFlags.FLAGS_NONE); 
    app.activate.connect (() => { 
        var win = app.active_window; 
        if (win == null) { 
            win = new HolaMundo.Window (app); 
        } 
        win.present (); 
    }); 
 
    return app.run (args); 
} 

Para contruir el ejecutable usamos:

$ valac --pkg gtk+-3.0 holagtkvala.vala

Conclusión

Apoya el desarrollo de GNOMEComo usuario de GTK/GNOME desde sus primeras versiones tengo que admitir que el entorno me parece fascinante. El completo sistema de desarrollo de GNOME nos ofrece todas las herramentias necesarias para programar de forma eficaz las apliciones de escritorio. El conjunto de librerías que ofrece la plataforma nos permite no tener que 'reinventar la rueda' en cada proyecto y a su vez poder utilizar todas las caracteristicas de un completo entorno de desarrollo y un moderno escritorio.

El desarrollo base del sistema en C no solo lo hace tremendamente efectivo, sino que favorece la creación de Language Bindings o wrappers, es decir, interfaces de programación que proporcionan un código específicamente diseñado para ser usado desde el lenguaje de programación que elijamos garantizando la estabilidad de la API.

Entre los lenguajes que podemos usar para programar GTK/GNOME están: C, Vala, JavaScript, Python, Rust, C++ o Perl.

Modificado por última vez enViernes, 14 Agosto 2020 19:37
(1 Voto)
Etiquetado como :

Deja un comentario

Asegúrese de introducir toda la información requerida, indicada por un asterisco (*). No se permite código HTML.