Callback, structures et boucle

Version imprimable

Bonjour,

j'ai déjà parcouru les forums et le net pour essayer de résoudre mon problème mais il est un petit peu différent de ceux liés au passage de structures simples dans un callback.

Je génère un tableau de boutons à l'aide de deux boucles. Chaque bouton contient une image. J'aimerais changer d'image au clic sur le bouton à l'aide de la fonction : gtk_button_set_image(bouton,image);
J'y arrive très bien pour un bouton simple, qui n'est pas compris dans un tableau et avec une image non stockée dans une structure .
Or, mes images sont stockées dans un tableau d'images de la structure suivante :
Code:

1 2 3 4 5 6 7 8 typedef struct case_plateau { GtkWidget *image1[35];//image visible avant le clic GtkWidget *image2[35];//image visible après le clic GtkWidget *bouton[35];//bouton correspondant int i,j; }t_case;
Voici mes boucles qui associent une image à chaque bouton :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 t_case case_jeu; for(case_jeu.i=0;case_jeu.i<6;case_jeu.i++) { for(case_jeu.j=0;case_jeu.j<6;case_jeu.j++) { init_image(&case_jeu,a,nb1,nb2);//appel de la fonction qui associe une image à chaque bouton case_jeu.boutton[case_jeu.j] = gtk_button_new(); gtk_button_set_image(case_jeu.boutton[case_jeu.j],case_jeu.image1[case_jeu.j]);//on associe l'image1 au bouton ...//ajout du bouton à la table g_signal_connect(G_OBJECT(case_jeu.boutton[case_jeu.j]), "clicked", G_CALLBACK(clic1_sur_case), &case_jeu);//je transmet ma structure à ma fonction callback } }
Le tableau marche et les boutons contiennent bien image1. Image2[j] contient bien des images.
J'aimerais maintenant associer dans mon fonction "clic1_sur_cas" mon image2 à mon bouton. Voilà ce que j'ai fait :
Code:

1 2 3 4 5 void clic1_sur_case(GtkWidget *monbouton, gpointer data) { t_case *testcase = (t_case *)data;//Je cast data gtk_button_set_image(monbout->boutton[monbout->j],testcase.image2[testcase.j]); }
Mon programme plante lorsque je clique sur le bouton.
Pouvez-vous me dire où est-ce que je me suis trompé ?

Je vous remercie d'avance.

17/10/2009, 12h18
teuf13

La structure "case_jeu" que tu transmets au callback sera la même pour tous tes boutons, donc ça ne va pas faire ce que tu veux. De plus j'ai la forte impression que c'est une variable locale à la fonction qui initialise tout, donc elle n'existera plus en mémoire quand tes callbacks seront appelés.
17/10/2009, 12h52
cb450

Citation:

Envoyé par teuf13

La structure "case_jeu" que tu transmets au callback sera la même pour tous tes boutons, donc ça ne va pas faire ce que tu veux.

Quelle serait alors l'alternative ? Passer par deux structures différentes ?

Citation:

Envoyé par teuf13

De plus j'ai la forte impression que c'est une variable locale à la fonction qui initialise tout, donc elle n'existera plus en mémoire quand tes callbacks seront appelés.

Pourtant la structure case_jeu qui passe par une fonction "void init(t_case * case_jeu)" me ressort bien les valeurs que je veux dans mon main.
17/10/2009, 13h15
teuf13

Citation:

Envoyé par cb450

Quelle serait alors l'alternative ? Passer par deux structures différentes ?

Je pense que j'allouerais une structure bcp plus simple à chaque itération dans la boucle qui contiendrait juste l'image avant/après pour le bouton auquel tu associes le callback. Beaucoup moins de risques de s'embrouiller avec les pointeurs en faisant comme ça.

Citation:

Envoyé par cb450

Pourtant la structure case_jeu qui passe par une fonction "void init(t_case * case_jeu)" me ressort bien les valeurs que je veux dans mon main.

Pourtant ton programme plante pour des raisons mystérieuses ;) Quand je dis "j'ai l'impression que", je veux dire que la façon dont t'as présenté ton code me donne cette impression, mais j'ai pas suffisammnet de code pour en être certain, donc c'est une invitation à vérifier ce point.
17/10/2009, 18h39
cb450
Citation:

Envoyé par teuf13

Pourtant ton programme plante pour des raisons mystérieuses ;) Quand je dis "j'ai l'impression que", je veux dire que la façon dont t'as présenté ton code me donne cette impression, mais j'ai pas suffisamment de code pour en être certain, donc c'est une invitation à vérifier ce point.

En fait, ma fonction callback "entre" bien dans ma fonction, j'ai fait les tests, ça marche sur toutes les cases[j]. Seulement, elle n'a pas l'air de bien transmettre ma structure à ma fonction ou alors je me plante à la réception.

J'ai essayé avec un bouton à part et une structure "simplifiée".
Ma structure (dans un .h) :
Code:

1 2 3 4 5 typedef struct case_jeu { int test; }t_case
Mon main (en fait c'est une fonction, mais c'est dans celle là que je déclare ma variable de type t_case*)
Code:

1 2 3 4 5 6 t_case case_jeu; case_jeu.test=20; GtkWidget *btn; ... //blabla, je crée le bouton g_signal_connect(G_OBJECT(btn), "clicked", G_CALLBACK(clic1_sur_case), &case_jeu);
Ma fonction clic1_sur_case :
Code:

1 2 3 4 5 void clic1_sur_case(GtkWidget *monbout, gpointer data) { t_case* testcase = (t_case*)data; printf("%d\n", testcase->t); }
Ça m'affiche quelque chose(une adresse) mais pas mon nombre 20.
Où est-ce que je me trompe, telle est la question :D

Encore une fois, si tu fais
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 void init (..) { t_case case_jeu; ... g_signal_connect(G_OBJECT(btn), "clicked", G_CALLBACK(clic1_sur_case), &case_jeu); ... } int main (int argc, char **argv) { ... init (...); ... gtk_main(); }
Ca ne fonctionnera pas, au moment où ton signal est invoqué, case_jeu n'existe plus nul part

18/10/2009, 10h27
cb450

Grosse erreur en effet. Maintenant, un int tout con de ma structure passe sans problème dans mon callback, je le récupère bien.
Reste que je n'arrive pas à récupérer correctement mes infos en fonction de j. Or je ne peux pas vraiment trop faire autrement puisque si je n'initialise pas toutes mes images dès le départ, je ne pourrais pas imposer certaines conditions sur ma grille.
18/10/2009, 11h26
teuf13

Si tu veux recevoir des données différentes en fonction du bouton sur lequel on clique, soit tu retrouves la valeur de j en utilisant le GtkButton que tu récupères en argument de ton callback, soit tu passes une structure différente pour chaque bouton quand tu assignes les callbacks. La tu passes un pointeur sur la même instance de la structure à chaque fois, donc au final, quel que soit le bouton tu verras les mêmes données.
18/10/2009, 12h03
lowwa132
Tu as essayé en faisant plutôt un tableau de structure ?

Du genre...
Code:

1 2 3 4 5 typedef struct t_bouton { GtkWidget *pImage; GtkWidget *pButton; }t_bouton;
Après tu mets ce que tu veux dedans, un gint etat; associé au bouton pour savoir quel pipe tu as :mouarf:

Et en déclaration dans le main :

Code:

t_bouton bouton[36];

Le tableau de structures semble être la bonne solution mais un problème persiste.
Voilà ce que j'ai fait :
Ma structure :
Code:

1 2 3 4 5 6 7 typedef struct bouton { GtkWidget *image; GtkWidget *monbouton; int etat; }t_bouton;
Main :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 t_bouton bouton[36]; int i,j; for(i=0;i<36;i++) { for(j=0;j<36;j++) { ...//initialisation du tableau avec images etc... bouton[j].etat=j; bouton[bouton->etat].etat=bouton[j].etat;//en gros, je donne à etat la valeur de j g_signal_connect(G_OBJECT(bouton[j].monbouton), "clicked", G_CALLBACK(clic1_sur_case), &bouton);//lorsque je clique sur mon bouton j } }
Ma fonction :
Code:

1 2 3 4 5 void clic1_sur_case(GtkWidget *monbout, gpointer data) { t_case* testcase = (t_case*)data; printf("%d\n", testcase[testcase->etat].etat); }
Le problème est que testcase[testcase->etat].etat m'affiche 5 puisque c'est le dernier j de ma boucle. Or j'aimerais qu'il m'affiche le jième bouton sur lequel j'appuie.
Je sens que je suis pas loin mais que je prend le problème à l'envers.

18/10/2009, 14h52
lowwa132

Bon alors déjà il y a un truc que je capte pas.

Notre plateau de jeu c'est bien du 6*6 non ?

Donc tu devrais avoir une double boucle avec i allant de 0 à 6 et de même pour j...

Ensuite, ce n'est pas un tableau de pointeurs sur structures, mais un tableau de structures, donc il ne devrait pas y avoir de "->" non ?
18/10/2009, 15h02
cb450

Oui, c'est du 6 par 6, simple erreur quand j'ai recopié ici.
Après, je t'avouerais que j'ai mis les "->" parce que ça ne passe pas à la compil autrement.

En fait, ma structure contient deux gtkwidget image (image1 et image2) dont un contient les faces cachées et l'autre les pipes. J'initialise tout avant puisqu'il y a certaines conditions sur les pipes(aléatoire, bombe et explosif) mais je n'affiche que la face cachée au départ(ce qui marche).
En théorie, je n'ai plus qu'à remplacer l'image 2 qui est déjà initialisée dans le bouton correspondant.

Je fais peut-être une erreur dans mon raisonnement mais as-tu procédé de la même façon, avec un tableau de structure ?
18/10/2009, 16h32
lowwa132
Désolé du temps de réponse, je travaillais sur la fonction callback.

Donc moi j'utilise bien un tableau de structures avec dedans :
Code:

1 2 3 4 GtkWidget *pImage; GtkWidget *button; gint etat;
Dans mon main j'ai t_boutons cases[37]; (j'ai mis une case en plus pour la zone de swap)

Mon gint etat je l'ai mis au cas où, j'en aurais peut-être pas besoin en fait.

J'ai mis un signal pour chaque button, lors de l'initialisation de ces derniers (avec association d'image etc).
Je passe l'adresse du premier élément de mon tableau de structures pour la fonction callback.
J'ai un truc du genre g_signal_connect(........, G_CALLBACK(callback_swap), cases);

Pour la fonction callback, tu récupères le widget en question (le bouton) et ton paramètre que tu as décidé de passer, donc le tableau de structures.
18/10/2009, 18h04
cb450

En fait, dans le main, faut initialiser la structure comme ça plutôt :
t_boutons cases[7][7];
Autrement on perd toutes les données du bouton en question pour la suite puisque quand tu crées le tableau, tu crées juste un cases.bouton[j].
En fait, j'écrasais à chaque fois dans ma boucle le j en question. Comme pour le puissance4 finalement.
T'avais fais attention à ça ?
18/10/2009, 18h19
lowwa132

Citation:

Envoyé par cb450

En fait, dans le main, faut initialiser la structure comme ça plutôt :
t_boutons cases[7][7];
Autrement on perd toutes les données du bouton en question pour la suite puisque quand tu crées le tableau, tu crées juste un cases.bouton[j].
En fait, j'écrasais à chaque fois dans ma boucle le j en question. Comme pour le puissance4 finalement.
T'avais fais attention à ça ?

Mouarf :ccool:
Pas bête, j'aurais du y penser non de diou !

Oui c'est vrai qu'après pour le test de victoire ça risque d'être bordélique...
18/10/2009, 23h08
cb450

J'ai réussi.
Si ça peut aider des gens, voilà quelles ont été mes erreurs :
- ne pas avoir gardé la structure d'une fonction callback
- ne pas avoir mis mes signaux dans le main (erreur de débutant)
- utiliser des tableaux dans une structure au lieu d'un tableau de structure
- perdre les infos de mes boutons dans mes boucles par remplacement des j (utiliser un tableau revient à penser aux 2 dimensions [i][j], c'est logique mais on n'y pense pas toujours)
- ne pas avoir envoyé les coordonnées d'une des "cases" du tableau de structures à ma fonction callback (bien mettre en paramètre &mastruct[i][j] en dernier paramètre du signal)

Merci lowwa et teuf pour votre aide :ccool:
19/10/2009, 08h24
teuf13

Citation:

Envoyé par cb450

- ne pas avoir mis mes signaux dans le main (erreur de débutant)

Pas sûr de ce que tu entends par là, j'ai tendance à mettre le moins de choses possibles dans mon main, et l'enregistrement des signaux ne fait pas partie des choses que je mets en priorité à cet endroit :)

Citation:

Envoyé par teuf13

Pas sûr de ce que tu entends par là, j'ai tendance à mettre le moins de choses possibles dans mon main, et l'enregistrement des signaux ne fait pas partie des choses que je mets en priorité à cet endroit :)

Je suis d'accord.
Pour exemple voila le genre de "main();" que j'écris:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 int main (int argc, char *argv[]) { gtk_init (&argc, &argv); PGUI = g_try_new(Spointer, 1); if (PGUI) { create_window (); gtk_main (); return 0; } g_printerr("Allocation mémoire impossible!\n"); return 1; }

Hum... J'aime pas trop ce style, je préfère plutôt tester l'erreur avant le cas nominal, pour faciliter la lecture :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 int main (int argc, char *argv[]) { gtk_init (&argc, &argv); PGUI = g_try_new(Spointer, 1); if (PGUI == NULL) { g_printerr("Allocation mémoire impossible!\n"); return 1; } create_window (); gtk_main (); return 0; }
M'enfin dans le cas présent, si c'est pour quitter si l'allocation ne fonctionne pas, autant utiliser g_new plutôt que g_try_new...
Code:

1 2 3 4 5 6 7 8 int main (int argc, char *argv[]) { gtk_init (&argc, &argv); PGUI = g_new(Spointer, 1); create_window (); gtk_main (); return 0; }

21/10/2009, 14h59
gerald3d

Histoire de chipoter ;) g_new(); crash l'application. Pas très propre comme fin!
23/10/2009, 14h09
liberforce

C'est un comportement normal. Si tu n'as plus de mémoire, de toute façon tu ne pourras pas afficher une boite de dialogue te disant que tu n'en as plus. La seule solution, c'est de quitter, et rendre la mémoire au système d'exploitation. T'imagines s'il fallait vérifier toutes les allocations ? Tu perdrais vachement en lisibilité de code.

Le seul cas où g_try_new est une bonne solution, c'est quand tu as une grosse allocation à faire pour un buffer par exemple et que tu n'es pas sûr que cela passe au niveau taille. Mais pour les allocations "de tous les jours", et surtout pour une simple structure, c'est complètement superflu.