Merge lp:~unity-team/unity/touchy-feely into lp:unity

[Neil J. Patel]

Initial gesture bits. Going to be changed again before next week, but this is the result of the initial development phase.

You'll need to

sudo apt-get install utouch libutouch-grail-dev libxcb-icccm1-dev

The actual dispatch of gestures code will be tweaked again to have gesture-handler objects (so you don't have an epic if/def), I couldn't land that for this week, unfortunately.

Apart from that, please make sure the code makes sense and, the most important thing, doesn't kill your system if you don't have any MT.

Thanks!

if you do have MT, then

- three-finger-drag to move windows (move them toward the top for maximize options)
- splay to maxmize, splay again to fullscreen
- pinch to unfullscreen, pinch again to unmaximise
- four-finger-tap for dash
- four-finger-pinch/splay for window picker

*** These gestures are _NOT_ final ***

=== modified file '.bzrignore'
--- .bzrignore	2010-08-23 17:01:29 +0000
+++ .bzrignore	2010-08-26 15:13:42 +0000
@@ -344,6 +344,12 @@
 unity-private/places/places-volume-controller.c
 unity-private/places/places-volume-child-controller.c
 tests/unit/test-place-browser.c
+unity-private/gesture/gesture-dispatcher-xcb-glu.c
+unity-private/gesture/gesture-dispatcher-xcb.c
+unity-private/gesture/gesture-dispatcher.c
+unity-private/gesture/gesture-event.c
+unity-private/gesture/gesture-dispatcher-geis-glu.c
+unity-private/gesture/gesture-dispatcher-geis.c
 unity-private/places/places-place-home-renderer.c
 unity/unity-stripe-texture.c
 unity/unity-layered-bin.c

=== modified file 'configure.ac'
--- configure.ac	2010-08-25 11:12:12 +0000
+++ configure.ac	2010-08-26 15:13:42 +0000
@@ -118,6 +118,8 @@
                   pango >= 1.6.0
                   unique-1.0
                   unity-misc
+                  utouch-grail
+                  xcb-icccm
                   x11)
 
 AC_SUBST(BASE_CFLAGS)

=== modified file 'targets/mutter/expose-manager.vala'
--- targets/mutter/expose-manager.vala	2010-08-19 10:36:39 +0000
+++ targets/mutter/expose-manager.vala	2010-08-26 15:13:42 +0000
@@ -235,7 +235,8 @@
 
   public class ExposeManager : Object
   {
-    private List<ExposeClone> exposed_windows;
+    public List<ExposeClone> exposed_windows;
+
     private Clutter.Group expose_group;
     private Plugin owner;
     private Clutter.Stage stage;

=== modified file 'targets/mutter/plugin.vala'
--- targets/mutter/plugin.vala	2010-08-19 10:36:39 +0000
+++ targets/mutter/plugin.vala	2010-08-26 15:13:42 +0000
@@ -46,6 +46,7 @@
     ZERO,
   }
 
+  /*
   public class ActorBlur : Ctk.Bin
   {
     private Clutter.Clone clone;
@@ -70,6 +71,7 @@
     }
   }
 
+  */
   public class Plugin : Object, Shell
   {
     /* Signals */
@@ -159,6 +161,29 @@
     private DBus.Connection screensaver_conn;
     private dynamic DBus.Object screensaver;
 
+    public Gesture.Dispatcher gesture_dispatcher;
+
+    /* Pinch info */
+    private float start_pinch_radius = 0.0f;
+    private unowned Mutter.Window? resize_window = null;
+    /*private float   resize_last_x1 = 0.0f;
+    private float   resize_last_y1 = 0.0f;
+    private float   resize_last_x2 = 0.0f;
+    private float   resize_last_y2 = 0.0f;*/
+
+    /* Pan info */
+    private unowned Mutter.Window? start_pan_window = null;
+    private unowned Clutter.Rectangle? start_frame_rect = null;
+    private float last_pan_x_root = 0.0f;
+    private float last_pan_maximised_x_root = 0.0f;
+    private enum MaximizeType {
+      NONE,
+      FULL,
+      LEFT,
+      RIGHT
+    }
+    private MaximizeType maximize_type = MaximizeType.NONE;
+      
     construct
     {
       fullscreen_requests = new Gee.ArrayList<Object> ();
@@ -317,8 +342,12 @@
           });
         }
 
+      gesture_dispatcher = new Gesture.XCBDispatcher ();
+      gesture_dispatcher.gesture.connect (on_gesture_received);
+      
       this.ensure_input_region ();
       return false;
+      
     }
 
     private void on_focus_window_changed ()
@@ -770,6 +799,470 @@
         }
     }
 
+    private void on_gesture_received (Gesture.Event event)
+    {
+      if (event.type == Gesture.Type.TAP &&
+          expose_manager.expose_showing == false)
+        {
+          if (event.fingers == 3)
+            {
+              ;
+            }
+          else if (event.fingers == 4)
+            {
+              show_unity ();
+            }
+        }
+      else if (event.type == Gesture.Type.PINCH &&
+               places_showing == false)
+        {
+          if (event.fingers == 3)
+            {
+              if (event.state == Gesture.State.ENDED)
+                {
+                  var actor = stage.get_actor_at_pos (Clutter.PickMode.ALL,
+                                                      (int)event.root_x,
+                                                      (int)event.root_y);
+                  
+                  while (!(actor is Mutter.Window) && actor != null && actor != stage)
+                    actor = actor.get_parent ();
+
+                  if (actor is Mutter.Window)
+                    {
+                      unowned Mutter.MetaWindow win = (actor as Mutter.Window).get_meta_window ();
+                      bool fullscreen = false;
+
+                      (win as Object).get ("fullscreen", out fullscreen);
+
+                      if (event.pinch_event.radius_delta >= 0.0f)
+                        {
+                          if (Mutter.MetaWindow.is_maximized (win))
+                            {
+                              /* Fullscreen */
+                              Mutter.MetaWindow.make_fullscreen (win);
+                            }
+                          else
+                            {
+                              /* Maximize */
+                              Mutter.MetaWindow.maximize (win,
+                                                          Mutter.MetaMaximizeFlags.HORIZONTAL |
+                                                          Mutter.MetaMaximizeFlags.VERTICAL);
+                            }
+  
+                        }
+                      else
+                        {
+                          if (fullscreen)
+                           {
+                             Mutter.MetaWindow.unmake_fullscreen (win);
+                           }
+                         else if (Mutter.MetaWindow.is_maximized (win))
+                           {
+                             Mutter.MetaWindow.unmaximize (win,
+                                                             Mutter.MetaMaximizeFlags.HORIZONTAL | Mutter.MetaMaximizeFlags.VERTICAL);
+                           }
+                        }
+                    }
+                 }
+
+              /* FIXME: This can't work with the current information we are getting */
+              /*
+              debug ("Resize Window");
+              if (true == true)
+                return;
+
+              if (event.state == Gesture.State.BEGAN)
+                {
+                  resize_window = null;
+
+                  var actor = stage.get_actor_at_pos (Clutter.PickMode.ALL,
+                                                      (int)event.root_x,
+                                                      (int)event.root_y);
+                  if (actor is Mutter.Window == false)
+                    actor = actor.get_parent ();
+
+                  if (actor is Mutter.Window)
+                    {
+                      resize_window = actor as Mutter.Window;
+                      resize_last_x1 = event.pinch_event.bounding_box_x1;
+                      resize_last_y1 = event.pinch_event.bounding_box_y1;
+                      resize_last_x2 = event.pinch_event.bounding_box_x2;
+                      resize_last_y2 = event.pinch_event.bounding_box_y2;
+                    }
+                }
+              else if (event.state == Gesture.State.CONTINUED)
+                {
+                  if (resize_window is Mutter.Window == false)
+                    return;
+
+                  print ("RESIZE: %f %f %f %f\n",
+                         resize_last_x1 - event.pinch_event.bounding_box_x1,
+                         resize_last_y1 - event.pinch_event.bounding_box_y1,
+                         resize_last_x2 - event.pinch_event.bounding_box_x2,
+                         resize_last_y2 - event.pinch_event.bounding_box_y2);
+
+                  var nx = resize_window.x;
+                  var ny = resize_window.y;
+                  var nwidth = resize_window.width;
+                  var nheight = resize_window.height;
+
+                  nx += (resize_last_x1 - event.pinch_event.bounding_box_x1) * event.pinch_event.radius_delta;
+                  ny += (resize_last_y1 - event.pinch_event.bounding_box_y1) * event.pinch_event.radius_delta;
+                  nwidth += (resize_last_x2 - event.pinch_event.bounding_box_x2) * event.pinch_event.radius_delta;
+                  nheight += (resize_last_y2 - event.pinch_event.bounding_box_y2) * event.pinch_event.radius_delta;
+
+                  Mutter.MetaWindow.move_resize (resize_window.get_meta_window (),
+                                                 false,
+                                                 (int)nx,
+                                                 (int)ny,
+                                                 (int)nwidth,
+                                                 (int)nheight);
+                                                 
+ 
+                  resize_last_x1 = event.pinch_event.bounding_box_x1;
+                  resize_last_y1 = event.pinch_event.bounding_box_y1;
+                  resize_last_x2 = event.pinch_event.bounding_box_x2;
+                  resize_last_y2 = event.pinch_event.bounding_box_y2;
+                }
+              else if (event.state == Gesture.State.ENDED)
+                {
+                  if (resize_window is Mutter.Window == false)
+                    return;
+
+                  resize_window = null;
+                }
+              print (@"$event\n");
+              */
+            }
+          else if (event.fingers == 4)
+            {
+              if (event.state == Gesture.State.BEGAN)
+                {
+                  if (expose_manager.expose_showing)
+                    {
+                      expose_manager.end_expose ();
+                    }
+                  else
+                    {
+                      SList<Clutter.Actor> windows = new SList<Clutter.Actor> ();
+                      unowned GLib.List<Mutter.Window> mutter_windows = plugin.get_windows ();
+                      foreach (Mutter.Window w in mutter_windows)
+                        {
+                          windows.append (w);
+                        }
+                      expose_windows (windows,  get_launcher_width_foobar () + 10);
+                    }
+
+                  foreach (ExposeClone clone in expose_manager.exposed_windows)
+                    {
+                      clone.get_animation ().get_timeline ().pause ();
+                    }
+
+                  start_pinch_radius = event.pinch_event.radius_delta;
+                }
+              else if (event.state == Gesture.State.CONTINUED)
+                {
+                  foreach (ExposeClone clone in expose_manager.exposed_windows)
+                    {
+                      int I_JUST_PULLED_THIS_FROM_MY_FOO = 5;
+
+                      if (event.pinch_event.radius_delta >= 0)
+                        {
+                          if (start_pinch_radius < 0)
+                            {
+                              /* We're moving backward */
+                              I_JUST_PULLED_THIS_FROM_MY_FOO *= -1;
+                            }
+                        }
+                      else
+                        {
+                          if (start_pinch_radius >= 0)
+                            {
+                              /* We're moving backward */
+                              I_JUST_PULLED_THIS_FROM_MY_FOO *= -1;
+                            }
+                        }
+
+                      var tl = clone.get_animation ().get_timeline ();
+                      tl.advance (tl.get_elapsed_time ()
+                                  + I_JUST_PULLED_THIS_FROM_MY_FOO);
+                     
+                      float factor = (float)tl.get_elapsed_time () /
+                                     (float)tl.get_duration ();
+                      
+                      Value v = Value (typeof (float));
+                      
+                      var interval = clone.get_animation ().get_interval ("x");
+                      interval.compute_value (factor, v);
+                      clone.x = v.get_float ();
+
+                      interval = clone.get_animation ().get_interval ("y");
+                      interval.compute_value (factor, v);
+                      clone.y = v.get_float ();
+
+                      double scalex, scaley;
+                      clone.get_scale (out scalex, out scaley);
+
+                      v = Value (typeof (double));
+
+                      interval = clone.get_animation ().get_interval ("scale-x");
+                      interval.compute_value (factor, v);
+                      scalex = v.get_double ();
+
+                      interval = clone.get_animation ().get_interval ("scale-y");
+                      interval.compute_value (factor, v);
+                      scaley = v.get_double ();
+
+                      clone.set_scale (scalex, scaley);
+                    }
+                 }
+              else if (event.state == Gesture.State.ENDED)
+                {
+                  foreach (ExposeClone clone in expose_manager.exposed_windows)
+                    {
+                      var anim = clone.get_animation ();
+                      
+                      Value v = Value (typeof (float));
+                      
+                      var interval = anim.get_interval ("x");
+                      v.set_float (clone.x);
+                      interval.set_initial_value (v);
+
+                      interval = anim.get_interval ("y");
+                      v.set_float (clone.y);
+                      interval.set_initial_value (v);
+
+                      v = Value (typeof (double));
+                      double scalex, scaley;
+                      clone.get_scale (out scalex, out scaley);
+
+                      interval = anim.get_interval ("scale-x");
+                      v.set_double (scalex);
+                      interval.set_initial_value (v);
+
+                      interval = anim.get_interval ("scale-y");
+                      v.set_double (scaley);
+                      interval.set_initial_value (v);
+
+                      clone.get_animation ().get_timeline ().start ();
+                      clone.queue_relayout ();
+                    }
+                }
+            }
+        }
+      else if (event.type == Gesture.Type.PAN)
+        {
+          if (resize_window is Mutter.Window)
+            return;
+          if (event.fingers == 3)
+            {
+              if (event.state == Gesture.State.BEGAN)
+                {
+                  start_pan_window = null;
+
+                  var actor = stage.get_actor_at_pos (Clutter.PickMode.ALL,
+                                                      (int)event.root_x,
+                                                      (int)event.root_y);
+                  if (actor is Mutter.Window == false)
+                    actor = actor.get_parent ();
+
+                  if (actor is Mutter.Window)
+                    {
+                      start_pan_window = actor as Mutter.Window;
+
+                      if (start_pan_window.get_window_type () != Mutter.MetaCompWindowType.NORMAL &&
+                          start_pan_window.get_window_type () != Mutter.MetaCompWindowType.DIALOG &&
+                          start_pan_window.get_window_type () != Mutter.MetaCompWindowType.MODAL_DIALOG &&
+                          start_pan_window.get_window_type () != Mutter.MetaCompWindowType.UTILITY)
+                        start_pan_window = null;
+                    }
+                }
+              else if (event.state == Gesture.State.CONTINUED)
+                {
+                  if (start_pan_window is Mutter.Window == false)
+                    return;
+
+                  last_pan_x_root = event.root_x;
+
+                  unowned Mutter.MetaWindow win = start_pan_window.get_meta_window ();
+                  bool fullscreen = false;
+                  win.get ("fullscreen", out fullscreen);
+
+                  if (!Mutter.MetaWindow.is_maximized (win) && fullscreen == false)
+                    {
+                      if (start_pan_window.y == PANEL_HEIGHT
+                          && event.pan_event.delta_y < 0.0f)
+                        {
+                          if (start_frame_rect is Clutter.Rectangle == false)
+                            {
+                              Clutter.Rectangle frame = new Clutter.Rectangle.with_color ({ 0, 0, 0, 10 });
+                              frame.border_color = { 255, 255, 255, 255 };
+                              frame.border_width = 3;
+
+                              stage.add_actor (frame);
+                              frame.set_size (start_pan_window.width,
+                                              start_pan_window.height);
+                              frame.set_position (start_pan_window.x,
+                                                  start_pan_window.y);
+                              frame.show ();
+
+                             start_frame_rect = frame;
+
+                              last_pan_maximised_x_root = event.root_x;
+                            }
+
+                          maximize_type = MaximizeType.FULL;
+                          var MAX_DELTA = 50.0f;
+                          if (event.root_x < last_pan_maximised_x_root - MAX_DELTA)
+                            {
+                              maximize_type = MaximizeType.LEFT;
+                              start_frame_rect.animate (Clutter.AnimationMode.EASE_OUT_QUAD,
+                                                        150,
+                                                        "x", (float)QUICKLAUNCHER_WIDTH,
+                                                        "y", (float)PANEL_HEIGHT,
+                                                        "width", (stage.width - QUICKLAUNCHER_WIDTH)/2.0f,
+                                                        "height", stage.height - PANEL_HEIGHT);
+
+                            }
+                          else if (event.root_x > last_pan_maximised_x_root + MAX_DELTA)
+                            {
+                              maximize_type = MaximizeType.RIGHT;
+                              start_frame_rect.animate (Clutter.AnimationMode.EASE_OUT_QUAD,
+                                                        150,
+                                                        "x", (float)((stage.width - QUICKLAUNCHER_WIDTH)/2.0f) + QUICKLAUNCHER_WIDTH,
+                                                        "y", (float)PANEL_HEIGHT,
+                                                        "width", (stage.width - QUICKLAUNCHER_WIDTH)/2.0f,
+                                                        "height", stage.height - PANEL_HEIGHT);
+                            }
+                          else
+                            {
+                              start_frame_rect.animate (Clutter.AnimationMode.EASE_OUT_QUAD,
+                                                        150,
+                                                        "x", (float)QUICKLAUNCHER_WIDTH,
+                                                        "y", (float)PANEL_HEIGHT,
+                                                        "width", stage.width - QUICKLAUNCHER_WIDTH,
+                                                        "height", stage.height - PANEL_HEIGHT);
+
+                             }
+                        }
+                     else
+                        {
+                          start_pan_window.x += Math.floorf (event.pan_event.delta_x + 0.5f);
+                          start_pan_window.y += Math.floorf (event.pan_event.delta_y + 0.5f);
+                          start_pan_window.x = float.max (start_pan_window.x, QUICKLAUNCHER_WIDTH);
+                          start_pan_window.y = float.max (start_pan_window.y, PANEL_HEIGHT);
+
+                          if (start_frame_rect is Clutter.Rectangle)
+                            {
+                              if (start_frame_rect.opacity == 0)
+                                {
+                                  stage.remove_actor (start_frame_rect);
+                                  start_frame_rect = null;
+                                }
+                              else if (start_pan_window.y > PANEL_HEIGHT + 5 &&
+                                (start_frame_rect.get_animation () is Clutter.Animation == false))
+                                {
+                                  start_frame_rect.animate (Clutter.AnimationMode.EASE_IN_QUAD,
+                                                            150,
+                                                            "x", start_pan_window.x,
+                                                            "y", start_pan_window.y,
+                                                            "width", start_pan_window.width,
+                                                            "height", start_pan_window.height,
+                                                            "opacity", 0);
+                                }
+                            }
+                        }
+                    }
+                  else
+                    {
+                      if (event.pan_event.delta_y >= 0.0f && fullscreen == false)
+                        {
+                          Mutter.MetaWindow.unmaximize (win,
+                                                        Mutter.MetaMaximizeFlags.HORIZONTAL | Mutter.MetaMaximizeFlags.VERTICAL);
+                        }
+                    }
+                }
+              else if (event.state == Gesture.State.ENDED)
+                {
+                  if (start_pan_window is Mutter.Window)
+                    {
+                      unowned Mutter.MetaWindow win = start_pan_window.get_meta_window ();
+                      float nx = 0;
+                      float ny = 0;
+                      float nwidth = 0;
+                      float nheight = 0;
+                      bool  move_resize = false;
+                      bool fullscreen = false;
+                      win.get ("fullscreen", out fullscreen);
+
+                      int wx, wy, ww, wh;
+                      Mutter.MetaWindow.get_geometry (win, out wx, out wy, out ww, out wh);
+                      Mutter.MetaRectangle rect = Mutter.MetaRectangle ();
+                      Mutter.MetaWindow.get_outer_rect (win, rect);
+
+                      if (Mutter.MetaWindow.is_maximized (win) || fullscreen)
+                        {
+                        }
+                      else if (start_pan_window.y == PANEL_HEIGHT && event.pan_event.delta_y < 0.0f)
+                        {
+                          if (maximize_type == MaximizeType.FULL)
+                            {
+                            
+                              Mutter.MetaWindow.maximize (win,
+                                                          Mutter.MetaMaximizeFlags.HORIZONTAL | Mutter.MetaMaximizeFlags.VERTICAL);
+                            }
+                          else if (maximize_type == MaximizeType.RIGHT)
+                            {
+                              nx = (float)QUICKLAUNCHER_WIDTH + (stage.width-QUICKLAUNCHER_WIDTH)/2.0f;
+                              ny = (float)PANEL_HEIGHT;
+                              nwidth = (stage.width - QUICKLAUNCHER_WIDTH)/2.0f;
+                              nheight = stage.height - PANEL_HEIGHT;
+
+                              move_resize = true;
+                            }
+                          else if (maximize_type == MaximizeType.LEFT)
+                            {
+                              nx = (float)QUICKLAUNCHER_WIDTH;
+                              ny = (float)PANEL_HEIGHT;
+                              nwidth = (stage.width - QUICKLAUNCHER_WIDTH)/2.0f;
+                              nheight = stage.height - PANEL_HEIGHT;
+
+                              move_resize = true;
+                            }
+                        }
+                      else
+                        {
+                          /* FIXME: We need to somehow convince Mutter to tell
+                           * us the size of the frame. 27 = top + bottom frame
+                           * 1 = left frame
+                           * 24 = size of top frame
+                           */
+                          nx = start_pan_window.x;
+                          ny = start_pan_window.y; /* Kittens are dying */
+                          nwidth = start_pan_window.width;
+                          nheight = start_pan_window.height;
+                          move_resize = true;
+
+                          print ("%d %d %d %d\n",wx, wy, rect.x, rect.y);
+                        }
+
+                      X.Window xwin = start_pan_window.get_x_window ();
+                      unowned Gdk.Window w = Gdk.Window.foreign_new ((Gdk.NativeWindow)xwin);
+                      if (w is Gdk.Window && move_resize)
+                        {
+                          Mutter.MetaWindow.move_resize (win, false, ((int)nx),
+                                                         ((int)ny),
+                                                         (int)nwidth, (int)nheight);
+                        }
+                    }
+
+                    if (start_frame_rect is Clutter.Rectangle)
+                      stage.remove_actor (start_frame_rect);
+                }
+            }
+        }
+    }
+
     /*
      * MUTTER PLUGIN HOOKS
      */
@@ -889,6 +1382,5 @@
     {
       return this.get_launcher_width ();
     }
-
   }
 }

=== modified file 'unity-private/Makefile.am'
--- unity-private/Makefile.am	2010-08-19 14:58:10 +0000
+++ unity-private/Makefile.am	2010-08-26 15:13:42 +0000
@@ -127,6 +127,13 @@
   launcher/scroller-model.vala \
   launcher/scroller-view.vala
 
+gesture_sources = \
+  gesture/gesture-dispatcher.vala \
+  gesture/gesture-dispatcher-xcb.vala \
+  gesture/gesture-dispatcher-xcb-glu.vala \
+  gesture/gesture-event.vala
+
+
 testing_sources = \
   testing/background.vala \
   testing/object-registry.vala \
@@ -136,6 +143,7 @@
   testing/test-window.vala
 
 libunity_private_la_VALASOURCES = \
+  $(gesture_sources) \
   $(private_sources) \
   $(panel_sources) \
   $(places_sources) \
@@ -143,6 +151,9 @@
   $(testing_sources)
 
 libunity_private_la_SOURCES = \
+  gesture/gesture.c \
+  gesture/gesture.h \
+  gesture/gesture-dispatcher-xcb-glue.c \
   unity-utils.c \
   unity-utils.h \
   $(libunity_private_la_VALASOURCES:.vala=.c)

=== added directory 'unity-private/gesture'
=== added file 'unity-private/gesture/gesture-dispatcher-xcb-glu.vala'
--- unity-private/gesture/gesture-dispatcher-xcb-glu.vala	1970-01-01 00:00:00 +0000
+++ unity-private/gesture/gesture-dispatcher-xcb-glu.vala	2010-08-26 15:13:42 +0000
@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2010 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 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 warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by Neil Jagdish Patel <[e-mail]>
+ *
+ */
+
+namespace Unity.Gesture.XCBDispatcherGlue
+{
+  public extern void init (GLib.Object obj);
+  public extern void finish ();
+}

=== added file 'unity-private/gesture/gesture-dispatcher-xcb-glue.c'
--- unity-private/gesture/gesture-dispatcher-xcb-glue.c	1970-01-01 00:00:00 +0000
+++ unity-private/gesture/gesture-dispatcher-xcb-glue.c	2010-08-26 15:13:42 +0000
@@ -0,0 +1,448 @@
+/*
+ * Copyright (C) 2010 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 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 warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by Neil Jagdish Patel <[e-mail]>
+ *             Chase Douglas <[e-mail]>
+ *
+ */
+
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <xcb/xcb.h>
+#include <xcb/xcb_icccm.h>
+#include <X11/X.h>
+
+#include <glib.h>
+#include <glib-object.h>
+
+#include <grail.h>
+
+#include "gesture.h"
+
+#include "../unity-private.h"
+
+#define XCB_DISPATCHER_TIMEOUT 100
+
+typedef struct
+{
+  GSource source;
+
+
+  xcb_connection_t    *connection;
+  xcb_generic_event_t *event;
+
+  GObject *dispatcher;
+
+  UnityGestureEvent    *gesture_event;
+
+} XCBSource;
+
+static gboolean source_prepare (GSource     *source, gint *timeout);
+static gboolean source_check   (GSource     *source);
+static gboolean source_dispatch(GSource     *source,
+                                GSourceFunc  callback,
+                                gpointer     user_data);
+static void     source_finalize(GSource     *source);
+
+static gint     set_mask (xcb_connection_t *connection,
+                          xcb_window_t      window,
+                          uint16_t          device_id,
+                          uint16_t          mask_len,
+                          uint32_t         *mask);
+
+static GSourceFuncs XCBFuncs = {
+  &source_prepare,
+  &source_check,
+  &source_dispatch,
+  &source_finalize,
+  0,
+  0
+};
+
+void
+unity_gesture_xcb_dispatcher_glue_init (GObject *object)
+{
+  g_debug ("%s", G_STRFUNC);
+  xcb_connection_t *connection;
+  XCBSource        *source;
+  uint16_t          mask_len = 1;
+  grail_mask_t     *mask;
+
+  connection = xcb_connect (NULL, NULL);
+
+  mask = calloc (1, sizeof(grail_mask_t) * mask_len);
+
+  /* Fiddle */
+  grail_mask_set (mask, GRAIL_TYPE_TAP3);
+  grail_mask_set (mask, GRAIL_TYPE_TAP4);
+
+  /* Gropes */
+  grail_mask_set (mask, GRAIL_TYPE_EPINCH);
+  grail_mask_set (mask, GRAIL_TYPE_MPINCH);
+
+  /* Pots and */
+  grail_mask_set (mask, GRAIL_TYPE_EDRAG);
+  grail_mask_set (mask, GRAIL_TYPE_MDRAG);
+
+  if (set_mask (connection, 0, 0, mask_len, (uint32_t*)mask))
+    {
+      g_warning ("Unable to initialize gesture dispatcher xcb");
+      return;
+    }
+
+  source = (XCBSource*)g_source_new (&XCBFuncs, sizeof(XCBSource));
+  source->connection = connection;
+  source->dispatcher = object;
+  source->gesture_event = unity_gesture_event_new ();
+  source->gesture_event->pan_event = unity_gesture_pan_event_new ();
+  source->gesture_event->pinch_event = unity_gesture_pinch_event_new ();
+  source->gesture_event->tap_event = unity_gesture_tap_event_new ();
+
+  g_source_attach (&source->source, NULL);
+}
+
+void
+unity_gesture_xcb_dispatcher_glue_finish ()
+{
+  g_debug ("%s", G_STRFUNC);
+}
+
+void
+unity_gesture_xcb_dispatcher_glue_main_iteration (XCBSource *source)
+{
+  const xcb_query_extension_reply_t *extension_info;
+  xcb_connection_t *connection = source->connection;
+  
+	extension_info = xcb_get_extension_data(connection, &xcb_gesture_id);
+
+  if (source->event != NULL)
+    {
+      xcb_generic_event_t *event;
+      xcb_gesture_notify_event_t *gesture_event;
+      float *properties;
+      int i;
+      UnityGestureEvent    *dispatch_event = source->gesture_event;
+
+      dispatch_event->type = UNITY_GESTURE_TYPE_NONE;
+
+      event = source->event;
+      if (!event)
+        { 
+          fprintf (stderr, "Warning: I/O error while waiting for event\n");
+          return;
+        }
+
+      if (event->response_type != GenericEvent)
+        {
+          fprintf (stderr, "Warning: Received non-generic event type: "
+                   "%d\n", event->response_type);
+          return;
+        }
+
+      gesture_event = (xcb_gesture_notify_event_t *)event;
+      properties = (float *)(gesture_event + 1);
+      
+      if (gesture_event->extension != extension_info->major_opcode)
+        {
+          fprintf (stderr, "Warning: Received non-gesture extension "
+                   "event: %d\n", gesture_event->extension);
+          return;
+        }
+
+      if (gesture_event->event_type != XCB_GESTURE_NOTIFY)
+        {
+          fprintf (stderr, "Warning: Received unrecognized gesture event "
+                   "type: %d\n", gesture_event->event_type);
+          return;
+        }
+
+      switch (gesture_event->gesture_type)
+        {
+        case GRAIL_TYPE_EDRAG:
+        case GRAIL_TYPE_MDRAG:
+          dispatch_event->type = UNITY_GESTURE_TYPE_PAN;
+          dispatch_event->fingers = gesture_event->gesture_type == GRAIL_TYPE_EDRAG ? 3 : 4;
+
+          break;
+        case GRAIL_TYPE_EPINCH:
+        case GRAIL_TYPE_MPINCH:
+          dispatch_event->type = UNITY_GESTURE_TYPE_PINCH;
+          dispatch_event->fingers = gesture_event->gesture_type == GRAIL_TYPE_EPINCH ? 3 : 4;
+          break;
+        case GRAIL_TYPE_TAP3:
+        case GRAIL_TYPE_TAP4:
+          dispatch_event->type = UNITY_GESTURE_TYPE_TAP;
+          dispatch_event->fingers =
+                        gesture_event->gesture_type == GRAIL_TYPE_TAP3 ? 3 : 4;
+          break;
+        default:
+          g_warning ("Unknown Gesture Event Type %d\n",
+                     gesture_event->gesture_type);
+          break;
+        }
+
+      if (dispatch_event->type != UNITY_GESTURE_TYPE_NONE)
+        {
+          dispatch_event->device_id = gesture_event->device_id;
+          dispatch_event->gesture_id = gesture_event->gesture_id;
+          dispatch_event->timestamp = gesture_event->time;
+          dispatch_event->state = gesture_event->status;
+          dispatch_event->root_x = (gint32)gesture_event->focus_x;
+          dispatch_event->root_y = (gint32)gesture_event->focus_y;
+          dispatch_event->root_window = gesture_event->root;
+          dispatch_event->event_window = gesture_event->event;
+          dispatch_event->child_window = gesture_event->child;
+
+          g_signal_emit_by_name (source->dispatcher,
+                                 "gesture",
+                                 dispatch_event);
+       }
+
+      /* Load in properties */
+      if (dispatch_event->type == UNITY_GESTURE_TYPE_PAN &&
+          gesture_event->num_props >= 6)
+        {
+          UnityGesturePanEvent *ev = dispatch_event->pan_event;
+          ev->delta_x = properties[GRAIL_PROP_DRAG_DX];
+          ev->delta_y = properties[GRAIL_PROP_DRAG_DY];
+          ev->velocity_x = properties[GRAIL_PROP_DRAG_VX];
+          ev->velocity_y = properties[GRAIL_PROP_DRAG_VY];
+          ev->x = properties[GRAIL_PROP_DRAG_X];
+          ev->y = properties[GRAIL_PROP_DRAG_Y];
+        }
+      else if (dispatch_event->type == UNITY_GESTURE_TYPE_PINCH &&
+               gesture_event->num_props >= 7)
+        {
+          UnityGesturePinchEvent *ev = dispatch_event->pinch_event;
+          ev->radius_delta = properties[GRAIL_PROP_PINCH_DR];
+          ev->radius_velocity = properties[GRAIL_PROP_PINCH_VR];
+          ev->radius = properties[GRAIL_PROP_PINCH_R];
+          ev->bounding_box_x1 = properties[GRAIL_PROP_PINCH_X1];
+          ev->bounding_box_y1 = properties[GRAIL_PROP_PINCH_Y1];
+          ev->bounding_box_x2 = properties[GRAIL_PROP_PINCH_X2];
+          ev->bounding_box_y2 = properties[GRAIL_PROP_PINCH_Y2];
+
+        }
+      else if (dispatch_event->type == UNITY_GESTURE_TYPE_TAP &&
+               gesture_event->num_props >= 3)
+        {
+          UnityGestureTapEvent *ev = dispatch_event->tap_event;
+          ev->duration = properties[GRAIL_PROP_TAP_DT];
+          ev->x2 = properties[GRAIL_PROP_TAP_X];
+          ev->y2 = properties[GRAIL_PROP_TAP_Y];
+        }
+   }
+}
+
+static gboolean
+source_prepare (GSource     *source, gint *timeout)
+{
+  XCBSource *s = (XCBSource *)source;
+
+  *timeout = XCB_DISPATCHER_TIMEOUT;
+
+  s->event = xcb_poll_for_event (s->connection);
+  
+  return s->event == NULL ? FALSE : TRUE;
+}
+
+static gboolean
+source_check   (GSource     *source)
+{
+  return ((XCBSource*)source)->event == NULL ? FALSE : TRUE;
+}
+
+static gboolean
+source_dispatch(GSource     *source,
+                GSourceFunc  callback,
+                gpointer     user_data)
+{
+  unity_gesture_xcb_dispatcher_glue_main_iteration ((XCBSource*)source);
+  return TRUE;
+}
+
+static void
+source_finalize (GSource *source)
+{
+
+}
+
+static int set_mask_on_window(xcb_connection_t *connection, xcb_window_t window,
+			      uint16_t device_id, uint16_t mask_len,
+			      uint32_t *mask) {
+	xcb_generic_error_t *error;
+	xcb_void_cookie_t select_cookie;
+	xcb_gesture_get_selected_events_cookie_t events_cookie;
+	xcb_gesture_get_selected_events_reply_t *events_reply;
+	xcb_gesture_event_mask_iterator_t events_iterator;
+	int masks_len_reply;
+	int mask_len_reply;
+	uint32_t *mask_reply;
+
+	select_cookie = xcb_gesture_select_events_checked(connection, window,
+							  device_id, mask_len,
+							  mask);
+	error = xcb_request_check(connection, select_cookie);
+	if (error) {
+		fprintf(stderr,
+			"Error: Failed to select events on window 0x%x\n",
+			window);
+		return -1;
+	}
+
+	events_cookie = xcb_gesture_get_selected_events(connection, window);
+	events_reply = xcb_gesture_get_selected_events_reply(connection,
+							     events_cookie,
+							     &error);
+	if (!events_reply) {
+		fprintf(stderr,
+			"Error: Failed to receive selected events reply on "
+			"window 0x%x\n", window);
+		return -1;
+	}
+
+	masks_len_reply =
+		xcb_gesture_get_selected_events_masks_length(events_reply);
+	if (masks_len_reply != 1) {
+		fprintf(stderr,
+			"Error: Wrong selected masks length returned: %d\n",
+			masks_len_reply);
+		return -1;
+	}
+
+	events_iterator =
+		xcb_gesture_get_selected_events_masks_iterator(events_reply);
+	if (events_iterator.data->device_id != device_id) {
+		fprintf(stderr,
+			"Error: Incorrect device id returned by server: %d\n",
+			events_iterator.data->device_id);
+		return -1;
+	}
+
+	mask_len_reply =
+		xcb_gesture_event_mask_mask_data_length(events_iterator.data);
+	if (mask_len_reply != mask_len) {
+		fprintf(stderr,
+			"Error: Incorrect mask length returned by server: %d\n",
+			mask_len_reply);
+		return -1;
+	}
+
+	mask_reply = xcb_gesture_event_mask_mask_data(events_iterator.data);
+	if (memcmp(mask, mask_reply, mask_len * 4) != 0) {
+		fprintf(stderr, "Error: Incorrect mask returned by server\n");
+		return -1;
+	}
+
+	free(events_reply);
+
+	return 0;
+}
+
+static int set_mask_on_subwindows(xcb_connection_t *connection,
+				  xcb_window_t window, uint16_t device_id,
+				  uint16_t mask_len, uint32_t *mask) {
+	xcb_generic_error_t *error;
+	xcb_query_tree_cookie_t tree_cookie;
+	xcb_query_tree_reply_t *tree_reply;
+	xcb_window_t *children;
+	int num_children;
+	int i;
+
+	if (set_mask_on_window(connection, window, device_id, mask_len, mask))
+		return -1;
+
+	tree_cookie = xcb_query_tree(connection, window);
+	tree_reply = xcb_query_tree_reply(connection, tree_cookie, &error);
+	if (!tree_reply) {
+		fprintf(stderr, "Error: Failed to query tree for window 0x%x\n",
+		window);
+		return -1;
+	}
+
+	num_children = xcb_query_tree_children_length(tree_reply);
+	if (num_children <= 0)
+		return 0;
+
+	children = xcb_query_tree_children(tree_reply);
+	if (!children) {
+		fprintf(stderr,
+			"Error: Failed to retrieve children of window 0x%x\n",
+			window);
+		return -1;
+	}
+
+	for (i = 0; i < num_children; i++)
+		if (set_mask_on_subwindows(connection, children[i], device_id,
+					   mask_len, mask))
+			return -1;
+	
+	free(tree_reply);
+
+	return 0;
+}
+
+static int set_mask(xcb_connection_t *connection, xcb_window_t window,
+		    uint16_t device_id, uint16_t mask_len, uint32_t *mask) {
+	xcb_generic_error_t *error;
+	xcb_gesture_query_version_cookie_t version_cookie;
+	xcb_gesture_query_version_reply_t *version_reply;
+
+	version_cookie = xcb_gesture_query_version(connection, 0, 5);
+	version_reply = xcb_gesture_query_version_reply(connection,
+							version_cookie, &error);
+	if (!version_reply) {
+		fprintf(stderr,
+			"Error: Failed to receive gesture version reply\n");
+		return -1;
+	}
+
+	if (version_reply->major_version != 0 &&
+	    version_reply->minor_version != 5) {
+		fprintf(stderr,
+			"Error: Server supports unrecognized version: %d.%d\n",
+			version_reply->major_version,
+			version_reply->minor_version);
+		return -1;
+	}
+
+	free(version_reply);
+
+	if (window != 0) {
+		if (set_mask_on_window(connection, window, device_id, mask_len,
+				       mask))
+			return -1;
+	}
+	else {
+		const xcb_setup_t *setup;
+		xcb_screen_iterator_t screen;
+
+		setup = xcb_get_setup(connection);
+		if (!setup) {
+			fprintf(stderr, "Error: Failed to get xcb setup\n");
+			return -1;
+		}
+
+		for (screen = xcb_setup_roots_iterator(setup); screen.rem;
+		     xcb_screen_next(&screen))
+			if (set_mask_on_subwindows(connection,
+			    screen.data->root, device_id, mask_len, mask))
+				return -1;
+	}
+
+	return 0;
+}

=== added file 'unity-private/gesture/gesture-dispatcher-xcb.vala'
--- unity-private/gesture/gesture-dispatcher-xcb.vala	1970-01-01 00:00:00 +0000
+++ unity-private/gesture/gesture-dispatcher-xcb.vala	2010-08-26 15:13:42 +0000
@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2010 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 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 warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by Neil Jagdish Patel <[e-mail]>
+ *
+ */
+
+namespace Unity.Gesture
+{
+  public class XCBDispatcher : Dispatcher
+  {
+    public XCBDispatcher ()
+    {
+      XCBDispatcherGlue.init (this as GLib.Object);
+    }
+
+    ~XCBDispatcher ()
+    {
+      XCBDispatcherGlue.finish ();
+    }
+  }
+}

=== added file 'unity-private/gesture/gesture-dispatcher.vala'
--- unity-private/gesture/gesture-dispatcher.vala	1970-01-01 00:00:00 +0000
+++ unity-private/gesture/gesture-dispatcher.vala	2010-08-26 15:13:42 +0000
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2010 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 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 warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by Neil Jagdish Patel <[e-mail]>
+ *
+ */
+
+namespace Unity.Gesture
+{
+  public abstract class Dispatcher : GLib.Object
+  {
+    public signal void gesture (Gesture.Event event);
+  }
+}

=== added file 'unity-private/gesture/gesture-event.vala'
--- unity-private/gesture/gesture-event.vala	1970-01-01 00:00:00 +0000
+++ unity-private/gesture/gesture-event.vala	2010-08-26 15:13:42 +0000
@@ -0,0 +1,164 @@
+/*
+ * Copyright (C) 2010 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 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 warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by Neil Jagdish Patel <[e-mail]>
+ *
+ */
+
+using X;
+
+namespace Unity.Gesture
+{
+  public enum Type
+  {
+    NONE,
+    PAN,
+    PINCH,
+    ROTATE,
+    TAP
+  }
+
+  public enum State
+  {
+    BEGAN,
+    CONTINUED,
+    ENDED
+  }
+  
+  public class Event
+  {
+    public Type   type;
+
+    public uint32 device_id;
+    public uint32 gesture_id;
+    public uint32 timestamp;
+    public State  state;
+    public int32  fingers;
+
+    public float root_x;
+    public float root_y;
+
+    public Window root_window;
+    public Window event_window;
+    public Window child_window;
+
+    public PanEvent   pan_event;
+    public PinchEvent pinch_event;
+    public TapEvent   tap_event;
+
+    public string to_string ()
+    {
+      string ret = "";
+
+      ret += type_to_string (type) + " Gesture\n";
+      ret += "\tDevice ID  : %u\n".printf (device_id);
+      ret += "\tGesture ID : %u\n".printf (gesture_id);
+      ret += "\tTimestamp  : %u\n".printf (timestamp);
+      ret += "\tState      : " + state_to_string (state) + "\n";
+      ret += "\tFingers    : %u\n".printf (fingers);
+      ret += "\tX Root     : %f\n".printf (root_x);
+      ret += "\tY Root     : %f\n".printf (root_y);
+      ret += "\tRootWin    : %u\n".printf ((uint32)root_window);
+      ret += "\tEventWin   : %u\n".printf ((uint32)event_window);
+      ret += "\tChildWin   : %u\n".printf ((uint32)child_window);
+
+      switch (type)
+        {
+        case Type.PAN:
+          ret += "\tDeltaX     : %f\n".printf (pan_event.delta_x);
+          ret += "\tDeltaY     : %f\n".printf (pan_event.delta_y);
+          ret += "\tVelocityX  : %f\n".printf (pan_event.velocity_x);
+          ret += "\tVelocityY  : %f\n".printf (pan_event.velocity_y);
+          ret += "\tX          : %f\n".printf (pan_event.x);
+          ret += "\tY          : %f\n".printf (pan_event.y);
+          break;
+        case Type.PINCH:
+          ret += "\tRadiusDelta: %f\n".printf (pinch_event.radius_delta);
+          ret += "\tRadiusVeloc: %f\n".printf (pinch_event.radius_velocity);
+          ret += "\tRadius     : %f\n".printf (pinch_event.radius);
+          ret += "\tBoundingX1 : %f\n".printf (pinch_event.bounding_box_x1);
+          ret += "\tBoundingY1 : %f\n".printf (pinch_event.bounding_box_y1);
+          ret += "\tBoundingX2 : %f\n".printf (pinch_event.bounding_box_x2);
+          ret += "\tBoundingY2 : %f\n".printf (pinch_event.bounding_box_y2);
+          break;
+
+        case Type.TAP:
+          ret += "\tDuration   : %f\n".printf (tap_event.duration); 
+          ret += "\tX2         : %f\n".printf (tap_event.x2);
+          ret += "\tY2         : %f\n".printf (tap_event.y2);
+          break;
+        
+        default:
+          break;
+        }
+
+      return ret;
+    }
+
+    public static string type_to_string (Type type)
+    {
+      if (type == Type.PAN)
+        return "Pan";
+      else if (type == Type.PINCH)
+        return "Pinch";
+      else if (type == Type.ROTATE)
+        return "Rotate";
+      else if (type == Type.TAP)
+        return "Tap";
+      else
+        return "Unknown";
+    }
+
+    public static string state_to_string (State state)
+    {
+      if (state == State.BEGAN)
+        return "Began";
+      else if (state == State.CONTINUED)
+        return "Continued";
+      else if (state == State.ENDED)
+        return "Ended";
+      else
+        return "Unknown";
+    }
+  }
+
+  public class PanEvent
+  {
+    public float delta_x;
+    public float delta_y;
+    public float velocity_x;
+    public float velocity_y;
+    public float x;
+    public float y;
+  }
+
+  public class PinchEvent
+  {
+    public float radius_delta;
+    public float radius_velocity;
+    public float radius;
+    public float bounding_box_x1;
+    public float bounding_box_y1;
+    public float bounding_box_x2;
+    public float bounding_box_y2;
+  }
+
+  public class TapEvent
+  {
+    public float duration;
+    public float x2;
+    public float y2;
+  }
+}

=== added file 'unity-private/gesture/gesture.c'
--- unity-private/gesture/gesture.c	1970-01-01 00:00:00 +0000
+++ unity-private/gesture/gesture.c	2010-08-26 15:13:42 +0000
@@ -0,0 +1,467 @@
+/*
+ * This file generated automatically from gesture.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+#include <string.h>
+#include <assert.h>
+#include "xcb/xcbext.h"
+#include "gesture.h"
+#include "X11/Xproto.h"
+
+xcb_extension_t xcb_gesture_id = { "GestureExtension", 0 };
+
+
+/*****************************************************************************
+ **
+ ** void xcb_gesture_float32_next
+ ** 
+ ** @param xcb_gesture_float32_iterator_t *i
+ ** @returns void
+ **
+ *****************************************************************************/
+ 
+void
+xcb_gesture_float32_next (xcb_gesture_float32_iterator_t *i  /**< */)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_gesture_float32_t);
+}
+
+
+/*****************************************************************************
+ **
+ ** xcb_generic_iterator_t xcb_gesture_float32_end
+ ** 
+ ** @param xcb_gesture_float32_iterator_t i
+ ** @returns xcb_generic_iterator_t
+ **
+ *****************************************************************************/
+ 
+xcb_generic_iterator_t
+xcb_gesture_float32_end (xcb_gesture_float32_iterator_t i  /**< */)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+
+/*****************************************************************************
+ **
+ ** uint32_t * xcb_gesture_event_mask_mask_data
+ ** 
+ ** @param const xcb_gesture_event_mask_t *R
+ ** @returns uint32_t *
+ **
+ *****************************************************************************/
+ 
+uint32_t *
+xcb_gesture_event_mask_mask_data (const xcb_gesture_event_mask_t *R  /**< */)
+{
+    return (uint32_t *) (R + 1);
+}
+
+
+/*****************************************************************************
+ **
+ ** int xcb_gesture_event_mask_mask_data_length
+ ** 
+ ** @param const xcb_gesture_event_mask_t *R
+ ** @returns int
+ **
+ *****************************************************************************/
+ 
+int
+xcb_gesture_event_mask_mask_data_length (const xcb_gesture_event_mask_t *R  /**< */)
+{
+    return R->mask_len;
+}
+
+
+/*****************************************************************************
+ **
+ ** xcb_generic_iterator_t xcb_gesture_event_mask_mask_data_end
+ ** 
+ ** @param const xcb_gesture_event_mask_t *R
+ ** @returns xcb_generic_iterator_t
+ **
+ *****************************************************************************/
+ 
+xcb_generic_iterator_t
+xcb_gesture_event_mask_mask_data_end (const xcb_gesture_event_mask_t *R  /**< */)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint32_t *) (R + 1)) + (R->mask_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+
+/*****************************************************************************
+ **
+ ** void xcb_gesture_event_mask_next
+ ** 
+ ** @param xcb_gesture_event_mask_iterator_t *i
+ ** @returns void
+ **
+ *****************************************************************************/
+ 
+void
+xcb_gesture_event_mask_next (xcb_gesture_event_mask_iterator_t *i  /**< */)
+{
+    xcb_gesture_event_mask_t *R = i->data;
+    xcb_generic_iterator_t child = xcb_gesture_event_mask_mask_data_end(R);
+    --i->rem;
+    i->data = (xcb_gesture_event_mask_t *) child.data;
+    i->index = child.index;
+}
+
+
+/*****************************************************************************
+ **
+ ** xcb_generic_iterator_t xcb_gesture_event_mask_end
+ ** 
+ ** @param xcb_gesture_event_mask_iterator_t i
+ ** @returns xcb_generic_iterator_t
+ **
+ *****************************************************************************/
+ 
+xcb_generic_iterator_t
+xcb_gesture_event_mask_end (xcb_gesture_event_mask_iterator_t i  /**< */)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_gesture_event_mask_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+
+/*****************************************************************************
+ **
+ ** xcb_gesture_query_version_cookie_t xcb_gesture_query_version
+ ** 
+ ** @param xcb_connection_t *c
+ ** @param uint16_t          major_version
+ ** @param uint16_t          minor_version
+ ** @returns xcb_gesture_query_version_cookie_t
+ **
+ *****************************************************************************/
+ 
+xcb_gesture_query_version_cookie_t
+xcb_gesture_query_version (xcb_connection_t *c  /**< */,
+                           uint16_t          major_version  /**< */,
+                           uint16_t          minor_version  /**< */)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        /* count */ 2,
+        /* ext */ &xcb_gesture_id,
+        /* opcode */ XCB_GESTURE_QUERY_VERSION,
+        /* isvoid */ 0
+    };
+    
+    struct iovec xcb_parts[4];
+    xcb_gesture_query_version_cookie_t xcb_ret;
+    xcb_gesture_query_version_request_t xcb_out;
+    
+    xcb_out.major_version = major_version;
+    xcb_out.minor_version = minor_version;
+    
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+
+/*****************************************************************************
+ **
+ ** xcb_gesture_query_version_cookie_t xcb_gesture_query_version_unchecked
+ ** 
+ ** @param xcb_connection_t *c
+ ** @param uint16_t          major_version
+ ** @param uint16_t          minor_version
+ ** @returns xcb_gesture_query_version_cookie_t
+ **
+ *****************************************************************************/
+ 
+xcb_gesture_query_version_cookie_t
+xcb_gesture_query_version_unchecked (xcb_connection_t *c  /**< */,
+                                     uint16_t          major_version  /**< */,
+                                     uint16_t          minor_version  /**< */)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        /* count */ 2,
+        /* ext */ &xcb_gesture_id,
+        /* opcode */ XCB_GESTURE_QUERY_VERSION,
+        /* isvoid */ 0
+    };
+    
+    struct iovec xcb_parts[4];
+    xcb_gesture_query_version_cookie_t xcb_ret;
+    xcb_gesture_query_version_request_t xcb_out;
+    
+    xcb_out.major_version = major_version;
+    xcb_out.minor_version = minor_version;
+    
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+
+/*****************************************************************************
+ **
+ ** xcb_gesture_query_version_reply_t * xcb_gesture_query_version_reply
+ ** 
+ ** @param xcb_connection_t                    *c
+ ** @param xcb_gesture_query_version_cookie_t   cookie
+ ** @param xcb_generic_error_t                **e
+ ** @returns xcb_gesture_query_version_reply_t *
+ **
+ *****************************************************************************/
+ 
+xcb_gesture_query_version_reply_t *
+xcb_gesture_query_version_reply (xcb_connection_t                    *c  /**< */,
+                                 xcb_gesture_query_version_cookie_t   cookie  /**< */,
+                                 xcb_generic_error_t                **e  /**< */)
+{
+    return (xcb_gesture_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+
+/*****************************************************************************
+ **
+ ** xcb_void_cookie_t xcb_gesture_select_events_checked
+ ** 
+ ** @param xcb_connection_t *c
+ ** @param xcb_window_t      window
+ ** @param uint16_t          device_id
+ ** @param uint16_t          mask_len
+ ** @param const uint32_t   *mask
+ ** @returns xcb_void_cookie_t
+ **
+ *****************************************************************************/
+ 
+xcb_void_cookie_t
+xcb_gesture_select_events_checked (xcb_connection_t *c  /**< */,
+                                   xcb_window_t      window  /**< */,
+                                   uint16_t          device_id  /**< */,
+                                   uint16_t          mask_len  /**< */,
+                                   const uint32_t   *mask  /**< */)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        /* count */ 4,
+        /* ext */ &xcb_gesture_id,
+        /* opcode */ XCB_GESTURE_SELECT_EVENTS,
+        /* isvoid */ 1
+    };
+    
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_gesture_select_events_request_t xcb_out;
+    
+    xcb_out.window = window;
+    xcb_out.device_id = device_id;
+    xcb_out.mask_len = mask_len;
+    
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    xcb_parts[4].iov_base = (char *) mask;
+    xcb_parts[4].iov_len = mask_len * sizeof(uint32_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+
+/*****************************************************************************
+ **
+ ** xcb_void_cookie_t xcb_gesture_select_events
+ ** 
+ ** @param xcb_connection_t *c
+ ** @param xcb_window_t      window
+ ** @param uint16_t          device_id
+ ** @param uint16_t          mask_len
+ ** @param const uint32_t   *mask
+ ** @returns xcb_void_cookie_t
+ **
+ *****************************************************************************/
+ 
+xcb_void_cookie_t
+xcb_gesture_select_events (xcb_connection_t *c  /**< */,
+                           xcb_window_t      window  /**< */,
+                           uint16_t          device_id  /**< */,
+                           uint16_t          mask_len  /**< */,
+                           const uint32_t   *mask  /**< */)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        /* count */ 4,
+        /* ext */ &xcb_gesture_id,
+        /* opcode */ XCB_GESTURE_SELECT_EVENTS,
+        /* isvoid */ 1
+    };
+    
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_gesture_select_events_request_t xcb_out;
+    
+    xcb_out.window = window;
+    xcb_out.device_id = device_id;
+    xcb_out.mask_len = mask_len;
+    
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    xcb_parts[4].iov_base = (char *) mask;
+    xcb_parts[4].iov_len = mask_len * sizeof(uint32_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+
+/*****************************************************************************
+ **
+ ** xcb_gesture_get_selected_events_cookie_t xcb_gesture_get_selected_events
+ ** 
+ ** @param xcb_connection_t *c
+ ** @param xcb_window_t      window
+ ** @returns xcb_gesture_get_selected_events_cookie_t
+ **
+ *****************************************************************************/
+ 
+xcb_gesture_get_selected_events_cookie_t
+xcb_gesture_get_selected_events (xcb_connection_t *c  /**< */,
+                                 xcb_window_t      window  /**< */)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        /* count */ 2,
+        /* ext */ &xcb_gesture_id,
+        /* opcode */ XCB_GESTURE_GET_SELECTED_EVENTS,
+        /* isvoid */ 0
+    };
+    
+    struct iovec xcb_parts[4];
+    xcb_gesture_get_selected_events_cookie_t xcb_ret;
+    xcb_gesture_get_selected_events_request_t xcb_out;
+    
+    xcb_out.window = window;
+    
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+
+/*****************************************************************************
+ **
+ ** xcb_gesture_get_selected_events_cookie_t xcb_gesture_get_selected_events_unchecked
+ ** 
+ ** @param xcb_connection_t *c
+ ** @param xcb_window_t      window
+ ** @returns xcb_gesture_get_selected_events_cookie_t
+ **
+ *****************************************************************************/
+ 
+xcb_gesture_get_selected_events_cookie_t
+xcb_gesture_get_selected_events_unchecked (xcb_connection_t *c  /**< */,
+                                           xcb_window_t      window  /**< */)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        /* count */ 2,
+        /* ext */ &xcb_gesture_id,
+        /* opcode */ XCB_GESTURE_GET_SELECTED_EVENTS,
+        /* isvoid */ 0
+    };
+    
+    struct iovec xcb_parts[4];
+    xcb_gesture_get_selected_events_cookie_t xcb_ret;
+    xcb_gesture_get_selected_events_request_t xcb_out;
+    
+    xcb_out.window = window;
+    
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+
+/*****************************************************************************
+ **
+ ** int xcb_gesture_get_selected_events_masks_length
+ ** 
+ ** @param const xcb_gesture_get_selected_events_reply_t *R
+ ** @returns int
+ **
+ *****************************************************************************/
+ 
+int
+xcb_gesture_get_selected_events_masks_length (const xcb_gesture_get_selected_events_reply_t *R  /**< */)
+{
+    return R->num_masks;
+}
+
+
+/*****************************************************************************
+ **
+ ** xcb_gesture_event_mask_iterator_t xcb_gesture_get_selected_events_masks_iterator
+ ** 
+ ** @param const xcb_gesture_get_selected_events_reply_t *R
+ ** @returns xcb_gesture_event_mask_iterator_t
+ **
+ *****************************************************************************/
+ 
+xcb_gesture_event_mask_iterator_t
+xcb_gesture_get_selected_events_masks_iterator (const xcb_gesture_get_selected_events_reply_t *R  /**< */)
+{
+    xcb_gesture_event_mask_iterator_t i;
+    i.data = (xcb_gesture_event_mask_t *) (R + 1);
+    i.rem = R->num_masks;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+
+/*****************************************************************************
+ **
+ ** xcb_gesture_get_selected_events_reply_t * xcb_gesture_get_selected_events_reply
+ ** 
+ ** @param xcb_connection_t                          *c
+ ** @param xcb_gesture_get_selected_events_cookie_t   cookie
+ ** @param xcb_generic_error_t                      **e
+ ** @returns xcb_gesture_get_selected_events_reply_t *
+ **
+ *****************************************************************************/
+ 
+xcb_gesture_get_selected_events_reply_t *
+xcb_gesture_get_selected_events_reply (xcb_connection_t                          *c  /**< */,
+                                       xcb_gesture_get_selected_events_cookie_t   cookie  /**< */,
+                                       xcb_generic_error_t                      **e  /**< */)
+{
+    return (xcb_gesture_get_selected_events_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+

=== added file 'unity-private/gesture/gesture.h'
--- unity-private/gesture/gesture.h	1970-01-01 00:00:00 +0000
+++ unity-private/gesture/gesture.h	2010-08-26 15:13:42 +0000
@@ -0,0 +1,547 @@
+/*
+ * This file generated automatically from gesture.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+/**
+ * @defgroup XCB_gesture_API XCB gesture API
+ * @brief gesture XCB Protocol Implementation.
+ * @{
+ **/
+
+#ifndef __GESTURE_H
+#define __GESTURE_H
+
+#include "xcb/xcb.h"
+#include "X11/Xproto.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define XCB_GESTURE_MAJOR_VERSION 0
+#define XCB_GESTURE_MINOR_VERSION 5
+  
+extern xcb_extension_t xcb_gesture_id;
+
+typedef float xcb_gesture_float32_t;
+
+/**
+ * @brief xcb_gesture_float32_iterator_t
+ **/
+typedef struct xcb_gesture_float32_iterator_t {
+    xcb_gesture_float32_t *data; /**<  */
+    int                    rem; /**<  */
+    int                    index; /**<  */
+} xcb_gesture_float32_iterator_t;
+
+/**
+ * @brief xcb_gesture_event_mask_t
+ **/
+typedef struct xcb_gesture_event_mask_t {
+    uint16_t device_id; /**<  */
+    uint16_t mask_len; /**<  */
+} xcb_gesture_event_mask_t;
+
+/**
+ * @brief xcb_gesture_event_mask_iterator_t
+ **/
+typedef struct xcb_gesture_event_mask_iterator_t {
+    xcb_gesture_event_mask_t *data; /**<  */
+    int                       rem; /**<  */
+    int                       index; /**<  */
+} xcb_gesture_event_mask_iterator_t;
+
+/**
+ * @brief xcb_gesture_query_version_cookie_t
+ **/
+typedef struct xcb_gesture_query_version_cookie_t {
+    unsigned int sequence; /**<  */
+} xcb_gesture_query_version_cookie_t;
+
+/** Opcode for xcb_gesture_query_version. */
+#define XCB_GESTURE_QUERY_VERSION 1
+
+/**
+ * @brief xcb_gesture_query_version_request_t
+ **/
+typedef struct xcb_gesture_query_version_request_t {
+    uint8_t  major_opcode; /**<  */
+    uint8_t  minor_opcode; /**<  */
+    uint16_t length; /**<  */
+    uint16_t major_version; /**<  */
+    uint16_t minor_version; /**<  */
+} xcb_gesture_query_version_request_t;
+
+/**
+ * @brief xcb_gesture_query_version_reply_t
+ **/
+typedef struct xcb_gesture_query_version_reply_t {
+    uint8_t  response_type; /**<  */
+    uint8_t  pad0; /**<  */
+    uint16_t sequence; /**<  */
+    uint32_t length; /**<  */
+    uint16_t major_version; /**<  */
+    uint16_t minor_version; /**<  */
+    uint8_t  pad1[20]; /**<  */
+} xcb_gesture_query_version_reply_t;
+
+/** Opcode for xcb_gesture_select_events. */
+#define XCB_GESTURE_SELECT_EVENTS 2
+
+/**
+ * @brief xcb_gesture_select_events_request_t
+ **/
+typedef struct xcb_gesture_select_events_request_t {
+    uint8_t      major_opcode; /**<  */
+    uint8_t      minor_opcode; /**<  */
+    uint16_t     length; /**<  */
+    xcb_window_t window; /**<  */
+    uint16_t     device_id; /**<  */
+    uint16_t     mask_len; /**<  */
+} xcb_gesture_select_events_request_t;
+
+/**
+ * @brief xcb_gesture_get_selected_events_cookie_t
+ **/
+typedef struct xcb_gesture_get_selected_events_cookie_t {
+    unsigned int sequence; /**<  */
+} xcb_gesture_get_selected_events_cookie_t;
+
+/** Opcode for xcb_gesture_get_selected_events. */
+#define XCB_GESTURE_GET_SELECTED_EVENTS 3
+
+/**
+ * @brief xcb_gesture_get_selected_events_request_t
+ **/
+typedef struct xcb_gesture_get_selected_events_request_t {
+    uint8_t      major_opcode; /**<  */
+    uint8_t      minor_opcode; /**<  */
+    uint16_t     length; /**<  */
+    xcb_window_t window; /**<  */
+} xcb_gesture_get_selected_events_request_t;
+
+/**
+ * @brief xcb_gesture_get_selected_events_reply_t
+ **/
+typedef struct xcb_gesture_get_selected_events_reply_t {
+    uint8_t  response_type; /**<  */
+    uint8_t  pad0; /**<  */
+    uint16_t sequence; /**<  */
+    uint32_t length; /**<  */
+    uint16_t num_masks; /**<  */
+    uint8_t  pad1[22]; /**<  */
+} xcb_gesture_get_selected_events_reply_t;
+
+/** Opcode for xcb_gesture_notify. */
+#define XCB_GESTURE_NOTIFY 0
+
+/**
+ * @brief xcb_gesture_notify_event_t
+ **/
+typedef struct xcb_gesture_notify_event_t {
+    uint8_t               response_type; /**<  */
+    uint8_t               extension; /**<  */
+    uint16_t              sequence; /**<  */
+    uint32_t              length; /**<  */
+    uint16_t              event_type; /**<  */
+    uint16_t              gesture_id; /**<  */
+    uint16_t              gesture_type; /**<  */
+    uint16_t              device_id; /**<  */
+    xcb_timestamp_t       time; /**<  */
+    xcb_window_t          root; /**<  */
+    xcb_window_t          event; /**<  */
+    xcb_window_t          child; /**<  */
+    uint32_t              full_sequence; /**<  */
+    xcb_gesture_float32_t focus_x; /**<  */
+    xcb_gesture_float32_t focus_y; /**<  */
+    uint16_t              status; /**<  */
+    uint16_t              num_props; /**<  */
+} xcb_gesture_notify_event_t;
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_gesture_float32_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_gesture_float32_t)
+ */
+
+/*****************************************************************************
+ **
+ ** void xcb_gesture_float32_next
+ ** 
+ ** @param xcb_gesture_float32_iterator_t *i
+ ** @returns void
+ **
+ *****************************************************************************/
+ 
+void
+xcb_gesture_float32_next (xcb_gesture_float32_iterator_t *i  /**< */);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_gesture_float32_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+
+/*****************************************************************************
+ **
+ ** xcb_generic_iterator_t xcb_gesture_float32_end
+ ** 
+ ** @param xcb_gesture_float32_iterator_t i
+ ** @returns xcb_generic_iterator_t
+ **
+ *****************************************************************************/
+ 
+xcb_generic_iterator_t
+xcb_gesture_float32_end (xcb_gesture_float32_iterator_t i  /**< */);
+
+
+/*****************************************************************************
+ **
+ ** uint32_t * xcb_gesture_event_mask_mask_data
+ ** 
+ ** @param const xcb_gesture_event_mask_t *R
+ ** @returns uint32_t *
+ **
+ *****************************************************************************/
+ 
+uint32_t *
+xcb_gesture_event_mask_mask_data (const xcb_gesture_event_mask_t *R  /**< */);
+
+
+/*****************************************************************************
+ **
+ ** int xcb_gesture_event_mask_mask_data_length
+ ** 
+ ** @param const xcb_gesture_event_mask_t *R
+ ** @returns int
+ **
+ *****************************************************************************/
+ 
+int
+xcb_gesture_event_mask_mask_data_length (const xcb_gesture_event_mask_t *R  /**< */);
+
+
+/*****************************************************************************
+ **
+ ** xcb_generic_iterator_t xcb_gesture_event_mask_mask_data_end
+ ** 
+ ** @param const xcb_gesture_event_mask_t *R
+ ** @returns xcb_generic_iterator_t
+ **
+ *****************************************************************************/
+ 
+xcb_generic_iterator_t
+xcb_gesture_event_mask_mask_data_end (const xcb_gesture_event_mask_t *R  /**< */);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_gesture_event_mask_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_gesture_event_mask_t)
+ */
+
+/*****************************************************************************
+ **
+ ** void xcb_gesture_event_mask_next
+ ** 
+ ** @param xcb_gesture_event_mask_iterator_t *i
+ ** @returns void
+ **
+ *****************************************************************************/
+ 
+void
+xcb_gesture_event_mask_next (xcb_gesture_event_mask_iterator_t *i  /**< */);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_gesture_event_mask_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+
+/*****************************************************************************
+ **
+ ** xcb_generic_iterator_t xcb_gesture_event_mask_end
+ ** 
+ ** @param xcb_gesture_event_mask_iterator_t i
+ ** @returns xcb_generic_iterator_t
+ **
+ *****************************************************************************/
+ 
+xcb_generic_iterator_t
+xcb_gesture_event_mask_end (xcb_gesture_event_mask_iterator_t i  /**< */);
+
+/**
+ * Delivers a request to the X server
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ * 
+ */
+
+/*****************************************************************************
+ **
+ ** xcb_gesture_query_version_cookie_t xcb_gesture_query_version
+ ** 
+ ** @param xcb_connection_t *c
+ ** @param uint16_t          major_version
+ ** @param uint16_t          minor_version
+ ** @returns xcb_gesture_query_version_cookie_t
+ **
+ *****************************************************************************/
+ 
+xcb_gesture_query_version_cookie_t
+xcb_gesture_query_version (xcb_connection_t *c  /**< */,
+                           uint16_t          major_version  /**< */,
+                           uint16_t          minor_version  /**< */);
+
+/**
+ * Delivers a request to the X server
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ * 
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+
+/*****************************************************************************
+ **
+ ** xcb_gesture_query_version_cookie_t xcb_gesture_query_version_unchecked
+ ** 
+ ** @param xcb_connection_t *c
+ ** @param uint16_t          major_version
+ ** @param uint16_t          minor_version
+ ** @returns xcb_gesture_query_version_cookie_t
+ **
+ *****************************************************************************/
+ 
+xcb_gesture_query_version_cookie_t
+xcb_gesture_query_version_unchecked (xcb_connection_t *c  /**< */,
+                                     uint16_t          major_version  /**< */,
+                                     uint16_t          minor_version  /**< */);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ * 
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_gesture_query_version_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+
+/*****************************************************************************
+ **
+ ** xcb_gesture_query_version_reply_t * xcb_gesture_query_version_reply
+ ** 
+ ** @param xcb_connection_t                    *c
+ ** @param xcb_gesture_query_version_cookie_t   cookie
+ ** @param xcb_generic_error_t                **e
+ ** @returns xcb_gesture_query_version_reply_t *
+ **
+ *****************************************************************************/
+ 
+xcb_gesture_query_version_reply_t *
+xcb_gesture_query_version_reply (xcb_connection_t                    *c  /**< */,
+                                 xcb_gesture_query_version_cookie_t   cookie  /**< */,
+                                 xcb_generic_error_t                **e  /**< */);
+
+/**
+ * Delivers a request to the X server
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ * 
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+
+/*****************************************************************************
+ **
+ ** xcb_void_cookie_t xcb_gesture_select_events_checked
+ ** 
+ ** @param xcb_connection_t *c
+ ** @param xcb_window_t      window
+ ** @param uint16_t          device_id
+ ** @param uint16_t          mask_len
+ ** @param const uint32_t   *mask
+ ** @returns xcb_void_cookie_t
+ **
+ *****************************************************************************/
+ 
+xcb_void_cookie_t
+xcb_gesture_select_events_checked (xcb_connection_t *c  /**< */,
+                                   xcb_window_t      window  /**< */,
+                                   uint16_t          device_id  /**< */,
+                                   uint16_t          mask_len  /**< */,
+                                   const uint32_t   *mask  /**< */);
+
+/**
+ * Delivers a request to the X server
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ * 
+ */
+
+/*****************************************************************************
+ **
+ ** xcb_void_cookie_t xcb_gesture_select_events
+ ** 
+ ** @param xcb_connection_t *c
+ ** @param xcb_window_t      window
+ ** @param uint16_t          device_id
+ ** @param uint16_t          mask_len
+ ** @param const uint32_t   *mask
+ ** @returns xcb_void_cookie_t
+ **
+ *****************************************************************************/
+ 
+xcb_void_cookie_t
+xcb_gesture_select_events (xcb_connection_t *c  /**< */,
+                           xcb_window_t      window  /**< */,
+                           uint16_t          device_id  /**< */,
+                           uint16_t          mask_len  /**< */,
+                           const uint32_t   *mask  /**< */);
+
+/**
+ * Delivers a request to the X server
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ * 
+ */
+
+/*****************************************************************************
+ **
+ ** xcb_gesture_get_selected_events_cookie_t xcb_gesture_get_selected_events
+ ** 
+ ** @param xcb_connection_t *c
+ ** @param xcb_window_t      window
+ ** @returns xcb_gesture_get_selected_events_cookie_t
+ **
+ *****************************************************************************/
+ 
+xcb_gesture_get_selected_events_cookie_t
+xcb_gesture_get_selected_events (xcb_connection_t *c  /**< */,
+                                 xcb_window_t      window  /**< */);
+
+/**
+ * Delivers a request to the X server
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ * 
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+
+/*****************************************************************************
+ **
+ ** xcb_gesture_get_selected_events_cookie_t xcb_gesture_get_selected_events_unchecked
+ ** 
+ ** @param xcb_connection_t *c
+ ** @param xcb_window_t      window
+ ** @returns xcb_gesture_get_selected_events_cookie_t
+ **
+ *****************************************************************************/
+ 
+xcb_gesture_get_selected_events_cookie_t
+xcb_gesture_get_selected_events_unchecked (xcb_connection_t *c  /**< */,
+                                           xcb_window_t      window  /**< */);
+
+
+/*****************************************************************************
+ **
+ ** int xcb_gesture_get_selected_events_masks_length
+ ** 
+ ** @param const xcb_gesture_get_selected_events_reply_t *R
+ ** @returns int
+ **
+ *****************************************************************************/
+ 
+int
+xcb_gesture_get_selected_events_masks_length (const xcb_gesture_get_selected_events_reply_t *R  /**< */);
+
+
+/*****************************************************************************
+ **
+ ** xcb_gesture_event_mask_iterator_t xcb_gesture_get_selected_events_masks_iterator
+ ** 
+ ** @param const xcb_gesture_get_selected_events_reply_t *R
+ ** @returns xcb_gesture_event_mask_iterator_t
+ **
+ *****************************************************************************/
+ 
+xcb_gesture_event_mask_iterator_t
+xcb_gesture_get_selected_events_masks_iterator (const xcb_gesture_get_selected_events_reply_t *R  /**< */);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ * 
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_gesture_get_selected_events_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+
+/*****************************************************************************
+ **
+ ** xcb_gesture_get_selected_events_reply_t * xcb_gesture_get_selected_events_reply
+ ** 
+ ** @param xcb_connection_t                          *c
+ ** @param xcb_gesture_get_selected_events_cookie_t   cookie
+ ** @param xcb_generic_error_t                      **e
+ ** @returns xcb_gesture_get_selected_events_reply_t *
+ **
+ *****************************************************************************/
+ 
+xcb_gesture_get_selected_events_reply_t *
+xcb_gesture_get_selected_events_reply (xcb_connection_t                          *c  /**< */,
+                                       xcb_gesture_get_selected_events_cookie_t   cookie  /**< */,
+                                       xcb_generic_error_t                      **e  /**< */);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/**
+ * @}
+ */

=== modified file 'unity-private/launcher/scroller-view.vala'
--- unity-private/launcher/scroller-view.vala	2010-08-26 10:27:34 +0000
+++ unity-private/launcher/scroller-view.vala	2010-08-26 15:13:42 +0000
@@ -586,9 +586,6 @@
       Cairo.TextExtents real_extents = Cairo.TextExtents ();
       cr.text_extents (text, out extents);
 
-      double w_diff = extents.width - real_extents.width;
-      double h_diff = extents.height - real_extents.height;
-
       w += extents.width;
       h += extents.height;
       cr.set_source_rgba (0.07, 0.07, 0.07, 0.8);

=== modified file 'unity-private/testing/background.vala'
--- unity-private/testing/background.vala	2010-08-25 16:39:53 +0000
+++ unity-private/testing/background.vala	2010-08-26 15:13:42 +0000
@@ -44,6 +44,11 @@
     private string sec_col;
     private string filename;
 
+    public Background ()
+    {
+      Object ();
+    }
+
     construct
     {
       START_FUNCTION ();

=== modified file 'unity-private/testing/test-window.vala'
--- unity-private/testing/test-window.vala	2010-08-12 10:18:36 +0000
+++ unity-private/testing/test-window.vala	2010-08-26 15:13:42 +0000
@@ -43,6 +43,7 @@
     private Panel.View          panel;
     private Places.Controller   controller;
     private Unity.Places.View   places;
+    private Gesture.Dispatcher  gesture_dispatcher;
 
     private bool showing_places;
 
@@ -156,6 +157,8 @@
           this.wnck_screen.active_window_changed.connect (this.on_active_window_changed);
         }
 
+      gesture_dispatcher = new Gesture.XCBDispatcher ();
+
       END_FUNCTION ();
     }
 

=== modified file 'vapi/mutter-2.28.vapi'
--- vapi/mutter-2.28.vapi	2010-08-12 11:41:51 +0000
+++ vapi/mutter-2.28.vapi	2010-08-26 15:13:42 +0000
@@ -789,6 +789,14 @@
 		public static void unmaximize (Mutter.MetaWindow window, Mutter.MetaMaximizeFlags directions);
 		[CCode (cname = "meta_window_unminimize")]
 		public static void unminimize (Mutter.MetaWindow window);
+    [CCode (cname = "meta_window_move_resize")]
+    public static void move_resize (Mutter.MetaWindow window, bool user_op, int root_x, int root_y, int width, int height);
+    [CCode (cname = "meta_window_get_geometry")]
+    public static void get_geometry (Mutter.MetaWindow window, out int x, out int y, out int width, out int height);
+    [CCode (cname = "meta_window_make_fullscreen")]
+    public static void make_fullscreen (Mutter.MetaWindow window);
+    [CCode (cname = "meta_window_unmake_fullscreen")]
+    public static void unmake_fullscreen (Mutter.MetaWindow window);
 	}
 	[Compact]
 	[CCode (cheader_filename = "mutter-plugins.h")]