Merge lp:~dandrader/nux/geis into lp:nux

[Jay Taoko]

Adding gestures support to Nux.

[Daniel d'Andrada (dandrader)]

It's worth noting that the Unity compiz plugin will have to be changed in order to work with a nux version that has gestures support. Currently it uses utouch-geis directly. With that nux patch in, it will have to use gestures via the nux API instead.

[Chase Douglas (chasedouglas)]

* Please use one of the c++ or NUX-specific casts. For example:

GeisAdapterEventSource *event_source = (GeisAdapterEventSource*) source;

should be:

GeisAdapterEventSource *event_source = reinterpret_cast<GeisAdapterEventSource*>(source);

* Why is GeisAdapter::nux_event_ a member instead of a local variable in ProcessGeisEvents?

* How do we make sure that a nux area that receives a gesture begin will also receive the gesture updates and end for the same gesture? What if the area moves such that the touches no longer are in it? The gesture events must still go to the area that received the begin event. I don't see code that handles this.

* GET_LATEST_EVENT should be a real function, not a macro. Use anonymous namespaces or static functions.

I have reviewed all the utouch-specific code. I think it's sound other than the above issues. I have not reviewed any code that modifies how Nux works.

review: Needs Fixing

[Jay Taoko (jaytaoko)]

I get a build error:

make[2]: Entering directory `/home/jay/inalogic/build/nux.geis/Nux'
  CXX libnux_2.0_la-GeisAdapter.lo
./GeisAdapter.cpp: In member function 'void nux::GeisAdapter::FillNuxEvent(nux::GestureEvent&, GeisEvent, nux::EventType)':
./GeisAdapter.cpp:344:41: error: 'GEIS_EVENT_ATTRIBUTE_CONSTRUCTION_FINISHED' was not declared in this scope

Am I missing a library on my system? I am still on Precise. I have libutouch-geis-dev installed.

review: Needs Information

[Daniel d'Andrada (dandrader)]

> I get a build error:
>
> make[2]: Entering directory `/home/jay/inalogic/build/nux.geis/Nux'
> CXX libnux_2.0_la-GeisAdapter.lo
> ./GeisAdapter.cpp: In member function 'void
> nux::GeisAdapter::FillNuxEvent(nux::GestureEvent&, GeisEvent,
> nux::EventType)':
> ./GeisAdapter.cpp:344:41: error: 'GEIS_EVENT_ATTRIBUTE_CONSTRUCTION_FINISHED'
> was not declared in this scope
>
> Am I missing a library on my system? I am still on Precise. I have libutouch-
> geis-dev installed.

No. That's a recent addition to utouch-geis API. You will have to get it directly from lp:utouch-geis/trunk.

[Daniel d'Andrada (dandrader)]

Back to "work in progress" status as GesturesSubscription API will need to be a bit more powerful to cater for Unity Shell compiz plugin use case.

[Daniel d'Andrada (dandrader)]

> * How do we make sure that a nux area that receives a gesture begin will also
> receive the gesture updates and end for the same gesture? What if the area
> moves such that the touches no longer are in it? The gesture events must still
> go to the area that received the begin event. I don't see code that handles
> this.

The class Gesture binds a gesture to a target InputArea. That is done on GESTURE_BEGIN event and doesn't change after that.

[Daniel d'Andrada (dandrader)]

> * Why is GeisAdapter::nux_event_ a member instead of a local variable in
> ProcessGeisEvents?

It's a small optimization to avoid unnecessary memory allocations.

[lp:~dandrader/nux/geis]

620. By Gord Allott on 2012-06-11

removes some executable flags from nux cpp/h files. Fixes: . Approved by Jay Taoko.

621. By Steve Baker on 2012-06-12

Cleaning up some coverity warnings.. Fixes: https://bugs.launchpad.net/bugs/937564, https://bugs.launchpad.net/bugs/937576, https://bugs.launchpad.net/bugs/937586, https://bugs.launchpad.net/bugs/937588. Approved by Tim Penhey.

622. By Andrea Azzarone on 2012-06-13

Don't call QueueDraw during the layout process.. Fixes: https://bugs.launchpad.net/bugs/994884. Approved by Michal Hruby, Tim Penhey.

[Daniel d'Andrada (dandrader)]

> * GET_LATEST_EVENT should be a real function, not a macro. Use anonymous
> namespaces or static functions.

That won't work because that code is called from both a const and a regular method that return a const reference and a regular one respectively. The only other way I see would be to call the const version from withing the non-const one and doing a const_cast on the return value. But I don't see it as a better option.

[Daniel d'Andrada (dandrader)]

It's been improved and all comments from Chase have been worked on (either fixed in code or explained).

A patch for unity to make is work with that new Nux is also ready in lp:~dandrader/unity/nux_gestures.

Ready for a new review.

[Chase Douglas (chasedouglas)]

> > * Why is GeisAdapter::nux_event_ a member instead of a local variable in
> > ProcessGeisEvents?
>
> It's a small optimization to avoid unnecessary memory allocations.

Sorry for not replying to this sooner.

Variables that are only accessed in a function should be local to that function. It's a rule in place in order to keep the source code structured. If a developer needs to change the code that manipulates the object, they would have to check how the object is used elsewhere unless it is local.

The object is a class with one virtual function and a bunch of data. This shouldn't be an issue when allocated on the stack.

review: Needs Fixing

[Chase Douglas (chasedouglas)]

> > * GET_LATEST_EVENT should be a real function, not a macro. Use anonymous
> > namespaces or static functions.
>
> That won't work because that code is called from both a const and a regular
> method that return a const reference and a regular one respectively. The only
> other way I see would be to call the const version from withing the non-const
> one and doing a const_cast on the return value. But I don't see it as a better
> option.

I guess I'm confused. Why do you need a const version of the method? Why not just return a non-const version, and any callers that want to keep it as const can just assign it to add const-ness.

review: Needs Information

[Chase Douglas (chasedouglas)]

> > * How do we make sure that a nux area that receives a gesture begin will
> also
> > receive the gesture updates and end for the same gesture? What if the area
> > moves such that the touches no longer are in it? The gesture events must
> still
> > go to the area that received the begin event. I don't see code that handles
> > this.
>
> The class Gesture binds a gesture to a target InputArea. That is done on
> GESTURE_BEGIN event and doesn't change after that.

I think I see how it's working now. I'm happy :).

[Chase Douglas (chasedouglas)]

I notice that only one gesture is allowed per target area. Theoretically this should be possible. The issue is when there are gestures with overlapping touches. Why now allow for multiple non-overlapping gestures?

review: Needs Fixing

[Daniel d'Andrada (dandrader)]

> I notice that only one gesture is allowed per target area. Theoretically this
> should be possible. The issue is when there are gestures with overlapping
> touches. Why now allow for multiple non-overlapping gestures?

What's the use for that? I fear this could make the implementation overly complex for no use case in sight.

[Daniel d'Andrada (dandrader)]

> > > * GET_LATEST_EVENT should be a real function, not a macro. Use anonymous
> > > namespaces or static functions.
> >
> > That won't work because that code is called from both a const and a regular
> > method that return a const reference and a regular one respectively. The
> only
> > other way I see would be to call the const version from withing the non-
> const
> > one and doing a const_cast on the return value. But I don't see it as a
> better
> > option.
>
> I guess I'm confused. Why do you need a const version of the method?

Because it's called from within other const methods.

> Why not just return a non-const version, and any callers that want to keep it as const
> can just assign it to add const-ness.

I didn't understand you. Could you please write down some example code?

[Daniel d'Andrada (dandrader)]

> > > * Why is GeisAdapter::nux_event_ a member instead of a local variable in
> > > ProcessGeisEvents?
> >
> > It's a small optimization to avoid unnecessary memory allocations.
>
> Sorry for not replying to this sooner.
>
> Variables that are only accessed in a function should be local to that
> function. It's a rule in place in order to keep the source code structured. If
> a developer needs to change the code that manipulates the object, they would
> have to check how the object is used elsewhere unless it is local.
>
> The object is a class with one virtual function and a bunch of data. This
> shouldn't be an issue when allocated on the stack.

Ok, I will remove that optimization since you insist on it.

[Chase Douglas (chasedouglas)]

On 06/15/2012 11:48 AM, Daniel d'Andrada wrote:
>>>> * GET_LATEST_EVENT should be a real function, not a macro. Use anonymous
>>>> namespaces or static functions.
>>>
>>> That won't work because that code is called from both a const and a regular
>>> method that return a const reference and a regular one respectively. The
>> only
>>> other way I see would be to call the const version from withing the non-
>> const
>>> one and doing a const_cast on the return value. But I don't see it as a
>> better
>>> option.
>>
>> I guess I'm confused. Why do you need a const version of the method?
>
> Because it's called from within other const methods.
>
>> Why not just return a non-const version, and any callers that want to keep it as const
>> can just assign it to add const-ness.
>
> I didn't understand you. Could you please write down some example code?

Sorry, I realize there are a few things going on, including me
forgetting about const methods only being able to call const methods.

I think we can resolve all this by removing the non-const
GetLatestEvent() method and making GestureEvent::Accept() and
GestureEvent::Reject() const methods too. There's nothing in those
methods that modify the GestureEvent object.

[Daniel d'Andrada (dandrader)]

> On 06/15/2012 11:48 AM, Daniel d'Andrada wrote:
> >>>> * GET_LATEST_EVENT should be a real function, not a macro. Use anonymous
> >>>> namespaces or static functions.
> >>>
> >>> That won't work because that code is called from both a const and a
> regular
> >>> method that return a const reference and a regular one respectively. The
> >> only
> >>> other way I see would be to call the const version from withing the non-
> >> const
> >>> one and doing a const_cast on the return value. But I don't see it as a
> >> better
> >>> option.
> >>
> >> I guess I'm confused. Why do you need a const version of the method?
> >
> > Because it's called from within other const methods.
> >
> >> Why not just return a non-const version, and any callers that want to keep
> it as const
> >> can just assign it to add const-ness.
> >
> > I didn't understand you. Could you please write down some example code?
>
> Sorry, I realize there are a few things going on, including me
> forgetting about const methods only being able to call const methods.
>
> I think we can resolve all this by removing the non-const
> GetLatestEvent() method and making GestureEvent::Accept() and
> GestureEvent::Reject() const methods too. There's nothing in those
> methods that modify the GestureEvent object.

That works but makes for a weird API. Accept() and Reject() doesn't sound like methods that should be const (like getters) even though in their current implementation they can be so.

[Chase Douglas (chasedouglas)]

On 06/15/2012 01:34 PM, Daniel d'Andrada wrote:
>> On 06/15/2012 11:48 AM, Daniel d'Andrada wrote:
>>>>>> * GET_LATEST_EVENT should be a real function, not a macro. Use anonymous
>>>>>> namespaces or static functions.
>>>>>
>>>>> That won't work because that code is called from both a const and a
>> regular
>>>>> method that return a const reference and a regular one respectively. The
>>>> only
>>>>> other way I see would be to call the const version from withing the non-
>>>> const
>>>>> one and doing a const_cast on the return value. But I don't see it as a
>>>> better
>>>>> option.
>>>>
>>>> I guess I'm confused. Why do you need a const version of the method?
>>>
>>> Because it's called from within other const methods.
>>>
>>>> Why not just return a non-const version, and any callers that want to keep
>> it as const
>>>> can just assign it to add const-ness.
>>>
>>> I didn't understand you. Could you please write down some example code?
>>
>> Sorry, I realize there are a few things going on, including me
>> forgetting about const methods only being able to call const methods.
>>
>> I think we can resolve all this by removing the non-const
>> GetLatestEvent() method and making GestureEvent::Accept() and
>> GestureEvent::Reject() const methods too. There's nothing in those
>> methods that modify the GestureEvent object.
>
> That works but makes for a weird API. Accept() and Reject() doesn't sound like methods that should be const (like getters) even though in their current implementation they can be so.

I understand the logic, but c++ constness is really an API construct,
not a logic construct. Usually the domains overlap, but not always.
Admittedly, I don't have any good examples, but I feel being true to the
execution when using constness is best.

Please enlighten me if you think I'm wrong. I'm not an expert on C++, I
just hope I know how to not shoot my foot with it :).

[Daniel d'Andrada (dandrader)]

> On 06/15/2012 01:34 PM, Daniel d'Andrada wrote:
> >> On 06/15/2012 11:48 AM, Daniel d'Andrada wrote:
> >>>>>> * GET_LATEST_EVENT should be a real function, not a macro. Use
> anonymous
> >>>>>> namespaces or static functions.
> >>>>>
> >>>>> That won't work because that code is called from both a const and a
> >> regular
> >>>>> method that return a const reference and a regular one respectively. The
> >>>> only
> >>>>> other way I see would be to call the const version from withing the non-
> >>>> const
> >>>>> one and doing a const_cast on the return value. But I don't see it as a
> >>>> better
> >>>>> option.
> >>>>
> >>>> I guess I'm confused. Why do you need a const version of the method?
> >>>
> >>> Because it's called from within other const methods.
> >>>
> >>>> Why not just return a non-const version, and any callers that want to
> keep
> >> it as const
> >>>> can just assign it to add const-ness.
> >>>
> >>> I didn't understand you. Could you please write down some example code?
> >>
> >> Sorry, I realize there are a few things going on, including me
> >> forgetting about const methods only being able to call const methods.
> >>
> >> I think we can resolve all this by removing the non-const
> >> GetLatestEvent() method and making GestureEvent::Accept() and
> >> GestureEvent::Reject() const methods too. There's nothing in those
> >> methods that modify the GestureEvent object.
> >
> > That works but makes for a weird API. Accept() and Reject() doesn't sound
> like methods that should be const (like getters) even though in their current
> implementation they can be so.
>
> I understand the logic, but c++ constness is really an API construct,
> not a logic construct. Usually the domains overlap, but not always.
> Admittedly, I don't have any good examples, but I feel being true to the
> execution when using constness is best.
>
> Please enlighten me if you think I'm wrong. I'm not an expert on C++, I
> just hope I know how to not shoot my foot with it :).

Changed from the macro to the const_cast way that people say "Effective C++" book advocates.
Hope you like it better :)

[Chase Douglas (chasedouglas)]

> > On 06/15/2012 01:34 PM, Daniel d'Andrada wrote:
> > >> On 06/15/2012 11:48 AM, Daniel d'Andrada wrote:
> > >>>>>> * GET_LATEST_EVENT should be a real function, not a macro. Use
> > anonymous
> > >>>>>> namespaces or static functions.
> > >>>>>
> > >>>>> That won't work because that code is called from both a const and a
> > >> regular
> > >>>>> method that return a const reference and a regular one respectively.
> The
> > >>>> only
> > >>>>> other way I see would be to call the const version from withing the
> non-
> > >>>> const
> > >>>>> one and doing a const_cast on the return value. But I don't see it as
> a
> > >>>> better
> > >>>>> option.
> > >>>>
> > >>>> I guess I'm confused. Why do you need a const version of the method?
> > >>>
> > >>> Because it's called from within other const methods.
> > >>>
> > >>>> Why not just return a non-const version, and any callers that want to
> > keep
> > >> it as const
> > >>>> can just assign it to add const-ness.
> > >>>
> > >>> I didn't understand you. Could you please write down some example code?
> > >>
> > >> Sorry, I realize there are a few things going on, including me
> > >> forgetting about const methods only being able to call const methods.
> > >>
> > >> I think we can resolve all this by removing the non-const
> > >> GetLatestEvent() method and making GestureEvent::Accept() and
> > >> GestureEvent::Reject() const methods too. There's nothing in those
> > >> methods that modify the GestureEvent object.
> > >
> > > That works but makes for a weird API. Accept() and Reject() doesn't sound
> > like methods that should be const (like getters) even though in their
> current
> > implementation they can be so.
> >
> > I understand the logic, but c++ constness is really an API construct,
> > not a logic construct. Usually the domains overlap, but not always.
> > Admittedly, I don't have any good examples, but I feel being true to the
> > execution when using constness is best.
> >
> > Please enlighten me if you think I'm wrong. I'm not an expert on C++, I
> > just hope I know how to not shoot my foot with it :).
>
> Changed from the macro to the const_cast way that people say "Effective C++"
> book advocates.
> Hope you like it better :)

It's better, but I'm not sure it's 100% correct. It feels to me like this shows the design isn't proper, but I admit to having written similar things in the past because I couldn't figure out how to do it "correctly" either. I certainly don't have any better suggestions, so it's good enough for me :).

Everything else I've noted has been taken care of, so I approve :). Yay!

review: Approve

[lp:~dandrader/nux/geis]

623. By Daniel van Vugt on 2012-06-19

Don't allow a View to be queued multiple times on the draw list. It causes
unbounded list growth and the UI to freeze in some cases. (LP: #1014610)
. Fixes: https://bugs.launchpad.net/bugs/1014610. Approved by Tim Penhey.

624. By Brandon Schaefer on 2012-06-22

Fix memory leak in InputMethdIBus::OnPreeditUpdate.. Fixes: . Approved by Marco Trevisan (Treviño).

625. By Marco Trevisan (Treviño) on 2012-06-27

TextEntry: Handle also Key-Up events so that ibus will work with release hotkeys

InputMethodIBus: keep a list of hotkey events and add IsHotkeyEvent and IsConnected. Fixes: https://bugs.launchpad.net/bugs/1016665. Approved by Brandon Schaefer.

626. By Łukasz Zemczak on 2012-07-03

Updated Nux API version to 3.0. Deprecated nux-image library. The feature by nux-image has been merged into nux-graphics.. Fixes: . Approved by Łukasz Zemczak, Didier Roche, Tim Penhey.

627. By Marco Trevisan (Treviño) on 2012-07-03

TextEntry: don't allow invalid character to be written and ignore keypress when holding Alt or Super. Fixes: https://bugs.launchpad.net/bugs/1013751. Approved by Brandon Schaefer.

628. By Marco Trevisan (Treviño) on 2012-07-03

TextEntry: make the clipboard functions virtual to be implemented by clients. Fixes: https://bugs.launchpad.net/bugs/1016354. Approved by Thomi Richards, Brandon Schaefer.

629. By Marco Trevisan (Treviño) on 2012-07-10

TextEntry: ignore meta keypresses when in composition mode. Fixes: https://bugs.launchpad.net/bugs/961741. Approved by Andrea Azzarone.

630. By Marco Trevisan (Treviño) on 2012-07-11

TextEntry: correctly handle a "double-deadkey" pressure

Correctly reset the dead_key mode when terminated.. Fixes: https://bugs.launchpad.net/bugs/950740, https://bugs.launchpad.net/bugs/961741. Approved by Brandon Schaefer.

631. By Michal Hruby on 2012-07-11

Make GdkPixbuf conversions faster. Fixes: . Approved by Jay Taoko, Sam Spilsbury.

632. By Jay Taoko on 2012-07-11

* Fix in volume texture API. Fixes: . Approved by Gord Allott.

633. By Marco Trevisan (Treviño) on 2012-07-11

TextEntryComposeSeqs: updated with new sequencies computed using compose key list generator script

List based on:
http://cgit.freedesktop.org/xorg/lib/libX11/plain/nls/en_US.UTF-8/Compose.pre

Updated also the dead_keys_map with valid values and updated to char*. Fixes: https://bugs.launchpad.net/bugs/961741. Approved by Brandon Schaefer.

634. By Jay Taoko on 2012-07-12

* Refactoring Nux timer API: Some cleanup and update were required for the animation framework.. Fixes: . Approved by Jay Taoko.

635. By Marco Trevisan (Treviño) on 2012-07-14

TextEntry: refactored the composition code to use KeySym's. Fixes: . Approved by Brandon Schaefer.

636. By Brandon Schaefer on 2012-07-16

Fixed some tests.. Fixes: . Approved by Thomi Richards.

637. By Jay Taoko on 2012-07-18

* Added support for character hiding in the text entry (password input). Fixes: . Approved by Brandon Schaefer.

650. By Daniel d'Andrada on 2012-06-07

Obey event inspectors and do discard events when told so

651. By Daniel d'Andrada on 2012-06-13

Split a Geis Tap Update into a Tap Begin and a Tap End

That's to ensure that all gestures behave consistenly. They
should be comprised by a Begin event followed by zero or more
Update events and end with a End event.

Tap gestures don't follow this rule as it only sends a single Update
and nothing more. Exposing this to upper layers in the code would require
special casing of Tap gestures everywhere.

652. By Daniel d'Andrada on 2012-06-14

Make GesturesSubscriptions accept multiple gesture classes

653. By Daniel d'Andrada on 2012-06-14

Use C++ casts instead of C casts in GeisAdapter

654. By Daniel d'Andrada on 2012-06-14

Correctly process gesture events that finish their constructions only when ending.

655. By Daniel d'Andrada on 2012-06-15

Expose configuration options in GesturesSubscription

656. By Daniel d'Andrada on 2012-06-15

GeisAdapter: make nux_event_ a local variable

As it's only used iniside ProcessGeisEvents().
The code gets clearer and the performance penalty should be irrelevant.

657. By Daniel d'Andrada on 2012-06-15

Gestures support needs at least version 2.2.10 or utouch-geis

658. By Daniel d'Andrada on 2012-06-15

Resolve the const&non-const getters issue the const_cast way

As "Effective C++" advocates

659. By Daniel d'Andrada on 2012-06-26

Some refactoring so that unity can use more code from nux

instead of having unity using a modified copy of GestureBroker, Gesture, etc.

660. By Daniel d'Andrada on 2012-06-26

Fix build

661. By Daniel d'Andrada on 2012-07-27

Use geis from Open Input Framework instead of utouch-geis

662. By Daniel d'Andrada on 2012-07-27

Fix build of gtest-nux

663. By Daniel d'Andrada on 2012-08-01

Bump ABI version

[Jay Taoko (jaytaoko)]

review: Approve

=== modified file '.bzrignore'
--- .bzrignore	2011-11-11 00:40:50 +0000
+++ .bzrignore	2012-08-01 18:42:21 +0000
@@ -63,5 +63,7 @@
 **/nux.log
 **/nux.log.*
 examples/cairo_wrapper
+examples/gestures
 examples/tiles_view
 test-graphics-display
+Nux/Features.h

=== modified file 'Nux/Area.cpp'
--- Nux/Area.cpp	2012-06-12 09:13:06 +0000
+++ Nux/Area.cpp	2012-08-01 18:42:21 +0000
@@ -29,6 +29,10 @@
 #include "BaseWindow.h"
 #include "MenuPage.h"
 
+#ifdef NUX_GESTURES_SUPPORT
+#include "NuxGraphics/GestureEvent.h"
+#endif
+
 namespace nux
 {
 
@@ -1036,5 +1040,34 @@
 
     return false;
   }
+
+#ifdef NUX_GESTURES_SUPPORT
+  Area* Area::GetInputAreaHitByGesture(const GestureEvent &event)
+  {
+    return nullptr;
+  }
+
+  bool Area::IsGestureInsideArea(const nux::GestureEvent &event) const
+  {
+    if (event.IsDirectTouch())
+    {
+      Geometry geometry = GetAbsoluteGeometry();
+      Point p;
+      for (const auto touch_point : event.GetTouches())
+      {
+        p.x = (int)touch_point.x;
+        p.y = (int)touch_point.y;
+        if (!geometry.IsInside(p))
+          return false;
+      }
+      return true;
+    }
+    else
+    {
+      return GetAbsoluteGeometry().IsInside(event.GetFocus());
+    }
+  }
+
+#endif // NUX_GESTURES_SUPPORT
 }
 

=== modified file 'Nux/Area.h'
--- Nux/Area.h	2012-03-12 21:45:30 +0000
+++ Nux/Area.h	2012-08-01 18:42:21 +0000
@@ -24,6 +24,7 @@
 #define BASEOBJECT_H
 
 #include <sigc++/sigc++.h>
+#include "Features.h"
 #include "NuxCore/InitiallyUnownedObject.h"
 #include "NuxGraphics/Events.h"
 #include "Utils.h"
@@ -33,6 +34,9 @@
 {
   class WindowThread;
   class GraphicsEngine;
+#ifdef NUX_GESTURES_SUPPORT
+  class GestureEvent;
+#endif // NUX_GESTURES_SUPPORT
 
 // In a Horizontal/Vertical Layout, the following enum have the respective meanings:
 // eFull: the object has the full height/width of the parent layout(minus margins)
@@ -623,6 +627,21 @@
     //! If this variable is not NULL, then this area is part of the keyboard focus chain.
     Area* next_object_to_key_focus_area_;
 
+
+#ifdef NUX_GESTURES_SUPPORT
+    //! Returns the InputArea hit by the given gesture
+    virtual Area* GetInputAreaHitByGesture(const GestureEvent &event);
+
+    //! Returns whether the gesture from the given event is fully inside this area.
+    /*!
+      For getures from direct devices (e.g. touchscreens), it checks whether all
+      touch points lie within this area's boundaries. For gestures from indirect
+      devices (e.g. touchpads) it checks whether the gesture's focus point lies
+      inside this area.
+     */
+    bool IsGestureInsideArea(const GestureEvent &event) const;
+#endif // NUX_GESTURES_SUPPORT
+
   private:
     void ReconfigureParentLayout(Area *child = 0);
     void CheckMinSize();

=== modified file 'Nux/BaseWindow.cpp'
--- Nux/BaseWindow.cpp	2012-01-18 19:51:33 +0000
+++ Nux/BaseWindow.cpp	2012-08-01 18:42:21 +0000
@@ -511,4 +511,27 @@
   {
     return accept_key_nav_focus_;
   }
+
+#ifdef NUX_GESTURES_SUPPORT
+  Area* BaseWindow::GetInputAreaHitByGesture(const nux::GestureEvent &event)
+  {
+    if (!IsVisible())
+      return nullptr;
+
+    if (!IsGestureInsideArea(event))
+      return nullptr;
+
+    if (m_layout)
+    {
+      Area *area_hit = m_layout->GetInputAreaHitByGesture(event);
+      if (area_hit)
+        return area_hit;
+    }
+
+    if (HasSubscriptionForGesture(event))
+      return this;
+    else
+      return nullptr;
+  }
+#endif
 }

=== modified file 'Nux/BaseWindow.h'
--- Nux/BaseWindow.h	2012-01-17 20:15:44 +0000
+++ Nux/BaseWindow.h	2012-08-01 18:42:21 +0000
@@ -26,6 +26,7 @@
 
 #include <boost/scoped_ptr.hpp>
 #include "ScrollView.h"
+#include "Features.h"
 
 #if defined(NUX_OS_WINDOWS)
 #include "NuxGraphics/Events.h"
@@ -46,6 +47,10 @@
   class HLayout;
   class PopUpWindow;
 
+#ifdef NUX_GESTURES_SUPPORT
+    class GestureEvent;
+#endif
+
   //typedef TopView BaseWindow;
 
   /*!
@@ -186,6 +191,11 @@
     {
       return _name;
     }
+
+#ifdef NUX_GESTURES_SUPPORT
+    virtual Area* GetInputAreaHitByGesture(const nux::GestureEvent &event);
+#endif
+
   protected:
 
     void SetAcceptKeyNavFocus(bool accept);

=== added file 'Nux/Features.h.in'
--- Nux/Features.h.in	1970-01-01 00:00:00 +0000
+++ Nux/Features.h.in	2012-08-01 18:42:21 +0000
@@ -0,0 +1,14 @@
+/* This file specifies which optional features are available on this specific
+   build of NUX libraries
+
+   Generated from Features.h.in by configure.
+ */
+
+#ifndef NUX_FEATURES_H
+#define NUX_FEATURES_H
+
+// Whether NUX was built with gestures support. I.e., whether the gestures
+// API is available.
+#define @NUX_GESTURES_SUPPORT@
+
+#endif

=== added file 'Nux/GeisAdapter.cpp'
--- Nux/GeisAdapter.cpp	1970-01-01 00:00:00 +0000
+++ Nux/GeisAdapter.cpp	2012-08-01 18:42:21 +0000
@@ -0,0 +1,528 @@
+/*
+ * Copyright 2012 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License, as
+ * published by the  Free Software Foundation; either version 2.1 or 3.0
+ * of the License.
+ *
+ * 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 along with this program. If not, see <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Daniel d'Andrada <[e-mail]>
+ *
+ */
+
+#include <NuxCore/Logger.h>
+#include <string.h>
+#include "GeisAdapter.h"
+
+#if (defined(NUX_OS_LINUX) || defined(NUX_USE_GLIB_LOOP_ON_WINDOWS)) && (!defined(NUX_DISABLE_GLIB_LOOP))
+#define NUX_USE_GLIB_LOOP
+#endif
+
+#define GEIS_CLASS_UNREF(c) if (c) {geis_gesture_class_unref(c); c = nullptr;}
+
+using namespace nux;
+
+namespace
+{
+  nux::logging::Logger logger("nux.geisadapter");
+
+#ifdef NUX_USE_GLIB_LOOP
+  struct GeisAdapterEventSource
+  {
+    GSource source;
+    GPollFD event_poll_fd;
+  };
+
+  static gboolean geis_source_prepare(GSource *source, gint *timeout)
+  {
+    *timeout = -1;
+    return FALSE;
+  }
+
+  static gboolean geis_source_check(GSource *source)
+  {
+    gboolean retval;
+    GeisAdapterEventSource *event_source = reinterpret_cast<GeisAdapterEventSource*>(source);
+
+    if ((event_source->event_poll_fd.revents & G_IO_IN))
+    {
+      retval = TRUE;
+    }
+    else
+    {
+      retval = FALSE;
+    }
+
+    return retval;
+  }
+
+  gboolean geis_source_dispatch(GSource *source, GSourceFunc  callback, gpointer user_data)
+  {
+    GeisAdapter *geis_adapter = NUX_STATIC_CAST(GeisAdapter*, user_data);
+    geis_adapter->ProcessGeisEvents();
+    return TRUE;
+  }
+
+  static GSourceFuncs geis_source_funcs =
+  {
+    geis_source_prepare,
+    geis_source_check,
+    geis_source_dispatch,
+    NULL
+  };
+#endif
+}
+
+GeisAdapter::GeisAdapter() :
+    geis_(nullptr)
+  , class_drag_(nullptr)
+  , class_pinch_(nullptr)
+  , class_rotate_(nullptr)
+  , class_tap_(nullptr)
+  , class_touch_(nullptr)
+  , is_init_complete_(false)
+{
+  geis_ = geis_new(GEIS_INIT_NO_ATOMIC_GESTURES, nullptr);
+  if (!geis_)
+  {
+    LOG_WARNING(logger) << "Couldn't create a Geis instance."
+                           " Multitouch gesture support disabled.";
+  }
+}
+
+GeisAdapter::~GeisAdapter()
+{
+  GEIS_CLASS_UNREF(class_drag_)
+  GEIS_CLASS_UNREF(class_pinch_)
+  GEIS_CLASS_UNREF(class_rotate_)
+  GEIS_CLASS_UNREF(class_tap_)
+  GEIS_CLASS_UNREF(class_touch_)
+  geis_delete(geis_);
+
+#ifdef NUX_USE_GLIB_LOOP
+  g_source_remove_by_funcs_user_data(&geis_source_funcs, this);
+#endif
+}
+
+#ifdef NUX_USE_GLIB_LOOP
+void GeisAdapter::CreateGSource(GMainContext *context)
+{
+  GSource *source = g_source_new(&geis_source_funcs,
+                                 sizeof(GeisAdapterEventSource));
+  GeisAdapterEventSource *event_source = reinterpret_cast<GeisAdapterEventSource*>(source);
+
+  g_source_set_priority(source, G_PRIORITY_DEFAULT);
+
+  GeisStatus status = geis_get_configuration(geis_, GEIS_CONFIGURATION_FD,
+      &event_source->event_poll_fd.fd);
+  if (status != GEIS_STATUS_SUCCESS)
+  {
+    LOG_WARNING(logger) << "Failed to get geis file descriptor."
+      " Multitouch gesture support disabled.";
+    g_source_destroy(source);
+    return;
+  }
+
+  event_source->event_poll_fd.events = G_IO_IN;
+
+  g_source_add_poll(source, &event_source->event_poll_fd);
+  g_source_set_callback(source, 0, this, 0);
+
+  g_source_attach(source, context);
+}
+#endif // NUX_USE_GLIB_LOOP
+
+void GeisAdapter::ProcessGeisEvents()
+{
+  GeisEvent event = nullptr;
+  GeisStatus status = GEIS_STATUS_UNKNOWN_ERROR;
+  GestureEvent nux_event;
+
+  status = geis_dispatch_events(geis_);
+  if (status != GEIS_STATUS_SUCCESS)
+  {
+    LOG_WARNING(logger) << "Failed to dispatch events! Status: " << status;
+  }
+
+  status = geis_next_event(geis_, &event);
+  if (status != GEIS_STATUS_SUCCESS && status != GEIS_STATUS_CONTINUE
+      && status != GEIS_STATUS_EMPTY)
+  {
+    LOG_WARNING(logger) << "Failed to get next event! Status: " << status;
+  }
+
+  while (status == GEIS_STATUS_CONTINUE || status == GEIS_STATUS_SUCCESS)
+  {
+    switch (geis_event_type(event))
+    {
+      case GEIS_EVENT_GESTURE_BEGIN:
+        FillNuxEvent(nux_event, event, EVENT_GESTURE_BEGIN);
+        event_ready.emit(nux_event);
+        break;
+      case GEIS_EVENT_GESTURE_UPDATE:
+        FillNuxEvent(nux_event, event, EVENT_GESTURE_UPDATE);
+        if (nux_event.GetGestureClasses() == TAP_GESTURE)
+        {
+          // Geis sends a single Update event for a tap gesture and nothing more,
+          // but it's better to be consistent with the rule that all gestures
+          // must begin and end (with any number of updates in between).
+          // Otherwise code in upper layers will have to add special cases just
+          // for the tap gesture.
+          nuxAssert(!pending_next_event_);
+          SplitUpdateIntoBeginAndEnd(nux_event);
+          nuxAssert(pending_next_event_);
+          event_ready.emit(nux_event);
+          event_ready.emit(*pending_next_event_);
+          pending_next_event_.reset();
+        }
+        else
+          event_ready.emit(nux_event);
+        break;
+      case GEIS_EVENT_GESTURE_END:
+        FillNuxEvent(nux_event, event, EVENT_GESTURE_END);
+        event_ready.emit(nux_event);
+        break;
+      case GEIS_EVENT_CLASS_AVAILABLE:
+        this->ProcessEventClassAvailable(event);
+        break;
+      case GEIS_EVENT_DEVICE_AVAILABLE:
+        this->ProcessEventDeviceAvailable(event);
+        break;
+      case GEIS_EVENT_DEVICE_UNAVAILABLE:
+        this->ProcessEventDeviceUnavailable(event);
+        break;
+      case GEIS_EVENT_INIT_COMPLETE:
+        this->is_init_complete_ = true;
+        this->init_complete.emit();
+        break;
+      default:
+        break;
+    }
+    geis_event_delete(event);
+    status = geis_next_event(this->geis_, &event);
+  }
+}
+
+void GeisAdapter::SplitUpdateIntoBeginAndEnd(GestureEvent &nux_event)
+{
+  nux_event.type = EVENT_GESTURE_BEGIN;
+
+  // Work around a bug in geis. A very quick gesture (e.g. a quick tap)
+  // will end with its is_construction_finished still set to false.
+  // https://bugs.launchpad.net/grail/+bug/1012315
+  nux_event.is_construction_finished_ = true;
+
+  pending_next_event_.reset(new GestureEvent);
+  *pending_next_event_ = nux_event;
+  pending_next_event_->type = EVENT_GESTURE_END;
+}
+
+bool GeisAdapter::ProcessNextEvent(GestureEvent *nux_event)
+{
+  if (pending_next_event_)
+  {
+    *nux_event = *pending_next_event_;
+    pending_next_event_.reset();
+    return true;
+  }
+
+  GeisEvent event = nullptr;
+  GeisStatus status = GEIS_STATUS_UNKNOWN_ERROR;
+  bool filled_nux_event = false;
+
+  status = geis_dispatch_events(geis_);
+  if (status != GEIS_STATUS_SUCCESS)
+  {
+    LOG_WARNING(logger) << "Failed to dispatch events! Status: " << status;
+  }
+
+  status = geis_next_event(geis_, &event);
+  if (status != GEIS_STATUS_SUCCESS && status != GEIS_STATUS_CONTINUE
+      && status != GEIS_STATUS_EMPTY)
+  {
+    LOG_WARNING(logger) << "Failed to get next event! Status: " << status;
+  }
+
+  if (status == GEIS_STATUS_CONTINUE || status == GEIS_STATUS_SUCCESS)
+  {
+    switch (geis_event_type(event))
+    {
+      case GEIS_EVENT_GESTURE_BEGIN:
+        FillNuxEvent(*nux_event, event, EVENT_GESTURE_BEGIN);
+        filled_nux_event = true;
+        break;
+      case GEIS_EVENT_GESTURE_UPDATE:
+        FillNuxEvent(*nux_event, event, EVENT_GESTURE_UPDATE);
+        if (nux_event->GetGestureClasses() == TAP_GESTURE)
+        {
+          // Geis sends a single Update event for a tap gesture and nothing more,
+          // but it's better to be consistent with the rule that all gestures
+          // must begin and end (with any number of updates in between).
+          // Otherwise code in upper layers will have to add special cases just
+          // for the tap gesture.
+          SplitUpdateIntoBeginAndEnd(*nux_event);
+        }
+        filled_nux_event = true;
+        break;
+      case GEIS_EVENT_GESTURE_END:
+        FillNuxEvent(*nux_event, event, EVENT_GESTURE_END);
+        filled_nux_event = true;
+        break;
+      case GEIS_EVENT_CLASS_AVAILABLE:
+        this->ProcessEventClassAvailable(event);
+        break;
+      case GEIS_EVENT_DEVICE_AVAILABLE:
+        this->ProcessEventDeviceAvailable(event);
+        break;
+      case GEIS_EVENT_DEVICE_UNAVAILABLE:
+        this->ProcessEventDeviceUnavailable(event);
+        break;
+      case GEIS_EVENT_INIT_COMPLETE:
+        this->is_init_complete_ = true;
+        this->init_complete.emit();
+        break;
+      default:
+        break;
+    }
+    geis_event_delete(event);
+  }
+
+  if (!filled_nux_event)
+    nux_event->Reset();
+
+  return filled_nux_event;
+}
+
+void GeisAdapter::ProcessEventDeviceAvailable(GeisEvent event)
+{
+  GeisAttr attr = geis_event_attr_by_name(event, GEIS_EVENT_ATTRIBUTE_DEVICE);
+  if (!attr)
+  {
+    LOG_WARNING(logger) <<
+        "Missing device attr in \"Device Available\" event.";
+    return;
+  }
+
+  GeisDevice geis_device = static_cast<GeisDevice>(geis_attr_value_to_pointer(attr));
+  if (!geis_device)
+  {
+    LOG_WARNING(logger) << "\"Device Available\" event contains a null device";
+    return;
+  }
+
+  Device device;
+
+  attr = geis_device_attr_by_name(geis_device, GEIS_DEVICE_ATTRIBUTE_DIRECT_TOUCH);
+  if (!attr)
+  {
+    LOG_WARNING(logger) << "Missing \"direct touch\" attr in device.";
+    return;
+  }
+  device.direct_touch = geis_attr_value_to_boolean(attr) == GEIS_TRUE;
+
+  device.id = geis_device_id(geis_device);
+  devices_[device.id] = device;
+}
+
+void GeisAdapter::ProcessEventDeviceUnavailable(GeisEvent event)
+{
+  GeisAttr attr = geis_event_attr_by_name(event, GEIS_EVENT_ATTRIBUTE_DEVICE);
+  if (!attr)
+  {
+    LOG_WARNING(logger) <<
+        "Missing device attr in  \"Device Available\" event.";
+    return;
+  }
+
+  GeisDevice geis_device = static_cast<GeisDevice>(geis_attr_value_to_pointer(attr));
+  if (!geis_device)
+  {
+    LOG_WARNING(logger) << "\"Device Available\" event contains a null device";
+    return;
+  }
+
+  devices_.erase(geis_device_id(geis_device));
+}
+
+void GeisAdapter::FillNuxEvent(GestureEvent &nux_event,
+                               GeisEvent event,
+                               EventType nux_event_type)
+{
+  GeisAttr attr = geis_event_attr_by_name(event, GEIS_EVENT_ATTRIBUTE_GROUPSET);
+  GeisGroupSet group_set =
+    static_cast<GeisGroupSet>(geis_attr_value_to_pointer(attr));
+
+  /* I expect only one group. */
+  if (geis_groupset_group_count(group_set) != 1)
+  {
+    LOG_WARNING(logger) << "Received a gesture event with "
+      << geis_groupset_group_count(group_set) << " groups";
+    return;
+  }
+
+  GeisGroup group = geis_groupset_group(group_set, 0);
+
+  /* I expect only one frame. */
+  if (geis_group_frame_count(group) != 1)
+  {
+    LOG_WARNING(logger) << "Received a gesture event with a group containing "
+      << geis_group_frame_count(group) << " frames";
+    return;
+  }
+
+  nux_event.Reset();
+  nux_event.type = nux_event_type;
+  nux_event.geis_ = geis_;
+  nux_event.geis_group_ = group;
+
+  GeisFrame frame = geis_group_frame(group, 0);
+  FillNuxEventGestureAttributes(nux_event, frame);
+
+  attr = geis_event_attr_by_name(event, GEIS_EVENT_ATTRIBUTE_CONSTRUCTION_FINISHED);
+  nux_event.is_construction_finished_ = geis_attr_value_to_boolean(attr) == GEIS_TRUE;
+
+  attr = geis_event_attr_by_name(event, GEIS_EVENT_ATTRIBUTE_TOUCHSET);
+  GeisTouchSet touch_set =
+    static_cast<GeisTouchSet>(geis_attr_value_to_pointer(attr));
+  FillNuxEventTouches(nux_event, touch_set);
+
+  // OBS: A gesture may belong to more than one gesture class
+  if (class_drag_ && geis_frame_is_class(frame, class_drag_))
+  {
+    nux_event.gesture_classes_ |= DRAG_GESTURE;
+  }
+  if (class_pinch_ && geis_frame_is_class(frame, class_pinch_))
+  {
+    nux_event.gesture_classes_ |= PINCH_GESTURE;
+  }
+  if (class_rotate_ && geis_frame_is_class(frame, class_rotate_))
+  {
+    nux_event.gesture_classes_ |= ROTATE_GESTURE;
+  }
+  if (class_tap_ && geis_frame_is_class(frame, class_tap_))
+  {
+    nux_event.gesture_classes_ |= TAP_GESTURE;
+  }
+  if (class_touch_ && geis_frame_is_class(frame, class_touch_))
+  {
+    nux_event.gesture_classes_ |= TOUCH_GESTURE;
+  }
+
+  // Work around a bug in geis. A very quick gesture (e.g. a quick tap)
+  // will end with its is_construction_finished still set to false.
+  // https://bugs.launchpad.net/grail/+bug/1012315
+  if (nux_event_type == EVENT_GESTURE_END)
+    nux_event.is_construction_finished_ = true;
+}
+
+void GeisAdapter::FillNuxEventGestureAttributes(GestureEvent &nux_event, GeisFrame frame)
+{
+  GeisSize attr_count = geis_frame_attr_count(frame);
+  GeisAttr attr = 0;
+
+  nux_event.gesture_id_ = geis_frame_id(frame);
+
+  // Idea: use a hash mapping string attribute names to their correponding
+  // addresses in the GestureEvent class.
+  for (GeisSize i = 0; i < attr_count; ++i)
+  {
+    attr = geis_frame_attr(frame, i);
+    if (g_str_equal(geis_attr_name(attr), GEIS_GESTURE_ATTRIBUTE_DEVICE_ID))
+    {
+      int device_id = geis_attr_value_to_integer(attr);
+      nux_event.is_direct_touch_ = devices_[device_id].direct_touch;
+    }
+    else if (g_str_equal(geis_attr_name(attr), GEIS_GESTURE_ATTRIBUTE_TIMESTAMP))
+      nux_event.timestamp_ = geis_attr_value_to_integer(attr);
+    else if (g_str_equal(geis_attr_name(attr), GEIS_GESTURE_ATTRIBUTE_FOCUS_X))
+      nux_event.focus_.x = geis_attr_value_to_float(attr);
+    else if (g_str_equal(geis_attr_name(attr), GEIS_GESTURE_ATTRIBUTE_FOCUS_Y))
+      nux_event.focus_.y = geis_attr_value_to_float(attr);
+    else if (g_str_equal(geis_attr_name(attr), GEIS_GESTURE_ATTRIBUTE_DELTA_X))
+      nux_event.delta_.x = geis_attr_value_to_float(attr);
+    else if (g_str_equal(geis_attr_name(attr), GEIS_GESTURE_ATTRIBUTE_DELTA_Y))
+      nux_event.delta_.y = geis_attr_value_to_float(attr);
+    else if (g_str_equal(geis_attr_name(attr), GEIS_GESTURE_ATTRIBUTE_ANGLE))
+      nux_event.angle_ = geis_attr_value_to_float(attr);
+    else if (g_str_equal(geis_attr_name(attr), GEIS_GESTURE_ATTRIBUTE_ANGLE_DELTA))
+      nux_event.angle_delta_ = geis_attr_value_to_float(attr);
+    else if (g_str_equal(geis_attr_name(attr), GEIS_GESTURE_ATTRIBUTE_ANGULAR_VELOCITY))
+      nux_event.angular_velocity_ = geis_attr_value_to_float(attr);
+    else if (g_str_equal(geis_attr_name(attr), GEIS_GESTURE_ATTRIBUTE_TAP_TIME))
+      nux_event.tap_duration_ = geis_attr_value_to_integer(attr);
+    else if (g_str_equal(geis_attr_name(attr), GEIS_GESTURE_ATTRIBUTE_VELOCITY_X))
+      nux_event.velocity_.x = geis_attr_value_to_float(attr);
+    else if (g_str_equal(geis_attr_name(attr), GEIS_GESTURE_ATTRIBUTE_VELOCITY_Y))
+      nux_event.velocity_.y = geis_attr_value_to_float(attr);
+    else if (g_str_equal(geis_attr_name(attr), GEIS_GESTURE_ATTRIBUTE_RADIUS))
+      nux_event.radius_ = geis_attr_value_to_float(attr);
+    else if (g_str_equal(geis_attr_name(attr), GEIS_GESTURE_ATTRIBUTE_RADIUS_DELTA))
+      nux_event.radius_delta_ = geis_attr_value_to_float(attr);
+    else if (g_str_equal(geis_attr_name(attr), GEIS_GESTURE_ATTRIBUTE_RADIAL_VELOCITY))
+      nux_event.radial_velocity_ = geis_attr_value_to_float(attr);
+  }
+}
+
+void GeisAdapter::FillNuxEventTouches(GestureEvent &nux_event, GeisTouchSet touch_set)
+{
+  GeisSize count = geis_touchset_touch_count(touch_set);
+
+  TouchPoint point;
+  for (GeisSize i = 0; i < count; ++i)
+  {
+    GeisTouch geis_touch = geis_touchset_touch(touch_set, i);
+
+    point.id = geis_attr_value_to_integer(
+        geis_touch_attr_by_name(geis_touch, GEIS_TOUCH_ATTRIBUTE_ID));
+    point.x = geis_attr_value_to_float(
+        geis_touch_attr_by_name(geis_touch, GEIS_TOUCH_ATTRIBUTE_X));
+    point.y = geis_attr_value_to_float(
+        geis_touch_attr_by_name(geis_touch, GEIS_TOUCH_ATTRIBUTE_Y));
+
+    nux_event.touches_.push_back(point);
+  }
+}
+
+void GeisAdapter::ProcessEventClassAvailable(GeisEvent event)
+{
+  GeisGestureClass gesture_class;
+  GeisAttr attr;
+
+  attr = geis_event_attr_by_name(event, GEIS_EVENT_ATTRIBUTE_CLASS);
+  gesture_class = static_cast<GeisGestureClass>(geis_attr_value_to_pointer(attr));
+
+  if (strcmp(GEIS_GESTURE_DRAG, geis_gesture_class_name(gesture_class)) == 0)
+  {
+    class_drag_ = gesture_class;
+    geis_gesture_class_ref(gesture_class);
+  }
+  else if (strcmp(GEIS_GESTURE_PINCH, geis_gesture_class_name(gesture_class)) == 0)
+  {
+    class_pinch_ = gesture_class;
+    geis_gesture_class_ref(gesture_class);
+  }
+  else if (strcmp(GEIS_GESTURE_ROTATE, geis_gesture_class_name(gesture_class)) == 0)
+  {
+    class_rotate_ = gesture_class;
+    geis_gesture_class_ref(gesture_class);
+  }
+  else if (strcmp(GEIS_GESTURE_TAP, geis_gesture_class_name(gesture_class)) == 0)
+  {
+    class_tap_ = gesture_class;
+    geis_gesture_class_ref(gesture_class);
+  }
+  else if (strcmp(GEIS_GESTURE_TOUCH, geis_gesture_class_name(gesture_class)) == 0)
+  {
+    class_touch_ = gesture_class;
+    geis_gesture_class_ref(gesture_class);
+  }
+}

=== added file 'Nux/GeisAdapter.h'
--- Nux/GeisAdapter.h	1970-01-01 00:00:00 +0000
+++ Nux/GeisAdapter.h	2012-08-01 18:42:21 +0000
@@ -0,0 +1,122 @@
+/*
+ * Copyright 2012 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License, as
+ * published by the  Free Software Foundation; either version 2.1 or 3.0
+ * of the License.
+ *
+ * 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 along with this program. If not, see <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Daniel d'Andrada <[e-mail]>
+ *
+ */
+
+#ifndef GEISADAPTER_H
+#define GEISADAPTER_H
+#include "Features.h"
+#ifdef NUX_GESTURES_SUPPORT
+
+#include <sigc++/sigc++.h>
+#include <geis/geis.h>
+#include <glib.h>
+
+#include <map>
+#include <memory>
+
+#include "NuxGraphics/GestureEvent.h"
+
+namespace nux
+{
+
+/*!
+  This class translates events from geis into native nux::GestureEvents
+ */
+class GeisAdapter : public sigc::trackable
+{
+public:
+  GeisAdapter();
+  ~GeisAdapter();
+
+#if (defined(NUX_OS_LINUX) || defined(NUX_USE_GLIB_LOOP_ON_WINDOWS)) && (!defined(NUX_DISABLE_GLIB_LOOP))
+  void CreateGSource(GMainContext *context);
+#endif
+
+  /*
+    Returns whether initialization is complete.
+    See also: signal init_complete()
+   */
+  bool IsInitComplete() const {return is_init_complete_;}
+
+  /*
+    Initialization has finished. Subscriptions
+    can now be filtered and activated.
+   */
+  sigc::signal<void> init_complete;
+
+  //! Emitted when a new GestureEvent is ready to be processed
+  sigc::signal<void, GestureEvent &> event_ready;
+
+  Geis GetGeisInstance() const {return geis_;}
+
+  void ProcessGeisEvents();
+
+  //! Processes the next pending Geis event, which may yield a GestureEvent
+  /*!
+    Returns true if GestureEvent was filled and false otherwise.
+   */
+  bool ProcessNextEvent(GestureEvent *event);
+
+private:
+
+  class Device {
+    public:
+    int id;
+    bool direct_touch;
+  };
+
+
+  void ProcessEventDeviceAvailable(GeisEvent event);
+  void ProcessEventDeviceUnavailable(GeisEvent event);
+  void ProcessEventClassAvailable(GeisEvent event);
+  void FillNuxEvent(GestureEvent &nux_event,
+                    GeisEvent event,
+                    EventType nux_event_type);
+
+  void FillNuxEventGestureAttributes(GestureEvent &nux_event, GeisFrame frame);
+  void FillNuxEventTouches(GestureEvent &nux_event, GeisTouchSet touch_set);
+
+  void SplitUpdateIntoBeginAndEnd(GestureEvent &nux_event);
+
+  Geis geis_;
+
+  GeisGestureClass class_drag_;
+  GeisGestureClass class_pinch_;
+  GeisGestureClass class_rotate_;
+  GeisGestureClass class_tap_;
+  GeisGestureClass class_touch_;
+
+  bool is_init_complete_;
+
+  /* maps a device id to its corresponding device */
+  std::map<int, Device> devices_;
+
+  /* Sometimes a single GeisEvent can yield two GestureEvents. When that
+     happens, that second GestureEvent will be temporarily held here until
+     it's consumed. */
+  std::unique_ptr<GestureEvent> pending_next_event_;
+
+  friend class GeisAdapterTest;
+};
+
+} // namespace nux
+
+#endif // NUX_GESTURES_SUPPORT
+#endif // GEISADAPTER_H

=== added file 'Nux/Gesture.cpp'
--- Nux/Gesture.cpp	1970-01-01 00:00:00 +0000
+++ Nux/Gesture.cpp	2012-08-01 18:42:21 +0000
@@ -0,0 +1,295 @@
+/*
+ * Copyright (C) 2012 - Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License, as
+ * published by the  Free Software Foundation; either version 2.1 or 3.0
+ * of the License.
+ *
+ * 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 along with this program. If not, see <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Daniel d'Andrada <[e-mail]>
+ */
+
+#include "Gesture.h"
+#include "Nux/InputArea.h"
+
+using namespace nux;
+
+/*****************************************************************************
+ * InputAreaTarget
+ *****************************************************************************/
+
+InputAreaTarget::InputAreaTarget(InputArea *input_area)
+  : input_area_(input_area)
+{
+}
+
+GestureDeliveryRequest InputAreaTarget::GestureEvent(const nux::GestureEvent &event)
+{
+  if (input_area_.IsValid())
+    return input_area_->GestureEvent(event);
+  else
+    return GestureDeliveryRequest::NONE;
+}
+
+bool InputAreaTarget::Equals(const GestureTarget& other) const
+{
+  const InputAreaTarget *input_area_target = dynamic_cast<const InputAreaTarget *>(&other);
+
+  if (input_area_target)
+  {
+    return input_area_ == input_area_target->input_area_;
+  }
+  else
+  {
+    return false;
+  }
+}
+
+/*****************************************************************************
+ * Gesture
+ *****************************************************************************/
+
+Gesture::Gesture(const nux::GestureEvent &event)
+      : event_delivery_enabled_(false),
+        acceptance_status_(AcceptanceStatus::UNDECIDED)
+{
+  queued_events_.reserve(20);
+  queued_events_.push_back(event);
+}
+
+void Gesture::AddTarget(ShPtGestureTarget target)
+{
+  target_list_.push_back(target);
+}
+
+void Gesture::RemoveTarget(ShPtGestureTarget target)
+{
+  auto check_same_target = [&](const ShPtGestureTarget& other_target)
+  {
+    return *other_target == *target;
+  };
+
+  target_list_.remove_if(check_same_target);
+}
+
+void Gesture::EnableEventDelivery()
+{
+  if (event_delivery_enabled_)
+    return;
+
+  event_delivery_enabled_ = true;
+
+  if (queued_events_.size() == 0)
+    return;
+
+  // Deliver all queued events but keep the last one
+  last_event_ = queued_events_[queued_events_.size()-1];
+  for (auto event : queued_events_)
+  {
+    DeliverEvent(event);
+  }
+  queued_events_.clear();
+}
+
+void Gesture::Update(const nux::GestureEvent& event)
+{
+  if (event_delivery_enabled_)
+  {
+    DeliverEvent(event);
+    last_event_ = event;
+  }
+  else
+  {
+    queued_events_.push_back(event);
+  }
+}
+
+void Gesture::DeliverEvent(const GestureEvent &event)
+{
+  auto it = target_list_.begin();
+  while (it != target_list_.end())
+  {
+    GestureDeliveryRequest request = (*it)->GestureEvent(event);
+
+    switch(request)
+    {
+      case GestureDeliveryRequest::EXCLUSIVITY:
+        ExecuteTargetExclusivityRequest(event, it);
+        break;
+
+      default: // NONE
+        ++it;
+    }
+  }
+}
+
+void Gesture::ExecuteTargetExclusivityRequest(const GestureEvent &event,
+    std::list<ShPtGestureTarget>::iterator &it_requestor)
+{
+
+  // Don't send gesture lost events for a gesture begin.
+  // Targets can't lose a gesture they never knew about.
+  if (event.type != EVENT_GESTURE_BEGIN)
+  {
+    GestureEvent event_lost = event;
+    event_lost.type = EVENT_GESTURE_LOST;
+    auto other_it = target_list_.rbegin();
+    while (*other_it != *it_requestor)
+    {
+      (*other_it)->GestureEvent(event_lost);
+      ++other_it;
+    }
+  }
+
+  ++it_requestor;
+  target_list_.erase(it_requestor, target_list_.end());
+  it_requestor = target_list_.end();
+}
+
+nux::GestureEvent &Gesture::GetLatestEvent()
+{
+  if (event_delivery_enabled_)
+  {
+    nuxAssert(queued_events_.size() == 0);
+    return last_event_;
+  }
+  else
+  {
+    nuxAssert(queued_events_.size() > 0);
+    return queued_events_[queued_events_.size()-1];
+  }
+}
+
+const nux::GestureEvent &Gesture::GetLatestEvent() const
+{
+  if (event_delivery_enabled_)
+  {
+    nuxAssert(queued_events_.size() == 0);
+    return last_event_;
+  }
+  else
+  {
+    nuxAssert(queued_events_.size() > 0);
+    return queued_events_[queued_events_.size()-1];
+  }
+}
+
+bool Gesture::IsConstructionFinished() const
+{
+  return GetLatestEvent().IsConstructionFinished();
+}
+
+int Gesture::GetId() const
+{
+  return GetLatestEvent().GetGestureId();
+}
+
+const std::vector<TouchPoint> &Gesture::GetTouches() const
+{
+  return GetLatestEvent().GetTouches();
+}
+
+bool Gesture::HasTouchesInCommon(
+    const std::shared_ptr<Gesture> &other_gesture) const
+{
+  const std::vector<TouchPoint> &my_touches = GetTouches();
+  const std::vector<TouchPoint> &other_touches = other_gesture->GetTouches();
+
+  for (const auto other_touch : other_touches)
+  {
+    for (const auto my_touch : my_touches)
+    {
+      if (other_touch == my_touch)
+        return true;
+    }
+  }
+
+  return false;
+}
+
+void Gesture::Reject()
+{
+  g_assert(acceptance_status_ == AcceptanceStatus::UNDECIDED);
+  GetLatestEvent().Reject();
+  acceptance_status_ = AcceptanceStatus::REJECTED;
+}
+
+void Gesture::Accept()
+{
+  g_assert(acceptance_status_ == AcceptanceStatus::UNDECIDED);
+  GetLatestEvent().Accept();
+  acceptance_status_ = AcceptanceStatus::ACCEPTED;
+}
+
+/*****************************************************************************
+ * GestureSet
+ *****************************************************************************/
+
+void GestureSet::Add(Gesture *gesture)
+{
+  map_id_to_gesture_[gesture->GetId()] = std::shared_ptr<Gesture>(gesture);
+}
+
+void GestureSet::Add(std::shared_ptr<Gesture> &gesture)
+{
+  map_id_to_gesture_[gesture->GetId()] = gesture;
+}
+
+std::shared_ptr<Gesture> GestureSet::FindFromGestureId(int gesture_id)
+{
+  std::map<int, std::shared_ptr<Gesture> >::iterator it
+    = map_id_to_gesture_.find(gesture_id);
+
+  if (it != map_id_to_gesture_.end())
+    return it->second;
+  else
+    return std::shared_ptr<Gesture>();
+}
+
+std::shared_ptr<Gesture> GestureSet::FindFromTarget(ShPtGestureTarget wanted_target)
+{
+  for (auto it : map_id_to_gesture_)
+  {
+    std::shared_ptr<Gesture> &gesture = it.second;
+    const std::list<ShPtGestureTarget> &target_list = gesture->GetTargetList();
+    for (auto target : target_list)
+    {
+      if (*target == *wanted_target)
+        return gesture;
+    }
+  }
+  return nullptr;
+}
+
+std::vector< std::shared_ptr<Gesture> >
+  GestureSet::GetConflictingGestures(std::shared_ptr<Gesture> &gesture)
+{
+  std::vector< std::shared_ptr<Gesture> > conflicting_gestures;
+
+  for (auto it : map_id_to_gesture_)
+  {
+    std::shared_ptr<Gesture> &other_gesture = it.second;
+
+    if (other_gesture == gesture)
+      continue;
+
+    if (other_gesture->HasTouchesInCommon(gesture))
+      conflicting_gestures.push_back(other_gesture);
+  }
+
+  return conflicting_gestures;
+}
+
+void GestureSet::Remove(std::shared_ptr<Gesture> &gesture)
+{
+  map_id_to_gesture_.erase(gesture->GetId());
+}

=== added file 'Nux/Gesture.h'
--- Nux/Gesture.h	1970-01-01 00:00:00 +0000
+++ Nux/Gesture.h	2012-08-01 18:42:21 +0000
@@ -0,0 +1,170 @@
+/*
+ * Copyright (C) 2012 - Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License, as
+ * published by the  Free Software Foundation; either version 2.1 or 3.0
+ * of the License.
+ *
+ * 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 along with this program. If not, see <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Daniel d'Andrada <[e-mail]>
+ */
+
+#ifndef NUX_GESTURE_H
+#define NUX_GESTURE_H
+#include "Features.h"
+#ifdef NUX_GESTURES_SUPPORT
+
+#include <memory>
+
+#include "NuxGraphics/GestureEvent.h"
+
+/*
+  A collection of helper classes used by WindowCompositor for the task of
+  delivering GestureEvents to their correct target InputAreas and in the
+  decision of whether a gesture should be accepted or rejected.
+ */
+namespace nux
+{
+class InputArea;
+
+/*
+  Interface for gesture targets.
+ */
+class GestureTarget
+{
+  public:
+
+    /*!
+      Called whenever there's a new gesture event for this target.
+      \param event GestureEvent to be processed by the target.
+      \return A request about the delivery of events for the related gesture.
+     */
+    virtual GestureDeliveryRequest GestureEvent(const GestureEvent &event) = 0;
+
+    bool operator ==(const GestureTarget& other) const
+    {
+      return Equals(other);
+    }
+
+  private:
+    /*!
+      For some types of target, different instances may wrap the same actual target,
+      in which case reimplementing this method is necessary.
+     */
+    virtual bool Equals(const GestureTarget& other) const
+    {
+      return this == &other;
+    }
+};
+typedef std::shared_ptr<GestureTarget> ShPtGestureTarget;
+
+class InputAreaTarget : public GestureTarget
+{
+  public:
+    InputAreaTarget(InputArea *input_area);
+    virtual GestureDeliveryRequest GestureEvent(const nux::GestureEvent &event);
+
+  private:
+    virtual bool Equals(const GestureTarget& other) const;
+    ObjectWeakPtr<InputArea> input_area_;
+};
+
+//! A class that relates a multitouch gesture to its target entity
+/*!
+  It relates a gesture to its target, which can be either a window or
+  unity.
+
+  It's fed with GestureEvents via Update().
+  It stores those GestureEvents in a queue until EnableEventDelivery() is
+  called, when all queued events are finally acted upon. After
+  that, further events fed via Update() will have an immediate effect over its
+  target instead of being queued.
+ */
+class Gesture
+{
+  public:
+
+    Gesture(const GestureEvent &event);
+
+    void AddTarget(ShPtGestureTarget target);
+    void RemoveTarget(ShPtGestureTarget target);
+    const std::list<ShPtGestureTarget> &GetTargetList() const {return target_list_;}
+
+    void EnableEventDelivery();
+    void Update(const GestureEvent& event);
+    bool IsConstructionFinished() const;
+    bool IsDeliveringEvents() const {return event_delivery_enabled_;}
+    int GetId() const;
+    const std::vector<TouchPoint> &GetTouches() const;
+
+    //! Returns whether the given gesture has any touches in common with this one.
+    bool HasTouchesInCommon(const std::shared_ptr<Gesture> &other_gesture) const;
+
+    //! Rejects the gesture.
+    /*
+      After rejection a gesture is no longer valid
+     */
+    void Reject();
+
+    //! Accepts the gesture
+    void Accept();
+
+    enum class AcceptanceStatus
+    {
+      UNDECIDED,
+      ACCEPTED,
+      REJECTED
+    };
+
+    AcceptanceStatus GetAcceptanceStatus() const {return acceptance_status_;}
+
+  private:
+    const GestureEvent &GetLatestEvent() const;
+    GestureEvent &GetLatestEvent();
+    void DeliverEvent(const GestureEvent &event);
+    void ExecuteTargetExclusivityRequest(const GestureEvent &event,
+        std::list<ShPtGestureTarget>::iterator &it_requestor);
+
+    std::list<ShPtGestureTarget> target_list_;
+
+    // events that are waiting to be delivered
+    std::vector<GestureEvent> queued_events_;
+
+    // last event delivered
+    GestureEvent last_event_;
+
+    bool event_delivery_enabled_;
+    AcceptanceStatus acceptance_status_;
+};
+
+/*
+  Stores information on all curently active gestures.
+ */
+class GestureSet
+{
+  public:
+    void Add(Gesture *gesture);
+    void Add(std::shared_ptr<Gesture> &gesture);
+    std::shared_ptr<Gesture> FindFromGestureId(int gesture_id);
+    std::shared_ptr<Gesture> FindFromTarget(ShPtGestureTarget target);
+    void Remove(std::shared_ptr<Gesture> &gesture);
+
+    std::vector< std::shared_ptr<Gesture> >
+      GetConflictingGestures(std::shared_ptr<Gesture> &gesture);
+
+  private:
+    std::map<int, std::shared_ptr<Gesture> > map_id_to_gesture_;
+};
+
+} // namespace nux
+#endif // NUX_GESTURES_SUPPORT
+#endif // NUX_GESTURE_H

=== added file 'Nux/GestureBroker.cpp'
--- Nux/GestureBroker.cpp	1970-01-01 00:00:00 +0000
+++ Nux/GestureBroker.cpp	2012-08-01 18:42:21 +0000
@@ -0,0 +1,200 @@
+/*
+ * Copyright (C) 2012 - Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License, as
+ * published by the  Free Software Foundation; either version 2.1 or 3.0
+ * of the License.
+ *
+ * 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 along with this program. If not, see <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Daniel d'Andrada <[e-mail]>
+ */
+
+#include "GestureBroker.h"
+#include "Gesture.h"
+
+using namespace nux;
+
+GestureBroker::GestureBroker()
+{
+}
+
+GestureBroker::~GestureBroker()
+{
+}
+
+void GestureBroker::ProcessGestureBegin(nux::GestureEvent &event)
+{
+  std::vector<ShPtGestureTarget> target_list = FindGestureTargets(event);
+
+  bool gesture_bound_to_target = false;
+  for (auto target : target_list)
+  {
+    bool ok = BindNewGestureToTarget(event, target);
+    gesture_bound_to_target |= ok;
+  }
+
+  if (!gesture_bound_to_target)
+    event.Reject();
+}
+
+bool GestureBroker::BindNewGestureToTarget(nux::GestureEvent &event, ShPtGestureTarget target)
+{
+  bool successful;
+  std::shared_ptr<Gesture> existing_gesture =
+    gesture_set_.FindFromTarget(target);
+
+  auto create_gesture_for_target = [&]()
+  {
+    std::shared_ptr<Gesture> gesture =
+      gesture_set_.FindFromGestureId(event.GetGestureId());
+
+    if (!gesture)
+      gesture = std::shared_ptr<Gesture>(new Gesture(event));
+
+    gesture->AddTarget(target);
+    gesture_set_.Add(gesture);
+
+    if (event.IsConstructionFinished())
+    {
+      gesture->Accept();
+      gesture->EnableEventDelivery();
+    }
+  };
+
+  auto remove_target_from_existing_gesture = [&]()
+  {
+    existing_gesture->RemoveTarget(target);
+    if (existing_gesture->GetTargetList().size() == 0)
+    {
+      existing_gesture->Reject();
+      gesture_set_.Remove(existing_gesture);
+    }
+  };
+
+  if (existing_gesture)
+  {
+    // There's a conflict here.
+    // The target for this new gesture already has a gesture.
+
+    if (existing_gesture->IsDeliveringEvents())
+    {
+      // A target can have only one gesture at a time.
+      successful = false;
+    }
+    else
+    {
+      // Since the existing gesture hasn't been delivered to the target yet,
+      // we can choose which will continue.
+      // The rule is that the gesture with the most touches has precedence over
+      // the other.
+      int existing_num_touches = existing_gesture->GetTouches().size();
+      int new_num_touches = event.GetTouches().size();
+      if (new_num_touches < existing_num_touches)
+      {
+        successful = false;
+      }
+      else if (new_num_touches == existing_num_touches)
+      {
+        // It means that there are more fingers on the target area
+        // than the target area can handle
+        // (i.e. three fingers over an area that handles only two-fingers'
+        // gestures)
+        remove_target_from_existing_gesture();
+        successful = false;
+      }
+      else // new_num_touches > existing_num_touches
+      {
+        remove_target_from_existing_gesture();
+        create_gesture_for_target();
+        successful = true;
+      }
+    }
+  }
+  else
+  {
+    create_gesture_for_target();
+    successful = true;
+  }
+
+  return successful;
+}
+
+void GestureBroker::ProcessGestureUpdate(nux::GestureEvent &event)
+{
+  std::shared_ptr<Gesture> gesture = gesture_set_.FindFromGestureId(event.GetGestureId());
+  if (!gesture)
+  {
+    return;
+  }
+
+  if (event.IsConstructionFinished() && !gesture->IsConstructionFinished())
+  {
+    // This is the first update for this gesture signaling that
+    // its construction has finished.
+    gesture->Update(event);
+    ResolveBufferedGestureThatFinishedConstruction(gesture);
+  }
+  else
+  {
+    gesture->Update(event);
+  }
+}
+
+void GestureBroker::ProcessGestureEnd(nux::GestureEvent &event)
+{
+  std::shared_ptr<Gesture> gesture = gesture_set_.FindFromGestureId(event.GetGestureId());
+  if (!gesture)
+    return;
+
+  if (event.IsConstructionFinished() && !gesture->IsConstructionFinished())
+  {
+    // This is the first update for this gesture signaling that
+    // its construction has finished.
+    gesture->Update(event);
+    ResolveBufferedGestureThatFinishedConstruction(gesture);
+  }
+  else
+  {
+    gesture->Update(event);
+  }
+
+  // We no longer have to keep track of it.
+  gesture_set_.Remove(gesture);
+
+  // We cannot leave a gesture behing without making a decision on its acceptance.
+  if (gesture->GetAcceptanceStatus() == Gesture::AcceptanceStatus::UNDECIDED)
+  {
+    // This will likely only happen if a geture is ending with its construction unfinished,
+    // which is an odd situation, but just in case...
+    gesture->Reject();
+  }
+}
+
+void GestureBroker::ResolveBufferedGestureThatFinishedConstruction(
+    std::shared_ptr<Gesture> &gesture)
+{
+  gesture->Accept();
+  gesture->EnableEventDelivery(); // will flush all queued events
+
+  std::vector< std::shared_ptr<Gesture> > conflicting_gestures =
+    gesture_set_.GetConflictingGestures(gesture);
+  if (conflicting_gestures.size() != 0)
+  {
+    // That shouldn't happen. All conflicting gestures should have been
+    // dealt with when they begun.
+    for (auto conflicting_gesture : conflicting_gestures)
+    {
+      conflicting_gesture->Reject();
+      gesture_set_.Remove(conflicting_gesture);
+    }
+  }
+}

=== added file 'Nux/GestureBroker.h'
--- Nux/GestureBroker.h	1970-01-01 00:00:00 +0000
+++ Nux/GestureBroker.h	2012-08-01 18:42:21 +0000
@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2012 - Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License, as
+ * published by the  Free Software Foundation; either version 2.1 or 3.0
+ * of the License.
+ *
+ * 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 along with this program. If not, see <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Daniel d'Andrada <[e-mail]>
+ */
+
+#ifndef NUX_GESTURE_BROKER_H
+#define NUX_GESTURE_BROKER_H
+#include "Features.h"
+#ifdef NUX_GESTURES_SUPPORT
+
+#include <sigc++/sigc++.h>
+
+#include "Gesture.h"
+
+namespace nux
+{
+/*!
+  Receives GestureEvents and delivers them to the appropriate
+  gesture targets.
+ */
+class GestureBroker : public sigc::trackable
+{
+public:
+  GestureBroker();
+  virtual ~GestureBroker();
+
+  void ProcessGestureBegin(nux::GestureEvent &event);
+  void ProcessGestureUpdate(nux::GestureEvent &event);
+  void ProcessGestureEnd(nux::GestureEvent &event);
+
+private:
+
+  bool BindNewGestureToTarget(nux::GestureEvent &event, ShPtGestureTarget target);
+
+  void ResolveBufferedGestureThatFinishedConstruction(
+      std::shared_ptr<Gesture> &gesture);
+
+  /*!
+    Finds the targets of the gesture from the given gesture event.
+   */
+  std::vector<ShPtGestureTarget> virtual FindGestureTargets(const nux::GestureEvent &event) = 0;
+
+  GestureSet gesture_set_;
+};
+
+} // namespace nux
+#endif // NUX_GESTURES_SUPPORT
+#endif // NUX_GESTURE_BROKER_H

=== added file 'Nux/GesturesSubscription.cpp'
--- Nux/GesturesSubscription.cpp	1970-01-01 00:00:00 +0000
+++ Nux/GesturesSubscription.cpp	2012-08-01 18:42:21 +0000
@@ -0,0 +1,379 @@
+/*
+ * Copyright 2012 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License, as
+ * published by the  Free Software Foundation; either version 2.1 or 3.0
+ * of the License.
+ *
+ * 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 along with this program. If not, see <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Daniel d'Andrada <[e-mail]>
+ *
+ */
+
+#include "GesturesSubscription.h"
+#include "Nux.h"
+#include "NuxCore/Logger.h"
+#include "Nux/GeisAdapter.h"
+
+namespace nux
+{
+
+namespace
+{
+  logging::Logger logger("nux.gestures_subscription");
+}
+
+GesturesSubscription::GesturesSubscription()
+  : gesture_classes_(DRAG_GESTURE|PINCH_GESTURE|ROTATE_GESTURE),
+    num_touches_(2),
+    window_id_(GetWindowThread()->GetGraphicsDisplay().GetWindowHandle()),
+    sub_(nullptr),
+    is_active_(false),
+    drag_threshold_(0.0026f),
+    drag_timeout_(0),
+    pinch_threshold_(1.1f),
+    pinch_timeout_(0),
+    rotate_threshold_(2.0f*3.1415926f/50.0f),
+    rotate_timeout_(0),
+    tap_threshold_(0.0026f),
+    tap_timeout_(300)
+{
+}
+
+GesturesSubscription::~GesturesSubscription()
+{
+  if (sub_)
+    geis_subscription_delete(sub_);
+}
+
+void GesturesSubscription::Activate()
+{
+  if (is_active_)
+    return;
+
+  is_active_ = true;
+
+  if (sub_)
+  {
+    GeisStatus status = geis_subscription_activate(sub_);
+    if (status != GEIS_STATUS_SUCCESS)
+    {
+      LOG_ERROR(logger) << "Failed to activate Geis subscription.";
+    }
+    // configuration only works on active subscription (should be fixed in geis)
+    ConfigureGeisSubscription();
+  }
+  else
+  {
+    CreateGeisSubscriptionWhenPossible();
+  }
+}
+
+void GesturesSubscription::Deactivate()
+{
+  if (!is_active_)
+    return;
+
+  is_active_ = false;
+
+  if (sub_)
+  {
+    GeisStatus status = geis_subscription_deactivate(sub_);
+    if (status != GEIS_STATUS_SUCCESS)
+    {
+      LOG_ERROR(logger) << "Failed to deactivate Geis subscription.";
+    }
+  }
+}
+
+void GesturesSubscription::SetGestureClasses(int gesture_classes)
+{
+  SetProperty(gesture_classes_, gesture_classes);
+
+  #define NUX_ALL_GESTURES (DRAG_GESTURE|PINCH_GESTURE|TAP_GESTURE|TOUCH_GESTURE);
+  unwanted_gesture_classes_ = ~gesture_classes & NUX_ALL_GESTURES;
+  #undef NUX_ALL_GESTURES
+}
+
+void GesturesSubscription::SetNumTouches(unsigned int num_touches)
+{
+  SetProperty(num_touches_, num_touches);
+}
+
+void GesturesSubscription::SetWindowId(int window_id)
+{
+  SetProperty(window_id_, window_id);
+}
+
+void GesturesSubscription::SetRecognitionThreshold(GestureClass gesture_class,
+                                                   float threshold)
+{
+  if (threshold < 0.0f)
+    return;
+
+  switch(gesture_class)
+  {
+    case DRAG_GESTURE:
+      SetProperty(drag_threshold_, threshold);
+      break;
+    case PINCH_GESTURE:
+      SetProperty(pinch_threshold_, threshold);
+      break;
+    case TAP_GESTURE:
+      SetProperty(tap_threshold_, threshold);
+      break;
+    case ROTATE_GESTURE:
+      SetProperty(rotate_threshold_, threshold);
+      break;
+    default:
+      break;
+  }
+}
+
+void GesturesSubscription::SetRecognitionTimeout(GestureClass gesture_class,
+                                                 int timeout)
+{
+  if (timeout < 0)
+    return;
+
+  switch(gesture_class)
+  {
+    case DRAG_GESTURE:
+      SetProperty(drag_timeout_, timeout);
+      break;
+    case PINCH_GESTURE:
+      SetProperty(pinch_timeout_, timeout);
+      break;
+    case TAP_GESTURE:
+      SetProperty(tap_timeout_, timeout);
+      break;
+    case ROTATE_GESTURE:
+      SetProperty(rotate_timeout_, timeout);
+      break;
+    default:
+      break;
+  }
+}
+
+std::vector<const char *> GesturesSubscription::CreateGeisGestureClasses()
+{
+  std::vector<const char *> geis_gesture_classes;
+
+  #define ADD_GESTURE(name) \
+    if (gesture_classes_ & name##_GESTURE) \
+      geis_gesture_classes.push_back(GEIS_GESTURE_##name);
+
+  ADD_GESTURE(DRAG)
+  ADD_GESTURE(PINCH)
+  ADD_GESTURE(ROTATE)
+  ADD_GESTURE(TAP)
+  ADD_GESTURE(TOUCH)
+
+  #undef ADD_GESTURE
+
+  return geis_gesture_classes;
+}
+
+GeisStatus GesturesSubscription::AddGestureClassAndNumTouchesTerm(GeisFilter filter)
+{
+  GeisStatus status = GEIS_STATUS_UNKNOWN_ERROR;
+  std::vector<const char *> geis_gesture_classes = CreateGeisGestureClasses();
+
+  switch (geis_gesture_classes.size())
+  {
+    case 1:
+      status = geis_filter_add_term(filter,
+          GEIS_FILTER_CLASS,
+          GEIS_CLASS_ATTRIBUTE_NAME, GEIS_FILTER_OP_EQ, geis_gesture_classes[0],
+          GEIS_GESTURE_ATTRIBUTE_TOUCHES, GEIS_FILTER_OP_EQ, num_touches_,
+          nullptr);
+      break;
+    case 2:
+      status = geis_filter_add_term(filter,
+          GEIS_FILTER_CLASS,
+          GEIS_CLASS_ATTRIBUTE_NAME, GEIS_FILTER_OP_EQ, geis_gesture_classes[0],
+          GEIS_CLASS_ATTRIBUTE_NAME, GEIS_FILTER_OP_EQ, geis_gesture_classes[1],
+          GEIS_GESTURE_ATTRIBUTE_TOUCHES, GEIS_FILTER_OP_EQ, num_touches_,
+          nullptr);
+      break;
+    case 3:
+      status = geis_filter_add_term(filter,
+          GEIS_FILTER_CLASS,
+          GEIS_CLASS_ATTRIBUTE_NAME, GEIS_FILTER_OP_EQ, geis_gesture_classes[0],
+          GEIS_CLASS_ATTRIBUTE_NAME, GEIS_FILTER_OP_EQ, geis_gesture_classes[1],
+          GEIS_CLASS_ATTRIBUTE_NAME, GEIS_FILTER_OP_EQ, geis_gesture_classes[2],
+          GEIS_GESTURE_ATTRIBUTE_TOUCHES, GEIS_FILTER_OP_EQ, num_touches_,
+          nullptr);
+      break;
+    case 4:
+      status = geis_filter_add_term(filter,
+          GEIS_FILTER_CLASS,
+          GEIS_CLASS_ATTRIBUTE_NAME, GEIS_FILTER_OP_EQ, geis_gesture_classes[0],
+          GEIS_CLASS_ATTRIBUTE_NAME, GEIS_FILTER_OP_EQ, geis_gesture_classes[1],
+          GEIS_CLASS_ATTRIBUTE_NAME, GEIS_FILTER_OP_EQ, geis_gesture_classes[2],
+          GEIS_CLASS_ATTRIBUTE_NAME, GEIS_FILTER_OP_EQ, geis_gesture_classes[3],
+          GEIS_GESTURE_ATTRIBUTE_TOUCHES, GEIS_FILTER_OP_EQ, num_touches_,
+          nullptr);
+      break;
+    case 5:
+      status = geis_filter_add_term(filter,
+          GEIS_FILTER_CLASS,
+          GEIS_CLASS_ATTRIBUTE_NAME, GEIS_FILTER_OP_EQ, geis_gesture_classes[0],
+          GEIS_CLASS_ATTRIBUTE_NAME, GEIS_FILTER_OP_EQ, geis_gesture_classes[1],
+          GEIS_CLASS_ATTRIBUTE_NAME, GEIS_FILTER_OP_EQ, geis_gesture_classes[2],
+          GEIS_CLASS_ATTRIBUTE_NAME, GEIS_FILTER_OP_EQ, geis_gesture_classes[4],
+          GEIS_GESTURE_ATTRIBUTE_TOUCHES, GEIS_FILTER_OP_EQ, num_touches_,
+          nullptr);
+      break;
+    default:
+      status = geis_filter_add_term(filter,
+          GEIS_FILTER_CLASS,
+          GEIS_GESTURE_ATTRIBUTE_TOUCHES, GEIS_FILTER_OP_EQ, num_touches_,
+          nullptr);
+      break;
+  }
+
+  return status;
+}
+
+void GesturesSubscription::CreateGeisSubscription()
+{
+  GeisStatus status = GEIS_STATUS_UNKNOWN_ERROR;
+  GeisFilter filter = nullptr;
+  Geis geis = GetWindowThread()->GetGeisAdapter()->GetGeisInstance();
+
+  sub_ = geis_subscription_new(geis, "nux", GEIS_SUBSCRIPTION_NONE);
+  if (!sub_)
+  {
+    LOG_ERROR(logger) << "Failed to create Geis subscription.";
+    goto cleanup;
+  }
+
+  filter = geis_filter_new(geis, "filter");
+  if (!filter)
+  {
+    LOG_ERROR(logger) << "Failed to create Geis filter.";
+    goto cleanup;
+  }
+
+  status = AddGestureClassAndNumTouchesTerm(filter);
+  if (status != GEIS_STATUS_SUCCESS)
+  {
+    LOG_ERROR(logger) << "Failed to add gesture term to Geis filter.";
+    goto cleanup;
+  }
+
+  status = geis_filter_add_term(filter,
+      GEIS_FILTER_REGION,
+      GEIS_REGION_ATTRIBUTE_WINDOWID, GEIS_FILTER_OP_EQ,
+      window_id_,
+      nullptr);
+  if (status != GEIS_STATUS_SUCCESS)
+  {
+    LOG_ERROR(logger) << "Failed to add region term to Geis filter.";
+    goto cleanup;
+  }
+
+  status = geis_subscription_add_filter(sub_, filter);
+  if (status != GEIS_STATUS_SUCCESS)
+  {
+    LOG_ERROR(logger) << "Failed to add filter to subscription.";
+    goto cleanup;
+  }
+  filter = nullptr; // it now belongs to the subscription
+
+  if (is_active_)
+  {
+    status = geis_subscription_activate(sub_);
+    if (status != GEIS_STATUS_SUCCESS)
+    {
+      LOG_ERROR(logger) << "Failed to activate Geis subscription.";
+      goto cleanup;
+    }
+    // configuration only works on active subscription (should be fixed in geis)
+    ConfigureGeisSubscription();
+  }
+
+cleanup:
+  if (status != GEIS_STATUS_SUCCESS)
+  {
+    geis_filter_delete(filter);
+    geis_subscription_delete(sub_);
+    sub_ = nullptr;
+  }
+}
+
+void GesturesSubscription::CreateGeisSubscriptionWhenPossible()
+{
+  GeisAdapter *geis_adapter = GetWindowThread()->GetGeisAdapter();
+
+  if (geis_adapter->IsInitComplete())
+    CreateGeisSubscription();
+  else
+    geis_adapter->init_complete.connect(
+        sigc::mem_fun(this, &GesturesSubscription::CreateGeisSubscription));
+}
+
+void GesturesSubscription::UpdateGeisSubscription()
+{
+  nuxAssert(sub_ != nullptr);
+
+  if (is_active_)
+    geis_subscription_deactivate(sub_);
+
+  geis_subscription_delete(sub_);
+
+  // Recreate the subscription only once it's active again
+  if (is_active_)
+    CreateGeisSubscription();
+}
+
+bool GesturesSubscription::MatchesGesture(const GestureEvent &event) const
+{
+  if (event.GetTouches().size() != num_touches_)
+    return false;
+
+  if ((event.GetGestureClasses() & gesture_classes_) == 0)
+    return false;
+
+  if ((event.GetGestureClasses() & unwanted_gesture_classes_) != 0)
+    return false;
+
+  return true;
+}
+
+void GesturesSubscription::ConfigureGeisSubscription()
+{
+  nuxAssert(sub_);
+  GeisStatus status;
+
+  auto setGeisConfig = [&](const char *name, GeisPointer var)
+  {
+    status = geis_subscription_set_configuration(sub_, name, var);
+    if (status != GEIS_STATUS_SUCCESS)
+    {
+      LOG_ERROR(logger) << "Failed to set Geis subscription configuration "
+        << name;
+    }
+  };
+
+  setGeisConfig(GEIS_CONFIG_DRAG_THRESHOLD, &drag_threshold_);
+  setGeisConfig(GEIS_CONFIG_DRAG_TIMEOUT, &drag_timeout_);
+  setGeisConfig(GEIS_CONFIG_PINCH_THRESHOLD, &pinch_threshold_);
+  setGeisConfig(GEIS_CONFIG_PINCH_TIMEOUT, &pinch_timeout_);
+  setGeisConfig(GEIS_CONFIG_TAP_THRESHOLD, &tap_threshold_);
+  setGeisConfig(GEIS_CONFIG_TAP_TIMEOUT, &tap_timeout_);
+  setGeisConfig(GEIS_CONFIG_ROTATE_THRESHOLD, &rotate_threshold_);
+  setGeisConfig(GEIS_CONFIG_ROTATE_TIMEOUT, &rotate_timeout_);
+}
+
+} // namespace nux

=== added file 'Nux/GesturesSubscription.h'
--- Nux/GesturesSubscription.h	1970-01-01 00:00:00 +0000
+++ Nux/GesturesSubscription.h	2012-08-01 18:42:21 +0000
@@ -0,0 +1,181 @@
+/*
+ * Copyright 2012 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License, as
+ * published by the  Free Software Foundation; either version 2.1 or 3.0
+ * of the License.
+ *
+ * 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 along with this program. If not, see <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Daniel d'Andrada <[e-mail]>
+ *
+ */
+
+#ifndef NUX_GESTURES_SUBSCRIPTION_H
+#define NUX_GESTURES_SUBSCRIPTION_H
+#include "Features.h"
+#ifdef NUX_GESTURES_SUPPORT
+
+#include <geis/geis.h>
+#include <memory>
+
+// For the GestureClass enumeration.
+#include "NuxGraphics/GestureEvent.h"
+
+namespace nux
+{
+  //! Represents a subscription to multitouch gestures
+  /*!
+    Typical usage:
+      GesturesSubscription *subscription = new GesturesSubscription;
+      subscription->SetGestureClass(TAP_GESTURE);
+      subscription->SetNumTouches(2);
+      subscription->Activate();
+   */
+  /*
+    Wraps all the complexity involved in directly manipulating a GeisSubscription
+    and exposes a simpler, C++, API.
+   */
+  class GesturesSubscription
+  {
+    public:
+      //! Creates a new, inactive, gestures subscription
+      GesturesSubscription();
+
+      //! Destroys this gestures subscription.
+      virtual ~GesturesSubscription();
+
+      //! Activates the subscription
+      void Activate();
+
+      //! Deactivates the subscription
+      void Deactivate();
+
+      //! Returns whether the subscription is active
+      /*!
+        Nux only get gesture events that matches active subscriptions.
+
+        Subscriptions are inactive by default.
+       */
+      bool IsActive() const {return is_active_;}
+
+      //! Sets the classes of gestures this subscription is interested on
+      void SetGestureClasses(int gesture_classes);
+
+      //! Returns the gesture class that this subscription is interested on
+      /*!
+        By default it's set to DRAG_GESTURE|PINCH_GESTURE|ROTATE_GESTURE
+       */
+      int GetGestureClasses() const {return gesture_classes_;}
+
+      //! The subscription will be interested in gestures with the given number of touches
+      void SetNumTouches(unsigned int num_touches);
+
+      //! Returns the number of touches that this subscription is interested on
+      /*!
+        By default it is set to two touches.
+       */
+      unsigned int GetNumTouches() const {return num_touches_;}
+
+      //! Specifies the native window from which touch events will be gathered
+      /*!
+        See also GetWindowId()
+       */
+      void SetWindowId(int window_id);
+
+      //! Returns the native window id from which touch events are gathered.
+      /*!
+        By default this is the same native window that Nux uses for rendering.
+        But in cases they differ you should speficy the native window that will
+        provide the touch events with SetWindowId().
+       */
+      int GetWindowId() const {return window_id_;}
+
+      //! Sets the recognition threshold for a given gesture class
+      /*!
+        For the pinch gesture class, the threshold is the current
+        radius divided by the initial radius and should be bigger than one.
+        Its default value is 1.1.
+
+        For the drag gesture class, the threshold is in meters and represents
+        the minimum amount of movement required for a drag to be recognized.
+        Its default value is 0.0026
+
+        For the tap gesture class, the threshold is in meters and represents
+        the maximum amount of movement allowed for a tap to be recognized.
+        Its default value is 0.0026
+
+        For the rotate gesture class, the threshold is in radians and represents
+        the mimimum amout of rotation required for a rotation gesture to be
+        recognized. Its default value is (2*PI)/50.
+
+        It has no effect or meaning for the touch gesture class.
+       */
+      void SetRecognitionThreshold(GestureClass gesture_class, float threshold);
+
+      //! Sets the recognition timeout for a given gesture class
+      /*!
+        The timeout is in milliseconds.
+        Setting 0 (zero) means that the recognition never times out.
+
+        The default timeout for drag, pinch and rotate gesture classes is 0 (zero).
+        Fot taps it's 300.
+
+        It has no effect or meaning for the touch gesture class.
+       */
+      void SetRecognitionTimeout(GestureClass gesture_class, int timeout);
+
+      //! Returns whether the gesture from the given event matches this subscription
+      bool MatchesGesture(const GestureEvent &event) const;
+
+    private:
+      std::vector<const char *> CreateGeisGestureClasses();
+      GeisStatus AddGestureClassAndNumTouchesTerm(GeisFilter filter);
+      void CreateGeisSubscription();
+      void CreateGeisSubscriptionWhenPossible();
+      void UpdateGeisSubscription();
+      void ConfigureGeisSubscription();
+
+      template<typename T>
+      void SetProperty(T& prop, T new_value)
+      {
+        if (prop == new_value)
+          return;
+
+        prop = new_value;
+
+        if (sub_)
+          UpdateGeisSubscription();
+      }
+
+      int gesture_classes_;
+      int unwanted_gesture_classes_;
+      unsigned int num_touches_;
+      int window_id_;
+      GeisSubscription sub_;
+      bool is_active_;
+
+      float drag_threshold_;
+      int drag_timeout_;
+      float pinch_threshold_;
+      int pinch_timeout_;
+      float rotate_threshold_;
+      int rotate_timeout_;
+      float tap_threshold_;
+      int tap_timeout_;
+  };
+
+  typedef std::shared_ptr<GesturesSubscription> ShGesturesSubscription;
+
+} // namespace nux
+
+#endif // NUX_GESTURES_SUPPORT
+#endif // NUX_GESTURES_SUBSCRIPTION_H

=== modified file 'Nux/InputArea.cpp'
--- Nux/InputArea.cpp	2012-02-19 05:41:42 +0000
+++ Nux/InputArea.cpp	2012-08-01 18:42:21 +0000
@@ -27,11 +27,16 @@
 
 #include "NuxCore/Logger.h"
 
+#include "Features.h"
 #include "Nux.h"
 #include "InputArea.h"
 #include "NuxGraphics/GraphicsEngine.h"
 #include "WindowCompositor.h"
 
+#ifdef NUX_GESTURES_SUPPORT
+#include "GesturesSubscription.h"
+#endif
+
 namespace nux
 {
 namespace {
@@ -411,5 +416,76 @@
 
     return true;
   }  
+
+#ifdef NUX_GESTURES_SUPPORT
+  void InputArea::CreateGesturesSubscription(int gesture_classes,
+                                             unsigned int num_touches)
+  {
+    GesturesSubscription *subscription = new GesturesSubscription;
+    subscription->SetGestureClasses(gesture_classes);
+    subscription->SetNumTouches(num_touches);
+    subscription->Activate();
+
+    gestures_subscriptions_.push_back(ShGesturesSubscription(subscription));
+  }
+
+  void InputArea::AddGesturesSubscription(
+      std::shared_ptr<nux::GesturesSubscription> &subscription)
+  {
+    for (auto sub : gestures_subscriptions_)
+    {
+      if (sub.get() == subscription.get())
+        return;
+    }
+
+    gestures_subscriptions_.push_back(subscription);
+  }
+
+  void InputArea::RemoveGesturesSubscription(
+      std::shared_ptr<nux::GesturesSubscription> &subscription)
+  {
+    std::list<std::shared_ptr<nux::GesturesSubscription> >::iterator it;
+    for (it = gestures_subscriptions_.begin();
+        it != gestures_subscriptions_.end(); ++it)
+    {
+      if (it->get() == subscription.get())
+      {
+        gestures_subscriptions_.erase(it);
+        return;
+      }
+      ++it;
+    }
+  }
+
+  const std::list<ShGesturesSubscription>&
+  InputArea::GetGesturesSubscriptions() const
+  {
+    return gestures_subscriptions_;
+  }
+
+  bool InputArea::HasSubscriptionForGesture(const nux::GestureEvent &event) const
+  {
+    for (const auto subscription : gestures_subscriptions_)
+    {
+      if (subscription->MatchesGesture(event))
+        return true;
+    }
+
+    return false;
+  }
+
+  Area* InputArea::GetInputAreaHitByGesture(const nux::GestureEvent &event)
+  {
+    if (!IsVisible())
+      return nullptr;
+
+    if (!HasSubscriptionForGesture(event))
+      return nullptr;
+
+    if (!IsGestureInsideArea(event))
+      return nullptr;
+
+    return this;
+  }
+#endif // NUX_GESTURES_SUPPORT
 }
-

=== modified file 'Nux/InputArea.h'
--- Nux/InputArea.h	2012-02-19 05:41:42 +0000
+++ Nux/InputArea.h	2012-08-01 18:42:21 +0000
@@ -23,6 +23,8 @@
 #ifndef INPUTAREA_H
 #define INPUTAREA_H
 
+#include "Features.h"
+
 #include "Area.h"
 
 #if defined(NUX_OS_WINDOWS)
@@ -32,8 +34,17 @@
 #endif
 #include "NuxGraphics/GraphicsDisplay.h"
 
+#ifdef NUX_GESTURES_SUPPORT
+#include <list>
+#include <memory>
+#include "Nux/GesturesSubscription.h"
+#endif
+
 namespace nux
 {
+#ifdef NUX_GESTURES_SUPPORT
+  class GestureEvent;
+#endif
   class WindowCompositor;
   class InputArea;
 
@@ -194,6 +205,52 @@
 #endif
 
   public:
+
+#ifdef NUX_GESTURES_SUPPORT
+    //! Creates a new gesture subscription for this input area and activates it
+    /*
+      Convenience function.
+      It's the same as doing the following:
+        ShGesturesSubscription sub(new GesturesSubscription);
+        sub->SetGestureClasses(gesture_classes);
+        sub->SetNumTouches(num_touches);
+        sub->Activate();
+        input_area->AddGesturesSubscription(sub);
+     */
+    void CreateGesturesSubscription(int gesture_classes,
+                                    unsigned int num_touches);
+
+    //! Adds a gestures subscription to this input area.
+    /*!
+      A single subscription can be shared among multiple InputAreas.
+     */
+    void AddGesturesSubscription(ShGesturesSubscription &subscription);
+
+    //! Removes a gestures subscription from this input area.
+    void RemoveGesturesSubscription(ShGesturesSubscription &subscription);
+
+    //! Returns all multitouch gestures subscriptions that this area cares about.
+    /*!
+      An input area will receive GestureEvents for multitouch gestures that
+      hit his area and matches any active subscription present in this list.
+     */
+    const std::list<ShGesturesSubscription> &GetGesturesSubscriptions() const;
+
+    //! Returns whether this area has a subscription that matches the gesture event
+    bool HasSubscriptionForGesture(const GestureEvent &event) const;
+
+    //! Returns the InputArea hit by the given gesture
+    /*!
+      If this area or any of its children is hit by the gesture from the given
+      event, that area will be returned. Otherwise, it returns nullptr.
+     */
+    virtual Area* GetInputAreaHitByGesture(const GestureEvent &event);
+
+  private:
+    std::list<ShGesturesSubscription> gestures_subscriptions_;
+#endif // NUX_GESTURES_SUPPORT
+
+  public:
     //! Signal emitted when the Mouse moves over the InputArea surface.
     sigc::signal<void, int, int, int, int, unsigned long, unsigned long> mouse_move;  // send the current position inside the area
     
@@ -310,6 +367,28 @@
     sigc::signal<void, InputArea*> start_keyboard_grab;
     sigc::signal<void, InputArea*> end_keyboard_grab;
 
+#ifdef NUX_GESTURES_SUPPORT
+    //! Called whenever a GestureEvent is received
+    /*!
+      You should reimplement this method to handle gestures. Typically you would
+      add code to make this area react to the gestures received.
+
+      In order to receive events from a given kind of gesture, an area has to
+      have a corresponding gesture subscription. See CreateGesturesSubscription()
+      and AddGesturesSubscription().
+
+      This method is called only with gestures that have already
+      been accepted. Therefore you shouldn't call GestureEvent::Accept()
+      or GestureEvent::Reject() from here as there's no point in doing so.
+
+      Default implementation just returns GestureDeliveryRequest::NONE.
+     */
+    virtual GestureDeliveryRequest GestureEvent(const GestureEvent &event)
+    {
+      return GestureDeliveryRequest::NONE;
+    }
+#endif
+
     protected:
 
       virtual bool AcceptKeyNavFocus();

=== modified file 'Nux/Layout.cpp'
--- Nux/Layout.cpp	2011-11-25 04:59:29 +0000
+++ Nux/Layout.cpp	2012-08-01 18:42:21 +0000
@@ -599,4 +599,24 @@
   {
     return false;
   }
+
+#ifdef NUX_GESTURES_SUPPORT
+  Area* Layout::GetInputAreaHitByGesture(const GestureEvent &event)
+  {
+    if (!IsVisible())
+      return nullptr;
+
+    if (!IsGestureInsideArea(event))
+      return nullptr;
+
+    for (const auto area : _layout_element_list)
+    {
+      Area *area_hit = area->GetInputAreaHitByGesture(event);
+      if (area_hit)
+        return area_hit;
+    }
+
+    return nullptr;
+  }
+#endif
 }

=== modified file 'Nux/Layout.h'
--- Nux/Layout.h	2011-11-24 17:54:41 +0000
+++ Nux/Layout.h	2012-08-01 18:42:21 +0000
@@ -249,6 +249,10 @@
     sigc::signal<void, Layout*, Area*> ViewAdded;
     sigc::signal<void, Layout*, Area*> ViewRemoved;
 
+#ifdef NUX_GESTURES_SUPPORT
+    virtual Area* GetInputAreaHitByGesture(const GestureEvent &event);
+#endif
+
   protected:
     virtual bool AcceptKeyNavFocus();
     

=== modified file 'Nux/MainLoopGLib.cpp'
--- Nux/MainLoopGLib.cpp	2012-07-04 16:36:46 +0000
+++ Nux/MainLoopGLib.cpp	2012-08-01 18:42:21 +0000
@@ -1,3 +1,4 @@
+#include "Features.h"
 #include "Nux.h"
 #include "Layout.h"
 #include "NuxCore/Logger.h"
@@ -61,7 +62,9 @@
     }
     else
     {
-      return_code = dd->window_thread->ExecutionLoop(0);
+      Event event;
+      dd->window_thread->GetGraphicsDisplay().GetSystemEvent(&event);
+      return_code = dd->window_thread->ProcessEvent(event);
     }
 
     if ((return_code == 0) && !dd->window_thread->IsEmbeddedWindow())
@@ -125,7 +128,10 @@
   {
     nux_glib_threads_lock();
     WindowThread *window_thread = NUX_STATIC_CAST(WindowThread *, user_data);
-    unsigned int return_code = window_thread->ExecutionLoop(0);
+
+    Event event;
+    window_thread->GetGraphicsDisplay().GetSystemEvent(&event);
+    unsigned int return_code = window_thread->ProcessEvent(event);
 
     if (return_code == 0 && !window_thread->IsEmbeddedWindow())
     {
@@ -256,6 +262,20 @@
     else
       g_source_attach(source, main_loop_glib_context_);
 
+#ifdef NUX_GESTURES_SUPPORT
+    //TODO: Some people say that it's much faster to share a GSource among many
+    // file descriptors than having a separate GSource for each file descriptor.
+    // See if it would be better to have GeisAdapter sharing the same GSource with
+    // WindowThread/Nux/X
+    if (IsEmbeddedWindow())
+      geis_adapter_->CreateGSource(nullptr);
+    else
+      geis_adapter_->CreateGSource(main_loop_glib_context_);
+
+    geis_adapter_->event_ready.connect(
+        sigc::mem_fun(this, &WindowThread::ProcessGestureEvent));
+#endif
+
     if (_Timelines->size() > 0)
       StartMasterClock();
 

=== modified file 'Nux/Makefile.am'
--- Nux/Makefile.am	2012-05-25 20:36:09 +0000
+++ Nux/Makefile.am	2012-08-01 18:42:21 +0000
@@ -16,13 +16,15 @@
   $(GCC_FLAGS) \
   $(NUX_CFLAGS) \
   $(IBUS_CFLAGS) \
+  $(GEIS_CFLAGS) \
   $(MAINTAINER_CFLAGS)
 
 libnux_@NUX_API_VERSION@_la_LIBADD = \
   $(top_builddir)/NuxCore/libnux-core-@NUX_API_VERSION@.la \
   $(top_builddir)/NuxGraphics/libnux-graphics-@NUX_API_VERSION@.la \
   $(NUX_LIBS) \
-  $(IBUS_LIBS) 
+  $(IBUS_LIBS) \
+  $(GEIS_LIBS)
 
 libnux_@NUX_API_VERSION@_la_LDFLAGS = \
   $(NUX_LT_LDFLAGS)
@@ -112,6 +114,14 @@
   $(srcdir)/WindowCompositor.cpp \
   $(srcdir)/WindowThread.cpp
 
+if HAVE_GEIS
+source_cpp += \
+  $(srcdir)/GeisAdapter.cpp \
+  $(srcdir)/Gesture.cpp \
+  $(srcdir)/GestureBroker.cpp \
+  $(srcdir)/GesturesSubscription.cpp
+endif
+
 source_h = \
   $(builddir)/ABI.h \
   $(srcdir)/AbstractButton.h \
@@ -139,6 +149,7 @@
   $(srcdir)/Dialog.h \
   $(srcdir)/DoubleValidator.h \
   $(srcdir)/EditTextBox.h \
+  $(builddir)/Features.h \
   $(srcdir)/FileSelector.h \
   $(srcdir)/FloatingWindow.h \
   $(srcdir)/GridHLayout.h \
@@ -199,6 +210,14 @@
   $(srcdir)/WindowCompositor.h \
   $(srcdir)/WindowThread.h
 
+if HAVE_GEIS
+source_h += \
+  $(srcdir)/GeisAdapter.h \
+  $(srcdir)/Gesture.h \
+  $(srcdir)/GestureBroker.h \
+  $(srcdir)/GesturesSubscription.h
+endif
+
 nuxprogramframework_cpp = \
   $(srcdir)/ProgramFramework/ProgramTemplate.cpp \
   $(srcdir)/ProgramFramework/TestView.cpp \

=== modified file 'Nux/View.cpp'
--- Nux/View.cpp	2012-06-18 12:03:53 +0000
+++ Nux/View.cpp	2012-08-01 18:42:21 +0000
@@ -484,4 +484,27 @@
   {
     return true;
   }
+
+#ifdef NUX_GESTURES_SUPPORT
+  Area* View::GetInputAreaHitByGesture(const nux::GestureEvent &event)
+  {
+    if (!IsVisible())
+      return nullptr;
+
+    if (!IsGestureInsideArea(event))
+      return nullptr;
+
+    if (view_layout_)
+    {
+      Area *area = view_layout_->GetInputAreaHitByGesture(event);
+      if (area)
+        return area;
+    }
+
+    if (HasSubscriptionForGesture(event))
+      return this;
+    else
+      return nullptr;
+  }
+#endif
 }

=== modified file 'Nux/View.h'
--- Nux/View.h	2012-02-09 05:57:20 +0000
+++ Nux/View.h	2012-08-01 18:42:21 +0000
@@ -23,6 +23,7 @@
 #ifndef ABSTRACTOBJECTBASE_H
 #define ABSTRACTOBJECTBASE_H
 
+#include "Features.h"
 #include "Nux.h"
 #include "NuxCore/Property.h"
 
@@ -31,6 +32,9 @@
 namespace nux
 {
   class Layout;
+#ifdef NUX_GESTURES_SUPPORT
+  class GestureEvent;
+#endif
 
   class View: public InputArea
   {
@@ -147,6 +151,9 @@
 
     void IsHitDetectionSkipingChildren(bool skip_children);
 
+#ifdef NUX_GESTURES_SUPPORT
+    virtual Area* GetInputAreaHitByGesture(const nux::GestureEvent &event);
+#endif
 
   protected:
 

=== modified file 'Nux/WindowCompositor.cpp'
--- Nux/WindowCompositor.cpp	2012-07-17 22:22:45 +0000
+++ Nux/WindowCompositor.cpp	2012-08-01 18:42:21 +0000
@@ -91,6 +91,10 @@
     m_MenuRemoved = false;
     m_ModalWindow = NULL;
     m_Background = new ColorLayer(Color(0xFF4D4D4D));
+
+#ifdef NUX_GESTURES_SUPPORT
+    gesture_broker_.reset(new DefaultGestureBroker(this));
+#endif
   }
 
   void WindowCompositor::BeforeDestructor()
@@ -1086,6 +1090,20 @@
       {
         DndEventCycle(event);
       }
+#ifdef NUX_GESTURES_SUPPORT
+      else if (event.type == EVENT_GESTURE_BEGIN)
+      {
+        gesture_broker_->ProcessGestureBegin(static_cast<GestureEvent&>(event));
+      }
+      else if (event.type == EVENT_GESTURE_UPDATE)
+      {
+        gesture_broker_->ProcessGestureUpdate(static_cast<GestureEvent&>(event));
+      }
+      else if (event.type == EVENT_GESTURE_END)
+      {
+        gesture_broker_->ProcessGestureEnd(static_cast<GestureEvent&>(event));
+      }
+#endif
     }
     inside_event_cycle_ = false;
   }
@@ -2412,5 +2430,56 @@
 
     return ok;
   }
+
+#ifdef NUX_GESTURES_SUPPORT
+  void WindowCompositor::SetGestureBroker(std::unique_ptr<GestureBroker> gesture_broker)
+  {
+    gesture_broker_ = std::move(gesture_broker);
+  }
+
+  InputArea *WindowCompositor::LocateGestureTarget(const GestureEvent &event)
+  {
+    InputArea *input_area = nullptr;
+
+    for (auto window : _view_window_list)
+    {
+      if (!window.IsValid())
+        continue;
+
+      input_area = static_cast<InputArea*>(window->GetInputAreaHitByGesture(event));
+      if (input_area)
+        break;
+    }
+
+    // If a target InputArea wasn't found in any of the BaseWindows, then check
+    // the InputAreas in the layout of the main window.
+    if (!input_area)
+    {
+      Layout* main_window_layout = window_thread_->GetLayout();
+      if (main_window_layout)
+        input_area = static_cast<InputArea*>(
+            main_window_layout->GetInputAreaHitByGesture(event));
+    }
+
+    return input_area;
+  }
+
+  DefaultGestureBroker::DefaultGestureBroker(WindowCompositor *window_compositor)
+    : window_compositor_(window_compositor)
+  {
+  }
+
+  std::vector<ShPtGestureTarget>
+  DefaultGestureBroker::FindGestureTargets(const nux::GestureEvent &event)
+  {
+    std::vector<ShPtGestureTarget> targets;
+
+    InputArea *target_area = window_compositor_->LocateGestureTarget(event);
+    if (target_area)
+      targets.push_back(ShPtGestureTarget(new InputAreaTarget(target_area)));
+
+    return targets;
+  }
+#endif
 }
 

=== modified file 'Nux/WindowCompositor.h'
--- Nux/WindowCompositor.h	2012-06-11 14:27:57 +0000
+++ Nux/WindowCompositor.h	2012-08-01 18:42:21 +0000
@@ -23,6 +23,7 @@
 #ifndef WINDOWCOMPOSITOR_H
 #define WINDOWCOMPOSITOR_H
 
+#include "Features.h"
 #include "BaseWindow.h"
 
 #include <sigc++/trackable.h>
@@ -30,6 +31,12 @@
 
 #include <NuxCore/ObjectPtr.h>
 
+#ifdef NUX_GESTURES_SUPPORT
+#include <unordered_map>
+#include "Gesture.h"
+#include "GestureBroker.h"
+#endif
+
 namespace nux
 {
   class MenuPage;
@@ -407,6 +414,12 @@
     */
     RenderTargetTextures& GetWindowBuffer(BaseWindow* window);
 
+#ifdef NUX_GESTURES_SUPPORT
+    InputArea *LocateGestureTarget(const GestureEvent &event);
+
+    void SetGestureBroker(std::unique_ptr<GestureBroker> gesture_broker);
+#endif
+
   private:
     //! Render the interface.
     void Draw(bool SizeConfigurationEvent, bool force_draw);
@@ -642,6 +655,10 @@
   private:
     WindowThread* window_thread_; //!< The WindowThread to which this object belongs.
 
+#ifdef NUX_GESTURES_SUPPORT
+    std::unique_ptr<GestureBroker> gesture_broker_;
+#endif
+
     //! Perform some action before destruction.
     /*!
         Perform some action before destruction. This function should only be 
@@ -667,6 +684,18 @@
     friend class View;
   };
 
+#ifdef NUX_GESTURES_SUPPORT
+  class DefaultGestureBroker : public GestureBroker
+  {
+    public:
+      DefaultGestureBroker(WindowCompositor *window_compositor);
+    private:
+      std::vector<ShPtGestureTarget>
+      virtual FindGestureTargets(const nux::GestureEvent &event);
+
+      WindowCompositor *window_compositor_;
+  };
+#endif
 }
 #endif // WINDOWCOMPOSITOR_H
 

=== modified file 'Nux/WindowThread.cpp'
--- Nux/WindowThread.cpp	2012-07-04 16:36:46 +0000
+++ Nux/WindowThread.cpp	2012-08-01 18:42:21 +0000
@@ -19,7 +19,7 @@
  *
  */
 
-
+#include "Features.h"
 #include "Nux.h"
 #include "Layout.h"
 #include "NuxCore/Logger.h"
@@ -61,6 +61,9 @@
     , embedded_window_(false)
     , window_size_configuration_event_(false)
     , force_rendering_(false)
+#ifdef NUX_GESTURES_SUPPORT
+    , geis_adapter_(new GeisAdapter)
+#endif
   {
     // Thread specific objects
     graphics_display_       = NULL;
@@ -493,13 +496,51 @@
 
   extern EventToNameStruct EventToName[];
 
-#if (defined(NUX_OS_LINUX) || defined(NUX_USE_GLIB_LOOP_ON_WINDOWS)) && (!defined(NUX_DISABLE_GLIB_LOOP))
-  unsigned int WindowThread::ExecutionLoop(unsigned int timer_id)
-#else
+#if (!defined(NUX_OS_LINUX) && !defined(NUX_USE_GLIB_LOOP_ON_WINDOWS)) || defined(NUX_DISABLE_GLIB_LOOP)
+#ifdef NUX_GESTURES_SUPPORT
+  Event *WindowThread::FetchNextEvent()
+  {
+    Event *event;
+
+    if (check_geis_first_)
+    {
+      if (geis_adapter_->ProcessNextEvent(&gesture_event_))
+      {
+        event = &gesture_event_;
+      }
+      else
+      {
+        graphics_display_->GetSystemEvent(&input_event_);
+        event = &input_event;
+      }
+    }
+    else
+    {
+      if (graphics_display_->GetSystemEvent(&input_event_))
+      {
+        event = &input_event_;
+      }
+      else
+      {
+        geis_adapter_->ProcessNextEvent(&gesture_event_);
+        event = &gesture_event_;
+      }
+    }
+
+    // If we are running in a loop and both event buffers (X and GEIS) happens
+    // to have pending events, let's take one from each alternately so that no
+    // buffer overflows.
+    check_geis_first_ = !check_geis_first_;
+
+    return event;
+  }
+#endif // NUX_GESTURES_SUPPORT
+
   unsigned int WindowThread::ExecutionLoop()
-#endif
   {
+#ifndef NUX_GESTURES_SUPPORT
     Event event;
+#endif
 
     if (!IsEmbeddedWindow() && graphics_display_->IsPauseThreadGraphicsRendering())
     {
@@ -507,190 +548,218 @@
       return 0;
     }
 
-#if (!defined(NUX_OS_LINUX) && !defined(NUX_USE_GLIB_LOOP_ON_WINDOWS)) || defined(NUX_DISABLE_GLIB_LOOP)
     while (true)
-#endif
     {
-      _inside_main_loop = true;
-
-      if (first_pass_)
-      {
-        // Reset the timers that were called before the mainloop got initialized.
-        GetTimer().StartEarlyTimerObjects();
-      }
-
-      memset(&event, 0, sizeof(Event));
+#ifdef NUX_GESTURES_SUPPORT
+      int result = DoProcessEvent(*FetchNextEvent());
+#else
       graphics_display_->GetSystemEvent(&event);
-
-      if ((event.type == NUX_DND_ENTER_WINDOW) ||
+      int result = DoProcessEvent(event);
+#endif
+      if (result != 1)
+        return result;
+    }
+
+    return 1;
+  }
+#endif // GLIB loop or not
+
+  unsigned int WindowThread::ProcessEvent(Event &event)
+  {
+    if (!IsEmbeddedWindow() && graphics_display_->IsPauseThreadGraphicsRendering())
+    {
+      // Do not sleep. Just return and let the GraphicsDisplay::SwapBuffer do the sleep if necessary.
+      return 0;
+    }
+
+    return DoProcessEvent(event);
+  }
+
+  unsigned int WindowThread::DoProcessEvent(Event &event)
+  {
+    _inside_main_loop = true;
+
+    if (first_pass_)
+    {
+      // Reset the timers that were called before the mainloop got initialized.
+      GetTimer().StartEarlyTimerObjects();
+    }
+
+    if ((event.type == NUX_DND_ENTER_WINDOW) ||
         (event.type == NUX_DND_LEAVE_WINDOW))
-      {
-        GetWindowCompositor().ResetDnDArea();
-      }
-
-      // Call event inspectors.
-      CallEventInspectors(&event);
-
-      if ((event.type == NUX_TERMINATE_APP) || (this->GetThreadState() == THREADSTOP))
-      {
-          return 0;
-      }
-      
-      if (event.type == NUX_SIZE_CONFIGURATION)
-      {
-        window_size_configuration_event_ = true;
-        Rect r = graphics_display_->GetWindowGeometry();
-        window_configuration.emit(r.x, r.y, r.width, r.height);
-      }
-
-      int w, h;
-      // Call gGfx_OpenGL.getWindowSize after the gGfx_OpenGL.get_event.
-      // Otherwise, w and h may not be correct for the current frame if a resizing happened.
-      graphics_display_->GetWindowSize(w, h);
-
-      if ((event.type == NUX_MOUSE_PRESSED) ||
+    {
+      GetWindowCompositor().ResetDnDArea();
+    }
+
+    // Call event inspectors.
+    bool event_discarded = CallEventInspectors(&event);
+    if (event_discarded)
+    {
+      return 1;
+    }
+
+    if ((event.type == NUX_TERMINATE_APP) || (this->GetThreadState() == THREADSTOP))
+    {
+      return 0;
+    }
+
+    if (event.type == NUX_SIZE_CONFIGURATION)
+    {
+      window_size_configuration_event_ = true;
+      Rect r = graphics_display_->GetWindowGeometry();
+      window_configuration.emit(r.x, r.y, r.width, r.height);
+    }
+
+    int w, h;
+    // Call gGfx_OpenGL.getWindowSize after the gGfx_OpenGL.get_event.
+    // Otherwise, w and h may not be correct for the current frame if a resizing happened.
+    graphics_display_->GetWindowSize(w, h);
+
+    if ((event.type == NUX_MOUSE_PRESSED) ||
+        (event.type == NUX_MOUSE_RELEASED) ||
+        (event.type == NUX_MOUSE_DOUBLECLICK) ||
+        (event.type == NUX_MOUSE_MOVE) ||
+        (event.type == NUX_SIZE_CONFIGURATION) ||
+        (event.type == NUX_KEYDOWN) ||
+        (event.type == NUX_KEYUP) ||
+        (event.type == NUX_NC_WINDOW_CONFIGURATION) ||
+        (event.type == NUX_WINDOW_ENTER_FOCUS) ||
+        (event.type == NUX_WINDOW_EXIT_FOCUS) ||
+        (event.type == NUX_WINDOW_MOUSELEAVE) ||
+        (event.type == NUX_DND_MOVE) ||
+        (event.type == NUX_DND_DROP) ||
+        (event.type == NUX_DND_ENTER) ||
+        (event.type == NUX_DND_LEAVE) ||
+        (event.type == NUX_MOUSE_WHEEL) ||
+        event.type == EVENT_GESTURE_BEGIN ||
+        event.type == EVENT_GESTURE_UPDATE ||
+        event.type == EVENT_GESTURE_END)
+    {
+      //DISPATCH EVENT HERE
+      //event.Application = Application;
+      window_compositor_->ProcessEvent(event);
+    }
+
+    if (event.type == NUX_SIZE_CONFIGURATION)
+    {
+      if (!graphics_display_->isWindowMinimized())
+      {
+        graphics_display_->SetViewPort(0, 0, event.width, event.height);
+        ReconfigureLayout();
+        window_compositor_->FormatRenderTargets(event.width, event.height);
+      }
+      window_compositor_->FloatingAreaConfigureNotify(event.width, event.height);
+      window_size_configuration_event_ = true;
+    }
+
+    // Some action may have caused layouts and areas to request a recompute. 
+    // Process them here before the Draw section.
+    if (!graphics_display_->isWindowMinimized() && !IsEmbeddedWindow())
+    {
+      if (queue_main_layout_)
+      {
+        ReconfigureLayout();
+      }
+      else 
+      {
+        // Compute the layouts that have been queued.
+        ComputeQueuedLayout();
+      }
+    }
+
+    _inside_main_loop = false;
+
+    if (!graphics_display_->IsPauseThreadGraphicsRendering() || IsEmbeddedWindow())
+    {
+      bool SwapGLBuffer = false;
+
+      // Warn the host window manager to initiate a draw cycle.
+      bool request_draw_cycle_to_host_wm = false;
+
+      if (first_pass_)
+      {
+        if (IsEmbeddedWindow())
+        {
+          request_draw_cycle_to_host_wm = true;
+          force_rendering_ = true;
+        }
+        else
+        {
+          window_compositor_->Draw(window_size_configuration_event_, true);
+        }
+        first_pass_ = false;
+      }
+      else
+      {
+        bool b = (event.type == NUX_MOUSE_PRESSED) ||
           (event.type == NUX_MOUSE_RELEASED) ||
           (event.type == NUX_MOUSE_DOUBLECLICK) ||
-          (event.type == NUX_MOUSE_MOVE) ||
+          //(event.type == NUX_MOUSE_MOVE) ||
           (event.type == NUX_SIZE_CONFIGURATION) ||
           (event.type == NUX_KEYDOWN) ||
           (event.type == NUX_KEYUP) ||
           (event.type == NUX_NC_WINDOW_CONFIGURATION) ||
           (event.type == NUX_WINDOW_ENTER_FOCUS) ||
           (event.type == NUX_WINDOW_EXIT_FOCUS) ||
-          (event.type == NUX_WINDOW_MOUSELEAVE) ||
-          (event.type == NUX_DND_MOVE) ||
-          (event.type == NUX_DND_DROP) ||
-          (event.type == NUX_DND_ENTER) ||
-          (event.type == NUX_DND_LEAVE) ||
-          (event.type == NUX_MOUSE_WHEEL))
-      {
-          //DISPATCH EVENT HERE
-          //event.Application = Application;
-          window_compositor_->ProcessEvent(event);
-      }
-
-      if (event.type == NUX_SIZE_CONFIGURATION)
-      {
-          if (!graphics_display_->isWindowMinimized())
-          {
-              graphics_display_->SetViewPort(0, 0, event.width, event.height);
-              ReconfigureLayout();
-              window_compositor_->FormatRenderTargets(event.width, event.height);
-          }
-          window_compositor_->FloatingAreaConfigureNotify(event.width, event.height);
-          window_size_configuration_event_ = true;
-      }
-
-      // Some action may have caused layouts and areas to request a recompute. 
-      // Process them here before the Draw section.
-      if (!graphics_display_->isWindowMinimized() && !IsEmbeddedWindow())
-      {
-        if (queue_main_layout_)
-        {
-          ReconfigureLayout();
-        }
-        else 
-        {
-          // Compute the layouts that have been queued.
-          ComputeQueuedLayout();
-        }
-      }
-      
-      _inside_main_loop = false;
-
-      if (!graphics_display_->IsPauseThreadGraphicsRendering() || IsEmbeddedWindow())
-      {
-        bool SwapGLBuffer = false;
-        
-        // Warn the host window manager to initiate a draw cycle.
-        bool request_draw_cycle_to_host_wm = false;
-
-        if (first_pass_)
-        {
-          if (IsEmbeddedWindow())
-          {
-            request_draw_cycle_to_host_wm = true;
-            force_rendering_ = true;
-          }
-          else
-          {
-            window_compositor_->Draw(window_size_configuration_event_, true);
-          }
-          first_pass_ = false;
-        }
-        else
-        {
-          bool b = (event.type == NUX_MOUSE_PRESSED) ||
-                   (event.type == NUX_MOUSE_RELEASED) ||
-                   (event.type == NUX_MOUSE_DOUBLECLICK) ||
-                   //(event.type == NUX_MOUSE_MOVE) ||
-                   (event.type == NUX_SIZE_CONFIGURATION) ||
-                   (event.type == NUX_KEYDOWN) ||
-                   (event.type == NUX_KEYUP) ||
-                   (event.type == NUX_NC_WINDOW_CONFIGURATION) ||
-                   (event.type == NUX_WINDOW_ENTER_FOCUS) ||
-                   (event.type == NUX_WINDOW_EXIT_FOCUS) ||
-                   (event.type == NUX_WINDOW_DIRTY);
-
-          if (b && window_compositor_->IsTooltipActive())
-          {
-            // Cancel the tooltip since an event that should cause the tooltip to disappear has occurred.
-            window_compositor_->CancelTooltip();
-            b |= true;
-          }
-
-          if (!window_compositor_->ValidateMouseInsideTooltipArea(event.x, event.y) && window_compositor_->IsTooltipActive())
-          {
-            // Cancel the tooltip since an event that should cause the tooltip to disappear has occurred.
-            window_compositor_->CancelTooltip();
-            b |= true;
-          }
-
-          if (b || IsRedrawNeeded())
-          {
-            if (IsEmbeddedWindow())
-            {
-              request_draw_cycle_to_host_wm = true;
-            }
-            else
-            {
-              window_compositor_->Draw(window_size_configuration_event_, false);
-            }
-            SwapGLBuffer = true;
-          }
-          else if (window_compositor_->GetWidgetDrawingOverlay() != 0)
-          {
-            if (IsEmbeddedWindow())
-            {
-              request_draw_cycle_to_host_wm = true;
-            }
-            else
-            {
-              window_compositor_->Draw(window_size_configuration_event_, false);
-            }
-            SwapGLBuffer = false;
-          }
-
-        }
-
-        if (!IsEmbeddedWindow())
-        {
-          if (SwapGLBuffer)
-          {
-            // Something was rendered! Swap the rendering buffer!
-            graphics_display_->SwapBuffer(true);
-          }
-
-          ClearRedrawFlag();
-          GetWindowThread()->GetGraphicsEngine().ResetStats();
-        }
-        else if (IsEmbeddedWindow() && (_draw_requested_to_host_wm == false) && request_draw_cycle_to_host_wm)
-        {
-          RequestRedraw();
-        }
-        window_size_configuration_event_ = false;
-      }
+          (event.type == NUX_WINDOW_DIRTY);
+
+        if (b && window_compositor_->IsTooltipActive())
+        {
+          // Cancel the tooltip since an event that should cause the tooltip to disappear has occurred.
+          window_compositor_->CancelTooltip();
+          b |= true;
+        }
+
+        if (!window_compositor_->ValidateMouseInsideTooltipArea(event.x, event.y) && window_compositor_->IsTooltipActive())
+        {
+          // Cancel the tooltip since an event that should cause the tooltip to disappear has occurred.
+          window_compositor_->CancelTooltip();
+          b |= true;
+        }
+
+        if (b || IsRedrawNeeded())
+        {
+          if (IsEmbeddedWindow())
+          {
+            request_draw_cycle_to_host_wm = true;
+          }
+          else
+          {
+            window_compositor_->Draw(window_size_configuration_event_, false);
+          }
+          SwapGLBuffer = true;
+        }
+        else if (window_compositor_->GetWidgetDrawingOverlay() != 0)
+        {
+          if (IsEmbeddedWindow())
+          {
+            request_draw_cycle_to_host_wm = true;
+          }
+          else
+          {
+            window_compositor_->Draw(window_size_configuration_event_, false);
+          }
+          SwapGLBuffer = false;
+        }
+
+      }
+
+      if (!IsEmbeddedWindow())
+      {
+        if (SwapGLBuffer)
+        {
+          // Something was rendered! Swap the rendering buffer!
+          graphics_display_->SwapBuffer(true);
+        }
+
+        ClearRedrawFlag();
+        GetWindowThread()->GetGraphicsEngine().ResetStats();
+      }
+      else if (IsEmbeddedWindow() && (_draw_requested_to_host_wm == false) && request_draw_cycle_to_host_wm)
+      {
+        RequestRedraw();
+      }
+      window_size_configuration_event_ = false;
     }
 
     return 1;

=== modified file 'Nux/WindowThread.h'
--- Nux/WindowThread.h	2012-06-11 14:27:57 +0000
+++ Nux/WindowThread.h	2012-08-01 18:42:21 +0000
@@ -24,6 +24,11 @@
 #define WINDOWTHREAD_H
 
 #include "TimerProc.h"
+#include "Features.h"
+
+#ifdef NUX_GESTURES_SUPPORT
+#include "GeisAdapter.h"
+#endif
 
 namespace nux
 {
@@ -313,6 +318,15 @@
 
     std::vector<Geometry> GetDrawList();
 
+#ifdef NUX_GESTURES_SUPPORT
+    /*!
+      Simple wrapper for ProcessEvent for connection with GeisAdapter::event_ready
+    */
+    void ProcessGestureEvent(GestureEvent &event) { ProcessEvent(event); }
+
+    GeisAdapter *GetGeisAdapter() const {return geis_adapter_.get();}
+#endif
+
   protected:
 
     /*!
@@ -421,33 +435,21 @@
     */
     void DisableMouseKeyboardInput();
 
-#if (defined(NUX_OS_LINUX) || defined(NUX_USE_GLIB_LOOP_ON_WINDOWS)) && (!defined(NUX_DISABLE_GLIB_LOOP))
-
-    /*!
-        Entire frame of goes through this function. It does the following:
-          * get the input events from the mouse, keyboard, touchpad
-          * processes the input events
-          * resizes views
-          * draw the frame
-        This function is called when there is an input event or when a timer has expired.
-
-        @param timer_id The id of the timer that has has expired.
-    */
-    unsigned int ExecutionLoop(unsigned int timer_id);
-#else
-    /*!
-        Entire frame of goes through this function. It does the following:
-          * get the input events from the mouse, keyboard, touchpad
-          * processes the input events
-          * resizes views
-          * draw the frame
-        This function is called when there is an input event or when a timer has expired.
-
-        @param timer_id The id of the timer that has has expired.
-    */
+#if (!defined(NUX_OS_LINUX) && !defined(NUX_USE_GLIB_LOOP_ON_WINDOWS)) || defined(NUX_DISABLE_GLIB_LOOP)
+    //! Calls ProcessEvent in a loop
     unsigned int ExecutionLoop();
 #endif
 
+    /*!
+        It does the following:
+          * processes the input events
+          * resizes views
+          * draw the frame
+        This function is called when there is an input event, a gesture event or
+        when a timer has expired.
+    */
+    unsigned int ProcessEvent(Event &event);
+
     virtual ThreadState StartChildThread(AbstractThread *thread, bool Modal);
     virtual void AddChildThread(AbstractThread *);
     virtual void RemoveChildThread(AbstractThread *);
@@ -461,6 +463,12 @@
     WindowThread *modal_window_thread_;
 
   private:
+    /*!
+      Internally called by ProcessEvent end ExecutionLopp after early return
+      check.
+     */
+    unsigned int DoProcessEvent(Event &event);
+
     //! Execute the main loop of this thread.
     /*!
         Execute the main loop of this thread.
@@ -608,6 +616,14 @@
     bool AddChildWindowGlibLoop(WindowThread* wnd_thread);
 
     unsigned int AddGLibTimeout(unsigned int duration);
+#else // no GLIB loop
+    Event input_event_;
+    GestureEvent gesture_event_;
+    Event *FetchNextEvent();
+#endif
+
+#ifdef NUX_GESTURES_SUPPORT
+    std::unique_ptr<GeisAdapter> geis_adapter_;
 #endif
 
     /*!

=== modified file 'NuxCore/Rect.cpp'
--- NuxCore/Rect.cpp	2011-09-28 19:18:29 +0000
+++ NuxCore/Rect.cpp	2012-08-01 18:42:21 +0000
@@ -120,6 +120,12 @@
              (y <= p.y) && (y + height > p.y) );
   }
 
+  bool Rect::IsInside(const Point2D<float> &p) const
+  {
+    return ( (x <= (int)p.x) && (x + width > (int)p.x) &&
+             (y <= (int)p.y) && (y + height > (int)p.y) );
+  }
+
   bool Rect::IsPointInside (int x_, int y_) const
   {
     return ( (x <= x_) && (x + width > x_) &&

=== modified file 'NuxCore/Rect.h'
--- NuxCore/Rect.h	2011-09-09 21:47:54 +0000
+++ NuxCore/Rect.h	2012-08-01 18:42:21 +0000
@@ -48,6 +48,7 @@
     bool IsNull() const;
 
     bool IsInside(const Point &p) const;
+    bool IsInside(const Point2D<float> &p) const;
     Rect Intersect(const Rect &) const;
 
     // expand the width by factor_x and the height by factor_y

=== modified file 'NuxGraphics/Events.h'
--- NuxGraphics/Events.h	2012-02-07 22:51:46 +0000
+++ NuxGraphics/Events.h	2012-08-01 18:42:21 +0000
@@ -230,6 +230,10 @@
     EVENT_DND_LEAVE,  //!< Synthetic event generated when the dnd action leaves an InputArea. This is not the event sent when the dnd action leaves the window.
     EVENT_DND_ENTER_WINDOW,  //!< Emitted when the DND action goes inside(XdndLeave) a window.
     EVENT_DND_LEAVE_WINDOW,   //!< Emitted when the DND action goes outside(XdndEnter) a window.
+    EVENT_GESTURE_BEGIN, //!< Emitted when a gesture begins. Event class is GestureEvent.
+    EVENT_GESTURE_UPDATE, //!< Emitted when a gesture is updated. Event class is GestureEvent.
+    EVENT_GESTURE_END, //!< Emitted when a gesture ends. Event class is GestureEvent.
+    EVENT_GESTURE_LOST, //!< Emitted when a gesture target loses a gesture. Event class is GestureEvent.
 
 
     // The following values are deprecated. Use the ones above.
@@ -306,7 +310,7 @@
 
     // Because an event is save in event_type instead of calling immediately the handling function,
     // we must clear the previous event each time before we test for new event in Gfx_OpenGLImpl::get_event.
-    void Reset();
+    /*virtual*/ void Reset();
 
     int GetX() const;
     int GetY() const;

=== added file 'NuxGraphics/GestureEvent.cpp'
--- NuxGraphics/GestureEvent.cpp	1970-01-01 00:00:00 +0000
+++ NuxGraphics/GestureEvent.cpp	2012-08-01 18:42:21 +0000
@@ -0,0 +1,80 @@
+/*
+ * Copyright 2012 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License, as
+ * published by the  Free Software Foundation; either version 2.1 or 3.0
+ * of the License.
+ *
+ * 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 along with this program. If not, see <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Daniel d'Andrada <[e-mail]>
+ *
+ */
+
+#include "GestureEvent.h"
+#include "NuxCore/Logger.h"
+
+using namespace nux;
+
+namespace
+{
+  nux::logging::Logger logger("nux.gestureevent");
+}
+
+GestureEvent::GestureEvent()
+{
+  // that's how many fingers you have on your hand (duh).
+  // Can't have gestures with more than that many touch points.
+  touches_.reserve(5);
+}
+
+void GestureEvent::Accept()
+{
+  GeisStatus status;
+  status = geis_gesture_accept(geis_, geis_group_, gesture_id_);
+  if (status != GEIS_STATUS_SUCCESS)
+  {
+    LOG_WARNING(logger) << "Failed to accept gesture with id " << gesture_id_;
+  }
+}
+
+void GestureEvent::Reject()
+{
+  GeisStatus status;
+  status = geis_gesture_reject(geis_, geis_group_, gesture_id_);
+  if (status != GEIS_STATUS_SUCCESS)
+  {
+    LOG_WARNING(logger) << "Failed to reject gesture with id " << gesture_id_;
+  }
+}
+
+void GestureEvent::Reset()
+{
+  Event::Reset();
+
+  gesture_id_ = -1;
+  gesture_classes_ = 0;
+  timestamp_ = -1;
+  focus_.x = focus_.y = 0.0f;
+  delta_.x = delta_.y = 0.0f;
+  angle_ = 0.0f;
+  angle_delta_ = 0.0f;
+  angular_velocity_ = 0.0f;
+  tap_duration_ = -1;
+  velocity_.x = velocity_.y = 0.0f;
+  radius_ = 0.0f;
+  radius_delta_ = 0.0f;
+  radial_velocity_ = 0.0f;
+  is_construction_finished_ = false;
+  touches_.clear();
+  geis_ = nullptr;
+  geis_group_ = nullptr;
+}

=== added file 'NuxGraphics/GestureEvent.h'
--- NuxGraphics/GestureEvent.h	1970-01-01 00:00:00 +0000
+++ NuxGraphics/GestureEvent.h	2012-08-01 18:42:21 +0000
@@ -0,0 +1,162 @@
+/*
+ * Copyright 2012 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License, as
+ * published by the  Free Software Foundation; either version 2.1 or 3.0
+ * of the License.
+ *
+ * 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 along with this program. If not, see <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Daniel d'Andrada <[e-mail]>
+ *
+ */
+
+#ifndef NUX_GESTURE_EVENT_H
+#define NUX_GESTURE_EVENT_H
+#include "Nux/Features.h"
+#ifdef NUX_GESTURES_SUPPORT
+
+#include <geis/geis.h>
+#include <vector>
+
+#include "Events.h"
+#include "NuxCore/Math/Point2D.h"
+
+namespace nux
+{
+  //! Enumerates all possible gesture classes.
+  enum GestureClass
+  {
+    DRAG_GESTURE   = 1, //! A drag gesture
+    PINCH_GESTURE  = 2, //! A pinch gesture
+    ROTATE_GESTURE = 4, //! A rotation gesture
+    TAP_GESTURE    = 8, //! A tap gesture.
+    TOUCH_GESTURE  = 16 /*! A touch gesture. It merely groups two or more touch
+                            points and send their information, without interpreting
+                            what gestures the touch points are performing. */
+  };
+
+  class TouchPoint
+  {
+    public:
+      TouchPoint() : id(-1), x(0.0f), y(0.0f) {}
+      TouchPoint(int id, float x, float y) : id(id), x(x), y(y) {}
+
+      bool operator ==(const TouchPoint& other) const
+      {
+        return id == other.id;
+      }
+
+      int id;
+      float x;
+      float y;
+  };
+
+  //! Gesture Event class
+  class GestureEvent : public Event
+  {
+  public:
+    //! Constructs a GestureEvent
+    GestureEvent();
+
+    //! Accepts the gesture.
+    void Accept();
+    //! Rejects the gesture.
+    void Reject();
+
+    //! The gesture classes that this gesture belongs to.
+    /*!
+      A bitwise "or" of one or more gesture classes from
+      GestureClass enumeration.
+
+      A single physical gesture can comply/belong to more than
+      one gesture class, such as a rotating pinch.
+     */
+    int GetGestureClasses() const {return gesture_classes_;}
+
+    //! Whether all gestures for the related touch points have been presented.
+    /*!
+      This property allows the client to determine if all the possible gestures
+      from the set of touches in this event have already been presented. When
+      this value is true, the client will have received all the information needed
+      to make a gesture accept and reject decision based on potentially
+      overlapping gestures. An example is when both one and two touch gestures are
+      subscribed on the same window with the same gesture classes and thresholds.
+      When this property is true for one touch gesture events, the client can be
+      sure there are no other touches unless a two touch gesture event has already
+      been sent.
+      Another example is when you subscribe for three touches Touch and four
+      touches Drag. As soon as a third finger is detected a three touches Touch
+      gesture will begin, but you cannot be sure a fourth finger isn't coming
+      right after (that can eventually cause a four touches Drag) until this
+      property is true.
+    */
+    bool IsConstructionFinished() const { return is_construction_finished_;}
+
+    int GetGestureId() const {return gesture_id_;}
+    bool IsDirectTouch() const {return is_direct_touch_;}
+    int GetTimestamp() const {return timestamp_;}
+    const Point2D<float> &GetFocus() const {return focus_;}
+    const Point2D<float> &GetDelta() const {return delta_;}
+    float GetAngle() const {return angle_;}
+    float GetAngleDelta() const {return angle_delta_;}
+    float GetAngularVelocity() const {return angular_velocity_;}
+
+    //! Duration of a tap gesture, in milliseconds
+    int GetTapDuration() const {return tap_duration_;}
+
+    const Point2D<float> &GetVelocity() {return velocity_;}
+    float GetRadius() const {return radius_;}
+    float GetRadiusDelta() const {return radius_delta_;}
+    float GetRadialVelocity() const {return radial_velocity_;}
+    const std::vector<TouchPoint> &GetTouches() const {return touches_;}
+
+    virtual void Reset();
+
+  private:
+    int gesture_id_;
+    int gesture_classes_;
+    bool is_direct_touch_;
+    int timestamp_;
+    Point2D<float> focus_;
+    Point2D<float> delta_;
+    float angle_;
+    float angle_delta_;
+    float angular_velocity_;
+    int tap_duration_;
+    Point2D<float> velocity_;
+    float radius_;
+    float radius_delta_;
+    float radial_velocity_;
+    std::vector<TouchPoint> touches_;
+    bool is_construction_finished_;
+
+    Geis geis_;
+    GeisGroup geis_group_;
+    friend class GeisAdapter;
+    friend class FakeGestureEvent;
+  };
+
+  //! Enumerates possible requests regarding delivery of gesture events.
+  enum class GestureDeliveryRequest
+  {
+    NONE, /*!< No request. Continue with current delivery policy. */
+    EXCLUSIVITY /*!< From this moment onwards, deliver events from the related
+                  gesture only to this target. Other targets for this gesture
+                  will receive an event of type EVENT_GESTURE_LOST instead of
+                  this event.
+                  Note that it doesn't affect targets that come before this
+                  one in the order of delivery. */
+  };
+} // namespace nux
+
+#endif // NUX_GESTURES_SUPPORT
+#endif // NUX_GESTURE_EVENT_H

=== modified file 'NuxGraphics/GraphicsDisplayWin.cpp'
--- NuxGraphics/GraphicsDisplayWin.cpp	2012-02-26 03:55:44 +0000
+++ NuxGraphics/GraphicsDisplayWin.cpp	2012-08-01 18:42:21 +0000
@@ -1130,12 +1130,13 @@
   }
 
 //---------------------------------------------------------------------------------------------------------
-  void GraphicsDisplay::GetSystemEvent(Event *evt)
+  bool GraphicsDisplay::GetSystemEvent(Event *evt)
   {
     MSG		msg;
     event_->Reset();
     // Erase mouse event and mouse doubleclick states. Keep the mouse states.
     event_->mouse_state &= 0x0F000000;
+    bool got_event;
 
     // Always set the second parameter of PeekMessage to NULL. Indeed, many services creates
     // windows on the program behalf. If pass the main window as filter, we will miss all the
@@ -1153,10 +1154,12 @@
       DispatchMessage(&msg);
 
       memcpy(evt, event_, sizeof(Event));
+      got_event = true;
     }
     else
     {
       memcpy(evt, event_, sizeof(Event));
+      got_event = false;
     }
 
     if (msg.message == WM_QUIT)
@@ -1174,6 +1177,8 @@
       event_->type = NUX_NO_EVENT;
       memcpy(evt, event_, sizeof(Event));
     }
+
+    return got_event;
   }
 
   void GraphicsDisplay::ProcessForeignWin32Event(HWND hWnd, MSG msg, WPARAM wParam, LPARAM lParam, Event *event)

=== modified file 'NuxGraphics/GraphicsDisplayWin.h'
--- NuxGraphics/GraphicsDisplayWin.h	2011-10-21 22:06:35 +0000
+++ NuxGraphics/GraphicsDisplayWin.h	2012-08-01 18:42:21 +0000
@@ -155,7 +155,10 @@
     void SwapBuffer(bool glswap = true);
 
     // Event methods
-    void GetSystemEvent(Event *evt);
+    /*!
+      Returns true if there was a pending event to be fetched and false otherwise
+     */
+    bool GetSystemEvent(Event *evt);
     Event &GetCurrentEvent();
 
     bool isWindowMinimized() const

=== modified file 'NuxGraphics/GraphicsDisplayX11.cpp'
--- NuxGraphics/GraphicsDisplayX11.cpp	2012-04-16 18:37:21 +0000
+++ NuxGraphics/GraphicsDisplayX11.cpp	2012-08-01 18:42:21 +0000
@@ -1216,12 +1216,13 @@
     return state;
   }
 
-  void GraphicsDisplay::GetSystemEvent(Event *evt)
+  bool GraphicsDisplay::GetSystemEvent(Event *evt)
   {
     m_pEvent->Reset();
     // Erase mouse event and mouse doubleclick states. Keep the mouse states.
     m_pEvent->mouse_state &= 0x0F000000;
     bool bProcessEvent = true;
+    bool got_event;
 
     // Process event matching this window
     XEvent xevent;
@@ -1238,7 +1239,7 @@
           if (result)
           {
             memcpy(evt, m_pEvent, sizeof(Event));
-            return;
+            return true;
           }
         }
       }
@@ -1289,11 +1290,15 @@
 
       memcpy(evt, m_pEvent, sizeof(Event));
 
+      got_event = true;
     }
     else
     {
       memcpy(evt, m_pEvent, sizeof(Event));
+      got_event = false;
     }
+
+    return got_event;
   }
   
 #if defined(NUX_OS_LINUX)

=== modified file 'NuxGraphics/GraphicsDisplayX11.h'
--- NuxGraphics/GraphicsDisplayX11.h	2012-01-26 23:01:57 +0000
+++ NuxGraphics/GraphicsDisplayX11.h	2012-08-01 18:42:21 +0000
@@ -224,7 +224,10 @@
     void SwapBuffer(bool glswap = true);
 
     // Event methods
-    void GetSystemEvent(Event *evt);
+    /*!
+      Returns true if there was a pending event to be fetched and false otherwise
+     */
+    bool GetSystemEvent(Event *evt);
 
     // Os specific
     int GetGlXMajor() const;

=== modified file 'NuxGraphics/Makefile.am'
--- NuxGraphics/Makefile.am	2012-05-25 20:36:09 +0000
+++ NuxGraphics/Makefile.am	2012-08-01 18:42:21 +0000
@@ -16,11 +16,13 @@
   -DG_LOG_DOMAIN=\"NuxGraphics\" \
   $(GCC_FLAGS) \
   $(NUX_GRAPHICS_CFLAGS) \
-  $(MAINTAINER_CFLAGS)
+  $(MAINTAINER_CFLAGS) \
+  $(GEIS_CFLAGS)
 
 libnux_graphics_@NUX_API_VERSION@_la_LIBADD = \
   $(top_builddir)/NuxCore/libnux-core-@NUX_API_VERSION@.la \
-  $(NUX_GRAPHICS_LIBS)
+  $(NUX_GRAPHICS_LIBS) \
+  $(GEIS_LIBS)
 
 libnux_graphics_@NUX_API_VERSION@_la_LDFLAGS = \
   $(NUX_LT_LDFLAGS)
@@ -90,6 +92,11 @@
   $(srcdir)/VirtualKeyCodesX11.h \
   $(srcdir)/XInputWindow.h
 
+if HAVE_GEIS
+source_h += \
+  $(srcdir)/GestureEvent.h
+endif
+
 source_cpp = \
   $(srcdir)/BitmapFormats.cpp \
   $(srcdir)/CairoGraphics.cpp \
@@ -152,6 +159,11 @@
   $(srcdir)/RunTimeStats.cpp \
   $(srcdir)/XInputWindow.cpp
 
+if HAVE_GEIS
+source_cpp += \
+  $(srcdir)/GestureEvent.cpp
+endif
+
 libnux_graphics_@NUX_API_VERSION@_la_SOURCES = \
   $(source_cpp) \
   $(source_h)

=== modified file 'NuxGraphics/nux-graphics.pc.in'
--- NuxGraphics/nux-graphics.pc.in	2012-05-25 20:36:09 +0000
+++ NuxGraphics/nux-graphics.pc.in	2012-08-01 18:42:21 +0000
@@ -9,4 +9,4 @@
 Libs: -L${libdir} -lnux-graphics-@NUX_API_VERSION@
 Cflags: -I${includedir}/Nux-@NUX_API_VERSION@
 
-Requires: glib-2.0 cairo libpng gdk-pixbuf-2.0 nux-core-@NUX_API_VERSION@ @GL_PKGS@ xxf86vm xinerama libutouch-geis
+Requires: glib-2.0 cairo libpng gdk-pixbuf-2.0 nux-core-@NUX_API_VERSION@ @GL_PKGS@ xxf86vm xinerama libgeis

=== modified file 'configure.ac'
--- configure.ac	2012-07-26 00:50:33 +0000
+++ configure.ac	2012-08-01 18:42:21 +0000
@@ -22,7 +22,11 @@
 # The number format is : year/month/day
 # e.g.: december 5th, 2011 is: 20111205
 # To make more than one API change in a day, add a number to the date. Like 20111205.xx
+<<<<<<< TREE
 m4_define([nux_abi_version], [20120725.01])
+=======
+m4_define([nux_abi_version], [20120801.01])
+>>>>>>> MERGE-SOURCE
 
 m4_define([nux_version],
           [nux_major_version.nux_minor_version.nux_micro_version])
@@ -155,7 +159,6 @@
                   xxf86vm
                   sigc++-2.0
 		              xinerama
-                  libutouch-geis
                   )
 AC_SUBST(NUX_GRAPHICS_CFLAGS)
 AC_SUBST(NUX_GRAPHICS_LIBS)
@@ -193,6 +196,55 @@
 AC_SUBST(IBUS_CFLAGS)
 AC_SUBST(IBUS_LIBS)
 
+dnl *********************************************************
+dnl Enable/disable gestures (geis, from Open Input Framework)
+dnl *********************************************************
+
+AC_ARG_ENABLE(gestures,
+              AC_HELP_STRING(--disable-gestures, Disables multitouch gestures support (default: auto-detect)),
+              [],
+              [enable_gestures=auto])
+
+
+# Check for geis as an optional dependency
+AS_IF([test "x$enable_gestures" = "xauto"],
+      [
+        PKG_CHECK_MODULES(GEIS,
+                          [libgeis >= 2.2.10],
+                          [have_geis=yes],
+                          [have_geis=no])
+      ])
+
+
+AS_IF([test "x$enable_gestures" = "xyes"],
+      [
+        PKG_CHECK_MODULES(GEIS,
+                          [libgeis >= 2.2.10],
+                          [have_geis=yes],
+                          [
+                            AC_MSG_ERROR([libgeis not found!])
+                            have_geis=no
+                          ])
+      ])
+
+AS_IF([test "x$enable_gestures" = "xno"],
+      [have_geis=no])
+
+AS_IF([test "x$have_geis" = "xyes"],
+      [
+        NUX_GESTURES_SUPPORT="NUX_GESTURES_SUPPORT"
+        AM_CONDITIONAL(HAVE_GEIS, true)
+      ],
+      [
+        NUX_GESTURES_SUPPORT="NUX_NO_GESTURES_SUPPORT"
+        AM_CONDITIONAL(HAVE_GEIS, false)
+      ])
+
+AC_SUBST(NUX_GESTURES_SUPPORT)
+
+AC_SUBST(GEIS_CFLAGS)
+AC_SUBST(GEIS_LIBS)
+
 dnl ************************************
 dnl Enable/disable tests
 dnl ************************************
@@ -336,6 +388,7 @@
   Nux/Makefile
   Nux/nux.pc
   Nux/ABI.h
+  Nux/Features.h
   examples/Makefile
   tests/Makefile
   tools/Makefile
@@ -371,6 +424,7 @@
 echo -e "        Build Examples     : ${BOLD_WHITE}${enable_examples}${RESET}"
 echo -e "        Build Gpu Tests    : ${BOLD_WHITE}${enable_gputests}${RESET}"
 echo -e "        Build Nux Tests    : ${BOLD_WHITE}${enable_tests}${RESET}"
+echo -e "        Gestures support   : ${BOLD_WHITE}${have_geis}${RESET}"
 echo ""
 
 echo -e "${RESET}"

=== modified file 'examples/Makefile.am'
--- examples/Makefile.am	2012-05-25 20:36:09 +0000
+++ examples/Makefile.am	2012-08-01 18:42:21 +0000
@@ -31,6 +31,9 @@
 #                  timeline \
 #                  tooltip
 
+if HAVE_GEIS
+noinst_PROGRAMS += gestures
+endif
 
 # We only have to do this AM_ once to affect all the binaries we build from
 # this Makefile
@@ -107,6 +110,11 @@
 coverflow_SOURCES = coverflow.cpp
 coverflow_LDADD = $(ALL_LIBS)
 
+if HAVE_GEIS
+gestures_SOURCES = gestures.cpp
+gestures_LDADD = $(ALL_LIBS)
+endif
+
 # To distribute source add the source code here
 #sourceexampledir = "$(pkgdatadir)/examples"
 #sourceexample_DATA = $(combobox_SOURCES) \

=== added file 'examples/gestures.cpp'
--- examples/gestures.cpp	1970-01-01 00:00:00 +0000
+++ examples/gestures.cpp	2012-08-01 18:42:21 +0000
@@ -0,0 +1,100 @@
+/*
+ * Copyright 2012 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License, as
+ * published by the  Free Software Foundation; either version 2.1 or 3.0
+ * of the License.
+ *
+ * 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 along with this program. If not, see <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Daniel d'Andrada <[e-mail]>
+ *
+ */
+
+#include "Nux/FloatingWindow.h"
+#include "Nux/GesturesSubscription.h"
+#include "Nux/Nux.h"
+#include "Nux/WindowThread.h"
+#include <iostream>
+
+using namespace nux;
+
+BaseWindow *window = nullptr;
+
+class GesturalWindow : public FloatingWindow
+{
+  NUX_DECLARE_OBJECT_TYPE(GesturalWindow, FloatingWindow);
+  public:
+  GesturalWindow(const char *window_name = "", NUX_FILE_LINE_PROTO)
+    : FloatingWindow(window_name, NUX_FILE_LINE_PARAM) 
+  {
+    CreateGesturesSubscription(TOUCH_GESTURE, 3);
+    event_count = 0;
+  }
+
+  virtual ~GesturalWindow() {}
+
+  virtual GestureDeliveryRequest GestureEvent(const nux::GestureEvent &event)
+  {
+    std::cout << "GesturalWindow got GestureEvent "
+              << ++event_count << "\n";
+
+    return GestureDeliveryRequest::NONE;
+  }
+
+  int event_count;
+};
+NUX_IMPLEMENT_OBJECT_TYPE(GesturalWindow);
+
+int GesturesEventInspector(Area* area, Event* event, void* data)
+{
+  if (event->type < EVENT_GESTURE_BEGIN || event->type > EVENT_GESTURE_END)
+    return false;
+
+  GestureEvent *gesture_event = static_cast<GestureEvent*>(event);
+
+  if (gesture_event->type == EVENT_GESTURE_BEGIN)
+  {
+    std::cout << "Gesture begun\n";
+  }
+  else if (gesture_event->type == EVENT_GESTURE_UPDATE)
+    std::cout << "Gesture updated\n";
+  else
+    std::cout << "Gesture ended\n";
+
+  return false;
+}
+
+void UserInterfaceInitialization(NThread* thread, void* InitData)
+{
+  window = new GesturalWindow(TEXT("Gestural Window"), NUX_TRACKER_LOCATION);
+  window->SetBaseXY(100, 20);
+  window->ShowWindow(true);
+}
+
+int main()
+{
+  // Initialize Nux.
+  NuxInitialize(0);
+
+  // Create a window thread.
+  WindowThread* window_thread = CreateGUIThread(
+      "Gestures", 640, 300, 0, &UserInterfaceInitialization, 0);
+
+  window_thread->InstallEventInspector(GesturesEventInspector, nullptr);
+
+  // Start the main loop.
+  window_thread->Run(NULL);
+
+  window->Dispose(); // will cause the window to be deleted (as ref count is zeroed)
+  delete window_thread;
+  return 0;
+}

=== added file 'tests/FakeGestureEvent.h'
--- tests/FakeGestureEvent.h	1970-01-01 00:00:00 +0000
+++ tests/FakeGestureEvent.h	2012-08-01 18:42:21 +0000
@@ -0,0 +1,63 @@
+#ifndef FAKE_GESTURE_EVENT_H
+#define FAKE_GESTURE_EVENT_H
+
+#include <NuxGraphics/GestureEvent.h>
+#include <map>
+
+namespace nux {
+class FakeGestureEvent
+{
+  public:
+    nux::EventType type;
+
+    int gesture_id;
+    int gesture_classes;
+    bool is_direct_touch;
+    int timestamp;
+    nux::Point2D<float> focus;
+    nux::Point2D<float> delta;
+    float angle;
+    float angle_delta;
+    float angular_velocity;
+    int tap_duration;
+    nux::Point2D<float> velocity;
+    float radius;
+    float radius_delta;
+    float radial_velocity;
+    std::vector<nux::TouchPoint> touches;
+    bool is_construction_finished;
+
+    nux::GestureEvent &ToGestureEvent()
+    {
+      event_.type = type;
+
+      event_.gesture_id_ = gesture_id;
+      event_.gesture_classes_ = gesture_classes;
+      event_.is_direct_touch_ = is_direct_touch;
+      event_.timestamp_ = timestamp;
+      event_.focus_ = focus;
+      event_.delta_ = delta;
+      event_.angle_ = angle;
+      event_.angle_delta_ = angle_delta;
+      event_.angular_velocity_ = angular_velocity;
+      event_.tap_duration_ = tap_duration;
+      event_.velocity_ = velocity;
+      event_.radius_ = radius;
+      event_.radius_delta_ = radius_delta;
+      event_.radial_velocity_ = radial_velocity;
+      event_.touches_ = touches;
+      event_.is_construction_finished_ = is_construction_finished;
+
+      return event_;
+    }
+
+  private:
+    nux::GestureEvent event_;
+};
+} // namespace nux
+
+// maps a gesture id to its acceptance
+// each Accept() increments by one and each Reject() decrements by one.
+extern std::map<int, int> g_gesture_acceptance;
+
+#endif // FAKE_GESTURE_EVENT_H

=== modified file 'tests/Makefile.am'
--- tests/Makefile.am	2012-07-03 11:04:59 +0000
+++ tests/Makefile.am	2012-08-01 18:42:21 +0000
@@ -78,6 +78,13 @@
   gtest-nux-windowcompositor.cpp \
   gtest-nux-windowthread.cpp
 
+if HAVE_GEIS
+gtest_nux_SOURCES += \
+	geis_mock.cpp \
+  gtest-nux-geisadapter.cpp \
+  gtest-nux-gesturebroker.cpp
+endif
+
 gtest_nux_CPPFLAGS = \
   -I$(srcdir) \
   -I$(top_srcdir) \

=== added file 'tests/geis_mock.cpp'
--- tests/geis_mock.cpp	1970-01-01 00:00:00 +0000
+++ tests/geis_mock.cpp	2012-08-01 18:42:21 +0000
@@ -0,0 +1,483 @@
+/*
+ * Copyright 2012 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License, as
+ * published by the  Free Software Foundation; either version 2.1 or 3.0
+ * of the License.
+ *
+ * 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 along with this program. If not, see <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Daniel d'Andrada <[e-mail]>
+ *
+ */
+
+#include <geis/geis.h>
+#include "geis_mock.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <sys/eventfd.h>
+#include <unistd.h>
+
+//#define DEBUG_PRINT printf("%s mock called!\n", __func__);
+#define DEBUG_PRINT
+
+/******** GeisAttributes helper class *********/
+
+GeisAttr GeisAttributes::GetByName(GeisString name)
+{
+  for (size_t i = 0; i < vector.size(); ++i)
+  {
+    GeisAttr attr = vector[i].get();
+    if (attr->name.compare(name) == 0)
+      return attr;
+  }
+  return nullptr;
+}
+
+GeisAttr GeisAttributes::GetByIndex(GeisSize index)
+{
+  if (vector.size() > index)
+  {
+    return vector[index].get();
+  }
+  else
+  {
+    return nullptr;
+  }
+}
+
+GeisSize GeisAttributes::Count()
+{
+  return vector.size();
+}
+
+void GeisAttributes::AddBoolean(const char *name, GeisBoolean value)
+{
+  std::unique_ptr<struct _GeisAttr> attr(new struct _GeisAttr);
+  attr->type = GEIS_ATTR_TYPE_BOOLEAN;
+  attr->name = name;
+  attr->b = value;
+  vector.push_back(std::move(attr));
+}
+
+void GeisAttributes::AddFloat(const char *name, GeisFloat value)
+{
+  std::unique_ptr<struct _GeisAttr> attr(new struct _GeisAttr);
+  attr->type = GEIS_ATTR_TYPE_FLOAT;
+  attr->name = name;
+  attr->f = value;
+  vector.push_back(std::move(attr));
+}
+
+void GeisAttributes::AddInteger(const char *name, GeisInteger value)
+{
+  std::unique_ptr<struct _GeisAttr> attr(new struct _GeisAttr);
+  attr->type = GEIS_ATTR_TYPE_INTEGER;
+  attr->name = name;
+  attr->i = value;
+  vector.push_back(std::move(attr));
+}
+
+void GeisAttributes::AddPointer(const char *name, void *value)
+{
+  std::unique_ptr<struct _GeisAttr> attr(new struct _GeisAttr);
+  attr->type = GEIS_ATTR_TYPE_POINTER;
+  attr->name = name;
+  attr->p    = value;
+  vector.push_back(std::move(attr));
+}
+
+/******* Geis  *******/
+
+Geis geis_new(GeisString init_arg_name, ...)
+{
+  DEBUG_PRINT
+  Geis geis = new struct _Geis;
+  geis->fd = eventfd(0, EFD_NONBLOCK);
+  return geis;
+}
+
+GeisStatus geis_delete(Geis geis)
+{
+  DEBUG_PRINT
+  close(geis->fd);
+  delete geis;
+  return GEIS_STATUS_SUCCESS;
+}
+
+GeisStatus geis_get_configuration(Geis geis,
+                                  GeisString configuration_item_name,
+                                  void *configuration_item_value)
+{
+  DEBUG_PRINT
+  if (strcmp(configuration_item_name, GEIS_CONFIGURATION_FD) == 0)
+  {
+    int *fd = static_cast<int*>(configuration_item_value);
+    *fd = geis->fd;
+    return GEIS_STATUS_SUCCESS;
+  }
+  else
+  {
+    return GEIS_STATUS_NOT_SUPPORTED;
+  }
+}
+
+GeisStatus geis_dispatch_events(Geis geis)
+{
+  DEBUG_PRINT
+  return GEIS_STATUS_SUCCESS;
+}
+
+GeisStatus geis_next_event(Geis geis, GeisEvent *event)
+{
+  DEBUG_PRINT
+
+  if (geis->pending_events.size() > 0)
+  {
+    *event = geis->pending_events.front();
+    geis->pending_events.pop_front();
+
+    if (geis->pending_events.size() > 0)
+      return GEIS_STATUS_CONTINUE;
+    else
+      return GEIS_STATUS_SUCCESS;
+  }
+  else
+  {
+    *event = nullptr;
+    return GEIS_STATUS_EMPTY;
+  }
+}
+
+GeisStatus geis_gesture_accept(Geis          geis,
+                               GeisGroup     group,
+                               GeisGestureId gesture_id)
+{
+  DEBUG_PRINT
+  return GEIS_STATUS_SUCCESS;
+}
+
+GeisStatus geis_gesture_reject(Geis          geis,
+                               GeisGroup     group,
+                               GeisGestureId gesture_id)
+{
+  DEBUG_PRINT
+  return GEIS_STATUS_SUCCESS;
+}
+
+/******* Attr  *******/
+
+GeisString geis_attr_name(GeisAttr attr)
+{
+  DEBUG_PRINT
+  return attr->name.c_str();
+}
+
+GeisAttrType geis_attr_type(GeisAttr attr)
+{
+  DEBUG_PRINT
+  return attr->type;
+}
+
+GeisBoolean geis_attr_value_to_boolean(GeisAttr attr)
+{
+  DEBUG_PRINT
+  return attr->b;
+}
+
+GeisFloat geis_attr_value_to_float(GeisAttr attr)
+{
+  DEBUG_PRINT
+  return attr->f;
+}
+
+GeisInteger geis_attr_value_to_integer(GeisAttr attr)
+{
+  DEBUG_PRINT
+  return attr->i;
+}
+
+GeisPointer geis_attr_value_to_pointer(GeisAttr attr)
+{
+  DEBUG_PRINT
+  return attr->p;
+}
+
+GeisString geis_attr_value_to_string(GeisAttr attr)
+{
+  DEBUG_PRINT
+  return attr->s.c_str();
+}
+
+/*********** Event  **************/
+
+void geis_event_delete(GeisEvent event)
+{
+  DEBUG_PRINT
+  delete event;
+}
+
+GeisEventType geis_event_type(GeisEvent event)
+{
+  DEBUG_PRINT
+  return event->type;
+}
+
+GeisSize geis_event_attr_count(GeisEvent event)
+{
+  DEBUG_PRINT
+  return event->attributes.Count();
+}
+
+GeisAttr geis_event_attr(GeisEvent event, GeisSize index)
+{
+  DEBUG_PRINT
+  return event->attributes.GetByIndex(index);
+}
+
+GeisAttr geis_event_attr_by_name(GeisEvent event, GeisString attr_name)
+{
+  DEBUG_PRINT
+  return event->attributes.GetByName(attr_name);
+}
+
+/******** Gesture Class   ***********/
+
+void geis_gesture_class_ref(GeisGestureClass gesture_class)
+{
+  DEBUG_PRINT
+}
+
+void geis_gesture_class_unref(GeisGestureClass gesture_class)
+{
+  DEBUG_PRINT
+}
+
+GeisString geis_gesture_class_name(GeisGestureClass gesture_class)
+{
+  DEBUG_PRINT
+  return const_cast<char *>(gesture_class->name.c_str());
+}
+
+GeisInteger geis_gesture_class_id(GeisGestureClass gesture_class)
+{
+  DEBUG_PRINT
+  return gesture_class->id;
+}
+
+GeisSize geis_gesture_class_attr_count(GeisGestureClass gesture_class)
+{
+  DEBUG_PRINT
+  return gesture_class->attributes.Count();
+}
+
+GeisAttr geis_gesture_class_attr(GeisGestureClass gesture_class, int index)
+{
+  DEBUG_PRINT
+  return gesture_class->attributes.GetByIndex(index);
+}
+
+/********* Device ***********/
+
+GeisInteger geis_device_id(GeisDevice device)
+{
+  DEBUG_PRINT
+  return device->id;
+}
+
+GeisAttr geis_device_attr_by_name(GeisDevice device, GeisString attr_name)
+{
+  DEBUG_PRINT
+  return device->attributes.GetByName(attr_name);
+}
+
+/********** Group Set **********/
+
+GeisSize geis_groupset_group_count(GeisGroupSet groupset)
+{
+  DEBUG_PRINT
+  return groupset->vector.size();
+}
+
+GeisGroup geis_groupset_group(GeisGroupSet groupset, GeisSize index)
+{
+  DEBUG_PRINT
+  return groupset->vector[index];
+}
+
+/****** Group ******/
+
+GeisSize geis_group_frame_count(GeisGroup group)
+{
+  DEBUG_PRINT
+  return group->vector.size();
+}
+
+GeisFrame geis_group_frame(GeisGroup group, GeisSize index)
+{
+  DEBUG_PRINT
+  return group->vector[index];
+}
+
+/***** Touch Set *****/
+
+GeisSize geis_touchset_touch_count(GeisTouchSet touchset)
+{
+  DEBUG_PRINT
+  return touchset->vector.size();
+}
+
+GeisTouch geis_touchset_touch(GeisTouchSet touchset, GeisSize index)
+{
+  DEBUG_PRINT
+  return touchset->vector[index];
+}
+
+/***** Touch ******/
+
+GeisTouchId geis_touch_id(GeisTouch touch)
+{
+  DEBUG_PRINT
+  return touch->id;
+}
+
+GeisSize geis_touch_attr_count(GeisTouch touch)
+{
+  DEBUG_PRINT
+  return touch->attributes.Count();
+}
+
+GeisAttr geis_touch_attr(GeisTouch touch, GeisSize index)
+{
+  DEBUG_PRINT
+  return touch->attributes.GetByIndex(index);
+}
+
+GeisAttr geis_touch_attr_by_name(GeisTouch touch, GeisString name)
+{
+  DEBUG_PRINT
+  return touch->attributes.GetByName(name);
+}
+
+/***** Frame *****/
+
+GeisGestureId geis_frame_id(GeisFrame frame)
+{
+  DEBUG_PRINT
+  return frame->id;
+}
+
+GeisBoolean geis_frame_is_class(GeisFrame        frame,
+                                GeisGestureClass gesture_class)
+{
+  DEBUG_PRINT
+  std::set<int>::iterator it = frame->class_ids.find(gesture_class->id);
+  if (it == frame->class_ids.end())
+    return GEIS_FALSE;
+  else
+    return GEIS_TRUE;
+}
+
+GeisSize geis_frame_attr_count(GeisFrame frame)
+{
+  DEBUG_PRINT
+  return frame->attributes.Count();
+}
+
+GeisAttr geis_frame_attr(GeisFrame frame, GeisSize index)
+{
+  DEBUG_PRINT
+  return frame->attributes.GetByIndex(index);
+}
+
+GeisAttr geis_frame_attr_by_name(GeisFrame frame, GeisString name)
+{
+  DEBUG_PRINT
+  return frame->attributes.GetByName(name);
+}
+
+/***** Subscription *****/
+
+GeisSubscription geis_subscription_new(Geis                  geis,
+                                       GeisString            name,
+                                       GeisSubscriptionFlags flags)
+{
+  DEBUG_PRINT
+  return new struct _GeisSubscription;
+}
+
+GeisStatus geis_subscription_delete(GeisSubscription subscription)
+{
+  DEBUG_PRINT
+  for (auto filter : subscription->filters)
+  {
+    delete filter;
+  }
+  delete subscription;
+  return GEIS_STATUS_SUCCESS;
+}
+
+GeisStatus geis_subscription_activate(GeisSubscription subscription)
+{
+  DEBUG_PRINT
+  return GEIS_STATUS_SUCCESS;
+}
+
+GeisStatus geis_subscription_deactivate(GeisSubscription subscription)
+{
+  DEBUG_PRINT
+  return GEIS_STATUS_SUCCESS;
+}
+
+GeisString geis_subscription_name(GeisSubscription subscription)
+{
+  DEBUG_PRINT
+  return const_cast<char *>(subscription->name.c_str());
+}
+
+GeisInteger geis_subscription_id(GeisSubscription subscription)
+{
+  DEBUG_PRINT
+  return subscription->id;
+}
+
+GeisStatus geis_subscription_add_filter(GeisSubscription subscription,
+                                        GeisFilter       filter)
+{
+  DEBUG_PRINT
+  subscription->filters.push_back(filter);
+  return GEIS_STATUS_SUCCESS;
+}
+
+GeisFilter geis_subscription_filter_by_name(GeisSubscription sub,
+                                            GeisString       name)
+{
+  DEBUG_PRINT
+  return nullptr;
+}
+
+GeisStatus geis_subscription_remove_filter(GeisSubscription subscription,
+                                          GeisFilter       filter)
+{
+  DEBUG_PRINT
+  std::vector<GeisFilter>::iterator it = subscription->filters.begin();
+  while (it != subscription->filters.end())
+  {
+    if (filter == *it)
+    {
+      subscription->filters.erase(it);
+      return GEIS_STATUS_SUCCESS;
+    }
+    ++it;
+  }
+  return GEIS_STATUS_BAD_ARGUMENT;
+}

=== added file 'tests/geis_mock.h'
--- tests/geis_mock.h	1970-01-01 00:00:00 +0000
+++ tests/geis_mock.h	2012-08-01 18:42:21 +0000
@@ -0,0 +1,148 @@
+/*
+ * Copyright 2012 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License, as
+ * published by the  Free Software Foundation; either version 2.1 or 3.0
+ * of the License.
+ *
+ * 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 along with this program. If not, see <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Daniel d'Andrada <[e-mail]>
+ *
+ */
+
+#ifndef GEIS_MOCK_H
+#define GEIS_MOCK_H
+
+#include <memory>
+#include <set>
+#include <string>
+#include <vector>
+#include <list>
+
+/* helper class */
+class GeisAttributes
+{
+ public:
+  GeisAttr GetByName(GeisString name);
+  GeisAttr GetByIndex(GeisSize index);
+  GeisSize Count();
+  void AddBoolean(const char *name, GeisBoolean value);
+  void AddFloat(const char *name, GeisFloat value);
+  void AddInteger(const char *name, GeisInteger value);
+  void AddPointer(const char *name, void *value);
+  std::vector< std::unique_ptr<struct _GeisAttr> > vector;
+};
+
+struct _GeisAttr
+{
+  GeisAttrType type;
+  std::string name;
+
+  GeisBoolean  b;
+  GeisFloat    f;
+  GeisInteger  i;
+  std::string  s;
+  void*        p;
+};
+
+struct GeisStructWithAttributes
+{
+  GeisAttributes attributes;
+
+  bool GetBoolean(const char *name)
+  {
+    return attributes.GetByName(name)->b;
+  }
+
+  float GetFloat(const char *name)
+  {
+    return attributes.GetByName(name)->f;
+  }
+
+  int GetInteger(const char *name)
+  {
+    return attributes.GetByName(name)->i;
+  }
+
+  std::string GetString(const char *name)
+  {
+    return attributes.GetByName(name)->s;
+  }
+
+  void* GetPointer(const char *name)
+  {
+    return attributes.GetByName(name)->p;
+  }
+};
+
+struct _Geis
+{
+  int fd;
+  std::list<GeisEvent> pending_events;
+};
+
+struct _GeisGestureClass : GeisStructWithAttributes
+{
+  int id;
+  std::string name;
+};
+
+struct _GeisEvent : GeisStructWithAttributes
+{
+  GeisEventType type;
+};
+
+struct _GeisDevice : GeisStructWithAttributes
+{
+  int id;
+};
+
+struct _GeisGroup
+{
+  int id;
+  std::vector<GeisFrame> vector;
+};
+
+struct _GeisGroupSet
+{
+  std::vector<GeisGroup> vector;
+};
+
+struct _GeisTouch : GeisStructWithAttributes
+{
+  int id;
+};
+
+struct _GeisTouchSet
+{
+  std::vector<GeisTouch> vector;
+};
+
+struct _GeisFrame : GeisStructWithAttributes
+{
+  int id;
+  std::set<int> class_ids;
+};
+
+struct _GeisSubscription
+{
+  int id;
+  std::string name;
+  std::vector<GeisFilter> filters;
+};
+
+struct _GeisFilter
+{
+  int foo;
+};
+
+#endif

=== added file 'tests/gtest-nux-geisadapter.cpp'
--- tests/gtest-nux-geisadapter.cpp	1970-01-01 00:00:00 +0000
+++ tests/gtest-nux-geisadapter.cpp	2012-08-01 18:42:21 +0000
@@ -0,0 +1,230 @@
+#include <gtest/gtest.h>
+
+#include <Nux/GeisAdapter.h>
+#include "geis_mock.h"
+#include <list>
+
+class GeisAdapterTest : public ::testing::Test
+{
+  public:
+
+  GeisAdapterTest()
+  {
+    adapter_emitted_init_complete = false;
+  }
+
+  void AddGestureClass(Geis geis, GeisGestureClass gesture_class)
+  {
+    GeisEvent event = new struct _GeisEvent;
+    event->type = GEIS_EVENT_CLASS_AVAILABLE;
+    event->attributes.AddPointer(GEIS_EVENT_ATTRIBUTE_CLASS, gesture_class);
+    geis->pending_events.push_back(event);
+  }
+
+  void AddDevice(Geis geis, GeisDevice device)
+  {
+    GeisEvent event = new struct _GeisEvent;
+    event->type = GEIS_EVENT_DEVICE_AVAILABLE;
+    event->attributes.AddPointer(GEIS_EVENT_ATTRIBUTE_DEVICE, device);
+    geis->pending_events.push_back(event);
+  }
+
+  void FinishInitialization(Geis geis)
+  {
+    GeisEvent event = new struct _GeisEvent;
+    event->type = GEIS_EVENT_INIT_COMPLETE;
+    geis->pending_events.push_back(event);
+  }
+
+  void StoreNuxGestureEvent(nux::GestureEvent &gesture_event)
+  {
+    gesture_events.push_back(gesture_event);
+  }
+
+  void MarkInitCompleteAsEmitted()
+  {
+    adapter_emitted_init_complete = true;
+  }
+
+  std::list<nux::GestureEvent> gesture_events;
+  bool adapter_emitted_init_complete;
+};
+
+/*
+  Send a GEIS_EVENT_INIT_COMPLETE and check if GeisAdapter emits init_complete
+  and IsInitComplete() returns a correct value.
+ */
+TEST_F(GeisAdapterTest, SignalsInitComplete)
+{
+  nux::GeisAdapter geis_adapter;
+  Geis geis = geis_adapter.GetGeisInstance();
+
+  ASSERT_FALSE(geis_adapter.IsInitComplete());
+
+  geis_adapter.init_complete.connect(sigc::mem_fun(this,
+      &GeisAdapterTest::MarkInitCompleteAsEmitted));
+
+  FinishInitialization(geis);
+
+  geis_adapter.ProcessGeisEvents();
+
+  ASSERT_TRUE(adapter_emitted_init_complete);
+  ASSERT_TRUE(geis_adapter.IsInitComplete());
+}
+
+/*
+  First send some necessary initialization events. One to define a multi-touch device,
+  another defining a gesture class and one that tells that the initialization
+  has completed.
+
+  After that send a well formed GEIS_EVENT_GESTURE_BEGIN and check if GeisAdapter
+  emits a corresponding nux::GestureEvent.
+ */
+TEST_F(GeisAdapterTest, EmitsWellFormedNuxGestureEvent)
+{
+  nux::GeisAdapter geis_adapter;
+  Geis geis = geis_adapter.GetGeisInstance();
+
+  struct _GeisGestureClass drag_class;
+  drag_class.id = 12;
+  drag_class.name = GEIS_GESTURE_DRAG;
+  AddGestureClass(geis, &drag_class);
+
+  struct _GeisDevice device;
+  device.id = 7;
+  device.attributes.AddBoolean(GEIS_DEVICE_ATTRIBUTE_DIRECT_TOUCH, true);
+  AddDevice(geis, &device);
+
+  FinishInitialization(geis);
+
+  struct _GeisFrame frame;
+  frame.id = 321;
+  frame.class_ids.insert(drag_class.id);
+  frame.attributes.AddInteger(GEIS_GESTURE_ATTRIBUTE_DEVICE_ID, device.id);
+  frame.attributes.AddFloat(GEIS_GESTURE_ATTRIBUTE_FOCUS_X, 87.3f);
+  frame.attributes.AddFloat(GEIS_GESTURE_ATTRIBUTE_FOCUS_Y, 123.4f);
+
+  struct _GeisGroup group;
+  group.vector.push_back(&frame);
+
+  struct _GeisGroupSet group_set;
+  group_set.vector.push_back(&group);
+
+  struct _GeisTouch touch;
+  touch.id = 0;
+  touch.attributes.AddFloat(GEIS_TOUCH_ATTRIBUTE_ID, 123);
+  touch.attributes.AddFloat(GEIS_TOUCH_ATTRIBUTE_X, 777.7f);
+  touch.attributes.AddFloat(GEIS_TOUCH_ATTRIBUTE_Y, 888.8f);
+
+  struct _GeisTouchSet touch_set;
+  touch_set.vector.push_back(&touch);
+
+  GeisEvent event = new struct _GeisEvent;
+  event->type = GEIS_EVENT_GESTURE_BEGIN;
+  event->attributes.AddPointer(GEIS_EVENT_ATTRIBUTE_GROUPSET, &group_set);
+  event->attributes.AddPointer(GEIS_EVENT_ATTRIBUTE_TOUCHSET, &touch_set);
+  event->attributes.AddBoolean(GEIS_EVENT_ATTRIBUTE_CONSTRUCTION_FINISHED, true);
+  geis->pending_events.push_back(event);
+
+  geis_adapter.event_ready.connect(sigc::mem_fun(this,
+      &GeisAdapterTest::StoreNuxGestureEvent));
+
+  geis_adapter.ProcessGeisEvents();
+
+  ASSERT_EQ(1, gesture_events.size());
+
+  const nux::GestureEvent &gesture_event = gesture_events.front();
+
+  ASSERT_EQ(nux::EVENT_GESTURE_BEGIN, gesture_event.type);
+
+  ASSERT_EQ(frame.id, gesture_event.GetGestureId());
+
+  ASSERT_EQ(device.GetBoolean(GEIS_DEVICE_ATTRIBUTE_DIRECT_TOUCH),
+            gesture_event.IsDirectTouch());
+
+  ASSERT_FLOAT_EQ(frame.GetFloat(GEIS_GESTURE_ATTRIBUTE_FOCUS_X),
+                  gesture_event.GetFocus().x);
+
+  ASSERT_FLOAT_EQ(frame.GetFloat(GEIS_GESTURE_ATTRIBUTE_FOCUS_Y),
+                  gesture_event.GetFocus().y);
+
+  ASSERT_EQ(touch_set.vector.size(), gesture_event.GetTouches().size());
+  for (size_t i = 0; i < gesture_event.GetTouches().size(); ++i)
+  {
+    ASSERT_FLOAT_EQ(touch_set.vector[i]->GetInteger(GEIS_TOUCH_ATTRIBUTE_ID),
+                    gesture_event.GetTouches()[i].id);
+
+    ASSERT_FLOAT_EQ(touch_set.vector[i]->GetFloat(GEIS_TOUCH_ATTRIBUTE_X),
+                    gesture_event.GetTouches()[i].x);
+
+    ASSERT_FLOAT_EQ(touch_set.vector[i]->GetFloat(GEIS_TOUCH_ATTRIBUTE_Y),
+                    gesture_event.GetTouches()[i].y);
+  }
+
+}
+
+/*
+  Checks that when a Tap Update GeisEvent is received, GeisAdpater generates
+  two events from it: A Tap Begin and a Tap End.
+ */
+TEST_F(GeisAdapterTest, SplitTapUpdateIntoTapBeginAndTapEnd)
+{
+  nux::GeisAdapter geis_adapter;
+  Geis geis = geis_adapter.GetGeisInstance();
+
+  struct _GeisGestureClass tap_class;
+  tap_class.id = 12;
+  tap_class.name = GEIS_GESTURE_TAP;
+  AddGestureClass(geis, &tap_class);
+
+  struct _GeisDevice device;
+  device.id = 7;
+  device.attributes.AddBoolean(GEIS_DEVICE_ATTRIBUTE_DIRECT_TOUCH, true);
+  AddDevice(geis, &device);
+
+  FinishInitialization(geis);
+
+  struct _GeisFrame frame;
+  frame.id = 321;
+  frame.class_ids.insert(tap_class.id);
+  frame.attributes.AddInteger(GEIS_GESTURE_ATTRIBUTE_DEVICE_ID, device.id);
+  frame.attributes.AddFloat(GEIS_GESTURE_ATTRIBUTE_FOCUS_X, 87.3f);
+  frame.attributes.AddFloat(GEIS_GESTURE_ATTRIBUTE_FOCUS_Y, 123.4f);
+
+  struct _GeisGroup group;
+  group.vector.push_back(&frame);
+
+  struct _GeisGroupSet group_set;
+  group_set.vector.push_back(&group);
+
+  struct _GeisTouch touch;
+  touch.id = 0;
+  touch.attributes.AddFloat(GEIS_TOUCH_ATTRIBUTE_ID, 123);
+  touch.attributes.AddFloat(GEIS_TOUCH_ATTRIBUTE_X, 777.7f);
+  touch.attributes.AddFloat(GEIS_TOUCH_ATTRIBUTE_Y, 888.8f);
+
+  struct _GeisTouchSet touch_set;
+  touch_set.vector.push_back(&touch);
+
+  GeisEvent event = new struct _GeisEvent;
+  event->type = GEIS_EVENT_GESTURE_UPDATE;
+  event->attributes.AddPointer(GEIS_EVENT_ATTRIBUTE_GROUPSET, &group_set);
+  event->attributes.AddPointer(GEIS_EVENT_ATTRIBUTE_TOUCHSET, &touch_set);
+  event->attributes.AddBoolean(GEIS_EVENT_ATTRIBUTE_CONSTRUCTION_FINISHED, false);
+  geis->pending_events.push_back(event);
+
+  geis_adapter.event_ready.connect(sigc::mem_fun(this,
+      &GeisAdapterTest::StoreNuxGestureEvent));
+
+  geis_adapter.ProcessGeisEvents();
+
+  ASSERT_EQ(2, gesture_events.size());
+
+  ASSERT_EQ(nux::EVENT_GESTURE_BEGIN, gesture_events.front().type);
+  ASSERT_EQ(nux::TAP_GESTURE, gesture_events.front().GetGestureClasses());
+  ASSERT_TRUE(gesture_events.front().IsConstructionFinished());
+
+  ASSERT_EQ(nux::EVENT_GESTURE_END, gesture_events.back().type);