Dopo aver salvato il codice in un file di estensione .c, rechiamoci nel terminale, spostiamoci (mediante il comando cd) nella cartella in cui risiede il file e copiamo il seguente codice:

gcc -Wall -g codice.c -o eseguibile `pkg-config --cflags --libs gtk+-2.0`

Premiamo invio e se tutto va a buon fine il terminale non dovrebbe restituire nulla.
Ricordate di cambiare codice.c con il nome del vostro file e eseguibile con un nome che volete dare all’eseguibile.

Ora è possibile lanciare l’eseguibile con:

./eseguibile

oppure recandoci nella cartella dove esso risiede ed effettuando un doppio click sul file che riporta lo stesso nome.

E’ importante tenere presente che i parametri pkg-config –cflags –libs gtk+-2.0 devono essere racchiusi tra apici inversi. Questo carattere si ottiene dalla combinazione su tastiera AltGr + ‘

Bene! Dopo questo preambolo in stile zen possiamo iniziare il cammino per studiare come dare vita al nostro codice C grazie alle gtk.

E’ doveroso, prima di cominciare, spiegare cosa sono le gtk.

GTK+ (acronimo di GIMP ToolKit) è il nome di un insieme di strumenti grafici, basati sulla libreria libgtk, che permette di programmare e creare interfacce grafiche con lo steso stile di quelle che normalmente vediamo in ambiente Gnome. Qualora vorreste iniziare a programmare con tali librerie bisogna prima soddisfare le dipendenze installando libgtk2.0-dev presente nei repository di tutte le distro.

Ora possiamo iniziare a vedere un semplicissimo codice che genera una finestra standard 200×200 pixel.

#include 

int main (int argc, char *argv[])
{
    GtkWidget *window;

    gtk_init(&argc, &argv);

    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_widget_show(window);

    gtk_main();

    return 0;
}

Iniziamo con l’analizzare riga per riga il codice appena scritto.

Per prima cosa bisogna importare mediante #include il file contenente le funzioni e le strutture su cui si basano le gtk+; il file gtk/gtk.h, infatti, deve essere presente in ogni software che basa la propria interfaccia su questa libreria.

Mediante la dichiarazione di gtkWidget si ottiene un elemento di tipo finestra (window appunto) che potrà essere successivamente manipolato attraverso i suoi metodi.

Con gtk_init(&argc, &argv) si inizializzano tutti i parametri mediante alcuni argomenti da riga di comando che sono noti a tutti i programmi gtk. E’ possibile, infatti, passare da terminale alcuni parametri che si potrebbero definire standard e che sono uguali per qualsiasi software che sfrutti queste librerie. Essi sono: –display, –debug-level, –no-xshm, –sync, –show-events e –no-show-event.
Il nostro programma al suo avvio andrà alla ricerca di questi parametri e qualora ne incontri qualcuno, lo legge, lo usa, lo elimina dall’array argv[] e decrementa argc. In questo modo alla fine di questo processo sarà possibile analizzare gli argomenti eventualmente passati dall’utente come si faceva prima di usare le gtk.

La riga window = gtk_window_new(GTK_WINDOW_TOPLEVEL) crea la finestra sfruttando una inizializzazione simile a quella presente in linguaggi come il C++.

Gtk_widget_show(window) si limita a mostrare la finestra appena creata.

Dopo le inizializzazioni dei nostri elementi, si incontra la chiamata a gtk_main(). Tale funzione non fa altro che dirci che il codice a finito di creare l’interfaccia e che è in attesa che in X accada qualche evento da gestire (ad esempio la pressione di un tasto della tastiera o un doppio click del mouse).

Infine si pone un return 0 come si era abbituati per restiuire l’intero dichiarato all’inizio del nostro main se l’applicazione si chiude senza problemi.

Questo è solo un semplice esempio. Per quanto stupido possa essere esso contiene le basi per capire il funzionamento iniziale di queste librerie. Si vdrà più avanti qualche esempio più “corposo”.

Alla prossima 🙂