Détecter ouverture fenêtre

Version imprimable

31/03/2012, 19h28
LM_programme

Détecter ouverture fenêtre

Bonjour,

J'ai la fenêtre principale de mon application.
à partir d'un bouton, j'en ouvre une seconde fenêtre.

Jusqu'ici tout va bien
Sauf que je voudrais détecter l'ouverture et la fermeture de la seconde fenêtre.
car si on presse plusieurs fois le bouton. il ouvre le même nombre de fenêtre.

Existe-t-il une fonction dans la bibliothèque GTK+ pour détecter ce genre de fenêtre ?

Mon application est programmé en C et GTK+
31/03/2012, 20h53
gerald3d

Ta deuxième fenêtre est représentée par un pointeur GtkWidget. Tu peux utiliser la fonction GtkStateFlags gtk_widget_get_state_flags (GtkWidget *widget);.

Sinon tu peux aussi déactiver le bouton qui ouvre la deuxième fenêtre dés le premier clic.
31/03/2012, 22h52
LM_programme

Citation:

Envoyé par gerald3d

Ta deuxième fenêtre est représentée par un pointeur GtkWidget. Tu peux utiliser la fonction GtkStateFlags gtk_widget_get_state_flags (GtkWidget *widget);.

Comment utilise-t-on cette fonction ?

Pour la deuxième idée, j'arrive à désactivé mon bouton mais je n'arrive pas à le réactivé lors de la fermeture de ma seconde fenêtre.

Pour réactiver ton bouton il te faut avoir son pointeur. Le premier réflexe que tout le monde a est de déclarer ce pointeur en global. C'est qui est à éviter pour des raisons de lecture de code futur, entre autre.
Il te faut donc organiser tes données de manière à pouvoir y accéder en tout point du programme sans pour autant utiliser les déclarations en global.

Pourrais-tu nous montrer ton code que l'on puisse t'aiguiller un peu plus?

Pour la fonction que je t'ai donné tu récupères un flag :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 enum GtkStateFlags typedef enum { GTK_STATE_FLAG_NORMAL = 0, GTK_STATE_FLAG_ACTIVE = 1 << 0, GTK_STATE_FLAG_PRELIGHT = 1 << 1, GTK_STATE_FLAG_SELECTED = 1 << 2, GTK_STATE_FLAG_INSENSITIVE = 1 << 3, GTK_STATE_FLAG_INCONSISTENT = 1 << 4, GTK_STATE_FLAG_FOCUSED = 1 << 5, GTK_STATE_FLAG_BACKDROP = 1 << 6 } GtkStateFlags;
Tu peux ainsi tester l'état du widget que tu as transmis.

Citation:

Envoyé par LM_programme

J'ai la fenêtre principale de mon application.
à partir d'un bouton, j'en ouvre une seconde fenêtre.

Jusqu'ici tout va bien
Sauf que je voudrais détecter l'ouverture et la fermeture de la seconde fenêtre.
car si on presse plusieurs fois le bouton. il ouvre le même nombre de fenêtre.

Bonjour,

je pense que ce que tu souhaites, c'est tout simplement cacher ta fenêtre au lieu de la fermer. Le principe:

tu fais en sorte que ta fenêtre soit un singleton: une seule instance peut exister. Tu peux facilement avoir ce comportement avec une variable statique, même s'il y a d'autres méthodes.
si elle existe déjà, tu ne fais qu'afficher la fenêtre, tu n'en crées pas une nouvelle.
utilises le signal "delete-event" qui te prévient qu'on essaie de fermer la fenêtre
au lieu de fermer la fenêtre, cache la, avec gtk_widget_hide_on_delete
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 GtkWidget *create_my_window () { GtkWidget * window; // tu crées ta fenêtre ... return window; } on_button_clicked (...) { static GtkWidget *window = NULL; if (window == NULL) { window = create_my_window (); g_signal_connect (window, "delete-event", G_CALLBACK(gtk_widget_hide_on_delete); NULL); } else gtk_widget_show_all (window); }

voici le code

Fichier main.c ( fenêtre principal )

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
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
 
# include <stdlib.h>
# include <string.h>
# include <math.h>
# include <gtk/gtk.h>
# include "formule.h"
# include "map.h"
 
int main (int argc,char *argv[]){
      gtk_init(&argc, &argv);
      donnee form = {NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL};
   // widget GTK
      GtkWidget *p_Fenetre = NULL;
      GtkWidget *p_Cadre_form = NULL;
      GtkWidget *p_Cadre_result = NULL;
      GtkWidget *p_Table = NULL;
      GtkWidget *p_Table_1 = NULL;
      GtkWidget *p_Vboite[1] = {NULL};
      GtkWidget *p_Etiquette[8] =
         {NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL};
      GtkWidget *p_Alignement[7] =
         {NULL,NULL,NULL,NULL,NULL,NULL,NULL};
      GtkWidget *p_Groupe = NULL;
      GtkWidget *p_Button = NULL;
      GtkWidget *p_Button_image = NULL;
   // initialisation GTK
      p_Fenetre = gtk_window_new(GTK_WINDOW_TOPLEVEL);
      gtk_window_set_default_size(GTK_WINDOW(p_Fenetre), 350, 300);
		gtk_window_set_title(
      GTK_WINDOW(p_Fenetre), " Dimensionnement Eaux pluviales ");
   // Création des boutons
      p_Button = gtk_button_new (); 
      p_Button_image = gtk_image_new_from_file
          ("image/carte_france_mini.png");
      gtk_button_set_image(GTK_BUTTON(p_Button), p_Button_image);
   // Création des entrées texte
      form.p_Nom_bassin = gtk_entry_new ();
      gtk_entry_set_text (GTK_ENTRY(form.p_Nom_bassin),"Bassin EP 01");
		gtk_widget_set_can_focus (GTK_WIDGET(form.p_Nom_bassin),1);
   // Création du tableau
      p_Table = gtk_table_new ( 6,3,FALSE );
      p_Table_1 = gtk_table_new ( 4,3,FALSE );
   // Création des cadres
      p_Cadre_form = gtk_frame_new(" Paramètres ");  
      p_Cadre_result = gtk_frame_new(" Résultat ");  
	// Création des boites
      p_Vboite[0] = gtk_vbox_new(FALSE,0);
	// Création du groupe caché
		p_Groupe = gtk_expander_new_with_mnemonic 
          ("cliquez ici pour + de paramètres");
   // Création des étiquettes
		p_Etiquette[0]=gtk_label_new("Nom du bassin : ");
		gtk_misc_set_alignment(GTK_MISC(p_Etiquette[0]), 1.0, 0.5);
		p_Etiquette[1]=gtk_label_new("Région : ");
		gtk_misc_set_alignment(GTK_MISC(p_Etiquette[1]), 1.0, 0.5);
		p_Etiquette[2]=gtk_label_new("Période de retour : ");
		gtk_misc_set_alignment(GTK_MISC(p_Etiquette[2]), 1.0, 0.5);
		p_Etiquette[3]=gtk_label_new("Type de surface : ");
		gtk_misc_set_alignment(GTK_MISC(p_Etiquette[3]), 1.0, 0.5);
		p_Etiquette[4]=gtk_label_new("Surface Bassin versant : ");
		gtk_misc_set_alignment(GTK_MISC(p_Etiquette[4]), 1.0, 0.5);
		p_Etiquette[5]=gtk_label_new(" Mètre(s)");
		gtk_misc_set_alignment(GTK_MISC(p_Etiquette[5]), 0.0, 0.5);
		p_Etiquette[6]=gtk_label_new(" Le plus long chemin : ");
		gtk_misc_set_alignment(GTK_MISC(p_Etiquette[6]), 1.0, 0.5);
		p_Etiquette[7]=gtk_label_new(" La pente du bassin : ");
		gtk_misc_set_alignment(GTK_MISC(p_Etiquette[7]), 1.0, 0.5);
		form.p_Resultat=gtk_label_new("Region 1");
		gtk_misc_set_alignment(GTK_MISC(form.p_Resultat), 0.0, 0.0);
   // Création des listes déroulantes
		form.p_Liste_reg = gtk_combo_box_new_text ();
      gtk_combo_box_append_text  (GTK_COMBO_BOX (form.p_Liste_reg), "Region 1");
      gtk_combo_box_append_text  (GTK_COMBO_BOX (form.p_Liste_reg), "Region 2");
      gtk_combo_box_append_text  (GTK_COMBO_BOX (form.p_Liste_reg), "Region 3");
      gtk_combo_box_set_active (GTK_COMBO_BOX (form.p_Liste_reg), 0);
		form.p_Liste_duree = gtk_combo_box_new_text ();
      gtk_combo_box_append_text  (GTK_COMBO_BOX (form.p_Liste_duree), "10 ans");
      gtk_combo_box_append_text  (GTK_COMBO_BOX (form.p_Liste_duree), "5 ans");
      gtk_combo_box_append_text  (GTK_COMBO_BOX (form.p_Liste_duree), "2 ans");
      gtk_combo_box_append_text  (GTK_COMBO_BOX (form.p_Liste_duree), "1 ans");
      gtk_combo_box_set_active (GTK_COMBO_BOX (form.p_Liste_duree), 0);
		form.p_Liste_type = gtk_combo_box_new_text ();
      gtk_combo_box_append_text  (GTK_COMBO_BOX (form.p_Liste_type),"Espace vert");
      gtk_combo_box_append_text  (GTK_COMBO_BOX(form.p_Liste_type),"Voirie");
      gtk_combo_box_append_text  (GTK_COMBO_BOX (form.p_Liste_type),"Bâtiment");
      gtk_combo_box_set_active (GTK_COMBO_BOX (form.p_Liste_type), 1);
   // Création des des boutons de saisie numérique
		form.p_Num_surface = gtk_spin_button_new_with_range(10,2000000, 10); 
		form.p_Num_chemin = gtk_spin_button_new_with_range(10, 500, 1); 
		form.p_Num_pente = gtk_spin_button_new_with_range(0.1, 5, .1); 
   // alignement
      p_Alignement[0] = gtk_alignment_new (0,0,0,0); 
      p_Alignement[1] = gtk_alignment_new (0,0,0,0); 
      p_Alignement[2] = gtk_alignment_new (0,0,0,0); 
      p_Alignement[3] = gtk_alignment_new (0,0,0,0); 
      p_Alignement[4] = gtk_alignment_new (0,0,0,0); 
      p_Alignement[5] = gtk_alignment_new (0,0,0,0); 
      p_Alignement[6] = gtk_alignment_new (0,0,0,0); 
   // Assemblage des boites
      gtk_container_add(GTK_CONTAINER(p_Fenetre), p_Vboite[0]);
		gtk_box_pack_start(GTK_BOX(p_Vboite[0]), p_Cadre_form, FALSE, FALSE, 0);
      gtk_container_add(GTK_CONTAINER(p_Cadre_form), p_Table );
      // 1 ère ligne du tableau
      gtk_table_attach(GTK_TABLE(p_Table), p_Etiquette[0],
        0, 1, 0, 1,
        GTK_FILL, GTK_EXPAND,
        0, 0);
      gtk_table_attach(GTK_TABLE(p_Table), p_Alignement[0],
        1, 3, 0, 1,
        GTK_FILL, GTK_EXPAND,
        0, 0);
      gtk_container_add(GTK_CONTAINER(p_Alignement[0]),form.p_Nom_bassin );
      // 2 ème ligne du tableau
      gtk_table_attach(GTK_TABLE(p_Table), p_Etiquette[1],
        0, 1, 1, 2,
        GTK_FILL, GTK_EXPAND,
        0, 0);
      gtk_table_attach(GTK_TABLE(p_Table), p_Alignement[1],
        1, 2, 1, 2,
        GTK_FILL, GTK_EXPAND,
        0, 0);
      gtk_container_add(GTK_CONTAINER(p_Alignement[1]), form.p_Liste_reg );
      gtk_widget_set_size_request(form.p_Liste_reg, 120, 28);
      gtk_table_attach(GTK_TABLE(p_Table), p_Button,
        2, 3, 1, 2,
        GTK_EXPAND, GTK_EXPAND,
        0, 0);
      gtk_widget_set_size_request(p_Button, 28, 28);
      // 3 ème ligne du tableau
      gtk_table_attach(GTK_TABLE(p_Table), p_Etiquette[2],
        0, 1, 2, 3,
        GTK_FILL, GTK_EXPAND,
        0, 0);
      gtk_table_attach(GTK_TABLE(p_Table), p_Alignement[2],
        1, 2, 2, 3,
        GTK_FILL, GTK_EXPAND,
        0, 0);
      gtk_container_add(GTK_CONTAINER(p_Alignement[2]), form.p_Liste_duree );
      gtk_widget_set_size_request(form.p_Liste_duree, 120, 28);
      // 4 ème ligne du tableau
      gtk_table_attach(GTK_TABLE(p_Table), p_Etiquette[3],
        0, 1, 3, 4,
        GTK_FILL, GTK_EXPAND,
        0, 0);
      gtk_table_attach(GTK_TABLE(p_Table), p_Alignement[3],
        1, 2, 3, 4,
        GTK_FILL, GTK_EXPAND,
        0, 0);
      gtk_container_add(GTK_CONTAINER(p_Alignement[3]), form.p_Liste_type );
      gtk_widget_set_size_request(form.p_Liste_type, 120, 28);
      // 5 ème ligne du tableau
      gtk_table_attach(GTK_TABLE(p_Table), p_Etiquette[4],
        0, 1, 4, 5,
        GTK_FILL, GTK_EXPAND,
        0, 0);
      gtk_table_attach(GTK_TABLE(p_Table), p_Alignement[4],
        1, 2, 4, 5,
        GTK_FILL, GTK_EXPAND,
        0, 0);
      gtk_container_add(GTK_CONTAINER(p_Alignement[4]),form.p_Num_surface );
      gtk_widget_set_size_request(form.p_Num_surface, 120, 28);
      gtk_table_attach(GTK_TABLE(p_Table), p_Etiquette[5],
        2, 3, 4, 5,
        GTK_EXPAND, GTK_EXPAND,
        0, 0);
      // 6 ème ligne du tableau
      gtk_table_attach(GTK_TABLE(p_Table), p_Groupe,
        0, 2, 5, 6,
        GTK_FILL, GTK_EXPAND,
        0, 0);
      // Tableau Paramètres supplémentaires
      // 1 ère ligne du tableau OPTION
      gtk_table_attach(GTK_TABLE(p_Table_1), p_Etiquette[6],
        0, 1, 0, 1,
        GTK_FILL, GTK_EXPAND,
        0, 0);
      gtk_table_attach(GTK_TABLE(p_Table_1), p_Alignement[5],
        1, 2, 0, 1,
        GTK_EXPAND, GTK_EXPAND,
        0, 0);
      gtk_container_add(GTK_CONTAINER(p_Alignement[5]),form.p_Num_chemin );
      gtk_widget_set_size_request(form.p_Num_chemin, 120, 28);
      // 2 ème ligne du tableau OPTION
      gtk_table_attach(GTK_TABLE(p_Table_1), p_Etiquette[7],
        0, 1, 1, 2,
        GTK_FILL, GTK_EXPAND,
        0, 0);
      gtk_table_attach(GTK_TABLE(p_Table_1), p_Alignement[6],
        1, 2, 1, 2,
        GTK_EXPAND, GTK_EXPAND,
        0, 0);
      gtk_container_add(GTK_CONTAINER(p_Alignement[6]),form.p_Num_pente );
      gtk_widget_set_size_request(form.p_Num_pente, 120, 28);
      gtk_container_add(GTK_CONTAINER(p_Groupe),p_Table_1 );
		gtk_box_pack_start(GTK_BOX(p_Vboite[0]), p_Cadre_result, TRUE, TRUE, 0);
      gtk_container_add(GTK_CONTAINER(p_Cadre_result),form.p_Resultat);
   // Définition des callbacks
     g_signal_connect (
      G_OBJECT (form.p_Liste_reg), "changed",G_CALLBACK(Calcul),&form
      );
     g_signal_connect (
      G_OBJECT (form.p_Liste_duree), "changed",G_CALLBACK(Calcul),&form
      );
     g_signal_connect (
      G_OBJECT (form.p_Liste_type), "changed",G_CALLBACK(Calcul),&form
      );
     g_signal_connect (
      G_OBJECT (form.p_Num_surface), "value_changed",G_CALLBACK(Calcul),&form
      );
		g_signal_connect(
      G_OBJECT(p_Fenetre), "destroy",G_CALLBACK(gtk_main_quit), NULL
      );
		g_signal_connect(
      G_OBJECT(p_Button), "clicked",G_CALLBACK(carte_france), NULL
      );
   // affiche la boucle évènementielle
      gtk_widget_show_all(p_Fenetre);
      gtk_main();
}

fichier map.c ( seconde fenêtre )
En pressant sur la widget p_Button on appelle cette fenêtre.

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
 
#include <stdio.h>
#include <gtk/gtk.h>
#include "map.h"
 
void carte_france (GtkWidget *p_Button, gpointer p_data)
{
 // Désactive le bouton de la carte
   gtk_widget_set_sensitive( p_Button, FALSE );
 // widget GTK
   GtkWidget *p_Fenetre_carte = NULL;
   GtkWidget *p_Image_carte = NULL;
   GtkWidget *p_Vboite_carte = NULL;
   GtkWidget *p_Bouton_carte = NULL;
 // création de la fenêtre
	p_Fenetre_carte = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_window_set_default_size(GTK_WINDOW(p_Fenetre_carte), 700, 700);
	gtk_window_set_title(
	   GTK_WINDOW(p_Fenetre_carte),
      " Carte de france des regions pluviomètriques ");
 // création des boites  
   p_Vboite_carte = gtk_vbox_new(FALSE,0);
   gtk_container_add(GTK_CONTAINER(p_Fenetre_carte), p_Vboite_carte);
 // chargement de l'image 
	p_Image_carte = gtk_image_new_from_file
	   ("image/carte_france.png");
	gtk_box_pack_start(GTK_BOX(p_Vboite_carte), p_Image_carte, FALSE, FALSE, 0);
 // création du bouton fermer
   p_Bouton_carte = gtk_button_new_with_label("FERMER");  
	gtk_box_pack_start(GTK_BOX(p_Vboite_carte), p_Bouton_carte,FALSE,FALSE, 5);
 // fonction de callback
	g_signal_connect(
	G_OBJECT(p_Fenetre_carte), "destroy",G_CALLBACK(gtk_widget_destroy), NULL
   );
	g_signal_connect(
	G_OBJECT(p_Bouton_carte),"clicked",G_CALLBACK(quitter),p_Fenetre_carte
   );
	gtk_widget_show_all(p_Fenetre_carte);
};
void quitter (GtkWidget* widget, gpointer p_data)
{
   GtkWidget *recup;
   recup = p_data;
   gtk_widget_destroy(recup); 
}

02/04/2012, 19h20
gerald3d
Dans la fonction carte_france(); tu affectes le signal destroy :
Code:

1 2 // fonction de callback g_signal_connect(G_OBJECT(p_Fenetre_carte), "destroy",G_CALLBACK(gtk_widget_destroy), NULL);
C'est ici que tu vas pouvoir réactiver ton bouton. Plutôt que de détruire la fenêtre directement exécutes une fonction de ton choix. Dans cette fonction tu transmets le pointeur du bouton que tu as à ta disposition dans la fonction carte_france();.

Ainsi, imaginons la fonction void callback_destroy_second_window (GtkWidget *object, gpointer user_data);. tu commences par affecter le signal destroy à cette fonction en transmettant le bouton :

Code:

g_signal_connect(G_OBJECT(p_Fenetre_carte), "destroy",G_CALLBACK(callback_destroy_second_window), p_Button);

Et enfin dans la fonction callback_destroy_second_window(); tu fais ceci :
Code:

1 2 3 4 5 void callback_destroy_second_window(GtkWidget *window, GtkWidget *p_Button) { gtk_widget_set_sensitive (p_Button, TRUE); gtk_widget_destroy (window); }
02/04/2012, 21h32
LM_programme
ça marche impeccable quand je clique sur la croix pour détruire ma fenêtre :ccool:
Par contre, j'ai un bouton << FERMER >> et j'ai lié un CALLBACK qui appelle la fonction quitter

Extrait du code ( ligne 35 à 38 ) du fichier map.c:
Code:

1 2 3 4 5 g_signal_connect( G_OBJECT(p_Bouton_carte),"clicked",G_CALLBACK(quitter),p_Fenetre_carte ); gtk_widget_show_all(p_Fenetre_carte);
Est-il nécessaire de faire une structure pour passer mon pointeur p_Button et mon pointeur p_Fenetre_carte[
03/04/2012, 18h25
gerald3d

En effet c'est la méthode la plus simple et la plus efficace : une structure qui englobe tous les pointeurs qui doivent être accessibles en tout point de ton programme.

solution

j'ai trouvé la solution avec la fonction g_signal_connect_swapped ()
je lance une première fonction active_bouton_carte pour réactiver le bouton ensuite grâce à la fonction GTK ci-dessus je lance un seconde fonction quitter qui détruit la fenêtre. :mrgreen:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 g_signal_connect( G_OBJECT(p_Bouton_carte),"clicked", G_CALLBACK(active_bouton_carte),p_Button ); g_signal_connect_swapped( G_OBJECT(p_Bouton_carte),"clicked", G_CALLBACK(quitter),p_Fenetre_carte ); gtk_widget_show_all(p_Fenetre_carte); }; void active_bouton_carte (GtkWidget *p_Fenetre_carte, GtkWidget *p_Button ) { gtk_widget_set_sensitive (p_Button, TRUE); } void quitter (GtkWidget *p_Fenetre_carte, GtkWidget *p_Button ) { gtk_widget_destroy (p_Fenetre_carte); }