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.
