Discussion :

[diesel83]

Bonsoir,

Qui peut me dire comment capturer le pointeur de la souris dans un widget ?.

La capture serait activée suite à un clic gauche de la souris alors que le pointeur de la souris serait sur le widget. Tant que le bouton gauche de la souris resterait appuyé, les événements de position de la souris ne seraient adressés qu'à mon widget. Dès que le bouton gauche de la souris serait relâché, le pointeur serait libéré et le comportement redeviendrait "normal".

Jean-Marie

[pvincent]

Il me semble qu'il y a eu une discussion sur ce forum pour savoir si on pouvait commander la position du pointeur de la souris par programme et si je me souviens bien, la réponse est NON, car il est assez déroutant pour l'utilisateur de voir celui-ci se balader sur l'écran sans qu'il ne bouge le mulot.

Par contre, si tu veux détecter la position du pointeur et l'état des touches de la souris, il faut écrire un "event handler" connecté au signaux définis pour GtkWidget comme par exemple
“key-press-event” (https://developer.gnome.org/gtk3/sta...ey-press-event)
ou “motion-notify-event”
et exploiter les données disponibles dans la structure correspondante
par exemple GdkEventMotion (https://developer.gnome.org/gdk3/sta...GdkEventMotion)

Tu dois pouvoir trouver des exemples sur le net.

[diesel83]

Merci pour la réponse, mais ce n'est exactement la question qui était posée.

Je sais me connecter aux évènements pour détecter l'appui sur un bouton ou le relâcher, ainsi qu'être prévenu des déplacements du pointeur.

Ce que je veux, c'est continuer à être prévenu même si le pointeur sort du widget (tant que le bouton gauche de la souris reste appuyé).

Un peu l'équivalent du focus pour ce qui est de la saisie clavier.

Jean-Marie

[gerald3d]

Bonjour.

Sans avoir essayé je partirais de ce principe.

Si tu désires connaître la position de la souris en dehors d'un widget, il te faut capturer sa position sur tout l'écran. Il te faut donc récupérer la fenêtre root. J'utiliserais à cette fin la fonction GdkWindow *gdk_get_default_root_window (void);.
On peut à partir de maintenant ajouter l'écouteur GDK_POINTER_MOTION_MASK avec la fonction void gdk_window_set_events (GdkWindow *window, GdkEventMask event_mask);.

Il ne reste plus qu'à connecter un callback à cet écouteur avec la fonction g_signal_connect();. Vu que les GdkWindow héritent directement des GObject ca ne devrait pas poser de problème.

J'insiste sur le fait que je n'ai jamais tenté ce genre d'opération. Ce n'est qu'une idée à creuser...

[diesel83]

Bonsoir Gérald3d,

Merci pour ta réponse.

Je vais utiliser ces éléments dans google et j'espère bien y trouver une réponse définitive.

C'est par exemple comme ça que fonctionne le widget GtkScale. J'ai regardé le code, mais il est vraiment très compliqué (et dépend de tout un tas d'autres fichiers). Au moins, ça démontre que c'est possible.

Jean-Marie

[pvincent]

Effectivement, je n'avais pas compris ton problème.

J'ai essayé de voir se qui se passe sous GTK+-2 (Linux), et au moins dans ce cas, il semble qu'il n'y a rien de particulier à faire: tant que le bouton de la souris reste enfoncé, le handler continue de recevoir les coordonnées du pointeur et c'est seulement quand je relâche le bouton que le widget je perd le focus, ou plutôt qu'un nouveau clic me le fait perdre.
J'ai ainsi testé avec Gimp en selectionnant un rectangle et GraceGTK.

Avec les version récentes de Gimp, comme le GC XOR à disparu, le test peut ne pas être significatif car ils ont dû bidouiller pour obtenir un comportement équivalent et GraceGTK n'est pas encore près à passer à GTK+-3.

Ceci peut faire penser que si ça ne marche pas chez toi comme tu le souhaite, c'est peut être simplement une question de choix pour le mode de fonctionnement du focus: c'est peut être une piste à suivre.

[gerald3d]

Bonsoir tout le monde.

Ce post commence à dater mais j'ai bricoler une solution qui pourrait intéresser certains d'entre-vous. Je vous la livre en pature.

Ce code crée une fenêtre avec une grille dans laquelle j'affiche en temps réel les coordonnées de la souris. L'intérêt ici est de disposer des coordonnées écran de la souris, et non des coordonnées à l'intérieur de la fenêtre/widget créé(e).


À vos commentaires/questions...

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
#include <stdlib.h>
#include <gtk/gtk.h>
 
typedef struct
{
  GtkWidget *coordx, *coordy;
} SCoord;
 
gboolean
g_callback_draw (GtkWidget    *widget, cairo_t *cr, SCoord *coord)
{
  GdkWindow *root = NULL;
  gint x, y;
 
  // Récupération de la fenêtre root
  root = gdk_get_default_root_window ();
  if (root==NULL) g_printerr ("root = NULL !!!");
 
  // Récupération de la souris
  GdkDevice *pointer = gdk_device_manager_get_client_pointer (gdk_display_get_device_manager (gdk_window_get_display (root)));
 
  // Récupération des coordonnées de la souris
  gdk_window_get_device_position (root, pointer, &x, &y, NULL);
 
  // MAJ des GtkLabel pour affichage des coordonnées
  gchar *text_x = g_strdup_printf("%d", x);
  gchar *text_y = g_strdup_printf("%d", y);
  gtk_label_set_text (GTK_LABEL (coord->coordx), text_x);
  gtk_label_set_text (GTK_LABEL (coord->coordy), text_y);
  g_free(text_x);
  g_free(text_y);
 
  return FALSE;
}
 
int
main(int argc, char** argv)
{
  GtkWidget *window = NULL;
  GtkWidget *grid = NULL;
  GtkWidget *label = NULL;
  SCoord coord;
 
  // Initialisation gtk
  gtk_init(&argc, &argv);
 
  // Creation fenetre
  window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  gtk_window_set_title(GTK_WINDOW(window), "Test capture évènements souris");
  gtk_window_set_default_size(GTK_WINDOW(window), 400, 200);
  gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER_ALWAYS);
 
  // Connexion du signal "delete-event" pour fermer l'application
  g_signal_connect(G_OBJECT(window), "delete-event", G_CALLBACK(gtk_main_quit), NULL);
 
  // Création d'une grille pour afficher les coordonnées de la souris en temps réel.
  grid = gtk_grid_new ();
  gtk_container_add (GTK_CONTAINER(window), grid);
 
  label = gtk_label_new ("coordonnées souris :");
  gtk_grid_attach (GTK_GRID(grid), label, 0, 0, 4, 1);
  label = gtk_label_new (",");
  gtk_grid_attach (GTK_GRID(grid), label, 1, 1, 1, 1);
 
  coord.coordx = gtk_label_new ("0");
  gtk_grid_attach (GTK_GRID(grid), coord.coordx, 0, 1, 1, 1);
 
  coord.coordy = gtk_label_new ("0");
  gtk_grid_attach (GTK_GRID(grid), coord.coordy, 2, 1, 1, 1);
 
  // Connexion du signal "draw". Dans ce callback on va pouvoir accéder à la fenêtre root
  g_signal_connect(G_OBJECT(window), "draw", G_CALLBACK(g_callback_draw), &coord);
 
  // Affichage de tout
  gtk_widget_show_all(window);
 
  gtk_main();
 
  return EXIT_SUCCESS;
}

[diesel83]

Bonsoir,

J'ai trouvé.

Il faut attacher au widget GtkDrawingArea les événements "button-press-event" et "motion-notify-event". Ainsi, lorsque le bouton gauche de la souris reste appuyé, le widget continue à recevoir les événements de mouvement de la souris, même si le pointeur "sort" du widget.

Pour le démontrer, j'ai écrit le petit programme dont le listing suit qui trace des lignes à partir du coin en haut à gauche de la fenêtre. Pour vérifier la fonctionnalité, il suffit, en maintenant le bouton gauche de la souris, de "sortir du cadre". Les lignes continuent à se tracer.

L'attachement des événements est fait à la ligne 241.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
#include <stdlib.h>
#include <gtk/gtk.h>
 
/* Prototypes des fonctions */
 
static void clear_surface (void);
static void draw_brush (GtkWidget *, gdouble, gdouble);
 
/* Prototypes des fonctions de callback */
 
static void cb_close_window (void);
static gboolean cb_configure_event (GtkWidget *, GdkEventConfigure *, gpointer);
static gboolean cb_draw (GtkWidget *, cairo_t *, gpointer);
static gboolean cb_button_press_event (GtkWidget *, GdkEventButton *, gpointer);
static gboolean cb_motion_notify_event (GtkWidget *, GdkEventMotion *, gpointer);
 
/* La surface sur laquelle on va dessiner (en mémoire, pas à l'affichage) */
 
static cairo_surface_t *surface = NULL;
 
/**************************************************************************************************/
/* Fonctions de dessin                                                                            */
/**************************************************************************************************/
 
static void clear_surface (void)
 
{
 
	cairo_t *ct;
 
/* Associe le contexte cairo avec la surface en mémoire */
 
	ct = cairo_create (surface);
 
/* Sélectionne une couleur blanche */
 
	cairo_set_source_rgb (ct, 1, 1, 1);
 
/* remplit la surface en mémoire */
 
	cairo_paint (ct);
 
/* Libère le contexte cairo */
 
	cairo_destroy (ct);
 
/* La mise en file du signal "draw" pour recopier le contenu de la surface en mémoire sur le */
/* DrawingArea est faite par la fonction appelante */
 
}
 
static void draw_brush (GtkWidget *drawingarea, gdouble x, gdouble y)
 
{
 
	cairo_t *ct;
 
	ct = cairo_create (surface);
 
/* Sélectionne une couleur bleue */
 
	cairo_set_source_rgb (ct, 0, 0, 1);
 
/* Dessine un trait du coin en haut à gauche de la surface jusqu'à la position du pointeur */
 
	cairo_set_line_width (ct, 0.5);
	cairo_move_to (ct, 0, 0);
	cairo_line_to (ct, x, y);
 
	cairo_stroke (ct);
 
	cairo_destroy (ct);
 
/* Récupère le contexte du DrawingArea */
 
	ct = gdk_cairo_create (gtk_widget_get_window (drawingarea));
 
/* Sélectionne une couleur bleue */
 
	cairo_set_source_rgb (ct, 0, 0, 1);
 
/* Dessine un trait du coin en haut à gauche de la surface jusqu'à la position du pointeur */
 
	cairo_set_line_width (ct, 0.5);
	cairo_move_to (ct, 0, 0);
	cairo_line_to (ct, x, y);
 
	cairo_stroke (ct);
 
	cairo_destroy (ct);
 
}
 
/**************************************************************************************************/
/* Fonctions de callback                                                                          */
/**************************************************************************************************/
 
static void cb_close_window (void)
 
{
 
/* Si la surface de dessin existe en mémoire, on la détruit */
 
	if (surface) cairo_surface_destroy (surface);
 
	gtk_main_quit ();
 
}
 
/* fonction exécutée notamment si la fenêtre de l'application est redimensionnée */
/* et au lancement de l'application */
 
static gboolean cb_configure_event (GtkWidget *drawingarea, GdkEventConfigure *event, gpointer user_data)
 
{
 
/* Si la surface de dessin existe en mémoire, on la détruit */
 
	if (surface) cairo_surface_destroy (surface);
 
/* Initialise la surface de dessin en mémoire avec les paramètres du DrawingArea */
 
	surface = gdk_window_create_similar_surface (gtk_widget_get_window (drawingarea), CAIRO_CONTENT_COLOR,
				gtk_widget_get_allocated_width (drawingarea), gtk_widget_get_allocated_height (drawingarea));
 
/* et la remplit en blanc */
 
	clear_surface ();
 
	(void) user_data;
 
	return TRUE;
 
}
 
static gboolean cb_draw (GtkWidget *drawingarea, cairo_t *ct, gpointer user_data)
 
{
 
/* Crée un pattern à partir de l'ensemble de la surface en mémoire */
 
	cairo_set_source_surface (ct, surface, 0, 0);
 
/* remplit la partie du DrawingArea à peindre avec ce pattern */
 
	cairo_paint (ct);
 
	(void) user_data;
 
	return FALSE;
 
}
 
static gboolean cb_button_press_event (GtkWidget *drawingarea, GdkEventButton *event, gpointer user_data)
 
{
 
	if (!surface) return FALSE;
 
/* Appui sur le bouton de gauche, on dessine une droite */
 
	if (event->button == GDK_BUTTON_PRIMARY) draw_brush (drawingarea, event->x, event->y);
 
/* Appui sur le bouton de droite, on efface le dessin */
 
	else if (event->button == GDK_BUTTON_SECONDARY)
 
	{
 
		clear_surface ();
 
/* génère le signal "draw" avec comme paramètre la surface totale du DrawingArea */
 
		gtk_widget_queue_draw (drawingarea);
 
	}
 
	(void) user_data;
 
	return TRUE;
 
}
 
static gboolean cb_motion_notify_event (GtkWidget *drawingarea, GdkEventMotion *event, gpointer user_data)
 
{
 
	if (!surface) return FALSE;
 
/* Si le pointeur de la souris a bougé et si le bouton de gauche est encore appuyé, on dessine une droite */
 
	if (event->state & GDK_BUTTON1_MASK) draw_brush (drawingarea, event->x, event->y);
 
	(void) user_data;
 
	return TRUE;
 
}
 
int main (int argc, char *argv[])
 
{
 
/* Déclaration des pointeurs sur les widgets */
 
	GtkWindow *window;
	GtkFrame *frame;
	GtkWidget *drawingarea;
 
/* Initialisation de gtk+ */
 
	gtk_init (&argc, &argv);
 
/* Création des widgets */
 
	window = GTK_WINDOW (gtk_window_new (GTK_WINDOW_TOPLEVEL));
	frame = GTK_FRAME (gtk_frame_new (NULL));
	drawingarea = gtk_drawing_area_new ();
 
/* Configuration des widgets */
 
	gtk_window_set_title (window, "Lines");
	gtk_container_set_border_width (GTK_CONTAINER (window), 8);
	gtk_frame_set_shadow_type (frame, GTK_SHADOW_IN);
	gtk_widget_set_size_request (drawingarea, 500, 500);
 
/* Intégration des widgets les uns dans les autres */
 
	gtk_container_add (GTK_CONTAINER (window), GTK_WIDGET (frame));
	gtk_container_add (GTK_CONTAINER (frame), drawingarea);
 
/* Attachement des fonctions de callback */
 
	g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (cb_close_window), NULL);
 
	g_signal_connect (drawingarea, "configure-event", G_CALLBACK (cb_configure_event), NULL);
	g_signal_connect (drawingarea, "draw", G_CALLBACK (cb_draw), NULL);
 
/* Ajoute les évènements "appui sur un bouton de la souris" et "déplacement de la souris" aux évènements auxquels réagit le widget drawingarea */
 
	gtk_widget_set_events (drawingarea, gtk_widget_get_events (drawingarea) | GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK);
 
	g_signal_connect (drawingarea, "button-press-event", G_CALLBACK (cb_button_press_event), NULL);
	g_signal_connect (drawingarea, "motion-notify-event", G_CALLBACK (cb_motion_notify_event), NULL);
 
/* On affiche le tout */
 
	gtk_widget_show_all (GTK_WIDGET (window));
 
/* Et c'est parti ! */
 
	gtk_main ();
 
	return EXIT_SUCCESS;
 
}

Merci pour les réponses qui m'ont été fournies.

Jean-Marie