Discussion :

[sorry60]

Salut à tous !

Voila j'ai un petit probleme, j'aimerais mettre une boucle infinie dans un programme utilisant GTK (donc il y a deja la boucle infinie événementielle gtk_main() ).
J'ai essayé :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
gtk_main();
while(1)
{
   printf("ok\n");
}

Mais biensur ça fonctionne pas, il rentre dans le while(1) une fois gtk_main() terminé
Je vois pas du tout comment faire, j'espere qu'il y a une astuce

Merci pour votre aide
Sorry

[gege2061]

Bonjour,
quel est le but de la manip'?
Avoir OK qui s'affiche continuellement en arrière plan?
Il faut untiliser gtk_init_add pour ajouter une fonction à appeler lors de l'entrée dans gtk_main. Mais l'appel est surement bloquant donc cette fonction doit elle même faire appel à un thread qui exécutera la boucle.

[sorry60]

Bonjour,
quel est le but de la manip'?
Avoir OK qui s'affiche continuellement en arrière plan?
Il faut untiliser gtk_init_add pour ajouter une fonction à appeler lors de l'entrée dans gtk_main. Mais l'appel est surement bloquant donc cette fonction doit elle même faire appel à un thread qui exécutera la boucle.

C'est pour un Client.
Il reste en attente de reception de messages (d'où le while(1) ), mais quand on clic sur un bouton, il envoie un message...

Si je t'ai bien compris, je dois faire une fonction CALLBACK qui reste en attente d'un message (avec select...), donc comme ça pas besoin de while(1) ?

[Nasky]

Pourquoi ne pas placer ta boucle avant le gtk_main_quit :

Nas'

[sorry60]

Pourquoi ne pas placer ta boucle avant le gtk_main_quit :

Nas'

Cette instruction se trouve dans la fonction qui gère le bouton quitter
Si je met ma boucle dans le code du bouton quitter, il ne sera executer que lors du clic sur ce bouton. Alors que mon programme doit etre tout le temps à l'ecoute d'un message, d'où mon probleme

[sorry60]

En fait, la solution serait que la boucle événementielle infinie gtk_main() appelle à chaque itération mon bloc d'instruction servant à écouter sur la socket:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
select(...)
/* ... */
if (FD_ISSET(...) )
{
   recv( ...);
   /* ... */
}
/* ... */

Comme ça pas besoin de while(1)
Mais je ne sais si c'est possible, et si oui comment faire, car aucun événement ne serait lié à cette fonction, elle devra etre appellée à chaque fois

[gege2061]

Mais je ne sais si c'est possible, et si oui comment faire, car aucun événement ne serait lié à cette fonction, elle devra etre appellée à chaque fois

Avec un timer peut être : g_timeout_add

[sorry60]

Mais je ne sais si c'est possible, et si oui comment faire, car aucun événement ne serait lié à cette fonction, elle devra etre appellée à chaque fois

Avec un timer peut être : g_timeout_add

Ouai apparemment c'est un peu ça, je vais tester ça.
Merci pour ton aide

[Franck.H]

Pourquoi pas tout simplement un Thread qui s'occuperais que de cette action ?

[Nasky]

Pourquoi se compliquer avec un thread?

Sinon, gtk_timeout_add(x, ptr_fct,data) te permettra d'appeler une fonction toutes les x ms.
Par contre, attention au fonctionnement de cette fonction, en particulier si elle est appelée à chaque clic sur un bouton.
En effet, si le bouton lance cette fonction (qui lance une autre fonction) et que tu cliques plusieurs fois sur ce bouton, il va lancer plusieurs fois la fonction et donc t'auras l'impression que l'intervalle se réduit (la vitesse augmente).
Une solution pour contrer ce problème est d'utiliser une variable qui te donne le nombre de clic (une 'static') et d'insérer les id retournés par gtk_timeout_add() et de supprimer ceux qui sont en trop avec gtk_timeout_remove(id).
Je sais pas si t'as compris et surtout si ça te concerne, mais j'ai été un peu piégé par ça, j'ai du faire une ptite bidouille (comme expliqué) pour empêcher ça.

Nas'

[sorry60]

Pourquoi pas tout simplement un Thread qui s'occuperais que de cette action ?

J'essaye d'éviter le plus possible les threads, et en plus je veux un code portable windows - linux

[sorry60]

Pourquoi se compliquer avec un thread?

Sinon, gtk_timeout_add(x, ptr_fct,data) te permettra d'appeler une fonction toutes les x ms.
Par contre, attention au fonctionnement de cette fonction, en particulier si elle est appelée à chaque clic sur un bouton.
En effet, si le bouton lance cette fonction (qui lance une autre fonction) et que tu cliques plusieurs fois sur ce bouton, il va lancer plusieurs fois la fonction et donc t'auras l'impression que l'intervalle se réduit (la vitesse augmente).
Une solution pour contrer ce problème est d'utiliser une variable qui te donne le nombre de clic (une 'static') et d'insérer les id retournés par gtk_timeout_add() et de supprimer ceux qui sont en trop avec gtk_timeout_remove(id).
Je sais pas si t'as compris et surtout si ça te concerne, mais j'ai été un peu piégé par ça, j'ai du faire une ptite bidouille (comme expliqué) pour empêcher ça.

Nas'

non ma fonction n'est appellé par aucun événement.
Elle doit tourner en arrière plan, comme ça des qu'un message arrive, il est réceptionné.
C'est ma fonction d'envoie de message qui est gérée par un bouton, mais ici pas de probleme.

[Franck.H]

Pourquoi pas tout simplement un Thread qui s'occuperais que de cette action ?

J'essaye d'éviter le plus possible les threads, et en plus je veux un code portable windows - linux

p_thread est portable, mieux encore, si tu utilise GTK donc GLib obligatoirement et je crois même qu'il s'y trouve une abstraction pour les Thread, je pense que c'est le meilleur moyen pour avoir une partie d'un programme qui tourne en arriere plan et qu'il soit portable !
Après si y'a d'autres soluces mieux adapté je connais pas, je ne donne que mon point de vue !

[sorry60]

Le timer me parait etre une bonne solution.
Je n'ai pas encore tester, si c'est pas bon alors j'essaierai les threads

[sorry60]

J'ai essayé ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
void test(void)
{
	printf("Ok\n");
}
 
int main(int argc, char **argv)
{
	/*Déclaration des variables*/
  	GtkWidget* pFenetrePrincipale;
  	GtkWidget* pBoutonQuitter;
 
	gtk_init(&argc, &argv);
 
	creerFenetre(&pFenetrePrincipale,"Test",400,400);
	creerBouton(&pBoutonQuitter,"Quitter");
	gtk_container_add(GTK_CONTAINER(pFenetrePrincipale),GTK_WIDGET(pBoutonQuitter));
	g_signal_connect(G_OBJECT(pBoutonQuitter),"clicked",G_CALLBACK(gtk_main_quit),NULL);
	gtk_widget_show_all(pFenetrePrincipale);
	g_timeout_add(1000, GSourceFunc(test),NULL);
 
	gtk_main();
 
    return 0;
}

Mais j'arrive pas à compiler :

gcc -Wall -Wextra -ansi -O2 test.c -o test `pkg-config --cflags --libs gtk+-2.0`
test.c: In function ‘main’:
test.c:60: erreur: syntax error before ‘GSourceFunc’

Je vois pas où est l'erreur de syntaxe
Suis-je aveugle ?

[sorry60]

La syntaxe était :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

g_timeout_add(1000,(GSourceFunc)test,NULL);

Ca l'air de bien fonctionner, il m'affiche "OK" toutes les secondes, et quitte bien quand je clic sur le bouton

[gege2061]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

g_timeout_add(1000, GSourceFunc(test),NULL);

Il est temps de réviser le chapitre du transcriptage!

Et aussi de lire la dic : GSourceFunc à pour définition :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

gboolean (*GSourceFunc)  (gpointer data);

et non :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

void (*GSourceFunc)  (void);

[Nasky]

Ce n'est pas la bonne synthaxe, sorry60.

Petit rappel du fonctionnement de gtk_timeout_add().
Par l'intérmédiaire d'un pointeur sur fonction, elle appelle cette fonction à intervalle régulier.
La fonction à appeler a le prototype suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

gboolean test(gpointer data);

Le deuxième paramètre de gtk_timeout_add() est juste un pointeur sur fonction du type de test(). Tu peux donc l'appeler comme tu veux.
De plus, la fonction appelée par gtk_timeout_add() doit renvoyer un boolean pour dire si on l'exécute ou pas. Si elle renvoie TRUE, on l'exécute. Si elle renvoie FALSE, on arrête l'exécution.
Exemple d'utilisation :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
gboolean (*ptr_fct) (gpointer data) ; // pointeur sur fonction
ptr_fct = test ; // pointe sur la fonction test() pour pouvoir l'appeler
gtk_timeout_add(1000,ptr_fct,NULL); // appel toutes les secondes de la fonction pointée par ptr_fct à savoir test()
 
// fonction test
gboolean test(gpointer data)
{
   static int times = 0 ; // nombre d'appel à la fonction
   gboolean ret = TRUE ; // continuer ou pas
   times++ ; 
   // appeler que 10 fois la fonction
   if(times > 10)
   {
       ret = FASLE ; // arreter
   }
 
return ret ;
}

Après 10 appels, gtk_timeout_add() arrêtera d'appeler la fonction.

J'espère que c'est plus clair

Nas'

[sorry60]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

g_timeout_add(1000,(GSourceFunc)test,NULL);

Marche tres bien, c'est pas bon ?