Discussion :

[diesel83]

Bonne année à toutes et à tous.

Je suis en train de m'exercer à la programmation d'interfaces homme/machine avec GTK+ 3.

Dans la cadre d'un projet plus ambitieux, je veux pouvoir régler des valeurs numériques (a priori contenues dans des GtkLabels) à l'aide de curseurs qui apparaissent quand on en a besoin et qui disparaissent à l'issue.

J'ai donc écrit un petit programme pour démontrer la fonctionnalité. Ça m'a pris pas mal de temps mais j'ai fini par y arriver et en cette nouvelle année, je me propose de vous le faire partager. Et n'hésitez pas à me critiquer.

Le programme, donc :

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
237
238
239
240
241
242
243
244
245
246
247
248
249
250
#include <stdlib.h> /* définition de EXIT_SUCCESS */
#include <string.h>
#include <gtk/gtk.h>
 
/* Prototypes des fonctions de callback */
 
static gboolean cb_enter_notify_eventbox (GtkEventBox *, GdkEvent *, GtkWindow *);
static gboolean cb_leave_notify_eventbox (GtkEventBox *, GdkEvent *, GtkWindow *);
static gboolean cb_enter_notify_popup (GtkWindow *, GdkEvent *, gpointer);
static gboolean cb_leave_notify_popup (GtkWindow *, GdkEvent *, gpointer);
static void cb_value_scale_changed (GtkRange *, GtkLabel *);
static gboolean end_timeout (GtkWindow *);
 
/* Déclaration des objets globaux */
 
gboolean eventbox_has_pointer = FALSE;
gboolean popup_has_pointer = FALSE;
 
int main (int argc, char *argv[])
 
{
 
/* Initialisation de GTK */
 
	gtk_init (&argc, &argv);
 
/* Déclaration des objets */
 
	GtkWindow *window, *popup;
	GtkGrid *grid;
	GtkEventBox *eventbox;
	GtkFrame *frame;
	GtkLabel *label1, *label2;
	GtkAdjustment *adj;
	GtkScale *scale;
 
/* Initialisation des objets */
 
	window = GTK_WINDOW (gtk_window_new (GTK_WINDOW_TOPLEVEL));
	grid = GTK_GRID (gtk_grid_new ());
	label1 = GTK_LABEL (gtk_label_new ("Valeur : "));
	eventbox = GTK_EVENT_BOX (gtk_event_box_new ());
	frame = GTK_FRAME (gtk_frame_new (NULL));
	label2 = GTK_LABEL (gtk_label_new ("100%"));
 
	popup = GTK_WINDOW (gtk_window_new (GTK_WINDOW_TOPLEVEL));
	adj = GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, 100, 1, 0, 0));
	scale = GTK_SCALE (gtk_scale_new (GTK_ORIENTATION_VERTICAL, adj));
 
/* Paramétrage des objets */
 
	gtk_window_set_title (window, "Mon exemple 1");
	gtk_container_set_border_width (GTK_CONTAINER (window), 10);
	gtk_widget_set_size_request (GTK_WIDGET (window), 600, 600);
 
	gtk_grid_set_row_spacing (grid, 5);
	gtk_grid_set_column_homogeneous (grid, FALSE);
	gtk_grid_set_row_homogeneous (grid, FALSE);
	gtk_widget_set_halign (GTK_WIDGET (grid), GTK_ALIGN_START);
	gtk_widget_set_valign (GTK_WIDGET (grid), GTK_ALIGN_START);
 
	gtk_label_set_width_chars (label2, 5);
	gtk_label_set_justify (label2, GTK_JUSTIFY_RIGHT);
	gtk_widget_set_halign (GTK_WIDGET (label2), GTK_ALIGN_END);
 
	gtk_window_set_decorated (popup, FALSE);
	gtk_widget_set_size_request (GTK_WIDGET (popup), 1, 140);
	gtk_window_set_resizable (popup, FALSE);
 
	gtk_scale_set_draw_value (scale, FALSE);
	gtk_range_set_inverted (GTK_RANGE (scale), TRUE);
 
/* Attachement des objets les uns dans les autres */
 
	gtk_container_add (GTK_CONTAINER (frame), GTK_WIDGET (label2));
	gtk_container_add (GTK_CONTAINER (eventbox), GTK_WIDGET (frame));
 
	gtk_grid_attach (grid, GTK_WIDGET (label1), 0 , 0, 1, 1);
	gtk_grid_attach_next_to (grid, GTK_WIDGET (eventbox), GTK_WIDGET (label1), GTK_POS_RIGHT, 1, 1);
 
	gtk_container_add (GTK_CONTAINER (window), GTK_WIDGET (grid));
 
	gtk_container_add (GTK_CONTAINER (popup), GTK_WIDGET (scale));
 
/* Déclaration des fonctions de callback */
 
	g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (gtk_main_quit), NULL);
 
	g_signal_connect (G_OBJECT (eventbox), "enter-notify-event", G_CALLBACK (cb_enter_notify_eventbox), (gpointer) popup);
	g_signal_connect (G_OBJECT (eventbox), "leave-notify-event", G_CALLBACK (cb_leave_notify_eventbox), (gpointer) popup);
 
	g_signal_connect (G_OBJECT (popup), "enter-notify-event", G_CALLBACK (cb_enter_notify_popup), NULL);
	g_signal_connect (G_OBJECT (popup), "leave-notify-event", G_CALLBACK (cb_leave_notify_popup), NULL);
 
	g_signal_connect (G_OBJECT (scale), "value_changed", G_CALLBACK (cb_value_scale_changed), (gpointer) label2);
 
/* Affiche les widgets */
 
	gtk_widget_show (GTK_WIDGET (scale));
 
	gtk_widget_show_all (GTK_WIDGET (window));
 
/* Et c'est parti ! */
 
	gtk_main ();
 
	return EXIT_SUCCESS;
 
}
 
static gboolean cb_enter_notify_eventbox (GtkEventBox *eventbox, GdkEvent *event, GtkWindow *popup)
 
{
 
/* Déclaration des variables locales à la fonction */
 
	int label_value;
	GtkWindow *window;
	GtkFrame *frame;
	GtkLabel *label;
	GtkScale *scale;
	GtkAllocation allocation;
	gint window_x, window_y, widget_x, widget_y;
 
/* Note que le pointeur est au dessus de l'enventbox */
 
	eventbox_has_pointer = TRUE;
 
/* Retrouve les objets */
 
	frame = GTK_FRAME (gtk_bin_get_child (GTK_BIN (eventbox)));
	label = GTK_LABEL (gtk_bin_get_child (GTK_BIN (frame)));
 
	scale = GTK_SCALE (gtk_bin_get_child (GTK_BIN (popup)));
 
/* Affecte la valeur courante du label au curseur */
 
	sscanf (gtk_label_get_text (label), "%d", &label_value);
	gtk_range_set_value (GTK_RANGE (scale), (gdouble) label_value);
 
/* Calcule la position du coin en haut et à droite du frame */
 
	window = GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (eventbox)));
	gdk_window_get_position (gtk_widget_get_window (GTK_WIDGET (window)), &window_x, &window_y);
	gtk_widget_get_allocation (GTK_WIDGET (frame), &allocation);
	gtk_widget_translate_coordinates (GTK_WIDGET (frame), GTK_WIDGET (window), window_x + allocation.width, window_y, &widget_x, &widget_y);
 
/* Déplace la fenêtre popup juste à droite du frame */
 
	gtk_window_move (popup, widget_x, widget_y);
 
/* affiche le popup */
 
	gtk_widget_show (GTK_WIDGET (popup));
 
	(void) event;
 
	return TRUE;
 
}
 
static gboolean cb_leave_notify_eventbox (GtkEventBox *eventbox, GdkEvent *event, GtkWindow *popup)
 
{
 
/* Note que le pointeur a quitté l'enventbox */
 
	eventbox_has_pointer = FALSE;
 
/* Lance le timeout (2 dixièmes de seconde) */
 
	g_timeout_add (200, (GSourceFunc) end_timeout, (gpointer) popup);
 
	(void) eventbox;
	(void) event;
 
	return TRUE;
 
}
 
static gboolean cb_enter_notify_popup (GtkWindow *popup, GdkEvent *event, gpointer user_data)
 
{
 
/* Note que le pointeur est au dessus du popup */
 
	popup_has_pointer = TRUE;
 
	(void) popup;
	(void) event;
	(void) user_data;
 
	return TRUE;
 
}
 
static gboolean cb_leave_notify_popup (GtkWindow *popup, GdkEvent *event, gpointer user_data)
 
{
 
/* Note que le pointeur a quitté la fenêtre popup */
 
	popup_has_pointer = FALSE;
 
/* Lance le timeout (2 dixièmes de seconde) */
 
	g_timeout_add (200, (GSourceFunc) end_timeout, (gpointer) popup);
 
	(void) user_data;
	(void) event;
 
	return TRUE;
 
}
 
static void cb_value_scale_changed (GtkRange *scale, GtkLabel *label)
 
{
 
/* Déclare une chaîne de caractères pour le label (avec de la marge) */
 
	gchar label_text[10];
 
/* récupère la valeur du curseur et la recopie dans le label */
 
	sprintf (label_text, "%3.0f%%", gtk_range_get_value (scale));
 
	gtk_label_set_text (label, label_text);
 
}
 
static gboolean end_timeout (GtkWindow *popup)
 
{
 
/* Si le pointeur de la souris n'est pas au dessus de l'un des widgets */
 
	if ( ! (eventbox_has_pointer || popup_has_pointer))
 
	{
 
/* Masque la fenêtre popup */
 
		gtk_widget_hide (GTK_WIDGET (popup));
 
	}
 
	return FALSE;
 
}

Jean-Marie

[gerald3d]

C'est pas mal du tout.

Histoire de chipoter un peu (ca ne serait pas rigolo autrement ), je ne suis pas fan des variables globales ni du fait que la fenêtre principale perde le focus à l'apparition du régleur. Ceci étant du bien sûr au fait que le régleur est une fenêtre.

Mais comme je l'ai écrit, ici je chipote .

Bonne année à toi aussi au passage...

[diesel83]

Bonsoir Gérald,

Bonnes remarques.

Maintenant que tu en parles, il serait probablement possible de mettre le curseur dans un GtkFixed plutôt que dans un GtkWindow, ce qui permettrait de ne pas faire perdre le focus à la fenêtre principale. Je vais essayer de réécrire le code comme ça mais j'espère que ça ne va pas me mettre le souk dans ce qu'il pourrait y avoir dessous.

Pour les variables globales, il faut qu'elles soient disponibles dans toutes les fonctions de callback et dans la fonction de fin de timeout, mais je vais y réfléchir.

Jean-Marie

[Schaublore]

Salut,

Je trouve le "widget" vraiment sympa. C'est une bonne idée. En plus le programme est claire, commenté, aéré...
Ca me fait penser au GtkScaleButton, dommage que là c'est pas déjà un "GtkScaleLabel".

Y'a juste un truc qui me chatouille dans le code, c'est les:

Code C :

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

GtkGrid *grid = GTK_GRID (gtk_grid_new ());

au lieu de:

Code C :

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

1
2
3
4
GtkWidget *grid = gtk_grid_new ();
gtk_grid_*(GTK_GRID(grid), ...);
gtk_grid_*(GTK_GRID(grid), ...);
gtk_grid_*(GTK_GRID(grid), ...);

Mais bon, est-ce vraiment important...



En tout cas, bravo, je trouve que ca reste une bonne idée, et pas mal présenté


PS: Je crois qu'un GTK_WINDOW_POPUP corrige le focus

[diesel83]

Ben..., je préfère typer les objets par leur type réel plutôt que systématiquement GtkWidget*.

Depuis que je fais ça, j'ai remarqué que je ne caste pas plus qu'en les déclarant GtkWidget par défaut. Et par ailleurs, je trouve quand-même bizarre qu'un Gtk_Xxx_new() génère systématiquement un pointer GtkWidget plutôt qu'un GtkXxx.

Justement, dans ton exemple, tu économises, un cast pour l'initialisation de ton pointeur pour t'en payer 3 sur chacune des fonctions suivantes.

Et j'applique la logique suivante :

Pour un objet de type Xxx* membre gauche d'une affectation, Je caste systématiquement le résultat de la partie droite en GTK_XXX().
Pour un objet de type Xxx* premier paramètre d'une fonction attachée à un type d'objet :
- si la fonction est du type gtk_Xxx_quelquechose(), je ne caste pas,
- si la fonction est du type gtk_autretype_quelquechose(), je caste GTK_AUTRETYPE().

Et pour l'instant, cette logique n'a pas été mise en défaut.

Pour le focus, j'ai lu dans plusieurs docs (dont la doc officielle du projet GTK) qu'il ne fallait pas utiliser les fenêtres de type popup, y compris pour faire des popups. Donc je n'ai pas utilisé (même si j'ai été tenté). Je vais regarder de ce côté là.

Jean-Marie

[pvincent]

Quand on a beaucoup de données numériques à traiter correspondant à des types de widgets différents, je vois au moins un avantage à utiliser GtkWidget: dans le corps du programme il est possible de traiter de façon uniforme les différents widgets en se souciant uniquement du type de la variable impliquée.
Un début d'exemple pour illustrer ce que je veux dire (les deux derniers types de widgets sont de mon cru et le gg_get_int() est sur le même modèle):

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
 
/**
 * Unified set/get for gint and gdouble  variables 
 */
void gg_set_int (GtkWidget *w ,gint val) 
{
  gint old_val;
  if (w == NULL) {
    fprintf (stderr ,"gg_set_int called with NULL widget\n");
    return;
  }
 
  /* To avoid emiting signals not needed */
  old_val = gg_get_int (w);
  if (val == old_val) return;
 
  if (GTK_IS_COMBO_BOX (w)) {
    gtk_combo_box_set_active (GTK_COMBO_BOX (w) ,val);
  } else if (GTK_IS_TOGGLE_BUTTON (w)) {
    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w) ,val);    
  } else if (GTK_IS_SPIN_BUTTON (w)) {
    gtk_spin_button_set_value (GTK_SPIN_BUTTON (w) ,(gdouble) val);
  } else if (GTK_IS_RANGE (w)) {
    gtk_range_set_value (GTK_RANGE(w) ,(gdouble) val);
  } else if (GTK_IS_CHECK_MENU_ITEM (w)) {
    gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w) ,val);
  } else if (IS_GW_LIST (w)) {
    gw_list_select (GW_LIST (w) ,val);
  } else if (IS_GW_CHOICE(w)) {
    gw_choice_set (GW_CHOICE (w) ,val);
  } else {
    fprintf (stderr ,"gg_set_int: unknown type GtkWidget\n");
  }
}

Il suffit ensuite d'appeler gg_set_int() partout où on souhaite afficher une valeur entière: je trouve que cela clarifie l'écriture de callbacks comprenant un grand nombre de valeurs numériques.

[diesel83]

Bonjour vincent,

Bon, je vais peut-être donner l'impression de me raccrocher aux branches, mais je crois pas tout-à-fait.

Je cas que tu cites est très intéressant et je me suis aussi posé la question.

Dans une fonction (qu'elle soit de callback ou une fonction utilitaire comme afficher un code d'erreur indépendant du type de l'objet), il peut être effectivement plus efficace de "détyper" les objets.

D'une certaine manière, cela ne remet pas en cause la logique :
- dans un callback, on peut avoir à travailler sur un objet de type GtkWidget "pur" même si l'objet qui appelle le callback n'en est pas un. Dans ce cas, il paraît logique de typer l'objet dans la fonction de callback comme GtkWidget. Et cela n'empêche pas de garder le typage propre de l'objet en dehors de la fonction de callback,
- dans une fonction utilitaire comme celle que tu présentes au début de ton listing, je typerais plutôt gpointer en castant à chaque appel.

Jean-Marie

[diesel83]

Super !

Rien que le fait de changer le type de la fenêtre popup de GTK_WINDOW_TOPLEVEL en GTK_WINDOW_POPUP a permis de ne plus faire perdre le focus à la fenêtre principale.

Merci Schaublore.

Donc, le source "définitif" :

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
237
238
239
240
241
242
243
244
245
246
247
248
249
250
#include <stdlib.h> /* définition de EXIT_SUCCESS */
#include <string.h>
#include <gtk/gtk.h>
 
/* Prototypes des fonctions de callback */
 
static gboolean cb_enter_notify_eventbox (GtkEventBox *, GdkEvent *, GtkWindow *);
static gboolean cb_leave_notify_eventbox (GtkEventBox *, GdkEvent *, GtkWindow *);
static gboolean cb_enter_notify_popup (GtkWindow *, GdkEvent *, gpointer);
static gboolean cb_leave_notify_popup (GtkWindow *, GdkEvent *, gpointer);
static void cb_value_scale_changed (GtkRange *, GtkLabel *);
static gboolean end_timeout (GtkWindow *);
 
/* Déclaration des objets globaux */
 
gboolean eventbox_has_pointer = FALSE;
gboolean popup_has_pointer = FALSE;
 
int main (int argc, char *argv[])
 
{
 
/* Initialisation de GTK */
 
	gtk_init (&argc, &argv);
 
/* Déclaration des objets */
 
	GtkWindow *window, *popup;
	GtkGrid *grid;
	GtkEventBox *eventbox;
	GtkFrame *frame;
	GtkLabel *label1, *label2;
	GtkAdjustment *adj;
	GtkScale *scale;
 
/* Initialisation des objets */
 
	window = GTK_WINDOW (gtk_window_new (GTK_WINDOW_TOPLEVEL));
	grid = GTK_GRID (gtk_grid_new ());
	label1 = GTK_LABEL (gtk_label_new ("Valeur : "));
	eventbox = GTK_EVENT_BOX (gtk_event_box_new ());
	frame = GTK_FRAME (gtk_frame_new (NULL));
	label2 = GTK_LABEL (gtk_label_new ("100%"));
 
	popup = GTK_WINDOW (gtk_window_new (GTK_WINDOW_POPUP));
	adj = GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, 100, 1, 0, 0));
	scale = GTK_SCALE (gtk_scale_new (GTK_ORIENTATION_VERTICAL, adj));
 
/* Paramétrage des objets */
 
	gtk_window_set_title (window, "Mon exemple 1");
	gtk_container_set_border_width (GTK_CONTAINER (window), 10);
	gtk_widget_set_size_request (GTK_WIDGET (window), 600, 600);
 
	gtk_grid_set_row_spacing (grid, 5);
	gtk_grid_set_column_homogeneous (grid, FALSE);
	gtk_grid_set_row_homogeneous (grid, FALSE);
	gtk_widget_set_halign (GTK_WIDGET (grid), GTK_ALIGN_START);
	gtk_widget_set_valign (GTK_WIDGET (grid), GTK_ALIGN_START);
 
	gtk_label_set_width_chars (label2, 5);
	gtk_label_set_justify (label2, GTK_JUSTIFY_RIGHT);
	gtk_widget_set_halign (GTK_WIDGET (label2), GTK_ALIGN_END);
 
	gtk_window_set_decorated (popup, FALSE);
	gtk_widget_set_size_request (GTK_WIDGET (popup), 1, 140);
	gtk_window_set_resizable (popup, FALSE);
 
	gtk_scale_set_draw_value (scale, FALSE);
	gtk_range_set_inverted (GTK_RANGE (scale), TRUE);
 
/* Attachement des objets les uns dans les autres */
 
	gtk_container_add (GTK_CONTAINER (frame), GTK_WIDGET (label2));
	gtk_container_add (GTK_CONTAINER (eventbox), GTK_WIDGET (frame));
 
	gtk_grid_attach (grid, GTK_WIDGET (label1), 0 , 0, 1, 1);
	gtk_grid_attach_next_to (grid, GTK_WIDGET (eventbox), GTK_WIDGET (label1), GTK_POS_RIGHT, 1, 1);
 
	gtk_container_add (GTK_CONTAINER (window), GTK_WIDGET (grid));
 
	gtk_container_add (GTK_CONTAINER (popup), GTK_WIDGET (scale));
 
/* Déclaration des fonctions de callback */
 
	g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (gtk_main_quit), NULL);
 
	g_signal_connect (G_OBJECT (eventbox), "enter-notify-event", G_CALLBACK (cb_enter_notify_eventbox), (gpointer) popup);
	g_signal_connect (G_OBJECT (eventbox), "leave-notify-event", G_CALLBACK (cb_leave_notify_eventbox), (gpointer) popup);
 
	g_signal_connect (G_OBJECT (popup), "enter-notify-event", G_CALLBACK (cb_enter_notify_popup), NULL);
	g_signal_connect (G_OBJECT (popup), "leave-notify-event", G_CALLBACK (cb_leave_notify_popup), NULL);
 
	g_signal_connect (G_OBJECT (scale), "value_changed", G_CALLBACK (cb_value_scale_changed), (gpointer) label2);
 
/* Affiche les widgets */
 
	gtk_widget_show (GTK_WIDGET (scale));
 
	gtk_widget_show_all (GTK_WIDGET (window));
 
/* Et c'est parti ! */
 
	gtk_main ();
 
	return EXIT_SUCCESS;
 
}
 
static gboolean cb_enter_notify_eventbox (GtkEventBox *eventbox, GdkEvent *event, GtkWindow *popup)
 
{
 
/* Déclaration des variables locales à la fonction */
 
	int label_value;
	GtkWindow *window;
	GtkFrame *frame;
	GtkLabel *label;
	GtkScale *scale;
	GtkAllocation allocation;
	gint window_x, window_y, widget_x, widget_y;
 
/* Note que le pointeur est au dessus de l'enventbox */
 
	eventbox_has_pointer = TRUE;
 
/* Retrouve les objets */
 
	frame = GTK_FRAME (gtk_bin_get_child (GTK_BIN (eventbox)));
	label = GTK_LABEL (gtk_bin_get_child (GTK_BIN (frame)));
 
	scale = GTK_SCALE (gtk_bin_get_child (GTK_BIN (popup)));
 
/* Affecte la valeur courante du label au curseur */
 
	sscanf (gtk_label_get_text (label), "%d", &label_value);
	gtk_range_set_value (GTK_RANGE (scale), (gdouble) label_value);
 
/* Calcule la position du coin en haut et à droite du frame */
 
	window = GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (eventbox)));
	gdk_window_get_position (gtk_widget_get_window (GTK_WIDGET (window)), &window_x, &window_y);
	gtk_widget_get_allocation (GTK_WIDGET (frame), &allocation);
	gtk_widget_translate_coordinates (GTK_WIDGET (frame), GTK_WIDGET (window), window_x + allocation.width, window_y, &widget_x, &widget_y);
 
/* Déplace la fenêtre popup juste à droite du frame */
 
	gtk_window_move (popup, widget_x, widget_y);
 
/* affiche le popup */
 
	gtk_widget_show (GTK_WIDGET (popup));
 
	(void) event;
 
	return TRUE;
 
}
 
static gboolean cb_leave_notify_eventbox (GtkEventBox *eventbox, GdkEvent *event, GtkWindow *popup)
 
{
 
/* Note que le pointeur a quitté l'enventbox */
 
	eventbox_has_pointer = FALSE;
 
/* Lance le timeout (2 dixièmes de seconde) */
 
	g_timeout_add (200, (GSourceFunc) end_timeout, (gpointer) popup);
 
	(void) eventbox;
	(void) event;
 
	return TRUE;
 
}
 
static gboolean cb_enter_notify_popup (GtkWindow *popup, GdkEvent *event, gpointer user_data)
 
{
 
/* Note que le pointeur est au dessus du popup */
 
	popup_has_pointer = TRUE;
 
	(void) popup;
	(void) event;
	(void) user_data;
 
	return TRUE;
 
}
 
static gboolean cb_leave_notify_popup (GtkWindow *popup, GdkEvent *event, gpointer user_data)
 
{
 
/* Note que le pointeur a quitté la fenêtre popup */
 
	popup_has_pointer = FALSE;
 
/* Lance le timeout (2 dixièmes de seconde) */
 
	g_timeout_add (200, (GSourceFunc) end_timeout, (gpointer) popup);
 
	(void) user_data;
	(void) event;
 
	return TRUE;
 
}
 
static void cb_value_scale_changed (GtkRange *scale, GtkLabel *label)
 
{
 
/* Déclare une chaîne de caractères pour le label (avec de la marge) */
 
	gchar label_text[10];
 
/* récupère la valeur du curseur et la recopie dans le label */
 
	sprintf (label_text, "%3.0f%%", gtk_range_get_value (scale));
 
	gtk_label_set_text (label, label_text);
 
}
 
static gboolean end_timeout (GtkWindow *popup)
 
{
 
/* Si le pointeur de la souris n'est pas au dessus de l'un des widgets */
 
	if ( ! (eventbox_has_pointer || popup_has_pointer))
 
	{
 
/* Masque la fenêtre popup */
 
		gtk_widget_hide (GTK_WIDGET (popup));
 
	}
 
	return FALSE;
 
}

Jean-Marie

[diesel83]

Bon, je continue à progresser.

L'idée est de pouvoir utiliser mon curseur de contrôle sur un nombre variable de valeurs (GtkLabel) sans pour autant multiplier à l'infini les fonctions de callback.

J'ai dérivé un nouvel exemple du précédent avec deux labels au lieu d'un.

Mon problème est que j'ai encore dû déclarer une variable globale pour y stocker un pointeur sur le label à contrôler et je suis bien d'accord avec la remarque de Gerald3d sur les variables globales.

Est-ce que quelqu'un aurait une idée pour réussir à passer un pointeur sur le label à contrôler à la fonction de callback "value_changed" du curseur de contrôle .

Ci-joint le code de mon deuxième exemple :

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
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
#include <stdlib.h> /* définition de EXIT_SUCCESS */
#include <string.h>
#include <gtk/gtk.h>
 
/* Prototypes des fonctions de callback */
 
static gboolean cb_enter_notify_eventbox (GtkEventBox *, GdkEvent *, GtkWindow *);
static gboolean cb_leave_notify_eventbox (GtkEventBox *, GdkEvent *, GtkWindow *);
static gboolean cb_enter_notify_popup (GtkWindow *, GdkEvent *, gpointer);
static gboolean cb_leave_notify_popup (GtkWindow *, GdkEvent *, gpointer);
static void cb_value_scale_changed (GtkRange *, gpointer);
static gboolean end_timeout (GtkWindow *);
 
/* Déclaration des objets globaux */
 
gboolean eventbox_has_pointer = FALSE;
gboolean popup_has_pointer = FALSE;
GtkLabel *current_value;
 
int main (int argc, char *argv[])
 
{
 
/* Initialisation de GTK */
 
	gtk_init (&argc, &argv);
 
/* Déclaration des objets */
 
	GtkWindow *window, *popup;
	GtkGrid *grid;
	GtkEventBox *eventbox1, *eventbox2;
	GtkFrame *frame1, *frame2;
	GtkLabel *label1, *label2, *value1, *value2;
	GtkAdjustment *adj;
	GtkScale *scale;
 
/* Initialisation des objets */
 
	window = GTK_WINDOW (gtk_window_new (GTK_WINDOW_TOPLEVEL));
	grid = GTK_GRID (gtk_grid_new ());
	label1 = GTK_LABEL (gtk_label_new ("Valeur1 : "));
	eventbox1 = GTK_EVENT_BOX (gtk_event_box_new ());
	frame1 = GTK_FRAME (gtk_frame_new (NULL));
	value1 = GTK_LABEL (gtk_label_new ("100%"));
	label2 = GTK_LABEL (gtk_label_new ("   Valeur2 : "));
	eventbox2 = GTK_EVENT_BOX (gtk_event_box_new ());
	frame2 = GTK_FRAME (gtk_frame_new (NULL));
	value2 = GTK_LABEL (gtk_label_new ("50%"));
 
	popup = GTK_WINDOW (gtk_window_new (GTK_WINDOW_POPUP));
	adj = GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, 100, 1, 0, 0));
	scale = GTK_SCALE (gtk_scale_new (GTK_ORIENTATION_VERTICAL, adj));
 
/* Paramétrage des objets */
 
	gtk_window_set_title (window, "Mon exemple 2");
	gtk_container_set_border_width (GTK_CONTAINER (window), 10);
	gtk_widget_set_size_request (GTK_WIDGET (window), 600, 600);
 
	gtk_grid_set_row_spacing (grid, 5);
	gtk_grid_set_column_homogeneous (grid, FALSE);
	gtk_grid_set_row_homogeneous (grid, FALSE);
	gtk_widget_set_halign (GTK_WIDGET (grid), GTK_ALIGN_START);
	gtk_widget_set_valign (GTK_WIDGET (grid), GTK_ALIGN_START);
 
	gtk_label_set_width_chars (value1, 5);
	gtk_label_set_justify (value1, GTK_JUSTIFY_RIGHT);
	gtk_label_set_width_chars (value2, 5);
	gtk_label_set_justify (value2, GTK_JUSTIFY_RIGHT);
 
	gtk_window_set_decorated (popup, FALSE);
	gtk_widget_set_size_request (GTK_WIDGET (popup), 1, 140);
	gtk_window_set_resizable (popup, FALSE);
 
	gtk_scale_set_draw_value (scale, FALSE);
	gtk_range_set_inverted (GTK_RANGE (scale), TRUE);
 
/* Attachement des objets les uns dans les autres */
 
	gtk_container_add (GTK_CONTAINER (frame1), GTK_WIDGET (value1));
	gtk_container_add (GTK_CONTAINER (eventbox1), GTK_WIDGET (frame1));
	gtk_container_add (GTK_CONTAINER (frame2), GTK_WIDGET (value2));
	gtk_container_add (GTK_CONTAINER (eventbox2), GTK_WIDGET (frame2));
 
	gtk_grid_attach (grid, GTK_WIDGET (label1), 0 , 0, 1, 1);
	gtk_grid_attach_next_to (grid, GTK_WIDGET (eventbox1), GTK_WIDGET (label1), GTK_POS_RIGHT, 1, 1);
	gtk_grid_attach_next_to (grid, GTK_WIDGET (label2), GTK_WIDGET (eventbox1), GTK_POS_RIGHT, 1, 1);
	gtk_grid_attach_next_to (grid, GTK_WIDGET (eventbox2), GTK_WIDGET (label2), GTK_POS_RIGHT, 1, 1);
 
	gtk_container_add (GTK_CONTAINER (window), GTK_WIDGET (grid));
 
	gtk_container_add (GTK_CONTAINER (popup), GTK_WIDGET (scale));
 
/* Déclaration des fonctions de callback */
 
	g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (gtk_main_quit), NULL);
 
	g_signal_connect (G_OBJECT (eventbox1), "enter-notify-event", G_CALLBACK (cb_enter_notify_eventbox), (gpointer) popup);
	g_signal_connect (G_OBJECT (eventbox1), "leave-notify-event", G_CALLBACK (cb_leave_notify_eventbox), (gpointer) popup);
	g_signal_connect (G_OBJECT (eventbox2), "enter-notify-event", G_CALLBACK (cb_enter_notify_eventbox), (gpointer) popup);
	g_signal_connect (G_OBJECT (eventbox2), "leave-notify-event", G_CALLBACK (cb_leave_notify_eventbox), (gpointer) popup);
 
	g_signal_connect (G_OBJECT (popup), "enter-notify-event", G_CALLBACK (cb_enter_notify_popup), NULL);
	g_signal_connect (G_OBJECT (popup), "leave-notify-event", G_CALLBACK (cb_leave_notify_popup), NULL);
 
	g_signal_connect (G_OBJECT (scale), "value_changed", G_CALLBACK (cb_value_scale_changed), NULL);
 
/* Affiche les widgets */
 
	gtk_widget_show_all (GTK_WIDGET (window));
 
	gtk_widget_show (GTK_WIDGET (scale));
 
/* Et c'est parti ! */
 
	gtk_main ();
 
	return EXIT_SUCCESS;
 
}
 
static gboolean cb_enter_notify_eventbox (GtkEventBox *eventbox, GdkEvent *event, GtkWindow *popup)
 
{
 
/* Déclaration des variables locales à la fonction */
 
	int int_value;
	GtkWindow *window;
	GtkFrame *frame;
	GtkLabel *value;
	GtkScale *scale;
	GtkAllocation allocation;
	gint window_x, window_y, widget_x, widget_y;
 
/* Note que le pointeur est au dessus de l'enventbox */
 
	eventbox_has_pointer = TRUE;
 
/* Retrouve les objets */
 
	frame = GTK_FRAME (gtk_bin_get_child (GTK_BIN (eventbox)));
	value = GTK_LABEL (gtk_bin_get_child (GTK_BIN (frame)));
 
	scale = GTK_SCALE (gtk_bin_get_child (GTK_BIN (popup)));
 
/* Note le label concerné */
 
	current_value = value;
 
/* Affecte la valeur courante du label au curseur */
 
	sscanf (gtk_label_get_text (value), "%d", &int_value);
	gtk_range_set_value (GTK_RANGE (scale), (gdouble) int_value);
 
/* Calcule la position du coin en haut et à droite du frame */
 
	window = GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (eventbox)));
	gdk_window_get_position (gtk_widget_get_window (GTK_WIDGET (window)), &window_x, &window_y);
	gtk_widget_get_allocation (GTK_WIDGET (frame), &allocation);
	gtk_widget_translate_coordinates (GTK_WIDGET (frame), GTK_WIDGET (window), window_x + allocation.width, window_y, &widget_x, &widget_y);
 
/* Déplace la fenêtre popup juste à droite du frame */
 
	gtk_window_move (popup, widget_x, widget_y);
 
/* affiche le popup */
 
	gtk_widget_show (GTK_WIDGET (popup));
 
	(void) event;
 
	return TRUE;
 
}
 
static gboolean cb_leave_notify_eventbox (GtkEventBox *eventbox, GdkEvent *event, GtkWindow *popup)
 
{
 
/* Note que le pointeur a quitté l'enventbox */
 
	eventbox_has_pointer = FALSE;
 
/* Lance le timeout (1 dixième de seconde) */
 
	g_timeout_add (100, (GSourceFunc) end_timeout, (gpointer) popup);
 
	(void) eventbox;
	(void) event;
 
	return TRUE;
 
}
 
static gboolean cb_enter_notify_popup (GtkWindow *popup, GdkEvent *event, gpointer user_data)
 
{
 
/* Note que le pointeur est au dessus du popup */
 
	popup_has_pointer = TRUE;
 
	(void) popup;
	(void) event;
	(void) user_data;
 
	return TRUE;
 
}
 
static gboolean cb_leave_notify_popup (GtkWindow *popup, GdkEvent *event, gpointer user_data)
 
{
 
/* Note que le pointeur a quitté la fenêtre popup */
 
	popup_has_pointer = FALSE;
 
/* Lance le timeout (1 dixième de seconde) */
 
	g_timeout_add (100, (GSourceFunc) end_timeout, (gpointer) popup);
 
	(void) user_data;
	(void) event;
 
	return TRUE;
 
}
 
static void cb_value_scale_changed (GtkRange *scale, gpointer user_data)
 
{
 
/* Déclare une chaîne de caractères pour le label (avec de la marge) */
 
	gchar value_text[10];
 
/* récupère la valeur du curseur et la recopie dans le label */
 
	sprintf (value_text, "%3.0f%%", gtk_range_get_value (scale));
 
	gtk_label_set_text (current_value, value_text);
 
	(void) user_data;
 
}
 
static gboolean end_timeout (GtkWindow *popup)
 
{
 
/* Si le pointeur de la souris n'est pas au dessus de l'un des widgets */
 
	if ( ! (eventbox_has_pointer || popup_has_pointer))
 
	{
 
/* Masque la fenêtre popup */
 
		gtk_widget_hide (GTK_WIDGET (popup));
 
	}
 
	return FALSE;
 
}

Jean-Marie

[Schaublore]

Tu devrai créer un widget. (j'ai trouvé un GtkBin subclass example)

Ca serrai sympat de pouvoir ensuite l'attacher a un GimpChainButton:

[diesel83]

Bonjour Schaublore,

Ta réponse me fait chaud au cœur (bon, là, j'exagère peut-être un peu ) car j'étais à peu près arrivé à la même conclusion.

En gros, pour écrire des exemples comme les miens, on peut s'en tirer avec les objets natifs de GTK+, mais dès qu'on veut aller un peu plus loin, il faut créer ses objets ou en dériver des objets existants.

Et là, les variables que j'ai été obligé de déclarer globales seront encapsulées dans les objets.

Je m'y mets dès ce soir et je vous mettrai le code quand ce sera fini.

Jean-Marie

[gerald3d]

...
Et là, les variables que j'ai été obligé de déclarer globales seront encapsulées dans les objets.

Je m'y mets dès ce soir et je vous mettrai le code quand ce sera fini.

Jean-Marie

Finalement on y vient . Quand je le disais que les variables globales c'était pas terrible

[diesel83]

Bonjour Schaublore,

Ta réponse me fait chaud au cœur (bon, là, j'exagère peut-être un peu ) car j'étais à peu près arrivé à la même conclusion.

En gros, pour écrire des exemples comme les miens, on peut s'en tirer avec les objets natifs de GTK+, mais dès qu'on veut aller un peu plus loin, il faut créer ses objets ou en dériver des objets existants.

Et là, les variables que j'ai été obligé de déclarer globales seront encapsulées dans les objets.

Je m'y mets dès ce soir et je vous mettrai le code quand ce sera fini.

Jean-Marie

Bonjour,

Bon, ça avance, j'y suis presque.

Il me reste un petit problème.

J'ai créé un widget ScaledValue appartenant à une classe ScaledValueClass. Jusque là, tout va bien.

Dans mes différentes fonctions, j'utilise un pointeur sur mon widget ScaledValue portant le nom "exotique" de scaledvalue.

Je soupçonne qu'il doit bien exister une fonction qui me permette d'écrire :

Code :

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

scaledvalueclass = fonction_qui_va_bien (scaledvalue);

et à partir de laquelle le pointeur scaledvalueclass me donnera accès à la classe de mon widget.

Mais, je n'ai pas trouvé.

Quelqu'un connaît cette fonction ?.

Merci d'avance.

Amicalement.

Jean-Marie

[pvincent]

Je n'ai jamais expérimenté la chose, mais si j'en crois cette réponse :

You want to use g_type_class_ref

GtkSpinButtonClass *klass = g_type_class_ref(GTK_TYPE_SPIN_BUTTON);

and when you're done with it

g_type_class_unref(klass);

c'est g_type_class_ref() qui sert, suivi de g_type_class_unref() pour compenser.

Edit: sinon, en me basant sur l'existence de macros du type GTK_IS_SPIN_BUTTON, je me souviens d'avoir cherché sur le Net (et oublié où j'ai trouvé cette info) comment tester de la même façon et d'en avoir déduit que pour mon widget GwList (je ne voulais pas employer le préfixe GTK et je l'ai remplacé par GW), il fallait utiliser la macro IS_GW_LIST. Ca marche dans GraceGTK.

[diesel83]

Merci beaucoup pour la réponse.

En creusant un peu, j'ai fini par trouver sur le site du projet Gnome la fonction g_type_class_peek() qui doit répondre parfaitement à ce que je cherche.

En gros, elle fait la même chose que la fonction g_type_class_ref, sauf qu'elle n'incrémente pas le compteur et donc ne demande pas à déréférencer après.

A ce stade, je m'étonne juste qu'il faille descendre aussi bas dans les couches de GTK+ pour récupérer ce pointeur.

Lors de mes recherches solitaires, je n'étais descendu que jusqu'à g_objet (ce qui explique probablement que je n'aie rien trouvé).

Avec ça, je devrais terminer le codage de mon objet ce soir. Restera à faire fonctionner...

Jean-Marie

[diesel83]

Bonjour,

En ce moment, je galère un peu pour mettre au point mon widget.

Une de mes interrogations concerne ces fonctions qui sont appelées par le framework GTK : my_object_class_init, my_object_init, my_object_realize...

Qui sait où je pourrais trouver la liste de tous ces appels et ce qui est censé se passer à ce moment là ?.

Jean-Marie

[pvincent]

Je pense que l'information doit se trouver dans la doc de GObject, que je suis loin de comprendre en détail.
Pour la question que tu pose, il me semble que GClassInitFunc () dans https://developer.gnome.org/gobject/...ml#g-type-init est peut être le bon point de départ.
Pour ma part, je me suis surtout servi du tutoriel http://zetcode.com/tutorials/gtktutorial/customwidget/ et du hacking d'autre widgets, sans vraiment maîtriser le sujet.

[diesel83]

Bonjour,

Merci PVincent pour ta réponse.

Pour l'instant, je fais comme toi mais je suis un peu perdu car les différents tutoriels que j'ai vu n'utilisent pas les mêmes fonctions et je n'arrive pas à comprendre pourquoi.

Jean-Marie

[diesel83]

Bonsoir,

Après avoir beaucoup tâtonné, j'arrive enfin au bout (globalement ça fonctionne et il me reste quelques test à peaufiner pour que ce soit "parfait").

Je pense avoir à peu près "deviné" une règle pour dériver son propre widget de widgets existants (lorsque c'est possible et souhaitable) :

- construire (en réel ou mentalement) la fonctionnalité "permanente" de son widget (ne pas se préoccuper à ce stade d'éventuels popups intégrés au widget) à partir de widgets standards de la bibliothèque de widgets Gtk+ (dans le cas qui m'occupe, j'ai utilisé un GtkLabel dans un GtkEventBox, lui-même dans un GtkFrame). Voir mes exemples plus haut,
- dériver le nouveau widget à partir du widget standard le plus "enveloppant" (dans mon cas le GtkFrame).

Dans un premier temps, j'étais parti d'une dérivation de GtkWidget et je suis arrivé à une sorte d'impasse car il me manquait une GdkWindow pour y "ranger" mes widgets internes. Même si je pense que j'aurais pu y arriver quand-même, il s'est avéré beaucoup plus simple de dériver de GtkFrame qui m'a fourni gracieusement sa GdkWindow..

Jean-Marie

[diesel83]

Je ne vous ai pas oublié.

Élevé tout petit à la programmation sur des systèmes embarqués basés sur des processeurs 8 bits (pour les plus jeunes : oui, ça a existé !), j'ai tendance à économiser, notamment la mémoire.

Comme le popup n'est utilisé qu'en une seule fois pour l'un des objets survolé par le pointeur de la souris, j'ai essayé de le déclarer (de manière unique) au niveau de la classe de l'objet.

Ça marche parfaitement, sauf... lors des transitions rapide entre objets accolés les uns aux autres. Là, le temps de finir le traitement de l'un des objets (appel de la fonction de callback), le pointeur de la souris est déjà entré sur l'objet d'à côté et ça met la pagaille.

J'ai donc fini par décider de créer un popup par objet pour ne plus être embêté.

Je devrais vous publier le code très bientôt.

Jean-Marie