Date de publication : 20 Février 2007
Vous pouvez à présent faire interagir l'utilisateur avec des boutons, mais il peut aussi être utile de lui faire saisir des données. Nous allons utiliser pour cela le widget GtkEntry qui défini une zone de texte (une ligne) dans lequel l'utilisateur peut taper du texte ou alors dans lequel le programme peut afficher une information.
Pour créer un GtkEntry, nous avons à notre disposition deux fonctions différentes :
GtkWidget* gtk_entry_new(void);
GtkWidget* gtk_entry_new_with_max_length(gint max);
La première fonction crée un widget GtkEntry de base, tandis
que la seconde permet en plus de définir le nombre maximum de caractère
que l'utilisateur peut taper (paramètre max
de type gint
).
Nous allons maintenant comment utiliser les deux fonctions principales de ce widget.
void gtk_entry_set_text(GtkEntry *entry, const gchar *text);
G_CONST_RETURN gchar* gtk_entry_get_text(GtkEntry *entry);
La première fonction nous permet d'insérer du texte dans le GtkEntry.
Le paramètre entry
correspond bien sur au GtkEntry dans
lequel on veut insérer le texte text
. A noter, que cette
fonction nécessite que entry
soit de type GtkEntry*
,
il faudra donc utiliser la macro de conversion GTK_ENTRY()
.
La deuxième fonction permet de récupérer le texte qui
a été tapé par l'utilisateur dans le GtkEntry entry. La
valeur de retour est de type G_CONST_RETURN gchar*
, c'est à
dire qu'il faudra récupérer le texte dans une variable de type
const gchar*
. De plus, il est inutile d'allouer de la mémoire
pour la variable qui va recevoir le texte, et donc de ne surtout pas libérer
la mémoire car cela rendrait votre application instable.
Comme exemple, nous allons créer une fenêtre comportant un GtkEntry, un GtkButton et un GtkLabel. Le but sera d'afficher le texte du GtkEntry dans le GtkLabel. Cette opération s'effectuera lorsque l'utilisateur appuie sur la touche ENTREE à la fin de sa saisie (interception du signal "activate") ou lorsqu'il cliquera sur le GtkButton (interception du signal "clicked").
Ensuite, les fonctions callback récupèreront le texte du GtkEntry pour l'afficher dans le GtkLabel. Si cette opération ne pose aucun problème pour le signal "activate" du GtkEntry, un problème existe lorsque l'on clique sur le GtkButton.
En effet, pour faire son travail correctement, la fonction callback doit connaître le GtkEntry et le GtkLabel. Dans le cas du signal "activate", le GtkEntry est envoyé en paramètre principal de la fonction callback (widget émetteur du signal) et l'on rajoute le GtkLabel en paramètre supplémentaire. Par contre, pour le signal "clicked", le widget émetteur est le GtkButton et l'on ne pourra passer qu'un seul widget en donnée supplémentaire.
La solution consiste à utiliser les listes du chapitre précédent (VII. Les listes chaînées) ainsi qu'une fonction du widget GtkContainer :
GList* gtk_container_get_children(GtkContainer *container);
Cette fonction crée une liste doublement chaînée contenant
tous les widgets qui ont été insérés dans le widget
container
. Dans notre cas, il nous suffira de passer la GtkBox
contenant tous les widgets à la fonction callback pour avoir accès
à tout ce dont nous avons besoin.
#include <stdlib.h> #include <gtk/gtk.h> void
on_activate_entry(GtkWidget *pEntry, 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); /* Creation du GtkEntry
*/ pButton = gtk_button_new_with_label("Copier"); pLabel = gtk_label_new(NULL); /* Connexion du signal
"activate" du GtkEntry */ /* Connexion du signal
"clicked" du GtkButton */ gtk_widget_show_all(pWindow); gtk_main(); return EXIT_SUCCESS; /* Fonction callback execute lors du signal "activate"
*/ /* Recuperation du texte
contenu dans le GtkEntry */ /* Modification du texte
contenu dans le GtkLabel */ /* Fonction callback executee lors du signal "clicked"
*/ /* Recuperation de la liste
des elements que contient la GtkVBox */ /* Le premier element est
le GtkEntry */ /* Passage a l element
suivant : le GtkButton */ /* Passage a l element
suivant : le GtkLabel */ /* Cet element est le GtkLabel
*/ /* Recuperation du texte
contenu dans le GtkEntry */ /* Modification du texte
contenu dans le GtkLabel */ /* Liberation de la memoire
utilisee par la liste */ |
Résultat : |
Généralement, lorsque nous tapons un mot de passe, nous souhaitons
que celui-ci reste secret. Le widget GtkEntry
permet cela grâce
à cette fonction :
void gtk_entry_set_visibility(GtkEntry *entry, gboolean visible);
Il suffit donc de mettre le paramètre visible
à
FALSE
pour cacher le texte qui sera entré.
A l'inverse, pour savoir si le texte entré sera visible ou pas, il faut utiliser cette fonction :
gboolean gtk_entry_get_visibility(GtkEntry *entry);
La valeur de retour sera, bien sûr, égale à TRUE
si le texte est visible et à FALSE
dans le cas contraire.
Par défaut, lorsque l'on ajoute du texte à un GtkEntry
qui a son paramètre visible
à FALSE
,
GTK+
remplacera toutes les lettres par des '*'. Pour modifier celui-ci,
il faut utiliser cette fonction :
void gtk_entry_set_invisible_char(GtkEntry *entry, gunichar ch);
Le paramètre ch
correspond au caractère de remplacement
que nous souhaitons. Celui-ci est de type gunichar
qui correspond
à l'encodage UCS-4
. Bien que l'affichage de GTK+ se fasse
avec l'encodage UTF-8
, cela ne pose aucun problème car cette
fois-ci, la conversion est faite automatiquement.
Et pour terminer, la fonction permettant de connaître le caractère de remplacement est :
gunichar gtk_entry_get_invisble_char(GtkEntry *entry);
Cette fois, nous allons reprendre l'exemple précédent en activant le mode "mot de passe" et en limitant la saisie à huit caractères. Nous modifierons aussi le caractère de remplacement '*' par '$'.
#include <stdlib.h> #include <gtk/gtk.h> void
on_activate_entry(GtkWidget *pEntry, 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); /* Creation du GtkEntry
avec 8 caracteres maximum */ pButton = gtk_button_new_with_label("Copier"); pLabel = gtk_label_new(NULL); /* Connexion du signal
"activate" du GtkEntry */ /* Connexion du signal
"clicked" du GtkButton */ gtk_widget_show_all(pWindow); gtk_main(); return EXIT_SUCCESS; /* Fonction callback execute lors du signal "activate"
*/ /* Recuperation du texte
contenu dans le GtkEntry */ /* Modification du texte
contenu dans le GtkLabel */ /* Fonction callback executee lors du signal "clicked"
*/ /* Recuperation de la liste
des elements que contient la GtkVBox */ /* Le premier element est
le GtkEntry */ /* Passage a l element
suivant : le GtkButton */ /* Passage a l element
suivant : le GtkLabel */ /* Cet element est le GtkLabel
*/ /* Recuperation du texte
contenu dans le GtkEntry */ /* Modification du texte
contenu dans le GtkLabel */ /* Liberation de la memoire
utilisee par la liste */ |
Résultat : |
activate |
Prototype fonction callback : void user_function(GtkEntry *entry, gpointer user_data); |
copy-clipboard |
Prototype fonction callback : void user_function(GtkEntry *entry, gpointer user_data); |
cut-clipboard |
Prototype fonction callback : void user_function(GtkEntry *entry, gpointer user_data); |
delete-from-cursor |
Prototype fonction callback : void user_function(GtkEntry *entry, GtkDeleteType arg1, gint arg2, gpointer user_data); |
insert-at-cursor |
Prototype fonction callback : void user_function(GtkEntry *entry, gchar *arg1, gpointer user_data); |
move-cursor |
Prototype fonction callback : void user_function(GtkEntry *entry, GtkMovementStep arg1, gint arg2, gboolean arg3, gpointer user_data); |
paste-clipboard |
Prototype fonction callback : void user_function(GtkEntry *entry, gpointer user_data); |
populate-popup |
Prototype fonction callback : void user_function(GtkEntry *entry, GtkMenu *arg1, gpointer user_data); |
toggle-overwrite |
Prototype fonction callback : void user_function (GtkEntry *entry, gpointer user_data); |
void gtk_entry_set_max_length (GtkEntry *entry, gint max); |
Définit le nombre maximum de caractère que
l'utilisateur peut saisir. Entrée(s) : entry : le GtkEntry. max : le nombre de caractère. Sortie : rien. |
gint gtk_entry_get_max_length (GtkEntry *entry); |
Récupère le nombre maximum de caractère
que l'utilisateur peut saisir. Entrée(s) : entry : le GtkEntry. Sortie : le nombre maximum de caractères. |