libgrip

Merge lp:~bratsche/libgrip/event-routing into lp:libgrip

  1. event-routing
  2. Merge into trunk
Proposed by Cody Russell
Status: Merged
Merged at revision: 16
Proposed branch: lp:~bratsche/libgrip/event-routing
Merge into: lp:libgrip
Diff against target: 843 lines (+421/-144)
3 files modified
examples/rectangle-mover/gesture.c (+107/-55)
src/gripgesturemanager.c (+307/-84)
src/gripgesturemanager.h (+7/-5)
To merge this branch: bzr merge lp:~bratsche/libgrip/event-routing
Reviewer Review Type Date Requested Status
Henrik Rydberg (community) Needs Information
Stephen M. Webb (community) Approve
Review via email: mp+43378@code.launchpad.net

Description of the change

This changes the API of libgrip. Gesture callbacks are now registered by widget rather than by window.

See the rectangle mover test program to test it out, and note that you should be able to do the normal gestures only in the drawing area. The area on the left is a treeview (although I'm not populating it with anything yet); doing gesture events on the treeview will result in nothing happening. Below the treeview is a "Quit" button, and tapping this will cause the test program to exit.

To post a comment you must log in.
Revision history for this message
Stephen M. Webb (bregma) wrote :

Code compiles OK and the supplied test program draws a barbie pink box that rotates, drags, expands, shrinks, and entertains for minutes on end when gesturing over the drawing area and nowhere else, but only the Quit button responds to a 2-finger tap (as expected).

The code looks clean. This is a good change.

review: Approve
Revision history for this message
Henrik Rydberg (rydberg) wrote :

I love test programs :-) I noticed some problems:

1. Dragging seems to lose some events along the way

2. Rotating around a finger looks odd (rather grail's fault)

3. For me, tapping the quit button did not work

I have attaching an evemu test case, where I first maximize the ./gesture program, then start recording some movements, and lastly tap the quit button. Will only work on natty, please holler if it would help you.

review: Needs Information

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk
=== modified file 'examples/rectangle-mover/gesture.c'
--- examples/rectangle-mover/gesture.c 2010-12-09 01:25:48 +0000
+++ examples/rectangle-mover/gesture.c 2010-12-10 18:01:55 +0000
@@ -38,32 +38,19 @@
38 return FALSE;38 return FALSE;
39}39}
4040
41GtkWidget *41static void
42create_window (void)42button_tap (GtkWidget *widget,
43 GripTimeType time_type,
44 GripGestureEvent *event,
45 gpointer user_data)
43{46{
44 GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);47 g_signal_emit_by_name (widget, "clicked");
45 GtkWidget *da;
46 const GdkColor white = { 0, 0xffff, 0xffff, 0xffff };
47
48 gtk_window_set_title (GTK_WINDOW (window), "Touch Demo");
49 gtk_window_set_default_size (GTK_WINDOW (window), 600, 600);
50 g_signal_connect (window, "destroy", G_CALLBACK (gtk_widget_destroyed), &window);
51
52 da = gtk_drawing_area_new ();
53 gtk_container_add (GTK_CONTAINER (window), da);
54
55 gtk_widget_modify_bg (da, GTK_STATE_NORMAL, &white);
56
57 g_signal_connect (da, "expose-event",
58 G_CALLBACK (expose_event), NULL);
59
60 return window;
61}48}
6249
63static void50static void
64gesture_callback (GtkWindow *window,51gesture_callback (GtkWidget *widget,
65 GripTimeType time_type,52 GripTimeType time_type,
66 GripGestureEvent *event,53 GripGestureEvent *event,
67 gpointer user_data)54 gpointer user_data)
68{55{
69 if (time_type == GRIP_TIME_START)56 if (time_type == GRIP_TIME_START)
@@ -103,12 +90,106 @@
103 }90 }
104 break;91 break;
10592
106 case GRIP_GESTURE_TAP:93 case GRIP_GESTURE_TAP:
107 break;94 break;
108 }95 }
109 }96 }
11097
111 gtk_widget_queue_draw (GTK_WIDGET (window));98 gtk_widget_queue_draw (GTK_WIDGET (widget));
99}
100
101
102static GtkTreeModel *
103create_model ()
104{
105 return (GtkTreeModel *)gtk_list_store_new (1, G_TYPE_STRING);
106}
107
108static GtkWidget *
109create_window (GripGestureManager *manager)
110{
111 GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
112 GtkWidget *da;
113 GtkWidget *hbox;
114 GtkWidget *vbox;
115 GtkWidget *button;
116 GtkWidget *tv;
117 GtkTreeModel *model;
118 GtkWidget *sw;
119 const GdkColor white = { 0, 0xffff, 0xffff, 0xffff };
120
121 da = gtk_drawing_area_new ();
122
123 gtk_window_set_title (GTK_WINDOW (window), "Touch Demo");
124 gtk_window_set_default_size (GTK_WINDOW (window), 600, 600);
125 g_signal_connect (window, "destroy", G_CALLBACK (gtk_widget_destroyed), &window);
126 g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
127
128 hbox = gtk_hbox_new (FALSE, 0);
129 vbox = gtk_vbox_new (FALSE, 0);
130
131 gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
132 gtk_box_pack_start (GTK_BOX (hbox), da, TRUE, TRUE, 0);
133
134 model = create_model ();
135 sw = gtk_scrolled_window_new (NULL, NULL);
136 tv = gtk_tree_view_new_with_model (model);
137 g_object_unref (model);
138
139 gtk_container_add (GTK_CONTAINER (sw), tv);
140
141 gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0);
142
143 button = gtk_button_new_with_label ("Quit");
144 g_signal_connect (button,
145 "clicked",
146 G_CALLBACK (gtk_main_quit),
147 NULL);
148 grip_gesture_manager_register_window (manager,
149 button,
150 GRIP_GESTURE_TAP,
151 1,
152 button_tap,
153 NULL, NULL);
154
155 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
156
157 gtk_container_add (GTK_CONTAINER (window), hbox);
158
159 gtk_widget_modify_bg (da, GTK_STATE_NORMAL, &white);
160
161 g_signal_connect (da, "expose-event",
162 G_CALLBACK (expose_event), NULL);
163
164 grip_gesture_manager_register_window (manager,
165 da,
166 GRIP_GESTURE_PINCH,
167 2,
168 gesture_callback,
169 NULL, NULL);
170
171 grip_gesture_manager_register_window (manager,
172 da,
173 GRIP_GESTURE_ROTATE,
174 2,
175 gesture_callback,
176 NULL, NULL);
177
178 grip_gesture_manager_register_window (manager,
179 da,
180 GRIP_GESTURE_DRAG,
181 2,
182 gesture_callback,
183 NULL, NULL);
184
185 grip_gesture_manager_register_window (manager,
186 da,
187 GRIP_GESTURE_TAP,
188 2,
189 gesture_callback,
190 NULL, NULL);
191
192 return window;
112}193}
113194
114static void195static void
@@ -122,7 +203,7 @@
122int203int
123main (int argc, char **argv)204main (int argc, char **argv)
124{205{
125 GtkWindow *window;206 GtkWidget *window;
126 GripGestureManager *manager;207 GripGestureManager *manager;
127208
128 gtk_init (&argc, &argv);209 gtk_init (&argc, &argv);
@@ -131,40 +212,11 @@
131 * my Dell XT2 has in it. */212 * my Dell XT2 has in it. */
132 signal (SIGABRT, abort_handler);213 signal (SIGABRT, abort_handler);
133214
134 window = (GtkWindow *)create_window ();
135 manager = grip_gesture_manager_get ();215 manager = grip_gesture_manager_get ();
216 window = create_window (manager);
136217
137 g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);218 g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
138219
139 grip_gesture_manager_register_window (manager,
140 window,
141 GRIP_GESTURE_PINCH,
142 2,
143 gesture_callback,
144 NULL, NULL);
145
146 grip_gesture_manager_register_window (manager,
147 window,
148 GRIP_GESTURE_ROTATE,
149 2,
150 gesture_callback,
151 NULL, NULL);
152
153 grip_gesture_manager_register_window (manager,
154 window,
155 GRIP_GESTURE_DRAG,
156 2,
157 gesture_callback,
158 NULL, NULL);
159
160 grip_gesture_manager_register_window (manager,
161 window,
162 GRIP_GESTURE_TAP,
163 2,
164 gesture_callback,
165 NULL, NULL);
166
167
168 gtk_widget_show_all (GTK_WIDGET (window));220 gtk_widget_show_all (GTK_WIDGET (window));
169221
170 gtk_main ();222 gtk_main ();
171223
=== modified file 'src/gripgesturemanager.c'
--- src/gripgesturemanager.c 2010-12-09 01:25:48 +0000
+++ src/gripgesturemanager.c 2010-12-10 18:01:55 +0000
@@ -41,6 +41,7 @@
41struct _GripGestureBinding41struct _GripGestureBinding
42{42{
43 GripGestureType type;43 GripGestureType type;
44 GtkWidget *widget;
44 gint touches;45 gint touches;
45 GripGestureCallback callback;46 GripGestureCallback callback;
46 gpointer data;47 gpointer data;
@@ -58,7 +59,7 @@
58struct _GripRegistrationRequest59struct _GripRegistrationRequest
59{60{
60 GripGestureManager *manager;61 GripGestureManager *manager;
61 GtkWindow *window;62 GtkWidget *widget;
62 GripGestureType gesture_type;63 GripGestureType gesture_type;
63 gint touch_points;64 gint touch_points;
64 GripGestureCallback callback;65 GripGestureCallback callback;
@@ -96,6 +97,10 @@
96 GeisSize attr_count,97 GeisSize attr_count,
97 GeisGestureAttr *attrs);98 GeisGestureAttr *attrs);
9899
100static void window_mapped_cb (GtkWidget *widget,
101 GdkEvent *event,
102 gpointer user_data);
103
99static GripGestureManager *manager_singleton = NULL;104static GripGestureManager *manager_singleton = NULL;
100static GeisGestureFuncs gesture_funcs = {105static GeisGestureFuncs gesture_funcs = {
101 gesture_added,106 gesture_added,
@@ -351,6 +356,16 @@
351 {356 {
352 event->timestamp = attrs[i].integer_val;357 event->timestamp = attrs[i].integer_val;
353 }358 }
359 else if (g_strcmp0 (attrs[i].name, GEIS_GESTURE_ATTRIBUTE_FOCUS_X) == 0 &&
360 attrs[i].type == GEIS_ATTR_TYPE_FLOAT)
361 {
362 event->focus_x = attrs[i].float_val;
363 }
364 else if (g_strcmp0 (attrs[i].name, GEIS_GESTURE_ATTRIBUTE_FOCUS_Y) == 0 &&
365 attrs[i].type == GEIS_ATTR_TYPE_FLOAT)
366 {
367 event->focus_y = attrs[i].float_val;
368 }
354 else if (g_strcmp0 (attrs[i].name, GEIS_GESTURE_ATTRIBUTE_POSITION_X) == 0 &&369 else if (g_strcmp0 (attrs[i].name, GEIS_GESTURE_ATTRIBUTE_POSITION_X) == 0 &&
355 attrs[i].type == GEIS_ATTR_TYPE_FLOAT)370 attrs[i].type == GEIS_ATTR_TYPE_FLOAT)
356 {371 {
@@ -389,6 +404,21 @@
389{404{
390}405}
391406
407static gboolean
408matches_widget (GtkWidget *widget,
409 GdkWindow *window,
410 gint x,
411 gint y)
412{
413 GtkAllocation alloc;
414 gint ax, ay;
415
416 gtk_widget_get_allocation (widget, &alloc);
417 gdk_window_get_root_coords (window, alloc.x, alloc.y, &ax, &ay);
418
419 return (x >= ax && x < ax + alloc.width && y >= ay && y < ay + alloc.height);
420}
421
392static void422static void
393gesture_start (void *cookie,423gesture_start (void *cookie,
394 GeisGestureType type,424 GeisGestureType type,
@@ -417,10 +447,16 @@
417447
418 if (drag.fingers == binding->touches)448 if (drag.fingers == binding->touches)
419 {449 {
420 binding->callback (reg->window,450 if (matches_widget (binding->widget,
421 GRIP_TIME_START,451 GTK_WIDGET (reg->window)->window,
422 ((GripGestureEvent*)&drag),452 (gint)drag.focus_x,
423 binding->data);453 (gint)drag.focus_y))
454 {
455 binding->callback (binding->widget,
456 GRIP_TIME_START,
457 ((GripGestureEvent*)&drag),
458 binding->data);
459 }
424 }460 }
425 }461 }
426 else if (type == GRIP_GESTURE_PINCH)462 else if (type == GRIP_GESTURE_PINCH)
@@ -435,10 +471,16 @@
435471
436 if (pinch.fingers == binding->touches)472 if (pinch.fingers == binding->touches)
437 {473 {
438 binding->callback (reg->window,474 if (matches_widget (binding->widget,
439 GRIP_TIME_START,475 GTK_WIDGET (reg->window)->window,
440 ((GripGestureEvent*)&pinch),476 (gint)pinch.focus_x,
441 binding->data);477 (gint)pinch.focus_y))
478 {
479 binding->callback (binding->widget,
480 GRIP_TIME_START,
481 ((GripGestureEvent*)&pinch),
482 binding->data);
483 }
442 }484 }
443 }485 }
444 else if (type == GRIP_GESTURE_ROTATE)486 else if (type == GRIP_GESTURE_ROTATE)
@@ -453,10 +495,16 @@
453495
454 if (rotate.fingers == binding->touches)496 if (rotate.fingers == binding->touches)
455 {497 {
456 binding->callback (reg->window,498 if (matches_widget (binding->widget,
457 GRIP_TIME_START,499 GTK_WIDGET (reg->window)->window,
458 ((GripGestureEvent*)&rotate),500 (gint)rotate.focus_x,
459 binding->data);501 (gint)rotate.focus_y))
502 {
503 binding->callback (binding->widget,
504 GRIP_TIME_START,
505 ((GripGestureEvent*)&rotate),
506 binding->data);
507 }
460 }508 }
461 }509 }
462 else if (type == GRIP_GESTURE_TAP)510 else if (type == GRIP_GESTURE_TAP)
@@ -471,11 +519,17 @@
471519
472 if (tap.fingers == binding->touches)520 if (tap.fingers == binding->touches)
473 {521 {
474 binding->callback (reg->window,522 if (matches_widget (binding->widget,
475 GRIP_TIME_START,523 GTK_WIDGET (reg->window)->window,
476 ((GripGestureEvent*)&tap),524 (gint)tap.focus_x,
477 binding->data);525 (gint)tap.focus_y))
478 }526 {
527 binding->callback (binding->widget,
528 GRIP_TIME_START,
529 ((GripGestureEvent*)&tap),
530 binding->data);
531 }
532 }
479 }533 }
480 }534 }
481 }535 }
@@ -509,10 +563,16 @@
509563
510 if (drag.fingers == binding->touches)564 if (drag.fingers == binding->touches)
511 {565 {
512 binding->callback (reg->window,566 if (matches_widget (binding->widget,
513 GRIP_TIME_UPDATE,567 GTK_WIDGET (reg->window)->window,
514 ((GripGestureEvent*)&drag),568 (gint)drag.focus_x,
515 binding->data);569 (gint)drag.focus_y))
570 {
571 binding->callback (binding->widget,
572 GRIP_TIME_UPDATE,
573 ((GripGestureEvent*)&drag),
574 binding->data);
575 }
516 }576 }
517 }577 }
518 else if (type == GRIP_GESTURE_PINCH)578 else if (type == GRIP_GESTURE_PINCH)
@@ -527,10 +587,16 @@
527587
528 if (pinch.fingers == binding->touches)588 if (pinch.fingers == binding->touches)
529 {589 {
530 binding->callback (reg->window,590 if (matches_widget (binding->widget,
531 GRIP_TIME_UPDATE,591 GTK_WIDGET (reg->window)->window,
532 ((GripGestureEvent*)&pinch),592 (gint)pinch.focus_x,
533 binding->data);593 (gint)pinch.focus_y))
594 {
595 binding->callback (binding->widget,
596 GRIP_TIME_UPDATE,
597 ((GripGestureEvent*)&pinch),
598 binding->data);
599 }
534 }600 }
535 }601 }
536 else if (type == GRIP_GESTURE_ROTATE)602 else if (type == GRIP_GESTURE_ROTATE)
@@ -545,10 +611,16 @@
545611
546 if (rotate.fingers == binding->touches)612 if (rotate.fingers == binding->touches)
547 {613 {
548 binding->callback (reg->window,614 if (matches_widget (binding->widget,
549 GRIP_TIME_UPDATE,615 GTK_WIDGET (reg->window)->window,
550 ((GripGestureEvent*)&rotate),616 (gint)rotate.focus_x,
551 binding->data);617 (gint)rotate.focus_y))
618 {
619 binding->callback (binding->widget,
620 GRIP_TIME_UPDATE,
621 ((GripGestureEvent*)&rotate),
622 binding->data);
623 }
552 }624 }
553 }625 }
554 else if (type == GRIP_GESTURE_TAP)626 else if (type == GRIP_GESTURE_TAP)
@@ -563,11 +635,17 @@
563635
564 if (tap.fingers == binding->touches)636 if (tap.fingers == binding->touches)
565 {637 {
566 binding->callback (reg->window,638 if (matches_widget (binding->widget,
567 GRIP_TIME_UPDATE,639 GTK_WIDGET (reg->window)->window,
568 ((GripGestureEvent*)&tap),640 (gint)tap.focus_x,
569 binding->data);641 (gint)tap.focus_y))
570 }642 {
643 binding->callback (binding->widget,
644 GRIP_TIME_UPDATE,
645 ((GripGestureEvent*)&tap),
646 binding->data);
647 }
648 }
571 }649 }
572 }650 }
573 }651 }
@@ -601,10 +679,16 @@
601679
602 if (drag.fingers == binding->touches)680 if (drag.fingers == binding->touches)
603 {681 {
604 binding->callback (reg->window,682 if (matches_widget (binding->widget,
605 GRIP_TIME_END,683 GTK_WIDGET (reg->window)->window,
606 ((GripGestureEvent*)&drag),684 (gint)drag.focus_x,
607 binding->data);685 (gint)drag.focus_y))
686 {
687 binding->callback (binding->widget,
688 GRIP_TIME_END,
689 ((GripGestureEvent*)&drag),
690 binding->data);
691 }
608 }692 }
609 }693 }
610 else if (type == GRIP_GESTURE_PINCH)694 else if (type == GRIP_GESTURE_PINCH)
@@ -619,10 +703,16 @@
619703
620 if (pinch.fingers == binding->touches)704 if (pinch.fingers == binding->touches)
621 {705 {
622 binding->callback (reg->window,706 if (matches_widget (binding->widget,
623 GRIP_TIME_END,707 GTK_WIDGET (reg->window)->window,
624 ((GripGestureEvent*)&pinch),708 (gint)pinch.focus_x,
625 binding->data);709 (gint)pinch.focus_y))
710 {
711 binding->callback (binding->widget,
712 GRIP_TIME_END,
713 ((GripGestureEvent*)&pinch),
714 binding->data);
715 }
626 }716 }
627 }717 }
628 else if (type == GRIP_GESTURE_ROTATE)718 else if (type == GRIP_GESTURE_ROTATE)
@@ -637,10 +727,16 @@
637727
638 if (rotate.fingers == binding->touches)728 if (rotate.fingers == binding->touches)
639 {729 {
640 binding->callback (reg->window,730 if (matches_widget (binding->widget,
641 GRIP_TIME_END,731 GTK_WIDGET (reg->window)->window,
642 ((GripGestureEvent*)&rotate),732 (gint)rotate.focus_x,
643 binding->data);733 (gint)rotate.focus_y))
734 {
735 binding->callback (binding->widget,
736 GRIP_TIME_END,
737 ((GripGestureEvent*)&rotate),
738 binding->data);
739 }
644 }740 }
645 }741 }
646 else if (type == GRIP_GESTURE_TAP)742 else if (type == GRIP_GESTURE_TAP)
@@ -655,11 +751,17 @@
655751
656 if (tap.fingers == binding->touches)752 if (tap.fingers == binding->touches)
657 {753 {
658 binding->callback (reg->window,754 if (matches_widget (binding->widget,
659 GRIP_TIME_END,755 GTK_WIDGET (reg->window)->window,
660 ((GripGestureEvent*)&tap),756 (gint)tap.focus_x,
661 binding->data);757 (gint)tap.focus_y))
662 }758 {
759 binding->callback (binding->widget,
760 GRIP_TIME_END,
761 ((GripGestureEvent*)&tap),
762 binding->data);
763 }
764 }
663 }765 }
664 }766 }
665 }767 }
@@ -730,7 +832,7 @@
730832
731static void833static void
732register_internal (GripGestureManager *manager,834register_internal (GripGestureManager *manager,
733 GtkWindow *window,835 GtkWidget *widget,
734 GripGestureType gesture_type,836 GripGestureType gesture_type,
735 gint touch_points,837 gint touch_points,
736 GripGestureCallback callback,838 GripGestureCallback callback,
@@ -740,12 +842,18 @@
740 GripGestureManagerPrivate *priv;842 GripGestureManagerPrivate *priv;
741 GripGestureRegistration *reg;843 GripGestureRegistration *reg;
742 GripGestureBinding *binding;844 GripGestureBinding *binding;
845 GtkWidget *toplevel;
743846
744 g_return_if_fail (GRIP_IS_GESTURE_MANAGER (manager));847 g_return_if_fail (GRIP_IS_GESTURE_MANAGER (manager));
848 g_return_if_fail (GTK_IS_WIDGET (widget));
849
850 toplevel = gtk_widget_get_toplevel (widget);
851
852 g_return_if_fail (GTK_IS_WINDOW (toplevel));
745853
746 priv = manager->priv;854 priv = manager->priv;
747855
748 if (!(reg = g_hash_table_lookup (priv->hash, window)))856 if (!(reg = g_hash_table_lookup (priv->hash, toplevel)))
749 {857 {
750 GeisInstance instance;858 GeisInstance instance;
751 GIOChannel *iochannel;859 GIOChannel *iochannel;
@@ -753,7 +861,7 @@
753 GeisXcbWinInfo xcb_win_info = {861 GeisXcbWinInfo xcb_win_info = {
754 .display_name = NULL,862 .display_name = NULL,
755 .screenp = NULL,863 .screenp = NULL,
756 .window_id = GDK_DRAWABLE_XID (GTK_WIDGET (window)->window)864 .window_id = GDK_DRAWABLE_XID (toplevel->window)
757 };865 };
758 GeisWinInfo win_info = {866 GeisWinInfo win_info = {
759 GEIS_XCB_FULL_WINDOW,867 GEIS_XCB_FULL_WINDOW,
@@ -783,10 +891,10 @@
783891
784 reg = g_new0 (GripGestureRegistration, 1);892 reg = g_new0 (GripGestureRegistration, 1);
785893
786 reg->window = window;894 reg->window = GTK_WINDOW (toplevel);
787 reg->instance = instance;895 reg->instance = instance;
788896
789 g_signal_connect (window,897 g_signal_connect (toplevel,
790 "destroy",898 "destroy",
791 G_CALLBACK (window_destroyed_cb),899 G_CALLBACK (window_destroyed_cb),
792 manager);900 manager);
@@ -810,6 +918,7 @@
810 binding = g_new0 (GripGestureBinding, 1);918 binding = g_new0 (GripGestureBinding, 1);
811919
812 binding->type = gesture_type;920 binding->type = gesture_type;
921 binding->widget = widget;
813 binding->touches = touch_points;922 binding->touches = touch_points;
814 binding->callback = callback;923 binding->callback = callback;
815 binding->data = user_data;924 binding->data = user_data;
@@ -818,11 +927,101 @@
818 reg->bindings = g_list_append (reg->bindings, binding);927 reg->bindings = g_list_append (reg->bindings, binding);
819928
820 g_hash_table_insert (priv->hash,929 g_hash_table_insert (priv->hash,
821 window,930 toplevel,
822 reg);931 reg);
823}932}
824933
825static void934static void
935toplevel_notify_cb (GtkWidget *widget,
936 GParamSpec *pspec,
937 gpointer user_data)
938{
939 if (pspec->name == g_intern_static_string ("parent"))
940 {
941 GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
942 GripRegistrationRequest *req = (GripRegistrationRequest *)user_data;
943
944 if (GTK_IS_WINDOW (toplevel))
945 {
946 g_signal_handlers_disconnect_by_func (widget,
947 G_CALLBACK (toplevel_notify_cb),
948 user_data);
949
950 if (gtk_widget_get_mapped (GTK_WIDGET (toplevel)))
951 {
952 register_internal (req->manager,
953 req->widget,
954 req->gesture_type,
955 req->touch_points,
956 req->callback,
957 req->user_data,
958 req->destroy);
959
960 g_free (req);
961 }
962 else
963 {
964 GripGestureManagerPrivate *priv = req->manager->priv;
965
966 priv->requests = g_list_append (priv->requests, req);
967
968 g_signal_connect (toplevel,
969 "map-event",
970 G_CALLBACK (window_mapped_cb),
971 req->manager);
972 }
973 }
974 else
975 {
976 g_signal_connect (G_OBJECT (toplevel),
977 "notify",
978 G_CALLBACK (toplevel_notify_cb),
979 user_data);
980 }
981 }
982}
983
984static void
985register_widget (GripGestureManager *manager,
986 GtkWidget *widget,
987 GripGestureType gesture_type,
988 gint touch_points,
989 GripGestureCallback callback,
990 gpointer user_data,
991 GDestroyNotify destroy)
992{
993 GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
994
995 if (GTK_IS_WINDOW (toplevel))
996 {
997 register_internal (manager,
998 widget,
999 gesture_type,
1000 touch_points,
1001 callback,
1002 user_data,
1003 destroy);
1004 }
1005 else
1006 {
1007 GripRegistrationRequest *req = g_new0 (GripRegistrationRequest, 1);
1008
1009 req->manager = manager;
1010 req->widget = widget;
1011 req->gesture_type = gesture_type;
1012 req->touch_points = touch_points;
1013 req->callback = callback;
1014 req->user_data = user_data;
1015 req->destroy = destroy;
1016
1017 g_signal_connect (toplevel,
1018 "notify",
1019 G_CALLBACK (toplevel_notify_cb),
1020 req);
1021 }
1022}
1023
1024static void
826window_mapped_cb (GtkWidget *widget,1025window_mapped_cb (GtkWidget *widget,
827 GdkEvent *event,1026 GdkEvent *event,
828 gpointer user_data)1027 gpointer user_data)
@@ -835,13 +1034,13 @@
835 {1034 {
836 GripRegistrationRequest *req = tmp->data;1035 GripRegistrationRequest *req = tmp->data;
8371036
838 register_internal (req->manager,1037 register_widget (req->manager,
839 req->window,1038 req->widget,
840 req->gesture_type,1039 req->gesture_type,
841 req->touch_points,1040 req->touch_points,
842 req->callback,1041 req->callback,
843 req->user_data,1042 req->user_data,
844 req->destroy);1043 req->destroy);
8451044
846 g_free (req);1045 g_free (req);
847 }1046 }
@@ -871,44 +1070,68 @@
871 */1070 */
872void1071void
873grip_gesture_manager_register_window (GripGestureManager *manager,1072grip_gesture_manager_register_window (GripGestureManager *manager,
874 GtkWindow *window,1073 GtkWidget *widget,
875 GripGestureType gesture_type,1074 GripGestureType gesture_type,
876 gint touch_points,1075 gint touch_points,
877 GripGestureCallback callback,1076 GripGestureCallback callback,
878 gpointer user_data,1077 gpointer user_data,
879 GDestroyNotify destroy)1078 GDestroyNotify destroy)
880{1079{
1080 GtkWidget *toplevel;
1081
881 g_return_if_fail (GRIP_IS_GESTURE_MANAGER (manager));1082 g_return_if_fail (GRIP_IS_GESTURE_MANAGER (manager));
882 g_return_if_fail (GTK_IS_WINDOW (window));1083 g_return_if_fail (GTK_IS_WIDGET (widget));
8831084
884 if (gtk_widget_get_mapped (GTK_WIDGET (window)))1085 toplevel = gtk_widget_get_toplevel (widget);
1086
1087 if (GTK_IS_WINDOW (toplevel))
885 {1088 {
886 register_internal (manager,1089 if (gtk_widget_get_mapped (GTK_WIDGET (toplevel)))
887 window,1090 {
888 gesture_type,1091 register_internal (manager,
889 touch_points,1092 widget,
890 callback,1093 gesture_type,
891 user_data,1094 touch_points,
892 destroy);1095 callback,
1096 user_data,
1097 destroy);
1098 }
1099 else
1100 {
1101 GripRegistrationRequest *req = g_new0 (GripRegistrationRequest, 1);
1102 GripGestureManagerPrivate *priv = manager->priv;
1103
1104 req->manager = manager;
1105 req->widget = widget;
1106 req->gesture_type = gesture_type;
1107 req->touch_points = touch_points;
1108 req->callback = callback;
1109 req->user_data = user_data;
1110 req->destroy = destroy;
1111
1112 priv->requests = g_list_append (priv->requests, req);
1113
1114 g_signal_connect (toplevel,
1115 "map-event",
1116 G_CALLBACK (window_mapped_cb),
1117 manager);
1118 }
893 }1119 }
894 else1120 else
895 {1121 {
896 GripRegistrationRequest *req = g_new0 (GripRegistrationRequest, 1);1122 GripRegistrationRequest *req = g_new0 (GripRegistrationRequest, 1);
897 GripGestureManagerPrivate *priv = manager->priv;
8981123
899 req->manager = manager;1124 req->manager = manager;
900 req->window = window;1125 req->widget = widget;
901 req->gesture_type = gesture_type;1126 req->gesture_type = gesture_type;
902 req->touch_points = touch_points;1127 req->touch_points = touch_points;
903 req->callback = callback;1128 req->callback = callback;
904 req->user_data = user_data;1129 req->user_data = user_data;
905 req->destroy = destroy;1130 req->destroy = destroy;
9061131
907 priv->requests = g_list_append (priv->requests, req);1132 g_signal_connect (toplevel,
9081133 "notify",
909 g_signal_connect (window,1134 G_CALLBACK (toplevel_notify_cb),
910 "map-event",1135 req);
911 G_CALLBACK (window_mapped_cb),
912 manager);
913 }1136 }
914}1137}
9151138
=== modified file 'src/gripgesturemanager.h'
--- src/gripgesturemanager.h 2010-11-22 14:49:44 +0000
+++ src/gripgesturemanager.h 2010-12-10 18:01:55 +0000
@@ -122,6 +122,8 @@
122 guint fingers;122 guint fingers;
123123
124 guint32 tap_time;124 guint32 tap_time;
125 gfloat focus_x;
126 gfloat focus_y;
125 gfloat position_x;127 gfloat position_x;
126 gfloat position_y;128 gfloat position_y;
127};129};
@@ -159,7 +161,7 @@
159 GObjectClass parent_class;161 GObjectClass parent_class;
160};162};
161163
162typedef void (* GripGestureCallback) (GtkWindow *window,164typedef void (* GripGestureCallback) (GtkWidget *widget,
163 GripTimeType time,165 GripTimeType time,
164 GripGestureEvent *gesture,166 GripGestureEvent *gesture,
165 gpointer user_data);167 gpointer user_data);
@@ -167,12 +169,12 @@
167GType grip_gesture_manager_get_type (void) G_GNUC_CONST;169GType grip_gesture_manager_get_type (void) G_GNUC_CONST;
168GripGestureManager *grip_gesture_manager_get (void);170GripGestureManager *grip_gesture_manager_get (void);
169void grip_gesture_manager_register_window (GripGestureManager *manager,171void grip_gesture_manager_register_window (GripGestureManager *manager,
170 GtkWindow *window,172 GtkWidget *widget,
171 GripGestureType gesture_type,173 GripGestureType gesture_type,
172 gint touch_points,174 gint touch_points,
173 GripGestureCallback callback,175 GripGestureCallback callback,
174 gpointer user_data,176 gpointer user_data,
175 GDestroyNotify destroy);177 GDestroyNotify destroy);
176178
177G_END_DECLS179G_END_DECLS
178180

Subscribers

People subscribed via source and target branches