Merge lp:~chasedouglas/grail/touch-states into lp:grail

[Chase Douglas]

Fix touch state accounting. With this branch, unity gestures should
function appropriately, modulo bugs in unity itself.

I am proposing this now so the code can be reviewed. I will write a test
and propose it before merging this branch.

If this is deemed to be an inappropriate fix, we can take some of the
individual fixes that really fix things and backport them to the current
code. However, I think this gives us a better base going forward for
touch accounting.

The branch contains some miscellaneous format cleanups here and there.
They are all indentation fixes IIRC.

[Daniel d'Andrada (dandrader)]

* some changes merely fix indentation. That pollutes the commit diff and bzr history.
* touch.h and touch.cpp headers should have a 2012 copyright and should be LGPL.
* I don't like the cyclic reference "Touch <-> Recognizer" even though Touch doesn't hold a shared_ptr of Recognizer. I think it would be cleaner to pass device and window_id to Touch instead of the recognizer himself. As for the Recognizer::DeleteTouch() call, since recognizer holds weak pointers things are still under control. When querying all_touches_ you would just have to also check whether the content is null and if so remove it from the list. Can we use sigc++ or some library that provides signals and slots? That would be the best solution.

[Chase Douglas (chasedouglas)]

> * some changes merely fix indentation. That pollutes the commit diff and bzr
> history.

I don't usually see any issues with fixing formatting as you go. It would be nicer to always have it split out into separate commits, but the burden for maintaining those commits usually means people don't bother with them, even when it's within the same area of code. In other words, I would rather allow for a few format fixes than potentially forgo format fixing contributions because of the extra effort involved for trivial gain.

I wouldn't mind proposing this as a question to the utouch team to get feedback and make a policy decision.

> * touch.h and touch.cpp headers should have a 2012 copyright and should be
> LGPL.

Good catch :).

> * I don't like the cyclic reference "Touch <-> Recognizer" even though Touch
> doesn't hold a shared_ptr of Recognizer. I think it would be cleaner to pass
> device and window_id to Touch instead of the recognizer himself. As for the
> Recognizer::DeleteTouch() call, since recognizer holds weak pointers things
> are still under control. When querying all_touches_ you would just have to
> also check whether the content is null and if so remove it from the list.

The reason Recognizer needs the all_touches_ map is so it can update an existing touch state object that it may not have a reference to. If a touch is past the composition time, it will no longer exist in the free_touches_ map. The all_touches_ map is basically a per-recognizer global touch set.

I originally passed the device and window id directly to the touch object. I had to switch to the all_touches_ map because of the above issue.

> Can
> we use sigc++ or some library that provides signals and slots? That would be
> the best solution.

How would that resolve this issue?

[Daniel d'Andrada (dandrader)]

> [...]
> > Can
> > we use sigc++ or some library that provides signals and slots? That would be
> > the best solution.
>
> How would that resolve this issue?

Recognizer {
  connect touch.destroyed(id) to this::DeleteTouch(id)
}

Touch {
  ~Touch() {
    emit destroyed(id);
  }
}

[Daniel d'Andrada (dandrader)]

> > * some changes merely fix indentation. That pollutes the commit diff and bzr
> > history.
>
> I don't usually see any issues with fixing formatting as you go. It would be
> nicer to always have it split out into separate commits, [...]

What I meant is to only fix the coding style of the lines your commit has to change anyway. Purely cosmetic/coding style commits wouldn't be made.

Yes, we could propose that policy to the team to collect feedack.

[Daniel d'Andrada (dandrader)]

AtomicRecognizer::CollectNewTouches() was meant to fill in only the new_touches_ set, hence its name. Now it's also changing all_touches_ and free_touches_ sets. That leaves its name and documentation inconsistent with what it actually does. For clarity's sake I think that method should either be renamed or the other sets updated elsewhere.

[Chase Douglas (chasedouglas)]

I have worked around the circular referencing between the recognizer and touch classes. There isn't a need for signals here.

I'm not opposed to signals, Daniel pointed out some good reasons for using them on irc. However, we're too late in the cycle to add a new dependency so any changes we make will need to be done using direct method calls instead of signals.

[Daniel d'Andrada (dandrader)]

* touch.h - you forgot to remove line 29
* touch.cpp - you forgot to remove line 26
* gesture.h:46 - s/touch_id/touch
* regular-recognizer.cpp
 - 107 - you could take the opportunity and fix that comment. It reffers to accepted stuff instead of unaccepted.
 - 125 - trailing whitespace

[Daniel d'Andrada (dandrader)]

Looks good, apart from the small issues mentioned in previous commits

review: Needs Fixing

[Daniel d'Andrada (dandrader)]

> Looks good, apart from the small issues mentioned in previous commits
s/commits/comments

[Chase Douglas (chasedouglas)]

All the comments should be addressed by the prerequisite branch and changes in this branch.

review: Needs Resubmitting

[Daniel d'Andrada (dandrader)]

Looking good!

I would leave commit 218 out but that's up to you

review: Approve

[Chase Douglas (chasedouglas)]

I have verified on my personal amd64 and i386 systems that all the tests pass and no memory leaks in grail occur.

=== modified file 'src/Makefile.am'
--- src/Makefile.am	2012-03-20 20:45:15 +0000
+++ src/Makefile.am	2012-03-27 17:29:32 +0000
@@ -65,7 +65,9 @@
 	v3/slice.cpp \
 	v3/slice.h \
 	v3/subscription.cpp \
-	v3/subscription.h
+	v3/subscription.h \
+	v3/touch.cpp \
+	v3/touch.h
 endif
 
 INCLUDES = -I$(top_srcdir)/include/ $(FRAME_CFLAGS)

=== modified file 'src/v3/atomic-recognizer.cpp'
--- src/v3/atomic-recognizer.cpp	2012-03-27 17:29:32 +0000
+++ src/v3/atomic-recognizer.cpp	2012-03-27 17:29:32 +0000
@@ -32,6 +32,7 @@
 #include "v3/handle.h"
 #include "v3/gesture.h"
 #include "v3/log.h"
+#include "v3/touch.h"
 
 namespace {
 const uint64_t MAX_TOUCHES_FOR_GESTURES = 5;
@@ -59,7 +60,7 @@
   uint64_t event_time = frame_event_get_time(event);
 
   UpdateTime(event_time);
-  CollectNewTouches(event);
+  ProcessTouches(event);
   if (new_touches_.size() > 0) {
     /* process all new touches at once to avoid the premature initiation of
        gestures for less touches than what the event brings */
@@ -83,7 +84,8 @@
  * subscription, add the touches to the gesture and accept them. Otherwise, end
  * the gesture and add the current gesture touches to the free touches list.
  */
-void AtomicRecognizer::HandleNewTouchesForAcceptedGesture(const SharedGesture& gesture) {
+void AtomicRecognizer::HandleNewTouchesForAcceptedGesture(
+    const SharedGesture& gesture) {
   UGSubscription* subscription = gesture->subscription();
   if (gesture->current_touches().size() + new_touches_.size() <=
       subscription->touches_max()) {
@@ -91,23 +93,21 @@
     LOG(Dbg) << "new_touches_ have been added to atomic gesture "
              << gesture->id() << "\n";
 
-    for (UFTouchId touch_id : new_touches_) {
-      if (frame_x11_accept_touch(device_, window_id_, touch_id) !=
-          UFStatusSuccess)
-        LOG(Err) << "touch " << touch_id << " failed to be accepted\n";
-
-      LOG(Dbg) << "touch " << touch_id
+    for (const auto& pair : new_touches_) {
+      const SharedTouch& touch = pair.second;
+      touch->Accept();
+      LOG(Dbg) << "touch " << touch->id()
                << " has been accepted because it has been added to an atomic "
                   "gesture\n";
 
-      INSERT_TOUCH(touch_id, accepted_touches_);
-      ERASE_TOUCH(touch_id, unaccepted_touches_);
-      ERASE_TOUCH(touch_id, free_touches_);
+      ERASE_TOUCH(touch->id(), free_touches_);
     }
     CLEAR_TOUCHES(new_touches_);
   } else {
-    for (UFTouchId touch : gesture->current_touches())
+    for (const auto& pair : gesture->current_touches()) {
+      const SharedTouch& touch = pair.second;
       INSERT_TOUCH(touch, free_touches_);
+    }
     gesture->End();
     LOG(Dbg) << "ended active atomic gesture " << gesture->id()
              << " because " << new_touches_.size()
@@ -130,14 +130,17 @@
   UGSubscription* subscription = gesture->subscription();
   if (gesture->current_touches().size() + new_touches_.size() <=
       subscription->touches_max()) {
-    for (UFTouchId touch_id : new_touches_) {
-      gesture->AddTouch(touch_id);
-      LOG(Dbg) << "touch " << touch_id << " has been added to atomic gesture "
-               << gesture->id() << "\n";
+    for (const auto& pair : new_touches_) {
+      const SharedTouch& touch = pair.second;
+      gesture->AddTouch(touch);
+      LOG(Dbg) << "touch " << touch->id() << " has been added to atomic "
+               << "gesture " << gesture->id() << "\n";
     }
   } else {
-    for (UFTouchId touch_id : gesture->current_touches())
-      INSERT_TOUCH(touch_id, free_touches_);
+    for (const auto& pair : gesture->current_touches()) {
+      const SharedTouch& touch = pair.second;
+      INSERT_TOUCH(touch, free_touches_);
+    }
     gesture->Cancel();
     LOG(Dbg) << "canceled inactive atomic gesture " << gesture->id()
              << " because a new touch began and the max touches has been "
@@ -148,13 +151,13 @@
 
 /**
  * @internal
- * Register all new touches present in the given uTouch-Frame event.
+ * Process all touches present in the given uTouch-Frame event.
+ *
+ * Add new touches to new_touches_ and free_touches_ maps, update the grail
+ * touch state for existing touches, and remove touches from maps when they
+ * physically end.
  */
-void AtomicRecognizer::CollectNewTouches(const UFEvent event) {
-  /* Check if any subscriptions are active before doing any processing */
-  if (num_subscriptions_ == 0)
-    return;
-
+void AtomicRecognizer::ProcessTouches(const UFEvent event) {
   UFFrame frame;
   UFStatus status = frame_event_get_property(event, UFEventPropertyFrame,
                                              &frame);
@@ -164,8 +167,6 @@
   }
 
   unsigned int num_touches = frame_frame_get_num_touches(frame);
-  uint64_t touch_start_time;
-  UFTouchId touch_id;
   for (unsigned int i = 0; i < num_touches; ++i) {
     UFTouch touch;
     status = frame_frame_get_touch_by_index(frame, i, &touch);
@@ -174,26 +175,33 @@
       continue;
     }
 
-    touch_id = frame_touch_get_id(touch);
-
     switch (frame_touch_get_state(touch)) {
-      case UFTouchStateBegin:
-        touch_start_time = frame_touch_get_start_time(touch);
-
-        /* Note touch start time and add to initial touch lists */
-        start_times_[touch_id] = touch_start_time;
-        LOG(Dbg) << "touch " << touch_id << " began with start time "
-                 << start_times_[touch_id] << "\n";
-
-        INSERT_TOUCH(touch_id, new_touches_);
-        break;
-
-      case UFTouchStateEnd:
-        ERASE_TOUCH(touch_id, new_touches_);
-        break;
-
-      default:
-        break;
+      case UFTouchStateBegin: {
+        SharedTouch grail_touch(new Touch(touch, device_, window_id_));
+
+        LOG(Dbg) << "touch " << grail_touch->id() << " began with start time "
+                 << grail_touch->start_time() << "\n";
+
+        INSERT_TOUCH(grail_touch, all_touches_);
+        INSERT_TOUCH(grail_touch, new_touches_);
+        break;
+      }
+
+      case UFTouchStateUpdate:
+      case UFTouchStateEnd: {
+        auto it = all_touches_.find(frame_touch_get_id(touch));
+        if (it != all_touches_.end()) {
+          const SharedTouch& grail_touch = it->second;
+
+          grail_touch->Update(touch);
+
+          if (grail_touch->pending_end() || grail_touch->ended()) {
+            ERASE_TOUCH(grail_touch->id(), new_touches_);
+            ERASE_TOUCH(grail_touch->id(), free_touches_);
+          }
+        }
+        break;
+      }
     }
   }
 }
@@ -210,9 +218,9 @@
     return;
 
   /* The new touches can now be used */
-  for (UFTouchId touch_id : new_touches_) {
-    INSERT_TOUCH(touch_id, unaccepted_touches_);
-    INSERT_TOUCH(touch_id, free_touches_);
+  for (const auto& pair : new_touches_) {
+    const SharedTouch& touch = pair.second;
+    INSERT_TOUCH(touch, free_touches_);
   }
 
   /* HandleNewTouchForAcceptedGesture may erase the gesture from
@@ -249,15 +257,17 @@
 
   uint64_t min_start_time = std::numeric_limits<uint64_t>::max();
   uint64_t max_start_time = 0;
-  for (UFTouchId touch_id : free_touches_) {
-    if (unaccepted_touches_.find(touch_id) == unaccepted_touches_.end())
+  for (const auto& pair : free_touches_) {
+    const SharedTouch& touch = pair.second;
+
+    if (touch->accepted())
       continue;
 
-    if (start_times_[touch_id] < min_start_time)
-      min_start_time = start_times_[touch_id];
+    if (touch->start_time() < min_start_time)
+      min_start_time = touch->start_time();
 
-    if (start_times_[touch_id] > max_start_time)
-      max_start_time = start_times_[touch_id];
+    if (touch->start_time() > max_start_time)
+      max_start_time = touch->start_time();
   }
 
   /* All touches in a gesture must begin within a composition timeframe */

=== modified file 'src/v3/atomic-recognizer.h'
--- src/v3/atomic-recognizer.h	2012-03-26 16:12:59 +0000
+++ src/v3/atomic-recognizer.h	2012-03-27 17:29:32 +0000
@@ -37,7 +37,7 @@
  private:
   void HandleNewTouchesForAcceptedGesture(const SharedGesture& gesture);
   void HandleNewTouchesForUnacceptedGesture(const SharedGesture& gesture);
-  void CollectNewTouches(const UFEvent event);
+  void ProcessTouches(const UFEvent event);
   void MatchSubscriptionsForNewTouches();
   void MatchGestures();
   void FindGesturesToAccept(uint64_t event_time);
@@ -45,7 +45,7 @@
 
   /* Touches that have begun but not yet been matched against subscriptions
      (for the creation of new gestures) or used to update existing gestures. */
-  TouchSet new_touches_;
+  TouchMap new_touches_;
 };
 
 } // namespace grail

=== modified file 'src/v3/forward.h'
--- src/v3/forward.h	2012-03-26 12:57:55 +0000
+++ src/v3/forward.h	2012-03-27 17:29:32 +0000
@@ -21,6 +21,7 @@
 #ifndef UTOUCH_GRAIL_FORWARD_H_
 #define UTOUCH_GRAIL_FORWARD_H_
 
+#include <map>
 #include <memory>
 #include <set>
 #include <sstream>
@@ -42,22 +43,27 @@
 class Recognizer;
 typedef std::shared_ptr<Recognizer> SharedRecognizer;
 
+class Touch;
+typedef std::shared_ptr<Touch> SharedTouch;
+
 class UGSlice;
 typedef std::shared_ptr<UGSlice> SharedUGSlice;
 
 class UGSubscription;
 typedef std::shared_ptr<UGSubscription> SharedUGSubscription;
 
-class TouchSet : public std::set<UFTouchId> {
+typedef std::set<UFTouchId> TouchSet;
+
+class TouchMap : public std::map<UFTouchId, SharedTouch> {
 
 public:
   std::string ToString() const {
     std::ostringstream stream;
     auto it = begin();
     if (it != end())
-      stream << *it++;
+      stream << (it++)->first;
     while (it != end())
-      stream << ", " << *it++;
+      stream << ", " << (it++)->first;
     return stream.str();
   }
 };

=== modified file 'src/v3/gesture.cpp'
--- src/v3/gesture.cpp	2012-03-26 17:46:22 +0000
+++ src/v3/gesture.cpp	2012-03-27 17:29:32 +0000
@@ -30,6 +30,7 @@
 #include "v3/log.h"
 #include "v3/recognizer.h"
 #include "v3/slice.h"
+#include "v3/touch.h"
 
 namespace utouch {
 namespace grail {
@@ -39,12 +40,11 @@
  * Creates a new gesture
  */
 Gesture::Gesture(Recognizer* recognizer, UGSubscription* subscription,
-                 TouchSet& touches, uint64_t start_time)
+                 TouchMap& touches, uint64_t start_time)
     : recognizer_(recognizer),
       id_(recognizer_->handle()->NewGestureID(recognizer_)),
       subscription_(subscription),
       current_touches_(touches),
-      unowned_touches_(touches),
       all_touches_(touches),
       start_time_(start_time),
       owned_(false),
@@ -59,12 +59,11 @@
  * @internal
  * Copies an existing gesture, but with the passed in touch set
  */
-Gesture::Gesture(const Gesture* other_gesture, TouchSet& touches)
+Gesture::Gesture(const Gesture* other_gesture, TouchMap& touches)
     : recognizer_(other_gesture->recognizer_),
       id_(recognizer_->handle()->NewGestureID(recognizer_)),
       subscription_(other_gesture->subscription_),
       current_touches_(touches),
-      unowned_touches_(touches),
       all_touches_(touches),
       start_time_(other_gesture->start_time_),
       owned_(false),
@@ -78,28 +77,26 @@
  * @internal
  * Add a new touch to an existing gesture
  */
-void Gesture::AddTouch(UFTouchId touch_id) {
-  current_touches_.insert(touch_id);
-  unowned_touches_.insert(touch_id);
-  all_touches_.insert(touch_id);
+void Gesture::AddTouch(const SharedTouch& touch) {
+  current_touches_[touch->id()] = touch;
+  all_touches_[touch->id()] = touch;
 }
 
 /**
  * @internal
  * Add a new set of touches to an existing gesture.
  */
-void Gesture::AddTouches(TouchSet touch_set) {
-  current_touches_.insert(touch_set.begin(), touch_set.end());
-  unowned_touches_.insert(touch_set.begin(), touch_set.end());
-  all_touches_.insert(touch_set.begin(), touch_set.end());
+void Gesture::AddTouches(TouchMap touches) {
+  current_touches_.insert(touches.begin(), touches.end());
+  all_touches_.insert(touches.begin(), touches.end());
 }
 
 /**
  * @internal
  * Returns whether that gesture contains the given touch.
  */
-bool Gesture::ContainsTouch(UFTouchId touch_id) const {
-  return current_touches_.find(touch_id) != current_touches_.end();
+bool Gesture::ContainsTouch(const SharedTouch& touch) const {
+  return current_touches_.find(touch->id()) != current_touches_.end();
 }
 
 /**
@@ -128,37 +125,25 @@
   TouchSet ended_touches;
   bool touch_found = false;
   for (UFTouchId touch_id : modified_touches) {
+    const auto& it = current_touches_.find(touch_id);
+
     /* If the touch is not part of this gesture, skip it */
-    if (current_touches_.find(touch_id) != current_touches_.end())
+    if (it != current_touches_.end())
       touch_found = true;
     else
       continue;
 
-    UFTouch touch;
-    status = frame_frame_get_touch_by_id(frame, touch_id, &touch);
-    if (status != UFStatusSuccess) {
-      LOG(Warn) << "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) {
-      LOG(Warn) << "failed to get touch from frame\n";
-      return;
-    }
-
-    if (state == UFTouchStateEnd) {
-      if (owned) {
-        ended_touches.insert(touch_id);
-      } else {
-        /* If we receive a touch end before we own it, someone higher in the
-         * stack accepted it. We need to cancel any handling of the touch. */
-        canceled_ = true;
-        break;
-      }
-    }
+    const SharedTouch& touch = it->second;
+
+    if (touch->ended() && !touch->owned()) {
+      /* If we receive a touch end before we own it, someone higher in the
+       * stack accepted it. We need to cancel any handling of the touch. */
+      canceled_ = true;
+      break;
+    }
+
+    if (touch->pending_end() || touch->ended())
+      ended_touches.insert(touch->id());
   }
 
   /* If the frame doesn't include any info about the touches in the gesture, or
@@ -265,6 +250,7 @@
   if (IsPhysicallyEnded()) {
     ended_ = true;
     last_slice_.reset();
+    LOG(Dbg) << "gesture " << id_ << " has ended\n";
   }
 }
 
@@ -276,41 +262,19 @@
   if (owned_ || not_owned_)
     return;
 
-  for (auto it = unowned_touches_.begin(); it != unowned_touches_.end(); ) {
-    UFTouchId touch_id = *it++;
-    UFTouch touch;
-    UFStatus status = frame_frame_get_touch_by_id(slices_.back()->frame(),
-                                                  touch_id, &touch);
-    if (status != UFStatusSuccess) {
-      LOG(Warn) << "failed to get touch " << touch_id << " from frame, gesture "
-                << id_ << " marked as not owned\n";
-      not_owned_ = true;
-      return;
-    }
+  for (const auto& pair : all_touches_) {
+    const SharedTouch& touch = pair.second;
 
-    int owned;
-    status = frame_touch_get_property(touch, UFTouchPropertyOwned, &owned);
-    if (status != UFStatusSuccess) {
+    if (touch->owned()) {
+      continue;
+    } else if (touch->ended()) {
       LOG(Warn) << "failed to get ownership property from touch, gesture "
                 << id_ << " marked as not owned\n";
       not_owned_ = true;
       return;
-    }
-
-    if (owned) {
-      LOG(Dbg) << "touch " << touch_id << " is now owned for gesture " << id_
-               << "\n";
-      unowned_touches_.erase(touch_id);
-      continue;
-    }
-
-    if (frame_touch_get_state(touch) == UFTouchStateEnd) {
-      LOG(Dbg) << "touch " << touch_id << "ended before it was owned, gesture "
-               << id_ << " marked as not owned\n";
-      not_owned_ = true;
-    }
-
-    return;
+    } else {
+      return;
+    }
   }
 
   LOG(Dbg) << "all touches owned, marking gesture " << id_ << " as owned\n";
@@ -397,7 +361,8 @@
   last_slice_.reset();
   ended_ = true;
   current_touches_.clear();
-  unowned_touches_.clear();
+  all_touches_.clear();
+  LOG(Dbg) << "gesture " << id_ << " has ended\n";
 }
 
 /**
@@ -417,5 +382,10 @@
   }
 }
 
+Gesture::~Gesture()
+{
+  LOG(Dbg) << "deleting gesture " << id_ << "\n";
+}
+
 } // namespace grail
 } // namespace utouch

=== modified file 'src/v3/gesture.h'
--- src/v3/gesture.h	2012-03-26 12:57:55 +0000
+++ src/v3/gesture.h	2012-03-27 17:29:32 +0000
@@ -37,12 +37,13 @@
 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);
+          TouchMap& touches, uint64_t start_time);
+  Gesture(const Gesture* gesture, TouchMap& touches);
+  ~Gesture();
 
-  void AddTouch(UFTouchId touch_id);
-  void AddTouches(TouchSet touch_set);
-  bool ContainsTouch(UFTouchId touch_id) const;
+  void AddTouch(const SharedTouch& touch);
+  void AddTouches(TouchMap touches);
+  bool ContainsTouch(const SharedTouch& touch) const;
   void Update(UFEvent event, TouchSet& touches);
   bool IsActive() const;
   bool IsConstructionFinished() const;
@@ -57,8 +58,8 @@
   const unsigned int id() const { return id_; }
   const Recognizer& recognizer() const { return *recognizer_; }
   UGSubscription* subscription() const { return subscription_; }
-  const TouchSet& current_touches() const { return current_touches_; }
-  const TouchSet& all_touches() const { return all_touches_; }
+  const TouchMap& current_touches() const { return current_touches_; }
+  const TouchMap& all_touches() const { return all_touches_; }
   const uint64_t start_time() const { return start_time_; }
   bool canceled() const { return canceled_; }
   bool ended() const { return ended_; }
@@ -75,9 +76,8 @@
   Recognizer* recognizer_;
   unsigned int id_;
   UGSubscription* subscription_;
-  TouchSet current_touches_; /**< Current touches of the gesture */
-  TouchSet unowned_touches_; /**< Current, unowned touches of the gesture */
-  TouchSet all_touches_; /**< All previous and current touches of the gesture */
+  TouchMap current_touches_; /**< Current touches of the gesture */
+  TouchMap all_touches_; /**< All previous and current touches of the gesture */
   uint64_t start_time_;
   bool owned_;
   bool not_owned_;

=== modified file 'src/v3/recognizer.cpp'
--- src/v3/recognizer.cpp	2012-03-27 17:29:32 +0000
+++ src/v3/recognizer.cpp	2012-03-27 17:29:32 +0000
@@ -32,6 +32,7 @@
 #include "v3/handle.h"
 #include "v3/gesture.h"
 #include "v3/log.h"
+#include "v3/touch.h"
 
 namespace utouch {
 namespace grail {
@@ -144,12 +145,10 @@
  * @internal
  * A helper function to get information from a touch frame
  *
- * This function retrieves a set of touches that have been modified, including
- * touches that have ended. It also retrieves the set of touches that have ended
- * separately.
+ * This function retrieves a set of touches that have been modified.
  */
-void GetModifiedAndEndedTouches(UFFrame frame, TouchSet* modified,
-                                TouchSet* ended, uint64_t event_time) {
+void GetModifiedTouches(UFFrame frame, TouchSet* modified,
+                        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;
@@ -165,24 +164,6 @@
       UFTouchId touch_id = frame_touch_get_id(touch);
 
       modified->insert(touch_id);
-
-      if (frame_touch_get_state(touch) == UFTouchStateEnd) {
-        ended->insert(touch_id);
-        LOG(Dbg) << "touch " << touch_id << " ended\n";
-      } else {
-        int pending_end_value;
-        status = frame_touch_get_property(touch, UFTouchPropertyPendingEnd,
-                                          &pending_end_value);
-        if (status != UFStatusSuccess) {
-          LOG(Warn) << "failed to get touch pending end property\n";
-          continue;
-        }
-
-        if (pending_end_value) {
-          ended->insert(touch_id);
-          LOG(Dbg) << "touch " << touch_id << " is pending end\n";
-        }
-      }
     }
   }
 }
@@ -203,9 +184,7 @@
   }
 
   TouchSet modified_touches;
-  TouchSet ended_touches;
-  GetModifiedAndEndedTouches(frame, &modified_touches,
-                             &ended_touches, frame_event_get_time(event));
+  GetModifiedTouches(frame, &modified_touches, frame_event_get_time(event));
 
   /* For each accepted gesture, update its state */
   for (auto it = accepted_gestures_.begin(); it != accepted_gestures_.end(); ) {
@@ -213,8 +192,12 @@
     gesture->Update(event, modified_touches);
     if (gesture->ended()) {
       /* Allow touches of an ended gesture to be part of a new gesture */
-      for (UFTouchId touch_id : gesture->current_touches())
-        INSERT_TOUCH(touch_id, free_touches_);
+      for (const auto& pair : gesture->current_touches()) {
+        const SharedTouch& touch = pair.second;
+
+        if (!touch->pending_end() && !touch->ended())
+          INSERT_TOUCH(touch, free_touches_);
+      }
 
       LOG(Dbg) << "gesture " << gesture->id()
                << " has been erased from accepted gestures\n";
@@ -235,27 +218,13 @@
     }
   }
 
-  /* For each ended touch, reject it if it is unaccepted and is not part of any
-   * remaining gesture */
-  for (UFTouchId touch_id : ended_touches) {
-    for (const SharedGesture& gesture : unaccepted_gestures_)
-      if (gesture->all_touches().find(touch_id) != gesture->all_touches().end())
-        goto next_touch;
-
-    if (unaccepted_touches_.find(touch_id) != unaccepted_touches_.end()) {
-      if (frame_x11_reject_touch(device_, window_id_, touch_id) !=
-              UFStatusSuccess)
-          LOG(Err) << "touch " << touch_id << " failed to be rejected\n";
-      LOG(Dbg) << "touch " << touch_id
-               << " has been rejected because it has ended and is not part of "
-                  "a gesture\n";
-      ERASE_TOUCH(touch_id, unaccepted_touches_);
-    }
-
-    ERASE_TOUCH(touch_id, free_touches_);
-    start_times_.erase(touch_id);
-
-next_touch: ;
+  /* Delete all ended touches */
+  for (auto it = all_touches_.begin(); it != all_touches_.end(); ) {
+    const auto& pair = *it++;
+    const SharedTouch& touch = pair.second;
+
+    if (touch->ended())
+      all_touches_.erase(touch->id());
   }
 }
 
@@ -277,15 +246,17 @@
     if (!gesture->IsActive() || gesture->IsConstructionFinished())
       continue;
 
-    for (UFTouchId touch_id : gesture->current_touches()) {
-      if (time - start_times_[touch_id] < COMPOSITION_TIME)
+    for (const auto& pair : gesture->current_touches()) {
+      const SharedTouch& touch = pair.second;
+
+      if (time - touch->start_time() < COMPOSITION_TIME)
         goto next_gesture;
 
       for (const SharedGesture& other_gesture : unaccepted_gestures_) {
         if (other_gesture == gesture)
           continue;
 
-        if (other_gesture->current_touches().find(touch_id) !=
+        if (other_gesture->current_touches().find(touch->id()) !=
             other_gesture->current_touches().end() &&
             !other_gesture->IsActive())
           goto next_gesture;
@@ -322,30 +293,20 @@
     }
   }
 
-  /* Reject unaccepted touches that are older than the composition time and are
-   * not part of any potential gesture */
-  for (auto it = unaccepted_touches_.begin();
-       it != unaccepted_touches_.end();
-       ) {
-    UFTouchId touch_id = *it++;
-    if (time - start_times_[touch_id] < COMPOSITION_TIME)
+  /* Remove touches older than the gesture composition time from free_touches_
+   */
+  for (auto it = free_touches_.begin(); it != free_touches_.end(); ) {
+    const auto& pair = *it++;
+    const SharedTouch& touch = pair.second;
+
+    if (time - touch->start_time() < COMPOSITION_TIME)
       continue;
 
-    for (const SharedGesture& gesture : unaccepted_gestures_)
-      if (gesture->all_touches().find(touch_id) != gesture->all_touches().end())
-        goto next_touch;
-
-    if (frame_x11_reject_touch(device_, window_id_, touch_id) !=
-            UFStatusSuccess)
-      LOG(Err) << "touch " << touch_id << " failed to be rejected\n";
-    LOG(Dbg) << "touch " << touch_id
-             << " has been rejected because it has timed out and is not part "
-                "of any gesture (time: " << time << ", touch start time: "
-             << start_times_[touch_id] << ")\n";
-    ERASE_TOUCH(touch_id, unaccepted_touches_);
-    ERASE_TOUCH(touch_id, free_touches_);
-
-next_touch: ;
+    LOG(Dbg) << "touch " << touch->id()
+             << " has been removed from free_touches_ because it is older than "
+                "the gesture composition time (time: " << time
+             << ", touch start time: " << touch->start_time() << ")\n";
+    ERASE_TOUCH(touch->id(), free_touches_);
   }
 
   CheckConstructionFinished(time);
@@ -359,13 +320,16 @@
   /* Find the minimum timeout of each unaccepted touch that is not part of a
    * gesture */
   uint64_t min_timeout = std::numeric_limits<uint64_t>::max();
-  for (UFTouchId touch_id : unaccepted_touches_) {
+  for (const auto& pair : free_touches_) {
+    const SharedTouch& touch = pair.second;
+
     for (const SharedGesture& gesture : unaccepted_gestures_)
-      if (gesture->all_touches().find(touch_id) != gesture->all_touches().end())
+      if (gesture->all_touches().find(touch->id()) !=
+          gesture->all_touches().end())
         goto next_touch;
 
-    if (COMPOSITION_TIME + start_times_[touch_id] < min_timeout)
-      min_timeout = start_times_[touch_id] + COMPOSITION_TIME;
+    if (COMPOSITION_TIME + touch->start_time() < min_timeout)
+      min_timeout = touch->start_time() + COMPOSITION_TIME;
 
 next_touch: ;
   }
@@ -405,17 +369,14 @@
   LOG(Dbg) << "gesture " << gesture->id() << " has been accepted by the "
                                              "client\n";
 
-  for (UFTouchId touch_id : gesture->all_touches()) {
-    if (accepted_touches_.find(touch_id) == accepted_touches_.end()) {
-      /* Accept each unaccepted touch in the gesture */
-      if (frame_x11_accept_touch(device_, window_id_, touch_id) !=
-              UFStatusSuccess)
-          LOG(Err) << "touch " << touch_id << " failed to be accepted\n";
-      LOG(Dbg) << "touch " << touch_id
+  for (const auto& pair : gesture->all_touches()) {
+    const SharedTouch& touch = pair.second;
+
+    if (!touch->accepted()) {
+      touch->Accept();
+      LOG(Dbg) << "touch " << touch->id()
                << " has been accepted because it is part of an accepted "
                   "gesture\n";
-      INSERT_TOUCH(touch_id, accepted_touches_);
-      ERASE_TOUCH(touch_id, unaccepted_touches_);
     } else {
       /* This gesture may be an extension to more touches of an accepted
        * gesture. Cancel the old gesture and remove any gesture events for it
@@ -426,10 +387,10 @@
              it != accepted_gestures_.end();
              ) {
           const SharedGesture& other_gesture = *it++;
-          const TouchSet& other_touches = other_gesture->current_touches();
-          if (other_touches.find(touch_id) != other_touches.end()) {
+          const TouchMap& other_touches = other_gesture->current_touches();
+          if (other_touches.find(touch->id()) != other_touches.end()) {
             LOG(Dbg) << "cancelling gesture " << other_gesture->id()
-                     << " because it has a touch (" << touch_id << ") "
+                     << " because it has a touch (" << touch->id() << ") "
                      << "that is part of a new accepted gesture\n";
             other_gesture->Cancel();
             handle_->RemoveGestureFromEventQueue(other_gesture->id());
@@ -443,7 +404,7 @@
 
     /* Remove this touch from the free touches set, it can't be used for new
      * gestures while it is part of an accepted gesture */
-    ERASE_TOUCH(touch_id, free_touches_);
+    ERASE_TOUCH(touch->id(), free_touches_);
   }
 
   /* Reject any overlapping unaccepted gestures. Atomic subscriptions may have
@@ -455,11 +416,14 @@
       const SharedGesture& other_gesture = *it++;
       if (other_gesture == gesture)
         continue;
-      for (UFTouchId touch_id : other_gesture->all_touches()) {
-        if (gesture->all_touches().find(touch_id) !=
+
+      for (const auto& pair : other_gesture->all_touches()) {
+        const SharedTouch& touch = pair.second;
+
+        if (gesture->all_touches().find(touch->id()) !=
             gesture->all_touches().end()) {
           LOG(Dbg) << "rejecting gesture " << other_gesture->id()
-                   << "because it has a touch (" << touch_id
+                   << "because it has a touch (" << touch->id()
                    << ") that is part of an accepted gesture\n";
           RejectGesture(other_gesture);
           break;

=== modified file 'src/v3/recognizer.h'
--- src/v3/recognizer.h	2012-03-26 16:08:56 +0000
+++ src/v3/recognizer.h	2012-03-27 17:29:32 +0000
@@ -32,27 +32,27 @@
 #include "v3/forward.h"
 #include "v3/subscription.h"
 
-#define INSERT_TOUCH(element, set) \
+#define INSERT_TOUCH(touch, map) \
   { \
-    (set).insert(element); \
-    LOG(Dbg) << "touch " << element << " has been added to " #set "\n"; \
+    (map)[(touch)->id()] = (touch); \
+    LOG(Dbg) << "touch " << (touch)->id() << " has been added to " #map "\n"; \
   }
 
-#define ERASE_TOUCH(element, set) \
+#define ERASE_TOUCH(touch_id, map) \
   { \
-    (set).erase(element); \
-    LOG(Dbg) << "touch " << element << " has been erased from " #set "\n"; \
+    LOG(Dbg) << "touch " << touch_id << " has been erased from " #map "\n"; \
+    (map).erase(touch_id); \
   }
 
 /* OBS: it avoids the "expensive" ToString() call when debug output is not
    wanted. */
-#define CLEAR_TOUCHES(set) \
+#define CLEAR_TOUCHES(map) \
   { \
     if (utouch::grail::Logger::instance().level() <= utouch::grail::Logger::Dbg) \
-      if ((set).size() > 0) \
-        LOG(Dbg) << "touch(es) " << (set).ToString() \
-                 << " have been erased from " #set "\n"; \
-    (set).clear(); \
+      if ((map).size() > 0) \
+        LOG(Dbg) << "touch(es) " << (map).ToString() \
+                 << " have been erased from " #map "\n"; \
+    (map).clear(); \
   }
 
 namespace utouch {
@@ -76,6 +76,8 @@
   UGStatus RejectGesture(unsigned int id);
 
   UGHandle* handle() const { return handle_; }
+  UFDevice device() const { return device_; }
+  UFWindowId window_id() const { return window_id_; }
   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_; }
@@ -96,10 +98,8 @@
   std::set<UGSubscription*> subscriptions_[5];
   std::set<SharedGesture> unaccepted_gestures_;
   std::set<SharedGesture> accepted_gestures_;
-  std::map<UFTouchId, uint64_t> start_times_;
-  TouchSet unaccepted_touches_;
-  TouchSet accepted_touches_;
-  TouchSet free_touches_;
+  TouchMap free_touches_;
+  TouchMap all_touches_;
 
   unsigned int num_subscriptions_;
 

=== modified file 'src/v3/regular-recognizer.cpp'
--- src/v3/regular-recognizer.cpp	2012-03-27 17:29:32 +0000
+++ src/v3/regular-recognizer.cpp	2012-03-27 17:29:32 +0000
@@ -32,6 +32,7 @@
 #include "v3/handle.h"
 #include "v3/gesture.h"
 #include "v3/log.h"
+#include "v3/touch.h"
 
 namespace utouch {
 namespace grail {
@@ -53,19 +54,21 @@
   LOG(Dbg) << "new event " << event << " with time "
            << frame_event_get_time(event) << "\n";
   UpdateTime(frame_event_get_time(event));
-  MatchSubscriptionsForEvent(event);
+  ProcessTouches(event);
   ProcessEvent(event);
 }
 
 /**
  * @internal
- * Analyze a uTouch-Frame event to see if any new gestures should begin
+ * Process all touches present in the given uTouch-Frame event.
+ *
+ * Add new touches to new_touches_ and free_touches_ maps, update the grail
+ * touch state for existing touches, and remove touches from maps when they
+ * physically end.
+ *
+ * When a touch begins, attempt to match it to all gesture subscriptions.
  */
-void RegularRecognizer::MatchSubscriptionsForEvent(const UFEvent event) {
-  /* Check if any subscriptions are active before doing any processing */
-  if (num_subscriptions_ == 0)
-    return;
-
+void RegularRecognizer::ProcessTouches(const UFEvent event) {
   UFFrame frame;
   UFStatus status = frame_event_get_property(event, UFEventPropertyFrame,
                                              &frame);
@@ -84,43 +87,57 @@
       continue;
     }
 
-    if (frame_touch_get_state(touch) != UFTouchStateBegin)
-      continue;
-
-    UFTouchId touch_id = frame_touch_get_id(touch);
-
-    /* Note touch start time and add to initial touch lists */
-    start_times_[touch_id] = frame_touch_get_start_time(touch);
-    LOG(Dbg) << "touch " << touch_id << " began with start time "
-             << start_times_[touch_id] << "\n";
-
-    INSERT_TOUCH(touch_id, unaccepted_touches_);
-    INSERT_TOUCH(touch_id, free_touches_);
-
-    /* HandleNewTouchForAcceptedGesture may erase the gesture from
-     * accepted_gestures_, so we can't use range-based for loops */
-    for (auto it = accepted_gestures_.begin();
-         it != accepted_gestures_.end();
-         ) {
-      const SharedGesture& gesture = *it++;
-      HandleNewTouchForAcceptedGesture(touch_id, gesture);
-    }
-
-    /* HandleNewTouchForAcceptedGesture may erase the gesture from
-     * accepted_gestures_, so we can't use range-based for loops */
-    for (auto it = unaccepted_gestures_.begin();
-         it != unaccepted_gestures_.end();
-         ) {
-      const SharedGesture& gesture = *it++;
-      HandleNewTouchForUnacceptedGesture(touch_id, gesture);
-    }
-
-    /* Attempt to match new gestures for active subscriptions */
-    MatchOneTouchGestures(touch_id);
-    MatchTwoTouchGestures(touch_id);
-    MatchThreeTouchGestures(touch_id);
-    MatchFourTouchGestures(touch_id);
-    MatchFiveTouchGestures(touch_id);
+    switch (frame_touch_get_state(touch)) {
+      case UFTouchStateBegin: {
+        SharedTouch grail_touch(new Touch(touch, device_, window_id_));
+
+        LOG(Dbg) << "touch " << grail_touch->id() << " began with start time "
+                 << grail_touch->start_time() << "\n";
+
+        INSERT_TOUCH(grail_touch, all_touches_);
+        INSERT_TOUCH(grail_touch, free_touches_);
+
+        /* HandleNewTouchForAcceptedGesture may erase the gesture from
+         * accepted_gestures_, so we can't use range-based for loops */
+        for (auto it = accepted_gestures_.begin();
+             it != accepted_gestures_.end();
+             ) {
+          const SharedGesture& gesture = *it++;
+          HandleNewTouchForAcceptedGesture(grail_touch, gesture);
+        }
+
+        /* HandleNewTouchForUnacceptedGesture may erase the gesture from
+         * accepted_gestures_, so we can't use range-based for loops */
+        for (auto it = unaccepted_gestures_.begin();
+             it != unaccepted_gestures_.end();
+             ) {
+          const SharedGesture& gesture = *it++;
+          HandleNewTouchForUnacceptedGesture(grail_touch, gesture);
+        }
+
+        /* Attempt to match new gestures for active subscriptions */
+        MatchOneTouchGestures(grail_touch);
+        MatchTwoTouchGestures(grail_touch);
+        MatchThreeTouchGestures(grail_touch);
+        MatchFourTouchGestures(grail_touch);
+        MatchFiveTouchGestures(grail_touch);
+        break;
+      }
+
+      case UFTouchStateUpdate:
+      case UFTouchStateEnd: {
+        auto it = all_touches_.find(frame_touch_get_id(touch));
+        if (it != all_touches_.end()) {
+          const SharedTouch& grail_touch = it->second;
+
+          grail_touch->Update(touch);
+
+          if (grail_touch->pending_end() || grail_touch->ended())
+            ERASE_TOUCH(grail_touch->id(), free_touches_);
+        }
+        break;
+      }
+    }
   }
 }
 
@@ -134,16 +151,16 @@
  * Otherwise, do nothing. New gestures may still begin elsewhere.
  */
 void RegularRecognizer::HandleNewTouchForAcceptedGesture(
-    UFTouchId touch_id,
+    const SharedTouch& touch,
     const SharedGesture& gesture) {
   UGSubscription* subscription = gesture->subscription();
   if (gesture->current_touches().size() < subscription->touches_max()
-      && !gesture->ContainsTouch(touch_id)) {
-    TouchSet set(gesture->current_touches());
-    set.insert(touch_id);
-    Gesture* new_gesture = new Gesture(gesture.get(), set);
-    LOG(Dbg) << "touch " << touch_id << " has been added to accepted gesture "
-             << gesture->id() << " to create new gesture "
+      && !gesture->ContainsTouch(touch)) {
+    TouchMap map(gesture->current_touches());
+    map[touch->id()] = touch;
+    Gesture* new_gesture = new Gesture(gesture.get(), map);
+    LOG(Dbg) << "touch " << touch->id() << " has been added to accepted "
+             << "gesture " << gesture->id() << " to create new gesture "
              << new_gesture->id() << "\n";
     unaccepted_gestures_.insert(SharedGesture(new_gesture));
     LOG(Dbg) << "gesture " << new_gesture
@@ -161,15 +178,15 @@
  * Otherwise, do nothing. New gestures may still begin elsewhere.
  */
 void RegularRecognizer::HandleNewTouchForUnacceptedGesture(
-    UFTouchId touch_id,
+    const SharedTouch& touch,
     const SharedGesture& gesture) {
   UGSubscription* subscription = gesture->subscription();
   if (gesture->current_touches().size() < subscription->touches_max()
-        && !gesture->ContainsTouch(touch_id)) {
-    TouchSet set(gesture->current_touches());
-    set.insert(touch_id);
-    Gesture* new_gesture = new Gesture(gesture.get(), set);
-    LOG(Dbg) << "touch " << touch_id
+        && !gesture->ContainsTouch(touch)) {
+    TouchMap map(gesture->current_touches());
+    map[touch->id()] = touch;
+    Gesture* new_gesture = new Gesture(gesture.get(), map);
+    LOG(Dbg) << "touch " << touch->id()
              << " has been added to unaccepted gesture " << gesture->id()
              << " to create new gesture " << new_gesture->id() << "\n";
     unaccepted_gestures_.insert(SharedGesture(new_gesture));
@@ -182,17 +199,17 @@
  * @internal
  * Attempt to match the given touch against one touch subscriptions
  */
-void RegularRecognizer::MatchOneTouchGestures(UFTouchId touch_id) {
+void RegularRecognizer::MatchOneTouchGestures(const SharedTouch& touch) {
   for (UGSubscription* subscription : subscriptions_[0]) {
-    TouchSet set;
-    set.insert(touch_id);
-    Gesture* gesture = new Gesture(this, subscription, set,
-                                   start_times_[touch_id]);
+    TouchMap map;
+    map[touch->id()] = touch;
+    Gesture* gesture = new Gesture(this, subscription, map,
+                                   touch->start_time());
     unaccepted_gestures_.insert(SharedGesture(gesture));
 
     LOG(Dbg) << "New tentative gesture " << gesture->id()
              << " matched subscription " << subscription << " with mask "
-             << subscription->mask() << " for touch " << touch_id << "\n";
+             << subscription->mask() << " for touch " << touch->id() << "\n";
   }
 }
 
@@ -200,30 +217,30 @@
  * @internal
  * Attempt to match the given touch against two touch subscriptions
  */
-void RegularRecognizer::MatchTwoTouchGestures(UFTouchId touch_id) {
+void RegularRecognizer::MatchTwoTouchGestures(const SharedTouch& touch) {
   for (UGSubscription* subscription : subscriptions_[1]) {
-    for (UFTouchId other_id : free_touches_) {
-      if (other_id == touch_id)
+    for (const auto& pair : free_touches_) {
+      const SharedTouch& other = pair.second;
+      if (other->id() == touch->id())
         continue;
 
       /* All touches in a gesture must begin within a composition timeframe */
-      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];
+      uint64_t min_start_time = touch->start_time();
+      if (other->start_time() < min_start_time && !other->accepted())
+        min_start_time = other->start_time();
 
-      if (start_times_[touch_id] - min_start_time < COMPOSITION_TIME) {
-        TouchSet set;
-        set.insert(touch_id);
-        set.insert(other_id);
-        Gesture* gesture = new Gesture(this, subscription, set,
-                                       start_times_[touch_id]);
+      if (touch->start_time() - min_start_time < COMPOSITION_TIME) {
+        TouchMap map;
+        map[touch->id()] = touch;
+        map[other->id()] = other;
+        Gesture* gesture = new Gesture(this, subscription, map,
+                                       touch->start_time());
         unaccepted_gestures_.insert(SharedGesture(gesture));
 
         LOG(Dbg) << "New tentative gesture " << gesture->id()
                  << " matched subscription " << subscription << " with mask "
-                 << subscription->mask() << " for touches " << touch_id << ", "
-                 << other_id << "\n";
+                 << subscription->mask() << " for touches " << touch->id()
+                 << ", " << other->id() << "\n";
       }
     }
   }
@@ -233,38 +250,38 @@
  * @internal
  * Attempt to match the given touch against three touch subscriptions
  */
-void RegularRecognizer::MatchThreeTouchGestures(UFTouchId touch_id) {
+void RegularRecognizer::MatchThreeTouchGestures(const SharedTouch& touch) {
   for (UGSubscription* subscription : subscriptions_[2]) {
-    for (UFTouchId other_id_1 : free_touches_) {
-      if (other_id_1 == touch_id)
+    for (const auto& pair_1 : free_touches_) {
+      const SharedTouch& other_1 = pair_1.second;
+      if (other_1->id() == touch->id())
         continue;
 
-      for (UFTouchId other_id_2 : free_touches_) {
-        if (other_id_2 <= other_id_1 || other_id_2 == touch_id)
+      for (const auto& pair_2 : free_touches_) {
+        const SharedTouch& other_2 = pair_2.second;
+        if (other_2->id() <= other_1->id() || other_2->id() == touch->id())
           continue;
 
         /* All touches in a gesture must begin within a composition timeframe */
-        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];
+        uint64_t min_start_time = touch->start_time();
+        if (other_1->start_time() < min_start_time && !other_1->accepted())
+          min_start_time = other_1->start_time();
+        if (other_2->start_time() < min_start_time && !other_2->accepted())
+          min_start_time = other_2->start_time();
 
-        if (start_times_[touch_id] - min_start_time < COMPOSITION_TIME) {
-          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]);
+        if (touch->start_time() - min_start_time < COMPOSITION_TIME) {
+          TouchMap map;
+          map[touch->id()] = touch;
+          map[other_1->id()] = other_1;
+          map[other_2->id()] = other_2;
+          Gesture* gesture = new Gesture(this, subscription, map,
+                                         touch->start_time());
           unaccepted_gestures_.insert(SharedGesture(gesture));
 
           LOG(Dbg) << "New tentative gesture " << gesture->id()
                    << " matched subscription " << subscription << " with mask "
-                   << subscription->mask() << " for touches " << touch_id
-                   << ", " << other_id_1 << ", " << other_id_2 << "\n";
+                   << subscription->mask() << " for touches " << touch->id()
+                   << ", " << other_1->id() << ", " << other_2->id() << "\n";
         }
       }
     }
@@ -275,48 +292,48 @@
  * @internal
  * Attempt to match the given touch against four touch subscriptions
  */
-void RegularRecognizer::MatchFourTouchGestures(UFTouchId touch_id) {
+void RegularRecognizer::MatchFourTouchGestures(const SharedTouch& touch) {
   for (UGSubscription* subscription : subscriptions_[3]) {
-    for (UFTouchId other_id_1 : free_touches_) {
-      if (other_id_1 == touch_id)
+    for (const auto& pair_1 : free_touches_) {
+      const SharedTouch& other_1 = pair_1.second;
+      if (other_1->id() == touch->id())
         continue;
 
-      for (UFTouchId other_id_2 : free_touches_) {
-        if (other_id_2 <= other_id_1 || other_id_2 == touch_id)
+      for (const auto& pair_2 : free_touches_) {
+        const SharedTouch& other_2 = pair_2.second;
+        if (other_2->id() <= other_1->id() || other_2->id() == touch->id())
           continue;
 
-        for (UFTouchId other_id_3 : free_touches_) {
-          if (other_id_3 <= other_id_2 || other_id_3 == touch_id)
+        for (const auto& pair_3 : free_touches_) {
+          const SharedTouch& other_3 = pair_3.second;
+          if (other_3->id() <= other_2->id() || other_3->id() == touch->id())
             continue;
 
           /* All touches in a gesture must begin within a composition
            * timeframe */
-          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];
+          uint64_t min_start_time = touch->start_time();
+          if (other_1->start_time() < min_start_time && !other_1->accepted())
+            min_start_time = other_1->start_time();
+          if (other_2->start_time() < min_start_time && !other_2->accepted())
+            min_start_time = other_2->start_time();
+          if (other_3->start_time() < min_start_time && !other_3->accepted())
+            min_start_time = other_3->start_time();
 
-          if (start_times_[touch_id] - min_start_time < COMPOSITION_TIME) {
-            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]);
+          if (touch->start_time() - min_start_time < COMPOSITION_TIME) {
+            TouchMap map;
+            map[touch->id()] = touch;
+            map[other_1->id()] = other_1;
+            map[other_2->id()] = other_2;
+            map[other_3->id()] = other_3;
+            Gesture* gesture = new Gesture(this, subscription, map,
+                                           touch->start_time());
             unaccepted_gestures_.insert(SharedGesture(gesture));
 
             LOG(Dbg) << "New tentative gesture " << gesture->id()
                      << " matched subscription " << subscription
                      << " with mask " << subscription->mask() << " for touches "
-                     << touch_id << ", " << other_id_1 << ", " << other_id_2
-                     << ", " << other_id_3 << "\n";
+                     << touch->id() << ", " << other_1->id() << ", "
+                     << other_2->id() << ", " << other_3->id() << "\n";
           }
         }
       }
@@ -328,61 +345,57 @@
  * @internal
  * Attempt to match the given touch against five touch subscriptions
  */
-void RegularRecognizer::MatchFiveTouchGestures(UFTouchId touch_id) {
+void RegularRecognizer::MatchFiveTouchGestures(const SharedTouch& touch) {
   for (UGSubscription* subscription : subscriptions_[4]) {
-    for (UFTouchId other_id_1 : free_touches_) {
-      if (other_id_1 == touch_id)
+    for (const auto& pair_1 : free_touches_) {
+      const SharedTouch& other_1 = pair_1.second;
+      if (other_1->id() == touch->id())
         continue;
 
-      for (UFTouchId other_id_2 : free_touches_) {
-        if (other_id_2 <= other_id_1 || other_id_2 == touch_id)
+      for (const auto& pair_2 : free_touches_) {
+        const SharedTouch& other_2 = pair_2.second;
+        if (other_2->id() <= other_1->id() || other_2->id() == touch->id())
           continue;
 
-        for (UFTouchId other_id_3 : free_touches_) {
-          if (other_id_3 <= other_id_2 || other_id_3 == touch_id)
+        for (const auto& pair_3 : free_touches_) {
+          const SharedTouch& other_3 = pair_3.second;
+          if (other_3->id() <= other_2->id() || other_3->id() == touch->id())
             continue;
 
-          for (UFTouchId other_id_4 : free_touches_) {
-            if (other_id_4 <= other_id_3 || other_id_4 == touch_id)
+          for (const auto& pair_4 : free_touches_) {
+            const SharedTouch& other_4 = pair_4.second;
+            if (other_4->id() <= other_3->id() || other_4->id() == touch->id())
               continue;
 
             /* All touches in a gesture must begin within a composition
              * timeframe */
-            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];
+            uint64_t min_start_time = touch->start_time();
+            if (other_1->start_time() < min_start_time && !other_1->accepted())
+              min_start_time = other_1->start_time();
+            if (other_2->start_time() < min_start_time && !other_2->accepted())
+              min_start_time = other_2->start_time();
+            if (other_3->start_time() < min_start_time && !other_3->accepted())
+              min_start_time = other_3->start_time();
+            if (other_4->start_time() < min_start_time && !other_4->accepted())
+              min_start_time = other_4->start_time();
 
-            if (start_times_[touch_id] - min_start_time < COMPOSITION_TIME) {
-              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]);
+            if (touch->start_time() - min_start_time < COMPOSITION_TIME) {
+              TouchMap map;
+              map[touch->id()] = touch;
+              map[other_1->id()] = other_1;
+              map[other_2->id()] = other_2;
+              map[other_3->id()] = other_3;
+              map[other_4->id()] = other_4;
+              Gesture* gesture = new Gesture(this, subscription, map,
+                                             touch->start_time());
               unaccepted_gestures_.insert(SharedGesture(gesture));
 
               LOG(Dbg) << "New tentative gesture " << gesture->id()
                        << " matched subscription " << subscription
                        << " with mask " << subscription->mask()
-                       << " for touches " << touch_id << ", " << other_id_1
-                       << ", " << other_id_2 << ", " << other_id_3 << ", "
-                       << other_id_4 << "\n";
+                       << " for touches " << touch->id() << ", "
+                       << other_1->id() << ", " << other_2->id() << ", "
+                       << other_3->id() << ", " << other_4->id() << "\n";
             }
           }
         }

=== modified file 'src/v3/regular-recognizer.h'
--- src/v3/regular-recognizer.h	2012-03-26 12:57:55 +0000
+++ src/v3/regular-recognizer.h	2012-03-27 17:29:32 +0000
@@ -34,16 +34,16 @@
   virtual void ProcessFrameEvent(const UFEvent event);
 
  private:
-  void HandleNewTouchForAcceptedGesture(UFTouchId touch_id,
+  void HandleNewTouchForAcceptedGesture(const SharedTouch& touch,
                                         const SharedGesture& gesture);
-  void HandleNewTouchForUnacceptedGesture(UFTouchId touch_id,
+  void HandleNewTouchForUnacceptedGesture(const SharedTouch& touch,
                                           const SharedGesture& gesture);
-  void MatchSubscriptionsForEvent(const UFEvent event);
-  void MatchOneTouchGestures(UFTouchId touch_id);
-  void MatchTwoTouchGestures(UFTouchId touch_id);
-  void MatchThreeTouchGestures(UFTouchId touch_id);
-  void MatchFourTouchGestures(UFTouchId touch_id);
-  void MatchFiveTouchGestures(UFTouchId touch_id);
+  void ProcessTouches(const UFEvent event);
+  void MatchOneTouchGestures(const SharedTouch& touch);
+  void MatchTwoTouchGestures(const SharedTouch& touch);
+  void MatchThreeTouchGestures(const SharedTouch& touch);
+  void MatchFourTouchGestures(const SharedTouch& touch);
+  void MatchFiveTouchGestures(const SharedTouch& touch);
 };
 
 } // namespace grail

=== modified file 'src/v3/slice.cpp'
--- src/v3/slice.cpp	2012-03-26 13:28:53 +0000
+++ src/v3/slice.cpp	2012-03-27 17:29:32 +0000
@@ -32,6 +32,7 @@
 #include "v3/log.h"
 #include "v3/recognizer.h"
 #include "v3/subscription.h"
+#include "v3/touch.h"
 
 namespace {
 
@@ -47,7 +48,7 @@
  * Create a gesture begin slice
  */
 UGSlice::UGSlice(Gesture& gesture, UFEvent event,
-                 const TouchSet& touches, UGGestureTypeMask recognized)
+                 const TouchMap& touches, UGGestureTypeMask recognized)
     : id_(gesture.id()),
       event_(event),
       frame_(NULL),
@@ -128,7 +129,7 @@
  * Create a gesture update or end slice based on new touch frame
  */
 UGSlice::UGSlice(const SharedUGSlice& prev, Gesture &gesture,
-                 UFEvent event, const TouchSet& touches)
+                 UFEvent event, const TouchMap& touches)
     : id_(prev->id_),
       event_(event ? : NULL),
       frame_(NULL),
@@ -189,16 +190,19 @@
  * @internal
  * Get gesture slice transformation properties
  */
-void UGSlice::GetValues(Gesture &gesture, const TouchSet& touches,
+void UGSlice::GetValues(Gesture &gesture, const TouchMap& touches,
                         float* x, float* y, float* radius, float* angle,
                         bool init) {
   *x = 0;
   *y = 0;
 
   /* Accumulate X and Y positions */
-  for (UFTouchId touch_id : touches) {
+  for (const auto& pair : touches) {
+    const SharedTouch& grail_touch = pair.second;
+
     UFTouch touch;
-    UFStatus status = frame_frame_get_touch_by_id(frame_, touch_id, &touch);
+    UFStatus status = frame_frame_get_touch_by_id(frame_, grail_touch->id(),
+                                                  &touch);
     if (status != UFStatusSuccess) {
       LOG(Warn) << "failed to get touch from frame\n";
       continue;
@@ -224,12 +228,15 @@
   *radius = 0;
   *angle = 0;
   int num_angles = 0;
-  for (UFTouchId touch_id : touches) {
+  for (const auto& pair : touches) {
+    const SharedTouch& grail_touch = pair.second;
+
     UFTouch touch;
     float cur_x;
     float cur_y;
 
-    UFStatus status = frame_frame_get_touch_by_id(frame_, touch_id, &touch);
+    UFStatus status = frame_frame_get_touch_by_id(frame_, grail_touch->id(),
+                                                  &touch);
     if (status != UFStatusSuccess) {
       LOG(Warn) << "failed to get touch from frame\n";
       continue;
@@ -257,7 +264,7 @@
       num_angles++;
     } else if (frame_touch_get_state(touch) != UFTouchStateBegin) {
       /* Update touch angle if the touch has moved */
-      float prev_angle = gesture.AngleForTouch(touch_id);
+      float prev_angle = gesture.AngleForTouch(grail_touch->id());
 
       if (new_angle - prev_angle < -M_PI)
         new_angle += 2 * M_PI;
@@ -269,7 +276,7 @@
     }
 
     /* Save the touch angle in the gesture state */
-    gesture.SetAngleForTouch(touch_id, new_angle);
+    gesture.SetAngleForTouch(grail_touch->id(), new_angle);
   }
 
   /* Calculate the average angle of the touches */
@@ -390,30 +397,11 @@
 void UGSlice::CheckGestureEnd() {
   /* Get number of physically non-ended touches */
   unsigned int num_active_touches = 0;
-  for (UFTouchId touch_id : touches_) {
-    UFTouch touch;
-    UFStatus status = frame_frame_get_touch_by_id(frame_, touch_id, &touch);
-    if (status != UFStatusSuccess) {
-      LOG(Warn) << "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) {
-        LOG(Warn) << "failed to get touch pending end property\n";
-        continue;
-      }
-
-      if (pending_end)
-        continue;
-    }
-
-    num_active_touches++;
+  for (const auto& pair : touches_) {
+    const SharedTouch& touch = pair.second;
+
+    if (!touch->pending_end() && !touch->ended())
+      num_active_touches++;
   }
 
   /* Check if currently active touches is outside range for subscription */
@@ -497,7 +485,7 @@
   auto it = touches_.cbegin();
   std::advance(it, index);
 
-  *touch_id = *it;
+  *touch_id = it->first;
 
   return UGStatusSuccess;
 }

=== modified file 'src/v3/slice.h'
--- src/v3/slice.h	2012-03-26 13:28:53 +0000
+++ src/v3/slice.h	2012-03-27 17:29:32 +0000
@@ -35,13 +35,13 @@
 class UGSlice : public UGSlice_ {
  public:
   /** @internal Create a new slice for a new gesture */
-  UGSlice(Gesture& gesture, UFEvent event, const TouchSet& touches,
+  UGSlice(Gesture& gesture, UFEvent event, const TouchMap& touches,
           UGGestureTypeMask recognized);
   /** @internal Create a new copy of an existing slice */
   UGSlice(const SharedUGSlice& prev, bool end = false);
   /** @internal Create a new slice by updating an existing slice */
   UGSlice(const SharedUGSlice& prev, Gesture &gesture,
-          UFEvent event, const TouchSet& touches);
+          UFEvent event, const TouchMap& touches);
 
   ~UGSlice();
 
@@ -51,7 +51,7 @@
   UGStatus GetProperty(UGSliceProperty property, void* value) const;
 
   uint64_t time() const { return time_; }
-  const TouchSet& touches() { return touches_; }
+  const TouchMap& touches() { return touches_; }
   const UFFrame& frame() { return frame_; }
   UGGestureState state() const { return state_; }
   bool physically_ended() const { return physically_ended_; }
@@ -66,7 +66,7 @@
   unsigned int id_;
   const UFEvent event_;
   UFFrame frame_;
-  TouchSet touches_;
+  TouchMap touches_;
   uint64_t time_;
   UGGestureState state_;
   bool physically_ended_;
@@ -85,7 +85,7 @@
   bool touch_count_changed_;
   UGSubscription *subscription_;
 
-  void GetValues(Gesture &gesture, const TouchSet& touches, float* x, float* y,
+  void GetValues(Gesture &gesture, const TouchMap& touches, float* x, float* y,
                  float* radius, float* angle, bool init);
   void SetTransforms(Gesture &gesture);
   void SetCenterOfRotation();

=== added file 'src/v3/touch.cpp'
--- src/v3/touch.cpp	1970-01-01 00:00:00 +0000
+++ src/v3/touch.cpp	2012-03-27 17:29:32 +0000
@@ -0,0 +1,89 @@
+/*****************************************************************************
+ *
+ * grail - Gesture Recognition And Instantiation Library
+ *
+ * Copyright (C) 2012 Canonical Ltd.
+ *
+ * This library is free software: you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License version 3
+ * as published by the Free Software Foundation.
+ *
+ * This library is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranties of 
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
+ * PURPOSE.  See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ ****************************************************************************/
+
+#include "v3/touch.h"
+
+#include <utouch/frame_x11.h>
+
+#include "v3/log.h"
+
+namespace utouch {
+namespace grail {
+
+Touch::Touch(UFTouch touch, UFDevice device, UFWindowId window_id)
+      : id_(frame_touch_get_id(touch)),
+        start_time_(frame_touch_get_start_time(touch)),
+        device_(device),
+        window_id_(window_id),
+        accepted_(false),
+        pending_end_(false),
+        owned_(false),
+        ended_(false) {
+  Update(touch);
+}
+
+void Touch::Update(UFTouch touch) {
+  if (frame_touch_get_state(touch) == UFTouchStateEnd) {
+    ended_ = true;
+    LOG(Dbg) << "touch " << id_ << " has ended\n";
+  }
+
+  UFStatus status;
+  int value;
+
+  if (!pending_end_) {
+    status = frame_touch_get_property(touch, UFTouchPropertyPendingEnd, &value);
+    if (status != UFStatusSuccess) {
+      LOG(Warn) << "failed to get touch pending end property\n";
+    } else if (value) {
+      pending_end_ = true;
+      LOG(Dbg) << "touch " << id_ << " is pending end\n";
+    }
+  }
+
+  if (!owned_) {
+    status = frame_touch_get_property(touch, UFTouchPropertyOwned, &value);
+    if (status != UFStatusSuccess) {
+      LOG(Warn) << "failed to get touch owned property\n";
+    } else if (value) {
+      owned_ = true;
+      LOG(Dbg) << "touch " << id_ << " is owned\n";
+    }
+  }
+}
+
+void Touch::Accept() {
+  LOG(Dbg) << "accepting touch " << id_ << "\n";
+  if (frame_x11_accept_touch(device_, window_id_, id_) != UFStatusSuccess)
+    LOG(Err) << "touch " << id_ << " failed to be accepted\n";
+
+  accepted_ = true;
+}
+
+Touch::~Touch() {
+  if (!accepted_) {
+    LOG(Dbg) << "rejecting touch " << id_ << "\n";
+    if (frame_x11_reject_touch(device_, window_id_, id_) != UFStatusSuccess)
+      LOG(Err) << "touch " << id_ << " failed to be rejected\n";
+  }
+}
+
+} // namespace grail
+} // namespace utouch

=== added file 'src/v3/touch.h'
--- src/v3/touch.h	1970-01-01 00:00:00 +0000
+++ src/v3/touch.h	2012-03-27 17:29:32 +0000
@@ -0,0 +1,64 @@
+/*****************************************************************************
+ *
+ * grail - Gesture Recognition And Instantiation Library
+ *
+ * Copyright (C) 2012 Canonical Ltd.
+ *
+ * This library is free software: you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License version 3
+ * as published by the Free Software Foundation.
+ *
+ * This library is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranties of 
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
+ * PURPOSE.  See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ ****************************************************************************/
+
+#ifndef UTOUCH_GRAIL_TOUCH_H_
+#define UTOUCH_GRAIL_TOUCH_H_
+
+#include <utouch/frame.h>
+
+namespace utouch {
+namespace grail {
+
+class Touch {
+ public:
+  Touch(UFTouch touch, UFDevice device, UFWindowId window_id);
+  ~Touch();
+
+  void Update(UFTouch touch);
+  void Accept();
+
+  UFTouchId id() const { return id_; }
+  uint64_t start_time() const { return start_time_; }
+  bool accepted() const { return accepted_; }
+  bool pending_end() const { return pending_end_; }
+  void set_pending_end(bool pending_end) { pending_end_ = pending_end; }
+  bool owned() const { return owned_; }
+  void set_owned(bool owned) { owned_ = owned; }
+  bool ended() const { return ended_; }
+  void set_ended(bool ended) { ended_ = ended; }
+
+  Touch(const Touch&) = delete;
+  Touch& operator=(const Touch&) = delete;
+
+ private:
+  UFTouchId id_;
+  uint64_t start_time_;
+  UFDevice device_;
+  UFWindowId window_id_;
+  bool accepted_;
+  bool pending_end_;
+  bool owned_;
+  bool ended_;
+};
+
+} // namespace grail
+} // namespace utouch
+
+#endif // UTOUCH_GRAIL_TOUCH_H_