Xlib

Xlib (également connu sous le nom de libX11 ) est une bibliothèque cliente du protocole X Window System écrite en langage de programmation C. Elle contient des fonctions permettant d'interagir avec un serveur X. Ces fonctions permettent aux programmeurs d'écrire des programmes sans connaître les détails du protocole X.

Peu d'applications utilisent directement Xlib ; elles utilisent plutôt d'autres bibliothèques qui utilisent des fonctions Xlib pour fournir des boîtes à outils de widgets :

• Intrinsèques de la boîte à outils X (Xt)
• Ensemble de widgets Athena (Xaw)
• Motif
• FLTK
• GTK
• Qt (version X11)
• Tk
• SDL (couche DirectMedia simple)
• SFML (Bibliothèque multimédia simple et rapide)

Xlib est apparu vers 1985, et est utilisé dans les interfaces graphiques de nombreux systèmes d'exploitation de type Unix . Une réimplémentation de Xlib a été introduite en 2007 à l'aide de XCB .

Les principaux types de données dans Xlib sont la structure Display et les types des identifiants.

De manière informelle, un écran est un périphérique physique ou virtuel sur lequel des opérations graphiques sont effectuées. La Displaystructure de la bibliothèque Xlib contient des informations sur l'écran, mais surtout des informations relatives au canal entre le client et le serveur. Par exemple, dans un système d'exploitation de type UnixDisplay , la structure contient le handle de fichier du socket de ce canal (celui-ci peut être récupéré à l'aide de la ConnectionNumbermacro). La plupart des fonctions Xlib ont une Displaystructure comme argument car elles opèrent sur le canal ou sont relatives à un canal spécifique. En particulier, toutes les fonctions Xlib qui interagissent avec le serveur ont besoin de cette structure pour accéder au canal. Certaines autres fonctions ont besoin de cette structure, même si elles opèrent localement, car elles opèrent sur des données relatives à un canal spécifique. Les opérations de ce type incluent par exemple les opérations sur la file d'attente des événements, qui sont décrites ci-dessous.

Les fenêtres, les palettes de couleurs, etc. sont gérées par le serveur, ce qui signifie que les données relatives à leur implémentation réelle sont toutes stockées sur le serveur. Le client opère sur ces objets en utilisant leurs identifiants . Le client ne peut pas opérer directement sur un objet, mais peut uniquement demander au serveur d'effectuer l'opération en spécifiant l'identifiant de l'objet.

Les types Windows, Pixmap, Font, Colormap, etc. sont tous des identifiants, qui sont des entiers de 32 bits (comme dans le protocole X11 lui-même). Un client « crée » une fenêtre en demandant au serveur de créer une fenêtre. Cela se fait via un appel à une fonction Xlib qui renvoie un identifiant pour la fenêtre, c'est-à-dire un numéro. Cet identifiant peut ensuite être utilisé par le client pour demander au serveur d'autres opérations sur la même fenêtre.

Les identifiants sont propres au serveur. La plupart d'entre eux peuvent être utilisés par différentes applications pour faire référence aux mêmes objets. Par exemple, deux applications se connectant au même serveur utilisent le même identifiant pour faire référence à la même fenêtre. Ces deux applications utilisent deux canaux différents et ont donc deux structures d'affichage différentes ; cependant, lorsqu'elles demandent des opérations sur le même identifiant, ces opérations seront effectuées sur le même objet.

Les fonctions Xlib qui envoient des requêtes au serveur n'envoient généralement pas ces requêtes immédiatement mais les stockent dans un tampon, appelé tampon de requêtes . Le terme requête dans ce cas fait référence à la requête du client qui est dirigée vers le serveur : le tampon de requêtes peut contenir toutes sortes de requêtes au serveur, pas seulement celles ayant un effet visible sur l'écran. Le tampon de requêtes est garanti d'être vidé (c'est-à-dire que toutes les requêtes effectuées jusqu'à présent sont envoyées au serveur) après un appel aux fonctions XSyncou XFlush, après un appel à une fonction qui renvoie une valeur du serveur (ces fonctions se bloquent jusqu'à ce que la réponse soit reçue), et dans certaines autres conditions.

Xlib stocke les événements reçus dans une file d'attente. L'application cliente peut inspecter et récupérer les événements de la file d'attente. Alors que le serveur X envoie des événements de manière asynchrone, les applications utilisant la bibliothèque Xlib doivent appeler explicitement les fonctions Xlib pour accéder aux événements de la file d'attente. Certaines de ces fonctions peuvent se bloquer ; dans ce cas, elles vident également le tampon de requête.

Les erreurs sont plutôt reçues et traitées de manière asynchrone : l'application peut fournir un gestionnaire d'erreurs qui sera appelé chaque fois qu'un message d'erreur du serveur est reçu.

Il n'est pas garanti que le contenu d'une fenêtre soit conservé si la fenêtre ou une de ses parties est rendue invisible. Dans ce cas, un Exposeévénement est envoyé à l'application lorsque la fenêtre ou une partie de celle-ci est à nouveau visible. L'application est alors censée afficher à nouveau le contenu de la fenêtre.

Les fonctions de la bibliothèque Xlib peuvent être regroupées en :

1. opérations sur la connexion ( XOpenDisplay, XCloseDisplay, ...);
2. les demandes adressées au serveur, y compris les demandes d'opérations ( XCreateWindow, XCreateGC,...) et les demandes d'informations ( XGetWindowProperty, ...) ; et
3. opérations locales au client : opérations sur la file d'attente des événements ( XNextEvent, XPeekEvent, , ...) et autres opérations sur les données locales ( XLookupKeysym, XParseGeometry, XSetRegion, XCreateImage, XSaveContext, ...)

Le programme suivant crée une fenêtre avec un petit carré noir à l'intérieur :

/* 
 Application Xlib simple pour créer une fenêtre et dessiner une boîte à l'intérieur. 
 gcc input.c -o output -lX11 
*/ 
#include <X11/Xlib.h> #include <stdio.h> #include <stdlib.h> #include <string.h> int main ( void ) { Display * display ; Window window ; XEvent event ; char * msg = "Hello, World!" ; int s ; // ouvrir une connexion au serveur display = XOpenDisplay ( NULL ); if ( display == NULL ) { fprintf ( stderr , "Impossible d'ouvrir l'affichage " ); exit ( 1 ); } s = DefaultScreen ( display ); // créer une fenêtre window = XCreateSimpleWindow ( display , RootWindow ( display , s ), 10 , 10 , 200 , 200 , 1 , BlackPixel ( display , s ), WhitePixel ( display , s )); // sélectionner le type d'événements qui nous intéressent XSelectInput ( display , window , ExposureMask | KeyPressMask ); // mapper (afficher) la fenêtre XMapWindow ( display , window ); // boucle d'événements for (;;) { XNextEvent ( display , & event ); // dessiner ou redessiner la fenêtre if ( event . type == Expose ) { XFillRectangle ( display , window , DefaultGC ( display , s ), 20 , 20 , 10 , 10 );
XDrawString ( display , window , DefaultGC ( display , s ), 50,50 , msg , strlen ( msg ) ); } // quitter en appuyant sur une touche if ( event.type == KeyPress ) break ; } // fermer la connexion au serveur XCloseDisplay ( display ); return 0 ; }

Le client crée une connexion avec le serveur en appelant XOpenDisplay. Il demande ensuite la création d'une fenêtre avec XCreateSimpleWindow. Un appel séparé à XMapWindowest nécessaire pour mapper la fenêtre, c'est-à-dire pour la rendre visible à l'écran.

Le carré est dessiné en appelant XFillRectangle. Cette opération ne peut être effectuée qu'après la création de la fenêtre. Cependant, l'effectuer une fois peut ne pas être suffisant. En effet, il n'est pas toujours garanti que le contenu de la fenêtre soit conservé. Par exemple, si la fenêtre est recouverte puis découverte, son contenu peut nécessiter d'être redessiné. Le programme est informé que la fenêtre ou une partie de celle-ci doit être dessinée par la réception d'un Exposeévénement.

Le dessin du contenu de la fenêtre est donc réalisé à l'intérieur de la boucle gérant les événements . Avant d'entrer dans cette boucle, on sélectionne les événements qui intéressent l'application, dans ce cas avec XSelectInput. La boucle événementielle attend un événement entrant : si cet événement est un appui sur une touche, l'application sort ; s'il s'agit d'un événement d'exposition, le contenu de la fenêtre est dessiné. La fonction XNextEventbloque et vide le tampon de requête s'il n'y a pas d'événement dans la file.

Xlib ne fournit pas de support pour les boutons, les menus, les barres de défilement, etc. Ces widgets sont fournis par d'autres bibliothèques, qui utilisent à leur tour Xlib. Il existe deux types de bibliothèques de ce type :

• bibliothèques construites sur la base de la bibliothèque X Toolkit Intrinsics (Xt), qui fournit un support pour les widgets mais ne fournit aucun widget particulier ; des widgets spécifiques sont fournis par des bibliothèques d'ensembles de widgets qui utilisent Xt, telles que Xaw et Motif ;
• bibliothèques qui fournissent des ensembles de widgets en utilisant Xlib directement, sans la bibliothèque Xt, telles que les versions X de GTK , Qt , FLTK et fpGUI .

Les applications utilisant l’une de ces bibliothèques de widgets spécifient généralement le contenu de la fenêtre avant d’entrer dans la boucle principale et n’ont pas besoin de gérer explicitement Exposeles événements et de redessiner le contenu de la fenêtre.

La bibliothèque XCB est une alternative à Xlib. Ses deux objectifs principaux sont : la réduction de la taille de la bibliothèque et l'accès direct au protocole X11. Une modification de Xlib a été réalisée pour utiliser XCB comme couche bas niveau.