Xlib

Xlib
software
Schermata di esempio
Schermata di esempio
GenereLibreria di C
SviluppatoreX.Org Foundation
Data prima versione1985
Ultima versione1.8.10 (28 luglio 2024)
Sistema operativoMultipiattaforma
LinguaggioC
LicenzaExpat license, licenza X11 e Historical Permission Notice and Disclaimer
(licenza libera)
Sito webwww.x.org, documentazione
Modifica dati su Wikidata · Manuale

Xlib è una libreria per il protocollo X Window System, sviluppata in C. Contiene funzioni usabili da un client per interfacciarsi con il server grafico. Tramite queste funzioni i programmatori possono scrivere codice senza conoscere i dettagli del protocollo. Poche applicazioni usano Xlib direttamente; generalmente impiegano altre librerie che usano le funzioni di Xlib per fornire i blocchi logici per costruire l'interfaccia:

Xlib fece la sua comparsa circa nel 1985 ed è utilizzata nelle interfacce grafiche di molti sistemi operativi Unix-like. La libreria XCB è un'alternativa a Xlib.

Tipi di dato

Xlib e il suo ruolo nella pila grafica

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

Informalmente lo schermo è un dispositivo, fisico o virtuale, sul quale si effettuano operazioni grafiche. La struttura Display contiene informazioni sullo schermo, ma soprattutto relative al canale tra il client ed il server. Ad esempio, in un sistema operativo Unix-like, la struttura Display contiene il puntatore al file del socket del canale (è recuperabile tramite la macro ConnectionNumber). La maggior parte delle funzioni di Xlib hanno una struttura Display come argomento perché operano sul 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 anche se operano localmente, perché operano su dati relativi ad un canale specifico. Operazioni di questo tipo includono, ad esempio, operazioni sulla coda degli eventi, descritte di sotto.

Le finestre, le mappe di colore ed altri sono amministrati dal server, che significa che i dati della loro istanza attuale sono tutti nel server. Il client opera su questi oggetti tramite i loro identificatori. Non si può operare direttamente su un oggetto, ma solo richiedere al server di compiere l'azione sull'oggetto specificato dall'identificatore.

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

Gli identificatori sono unici per il server. Per la maggior parte possono essere utilizzati da diverse applicazioni per riferirsi agli stessi oggetti. Ad esempio, due applicazioni connesse allo stesso server possono usare lo stesso riferimento per specificare la stessa finestra. Queste applicazioni usano due diversi canali, e quindi hanno due strutture Display separate; però, quando richiedono un'operazione usando lo stesso identificatore, questa sarà praticata sullo stesso oggetto.

Funzioni

Le funzioni nella libreria di Xlib possono essere raggruppate in:

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

Esempio

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

 /*
  * Un'applicazione base con 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;
 
    /* apre 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);
 
    /* ciclo per eventi */
    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 la 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 invocando XOpenDisplay. In seguito richiede la creazione di una finestra con XCreateSimpleWindow. La chiamata di XMapWindow rende la finestra visibile.

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

Per questo motivo il disegno del contenuto della finestra è fatto in un ciclo di eventi. Prima di entrare nel ciclo gli eventi di interesse vengono scelti, in questo caso con XSelectInput. Il ciclo degli eventi attende un evento entrante: se l'evento è la pressione di un tasto, l'applicazione viene chiusa, se è un evento di esposizione (la finestra è visibile), il contenuto viene ridisegnato. La funzione XNextEvent blocca e svuota il buffer se non ci sono eventi in coda.

Voci correlate

Altri progetti

Collegamenti esterni

  Portale Informatica: accedi alle voci di Wikipedia che trattano di informatica