Projet chasse au trésor

**Dimitri95** · 26/01/2015, 18h09

Bonjour, je fais un projet d'un jeu de chasse au trésor et là je suis à la conception de ma fenêtre principale. Alors j'ai 4 boutons dont 3 dans une Hbox et 1 dans une Vbox. Je souhaite avoir une marge de 10 pixels d’une part entre les bords de la fenêtre et les boutons, d’autre part entre deux boutons consécutifs ( cette marge doit concerner uniquement ceux de la Hbox).

Voici mon code source :

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
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
91
92
93
94
95
96
97
98
99
100
#include <stdlib.h>
#include <gtk/gtk.h>
#include <string.h>
//Declaration des  fonctions
 
 
//Déclaration variable globales
 
  //Fenetre principale
  GtkWidget* pFenetre = NULL;
 
  // Variables pour stocker les images
  GdkPixbuf* pixbuf1;
 
 
int main(int argc, char** argv)
{	
 
 
  // Initialisation de l'environnement gtk
  gtk_init(&argc, &argv);
 
  	GtkWidget* pBoutonRecommencer = NULL;
  	GtkWidget* pBouton1=NULL;
	GtkWidget* pBouton2=NULL;
	GtkWidget* pBouton3=NULL;
  	GtkWidget* pLabel=NULL;
 
    //  Creation d'une fenêtre
  pFenetre = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 
    //Titre de la fenêtre
  	gtk_window_set_title(GTK_WINDOW(pFenetre), "Le jeu du trésor ");
  	// On modifie la taille de la fenetre
	gtk_window_set_default_size(GTK_WINDOW (pFenetre), 200, 150);
	// On interdit de modifier la taille
	gtk_window_set_resizable (GTK_WINDOW (pFenetre), TRUE);
	//On centre toujours la fenetre
	gtk_window_set_position(GTK_WINDOW(pFenetre),GTK_WIN_POS_CENTER_ALWAYS);
 
  pLabel = gtk_label_new ("Choisissez un coffre !");
 
    // Declaration des boites
  GtkWidget* pVbox=NULL;
  GtkWidget* pHbox=NULL;
  GtkWidget* p_main_box = NULL;
 
   	 // Chargement des images
   	 GdkPixbuf * pb = gdk_pixbuf_new_from_file("coffreFerme.jpeg", NULL);
 	 if (pb==NULL) printf("Erreur en chargeant l'image coffreFerme.jpeg\n");
  	pixbuf1 = gdk_pixbuf_scale_simple(pb, 100, 100, GDK_INTERP_NEAREST);
 
 
  	 // Creation des quatre boutons 
  pBoutonRecommencer = gtk_button_new_with_label("Recommencer");
  pBouton1 = gtk_button_new();
  pBouton2 = gtk_button_new();
  pBouton3 = gtk_button_new();
 
  	  // Afiichage des images
 	 gtk_button_set_image(GTK_BUTTON(pBouton1),  gtk_image_new_from_pixbuf(pixbuf1));
 	 gtk_button_set_image(GTK_BUTTON(pBouton2),  gtk_image_new_from_pixbuf(pixbuf1));
 	 gtk_button_set_image(GTK_BUTTON(pBouton3),  gtk_image_new_from_pixbuf(pixbuf1));
 
 
  // Création des boites
  pVbox = gtk_vbox_new (FALSE, 1);
  pHbox = gtk_hbox_new (TRUE, 10);
  p_main_box = gtk_vbox_new (FALSE, 20);
 
 
 	//Ajoutons les quatre boutons et du label dans les boites
 	gtk_box_pack_start (GTK_BOX(pVbox), pLabel, FALSE, TRUE, 0);
 	gtk_box_pack_start (GTK_BOX(pVbox), pBoutonRecommencer, FALSE, TRUE, 0);
 	gtk_box_pack_end (GTK_BOX(pHbox), pBouton1, TRUE, TRUE, 10);
 	gtk_box_pack_end (GTK_BOX(pHbox), pBouton2, TRUE, TRUE, 10);
 	gtk_box_pack_end (GTK_BOX(pHbox), pBouton3, TRUE, TRUE, 10);
 
 
 
  // Ajoutons les deux boites dans la boite principale et celle ci dans la fenetre
   gtk_container_add (GTK_CONTAINER(p_main_box), pVbox);
   gtk_container_add (GTK_CONTAINER(p_main_box), pHbox);
   gtk_container_add (GTK_CONTAINER(pFenetre), p_main_box);
 
 
  //  Affichage de la fenêtre
  gtk_widget_show_all(pFenetre);
 
	// Fonction qui capte le signal de la petite croix pour fermer la fenetre
	gtk_signal_connect(GTK_OBJECT(pFenetre), "destroy", G_CALLBACK(gtk_main_quit), NULL);
 
 
 
 
 
 gtk_main();
 
return EXIT_SUCCESS;
}

**Dimitri95** · 28/01/2015, 21h31

Bonjour, je fais un projet d'un jeu de chasse au trésor et là je suis à la conception de ma fenêtre principale. Alors j'ai 4 boutons dont 3 dans une Hbox et 1 dans une Vbox. Je souhaite avoir une marge de 10 pixels d’une part entre les bords de la fenêtre et les boutons, d’autre part entre deux boutons consécutifs ( cette marge doit concerner uniquement ceux de la Hbox).

Voici mon code source :

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
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
91
92
93
94
95
96
97
98
99
100
101
 
#include <stdlib.h>
#include <gtk/gtk.h>
#include <string.h>
//Declaration des  fonctions
 
 
//Déclaration variable globales
 
  //Fenetre principale
  GtkWidget* pFenetre = NULL;
 
  // Variables pour stocker les images
  GdkPixbuf* pixbuf1;
 
 
int main(int argc, char** argv)
{	
 
 
  // Initialisation de l'environnement gtk
  gtk_init(&argc, &argv);
 
  	GtkWidget* pBoutonRecommencer = NULL;
  	GtkWidget* pBouton1=NULL;
	GtkWidget* pBouton2=NULL;
	GtkWidget* pBouton3=NULL;
  	GtkWidget* pLabel=NULL;
 
    //  Creation d'une fenêtre
  pFenetre = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 
    //Titre de la fenêtre
  	gtk_window_set_title(GTK_WINDOW(pFenetre), "Le jeu du trésor ");
  	// On modifie la taille de la fenetre
	gtk_window_set_default_size(GTK_WINDOW (pFenetre), 200, 150);
	// On interdit de modifier la taille
	gtk_window_set_resizable (GTK_WINDOW (pFenetre), TRUE);
	//On centre toujours la fenetre
	gtk_window_set_position(GTK_WINDOW(pFenetre),GTK_WIN_POS_CENTER_ALWAYS);
 
  pLabel = gtk_label_new ("Choisissez un coffre !");
 
    // Declaration des boites
  GtkWidget* pVbox=NULL;
  GtkWidget* pHbox=NULL;
  GtkWidget* p_main_box = NULL;
 
   	 // Chargement des images
   	 GdkPixbuf * pb = gdk_pixbuf_new_from_file("coffreFerme.jpeg", NULL);
 	 if (pb==NULL) printf("Erreur en chargeant l'image coffreFerme.jpeg\n");
  	pixbuf1 = gdk_pixbuf_scale_simple(pb, 100, 100, GDK_INTERP_NEAREST);
 
 
  	 // Creation des quatre boutons 
  pBoutonRecommencer = gtk_button_new_with_label("Recommencer");
  pBouton1 = gtk_button_new();
  pBouton2 = gtk_button_new();
  pBouton3 = gtk_button_new();
 
  	  // Afiichage des images
 	 gtk_button_set_image(GTK_BUTTON(pBouton1),  gtk_image_new_from_pixbuf(pixbuf1));
 	 gtk_button_set_image(GTK_BUTTON(pBouton2),  gtk_image_new_from_pixbuf(pixbuf1));
 	 gtk_button_set_image(GTK_BUTTON(pBouton3),  gtk_image_new_from_pixbuf(pixbuf1));
 
 
  // Création des boites
  pVbox = gtk_vbox_new (FALSE, 1);
  pHbox = gtk_hbox_new (TRUE, 10);
  p_main_box = gtk_vbox_new (FALSE, 20);
 
 
 	//Ajoutons les quatre boutons et du label dans les boites
 	gtk_box_pack_start (GTK_BOX(pVbox), pLabel, FALSE, TRUE, 0);
 	gtk_box_pack_start (GTK_BOX(pVbox), pBoutonRecommencer, FALSE, TRUE, 0);
 	gtk_box_pack_end (GTK_BOX(pHbox), pBouton1, TRUE, TRUE, 10);
 	gtk_box_pack_end (GTK_BOX(pHbox), pBouton2, TRUE, TRUE, 10);
 	gtk_box_pack_end (GTK_BOX(pHbox), pBouton3, TRUE, TRUE, 10);
 
 
 
  // Ajoutons les deux boites dans la boite principale et celle ci dans la fenetre
   gtk_container_add (GTK_CONTAINER(p_main_box), pVbox);
   gtk_container_add (GTK_CONTAINER(p_main_box), pHbox);
   gtk_container_add (GTK_CONTAINER(pFenetre), p_main_box);
 
 
  //  Affichage de la fenêtre
  gtk_widget_show_all(pFenetre);
 
	// Fonction qui capte le signal de la petite croix pour fermer la fenetre
	gtk_signal_connect(GTK_OBJECT(pFenetre), "destroy", G_CALLBACK(gtk_main_quit), NULL);
 
 
 
 
 
 gtk_main();
 
return EXIT_SUCCESS;
}

**gerald3d** · 29/01/2015, 20h44

Bonjour.

Avant d'aller plus avant ton code est orienté Gtk+2.0. Est-ce normal ?

**Dimitri95** · 30/01/2015, 11h49

Excusez moi mais je n'ai pas compris votre question, pouvez vous m'expliquer en d'autres termes svp?

**gerald3d** · 30/01/2015, 17h27

Plus directement tu utilises des fonctions qui n'existent plus dans Gtk+v3.0. J'en conclus que tu compiles avec la bibliothèque Gtk+v2.0. Ma question est la suivante : est-ce un choix volontaire de ta part ou bien tu ne sais pas trop comment faire et finalement c'est la version 2.0 que tu utilises parce qu'elle est installée par défaut sur ton système ?

**Dimitri95** · 01/02/2015, 01h20

Gtk+ est installé par défaut sur le sytème que j'utilise.

**gerald3d** · 01/02/2015, 10h12

Oui je le pense bien

. Ce qui est étonnant c'est que tu codes avec des instructions de la versions 2.0 alors que la version 3.0 est sortie depuis belle lurette.

Bon ce ne n'est pas grave, tant que ca ne te pose pas de problème particulier je vais regarder plus précisément ton problème est tenter de te répondre.

**gerald3d** · 01/02/2015, 14h27

Tout d'abord, en compilant ton code avec Gtk+2.0 j'ai deux erreurs :

Code :

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

1
2
/home/gerald/Projects/test/src/main.c:92: référence indéfinie vers « GTK_OBJECT »
/home/gerald/Projects/test/src/main.c:92: référence indéfinie vers « gtk_signal_connect »

Il faut utiliser G_OBJECT et g_signal_connect(); en lieu et place.

Ce problème réglé tu initialises un GdkPixbuf (pixbuf1) sans jamais libérer la ressource une fois utilisée. Pense à faire un g_object_unref(pixbuf1); après l'insertion de l'image dans tes boutons. Cette remarque est aussi valable pour pb.

En terme d'algorithme si pb==NULL tu continues tout de même à vouloir initialiser pixbuf1 avec et à utiliser ce dernier pour initialiser tes boutons. Ce n'est pas terrible il me semble. Initialises pixbuf1 avec une image par défaut en cas d'échec. Ainsi tu auras dans ton affichage une information visuelle.

Les déclarations en global sont à éviter le plus possible. Tu peux intégrer dans ton main(); pixbuf1 et pFenetre. Ca sera plus propre.

Pour finir la réponse à tes questions.

Le premier enfant de la fenêtre principale est p_main_box. Tu peux spécifier pour ce container un espace entre lui et le container parent.

Code :

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

gtk_container_set_border_width (GTK_CONTAINER(p_main_box), 10);

Ceci règle la première question.

Pour la deuxième question il me semble que ton code est correcte en l'état. Tu as bien spécifié lors de l'insertion des boutons un espace de 10. Que veux-tu plus précisément à ce sujet ?

**Dimitri95** · 03/02/2015, 09h19

Merci de votre aide, j'en tiendrai compte.
la fonction que vous m'avez donné fait exactement ce que je veux.

**Dimitri95** · 03/02/2015, 12h31

Mon problème a été résolu sauf que j'en rencontre un autre. L'idée c'est que j'ai créé deux fonctions qui changent les images de boutons, et la deuxième a besoin de la première dans son exécution, c'est pourquoi je détruit les signaux qui relient les boutons à la deuxième à l'intérieur d'elle même. Ensuite j'ai créé un bouton "Recommencer" qui est censé restaurer le signal détruit et recommencer la partie. Mais le programme s'arrete avec cette erreur :

**
GLib-GObject:ERROR:/tmp/buildd/glib2.0-2.33.12+really2.32.4/./gobject/gsignal.c:626:handler_unref_R: assertion failed: (hlist->tail_before == handler)
Abandon

Voilà mon code :

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
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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
 
#include <stdlib.h>
#include <gtk/gtk.h>
#include <string.h>
#include <stdio.h>
#include <time.h>
 
//Declaration des  fonctions
void tirage_coffre_tresor_simple (GtkWidget * pBouton);
void double_tirage (GtkWidget * pBouton);
void mise_a_jour_score ();
void recommencer_partie ();
void testclic();
 
//Déclaration variable globales
int doubletirage=0;
int tiragesimple=0;  
  //Fenetre principale
  GtkWidget* pFenetre = NULL;
 
  // Boutons et labels
  GtkWidget* pBoutonRecommencer = NULL;
  GtkWidget* pBouton0=NULL;
  GtkWidget* pBouton1=NULL;
  GtkWidget* pBouton2=NULL;
  GtkWidget* pLabel=NULL;
  GtkWidget* pScore=NULL;
 
  // Variables pour stocker les images et les scores
  GdkPixbuf* pixbuf1;
  GdkPixbuf* pixbuf2;
  GdkPixbuf* pixbuf3;
  int nb_victoires = 0;
  int nb_defaites = 0;
 
int main(int argc, char** argv)
{	
 
 
  // Initialisation de l'environnement gtk
  gtk_init(&argc, &argv);
 
    //  Creation d'une fenêtre
  pFenetre = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 
    //Titre de la fenêtre
  	gtk_window_set_title(GTK_WINDOW(pFenetre), "Le jeu du trésor ");
  	// On modifie la taille de la fenetre
	gtk_window_set_default_size(GTK_WINDOW (pFenetre), 200, 150);
	// On interdit de modifier la taille
	gtk_window_set_resizable (GTK_WINDOW (pFenetre), TRUE);
	//On centre toujours la fenetre
	gtk_window_set_position(GTK_WINDOW(pFenetre),GTK_WIN_POS_CENTER_ALWAYS);
 
   // Création des labels
  pLabel = gtk_label_new ("Choisissez un coffre !");
  pScore = gtk_label_new ("");
  mise_a_jour_score ();
 
    // Declaration des boites
  GtkWidget* pVbox=NULL;
  GtkWidget* pHbox=NULL;
  GtkWidget* p_main_box = NULL;
 
   	 // Chargement des images
   	 GdkPixbuf * pb1 = gdk_pixbuf_new_from_file("coffreFerme.jpeg", NULL);
 	 if (pb1==NULL) printf("Erreur en chargeant l'image coffreFerme.jpeg\n");
  	pixbuf1 = gdk_pixbuf_scale_simple(pb1, 100, 100, GDK_INTERP_NEAREST);
 
  	 GdkPixbuf * pb2 = gdk_pixbuf_new_from_file("coffreVide.jpeg", NULL);
         if (pb2==NULL) printf("Erreur en chargeant l'image coffreVide.jpeg\n");
         pixbuf2 = gdk_pixbuf_scale_simple(pb2, 100, 100, GDK_INTERP_NEAREST);
 
         GdkPixbuf * pb3 = gdk_pixbuf_new_from_file("coffreTresor.jpeg", NULL);
         if (pb3==NULL) printf("Erreur en chargeant l'image coffreTresor.jpeg\n");
         pixbuf3 = gdk_pixbuf_scale_simple(pb3, 100, 100, GDK_INTERP_NEAREST);
 
 
 
  	 // Creation des quatre boutons 
  pBoutonRecommencer = gtk_button_new_with_label("Recommencer");
  pBouton0 = gtk_button_new();
  pBouton1 = gtk_button_new();
  pBouton2 = gtk_button_new();
  gtk_widget_set_sensitive(pBoutonRecommencer, FALSE);
 
  	  // Affichage des images
 	 gtk_button_set_image(GTK_BUTTON(pBouton0), gtk_image_new_from_pixbuf(pixbuf1));
 	 gtk_button_set_image(GTK_BUTTON(pBouton1), gtk_image_new_from_pixbuf(pixbuf1));
 	 gtk_button_set_image(GTK_BUTTON(pBouton2), gtk_image_new_from_pixbuf(pixbuf1));
 
 
  // Création des boites
  pVbox = gtk_vbox_new (FALSE, 1);
  pHbox = gtk_hbox_new (TRUE, 10);
  p_main_box = gtk_vbox_new (FALSE, 20);
 
 
 	//Ajoutons les quatre boutons et les labels dans les boites
 	gtk_box_pack_start (GTK_BOX(pVbox), pScore, FALSE, TRUE, 0);
 	gtk_box_pack_start (GTK_BOX(pVbox), pLabel, FALSE, TRUE, 0);
 	gtk_box_pack_start (GTK_BOX(pVbox), pBoutonRecommencer, FALSE, TRUE, 0);
 	gtk_box_pack_end (GTK_BOX(pHbox), pBouton0, TRUE, TRUE, 10);
 	gtk_box_pack_end (GTK_BOX(pHbox), pBouton1, TRUE, TRUE, 10);
 	gtk_box_pack_end (GTK_BOX(pHbox), pBouton2, TRUE, TRUE, 10);
 
 
   //Ajoutons les deux boites dans la boite principale et celle ci dans la fenetre
   gtk_container_add (GTK_CONTAINER(p_main_box), pVbox);
   gtk_container_add (GTK_CONTAINER(p_main_box), pHbox);
   gtk_container_set_border_width (GTK_CONTAINER(pHbox), 10);
   gtk_container_add (GTK_CONTAINER(pFenetre), p_main_box);
 
  //  Affichage de la fenêtre
  gtk_widget_show_all(pFenetre);
 
	// Fonction qui capte le signal de la petite croix pour fermer la fenetre
	g_signal_connect(G_OBJECT(pFenetre), "destroy", G_CALLBACK(gtk_main_quit), NULL);
 
 
		// Fonction qui capte le clic de la souris pour le tirage au sort
	  	g_signal_connect(G_OBJECT(pBouton0), "clicked", G_CALLBACK(double_tirage), NULL);
	  	printf("signal double tirage bouton0\n");
	  	g_signal_connect(G_OBJECT(pBouton1), "clicked", G_CALLBACK(double_tirage), NULL);
	  	printf("signal double tirage bouton1\n");
	  	g_signal_connect(G_OBJECT(pBouton2), "clicked", G_CALLBACK(double_tirage), NULL);
	  	printf("signal double tirage bouton2\n");
	  	g_signal_connect(G_OBJECT(pBoutonRecommencer), "clicked", G_CALLBACK(recommencer_partie), NULL);
 gtk_main();
 
return EXIT_SUCCESS;
}
 
 
void tirage_coffre_tresor_simple (GtkWidget * pBouton)
{
	tiragesimple++;
	printf("tiragesimple %d\n\n", tiragesimple);
 
	srand(time(NULL));
	int coffre_au_tresor = rand () % (3-2+1) + 2;
		if (coffre_au_tresor == 2){
			gtk_button_set_image(GTK_BUTTON(pBouton), gtk_image_new_from_pixbuf(pixbuf2));
			nb_defaites++;
			gtk_label_set_label(GTK_LABEL(pLabel), "Perdu !");
			printf("Perdu\n\n");
		}
		else    {
			gtk_button_set_image(GTK_BUTTON(pBouton), gtk_image_new_from_pixbuf(pixbuf3));
			nb_victoires++;
			gtk_label_set_label(GTK_LABEL(pLabel), "Gagné !");
			printf("Gagné\n\n");
		}
	mise_a_jour_score();	
	gtk_widget_set_sensitive(pBoutonRecommencer, TRUE);
 
}
 
 
void double_tirage (GtkWidget * pBouton)
{
	doubletirage++;
	printf("\nDouble tirage %d\n",doubletirage);
	//tirage_coffre_tresor_simple(pBouton);
	g_signal_handlers_destroy(G_OBJECT(pBouton0));
	printf("double tirage détruit bouton0\n");
	g_signal_handlers_destroy(G_OBJECT(pBouton1));
	printf("double tirage détruit bouton1\n");
	g_signal_handlers_destroy(G_OBJECT(pBouton2));
	printf("double tirage détruit bouton2\n");
 
	g_signal_connect(G_OBJECT(pBouton0), "clicked", G_CALLBACK(tirage_coffre_tresor_simple), NULL);
	printf("signal tirage simple bouton0\n");
	g_signal_connect(G_OBJECT(pBouton1), "clicked", G_CALLBACK(tirage_coffre_tresor_simple), NULL);
	printf("signal tirage simple bouton1\n");
	g_signal_connect(G_OBJECT(pBouton2), "clicked", G_CALLBACK(tirage_coffre_tresor_simple), NULL);
	printf("signal tirage simple bouton2\n");
 
    srand(time(NULL));
	if (pBouton == pBouton0) {
		int coffre_vide = rand () % (2-1+1) + 1;
 
			if (coffre_vide == 1){
				gtk_button_set_image(GTK_BUTTON(pBouton1),  gtk_image_new_from_pixbuf(pixbuf2));
			}		
			else	{
				gtk_button_set_image(GTK_BUTTON(pBouton2), gtk_image_new_from_pixbuf(pixbuf2));
			}
	}
	else if (pBouton == pBouton1) {
		double coffre_vide = (double) rand() / RAND_MAX * (2-0) + 0;
			if (coffre_vide < 1){
				gtk_button_set_image(GTK_BUTTON(pBouton0), gtk_image_new_from_pixbuf(pixbuf2));
			}
			else	
				gtk_button_set_image(GTK_BUTTON(pBouton2), gtk_image_new_from_pixbuf(pixbuf2));
	}
	else 	{
		int coffre_vide = rand () % (1-0+1) + 0;
			if (coffre_vide == 0){
				gtk_button_set_image(GTK_BUTTON(pBouton0), gtk_image_new_from_pixbuf(pixbuf2));
			}
			else	{
				gtk_button_set_image(GTK_BUTTON(pBouton1), gtk_image_new_from_pixbuf(pixbuf2));
			}
	}
 
	gtk_widget_set_sensitive(pBoutonRecommencer, TRUE);
	printf ("\n");	
 
}
 
 
void mise_a_jour_score ()
{
	char message[100];
  	sprintf(message, "Victoires : %d   Défaites : %d", nb_victoires, nb_defaites);
  	printf("Victoires : %d   Défaites : %d\n\n",nb_victoires, nb_defaites); 
  	gtk_label_set_text(GTK_LABEL(pScore), message);
 
}
 
void recommencer_partie ()
{
	gtk_button_set_image(GTK_BUTTON(pBouton0),  gtk_image_new_from_pixbuf(pixbuf1));
	gtk_button_set_image(GTK_BUTTON(pBouton1),  gtk_image_new_from_pixbuf(pixbuf1));
	gtk_button_set_image(GTK_BUTTON(pBouton2),  gtk_image_new_from_pixbuf(pixbuf1));
	g_signal_connect(G_OBJECT(pBouton0), "clicked", G_CALLBACK(double_tirage), NULL);
	printf("signal double tirage bouton0\n");
	g_signal_connect(G_OBJECT(pBouton1), "clicked", G_CALLBACK(double_tirage), NULL);
	printf("signal double tirage bouton1\n");
	g_signal_connect(G_OBJECT(pBouton2), "clicked", G_CALLBACK(double_tirage), NULL);
	printf("signal double tirage bouton2\n");
	gtk_label_set_label(GTK_LABEL(pLabel), "Choisissez un coffre !");
	gtk_widget_set_sensitive(pBoutonRecommencer, FALSE);
}

**gerald3d** · 03/02/2015, 22h26

Tout d'abord tu ne respectes pas le prototype du callback associé au signal clicked. Voir signal "clicked".

Ensuite, pour déterminer où le bas blesse tu peux

soit utiliser des printf(); pour déterminer où le code s'arrête,
soit compiler ton code avec l'option -g et par la suite l'exécuter avec gdb par exemple. Il te donnera moultes informations lors du plantage.

Pour ton problème actuel je n'arrive pas à trouver la documentation de la fonction g_signal_handlers_destroy();. Et malheureusement je pense que le problème vient de là.

Remarque :
Pense à utiliser le pointeur utilisateur que tu peux propager dans tes fonctions callbacks pour supprimer toutes ces déclarations en global. Ton code commence à devenir illisible. Tu vas rapidement ne plus savoir à quel moment tu peux ou non utiliser une variable/pointeur et surtout qui la modifie.

**Dimitri95** · 04/02/2015, 18h24

ok merci, et ne savez vous pas non plus comment utiliser "g_signal_disconnect" ?

**gerald3d** · 05/02/2015, 18h56

L'utilisation de gtk_signal_disconnect(); est déprécié. Il faut utiliser g_signal_handler_disconnect(); en lieu et place.

Son utilisation est assez simple :

En premier argument tu transmet l'objet concerné (ici ton bouton).
En second argument l'id référence que tu auras récupérer lors de l'utilisation de la fonction g_signal_connect();.

Ainsi Gtk+ sait quel pointeur enlever de la liste des callbacks associés au widget.

Remarque :
Si la fonction g_signal_handler_disconnect(); est inconnue lors de la compilation tu peux toujours utiliser gtk_signal_disconnect(); avec les même arguments.

**Ranger93** · 08/02/2015, 17h04

Bonjour, travaillant sur un projet similaire, je rencontre des erreurs que je n'arrive pas à corriger :
(tresor2:3080): Gtk-CRITICAL **: IA__gtk_widget_set_parent: assertion 'widget != parent' failed
Erreur de segmentation (core dumped)

Le problème étant que lors de la compilation aucune erreurs n'est détecté et c'est seulement lorsque je lance le programme qu'il m'affiche ces erreurs.

Voici mon code :

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
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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
#include <stdlib.h>
#include <gtk/gtk.h>
#include <time.h>
 
// constantes
typedef enum {FERME=0,VIDE=1,PLEIN=2} etat_coffre_t;
typedef enum {DEBUT, PREMIER_CHOIX, GAGNE, PERDU} etat_jeu_t;
 
/*Declaration des variables globales*/
 
// bouton try again
GtkWidget* Recommencer=NULL;
 
// etat coffres et jeu
etat_coffre_t etat_coffre[3]={FERME,FERME,FERME};
etat_jeu_t etat_jeu= DEBUT ;
 
// endroit tresor
int case_tresor = 0;
 
// points
int defaites = 0;
int victoires = 0;
 
// Fenetre
GtkWidget* Fenetre = NULL;
 
// boutons coffres
GtkWidget* Button[3] = { NULL, NULL, NULL };
 
// images tresors
GdkPixbuf* pixbuf[3] = { NULL, NULL, NULL };
 
// label score instructions
GtkWidget* Score = NULL;
GtkWidget* Message = NULL;
 
// Déclaration des fonctions
void clic_bouton(int bouton);
void clic_bouton1();
void clic_bouton2();
void clic_bouton3();
void initialisation();
void coffre(int bouton, etat_coffre_t etat);
void scores_update();
 
// Définitions de fonctions
int main(int argc, char** argv)
{
	int etat_coffre, bouton ;
 
	// Initialisation gtk
	gtk_init(&argc, &argv);
 
	// Initialisation aleatoire
	srand(time(NULL));
 
	// Creation fenetre
	Fenetre = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_window_set_title(GTK_WINDOW(Fenetre), "Chasse au trésor");
	gtk_window_set_default_size(GTK_WINDOW(Fenetre), 400, 200);
	gtk_window_set_position(GTK_WINDOW(Fenetre), GTK_WIN_POS_CENTER_ALWAYS);
 
	// Declaration boite horizontale
	GtkWidget* HBox=NULL;
	GtkWidget* HBoxTresor=NULL;
	GtkWidget* VBoxTresor1=NULL;
 
	// Creation boutons
	for (bouton=0; bouton<3; bouton++)
	{
		Button[bouton ] = gtk_button_new();
	}
 
	// Creation des images  
	char * cheminsImages[3] =
	{"coffre_ferme.jpg",
	 "coffre_vide.jpg",
	 "coffre_plein.jpg"
	};
 
	for (etat_coffre=0; etat_coffre<3; etat_coffre=etat_coffre+1)
	{
		GdkPixbuf * pb = gdk_pixbuf_new_from_file(cheminsImages[etat_coffre], NULL);
    		pixbuf[etat_coffre] = gdk_pixbuf_scale_simple(pb, 100, 100, GDK_INTERP_NEAREST);
  	}
 
	// Creation des boites
	HBox = gtk_hbox_new(TRUE, 20);
	HBoxTresor = gtk_hbox_new(TRUE, 0);
	VBoxTresor1 = gtk_vbox_new(FALSE, 0);
 
	// Ajout boutons boite
	for (bouton=0; bouton<3; bouton++) 
	{
		gtk_box_pack_start(GTK_BOX(HBox), Button[bouton], FALSE, TRUE, 0);
	}
 
	// Label scores et instructions
	Score = gtk_label_new("Victoires: 0   Défaites : 0");
	gtk_box_pack_start(GTK_BOX(VBoxTresor1), Score, FALSE, FALSE, 0);
	Message = gtk_label_new("");
	gtk_box_pack_start(GTK_BOX(VBoxTresor1), Message, FALSE, FALSE, 0);
 
	// Bouton reinitialisation
	Recommencer = gtk_button_new_with_mnemonic("_Recommencer");
	gtk_box_pack_start(GTK_BOX(VBoxTresor1), Recommencer, FALSE, FALSE, 0);
 
	//conteneurs
	gtk_box_pack_start(GTK_BOX(HBoxTresor), HBoxTresor, TRUE, TRUE, 20);
	gtk_box_pack_start(GTK_BOX(VBoxTresor1), HBoxTresor, TRUE, TRUE, 20);
 
	gtk_container_add(GTK_CONTAINER(Fenetre), VBoxTresor1);
 
	// Affichage de tout
	gtk_widget_show_all(Fenetre);
	gtk_signal_connect(GTK_OBJECT(Fenetre), "destroy", G_CALLBACK(gtk_main_quit), NULL);
 
	// callbacks des coffres
	gtk_signal_connect(GTK_OBJECT(Button[0]), "clicked", G_CALLBACK(clic_bouton1), NULL);
	gtk_signal_connect(GTK_OBJECT(Button[1]), "clicked", G_CALLBACK(clic_bouton2), NULL);
	gtk_signal_connect(GTK_OBJECT(Button[2]), "clicked", G_CALLBACK(clic_bouton3), NULL);
 
	// callback bouton Recommencer
	gtk_signal_connect(GTK_OBJECT(Recommencer), "clicked", G_CALLBACK(initialisation), NULL);
 
	initialisation();
	gtk_main();
 
	return EXIT_SUCCESS;
}
 
// callbacks
void initialisation()
{
	// etat jeu
	etat_jeu = DEBUT;
 
	// coffre avec tresor
	case_tresor = (rand() % 3);
 
	// coffres fermés
	int bouton;
	for (bouton = 0; bouton<3; bouton = bouton + 1)
	{
		coffre(bouton, FERME);
	}
 
	// message
	gtk_label_set_text(GTK_LABEL(Message), "Choisissez un coffre");
 
	// désactivation du bouton try again
	gtk_widget_set_sensitive(Recommencer, FALSE);
}
 
void clic_bouton(int bouton)
{
	// Ouverture coffre deja ouvert
	if (etat_coffre[bouton] != FERME)
	{
		return;
	}
 
	// premier choix deja fait
	if (etat_jeu == PREMIER_CHOIX)
	{
		if (case_tresor == bouton) 
		{
			etat_jeu = GAGNE;
			coffre(bouton, PLEIN);
			victoires = victoires + 1;
			gtk_label_set_text(GTK_LABEL(Message), "Gagné");
		}
		else 
		{
			etat_jeu = PERDU;
			coffre(bouton, VIDE);
			defaites = defaites + 1;
			gtk_label_set_text(GTK_LABEL(Message), "Perdu");
		}
		gtk_widget_set_sensitive(Recommencer, TRUE);
		scores_update();
	}
 
	if (etat_jeu == DEBUT) 
	{
		etat_jeu = PREMIER_CHOIX;
		if (case_tresor != bouton)
		{
			// ouverture coffre vide
			int ahah = 0;
			for (ahah = 0; ahah<3; ahah = ahah + 1) 
			{
				if (ahah != bouton && ahah != case_tresor)
				{
					coffre(ahah, VIDE);
				}
			}
		}
		else 
		{
			// ouverture autre coffre
			int autre = (bouton + (rand() % 2) + 1) % 3;
			coffre(autre, VIDE);
		}
	}
}
 
void coffre(int bouton, etat_coffre_t etat)
{
	GtkWidget * image = gtk_image_new_from_pixbuf(pixbuf[etat]);
	gtk_button_set_image(GTK_BUTTON(Button[bouton]), image);
	etat_coffre[bouton] = etat ;
}
 
void scores_update()
{
	char message[100];
	sprintf(message, "Victoires : %d   Défaites : %d",victoires, defaites);
	gtk_label_set_text(GTK_LABEL(Score), message);
}
 
void clic_bouton1()
{
	 clic_bouton(0);
}
 
void clic_bouton2()
{
	clic_bouton(1);
}
 
void clic_bouton3()
{
	clic_bouton(2);
}

J'espère que j'obtiendrai assez rapidement une réponse car c'est urgent.

**gerald3d** · 08/02/2015, 17h31

Envoyé par Ranger93

Bonjour, travaillant sur un projet similaire, je rencontre des erreurs que je n'arrive pas à corriger :
(tresor2:3080): Gtk-CRITICAL **: IA__gtk_widget_set_parent: assertion 'widget != parent' failed
Erreur de segmentation (core dumped)

Le problème étant que lors de la compilation aucune erreurs n'est détecté et c'est seulement lorsque je lance le programme qu'il m'affiche ces erreurs.

Voici mon code :

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
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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
#include <stdlib.h>
#include <gtk/gtk.h>
#include <time.h>
 
// constantes
typedef enum {FERME=0,VIDE=1,PLEIN=2} etat_coffre_t;
typedef enum {DEBUT, PREMIER_CHOIX, GAGNE, PERDU} etat_jeu_t;
 
/*Declaration des variables globales*/
 
// bouton try again
GtkWidget* Recommencer=NULL;
 
// etat coffres et jeu
etat_coffre_t etat_coffre[3]={FERME,FERME,FERME};
etat_jeu_t etat_jeu= DEBUT ;
 
// endroit tresor
int case_tresor = 0;
 
// points
int defaites = 0;
int victoires = 0;
 
// Fenetre
GtkWidget* Fenetre = NULL;
 
// boutons coffres
GtkWidget* Button[3] = { NULL, NULL, NULL };
 
// images tresors
GdkPixbuf* pixbuf[3] = { NULL, NULL, NULL };
 
// label score instructions
GtkWidget* Score = NULL;
GtkWidget* Message = NULL;
 
// Déclaration des fonctions
void clic_bouton(int bouton);
void clic_bouton1();
void clic_bouton2();
void clic_bouton3();
void initialisation();
void coffre(int bouton, etat_coffre_t etat);
void scores_update();
 
// Définitions de fonctions
int main(int argc, char** argv)
{
	int etat_coffre, bouton ;
 
	// Initialisation gtk
	gtk_init(&argc, &argv);
 
	// Initialisation aleatoire
	srand(time(NULL));
 
	// Creation fenetre
	Fenetre = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_window_set_title(GTK_WINDOW(Fenetre), "Chasse au trésor");
	gtk_window_set_default_size(GTK_WINDOW(Fenetre), 400, 200);
	gtk_window_set_position(GTK_WINDOW(Fenetre), GTK_WIN_POS_CENTER_ALWAYS);
 
	// Declaration boite horizontale
	GtkWidget* HBox=NULL;
	GtkWidget* HBoxTresor=NULL;
	GtkWidget* VBoxTresor1=NULL;
 
	// Creation boutons
	for (bouton=0; bouton<3; bouton++)
	{
		Button[bouton ] = gtk_button_new();
	}
 
	// Creation des images  
	char * cheminsImages[3] =
	{"coffre_ferme.jpg",
	 "coffre_vide.jpg",
	 "coffre_plein.jpg"
	};
 
	for (etat_coffre=0; etat_coffre<3; etat_coffre=etat_coffre+1)
	{
		GdkPixbuf * pb = gdk_pixbuf_new_from_file(cheminsImages[etat_coffre], NULL);
    		pixbuf[etat_coffre] = gdk_pixbuf_scale_simple(pb, 100, 100, GDK_INTERP_NEAREST);
  	}
 
	// Creation des boites
	HBox = gtk_hbox_new(TRUE, 20);
	HBoxTresor = gtk_hbox_new(TRUE, 0);
	VBoxTresor1 = gtk_vbox_new(FALSE, 0);
 
	// Ajout boutons boite
	for (bouton=0; bouton<3; bouton++) 
	{
		gtk_box_pack_start(GTK_BOX(HBox), Button[bouton], FALSE, TRUE, 0);
	}
 
	// Label scores et instructions
	Score = gtk_label_new("Victoires: 0   Défaites : 0");
	gtk_box_pack_start(GTK_BOX(VBoxTresor1), Score, FALSE, FALSE, 0);
	Message = gtk_label_new("");
	gtk_box_pack_start(GTK_BOX(VBoxTresor1), Message, FALSE, FALSE, 0);
 
	// Bouton reinitialisation
	Recommencer = gtk_button_new_with_mnemonic("_Recommencer");
	gtk_box_pack_start(GTK_BOX(VBoxTresor1), Recommencer, FALSE, FALSE, 0);
 
	//conteneurs
	gtk_box_pack_start(GTK_BOX(HBoxTresor), HBoxTresor, TRUE, TRUE, 20);
	gtk_box_pack_start(GTK_BOX(VBoxTresor1), HBoxTresor, TRUE, TRUE, 20);
 
	gtk_container_add(GTK_CONTAINER(Fenetre), VBoxTresor1);
 
	// Affichage de tout
	gtk_widget_show_all(Fenetre);
	gtk_signal_connect(GTK_OBJECT(Fenetre), "destroy", G_CALLBACK(gtk_main_quit), NULL);
 
	// callbacks des coffres
	gtk_signal_connect(GTK_OBJECT(Button[0]), "clicked", G_CALLBACK(clic_bouton1), NULL);
	gtk_signal_connect(GTK_OBJECT(Button[1]), "clicked", G_CALLBACK(clic_bouton2), NULL);
	gtk_signal_connect(GTK_OBJECT(Button[2]), "clicked", G_CALLBACK(clic_bouton3), NULL);
 
	// callback bouton Recommencer
	gtk_signal_connect(GTK_OBJECT(Recommencer), "clicked", G_CALLBACK(initialisation), NULL);
 
	initialisation();
	gtk_main();
 
	return EXIT_SUCCESS;
}
 
// callbacks
void initialisation()
{
	// etat jeu
	etat_jeu = DEBUT;
 
	// coffre avec tresor
	case_tresor = (rand() % 3);
 
	// coffres fermés
	int bouton;
	for (bouton = 0; bouton<3; bouton = bouton + 1)
	{
		coffre(bouton, FERME);
	}
 
	// message
	gtk_label_set_text(GTK_LABEL(Message), "Choisissez un coffre");
 
	// désactivation du bouton try again
	gtk_widget_set_sensitive(Recommencer, FALSE);
}
 
void clic_bouton(int bouton)
{
	// Ouverture coffre deja ouvert
	if (etat_coffre[bouton] != FERME)
	{
		return;
	}
 
	// premier choix deja fait
	if (etat_jeu == PREMIER_CHOIX)
	{
		if (case_tresor == bouton) 
		{
			etat_jeu = GAGNE;
			coffre(bouton, PLEIN);
			victoires = victoires + 1;
			gtk_label_set_text(GTK_LABEL(Message), "Gagné");
		}
		else 
		{
			etat_jeu = PERDU;
			coffre(bouton, VIDE);
			defaites = defaites + 1;
			gtk_label_set_text(GTK_LABEL(Message), "Perdu");
		}
		gtk_widget_set_sensitive(Recommencer, TRUE);
		scores_update();
	}
 
	if (etat_jeu == DEBUT) 
	{
		etat_jeu = PREMIER_CHOIX;
		if (case_tresor != bouton)
		{
			// ouverture coffre vide
			int ahah = 0;
			for (ahah = 0; ahah<3; ahah = ahah + 1) 
			{
				if (ahah != bouton && ahah != case_tresor)
				{
					coffre(ahah, VIDE);
				}
			}
		}
		else 
		{
			// ouverture autre coffre
			int autre = (bouton + (rand() % 2) + 1) % 3;
			coffre(autre, VIDE);
		}
	}
}
 
void coffre(int bouton, etat_coffre_t etat)
{
	GtkWidget * image = gtk_image_new_from_pixbuf(pixbuf[etat]);
	gtk_button_set_image(GTK_BUTTON(Button[bouton]), image);
	etat_coffre[bouton] = etat ;
}
 
void scores_update()
{
	char message[100];
	sprintf(message, "Victoires : %d   Défaites : %d",victoires, defaites);
	gtk_label_set_text(GTK_LABEL(Score), message);
}
 
void clic_bouton1()
{
	 clic_bouton(0);
}
 
void clic_bouton2()
{
	clic_bouton(1);
}
 
void clic_bouton3()
{
	clic_bouton(2);
}

J'espère que j'obtiendrai assez rapidement une réponse car c'est urgent.

Bonjour.

Crées un nouveau post pour ne pas polluer celui-là. Je regarde ton code après.

**tuonick** · 09/02/2015, 12h52

Bonjour Ranger 93, je ne sais pas par quel miracle ton code est le meme que le mien, avec notamment la variable "ahah", le commentaire avec le bouton "try again" et tellement d'autres choses...
Si tu es à l'institut Galilée, je te conseille de ne pas envoyer ce code qui est le mien qui est quasi le meme puisque le tien a les memes erreurs que j'avais..., sauf que moi je les ai corrigées...

Projet chasse au trésor

GTK+

Discussions similaires

Partager

Partager