Décompteur de temps

Version imprimable

Décompteur de temps

Bonjour la communauté. :D

Tout d'abord, merci à Franck pour ses explications sur mon précédent long post. (Pour info, j'ai réussi à faire ce que je voulais (charger une image et obtenir la position de la souris))

Cette fois-ci, le sujet de mon post est clair, je voudrais réaliser un décompteur de temps.

Clairement, une fois qu'une image s'affiche, je voudrais :

_soit avoir un label qui se met à jour toutes les secondes du style "il reste 5 secondes", "il reste 4 secondes", etc, en temps réel. Pendant ces 5 secondes, je veux que l'utilisateur ne puisse rien faire à part attendre. J'ai déja essayé de mettre des "sleep(1)" avec des "gtk_widget_show_all(pWindow);" un peu partout mais rien à faire : une fois que j'exécute le pgm, 5 secondes s'écoulent et je vois ma fenêtre uniquement à la fin du décompteur.

_soit éventuellement un popup qui s'ouvre et affiche pareillement "il reste x secondes" toutes les secondes. J'avoue le problème est un peu pareil, si j'arrive pas à mettre à jour un label toutes les x secondes, j'arriverai encore moins à mettre un label à jour dans un popup... :roll:

Je joints un petit bout de code (sur lequel j'ai le problème expliqué) au cas ou ca peut vosu aider...
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 #include <stdlib.h> #include <gtk/gtk.h> int main(int argc,char **argv) { GtkWidget* pWindow; GtkWidget* pLabel; int cpt=5 ; gtk_init(&argc,&argv); gint val; pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(pWindow), "Les labels"); gtk_window_set_default_size(GTK_WINDOW(pWindow), 300, 300); /* Creation du label */ pLabel=gtk_label_new("Hello World!"); /* On ajoute le label a l'interieur de la fenetre */ gtk_container_add(GTK_CONTAINER(pWindow), pLabel); while ( cpt >= 0 ) { val = cpt; gchar *chaine = NULL; chaine = g_strdup_printf ("%d", val); gtk_label_set_label (GTK_LABEL (pLabel), chaine); gtk_widget_show_all(pWindow); sleep(1); g_free (chaine), chaine = NULL; cpt--; } /* Affichage de la fenetre et de tout ce qu'il contient */ gtk_widget_show_all(pWindow); /* Connexion du signal /* On appelle directement la fonction de sortie de boucle */ g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL); gtk_main(); return EXIT_SUCCESS; }

06/03/2007, 20h39
Lunixinclar

Salut,
g_timeout_add() exécute du code toutes les n secondes.
08/03/2007, 15h51
thibane

Salut lunixinclar.

La petite nuance, c'est que moi je veux qu'il ne se passe rien pendant un laps de temps (mais qu'on voit quand même la pWindow avec tout ce qu'elle contient dedans) et non exécuter un code pendant un laps de temps.

Alors peut-être que tu vas me dire que c'est pareil et qu'il suffit de prendre le problème à l'envers mais je te réponds tout de suite que je ne vois pas comment faire... :D

PS : je rapelle ce que fait le programme que j'ai posté plus haut. Au lancement du programme, il n'y a rien à l'écran mais le compteur se décrémente quand même de 5 à 0 et je ne vois rien à l'écran pendant 5 secondes. Une fois arrivé à 0, le programme "se réveille" et affiche 0 dans la fenêtre. Donc le sleep a tout endormi, au point de ne rien voir à l'écran...

Bonne journée.

Ce code peut aider

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#include <gtk/gtk.h>
 
gchar nbSecondesEcoulees=0;
 
gboolean decompte (GtkWidget* Fenetre)
{
  g_print("%d\n", ++nbSecondesEcoulees);
 
  if (nbSecondesEcoulees==5)
  {
    gtk_widget_show_all(Fenetre);
    return FALSE;
  }
 
  return TRUE;
}
 
int main(int argc, char **argv)
{
  GtkWidget* Fen;
  GtkWidget* Bouton;
  gtk_init(&argc, &argv);
 
  Fen = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 
  Bouton = gtk_button_new_with_label ("Quitter");
  gtk_container_add(GTK_CONTAINER(Fen),GTK_WIDGET(Bouton));
  g_signal_connect(G_OBJECT(Bouton),"clicked",G_CALLBACK(gtk_main_quit), NULL);
 
  // Appelle la fonction decompte toutes les 1000 ms
  // http://developer.gnome.org/doc/API/2.0/glib/glib-The-Main-Event-Loop.html
  g_timeout_add(1000, (gpointer)decompte, Fen);
 
  gtk_main();
  return 0;
}

Merci lunixinclar. En effet, ce code m'a aidé et j'arrive presque à ce que je veux faire.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 #include <gtk/gtk.h> gchar nbSecondesEcoulees = 6; gboolean decompte_b (GtkWidget* Bouton) { gtk_widget_set_sensitive (GTK_WIDGET (Bouton), FALSE); if (nbSecondesEcoulees == -1) { gtk_widget_set_sensitive (GTK_WIDGET (Bouton), TRUE); return FALSE ; } gtk_widget_show_all(Bouton); return TRUE; } gboolean decompte (GtkWidget* pLabel) { gchar *chaine = NULL; gint val; g_print("%d\n", --nbSecondesEcoulees); val = nbSecondesEcoulees; if (nbSecondesEcoulees == -1) { return FALSE ; } chaine = g_strdup_printf ("%d", val); gtk_label_set_label (GTK_LABEL (pLabel), chaine); g_free (chaine), chaine = NULL; gtk_widget_show_all(pLabel); return TRUE; } int main(int argc, char **argv) { GtkWidget *pVBox; GtkWidget* pLabel; GtkWidget* Fen; GtkWidget* Bouton; int cpt=5; gtk_init(&argc, &argv); /* Creation de la GtkBox verticale */ pVBox = gtk_vbox_new(TRUE, 0); Fen = gtk_window_new (GTK_WINDOW_TOPLEVEL); Bouton = gtk_button_new_with_label ("Quitter"); pLabel=gtk_label_new(""); /* Ajout de la GtkVBox dans la fenetre */ gtk_container_add(GTK_CONTAINER(Fen), pVBox); gtk_box_pack_start(GTK_BOX(pVBox), Bouton, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(pVBox), pLabel, TRUE, TRUE, 0); /*gtk_container_add(GTK_CONTAINER(Fen), GTK_WIDGET(pLabel)); gtk_container_add(GTK_CONTAINER(Fen),GTK_WIDGET(Bouton));*/ g_signal_connect(G_OBJECT(Bouton),"clicked",G_CALLBACK(gtk_main_quit), NULL); // Appelle la fonction decompte toutes les 1000 ms // http://developer.gnome.org/doc/API/2.0/glib/glib-The-Main-Event-Loop.html g_timeout_add(1000, (gpointer)decompte, pLabel); g_timeout_add(1000, (gpointer)decompte_b, Bouton); gtk_widget_show_all(Fen); gtk_main(); return 0; }
Explication sommaire du code :
Toutes les secondes, la fonction g_timeout_add appelle la fonction 'decompte' et la fonction 'decompte_b'.
La fonction 'decompte' met à jour un label (5, 4, 3, 2 ,1 et 0) et décrémente un compteur de telle sorte à aller de 5 à 0.
La fonction 'decompte_b' quant à elle, s'occupe de désactiver le bouton QUITTER pendant le décompte et le réactive à la fin.

J'ai alors 3 soucis (du moins important au plus important :D ):

_le premier, c'est que l'utilisateur peut toujours cliquer sur la croix supérieure droite pour fermer la fenêtre. L'idéal pour moi serait de lui interdire totalement la fermeture pendant le décompte.

_le deuxième, c'est que j'aimerais rassembler les deux fonctions de telle à sorte à pouvoir gérer à la fois la mise à jour du label et la dés/activation du bouton.

_enfin, mon soucis le plus coriace (à mes yeux biensur) réside dans le fait que le décompte se fait dans UNE fonction et non pas dans LE MAIN.
Je vais tenter d'expliquer mon problème...
Par la suite, je vais devoir faire appel plusieurs fois à cette fenêtre de décompte.
La fonction g_timeout_add appelle du code tous les X secondes.
Mais moi je voudrais appeler plusieurs fois une fonction qui s'occupe du décompte.
Mon problème vient sûrement du faire que je n'ai pas compris comment fonctionnait cette fonction g_timeout_add. J'ai à la fois l'impression que ce n'est pas ce dont j'ai besoin et à la fois ça fait exactement ce que je veux, c'est assez bizarre... :?

Voila j'espère que quelqu'un pourra répondre à tout ca... :D
Bonne journée

20/03/2007, 16h04
thibane

Personne ne peut m'aiguiller la-dessus? Ca me bloque violemment! :(
20/03/2007, 18h14
Franck.H
Citation:

_le premier, c'est que l'utilisateur peut toujours cliquer sur la croix supérieure droite pour fermer la fenêtre. L'idéal pour moi serait de lui interdire totalement la fermeture pendant le décompte.

Je sais pas faire et je doute que cela soit possible directement avec GTK+ ... il faudrais me semble t-il, subclasser la fenêtre mais cela il me semble également que c'est en fonction du gestionnaire de fenêtre donc suivant le système (mais je peut me tromper) :aie:

Citation:

_le deuxième, c'est que j'aimerais rassembler les deux fonctions de telle à sorte à pouvoir gérer à la fois la mise à jour du label et la dés/activation du bouton.

Bin facile ca, le prototype de la fonction callback étant:

Code:

gboolean func (gpointer data);

Il te suffit de mettre les widgets en question dans une structure puis de passer la structure en tant que dernier argument à la fonction
Code:

1 2 3 guint g_timeout_add (guint interval, GSourceFunc function, gpointer data);
;)

Citation:

_enfin, mon soucis le plus coriace (à mes yeux biensur) réside dans le fait que le décompte se fait dans UNE fonction et non pas dans LE MAIN.

Ha si tu veux faire ainsi, il va falloir plutôt utiliser les GTimer ;)

Hum... Tu n'avais pas encore vu le timer dans la doc? :cry: N'a pas du chercher longtemps.

Un code pour (ne pas) fermer la fenêtre, à adapter. J'ai laissé les commentaires originaux ça vient d'un tuto de gtk.org je crois.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
#include <gtk/gtk.h>
 
// Une variable globale.
gboolean jePeuxFermer = TRUE;
 
 
static gboolean delete_event(GtkWidget *widget, GdkEvent *event, gpointer data)
{
  /* If you return FALSE in the "delete_event" signal handler,
     GTK will emit the "destroy" signal. Returning TRUE means
     you don't want the window to be destroyed.
     This is useful for popping up 'are you sure you want to quit?' type dialogs. */
  g_print ("delete event occurred\n");
  /* Change TRUE to FALSE and the main window will be destroyed with a "delete_event". */
  if (jePeuxFermer) return FALSE;
  return TRUE;
  //return jePeuxFermer;
}
 
int main( int   argc, char *argv[] )
{
  GtkWidget *fen;
  GtkWidget *button;
 
  gtk_init (&argc, &argv);
 
  fen = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 
  /* When the window is given the "delete_event" signal (this is given
     by the window manager, usually by the "close" option, or on the
     titlebar), we ask it to call the delete_event () function
     as defined above. The data passed to the callback
     function is NULL and is ignored in the callback function. */
  g_signal_connect (G_OBJECT (fen), "delete_event",G_CALLBACK (delete_event), NULL);
 
  /* Here we connect the "destroy" event to a signal handler.  
     This event occurs when we call gtk_widget_destroy() on the window,
     or if we return FALSE in the "delete_event" callback. */
  g_signal_connect (G_OBJECT (fen), "destroy",G_CALLBACK ( gtk_main_quit), NULL);
 
  button = gtk_button_new_with_label ("Bouton");
  gtk_container_add (GTK_CONTAINER (fen), button);
 
  gtk_widget_show_all (fen);
  gtk_main ();
 
  return 0;
}

21/03/2007, 10h28
Franck.H

Citation:

Envoyé par Lunixinclar

Hum... Tu n'avais pas encore vu le timer dans la doc? :cry: N'a pas du chercher longtemps.

Un code pour (ne pas) fermer la fenêtre, à adapter. J'ai laissé les commentaires originaux ça vient d'un tuto de gtk.org je crois.

Ha ouais, je voyais pas aussi simple en fait ... sympa l'astuce :P