4 bits blog

Aunque comencé explicándoos como funcionan las ventanas y los contenedores de GTK+ creo que lo mejor habría sido explicar primero qué son y cómo funcionan los widgets de GTK+. Así que aquí viene una explicación sobre los widgets.

La clase GtkWidget

Es la clase básica de la que parte cualquier otro widget de GTK+, esta clase en sí misma no hace nada específico (por ejemplo: un cuadro de texto, un botón, …) para ello existen clases específicas, como las ventanas o los contenedores. Estas clases más específicas heredan de la clase GtkWidget las funciones, atributos y señales básicas que les hacen ser clases válidas para poder usarse en GTK+.

Partes esenciales de un widget

Como cualquier clase de cualquier lenguaje de programación orientado a objetos, la clase de un widget se divide en:

• Funciones: Son las funciones que permiten trabajar con dicha clase. Aquí las llamo funciones porque estamos trabajando sobre C, si fuera sobre cualquier lenguaje de programación orientado a objetos las llamaría métodos.
• Atributos (o propiedades): Son variables asociadas a la clase que identifican propiedades de ésta, por ejemplo: el color, la altura, …
• Señales: Muchos lenguajes de programación orientada a objetos no usan señales, pero en GTK+ son necesarias para controlar los eventos.
  Las señales identifican el evento que se ha producido, y se deben asociar a alguna función para que GTK+ al interceptar la señal ejecute dicha función, por ejemplo: al pulsar un botón que se escriba un mensaje en un cuadro de texto, la señal sería la pulsación del botón y la función asociada a ella la escritura del mensaje en el cuadro de texto.

De este modo, en la documentación de la API de GTK+, se puede observar que cada widget se descompone en estas partes para que sepamos claramente qué se puede hacer y/o qué tareas realiza dicho widget.

He aquí otro capítulo de esta serie que deje abandonada hace tiempo, ya que cuando uno empieza a trabajar le quedan pocas ganas al llegar a casa de ponerse a pensar, pero resulta que desde hace días me han venido las ganas de revitalizar este blog.

Las ventanas

Las ventanas son los widgets raíces, ya que sin ellas no podría haber aplicación. Hereda las propiedades de GtkContainer, por lo que puede contener a otro widget (¡cuidado! sólo a uno), por lo que lo normal es que dentro de una ventana se introduzca un GtkBox de algún tipo, en el que se coloquen el resto de widgets de la aplicación.

Como veis en el título digo ventanas, y es que hay varios tipos de ventanas:

• GtkDialog: Crea una ventana emergente. Dentro de este tipo de ventanas existen varios tipos predefinidos como el dialogo de “Acerca de”, el de elección de archivo, el de elección de color, …
• GtkInvisible: Crea una ventana invisible.
• GtkMessageDialog: Crea una ventana con un mensaje personalizado, es uno de los tipos predefinidos del GtkDialog. Son las ventanas que muestran mensajes de error, advertencia, …
• GtkWindow: Crea una ventana normal y corriente. Será el widget que se use como base para cualquier aplicación.
• GtkAssistant: Crea un asistente para guiar al usuario en varios pasos.

Como he dicho, de todos estos tipos el más importante es GtkWindow, que es la ventana normal y corriente que tiene cualquier aplicación.

Leer el resto »

A partir de este capítulo intentaré explicaros los widgets, que considero básicos, de GTK+ y a partir de ahí seréis vosotros quienes tengáis que ampliar conocimientos. Pero antes de eso todavía toca explicar una de las características de GTK+, que quizá le hacen algo especial respecto a otros, son los contenedores.

Los contenedores

Una aplicación GTK+ viene definida por un widget de una ventana (que explicaré más adelante) en el cual se colocan los otros widgets (entradas de texto, etiquetas, botones, …) para formar una interfaz gráfica de usuario. La peculiaridad de GTK+ es cómo se colocan dichos widgets, para ello se hacen uso de otros widgets llamados contenedores, éstos sirven para (como su propio nombre indica) contener otros widgets, de modo que para distribuir los widgets por la ventana primero deberemos colocar algún contenedor sobre el cual insertar dichos widgets. Esto hace de GTK+ diferente a otros lenguajes de interfaces gráficas, en los cuales los widgets se colocan por coordenadas.

Hay varios widgets básicos de contenedores:

• GtkHBox: Es un contenedor horizontal, quiere decir que los widgets se colocan horizontalmente.
• GtkVBox: Es un contenedor vertical, quiere decir que los widgets se colocan verticalmente.
• GtkTable: Crea una tabla de MxN contenedores, los widgets se colocan en la posición AxB que queramos dentro de nuestra tabla MxN. Este se diferencia del resto en las funciones usadas para colocar los widgets, usará las suyas propias en lugar de las de GtkBox que explicaré a continuación.

(Como podéis ver os enlazo a la documentación de la API de GTK+ para cada widget, para mí es el mejor recurso de documentación.)

Leer el resto »

Iniciando GTK+

Antes de empezar con otra cosa, voy a explicar como iniciar GTK+ en nuestra aplicación. Los pasos más importantes son los siguientes:

1. Hay que inicializar el toolkit, para ello se llama a la siguiente función:

   gtk_init (int *argc, char **argv[]);

   Esta función se usa para iniciar el toolkit y parsear los parámetros relativos a GTK+ que reciba nuestra aplicación, de modo que GTK+ los use y no nos tengamos de preocupar de parsearlos nosotros, dichos parámetros son eliminados de la lista.

2. Ejecutar el main loop (o bucle principal), éste se encarga de dejar a la aplicación en un bucle, hasta que llamemos a la función de salida de dicho bucle, en el cual se tratan las diferentes señales que se produzcan en nuestra aplicación. Para ello se llama a la siguiente función:

   gtk_main ();

   Para salir del bucle se llama a la siguiente función:

   gtk_main_quit ();

Obviamente, antes de ejecutar el main loop se deberán tener los manejadores de las señales asignados y todas las variables inicializadas, ya que una vez se ejecuta no tendremos control sobre nada de la aplicación.

Leer el resto »

Desde hace tiempo vengo queriendo hacer una serie de posts para explicar (a la vez que yo aprendo) a programar interfaces gráficas usando GTK+, que es el toolkit usado por las aplicaciones de GNOME, aunque es multiplataforma y puede ser usado en varios sistemas operativos (Windows, Mac).

En esta serie de posts no planeo explicar todo al detalle, ya que existen muy buenos documentos para ello, pero sí quiero dar unas nociones básicas para que cualquiera pueda desenvolverse luego y seguir aumentando sus conocimientos sin mucho esfuerzo, además yo voy a ir aprendiendo paralelamente a estos posts, así que puede que tengan fallos, perdonadme por ello.

Introducción: Diseño de interfaces gráficas

Lo primero que quiero es realizar una pequeña introducción al diseño (desde el punto de vista de la programación, eso siempre) de las interfaces gráficas, desde un punto de vista genérico, es decir, sin relación a un lenguaje o plataforma específica.

Una interfaz gráfica es un medio por el cual el usuario trabaja con la aplicación de una manera gráfica, normalmente usando entornos de ventanas. Se diferencia de una interfaz de texto, en que en éstas el usuario trabaja con la aplicación introduciendo texto, normalmente usando órdenes en consolas.

El diseño de una interfaz gráfica se basa en objetos (en GTK+ se les conoce como widgets) como pueden ser botones, cuadros de texto, menús, etc… que permiten realizar acciones específicas. Estos objetos, a nivel de programación, tendrán unas propiedades y, lo más importante, unos eventos (o señales) que se dispararán cuando se realice algún tipo de acción sobre ellos (por ejemplo: se pulsa un botón, se introduce texto en un cuadro de texto, …)

Para mí, lo más importante es entender que estos eventos deben ser tratados inmediatamente, para ello normalmente se relaciona una función y unos datos a un evento, de este modo cada vez que se produzca dicho evento se ejecutará la función junto a los datos que tenga relacionados.

Leer el resto »