Cours GTK 2

Date de publication : 20 Février 2007

Précédent Sommaire Suivant Version PDF (Miroir) Version hors-ligne (Miroir)

Les boutons (partie 1)

Nous allons cette fois nous intéresser à un élément essentiel d'une interface graphique : le bouton. En effet celui-ci permet à l'utilisateur d'effectuer une action grâce à un simple click de souris. GTK+ nous permet de les utiliser grâce au widget GtkButton :

1. Création et affichage d'un bouton.

Dans ce chapitre, notre objectif sera de créer une application contenant un bouton qui permettra de quitter l'application.

1.1 Créer un bouton avec du texte.

Dans un premier temps, nous allons déclarer un pointeur vers une structure GtkWidget afin de pouvoir ensuite créer le bouton.

GtkWidget *pQuitBtn;

Ensuite, il faut initialiser le bouton. Pour cela, GTK+ permet l'utilisation de quatre fonctions différentes :

GtkWidget* gtk_button_new(void);
GtkWidget* gtk_button_new_with_label(const gchar *label);
GtkWidget* gtk_button_new_with_mnemonic(const gchar *label);
GtkWidget* gtk_button_new_from_stock(const gchar *stock_id);

La première fonction permet de créer un bouton vide. Cela permet de personnaliser complètement le bouton car GtkButton dérive de GtkContainer. On peut donc inclure n'importe quel type de widget dans le bouton (label, image, ...).

La deuxième fonction s'occupe en plus d'insérer un label à l'intérieur du bouton. Le paramètre label correspond au texte à afficher. Comme pour le widget GtkLabel, si un caractère accentué est utilisé, il faudra appeler la fonction g_locale_to_utf8 pour avoir un affichage correct du texte (voir IV. Les labels pour plus de précision).

La troisième fonction ajoute à cela une nouvelle fonctionnalité. Elle permet, en plus d'afficher un label, de faire réagir le bouton à l'aide d'un raccourci clavier. La touche servant de raccourci est spécifiée dans le paramètre label. Il suffit de mettre "_" devant la lettre souhaitée pour que la combinaison Atl+Touche active le bouton. Par exemple pour l'application de ce chapitre, le texte à afficher sera "Quitter" et si nous voulons que la combinaison de touches Atl+Q permette de quitter l'application, le paramètre label devra être "_Quitter".

La quatrième fonction permet de créer un bouton avec un label, un raccourci clavier et une image. Cependant, pour faire cela, GTK+ utilise les GtkStockItem qui est une structure contenant les informations sur le label et l'image à afficher. GTK+ comporte déjà beaucoup de GtkStockItem prédéfinis (en tout cas les plus courant). Le paramètre stock_id est donc l'identifiant du GtkStockItem à utiliser. Pour notre exemple, l'identifiant est GTK_STOCK_QUIT.

1.2 Quitter l'application en cliquant sur le bouton

Pour cela, nous allons surveiller le signal "clicked" qui est émis lorsque l'utilisateur clique sur le bouton. Lorsque ce signal est reçu nous allons appeler gtk_main_quit pour fermer l'application et détruire tous les widgets. La ligne de code est donc :

g_signal_connect(G_OBJECT(pQuitBtn), "clicked", G_CALLBACK(gtk_main_quit), NULL);

1.3 Affichage dans une fenêtre

Comme pour le chapitre précédent, on utilise la fonction gtk_container_add pour insérer le bouton dans la fenêtre et gtk_widget_show_all pour afficher le tout.

1.4 Programme exemple

#include <stdlib.h>
#include <gtk/gtk.h>

#define EXEMPLE_1 0
#define EXEMPLE_2 1
#define EXEMPLE_3 2

void AddBtn(GtkWidget *pWindow, gint iExemple);

int main(int argc, char **argv)
{
GtkWidget* pWindow;

gtk_init(&argc, &argv);

    /* Creation de la fenetre */
    pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_default_size(GTK_WINDOW(pWindow), 320 ,200);

    /* Connexion du signal "destroy" de la fenetre */
    g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);

/* Insertion du bouton */
AddBtn(pWindow, EXEMPLE_1);

/* Affichage de la fenetre */
gtk_widget_show_all(pWindow);

/* Demarrage de la boucle evenementielle */
gtk_main();

return EXIT_SUCCESS;
}

/*
/* void AddBtn(GtkWidget *pWindow, gint iExemple)
/*
/* Fonction en charge d'inserer le bouton dans la fenetre
/*
/* Parametre :
/* - pWindow : fenetre parente
/* - iExemple : mode de creation
/* EXEMPLE_1 pour un bouton label
/* EXEMPLE_2 pour un bouton EXEMPLE_1 + raccourci
/* EXEMPLE_3 pour un bouton EXEMPLE_2 + image
*/

void AddBtn(GtkWidget *pWindow, gint iExemple)
{
GtkWidget *pQuitBtn;

    switch(iExemple)
    {
    default:
    case EXEMPLE_1:
        /* Bouton avec un label */
        pQuitBtn = gtk_button_new_with_label("Quitter");
        gtk_window_set_title(GTK_WINDOW(pWindow), "Les boutons - Exemple 1");
        break;
    case EXEMPLE_2:
        /* Bouton avec un label et un raccourci */
        pQuitBtn = gtk_button_new_with_mnemonic("_Quitter");
        gtk_window_set_title(GTK_WINDOW(pWindow), "Les boutons - Exemple 2");
        break;
    case EXEMPLE_3:
        /* Bouton avec un label, un raccourci et une image */
        pQuitBtn = gtk_button_new_from_stock(GTK_STOCK_QUIT);
        gtk_window_set_title(GTK_WINDOW(pWindow), "Les boutons - Exemple 3");
        break;
    }

/* Connexion du signal "clicked" du bouton */
g_signal_connect(G_OBJECT(pQuitBtn), "clicked", G_CALLBACK(gtk_main_quit), NULL);

/* Insertion du bouton dans la fenetre */
gtk_container_add(GTK_CONTAINER(pWindow), pQuitBtn);
}

Résultat :

iExemple = EXEMPLE_1

iExemple = EXEMPLE_2

iExemple = EXEMPLE_3

2. En savoir plus :

2.1 Signaux

activate

Prototype fonction callback :

void user_function 
      (GtkButton *button, gpointer user_data);

Ce signal est émis lorsque le bouton a le focus est que l'on appuie sur la touche "Enter".

enter

Prototype fonction callback :

void user_function 
      (GtkButton *button, gpointer user_data);

Ce signal est émis lorsque le pointeur de la souris entre dans la zone du bouton.

leave

Prototype fonction callback :

void user_function 
      (GtkButton *button, gpointer user_data);

Ce signal est émis lorsque le pointeur de la souris quitte la zone du bouton.

pressed

Prototype fonction callback :

void user_function 
      (GtkButton *button, gpointer user_data);

Ce signal est émis au moment où l'on appuie sur le bouton.

released

Prototype fonction callback :

void user_function 
      (GtkButton *button, gpointer user_data);

Ce signal est émis au moment où l'on relâche le bouton.

2.2 Fonctions documentées

void gtk_button_pressed (GtkButton *button);

Emet le signal "pressed" pour le GtkButton concerné.
Entrée(s) :
button : le bouton.
Sortie : rien.

void gtk_button_released (GtkButton *button);

Emet le signal "released" pour le GtkButton concerné.
Entrée(s) :
button : le bouton.
Sortie : rien.

void gtk_button_clicked (GtkButton *button);

Emet le signal "clicked" pour le GtkButton concerné.
Entrée(s) :
button : le bouton.
Sortie : rien.

void gtk_button_enter (GtkButton *button);

Emet le signal "enter" pour le GtkButton concerné.
Entrée(s) :
button : le bouton.
Sortie : rien.

void gtk_button_leave (GtkButton *button);

Emet le signal "leave" pour le GtkButton concerné.
Entrée(s) :
button : le bouton.
Sortie : rien.

void gtk_button_set_relief (GtkButton *button, GtkReliefStyle newstyle);

Définit le style du bouton.
Entrée(s) :
button : le bouton.
newstyle : style du bouton.
Les différent styles sont :
*GTK_RELIEF_NORMAL (par défaut).

*GTK_RELIEF_HALF.

      *GTK_RELIEF_NONE.

Sortie : rien.

GtkReliefStyle gtk_button_get_relief (GtkButton *button);

Récupère le style du bouton.
Entrée(s) :
button : le bouton.
Sortie : GtkReliefStyle.

void gtk_button_set_label (GtkButton *button, const gchar *label);

Modifie le texte d'un bouton.
Entrée(s) :
button : le bouton.
label : le texte à afficher.
Sortie : rien.

G_CONST_RETURN gchar* gtk_button_get_label (GtkButton *button);

Récupère le texte d'un bouton.
Entrée(s) :
button : le bouton.
Sortie : const gchar*.

gboolean gtk_button_get_use_stock (GtkButton *button);

Pour savoir si un bouton utilise les GtkStockItem.
Entrée(s) :
button : le bouton.
Sortie : gboolean, TRUE si le bouton utilise un GtkStockItem, FALSE sinon.

void gtk_button_set_use_stock (GtkButton *button, gboolean use_stock);

Définit si le bouton utilise un objet GtkStockItem.
Entrée(s) :
button : le bouton.
use_stock : TRUE pour utiliser GtkStockItem, FALSE sinon.
Sortie : rien.

gboolean gtk_button_get_use_underline (GtkButton *button);

Pour savoir si un bouton utilise un raccourci clavier.
Entrée(s) :
button : le bouton.
Sortie : gboolean, TRUE si le bouton utilise un raccourci, FALSE sinon.

void gtk_button_set_use_underline (GtkButton *button, gboolean use_underline);

Définit le bouton utilise un raccourci clavier.
Entrée(s) :
button : le bouton.
use_underline : TRUE pour utiliser le raccourci, FALSE sinon.
Sortie : rien.

Date de mise à jour : 12 décembre 2002.

Précédent Sommaire Suivant Version PDF (Miroir) Version hors-ligne (Miroir)