Debian Codegraph @

testsuite/gtk/gestures.c

raw
1 #include <gtk/gtk.h>
2
3 typedef struct {
4 GtkWidget *widget;
5 gint x;
6 gint y;
7 guint state;
8 guint pressed : 1;
9 } PointState;
10
11 static PointState mouse_state;
12 static PointState touch_state[10]; /* touchpoint 0 gets pointer emulation,
13 * use it first in tests for consistency.
14 */
15
16 #define EVENT_SEQUENCE(point) (GdkEventSequence*) ((point) - touch_state + 1)
17
18 static void
19 point_press (PointState *point,
20 GtkWidget *widget,
21 guint button)
22 {
23 GdkDisplay *display;
24 GdkDevice *device;
25 GdkSeat *seat;
26 GdkEvent *ev;
27
28 display = gtk_widget_get_display (widget);
29 seat = gdk_display_get_default_seat (display);
30 device = gdk_seat_get_pointer (seat);
31
32 if (point == &mouse_state)
33 {
34 ev = gdk_event_new (GDK_BUTTON_PRESS);
35 ev->any.window = g_object_ref (gtk_widget_get_window (widget));
36 ev->button.time = GDK_CURRENT_TIME;
37 ev->button.x = point->x;
38 ev->button.y = point->y;
39 ev->button.button = button;
40 ev->button.state = point->state;
41
42 point->state |= GDK_BUTTON1_MASK << (button - 1);
43 }
44 else
45 {
46 ev = gdk_event_new (GDK_TOUCH_BEGIN);
47 ev->any.window = g_object_ref (gtk_widget_get_window (widget));
48 ev->touch.time = GDK_CURRENT_TIME;
49 ev->touch.x = point->x;
50 ev->touch.y = point->y;
51 ev->touch.sequence = EVENT_SEQUENCE (point);
52
53 if (point == &touch_state[0])
54 ev->touch.emulating_pointer = TRUE;
55 }
56
57 gdk_event_set_device (ev, device);
58
59 gtk_main_do_event (ev);
60
61 gdk_event_free (ev);
62
63 point->widget = widget;
64 }
65
66 static void
67 point_update (PointState *point,
68 GtkWidget *widget,
69 gdouble x,
70 gdouble y)
71 {
72 GdkDisplay *display;
73 GdkDevice *device;
74 GdkSeat *seat;
75 GdkEvent *ev;
76
77 display = gtk_widget_get_display (widget);
78 seat = gdk_display_get_default_seat (display);
79 device = gdk_seat_get_pointer (seat);
80
81 point->x = x;
82 point->y = y;
83
84 if (point == &mouse_state)
85 {
86 ev = gdk_event_new (GDK_MOTION_NOTIFY);
87 ev->any.window = g_object_ref (gtk_widget_get_window (widget));
88 ev->button.time = GDK_CURRENT_TIME;
89 ev->motion.x = x;
90 ev->motion.y = y;
91 ev->motion.state = point->state;
92 }
93 else
94 {
95 if (!point->widget || widget != point->widget)
96 return;
97
98 ev = gdk_event_new (GDK_TOUCH_UPDATE);
99 ev->any.window = g_object_ref (gtk_widget_get_window (widget));
100 ev->touch.time = GDK_CURRENT_TIME;
101 ev->touch.x = x;
102 ev->touch.y = y;
103 ev->touch.sequence = EVENT_SEQUENCE (point);
104 ev->touch.state = 0;
105
106 if (point == &touch_state[0])
107 ev->touch.emulating_pointer = TRUE;
108 }
109
110 gdk_event_set_device (ev, device);
111
112 gtk_main_do_event (ev);
113
114 gdk_event_free (ev);
115 }
116
117 static void
118 point_release (PointState *point,
119 guint button)
120 {
121 GdkDisplay *display;
122 GdkDevice *device;
123 GdkSeat *seat;
124 GdkEvent *ev;
125
126 if (point->widget == NULL)
127 return;
128
129 display = gtk_widget_get_display (point->widget);
130 seat = gdk_display_get_default_seat (display);
131 device = gdk_seat_get_pointer (seat);
132
133 if (!point->widget)
134 return;
135
136 if (point == &mouse_state)
137 {
138 if ((point->state & (GDK_BUTTON1_MASK << (button - 1))) == 0)
139 return;
140
141 ev = gdk_event_new (GDK_BUTTON_RELEASE);
142 ev->any.window = g_object_ref (gtk_widget_get_window (point->widget));
143 ev->button.time = GDK_CURRENT_TIME;
144 ev->button.x = point->x;
145 ev->button.y = point->y;
146 ev->button.state = point->state;
147
148 point->state &= ~(GDK_BUTTON1_MASK << (button - 1));
149 }
150 else
151 {
152 ev = gdk_event_new (GDK_TOUCH_END);
153 ev->any.window = g_object_ref (gtk_widget_get_window (point->widget));
154 ev->touch.time = GDK_CURRENT_TIME;
155 ev->touch.x = point->x;
156 ev->touch.y = point->y;
157 ev->touch.sequence = EVENT_SEQUENCE (point);
158 ev->touch.state = point->state;
159
160 if (point == &touch_state[0])
161 ev->touch.emulating_pointer = TRUE;
162 }
163
164 gdk_event_set_device (ev, device);
165
166 gtk_main_do_event (ev);
167
168 gdk_event_free (ev);
169 }
170
171 static const gchar *
172 phase_nick (GtkPropagationPhase phase)
173 {
174 GTypeClass *class;
175 GEnumValue *value;
176
177 class = g_type_class_ref (GTK_TYPE_PROPAGATION_PHASE);
178 value = g_enum_get_value ((GEnumClass*)class, phase);
179 g_type_class_unref (class);
180
181 return value->value_nick;
182 }
183
184 static const gchar *
185 state_nick (GtkEventSequenceState state)
186 {
187 GTypeClass *class;
188 GEnumValue *value;
189
190 class = g_type_class_ref (GTK_TYPE_EVENT_SEQUENCE_STATE);
191 value = g_enum_get_value ((GEnumClass*)class, state);
192 g_type_class_unref (class);
193
194 return value->value_nick;
195 }
196
197 typedef struct {
198 GString *str;
199 gboolean exit;
200 } LegacyData;
201
202 static gboolean
203 legacy_cb (GtkWidget *w, GdkEventButton *button, gpointer data)
204 {
205 LegacyData *ld = data;
206
207 if (ld->str->len > 0)
208 g_string_append (ld->str, ", ");
209 g_string_append_printf (ld->str, "legacy %s", gtk_widget_get_name (w));
210
211 return ld->exit;
212 }
213
214 typedef struct {
215 GString *str;
216 GtkEventSequenceState state;
217 } GestureData;
218
219 static void
220 press_cb (GtkGesture *g, gint n_press, gdouble x, gdouble y, gpointer data)
221 {
222 GtkEventController *c = GTK_EVENT_CONTROLLER (g);
223 GdkEventSequence *sequence;
224 GtkPropagationPhase phase;
225 GestureData *gd = data;
226 const gchar *name;
227
228 name = g_object_get_data (G_OBJECT (g), "name");
229 phase = gtk_event_controller_get_propagation_phase (c);
230
231 if (gd->str->len > 0)
232 g_string_append (gd->str, ", ");
233 g_string_append_printf (gd->str, "%s %s", phase_nick (phase), name);
234
235 sequence = gtk_gesture_get_last_updated_sequence (g);
236
237 if (sequence)
238 g_string_append_printf (gd->str, " (%x)", GPOINTER_TO_UINT (sequence));
239
240 if (gd->state != GTK_EVENT_SEQUENCE_NONE)
241 gtk_gesture_set_state (g, gd->state);
242 }
243
244 static void
245 cancel_cb (GtkGesture *g, GdkEventSequence *sequence, gpointer data)
246 {
247 GestureData *gd = data;
248 const gchar *name;
249
250 name = g_object_get_data (G_OBJECT (g), "name");
251
252 if (gd->str->len > 0)
253 g_string_append (gd->str, ", ");
254 g_string_append_printf (gd->str, "%s cancelled", name);
255 }
256
257 static void
258 begin_cb (GtkGesture *g, GdkEventSequence *sequence, gpointer data)
259 {
260 GestureData *gd = data;
261 const gchar *name;
262
263 name = g_object_get_data (G_OBJECT (g), "name");
264
265 if (gd->str->len > 0)
266 g_string_append (gd->str, ", ");
267 g_string_append_printf (gd->str, "%s began", name);
268
269 if (gd->state != GTK_EVENT_SEQUENCE_NONE)
270 gtk_gesture_set_state (g, gd->state);
271 }
272
273 static void
274 end_cb (GtkGesture *g, GdkEventSequence *sequence, gpointer data)
275 {
276 GestureData *gd = data;
277 const gchar *name;
278
279 name = g_object_get_data (G_OBJECT (g), "name");
280
281 if (gd->str->len > 0)
282 g_string_append (gd->str, ", ");
283 g_string_append_printf (gd->str, "%s ended", name);
284 }
285
286 static void
287 update_cb (GtkGesture *g, GdkEventSequence *sequence, gpointer data)
288 {
289 GestureData *gd = data;
290 const gchar *name;
291
292 name = g_object_get_data (G_OBJECT (g), "name");
293
294 if (gd->str->len > 0)
295 g_string_append (gd->str, ", ");
296 g_string_append_printf (gd->str, "%s updated", name);
297 }
298
299 static void
300 state_changed_cb (GtkGesture *g, GdkEventSequence *sequence, GtkEventSequenceState state, gpointer data)
301 {
302 GestureData *gd = data;
303 const gchar *name;
304
305 name = g_object_get_data (G_OBJECT (g), "name");
306
307 if (gd->str->len > 0)
308 g_string_append (gd->str, ", ");
309 g_string_append_printf (gd->str, "%s state %s", name, state_nick (state));
310
311 if (sequence != NULL)
312 g_string_append_printf (gd->str, " (%x)", GPOINTER_TO_UINT (sequence));
313 }
314
315
316 static GtkGesture *
317 add_gesture (GtkWidget *w, const gchar *name, GtkPropagationPhase phase, GString *str, GtkEventSequenceState state)
318 {
319 GtkGesture *g;
320 GestureData *data;
321
322 data = g_new (GestureData, 1);
323 data->str = str;
324 data->state = state;
325
326 g = gtk_gesture_multi_press_new (w);
327 gtk_gesture_single_set_touch_only (GTK_GESTURE_SINGLE (g), FALSE);
328 gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (g), 1);
329 gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (g), phase);
330
331 g_object_set_data (G_OBJECT (g), "name", (gpointer)name);
332
333 g_signal_connect (g, "pressed", G_CALLBACK (press_cb), data);
334 g_signal_connect (g, "cancel", G_CALLBACK (cancel_cb), data);
335 g_signal_connect (g, "update", G_CALLBACK (update_cb), data);
336 g_signal_connect (g, "sequence-state-changed", G_CALLBACK (state_changed_cb), data);
337
338 return g;
339 }
340
341 static GtkGesture *
342 add_mt_gesture (GtkWidget *w, const gchar *name, GtkPropagationPhase phase, GString *str, GtkEventSequenceState state)
343 {
344 GtkGesture *g;
345 GestureData *data;
346
347 data = g_new (GestureData, 1);
348 data->str = str;
349 data->state = state;
350
351 g = gtk_gesture_rotate_new (w);
352 gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (g), phase);
353
354 g_object_set_data (G_OBJECT (g), "name", (gpointer)name);
355
356 g_signal_connect (g, "begin", G_CALLBACK (begin_cb), data);
357 g_signal_connect (g, "update", G_CALLBACK (update_cb), data);
358 g_signal_connect (g, "end", G_CALLBACK (end_cb), data);
359 g_signal_connect (g, "sequence-state-changed", G_CALLBACK (state_changed_cb), data);
360
361 return g;
362 }
363
364 static void
365 add_legacy (GtkWidget *w, GString *str, gboolean exit)
366 {
367 LegacyData *data;
368
369 data = g_new (LegacyData, 1);
370 data->str = str;
371 data->exit = exit;
372 g_signal_connect (w, "button-press-event", G_CALLBACK (legacy_cb), data);
373 }
374
375 static void
376 test_phases (void)
377 {
378 GtkWidget *A, *B, *C;
379 GString *str;
380
381 A = gtk_window_new (GTK_WINDOW_TOPLEVEL);
382 gtk_widget_set_name (A, "A");
383 B = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
384 gtk_widget_set_name (B, "B");
385 C = gtk_event_box_new ();
386 gtk_widget_set_hexpand (C, TRUE);
387 gtk_widget_set_vexpand (C, TRUE);
388 gtk_widget_set_name (C, "C");
389
390 gtk_container_add (GTK_CONTAINER (A), B);
391 gtk_container_add (GTK_CONTAINER (B), C);
392
393 gtk_widget_show_all (A);
394
395 str = g_string_new ("");
396
397 add_gesture (A, "a1", GTK_PHASE_CAPTURE, str, GTK_EVENT_SEQUENCE_NONE);
398 add_gesture (B, "b1", GTK_PHASE_CAPTURE, str, GTK_EVENT_SEQUENCE_NONE);
399 add_gesture (C, "c1", GTK_PHASE_CAPTURE, str, GTK_EVENT_SEQUENCE_NONE);
400 add_gesture (A, "a2", GTK_PHASE_TARGET, str, GTK_EVENT_SEQUENCE_NONE);
401 add_gesture (B, "b2", GTK_PHASE_TARGET, str, GTK_EVENT_SEQUENCE_NONE);
402 add_gesture (C, "c2", GTK_PHASE_TARGET, str, GTK_EVENT_SEQUENCE_NONE);
403 add_gesture (A, "a3", GTK_PHASE_BUBBLE, str, GTK_EVENT_SEQUENCE_NONE);
404 add_gesture (B, "b3", GTK_PHASE_BUBBLE, str, GTK_EVENT_SEQUENCE_NONE);
405 add_gesture (C, "c3", GTK_PHASE_BUBBLE, str, GTK_EVENT_SEQUENCE_NONE);
406
407 point_update (&mouse_state, C, 10, 10);
408 point_press (&mouse_state, C, 1);
409
410 g_assert_cmpstr (str->str, ==,
411 "capture a1, "
412 "capture b1, "
413 "capture c1, "
414 "target c2, "
415 "bubble c3, "
416 "bubble b3, "
417 "bubble a3");
418
419 g_string_free (str, TRUE);
420
421 gtk_widget_destroy (A);
422 }
423
424 static void
425 test_mixed (void)
426 {
427 GtkWidget *A, *B, *C;
428 GString *str;
429
430 A = gtk_window_new (GTK_WINDOW_TOPLEVEL);
431 gtk_widget_set_name (A, "A");
432 B = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
433 gtk_widget_set_name (B, "B");
434 C = gtk_event_box_new ();
435 gtk_widget_set_hexpand (C, TRUE);
436 gtk_widget_set_vexpand (C, TRUE);
437 gtk_widget_set_name (C, "C");
438
439 gtk_container_add (GTK_CONTAINER (A), B);
440 gtk_container_add (GTK_CONTAINER (B), C);
441
442 gtk_widget_show_all (A);
443
444 str = g_string_new ("");
445
446 add_gesture (A, "a1", GTK_PHASE_CAPTURE, str, GTK_EVENT_SEQUENCE_NONE);
447 add_gesture (B, "b1", GTK_PHASE_CAPTURE, str, GTK_EVENT_SEQUENCE_NONE);
448 add_gesture (C, "c1", GTK_PHASE_CAPTURE, str, GTK_EVENT_SEQUENCE_NONE);
449 add_gesture (A, "a2", GTK_PHASE_TARGET, str, GTK_EVENT_SEQUENCE_NONE);
450 add_gesture (B, "b2", GTK_PHASE_TARGET, str, GTK_EVENT_SEQUENCE_NONE);
451 add_gesture (C, "c2", GTK_PHASE_TARGET, str, GTK_EVENT_SEQUENCE_NONE);
452 add_gesture (A, "a3", GTK_PHASE_BUBBLE, str, GTK_EVENT_SEQUENCE_NONE);
453 add_gesture (B, "b3", GTK_PHASE_BUBBLE, str, GTK_EVENT_SEQUENCE_NONE);
454 add_gesture (C, "c3", GTK_PHASE_BUBBLE, str, GTK_EVENT_SEQUENCE_NONE);
455
456 add_legacy (A, str, GDK_EVENT_PROPAGATE);
457 add_legacy (B, str, GDK_EVENT_PROPAGATE);
458 add_legacy (C, str, GDK_EVENT_PROPAGATE);
459
460 point_update (&mouse_state, C, 10, 10);
461 point_press (&mouse_state, C, 1);
462
463 g_assert_cmpstr (str->str, ==,
464 "capture a1, "
465 "capture b1, "
466 "capture c1, "
467 "target c2, "
468 "legacy C, "
469 "bubble c3, "
470 "legacy B, "
471 "bubble b3, "
472 "legacy A, "
473 "bubble a3");
474
475 g_string_free (str, TRUE);
476
477 gtk_widget_destroy (A);
478 }
479
480 static void
481 test_early_exit (void)
482 {
483 GtkWidget *A, *B, *C;
484 GString *str;
485
486 A = gtk_window_new (GTK_WINDOW_TOPLEVEL);
487 gtk_widget_set_name (A, "A");
488 B = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
489 gtk_widget_set_name (B, "B");
490 C = gtk_event_box_new ();
491 gtk_widget_set_hexpand (C, TRUE);
492 gtk_widget_set_vexpand (C, TRUE);
493 gtk_widget_set_name (C, "C");
494
495 gtk_container_add (GTK_CONTAINER (A), B);
496 gtk_container_add (GTK_CONTAINER (B), C);
497
498 gtk_widget_show_all (A);
499
500 str = g_string_new ("");
501
502 add_gesture (A, "a1", GTK_PHASE_CAPTURE, str, GTK_EVENT_SEQUENCE_NONE);
503 add_gesture (B, "b1", GTK_PHASE_CAPTURE, str, GTK_EVENT_SEQUENCE_NONE);
504 add_gesture (C, "c1", GTK_PHASE_CAPTURE, str, GTK_EVENT_SEQUENCE_NONE);
505 add_gesture (C, "c2", GTK_PHASE_TARGET, str, GTK_EVENT_SEQUENCE_NONE);
506 add_gesture (A, "a3", GTK_PHASE_BUBBLE, str, GTK_EVENT_SEQUENCE_NONE);
507 add_gesture (B, "b3", GTK_PHASE_BUBBLE, str, GTK_EVENT_SEQUENCE_NONE);
508 add_gesture (C, "c3", GTK_PHASE_BUBBLE, str, GTK_EVENT_SEQUENCE_NONE);
509
510 add_legacy (A, str, GDK_EVENT_PROPAGATE);
511 add_legacy (B, str, GDK_EVENT_STOP);
512 add_legacy (C, str, GDK_EVENT_PROPAGATE);
513
514 point_update (&mouse_state, C, 10, 10);
515 point_press (&mouse_state, C, 1);
516
517 g_assert_cmpstr (str->str, ==,
518 "capture a1, "
519 "capture b1, "
520 "capture c1, "
521 "target c2, "
522 "legacy C, "
523 "bubble c3, "
524 "legacy B");
525
526 g_string_free (str, TRUE);
527
528 gtk_widget_destroy (A);
529 }
530
531 static void
532 test_claim_capture (void)
533 {
534 GtkWidget *A, *B, *C;
535 GString *str;
536
537 A = gtk_window_new (GTK_WINDOW_TOPLEVEL);
538 gtk_widget_set_name (A, "A");
539 B = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
540 gtk_widget_set_name (B, "B");
541 C = gtk_event_box_new ();
542 gtk_widget_set_hexpand (C, TRUE);
543 gtk_widget_set_vexpand (C, TRUE);
544 gtk_widget_set_name (C, "C");
545
546 gtk_container_add (GTK_CONTAINER (A), B);
547 gtk_container_add (GTK_CONTAINER (B), C);
548
549 gtk_widget_show_all (A);
550
551 str = g_string_new ("");
552
553 add_gesture (A, "a1", GTK_PHASE_CAPTURE, str, GTK_EVENT_SEQUENCE_NONE);
554 add_gesture (B, "b1", GTK_PHASE_CAPTURE, str, GTK_EVENT_SEQUENCE_NONE);
555 add_gesture (C, "c1", GTK_PHASE_CAPTURE, str, GTK_EVENT_SEQUENCE_CLAIMED);
556 add_gesture (C, "c2", GTK_PHASE_TARGET, str, GTK_EVENT_SEQUENCE_NONE);
557 add_gesture (A, "a3", GTK_PHASE_BUBBLE, str, GTK_EVENT_SEQUENCE_NONE);
558 add_gesture (B, "b3", GTK_PHASE_BUBBLE, str, GTK_EVENT_SEQUENCE_NONE);
559 add_gesture (C, "c3", GTK_PHASE_BUBBLE, str, GTK_EVENT_SEQUENCE_NONE);
560
561 point_update (&mouse_state, C, 10, 10);
562 point_press (&mouse_state, C, 1);
563
564 g_assert_cmpstr (str->str, ==,
565 "capture a1, "
566 "capture b1, "
567 "capture c1, "
568 "c1 state claimed");
569
570 g_string_free (str, TRUE);
571
572 gtk_widget_destroy (A);
573 }
574
575 static void
576 test_claim_target (void)
577 {
578 GtkWidget *A, *B, *C;
579 GString *str;
580
581 A = gtk_window_new (GTK_WINDOW_TOPLEVEL);
582 gtk_widget_set_name (A, "A");
583 B = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
584 gtk_widget_set_name (B, "B");
585 C = gtk_event_box_new ();
586 gtk_widget_set_hexpand (C, TRUE);
587 gtk_widget_set_vexpand (C, TRUE);
588 gtk_widget_set_name (C, "C");
589
590 gtk_container_add (GTK_CONTAINER (A), B);
591 gtk_container_add (GTK_CONTAINER (B), C);
592
593 gtk_widget_show_all (A);
594
595 str = g_string_new ("");
596
597 add_gesture (A, "a1", GTK_PHASE_CAPTURE, str, GTK_EVENT_SEQUENCE_NONE);
598 add_gesture (B, "b1", GTK_PHASE_CAPTURE, str, GTK_EVENT_SEQUENCE_NONE);
599 add_gesture (C, "c1", GTK_PHASE_CAPTURE, str, GTK_EVENT_SEQUENCE_NONE);
600 add_gesture (C, "c2", GTK_PHASE_TARGET, str, GTK_EVENT_SEQUENCE_CLAIMED);
601 add_gesture (A, "a3", GTK_PHASE_BUBBLE, str, GTK_EVENT_SEQUENCE_NONE);
602 add_gesture (B, "b3", GTK_PHASE_BUBBLE, str, GTK_EVENT_SEQUENCE_NONE);
603 add_gesture (C, "c3", GTK_PHASE_BUBBLE, str, GTK_EVENT_SEQUENCE_NONE);
604
605 point_update (&mouse_state, C, 10, 10);
606 point_press (&mouse_state, C, 1);
607
608 g_assert_cmpstr (str->str, ==,
609 "capture a1, "
610 "capture b1, "
611 "capture c1, "
612 "target c2, "
613 "c2 state claimed");
614
615 g_string_free (str, TRUE);
616
617 gtk_widget_destroy (A);
618 }
619
620 static void
621 test_claim_bubble (void)
622 {
623 GtkWidget *A, *B, *C;
624 GString *str;
625
626 A = gtk_window_new (GTK_WINDOW_TOPLEVEL);
627 gtk_widget_set_name (A, "A");
628 B = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
629 gtk_widget_set_name (B, "B");
630 C = gtk_event_box_new ();
631 gtk_widget_set_hexpand (C, TRUE);
632 gtk_widget_set_vexpand (C, TRUE);
633 gtk_widget_set_name (C, "C");
634
635 gtk_container_add (GTK_CONTAINER (A), B);
636 gtk_container_add (GTK_CONTAINER (B), C);
637
638 gtk_widget_show_all (A);
639
640 str = g_string_new ("");
641
642 add_gesture (A, "a1", GTK_PHASE_CAPTURE, str, GTK_EVENT_SEQUENCE_NONE);
643 add_gesture (B, "b1", GTK_PHASE_CAPTURE, str, GTK_EVENT_SEQUENCE_NONE);
644 add_gesture (C, "c1", GTK_PHASE_CAPTURE, str, GTK_EVENT_SEQUENCE_NONE);
645 add_gesture (C, "c2", GTK_PHASE_TARGET, str, GTK_EVENT_SEQUENCE_NONE);
646 add_gesture (A, "a3", GTK_PHASE_BUBBLE, str, GTK_EVENT_SEQUENCE_NONE);
647 add_gesture (B, "b3", GTK_PHASE_BUBBLE, str, GTK_EVENT_SEQUENCE_CLAIMED);
648 add_gesture (C, "c3", GTK_PHASE_BUBBLE, str, GTK_EVENT_SEQUENCE_NONE);
649
650 point_update (&mouse_state, C, 10, 10);
651 point_press (&mouse_state, C, 1);
652
653 g_assert_cmpstr (str->str, ==,
654 "capture a1, "
655 "capture b1, "
656 "capture c1, "
657 "target c2, "
658 "bubble c3, "
659 "bubble b3, "
660 "c3 cancelled, "
661 "c2 cancelled, "
662 "c1 cancelled, "
663 "b3 state claimed"
664 );
665
666 g_string_free (str, TRUE);
667
668 gtk_widget_destroy (A);
669 }
670
671 static void
672 test_early_claim_capture (void)
673 {
674 GtkWidget *A, *B, *C;
675 GtkGesture *g;
676 GString *str;
677
678 A = gtk_window_new (GTK_WINDOW_TOPLEVEL);
679 gtk_widget_set_name (A, "A");
680 B = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
681 gtk_widget_set_name (B, "B");
682 C = gtk_event_box_new ();
683 gtk_widget_set_hexpand (C, TRUE);
684 gtk_widget_set_vexpand (C, TRUE);
685 gtk_widget_set_name (C, "C");
686
687 gtk_container_add (GTK_CONTAINER (A), B);
688 gtk_container_add (GTK_CONTAINER (B), C);
689
690 gtk_widget_show_all (A);
691
692 str = g_string_new ("");
693
694 add_gesture (A, "a1", GTK_PHASE_CAPTURE, str, GTK_EVENT_SEQUENCE_NONE);
695 g = add_gesture (B, "b1", GTK_PHASE_CAPTURE, str, GTK_EVENT_SEQUENCE_CLAIMED);
696 add_gesture (C, "c1", GTK_PHASE_CAPTURE, str, GTK_EVENT_SEQUENCE_CLAIMED);
697 add_gesture (C, "c2", GTK_PHASE_TARGET, str, GTK_EVENT_SEQUENCE_NONE);
698 add_gesture (A, "a3", GTK_PHASE_BUBBLE, str, GTK_EVENT_SEQUENCE_NONE);
699 add_gesture (B, "b3", GTK_PHASE_BUBBLE, str, GTK_EVENT_SEQUENCE_NONE);
700 add_gesture (C, "c3", GTK_PHASE_BUBBLE, str, GTK_EVENT_SEQUENCE_NONE);
701
702 point_update (&mouse_state, C, 10, 10);
703 point_press (&mouse_state, C, 1);
704
705 g_assert_cmpstr (str->str, ==,
706 "capture a1, "
707 "capture b1, "
708 "b1 state claimed");
709
710 /* Reset the string */
711 g_string_erase (str, 0, str->len);
712
713 gtk_gesture_set_state (g, GTK_EVENT_SEQUENCE_DENIED);
714
715 g_assert_cmpstr (str->str, ==,
716 "capture c1, "
717 "c1 state claimed, "
718 "b1 state denied");
719
720 point_release (&mouse_state, 1);
721
722 g_string_free (str, TRUE);
723 gtk_widget_destroy (A);
724 }
725
726 static void
727 test_late_claim_capture (void)
728 {
729 GtkWidget *A, *B, *C;
730 GtkGesture *g;
731 GString *str;
732
733 A = gtk_window_new (GTK_WINDOW_TOPLEVEL);
734 gtk_widget_set_name (A, "A");
735 B = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
736 gtk_widget_set_name (B, "B");
737 C = gtk_event_box_new ();
738 gtk_widget_set_hexpand (C, TRUE);
739 gtk_widget_set_vexpand (C, TRUE);
740 gtk_widget_set_name (C, "C");
741
742 gtk_container_add (GTK_CONTAINER (A), B);
743 gtk_container_add (GTK_CONTAINER (B), C);
744
745 gtk_widget_show_all (A);
746
747 str = g_string_new ("");
748
749 add_gesture (A, "a1", GTK_PHASE_CAPTURE, str, GTK_EVENT_SEQUENCE_NONE);
750 g = add_gesture (B, "b1", GTK_PHASE_CAPTURE, str, GTK_EVENT_SEQUENCE_NONE);
751 add_gesture (C, "c1", GTK_PHASE_CAPTURE, str, GTK_EVENT_SEQUENCE_NONE);
752 add_gesture (C, "c2", GTK_PHASE_TARGET, str, GTK_EVENT_SEQUENCE_CLAIMED);
753 add_gesture (A, "a3", GTK_PHASE_BUBBLE, str, GTK_EVENT_SEQUENCE_NONE);
754 add_gesture (B, "b3", GTK_PHASE_BUBBLE, str, GTK_EVENT_SEQUENCE_NONE);
755 add_gesture (C, "c3", GTK_PHASE_BUBBLE, str, GTK_EVENT_SEQUENCE_NONE);
756
757 point_update (&mouse_state, C, 10, 10);
758 point_press (&mouse_state, C, 1);
759
760 g_assert_cmpstr (str->str, ==,
761 "capture a1, "
762 "capture b1, "
763 "capture c1, "
764 "target c2, "
765 "c2 state claimed");
766
767 /* Reset the string */
768 g_string_erase (str, 0, str->len);
769
770 gtk_gesture_set_state (g, GTK_EVENT_SEQUENCE_CLAIMED);
771
772 g_assert_cmpstr (str->str, ==,
773 "c2 cancelled, "
774 "c1 cancelled, "
775 "b1 state claimed");
776
777 point_release (&mouse_state, 1);
778
779 g_string_free (str, TRUE);
780 gtk_widget_destroy (A);
781 }
782
783 static void
784 test_group (void)
785 {
786 GtkWidget *A, *B, *C;
787 GString *str;
788 GtkGesture *g1, *g2;
789
790 A = gtk_window_new (GTK_WINDOW_TOPLEVEL);
791 gtk_widget_set_name (A, "A");
792 B = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
793 gtk_widget_set_name (B, "B");
794 C = gtk_event_box_new ();
795 gtk_widget_set_hexpand (C, TRUE);
796 gtk_widget_set_vexpand (C, TRUE);
797 gtk_widget_set_name (C, "C");
798
799 gtk_container_add (GTK_CONTAINER (A), B);
800 gtk_container_add (GTK_CONTAINER (B), C);
801
802 gtk_widget_show_all (A);
803
804 str = g_string_new ("");
805
806 add_gesture (A, "a1", GTK_PHASE_CAPTURE, str, GTK_EVENT_SEQUENCE_NONE);
807 add_gesture (B, "b1", GTK_PHASE_CAPTURE, str, GTK_EVENT_SEQUENCE_NONE);
808 add_gesture (C, "c1", GTK_PHASE_CAPTURE, str, GTK_EVENT_SEQUENCE_NONE);
809 g1 = add_gesture (C, "c2", GTK_PHASE_TARGET, str, GTK_EVENT_SEQUENCE_NONE);
810 g2 = add_gesture (C, "c3", GTK_PHASE_TARGET, str, GTK_EVENT_SEQUENCE_CLAIMED);
811 gtk_gesture_group (g1, g2);
812 add_gesture (A, "a3", GTK_PHASE_BUBBLE, str, GTK_EVENT_SEQUENCE_NONE);
813 add_gesture (B, "b3", GTK_PHASE_BUBBLE, str, GTK_EVENT_SEQUENCE_NONE);
814 add_gesture (C, "c4", GTK_PHASE_BUBBLE, str, GTK_EVENT_SEQUENCE_NONE);
815
816 point_update (&mouse_state, C, 10, 10);
817 point_press (&mouse_state, C, 1);
818
819 g_assert_cmpstr (str->str, ==,
820 "capture a1, "
821 "capture b1, "
822 "capture c1, "
823 "target c3, "
824 "c3 state claimed, "
825 "c2 state claimed, "
826 "target c2");
827
828 g_string_free (str, TRUE);
829
830 gtk_widget_destroy (A);
831 }
832
833 static void
834 test_gestures_outside_grab (void)
835 {
836 GtkWidget *A, *B, *C, *D;
837 GString *str;
838
839 A = gtk_window_new (GTK_WINDOW_TOPLEVEL);
840 gtk_widget_set_name (A, "A");
841 B = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
842 gtk_widget_set_name (B, "B");
843 C = gtk_event_box_new ();
844 gtk_widget_set_hexpand (C, TRUE);
845 gtk_widget_set_vexpand (C, TRUE);
846 gtk_widget_set_name (C, "C");
847
848 gtk_container_add (GTK_CONTAINER (A), B);
849 gtk_container_add (GTK_CONTAINER (B), C);
850
851 gtk_widget_show_all (A);
852
853 D = gtk_window_new (GTK_WINDOW_TOPLEVEL);
854 gtk_widget_show (D);
855
856 str = g_string_new ("");
857
858 add_gesture (A, "a1", GTK_PHASE_CAPTURE, str, GTK_EVENT_SEQUENCE_NONE);
859 add_gesture (B, "b1", GTK_PHASE_CAPTURE, str, GTK_EVENT_SEQUENCE_NONE);
860 add_gesture (C, "c1", GTK_PHASE_CAPTURE, str, GTK_EVENT_SEQUENCE_NONE);
861 add_gesture (C, "c2", GTK_PHASE_TARGET, str, GTK_EVENT_SEQUENCE_CLAIMED);
862 add_gesture (B, "b2", GTK_PHASE_BUBBLE, str, GTK_EVENT_SEQUENCE_NONE);
863 add_gesture (A, "a2", GTK_PHASE_BUBBLE, str, GTK_EVENT_SEQUENCE_NONE);
864
865 point_update (&mouse_state, C, 10, 10);
866 point_press (&mouse_state, C, 1);
867
868 g_assert_cmpstr (str->str, ==,
869 "capture a1, "
870 "capture b1, "
871 "capture c1, "
872 "target c2, "
873 "c2 state claimed");
874
875 /* Set a grab on another window */
876 g_string_erase (str, 0, str->len);
877 gtk_grab_add (D);
878
879 g_assert_cmpstr (str->str, ==,
880 "c1 cancelled, "
881 "c2 cancelled, "
882 "b1 cancelled, "
883 "a1 cancelled");
884
885 g_string_free (str, TRUE);
886
887 gtk_widget_destroy (A);
888 gtk_widget_destroy (D);
889 }
890
891 static void
892 test_gestures_inside_grab (void)
893 {
894 GtkWidget *A, *B, *C;
895 GString *str;
896
897 A = gtk_window_new (GTK_WINDOW_TOPLEVEL);
898 gtk_widget_set_name (A, "A");
899 B = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
900 gtk_widget_set_name (B, "B");
901 C = gtk_event_box_new ();
902 gtk_widget_set_hexpand (C, TRUE);
903 gtk_widget_set_vexpand (C, TRUE);
904 gtk_widget_set_name (C, "C");
905
906 gtk_container_add (GTK_CONTAINER (A), B);
907 gtk_container_add (GTK_CONTAINER (B), C);
908
909 gtk_widget_show_all (A);
910
911 str = g_string_new ("");
912
913 add_gesture (A, "a1", GTK_PHASE_CAPTURE, str, GTK_EVENT_SEQUENCE_NONE);
914 add_gesture (B, "b1", GTK_PHASE_CAPTURE, str, GTK_EVENT_SEQUENCE_NONE);
915 add_gesture (C, "c1", GTK_PHASE_CAPTURE, str, GTK_EVENT_SEQUENCE_NONE);
916 add_gesture (C, "c2", GTK_PHASE_TARGET, str, GTK_EVENT_SEQUENCE_CLAIMED);
917 add_gesture (B, "b2", GTK_PHASE_BUBBLE, str, GTK_EVENT_SEQUENCE_NONE);
918 add_gesture (A, "a2", GTK_PHASE_BUBBLE, str, GTK_EVENT_SEQUENCE_NONE);
919
920 point_update (&mouse_state, C, 10, 10);
921 point_press (&mouse_state, C, 1);
922
923 g_assert_cmpstr (str->str, ==,
924 "capture a1, "
925 "capture b1, "
926 "capture c1, "
927 "target c2, "
928 "c2 state claimed");
929
930 /* Set a grab on B */
931 g_string_erase (str, 0, str->len);
932 gtk_grab_add (B);
933 g_assert_cmpstr (str->str, ==,
934 "a1 cancelled");
935
936 /* Update with the grab under effect */
937 g_string_erase (str, 0, str->len);
938 point_update (&mouse_state, C, 20, 20);
939 g_assert_cmpstr (str->str, ==,
940 "b1 updated, "
941 "c1 updated, "
942 "c2 updated");
943
944 g_string_free (str, TRUE);
945
946 gtk_widget_destroy (A);
947 }
948
949 static void
950 test_multitouch_on_single (void)
951 {
952 GtkWidget *A, *B, *C;
953 GString *str;
954
955 A = gtk_window_new (GTK_WINDOW_TOPLEVEL);
956 gtk_widget_set_name (A, "A");
957 B = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
958 gtk_widget_set_name (B, "B");
959 C = gtk_event_box_new ();
960 gtk_widget_set_hexpand (C, TRUE);
961 gtk_widget_set_vexpand (C, TRUE);
962 gtk_widget_set_name (C, "C");
963
964 gtk_container_add (GTK_CONTAINER (A), B);
965 gtk_container_add (GTK_CONTAINER (B), C);
966
967 gtk_widget_show_all (A);
968
969 str = g_string_new ("");
970
971 add_gesture (A, "a1", GTK_PHASE_CAPTURE, str, GTK_EVENT_SEQUENCE_NONE);
972 add_gesture (B, "b1", GTK_PHASE_CAPTURE, str, GTK_EVENT_SEQUENCE_CLAIMED);
973
974 /* First touch down */
975 point_update (&touch_state[0], C, 10, 10);
976 point_press (&touch_state[0], C, 1);
977
978 g_assert_cmpstr (str->str, ==,
979 "capture a1 (1), "
980 "capture b1 (1), "
981 "b1 state claimed (1)");
982
983 /* Second touch down */
984 g_string_erase (str, 0, str->len);
985 point_update (&touch_state[1], C, 20, 20);
986 point_press (&touch_state[1], C, 1);
987
988 g_assert_cmpstr (str->str, ==,
989 "a1 state denied (2), "
990 "b1 state denied (2)");
991
992 g_string_free (str, TRUE);
993
994 gtk_widget_destroy (A);
995 }
996
997 static void
998 test_multitouch_activation (void)
999 {
1000 GtkWidget *A, *B, *C;
1001 GString *str;
1002
1003 A = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1004 gtk_widget_set_name (A, "A");
1005 B = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
1006 gtk_widget_set_name (B, "B");
1007 C = gtk_event_box_new ();
1008 gtk_widget_set_hexpand (C, TRUE);
1009 gtk_widget_set_vexpand (C, TRUE);
1010 gtk_widget_set_name (C, "C");
1011
1012 gtk_container_add (GTK_CONTAINER (A), B);
1013 gtk_container_add (GTK_CONTAINER (B), C);
1014
1015 gtk_widget_show_all (A);
1016
1017 str = g_string_new ("");
1018
1019 add_mt_gesture (C, "c1", GTK_PHASE_BUBBLE, str, GTK_EVENT_SEQUENCE_CLAIMED);
1020
1021 /* First touch down */
1022 point_update (&touch_state[0], C, 10, 10);
1023 point_press (&touch_state[0], C, 1);
1024
1025 g_assert_cmpstr (str->str, ==, "");
1026
1027 /* Second touch down */
1028 point_update (&touch_state[1], C, 20, 20);
1029 point_press (&touch_state[1], C, 1);
1030
1031 g_assert_cmpstr (str->str, ==,
1032 "c1 began, "
1033 "c1 state claimed (2), "
1034 "c1 state claimed");
1035
1036 /* First touch up */
1037 g_string_erase (str, 0, str->len);
1038 point_release (&touch_state[0], 1);
1039
1040 g_assert_cmpstr (str->str, ==,
1041 "c1 ended");
1042
1043 /* A third touch down triggering again action */
1044 g_string_erase (str, 0, str->len);
1045 point_update (&touch_state[2], C, 20, 20);
1046 point_press (&touch_state[2], C, 1);
1047
1048 g_assert_cmpstr (str->str, ==,
1049 "c1 began, "
1050 "c1 state claimed (3)");
1051
1052 /* One touch up, gesture is finished again */
1053 g_string_erase (str, 0, str->len);
1054 point_release (&touch_state[2], 1);
1055
1056 g_assert_cmpstr (str->str, ==,
1057 "c1 ended");
1058
1059 /* Another touch up, gesture remains inactive */
1060 g_string_erase (str, 0, str->len);
1061 point_release (&touch_state[1], 1);
1062
1063 g_assert_cmpstr (str->str, ==, "");
1064
1065 g_string_free (str, TRUE);
1066
1067 gtk_widget_destroy (A);
1068 }
1069
1070 static void
1071 test_multitouch_interaction (void)
1072 {
1073 GtkWidget *A, *B, *C;
1074 GtkGesture *g;
1075 GString *str;
1076
1077 A = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1078 gtk_widget_set_name (A, "A");
1079 B = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
1080 gtk_widget_set_name (B, "B");
1081 C = gtk_event_box_new ();
1082 gtk_widget_set_hexpand (C, TRUE);
1083 gtk_widget_set_vexpand (C, TRUE);
1084 gtk_widget_set_name (C, "C");
1085
1086 gtk_container_add (GTK_CONTAINER (A), B);
1087 gtk_container_add (GTK_CONTAINER (B), C);
1088
1089 gtk_widget_show_all (A);
1090
1091 str = g_string_new ("");
1092
1093 g = add_gesture (A, "a1", GTK_PHASE_CAPTURE, str, GTK_EVENT_SEQUENCE_CLAIMED);
1094 add_mt_gesture (C, "c1", GTK_PHASE_BUBBLE, str, GTK_EVENT_SEQUENCE_CLAIMED);
1095
1096 /* First touch down, a1 claims the sequence */
1097 point_update (&touch_state[0], C, 10, 10);
1098 point_press (&touch_state[0], C, 1);
1099
1100 g_assert_cmpstr (str->str, ==,
1101 "capture a1 (1), "
1102 "a1 state claimed (1)");
1103
1104 /* Second touch down, a1 denies and c1 takes over */
1105 g_string_erase (str, 0, str->len);
1106 point_update (&touch_state[1], C, 20, 20);
1107 point_press (&touch_state[1], C, 1);
1108
1109 /* Denying sequences in touch-excess situation is a responsibility of the caller */
1110 gtk_gesture_set_state (g, GTK_EVENT_SEQUENCE_DENIED);
1111
1112 g_assert_cmpstr (str->str, ==,
1113 "a1 state denied (2), "
1114 "c1 began, "
1115 "c1 state claimed, "
1116 "c1 state claimed (2), "
1117 "a1 state denied (1)");
1118
1119 /* Move first point, only c1 should update */
1120 g_string_erase (str, 0, str->len);
1121 point_update (&touch_state[0], C, 30, 30);
1122
1123 g_assert_cmpstr (str->str, ==,
1124 "c1 updated");
1125
1126 /* First touch up */
1127 g_string_erase (str, 0, str->len);
1128 point_release (&touch_state[0], 1);
1129
1130 g_assert_cmpstr (str->str, ==,
1131 "c1 ended");
1132
1133 /* A third touch down triggering again action on c1 */
1134 g_string_erase (str, 0, str->len);
1135 point_update (&touch_state[2], C, 20, 20);
1136 point_press (&touch_state[2], C, 1);
1137
1138 g_assert_cmpstr (str->str, ==,
1139 "a1 state denied (3), "
1140 "c1 began, "
1141 "c1 state claimed (3)");
1142
1143 /* One touch up, gesture is finished again */
1144 g_string_erase (str, 0, str->len);
1145 point_release (&touch_state[2], 1);
1146
1147 g_assert_cmpstr (str->str, ==,
1148 "c1 ended");
1149
1150 /* Another touch up, gesture remains inactive */
1151 g_string_erase (str, 0, str->len);
1152 point_release (&touch_state[1], 1);
1153
1154 g_assert_cmpstr (str->str, ==, "");
1155
1156 g_string_free (str, TRUE);
1157
1158 gtk_widget_destroy (A);
1159 }
1160
1161 int
1162 main (int argc, char *argv[])
1163 {
1164 gtk_test_init (&argc, &argv);
1165
1166 g_test_add_func ("/gestures/propagation/phases", test_phases);
1167 g_test_add_func ("/gestures/propagation/mixed", test_mixed);
1168 g_test_add_func ("/gestures/propagation/early-exit", test_early_exit);
1169 g_test_add_func ("/gestures/claim/capture", test_claim_capture);
1170 g_test_add_func ("/gestures/claim/target", test_claim_target);
1171 g_test_add_func ("/gestures/claim/bubble", test_claim_bubble);
1172 g_test_add_func ("/gestures/claim/early-capture", test_early_claim_capture);
1173 g_test_add_func ("/gestures/claim/late-capture", test_late_claim_capture);
1174 g_test_add_func ("/gestures/group", test_group);
1175 g_test_add_func ("/gestures/grabs/gestures-outside-grab", test_gestures_outside_grab);
1176 g_test_add_func ("/gestures/grabs/gestures-inside-grab", test_gestures_inside_grab);
1177 g_test_add_func ("/gestures/multitouch/gesture-single", test_multitouch_on_single);
1178 g_test_add_func ("/gestures/multitouch/multitouch-activation", test_multitouch_activation);
1179 g_test_add_func ("/gestures/multitouch/interaction", test_multitouch_interaction);
1180
1181 return g_test_run ();
1182 }