Régler une valeur numérique dans un label à l'aide d'un curseur popup.

Version imprimable

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.:lol:

Le programme, donc :

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

05/01/2015, 19h28
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...
05/01/2015, 19h56
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
06/01/2015, 01h20
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:

GtkGrid *grid = GTK_GRID (gtk_grid_new ());

au lieu de:
Code:

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
06/01/2015, 08h27
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

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:

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.

06/01/2015, 10h34
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

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.:D

Merci Schaublore.

Donc, le source "définitif" :

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

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:

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

07/01/2015, 02h17
Schaublore

1 pièce(s) jointe(s)

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

Ca serrai sympat de pouvoir ensuite l'attacher a un GimpChainButton:
Pièce jointe 165525
07/01/2015, 07h27
diesel83

Bonjour Schaublore,

Ta réponse me fait chaud au cœur (bon, là, j'exagère peut-être un peu :lol:) 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
07/01/2015, 10h52
gerald3d

Citation:

Envoyé par diesel83

...
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 :mrgreen:
05/02/2015, 07h48
diesel83

Citation:

Envoyé par diesel83

Bonjour Schaublore,

Ta réponse me fait chaud au cœur (bon, là, j'exagère peut-être un peu :lol:) 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:

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
05/02/2015, 10h30
pvincent

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

Citation:

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.
05/02/2015, 13h58
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
09/02/2015, 07h47
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
09/02/2015, 18h06
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.
12/02/2015, 08h41
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
17/02/2015, 20h52
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
01/03/2015, 12h12
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é !:D), 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

Bon, j'ai fini (enfin :mrgreen:).

Finalement, affecter un curseur popup pour chacun des objets m'a grandement simplifié le code (ce qui ne veut pas forcement dire qu'il est devenu plus efficace ; cela multiplie le nombre d'objets gérés par la framework g_object).

Le code, donc.

Le fichier d'entêtes de l'objet ScaledValue :

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
/***********************************************/
/* Fichier d'entêtes de l'objet ScaledValue.   */
/***********************************************/
 
/****************************************************************************************************/
/* Le widget ScaledValue prend à sa création via sa fonction scaled_value_new() une valeur initiale */
/* de type guint comprise entre 0 et 100.                                                           */
/* Il affiche cette valeur suivie du symbole "%" dans un rectangle entouré d'un frame.              */
/* La valeur peut aussi être changée via la fonction scaled-value_set_value().                      */
/* Lorsque le pointeur de la souris survole le widget, une fenêtre popup contenant un curseur       */
/* apparaît à droite du widget. Elle disparaît un 10ème de seconde après que le pointeur ait quitté */
/* le widget (le frame contenant la valeur affichée ou le popup contenant le curseur).              */
/* A l'aide du curseur, il est possible d'ajuster la valeur du widget.                              */
/* Chaque fois que la valeur a changé, le signal "value-changed" est émis.                          */
/* La nouvelle valeur peut être récupérée via la fonction scaled_value_get_value().                 */
/* Le widget garde la valeur intacte jusqu'à ce qu'elle soit à nouveau changée à l'aide du curseur  */
/* ou que le widget soit détruit.                                                                   */
/****************************************************************************************************/
 
#ifndef __SCALED_VALUE_H__
#define __SCALED_VALUE_H__
 
#include <glib.h>
#include <glib-object.h>
#include <gtk/gtkframe.h>
 
G_BEGIN_DECLS
 
#define SCALED_VALUE_TYPE			(scaled_value_get_type ())
#define SCALED_VALUE(any_widget)		(G_TYPE_CHECK_INSTANCE_CAST ((any_widget), \
								SCALED_VALUE_TYPE, ScaledValue))
#define SCALED_VALUE_CLASS(any_class)		(G_TYPE_CHECK_CLASS_CAST ((any_class), \
								SCALED_VALUE_TYPE, ScaledValueClass))
#define IS_SCALED_VALUE(any_widget)		(G_TYPE_CHECK_INSTANCE_TYPE ((any_widget), \
								SCALED_VALUE_TYPE))
#define IS_SCALED_VALUE_CLASS(any_class)	(G_TYPE_CHECK_CLASS_TYPE ((any_class), \
								SCALED_VALUE_TYPE))
 
typedef struct _ScaledValueClass	ScaledValueClass;
 
typedef struct _ScaledValue		ScaledValue;
typedef struct _ScaledValuePrivate	ScaledValuePrivate;
 
/* Déclaration de la structure de classe du widget ScaledValue. */
 
struct _ScaledValueClass
 
{
 
	GtkFrameClass parent_class; /* Pas un pointeur !. */
 
/* Déclare le signal "value-changed", émis chaque fois que la valeur change. */
 
	void (* value_changed) (ScaledValue *scaledvalue);
 
};
 
/* déclaration de la structure du widget ScaledValue. */
 
struct _ScaledValue
 
{
 
/* Le widget "de peau" du widget ScaledValue est un GtkFrame. Donc, dérive de GtkFrame. */
 
	GtkFrame frame; /* Pas un pointeur !. */
 
/* Pointeur sur les données privées du widget ScaledValue. */
 
	ScaledValuePrivate *priv;
 
};
 
/* Prototypes des fonctions. */
 
GType		scaled_value_get_type (void) G_GNUC_CONST;
GtkWidget *	scaled_value_new (guint value);
 
void		scaled_value_set_value (ScaledValue *scaledvalue, guint value);
guint		scaled_value_get_value (ScaledValue *scaledvalue);
 
G_END_DECLS
 
#endif /* __SCALED_VALUE_H__ */

Le fichier source de l'objet ScaledValue :

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
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
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
/*******************************************/
/* Fichier source de l'objet ScalableValue */
/*******************************************/
 
/****************************************************************************************************/
/* Le widget ScaledValue prend à sa création via sa fonction scaled_value_new() une valeur initiale */
/* de type guint comprise entre 0 et 100.                                                           */
/* Il affiche cette valeur suivie du symbole "%" dans un rectangle entouré d'un frame.              */
/* La valeur peut aussi être changée via la fonction scaled-value_set_value().                      */
/* Lorsque le pointeur de la souris survole le widget, une fenêtre popup contenant un curseur       */
/* apparaît à droite du widget. Elle disparaît un 10ème de seconde après que le pointeur ait quitté */
/* le widget (le frame contenant la valeur affichée ou le popup contenant le curseur).              */
/* A l'aide du curseur, il est possible d'ajuster la valeur du widget.                              */
/* Chaque fois que la valeur a changé, le signal "value-changed" est émis.                          */
/* La nouvelle valeur peut être récupérée via la fonction scaled_value_get_value().                 */
/* Le widget garde la valeur intacte jusqu'à ce qu'elle soit à nouveau changée à l'aide du curseur  */
/* ou que le widget soit détruit.                                                                   */
/****************************************************************************************************/
 
#include <gtk/gtk.h>
#include "scaledvalue.h"
 
/****************************************************************************************************/
/* Structure des données privées du widget ScaledValue.                                             */
/****************************************************************************************************/
 
struct _ScaledValuePrivate
 
{
 
/* Pointeurs sur les widgets permettant d'afficher la valeur et de recevoir les signaux. */
 
	GtkLabel	*label;
	GtkEventBox	*eventbox;
 
/* Pointeurs sur les widgets du popup. */
 
	GtkScale	*scale;
	GtkWindow	*popup;
 
/* Référence du timeout */
 
	guint		timeout_ref;
 
};
 
/****************************************************************************************************/
/* Signaux qui peuvent être émis par le widget ScaledValue.                                         */
/****************************************************************************************************/
 
enum
 
{
 
	VALUE_CHANGED,
	LAST_SIGNAL
 
};
 
static guint scaled_value_signals [LAST_SIGNAL] = { 0 };
 
/****************************************************************************************************/
/* Prototypes des fonctions du widget ScaledValue.                                                  */
/****************************************************************************************************/
 
/* Fonctions publiques (pour mémoire, définies dans scaledvalue.h) */
 
/* GType	scaled_value_get_type (void) G_GNUC_CONST; */
/* GtkWidget *	scaled_value_new (guint value); */
 
/* void		scaled_value_set_value (ScaledValue *scaledvalue, guint value); */
/* guint	scaled_value_get_value (ScaledValue *scaledvalue); */
 
 
/* Fonctions d'initialisation du widget ScaledValue */
 
static void	scaled_value_class_init (ScaledValueClass *);
static void	scaled_value_init (ScaledValue *);
 
/* Fonctions de callback */
 
static gboolean	scaled_value_cb_enter_notify_eventbox (GtkEventBox *, GdkEvent *, ScaledValue *);
static gboolean	scaled_value_cb_leave_notify_eventbox (GtkEventBox *, GdkEvent *, ScaledValue *);
static gboolean	scaled_value_cb_enter_notify_popup (GtkWindow *, GdkEvent *, ScaledValue *);
static gboolean	scaled_value_cb_leave_notify_popup (GtkWindow *, GdkEvent *, ScaledValue *);
static void	scaled_value_cb_value_scale_changed (GtkRange *, ScaledValue *);
static gboolean	scaled_value_end_timeout (ScaledValue *);
 
/****************************************************************************************************/
/* Code des fonctions.                                                                              */
/****************************************************************************************************/
 
/* Fournit le type GType correspondant au widget ScaledValue.                                */
/* Le type est créé au premier appel de la fonction (lors de l'initialisation de la classe). */
/* De plus, cette fonction enregistre la structure des données privées de la classe.         */
 
GType scaled_value_get_type (void)
 
{
 
/* Déclare le type "static" et le force à 0 pour le premier appel de la fonction */
 
	static GType scaled_value_type = 0;
 
/* Si le GType est égal à 0 */
 
	if (!scaled_value_type)
 
	{
 
		GTypeInfo scaled_value_info = 
 
		{
 
			sizeof (ScaledValueClass),
			NULL,
			NULL,
			(GClassInitFunc) scaled_value_class_init,
			NULL,
			NULL,
			sizeof (ScaledValue),
			0,
			(GInstanceInitFunc) scaled_value_init,
 
		};
 
/* Enregistre le type ScaledValue. Précise notamment que le type ScaledValue dérive de GTK_TYPE_FRAME,      */
/* ce qui permet d'utiliser toutes les propriétés de GtkFrame ainsi que celle des widgets dont dérive       */
/* GtkFrame, en particulier GtkContainer pour attacher le GtkEventBox et le GtkLabel au widget ScaledValue. */
 
		scaled_value_type = g_type_register_static (GTK_TYPE_FRAME, "ScaledValue", &scaled_value_info, 0);
 
	}
 
	return scaled_value_type;
 
}
 
/* Crée une nouvelle instance du widget ScaledValue et renvoie un pointeur sur ce widget.   */
/* A la première instance, appelle la fonction scaled_value_class_Init (), puis à chaque    */
/* nouvelle instance (dont la première), appelle la fonction scaled_value_init ()           */
 
GtkWidget* scaled_value_new (guint value)
 
{
 
/* Déclaration des variables locales à la fonction. */
 
	ScaledValue *scaledvalue;
	ScaledValuePrivate *priv;
 
/* Crée effectivement le widget ScaledValue. */
 
	scaledvalue = SCALED_VALUE (g_object_new (scaled_value_get_type (), NULL));
 
/* A ce stade, la fonction scaled_value_init () a déjà été exécutée.   */
/* Notamment, le pointeur scaledvalue->priv a déjà été initialisé.     */
/* Récupère un pointeur sur la structure privée du widget ScaledValue. */
 
	priv = scaledvalue->priv;
 
/* Affecte la valeur du widget au curseur. */
 
	gtk_range_set_value (GTK_RANGE (priv->scale), (gdouble) value);
 
/* Initialise le label. */
 
	gtk_label_set_text (priv->label, g_strdup_printf ("%d%%", value));
 
	return GTK_WIDGET (scaledvalue);
 
}
 
/* Initialise la classe ScaledValueClass. */
 
static void scaled_value_class_init (ScaledValueClass *scaledvalueclass)
 
{
 
/* Ajoute ScaledValuePrivate comme structure de données privée de chaque widget ScaledValue. */
 
	g_type_class_add_private (scaledvalueclass, sizeof (ScaledValuePrivate));
 
/* Enregistre le signal "value-changed" qui sera émis lorsque la valeur aura été changée. */
 
	scaled_value_signals [VALUE_CHANGED] = g_signal_new ("value-changed", G_TYPE_FROM_CLASS (scaledvalueclass),
							G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
							G_STRUCT_OFFSET (ScaledValueClass, value_changed),
							NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
 
}
 
/* Initialise le widget ScaledValue courant. Cette fonction est utilisée */
/* pour fixer la vue initiale du widget et les propriétés nécessaires.   */
 
static void scaled_value_init (ScaledValue *scaledvalue)
 
{
 
/* Déclaration des variables locales à la fonction. */
 
	ScaledValuePrivate *priv;
 
/* Initialise un pointeur statique sur les données privées du widget ScaledValue. */
 
	scaledvalue->priv = G_TYPE_INSTANCE_GET_PRIVATE (scaledvalue, SCALED_VALUE_TYPE, ScaledValuePrivate);
 
	priv = scaledvalue->priv;
 
/* A ce moment, il n'y a aps de timeout actif. */
 
	priv->timeout_ref = 0;
 
/* Crée le Label et l'EventBox qui l'entoure. */
 
	priv->label = GTK_LABEL (gtk_label_new (NULL));
	priv->eventbox = GTK_EVENT_BOX (gtk_event_box_new ());
 
/* Paramètre les widgets. */
 
	gtk_label_set_width_chars (priv->label, 5);
	gtk_misc_set_alignment (GTK_MISC (priv->label), 1, .5);
 
/* Attache les objets les uns aux autres. */
 
	gtk_container_add (GTK_CONTAINER (priv->eventbox), GTK_WIDGET (priv->label));
	gtk_container_add (GTK_CONTAINER (scaledvalue), GTK_WIDGET (priv->eventbox));
 
/* Attache les fonctions de callback. */
 
	g_signal_connect (G_OBJECT (priv->eventbox), "enter-notify-event",
			G_CALLBACK (scaled_value_cb_enter_notify_eventbox), scaledvalue);
	g_signal_connect (G_OBJECT (priv->eventbox), "leave-notify-event",
			G_CALLBACK (scaled_value_cb_leave_notify_eventbox), scaledvalue);
 
/* Affiche les widgets internes du widget ScaledValue. */
 
	gtk_widget_show (GTK_WIDGET (priv->label));
	gtk_widget_show (GTK_WIDGET (priv->eventbox));
 
/* Crée la fenêtre popup et l'objet MyScale qu'elle contient, ainsi que l'ajustement associé. */
 
	priv->scale = GTK_SCALE (gtk_scale_new_with_range (GTK_ORIENTATION_VERTICAL, 0, 100, 1));
	priv->popup = GTK_WINDOW (gtk_window_new (GTK_WINDOW_POPUP));
 
/* Paramètre les widgets. */
 
	gtk_scale_set_draw_value (GTK_SCALE (priv->scale), FALSE);
	gtk_range_set_inverted (GTK_RANGE (priv->scale), TRUE);
 
	gtk_window_set_decorated (priv->popup, FALSE);
	gtk_widget_set_size_request (GTK_WIDGET (priv->popup), 1, 140);
	gtk_window_set_resizable (priv->popup, FALSE);
 
/* Attache les objets les uns aux autres. */
 
	gtk_container_add (GTK_CONTAINER (priv->popup), GTK_WIDGET (priv->scale));
 
/* Rend le curseur visible dans la fenêtre popup. */
 
	gtk_widget_show (GTK_WIDGET (priv->scale));
 
/* Attache les fonctions de callback. */
 
	g_signal_connect (G_OBJECT (priv->popup), "enter-notify-event", G_CALLBACK (scaled_value_cb_enter_notify_popup), scaledvalue);
	g_signal_connect (G_OBJECT (priv->popup), "leave-notify-event", G_CALLBACK (scaled_value_cb_leave_notify_popup), scaledvalue);
 
	g_signal_connect (G_OBJECT (priv->scale), "value_changed", G_CALLBACK (scaled_value_cb_value_scale_changed), scaledvalue);
 
}
 
/* Fixe la valeur du widget ScaledValue. Si la valeur est différente de la valeur courante, le signal */
/*  "value-changed" est émis par le widget GtkScale interne et la valeur affichée est mise à jour.    */
 
void scaled_value_set_value (ScaledValue *scaledvalue, guint value)
 
{
 
/* Affecte la valeur du widget au curseur. */
 
	gtk_range_set_value (GTK_RANGE (scaledvalue->priv->scale), (gdouble) value);
 
}
 
/* Rend la valeur du widget ScaledValue */
 
guint scaled_value_get_value (ScaledValue *scaledvalue)
 
{
 
	return (guint) gtk_range_get_value (GTK_RANGE (scaledvalue->priv->scale));
 
}
 
/****************************************************************************************************/
/* Fonctions de callback.                                                                           */
/****************************************************************************************************/
 
/* Fonction appelée lorsque le pointeur entre au dessus de l'eventbox. */
 
static gboolean scaled_value_cb_enter_notify_eventbox (GtkEventBox *eventbox, GdkEvent *event, ScaledValue *scaledvalue)
 
{
 
/* Déclaration des variables locales à la fonction. */
 
	ScaledValuePrivate * priv;
	GtkWindow *window;
	GtkAllocation allocation; /* Pas un pointeur ! */
	gint window_x, window_y, widget_x, widget_y;
 
/* Récupère un pointeur sur la structure privée du widget ScaledValue. */
 
	priv = scaledvalue->priv;
 
/* Si un timeout est en cours pour le widget ScaledValue courant, on le stoppe. */
 
	if (priv->timeout_ref)
 
	{
 
		g_source_remove (priv->timeout_ref);
 
/* Efface la référence du timeout. */
 
		priv->timeout_ref = 0;
 
	}
 
/* Calcule la position du coin en haut et à droite du frame. */
 
	window = GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (scaledvalue)));
	gdk_window_get_position (gtk_widget_get_window (GTK_WIDGET (window)), &window_x, &window_y);
	gtk_widget_get_allocation (GTK_WIDGET (scaledvalue), &allocation);
	gtk_widget_translate_coordinates (GTK_WIDGET (scaledvalue), 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 (priv->popup, widget_x, widget_y);
 
/* affiche le popup. */
 
	gtk_widget_show (GTK_WIDGET (priv->popup));
 
	(void) event;
 
	return TRUE; /* Arrête la propagation de l'évènement. */
 
}
 
/* Fonction appelée lorsque le pointeur quitte l'eventbox. */
 
static gboolean scaled_value_cb_leave_notify_eventbox (GtkEventBox *eventbox, GdkEvent *event, ScaledValue *scaledvalue)
 
{
 
/* Lance le timeout (1 dixième de seconde) et enregistre sa référence. */
 
	scaledvalue->priv->timeout_ref = g_timeout_add (100, (GSourceFunc) scaled_value_end_timeout, scaledvalue);
 
	(void) eventbox;
	(void) event;
 
	return TRUE; /* Arrête la propagation de l'évènement. */
 
}
 
/* Fonction appelée lorsque le pointeur entre au dessus du popup. */
 
static gboolean scaled_value_cb_enter_notify_popup (GtkWindow *popup, GdkEvent *event, ScaledValue *scaledvalue)
 
{
 
/* Déclaration des variables locales à la fonction. */
 
	ScaledValuePrivate * priv;
 
/* Récupère un pointeur sur la structure privée du widget ScaledValue. */
 
	priv = scaledvalue->priv;
 
/* Arrête le timeout. */
 
	g_source_remove (priv->timeout_ref);
 
/* Efface la référence du timeout. */
 
	priv->timeout_ref = 0;
 
	(void) popup;
	(void) event;
 
	return TRUE; /* Arrête la propagation de l'évènement. */
 
}
 
/* Fonction appelée lorsque le pointeur quitte le popup. */
 
static gboolean scaled_value_cb_leave_notify_popup (GtkWindow *popup, GdkEvent *event, ScaledValue *scaledvalue)
 
{
 
/* Lance le timeout (1 dixième de seconde) et enregistre sa référence. */
 
	scaledvalue->priv->timeout_ref = g_timeout_add (100, (GSourceFunc) scaled_value_end_timeout, scaledvalue);
 
	(void) event;
 
	return TRUE; /* Arrête la propagation de l'évènement. */
 
}
 
/* Fonction appelée lorsque la valeur contrôlée par le curseur change. */
 
static void scaled_value_cb_value_scale_changed (GtkRange *scale, ScaledValue *scaledvalue)
 
{
 
/* Déclaration des variables locales à la fonction. */
 
	ScaledValuePrivate *priv;
 
/* Récupère un pointeur sur la structure privée du widget ScaledValue. */
 
	priv = scaledvalue->priv;
 
/* Aligne la valeur du widget sur celle du curseur. */
 
	gtk_label_set_text (priv->label, g_strdup_printf ("%d%%", (guint) gtk_range_get_value (scale)));
 
/* Emet le signal "value-changed". */
 
	g_signal_emit_by_name (scaledvalue, "value-changed");
 
}
 
/* Fonction appelée à la fin du timeout. Masque le popup. */
 
static gboolean scaled_value_end_timeout (ScaledValue *scaledvalue)
 
{
 
/* Déclaration des variables locales à la fonction. */
 
	ScaledValuePrivate *priv;
 
/* Récupère un pointeur sur la structure privée du widget ScaledValue. */
 
	priv = scaledvalue->priv;
 
/* Masque la fenêtre popup */
 
	gtk_widget_hide (GTK_WIDGET (priv->popup));
 
/* Efface la référence du timeout. */
 
	priv->timeout_ref = 0;
 
	return FALSE; /* Empèche le timeout de se relancer. */
 
}

Et enfin, un petit programme d'exemple :

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
#include <stdlib.h> /* Décaration de "EXIT_SUCCESS" */
#include <gtk/gtk.h>
 
#include "scaledvalue.h"
 
/* Prototypes de la fonction de callback */
 
static void cb_value_changed (ScaledValue *);
 
int main (int argc, char *argv[])
 
{
 
/* Initialisation de GTK */
 
	gtk_init (&argc, &argv);
 
/* Déclaration des objets */
 
	GtkWindow *window;
	GtkGrid *grid;
	ScaledValue *scaledvalue1, *scaledvalue2;
 
/* Initialisation des objets */
 
	window = GTK_WINDOW (gtk_window_new (GTK_WINDOW_TOPLEVEL));
	grid = GTK_GRID (gtk_grid_new ());
	scaledvalue1 = SCALED_VALUE (scaled_value_new (100));
	scaledvalue2 = SCALED_VALUE (scaled_value_new (50));
 
/* Paramétrage des objets */
 
	gtk_window_set_title (window, "Mon exemple 3");
	gtk_container_set_border_width (GTK_CONTAINER (window), 10);
	gtk_widget_set_size_request (GTK_WIDGET (window), 300, 300);
 
	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);
 
/* Attachement des objets les uns dans les autres */
 
	gtk_grid_attach (grid, GTK_WIDGET (scaledvalue1), 0 , 0, 1, 1);
 
	gtk_grid_attach_next_to (grid, GTK_WIDGET (scaledvalue2), GTK_WIDGET (scaledvalue1), GTK_POS_RIGHT, 1, 1);
 
	gtk_container_add (GTK_CONTAINER (window), GTK_WIDGET (grid));
 
/* Déclaration des fonctions de callback */
 
	g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (gtk_main_quit), NULL);
 
	g_signal_connect (G_OBJECT (scaledvalue1), "value-changed", G_CALLBACK (cb_value_changed), NULL);
	g_signal_connect (G_OBJECT (scaledvalue2), "value-changed", G_CALLBACK (cb_value_changed), NULL);
 
/* Affiche les widgets */
 
	gtk_widget_show_all (GTK_WIDGET (window));
 
/* Et c'est parti ! */
 
	gtk_main ();
 
	return EXIT_SUCCESS;
 
}
 
static void cb_value_changed (ScaledValue *scaledvalue)
 
{
 
	guint value;
 
/* récupère la valeur du curseur et la recopie dans le label */
 
	value = scaled_value_get_value (scaledvalue);
	g_print ("La nouvelle valeur est : %d%%\n", value);
 
}

C'est Gérald3d qui va être content ; plus une seule variable globale.8O

Maintenant, je vais me faire le même (ou presque) pour régler un angle entre 0 et 360° avec un bouton rotatif.

Jean-Marie

08/03/2015, 15h35
gerald3d

Citation:

Envoyé par diesel83

C'est Gérald3d qui va être content ; plus une seule variable globale.8O
Jean-Marie

Bravo, beau travail :plusser:. (Hé oui, je suis content :mouarf:)

Scrongneugneu !!. J'ai horreur de m'avouer vaincu.

J'ai donc continué sur ma première idée d'avoir un popup unique pour tous les objets... Et j'y suis arrivé.

Le fichier d'entêtes :

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
/***********************************************/
/* Fichier d'entêtes de l'objet ScaledValue.   */
/***********************************************/
 
/****************************************************************************************************/
/* Le widget ScaledValue prend à sa création via sa fonction scaled_value_new() une valeur initiale */
/* de type guint comprise entre 0 et 100.                                                           */
/* Il affiche cette valeur suivie du symbole "%" dans un rectangle entouré d'un frame.              */
/* La valeur peut aussi être changée via la fonction scaled-value_set_value().                      */
/* Lorsque le pointeur de la souris survole le widget, une fenêtre popup contenant un curseur       */
/* apparaît à droite du widget. Elle disparaît un 10ème de seconde après que le pointeur ait quitté */
/* le widget (le frame contenant la valeur affichée ou le popup contenant le curseur).              */
/* A l'aide du curseur, il est possible d'ajuster la valeur du widget.                              */
/* Chaque fois que la valeur a changé, le signal "value-changed" est émis.                          */
/* La nouvelle valeur peut être récupérée via la fonction scaled_value_get_value().                 */
/* Le widget garde la valeur intacte jusqu'à ce qu'elle soit à nouveau changée à l'aide du curseur  */
/* ou que le widget soit détruit.                                                                   */
/****************************************************************************************************/
 
#ifndef __SCALED_VALUE_H__
#define __SCALED_VALUE_H__
 
#include <glib.h>
#include <glib-object.h>
#include <gtk/gtkframe.h>
 
G_BEGIN_DECLS
 
#define SCALED_VALUE_TYPE			(scaled_value_get_type ())
#define SCALED_VALUE(any_widget)		(G_TYPE_CHECK_INSTANCE_CAST ((any_widget), \
								SCALED_VALUE_TYPE, ScaledValue))
#define SCALED_VALUE_CLASS(any_class)		(G_TYPE_CHECK_CLASS_CAST ((any_class), \
								SCALED_VALUE_TYPE, ScaledValueClass))
#define IS_SCALED_VALUE(any_widget)		(G_TYPE_CHECK_INSTANCE_TYPE ((any_widget), \
								SCALED_VALUE_TYPE))
#define IS_SCALED_VALUE_CLASS(any_class)	(G_TYPE_CHECK_CLASS_TYPE ((any_class), \
								SCALED_VALUE_TYPE))
 
typedef struct _ScaledValueClass	ScaledValueClass;
typedef struct _ScaledValueClassPrivate	ScaledValueClassPrivate;
 
typedef struct _ScaledValue		ScaledValue;
typedef struct _ScaledValuePrivate	ScaledValuePrivate;
 
/* Déclaration de la structure de classe du widget ScaledValue. */
 
struct _ScaledValueClass
 
{
 
	GtkFrameClass parent_class; /* Pas un pointeur !. */
 
/* Pointeur sur les données privées du widget ScaledValue. */
 
	ScaledValueClassPrivate *classpriv;
 
/* Déclare le signal "value-changed", émis chaque fois que la valeur change. */
 
	void (* value_changed) (ScaledValue *scaledvalue);
 
};
 
/* déclaration de la structure du widget ScaledValue. */
 
struct _ScaledValue
 
{
 
/* Le widget "de peau" du widget ScaledValue est un GtkFrame. Donc, dérive de GtkFrame. */
 
	GtkFrame frame; /* Pas un pointeur !. */
 
/* Pointeur sur les données privées du widget ScaledValue. */
 
	ScaledValuePrivate *priv;
 
};
 
/* Prototypes des fonctions. */
 
GType		scaled_value_get_type (void) G_GNUC_CONST;
GtkWidget *	scaled_value_new (guint value);
 
void		scaled_value_set_value (ScaledValue *scaledvalue, guint value);
guint		scaled_value_get_value (ScaledValue *scaledvalue);
 
G_END_DECLS
 
#endif /* __SCALED_VALUE_H__ */

Le fichier source :

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
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
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
/*******************************************/
/* Fichier source de l'objet ScalableValue */
/*******************************************/
 
/****************************************************************************************************/
/* Le widget ScaledValue prend à sa création via sa fonction scaled_value_new() une valeur initiale */
/* de type guint comprise entre 0 et 100.                                                           */
/* Il affiche cette valeur suivie du symbole "%" dans un rectangle entouré d'un frame.              */
/* La valeur peut aussi être changée via la fonction scaled-value_set_value().                      */
/* Lorsque le pointeur de la souris survole le widget, une fenêtre popup contenant un curseur       */
/* apparaît à droite du widget. Elle disparaît un 10ème de seconde après que le pointeur ait quitté */
/* le widget (le frame contenant la valeur affichée ou le popup contenant le curseur).              */
/* A l'aide du curseur, il est possible d'ajuster la valeur du widget.                              */
/* Chaque fois que la valeur a changé, le signal "value-changed" est émis.                          */
/* La nouvelle valeur peut être récupérée via la fonction scaled_value_get_value().                 */
/* Le widget garde la valeur intacte jusqu'à ce qu'elle soit à nouveau changée à l'aide du curseur  */
/* ou que le widget soit détruit.                                                                   */
/****************************************************************************************************/
 
#include <gtk/gtk.h>
#include "scaledvalue.h"
 
/****************************************************************************************************/
/* Structure des données privées de la classe du widget ScaledValue.                                */
/****************************************************************************************************/
 
struct _ScaledValueClassPrivate
 
{
 
/* Pointeurs sur les widgets du popup. */
 
	GtkScale	*scale;
	GtkWindow	*popup;
 
/* Pointeur sur le widget ScaledValue courant. */
 
	ScaledValue	*current_scaledvalue;
 
/* Référence du timeout */
 
	guint		timeout_ref;
 
};
 
/****************************************************************************************************/
/* Structure des données privées du widget ScaledValue.                                             */
/****************************************************************************************************/
 
struct _ScaledValuePrivate
 
{
 
/* La valeur gérée par le widget */
 
	guint			value;
 
/* Pointeurs sur les widgets permettant d'afficher la valeur et de recevoir les signaux. */
 
	GtkLabel		*label;
	GtkEventBox		*eventbox;
 
/* Pointeur sur les données privées de la classe du widget ScaledValue. */
 
	ScaledValueClassPrivate	*classpriv;
 
};
 
/****************************************************************************************************/
/* Signaux qui peuvent être émis par le widget ScaledValue.                                         */
/****************************************************************************************************/
 
enum
 
{
 
	VALUE_CHANGED,
	LAST_SIGNAL
 
};
 
static guint scaled_value_signals [LAST_SIGNAL] = { 0 };
 
/****************************************************************************************************/
/* Prototypes des fonctions du widget ScaledValue.                                                  */
/****************************************************************************************************/
 
/* Fonctions publiques (pour mémoire, définies dans scaledvalue.h) */
 
/* GType	scaled_value_get_type (void) G_GNUC_CONST; */
/* GtkWidget *	scaled_value_new (guint value); */
 
/* void		scaled_value_set_value (ScaledValue *scaledvalue, guint value); */
/* guint	scaled_value_get_value (ScaledValue *scaledvalue); */
 
/* Fonctions d'initialisation du widget ScaledValue */
 
static void	scaled_value_class_init (ScaledValueClass *);
static void	scaled_value_init (ScaledValue *);
 
/* Fonctions de callback */
 
static gboolean	scaled_value_cb_enter_notify_eventbox (GtkEventBox *, GdkEvent *, ScaledValue *);
static gboolean	scaled_value_cb_leave_notify_eventbox (GtkEventBox *, GdkEvent *, ScaledValueClassPrivate *);
static gboolean	scaled_value_cb_enter_notify_popup (GtkWindow *, GdkEvent *, ScaledValueClassPrivate *);
static gboolean	scaled_value_cb_leave_notify_popup (GtkWindow *, GdkEvent *, ScaledValueClassPrivate *);
static void	scaled_value_cb_value_scale_changed (GtkRange *, ScaledValueClassPrivate *);
static gboolean	scaled_value_end_timeout (ScaledValueClassPrivate *);
 
/****************************************************************************************************/
/* Code des fonctions.                                                                              */
/****************************************************************************************************/
 
/* Fournit le type GType correspondant au widget ScaledValue.                                */
/* Le type est créé au premier appel de la fonction (lors de l'initialisation de la classe). */
/* De plus, cette fonction enregistre la structure des données privées de la classe.         */
 
GType scaled_value_get_type (void)
 
{
 
/* Déclare le type "static" et le force à 0 pour le premier appel de la fonction */
 
	static GType scaled_value_type = 0;
 
/* Si le GType est égal à 0 */
 
	if (!scaled_value_type)
 
	{
 
		GTypeInfo scaled_value_info = 
 
		{
 
			sizeof (ScaledValueClass),
			NULL,
			NULL,
			(GClassInitFunc) scaled_value_class_init,
			NULL,
			NULL,
			sizeof (ScaledValue),
			0,
			(GInstanceInitFunc) scaled_value_init,
 
		};
 
/* Enregistre le type ScaledValue. Précise notamment que le type ScaledValue dérive de GTK_TYPE_FRAME,      */
/* ce qui permet d'utiliser toutes les propriétés de GtkFrame ainsi que celle des widgets dont dérive       */
/* GtkFrame, en particulier GtkContainer pour attacher le GtkEventBox et le GtkLabel au widget ScaledValue. */
 
		scaled_value_type = g_type_register_static (GTK_TYPE_FRAME, "ScaledValue", &scaled_value_info, 0);
 
/* Ajoute ScaledValueClassPrivate comme structure de données privée de la classe du widget ScaledValue. */
 
		g_type_add_class_private (scaled_value_type, sizeof (ScaledValueClassPrivate));
 
	}
 
	return scaled_value_type;
 
}
 
/* Crée une nouvelle instance du widget ScaledValue et renvoie un pointeur sur ce widget.   */
/* A la première instance, appelle la fonction scaled_value_class_Init (), puis à chaque    */
/* nouvelle instance (dont la première), appelle la fonction scaled_value_init ()           */
 
GtkWidget* scaled_value_new (guint value)
 
{
/* Déclaration des variables locales à la fonction. */
 
	ScaledValue *scaledvalue;
	ScaledValuePrivate *priv;
 
/* Crée effectivement le widget ScaledValue. */
 
	scaledvalue = SCALED_VALUE (g_object_new (scaled_value_get_type (), NULL));
 
/* A ce stade, la fonction scaled_value_init () a déjà été exécutée.   */
/* Notamment, le pointeur scaledvalue->priv a déjà été initialisé.     */
/* Récupère un pointeur sur la structure privée du widget ScaledValue. */
 
	priv = scaledvalue->priv;
 
/* Affecte la valeur du widget au curseur. */
 
	priv->value = value;
 
/* Initialise le label. */
 
	gtk_label_set_text (priv->label, g_strdup_printf ("%d%%", value));
 
	return GTK_WIDGET (scaledvalue);
 
}
 
/* Initialise la classe ScaledValueClass. */
 
static void scaled_value_class_init (ScaledValueClass *scaledvalueclass)
 
{
 
/* Déclaration des variables locales à la fonction. */
 
	ScaledValueClassPrivate *classpriv;
 
/* Initialise un pointeur statique sur les données privées du widget ScaledValue. */
 
	scaledvalueclass->classpriv = G_TYPE_CLASS_GET_PRIVATE (scaledvalueclass, SCALED_VALUE_TYPE, ScaledValueClassPrivate);
 
	classpriv = scaledvalueclass->classpriv;
 
/* Ajoute ScaledValuePrivate comme structure de données privée de chaque widget ScaledValue. */
 
	g_type_class_add_private (scaledvalueclass, sizeof (ScaledValuePrivate));
 
/* Enregistre le signal "value-changed" qui sera émis lorsque la valeur aura été changée. */
 
	scaled_value_signals [VALUE_CHANGED] = g_signal_new ("value-changed", G_TYPE_FROM_CLASS (scaledvalueclass),
							G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
							G_STRUCT_OFFSET (ScaledValueClass, value_changed),
							NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
 
/* Crée la fenêtre popup et l'objet GtkScale qu'elle contient. */
 
	classpriv->scale = GTK_SCALE (gtk_scale_new_with_range (GTK_ORIENTATION_VERTICAL, 0, 100, 1));
	classpriv->popup = GTK_WINDOW (gtk_window_new (GTK_WINDOW_POPUP));
 
/* Paramètre les widgets. */
 
	gtk_scale_set_draw_value (classpriv->scale, FALSE);
	gtk_range_set_inverted (GTK_RANGE (classpriv->scale), TRUE);
 
	gtk_range_set_value (GTK_RANGE (classpriv->scale), 50);
 
	gtk_window_set_decorated (classpriv->popup, FALSE);
	gtk_widget_set_size_request (GTK_WIDGET (classpriv->popup), 1, 140);
	gtk_window_set_resizable (classpriv->popup, FALSE);
 
/* Attache les objets les uns aux autres. */
 
	gtk_container_add (GTK_CONTAINER (classpriv->popup), GTK_WIDGET (classpriv->scale));
 
/* Rend le curseur visible dans la fenêtre popup. */
 
	gtk_widget_show (GTK_WIDGET (classpriv->scale));
 
/* Attache les fonctions de callback. */
 
	g_signal_connect (G_OBJECT (classpriv->popup), "enter-notify-event", G_CALLBACK (scaled_value_cb_enter_notify_popup), classpriv);
	g_signal_connect (G_OBJECT (classpriv->popup), "leave-notify-event", G_CALLBACK (scaled_value_cb_leave_notify_popup), classpriv);
 
	g_signal_connect (G_OBJECT (classpriv->scale), "value_changed", G_CALLBACK (scaled_value_cb_value_scale_changed), classpriv);
 
/* A ce moment, il n'y a pas de timeout actif. */
 
	classpriv->timeout_ref = 0;
 
}
 
/* Initialise le widget ScaledValue courant. Cette fonction est utilisée */
/* pour fixer la vue initiale du widget et les propriétés nécessaires.   */
 
static void scaled_value_init (ScaledValue *scaledvalue)
 
{
 
/* Déclaration des variables locales à la fonction. */
 
	ScaledValuePrivate *priv;
 
/* Initialise un pointeur statique sur les données privées du widget ScaledValue. */
 
	scaledvalue->priv = G_TYPE_INSTANCE_GET_PRIVATE (scaledvalue, SCALED_VALUE_TYPE, ScaledValuePrivate);
 
	priv = scaledvalue->priv;
 
/* Récupère un pointeur sur les données privées de la classe du widget ScaledValue. */
 
	priv->classpriv = G_TYPE_INSTANCE_GET_CLASS (scaledvalue, SCALED_VALUE_TYPE, ScaledValueClass)->classpriv;
 
/* Crée le Label et l'EventBox qui l'entoure. */
 
	priv->label = GTK_LABEL (gtk_label_new (NULL));
	priv->eventbox = GTK_EVENT_BOX (gtk_event_box_new ());
 
/* Paramètre les widgets. */
 
	gtk_label_set_width_chars (priv->label, 5);
	gtk_misc_set_alignment (GTK_MISC (priv->label), 1, .5);
 
/* Attache les objets les uns aux autres. */
 
	gtk_container_add (GTK_CONTAINER (priv->eventbox), GTK_WIDGET (priv->label));
	gtk_container_add (GTK_CONTAINER (scaledvalue), GTK_WIDGET (priv->eventbox));
 
/* Attache les fonctions de callback. */
 
	g_signal_connect (G_OBJECT (priv->eventbox), "enter-notify-event",
			G_CALLBACK (scaled_value_cb_enter_notify_eventbox), scaledvalue);
	g_signal_connect (G_OBJECT (priv->eventbox), "leave-notify-event",
			G_CALLBACK (scaled_value_cb_leave_notify_eventbox), priv->classpriv);
 
/* Affiche les widgets internes du widget ScaledValue. */
 
	gtk_widget_show (GTK_WIDGET (priv->label));
	gtk_widget_show (GTK_WIDGET (priv->eventbox));
 
}
 
/* Fixe la valeur du widget ScaledValue. */
 
void scaled_value_set_value (ScaledValue *scaledvalue, guint value)
 
{
 
/* Déclaration des variables locales à la fonction. */
 
	ScaledValuePrivate *priv;
 
/* Récupère un pointeur sur la structure privée du widget ScaledValue. */
 
	priv = scaledvalue->priv;
 
/* Fixe la valeur. */
 
	priv->value = value;
 
/* Met à jour le label. */
 
	gtk_label_set_text (priv->label, g_strdup_printf ("%d%%", value));
 
}
 
/* Rend la valeur du widget ScaledValue */
 
guint scaled_value_get_value (ScaledValue *scaledvalue)
 
{
 
	return scaledvalue->priv->value;
 
}
 
/****************************************************************************************************/
/* Fonctions de callback.                                                                           */
/****************************************************************************************************/
 
/* Fonction appelée lorsque le pointeur entre au dessus de l'eventbox. */
 
static gboolean scaled_value_cb_enter_notify_eventbox (GtkEventBox *eventbox, GdkEvent *event, ScaledValue *scaledvalue)
 
{
 
/* Déclaration des variables locales à la fonction. */
 
	ScaledValuePrivate * priv;
	ScaledValueClassPrivate *classpriv;
	GtkWindow *window;
	GtkAllocation allocation; /* Pas un pointeur ! */
	gint window_x, window_y, widget_x, widget_y;
 
/* Récupère les pointeurs sur les structures privées du widget ScaledValue et de sa classe. */
 
	priv = scaledvalue->priv;
	classpriv = priv->classpriv;
 
/* Référence l'instance courante du widget ScaledValue dans la structure de données de la classe. */
 
	classpriv->current_scaledvalue = scaledvalue;
 
/* Si un timeout est en cours pour le widget ScaledValue courant, on le stoppe. */
 
	if (classpriv->timeout_ref)
 
	{
 
		g_source_remove (classpriv->timeout_ref);
 
/* Efface la référence du timeout. */
 
		classpriv->timeout_ref = 0;
 
	}
 
/* Affecte la valeur du widget au curseur. */
 
	gtk_range_set_value (GTK_RANGE (classpriv->scale), (gdouble) priv->value);
 
/* Calcule la position du coin en haut et à droite du frame. */
 
	window = GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (scaledvalue)));
	gdk_window_get_position (gtk_widget_get_window (GTK_WIDGET (window)), &window_x, &window_y);
	gtk_widget_get_allocation (GTK_WIDGET (scaledvalue), &allocation);
	gtk_widget_translate_coordinates (GTK_WIDGET (scaledvalue), 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 (classpriv->popup, widget_x, widget_y);
 
/* affiche le popup. */
 
	gtk_widget_show (GTK_WIDGET (classpriv->popup));
 
	(void) event;
 
	return TRUE; /* Arrête la propagation de l'évènement. */
 
}
 
/* Fonction appelée lorsque le pointeur quitte l'eventbox. */
 
static gboolean scaled_value_cb_leave_notify_eventbox (GtkEventBox *eventbox, GdkEvent *event, ScaledValueClassPrivate *classpriv)
 
{
 
/* Lance le timeout (2 dixièmes de seconde) et enregistre sa référence. */
 
	classpriv->timeout_ref = g_timeout_add (200, (GSourceFunc) scaled_value_end_timeout, classpriv);
 
	(void) eventbox;
	(void) event;
 
	return TRUE; /* Arrête la propagation de l'évènement. */
 
}
 
/* Fonction appelée lorsque le pointeur entre au dessus du popup. */
 
static gboolean scaled_value_cb_enter_notify_popup (GtkWindow *popup, GdkEvent *event, ScaledValueClassPrivate *classpriv)
 
{
 
/* Arrête le timeout. */
 
	g_source_remove (classpriv->timeout_ref);
 
/* Efface la référence du timeout. */
 
	classpriv->timeout_ref = 0;
 
	(void) popup;
	(void) event;
 
	return TRUE; /* Arrête la propagation de l'évènement. */
 
}
 
/* Fonction appelée lorsque le pointeur quitte le popup. */
 
static gboolean scaled_value_cb_leave_notify_popup (GtkWindow *popup, GdkEvent *event, ScaledValueClassPrivate *classpriv)
 
{
 
/* Lance le timeout (2 dixièmes de seconde) et enregistre sa référence. */
 
	classpriv->timeout_ref = g_timeout_add (200, (GSourceFunc) scaled_value_end_timeout, classpriv);
 
	(void) event;
 
	return TRUE; /* Arrête la propagation de l'évènement. */
 
}
 
/* Fonction appelée lorsque la valeur contrôlée par le curseur change. */
 
static void scaled_value_cb_value_scale_changed (GtkRange *scale, ScaledValueClassPrivate *classpriv)
 
{
 
/* Déclaration des variables locales à la fonction. */
 
	ScaledValuePrivate *priv;
 
/* Récupère un pointeur sur la structure privée du widget ScaledValue. */
 
	priv = classpriv->current_scaledvalue->priv;
 
/* Aligne la valeur du widget et le label sur celle du curseur. */
 
	if (priv->value != (guint) gtk_range_get_value (scale))
 
	{
 
		priv->value = (guint) gtk_range_get_value (scale);
		gtk_label_set_text (priv->label, g_strdup_printf ("%d%%", priv->value));
 
/* Emet le signal "value-changed". */
 
		g_signal_emit_by_name (classpriv->current_scaledvalue, "value-changed");
 
	}
 
}
 
/* Fonction appelée à la fin du timeout. Masque le popup. */
 
static gboolean scaled_value_end_timeout (ScaledValueClassPrivate *classpriv)
 
{
 
/* Masque la fenêtre popup */
 
	gtk_widget_hide (GTK_WIDGET (classpriv->popup));
 
/* Efface la référence du timeout. */
 
	classpriv->timeout_ref = 0;
 
	return FALSE; /* Empèche le timeout de se relancer. */
 
}

Et enfin, un petit exemple d'utilisation :

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 <stdlib.h> /* Décaration de "EXIT_SUCCESS" */
#include <gtk/gtk.h>
 
#include "scaledvalue.h"
 
/* Prototypes de la fonction de callback */
 
static void cb_value_changed (ScaledValue *, guint *);
 
int main (int argc, char *argv[])
 
{
 
/* Déclaration des variables. */
 
	int i;
	guint values[12] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
 
/* Initialisation de GTK */
 
	gtk_init (&argc, &argv);
 
/* Déclaration des objets */
 
	GtkWindow *window;
	GtkGrid *grid;
	ScaledValue *scaledvalue1, *scaledvalue2, *scaledvalue3;
	ScaledValue *scaledvalue4, *scaledvalue5, *scaledvalue6;
	ScaledValue *scaledvalue7, *scaledvalue8, *scaledvalue9;
	ScaledValue *scaledvalue10, *scaledvalue11, *scaledvalue12;
 
/* Initialisation des objets */
 
	window = GTK_WINDOW (gtk_window_new (GTK_WINDOW_TOPLEVEL));
	grid = GTK_GRID (gtk_grid_new ());
	scaledvalue1 = SCALED_VALUE (scaled_value_new (values[0]));
	scaledvalue2 = SCALED_VALUE (scaled_value_new (values[1]));
	scaledvalue3 = SCALED_VALUE (scaled_value_new (values[2]));
	scaledvalue4 = SCALED_VALUE (scaled_value_new (values[3]));
	scaledvalue5 = SCALED_VALUE (scaled_value_new (values[4]));
	scaledvalue6 = SCALED_VALUE (scaled_value_new (values[5]));
	scaledvalue7 = SCALED_VALUE (scaled_value_new (values[6]));
	scaledvalue8 = SCALED_VALUE (scaled_value_new (values[7]));
	scaledvalue9 = SCALED_VALUE (scaled_value_new (values[8]));
	scaledvalue10 = SCALED_VALUE (scaled_value_new (values[9]));
	scaledvalue11 = SCALED_VALUE (scaled_value_new (values[10]));
	scaledvalue12 = SCALED_VALUE (scaled_value_new (values[11]));
 
/* Paramétrage des objets */
 
	gtk_window_set_title (window, "Mon exemple 4");
	gtk_container_set_border_width (GTK_CONTAINER (window), 10);
	gtk_widget_set_size_request (GTK_WIDGET (window), 300, 300);
 
	gtk_grid_set_row_spacing (grid, 0);
	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);
 
/* Attachement des objets les uns dans les autres */
 
	gtk_grid_attach (grid, GTK_WIDGET (scaledvalue1), 0 , 0, 1, 1);
	gtk_grid_attach_next_to (grid, GTK_WIDGET (scaledvalue2), GTK_WIDGET (scaledvalue1), GTK_POS_RIGHT, 1, 1);
	gtk_grid_attach_next_to (grid, GTK_WIDGET (scaledvalue3), GTK_WIDGET (scaledvalue2), GTK_POS_RIGHT, 1, 1);
	gtk_grid_attach_next_to (grid, GTK_WIDGET (scaledvalue4), GTK_WIDGET (scaledvalue1), GTK_POS_BOTTOM, 1, 1);
	gtk_grid_attach_next_to (grid, GTK_WIDGET (scaledvalue5), GTK_WIDGET (scaledvalue4), GTK_POS_RIGHT, 1, 1);
	gtk_grid_attach_next_to (grid, GTK_WIDGET (scaledvalue6), GTK_WIDGET (scaledvalue5), GTK_POS_RIGHT, 1, 1);
	gtk_grid_attach_next_to (grid, GTK_WIDGET (scaledvalue7), GTK_WIDGET (scaledvalue4), GTK_POS_BOTTOM, 1, 1);
	gtk_grid_attach_next_to (grid, GTK_WIDGET (scaledvalue8), GTK_WIDGET (scaledvalue7), GTK_POS_RIGHT, 1, 1);
	gtk_grid_attach_next_to (grid, GTK_WIDGET (scaledvalue9), GTK_WIDGET (scaledvalue8), GTK_POS_RIGHT, 1, 1);
	gtk_grid_attach_next_to (grid, GTK_WIDGET (scaledvalue10), GTK_WIDGET (scaledvalue7), GTK_POS_BOTTOM, 1, 1);
	gtk_grid_attach_next_to (grid, GTK_WIDGET (scaledvalue11), GTK_WIDGET (scaledvalue10), GTK_POS_RIGHT, 1, 1);
	gtk_grid_attach_next_to (grid, GTK_WIDGET (scaledvalue12), GTK_WIDGET (scaledvalue11), GTK_POS_RIGHT, 1, 1);
 
	gtk_container_add (GTK_CONTAINER (window), GTK_WIDGET (grid));
 
/* Déclaration des fonctions de callback */
 
	g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (gtk_main_quit), NULL);
 
	g_signal_connect (G_OBJECT (scaledvalue1), "value-changed", G_CALLBACK (cb_value_changed), &values[0]);
	g_signal_connect (G_OBJECT (scaledvalue2), "value-changed", G_CALLBACK (cb_value_changed), &values[1]);
	g_signal_connect (G_OBJECT (scaledvalue3), "value-changed", G_CALLBACK (cb_value_changed), &values[2]);
	g_signal_connect (G_OBJECT (scaledvalue4), "value-changed", G_CALLBACK (cb_value_changed), &values[3]);
	g_signal_connect (G_OBJECT (scaledvalue5), "value-changed", G_CALLBACK (cb_value_changed), &values[4]);
	g_signal_connect (G_OBJECT (scaledvalue6), "value-changed", G_CALLBACK (cb_value_changed), &values[5]);
	g_signal_connect (G_OBJECT (scaledvalue7), "value-changed", G_CALLBACK (cb_value_changed), &values[6]);
	g_signal_connect (G_OBJECT (scaledvalue8), "value-changed", G_CALLBACK (cb_value_changed), &values[7]);
	g_signal_connect (G_OBJECT (scaledvalue9), "value-changed", G_CALLBACK (cb_value_changed), &values[8]);
	g_signal_connect (G_OBJECT (scaledvalue10), "value-changed", G_CALLBACK (cb_value_changed), &values[9]);
	g_signal_connect (G_OBJECT (scaledvalue11), "value-changed", G_CALLBACK (cb_value_changed), &values[10]);
	g_signal_connect (G_OBJECT (scaledvalue12), "value-changed", G_CALLBACK (cb_value_changed), &values[11]);
 
/* Affiche les widgets */
 
	gtk_widget_show_all (GTK_WIDGET (window));
 
/* Et c'est parti ! */
 
	gtk_main ();
 
/* Affiche les valeurs dans la console... Pour voir. */
 
	for (i = 0; i < 12; i++)
 
	{
 
		g_print ("%d\n", values[i]);
 
	}
 
/* Et c'est fini ! */
 
	return EXIT_SUCCESS;
 
}
 
static void cb_value_changed (ScaledValue *scaledvalue, guint *value)
 
{
 
/* récupère la valeur du curseur et la recopie dans le label */
 
	*value = scaled_value_get_value (scaledvalue);
 
}

Jean-Marie