Merge lp:~bratsche/libgrope/single-callback into lp:libgrope

[Cody Russell]

The Python binding stuff doesn't seem to like having multiple callback functions register in one place, for some reason. So this branch switches to having a single callback function.

[Stephen M. Webb (bregma)]

Look OK to me.

review: Approve

=== modified file 'example/gesture.c'
--- example/gesture.c	2010-11-09 21:59:17 +0000
+++ example/gesture.c	2010-11-16 20:23:13 +0000
@@ -61,58 +61,49 @@
 }
 
 static void
-gesture_start (GtkWindow         *window,
-               GropeGestureEvent *event,
-               gpointer           user_data)
-{
-  in_touch++;
-
-  gtk_widget_queue_draw (GTK_WIDGET (window));
-}
-
-static void
-gesture_end (GtkWindow         *window,
-             GropeGestureEvent *event,
-             gpointer           user_data)
-{
-  in_touch--;
-
-  gtk_widget_queue_draw (GTK_WIDGET (window));
-}
-
-static void
-rotate_update (GtkWindow         *window,
-               GropeGestureEvent *event,
-               gpointer           user_data)
-{
-  GropeEventGestureRotate *e = (GropeEventGestureRotate *)event;
-
-  rotate += e->angle_delta * 100;
-
-  gtk_widget_queue_draw (GTK_WIDGET (window));
-}
-
-static void
-pinch_update (GtkWindow         *window,
-              GropeGestureEvent *event,
-              gpointer           user_data)
-{
-  GropeEventGesturePinch *e = (GropeEventGesturePinch *)event;
-
-  scale += e->radius_delta / 100;
-
-  gtk_widget_queue_draw (GTK_WIDGET (window));
-}
-
-static void
-drag_update (GtkWindow         *window,
-             GropeGestureEvent *event,
-             gpointer           user_data)
-{
-  GropeEventGestureDrag *e = (GropeEventGestureDrag *)event;
-
-  translate[0] += e->delta_x;
-  translate[1] += e->delta_y;
+gesture_callback (GtkWindow         *window,
+                  GropeTimeType      time_type,
+                  GropeGestureEvent *event,
+                  gpointer           user_data)
+{
+  if (time_type == GROPE_TIME_START)
+    {
+      in_touch++;
+    }
+  else if (time_type == GROPE_TIME_END)
+    {
+      in_touch--;
+    }
+  else
+    {
+      switch (event->type)
+        {
+        case GROPE_GESTURE_DRAG:
+          {
+            GropeEventGestureDrag *e = (GropeEventGestureDrag *)event;
+
+            translate[0] += e->delta_x;
+            translate[1] += e->delta_y;
+          }
+          break;
+
+        case GROPE_GESTURE_PINCH:
+          {
+            GropeEventGesturePinch *e = (GropeEventGesturePinch *)event;
+
+            scale += e->radius_delta / 100;
+          }
+          break;
+
+        case GROPE_GESTURE_ROTATE:
+          {
+            GropeEventGestureRotate *e = (GropeEventGestureRotate *)event;
+
+            rotate += e->angle_delta * 100;
+          }
+          break;
+        }
+    }
 
   gtk_widget_queue_draw (GTK_WIDGET (window));
 }
@@ -127,27 +118,21 @@
 					 window,
 					 GROPE_GESTURE_PINCH,
 					 2,
-					 gesture_start,
-					 pinch_update,
-					 gesture_end,
+					 gesture_callback,
                                          NULL, NULL);
 
   grope_gesture_manager_register_window (manager,
 					 window,
 					 GROPE_GESTURE_ROTATE,
 					 2,
-					 gesture_start,
-					 rotate_update,
-					 gesture_end,
+					 gesture_callback,
                                          NULL, NULL);
 
   grope_gesture_manager_register_window (manager,
 					 window,
 					 GROPE_GESTURE_DRAG,
 					 2,
-					 gesture_start,
-					 drag_update,
-					 gesture_end,
+					 gesture_callback,
                                          NULL, NULL);
 }
 

=== added directory 'example/python'
=== added file 'example/python/example.py'
--- example/python/example.py	1970-01-01 00:00:00 +0000
+++ example/python/example.py	2010-11-16 20:23:13 +0000
@@ -0,0 +1,48 @@
+import pygtk
+from gi.repository import Gtk
+from gi.repository import Grope
+
+# XXX For now, we'll use Grope directly. Once we have a good sense of what's
+# going to be needed in general for general Python code using Grope, we might
+# want to put that stuff in a wrapper grope module, and import everything from
+# there instead.
+
+
+class GestureTester(object):
+
+    def __init__(self):
+        builder = Gtk.Builder()
+        builder.add_from_file("pygrope-gestures.xml")
+        builder.connect_signals(self)
+        self.window = builder.get_object("window1")
+        self.window.show()
+
+    def window_mapped(self, widget, data=None):
+        # The gesture manager is only going to be needed for GTK2, since GTK3
+        # will have the gesture API natively. Conversely, pygrope will only be
+        # for GTK2, since PyGTK3 will having the bindings.
+        gesture_manager = Grope.GestureManager()
+        # For the purpose of this example, we are registering all gestures; we
+        # could limit this by choosing a different pygrope.GROPE_GESTURE_*
+        # mask. Similarly, we're using one set of callbacks for all the
+        # gestures; we could have different callbacks for different registered
+        # gestures.
+        # XXX the comment above is for the new API; the example below has been
+        # reverted to the older API until the new one is merged to trunk.
+        finger_count = 2
+        gesture_manager.register_window(self.window,
+                                        Grope.GestureType.PINCH,
+                                        finger_count,
+                                        self.callback,
+                                        None, None)
+
+    def callback(self, window, time_type, gesture_type, gesture_event):
+        print "received gesture"
+
+    def quit(self, widget, data=None):
+        Gtk.main_quit()
+
+
+if __name__ == "__main__":
+    app = GestureTester()
+    Gtk.main()

=== added file 'example/python/pygrope-gestures.xml'
--- example/python/pygrope-gestures.xml	1970-01-01 00:00:00 +0000
+++ example/python/pygrope-gestures.xml	2010-11-16 20:23:13 +0000
@@ -0,0 +1,16 @@
+<?xml version="1.0"?>
+<interface>
+  <requires lib="gtk+" version="2.16"/>
+  <!-- interface-naming-policy project-wide -->
+  <object class="GtkWindow" id="window1">
+    <property name="width_request">0</property>
+    <property name="height_request">0</property>
+    <property name="default_width">1400</property>
+    <property name="default_height">800</property>
+    <signal name="map_event" handler="window_mapped"/>
+    <signal name="delete_event" handler="quit"/>
+    <child>
+      <placeholder/>
+    </child>
+  </object>
+</interface>

=== modified file 'src/gropegesturemanager.c'
--- src/gropegesturemanager.c	2010-11-10 19:56:11 +0000
+++ src/gropegesturemanager.c	2010-11-16 20:23:13 +0000
@@ -40,9 +40,7 @@
 {
   GropeGestureType      type;
   gint                  touches;
-  GropeGestureCallback  start;
-  GropeGestureCallback  update;
-  GropeGestureCallback  end;
+  GropeGestureCallback  callback;
   gpointer              data;
   GDestroyNotify        destroy;
 };
@@ -367,9 +365,10 @@
 
               if (drag.fingers == binding->touches)
                 {
-                  binding->start (reg->window,
-                                  ((GropeGestureEvent*)&drag),
-                                  binding->data);
+                  binding->callback (reg->window,
+                                     GROPE_TIME_START,
+                                     ((GropeGestureEvent*)&drag),
+                                     binding->data);
                 }
             }
           else if (type == GROPE_GESTURE_PINCH)
@@ -384,9 +383,10 @@
 
               if (pinch.fingers == binding->touches)
                 {
-                  binding->start (reg->window,
-                                  ((GropeGestureEvent*)&pinch),
-                                  binding->data);
+                  binding->callback (reg->window,
+                                     GROPE_TIME_START,
+                                     ((GropeGestureEvent*)&pinch),
+                                     binding->data);
                 }
             }
           else if (type == GROPE_GESTURE_ROTATE)
@@ -401,9 +401,10 @@
 
               if (rotate.fingers == binding->touches)
                 {
-                  binding->start (reg->window,
-                                  ((GropeGestureEvent*)&rotate),
-                                  binding->data);
+                  binding->callback (reg->window,
+                                     GROPE_TIME_START,
+                                     ((GropeGestureEvent*)&rotate),
+                                     binding->data);
                 }
             }
 
@@ -440,9 +441,10 @@
 
               if (drag.fingers == binding->touches)
                 {
-                  binding->update (reg->window,
-                                   ((GropeGestureEvent*)&drag),
-                                   binding->data);
+                  binding->callback (reg->window,
+                                     GROPE_TIME_UPDATE,
+                                     ((GropeGestureEvent*)&drag),
+                                     binding->data);
                 }
             }
           else if (type == GROPE_GESTURE_PINCH)
@@ -457,9 +459,10 @@
 
               if (pinch.fingers == binding->touches)
                 {
-                  binding->update (reg->window,
-                                   ((GropeGestureEvent*)&pinch),
-                                   binding->data);
+                  binding->callback (reg->window,
+                                     GROPE_TIME_UPDATE,
+                                     ((GropeGestureEvent*)&pinch),
+                                     binding->data);
                 }
             }
           else if (type == GROPE_GESTURE_ROTATE)
@@ -474,9 +477,10 @@
 
               if (rotate.fingers == binding->touches)
                 {
-                  binding->update (reg->window,
-                                   ((GropeGestureEvent*)&rotate),
-                                   binding->data);
+                  binding->callback (reg->window,
+                                     GROPE_TIME_UPDATE,
+                                     ((GropeGestureEvent*)&rotate),
+                                     binding->data);
                 }
             }
         }
@@ -511,9 +515,10 @@
 
               if (drag.fingers == binding->touches)
                 {
-                  binding->end (reg->window,
-                                ((GropeGestureEvent*)&drag),
-                                binding->data);
+                  binding->callback (reg->window,
+                                     GROPE_TIME_END,
+                                     ((GropeGestureEvent*)&drag),
+                                     binding->data);
                 }
             }
           else if (type == GROPE_GESTURE_PINCH)
@@ -528,9 +533,10 @@
 
               if (pinch.fingers == binding->touches)
                 {
-                  binding->end (reg->window,
-                                ((GropeGestureEvent*)&pinch),
-                                binding->data);
+                  binding->callback (reg->window,
+                                     GROPE_TIME_END,
+                                     ((GropeGestureEvent*)&pinch),
+                                     binding->data);
                 }
             }
           else if (type == GROPE_GESTURE_ROTATE)
@@ -545,9 +551,10 @@
 
               if (rotate.fingers == binding->touches)
                 {
-                  binding->end (reg->window,
-                                ((GropeGestureEvent*)&rotate),
-                                binding->data);
+                  binding->callback (reg->window,
+                                     GROPE_TIME_END,
+                                     ((GropeGestureEvent*)&rotate),
+                                     binding->data);
                 }
             }
         }
@@ -619,12 +626,11 @@
 
 /**
  * grope_gesture_manager_register_window:
+ * @manager: A #GropeGestureManager instance.
  * @window: A #GtkWindow to register the gesture event for.
  * @gesture_type: The type of gesture event to register.
  * @touch_points: Number of touch points for this gesture.
- * @start: Called when a user initiates a gesture.
- * @update: Called each time the user updates the gesture.
- * @end: Called when the user ends the gesture.
+ * @callback: Called when a gesture starts, updates, or ends.
  * @user_data: User data
  * @destroy: Destroy callback for user data.
  *
@@ -638,9 +644,7 @@
 				       GtkWindow           *window,
 				       GropeGestureType     gesture_type,
 				       gint                 touch_points,
-				       GropeGestureCallback start,
-				       GropeGestureCallback update,
-				       GropeGestureCallback end,
+				       GropeGestureCallback callback,
                                        gpointer             user_data,
                                        GDestroyNotify       destroy)
 {
@@ -718,13 +722,11 @@
   /* XXX - check for duplicates in reg->bindings first */
   binding = g_new0 (GropeGestureBinding, 1);
 
-  binding->type    = gesture_type;
-  binding->touches = touch_points;
-  binding->start   = start;
-  binding->update  = update;
-  binding->end     = end;
-  binding->data    = user_data;
-  binding->destroy = destroy;
+  binding->type     = gesture_type;
+  binding->touches  = touch_points;
+  binding->callback = callback;
+  binding->data     = user_data;
+  binding->destroy  = destroy;
 
   reg->bindings = g_list_append (reg->bindings, binding);
 

=== modified file 'src/gropegesturemanager.h'
--- src/gropegesturemanager.h	2010-11-10 19:56:11 +0000
+++ src/gropegesturemanager.h	2010-11-16 20:23:13 +0000
@@ -52,6 +52,12 @@
   GROPE_GESTURE_ROTATE
 } GropeGestureType;
 
+typedef enum {
+  GROPE_TIME_START,
+  GROPE_TIME_UPDATE,
+  GROPE_TIME_END
+} GropeTimeType;
+
 struct _GropeEventGestureDrag
 {
   GropeGestureType  type;
@@ -136,6 +142,7 @@
 };
 
 typedef void (* GropeGestureCallback) (GtkWindow          *window,
+                                       GropeTimeType       time,
 				       GropeGestureEvent  *gesture,
                                        gpointer            user_data);
 
@@ -145,9 +152,7 @@
 							    GtkWindow           *window,
 							    GropeGestureType     gesture_type,
 							    gint                 touch_points,
-							    GropeGestureCallback start,
-							    GropeGestureCallback update,
-							    GropeGestureCallback end,
+							    GropeGestureCallback callback,
                                                             gpointer             user_data,
                                                             GDestroyNotify       destroy);