Discussion :

[Rniamo]

je voudrais lancé une fenêtre pendant qu'une autre est lancée mais ma structure n'est pas sauvegardée (je perds mes valeurs). Je me doute que c'est quelquechose de bête mais là je vois plus rien :

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
 
typedef struct _callback
{
	GtkWidget *win;
	GtkWidget *box_hide;
	GtkWidget *onglet;	
	GtkWidget *text_view;
	Tcolonne *colonnes;
	const gchar *nomPg;
	int nbColonnes;
}T_callback;
 
void quitter(GtkWidget *w, gpointer d)
{
	T_callback *f=(T_callback *)d;
	(void) w;
 
	if (Mix_PlayingMusic() || Mix_PausedMusic())
		Mix_HaltMusic();
	fermeSDLAudio();
 
	gtk_widget_destroy(f->win);
}
 
void quitter2(GtkWidget *w, gpointer d)
{
	// T_callback *f=(T_callback *)d;
	(void) d;
	(void) w;
 
	if (Mix_PlayingMusic() || Mix_PausedMusic())
		Mix_HaltMusic();
	fermeSDLAudio();
 
	gtk_main_quit();
}
 
void testeConf(GtkWidget *w, gpointer d)
{
	T_callback *f=(T_callback *) d;
	char nomTmp[]=".tmp";
	T_callback *TcbTmp;
	(void) w;
 
	if ( !(TcbTmp=(T_callback *)malloc(sizeof(T_callback))) )
		return;
 
	ecrireFichier(nomTmp,f);
	ouvrirFichier(nomTmp,TcbTmp);
	remove(nomTmp);
 
	creation_fenetre(TITRE_TEST,TcbTmp,1,0);
}
 
GtkWidget *creation_fenetre(const gchar *titre, T_callback *f, int quit, int ed)
{	
	GtkWidget *win, *vbox1, *vbox, *hbox, *label, *bouton;
	int i;
 
	/*création de la fenêtre*/
	win=gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_window_set_title(GTK_WINDOW(win),titre);
	gtk_window_set_position(GTK_WINDOW(win),GTK_WIN_POS_CENTER);
	gtk_window_set_resizable(GTK_WINDOW(win),TRUE);
	gtk_window_set_default_size(GTK_WINDOW(win),320,240);
	gtk_window_set_icon_from_file(GTK_WINDOW(win),ICONE,NULL);
 
	if (quit)
		g_signal_connect(G_OBJECT(win),"delete-event",G_CALLBACK(quitter),f);
	else
		g_signal_connect(G_OBJECT(win),"delete-event",G_CALLBACK(quitter2),NULL);
	g_signal_connect(G_OBJECT(win),"key_press_event",G_CALLBACK(key_press_event),f);
 
	if (!quit)
	{
		vbox1=gtk_vbox_new(FALSE,0);
		gtk_container_add(GTK_CONTAINER(win),vbox1);
 
		f->onglet=gtk_notebook_new();
		gtk_box_pack_start(GTK_BOX(vbox1),f->onglet, TRUE, TRUE,0);
		gtk_notebook_set_scrollable(GTK_NOTEBOOK(f->onglet), TRUE);
		gtk_notebook_set_tab_pos(GTK_NOTEBOOK(f->onglet), GTK_POS_BOTTOM);
	}
	if (!ed)
	{
		/***************************************** 1er onglet **********************************************/
		vbox=gtk_vbox_new(FALSE,0);
		if (!quit)
			gtk_notebook_append_page(GTK_NOTEBOOK(f->onglet),vbox,gtk_label_new("App."));
		else
			gtk_container_add(GTK_CONTAINER(win),vbox);
 
		f->box_hide=gtk_hbox_new(TRUE,0);
		gtk_box_pack_start(GTK_BOX(vbox),f->box_hide, FALSE, FALSE,0);
 
		menu(f->box_hide,f,quit);
 
		label=gtk_label_new(NULL);
		gtk_label_set_use_markup(GTK_LABEL(label),TRUE);
		if (f->nomPg)
			gtk_label_set_markup(GTK_LABEL(label),g_strdup_printf("<span font_desc=\"%s %d\" foreground=\"#0000FF\"><b>%s\n</b></span>",POLICE,TAILLE_POLICE,f->nomPg));
		else
			gtk_label_set_markup(GTK_LABEL(label),g_strdup_printf("<span font_desc=\"%s %d\" foreground=\"#0000FF\"><b>%s\n</b></span>",POLICE,TAILLE_POLICE,TITRE_PROGRAMME));	
		gtk_box_pack_start(GTK_BOX(vbox),label, FALSE, FALSE,0);
 
		hbox=gtk_hbox_new(FALSE,0);
		gtk_box_pack_start(GTK_BOX(vbox),hbox, TRUE, TRUE,0);
 
		for (i=0;i<(f->nbColonnes);i++)
		{
			creationColonne(&(f->colonnes[i]));
			ajoutColonneBox(hbox, &(f->colonnes[i]));
		}
 
		hbox=gtk_hbox_new(TRUE,0);
		gtk_box_pack_start(GTK_BOX(vbox),hbox, FALSE, FALSE,0);
 
		bouton=gtk_button_new_from_stock(GTK_STOCK_MEDIA_STOP);
		gtk_box_pack_start(GTK_BOX(hbox), bouton, TRUE, TRUE,0);
		g_signal_connect(G_OBJECT(bouton),"clicked",G_CALLBACK(stopp),f);
	}
 
	/***************************************** 2eme onglet **********************************************/	
	if (!quit)
	{
		vbox=gtk_vbox_new(FALSE,0);
		if (!ed)
			gtk_container_add(GTK_CONTAINER(win),vbox);
		else
			gtk_notebook_append_page(GTK_NOTEBOOK(f->onglet),vbox,gtk_label_new("Ed."));
 
		menuEd(vbox,f);
		zoneEd(vbox,f);
	}
 
 
	gtk_widget_show_all(win);
 
	return win;
}

[Moiban]

Salut,

Je n'ai pas bien compris ton problème, cependant ton code a un problème : le signal "delete-event" appelle une fonction dont le prototype est :

Code c :

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

gboolean user_function (GtkWidget *widget, GdkEvent *event, gpionter data)

Et ta fonction quitter n'en attends que deux, ce qui fait que le deuxième n'est pas le pointeur user_data mais le pointeur vers l'évènement GdkEvent. En pratique, ça va boguer, et pas qu'un peu :-°

Le retour booléen n'est pas bien grave, mais les arguments si, surtout si tu les utilise

Cordialement,
moiban

[Rniamo]

ok, j'ai mis "destroy" à la place.

Le problème est que quand je lance ma deuxième fenêtre et que je veux quitter (avec la fonction quitter) j'ai l'erreur suivante :

(SoundPlayer:24231): Gtk-CRITICAL **: gtk_widget_destroy: assertion `GTK_IS_WIDGET (widget)' failed

et la fenêtre ne se ferme pas.

Si je veux accéder aux champs de ma structure, "segmentation error".

Donc mon malloc dans testeConf() ne serait pas conservé?

[Rniamo]

quand je disais que c'était bête ...

j'oublié de faire l'affectation pour récupérer ma fenêtre ...

[Moiban]

Salut,

Tu as réessayé avec "destroy" ("et non "destroy-event" qui a le même prototype que "delete-event" ) ?
Par ce que ça collerai bien avec tes problèmes :
tu utiliserai la structure GdkEvent à la place de la tienne sans le savoir, et donc tu auras des erreurs graves (segmentation fault, etc) lors des accès dans la structure. Et forcement, f->win ne serait pas une GtkWindow.

essaye de garder "delete_event", mais de changer le prototype de tes fonction quitter* pour les rendre compatibles avec l'évènement.
Ça n'est pas une bonne idée si tu utilise les fonctions quitter* avec un autre évènement que les *-event (genre "clicked" par ex), mais tu n'as pas l'aire de le faire.

Mais non, ton malloc n'a pas de raison de ne pas être conservé.


PS :
à propos de malloc, deux petites remarques :

• Question de choix, mais la GLib de propose des fonctions d'allocations comme g_malloc(), g_new(), g_try_malloc(), etc. qui peuvent être pratique. Après malloc marche très bien donc il n'y a pas de problèmes à l'utiliser.
• tu n'as pas besoin de caster le retour d'un malloc(), ça ne sert à rien
• Et une petite astuce qui gagne à être connue : pour obtenir la taille à allouer, tu peux faire comme suit :

  Code c :

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

  void* var = malloc (sizeof *var);

  ce qui permet de change plus facilement le type de var si il t'en venait l'idée

[edit]
J'ai mis trop de temps à répondre moi :-°

[Rniamo]

merci quand même c'était intéressant.