Date de publication : 20 Février 2007
Parfois un programme doit faire de gros calculs, et il est utile d’avertir
l’utilisateur sur l'avancement du calcul afin qu’il soit au courant
et ne pense pas que le programme est bloqué. Nous allons donc étudierle
widget GtkProgressBar qui sert justement à cela.
Ce widget étant comme tous les autres widgets de GTK+ sa
fonction de création est très simple :
GtkWidget* gtk_progress_bar_new(void)
Voila, nous avons maintenant notre GtkProgressBar, maintenant
vous avez besoin de ne connaître que peu de fonctions pour la faire marcher.
Tout d'abord nous allons voir comment connaître la position de la GtkProgressBar
:
gdouble gtk_progress_bar_get_fraction(GtkProgressBar *pbar);
Cette fonction renvoie un double qui sera compris entre 0.0 et 1.0, c'est-à-dire
un pourcentage. Pour ce qui est du paramètre pbar, il faut
utiliser la macro de conversion GTK_PROGRESS_BAR().
A l'inverse, pour fixer la position de la GtkProgressBar, la fonction est :
void gtk_progress_bar_set_fraction(GtkProgressBar *pbar, gdouble fraction);
Là aussi, le paramètre fraction doit être
compris entre 0.0 et 1.0.
Notre premier exemple, très simple, sera fait d'une fenêtre (bien entendu) avec à l'intérieur une barre de progression et un bouton qui permettra de faire avancer la barre de progression de 10%. Et lorsque la barre de progression sera à 100%, nous la réinitialiserons à 0%.
| #include <stdlib.h> #include <gtk/gtk.h> void OnButton(GtkWidget *pWidget, gpointer data); int main(int
argc,char **argv) gtk_init(&argc,&argv); pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL); pMainVBox = gtk_vbox_new(TRUE, 0); /* Creation de la barre de progression
*/ pButton = gtk_button_new_with_label("Ajouter 10%"); gtk_widget_show_all(pWindow); g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL); gtk_main(); return EXIT_SUCCESS; void OnButton(GtkWidget *pWidget, gpointer
data) /* Recuperation de la valeur
de la barre de progression */ dFraction += 0.1; if(dFraction > 1.0) /* Modification de la valeur
de la barre de progression */ |
| Résultat :
|
Si nous modifions légèrement le programme précédent
pour insérer une boucle qui fera avancer automatiquement la barre de
progression (par exemple une boucle de 2000 itérations) cela ne fonctionnera
pas. La seule raison pour laquelle cela ne fonctionnera pas est que GTK+
ne reprend pas la main car le programme reste dans la boucle for alors GTK+
ne peut pas mettre à jour les widgets affichés.
La solution, est de dire clairement à GTK+ qu’il doit
remettre à jour grâce à la fonction suivante :
gboolean gtk_main_iteration (void);
Cette fonction permet de faire une itération comme son nom l’indique,
une est une seul donc à ce moment là GTK+ va reprendre
la main puis la rendre aussitôt, si bien qu’il pourra mettre à
jour les widgets. Donc il suffit d’ajouter cette fonction après
gtk_progress_bar_set_fraction pour faire fonctionner correctement
notre programme.
Ce problème étant réglé, nous allons faire face à un deuxième problème, ou plutôt pseudo-problème. En général, lorsque le programme fait un gros calcul, l’application doit être "bloquer" pendant ce temps. Donc tant que le traitement n’est pas fini, il faut éviter que l’utilisateur ne puisse change des données. Prenons le cas d’un correcteur d’orthographe, disons qu’il le fasse automatiquement. Pendant qu’il vérifie l’orthographe il serai bête que l’utilisateur puisse modifier le texte, ce qui fausserai alors toute la correction. Pourquoi cet exemple? Et bien le fait de rendre la main a GTK+ lui donne le pouvoir de traiter d’autres évènements, comme un clic de sourie et autres. Donc à tout moment pendant ce calcul l’utilisateur peut modifier quelque chose (ici pas grand choses si ce n’est que re-cliquer sur le bouton de démarrage de la boucle), donc il faut pouvoir l’empêcher de faire une quelconque action.
Nous allons pouvoir bloquer l'utilisateur à l'aide de ces deux fonctions :
void gtk_grab_add (GtkWidget *widget);
void gtk_grab_remove (GtkWidget *widget);
Nous allons faire une description rapide des ces deux fonctions à l'aide
d'un exemple. Prenons le cas ou l'utilisateur fait dans une application (de
dessin par exemple) une sélection par glissement, quand il quitte la
zone pour atterrir à coté voir en dehors de la fenêtre,
la sélection continue, et bien c’est parce que l’application
se focalise sur la fenêtre de sélection, c’est un peut ce
que fait gtk_grab_add. Nous lui donnons un widget et seuls les
évènements de ce widget seront traiter par GTK+, et cela tant
que gtk_grab_remove n’a pas été invoqué.
Si bien que quand l'utilisateur fait une sélection et qu'il passe au-dessus
d’un autre widget, il est ignorer.
Voilà maintenant nous avons tout pour que pendant la boucle la barre de progression soit remise à jour et sans que l’utilisateur ne puisse cliquer ailleurs.
Nous réutilisons donc l'exemple précédant en modifiant la fonction du bouton qui sert maintenant à démarrer la progression de la barre qui sera effectuer dans la fonction callback.
| #include <stdlib.h> #include <gtk/gtk.h> void OnButton(GtkWidget *pWidget, gpointer data); int main(int
argc,char **argv) gtk_init(&argc,&argv); pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL); pMainVBox = gtk_vbox_new(TRUE, 0); /* Creation de la barre de progression
*/ pButton = gtk_button_new_from_stock(GTK_STOCK_REFRESH); gtk_widget_show_all(pWindow); g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL); gtk_main(); return EXIT_SUCCESS; void OnButton(GtkWidget *pWidget, gpointer
data) /* Initialisation */ /* Ici on grab sur la barre de
progression pour 2 raisons : */ for(i = 0 ; i < iTotal ; ++i) /* On donne
la main a GTK+ */ /* On supprime le grab sur la
barre de progression */ |
| Résultat :
|
| void gtk_progress_bar_set_text (GtkProgressBar *pbar, const gchar *text); |
| Permet d'afficher du texte dans la barre de progression. Entrée(s) : pbar : objet GtkProgressBar. text : texte à afficher. Sortie : rien. |
| G_CONST_RETURN gchar* gtk_progress_bar_get_text(GtkProgressBar *pbar); |
| Permet d'obtenir le texte affiché dans la barre
de progression. Entrée(s) : pbar : objet GtkProgressBar. Sortie : le texte affiché. |
| void gtk_progress_bar_set_orientation(GtkProgressBar *pbar, GtkProgressBarOrientation orientation); |
| Permet de définir le sens de progression de la
GtkProgressBar. Entrée(s) : pbar : objet GtkProgressBar. orientation : une des valeurs suivante *GTK_PROGRESS_LEFT_TO_RIGHT -> de gauche à
droite*GTK_PROGRESS_RIGHT_TO_LEFT -> de droite à
gauche*GTK_PROGRESS_BOTTOM_TO_TOP -> de bas en haut*GTK_PROGRESS_TOP_TO_BOTTOM -> de haut en bas.Sortie : rien |
| GtkProgressBarOrientation gtk_progress_bar_get_orientation(GtkProgressBar *pbar); |
| Permet d'obtenir le sens de progression de la GtkProgressBar. Entrée(s) : pbar : objet GtkProgressBar. Sortie : le sens de progression. |
