4 bits blog

Si alguna vez habéis tenido que programar algo para funcionar sobre la consola de Linux, a lo mejor os habría gustado poder colorear la salida, como hacen la mayoría de los programas de la consola de Linux.

Pues si vuestra consola admite colores ANSI (casi todas lo hacen, incluso la de Windows), lo tenéis muy fácil ya que mediante unas cadenas de escape se pueden cambiar los colores. Estas cadenas siguen un patrón del tipo:

<ESC>[{attr1};...;{attrn}m

Donde attrX es un código numérico que determina una característica del texto (como subrayado), el color del texto y el color del fondo de éste. Estos código están definidos y se pueden consultar en esta web que contiene las cadenas de escape ANSI.

De este modo, si se quiere cambiar el color del texto, por ejemplo en un programa en C, se haría lo siguiente:

printf ("\e[32m Soy de color verde\n");
printf ("\e[0m Vuelvo a ser del color normal.\n");

Lo normal es que estas cadenas se guarden en algún tipo de constantes, para luego usarlas y no tener que escribir la cadena de escape cada vez que queramos cambiar el color.

(Sacado de zeros and ones)

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 »

Llevo ya tiempo pensando en cambiar mis contraseñas, tengo unas cuantas para diferentes cosas (como debe ser), pero se me están quedando cortas y ya uso la misma para algunas cosas (como no debe ser), así que quiero renovarlas.

Por este motivo, se me ocurrió hacer un pequeño programa (en C) que genera contraseñas aleatorias (llamado passwdgen), con una serie de opciones:

• En base al conjunto alfanumérico (alfabeto en mayúsculas, minúsculas y/o números).
• Longitud mínima y/o máxima personalizable, si se le da una mínima y otra máxima se escogerá una longitud aleatoria entre los valores dados. (La longitud predeterminada es de ocho caracteres)

De este modo, se genera aleatoriamente una cadena de caracteres en base al conjunto de caracteres y la longitud que queramos. Lo he subido a Google Code para que todos podáis hacer uso de él y/o si queréis trastear con el código, está licenciado bajo GPL 2.

Si estáis interesados, visitad la web de passwdgen.

Hace unos días expliqué cómo redirigir la salida de un proceso que ejecutemos desde nuestro programa en Windows, hoy voy a explicar cómo hacerlo en Linux (algo que todos deberías de saber ya).

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>

/* Proceso hijo */
void
do_child (int data_pipe[])
{
    /* Cerramos la parte de la tubería que no usamos (lectura) */
    close (data_pipe[0]);

    /* Tubería de escritura a salida estándar */
    dup2 (data_pipe[1], STDOUT_FILENO);

    /* Ejecutamos el proceso que queramos (p. ej.: ls) */
    execvp ("ls", NULL);

    perror ("execvp");
}

/* Proceso padre */
void
do_parent (int data_pipe[])
{
    char salida[200];
    int nread;

    /* Cerramos la parte de escritura */
    close (data_pipe[1]);

    /* Leemos la salida */
    nread = read (data_pipe[0], salida, 200);
    while (nread > 0) {
        printf ("%s", salida);
        nread = read (data_pipe[0], salida, 200);
    }

    close (data_pipe[0]);
}

int
main (int argc, char* argv[])
{
    int data_pipe[2];
    int pid;
    int rc;       

    rc = pipe (data_pipe);
    if (rc == -1) {
        perror ("pipe");
        exit (1);
    }

    pid = fork ();
    switch (pid) {
        case -1:
            perror ("fork");
            break;

        /* Proceso hijo */
        case 0:
            do_child (data_pipe);
            break;

        /* Proceso padre */
        default:
            do_parent (data_pipe);
            break;
    }

    return 0;
}