Programmazione di GUI con GTK

ArticleCategory:

AuthorImage:

TranslationInfo:

tr to en Özcan Güngör

en to it Alessandro Pellizzari

AboutTheAuthor

Abstract

In questa serie di articoli impareremo come scrivere interfacce grafiche (GUI) con GTK. Non ho idea di quanto durer�. Per capire questi articoli dovreste conoscere le seguenti caratteristiche del linguaggio C:

• Variabili
• Funzioni
• Puntatori

ArticleIllustration:

ArticleBody:

Cos'� GTK?

GTK (GIMP Toolkit) � una libreria per la creazione di Interfacce Utente Grafiche (GUI, Graphical User Interface). � disponibile sotto licenza GPL. Usando questa libreria potete creare programmi open-source, free o commerciali.

La libreria si chiama GIMP Toolkit (GTK) perch� originariamente � stata creata per sviluppare GIMP (General Image Manipulation Program). Gli autori di GTK sono:

• Peter Mattis
• Spencer Kimball
• Josh MacDonald

GTK � un'interfaccia utente orientata agli oggetti. Anche se � scritta in C, usa le idee di classe e funzione di callback.

Compilazione

Per compilare programmi GTK, dovete dire a gcc cosa sono e dove si trovano le librerie GTK. Il programma gtk-config "conosce" queste cose.

L'output di questo comando � simile al seguente (dipende dal sistema):

I parametri hanno il seguente significato:

(NdT: il comando si riferisce alla versione fino alla 1.2 di Gtk+. Dalla versione 2.0 si usa pkg-config con una sintassi diversa)

Per compilare un programma GTK di nome hello.c, si pu� usare il seguente comando:

gcc -o hello hello.c `gtk-config --cflags --libs`

Quello che segue il parametro -o � il nome del programma compilato.

Un primo programma

Assumiamo che GTK sia installato nel vostro sistema. L'ultima versione di GTK pu� essere trovata a ftp.gtk.org.

Scriviamo il nostro primo programma. Questo programma crea una finestra 200x200, vuota.

#include <gtk/gtk.h>

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);
}

GtkWidget � un tipo variabile per definire diverse componenti come finestre, bottoni, etichette... In questo esempio viene definita una finestra nel modo seguente:

void gtk_init(int *argc, char ***argv) inizializza il toolkit, passandogli i parametri scritti nella linea di comando. Questa funzione deve essere usata dopo aver definito i componenti.

GtkWidget *gtk_window_new(GtkWindowType windowtype) crea una nuova finestra. Il tipo di finestra pu� essere:

• GTK_WINDOW_TOPLEVEL
• GTK_WINDOW_DIALOG
• GTK_WINDOW_POPUP

void gtk_widget_show(GtkWidget *widget) viene usato per far apparire il componente nella finestra. Dopo aver definito un componente e averne cambiato gli attributi bisogna usare questa funzione.

void gtk_main(void) prepara le finestre e tutti i componenti per farli apparire sullo schermo. Questa funzione deve essere usata alla fine dei programmi GTK.

Usiamo un po' di propriet� della finestra, come titolo, dimensioni, posizione, ...

void gtk_window_set_title(GtkWindow *window, const gchar *title) viene usata per impostare o cambiare il titolo della window. Il primo parametro della funzione � di tipo GtkWindow. Ma window � di tipo GtkWidget. Durante la compilazione verremo avvisati di questo. Anche se il programma compilato funziona, � meglio correggerlo. GTK_WINDOW(GtkWidget *widget) viene usato per questo motivo. Il secondo parametro title � di tipo gchar. gchar viene definito nella libreria glib ed � la stessa cosa del tipo char.

void gtk_window_set_default_size(GtkWindow *window, gint width, gint height) imposta la dimensione di window. Come gchar, gint viene definito in glib ed � la stessa cosa di int.

void gtk_window_set_position(GtkWindow *window, GtkWindowPosition position)

• GTK_WIN_POS_NONE
• GTK_WIN_POS_CENTER
• GTK_WIN_POS_MOUSE
• GTK_WIN_POS_CENTER_ALWAYS

Ecco un esempio:

#include <gtk/gtk.h>

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

    gtk_init (&argc, &argv);

    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(window),"Ýlk Program");
    gtk_window_set_position(GTK_WINDOW(window),GTK_WIN_POS_CENTER);
    gtk_window_set_default_size(GTK_WINDOW(window),300,300);
    gtk_widget_show  (window);

    gtk_main ();

    return(0);
}

Segnali ed Eventi

Nelle GUI si possono usare mouse e tastiera, per esempio si pu� clickare su un pulsante. Si deve quindi usare la seguente funzione GTK:

guint gtk_signal_connect_object(GtkObject *object, const gchar *name, GtkSignalFu nc func, GtkObject *slot_object);

object � il componente che emette il segnale. Per esempio, se volete sapere quando un pulsante viene clickato, object sar� il pulsante. name � il nome dell'evento e pu� essere:

• event
• button_press_event
• button_release_event
• motion_notify_event
• delete_event
• destroy_event
• expose_event
• key_press_event
• key_release_event
• enter_notify_event
• leave_notify_event
• configure_event
• focus_in_event
• focus_out_event
• map_event
• unmap_event
• property_notify_event
• selection_clear_event
• selection_request_event
• selection_notify_event
• proximity_in_event
• proximity_out_event
• drag_begin_event
• drag_request_event
• drag_end_event
• drop_enter_event
• drop_leave_event
• drop_data_available_event
• other_event

func � il nome della funzione che verr� richiamata quando accadr� l'evento. Ecco un esempio:

#include <gtk/gtk.h>

void close( GtkWidget *widget,gpointer *data)
{
    gtk_main_quit();
}

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

    gtk_init (&argc, &argv);

    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    gtk_signal_connect (GTK_OBJECT (window), "destroy",
                        GTK_SIGNAL_FUNC (close), NULL);
    gtk_widget_show  (window);

    gtk_main ();

    return(0);
}

gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC (close), NULL)

Pi� avanti verranno spiegati i dettagli dei segnali e degli eventi.

Un normale bottone

I bottoni vengono generalmente usati per fare determinate azioni quando vengono clickati. In GTK ci sono due modi per creare i bottoni:

1. GtkWidget* gtk_button_new (void);
2. GtkWidget* gtk_button_new_with_label (const gchar *label);

La prima funzione crea un bottone senza etichetta (non c'� scritto niente dentro il bottone). La seconda crea un bottone con un'etichetta (label viene scritto nel bottone).

Qui useremo una nuova funzione:

void gtk_container_add(GtkContainer *container, GtkWidget *widget)

Usando questa funzione � possibile fare in modo che un bottone (o genericamente un qualsiasi componente) appaia in una finestra (o genericamente un qualsiasi contenitore). Nel prossimo esempio il contenitore � una finestra e il componente � un bottone. Pi� avanti impareremo di pi� sui contenitori.

La cosa pi� importante riguardo i bottoni � sapere se sono stati clickati o meno. Anche qui si usa la funzione gtk_signal_connect. Questa volta chiameremo un'altra funzione che verr� eseguita "dietro" il bottone. Ecco un esempio:

#include <gtk/gtk.h>

void close( GtkWidget *widget,gpointer *data)
{
    gtk_main_quit();
}

void clicked(GtkWidget *widget,gpointer *data)
{
        g_print("Button Clicked\n");
}

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

    gtk_init (&argc, &argv);

    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    gtk_signal_connect (GTK_OBJECT (window), "destroy",
                        GTK_SIGNAL_FUNC (close), NULL);

    button=gtk_button_new_with_label("Button");
    gtk_container_add(GTK_CONTAINER(window),button);
    gtk_signal_connect(GTK_OBJECT(button),"clicked",
                       GTK_SIGNAL_FUNC(clicked),NULL);
    gtk_widget_show(button);

    gtk_widget_show(window);

    gtk_main ();

    return(0);
}