Date de publication : 20 Février 2007
Nous allons dans ce chapitre étudier un style de fenêtre particulier : les boîtes de dialogue. Elles permettent de demander à l'utilisateur des informations ou alors d'afficher des messages. Ces boîtes de dialogue ressemblant fortement à des fenêtres classiques, il est normal que le widget GtkDialog dérive directement de GtkWindow.
La saisie d'information via le widget GtkEntry ne s'effectue presque jamais dans la fenêtre principale mais dans une boîte de dialogue. Nous allons donc voir comment créer une telle boîte.
Comme nous pouvons le voir sur l'image ci-dessus, une boîte de dialogue est constituée de trois éléments :
GtkVBox globale (en rouge) qui contiendra tous les widgets
affichés ;GtkHSeparator (en vert) qui sert de séparation entre
la zone de saisie et la zone des boutons ;GtkHBox (en bleu) qui contiendra les boutons de réponse.On peut donc ainsi distinguer deux zones différentes :
GtkHSeparator ;GtkHSeparator.La fonction de création est un peu plus complexe que d'habitude :
GtkWidget* gtk_dialog_new_with_buttons(const gchar *title, GtkWindow *parent, GtkDialogFlags flags, const gchar *first_button_text, ...);
Le premier paramètre title n'est autre que le titre de
la boîte de dialogue.
Le deuxième paramètre parent sert à désigner
la fenêtre parente. Cette valeur peut être égale à
NULL.
Le troisième paramètre flags permet de définir certains
paramètres de la boîte de dialogue. Ce paramètre peut prendre
trois valeurs différentes :
GTK_DIALOG_MODAL : créer une boîte de dialogue
modale, c'est à dire que tant que l'utilisateur n'a pas cliqué
sur un des boutons de réponse, les autres fenêtres seront figées
;GTK_DIALOG_DESTROY_WITH_PARENT : la boîte de dialogue
est détruite si la fenêtre parente est détruite ;GTK_DIALOG_NO_SEPARATOR : la ligne de séparation entre
la zone de travail et la zone de réponse n'est pas affichée.Enfin, le dernier paramètre est plutôt une liste de paramètres permettant de définir les boutons de la boîte de dialogue ainsi que les réponses qui leurs sont associées. Pour chaque bouton que nous voulons ajouter, il faut définir le texte du bouton et le type de réponse qui sera envoyé lorsque nous cliquerons sur le bouton.
Le texte du bouton peut, comme pour tous les boutons, être un texte normal,
un texte avec raccourci (Rappel : c'est de la forme "_Quitter") ou
même un GtkStockItem.
La valeur de la réponse, peut être un élément de
type GtkResponseType ou bien une valeur entière positive
que nous pouvons définir nous-même. Le plus simple étant
bien sûr d'utiliser les valeurs classiques définis par le type
GtkResponseType dont voici la liste :
GTK_RESPONSE_NONE ;GTK_RESPONSE_REJECT ;GTK_RESPONSE_ACCEPT ;GTK_RESPONSE_DELETE_EVENT ;GTK_RESPONSE_OK ;GTK_RESPONSE_CANCEL ;GTK_RESPONSE_CLOSE ;GTK_RESPONSE_YES ;GTK_RESPONSE_NO ;GTK_RESPONSE_APPLY ;GTK_RESPONSE_HELP.Une fois que tous les boutons ont été définis, il faut
le dire à notre fonction de création. Pour cela, il suffit de
terminer la liste des paramètres par NULL.
La majeure partie des éléments de la boîte de dialogue
sont maintenant créés. Il reste cependant à ajouter les
éléments de la zone de travail pour que la boîte soit complète.
Une fois que tous les éléments à ajouter dans la zone de
travail sont créés, il suffit de les ajouter dans la boîte
de dialogue avec la fonction gtk_box_pack_start.
La question est maintenant de savoir comment passer la GtkVBox
en paramètre à la fonction gtk_box_pack_start. Nous
allons tout simplement utiliser l'opérateur -> pour l'élément
GtkDialog de cette manière :
GTK_DIALOG(nom_de_la_boite)->vbox;
La boîte de dialogue est maintenant complète.
L'affichage de la boîte de dialogue comporte deux étapes. Tout
d'abord, il faut demander d'afficher tout le contenu de la GtkVBox qui est inclut
dans la boîte de dialogue avec la fonction gtk_widget_show_all.
Ensuite il faut afficher la boîte de dialogue en elle-même et attendre la réponse de l'utilisateur avec cette fonction :
gint gtk_dialog_run(GtkDialog *dialog);
Le paramètre de cette fonction étant de type GtkDialog
il faut utiliser la macro de conversion GTK_DIALOG().
Cette fonction affiche l'intégralité de la boîte de dialogue,
mais rentre aussi dans une boucle récursive qui ne s'arrêtera que
lorsque l'utilisateur cliquera sur un des boutons. La valeur de retour correspond
à la valeur associée au bouton cliqué. Si, par hasard,
l'utilisateur quitte la boîte de dialogue en cliquant sur la croix de
celle-ci, gtk_dialog_run renvoie GTK_RESPONSE_NONE.
Une fois la valeur de retour connue, il ne reste plus qu'à agir en conséquence.
L'exemple de ce chapitre est constitué d'une fenêtre principale
dans laquelle nous allons ajouter un GtkButton et un GtkLabel.
Lorsque l'utilisateur clique sur le GtkButton, une boîte de dialogue apparaîtra
et demandera à l'utilisateur de saisir son nom.
Cette boîte de dialogue sera constituée d'une GtkEntry,
d'un GtkButton "OK" et d'un GtkButton "Annuler".
Si l'utilisateur clique sur "OK" le contenu de la GtkEntry
sera copié dans le GtkLabel de la fenêtre principale
tandis que s'il clique sur "Annuler" on affichera "Vous
n'avez rien saisi." dans le GtkLabel.
| #include <stdlib.h> #include <gtk/gtk.h> static
GtkWidget *pLabel; void lancer_boite(void); int main(int
argc, char **argv) gtk_init(&argc, &argv); pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
pVBox = gtk_vbox_new(TRUE, 0); pButton = gtk_button_new_with_label("Cliquez
ici pour saisir votre nom"); pLabel = gtk_label_new(NULL); /* Connexion du signal
"clicked" pour ouvrir la boite de dialogue */ gtk_widget_show_all(pWindow); gtk_main(); return EXIT_SUCCESS;
void lancer_boite(void) /* Creation de la boite
de dialogue */ /* Creation de la zone
de saisie */ /* Affichage des elements
de la boite de dialogue */ /* On lance la boite de
dialogue et on recupere la reponse */ /* Destruction de la boite
de dialogue */ |
| Résultat :
|
Comme nous venons de le voir, le widget GtkDialog permet d'accélérer la programmation de simple fenêtre de saisie. Pour ce qui est de l'affichage de message, GTK+ offre un nouveau widget qui dérive directement de GtkDialog : le widget GtkMessageDialog. Ce widget permet de créer une boîte de dialogue complète avec une seule fonction.
L'unique fonction de ce widget est la fonction permettant de créer la boîte de dialogue :
GtkWidget* gtk_message_dialog_new (GtkWindow *parent, GtkDialogFlags flags, GtkMessageType type, GtkButtonsType buttons, const gchar *message_format, ...);
Les paramètres parent et flags sont identiques
à ceux du widget GtkDialog, nous ne reviendrons donc pas
dessus et allons nous concentrer sur les nouveaux paramètres.
Le tout premier type, permet de définir le texte qui sera
affiché dans la barre de titre de la boîte de dialogue ainsi que
l'icône correspondant. Ce paramètre est de type GtkMessageType
et peut prendre une des quatre valeurs suivantes :
| Valeur | Titre de la boîte de dialogue | Icône |
| GTK_MESSAGE_INFO | Information |  |
| GTK_MESSAGE_WARNING | Avertissement |  |
| GTK_MESSAGE_QUESTION | Question |  |
| GTK_MESSAGE_ERROR | Erreur |  |
Le deuxième nouveau paramètre buttons permet de définir les boutons qui seront présents en bas de la boîte de dialogue. Les valeurs autorisées sont les suivantes :
| Macro | Les boutons | Valeur de retour |
GTK_BUTTONS_NONE |
Aucun bouton | Néant |
GTK_BUTTONS_OK |
Un bouton Ok | GTK_RESPONSE_OK |
GTK_BUTTONS_CLOSE |
Un bouton Fermer | GTK_RESPONSE_CLOSE |
GTK_BUTTONS_CANCEL |
Un bouton Annuler | GTK_RESPONSE_CANCEL |
GTK_BUTTONS_YES_NO |
Un bouton Oui Un bouton Non |
GTK_RESPONSE_YES |
GTK_BUTTONS_OK_CANCEL |
Un bouton Ok Un bouton Annuler |
GTK_RESPONSE_OK |
Et le dernier paramètre message_format est tout simplement
le texte qui sera affiché à l'intérieur de la boîte
de dialogue. Ce texte peut être formaté comme il est possible de
le faire avec la fonction printf.
Nous allons créer une fenêtre comportant deux boutons. Le premier permettra d'afficher les informations habituelles d'une boîte de dialogue "A propos...". Le deuxième offrira la possibilité de quitter le programme, en passant par une demande de confirmation à l'utilisateur.
| #include <stdlib.h> #include <gtk/gtk.h> void
on_about_btn(GtkWidget *pBtn, gpointer data); int main(int
argc, char **argv) gtk_init(&argc,&argv); pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
pVBox = gtk_vbox_new(TRUE,0); pAboutBtn = gtk_button_new_with_label("A
propos..."); pQuitterBtn = gtk_button_new_from_stock (GTK_STOCK_QUIT); gtk_widget_show_all(pWindow); gtk_main(); return EXIT_SUCCESS;
void on_about_btn(GtkWidget *pBtn, gpointer
data) /* Creation de la boite
de message */ /* Affichage de la boite
de message */ /* Destruction de la boite
de message */ void on_quitter_btn(GtkWidget* widget, gpointer
data) /* Creation de la boite
de message */ /* Affichage et attente
d une reponse */ |
| Résultat :
|
| GtkWidget* gtk_dialog_new(); |
| Permet de créer un boîte de dialogue vierge. Entrée(s) : rien. Sortie : pointeur sur la boîte de dialogue. |
| void gtk_dialog_add_buttons(GtkDialog *dialog, const gchar *first_button_text, ...); |
| Ajoute des boutons à la boîte de dialogue. Entrée(s) : dialog : la boîte de dialogue. first_button_text, ... : texte et réponse des boutons. Sortie : rien. |
| GtkWidget* gtk_dialog_add_button(GtkDialog *dialog, const gchar *button_text, gint response_id); |
| Ajoute un bouton à la boîte de dialogue. Entrée(s) : dialog : la boîte de dialogue. button_text : texte du bouton. response_id : valeur de retour du bouton . Sortie : pointeur sur le nouveau bouton. |
| gboolean gtk_dialog_get_has_separator(GtkDialog *dialog); |
| Pour savoir si la boîte de dialogue possède
une barre de séparation. Entrée(s) : dialog : la boîte de dialogue. Sortie : TRUE si la barre de séparation est présente, FALSE sinon. |
| void gtk_dialog_set_has_separator(GtkDialog *dialog, gboolean setting); |
| Définit si la boîte de dialogue possède
une barre de séparation Entrée(s) : dialog : la boîte de dialogue en question setting : TRUE pour l'ajouter, FALSE sinon. Sortie : rien. |
