empecher destruction fenetre

Version imprimable

Bonjour,

Je cherches à empêcher la destruction de ma fenêtre lors du clic sur la croix de fermeture. J'ai mis une demande de confirmation et si je répond non la fenêtre est détruite.

Par contre pour ceux qui ont lus mes posts precedents, mon prob de barre d'outil/menu fonctionne avec ce code.

La selection de B dans le menu active A et désactive B, la salection de A fait l'inverse. La croix (GTK_STOCK_QUIT)dans la barre d'outil correspond à B selectionné , quand on clique l'icone devient l'icone GTK_STOCK_NEW ) et l'éat du menu change.

J'ai essayé d'utiliser g_signal_connect_object à la place de g_signal_connect pour empêcher la destruction de ma fenetre, ça marche pas, mais je dois pas être loin.

voici le code :

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
 
 
 
#include <gtk/gtk.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
 
void routine_1();
void routine_2();
void routine_sortie();
void recreation_barre_outil();
 
GtkWidget 	*fenetre;
GtkWidget 	*text_view;
GtkWidget 	*scrollbar;
GtkWidget 	*box;
GtkWidget 	*barre_outil;
GtkTextBuffer *buffer;
GtkWidget 	*barre_menu;
GtkWidget	*menu;
GtkWidget	*menuitem_sousmenu_fichier,*menuitem_a,*menuitem_b, *menuitem_quit;
GtkWidget	*svg;
int			elements_barre_outil;
 
int main (int argc, char **argv)
{
 
 
	gtk_init (&argc, &argv);
 
	fenetre = gtk_window_new (GTK_WINDOW_TOPLEVEL);
	gtk_window_set_title (GTK_WINDOW (fenetre), "Test");
	gtk_window_set_default_size(GTK_WINDOW(fenetre), 640, 480); 
	g_signal_connect_object (G_OBJECT(fenetre),"delete-event",G_CALLBACK(routine_sortie),svg,1<<0);
	box=gtk_vbox_new(FALSE,5); 
   	gtk_container_add(GTK_CONTAINER(fenetre),box);
 
	barre_menu=gtk_menu_bar_new();
	menu=gtk_menu_new();
	menuitem_sousmenu_fichier=gtk_menu_item_new_with_label("Fichier");
	gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem_sousmenu_fichier),menu);
	gtk_menu_shell_append(GTK_MENU_SHELL(barre_menu),menuitem_sousmenu_fichier);
 
	menuitem_a=gtk_menu_item_new_with_label("A");
	g_signal_connect(G_OBJECT(menuitem_a),"activate",G_CALLBACK(routine_1),fenetre);
	gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuitem_a);
 
	menuitem_b=gtk_menu_item_new_with_label("B");
	g_signal_connect(G_OBJECT(menuitem_b),"activate",G_CALLBACK(routine_2),fenetre);
	gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuitem_b);
	gtk_widget_set_sensitive(menuitem_a,FALSE);
 
	menuitem_quit=gtk_menu_item_new_with_label("Quitter");
	g_signal_connect(G_OBJECT(menuitem_quit),"activate",G_CALLBACK(routine_sortie),fenetre);
	gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuitem_quit);
 
	gtk_box_pack_start(GTK_BOX(box),barre_menu,FALSE,FALSE,0);
 
	barre_outil=gtk_toolbar_new();
	gtk_box_pack_start(GTK_BOX(box),barre_outil,FALSE,FALSE,0);
	gtk_toolbar_insert_stock(GTK_TOOLBAR(barre_outil),GTK_STOCK_STOP,NULL,NULL,routine_1,NULL,-1);	
	gtk_toolbar_insert_stock(GTK_TOOLBAR(barre_outil),GTK_STOCK_QUIT,NULL,NULL,routine_sortie,NULL,-1);	
	gtk_toolbar_set_style(GTK_TOOLBAR(barre_outil),GTK_TOOLBAR_ICONS);
	gtk_toolbar_set_icon_size(GTK_TOOLBAR(barre_outil),GTK_ICON_SIZE_MENU);
	elements_barre_outil=2;
 
	gtk_widget_show_all(fenetre);
  	gtk_main();
  	return 0;
}
 
void routine_1()
{
	gtk_widget_set_sensitive(menuitem_b,TRUE);
	gtk_widget_set_sensitive(menuitem_a,FALSE);
 
	elements_barre_outil=2;
	recreation_barre_outil();
 
	printf("routine 1 dÃ©clenchÃ©e\n");
}
 
void routine_2()
{
	gtk_widget_set_sensitive(menuitem_a,TRUE);
	gtk_widget_set_sensitive(menuitem_b,FALSE);
 
	elements_barre_outil=1;
	recreation_barre_outil();
 
	printf("routine 2 dÃ©clenchÃ©e\n");
 
}
 
void routine_sortie()
{
GtkWidget 		*demande_fermeture;
GtkResponseType reponse_fermeture;
 
	demande_fermeture=gtk_message_dialog_new (NULL, GTK_DIALOG_DESTROY_WITH_PARENT,
                                   GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO,
                                   "Etes-vous sur de vouloir quitter ?");
	gtk_window_set_title (GTK_WINDOW (demande_fermeture), "Confirmation");
	gtk_window_set_modal(GTK_WINDOW(demande_fermeture), TRUE);
	reponse_fermeture=gtk_dialog_run(GTK_DIALOG (demande_fermeture));
	gtk_widget_destroy(demande_fermeture);
	if (reponse_fermeture==GTK_RESPONSE_YES)
	{	
		gtk_main_quit();
	}
}
 
void recreation_barre_outil()
{
	gtk_widget_destroy(barre_outil);
	barre_outil=gtk_toolbar_new();
	gtk_box_pack_start(GTK_BOX(box),barre_outil,FALSE,FALSE,0);
	if (elements_barre_outil==2)
	gtk_toolbar_insert_stock(GTK_TOOLBAR(barre_outil),GTK_STOCK_STOP,NULL,NULL,routine_2,NULL,-1);	
	if (elements_barre_outil==1)
	gtk_toolbar_insert_stock(GTK_TOOLBAR(barre_outil),GTK_STOCK_NEW,NULL,NULL,routine_1,NULL,-1);	
	gtk_toolbar_set_style(GTK_TOOLBAR(barre_outil),GTK_TOOLBAR_ICONS);
	gtk_toolbar_set_icon_size(GTK_TOOLBAR(barre_outil),GTK_ICON_SIZE_MENU);	
	gtk_widget_show(barre_outil);
 
}

:arf:

20/09/2011, 13h29
Slookeur

Re

Bonjour,
pour empécher la destruction de ta fenêtre il faut définir un callback sur le signal "delete-event" qui correspond au signal envoyé par un clic sur la petite croix.
Et la fonction a utilisé comme callback est la fonction "gtk_widget_hide_on_delete"

ex:

Code:

g_signal_connect (G_OBJECT (your_window), "delete-event", G_CALLBACK (gtk_widget_hide_on_delete), NULL);

La fenêtre va alors être masquée et peut être de nouveau affichée par un gtk_widget_show.
21/09/2011, 08h45
Christophe

empecher destruction fenetre suite

Merci pour la réponse,

J'avais bien vu la fonction mais n'es pas réussi à l'utiliser je chercher à intercepter le déclenchement de l'événement delete-event, faire mon traitement puis rendre la main sans forcément cacher la fenêtre. Pour le moment, j'ai fait autrement.

Citation:

Envoyé par Slookeur

Bonjour,
pour empécher la destruction de ta fenêtre il faut définir un callback sur le signal "delete-event" qui correspond au signal envoyé par un clic sur la petite croix.
Et la fonction a utilisé comme callback est la fonction "gtk_widget_hide_on_delete"

ex:

Code:

g_signal_connect (G_OBJECT (your_window), "delete-event", G_CALLBACK (gtk_widget_hide_on_delete), NULL);

La fenêtre va alors être masquée et peut être de nouveau affichée par un gtk_widget_show.
21/09/2011, 12h16
liberforce
Bonjour,

ton problème est que ta callback ne respecte pas la signature attendue pour le signal delete-event.

D'après la documentation, le signal delete-event attend une callback ayant pour signature:
Code:

1 2 3 4 gboolean user_function (GtkWidget *widget, GdkEvent *event, gpointer user_data)
Or la callback que tu utilises a pour signature:

Code:

void routine_sortie()

Cela ne peut donc clairement pas marcher. Une callback doit toujours respecter la signature attendue par un évènement. Tu connais cette signature en consultant la documentation.

Dans ton cas, dans ta callback, tu dois appeler gtk_main_quit si l'utilisateur indique qu'il veut quitter le programme, et faire un:

Code:

return TRUE;

Si tu veux indiquer que l'évènement a été traité (ce qui évite le traitement par défaut d'être appelé, qui déclenche l'évènement "destroy" qui détruit la fenêtre).

C'est indiqué dans la doc du signal:

Citation:

Returns :
TRUE to stop other handlers from being invoked for the event. FALSE to propagate the event further.
22/09/2011, 09h34
Christophe

complément empecher fermeture fenetre

ma fonction passée en paramètres est effectivement une fonction "void". Selon la complexité du code que je fais, la fenêtre est détruite ou on.

Je penses que cela vient du fait que ma fonction ne retournant pas de traitement du signal delete-event, ma fenêtre est détruite ou non selon le traitement du signale delete-event par les objets en amont de ma fenêtre.

Donc je DOIS ABSOLUMENT retourner une valeur comme décrit dans la doc, gtk me laissant ne pas respecter la norme ( je ne vois pas comment ma fonction pourrait savoir que le retour qu'elle fait ne sera pas stocké dans un gboolean mais là ça dépasse le cadre gtk ), sinon tant pis pour moi si ça déconne.
22/09/2011, 11h08
liberforce

Citation:

Envoyé par chrtophe

Donc je DOIS ABSOLUMENT retourner une valeur comme décrit dans la doc, gtk me laissant ne pas respecter la norme ( je ne vois pas comment ma fonction pourrait savoir que le retour qu'elle fait ne sera pas stocké dans un gboolean mais là ça dépasse le cadre gtk ), sinon tant pis pour moi si ça déconne.

C'est une erreur courante: tu ne peux pas "inventer" de toi même la signature de la callback. En même temps si tu sais qu'un signal existe, ça ne parait pas déconnant que tu aies besoin de la doc du signal pour l'utiliser.

De plus, GTK n'a pas la possibilité de t'informer lorsque tu te trompes de signature pour une callback, car ton signal n'est connu qu'à l'exécution, pas à la compilation (c'est une chaine de caractères décodée durant l'exécution). C'est le côté dynamique et générique, qui fait que créer un nouveau signal ajout très peu de code, l'infrastructure étant là, mais cela a aussi quelques inconvénients pour le novice. Je pense que c'est l'erreur la plus commune chez les débutants.