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.