Merge lp:~ken-vandine/libgrip/packaging-with-gir-and-python into lp:~oif-team/libgrip/packaging

[Ken VanDine]

[Cody Russell (bratsche)]

review: Approve

=== modified file 'Makefile.am'
--- Makefile.am	2010-11-22 14:49:44 +0000
+++ Makefile.am	2011-01-24 20:08:35 +0000
@@ -4,7 +4,7 @@
 Q         = $(V:1=)
 QUIET_GEN = $(Q:@=@echo '  GEN   '$@;)
 
-SUBDIRS = build src examples/rectangle-mover
+SUBDIRS = build src bindings examples/rectangle-mover
 
 libgrip-0.1.pc: libgrip.pc
 	$(QUIET_GEN) cp -f libgrip.pc libgrip-0.1.pc

=== added directory 'bindings'
=== added file 'bindings/Makefile.am'
--- bindings/Makefile.am	1970-01-01 00:00:00 +0000
+++ bindings/Makefile.am	2011-01-24 20:08:35 +0000
@@ -0,0 +1,1 @@
+SUBDIRS = python

=== added directory 'bindings/python'
=== added file 'bindings/python/Grip.py'
--- bindings/python/Grip.py	1970-01-01 00:00:00 +0000
+++ bindings/python/Grip.py	2011-01-24 20:08:35 +0000
@@ -0,0 +1,52 @@
+#
+# Copyright 2010 Canonical, Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of either or both of the following licenses:
+#
+# 1) the GNU Lesser General Public License version 3, as published by the
+# Free Software Foundation; and/or
+# 2) the GNU Lesser General Public License version 2.1, as published by
+# the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the applicable version of the GNU Lesser General Public
+# License for more details.
+#
+# You should have received a copy of both the GNU Lesser General Public
+# License version 3 and version 2.1 along with this program.  If not, see
+# <http://www.gnu.org/licenses/>
+#
+# Authors:
+#    Cody Russell <[e-mail]>
+#
+
+from ..overrides import override
+from ..importer import modules
+
+Grip = modules['Grip'].introspection_module
+
+__all__ = []
+
+class GestureEvent(Grip.GestureEvent):
+    _UNION_MEMBERS = {
+        Grip.GestureType.DRAG: 'drag',
+        Grip.GestureType.PINCH: 'pinch',
+        Grip.GestureType.ROTATE: 'rotate',
+        Grip.GestureType.TAP: 'tap'
+    }
+
+    def __new__(cls, *args, **kwargs):
+        return Grip.GestureEvent.__new__(cls)
+
+    def __getattr__(self, name):
+        real_event = getattr(self, '_UNION_MEMBERS').get(self.type)
+        if real_event:
+            return getattr(getattr(self, real_event), name)
+        else:
+            return getattr(self, name)
+
+GestureEvent = override(GestureEvent)
+__all__.append('GestureEvent')

=== added file 'bindings/python/Makefile.am'
--- bindings/python/Makefile.am	1970-01-01 00:00:00 +0000
+++ bindings/python/Makefile.am	2011-01-24 20:08:35 +0000
@@ -0,0 +1,9 @@
+PLATFORM_VERSION = 2.0
+
+pkgpyexecdir = $(pyexecdir)/gi
+
+pygioverridesdir = $(pkgpyexecdir)/overrides
+pygioverrides_PYTHON = \
+        Grip.py
+
+EXTRA_DIST = Grip.py

=== modified file 'configure.ac'
--- configure.ac	2011-01-03 19:12:52 +0000
+++ configure.ac	2011-01-24 20:08:35 +0000
@@ -27,6 +27,8 @@
 AM_INIT_AUTOMAKE([1.9])
 AM_MAINTAINER_MODE
 
+AM_PATH_PYTHON
+
 GRIP_MAJOR_VERSION=grip_major_version
 GRIP_MINOR_VERSION=grip_minor_version
 GRIP_MICRO_VERSION=grip_micro_version
@@ -119,6 +121,8 @@
   build/autotools/shave-libtool
   build/autotools/shave
   src/Makefile
+  bindings/python/Makefile
+  bindings/Makefile
   examples/rectangle-mover/Makefile
   libgrip.pc
 ])

=== modified file 'debian/changelog'
--- debian/changelog	2011-01-03 19:18:45 +0000
+++ debian/changelog	2011-01-24 20:08:35 +0000
@@ -1,3 +1,21 @@
+libgrip (0.1.1-0ubuntu2) UNRELEASED; urgency=low
+
+  * Merged lp:~bratsche/libgrip/python-fixage-wip branch
+  * debian/{control,gir1.2-grip-0.1.install,libgrip-0.1-dev.install}
+    - Install the gir and typelib
+    - Added build depends for packages needed to build the GIR
+    - Added build depends for dh-autoreconf
+  * debian/{control,python-grip.install}
+    - Added new package for the python bindings (just a gi.overrides)
+  * debian/rules
+    - added dh_girepository for gir:Depends
+    - include autoreconf.mk
+  * +debian/source/format
+  * debian/libgrip-0.1-0.symbols
+    - Added new symbols
+
+ -- Ken VanDine <[e-mail]>  Mon, 24 Jan 2011 14:32:30 -0500
+
 libgrip (0.1.1-0ubuntu1) natty; urgency=low
 
   * Bump version and release for Natty.

=== modified file 'debian/control'
--- debian/control	2010-11-29 22:07:57 +0000
+++ debian/control	2011-01-24 20:08:35 +0000
@@ -1,14 +1,23 @@
 Source: libgrip
 Section: libs
 Priority: optional
+XS-Python-Version: all
 Maintainer: Cody Russell <[e-mail]>
 Build-Depends: debhelper (>= 5.0),
                cdbs (>= 0.4.41),
                libglib2.0-dev (>=2.14.0),
                libgtk2.0-dev (>= 2.21.5-1ubuntu3),
                gtk-doc-tools,
-               libutouch-geis-dev
-Standards-Version: 3.8.4
+               libutouch-geis-dev,
+               gobject-introspection,
+               libgirepository1.0-dev,
+               gir1.2-glib-2.0,
+               gir1.2-gtk-2.0,
+               gir1.2-pango-1.0,
+               gir1.2-gdkpixbuf-2.0,
+               gir1.2-freedesktop,
+               dh-autoreconf
+Standards-Version: 3.9.1
 Homepage: https://launchpad.net/libgrip
 
 Package: libgrip-0.1-0
@@ -32,3 +41,23 @@
 Description: Shared library providing multitouch gestures to gtk apps.
  .
  This package contains files that are needed to build applications.
+
+Package: gir1.2-grip-0.1
+Section: libs
+Architecture: any
+Depends: ${misc:Depends},
+         ${gir:Depends}
+Description: typelib file for libgrip
+ .
+ This package can be used by other packages using the GIRepository format to
+ generate dynamic bindings for libgrip
+
+Package: python-grip
+Section: python
+Architecture: all
+Depends: ${misc:Depends},
+         ${python:Depends}
+Description: python bindings for libgrip
+ .
+ This package provides Python bindings so that you can use libgrip from
+ a Python program.

=== added file 'debian/gir1.2-grip-0.1.install'
--- debian/gir1.2-grip-0.1.install	1970-01-01 00:00:00 +0000
+++ debian/gir1.2-grip-0.1.install	2011-01-24 20:08:35 +0000
@@ -0,0 +1,1 @@
+debian/tmp/usr/lib/girepository-1.0/Grip-0.1.typelib

=== modified file 'debian/libgrip-0.1-0.symbols'
--- debian/libgrip-0.1-0.symbols	2010-11-24 17:06:51 +0000
+++ debian/libgrip-0.1-0.symbols	2011-01-24 20:08:35 +0000
@@ -1,4 +1,8 @@
 libgrip-0.1.so.0 libgrip-0.1-0 #MINVER#
+ grip_gesture_event_copy@Base 0.1.1
+ grip_gesture_event_free@Base 0.1.1
+ grip_gesture_event_get_type@Base 0.1.1
+ grip_gesture_event_new@Base 0.1.1
  grip_gesture_manager_get@Base 0.1.0
  grip_gesture_manager_get_type@Base 0.1.0
  grip_gesture_manager_register_window@Base 0.1.0

=== modified file 'debian/libgrip-0.1-dev.install'
--- debian/libgrip-0.1-dev.install	2010-11-24 17:06:51 +0000
+++ debian/libgrip-0.1-dev.install	2011-01-24 20:08:35 +0000
@@ -1,3 +1,4 @@
 debian/tmp/usr/include/
 debian/tmp/usr/lib/pkgconfig
 debian/tmp/usr/lib/*.so
+debian/tmp/usr/share/gir-1.0/Grip-0.1.gir

=== added file 'debian/python-grip.install'
--- debian/python-grip.install	1970-01-01 00:00:00 +0000
+++ debian/python-grip.install	2011-01-24 20:08:35 +0000
@@ -0,0 +1,1 @@
+debian/tmp/usr/*/*python*

=== modified file 'debian/rules'
--- debian/rules	2010-11-24 17:06:51 +0000
+++ debian/rules	2011-01-24 20:08:35 +0000
@@ -2,8 +2,10 @@
 
 include /usr/share/cdbs/1/rules/debhelper.mk
 include /usr/share/cdbs/1/class/autotools.mk
-include /usr/share/cdbs/1/rules/simple-patchsys.mk
 include /usr/share/cdbs/1/rules/utils.mk
+include /usr/share/cdbs/1/rules/autoreconf.mk
+
+DEB_PYTHON_SYSTEM=dh_python2
 
 DEB_CONFIGURE_SCRIPT_ENV += LDFLAGS="-Wl,-O1 -Wl,--as-needed"
 DEB_COMPRESS_EXCLUDE = .c
@@ -14,4 +16,10 @@
 	find debian/tmp/usr/lib -name \*.la -exec rm {} \;
 	find debian/tmp/usr/lib -name \*.a -exec rm {} \;
 
+binary-predeb/gir%::
+	dh_girepository -p$(cdbs_curpkg)
+
+binary-predeb/python-grip::
+	dh_python2 -ppython-grip
+
 common-binary-predeb-arch:: list-missing

=== added directory 'debian/source'
=== added file 'debian/source/format'
--- debian/source/format	1970-01-01 00:00:00 +0000
+++ debian/source/format	2011-01-24 20:08:35 +0000
@@ -0,0 +1,1 @@
+3.0 (quilt)

=== modified file 'examples/pygrip/pygrip-gestures.xml'
--- examples/pygrip/pygrip-gestures.xml	2010-11-22 15:07:31 +0000
+++ examples/pygrip/pygrip-gestures.xml	2011-01-24 20:08:35 +0000
@@ -5,8 +5,8 @@
   <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>
+    <property name="default_width">800</property>
+    <property name="default_height">600</property>
     <signal name="map_event" handler="window_mapped"/>
     <signal name="delete_event" handler="quit"/>
     <child>

=== modified file 'examples/pygrip/pygrip.py' (properties changed: -x to +x)
--- examples/pygrip/pygrip.py	2010-11-22 15:07:31 +0000
+++ examples/pygrip/pygrip.py	2011-01-24 20:08:35 +0000
@@ -1,5 +1,6 @@
-import pygtk
+#!/usr/bin/python
 from gi.repository import Gtk
+Gtk.require_version('2.0')
 from gi.repository import Grip
 
 
@@ -16,26 +17,18 @@
         builder.add_from_file("pygrip-gestures.xml")
         builder.connect_signals(self)
         self.window = builder.get_object("window1")
+        self.gesture_manager = Grip.GestureManager()
         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, pygrip will only be
         # for GTK2, since PyGTK3 will having the bindings.
-        gesture_manager = Grip.GestureManager()
-        # For the purpose of this example, we are registering all gestures; we
-        # could limit this by choosing a different pygrip.GRIP_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, Grip.GestureType.PINCH, finger_count,self.callback,
-            None, None)
+        self.gesture_manager.register_window(widget, Grip.GestureType.PINCH, finger_count, self.callback, None)
 
-    def callback(self, window, time_type, gesture_type, gesture_event):
+    def callback(self, window, time_type, gesture_event, data):
         print "received gesture"
 
     def quit(self, widget, data=None):

=== modified file 'src/Makefile.am'
--- src/Makefile.am	2010-11-22 14:49:44 +0000
+++ src/Makefile.am	2011-01-24 20:08:35 +0000
@@ -38,6 +38,7 @@
 	$(INTROSPECTION_SCANNER)						\
 		-v --namespace Grip						\
 		--nsversion=0.1							\
+		--warn-all							\
 		--add-include-path=$(srcdir) $(GTK_CFLAGS)			\
 		--include=GObject-2.0						\
 		--include=GLib-2.0						\
@@ -104,4 +105,5 @@
 DISTCLEANFILES =			\
 	stamp-griptypebuiltins.h	\
 	griptypebuiltins.h		\
-	griptypebuiltins.c
\ No newline at end of file
+	griptypebuiltins.c
+

=== modified file 'src/gripgesturemanager.c'
--- src/gripgesturemanager.c	2011-01-18 15:32:31 +0000
+++ src/gripgesturemanager.c	2011-01-24 20:08:35 +0000
@@ -485,102 +485,106 @@
 
       if (binding->type == type)
         {
+	  GripGestureEvent *event = grip_gesture_event_new (type);
+
           if (type == GRIP_GESTURE_DRAG)
             {
-              GripEventGestureDrag drag;
-
-              drag.type    = type;
-              drag.id      = id;
-              drag.fingers = drag_gesture_handle_properties (&drag,
-                                                             attr_count,
-                                                             attrs);
-
-              if (drag.fingers == binding->touches)
+              GripEventGestureDrag *drag = (GripEventGestureDrag *)event;
+
+              drag->type    = type;
+              drag->id      = id;
+              drag->fingers = drag_gesture_handle_properties (drag,
+							      attr_count,
+							      attrs);
+
+              if (drag->fingers == binding->touches)
                 {
                   if (matches_widget (binding->widget,
                                       GTK_WIDGET (reg->window)->window,
-                                      (gint)drag.focus_x,
-                                      (gint)drag.focus_y))
+                                      (gint)drag->focus_x,
+                                      (gint)drag->focus_y))
                     {
                       binding->callback (binding->widget,
                                          GRIP_TIME_START,
-                                         ((GripGestureEvent*)&drag),
+                                         event,
                                          binding->data);
                     }
                 }
             }
           else if (type == GRIP_GESTURE_PINCH)
             {
-              GripEventGesturePinch pinch;
-
-              pinch.type    = type;
-              pinch.id      = id;
-              pinch.fingers = pinch_gesture_handle_properties (&pinch,
-                                                               attr_count,
-                                                               attrs);
-
-              if (pinch.fingers == binding->touches)
+              GripEventGesturePinch *pinch = (GripEventGesturePinch *)event;
+
+              pinch->type    = type;
+              pinch->id      = id;
+              pinch->fingers = pinch_gesture_handle_properties (pinch,
+								attr_count,
+								attrs);
+
+              if (pinch->fingers == binding->touches)
                 {
                   if (matches_widget (binding->widget,
                                       GTK_WIDGET (reg->window)->window,
-                                      (gint)pinch.focus_x,
-                                      (gint)pinch.focus_y))
+                                      (gint)pinch->focus_x,
+                                      (gint)pinch->focus_y))
                     {
                       binding->callback (binding->widget,
                                          GRIP_TIME_START,
-                                         ((GripGestureEvent*)&pinch),
+                                         event,
                                          binding->data);
                     }
                 }
             }
           else if (type == GRIP_GESTURE_ROTATE)
             {
-              GripEventGestureRotate rotate;
-
-              rotate.type    = type;
-              rotate.id      = id;
-              rotate.fingers = rotate_gesture_handle_properties (&rotate,
-                                                                 attr_count,
-                                                                 attrs);
-
-              if (rotate.fingers == binding->touches)
+              GripEventGestureRotate *rotate = (GripEventGestureRotate *)event;
+
+              rotate->type    = type;
+              rotate->id      = id;
+              rotate->fingers = rotate_gesture_handle_properties (rotate,
+								  attr_count,
+								  attrs);
+
+              if (rotate->fingers == binding->touches)
                 {
                   if (matches_widget (binding->widget,
                                       GTK_WIDGET (reg->window)->window,
-                                      (gint)rotate.focus_x,
-                                      (gint)rotate.focus_y))
+                                      (gint)rotate->focus_x,
+                                      (gint)rotate->focus_y))
                     {
                       binding->callback (binding->widget,
                                          GRIP_TIME_START,
-                                         ((GripGestureEvent*)&rotate),
+                                         event,
                                          binding->data);
                     }
                 }
             }
 	  else if (type == GRIP_GESTURE_TAP)
 	    {
-	      GripEventGestureTap tap;
-
-	      tap.type    = type;
-	      tap.id      = id;
-	      tap.fingers = tap_gesture_handle_properties (&tap,
-							   attr_count,
-							   attrs);
-
-	      if (tap.fingers == binding->touches)
+	      GripEventGestureTap *tap = (GripEventGestureTap *)event;
+
+	      tap->type    = type;
+	      tap->id      = id;
+	      tap->fingers = tap_gesture_handle_properties (tap,
+							    attr_count,
+							    attrs);
+
+	      if (tap->fingers == binding->touches)
 		{
                   if (matches_widget (binding->widget,
                                       GTK_WIDGET (reg->window)->window,
-                                      (gint)tap.focus_x,
-                                      (gint)tap.focus_y))
+                                      (gint)tap->focus_x,
+                                      (gint)tap->focus_y))
                     {
                       binding->callback (binding->widget,
                                          GRIP_TIME_START,
-                                         ((GripGestureEvent*)&tap),
+                                         event,
                                          binding->data);
                     }
                 }
 	    }
+
+	  grip_gesture_event_free (event);
         }
     }
 }
@@ -601,102 +605,106 @@
 
       if (binding->type == type)
         {
+	  GripGestureEvent *event = grip_gesture_event_new (type);
+
           if (type == GRIP_GESTURE_DRAG)
             {
-              GripEventGestureDrag drag;
-
-              drag.type    = type;
-              drag.id      = id;
-              drag.fingers = drag_gesture_handle_properties (&drag,
-                                                             attr_count,
-                                                             attrs);
-
-              if (drag.fingers == binding->touches)
+              GripEventGestureDrag *drag = (GripEventGestureDrag *)event;
+
+              drag->type    = type;
+              drag->id      = id;
+              drag->fingers = drag_gesture_handle_properties (drag,
+							      attr_count,
+							      attrs);
+
+              if (drag->fingers == binding->touches)
                 {
                   if (matches_widget (binding->widget,
                                       GTK_WIDGET (reg->window)->window,
-                                      (gint)drag.focus_x,
-                                      (gint)drag.focus_y))
+                                      (gint)drag->focus_x,
+                                      (gint)drag->focus_y))
                     {
                       binding->callback (binding->widget,
                                          GRIP_TIME_UPDATE,
-                                         ((GripGestureEvent*)&drag),
+                                         event,
                                          binding->data);
                     }
                 }
             }
           else if (type == GRIP_GESTURE_PINCH)
             {
-              GripEventGesturePinch pinch;
-
-              pinch.type    = type;
-              pinch.id      = id;
-              pinch.fingers = pinch_gesture_handle_properties (&pinch,
-                                                               attr_count,
-                                                               attrs);
-
-              if (pinch.fingers == binding->touches)
+              GripEventGesturePinch *pinch = (GripEventGesturePinch *)event;
+
+              pinch->type    = type;
+              pinch->id      = id;
+              pinch->fingers = pinch_gesture_handle_properties (pinch,
+								attr_count,
+								attrs);
+
+              if (pinch->fingers == binding->touches)
                 {
                   if (matches_widget (binding->widget,
                                       GTK_WIDGET (reg->window)->window,
-                                      (gint)pinch.focus_x,
-                                      (gint)pinch.focus_y))
+                                      (gint)pinch->focus_x,
+                                      (gint)pinch->focus_y))
                     {
                       binding->callback (binding->widget,
                                          GRIP_TIME_UPDATE,
-                                         ((GripGestureEvent*)&pinch),
+                                         event,
                                          binding->data);
                     }
                 }
             }
           else if (type == GRIP_GESTURE_ROTATE)
             {
-              GripEventGestureRotate rotate;
-
-              rotate.type    = type;
-              rotate.id      = id;
-              rotate.fingers = rotate_gesture_handle_properties (&rotate,
-                                                                 attr_count,
-                                                                 attrs);
-
-              if (rotate.fingers == binding->touches)
+              GripEventGestureRotate *rotate = (GripEventGestureRotate *)event;
+
+              rotate->type    = type;
+              rotate->id      = id;
+              rotate->fingers = rotate_gesture_handle_properties (rotate,
+								  attr_count,
+								  attrs);
+
+              if (rotate->fingers == binding->touches)
                 {
                   if (matches_widget (binding->widget,
                                       GTK_WIDGET (reg->window)->window,
-                                      (gint)rotate.focus_x,
-                                      (gint)rotate.focus_y))
+                                      (gint)rotate->focus_x,
+                                      (gint)rotate->focus_y))
                     {
                       binding->callback (binding->widget,
                                          GRIP_TIME_UPDATE,
-                                         ((GripGestureEvent*)&rotate),
+                                         event,
                                          binding->data);
                     }
                 }
             }
 	  else if (type == GRIP_GESTURE_TAP)
 	    {
-	      GripEventGestureTap tap;
-
-	      tap.type    = type;
-	      tap.id      = id;
-	      tap.fingers = tap_gesture_handle_properties (&tap,
-							   attr_count,
-							   attrs);
-
-	      if (tap.fingers == binding->touches)
+	      GripEventGestureTap *tap = (GripEventGestureTap *)event;
+
+	      tap->type    = type;
+	      tap->id      = id;
+	      tap->fingers = tap_gesture_handle_properties (tap,
+							    attr_count,
+							    attrs);
+
+	      if (tap->fingers == binding->touches)
 		{
                   if (matches_widget (binding->widget,
                                       GTK_WIDGET (reg->window)->window,
-                                      (gint)tap.focus_x,
-                                      (gint)tap.focus_y))
+                                      (gint)tap->focus_x,
+                                      (gint)tap->focus_y))
                     {
                       binding->callback (binding->widget,
                                          GRIP_TIME_UPDATE,
-                                         ((GripGestureEvent*)&tap),
+                                         event,
                                          binding->data);
                     }
                 }
 	    }
+
+	  grip_gesture_event_free (event);
         }
     }
 }
@@ -717,102 +725,106 @@
 
       if (binding->type == type)
         {
+	  GripGestureEvent *event = grip_gesture_event_new (type);
+
           if (type == GRIP_GESTURE_DRAG)
             {
-              GripEventGestureDrag drag;
-
-              drag.type    = type;
-              drag.id      = id;
-              drag.fingers = drag_gesture_handle_properties (&drag,
-                                                             attr_count,
-                                                             attrs);
-
-              if (drag.fingers == binding->touches)
+              GripEventGestureDrag *drag = (GripEventGestureDrag *)event;
+
+              drag->type    = type;
+              drag->id      = id;
+              drag->fingers = drag_gesture_handle_properties (drag,
+							      attr_count,
+							      attrs);
+
+              if (drag->fingers == binding->touches)
                 {
                   if (matches_widget (binding->widget,
                                       GTK_WIDGET (reg->window)->window,
-                                      (gint)drag.focus_x,
-                                      (gint)drag.focus_y))
+                                      (gint)drag->focus_x,
+                                      (gint)drag->focus_y))
                     {
                       binding->callback (binding->widget,
                                          GRIP_TIME_END,
-                                         ((GripGestureEvent*)&drag),
+                                         event,
                                          binding->data);
                     }
                 }
             }
           else if (type == GRIP_GESTURE_PINCH)
             {
-              GripEventGesturePinch pinch;
-
-              pinch.type    = type;
-              pinch.id      = id;
-              pinch.fingers = pinch_gesture_handle_properties (&pinch,
-                                                               attr_count,
-                                                               attrs);
-
-              if (pinch.fingers == binding->touches)
+              GripEventGesturePinch *pinch = (GripEventGesturePinch *)event;
+
+              pinch->type    = type;
+              pinch->id      = id;
+              pinch->fingers = pinch_gesture_handle_properties (pinch,
+								attr_count,
+								attrs);
+
+              if (pinch->fingers == binding->touches)
                 {
                   if (matches_widget (binding->widget,
                                       GTK_WIDGET (reg->window)->window,
-                                      (gint)pinch.focus_x,
-                                      (gint)pinch.focus_y))
+                                      (gint)pinch->focus_x,
+                                      (gint)pinch->focus_y))
                     {
                       binding->callback (binding->widget,
                                          GRIP_TIME_END,
-                                         ((GripGestureEvent*)&pinch),
+                                         event,
                                          binding->data);
                     }
                 }
             }
           else if (type == GRIP_GESTURE_ROTATE)
             {
-              GripEventGestureRotate rotate;
-
-              rotate.type    = type;
-              rotate.id      = id;
-              rotate.fingers = rotate_gesture_handle_properties (&rotate,
-                                                                 attr_count,
-                                                                 attrs);
-
-              if (rotate.fingers == binding->touches)
+              GripEventGestureRotate *rotate = (GripEventGestureRotate *)event;
+
+              rotate->type    = type;
+              rotate->id      = id;
+              rotate->fingers = rotate_gesture_handle_properties (rotate,
+								  attr_count,
+								  attrs);
+
+              if (rotate->fingers == binding->touches)
                 {
                   if (matches_widget (binding->widget,
                                       GTK_WIDGET (reg->window)->window,
-                                      (gint)rotate.focus_x,
-                                      (gint)rotate.focus_y))
+                                      (gint)rotate->focus_x,
+                                      (gint)rotate->focus_y))
                     {
                       binding->callback (binding->widget,
                                          GRIP_TIME_END,
-                                         ((GripGestureEvent*)&rotate),
+                                         event,
                                          binding->data);
                     }
                 }
             }
 	  else if (type == GRIP_GESTURE_TAP)
 	    {
-	      GripEventGestureTap tap;
-
-	      tap.type    = type;
-	      tap.id      = id;
-	      tap.fingers = tap_gesture_handle_properties (&tap,
-							   attr_count,
-							   attrs);
-
-	      if (tap.fingers == binding->touches)
+	      GripEventGestureTap *tap = (GripEventGestureTap *)event;
+
+	      tap->type    = type;
+	      tap->id      = id;
+	      tap->fingers = tap_gesture_handle_properties (tap,
+							    attr_count,
+							    attrs);
+
+	      if (tap->fingers == binding->touches)
 		{
                   if (matches_widget (binding->widget,
                                       GTK_WIDGET (reg->window)->window,
-                                      (gint)tap.focus_x,
-                                      (gint)tap.focus_y))
+                                      (gint)tap->focus_x,
+                                      (gint)tap->focus_y))
                     {
                       binding->callback (binding->widget,
                                          GRIP_TIME_END,
-                                         ((GripGestureEvent*)&tap),
+                                         event,
                                          binding->data);
                     }
                 }
 	    }
+
+	  grip_gesture_event_free (event);
         }
     }
 }
@@ -908,6 +920,9 @@
   g_return_if_fail (GRIP_IS_GESTURE_MANAGER (manager));
   g_return_if_fail (GTK_IS_WIDGET (widget));
 
+  g_print ("register internal (gesture_type == %d, touch_points == %d)\n",
+	   gesture_type, touch_points);
+
   toplevel = gtk_widget_get_toplevel (widget);
 
   g_return_if_fail (GTK_IS_WINDOW (toplevel));
@@ -1212,3 +1227,59 @@
                         req);
     }
 }
+
+GType
+grip_gesture_event_get_type (void)
+{
+  static GType type = 0;
+
+  if (type == 0)
+    {
+      type = g_boxed_type_register_static (g_intern_static_string ("GripGestureEvent"),
+					   (GBoxedCopyFunc)grip_gesture_event_copy,
+					   (GBoxedFreeFunc)grip_gesture_event_free);
+    }
+
+  return type;
+}
+
+GripGestureEvent *
+grip_gesture_event_new (GripGestureType type)
+{
+  GripGestureEvent *event = g_slice_new0 (GripGestureEvent);
+
+  event->any.type = type;
+  if (event->any.window)
+    g_print ("WINDOW!!\n");
+
+  return event;
+}
+
+GripGestureEvent *
+grip_gesture_event_copy (const GripGestureEvent *event)
+{
+  GripGestureEvent *new_event;
+
+  g_return_val_if_fail (event != NULL, NULL);
+
+  new_event = grip_gesture_event_new (event->type);
+  *new_event = *event;
+
+  g_print ("COPY!\n");
+
+  //  if (new_event->any.window)
+  //    g_object_ref (new_event->any.window);
+
+  return new_event;
+}
+
+void
+grip_gesture_event_free (GripGestureEvent *event)
+{
+  g_return_if_fail (event != NULL);
+
+  //  if (event->any.window)
+  //    g_object_unref (event->any.window);
+
+  g_slice_free (GripGestureEvent, event);
+}

=== modified file 'src/gripgesturemanager.h'
--- src/gripgesturemanager.h	2010-12-10 17:56:56 +0000
+++ src/gripgesturemanager.h	2011-01-24 20:08:35 +0000
@@ -42,6 +42,7 @@
 typedef struct _GripGestureManagerPrivate GripGestureManagerPrivate;
 
 typedef union  _GripGestureEvent       GripGestureEvent;
+typedef struct _GripEventGestureAny    GripEventGestureAny;
 typedef struct _GripEventGestureDrag   GripEventGestureDrag;
 typedef struct _GripEventGesturePinch  GripEventGesturePinch;
 typedef struct _GripEventGestureRotate GripEventGestureRotate;
@@ -60,9 +61,15 @@
   GRIP_TIME_END
 } GripTimeType;
 
+struct _GripEventGestureAny
+{
+  GdkEventType  type;
+  GdkWindow    *window;
+};
+
 struct _GripEventGestureDrag
 {
-  GripGestureType  type;
+  GripGestureType   type;
   guint             id;
   GdkWindow        *window;
   GdkWindow        *root;
@@ -81,7 +88,7 @@
 
 struct _GripEventGesturePinch
 {
-  GripGestureType  type;
+  GripGestureType   type;
   guint             id;
   GdkWindow        *window;
   GdkWindow        *root;
@@ -131,6 +138,7 @@
 union _GripGestureEvent
 {
   GripGestureType        type;
+  GripEventGestureAny    any;
   GripEventGestureDrag   drag;
   GripEventGesturePinch  pinch;
   GripEventGestureRotate rotate;
@@ -161,13 +169,39 @@
   GObjectClass parent_class;
 };
 
+/**
+ * GripGestureCallback:
+ * @widget: (in): A #GtkWidget pointer
+ * @time: A #GripTimeType
+ * @gesture: (in): A #GripGestureEvent pointer
+ * @user_data: (transfer none): user data
+ **/
 typedef void (* GripGestureCallback) (GtkWidget         *widget,
                                       GripTimeType       time,
                                       GripGestureEvent  *gesture,
                                       gpointer            user_data);
 
 GType                grip_gesture_manager_get_type        (void) G_GNUC_CONST;
+
+/**
+ * grip_gesture_manager_get:
+ *
+ * Retrieves a #GripGestureManager pointer.
+ *
+ * Return value: (transfer none): A #GripGestureManager
+ **/
 GripGestureManager *grip_gesture_manager_get              (void);
+
+/**
+ * grip_gesture_manager_register_window:
+ * @manager: self
+ * @widget: A #GtkWidget on which to register the gesture
+ * @gesture_type: Gesture type
+ * @touch_points: Number of touch points
+ * @callback: Callback
+ * @user_data: (transfer none): User data
+ * @destroy: (transfer none) (scope async): Destroy
+ */
 void                 grip_gesture_manager_register_window (GripGestureManager *manager,
                                                            GtkWidget          *widget,
                                                            GripGestureType     gesture_type,
@@ -176,6 +210,12 @@
                                                            gpointer            user_data,
                                                            GDestroyNotify      destroy);
 
+GType             grip_gesture_event_get_type (void) G_GNUC_CONST;
+GripGestureEvent *grip_gesture_event_new      (GripGestureType   gesture_type);
+void              grip_gesture_event_free     (GripGestureEvent *event);
+GripGestureEvent *grip_gesture_event_copy     (const GripGestureEvent *event);
+
+
 G_END_DECLS
 
 #endif /* __GRIP_GESTURE_MANAGER_H__ */