Merge lp:~thomas-voss/grail/rework_cosmetics into lp:~chasedouglas/grail/rework

[Thomas Voß]

Wrapped up the actual implementation in namespace utouch::grail. PIMPL-ed classes and switched to opaque-pointers for the C interface.

[Stephen M. Webb (bregma)]

src/v3/event.h:

(1) there is no need to namespace the class name since it is namespaced using a
namespace. "Event" should be fine.

(2) Inconsistent style: sometimes the reference modifier is separated from the
type name, sometimes not -- what does the team style guide say?

(3) why use a shared_ptr for the pimpl when copying the object is forbidden?
std::unique_ptr would be a better choice.

(4) is the tab style (mixed tab/spaces) consistent with the team style guidelines?

(5) Class documentation?

src/v3/gesture.h:

(1) why is <map> included?

(2) should utouch::grail::SharedUGDlice not be defined in the slice.h
header or be a member type?

(3) should utouch::grail::TouchSet not be defined in a touch header or be a
member type?

(4) do we really want to return a subscription by pointer?

(5) why use a shared_ptr for the pimpl when copying the object is forbidden?
std::unique_ptr would be a better choice.

src/v3/handle.h:

(1) why are <list> and <map> included? Why is <X11/X.h> included?

(2) there is no need to namespace the class name since it is namespaced using a
namespace. "Handle" should be fine.

(3) why use a shared_ptr for the pimpl when copying the object is forbidden?
std::unique_ptr would be a better choice.

(3) Inconsistent style: sometimes the pointer modifier is separated from the
type name, sometimes not, sometimes there is space after parentheses, sometimes
not -- what does the team style guide say?

src/v3/handle.cpp:

(1) Are the conditions passed to std::assert() reversed?

src/v3/recognizer.h:

(1) why are <list> and <map> included?

(2) See points in other files regarding style and use of shared_ptr.

src/v3/recognizer.cpp:

(1) I see a lot of raw Subscription pointers being passed around... should these
be wrapped in some kind of smart pointer?

src/v3/slice.h:

(1) See points in other files regarding namespacing, style and use of shared_ptr.

src/v3/slice.cpp:

(1) ::memcpy() is used but the required header is not included, <cstring>
provides std::memcpy()... std::copy_n() is probably a better choice anyway.

src/v3/subscription.h:

(1) See points in other files regarding namespacing, style and use of shared_ptr.

review: Needs Fixing

Unmerged revisions

241. By Thomas Voß on 2011-10-31

Modified: Reverted changes to initialization of limits.

240. By Thomas Voß on 2011-10-31

Cleaned up v3, introduced utouch::grail namespace and PIMPL-ed classes.

=== modified file 'include/utouch/grail.h'
--- include/utouch/grail.h	2011-10-19 21:39:17 +0000
+++ include/utouch/grail.h	2011-11-01 21:20:40 +0000
@@ -41,13 +41,13 @@
  */
 
 /** An object for the context of the uTouch Frame instance */
-typedef struct UGHandle_* UGHandle;
+typedef void * UGHandle;
 /** An object for a gesture subscription */
-typedef struct UGSubscription_* UGSubscription;
+typedef void * UGSubscription;
 /** An object for an event */
-typedef const struct UGEvent_* UGEvent;
+typedef const void * UGEvent;
 /** An object for a gesture state in time */
-typedef const struct UGSlice_* UGSlice;
+typedef void * UGSlice;
 
 /** The status code denoting the result of a function call */
 typedef enum UGStatus {
@@ -400,7 +400,7 @@
  * @param [out] event The retrieved event
  * @return UGStatusSuccess or UGStatusErrorNoEvent
  */
-UGStatus grail_get_event(UGHandle handle, UGEvent *event);
+UGStatus grail_get_event(UGHandle handle, UGEvent * event );
 
 /**
  * Release an event back to the uTouch Grail context
@@ -499,7 +499,7 @@
  * @param [in] event The event object
  * @return The type of the event
  */
-UGEventType grail_event_get_type(const UGEvent event);
+UGEventType grail_event_get_type( UGEvent event);
 
 /**
  * Get the time of an event
@@ -507,7 +507,7 @@
  * @param [in] event The event object
  * @return The time of the event
  */
-uint64_t grail_event_get_time(const UGEvent event);
+uint64_t grail_event_get_time(UGEvent event);
 
 /**
  * Get the ID of a gesture from a slice
 
=== modified file 'src/v3/event.cpp'
--- src/v3/event.cpp	2011-10-13 22:56:46 +0000
+++ src/v3/event.cpp	2011-11-01 21:20:40 +0000
@@ -1,6 +1,6 @@
 /*****************************************************************************
  *
- * utouch-grail - Multitouch Gesture Recognition Library
+ * Utouch-grail - Multitouch Gesture Recognition Library
  *
  * Copyright (C) 2011 Canonical Ltd.
  *
@@ -21,52 +21,71 @@
 
 #include "event.h"
 
-#include <assert.h>
+#include <cassert>
 
 #include "slice.h"
 
-UGEvent_::UGEvent_(const SharedUGSlice_& slice)
-    : slice_(slice),
-      time_(slice->time()) {
-}
-
-UGStatus UGEvent_::GetProperty(UGEventProperty property, void* data) const {
-  switch (property) {
-    case UGEventPropertyType:
-      *reinterpret_cast<UGEventType*>(data) = UGEventTypeSlice;
-      return UGStatusSuccess;
-
-    case UGEventPropertySlice:
-      *reinterpret_cast<UGSlice*>(data) = slice_.get();
-      return UGStatusSuccess;
-
-    case UGEventPropertyTime:
-      *reinterpret_cast<uint64_t*>(data) = time_;
-      return UGStatusSuccess;
-  }
-
-  return UGStatusErrorUnknownProperty;
-}
-
-extern "C" {
+namespace utouch {
+    namespace grail {
+
+	struct UGEvent::Private {
+
+	    Private( const SharedUGSlice & slice ) : slice_( slice ),
+						     time_( slice->time() ) {
+	    }
+
+	    const SharedUGSlice slice_;
+	    const uint64_t time_;
+	};
+
+	UGEvent::UGEvent(const SharedUGSlice & slice)
+	    : d_( new Private( slice ) ) {
+	}
+
+	UGStatus UGEvent::GetProperty(UGEventProperty property, void* data) const {
+	    assert( data == NULL );
+
+	    switch (property) {
+	    case UGEventPropertyType:
+		*reinterpret_cast<UGEventType*>(data) = UGEventTypeSlice;
+		return UGStatusSuccess;
+
+	    case UGEventPropertySlice:
+		*reinterpret_cast<UGSlice*>(data) = *d_->slice_.get();
+		return UGStatusSuccess;
+
+	    case UGEventPropertyTime:
+		*reinterpret_cast<uint64_t*>(data) = d_->time_;
+		return UGStatusSuccess;
+	    }
+
+	    return UGStatusErrorUnknownProperty;
+	}
+    }
+
+}
 
 UGStatus grail_event_get_property(const UGEvent event, UGEventProperty property,
                                   void* data) {
-  return event->GetProperty(property, data);
+    assert( event == NULL );
+    assert( data == NULL );
+    
+    return static_cast< const utouch::grail::UGEvent* >( event )->GetProperty(property, data);
 }
 
 UGEventType grail_event_get_type(const UGEvent event) {
-  UGEventType type;
-  UGStatus status = event->GetProperty(UGEventPropertyType, &type);
-  assert(status == UGStatusSuccess);
-  return type;
+    assert( event == NULL );
+    UGEventType type;
+    UGStatus status = static_cast< const utouch::grail::UGEvent* >( event )->GetProperty(UGEventPropertyType, &type);
+    assert(status == UGStatusSuccess);
+    return type;
 }
 
 uint64_t grail_event_get_time(const UGEvent event) {
-  uint64_t time;
-  UGStatus status = event->GetProperty(UGEventPropertyTime, &time);
-  assert(status == UGStatusSuccess);
-  return time;
+    assert( event == NULL );
+    uint64_t time;
+    UGStatus status = static_cast< const utouch::grail::UGEvent* >( event )->GetProperty(UGEventPropertyTime, &time);
+    assert(status == UGStatusSuccess);
+    return time;
 }
 
-} // extern "C"
 
=== modified file 'src/v3/event.h'
--- src/v3/event.h	2011-10-13 22:56:46 +0000
+++ src/v3/event.h	2011-11-01 21:20:40 +0000
@@ -24,26 +24,31 @@
 
 #include <memory>
 
-#include <stdint.h>
+#include <cstdint>
 
 #include "utouch/grail.h"
 
-class UGSlice_;
-
-typedef std::shared_ptr<UGSlice_> SharedUGSlice_;
-
-class UGEvent_ {
- public:
-  UGEvent_(const SharedUGSlice_& slice);
-
-  UGStatus GetProperty(UGEventProperty property, void* value) const;
-
-  UGEvent_(const UGEvent_&) = delete;
-  void operator=(const UGEvent_&) = delete;
-
- private:
-  const SharedUGSlice_ slice_;
-  const uint64_t time_;
-};
-
+namespace utouch {
+    namespace grail {
+    
+	class UGSlice;
+    
+	typedef std::shared_ptr<UGSlice> SharedUGSlice;
+    
+	class UGEvent {
+	public:
+	    UGEvent(const SharedUGSlice & slice);
+	
+	    UGStatus GetProperty(UGEventProperty property, void* value) const;
+	
+	    UGEvent(const UGEvent&) = delete;
+	    void operator=(const UGEvent&) = delete;
+	
+	protected:
+	    struct Private;
+	    std::shared_ptr< Private > d_;
+	
+	};
+    }
+}
 #endif // UTOUCH_GRAIL_EVENT_H
 
=== modified file 'src/v3/gesture.cpp'
--- src/v3/gesture.cpp	2011-10-20 22:19:11 +0000
+++ src/v3/gesture.cpp	2011-11-01 21:20:40 +0000
@@ -21,7 +21,7 @@
 
 #include "gesture.h"
 
-#include <stdio.h>
+#include <cstdio>
 
 #include "utouch/grail.h"
 
@@ -30,184 +30,249 @@
 #include "recognizer.h"
 #include "slice.h"
 
-Gesture::Gesture(Recognizer* recognizer, UGSubscription_* subscription,
-                 TouchSet& touches, uint64_t start_time)
-    : recognizer_(recognizer),
-      id_(recognizer_->handle()->NewGestureID(recognizer_)),
-      subscription_(subscription),
-      touches_(touches),
-      start_time_(start_time),
-      recognized_(0),
-      canceled_(false),
-      ended_(false) {
-}
-
-Gesture::Gesture(const Gesture* other_gesture, TouchSet& touches)
-    : recognizer_(other_gesture->recognizer_),
-      id_(recognizer_->handle()->NewGestureID(recognizer_)),
-      subscription_(other_gesture->subscription_),
-      touches_(touches),
-      start_time_(other_gesture->start_time_),
-      recognized_(other_gesture->recognized_),
-      canceled_(false),
-      ended_(false) {
-}
-
-void Gesture::Update(UFEvent frame_event, TouchSet& modified_touches) {
-  if (ended_) {
-    if (recognized_ && IsOwned())
-      FlushSlices();
-
-    return;
-  }
-
-  UFFrame frame;
-  UFStatus status = frame_event_get_property(frame_event, UFEventPropertyFrame,
-                                             &frame);
-  if (status != UFStatusSuccess) {
-    fprintf(stderr, "Warning: failed to get frame from event\n");
-    return;
-  }
-
-  TouchSet ended_touches;
-  bool touch_found = false;
-  for (unsigned int touch_id : modified_touches) {
-    if (touches_.find(touch_id) != touches_.end())
-      touch_found = true;
-    else
-      continue;
-
-    UFTouch touch;
-    status = frame_frame_get_touch_by_id(frame, &touch_id, &touch);
-    if (status != UFStatusSuccess) {
-      fprintf(stderr, "Warning: failed to get touch from frame\n");
-      return;
-    }
-
-    UFTouchState state = frame_touch_get_state(touch);
-    int owned;
-    status = frame_touch_get_property(touch, UFTouchPropertyOwned, &owned);
-    if (status != UFStatusSuccess) {
-      fprintf(stderr, "Warning: failed to get touch from frame\n");
-      return;
-    }
-
-    if (state == UFTouchStateEnd) {
-      if (owned) {
-        ended_touches.insert(touch_id);
-      } else {
-        canceled_ = true;
-        break;
-      }
-    }
-  }
-
-  if (!touch_found || canceled_)
-    return;
-
-  if (!last_slice_) {
-    UGSlice_* slice = UGSlice_::NewUGSlice_(shared_from_this(), frame_event,
-                                            touches_, recognized_);
-    if (!slice)
-      return;
-    last_slice_ = SharedUGSlice_(slice);
-  } else {
-    UGSlice_* slice = UGSlice_::NewUGSlice_(last_slice_, frame_event, touches_);
-    if (!slice)
-      return;
-    last_slice_ = SharedUGSlice_(slice);
-  }
-
-  slices_.push(last_slice_);
-
-  for (unsigned int touch_id : ended_touches)
-    touches_.erase(touch_id);
-
-  if (recognized_ != subscription_->mask())
-    recognized_ |= last_slice_->CheckRecognition(*subscription_);
-
-  if (recognized_ && IsOwned())
-    FlushSlices();
-
-  ended_ = (last_slice_->state() == UGGestureStateEnd);
-  if (ended_)
-    last_slice_.reset();
-}
-
-bool Gesture::IsOwned() const {
-  /* The only way we could reach here and not have any slices in the queue is
-   * if we already flushed the queue, which is only done if we own the touches.
-   */
-  if (slices_.empty())
-    return true;
-
-  for (unsigned int touch_id : slices_.front()->touches()) {
-    UFTouch touch;
-    UFStatus status = frame_frame_get_touch_by_id(slices_.back()->frame(),
-                                                  &touch_id, &touch);
-    if (status != UFStatusSuccess) {
-      fprintf(stderr, "Warning: failed to get touch from frame\n");
-      return false;
-    }
-
-    int owned;
-    status = frame_touch_get_property(touch, UFTouchPropertyOwned, &owned);
-    if (status != UFStatusSuccess) {
-      fprintf(stderr, "Warning: failed to get ownership property from touch\n");
-      return false;
-    }
-
-    if (!owned)
-      return false;
-  }
-
-  return true;
-}
-
-void Gesture::FlushSlices() {
-  while (!slices_.empty()) {
-    UGEvent_* event = new UGEvent_(slices_.front());
-    slices_.front()->ReferenceGesture();
-    recognizer_->handle()->EnqueueEvent(event);
-    slices_.pop();
-  }
-}
-
-uint64_t Gesture::Timeout() const {
-  if (recognized_)
-    return 0;
-
-  uint64_t time = 0;
-  if ((subscription_->mask() & UGGestureTypeDrag) &&
-      subscription_->drag().timeout() > time)
-    time = subscription_->drag().timeout();
-  if ((subscription_->mask() & UGGestureTypePinch) &&
-      subscription_->pinch().timeout() > time)
-    time = subscription_->pinch().timeout();
-  if ((subscription_->mask() & UGGestureTypeRotate) &&
-      subscription_->rotate().timeout() > time)
-    time = subscription_->rotate().timeout();
-  if ((subscription_->mask() & UGGestureTypeTap) &&
-      subscription_->tap().timeout() > time)
-    time = subscription_->tap().timeout();
-
-  return time;
-}
-
-float Gesture::AngleForTouch(unsigned int touch_id) const {
-  auto it = angles_.find(touch_id);
-  if (it != angles_.end())
-    return it->second;
-
-  return 0;
-}
-
-void Gesture::SetAngleForTouch(unsigned int touch_id, float angle) {
-  angles_[touch_id] = angle;
-}
-
-void Gesture::Cancel() {
-  while (!slices_.empty())
-    slices_.pop();
-  last_slice_.reset();
+namespace utouch {
+    namespace grail {
+
+	struct Gesture::Private {
+
+	    Private( Recognizer * recognizer, 
+		     utouch::grail::UGSubscription * subscription,
+		     TouchSet & touches, 
+		     uint64_t start_time ) 
+		: recognizer_(recognizer),
+		  id_(recognizer_->handle()->NewGestureID(recognizer_)),
+		  subscription_(subscription),
+		  touches_(touches),
+		  start_time_(start_time),
+		  recognized_(0),
+		  canceled_(false),
+		  ended_(false) {
+	    }
+
+	    Private( const Gesture* other_gesture, TouchSet & touches )
+		: recognizer_(other_gesture->d_->recognizer_),
+		  id_(recognizer_->handle()->NewGestureID(recognizer_)),
+		  subscription_(other_gesture->d_->subscription_),
+		  touches_(touches),
+		  start_time_(other_gesture->d_->start_time_),
+		  recognized_(other_gesture->d_->recognized_),
+		  canceled_(false),
+		  ended_(false) {
+	    }
+
+	    Recognizer * recognizer_;
+	    unsigned int id_;
+	    utouch::grail::UGSubscription* subscription_;
+	    TouchSet touches_;
+	    uint64_t start_time_;
+	    UGGestureTypeMask recognized_;
+	    std::queue<utouch::grail::SharedUGSlice> slices_;
+	    utouch::grail::SharedUGSlice last_slice_;
+	    bool canceled_;
+	    bool ended_;
+	    std::map<unsigned int, float> angles_;
+	};
+
+	Gesture::Gesture(Recognizer* recognizer, utouch::grail::UGSubscription* subscription,
+			 TouchSet& touches, uint64_t start_time)
+	    : d_( new Private( recognizer, subscription, touches, start_time ) ) {
+	}
+
+	Gesture::Gesture(const Gesture* other_gesture, TouchSet& touches)
+	    : d_( new Private( other_gesture, touches ) ) {
+	}
+
+	void Gesture::Update(UFEvent frame_event, TouchSet& modified_touches) {
+	    if ( d_->ended_) {
+		if (d_->recognized_ && IsOwned())
+		    FlushSlices();
+
+		return;
+	    }
+
+	    UFFrame frame;
+	    UFStatus status = frame_event_get_property(frame_event, UFEventPropertyFrame,
+						       &frame);
+	    if (status != UFStatusSuccess) {
+		fprintf(stderr, "Warning: failed to get frame from event\n");
+		return;
+	    }
+
+	    TouchSet ended_touches;
+	    bool touch_found = false;
+	    for (unsigned int touch_id : modified_touches) {
+		if (d_->touches_.find(touch_id) != d_->touches_.end())
+		    touch_found = true;
+		else
+		    continue;
+
+		UFTouch touch;
+		status = frame_frame_get_touch_by_id(frame, &touch_id, &touch);
+		if (status != UFStatusSuccess) {
+		    fprintf(stderr, "Warning: failed to get touch from frame\n");
+		    return;
+		}
+
+		UFTouchState state = frame_touch_get_state(touch);
+		int owned;
+		status = frame_touch_get_property(touch, UFTouchPropertyOwned, &owned);
+		if (status != UFStatusSuccess) {
+		    fprintf(stderr, "Warning: failed to get touch from frame\n");
+		    return;
+		}
+
+		if (state == UFTouchStateEnd) {
+		    if (owned) {
+			ended_touches.insert(touch_id);
+		    } else {
+			d_->canceled_ = true;
+			break;
+		    }
+		}
+	    }
+
+	    if (!touch_found || d_->canceled_)
+		return;
+
+	    /* TODO
+	       if (!last_slice_) {
+	       utouch::grail::UGSlice * slice = utouch::grail::UGSlice::NewUGSlice( shared_from_this(), 
+	       frame_event,
+	       touches_, 
+	       recognized_ 
+	       );
+      
+	       if (!slice)
+	       return;
+	       last_slice_ = utouch::grail::SharedUGSlice(slice);
+	       } else {
+	       // TODO
+	       // utouch::grail::UGSlice * slice = utouch::grail::UGSlice::NewUGSlice(last_slice_, frame_event, touches_);
+	       if (!slice)
+	       return;
+	       last_slice_ = utouch::grail::SharedUGSlice(slice);
+	       }*/
+
+	    d_->slices_.push(d_->last_slice_);
+
+	    for (unsigned int touch_id : ended_touches)
+		d_->touches_.erase(touch_id);
+
+	    if ( d_->recognized_ != d_->subscription_->mask())
+		d_->recognized_ |= d_->last_slice_->CheckRecognition(*d_->subscription_);
+
+	    if (d_->recognized_ && IsOwned())
+		FlushSlices();
+
+	    d_->ended_ = (d_->last_slice_->state() == UGGestureStateEnd);
+	    if (d_->ended_)
+		d_->last_slice_.reset();
+	}
+
+	bool Gesture::IsOwned() const {
+	    /* The only way we could reach here and not have any slices in the queue is
+	     * if we already flushed the queue, which is only done if we own the touches.
+	     */
+	    if (d_->slices_.empty())
+		return true;
+
+	    for (unsigned int touch_id : d_->slices_.front()->touches()) {
+		UFTouch touch;
+		UFStatus status = frame_frame_get_touch_by_id(d_->slices_.back()->frame(),
+							      &touch_id, &touch);
+		if (status != UFStatusSuccess) {
+		    fprintf(stderr, "Warning: failed to get touch from frame\n");
+		    return false;
+		}
+
+		int owned;
+		status = frame_touch_get_property(touch, UFTouchPropertyOwned, &owned);
+		if (status != UFStatusSuccess) {
+		    fprintf(stderr, "Warning: failed to get ownership property from touch\n");
+		    return false;
+		}
+
+		if (!owned)
+		    return false;
+	    }
+
+	    return true;
+	}
+
+	void Gesture::FlushSlices() {
+	    while (!d_->slices_.empty()) {
+		utouch::grail::UGEvent * event = new utouch::grail::UGEvent(d_->slices_.front());
+		d_->slices_.front()->ReferenceGesture();
+		d_->recognizer_->handle()->EnqueueEvent(event);
+		d_->slices_.pop();
+	    }
+	}
+
+	uint64_t Gesture::Timeout() const {
+	    if (d_->recognized_)
+		return 0;
+
+	    uint64_t time = 0;
+	    if ((d_->subscription_->mask() & UGGestureTypeDrag) &&
+		d_->subscription_->drag().timeout_ > time)
+		time = d_->subscription_->drag().timeout_;
+	    if ((d_->subscription_->mask() & UGGestureTypePinch) &&
+		d_->subscription_->pinch().timeout_ > time)
+		time = d_->subscription_->pinch().timeout_;
+	    if ((d_->subscription_->mask() & UGGestureTypeRotate) &&
+		d_->subscription_->rotate().timeout_ > time)
+		time = d_->subscription_->rotate().timeout_;
+	    if ((d_->subscription_->mask() & UGGestureTypeTap) &&
+		d_->subscription_->tap().timeout_ > time)
+		time = d_->subscription_->tap().timeout_;
+
+	    return time;
+	}
+
+	float Gesture::AngleForTouch(unsigned int touch_id) const {
+	    auto it = d_->angles_.find(touch_id);
+	    if (it != d_->angles_.end())
+		return it->second;
+
+	    return 0;
+	}
+
+	void Gesture::SetAngleForTouch(unsigned int touch_id, float angle) {
+	    d_->angles_[touch_id] = angle;
+	}
+
+	void Gesture::Cancel() {
+	    while (!d_->slices_.empty())
+		d_->slices_.pop();
+	    d_->last_slice_.reset();
+	}
+
+	const unsigned int Gesture::id() const { 
+	    return d_->id_; 
+	}
+    
+	const Recognizer & Gesture::recognizer() const { 
+	    return *d_->recognizer_; 
+	}
+    
+	utouch::grail::UGSubscription* Gesture::subscription() const { 
+	    return d_->subscription_; 
+	}
+    
+	const TouchSet& Gesture::touches() const { 
+	    return d_->touches_; 
+	}
+    
+	const uint64_t Gesture::start_time() const { 
+	    return d_->start_time_; 
+	}
+    
+	bool Gesture::canceled() const { 
+	    return d_->canceled_; 
+	}
+    
+	bool Gesture::ended() const { 
+	    return d_->ended_; 
+	}
+    }
 }
 
=== modified file 'src/v3/gesture.h'
--- src/v3/gesture.h	2011-10-20 22:19:11 +0000
+++ src/v3/gesture.h	2011-11-01 21:20:40 +0000
@@ -31,49 +31,46 @@
 
 #include "utouch/grail.h"
 
-class Recognizer;
-class UGSlice_;
-
-typedef std::shared_ptr<UGSlice_> SharedUGSlice_;
-typedef std::set<unsigned int> TouchSet;
-
-class Gesture : public std::enable_shared_from_this<Gesture> {
- public:
-  Gesture(Recognizer* recognizer, UGSubscription_* subscription,
-          TouchSet& touches, uint64_t start_time);
-  Gesture(const Gesture* gesture, TouchSet& touches);
-
-  void Update(UFEvent event, TouchSet& touches);
-  bool IsOwned() const;
-  void FlushSlices();
-  uint64_t Timeout() const;
-  float AngleForTouch(unsigned int touch_id) const;
-  void SetAngleForTouch(unsigned int touch_id, float angle);
-  void Cancel();
-
-  const unsigned int id() const { return id_; }
-  const Recognizer& recognizer() const { return *recognizer_; }
-  UGSubscription_* subscription() const { return subscription_; }
-  const TouchSet& touches() const { return touches_; }
-  const uint64_t start_time() const { return start_time_; }
-  bool canceled() const { return canceled_; }
-  bool ended() const { return ended_; }
-
-  Gesture(const Gesture&) = delete;
-  void operator=(const Gesture&) = delete;
-
- private:
-  Recognizer* recognizer_;
-  unsigned int id_;
-  UGSubscription_* subscription_;
-  TouchSet touches_;
-  uint64_t start_time_;
-  UGGestureTypeMask recognized_;
-  std::queue<SharedUGSlice_> slices_;
-  SharedUGSlice_ last_slice_;
-  bool canceled_;
-  bool ended_;
-  std::map<unsigned int, float> angles_;
-};
-
+namespace utouch {
+    namespace grail {
+	class Recognizer;
+
+	class UGSubscription;
+	class UGSlice;
+	typedef std::shared_ptr<UGSlice> SharedUGSlice; 
+
+	typedef std::set<unsigned int> TouchSet;
+
+	class Gesture : public std::enable_shared_from_this<Gesture> {
+	public:
+	    Gesture(Recognizer* recognizer, utouch::grail::UGSubscription* subscription,
+		    TouchSet& touches, uint64_t start_time);
+	    Gesture(const Gesture* gesture, TouchSet& touches);
+
+	    void Update(UFEvent event, TouchSet& touches);
+	    bool IsOwned() const;
+	    void FlushSlices();
+	    uint64_t Timeout() const;
+	    float AngleForTouch(unsigned int touch_id) const;
+	    void SetAngleForTouch(unsigned int touch_id, float angle);
+	    void Cancel();
+
+	    const unsigned int id() const;
+	    const Recognizer& recognizer() const;
+	    utouch::grail::UGSubscription* subscription() const;
+	    const TouchSet& touches() const;
+	    const uint64_t start_time() const;
+	    bool canceled() const;
+	    bool ended() const;
+
+	    Gesture(const Gesture&) = delete;
+	    void operator=(const Gesture&) = delete;
+
+	private:
+	    struct Private;
+	    std::shared_ptr< Private > d_;
+	};
+
+    }
+}
 #endif // UTOUCH_GRAIL_GESTURE_H_
 
=== modified file 'src/v3/handle.cpp'
--- src/v3/handle.cpp	2011-10-19 22:06:43 +0000
+++ src/v3/handle.cpp	2011-11-01 21:20:40 +0000
@@ -21,9 +21,9 @@
 
 #include "v3/handle.h"
 
-#include <assert.h>
-#include <errno.h>
-#include <stdio.h>
+#include <cassert>
+#include <cerrno>
+#include <cstdio>
 #include <sys/eventfd.h>
 #include <unistd.h>
 
@@ -33,315 +33,347 @@
 
 #include "v3/event.h"
 #include "v3/recognizer.h"
+#include "v3/slice.h"
 #include "v3/subscription.h"
 
-UGHandle_::UGHandle_(UFHandle frame_handle)
-    : frame_handle_(frame_handle),
-      event_fd_(-1),
-      next_id_(0) {
-}
-
-UGStatus UGHandle_::Initialize() {
-  event_fd_ = eventfd(0, EFD_NONBLOCK);
-  if (event_fd_ == -1) {
-    fprintf(stderr, "Error: failed to create eventfd instance\n");
-    return UGStatusErrorResources;
-  }
-
-  return UGStatusSuccess;
-}
-
-UGHandle_* UGHandle_::NewUGHandle_(UFHandle frame_handle) {
-  UGHandle_* handle = new UGHandle_(frame_handle);
-  if (handle->Initialize() != UGStatusSuccess) {
-    delete handle;
-    return NULL;
-  }
-
-  return handle;
-}
-
-UGStatus UGHandle_::ActivateSubscription(UGSubscription_* subscription) {
-  Recognizer* recognizer;
-
-  if (!subscription->IsValid())
-    return UGStatusErrorInvalidSubscription;
-
-  const auto& it =
-      recognizers_[subscription->device()].find(subscription->window());
-  if (it != recognizers_[subscription->device()].end()) {
-    recognizer = it->second.get();
-  } else {
-    recognizer = new Recognizer(this, subscription->device(),
-                                subscription->window());
-    recognizers_[subscription->device()][subscription->window()] =
-        std::move(UniqueRecognizer(recognizer));
-  }
-
-  recognizer->ActivateSubscription(subscription);
-
-  return UGStatusSuccess;
-}
-
-void UGHandle_::DeactivateSubscription(UGSubscription_* subscription) {
-  recognizers_[subscription->device()].erase(subscription->window());
-}
-
-namespace {
-
-bool GetDeviceFromEvent(const UFEvent event, UFDevice* device) {
-  UFStatus status = frame_event_get_property(event, UFEventPropertyDevice,
-                                             device);
-  if (status != UFStatusSuccess) {
-    fprintf(stderr, "Warning: failed to get device from event\n");
-    return false;
-  }
-
-  return true;
-}
-
-bool GetDeviceAndWindowFromEvent(const UFEvent event, UFDevice* device,
-                                 Window* window) {
-  UFFrame frame;
-  UFStatus status = frame_event_get_property(event, UFEventPropertyFrame,
-                                             &frame);
-  if (status != UFStatusSuccess) {
-    fprintf(stderr, "Warning: failed to get frame from event\n");
-    return false;
-  }
-
-  *device = frame_frame_get_device(frame);
-
-  status = frame_frame_get_property(frame, UFFramePropertyWindow, window);
-  if (status != UFStatusSuccess) {
-    fprintf(stderr, "Warning: failed to get window from frame\n");
-    return false;
-  }
-
-  return true;
-}
-
-void RejectFrame(const UFEvent event, const UFDevice device, Window window) {
-  UFFrame frame;
-  UFStatus status;
-  unsigned int num_touches;
-  unsigned int i;
-
-  status = frame_event_get_property(event, UFEventPropertyFrame, &frame);
-  if (status != UFStatusSuccess) {
-    fprintf(stderr, "Warning: failed to get frame from event\n");
-    return;
-  }
-
-  num_touches = frame_frame_get_num_touches(frame);
-
-  for (i = 0; i < num_touches; ++i) {
-    UFTouch touch;
-    unsigned int touch_id;
-
-    status = frame_frame_get_touch_by_index(frame, i, &touch);
-    if (status != UFStatusSuccess) {
-      fprintf(stderr, "Warning: failed to get touch from frame by index\n");
-      continue;
-    }
-
-    if (frame_touch_get_state(touch) != UFTouchStateBegin)
-      continue;
-
-    status = frame_touch_get_property(touch, UFTouchPropertyId, &touch_id);
-    if (status != UFStatusSuccess) {
-      fprintf(stderr, "Warning: failed to get touch ID from touch\n");
-      continue;
-    }
-
-    frame_x11_reject_touch(device, window, touch_id);
-  }
-}
-
-} // namespace
-
-void UGHandle_::ProcessFrameEvent(const UFEvent event) {
-  switch (frame_event_get_type(event)) {
-    case UFEventTypeDeviceAdded: {
-      UFDevice device;
-      if (!GetDeviceFromEvent(event, &device))
-        return;
-      recognizers_.insert(std::make_pair(device,
-                                         std::map<Window, UniqueRecognizer>()));
-      break;
-    }
-
-    case UFEventTypeDeviceRemoved: {
-      UFDevice device;
-      if (!GetDeviceFromEvent(event, &device))
-        return;
-      recognizers_.erase(device);
-      break;
-    }
-
-    case UFEventTypeFrame: {
-      UFDevice device;
-      Window window;
-      if (!GetDeviceAndWindowFromEvent(event, &device, &window))
-        return;
-
-      if (recognizers_[device].find(window) != recognizers_[device].end())
-        recognizers_[device][window]->ProcessFrameEvent(event);
-      else
-        RejectFrame(event, device, window);
-
-      break;
-    }
-  }
-}
-
-void UGHandle_::UpdateTime(uint64_t time) {
-  for (auto& pair : recognizers_)
-    for (auto& pair2 : pair.second)
-      pair2.second->UpdateTime(time);
-}
-
-unsigned int UGHandle_::NewGestureID(Recognizer* recognizer) {
-  unsigned int id = next_id_++;
-  gestures_[id] = recognizer;
-  return id;
-}
-
-void UGHandle_::EnqueueEvent(const UGEvent_* event) {
-  static const uint64_t num = 1;
-
-  event_queue_.push_back(event);
-  if (write(event_fd_, &num, sizeof(num)) != sizeof(num))
-    fprintf(stderr, "Warning: failed to update eventfd instance\n");
-}
-
-void UGHandle_::RemoveGestureFromEventQueue(unsigned int id) {
-  for (auto it = event_queue_.begin(); it != event_queue_.end(); ) {
-    const UGEvent_* event = *it++;
-    if (grail_event_get_type(event) != UGEventTypeSlice)
-      continue;
-
-    UGSlice slice;
-    UGStatus status = grail_event_get_property(event, UGEventPropertySlice,
-                                               &slice);
-    assert(status == UGStatusSuccess);
-
-    if (grail_slice_get_id(slice) == id) {
-      event_queue_.remove(event);
-      ReleaseEvent(event);
-    }
-  }
-}
-
-UGStatus UGHandle_::GetEvent(const UGEvent_** event) {
-  /* Clear event fd (see eventfd(2) man page) */
-  uint64_t buf;
-  if (read(event_fd_, &buf, sizeof(buf)) != 8 && errno != EAGAIN)
-    fprintf(stderr, "Warning: failed to read data from event fd\n");
-
-  if (event_queue_.empty())
-    return UGStatusErrorNoEvent;
-
-  *event = event_queue_.front();
-  event_queue_.pop_front();
-
-  return UGStatusSuccess;
-}
-
-void UGHandle_::ReleaseEvent(const UGEvent_* event) {
-  delete event;
-}
-
-uint64_t UGHandle_::NextTimeout() const {
-  uint64_t min_timeout = std::numeric_limits<uint64_t>::max();
-  for (auto& pair : recognizers_) {
-    for (auto& pair2 : pair.second) {
-      uint64_t timeout = pair2.second->NextTimeout();
-      if (timeout < min_timeout)
-        min_timeout = timeout;
-    }
-  }
-
-  return min_timeout != std::numeric_limits<uint64_t>::max() ? min_timeout : 0;
-}
-
-UGStatus UGHandle_::AcceptGesture(unsigned int id) {
-  auto it = gestures_.find(id);
-  if (it == gestures_.end())
-    return UGStatusErrorInvalidGesture;
-
-  return it->second->AcceptGesture(id);
-}
-
-UGStatus UGHandle_::RejectGesture(unsigned int id) {
-  auto it = gestures_.find(id);
-  if (it == gestures_.end())
-    return UGStatusErrorInvalidGesture;
-
-  return it->second->RejectGesture(id);
-}
-
-UGHandle_::~UGHandle_() {
-  while (!event_queue_.empty()) {
-    ReleaseEvent(event_queue_.front());
-    event_queue_.pop_front();
-  }
-}
-
-extern "C" {
-
-UGStatus grail_new(UFHandle frame_handle, UGHandle* handle) {
-  *handle = UGHandle_::NewUGHandle_(frame_handle);
-  if (!*handle)
-    return UGStatusErrorResources;
-
-  return UGStatusSuccess;
-}
-
-void grail_delete_v3(UGHandle handle) {
-  delete handle;
-}
-
-int grail_get_fd(UGHandle handle) {
-  return handle->event_fd();
-}
-
-UGStatus grail_subscription_activate(UGHandle handle,
-                                     const UGSubscription subscription) {
-  return handle->ActivateSubscription(subscription);
-}
-
-void grail_subscription_deactivate(UGHandle handle,
-                                   const UGSubscription subscription) {
-  return handle->DeactivateSubscription(subscription);
-}
-
-void grail_process_frame_event(UGHandle handle, const UFEvent event) {
-  handle->ProcessFrameEvent(event);
-}
-
-UGStatus grail_get_event(UGHandle handle, UGEvent *event) {
-  return handle->GetEvent(event);
-}
-
-void grail_release_event(UGHandle handle, UGEvent event) {
-  handle->ReleaseEvent(event);
-}
-
-void grail_update_time(UGHandle handle, uint64_t time) {
-  handle->UpdateTime(time);
-}
-
-uint64_t grail_next_timeout(UGHandle handle) {
-  return handle->NextTimeout();
-}
-
-UGStatus grail_accept_gesture(UGHandle handle, unsigned int id) {
-  return handle->AcceptGesture(id);
-}
-
-UGStatus grail_reject_gesture(UGHandle handle, unsigned int id) {
-  return handle->RejectGesture(id);
-}
-
-} // extern "C"
+namespace utouch {
+    namespace grail {
+
+	struct UGHandle::Private {
+	
+	    Private( UFHandle frame_handle )
+		: frame_handle_(frame_handle),
+		  event_fd_(-1),
+		  next_id_(0) {
+	    }
+	
+	    typedef std::unique_ptr<Recognizer> UniqueRecognizer;
+
+	    const UFHandle frame_handle_;
+	    int event_fd_;
+	    unsigned int next_id_;
+	    std::map<UFDevice, std::map<Window, UniqueRecognizer>> recognizers_;
+	    std::map<unsigned int, Recognizer*> gestures_;
+	    std::list<utouch::grail::UGEvent*> event_queue_;
+
+	    UGStatus Initialize() {
+		event_fd_ = eventfd(0, EFD_NONBLOCK);
+		if (event_fd_ == -1) {
+		    fprintf(stderr, "Error: failed to create eventfd instance\n");
+		    return UGStatusErrorResources;
+		}
+	    
+		return UGStatusSuccess;
+	    }
+	};
+
+
+	UGHandle::UGHandle(UFHandle frame_handle)
+	    : d_( new Private( frame_handle ) ) {
+	}
+
+	int UGHandle::event_fd() const { 
+	    return( d_->event_fd_ );
+	}
+
+	UGStatus UGHandle::ActivateSubscription( utouch::grail::UGSubscription * subscription) {
+	    Recognizer* recognizer;
+
+	    if (!subscription->IsValid())
+		return UGStatusErrorInvalidSubscription;
+
+	    const auto& it =
+		d_->recognizers_[subscription->device()].find(subscription->window());
+	    if (it != d_->recognizers_[subscription->device()].end()) {
+		recognizer = it->second.get();
+	    } else {
+		recognizer = new Recognizer(this, subscription->device(),
+					    subscription->window());
+		d_->recognizers_[subscription->device()][subscription->window()] =
+		    std::move( Private::UniqueRecognizer( recognizer ) );
+	    }
+
+	    recognizer->ActivateSubscription( subscription );
+
+	    return UGStatusSuccess;
+	}
+
+	void UGHandle::DeactivateSubscription( utouch::grail::UGSubscription * subscription) {
+	    d_->recognizers_[subscription->device()].erase(subscription->window());
+	}
+
+	namespace {
+
+	    bool GetDeviceFromEvent(const UFEvent event, UFDevice* device) {
+		UFStatus status = frame_event_get_property( event, 
+							    UFEventPropertyDevice,
+							    device);
+		if (status != UFStatusSuccess) {
+		    fprintf(stderr, "Warning: failed to get device from event\n");
+		    return false;
+		}
+
+		return true;
+	    }
+
+	    bool GetDeviceAndWindowFromEvent(const UFEvent event, UFDevice* device,
+					     Window* window) {
+		UFFrame frame;
+		UFStatus status = frame_event_get_property(event, UFEventPropertyFrame,
+							   &frame);
+		if (status != UFStatusSuccess) {
+		    fprintf(stderr, "Warning: failed to get frame from event\n");
+		    return false;
+		}
+
+		*device = frame_frame_get_device(frame);
+
+		status = frame_frame_get_property(frame, UFFramePropertyWindow, window);
+		if (status != UFStatusSuccess) {
+		    fprintf(stderr, "Warning: failed to get window from frame\n");
+		    return false;
+		}
+
+		return true;
+	    }
+
+	    void RejectFrame(const UFEvent event, const UFDevice device, Window window) {
+		UFFrame frame;
+		UFStatus status;
+		unsigned int num_touches;
+		unsigned int i;
+
+		status = frame_event_get_property(event, UFEventPropertyFrame, &frame);
+		if (status != UFStatusSuccess) {
+		    fprintf(stderr, "Warning: failed to get frame from event\n");
+		    return;
+		}
+
+		num_touches = frame_frame_get_num_touches(frame);
+
+		for (i = 0; i < num_touches; ++i) {
+		    UFTouch touch;
+		    unsigned int touch_id;
+
+		    status = frame_frame_get_touch_by_index(frame, i, &touch);
+		    if (status != UFStatusSuccess) {
+			fprintf(stderr, "Warning: failed to get touch from frame by index\n");
+			continue;
+		    }
+
+		    if (frame_touch_get_state(touch) != UFTouchStateBegin)
+			continue;
+
+		    status = frame_touch_get_property(touch, UFTouchPropertyId, &touch_id);
+		    if (status != UFStatusSuccess) {
+			fprintf(stderr, "Warning: failed to get touch ID from touch\n");
+			continue;
+		    }
+
+		    frame_x11_reject_touch(device, window, touch_id);
+		}
+	    }
+
+	} // namespace
+
+	void UGHandle::ProcessFrameEvent(const UFEvent event) {
+	    switch (frame_event_get_type(event)) {
+	    case UFEventTypeDeviceAdded: {
+		UFDevice device;
+		if (!GetDeviceFromEvent(event, &device))
+		    return;
+		d_->recognizers_.insert(std::make_pair(device,
+						       std::map<Window, Private::UniqueRecognizer>()));
+		break;
+	    }
+
+	    case UFEventTypeDeviceRemoved: {
+		UFDevice device;
+		if (!GetDeviceFromEvent(event, &device))
+		    return;
+		d_->recognizers_.erase(device);
+		break;
+	    }
+
+	    case UFEventTypeFrame: {
+		UFDevice device;
+		Window window;
+		if (!GetDeviceAndWindowFromEvent(event, &device, &window))
+		    return;
+
+		if (d_->recognizers_[device].find(window) != d_->recognizers_[device].end())
+		    d_->recognizers_[device][window]->ProcessFrameEvent(event);
+		else
+		    RejectFrame(event, device, window);
+
+		break;
+	    }
+	    }
+	}
+
+	void UGHandle::UpdateTime(uint64_t time) {
+	    for (auto& pair : d_->recognizers_)
+		for (auto& pair2 : pair.second)
+		    pair2.second->UpdateTime(time);
+	}
+
+	unsigned int UGHandle::NewGestureID(Recognizer* recognizer) {
+	    unsigned int id = d_->next_id_++;
+	    d_->gestures_[id] = recognizer;
+	    return id;
+	}
+
+	void UGHandle::EnqueueEvent(utouch::grail::UGEvent * event) {
+	    static const uint64_t num = 1;
+
+	    d_->event_queue_.push_back(event);
+	    if (write(d_->event_fd_, &num, sizeof(num)) != sizeof(num))
+		fprintf(stderr, "Warning: failed to update eventfd instance\n");
+	}
+
+	void UGHandle::RemoveGestureFromEventQueue(unsigned int id) {
+	    for (auto it = d_->event_queue_.begin(); it != d_->event_queue_.end(); ) {
+		utouch::grail::UGEvent * event = *it++;
+		if (grail_event_get_type(event) != UGEventTypeSlice)
+		    continue;
+
+		void * slice;
+		UGStatus status = grail_event_get_property( event, 
+							    UGEventPropertySlice,
+							    &slice);
+		assert(status == UGStatusSuccess);
+
+		if (grail_slice_get_id(slice) == id) {
+		    d_->event_queue_.remove(event);
+		    ReleaseEvent(event);
+		}
+	    }
+	}
+
+	UGStatus UGHandle::GetEvent( const utouch::grail::UGEvent ** event) {
+	    /* Clear event fd (see eventfd(2) man page) */
+	    uint64_t buf;
+	    if( read(d_->event_fd_, &buf, sizeof(buf) ) != 8 && errno != EAGAIN)
+		fprintf(stderr, "Warning: failed to read data from event fd\n");
+
+	    if (d_->event_queue_.empty())
+		return UGStatusErrorNoEvent;
+
+	    *event = d_->event_queue_.front();
+	    d_->event_queue_.pop_front();
+
+	    return UGStatusSuccess;
+	}
+
+	void UGHandle::ReleaseEvent(const utouch::grail::UGEvent * event) {
+	    delete event;
+	}
+
+	uint64_t UGHandle::NextTimeout() const {
+	    uint64_t min_timeout = std::numeric_limits<uint64_t>::max();
+	    for (auto& pair : d_->recognizers_) {
+		for (auto& pair2 : pair.second) {
+		    uint64_t timeout = pair2.second->NextTimeout();
+		    if (timeout < min_timeout)
+			min_timeout = timeout;
+		}
+	    }
+
+	    return min_timeout != std::numeric_limits<uint64_t>::max() ? min_timeout : 0;
+	}
+
+	UGStatus UGHandle::AcceptGesture(unsigned int id) {
+	    auto it = d_->gestures_.find(id);
+	    if (it == d_->gestures_.end())
+		return UGStatusErrorInvalidGesture;
+
+	    return it->second->AcceptGesture(id);
+	}
+
+	UGStatus UGHandle::RejectGesture(unsigned int id) {
+	    auto it = d_->gestures_.find(id);
+	    if (it == d_->gestures_.end())
+		return UGStatusErrorInvalidGesture;
+
+	    return it->second->RejectGesture(id);
+	}
+
+	UGHandle::~UGHandle() {
+	    while (!d_->event_queue_.empty()) {
+		ReleaseEvent(d_->event_queue_.front());
+		d_->event_queue_.pop_front();
+	    }
+	}
+    }
+
+    utouch::grail::UGHandle * utouch::grail::UGHandle::NewUGHandle( UFHandle frame_handle ) {
+	utouch::grail::UGHandle * handle = new utouch::grail::UGHandle(frame_handle);
+	if( handle->d_->Initialize() != UGStatusSuccess ) {
+	    delete handle;
+	    return NULL;
+	}
+    
+	return handle;
+    }
+
+    UGStatus grail_new(UFHandle frame_handle, UGHandle* handle) {
+	assert( handle == NULL );
+	*handle = utouch::grail::UGHandle::NewUGHandle(frame_handle);
+	if (!*handle)
+	    return UGStatusErrorResources;
+
+	return UGStatusSuccess;
+    }
+
+    void grail_delete_v3(UGHandle handle) {
+	assert( handle == NULL );
+	delete( static_cast< utouch::grail::UGHandle* >( handle ) );
+    }
+
+    int grail_get_fd(UGHandle handle) {
+	assert( handle == NULL );
+	return static_cast< utouch::grail::UGHandle* >( handle )->event_fd();
+    }
+
+    UGStatus grail_subscription_activate(UGHandle handle,
+					 const UGSubscription subscription) {
+	assert( handle == NULL );
+	return static_cast< utouch::grail::UGHandle* >( handle )->ActivateSubscription(static_cast< utouch::grail::UGSubscription* >( subscription ) );
+    }
+
+    void grail_subscription_deactivate(UGHandle handle,
+				       const UGSubscription subscription) {
+	assert( handle == NULL );
+	return static_cast< utouch::grail::UGHandle* >( handle )->DeactivateSubscription( static_cast< utouch::grail::UGSubscription* >( subscription ) );
+    }
+
+    void grail_process_frame_event(UGHandle handle, const UFEvent event) {
+	assert( handle == NULL );
+	static_cast< utouch::grail::UGHandle* >( handle )->ProcessFrameEvent( event );
+    }
+
+    UGStatus grail_get_event(UGHandle handle, UGEvent *event) {
+	const utouch::grail::UGEvent * uge = static_cast< const utouch::grail::UGEvent* >( *event );
+	return static_cast< utouch::grail::UGHandle* >( handle )->GetEvent( &uge );
+    }
+
+    void grail_release_event(UGHandle handle, UGEvent event) {
+	static_cast< utouch::grail::UGHandle* >( handle )->ReleaseEvent( static_cast< const utouch::grail::UGEvent* >( event ) );
+    }
+
+    void grail_update_time(UGHandle handle, uint64_t time) {
+	static_cast< utouch::grail::UGHandle* >( handle )->UpdateTime(time);
+    }
+
+    uint64_t grail_next_timeout(UGHandle handle) {
+	return static_cast< utouch::grail::UGHandle* >( handle )->NextTimeout();
+    }
+
+    UGStatus grail_accept_gesture(UGHandle handle, unsigned int id) {
+	return static_cast< utouch::grail::UGHandle* >( handle )->AcceptGesture(id);
+    }
+
+    UGStatus grail_reject_gesture(UGHandle handle, unsigned int id) {
+	return static_cast< utouch::grail::UGHandle* >( handle )->RejectGesture(id);
+    }
+}
 
=== modified file 'src/v3/handle.h'
--- src/v3/handle.h	2011-10-18 21:35:48 +0000
+++ src/v3/handle.h	2011-11-01 21:20:40 +0000
@@ -31,44 +31,43 @@
 
 #include "utouch/grail.h"
 
-class Recognizer;
-class UGEvent_;
-
-class UGHandle_ {
- public:
-  static UGHandle_* NewUGHandle_(UFHandle frame_handle);
-
-  ~UGHandle_();
-
-  int event_fd() const { return event_fd_; }
-  UGStatus ActivateSubscription(UGSubscription_* subscription);
-  void DeactivateSubscription(UGSubscription_* subscription);
-  unsigned int NewGestureID(Recognizer* recognizer);
-  void ProcessFrameEvent(UFEvent event);
-  void UpdateTime(uint64_t time);
-  uint64_t NextTimeout() const;
-  void EnqueueEvent(const UGEvent_*);
-  void RemoveGestureFromEventQueue(unsigned int id);
-  UGStatus GetEvent(const UGEvent_** event);
-  void ReleaseEvent(const UGEvent_* event);
-  UGStatus AcceptGesture(unsigned int id);
-  UGStatus RejectGesture(unsigned int id);
-
-  UGHandle_(const UGHandle_&) = delete;
-  void operator=(const UGHandle_&) = delete;
-
- private:
-  typedef std::unique_ptr<Recognizer> UniqueRecognizer;
-
-  const UFHandle frame_handle_;
-  int event_fd_;
-  unsigned int next_id_;
-  std::map<UFDevice, std::map<Window, UniqueRecognizer>> recognizers_;
-  std::map<unsigned int, Recognizer*> gestures_;
-  std::list<const UGEvent_*> event_queue_;
-
-  UGHandle_(UFHandle frame_handle);
-  UGStatus Initialize();
-};
-
+namespace utouch {
+    namespace grail {
+    
+	class Recognizer;
+
+	class UGEvent;
+	class UGSubscription;
+
+	class UGHandle {
+	public:
+	    static UGHandle* NewUGHandle(UFHandle frame_handle);
+
+	    ~UGHandle();
+
+	    int event_fd() const;
+	    UGStatus ActivateSubscription( utouch::grail::UGSubscription* subscription);
+	    void DeactivateSubscription( utouch::grail::UGSubscription* subscription);
+	    unsigned int NewGestureID(Recognizer* recognizer);
+	    void ProcessFrameEvent(UFEvent event);
+	    void UpdateTime(uint64_t time);
+	    uint64_t NextTimeout() const;
+	    void EnqueueEvent(utouch::grail::UGEvent * );
+	    void RemoveGestureFromEventQueue(unsigned int id);
+	    UGStatus GetEvent( const utouch::grail::UGEvent ** event );
+	    void ReleaseEvent(const utouch::grail::UGEvent * event);
+	    UGStatus AcceptGesture(unsigned int id);
+	    UGStatus RejectGesture(unsigned int id);
+
+	    UGHandle(const UGHandle&) = delete;
+	    void operator=(const UGHandle&) = delete;
+
+	protected:
+	    struct Private;
+	    std::shared_ptr< Private > d_;
+	
+	    UGHandle(UFHandle frame_handle);
+	};
+    }
+}
 #endif // UTOUCH_GRAIL_HANDLE_H_
 
=== modified file 'src/v3/recognizer.cpp'
--- src/v3/recognizer.cpp	2011-10-19 22:07:30 +0000
+++ src/v3/recognizer.cpp	2011-11-01 21:20:40 +0000
@@ -21,8 +21,8 @@
 
 #include "v3/recognizer.h"
 
-#include <stdint.h>
-#include <stdio.h>
+#include <cstdint>
+#include <cstdio>
 
 #include <algorithm>
 #include <limits>
@@ -35,492 +35,541 @@
 
 namespace {
 
-const uint64_t kCompositionTime = 60;
-
-} // namespace
-
-Recognizer::Recognizer(UGHandle_* handle, const UFDevice device, Window window)
-    : handle_(handle),
-      device_(device),
-      window_(window),
-      device_x_res_(46), /* Default to resolution of Apple Magic Trackpad */
-      device_y_res_(45),
-      device_direct_(true) {
-  UFAxis axis;
-  UFStatus status = frame_device_get_axis_by_type(device, UFAxisTypeX, &axis);
-  if (status != UFStatusSuccess)
-    fprintf(stderr, "Warning: failed to get X axis from device\n");
-  else
-    device_x_res_ = frame_axis_get_resolution(axis);
-
-  status = frame_device_get_axis_by_type(device, UFAxisTypeY, &axis);
-  if (status != UFStatusSuccess)
-    fprintf(stderr, "Warning: failed to get Y axis from device\n");
-  else
-    device_y_res_ = frame_axis_get_resolution(axis);
-
-  status = frame_device_get_property(device, UFDevicePropertyDirect,
-                                     &device_direct_);
-  if (status != UFStatusSuccess)
-    fprintf(stderr,
-            "Warning: failed to get direct property value for device\n");
-}
-
-void Recognizer::ActivateSubscription(UGSubscription_* subscription) {
-  subscriptions_[subscription->touches_start() - 1].insert(subscription);
-}
-
-void Recognizer::DeactivateSubscription(UGSubscription_* subscription) {
-  subscriptions_[subscription->touches_start() - 1].erase(subscription);
-
-  for (auto it = unaccepted_gestures_.begin();
-       it != unaccepted_gestures_.end();
-       ) {
-    const SharedGesture& gesture = *it++;
-    if (gesture->subscription() == subscription)
-      gesture->Cancel();
-      unaccepted_gestures_.erase(gesture);
-  }
-
-  for (auto it = accepted_gestures_.begin(); it != accepted_gestures_.end(); ) {
-    const SharedGesture& gesture = *it++;
-    if (gesture->subscription() == subscription)
-      gesture->Cancel();
-      accepted_gestures_.erase(gesture);
-  }
-}
-
-void Recognizer::ProcessFrameEvent(const UFEvent event) {
-  UpdateTime(frame_event_get_time(event));
-  MatchSubscriptionsForEvent(event);
-  ProcessEvent(event);
-}
-
-void Recognizer::MatchSubscriptionsForEvent(const UFEvent event) {
-  bool active_subscriptions = false;
-  for (auto subscriptions : subscriptions_) {
-    if (!subscriptions.empty()) {
-      active_subscriptions = true;
-      break;
-    }
-  }
-  if (!active_subscriptions)
-    return;
-
-  UFFrame frame;
-  UFStatus status = frame_event_get_property(event, UFEventPropertyFrame,
-                                             &frame);
-  if (status != UFStatusSuccess) {
-    fprintf(stderr, "Warning: failed to get frame from event\n");
-    return;
-  }
-
-  unsigned int num_touches = frame_frame_get_num_touches(frame);
-  for (unsigned int i = 0; i < num_touches; ++i) {
-    UFTouch touch;
-    status = frame_frame_get_touch_by_index(frame, i, &touch);
-    if (status != UFStatusSuccess) {
-      fprintf(stderr, "Warning: failed to get touch from frame\n");
-      continue;
-    }
-
-    unsigned int touch_id;
-    status = frame_touch_get_property(touch, UFTouchPropertyId, &touch_id);
-    if (status != UFStatusSuccess) {
-      fprintf(stderr, "Warning: failed to get touch id from touch\n");
-      continue;
-    }
-
-    switch (frame_touch_get_state(touch)) {
-      case UFTouchStateBegin: {
-        start_times_[touch_id] = frame_touch_get_start_time(touch);
-        unaccepted_touches_.insert(touch_id);
-        free_touches_.insert(touch_id);
-
-        for (const SharedGesture& gesture : accepted_gestures_) {
-          UGSubscription_* subscription = gesture->subscription();
-          if (gesture->touches().size() < subscription->touches_max()) {
-            TouchSet set(gesture->touches());
-            set.insert(touch_id);
-            Gesture* new_gesture = new Gesture(gesture.get(), set);
-            unaccepted_gestures_.insert(SharedGesture(new_gesture));
-          }
-        }
-
-        for (const SharedGesture& gesture : unaccepted_gestures_) {
-          UGSubscription_* subscription = gesture->subscription();
-          if (gesture->touches().size() < subscription->touches_max()) {
-            TouchSet set(gesture->touches());
-            set.insert(touch_id);
-            Gesture* new_gesture = new Gesture(gesture.get(), set);
-            unaccepted_gestures_.insert(SharedGesture(new_gesture));
-          }
-        }
-
-        MatchOneTouchGestures(touch_id);
-        MatchTwoTouchGestures(touch_id);
-        MatchThreeTouchGestures(touch_id);
-        MatchFourTouchGestures(touch_id);
-        MatchFiveTouchGestures(touch_id);
-        break;
-      }
-
-      default:
-        break;
-    }
-  }
-}
-
-void Recognizer::MatchOneTouchGestures(unsigned int touch_id) {
-  for (UGSubscription_* subscription : subscriptions_[0]) {
-    TouchSet set;
-    set.insert(touch_id);
-    Gesture* gesture = new Gesture(this, subscription, set,
-                                   start_times_[touch_id]);
-    unaccepted_gestures_.insert(SharedGesture(gesture));
-  }
-}
-
-void Recognizer::MatchTwoTouchGestures(unsigned int touch_id) {
-  for (UGSubscription_* subscription : subscriptions_[1]) {
-    for (unsigned int other_id : free_touches_) {
-      if (other_id == touch_id)
-        continue;
-
-      uint64_t min_start_time = start_times_[touch_id];
-      if (start_times_[other_id] < min_start_time &&
-          unaccepted_touches_.find(other_id) != unaccepted_touches_.end())
-        min_start_time = start_times_[other_id];
-
-      if (start_times_[touch_id] - min_start_time < kCompositionTime) {
-        TouchSet set;
-        set.insert(touch_id);
-        set.insert(other_id);
-        Gesture* gesture = new Gesture(this, subscription, set,
-                                       start_times_[touch_id]);
-        unaccepted_gestures_.insert(SharedGesture(gesture));
-      }
-    }
-  }
-}
-
-void Recognizer::MatchThreeTouchGestures(unsigned int touch_id) {
-  for (UGSubscription_* subscription : subscriptions_[2]) {
-    for (unsigned int other_id_1 : free_touches_) {
-      if (other_id_1 == touch_id)
-        continue;
-
-      for (unsigned int other_id_2 : free_touches_) {
-        if (other_id_2 == touch_id || other_id_2 == other_id_1)
-          continue;
-
-        uint64_t min_start_time = start_times_[touch_id];
-        if (start_times_[other_id_1] < min_start_time &&
-            unaccepted_touches_.find(other_id_1) != unaccepted_touches_.end())
-          min_start_time = start_times_[other_id_1];
-        if (start_times_[other_id_2] < min_start_time &&
-            unaccepted_touches_.find(other_id_2) != unaccepted_touches_.end())
-          min_start_time = start_times_[other_id_2];
-
-        if (start_times_[touch_id] - min_start_time < kCompositionTime) {
-          TouchSet set;
-          set.insert(touch_id);
-          set.insert(other_id_1);
-          set.insert(other_id_2);
-          Gesture* gesture = new Gesture(this, subscription, set,
-                                         start_times_[touch_id]);
-          unaccepted_gestures_.insert(SharedGesture(gesture));
-        }
-      }
-    }
-  }
-}
-
-void Recognizer::MatchFourTouchGestures(unsigned int touch_id) {
-  for (UGSubscription_* subscription : subscriptions_[3]) {
-    for (unsigned int other_id_1 : free_touches_) {
-      if (other_id_1 == touch_id)
-        continue;
-
-      for (unsigned int other_id_2 : free_touches_) {
-        if (other_id_2 == touch_id || other_id_2 == other_id_1)
-          continue;
-
-        for (unsigned int other_id_3 : free_touches_) {
-          if (other_id_3 == touch_id || other_id_3 == other_id_1 ||
-              other_id_3 == other_id_2)
-            continue;
-
-          uint64_t min_start_time = start_times_[touch_id];
-          if (start_times_[other_id_1] < min_start_time &&
-              unaccepted_touches_.find(other_id_1) != unaccepted_touches_.end())
-            min_start_time = start_times_[other_id_1];
-          if (start_times_[other_id_2] < min_start_time &&
-              unaccepted_touches_.find(other_id_2) != unaccepted_touches_.end())
-            min_start_time = start_times_[other_id_2];
-          if (start_times_[other_id_3] < min_start_time &&
-              unaccepted_touches_.find(other_id_3) != unaccepted_touches_.end())
-            min_start_time = start_times_[other_id_3];
-
-          if (start_times_[touch_id] - min_start_time < kCompositionTime) {
-            TouchSet set;
-            set.insert(touch_id);
-            set.insert(other_id_1);
-            set.insert(other_id_2);
-            set.insert(other_id_3);
-            Gesture* gesture = new Gesture(this, subscription, set,
-                                           start_times_[touch_id]);
-            unaccepted_gestures_.insert(SharedGesture(gesture));
-          }
-        }
-      }
-    }
-  }
-}
-
-void Recognizer::MatchFiveTouchGestures(unsigned int touch_id) {
-  for (UGSubscription_* subscription : subscriptions_[4]) {
-    for (unsigned int other_id_1 : free_touches_) {
-      if (other_id_1 == touch_id)
-        continue;
-
-      for (unsigned int other_id_2 : free_touches_) {
-        if (other_id_2 == touch_id || other_id_2 == other_id_1)
-          continue;
-
-        for (unsigned int other_id_3 : free_touches_) {
-          if (other_id_3 == touch_id || other_id_3 == other_id_1 ||
-              other_id_3 == other_id_2)
-            continue;
-
-          for (unsigned int other_id_4 : free_touches_) {
-            if (other_id_4 == touch_id || other_id_4 == other_id_1 ||
-                other_id_4 == other_id_2 || other_id_4 == other_id_3)
-              continue;
-
-            uint64_t min_start_time = start_times_[touch_id];
-            if (start_times_[other_id_1] < min_start_time &&
-                unaccepted_touches_.find(other_id_1) !=
-                    unaccepted_touches_.end())
-              min_start_time = start_times_[other_id_1];
-            if (start_times_[other_id_2] < min_start_time &&
-                unaccepted_touches_.find(other_id_2) !=
-                    unaccepted_touches_.end())
-              min_start_time = start_times_[other_id_2];
-            if (start_times_[other_id_3] < min_start_time &&
-                unaccepted_touches_.find(other_id_3) !=
-                    unaccepted_touches_.end())
-              min_start_time = start_times_[other_id_3];
-            if (start_times_[other_id_4] < min_start_time &&
-                unaccepted_touches_.find(other_id_4) !=
-                    unaccepted_touches_.end())
-              min_start_time = start_times_[other_id_4];
-
-            if (start_times_[touch_id] - min_start_time < kCompositionTime) {
-              TouchSet set;
-              set.insert(touch_id);
-              set.insert(other_id_1);
-              set.insert(other_id_2);
-              set.insert(other_id_3);
-              set.insert(other_id_4);
-              Gesture* gesture = new Gesture(this, subscription, set,
-                                             start_times_[touch_id]);
-              unaccepted_gestures_.insert(SharedGesture(gesture));
-            }
-          }
-        }
-      }
-    }
-  }
-}
-
-namespace {
-
-void GetModifiedAndEndedTouches(UFFrame frame, TouchSet* modified,
-                                TouchSet* ended, uint64_t event_time) {
-  unsigned int num_touches = frame_frame_get_num_touches(frame);
-  for (unsigned int i = 0; i < num_touches; ++i) {
-    UFTouch touch;
-    UFStatus status = frame_frame_get_touch_by_index(frame, i, &touch);
-    if (status != UFStatusSuccess) {
-      fprintf(stderr, "Warning: failed to get touch from frame\n");
-      continue;
-    }
-
-    if (frame_touch_get_time(touch) == event_time) {
-      unsigned int touch_id;
-      status = frame_touch_get_property(touch, UFTouchPropertyId, &touch_id);
-      if (status != UFStatusSuccess) {
-        fprintf(stderr, "Warning: failed to get touch id from touch\n");
-        continue;
-      }
-
-      modified->insert(touch_id);
-
-      if (frame_touch_get_state(touch) == UFTouchStateEnd)
-        ended->insert(touch_id);
-    }
-  }
-}
-
-} // namespace
-
-void Recognizer::ProcessEvent(const UFEvent& event) {
-  UFFrame frame;
-  UFStatus status = frame_event_get_property(event, UFEventPropertyFrame,
-                                             &frame);
-  if (status != UFStatusSuccess) {
-    fprintf(stderr, "Warning: failed to get frame from event\n");
-    return;
-  }
-
-  TouchSet modified_touches;
-  TouchSet ended_touches;
-  GetModifiedAndEndedTouches(frame, &modified_touches,
-                             &ended_touches, frame_event_get_time(event));
-
-  for (auto it = accepted_gestures_.begin(); it != accepted_gestures_.end(); ) {
-    const SharedGesture& gesture = *it++;
-    gesture->Update(event, modified_touches);
-    if (gesture->ended()) {
-      for (unsigned int touch_id : gesture->touches())
-        free_touches_.insert(touch_id);
-      accepted_gestures_.erase(gesture);
-    }
-  }
-
-  for (auto it = unaccepted_gestures_.begin();
-       it != unaccepted_gestures_.end();
-       ) {
-    const SharedGesture& gesture = *it++;
-    gesture->Update(event, modified_touches);
-    if (gesture->canceled())
-      RejectGesture(gesture);
-  }
-
-  for (unsigned int touch_id : ended_touches)
-    free_touches_.erase(touch_id);
-}
-
-void Recognizer::UpdateTime(uint64_t time) {
-  for (auto it = unaccepted_gestures_.begin();
-       it != unaccepted_gestures_.end();
-       ) {
-    const SharedGesture& gesture = *it++;
-    uint64_t timeout = gesture->Timeout();
-    if (timeout && time - gesture->start_time() > timeout)
-      RejectGesture(gesture);
-  }
-
-  for (auto it = unaccepted_touches_.begin(); it
-       != unaccepted_touches_.end();
-       ) {
-    unsigned int touch_id = *it++;
-    if (time - start_times_[touch_id] < kCompositionTime)
-      continue;
-
-    for (const SharedGesture& gesture : unaccepted_gestures_)
-      if (gesture->touches().find(touch_id) != gesture->touches().end())
-        goto next_touch;
-
-    frame_x11_reject_touch(device_, window_, touch_id);
-    unaccepted_touches_.erase(touch_id);
-    free_touches_.erase(touch_id);
-
-next_touch: ;
-  }
-}
-
-uint64_t Recognizer::NextTimeout() {
-  uint64_t min_timeout = std::numeric_limits<uint64_t>::max();
-  for (unsigned int touch_id : unaccepted_touches_)
-    if (kCompositionTime + start_times_[touch_id] < min_timeout)
-      min_timeout = start_times_[touch_id] + kCompositionTime;
-
-  for (const SharedGesture& gesture : unaccepted_gestures_) {
-    uint64_t timeout = gesture->Timeout();
-    if (timeout && gesture->start_time() + timeout < min_timeout)
-      min_timeout = gesture->start_time() + timeout;
-  }
-    
-  return min_timeout;
-}
-
-UGStatus Recognizer::AcceptGesture(unsigned int id) {
-  SharedGesture gesture;
-  for (const SharedGesture& test_gesture : unaccepted_gestures_) {
-    if (test_gesture->id() == id) {
-      gesture = test_gesture;
-      break;
-    }
-  }
-
-  if (!gesture)
-    return UGStatusErrorInvalidGesture;
-
-  for (unsigned int touch_id : gesture->touches()) {
-    if (accepted_touches_.find(touch_id) == accepted_touches_.end()) {
-      frame_x11_accept_touch(device_, window_, touch_id);
-      accepted_touches_.insert(touch_id);
-      unaccepted_touches_.erase(touch_id);
-    } else {
-      for (auto it = accepted_gestures_.begin();
-           it != accepted_gestures_.end();
-           ) {
-        const SharedGesture& other_gesture = *it++;
-        const TouchSet& other_touches = other_gesture->touches();
-        if (other_touches.find(touch_id) != other_touches.end()) {
-          gesture->Cancel();
-          handle_->RemoveGestureFromEventQueue(other_gesture->id());
-          accepted_gestures_.erase(other_gesture);
-        }
-      }
-    }
-
-    free_touches_.erase(touch_id);
-  }
-
-  for (auto it = unaccepted_gestures_.begin();
-       it != unaccepted_gestures_.end();
-       ) {
-    const SharedGesture& other_gesture = *it++;
-    if (other_gesture == gesture)
-      continue;
-    for (unsigned int touch_id : other_gesture->touches()) {
-      if (gesture->touches().find(touch_id) != gesture->touches().end()) {
-        RejectGesture(other_gesture);
-        break;
-      }
-    }
-  }
-
-  accepted_gestures_.insert(gesture);
-  unaccepted_gestures_.erase(gesture);
-
-  return UGStatusSuccess;
-}
-
-UGStatus Recognizer::RejectGesture(unsigned int id) {
-  for (const SharedGesture& gesture : unaccepted_gestures_) {
-    if (gesture->id() == id) {
-      RejectGesture(gesture);
-      return UGStatusSuccess;
-    }
-  }
-
-  return UGStatusErrorInvalidGesture;
-}
-
-void Recognizer::RejectGesture(const SharedGesture& gesture) {
-  gesture->Cancel();
-  handle_->RemoveGestureFromEventQueue(gesture->id());
-  unaccepted_gestures_.erase(gesture);
-}
-
-Recognizer::~Recognizer() {
-  for (const SharedGesture& gesture : unaccepted_gestures_)
-    gesture->Cancel();
-
-  for (const SharedGesture& gesture : accepted_gestures_)
-    gesture->Cancel();
+    const uint64_t kCompositionTime = 60;
+
+    void GetModifiedAndEndedTouches(UFFrame frame, utouch::grail::TouchSet* modified,
+				    utouch::grail::TouchSet* ended, uint64_t event_time) {
+	unsigned int num_touches = frame_frame_get_num_touches(frame);
+	for (unsigned int i = 0; i < num_touches; ++i) {
+	    UFTouch touch;
+	    UFStatus status = frame_frame_get_touch_by_index(frame, i, &touch);
+	    if (status != UFStatusSuccess) {
+		fprintf(stderr, "Warning: failed to get touch from frame\n");
+		continue;
+	    }
+
+	    if (frame_touch_get_time(touch) == event_time) {
+		unsigned int touch_id;
+		status = frame_touch_get_property(touch, UFTouchPropertyId, &touch_id);
+		if (status != UFStatusSuccess) {
+		    fprintf(stderr, "Warning: failed to get touch id from touch\n");
+		    continue;
+		}
+
+		modified->insert(touch_id);
+
+		if (frame_touch_get_state(touch) == UFTouchStateEnd)
+		    ended->insert(touch_id);
+	    }
+	}
+    }
+
+} // namespace
+
+namespace utouch {
+    namespace grail {
+
+	struct Recognizer::Private {
+
+	    Private( Recognizer * parent, utouch::grail::UGHandle * handle, const UFDevice device, Window window)
+		: parent_( parent ), 
+		  handle_(handle),
+		  device_(device),
+		  window_(window),
+		  device_x_res_(46), /* Default to resolution of Apple Magic Trackpad */
+		  device_y_res_(45),
+		  device_direct_(true) {
+		UFAxis axis;
+		UFStatus status = frame_device_get_axis_by_type(device, UFAxisTypeX, &axis);
+		if (status != UFStatusSuccess)
+		    fprintf(stderr, "Warning: failed to get X axis from device\n");
+		else
+		    device_x_res_ = frame_axis_get_resolution(axis);
+	    
+		status = frame_device_get_axis_by_type(device, UFAxisTypeY, &axis);
+		if (status != UFStatusSuccess)
+		    fprintf(stderr, "Warning: failed to get Y axis from device\n");
+		else
+		    device_y_res_ = frame_axis_get_resolution(axis);
+
+		status = frame_device_get_property( device, 
+						    UFDevicePropertyDirect,
+						    &device_direct_);
+		if (status != UFStatusSuccess)
+		    fprintf(stderr,
+			    "Warning: failed to get direct property value for device\n");
+	    }
+
+	    void MatchSubscriptionsForEvent(const UFEvent event) {
+		bool active_subscriptions = false;
+		for (auto subscriptions : subscriptions_) {
+		    if (!subscriptions.empty()) {
+			active_subscriptions = true;
+			break;
+		    }
+		}
+		if (!active_subscriptions)
+		    return;
+	    
+		UFFrame frame;
+		UFStatus status = frame_event_get_property( event, 
+							    UFEventPropertyFrame,
+							    &frame);
+		if (status != UFStatusSuccess) {
+		    fprintf(stderr, "Warning: failed to get frame from event\n");
+		    return;
+		}
+
+		unsigned int num_touches = frame_frame_get_num_touches(frame);
+		for (unsigned int i = 0; i < num_touches; ++i) {
+		    UFTouch touch;
+		    status = frame_frame_get_touch_by_index(frame, i, &touch);
+		    if (status != UFStatusSuccess) {
+			fprintf(stderr, "Warning: failed to get touch from frame\n");
+			continue;
+		    }
+
+		    unsigned int touch_id;
+		    status = frame_touch_get_property(touch, UFTouchPropertyId, &touch_id);
+		    if (status != UFStatusSuccess) {
+			fprintf(stderr, "Warning: failed to get touch id from touch\n");
+			continue;
+		    }
+
+		    switch (frame_touch_get_state(touch)) {
+		    case UFTouchStateBegin: {
+			start_times_[touch_id] = frame_touch_get_start_time(touch);
+			unaccepted_touches_.insert(touch_id);
+			free_touches_.insert(touch_id);
+
+			for (const utouch::grail::SharedGesture & gesture : accepted_gestures_) {
+			    utouch::grail::UGSubscription * subscription = gesture->subscription();
+			    if (gesture->touches().size() < subscription->touches_max()) {
+				TouchSet set(gesture->touches());
+				set.insert(touch_id);
+				utouch::grail::Gesture* new_gesture = new utouch::grail::Gesture(gesture.get(), set);
+				unaccepted_gestures_.insert(utouch::grail::SharedGesture(new_gesture));
+			    }
+			}
+
+			for (const utouch::grail::SharedGesture & gesture : unaccepted_gestures_) {
+			    utouch::grail::UGSubscription* subscription = gesture->subscription();
+			    if (gesture->touches().size() < subscription->touches_max()) {
+				TouchSet set(gesture->touches());
+				set.insert(touch_id);
+				utouch::grail::Gesture * new_gesture = new utouch::grail::Gesture(gesture.get(), set);
+				unaccepted_gestures_.insert( utouch::grail::SharedGesture(new_gesture));
+			    }
+			}
+
+			MatchOneTouchGestures(touch_id);
+			MatchTwoTouchGestures(touch_id);
+			MatchThreeTouchGestures(touch_id);
+			MatchFourTouchGestures(touch_id);
+			MatchFiveTouchGestures(touch_id);
+			break;
+		    }
+
+		    default:
+			break;
+		    }
+		}
+	    }
+
+	    void MatchOneTouchGestures(unsigned int touch_id) {
+		for( utouch::grail::UGSubscription* subscription : subscriptions_[0] ) {
+		    TouchSet set;
+		    set.insert(touch_id);
+		    utouch::grail::Gesture* gesture = new utouch::grail::Gesture( parent_, 
+								  subscription, set,
+								  start_times_[touch_id]);
+		    unaccepted_gestures_.insert(utouch::grail::SharedGesture(gesture));
+		}
+	    }
+
+	    void MatchTwoTouchGestures(unsigned int touch_id) {
+		for( utouch::grail::UGSubscription* subscription : subscriptions_[1] ) {
+		    for (unsigned int other_id : free_touches_) {
+			if (other_id == touch_id)
+			    continue;
+
+			uint64_t min_start_time = start_times_[touch_id];
+			if (start_times_[other_id] < min_start_time &&
+			    unaccepted_touches_.find(other_id) != unaccepted_touches_.end())
+			    min_start_time = start_times_[other_id];
+
+			if (start_times_[touch_id] - min_start_time < kCompositionTime) {
+			    TouchSet set;
+			    set.insert(touch_id);
+			    set.insert(other_id);
+			    utouch::grail::Gesture* gesture = new utouch::grail::Gesture(parent_, subscription, set,
+									 start_times_[touch_id]);
+			    unaccepted_gestures_.insert( utouch::grail::SharedGesture(gesture) );
+			}
+		    }
+		}
+	    }
+
+	    void MatchThreeTouchGestures(unsigned int touch_id) {
+		for( utouch::grail::UGSubscription* subscription : subscriptions_[2] ) {
+		    for (unsigned int other_id_1 : free_touches_) {
+			if (other_id_1 == touch_id)
+			    continue;
+
+			for (unsigned int other_id_2 : free_touches_) {
+			    if (other_id_2 == touch_id || other_id_2 == other_id_1)
+				continue;
+
+			    uint64_t min_start_time = start_times_[touch_id];
+			    if (start_times_[other_id_1] < min_start_time &&
+				unaccepted_touches_.find(other_id_1) != unaccepted_touches_.end())
+				min_start_time = start_times_[other_id_1];
+			    if (start_times_[other_id_2] < min_start_time &&
+				unaccepted_touches_.find(other_id_2) != unaccepted_touches_.end())
+				min_start_time = start_times_[other_id_2];
+
+			    if (start_times_[touch_id] - min_start_time < kCompositionTime) {
+				TouchSet set;
+				set.insert(touch_id);
+				set.insert(other_id_1);
+				set.insert(other_id_2);
+				utouch::grail::Gesture * gesture = new utouch::grail::Gesture(parent_, subscription, set,
+									      start_times_[touch_id]);
+				unaccepted_gestures_.insert(utouch::grail::SharedGesture(gesture));
+			    }
+			}
+		    }
+		}
+	    }
+
+	    void MatchFourTouchGestures(unsigned int touch_id) {
+		for( utouch::grail::UGSubscription* subscription : subscriptions_[3] ) {
+		    for (unsigned int other_id_1 : free_touches_) {
+			if (other_id_1 == touch_id)
+			    continue;
+
+			for (unsigned int other_id_2 : free_touches_) {
+			    if (other_id_2 == touch_id || other_id_2 == other_id_1)
+				continue;
+
+			    for (unsigned int other_id_3 : free_touches_) {
+				if (other_id_3 == touch_id || other_id_3 == other_id_1 ||
+				    other_id_3 == other_id_2)
+				    continue;
+
+				uint64_t min_start_time = start_times_[touch_id];
+				if (start_times_[other_id_1] < min_start_time &&
+				    unaccepted_touches_.find(other_id_1) != unaccepted_touches_.end())
+				    min_start_time = start_times_[other_id_1];
+				if (start_times_[other_id_2] < min_start_time &&
+				    unaccepted_touches_.find(other_id_2) != unaccepted_touches_.end())
+				    min_start_time = start_times_[other_id_2];
+				if (start_times_[other_id_3] < min_start_time &&
+				    unaccepted_touches_.find(other_id_3) != unaccepted_touches_.end())
+				    min_start_time = start_times_[other_id_3];
+
+				if (start_times_[touch_id] - min_start_time < kCompositionTime) {
+				    TouchSet set;
+				    set.insert(touch_id);
+				    set.insert(other_id_1);
+				    set.insert(other_id_2);
+				    set.insert(other_id_3);
+				    utouch::grail::Gesture * gesture = new utouch::grail::Gesture(parent_, 
+										  subscription, 
+										  set,
+										  start_times_[touch_id]);
+				    unaccepted_gestures_.insert(utouch::grail::SharedGesture(gesture));
+				}
+			    }
+			}
+		    }
+		}
+	    }
+
+	    void MatchFiveTouchGestures(unsigned int touch_id) {
+		for (utouch::grail::UGSubscription* subscription : subscriptions_[4]) {
+		    for (unsigned int other_id_1 : free_touches_) {
+			if (other_id_1 == touch_id)
+			    continue;
+
+			for (unsigned int other_id_2 : free_touches_) {
+			    if (other_id_2 == touch_id || other_id_2 == other_id_1)
+				continue;
+
+			    for (unsigned int other_id_3 : free_touches_) {
+				if (other_id_3 == touch_id || other_id_3 == other_id_1 ||
+				    other_id_3 == other_id_2)
+				    continue;
+
+				for (unsigned int other_id_4 : free_touches_) {
+				    if (other_id_4 == touch_id || other_id_4 == other_id_1 ||
+					other_id_4 == other_id_2 || other_id_4 == other_id_3)
+					continue;
+
+				    uint64_t min_start_time = start_times_[touch_id];
+				    if (start_times_[other_id_1] < min_start_time &&
+					unaccepted_touches_.find(other_id_1) !=
+					unaccepted_touches_.end())
+					min_start_time = start_times_[other_id_1];
+				    if (start_times_[other_id_2] < min_start_time &&
+					unaccepted_touches_.find(other_id_2) !=
+					unaccepted_touches_.end())
+					min_start_time = start_times_[other_id_2];
+				    if (start_times_[other_id_3] < min_start_time &&
+					unaccepted_touches_.find(other_id_3) !=
+					unaccepted_touches_.end())
+					min_start_time = start_times_[other_id_3];
+				    if (start_times_[other_id_4] < min_start_time &&
+					unaccepted_touches_.find(other_id_4) !=
+					unaccepted_touches_.end())
+					min_start_time = start_times_[other_id_4];
+
+				    if (start_times_[touch_id] - min_start_time < kCompositionTime) {
+					TouchSet set;
+					set.insert(touch_id);
+					set.insert(other_id_1);
+					set.insert(other_id_2);
+					set.insert(other_id_3);
+					set.insert(other_id_4);
+					utouch::grail::Gesture * gesture = new utouch::grail::Gesture(parent_, subscription, set,
+										      start_times_[touch_id]);
+					unaccepted_gestures_.insert( utouch::grail::SharedGesture(gesture) );
+				    }
+				}
+			    }
+			}
+		    }
+		}
+	    }
+
+	    void ProcessEvent(const UFEvent& event) {
+		UFFrame frame;
+		UFStatus status = frame_event_get_property(event, UFEventPropertyFrame,
+							   &frame);
+		if (status != UFStatusSuccess) {
+		    fprintf(stderr, "Warning: failed to get frame from event\n");
+		    return;
+		}
+
+		TouchSet modified_touches;
+		TouchSet ended_touches;
+		GetModifiedAndEndedTouches(frame, &modified_touches,
+					   &ended_touches, frame_event_get_time(event));
+
+		for (auto it = accepted_gestures_.begin(); it != accepted_gestures_.end(); ) {
+		    const utouch::grail::SharedGesture & gesture = *it++;
+		    gesture->Update(event, modified_touches);
+		    if (gesture->ended()) {
+			for (unsigned int touch_id : gesture->touches())
+			    free_touches_.insert(touch_id);
+			accepted_gestures_.erase(gesture);
+		    }
+		}
+
+		for (auto it = unaccepted_gestures_.begin();
+		     it != unaccepted_gestures_.end();
+		     ) {
+		    const utouch::grail::SharedGesture & gesture = *it++;
+		    gesture->Update(event, modified_touches);
+		    if (gesture->canceled())
+			RejectGesture(gesture);
+		}
+
+		for (unsigned int touch_id : ended_touches)
+		    free_touches_.erase(touch_id);
+	    }
+
+	
+
+	    void RejectGesture(const utouch::grail::SharedGesture& gesture) {
+		gesture->Cancel();
+		handle_->RemoveGestureFromEventQueue(gesture->id());
+		unaccepted_gestures_.erase(gesture);
+	    }
+
+	    Recognizer * parent_;
+
+	    utouch::grail::UGHandle * const handle_;
+	    const UFDevice device_;
+	    const Window window_;
+	    float device_x_res_; /* Units of pixel/mm */
+	    float device_y_res_;
+	    bool device_direct_;
+	    std::set<utouch::grail::UGSubscription*> subscriptions_[5];
+	    std::set<utouch::grail::SharedGesture> unaccepted_gestures_;
+	    std::set<utouch::grail::SharedGesture> accepted_gestures_;
+	    std::map<unsigned int, uint64_t> start_times_;
+	    TouchSet unaccepted_touches_;
+	    TouchSet accepted_touches_;
+	    TouchSet free_touches_;
+
+	};
+
+	Recognizer::Recognizer( utouch::grail::UGHandle * handle, const UFDevice device, Window window)
+	    : d_( new Private( this, handle, device, window ) ) {
+	}
+
+	void Recognizer::ActivateSubscription( utouch::grail::UGSubscription * subscription) {
+	    d_->subscriptions_[subscription->touches_start() - 1].insert(subscription);
+	}
+
+	void Recognizer::DeactivateSubscription( utouch::grail::UGSubscription * subscription) {
+	    d_->subscriptions_[subscription->touches_start() - 1].erase(subscription);
+
+	    for (auto it = d_->unaccepted_gestures_.begin();
+		 it != d_->unaccepted_gestures_.end();
+		 ) {
+		const utouch::grail::SharedGesture & gesture = *it++;
+		if (gesture->subscription() == subscription)
+		    gesture->Cancel();
+		d_->unaccepted_gestures_.erase(gesture);
+	    }
+
+	    for (auto it = d_->accepted_gestures_.begin(); it != d_->accepted_gestures_.end(); ) {
+		const utouch::grail::SharedGesture& gesture = *it++;
+		if (gesture->subscription() == subscription)
+		    gesture->Cancel();
+		d_->accepted_gestures_.erase(gesture);
+	    }
+	}
+
+	void Recognizer::ProcessFrameEvent(const UFEvent event) {
+	    UpdateTime(frame_event_get_time(event));
+	    d_->MatchSubscriptionsForEvent(event);
+	    d_->ProcessEvent(event);
+	}
+
+	void Recognizer::UpdateTime(uint64_t time) {
+	    for (auto it = d_->unaccepted_gestures_.begin();
+		 it != d_->unaccepted_gestures_.end();
+		 ) {
+		const utouch::grail::SharedGesture & gesture = *it++;
+		uint64_t timeout = gesture->Timeout();
+		if (timeout && time - gesture->start_time() > timeout)
+		    d_->RejectGesture(gesture);
+	    }
+
+	    for (auto it = d_->unaccepted_touches_.begin(); it
+		     != d_->unaccepted_touches_.end();
+		 ) {
+		unsigned int touch_id = *it++;
+		if (time - d_->start_times_[touch_id] < kCompositionTime)
+		    continue;
+
+		for (const utouch::grail::SharedGesture & gesture : d_->unaccepted_gestures_)
+		    if (gesture->touches().find(touch_id) != gesture->touches().end())
+			goto next_touch;
+
+		frame_x11_reject_touch(d_->device_, d_->window_, touch_id);
+		d_->unaccepted_touches_.erase(touch_id);
+		d_->free_touches_.erase(touch_id);
+
+	    next_touch: ;
+	    }
+	}
+
+	uint64_t Recognizer::NextTimeout() {
+	    uint64_t min_timeout = std::numeric_limits<uint64_t>::max();
+	    for (unsigned int touch_id : d_->unaccepted_touches_)
+		if (kCompositionTime + d_->start_times_[touch_id] < min_timeout)
+		    min_timeout = d_->start_times_[touch_id] + kCompositionTime;
+
+	    for (const utouch::grail::SharedGesture & gesture : d_->unaccepted_gestures_) {
+		uint64_t timeout = gesture->Timeout();
+		if (timeout && gesture->start_time() + timeout < min_timeout)
+		    min_timeout = gesture->start_time() + timeout;
+	    }
+    
+	    return min_timeout;
+	}
+
+	UGStatus Recognizer::AcceptGesture(unsigned int id) {
+	    utouch::grail::SharedGesture gesture;
+	    for (const utouch::grail::SharedGesture & test_gesture : d_->unaccepted_gestures_) {
+		if (test_gesture->id() == id) {
+		    gesture = test_gesture;
+		    break;
+		}
+	    }
+
+	    if (!gesture)
+		return UGStatusErrorInvalidGesture;
+
+	    for (unsigned int touch_id : gesture->touches()) {
+		if (d_->accepted_touches_.find(touch_id) == d_->accepted_touches_.end()) {
+		    frame_x11_accept_touch(d_->device_, d_->window_, touch_id);
+		    d_->accepted_touches_.insert(touch_id);
+		    d_->unaccepted_touches_.erase(touch_id);
+		} else {
+		    for (auto it = d_->accepted_gestures_.begin();
+			 it != d_->accepted_gestures_.end();
+			 ) {
+			const utouch::grail::SharedGesture & other_gesture = *it++;
+			const TouchSet& other_touches = other_gesture->touches();
+			if (other_touches.find(touch_id) != other_touches.end()) {
+			    gesture->Cancel();
+			    d_->handle_->RemoveGestureFromEventQueue(other_gesture->id());
+			    d_->accepted_gestures_.erase(other_gesture);
+			}
+		    }
+		}
+
+		d_->free_touches_.erase(touch_id);
+	    }
+
+	    for (auto it = d_->unaccepted_gestures_.begin();
+		 it != d_->unaccepted_gestures_.end();
+		 ) {
+		const utouch::grail::SharedGesture & other_gesture = *it++;
+		if (other_gesture == gesture)
+		    continue;
+		for (unsigned int touch_id : other_gesture->touches()) {
+		    if (gesture->touches().find(touch_id) != gesture->touches().end()) {
+			d_->RejectGesture(other_gesture);
+			break;
+		    }
+		}
+	    }
+
+	    d_->accepted_gestures_.insert(gesture);
+	    d_->unaccepted_gestures_.erase(gesture);
+
+	    return UGStatusSuccess;
+	}
+
+	UGStatus Recognizer::RejectGesture(unsigned int id) {
+	    for (const utouch::grail::SharedGesture & gesture : d_->unaccepted_gestures_) {
+		if (gesture->id() == id) {
+		    d_->RejectGesture(gesture);
+		    return UGStatusSuccess;
+		}
+	    }
+
+	    return UGStatusErrorInvalidGesture;
+	}
+
+	utouch::grail::UGHandle * Recognizer::handle() const { 
+	    return d_->handle_; 
+	}
+    
+	float Recognizer::device_x_res() const { 
+	    return d_->device_x_res_; 
+	}
+    
+	float Recognizer::device_y_res() const { 
+	    return d_->device_y_res_; 
+	}
+    
+	bool Recognizer::device_direct() const { 
+	    return d_->device_direct_; 
+	}
+
+	Recognizer::~Recognizer() {
+	    for (const utouch::grail::SharedGesture& gesture : d_->unaccepted_gestures_)
+		gesture->Cancel();
+
+	    for (const utouch::grail::SharedGesture& gesture : d_->accepted_gestures_)
+		gesture->Cancel();
+	}
+    }
 }
 
=== modified file 'src/v3/recognizer.h'
--- src/v3/recognizer.h	2011-10-19 22:07:30 +0000
+++ src/v3/recognizer.h	2011-11-01 21:20:40 +0000
@@ -32,57 +32,44 @@
 #include "utouch/grail.h"
 #include "v3/subscription.h"
 
-class Gesture;
-class UGHandle_;
-
-typedef std::set<unsigned int> TouchSet;
-typedef std::shared_ptr<Gesture> SharedGesture;
-
-class Recognizer {
- public:
-  Recognizer(UGHandle_* handle, const UFDevice device, Window window);
-  ~Recognizer();
-
-  void ActivateSubscription(UGSubscription_* subscription);
-  void DeactivateSubscription(UGSubscription_* subscription);
-  void ProcessFrameEvent(const UFEvent event);
-  void UpdateTime(uint64_t time);
-  uint64_t NextTimeout();
-  UGStatus AcceptGesture(unsigned int id);
-  UGStatus RejectGesture(unsigned int id);
-
-  UGHandle_* handle() const { return handle_; }
-  float device_x_res() const { return device_x_res_; }
-  float device_y_res() const { return device_y_res_; }
-  bool device_direct() const { return device_direct_; }
-
-  Recognizer(const Recognizer&) = delete;
-  void operator=(const Recognizer&) = delete;
-
- private:
-  UGHandle_* const handle_;
-  const UFDevice device_;
-  const Window window_;
-  float device_x_res_; /* Units of pixel/mm */
-  float device_y_res_;
-  bool device_direct_;
-  std::set<UGSubscription_*> subscriptions_[5];
-  std::set<SharedGesture> unaccepted_gestures_;
-  std::set<SharedGesture> accepted_gestures_;
-  std::map<unsigned int, uint64_t> start_times_;
-  TouchSet unaccepted_touches_;
-  TouchSet accepted_touches_;
-  TouchSet free_touches_;
-
-  void MatchSubscriptionsForEvent(const UFEvent event);
-  void MatchSubscriptionsForTouch(unsigned int touch_id);
-  void MatchOneTouchGestures(unsigned int touch_id);
-  void MatchTwoTouchGestures(unsigned int touch_id);
-  void MatchThreeTouchGestures(unsigned int touch_id);
-  void MatchFourTouchGestures(unsigned int touch_id);
-  void MatchFiveTouchGestures(unsigned int touch_id);
-  void ProcessEvent(const UFEvent& event);
-  void RejectGesture(const SharedGesture& gesture);
-};
-
+namespace utouch {
+    namespace grail {
+
+	class UGHandle;
+	class UGSubscription;
+    
+	class Gesture;
+	typedef std::shared_ptr<Gesture> SharedGesture;
+
+	typedef std::set<unsigned int> TouchSet;
+
+	class Recognizer {
+	public:
+	    Recognizer( utouch::grail::UGHandle * handle, const UFDevice device, Window window);
+	    ~Recognizer();
+
+	    void ActivateSubscription( utouch::grail::UGSubscription * subscription );
+	    void DeactivateSubscription( utouch::grail::UGSubscription* subscription);
+	    void ProcessFrameEvent(const UFEvent event);
+	    void UpdateTime(uint64_t time);
+	    uint64_t NextTimeout();
+	    UGStatus AcceptGesture(unsigned int id);
+	    UGStatus RejectGesture(unsigned int id);
+
+	    utouch::grail::UGHandle * handle() const;
+	    float device_x_res() const;
+	    float device_y_res() const;
+	    bool device_direct() const;
+
+	    Recognizer(const Recognizer&) = delete;
+	    void operator=(const Recognizer&) = delete;
+
+	protected:
+
+	    struct Private;
+	    std::shared_ptr< Private > d_;
+
+	};
+    }
+}
 #endif // UTOUCH_GRAIL_RECOGNIZER_H_
 
=== modified file 'src/v3/slice.cpp'
--- src/v3/slice.cpp	2011-10-21 00:06:58 +0000
+++ src/v3/slice.cpp	2011-11-01 21:20:40 +0000
@@ -21,10 +21,10 @@
 
 #include "v3/slice.h"
 
-#include <assert.h>
-#include <math.h>
-#include <stdio.h>
-#include <string.h>
+#include <cassert>
+#include <cmath>
+#include <cstdio>
+#include <cstring>
 
 #include <utouch/frame.h>
 
@@ -32,550 +32,687 @@
 #include "v3/recognizer.h"
 #include "v3/subscription.h"
 
-namespace {
-
-const UGTransform kIdentityTransform = { { 1, 0, 0 }, { 0, 1, 0 }, { 0, 0, 1 } };
-
-} // namespace
-
-UGSlice_::UGSlice_(const SharedGesture& gesture, UFEvent event,
-                   const TouchSet& touches, UGGestureTypeMask recognized)
-    : gesture_(gesture),
-      event_(event),
-      frame_(NULL),
-      touches_(touches),
-      time_(frame_event_get_time(event)),
-      state_(UGGestureStateBegin),
-      original_center_x_(0),
-      original_center_y_(0),
-      original_radius_(0),
-      original_angle_(0),
-      radius_(0),
-      angle_(0),
-      center_of_rotation_x_(0),
-      center_of_rotation_y_(0),
-      recognized_(recognized),
-      touch_count_changed_(false) {
-  frame_event_ref(event);
-
-  memcpy(transform_, kIdentityTransform, sizeof(kIdentityTransform));
-  memcpy(cumulative_transform_, kIdentityTransform, sizeof(kIdentityTransform));
-}
-
-UGSlice_* UGSlice_::NewUGSlice_(const SharedGesture& gesture, UFEvent event,
-                                const TouchSet& touches,
-                                UGGestureTypeMask recognized) {
-  UGSlice_* slice = new UGSlice_(gesture, event, touches, recognized);
-
-  UFStatus status = frame_event_get_property(event, UFEventPropertyFrame,
-                                             &slice->frame_);
-  if (status != UFStatusSuccess) {
-    fprintf(stderr, "Warning: failed to get frame from event\n");
-    delete slice;
-    return NULL;
-  }
-
-  slice->GetValues(touches, &slice->original_center_x_,
-                   &slice->original_center_y_, &slice->original_radius_,
-                   &slice->original_angle_, true);
-  slice->radius_ = slice->original_radius_;
-  slice->angle_ = slice->original_angle_;
-
-  return slice;
-}
-
-UGSlice_::UGSlice_(const SharedUGSlice_& prev, UFEvent event,
-                   const TouchSet& touches)
-    : gesture_(prev->gesture_),
-      event_(event ? : NULL),
-      frame_(NULL),
-      touches_(touches),
-      time_(frame_event_get_time(event)),
-      state_(UGGestureStateUpdate),
-      original_center_x_(prev->original_center_x_),
-      original_center_y_(prev->original_center_y_),
-      original_radius_(prev->original_radius_),
-      original_angle_(prev->original_angle_),
-      radius_(prev->radius_),
-      angle_(prev->angle_),
-      center_of_rotation_x_(0),
-      center_of_rotation_y_(0),
-      recognized_(prev->recognized_),
-      touch_count_changed_(touches_.size() != prev->touches_.size()) {
-  memcpy(transform_, kIdentityTransform, sizeof(kIdentityTransform));
-
-  if (touch_count_changed_) {
-    memcpy(cumulative_transform_, kIdentityTransform,
-           sizeof(kIdentityTransform));
-    original_radius_ = 0;
-    original_angle_ = 0;
-  } else {
-    memcpy(cumulative_transform_, prev->cumulative_transform_,
-           sizeof(prev->cumulative_transform_));
-  }
-
-  if (event_)
-    frame_event_ref(event_);
-}
-
-UGSlice_* UGSlice_::NewUGSlice_(const SharedUGSlice_& prev, UFEvent event,
-                                const TouchSet& touches) {
-  UGSlice_* slice = new UGSlice_(prev, event, touches);
-
-  UFStatus status = frame_event_get_property(event, UFEventPropertyFrame,
-                                             &slice->frame_);
-  if (status != UFStatusSuccess) {
-    fprintf(stderr, "Warning: failed to get frame from event\n");
-    delete slice;
-    return NULL;
-  }
-
-  if (slice->touch_count_changed_) {
-    slice->GetValues(touches, &slice->original_center_x_,
-                     &slice->original_center_y_, &slice->original_radius_,
-                     &slice->original_angle_, true);
-    slice->radius_ = slice->original_radius_;
-    slice->angle_ = slice->original_angle_;
-  } else {
-    slice->SetTransforms();
-    slice->SetCenterOfRotation();
-    slice->CheckGestureEnd();
-  }
-
-  return slice;
-}
-
-void UGSlice_::GetValues(const TouchSet& touches, float* x, float* y,
-                         float* radius, float* angle, bool init) {
-  *x = 0;
-  *y = 0;
-
-  for (unsigned int touch_id : touches) {
-    UFTouch touch;
-    UFStatus status = frame_frame_get_touch_by_id(frame_, &touch_id, &touch);
-    if (status != UFStatusSuccess) {
-      fprintf(stderr, "Warning: failed to get touch from frame\n");
-      continue;
-    }
-    
-    if (gesture_.lock()->recognizer().device_direct()) {
-      *x += frame_touch_get_window_x(touch);
-      *y += frame_touch_get_window_y(touch);
-    } else {
-      *x += frame_touch_get_device_x(touch);
-      *y += frame_touch_get_device_y(touch);
-    }
-  }
-
-  *x /= touches.size();
-  *y /= touches.size();
-
-  if (touches.size() == 1)
-    return;
-
-  *radius = 0;
-  *angle = 0;
-  int num_angles = 0;
-  for (unsigned int touch_id : touches) {
-    UFTouch touch;
-    float cur_x;
-    float cur_y;
-
-    UFStatus status = frame_frame_get_touch_by_id(frame_, &touch_id, &touch);
-    if (status != UFStatusSuccess) {
-      fprintf(stderr, "Warning: failed to get touch from frame\n");
-      continue;
-    }
-
-    if (gesture_.lock()->recognizer().device_direct()) {
-      cur_x = frame_touch_get_window_x(touch);
-      cur_y = frame_touch_get_window_y(touch);
-    } else {
-      cur_x = frame_touch_get_device_x(touch);
-      cur_y = frame_touch_get_device_y(touch);
-    }
-
-    *radius += sqrtf((cur_x - *x) * (cur_x - *x) + (cur_y - *y) * (cur_y - *y));
-
-    float new_angle = atan2f(cur_y - *y, cur_x - *x);
-
-    if (init) {
-      *angle += new_angle;
-      num_angles++;
-    } else if (frame_touch_get_state(touch) != UFTouchStateBegin) {
-      float prev_angle = gesture_.lock()->AngleForTouch(touch_id);
-
-      if (new_angle - prev_angle < -M_PI)
-        new_angle += 2 * M_PI;
-      else if (new_angle - prev_angle > M_PI)
-        new_angle -= 2 * M_PI;
-
-      *angle += new_angle - prev_angle;
-      num_angles++;
-    }
-
-    gesture_.lock()->SetAngleForTouch(touch_id, new_angle);
-  }
-
-  *radius /= touches.size();
-  *angle /= num_angles;
-  if (!init)
-    *angle += angle_;
-}
-
-void UGSlice_::SetTransforms() {
-  float center_x;
-  float center_y;
-  float new_radius = radius_;
-  float new_angle = angle_;
-  GetValues(touches_, &center_x, &center_y, &new_radius, &new_angle, false);
-
-  if (!touch_count_changed_) {
-    float scale = radius_ ? new_radius / radius_ : 1;
-
-    transform_[0][0] = cosf(new_angle - angle_) * scale;
-    transform_[0][1] = -sinf(new_angle - angle_) * scale;
-    transform_[0][2] =
-        center_x - cumulative_transform_[0][2] - original_center_x_;
-    transform_[1][0] = -transform_[0][1];
-    transform_[1][1] = transform_[0][0];
-    transform_[1][2] =
-        center_y - cumulative_transform_[1][2] - original_center_y_;
-
-    scale = original_radius_ ? new_radius / original_radius_ : 1;
-
-    cumulative_transform_[0][0] = cosf(new_angle - original_angle_) * scale;
-    cumulative_transform_[0][1] = -sinf(new_angle - original_angle_) * scale;
-    cumulative_transform_[0][2] = center_x - original_center_x_;
-    cumulative_transform_[1][0] = -cumulative_transform_[0][1];
-    cumulative_transform_[1][1] = cumulative_transform_[0][0];
-    cumulative_transform_[1][2] = center_y - original_center_y_;
-  } else {
-    original_radius_ += new_radius - radius_;
-    original_angle_ += new_angle - angle_;
-    original_center_x_ +=
-        center_x - (original_center_x_ + cumulative_transform_[0][2]);
-    original_center_y_ +=
-        center_y - (original_center_y_ + cumulative_transform_[1][2]);
-  }
-
-  radius_ = new_radius;
-  angle_ = new_angle;
-}
-
-/**
- * Determine the center of rotation point.
- *
- * For any given point q that is transformed by a 2D affine transformation
- * matrix T about anchor point P the new point q' may be determined by the
- * following equation:
- *
- * q' = T * (q - P) + P
- *
- * T and P are dependent, so we can modify one and find a new value for the
- * other. We will label the original T and P as T0 and P0, and the new values
- * will be labeled T1 and P1. We can find new values by solving the following
- * equation:
- *
- * q' = T0 * (q - P0) + P0 = T1 * (q - P1) + P1
- *
- * In the calculations below, we use variables for the scalar values
- * that make up T0, P0, T1, and P1:
- *
- * T0: [ a -b c ]  P0: [ x0 ]  T1: [ a -b 0 ]  P1: [ x1 ]
- *     [ b  a d ]      [ y0 ]      [ b  a 0 ]      [ y1 ]
- *     [ 0  0 1 ]      [  0 ]      [ 0  0 1 ]      [  0 ]
- *
- * Note that rotation and scaling are independent of the anchor point, so a and
- * b are equivalent between the transformation matrices.
- *
- * Since we know all the values of T0, P0, and T1, we can calculate the values
- * x1 and y1 in P1.
- */
-void UGSlice_::SetCenterOfRotation() {
-  float a = transform_[0][0];
-  float b = transform_[1][0];
-  float c = transform_[0][2];
-  float d = transform_[0][2];
-  float x0 = original_center_x_ + cumulative_transform_[0][2];
-  float y0 = original_center_y_ + cumulative_transform_[1][2];
-  float x1;
-  float y1;
-
-  float div = a*a - 2*a + b*b + 1;
-
-  if (fabsf(div) < 1e-5)
-    return;
-
-  x1 = (a*a*x0 - a*(2*x0+c) + b*b*x0 - b*d + c + x0) / div;
-  y1 = (a*a*y0 - a*(2*y0+d) + b*b*y0 + b*c + d + y0) / div;
-
-  center_of_rotation_x_ = x1;
-  center_of_rotation_y_ = y1;
-}
-
-void UGSlice_::CheckGestureEnd() {
-  unsigned int num_active_touches = 0;
-  for (unsigned int touch_id : touches_) {
-    UFTouch touch;
-    UFStatus status = frame_frame_get_touch_by_id(frame_, &touch_id, &touch);
-    if (status != UFStatusSuccess) {
-      fprintf(stderr, "Warning: failed to get touch from frame by id\n");
-      continue;
-    }
-
-    if (frame_touch_get_state(touch) == UFTouchStateEnd) {
-      continue;
-    } else {
-      int pending_end;
-      status = frame_touch_get_property(touch, UFTouchPropertyPendingEnd,
-                                        &pending_end);
-      if (status != UFStatusSuccess) {
-        fprintf(stderr, "Warning: failed to get touch pending end property\n");
-        continue;
-      }
-
-      if (pending_end)
-        continue;
-    }
-
-    num_active_touches++;
-  }
-
-  const UGSubscription_* subscription = gesture_.lock()->subscription();
-  unsigned int touches_start = subscription->touches_start();
-  unsigned int touches_min = subscription->touches_min();
-  if ((!touches_min && num_active_touches < touches_start) ||
-      (touches_min && num_active_touches < touches_min))
-    state_ = UGGestureStateEnd;
-}
-
-uint64_t UGSlice_::CumulativeTime() const {
-  return time_ - gesture_.lock()->start_time();
-}
-
-float UGSlice_::CumulativeDrag2() const {
-  float res_x = gesture_.lock()->recognizer().device_x_res();
-  float res_y = gesture_.lock()->recognizer().device_y_res();
-
-  return fabsf(cumulative_transform_[0][2] / res_x *
-               cumulative_transform_[0][2] / res_x +
-               cumulative_transform_[1][2] / res_y * 
-               cumulative_transform_[1][2] / res_y);
-}
-
-float UGSlice_::CumulativePinch() const {
-  float pinch = original_radius_ ? radius_ / original_radius_ : 1;
-
-  return (pinch >= 1 ? pinch : 1 / pinch);
-}
-
-UGGestureTypeMask UGSlice_::CheckRecognition(
-    const UGSubscription_& subscription) {
-  if ((subscription.mask() & UGGestureTypeDrag) &&
-      (!subscription.drag().timeout() ||
-       CumulativeTime() < subscription.drag().timeout()) &&
-      CumulativeDrag2() > subscription.drag().threshold())
-    recognized_ |= UGGestureTypeDrag;
-
-  if ((subscription.mask() & UGGestureTypePinch) &&
-      (!subscription.pinch().timeout() ||
-       CumulativeTime() < subscription.pinch().timeout()) &&
-      CumulativePinch() > subscription.pinch().threshold())
-    recognized_ |= UGGestureTypePinch;
-
-  if ((subscription.mask() & UGGestureTypeRotate) &&
-      (!subscription.rotate().timeout() ||
-       CumulativeTime() < subscription.rotate().timeout()) &&
-      fabsf(angle_ - original_angle_) > subscription.rotate().threshold())
-    recognized_ |= UGGestureTypeRotate;
-
-  if ((subscription.mask() & UGGestureTypeTap) &&
-      CumulativeTime() < subscription.tap().timeout() &&
-      state_ == UGGestureStateEnd)
-    recognized_ |= UGGestureTypeTap;
-
-  if (subscription.mask() & UGGestureTypeTouch)
-    recognized_ |= UGGestureTypeTouch;
-
-  return recognized_;
-}
-
-UGStatus UGSlice_::GetTouchId(unsigned int index, void* touch_id) const {
-  auto it = touches_.begin();
-  for (unsigned int i = 0; i < index; ++i, ++it)
-    if (it == touches_.end())
-      return UGStatusErrorInvalidIndex;
-
-  *reinterpret_cast<unsigned int*>(touch_id) = *it;
-  return UGStatusSuccess;
-}
-
-UGStatus UGSlice_::GetProperty(UGSliceProperty property, void* value) const {
-  switch (property) {
-    case UGSlicePropertyId:
-      *reinterpret_cast<unsigned int*>(value) = gesture_.lock()->id();
-      return UGStatusSuccess;
-
-    case UGSlicePropertyState:
-      *reinterpret_cast<UGGestureState*>(value) = state_;
-      return UGStatusSuccess;
-
-    case UGSlicePropertySubscription:
-      *reinterpret_cast<UGSubscription*>(value) = gesture_.lock()->subscription();
-      return UGStatusSuccess;
-
-    case UGSlicePropertyRecognized:
-      *reinterpret_cast<UGGestureTypeMask*>(value) = recognized_;
-      return UGStatusSuccess;
-
-    case UGSlicePropertyNumTouches:
-      *reinterpret_cast<unsigned int*>(value) = touches_.size();
-      return UGStatusSuccess;
-
-    case UGSlicePropertyFrame:
-      *reinterpret_cast<UFFrame*>(value) = frame_;
-      return UGStatusSuccess;
-
-    case UGSlicePropertyOriginalCenterX:
-      *reinterpret_cast<float*>(value) = original_center_x_;
-      return UGStatusSuccess;
-
-    case UGSlicePropertyOriginalCenterY:
-      *reinterpret_cast<float*>(value) = original_center_y_;
-      return UGStatusSuccess;
-
-    case UGSlicePropertyOriginalRadius:
-      *reinterpret_cast<float*>(value) = original_radius_;
-      return UGStatusSuccess;
-
-    case UGSlicePropertyTransform:
-      *reinterpret_cast<UGTransform**>(value) = &transform_;
-      return UGStatusSuccess;
-
-    case UGSlicePropertyCumulativeTransform:
-      *reinterpret_cast<UGTransform**>(value) = &cumulative_transform_;
-      return UGStatusSuccess;
-
-    case UGSlicePropertyCenterOfRotationX:
-      *reinterpret_cast<float*>(value) = center_of_rotation_x_;
-      return UGStatusSuccess;
-
-    case UGSlicePropertyCenterOfRotationY:
-      *reinterpret_cast<float*>(value) = center_of_rotation_y_;
-      return UGStatusSuccess;
-  }
-
-  return UGStatusErrorUnknownProperty;
-}
-
-UGSlice_::~UGSlice_() {
-  frame_event_unref(event_);
-}
-
-extern "C" {
-
-UGStatus grail_slice_get_property(const UGSlice slice, UGSliceProperty property,
-                                  void* value) {
-  return slice->GetProperty(property, value);
-}
-
-unsigned int grail_slice_get_id(const UGSlice slice) {
-  unsigned int id;
-  UGStatus status = slice->GetProperty(UGSlicePropertyId, &id);
-  assert(status == UGStatusSuccess);
-  return id;
-}
-
-UGGestureState grail_slice_get_state(const UGSlice slice) {
-  UGGestureState state;
-  UGStatus status = slice->GetProperty(UGSlicePropertyState, &state);
-  assert(status == UGStatusSuccess);
-  return state;
-}
-
-UGGestureTypeMask grail_slice_get_recognized(const UGSlice slice) {
-  UGGestureTypeMask mask;
-  UGStatus status = slice->GetProperty(UGSlicePropertyRecognized, &mask);
-  assert(status == UGStatusSuccess);
-  return mask;
-}
-
-UGSubscription grail_slice_get_subscription(const UGSlice slice) {
-  UGSubscription subscription;
-  UGStatus status = slice->GetProperty(UGSlicePropertySubscription,
-                                       &subscription);
-  assert(status == UGStatusSuccess);
-  return subscription;
-}
-
-unsigned int grail_slice_get_num_touches(const UGSlice slice) {
-  unsigned int num_touches;
-  UGStatus status = slice->GetProperty(UGSlicePropertyNumTouches, &num_touches);
-  assert(status == UGStatusSuccess);
-  return num_touches;
-}
-
-UGStatus grail_slice_get_touch_id(const UGSlice slice, unsigned int index,
-                                  void *touch_id) {
-  return slice->GetTouchId(index, touch_id);
-}
-
-float grail_slice_get_original_center_x(const UGSlice slice) {
-  float x;
-  UGStatus status = slice->GetProperty(UGSlicePropertyOriginalCenterX, &x);
-  assert(status == UGStatusSuccess);
-  return x;
-}
-
-float grail_slice_get_original_center_y(const UGSlice slice) {
-  float y;
-  UGStatus status = slice->GetProperty(UGSlicePropertyOriginalCenterY, &y);
-  assert(status == UGStatusSuccess);
-  return y;
-}
-
-float grail_slice_get_original_radius(const UGSlice slice) {
-  float radius;
-  UGStatus status = slice->GetProperty(UGSlicePropertyOriginalRadius, &radius);
-  assert(status == UGStatusSuccess);
-  return radius;
-}
-
-float grail_slice_get_center_of_rotation_x(const UGSlice slice) {
-  float x;
-  UGStatus status = slice->GetProperty(UGSlicePropertyCenterOfRotationX, &x);
-  assert(status == UGStatusSuccess);
-  return x;
-}
-
-float grail_slice_get_center_of_rotation_y(const UGSlice slice) {
-  float y;
-  UGStatus status = slice->GetProperty(UGSlicePropertyCenterOfRotationY, &y);
-  assert(status == UGStatusSuccess);
-  return y;
-}
-
-const UGTransform *grail_slice_get_transform(const UGSlice slice) {
-  UGTransform *transform;
-  UGStatus status = slice->GetProperty(UGSlicePropertyTransform, &transform);
-  assert(status == UGStatusSuccess);
-  return transform;
-}
-
-const UGTransform *grail_slice_get_cumulative_transform(const UGSlice slice) {
-  UGTransform *transform;
-  UGStatus status = slice->GetProperty(UGSlicePropertyCumulativeTransform,
-                                       &transform);
-  assert(status == UGStatusSuccess);
-  return transform;
-}
-
-const UFFrame grail_slice_get_frame(const UGSlice slice) {
-  UFFrame frame;
-  UGStatus status = slice->GetProperty(UGSlicePropertyFrame, &frame);
-  assert(status == UGStatusSuccess);
-  return frame;
-}
-
-} // extern "C"
+namespace utouch {
+    namespace grail {
+
+	const UGTransform kIdentityTransform = { 
+	    { 1, 0, 0 }, 
+	    { 0, 1, 0 }, 
+	    { 0, 0, 1 } 
+	};
+
+	struct UGSlice::Private {
+
+	    Private( const SharedUGSlice & prev, 
+		     UFEvent event,
+		     const TouchSet & touches )
+		: gesture_(prev->d_->gesture_),
+		  event_(event ? : NULL),
+		  frame_(NULL),
+		  touches_(touches),
+		  time_(frame_event_get_time(event)),
+		  state_(UGGestureStateUpdate),
+		  original_center_x_(prev->d_->original_center_x_),
+		  original_center_y_(prev->d_->original_center_y_),
+		  original_radius_(prev->d_->original_radius_),
+		  original_angle_(prev->d_->original_angle_),
+		  radius_(prev->d_->radius_),
+		  angle_(prev->d_->angle_),
+		  center_of_rotation_x_(0),
+		  center_of_rotation_y_(0),
+		  recognized_(prev->d_->recognized_),
+		  touch_count_changed_(touches_.size() != prev->d_->touches_.size()) {
+	
+		::memcpy(transform_, kIdentityTransform, sizeof(kIdentityTransform));
+	
+		if( touch_count_changed_ ) {
+		    ::memcpy( cumulative_transform_, 
+			      kIdentityTransform,
+			      sizeof( kIdentityTransform )
+			      );
+		    original_radius_ = 0;
+		    original_angle_ = 0;
+		} else {
+		    memcpy( cumulative_transform_, 
+			    prev->d_->cumulative_transform_,
+			    sizeof(prev->d_->cumulative_transform_)
+			    );
+		}
+	
+		if (event_)
+		    frame_event_ref(event_);
+	    }
+
+	    Private( const SharedGesture & gesture, 
+		     UFEvent event,
+		     const TouchSet & touches, 
+		     UGGestureTypeMask recognized )
+		: gesture_(gesture),
+		  event_(event),
+		  frame_(NULL),
+		  touches_(touches),
+		  time_(frame_event_get_time(event)),
+		  state_(UGGestureStateBegin),
+		  original_center_x_(0),
+		  original_center_y_(0),
+		  original_radius_(0),
+		  original_angle_(0),
+		  radius_(0),
+		  angle_(0),
+		  center_of_rotation_x_(0),
+		  center_of_rotation_y_(0),
+		  recognized_(recognized),
+		  touch_count_changed_(false) {
+	
+		frame_event_ref(event);
+	
+		memcpy(transform_, kIdentityTransform, sizeof(kIdentityTransform));
+		memcpy(cumulative_transform_, kIdentityTransform, sizeof(kIdentityTransform));
+	    }
+    
+	    ~Private() {
+		frame_event_unref(event_);
+	    }
+
+	    const std::weak_ptr<Gesture> gesture_;
+	    SharedGesture gesture_ref_;
+	    const UFEvent event_;
+	    UFFrame frame_;
+	    TouchSet touches_;
+	    uint64_t time_;
+	    UGGestureState state_;
+	    float original_center_x_;
+	    float original_center_y_;
+	    float original_radius_;
+	    float original_angle_;
+	    float radius_;
+	    float angle_;
+	    float transform_[3][3];
+	    float cumulative_transform_[3][3];
+	    float center_of_rotation_x_;
+	    float center_of_rotation_y_;
+	    UGGestureTypeMask recognized_;
+	    bool touch_count_changed_;
+    
+	    void GetValues( const TouchSet & touches, 
+			    float * x, 
+			    float * y, 
+			    float * radius,
+			    float* angle, 
+			    bool init
+			    ) {
+		assert( x == NULL );
+		assert( y == NULL );
+		assert( radius == NULL );
+		assert( angle == NULL );
+
+		*x = 0;
+		*y = 0;
+
+		for (unsigned int touch_id : touches) {
+		    UFTouch touch;
+		    UFStatus status = frame_frame_get_touch_by_id(frame_, &touch_id, &touch);
+		    if (status != UFStatusSuccess) {
+			fprintf(stderr, "Warning: failed to get touch from frame\n");
+			continue;
+		    }
+    
+		    if (gesture_.lock()->recognizer().device_direct()) {
+			*x += frame_touch_get_window_x(touch);
+			*y += frame_touch_get_window_y(touch);
+		    } else {
+			*x += frame_touch_get_device_x(touch);
+			*y += frame_touch_get_device_y(touch);
+		    }
+		}
+
+		*x /= touches.size();
+		*y /= touches.size();
+
+		if (touches.size() == 1)
+		    return;
+
+		*radius = 0;
+		*angle = 0;
+		int num_angles = 0;
+		for (unsigned int touch_id : touches) {
+		    UFTouch touch;
+		    float cur_x;
+		    float cur_y;
+
+		    UFStatus status = frame_frame_get_touch_by_id(frame_, &touch_id, &touch);
+		    if (status != UFStatusSuccess) {
+			fprintf(stderr, "Warning: failed to get touch from frame\n");
+			continue;
+		    }
+
+		    if (gesture_.lock()->recognizer().device_direct()) {
+			cur_x = frame_touch_get_window_x(touch);
+			cur_y = frame_touch_get_window_y(touch);
+		    } else {
+			cur_x = frame_touch_get_device_x(touch);
+			cur_y = frame_touch_get_device_y(touch);
+		    }
+
+		    *radius += sqrtf((cur_x - *x) * (cur_x - *x) + (cur_y - *y) * (cur_y - *y));
+
+		    float new_angle = atan2f(cur_y - *y, cur_x - *x);
+
+		    if (init) {
+			*angle += new_angle;
+			num_angles++;
+		    } else if (frame_touch_get_state(touch) != UFTouchStateBegin) {
+			float prev_angle = gesture_.lock()->AngleForTouch(touch_id);
+
+			if (new_angle - prev_angle < -M_PI)
+			    new_angle += 2 * M_PI;
+			else if (new_angle - prev_angle > M_PI)
+			    new_angle -= 2 * M_PI;
+
+			*angle += new_angle - prev_angle;
+			num_angles++;
+		    }
+
+		    gesture_.lock()->SetAngleForTouch(touch_id, new_angle);
+		}
+
+		*radius /= touches.size();
+		*angle /= num_angles;
+		if (!init)
+		    *angle += angle_;
+	    }
+    
+	    /**
+	     * Determine the center of rotation point.
+	     *
+	     * For any given point q that is transformed by a 2D affine transformation
+	     * matrix T about anchor point P the new point q' may be determined by the
+	     * following equation:
+	     *
+	     * q' = T * (q - P) + P
+	     *
+	     * T and P are dependent, so we can modify one and find a new value for the
+	     * other. We will label the original T and P as T0 and P0, and the new values
+	     * will be labeled T1 and P1. We can find new values by solving the following
+	     * equation:
+	     *
+	     * q' = T0 * (q - P0) + P0 = T1 * (q - P1) + P1
+	     *
+	     * In the calculations below, we use variables for the scalar values
+	     * that make up T0, P0, T1, and P1:
+	     *
+	     * T0: [ a -b c ]  P0: [ x0 ]  T1: [ a -b 0 ]  P1: [ x1 ]
+	     *     [ b  a d ]      [ y0 ]      [ b  a 0 ]      [ y1 ]
+	     *     [ 0  0 1 ]      [  0 ]      [ 0  0 1 ]      [  0 ]
+	     *
+	     * Note that rotation and scaling are independent of the anchor point, so a and
+	     * b are equivalent between the transformation matrices.
+	     *
+	     * Since we know all the values of T0, P0, and T1, we can calculate the values
+	     * x1 and y1 in P1.
+	     */
+	    void SetCenterOfRotation() {
+		float a = transform_[0][0];
+		float b = transform_[1][0];
+		float c = transform_[0][2];
+		float d = transform_[0][2];
+		float x0 = original_center_x_ + cumulative_transform_[0][2];
+		float y0 = original_center_y_ + cumulative_transform_[1][2];
+		float x1;
+		float y1;
+
+		float div = a*a - 2*a + b*b + 1;
+
+		// TODO: Replace magic number here :-)
+		if( ::fabsf( div ) < 1e-5 )
+		    return;
+
+		x1 = (a*a*x0 - a*(2*x0+c) + b*b*x0 - b*d + c + x0) / div;
+		y1 = (a*a*y0 - a*(2*y0+d) + b*b*y0 + b*c + d + y0) / div;
+
+		center_of_rotation_x_ = x1;
+		center_of_rotation_y_ = y1;
+	    }
+
+	    void CheckGestureEnd() {
+		std::size_t num_active_touches = 0;
+	
+		for (unsigned int touch_id : touches_) {
+		    UFTouch touch;
+		    UFStatus status = frame_frame_get_touch_by_id(frame_, &touch_id, &touch);
+		    if (status != UFStatusSuccess) {
+			fprintf(stderr, "Warning: failed to get touch from frame by id\n");
+			continue;
+		    }
+	    
+		    if (frame_touch_get_state(touch) == UFTouchStateEnd) {
+			continue;
+		    } else {
+			int pending_end;
+			status = frame_touch_get_property(touch, UFTouchPropertyPendingEnd,
+							  &pending_end);
+			if (status != UFStatusSuccess) {
+			    fprintf(stderr, "Warning: failed to get touch pending end property\n");
+			    continue;
+			}
+		
+			if (pending_end)
+			    continue;
+		    }
+	    
+		    num_active_touches++;
+		}
+	
+		const UGSubscription * subscription = gesture_.lock()->subscription();
+		unsigned int touches_start = subscription->touches_start();
+		unsigned int touches_min = subscription->touches_min();
+		if ((!touches_min && num_active_touches < touches_start) ||
+		    (touches_min && num_active_touches < touches_min))
+		    state_ = UGGestureStateEnd;
+	    }
+        
+	    void SetTransforms() {
+		float center_x;
+		float center_y;
+		float new_radius = radius_;
+		float new_angle = angle_;
+		GetValues( touches_, &center_x, &center_y, &new_radius, &new_angle, false);
+	
+		if (touch_count_changed_) {
+		    float scale = radius_ > 0 ? new_radius / radius_ : 1;
+	    
+		    transform_[0][0] = cosf(new_angle - angle_) * scale;
+		    transform_[0][1] = -sinf(new_angle - angle_) * scale;
+		    transform_[0][2] =
+			center_x - cumulative_transform_[0][2] - original_center_x_;
+		    transform_[1][0] = -transform_[0][1];
+		    transform_[1][1] = transform_[0][0];
+		    transform_[1][2] =
+			center_y - cumulative_transform_[1][2] - original_center_y_;
+	    
+		    scale = original_radius_ > 0 ? new_radius / original_radius_ : 1;
+	    
+		    cumulative_transform_[0][0] = ::cosf( new_angle - original_angle_ ) * scale;
+		    cumulative_transform_[0][1] = -::sinf( new_angle - original_angle_ ) * scale;
+		    cumulative_transform_[0][2] = center_x - original_center_x_;
+		    cumulative_transform_[1][0] = -cumulative_transform_[0][1];
+		    cumulative_transform_[1][1] = cumulative_transform_[0][0];
+		    cumulative_transform_[1][2] = center_y - original_center_y_;
+		} else {
+		    original_radius_ += new_radius - radius_;
+		    original_angle_ += new_angle - angle_;
+		    original_center_x_ +=
+			center_x - (original_center_x_ + cumulative_transform_[0][2]);
+		    original_center_y_ +=
+			center_y - (original_center_y_ + cumulative_transform_[1][2]);
+		}
+	
+		radius_ = new_radius;
+		angle_ = new_angle;
+	    }
+    
+	    uint64_t CumulativeTime() const {
+		return( time_ - gesture_.lock()->start_time() );
+	    }
+    
+	    float CumulativeDrag2() const {
+		float res_x = gesture_.lock()->recognizer().device_x_res();
+		float res_y = gesture_.lock()->recognizer().device_y_res();
+	
+		return fabsf(cumulative_transform_[0][2] / res_x *
+			     cumulative_transform_[0][2] / res_x +
+			     cumulative_transform_[1][2] / res_y * 
+			     cumulative_transform_[1][2] / res_y);
+	    }
+    
+	    float CumulativePinch() const {
+		float pinch = original_radius_ > 0 ? radius_ / original_radius_ : 1;
+	
+		return( pinch < 1 ? 1 / pinch : pinch );
+	    }
+	};
+
+   
+
+	UGSlice::UGSlice( const SharedGesture & gesture, 
+			  UFEvent event, 
+			  const TouchSet & touches,
+			  UGGestureTypeMask recognized) 
+	    : d_( new Private( gesture, event, touches, recognized ) ) {
+	  
+	}
+
+	UGSlice::UGSlice( const SharedUGSlice & prev, 
+			  UFEvent event, 
+			  const TouchSet& touches ) 
+	    : d_( new Private( prev, event, touches ) ) {
+	}
+
+	UGSlice* UGSlice::NewUGSlice( const SharedGesture & gesture, 
+				      UFEvent event,
+				      const TouchSet & touches,
+				      UGGestureTypeMask recognized ) {
+    
+	    UGSlice* slice = new UGSlice(gesture, event, touches, recognized);
+
+	    UFStatus status = frame_event_get_property( event, 
+							UFEventPropertyFrame,
+							&slice->d_->frame_);
+	    if (status != UFStatusSuccess) {
+		fprintf(stderr, "Warning: failed to get frame from event\n");
+		delete slice;	
+		return NULL;
+	    }
+
+	    slice->d_->GetValues( touches, 
+				  &slice->d_->original_center_x_,
+				  &slice->d_->original_center_y_, 
+				  &slice->d_->original_radius_,
+				  &slice->d_->original_angle_, 
+				  true);
+    
+	    slice->d_->radius_ = slice->d_->original_radius_;
+	    slice->d_->angle_ = slice->d_->original_angle_;
+
+	    return slice;
+	}
+
+	UGSlice* UGSlice::NewUGSlice(const SharedUGSlice& prev, UFEvent event,
+				     const TouchSet& touches) {
+	    UGSlice* slice = new UGSlice(prev, event, touches);
+
+	    UFStatus status = frame_event_get_property( event, 
+							UFEventPropertyFrame,
+							&slice->d_->frame_ );
+	    if (status != UFStatusSuccess) {
+		fprintf(stderr, "Warning: failed to get frame from event\n");
+		delete slice;
+		return NULL;
+	    }
+
+	    if (slice->d_->touch_count_changed_) {
+		slice->d_->GetValues( touches, 
+				      &slice->d_->original_center_x_,
+				      &slice->d_->original_center_y_, 
+				      &slice->d_->original_radius_,
+				      &slice->d_->original_angle_, 
+				      true);
+		slice->d_->radius_ = slice->d_->original_radius_;
+		slice->d_->angle_ = slice->d_->original_angle_;
+	    } else {
+		slice->d_->SetTransforms();
+		slice->d_->SetCenterOfRotation();
+		slice->d_->CheckGestureEnd();
+	    }
+
+	    return slice;
+	}
+
+	UGGestureTypeMask UGSlice::CheckRecognition( const UGSubscription & subscription ) {
+	    if ((subscription.mask() & UGGestureTypeDrag ) &&
+		(!subscription.drag().timeout_ ||
+		 d_->CumulativeTime() < subscription.drag().timeout_) &&
+		d_->CumulativeDrag2() > subscription.drag().threshold_)
+		d_->recognized_ |= UGGestureTypeDrag;
+
+	    if ((subscription.mask() & UGGestureTypePinch) &&
+		(!subscription.pinch().timeout_ ||
+		 d_->CumulativeTime() < subscription.pinch().timeout_) &&
+		d_->CumulativePinch() > subscription.pinch().threshold_)
+		d_->recognized_ |= UGGestureTypePinch;
+
+	    if ((subscription.mask() & UGGestureTypeRotate) &&
+		(!subscription.rotate().timeout_ ||
+		 d_->CumulativeTime() < subscription.rotate().timeout_) &&
+		::fabsf( d_->angle_ - d_->original_angle_) > subscription.rotate().threshold_)
+		d_->recognized_ |= UGGestureTypeRotate;
+
+	    if ((subscription.mask() & UGGestureTypeTap) &&
+		d_->CumulativeTime() < subscription.tap().timeout_ &&
+		d_->state_ == UGGestureStateEnd)
+		d_->recognized_ |= UGGestureTypeTap;
+
+	    if (subscription.mask() & UGGestureTypeTouch)
+		d_->recognized_ |= UGGestureTypeTouch;
+
+	    return( d_->recognized_ );
+	}
+
+	// Might be a performance penalty.
+	UGStatus UGSlice::GetTouchId(unsigned int index, void* touch_id) const {
+
+	    assert( touch_id == NULL );
+
+	    auto it = d_->touches_.begin();
+	    for( unsigned int i = 0; i < index; ++i, ++it )
+		if( it == d_->touches_.end() )
+		    return UGStatusErrorInvalidIndex;
+
+	    *reinterpret_cast<unsigned int*>( touch_id ) = *it;
+	    return( UGStatusSuccess );
+	}
+
+	UGStatus UGSlice::GetProperty(UGSliceProperty property, void* value) const {
+	    assert( value == NULL );
+	    switch( property ) {
+	    case UGSlicePropertyId:
+		*reinterpret_cast<unsigned int*>(value) = d_->gesture_.lock()->id();
+		return UGStatusSuccess;
+
+	    case UGSlicePropertyState:
+		*reinterpret_cast<UGGestureState*>( value ) = d_->state_;
+		return UGStatusSuccess;
+
+	    case UGSlicePropertySubscription:
+		*reinterpret_cast<void**>( value ) = d_->gesture_.lock()->subscription();
+		return UGStatusSuccess;
+
+	    case UGSlicePropertyRecognized:
+		*reinterpret_cast<UGGestureTypeMask*>(value) = d_->recognized_;
+		return UGStatusSuccess;
+
+	    case UGSlicePropertyNumTouches:
+		*reinterpret_cast<unsigned int*>(value) = d_->touches_.size();
+		return UGStatusSuccess;
+
+	    case UGSlicePropertyFrame:
+		*reinterpret_cast<UFFrame*>(value) = d_->frame_;
+		return UGStatusSuccess;
+
+	    case UGSlicePropertyOriginalCenterX:
+		*reinterpret_cast<float*>(value) = d_->original_center_x_;
+		return UGStatusSuccess;
+
+	    case UGSlicePropertyOriginalCenterY:
+		*reinterpret_cast<float*>(value) = d_->original_center_y_;
+		return UGStatusSuccess;
+
+	    case UGSlicePropertyOriginalRadius:
+		*reinterpret_cast<float*>(value) = d_->original_radius_;
+		return UGStatusSuccess;
+
+	    case UGSlicePropertyTransform:
+		*reinterpret_cast<UGTransform**>(value) = &d_->transform_;
+		return UGStatusSuccess;
+
+	    case UGSlicePropertyCumulativeTransform:
+		*reinterpret_cast<UGTransform**>(value) = &d_->cumulative_transform_;
+		return UGStatusSuccess;
+
+	    case UGSlicePropertyCenterOfRotationX:
+		*reinterpret_cast<float*>(value) = d_->center_of_rotation_x_;
+		return UGStatusSuccess;
+
+	    case UGSlicePropertyCenterOfRotationY:
+		*reinterpret_cast<float*>(value) = d_->center_of_rotation_y_;
+		return UGStatusSuccess;
+	    default:
+		break;
+	    }
+
+	    return UGStatusErrorUnknownProperty;
+	}
+
+	void UGSlice::ReferenceGesture() { 
+	    d_->gesture_ref_ = d_->gesture_.lock(); 
+	}
+
+	uint64_t UGSlice::time() const { 
+	    return d_->time_; 
+	}
+
+	const TouchSet & UGSlice::touches() { 
+	    return d_->touches_; 
+	}
+
+	const UFFrame & UGSlice::frame() { 
+	    return d_->frame_; 
+	}
+
+	UGGestureState UGSlice::state() const { 
+	    return d_->state_; 
+	}
+	
+	void UGSlice::set_state( UGGestureState state ) { 
+	    d_->state_ = state; 
+	}
+
+    }
+    // extern "C" {
+
+    UGStatus grail_slice_get_property( const UGSlice slice, 
+				       UGSliceProperty property,
+				       void* value) {
+	if( slice == NULL )
+	    return( UGStatusErrorGeneric );
+
+	return static_cast< const utouch::grail::UGSlice* >( slice )->GetProperty(property, value);
+    }
+
+    unsigned int grail_slice_get_id(const UGSlice slice) {
+	if( slice == NULL )
+	    return( UGStatusErrorGeneric );
+	unsigned int id;
+	UGStatus status = static_cast< const utouch::grail::UGSlice*>( slice )->GetProperty(UGSlicePropertyId, &id);
+	assert(status == UGStatusSuccess);
+	return id;
+    }
+
+    UGGestureState grail_slice_get_state(const UGSlice slice) {
+	assert( slice == NULL );
+	UGGestureState state;
+	UGStatus status = static_cast< const utouch::grail::UGSlice* >( slice )->GetProperty(UGSlicePropertyState, &state);
+	assert(status == UGStatusSuccess);
+	return state;
+    }
+
+    UGGestureTypeMask grail_slice_get_recognized(const UGSlice slice) {
+	if( slice == NULL )
+	    return( UGStatusErrorGeneric );
+    
+	UGGestureTypeMask mask;
+	UGStatus status = static_cast< const utouch::grail::UGSlice* >( slice )->GetProperty(UGSlicePropertyRecognized, &mask);
+	assert(status == UGStatusSuccess);
+	return mask;
+    }
+
+    UGSubscription grail_slice_get_subscription(const UGSlice slice) {
+	assert( slice == NULL );
+	
+	UGSubscription subscription;
+	UGStatus status = static_cast< const utouch::grail::UGSlice* >( slice )->GetProperty(UGSlicePropertySubscription,
+										     &subscription);
+	assert(status == UGStatusSuccess);
+	return subscription;
+    }
+
+    unsigned int grail_slice_get_num_touches(const UGSlice slice) {
+	assert( slice == NULL );
+
+	unsigned int num_touches;
+	UGStatus status = static_cast< const utouch::grail::UGSlice* >( slice )->GetProperty(UGSlicePropertyNumTouches, &num_touches);
+	assert(status == UGStatusSuccess);
+	return num_touches;
+    }
+
+    UGStatus grail_slice_get_touch_id(const UGSlice slice, unsigned int index,
+				      void *touch_id) {
+	if( slice == NULL )
+	    return( UGStatusErrorGeneric );
+	return static_cast< const utouch::grail::UGSlice* >( slice )->GetTouchId(index, touch_id);
+    }
+
+    float grail_slice_get_original_center_x(const UGSlice slice) {
+	if( slice == NULL )
+	    return( UGStatusErrorGeneric );
+	float x;
+	UGStatus status = static_cast< const utouch::grail::UGSlice* >( slice )->GetProperty(UGSlicePropertyOriginalCenterX, &x);
+	assert(status == UGStatusSuccess);
+	return x;
+    }
+
+    float grail_slice_get_original_center_y(const UGSlice slice) {
+	if( slice == NULL )
+	    return( UGStatusErrorGeneric );
+	float y;
+	UGStatus status = static_cast< const utouch::grail::UGSlice* >( slice )->GetProperty(UGSlicePropertyOriginalCenterY, &y);
+	assert(status == UGStatusSuccess);
+	return y;
+    }
+
+    float grail_slice_get_original_radius(const UGSlice slice) {
+	if( slice == NULL )
+	    return( UGStatusErrorGeneric );
+	float radius;
+	UGStatus status = static_cast< const utouch::grail::UGSlice* >( slice )->GetProperty(UGSlicePropertyOriginalRadius, &radius);
+	assert(status == UGStatusSuccess);
+	return radius;
+    }
+
+    float grail_slice_get_center_of_rotation_x(const UGSlice slice) {
+	if( slice == NULL )
+	    return( UGStatusErrorGeneric );
+	float x;
+	UGStatus status = static_cast< const utouch::grail::UGSlice* >( slice )->GetProperty(UGSlicePropertyCenterOfRotationX, &x);
+	assert(status == UGStatusSuccess);
+	return x;
+    }
+
+    float grail_slice_get_center_of_rotation_y(const UGSlice slice) {
+	if( slice == NULL )
+	    return( UGStatusErrorGeneric );
+	float y;
+	UGStatus status = static_cast< const utouch::grail::UGSlice* >( slice )->GetProperty(UGSlicePropertyCenterOfRotationY, &y);
+	assert(status == UGStatusSuccess);
+	return y;
+    }
+
+    const UGTransform *grail_slice_get_transform(const UGSlice slice) {
+	assert( slice == NULL );
+
+	UGTransform *transform;
+	UGStatus status = static_cast< const utouch::grail::UGSlice* >( slice )->GetProperty(UGSlicePropertyTransform, &transform);
+	assert(status == UGStatusSuccess);
+	return transform;
+    }
+
+    const UGTransform *grail_slice_get_cumulative_transform(const UGSlice slice) {
+	assert( slice == NULL );
+
+	UGTransform *transform;
+	UGStatus status = static_cast< const utouch::grail::UGSlice* >( slice )->GetProperty(UGSlicePropertyCumulativeTransform,
+										     &transform);
+	assert(status == UGStatusSuccess);
+	return transform;
+    }
+
+    const UFFrame grail_slice_get_frame(const UGSlice slice) {
+	assert( slice == NULL );
+
+	UFFrame frame;
+	UGStatus status = static_cast< const utouch::grail::UGSlice* >( slice )->GetProperty(UGSlicePropertyFrame, &frame);
+	assert(status == UGStatusSuccess);
+	return frame;
+    }
+}
+// } // extern "C"
 
=== modified file 'src/v3/slice.h'
--- src/v3/slice.h	2011-10-20 23:55:57 +0000
+++ src/v3/slice.h	2011-11-01 21:20:40 +0000
@@ -27,69 +27,61 @@
 
 #include "utouch/grail.h"
 
-class Gesture;
-
-typedef std::shared_ptr<Gesture> SharedGesture;
-typedef std::shared_ptr<UGSlice_> SharedUGSlice_;
-typedef std::set<unsigned int> TouchSet;
-
-class UGSlice_ {
- public:
-  static UGSlice_* NewUGSlice_(const SharedGesture& gesture, UFEvent event,
-                               const TouchSet& touches,
-                               UGGestureTypeMask recognized);
-  static UGSlice_* NewUGSlice_(const SharedUGSlice_& prev, UFEvent event,
-                               const TouchSet& touches);
-
-  ~UGSlice_();
-
-  void CheckGestureEnd();
-  UGGestureTypeMask CheckRecognition(const UGSubscription_& subscription);
-  UGStatus GetTouchId(unsigned int index, void* touch_id) const;
-  UGStatus GetProperty(UGSliceProperty property, void* value) const;
-  void ReferenceGesture() { gesture_ref_ = gesture_.lock(); }
-
-  uint64_t time() const { return time_; }
-  const TouchSet& touches() { return touches_; }
-  const UFFrame& frame() { return frame_; }
-  UGGestureState state() const { return state_; }
-  void set_state(UGGestureState state) { state_ = state; }
-
-  UGSlice_(const UGSlice_&) = delete;
-  void operator=(const UGSlice_&) = delete;
-
- private:
-  const std::weak_ptr<Gesture> gesture_;
-  SharedGesture gesture_ref_;
-  const UFEvent event_;
-  UFFrame frame_;
-  TouchSet touches_;
-  uint64_t time_;
-  UGGestureState state_;
-  float original_center_x_;
-  float original_center_y_;
-  float original_radius_;
-  float original_angle_;
-  float radius_;
-  float angle_;
-  float transform_[3][3];
-  float cumulative_transform_[3][3];
-  float center_of_rotation_x_;
-  float center_of_rotation_y_;
-  UGGestureTypeMask recognized_;
-  bool touch_count_changed_;
-
-  UGSlice_(const SharedGesture& gesture, UFEvent event, const TouchSet& touches,
-           UGGestureTypeMask recognized);
-  UGSlice_(const SharedUGSlice_& prev, UFEvent event, const TouchSet& touches);
-
-  void GetValues(const TouchSet& touches, float* x, float* y, float* radius,
-                 float* angle, bool init);
-  void SetTransforms();
-  void SetCenterOfRotation();
-  uint64_t CumulativeTime() const;
-  float CumulativeDrag2() const;
-  float CumulativePinch() const;
-};
-
+namespace utouch {
+    namespace grail {
+
+	class Gesture;
+
+	class UGSlice;
+	class UGSubscription;
+    
+	typedef std::shared_ptr<Gesture> SharedGesture;
+	typedef std::shared_ptr<UGSlice> SharedUGSlice;
+	typedef std::set<unsigned int> TouchSet;
+
+	class UGSlice {
+	public:
+	
+	    static UGSlice* NewUGSlice(const SharedGesture& gesture, UFEvent event,
+				       const TouchSet& touches,
+				       UGGestureTypeMask recognized);
+	    static UGSlice* NewUGSlice(const SharedUGSlice& prev, UFEvent event,
+				       const TouchSet& touches);
+
+	    void CheckGestureEnd();
+	
+	    UGGestureTypeMask CheckRecognition( const UGSubscription & subscription );
+
+	    UGStatus GetTouchId(unsigned int index, void* touch_id) const;
+
+	    UGStatus GetProperty(UGSliceProperty property, void* value) const;
+
+	    void ReferenceGesture();
+
+	    uint64_t time() const;
+	    const TouchSet& touches();
+	    const UFFrame& frame();
+	    UGGestureState state() const;
+	    void set_state( UGGestureState state );
+
+	    // Disable compiler generated c'tor, copy c'tor and assignment operator.	
+	    UGSlice( const UGSlice & ) = delete;
+	    // void operator=( const UGSlice & ) = delete;
+	    bool operator==( const UGSlice & ) const = delete;
+	
+	protected:
+	    struct Private;
+	    std::shared_ptr< Private > d_;
+
+	    UGSlice( const SharedGesture & gesture, 
+		     UFEvent event, 
+		     const TouchSet & touches,
+		     UGGestureTypeMask recognized);
+
+	    UGSlice( const SharedUGSlice & prev, 
+		     UFEvent event, 
+		     const TouchSet& touches );
+	};
+    }
+}
 #endif // UTOUCH_GRAIL_SLICE_H_
 
=== modified file 'src/v3/subscription.cpp'
--- src/v3/subscription.cpp	2011-10-20 16:00:48 +0000
+++ src/v3/subscription.cpp	2011-11-01 21:20:40 +0000
@@ -21,265 +21,303 @@
 
 #include "v3/subscription.h"
 
-#include <math.h>
-
-Limit::Limit(UGGestureType type) {
-  switch (type) {
-    case UGGestureTypeDrag:
-      timeout_ = 300;
-      threshold_ = 2.6;
-      break;
-
-    case UGGestureTypePinch:
-      timeout_ = 300;
-      threshold_ = 1.1; /* Different from grail v1, ratio instead of delta */
-      break;
-
-    case UGGestureTypeRotate:
-      timeout_ = 500;
-      threshold_ = 2 * M_PI / 50;
-      break;
-
-    case UGGestureTypeTap:
-      timeout_ = 300;
-      threshold_ = 0;
-      break;
-
-    case UGGestureTypeTouch:
-      timeout_ = 0;
-      threshold_ = 0;
-      break;
-  }
-}
-
-UGSubscription_::UGSubscription_()
-    : device_(0),
-      window_(0),
-      mask_(0),
-      touches_start_(2),
-      touches_min_(0),
-      touches_max_(0),
-      drag_(UGGestureTypeDrag),
-      pinch_(UGGestureTypePinch),
-      rotate_(UGGestureTypeRotate),
-      tap_(UGGestureTypeTap) {
-}
-
-bool UGSubscription_::IsValid() const {
-  if (!device_ ||
-      !window_ ||
-      mask_ == 0 ||
-      (touches_max_ && touches_start_ > touches_max_) ||
-      (touches_min_ && touches_start_ < touches_min_))
-    return false;
-
-  return true;
-}
-
-UGStatus UGSubscription_::SetProperty(UGSubscriptionProperty property,
-                                      const void* value) {
-  switch (property) {
-    case UGSubscriptionPropertyDevice: {
-      UFDevice device = *reinterpret_cast<const UFDevice*>(value);
-      if (!device)
-        return UGStatusErrorInvalidValue;
-      device_ = device;
-      return UGStatusSuccess;
-    }
-
-    case UGSubscriptionPropertyWindow: {
-      Window window = *reinterpret_cast<const Window*>(value);
-      if (!window)
-        return UGStatusErrorInvalidValue;
-      window_ = window;
-      return UGStatusSuccess;
-    }
-
-    case UGSubscriptionPropertyMask: {
-      UGGestureTypeMask mask =
-          *reinterpret_cast<const UGGestureTypeMask*>(value);
-      if (mask == 0)
-        return UGStatusErrorInvalidValue;
-      mask_ = mask;
-      return UGStatusSuccess;
-    }
-
-    case UGSubscriptionPropertyTouchesStart: {
-      unsigned int touches = *reinterpret_cast<const unsigned int*>(value);
-      if (touches == 0 || touches > 5)
-        return UGStatusErrorInvalidValue;
-      touches_start_ = touches;
-      return UGStatusSuccess;
-    }
-
-    case UGSubscriptionPropertyTouchesMinimum: {
-      unsigned int touches = *reinterpret_cast<const unsigned int*>(value);
-      if (touches == 0 || touches > 5)
-        return UGStatusErrorInvalidValue;
-      touches_min_ = touches;
-      return UGStatusSuccess;
-    }
-
-    case UGSubscriptionPropertyTouchesMaximum: {
-      unsigned int touches = *reinterpret_cast<const unsigned int*>(value);
-      if (touches == 0 || touches > 5)
-        return UGStatusErrorInvalidValue;
-      touches_max_ = touches;
-      return UGStatusSuccess;
-    }
-
-    case UGSubscriptionPropertyDragTimeout: {
-      uint64_t timeout = *reinterpret_cast<const uint64_t*>(value);
-      if (timeout < 0)
-        return UGStatusErrorInvalidValue;
-      drag_.set_timeout(timeout);
-      return UGStatusSuccess;
-    }
-
-    case UGSubscriptionPropertyDragThreshold: {
-      float threshold = *reinterpret_cast<const float*>(value);
-      if (threshold < 0)
-        return UGStatusErrorInvalidValue;
-      drag_.set_threshold(threshold);
-      return UGStatusSuccess;
-    }
-
-    case UGSubscriptionPropertyPinchTimeout: {
-      uint64_t timeout = *reinterpret_cast<const uint64_t*>(value);
-      if (timeout < 0)
-        return UGStatusErrorInvalidValue;
-      pinch_.set_timeout(timeout);
-      return UGStatusSuccess;
-    }
-
-    case UGSubscriptionPropertyPinchThreshold: {
-      float threshold = *reinterpret_cast<const float*>(value);
-      if (threshold < 0)
-        return UGStatusErrorInvalidValue;
-      pinch_.set_threshold(threshold);
-      return UGStatusSuccess;
-    }
-
-    case UGSubscriptionPropertyRotateTimeout: {
-      uint64_t timeout = *reinterpret_cast<const uint64_t*>(value);
-      if (timeout < 0)
-        return UGStatusErrorInvalidValue;
-      rotate_.set_timeout(timeout);
-      return UGStatusSuccess;
-    }
-
-    case UGSubscriptionPropertyRotateThreshold: {
-      float threshold = *reinterpret_cast<const float*>(value);
-      if (threshold < 0)
-        return UGStatusErrorInvalidValue;
-      rotate_.set_threshold(threshold);
-      return UGStatusSuccess;
-    }
-
-    case UGSubscriptionPropertyTapTimeout: {
-      uint64_t timeout = *reinterpret_cast<const uint64_t*>(value);
-      if (timeout < 0)
-        return UGStatusErrorInvalidValue;
-      tap_.set_timeout(timeout);
-      return UGStatusSuccess;
-    }
-
-    case UGSubscriptionPropertyTapThreshold: {
-      float threshold = *reinterpret_cast<const float*>(value);
-      if (threshold < 0)
-        return UGStatusErrorInvalidValue;
-      tap_.set_threshold(threshold);
-      return UGStatusSuccess;
-    }
-  }
-
-  return UGStatusErrorUnknownProperty;
-}
-
-UGStatus UGSubscription_::GetProperty(UGSubscriptionProperty property,
-                                      void* value) const {
-  switch (property) {
-    case UGSubscriptionPropertyDevice:
-      *reinterpret_cast<UFDevice*>(value) = device_;
-      return UGStatusSuccess;
-
-    case UGSubscriptionPropertyWindow:
-      *reinterpret_cast<Window*>(value) = window_;
-      return UGStatusSuccess;
-
-    case UGSubscriptionPropertyMask:
-      *reinterpret_cast<UGGestureTypeMask*>(value) = mask_;
-      return UGStatusSuccess;
-
-    case UGSubscriptionPropertyTouchesStart:
-      *reinterpret_cast<unsigned int*>(value) = touches_start_;
-      return UGStatusSuccess;
-
-    case UGSubscriptionPropertyTouchesMinimum:
-      *reinterpret_cast<unsigned int*>(value) = touches_min_;
-      return UGStatusSuccess;
-
-    case UGSubscriptionPropertyTouchesMaximum:
-      *reinterpret_cast<unsigned int*>(value) = touches_max_;
-      return UGStatusSuccess;
-
-    case UGSubscriptionPropertyDragTimeout:
-      *reinterpret_cast<uint64_t*>(value) = drag_.timeout();
-      return UGStatusSuccess;
-
-    case UGSubscriptionPropertyDragThreshold:
-      *reinterpret_cast<float*>(value) = drag_.threshold();
-      return UGStatusSuccess;
-
-    case UGSubscriptionPropertyPinchTimeout:
-      *reinterpret_cast<uint64_t*>(value) = pinch_.timeout();
-      return UGStatusSuccess;
-
-    case UGSubscriptionPropertyPinchThreshold:
-      *reinterpret_cast<float*>(value) = pinch_.threshold();
-      return UGStatusSuccess;
-
-    case UGSubscriptionPropertyRotateTimeout:
-      *reinterpret_cast<uint64_t*>(value) = rotate_.timeout();
-      return UGStatusSuccess;
-
-    case UGSubscriptionPropertyRotateThreshold:
-      *reinterpret_cast<float*>(value) = rotate_.threshold();
-      return UGStatusSuccess;
-
-    case UGSubscriptionPropertyTapTimeout:
-      *reinterpret_cast<uint64_t*>(value) = tap_.timeout();
-      return UGStatusSuccess;
-
-    case UGSubscriptionPropertyTapThreshold:
-      *reinterpret_cast<float*>(value) = tap_.threshold();
-      return UGStatusSuccess;
-  }
-
-  return UGStatusErrorUnknownProperty;
-}
-
-extern "C" {
-
-UGStatus grail_subscription_new(UGSubscription* subscription) {
-  *subscription = new UGSubscription_;
-  return UGStatusSuccess;
+#include <cassert>
+#include <cmath>
+
+namespace utouch {
+    namespace grail {
+
+	UGSubscription::Limit::Limit(UGGestureType type) {
+	    switch (type) {
+	    case UGGestureTypeDrag:
+		timeout_ = 300;
+		threshold_ = 2.6;
+		break;
+
+	    case UGGestureTypePinch:
+		timeout_ = 300;
+		threshold_ = 1.1; /* Different from grail v1, ratio instead of delta */
+		break;
+
+	    case UGGestureTypeRotate:
+		timeout_ = 500;
+		threshold_ = 2 * M_PI / 50;
+		break;
+
+	    case UGGestureTypeTap:
+		timeout_ = 300;
+		threshold_ = 0;
+		break;
+
+	    case UGGestureTypeTouch:
+		timeout_ = 0;
+		threshold_ = 0;
+		break;
+	    }
+	}
+
+	struct UGSubscription::Private {
+
+	    Private() : device_(0),
+			window_(0),
+			mask_(0),
+			touches_start_(2),
+			touches_min_(0),
+			touches_max_(0),
+			drag_(UGGestureTypeDrag),
+			pinch_(UGGestureTypePinch),
+			rotate_(UGGestureTypeRotate),
+			tap_(UGGestureTypeTap) {
+	    }
+
+	    UFDevice device_;
+	    Window window_;
+	    UGGestureTypeMask mask_;
+	    unsigned int touches_start_;
+	    unsigned int touches_min_;
+	    unsigned int touches_max_;
+	    Limit drag_;
+	    Limit pinch_;
+	    Limit rotate_;
+	    Limit tap_;
+	};
+
+	UGSubscription::UGSubscription()
+	    : d_( new Private() ) {
+	}
+
+	bool UGSubscription::IsValid() const {
+	    if (!d_->device_ ||
+		!d_->window_ ||
+		d_->mask_ == 0 ||
+		(d_->touches_max_ && d_->touches_start_ > d_->touches_max_) ||
+		(d_->touches_min_ && d_->touches_start_ < d_->touches_min_))
+		return false;
+
+	    return true;
+	}
+
+	UGStatus UGSubscription::SetProperty(UGSubscriptionProperty property,
+					     const void* value) {
+	
+	    assert( value == NULL );
+	
+	    switch (property) {
+	    case UGSubscriptionPropertyDevice: {
+		UFDevice device = *reinterpret_cast<const UFDevice*>(value);
+		if (!device)
+		    return UGStatusErrorInvalidValue;
+		d_->device_ = device;
+		return UGStatusSuccess;
+	    }
+
+	    case UGSubscriptionPropertyWindow: {
+		Window window = *reinterpret_cast<const Window*>(value);
+		if (!window)
+		    return UGStatusErrorInvalidValue;
+		d_->window_ = window;
+		return UGStatusSuccess;
+	    }
+
+	    case UGSubscriptionPropertyMask: {
+		UGGestureTypeMask mask =
+		    *reinterpret_cast<const UGGestureTypeMask*>(value);
+		if (mask == 0)
+		    return UGStatusErrorInvalidValue;
+		d_->mask_ = mask;
+		return UGStatusSuccess;
+	    }
+
+	    case UGSubscriptionPropertyTouchesStart: {
+		unsigned int touches = *reinterpret_cast<const unsigned int*>(value);
+		if (touches == 0 || touches > 5)
+		    return UGStatusErrorInvalidValue;
+		d_->touches_start_ = touches;
+		return UGStatusSuccess;
+	    }
+
+	    case UGSubscriptionPropertyTouchesMinimum: {
+		unsigned int touches = *reinterpret_cast<const unsigned int*>(value);
+		if (touches == 0 || touches > 5)
+		    return UGStatusErrorInvalidValue;
+		d_->touches_min_ = touches;
+		return UGStatusSuccess;
+	    }
+
+	    case UGSubscriptionPropertyTouchesMaximum: {
+		unsigned int touches = *reinterpret_cast<const unsigned int*>(value);
+		if (touches == 0 || touches > 5)
+		    return UGStatusErrorInvalidValue;
+		d_->touches_max_ = touches;
+		return UGStatusSuccess;
+	    }
+
+	    case UGSubscriptionPropertyDragTimeout: {
+		uint64_t timeout = *reinterpret_cast<const uint64_t*>(value);
+		if (timeout < 0)
+		    return UGStatusErrorInvalidValue;
+		d_->drag_.timeout_ = timeout;
+		return UGStatusSuccess;
+	    }
+
+	    case UGSubscriptionPropertyDragThreshold: {
+		float threshold = *reinterpret_cast<const float*>(value);
+		if (threshold < 0)
+		    return UGStatusErrorInvalidValue;
+		d_->drag_.threshold_ = threshold;
+		return UGStatusSuccess;
+	    }
+
+	    case UGSubscriptionPropertyPinchTimeout: {
+		uint64_t timeout = *reinterpret_cast<const uint64_t*>(value);
+		if (timeout < 0)
+		    return UGStatusErrorInvalidValue;
+		d_->pinch_.timeout_ = timeout;
+		return UGStatusSuccess;
+	    }
+
+	    case UGSubscriptionPropertyPinchThreshold: {
+		float threshold = *reinterpret_cast<const float*>(value);
+		if (threshold < 0)
+		    return UGStatusErrorInvalidValue;
+		d_->pinch_.threshold_ = threshold;
+		return UGStatusSuccess;
+	    }
+
+	    case UGSubscriptionPropertyRotateTimeout: {
+		uint64_t timeout = *reinterpret_cast<const uint64_t*>(value);
+		if (timeout < 0)
+		    return UGStatusErrorInvalidValue;
+		d_->rotate_.timeout_ = timeout;
+		return UGStatusSuccess;
+	    }
+
+	    case UGSubscriptionPropertyRotateThreshold: {
+		float threshold = *reinterpret_cast<const float*>(value);
+		if (threshold < 0)
+		    return UGStatusErrorInvalidValue;
+		d_->rotate_.threshold_ = threshold;
+		return UGStatusSuccess;
+	    }
+
+	    case UGSubscriptionPropertyTapTimeout: {
+		uint64_t timeout = *reinterpret_cast<const uint64_t*>(value);
+		if (timeout < 0)
+		    return UGStatusErrorInvalidValue;
+		d_->tap_.timeout_ = timeout;
+		return UGStatusSuccess;
+	    }
+
+	    case UGSubscriptionPropertyTapThreshold: {
+		float threshold = *reinterpret_cast<const float*>(value);
+		if (threshold < 0)
+		    return UGStatusErrorInvalidValue;
+		d_->tap_.threshold_ = threshold;
+		return UGStatusSuccess;
+	    }
+	    }
+
+	    return UGStatusErrorUnknownProperty;
+	}
+    
+	UGStatus UGSubscription::GetProperty(UGSubscriptionProperty property,
+					     void* value) const {
+	    assert( value == NULL );
+	    switch (property) {
+	    case UGSubscriptionPropertyDevice:
+		*reinterpret_cast<UFDevice*>(value) = d_->device_;
+		return UGStatusSuccess;
+	    
+	    case UGSubscriptionPropertyWindow:
+		*reinterpret_cast<Window*>(value) = d_->window_;
+		return UGStatusSuccess;
+	    
+	    case UGSubscriptionPropertyMask:
+		*reinterpret_cast<UGGestureTypeMask*>(value) = d_->mask_;
+		return UGStatusSuccess;
+
+	    case UGSubscriptionPropertyTouchesStart:
+		*reinterpret_cast<unsigned int*>(value) = d_->touches_start_;
+		return UGStatusSuccess;
+
+	    case UGSubscriptionPropertyTouchesMinimum:
+		*reinterpret_cast<unsigned int*>(value) = d_->touches_min_;
+		return UGStatusSuccess;
+
+	    case UGSubscriptionPropertyTouchesMaximum:
+		*reinterpret_cast<unsigned int*>(value) = d_->touches_max_;
+		return UGStatusSuccess;
+
+	    case UGSubscriptionPropertyDragTimeout:
+		*reinterpret_cast<uint64_t*>(value) = d_->drag_.timeout_;
+		return UGStatusSuccess;
+
+	    case UGSubscriptionPropertyDragThreshold:
+		*reinterpret_cast<float*>(value) = d_->drag_.threshold_;
+		return UGStatusSuccess;
+
+	    case UGSubscriptionPropertyPinchTimeout:
+		*reinterpret_cast<uint64_t*>(value) = d_->pinch_.timeout_;
+		return UGStatusSuccess;
+
+	    case UGSubscriptionPropertyPinchThreshold:
+		*reinterpret_cast<float*>(value) = d_->pinch_.threshold_;
+		return UGStatusSuccess;
+
+	    case UGSubscriptionPropertyRotateTimeout:
+		*reinterpret_cast<uint64_t*>(value) = d_->rotate_.timeout_;
+		return UGStatusSuccess;
+
+	    case UGSubscriptionPropertyRotateThreshold:
+		*reinterpret_cast<float*>(value) = d_->rotate_.threshold_;
+		return UGStatusSuccess;
+
+	    case UGSubscriptionPropertyTapTimeout:
+		*reinterpret_cast<uint64_t*>(value) = d_->tap_.timeout_;
+		return UGStatusSuccess;
+
+	    case UGSubscriptionPropertyTapThreshold:
+		*reinterpret_cast<float*>(value) = d_->tap_.threshold_;
+		return UGStatusSuccess;
+	    }
+
+	    return UGStatusErrorUnknownProperty;
+	}
+
+	UFDevice UGSubscription::device() const { return d_->device_; }
+	Window UGSubscription::window() const { return d_->window_; }
+	UGGestureTypeMask UGSubscription::mask() const { return d_->mask_; }
+	unsigned int UGSubscription::touches_start() const { return d_->touches_start_; }
+	unsigned int UGSubscription::touches_min() const { return d_->touches_min_; }
+	unsigned int UGSubscription::touches_max() const { return d_->touches_max_; }
+    
+	const UGSubscription::Limit & UGSubscription::drag() const { return d_->drag_; }
+	const UGSubscription::Limit & UGSubscription::pinch() const { return d_->pinch_; }
+	const UGSubscription::Limit & UGSubscription::rotate() const { return d_->rotate_; }
+	const UGSubscription::Limit & UGSubscription::tap() const { return d_->tap_; }
+    }
+}
+// extern "C" {
+
+UGStatus grail_subscription_new(UGSubscription * subscription) {
+    *subscription = new UGSubscription();
+    return UGStatusSuccess;
 }
 
 void grail_subscription_delete(UGSubscription subscription) {
-  delete subscription;
+    delete( static_cast< utouch::grail::UGSubscription* >( subscription ) );
 }
 
-UGStatus grail_subscription_set_property(UGSubscription subscription,
-                                         UGSubscriptionProperty property,
-                                         const void* value) {
-  return subscription->SetProperty(property, value);
+UGStatus grail_subscription_set_property( UGSubscription subscription,
+                                          UGSubscriptionProperty property,
+                                          const void* value) {
+    return( static_cast< utouch::grail::UGSubscription* >( subscription )->SetProperty(property, value ) );
 }
 
 UGStatus grail_subscription_get_property(UGSubscription subscription,
                                          UGSubscriptionProperty property,
                                          void* value) {
-  return subscription->GetProperty(property, value);
+    return( static_cast< utouch::grail::UGSubscription* >( subscription )->GetProperty(property, value) );
 }
 
-} // extern "C"
+// } // extern "C"
 
=== modified file 'src/v3/subscription.h'
--- src/v3/subscription.h	2011-10-12 23:36:27 +0000
+++ src/v3/subscription.h	2011-11-01 21:20:40 +0000
@@ -26,58 +26,47 @@
 
 #include "utouch/grail.h"
 
-class Limit {
- public:
-  explicit Limit(UGGestureType type);
-
-  uint64_t timeout() const { return timeout_; }
-  float threshold() const { return threshold_; }
-
-  Limit(const Limit&) = delete;
-  void operator=(const Limit&) = delete;
-
- private:
-  void set_timeout(uint64_t timeout) { timeout_ = timeout; }
-  void set_threshold(float threshold) { threshold_ = threshold; }
-  uint64_t timeout_;
-  float threshold_;
-
-  friend class UGSubscription_;
-};
-
-class UGSubscription_ {
- public:
-  UGSubscription_();
-
-  bool IsValid() const;
-  UGStatus SetProperty(UGSubscriptionProperty property, const void* value);
-  UGStatus GetProperty(UGSubscriptionProperty property, void* value) const;
-
-  UFDevice device() const { return device_; }
-  Window window() const { return window_; }
-  UGGestureTypeMask mask() const { return mask_; }
-  unsigned int touches_start() const { return touches_start_; }
-  unsigned int touches_min() const { return touches_min_; }
-  unsigned int touches_max() const { return touches_max_; }
-  const Limit& drag() const { return drag_; }
-  const Limit& pinch() const { return pinch_; }
-  const Limit& rotate() const { return rotate_; }
-  const Limit& tap() const { return tap_; }
-
-  UGSubscription_(const UGSubscription_&) = delete;
-  void operator=(const UGSubscription_&) = delete;
-
- private:
-  UFDevice device_;
-  Window window_;
-  UGGestureTypeMask mask_;
-  unsigned int touches_start_;
-  unsigned int touches_min_;
-  unsigned int touches_max_;
-  Limit drag_;
-  Limit pinch_;
-  Limit rotate_;
-  Limit tap_;
-};
-
+#include <memory>
+
+namespace utouch {
+    namespace grail {
+
+	class UGSubscription {
+	public:
+	    
+	    struct Limit {
+		explicit Limit( UGGestureType type );
+
+		uint64_t timeout_;
+		float threshold_;
+	    };
+	    
+	    UGSubscription();
+
+	    bool IsValid() const;
+  
+	    UGStatus SetProperty(UGSubscriptionProperty property, const void* value);
+	    UGStatus GetProperty(UGSubscriptionProperty property, void* value) const;
+
+	    UFDevice device() const;
+	    Window window() const;
+	    UGGestureTypeMask mask() const;
+	    unsigned int touches_start() const;
+	    unsigned int touches_min() const;
+	    unsigned int touches_max() const;
+	
+	    const Limit & drag() const;
+	    const Limit & pinch() const;
+	    const Limit & rotate() const;
+	    const Limit & tap() const;
+
+	    UGSubscription(const UGSubscription & ) = delete;
+	    UGSubscription & operator=(const UGSubscription & ) = delete;
+
+	protected:
+	    struct Private;
+	    std::shared_ptr< Private > d_;
+	};
+    }
+}
 #endif // UTOUCH_GRAIL_SUBSCRIPTION_H_