Xlib

Da Wikipedia, l'enciclopedia libera.
Xlib
Sviluppatore X.Org Foundation
Sistema operativo Multipiattaforma
Linguaggio C
Genere Libreria (non in lista)
Licenza Licenza libera
Sito web www.x.org, documentazione

Xlib è una libreria client per il protocollo X Window System, sviluppata in C.

Contiene funzioni per interagire con un server X. Per questi funzioni un programmatore può scrivere programmi senza conoscenza dei dettagli del protocollo. Pochi applicazioni usano Xlib direttamente; invece, impiegano altre librerie che usano le funzioni di Xlib per fornire i toolkit:

X Window System graphics stack

Xlib apparve circa 1985 ed è utilizzato in interfacce grafiche per molti sistemi operativi Unix-like. La libreria XCB è un'alternativa possibile a Xlib. Sebbene in questo momento Xlib è ancora in uso, una realizzazione di Xlib può utilizzare XCB.

Tipi di data[modifica | modifica sorgente]

I primi tipi di data in Xlib sono la struttura Display ed i tipi degli identificatori.

Informalmente, un display è un dispositivo fisico o virtuale, nel quale vengono fatte operazioni grafiche. La struttura Display della libreria Xlib contiene informazione di display, ma più significativamente contiene informazione relativa al canale tra il client ed il server. Ad esempio, in un sistema operativo Unix-like, la struttura Display contiene il handle di file del socket di questo canale (è recuperabile pel macro ConnectionNumber). La maggior parte delle funzioni di Xlib hanno Display come un argomento perché operano canale o sono relative ad uno specifico canale. In particolare, tutte le funzioni di Xlib che interagiscono col server hanno bisogno di questa struttura per avere accesso al canale.

Alcune altre funzioni hanno bisogno di questa struttura perfino se operano localmente, poiché operano data relativa ad un canale specifico. Operazioni di questo tipo includono, ad esempio, operazioni sulla coda degli eventi, descritte di sotto.

Le finestre, i colormap ed altri sono amministrate dal server, che significa che la data della loro attuale realizzazione è tutta depositata nel server. Il client opera questi oggetti per usare i loro identificatori. Non può operare un oggetto, ma solo richiedere al server di compiere l'operazione sull'oggetto specificato dall'identificatore.

I tipi Windows, Pixmap, Font, Colormap sono tutti identificatori, che sono numeri interi a 32 bit (come nello stesso protocollo di X11). Un client crea una finestra per richiedere al server di crearla. Questo è fatto per una chiamata di una funzione di Xlib, la quale restituisce un identificatore della finestra, cioè un numero. Questo identificatore può essere utilizzato dal client per richiedere altre operazioni sullo stesso oggetto.

Gli identificatori sono unici al server. La maggior parte di loro può essere utilizzata da diverse applicazioni per riferirsi agli stessi oggetti. Ad esempio, due applicazioni connesse allo stesso server usano lo stesso identificatore per riferirsi alla stessa finestra. Queste applicazioni usano due differenti canali, e quindi hanno due differenti strutture di Display; però, quando richiedono operazioni per lo stesso identificatore, queste operazioni saranno fatte sullo stesso oggetto.

Funzioni[modifica | modifica sorgente]

Le funzioni nella libreria di Xlib possono essere raggruppate in:

  1. operazioni su connessione (XOpenDisplay, XCloseDisplay, ...);
  2. richieste al server, incluse richieste per operazioni (XCreateWindow, XCreateGC, ...) e richieste per informazione (XGetWindowProperty,...);
  3. ed operazioni locali del client: operazioni sulla coda degli eventi (XNextEvent, XPeekEvent, ...) ed altre operazioni su data locale (XLookupKeysym, XParseGeometry, XSetRegion, XCreateImage, XSaveContext, ...)

Esempio[modifica | modifica sorgente]

Il seguente programma crea una finestra con un piccolo nero quadrato in essa.

 /*
  * Un'applicazione semplicistica Xlib disegnante un quadrato in una finestra.
  * gcc input.c -o output -lX11
  */
 
#include <X11/Xlib.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
int main()
{
    Display *display;
    Window window;
    XEvent event;
    char *msg = "Hello, World!";
    int s;
 
    /* apri una connessione col server */
    display = XOpenDisplay(NULL);
    if (display == NULL)
    {
        fprintf(stderr, "Cannot open display\n");
        exit(1);
    }
 
    s = DefaultScreen(display);
 
    /* crea una finestra */
    window = XCreateSimpleWindow(display, RootWindow(display, s), 10, 10, 200, 200, 1,
                           BlackPixel(display, s), WhitePixel(display, s));
 
    /* sceglie gli eventi che ci interessano */
    XSelectInput(display, window, ExposureMask | KeyPressMask);
 
    /* mostra la finestra */
    XMapWindow(display, window);
 
    /* event loop */
    while (1)
    {
        XNextEvent(display, &event);
 
        /* disegna o ridisegna la finestra */
        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));
        }
        /* esce con una pressione di un tasto */
        if (event.type == KeyPress)
            break;
    }
 
    /* chiude la connessione al server */
    XCloseDisplay(display);
 
    return 0;
 }

Il client crea una connessione col server per chiamare XOpenDisplay. Esso quindi richieste creazione di una finestra con XCreateSimpleWindow. Chiamata di XMapWindow fa la finestra visibile.

Il quadrato è disegnato per chiamata di XFillRectangle. Questa operazione può essere compiuto solo poiché la finestra è creata. Però, l'esecuzione può essere insufficiente. Certamente, preservazione del contenuto della finestra non è garantito. Ad esempio, se la finestra sia coperta e poi è scoperta di nuovo, il suo contenuto possa richiedere di essere ridisegnato. Il programma viene informato che la finestra o la sua parte deve essere disegnata quando riceve un evento Expose.

Il disegno del contenuto della finestra è fatto nell'loop degli eventi. Prima di entrare questo loop, gli eventi che interessano l'applicazione vengono scelti per XSelectInput. L'event loop attende un evento entrante: se l'evento sia una pressione di un tasto, l'applicazione viene chiuda, se sia un evento di esporre, il contenuto della finestra viene ridisegnato. La funzione XNextEvent blocca e scarica il buffer se non ci sia un evento nella coda.

Voci correlate[modifica | modifica sorgente]

Altri progetti[modifica | modifica sorgente]

Collegamenti esterni[modifica | modifica sorgente]