Xlib

De Wikipedia, la enciclopedia libre
Saltar a: navegación, búsqueda
Xlib
Logo de X.Org Foundation
Desarrollador
X.Org Foundation
www.x.org
Documentación
Información general
Lanzamiento inicial 1985
Última versión estable 1.5.0
6 de junio de 2012[1]
Género Biblioteca gráfica
Programado en C
Sistema operativo Unix like
Plataforma X Window System
Licencia Licencia de The Open Group[1]
Estado actual activo
En español No No
[editar datos en Wikidata ]

Xlib es una biblioteca que reúne un conjunto de funciones y macros realizadas en el lenguaje de programación C y utilizadas por un cliente para hacer de interfaz con el servidor gráfico de X Window System.[1] En resumen, es una interfaz de programación de bajo nivel para X11. Xlib está basada en la filosofía de eventos (o mensajes). La biblioteca apareció alrededor del 1985. Algunas aplicaciones utilizan directamente Xlib, sin embargo es muy común que se utilicen bibliotecas que a la vez la utilizan, entre ellas se encuentran: X Toolkit Intrinsics (Xt), Xaw, XView, Motif, GTK+, Qt (versión para X11), Tk.

Xlib proporciona un método relativamente sencillo para realizar peticiones de protocolo X al servidor. Incluye funciones para realizar más livianamente las tareas más frecuentes, permitiendo al programador no usar el protocolo X para dichas tareas. Proporciona rutinas para facilitar la labor de crear y manipular recursos básicos (ventanas, contextos gráficos,...), el dibujo de elementos gráficos (botones, líneas,...) o generar la entrada y salida de texto, entre otros.

Tipos de datos[editar]

Xlib y otras bibliotecas que la utilizan.

Los tipos de datos principales en Xlib están en la estructura Display[2] y en los tipos de los identificadores.

Display, que viene del inglés y en español es pantalla, informalmente significa un dispositivo físico o virtual donde se realizan las operaciones gráficas. La estructura Display en la biblioteca Xlib contiene información acerca de la pantalla, aunque también contiene información acerca del canal entre el cliente y el servidor gráfico. Por ejemplo, en un sistema operativo unix-like, la estructura Display contiene un manipuladar de archivo del socket de ese canal (que se puede recuperar usando la macro ConnectionNumber.) La mayoría de las funciones de Xlib tienen una estructura Display como uno de los argumentos para permitirle operar en un canal en específico. En particular, todas las funciones de Xlib que interactúan con el servidor gráfico necesitan de esta estructura para acceder al canal. Algunas otras funciones necesitan de esta estructura, aunque operen localmente, porque operan sobre datos relativos a un canal en específico. Operaciones de esta clase incluyen por ejemplo operaciones sobre una cola de mensajes.

El servidor maneja las ventanas, los mapas de color, etc., lo cual significa que los datos acerca de su implementación se almacenan en el servidor. El cliente opera sobre esos objetos utilizando identificadores. El cliente no puede actuar directamente sobre un objeto, solo puede pedírselo únicamente al servidor para que éste realice la operación especificada por el identificador de un objeto.

Los tipos Windows, Pixmap, Font, Colormap, etc. son todos identificadores, los cuales son enteros de 32 bits (como los del mismo protocolo X11). Un cliente "crea" una ventana haciendo un pedido al servidor. Esto se realiza haciendo una llamada a una función de Xlib que devuelve un identificador para la ventana, que es, un número. El identificador puede ser usado por el cliente para poder realizar otras operaciones sobre la misma ventana en el servidor.

Los identificadores son únicos para el servidor. La mayoría pueden ser utilizados por diferentes aplicaciones para hacer referencia a los mismos objetos. Por ejemplo, dos aplicaciones se conectan al mismo servidor usando el mismo identificador para referirse a la misma ventana. Estas dos aplicaciones pueden utilizar dos canales diferentes, y tener dos diferentes estructuras Display; sin embargo, cuando hagan un pedido de operación con el mismo identificador, estas se harán sobre el mismo objeto.

Funciones[editar]

Proporcionan a una aplicación la posibilidad de: abrir una presentación X, crear ventanas y escribir en ellas, recuperar eventos y cerrar la presentación. Casi todas las funciones se ejecutan de forma asíncrona y son peticiones enviadas a un buffer de salida. Para el trabajo en modo síncrono se requiere de Xsync tras la función de Xlib que se quiere ejecutar en modo síncrono.

Las funciones de la biblioteca Xlib pueden agruparse en:

  1. operaciones de conexión (XOpenDisplay, XCloseDisplay,...);
  2. requerimientos al servidor, incluyendo requerimientos para operaciones (XCreateWindow, XCreateGC,...) y requerimientos de información (XGetWindowProperty,...); y
  3. operaciones del cliente: de eventos (XNextEvent, XPeekEvent,...) y otras operaciones de datos locales (XLookupKeysym, XParseGeometry, XSetRegion, XCreateImage, XSaveContext,...)

Archivos de encabezados[editar]

Los archivos de encabezado son:

# include <X11/Xlib.h>
# include <X11/Xutil.h>
# include <X11/Xos.h>

Convenios de nombres de funciones y estructura de datos[editar]

Funciones y macros[editar]

Se encadenan palabras, la primera letra de cada una de ellas en mayúsculas. Ejemplo: NumeroDias. El nombre de las funciones empiezan con X mayúsculas. El nombre de las macros jamás lo hace.

Símbolos externos de X[editar]

Las variables están expresadas en minúsculas, y en las macros se utilizan todas mayúsculas. Los nombres compuestos son separados por el guion bajo "_"

Órdenes de los argumentos en las llamadas a funciones[editar]
  1. Presentación: El argumento Display, si aparece, siempre es el primero en la lista de los argumentos.
  2. Ventanas, fuentes y otros recursos X: El contexto Gráfico siempre va detrás de todos los de este tipo.
  3. Fuente y destino: Algunas funciones toman algo de uno o más argumentos (fuentes), y depositan el resultado en otros (destino). Las fuentes van antes del destino.
  4. x, y anchura y altura: (x, y son las coordenadas) El orden de aparición es tal cual se muestra.
  5. Máscara de bits: Para cambiar algún miembro de la estructura se debe utilizar una máscara de bits. Si una función tiene una máscara de bits como argumento, la máscara precede al puntero de la estructura.

Errores[editar]

Hay funciones en Xlib que devuelven un entero (resourceID), este referencia a objetos del servidor X (Window, Font, Pixmap, Colormap, Cursor y Gcontext) Hay funciones que devuelven un entero, si se encuentra a cero puede considerarse un error.

Interacción con el Protocolo X[editar]

El protocolo X tiene una arquitectura cliente/servidor. Se pueden transferir cuatro tipos de paquetes mediante este protocolo:

  1. Peticiones: el cliente solicita algo al servidor.
  2. Réplicas: las envía el servidor al cliente para responderle a determinadas peticiones.
  3. Eventos: el servidor se los envía al cliente y el cliente indicará para cada ventana que eventos quieren recibir.
  4. Errores: los envía el servidor

Casi todas las rutinas en Xlib son peticiones. Xlib encola dichas peticiones con lo que el cliente puede continuar ejecutándose. Esto se debe a que la gran parte de las llamadas a Xlib no requieren de una respuesta inmediata. Si hay algún problema: buffer lleno, petición de evento,… las peticiones que quedarán en el buffer y no se enviarán al servidor. Xlib envía el buffer al completo en las siguientes situaciones:

  1. Cuando una aplicación llama a una rutina que espera un evento y la cola de eventos no contiene ninguno del tipo que se solicitó
  2. En los caso de las rutinas Query, Fetch o Get. Pues se requiere la información del servidor inmediatamente.
  3. Se envía manualmente el buffer con: Xflush (Display *d) (vacía el buffer de peticiones y las envía al servidor) o Xsync (Display *d Bool discardEvents) (vacía el buffer de salida y espera a que las peticiones sean atendidas por el servidor X)

Ejemplo[editar]

El siguiente programa crea una ventana con un pequeño cuadrado negro dentro:

 /*
   Aplicación simple que usa Xlib, una ventana con un cuadrado negro en su interior
 */
 
 #include <X11/Xlib.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 int main(void) {
   Display *d;
   Window w;
   XEvent e;
   char *msg = "¡Hola, Mundo!";
   int s;
 
                        /* abrir la conexión con el servidor gráfico*/
   d = XOpenDisplay(NULL);
   if (d == NULL) {
     fprintf(stderr, "No se pudo conectar al servidor gráfico\n");
     exit(1);
   }
 
   s = DefaultScreen(d);
 
                        /* crea la ventana */
   w = XCreateSimpleWindow(d, RootWindow(d, s), 10, 10, 100, 100, 1,
                           BlackPixel(d, s), WhitePixel(d, s));
 
                        /* selecciona la clase de eventos que interesan */
   XSelectInput(d, w, ExposureMask | KeyPressMask);
 
                        /* muestra la ventana */
   XMapWindow(d, w);
 
                        /* lazo de eventos */
   while (1) {
     XNextEvent(d, &e);
                        /* dibujar o redibujar la ventana */
     if (e.type == Expose) {
       XFillRectangle(d, w, DefaultGC(d, s), 20, 20, 10, 10);
       XDrawString(d, w, DefaultGC(d, s), 50, 50, msg, strlen(msg));
     }
                        /* salir si se presionó una tecla */
     if (e.type == KeyPress)
       break;
   }
 
                        /* cerrar la conexión al servidor gráfico */
   XCloseDisplay(d);
 
   return 0;
 }

El cliente crea una conexión con el servidor llamando a la función XOpenDisplay. Luego pide la creación de la ventana con XCreateSimpleWindow. Una llamada más, a XMapWindow, se necesita para mapear la ventana en la pantalla, es decir para que sea visible.

El cuadrado se dibuja llamando a XFillRectangle. Esta operación solo puede realizarse cuando la ventana se crea. Sin embargo una vez realizado esto no es suficiente, de hecho, el contenido de la ventana no siempre está garantizado que se preserve. Por ejemplo, si la ventanta es cubierta o descubierta, se necesita que su contenido sea redibujado. El programa está informado de que la ventana o parte de ella debe dibujarse o redibujarse mediante la recepción de un evento Expose.

El redibujado del contenido está dentro de un lazo para eventos. Antes que entre a este lazo, se establece la clase de eventos de la aplicación, en este caso se realiza con la llamada a XSelectInput. El lazo de evento espera por la llegada de un evento: si el evento es una tecla presionada, la aplicación termina; si el evento es Expose, se redibuja el contenido de la ventana. La función XNextEvent bloquea y vuelca el buffer requerido si no hay ningún evento en la cola.

Otras bibliotecas[editar]

Xlib provee lo fundamental para interactuar con el servidor X, pero utilizar sólo Xlib puede llegar a ser muy complicado. Por ello, se han ido construyendo interfaces de más alto nivel como: Xt (X Toolkit Intrinsics) y sus derivados (Motif y Xaw), Qt o GTK+.

La biblioteca de XCB está recomendada por X.Org como reemplazo de Xlib, ya que provee un acceso de bajo nivel más eficiente y simple, y no se recomienda el uso de Xlib para nuevos desarrollos.[3]

Véase también[editar]

Referencias[editar]

Bibliografía[editar]

Enlaces externos[editar]