tester une fenêtre pendant qu'une autre est lancée :

Version imprimable

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:

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;
}

25/05/2008, 16h00
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:

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
25/05/2008, 16h06
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 :

Citation:

(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é?
25/05/2008, 16h19
Rniamo

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

j'oublié de faire l'affectation pour récupérer ma fenêtre ...
25/05/2008, 16h27
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:
  
  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 :-°
25/05/2008, 17h12
Rniamo

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