Merge lp:~dandrader/grail/lp949916 into lp:grail

[Daniel d'Andrada]

Don't emit Touch slices prematurely with atomic rules (LP #949916)

With atomic gesture rules being used, even when, say, 4 touches were coming with the very same timestamp, gestures for 2 and then 3 touches were being created and ended before the fourth touch finally got processed.

This branch first splits Recognizer into AtomicRecognizer and RegularRecognizer. Then it fixes the bug by wainting kCompositionTime before accepting a gesture in the AtomicRecognizer.

It also doesn't send slices from a gesture until it gets accepted. This ensures that Grail clients using subscriptions with atomic gestures rules won't get noise from gestures that won't be accepted in the end.

[Chase Douglas (chasedouglas)]

* In AtomicRecognizer::HandleNewTouchesForAcceptedGesture(), when a gesture is ended you have the following comment:

// OBS: Should they also go back to unaccepted_touches_ here?

An accepted touch cannot return to an unaccepted state. This is a property of the window manager, and of touch handling in general. If one client uses a touch, no one else may use the touch, period.

* Please use /* */ style comments for consistency.

* The fix for the bug involves dropping touch events until a timeout period is reached. This will make the gesture recognition inconsistent because the beginning frame event of a gesture will be indeterminate. If the user rolls the touches onto the touchpad vs putting them down all at once, the recognition might behave differently.

I think a better approach would be to prevent a gesture from becoming fully recognized until the construction finished timeout is reached.

* The test looks good, and I like the subclassing of recognizers :).

review: Needs Fixing

[Daniel d'Andrada (dandrader)]

Updated according to review comments.

[lp:~dandrader/grail/lp949916]

196. By Daniel d'Andrada on 2012-03-14

Merged "Erase ended touches from start_times_ map"

[Chase Douglas (chasedouglas)]

* I'm confused about what the correct Unity guidelines are for C++ code, which we use for utouch-grail and utouch-frame. It appears the style has changed without notification. For now, I'm going to overlook any style issues.

* I'm not crazy about the name SetKeepSlicesEnabled(). I think the "Enabled" is redundant. Perhaps rename it to SetKeepSlices()? It would follow the unity coding guidelines here: https://wiki.ubuntu.com/Unity/CodingStyle.

Everything else looks good! If you change the keep slices method name as suggested, feel free to merge :).

review: Approve

[lp:~dandrader/grail/lp949916]

197. By Daniel d'Andrada on 2012-03-14

Refactoring v3/Recognizer. Split into Regular and Atomic recognizers

Instead of having many "if (atomic_)" sprinkled throughout the code, have
two recognizers: of for atomic gesture rules and another for regular rules.

That will also make the atomic gestures code flow easier to understand and
tune. Likewise for regular rules.

198. By Daniel d'Andrada on 2012-03-14

Atomic rules: Don't send slices from premature gestures. (lp:949916)

Wait a bit until accepting a gesture to avoid premature gestures that
will immediately get cancelled due to the apparition of a new touch
point on the following events.
e.g. like when a user puts four fingers on a touch screen but
the corresponding touch points come in separate events (because fingers
don't land precisely in sync and/or UTouch frame doesn't process their
arrivals in the very same event). We should generate only the "final"
4-touches' gesture and not the intermediates 2-touches and 3-touches
gestures.

199. By Daniel d'Andrada on 2012-03-14

Regression test for lp:949916

Check that, when using atomic gestures, we don't get
premature slices of 2 or 3 touches when a roughly synced 4-fingers'
gesture is performed.

=== modified file 'src/Makefile.am'
--- src/Makefile.am	2012-02-01 16:24:12 +0000
+++ src/Makefile.am	2012-03-14 19:17:21 +0000
@@ -38,6 +38,8 @@
 if HAVE_XI
 v3dir = v3
 libutouch_grail_la_SOURCES += \
+	v3/atomic-recognizer.cpp \
+	v3/atomic-recognizer.h \
 	v3/event.cpp \
 	v3/event.h \
 	v3/forward.h \
@@ -49,6 +51,8 @@
 	v3/log.h \
 	v3/recognizer.cpp \
 	v3/recognizer.h \
+	v3/regular-recognizer.cpp \
+	v3/regular-recognizer.h \
 	v3/slice.cpp \
 	v3/slice.h \
 	v3/subscription.cpp \

=== added file 'src/v3/atomic-recognizer.cpp'
--- src/v3/atomic-recognizer.cpp	1970-01-01 00:00:00 +0000
+++ src/v3/atomic-recognizer.cpp	2012-03-14 19:17:21 +0000
@@ -0,0 +1,308 @@
+/*****************************************************************************
+ *
+ * grail - Gesture Recognition And Instantiation Library
+ *
+ * Copyright (C) 2012 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ ****************************************************************************/
+
+#include "v3/atomic-recognizer.h"
+
+#include <algorithm>
+#include <cassert>
+#include <cstdint>
+#include <cstdio>
+#include <limits>
+
+#include <utouch/frame.h>
+#include <utouch/frame_x11.h>
+
+#include "v3/handle.h"
+#include "v3/gesture.h"
+#include "v3/log.h"
+
+namespace {
+const uint64_t MAX_TOUCHES_FOR_GESTURES = 5;
+} // namespace
+
+namespace utouch {
+namespace grail {
+
+/**
+ * @internal
+ * Create a new atomic recognizer for a given device and window
+ */
+AtomicRecognizer::AtomicRecognizer(UGHandle* handle, const UFDevice device, UFWindowId window)
+    : Recognizer(handle, device, window) {
+}
+
+/**
+ * @internal
+ * Process a uTouch-Frame event
+ */
+void AtomicRecognizer::ProcessFrameEvent(const UFEvent event) {
+  LOG(Dbg) << "new event " << event << " with time "
+           << frame_event_get_time(event) << "\n";
+
+  uint64_t event_time = frame_event_get_time(event);
+
+  UpdateTime(event_time);
+  CollectNewTouches(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 */
+    MatchSubscriptionsForNewTouches();
+  }
+  ProcessEvent(event);
+  FindGestureToAccept(event_time);
+}
+
+/**
+ * @internal
+ * Perform tasks necessary for when new touches occur and there is an existing
+ * accepted gesture
+ *
+ * If a gesture may add touches without crossing the maximum for the
+ * 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) {
+  UGSubscription* subscription = gesture->subscription();
+  if (gesture->touches().size() + new_touches_.size() <= subscription->touches_max()) {
+    gesture->AddTouches(new_touches_);
+    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
+        << " 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_);
+    }
+    CLEAR_TOUCHES(new_touches_);
+  } else {
+    for (UFTouchId touch : gesture->touches())
+      INSERT_TOUCH(touch, free_touches_);
+    gesture->End();
+    LOG(Dbg) << "ended active atomic gesture " << gesture->id()
+      << " because " << new_touches_.size() << " new touch(es) began and the "
+      "max touches has been reached\n";
+    accepted_gestures_.erase(gesture);
+  }
+}
+
+/**
+ * @internal
+ * Perform tasks necessary for when new touches occur and there is an existing
+ * unaccepted gesture
+ *
+ * If a gesture may receive the new touches without crossing the maximum for
+ * the subscription, add the touches to the gesture. Otherwise, cancel the
+ * gesture and add the current gesture touches to the free touches list.
+ */
+void AtomicRecognizer::HandleNewTouchesForUnacceptedGesture(
+    const SharedGesture& gesture) {
+  UGSubscription* subscription = gesture->subscription();
+  if (gesture->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";
+    }
+  } else {
+    for (UFTouchId touch_id : gesture->touches())
+      INSERT_TOUCH(touch_id, free_touches_);
+    gesture->Cancel();
+    LOG(Dbg) << "canceled inactive atomic gesture " << gesture->id()
+             << " because a new touch began and the max touches has been "
+             << "reached\n";
+    unaccepted_gestures_.erase(gesture);
+  }
+}
+
+/**
+ * @internal
+ * Register all new touches present in the given uTouch-Frame event.
+ */
+void AtomicRecognizer::CollectNewTouches(const UFEvent event) {
+  /* Check if any subscriptions are active before doing any processing */
+  if (num_subscriptions_ == 0)
+    return;
+
+  UFFrame frame;
+  UFStatus status = frame_event_get_property(event, UFEventPropertyFrame,
+                                             &frame);
+  if (status != UFStatusSuccess) {
+    LOG(Warn) << "failed to get frame from event\n";
+    return;
+  }
+
+  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);
+    if (status != UFStatusSuccess) {
+      LOG(Warn) << "failed to get touch from frame\n";
+      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;
+    }
+  }
+}
+
+/**
+ * @internal
+ * Consume the new touches.
+ * Check if any new atomic gestures should begin because of the new touches
+ * that came.
+ */
+void AtomicRecognizer::MatchSubscriptionsForNewTouches() {
+  /* Check if any subscriptions are active before doing any processing */
+  if (num_subscriptions_ == 0)
+    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_);
+  }
+
+  // Under atomic gestures rules there can be only one accepted gesture
+  assert(accepted_gestures_.size() <= 1);
+  if (accepted_gestures_.size() != 0) {
+    const SharedGesture& gesture = *accepted_gestures_.begin();
+    HandleNewTouchesForAcceptedGesture(gesture);
+  }
+
+  if (new_touches_.size() == 0) {
+    // they've all been consumed by the accepted gesture.
+    return;
+  }
+
+  /* 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++;
+    HandleNewTouchesForUnacceptedGesture(gesture);
+  }
+
+  MatchGestures();
+  CLEAR_TOUCHES(new_touches_);
+}
+
+void AtomicRecognizer::MatchGestures() {
+  if (free_touches_.size() == 0
+      || free_touches_.size() > MAX_TOUCHES_FOR_GESTURES)
+    return;
+
+  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())
+      continue;
+
+    if (start_times_[touch_id] < min_start_time)
+      min_start_time = start_times_[touch_id];
+
+    if (start_times_[touch_id] > max_start_time)
+      max_start_time = start_times_[touch_id];
+  }
+
+  /* All touches in a gesture must begin within a composition timeframe */
+  if ((max_start_time - min_start_time) >= kCompositionTime)
+    return;
+
+  for (UGSubscription* subscription : subscriptions_[free_touches_.size()-1]) {
+    Gesture* gesture = new Gesture(this, subscription, free_touches_,
+        max_start_time);
+
+    /* hold slice events until we accept the gesture */
+    gesture->SetKeepSlices(true);
+
+    unaccepted_gestures_.insert(SharedGesture(gesture));
+
+    LOG(Dbg) << "New tentative gesture " << gesture->id()
+      << " matched subscription " << subscription << " with mask "
+      << subscription->mask() << " for touches " << free_touches_.ToString()
+      << std::endl;
+  }
+}
+
+void AtomicRecognizer::FindGestureToAccept(uint64_t event_time)
+{
+  uint64_t delta_time;
+  for (auto it = unaccepted_gestures_.begin();
+       it != unaccepted_gestures_.end();
+       ) {
+    const SharedGesture& gesture = *it++;
+
+    delta_time = event_time - gesture->start_time();
+
+      /* Atomic gestures must be accepted if they meet the subscription
+         criteria.
+         Wait a bit until accepting them to avoid premature gestures that
+         will immediately get cancelled due to the apparition of a new touch
+         point on the following events.
+         e.g. like when a user puts four fingers on a touch screen but
+         the corresponding touch points come in separate events (because fingers
+         don't land precisely in sync and/or UTouch frame doesn't process their
+         arrivals in the very same event). We should generate only the "final"
+         4-touches' gesture and not the intermediates 2-touches and 3-touches
+         gestures.
+       */
+    if (gesture->IsActive() && delta_time > 0
+        && delta_time >= kCompositionTime) {
+
+      gesture->SetKeepSlices(false);
+
+      LOG(Dbg) << "accepting active atomic gesture " << gesture->id() << "\n";
+      AcceptGesture(gesture->id());
+    }
+  }
+}
+
+} // namespace grail
+} // namespace utouch

=== added file 'src/v3/atomic-recognizer.h'
--- src/v3/atomic-recognizer.h	1970-01-01 00:00:00 +0000
+++ src/v3/atomic-recognizer.h	2012-03-14 19:17:21 +0000
@@ -0,0 +1,52 @@
+/*****************************************************************************
+ *
+ * grail - Gesture Recognition And Instantiation Library
+ *
+ * Copyright (C) 2012 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ ****************************************************************************/
+
+#ifndef UTOUCH_GRAIL_ATOMIC_RECOGNIZER_H_
+#define UTOUCH_GRAIL_ATOMIC_RECOGNIZER_H_
+
+#include "v3/recognizer.h"
+
+namespace utouch {
+namespace grail {
+
+class AtomicRecognizer : public Recognizer {
+ public:
+  AtomicRecognizer(UGHandle* handle, const UFDevice device, UFWindowId window);
+
+  virtual bool atomic() const {return true;}
+  virtual void ProcessFrameEvent(const UFEvent event);
+
+ private:
+  void HandleNewTouchesForAcceptedGesture(const SharedGesture& gesture);
+  void HandleNewTouchesForUnacceptedGesture(const SharedGesture& gesture);
+  void CollectNewTouches(const UFEvent event);
+  void MatchSubscriptionsForNewTouches();
+  void MatchGestures();
+  void FindGestureToAccept(uint64_t event_time);
+
+  // 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_;
+};
+
+} // namespace grail
+} // namespace utouch
+#endif

=== modified file 'src/v3/forward.h'
--- src/v3/forward.h	2011-11-25 18:11:49 +0000
+++ src/v3/forward.h	2012-03-14 19:17:21 +0000
@@ -24,6 +24,7 @@
 
 #include <memory>
 #include <set>
+#include <sstream>
 
 #include <utouch/frame.h>
 
@@ -48,7 +49,19 @@
 class UGSubscription;
 typedef std::shared_ptr<UGSubscription> SharedUGSubscription;
 
-typedef std::set<UFTouchId> TouchSet;
+class TouchSet : public std::set<UFTouchId> {
+
+public:
+  std::string ToString() const {
+    std::ostringstream stream;
+    auto it = begin();
+    if (it != end())
+      stream << *it++;
+    while (it != end())
+      stream << ", " << *it++;
+    return stream.str();
+  }
+};
 
 } // namespace grail
 } // namespace utouch

=== modified file 'src/v3/gesture.cpp'
--- src/v3/gesture.cpp	2012-02-15 04:36:48 +0000
+++ src/v3/gesture.cpp	2012-03-14 19:17:21 +0000
@@ -51,7 +51,8 @@
       not_owned_(false),
       recognized_(0),
       canceled_(false),
-      ended_(false) {
+      ended_(false),
+      keep_slices_(false) {
 }
 
 /**
@@ -83,6 +84,23 @@
 
 /**
  * @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());
+}
+
+/**
+ * @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();
+}
+
+/**
+ * @internal
  * Update a gesture with the passed in frame event and list of modified touches
  */
 void Gesture::Update(UFEvent frame_event, TouchSet& modified_touches) {
@@ -298,6 +316,9 @@
  * @internal
  * Flush all pending gesture slices to the client as grail events */
 void Gesture::FlushSlices() {
+  if (keep_slices_)
+    return;
+
   while (!slices_.empty()) {
     UGEvent* event = new UGEvent(slices_.front());
     slices_.front()->ReferenceGesture();
@@ -373,5 +394,22 @@
   unowned_touches_.clear();
 }
 
+/**
+ * @internal
+ * If true, FlushSlices() will have no effect. The Gesture will keep all its
+ * slices until this property is disabled again, which will cause all pending
+ * slices to be flushed.
+ *
+ * By default, this property is false. */
+void Gesture::SetKeepSlices(bool keep_slices)
+{
+  if (keep_slices_ && !keep_slices) {
+    keep_slices_ = keep_slices;
+    FlushSlices();
+  } else {
+    keep_slices_ = keep_slices;
+  }
+}
+
 } // namespace grail
 } // namespace utouch

=== modified file 'src/v3/gesture.h'
--- src/v3/gesture.h	2012-02-15 04:36:48 +0000
+++ src/v3/gesture.h	2012-03-14 19:17:21 +0000
@@ -42,6 +42,8 @@
   Gesture(const Gesture* gesture, TouchSet& touches);
 
   void AddTouch(UFTouchId touch_id);
+  void AddTouches(TouchSet touch_set);
+  bool ContainsTouch(UFTouchId touch_id) const;
   void Update(UFEvent event, TouchSet& touches);
   bool IsActive() const;
   bool IsConstructionFinished() const;
@@ -63,6 +65,8 @@
   Gesture(const Gesture&) = delete;
   Gesture& operator=(const Gesture&) = delete;
 
+  void SetKeepSlices(bool keep_slices);
+
  private:
   void CheckOwned();
   void FlushSlices();
@@ -81,6 +85,7 @@
   bool canceled_;
   bool ended_;
   std::map<UFTouchId, float> angles_;
+  bool keep_slices_;
 };
 
 } // namespace grail

=== modified file 'src/v3/handle.cpp'
--- src/v3/handle.cpp	2012-01-21 00:00:16 +0000
+++ src/v3/handle.cpp	2012-03-14 19:17:21 +0000
@@ -32,9 +32,10 @@
 
 #include <utouch/frame_x11.h>
 
+#include "v3/atomic-recognizer.h"
 #include "v3/event.h"
 #include "v3/log.h"
-#include "v3/recognizer.h"
+#include "v3/regular-recognizer.h"
 #include "v3/subscription.h"
 
 namespace utouch {
@@ -49,6 +50,25 @@
   }
 }
 
+Recognizer *UGHandle::CreateRecognizerForSubscription(
+    UGSubscription* subscription) {
+  Recognizer* recognizer;
+
+  if (subscription->atomic())
+    recognizer = new AtomicRecognizer(this,
+        subscription->device(),
+        subscription->window_id());
+  else
+    recognizer = new RegularRecognizer(this,
+        subscription->device(),
+        subscription->window_id());
+
+  recognizers_[subscription->device()][subscription->window_id()] =
+    std::move(UniqueRecognizer(recognizer));
+
+  return recognizer;
+}
+
 UGStatus UGHandle::ActivateSubscription(UGSubscription* subscription) {
   Recognizer* recognizer;
 
@@ -59,11 +79,15 @@
       recognizers_[subscription->device()].find(subscription->window_id());
   if (it != recognizers_[subscription->device()].end()) {
     recognizer = it->second.get();
+
+    if (recognizer->atomic() != subscription->atomic()
+        && recognizer->num_subscriptions() == 0) {
+      // Fix the mismatch
+      recognizer = CreateRecognizerForSubscription(subscription);
+    }
+
   } else {
-    recognizer = new Recognizer(this, subscription->device(),
-                                subscription->window_id());
-    recognizers_[subscription->device()][subscription->window_id()] =
-        std::move(UniqueRecognizer(recognizer));
+    recognizer = CreateRecognizerForSubscription(subscription);
   }
 
   return recognizer->ActivateSubscription(subscription);

=== modified file 'src/v3/handle.h'
--- src/v3/handle.h	2011-11-29 20:13:02 +0000
+++ src/v3/handle.h	2012-03-14 19:17:21 +0000
@@ -43,6 +43,7 @@
   ~UGHandle();
 
   int event_fd() const { return event_fd_; }
+  Recognizer *CreateRecognizerForSubscription(UGSubscription* subscription);
   UGStatus ActivateSubscription(UGSubscription* subscription);
   void DeactivateSubscription(UGSubscription* subscription);
   unsigned int NewGestureID(Recognizer* recognizer);

=== modified file 'src/v3/log.cpp'
--- src/v3/log.cpp	2012-01-06 20:00:08 +0000
+++ src/v3/log.cpp	2012-03-14 19:17:21 +0000
@@ -59,5 +59,9 @@
   }
 }
 
+Logger& Logger::instance() {
+  return logger;
+}
+
 } // namespace grail
 } // namespace utouch

=== modified file 'src/v3/log.h'
--- src/v3/log.h	2012-01-06 20:00:08 +0000
+++ src/v3/log.h	2012-03-14 19:17:21 +0000
@@ -44,6 +44,10 @@
 
   static std::ostream& Log(Level level);
 
+  static Logger& instance();
+
+  Level level() const {return static_cast<Level>(level_);};
+
  private:
   int level_;
   NullStreamBuf null_buf_;

=== modified file 'src/v3/recognizer.cpp'
--- src/v3/recognizer.cpp	2012-03-14 14:54:09 +0000
+++ src/v3/recognizer.cpp	2012-03-14 19:17:21 +0000
@@ -22,6 +22,7 @@
 #include "v3/recognizer.h"
 
 #include <algorithm>
+#include <cassert>
 #include <cstdint>
 #include <cstdio>
 #include <limits>
@@ -33,27 +34,11 @@
 #include "v3/gesture.h"
 #include "v3/log.h"
 
-#define INSERT_TOUCH(element, set) \
-  { \
-    (set).insert(element); \
-    LOG(Dbg) << "touch " << element << " has been added to " #set "\n"; \
-  }
-
-#define ERASE_TOUCH(element, set) \
-  { \
-    (set).erase(element); \
-    LOG(Dbg) << "touch " << element << " has been erased from " #set "\n"; \
-  }
-
-namespace {
-
-const uint64_t COMPOSITION_TIME = 60;
-
-} // namespace
-
 namespace utouch {
 namespace grail {
 
+uint64_t Recognizer::kCompositionTime = 60;
+
 /**
  * @internal
  * Create a new recognizer for a given device and window
@@ -64,7 +49,6 @@
       device_(device),
       window_id_(window_id),
       device_direct_(true),
-      atomic_(false),
       num_subscriptions_(0) {
   /* Save direct property for gesture processing */
   UFStatus status = frame_device_get_property(device, UFDevicePropertyDirect,
@@ -107,13 +91,11 @@
  */
 UGStatus Recognizer::ActivateSubscription(UGSubscription* subscription) {
   /* All the subscriptions must be atomic or non-atomic, mixes break things */
-  for (auto subscriptions : subscriptions_)
-    if (subscriptions.size() > 0 && subscription->atomic() != atomic_)
+  if (subscription->atomic() != atomic())
       return UGStatusErrorAtomicity;
 
   /* Save the subscription and update atomicity */
   subscriptions_[subscription->touches_start() - 1].insert(subscription);
-  atomic_ = subscription->atomic();
   num_subscriptions_++;
 
   return UGStatusSuccess;
@@ -157,425 +139,6 @@
   num_subscriptions_--;
 }
 
-/**
- * @internal
- * Process a uTouch-Frame event
- */
-void Recognizer::ProcessFrameEvent(const UFEvent event) {
-  LOG(Dbg) << "new event " << event << " with time "
-           << frame_event_get_time(event) << "\n";
-  UpdateTime(frame_event_get_time(event));
-  MatchSubscriptionsForEvent(event);
-  ProcessEvent(event);
-}
-
-/**
- * @internal
- * Analyze a uTouch-Frame event to see if any new gestures should begin
- */
-void Recognizer::MatchSubscriptionsForEvent(const UFEvent event) {
-  /* Check if any subscriptions are active before doing any processing */
-  if (num_subscriptions_ == 0)
-    return;
-
-  UFFrame frame;
-  UFStatus status = frame_event_get_property(event, UFEventPropertyFrame,
-                                             &frame);
-  if (status != UFStatusSuccess) {
-    LOG(Warn) << "failed to get frame from event\n";
-    return;
-  }
-
-  /* Process all the touches that began in this frame */
-  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) {
-      LOG(Warn) << "failed to get touch from frame\n";
-      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);
-  }
-}
-
-/**
- * @internal
- * Perform tasks necessary for when a new touch occurs and there is an existing
- * accepted gesture
- *
- * Under normal processing:
- *   If a gesture may add a touch without crossing the maximum for the
- *   subscription, create a new unaccepted gesture with the new touch.
- *   Otherwise, do nothing. New gestures may still begin elsewhere.
- *
- * Under atomic gesture processing:
- *   If a gesture may add a touch without crossing the maximum for the
- *   subscription, add the touch to the gesture and accept it. Otherwise, end
- *   the gesture and add the current gesture touches to the free touches list.
- */
-void Recognizer::HandleNewTouchForAcceptedGesture(
-    UFTouchId touch_id,
-    const SharedGesture& gesture) {
-  UGSubscription* subscription = gesture->subscription();
-  if (gesture->touches().size() < subscription->touches_max()) {
-    if (atomic_) {
-      gesture->AddTouch(touch_id);
-      LOG(Dbg) << "touch " << touch_id << " has been added to atomic gesture "
-               << gesture->id() << "\n";
-      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
-               << " has been accepted because it has been added to an atomic "
-                  "gesture";
-      INSERT_TOUCH(touch_id, accepted_touches_);
-      ERASE_TOUCH(touch_id, unaccepted_touches_);
-      ERASE_TOUCH(touch_id, free_touches_);
-    } else {
-      TouchSet set(gesture->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 "
-               << new_gesture->id() << "\n";
-      unaccepted_gestures_.insert(SharedGesture(new_gesture));
-      LOG(Dbg) << "gesture " << new_gesture << " has been added to unaccepted "
-                                               "gestures\n";
-    }
-  } else if (atomic_) {
-    for (UFTouchId touch : gesture->touches())
-      INSERT_TOUCH(touch, free_touches_);
-    gesture->End();
-    LOG(Dbg) << "ended active atomic gesture " << gesture->id()
-             << " because a new touch began and the max touches has been "
-             << "reached\n";
-    accepted_gestures_.erase(gesture);
-  }
-}
-
-/**
- * @internal
- * Perform tasks necessary for when a new touch occurs and there is an existing
- * unaccepted gesture
- *
- * Under normal processing:
- *   If a gesture may add a touch without crossing the maximum for the
- *   subscription, create a new unaccepted gesture with the new touch.
- *   Otherwise, do nothing. New gestures may still begin elsewhere.
- *
- * Under atomic gesture processing:
- *   If a gesture may add a touch without crossing the maximum for the
- *   subscription, add the touch to the gesture and accept it. Otherwise, cancel
- *   the gesture and add the current gesture touches to the free touches list.
- */
-void Recognizer::HandleNewTouchForUnacceptedGesture(
-    UFTouchId touch_id,
-    const SharedGesture& gesture) {
-  UGSubscription* subscription = gesture->subscription();
-  if (gesture->touches().size() < subscription->touches_max()) {
-    if (atomic_) {
-      gesture->AddTouch(touch_id);
-      LOG(Dbg) << "touch " << touch_id << " has been added to atomic gesture "
-               << gesture->id() << "\n";
-      ERASE_TOUCH(touch_id, free_touches_);
-    } else {
-      TouchSet set(gesture->touches());
-      set.insert(touch_id);
-      Gesture* new_gesture = new Gesture(gesture.get(), set);
-      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));
-      LOG(Dbg) << "gesture " << new_gesture << " has been added to unaccepted "
-                                               "gestures\n";
-    }
-  } else if (atomic_) {
-    for (UFTouchId touch : gesture->touches())
-      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 "
-             << "reached\n";
-    unaccepted_gestures_.erase(gesture);
-  }
-}
-
-/**
- * @internal
- * Attempt to match the given touch against one touch subscriptions
- */
-void Recognizer::MatchOneTouchGestures(UFTouchId touch_id) {
-  /* Under atomic gesture processing, don't begin a new gesture unless it
-   * includes all the free touches */
-  if (atomic_ && free_touches_.size() != 1)
-    return;
-
-  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));
-
-    LOG(Dbg) << "New tentative gesture " << gesture->id()
-             << " matched subscription " << subscription << " with mask "
-             << subscription->mask() << " for touch " << touch_id << "\n";
-  }
-}
-
-/**
- * @internal
- * Attempt to match the given touch against two touch subscriptions
- */
-void Recognizer::MatchTwoTouchGestures(UFTouchId touch_id) {
-  /* Under atomic gesture processing, don't begin a new gesture unless it
-   * includes all the free touches */
-  if (atomic_ && free_touches_.size() != 2)
-    return;
-
-  for (UGSubscription* subscription : subscriptions_[1]) {
-    for (UFTouchId other_id : free_touches_) {
-      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];
-
-      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]);
-        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";
-      }
-    }
-  }
-}
-
-/**
- * @internal
- * Attempt to match the given touch against three touch subscriptions
- */
-void Recognizer::MatchThreeTouchGestures(UFTouchId touch_id) {
-  /* Under atomic gesture processing, don't begin a new gesture unless it
-   * includes all the free touches */
-  if (atomic_ && free_touches_.size() != 3)
-    return;
-
-  for (UGSubscription* subscription : subscriptions_[2]) {
-    for (UFTouchId other_id_1 : free_touches_) {
-      if (other_id_1 == touch_id)
-        continue;
-
-      for (UFTouchId other_id_2 : free_touches_) {
-        if (other_id_2 <= other_id_1 || other_id_2 == 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_[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]);
-          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";
-        }
-      }
-    }
-  }
-}
-
-/**
- * @internal
- * Attempt to match the given touch against four touch subscriptions
- */
-void Recognizer::MatchFourTouchGestures(UFTouchId touch_id) {
-  /* Under atomic gesture processing, don't begin a new gesture unless it
-   * includes all the free touches */
-  if (atomic_ && free_touches_.size() != 4)
-    return;
-
-  for (UGSubscription* subscription : subscriptions_[3]) {
-    for (UFTouchId other_id_1 : free_touches_) {
-      if (other_id_1 == touch_id)
-        continue;
-
-      for (UFTouchId other_id_2 : free_touches_) {
-        if (other_id_2 <= other_id_1 || other_id_2 == touch_id)
-          continue;
-
-        for (UFTouchId other_id_3 : free_touches_) {
-          if (other_id_3 <= other_id_2 || other_id_3 == 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_[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]);
-            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";
-          }
-        }
-      }
-    }
-  }
-}
-
-/**
- * @internal
- * Attempt to match the given touch against five touch subscriptions
- */
-void Recognizer::MatchFiveTouchGestures(UFTouchId touch_id) {
-  /* Under atomic gesture processing, don't begin a new gesture unless it
-   * includes all the free touches */
-  if (atomic_ && free_touches_.size() != 5)
-    return;
-
-  for (UGSubscription* subscription : subscriptions_[4]) {
-    for (UFTouchId other_id_1 : free_touches_) {
-      if (other_id_1 == touch_id)
-        continue;
-
-      for (UFTouchId other_id_2 : free_touches_) {
-        if (other_id_2 <= other_id_1 || other_id_2 == touch_id)
-          continue;
-
-        for (UFTouchId other_id_3 : free_touches_) {
-          if (other_id_3 <= other_id_2 || other_id_3 == touch_id)
-            continue;
-
-          for (UFTouchId other_id_4 : free_touches_) {
-            if (other_id_4 <= other_id_3 || other_id_4 == 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];
-
-            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]);
-              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";
-            }
-          }
-        }
-      }
-    }
-  }
-}
-
 namespace {
 
 /**
@@ -670,11 +233,6 @@
       LOG(Dbg) << "rejecting gesture " << gesture->id() << " because it has "
                                                            " been canceled\n";
       RejectGesture(gesture);
-    } else if (gesture->IsActive() && gesture->subscription()->atomic()) {
-      /* Atomic gestures must be accepted if they meet the subscription criteria
-       */
-      LOG(Dbg) << "accepting active atomic gesture " << gesture->id() << "\n";
-      AcceptGesture(gesture->id());
     }
   }
 
@@ -713,7 +271,7 @@
  *   gesture has not crossed the recognition thresholds yet)
  */
 void Recognizer::CheckConstructionFinished(uint64_t time) {
-  if (atomic_)
+  if (atomic())
     return;
 
   for (const SharedGesture& gesture : unaccepted_gestures_) {
@@ -721,7 +279,7 @@
       continue;
 
     for (UFTouchId touch_id : gesture->touches()) {
-      if (time - start_times_[touch_id] < COMPOSITION_TIME)
+      if (time - start_times_[touch_id] < kCompositionTime)
         goto next_gesture;
 
       for (const SharedGesture& other_gesture : unaccepted_gestures_) {
@@ -771,7 +329,7 @@
        it != unaccepted_touches_.end();
        ) {
     UFTouchId touch_id = *it++;
-    if (time - start_times_[touch_id] < COMPOSITION_TIME)
+    if (time - start_times_[touch_id] < kCompositionTime)
       continue;
 
     for (const SharedGesture& gesture : unaccepted_gestures_)
@@ -808,8 +366,8 @@
       if (gesture->touches().find(touch_id) != gesture->touches().end())
         goto next_touch;
 
-    if (COMPOSITION_TIME + start_times_[touch_id] < min_timeout)
-      min_timeout = start_times_[touch_id] + COMPOSITION_TIME;
+    if (kCompositionTime + start_times_[touch_id] < min_timeout)
+      min_timeout = start_times_[touch_id] + kCompositionTime;
 
 next_touch: ;
   }
@@ -859,7 +417,7 @@
        * gesture. Cancel the old gesture and remove any gesture events for it
        * from the event queue. Atomic behavior does not allow for gestures to be
        * extended in this way, and gestures may overlap.*/
-      if (!atomic_) {
+      if (!atomic()) {
         for (auto it = accepted_gestures_.begin();
              it != accepted_gestures_.end();
              ) {
@@ -886,7 +444,7 @@
 
   /* Reject any overlapping unaccepted gestures. Atomic subscriptions may have
    * overlapping gestures due to historical behavior. */
-  if (!atomic_) {
+  if (!atomic()) {
     for (auto it = unaccepted_gestures_.begin();
          it != unaccepted_gestures_.end();
          ) {

=== modified file 'src/v3/recognizer.h'
--- src/v3/recognizer.h	2012-01-27 11:57:35 +0000
+++ src/v3/recognizer.h	2012-03-14 19:17:21 +0000
@@ -33,17 +33,43 @@
 #include "v3/forward.h"
 #include "v3/subscription.h"
 
+#define INSERT_TOUCH(element, set) \
+  { \
+    (set).insert(element); \
+    LOG(Dbg) << "touch " << element << " has been added to " #set "\n"; \
+  }
+
+#define ERASE_TOUCH(element, set) \
+  { \
+    (set).erase(element); \
+    LOG(Dbg) << "touch " << element << " has been erased from " #set "\n"; \
+  }
+
+// OBS: it avoids the "expensive" ToString() call when debug output is not wanted.
+#define CLEAR_TOUCHES(set) \
+  { \
+    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(); \
+  }
+
 namespace utouch {
 namespace grail {
 
 class Recognizer {
  public:
   Recognizer(UGHandle* handle, const UFDevice device, UFWindowId window);
-  ~Recognizer();
+  virtual ~Recognizer();
+
+  virtual bool atomic() const = 0;
+  virtual void ProcessFrameEvent(const UFEvent event) = 0;
+
+  unsigned int num_subscriptions() const {return num_subscriptions_;}
 
   UGStatus 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);
@@ -57,7 +83,9 @@
   Recognizer(const Recognizer&) = delete;
   Recognizer& operator=(const Recognizer&) = delete;
 
- private:
+ protected:
+  static uint64_t kCompositionTime; /* in milliseconds */
+
   UGHandle* const handle_;
   const UFDevice device_;
   const UFWindowId window_id_;
@@ -72,22 +100,12 @@
   TouchSet unaccepted_touches_;
   TouchSet accepted_touches_;
   TouchSet free_touches_;
+
   unsigned int num_subscriptions_;
 
-  void HandleNewTouchForAcceptedGesture(UFTouchId touch_id,
-                                        const SharedGesture& gesture);
-  void HandleNewTouchForUnacceptedGesture(UFTouchId touch_id,
-                                          const SharedGesture& gesture);
-  void MatchSubscriptionsForEvent(const UFEvent event);
-  void MatchSubscriptionsForTouch(UFTouchId touch_id);
-  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 ProcessEvent(const UFEvent& event);
   void CheckConstructionFinished(uint64_t time);
   void RejectGesture(SharedGesture gesture);
+  void ProcessEvent(const UFEvent& event);
 };
 
 } // namespace grail

=== added file 'src/v3/regular-recognizer.cpp'
--- src/v3/regular-recognizer.cpp	1970-01-01 00:00:00 +0000
+++ src/v3/regular-recognizer.cpp	2012-03-14 19:17:21 +0000
@@ -0,0 +1,396 @@
+/*****************************************************************************
+ *
+ * grail - Gesture Recognition And Instantiation Library
+ *
+ * Copyright (C) 2012 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ ****************************************************************************/
+
+#include "v3/regular-recognizer.h"
+
+#include <algorithm>
+#include <cassert>
+#include <cstdint>
+#include <cstdio>
+#include <limits>
+
+#include <utouch/frame.h>
+#include <utouch/frame_x11.h>
+
+#include "v3/handle.h"
+#include "v3/gesture.h"
+#include "v3/log.h"
+
+namespace utouch {
+namespace grail {
+
+/**
+ * @internal
+ * Create a new regular recognizer for a given device and window
+ */
+RegularRecognizer::RegularRecognizer(UGHandle* handle, const UFDevice device,
+                                     UFWindowId window_id)
+    : Recognizer(handle, device, window_id) {
+}
+
+/**
+ * @internal
+ * Process a uTouch-Frame event
+ */
+void RegularRecognizer::ProcessFrameEvent(const UFEvent event) {
+  LOG(Dbg) << "new event " << event << " with time "
+           << frame_event_get_time(event) << "\n";
+  UpdateTime(frame_event_get_time(event));
+  MatchSubscriptionsForEvent(event);
+  ProcessEvent(event);
+}
+
+/**
+ * @internal
+ * Analyze a uTouch-Frame event to see if any new gestures should begin
+ */
+void RegularRecognizer::MatchSubscriptionsForEvent(const UFEvent event) {
+  /* Check if any subscriptions are active before doing any processing */
+  if (num_subscriptions_ == 0)
+    return;
+
+  UFFrame frame;
+  UFStatus status = frame_event_get_property(event, UFEventPropertyFrame,
+                                             &frame);
+  if (status != UFStatusSuccess) {
+    LOG(Warn) << "failed to get frame from event\n";
+    return;
+  }
+
+  /* Process all the touches that began in this frame */
+  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) {
+      LOG(Warn) << "failed to get touch from frame\n";
+      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);
+  }
+}
+
+/**
+ * @internal
+ * Perform tasks necessary for when a new touch occurs and there is an existing
+ * accepted gesture
+ *
+ * If a gesture may add a touch without crossing the maximum for the
+ * subscription, create a new unaccepted gesture with the new touch.
+ * Otherwise, do nothing. New gestures may still begin elsewhere.
+ */
+void RegularRecognizer::HandleNewTouchForAcceptedGesture(
+    UFTouchId touch_id,
+    const SharedGesture& gesture) {
+  UGSubscription* subscription = gesture->subscription();
+  if (gesture->touches().size() < subscription->touches_max()
+      && !gesture->ContainsTouch(touch_id)) {
+    TouchSet set(gesture->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 "
+      << new_gesture->id() << "\n";
+    unaccepted_gestures_.insert(SharedGesture(new_gesture));
+    LOG(Dbg) << "gesture " << new_gesture << " has been added to unaccepted "
+      "gestures\n";
+  }
+}
+
+/**
+ * @internal
+ * Perform tasks necessary for when a new touch occurs and there is an existing
+ * unaccepted gesture
+ *
+ * If a gesture may add a touch without crossing the maximum for the
+ * subscription, create a new unaccepted gesture with the new touch.
+ * Otherwise, do nothing. New gestures may still begin elsewhere.
+ */
+void RegularRecognizer::HandleNewTouchForUnacceptedGesture(
+    UFTouchId touch_id,
+    const SharedGesture& gesture) {
+  UGSubscription* subscription = gesture->subscription();
+  if (gesture->touches().size() < subscription->touches_max()
+        && !gesture->ContainsTouch(touch_id)) {
+    TouchSet set(gesture->touches());
+    set.insert(touch_id);
+    Gesture* new_gesture = new Gesture(gesture.get(), set);
+    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));
+    LOG(Dbg) << "gesture " << new_gesture << " has been added to unaccepted "
+      "gestures\n";
+  }
+}
+
+/**
+ * @internal
+ * Attempt to match the given touch against one touch subscriptions
+ */
+void RegularRecognizer::MatchOneTouchGestures(UFTouchId 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));
+
+    LOG(Dbg) << "New tentative gesture " << gesture->id()
+             << " matched subscription " << subscription << " with mask "
+             << subscription->mask() << " for touch " << touch_id << "\n";
+  }
+}
+
+/**
+ * @internal
+ * Attempt to match the given touch against two touch subscriptions
+ */
+void RegularRecognizer::MatchTwoTouchGestures(UFTouchId touch_id) {
+  for (UGSubscription* subscription : subscriptions_[1]) {
+    for (UFTouchId other_id : free_touches_) {
+      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];
+
+      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));
+
+        LOG(Dbg) << "New tentative gesture " << gesture->id()
+                 << " matched subscription " << subscription << " with mask "
+                 << subscription->mask() << " for touches " << touch_id << ", "
+                 << other_id << "\n";
+      }
+    }
+  }
+}
+
+/**
+ * @internal
+ * Attempt to match the given touch against three touch subscriptions
+ */
+void RegularRecognizer::MatchThreeTouchGestures(UFTouchId touch_id) {
+  for (UGSubscription* subscription : subscriptions_[2]) {
+    for (UFTouchId other_id_1 : free_touches_) {
+      if (other_id_1 == touch_id)
+        continue;
+
+      for (UFTouchId other_id_2 : free_touches_) {
+        if (other_id_2 <= other_id_1 || other_id_2 == 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_[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));
+
+          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";
+        }
+      }
+    }
+  }
+}
+
+/**
+ * @internal
+ * Attempt to match the given touch against four touch subscriptions
+ */
+void RegularRecognizer::MatchFourTouchGestures(UFTouchId touch_id) {
+  for (UGSubscription* subscription : subscriptions_[3]) {
+    for (UFTouchId other_id_1 : free_touches_) {
+      if (other_id_1 == touch_id)
+        continue;
+
+      for (UFTouchId other_id_2 : free_touches_) {
+        if (other_id_2 <= other_id_1 || other_id_2 == touch_id)
+          continue;
+
+        for (UFTouchId other_id_3 : free_touches_) {
+          if (other_id_3 <= other_id_2 || other_id_3 == 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_[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));
+
+            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";
+          }
+        }
+      }
+    }
+  }
+}
+
+/**
+ * @internal
+ * Attempt to match the given touch against five touch subscriptions
+ */
+void RegularRecognizer::MatchFiveTouchGestures(UFTouchId touch_id) {
+  for (UGSubscription* subscription : subscriptions_[4]) {
+    for (UFTouchId other_id_1 : free_touches_) {
+      if (other_id_1 == touch_id)
+        continue;
+
+      for (UFTouchId other_id_2 : free_touches_) {
+        if (other_id_2 <= other_id_1 || other_id_2 == touch_id)
+          continue;
+
+        for (UFTouchId other_id_3 : free_touches_) {
+          if (other_id_3 <= other_id_2 || other_id_3 == touch_id)
+            continue;
+
+          for (UFTouchId other_id_4 : free_touches_) {
+            if (other_id_4 <= other_id_3 || other_id_4 == 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];
+
+            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));
+
+              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";
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+} // namespace grail
+} // namespace utouch

=== added file 'src/v3/regular-recognizer.h'
--- src/v3/regular-recognizer.h	1970-01-01 00:00:00 +0000
+++ src/v3/regular-recognizer.h	2012-03-14 19:17:21 +0000
@@ -0,0 +1,52 @@
+/*****************************************************************************
+ *
+ * grail - Gesture Recognition And Instantiation Library
+ *
+ * Copyright (C) 2012 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ ****************************************************************************/
+
+#ifndef UTOUCH_GRAIL_REGULAR_RECOGNIZER_H_
+#define UTOUCH_GRAIL_REGULAR_RECOGNIZER_H_
+
+#include "v3/recognizer.h"
+
+namespace utouch {
+namespace grail {
+
+class RegularRecognizer : public Recognizer {
+ public:
+  RegularRecognizer(UGHandle* handle, const UFDevice device, UFWindowId window);
+
+  virtual bool atomic() const {return false;}
+  virtual void ProcessFrameEvent(const UFEvent event);
+
+ private:
+  void HandleNewTouchForAcceptedGesture(UFTouchId touch_id,
+                                        const SharedGesture& gesture);
+  void HandleNewTouchForUnacceptedGesture(UFTouchId touch_id,
+                                          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);
+};
+
+} // namespace grail
+} // namespace utouch
+#endif

=== modified file 'test/Makefile.am'
--- test/Makefile.am	2012-03-06 20:12:40 +0000
+++ test/Makefile.am	2012-03-14 19:17:21 +0000
@@ -29,6 +29,7 @@
 	recording.h \
 	x11/fixture.cpp \
 	x11/fixture.h \
+	x11/no-premature-gestures.cpp \
 	x11/no-tap-after-drag.cpp \
 	x11/twodrag.cpp \
 	x11/dragthresh.cpp \

=== added file 'test/recordings/apple-wtrackpad-synced-4-drag.event'
--- test/recordings/apple-wtrackpad-synced-4-drag.event	1970-01-01 00:00:00 +0000
+++ test/recordings/apple-wtrackpad-synced-4-drag.event	2012-03-14 19:17:21 +0000
@@ -0,0 +1,713 @@
+E: 1331641155.505566 0003 0039 1
+E: 1331641155.505567 0003 0030 84
+E: 1331641155.505568 0003 0031 132
+E: 1331641155.505568 0003 0034 8
+E: 1331641155.505569 0003 0035 -1940
+E: 1331641155.505570 0003 0036 -910
+E: 1331641155.505571 0000 0002 0
+E: 1331641155.505571 0003 0039 2
+E: 1331641155.505572 0003 0030 64
+E: 1331641155.505573 0003 0031 76
+E: 1331641155.505573 0003 0034 1
+E: 1331641155.505574 0003 0035 1649
+E: 1331641155.505575 0003 0036 -1430
+E: 1331641155.505575 0000 0002 0
+E: 1331641155.505576 0003 0039 3
+E: 1331641155.505577 0003 0030 164
+E: 1331641155.505577 0003 0031 124
+E: 1331641155.505578 0003 0034 0
+E: 1331641155.505578 0003 0035 -1055
+E: 1331641155.505579 0003 0036 -1523
+E: 1331641155.505580 0000 0002 0
+E: 1331641155.505580 0003 0039 8
+E: 1331641155.505581 0003 0030 180
+E: 1331641155.505582 0003 0031 188
+E: 1331641155.505582 0003 0034 32
+E: 1331641155.505583 0003 0035 249
+E: 1331641155.505584 0003 0036 -1808
+E: 1331641155.505584 0000 0002 0
+E: 1331641155.505585 0001 014a 1
+E: 1331641155.505587 0001 014f 1
+E: 1331641155.505587 0003 0000 -1940
+E: 1331641155.505588 0003 0001 -910
+E: 1331641155.505589 0000 0000 0
+E: 1331641155.530563 0003 0039 1
+E: 1331641155.530564 0003 0030 100
+E: 1331641155.530564 0003 0031 152
+E: 1331641155.530565 0003 0034 0
+E: 1331641155.530565 0003 0035 -1950
+E: 1331641155.530566 0003 0036 -898
+E: 1331641155.530567 0000 0002 0
+E: 1331641155.530568 0003 0039 2
+E: 1331641155.530568 0003 0030 96
+E: 1331641155.530569 0003 0031 132
+E: 1331641155.530569 0003 0034 0
+E: 1331641155.530570 0003 0035 1631
+E: 1331641155.530571 0003 0036 -1420
+E: 1331641155.530571 0000 0002 0
+E: 1331641155.530572 0003 0039 3
+E: 1331641155.530573 0003 0030 148
+E: 1331641155.530573 0003 0031 136
+E: 1331641155.530574 0003 0034 0
+E: 1331641155.530575 0003 0035 -1061
+E: 1331641155.530575 0003 0036 -1516
+E: 1331641155.530576 0000 0002 0
+E: 1331641155.530577 0003 0039 8
+E: 1331641155.530577 0003 0030 176
+E: 1331641155.530578 0003 0031 168
+E: 1331641155.530579 0003 0034 0
+E: 1331641155.530579 0003 0035 251
+E: 1331641155.530580 0003 0036 -1814
+E: 1331641155.530581 0000 0002 0
+E: 1331641155.530583 0003 0000 -1950
+E: 1331641155.530584 0003 0001 -898
+E: 1331641155.530585 0000 0000 0
+E: 1331641155.546821 0003 0039 1
+E: 1331641155.546822 0003 0030 120
+E: 1331641155.546822 0003 0031 164
+E: 1331641155.546823 0003 0034 0
+E: 1331641155.546824 0003 0035 -1950
+E: 1331641155.546824 0003 0036 -868
+E: 1331641155.546825 0000 0002 0
+E: 1331641155.546826 0003 0039 2
+E: 1331641155.546826 0003 0030 104
+E: 1331641155.546827 0003 0031 168
+E: 1331641155.546828 0003 0034 0
+E: 1331641155.546828 0003 0035 1622
+E: 1331641155.546829 0003 0036 -1416
+E: 1331641155.546830 0000 0002 0
+E: 1331641155.546830 0003 0039 3
+E: 1331641155.546831 0003 0030 156
+E: 1331641155.546831 0003 0031 144
+E: 1331641155.546832 0003 0034 0
+E: 1331641155.546833 0003 0035 -1061
+E: 1331641155.546833 0003 0036 -1483
+E: 1331641155.546834 0000 0002 0
+E: 1331641155.546835 0003 0039 8
+E: 1331641155.546835 0003 0030 164
+E: 1331641155.546836 0003 0031 148
+E: 1331641155.546837 0003 0034 0
+E: 1331641155.546837 0003 0035 247
+E: 1331641155.546838 0003 0036 -1791
+E: 1331641155.546838 0000 0002 0
+E: 1331641155.546842 0003 0001 -868
+E: 1331641155.546842 0000 0000 0
+E: 1331641155.549309 0003 0039 1
+E: 1331641155.549310 0003 0030 132
+E: 1331641155.549310 0003 0031 176
+E: 1331641155.549311 0003 0034 0
+E: 1331641155.549312 0003 0035 -1954
+E: 1331641155.549312 0003 0036 -825
+E: 1331641155.549313 0000 0002 0
+E: 1331641155.549314 0003 0039 2
+E: 1331641155.549314 0003 0030 120
+E: 1331641155.549315 0003 0031 196
+E: 1331641155.549315 0003 0034 0
+E: 1331641155.549316 0003 0035 1616
+E: 1331641155.549317 0003 0036 -1382
+E: 1331641155.549317 0000 0002 0
+E: 1331641155.549318 0003 0039 3
+E: 1331641155.549319 0003 0030 176
+E: 1331641155.549319 0003 0031 180
+E: 1331641155.549320 0003 0034 0
+E: 1331641155.549321 0003 0035 -1056
+E: 1331641155.549321 0003 0036 -1443
+E: 1331641155.549322 0000 0002 0
+E: 1331641155.549323 0003 0039 8
+E: 1331641155.549323 0003 0030 156
+E: 1331641155.549324 0003 0031 152
+E: 1331641155.549325 0003 0034 0
+E: 1331641155.549325 0003 0035 241
+E: 1331641155.549326 0003 0036 -1760
+E: 1331641155.549327 0000 0002 0
+E: 1331641155.549329 0003 0000 -1952
+E: 1331641155.549330 0003 0001 -825
+E: 1331641155.549331 0000 0000 0
+E: 1331641155.551812 0003 0039 1
+E: 1331641155.551813 0003 0030 140
+E: 1331641155.551814 0003 0031 204
+E: 1331641155.551815 0003 0034 0
+E: 1331641155.551815 0003 0035 -1949
+E: 1331641155.551816 0003 0036 -767
+E: 1331641155.551817 0000 0002 0
+E: 1331641155.551817 0003 0039 2
+E: 1331641155.551818 0003 0030 132
+E: 1331641155.551819 0003 0031 208
+E: 1331641155.551819 0003 0034 0
+E: 1331641155.551820 0003 0035 1614
+E: 1331641155.551820 0003 0036 -1331
+E: 1331641155.551821 0000 0002 0
+E: 1331641155.551822 0003 0039 3
+E: 1331641155.551823 0003 0030 176
+E: 1331641155.551823 0003 0031 200
+E: 1331641155.551824 0003 0034 0
+E: 1331641155.551824 0003 0035 -1049
+E: 1331641155.551825 0003 0036 -1387
+E: 1331641155.551826 0000 0002 0
+E: 1331641155.551826 0003 0039 8
+E: 1331641155.551827 0003 0030 168
+E: 1331641155.551828 0003 0031 184
+E: 1331641155.551828 0003 0034 0
+E: 1331641155.551829 0003 0035 238
+E: 1331641155.551829 0003 0036 -1715
+E: 1331641155.551830 0000 0002 0
+E: 1331641155.551833 0003 0000 -1951
+E: 1331641155.551834 0003 0001 -767
+E: 1331641155.551834 0000 0000 0
+E: 1331641155.555561 0003 0039 1
+E: 1331641155.555562 0003 0030 156
+E: 1331641155.555563 0003 0031 216
+E: 1331641155.555563 0003 0034 0
+E: 1331641155.555564 0003 0035 -1940
+E: 1331641155.555565 0003 0036 -705
+E: 1331641155.555565 0000 0002 0
+E: 1331641155.555566 0003 0039 2
+E: 1331641155.555567 0003 0030 120
+E: 1331641155.555567 0003 0031 228
+E: 1331641155.555568 0003 0034 0
+E: 1331641155.555569 0003 0035 1618
+E: 1331641155.555569 0003 0036 -1275
+E: 1331641155.555570 0000 0002 0
+E: 1331641155.555571 0003 0039 3
+E: 1331641155.555571 0003 0030 180
+E: 1331641155.555572 0003 0031 180
+E: 1331641155.555572 0003 0034 0
+E: 1331641155.555573 0003 0035 -1039
+E: 1331641155.555574 0003 0036 -1323
+E: 1331641155.555574 0000 0002 0
+E: 1331641155.555575 0003 0039 8
+E: 1331641155.555576 0003 0030 184
+E: 1331641155.555576 0003 0031 192
+E: 1331641155.555577 0003 0034 -29
+E: 1331641155.555577 0003 0035 240
+E: 1331641155.555578 0003 0036 -1657
+E: 1331641155.555579 0000 0002 0
+E: 1331641155.555581 0003 0000 -1940
+E: 1331641155.555582 0003 0001 -705
+E: 1331641155.555583 0000 0000 0
+E: 1331641155.575560 0003 0039 1
+E: 1331641155.575561 0003 0030 148
+E: 1331641155.575562 0003 0031 208
+E: 1331641155.575563 0003 0034 0
+E: 1331641155.575563 0003 0035 -1928
+E: 1331641155.575564 0003 0036 -629
+E: 1331641155.575565 0000 0002 0
+E: 1331641155.575565 0003 0039 2
+E: 1331641155.575566 0003 0030 116
+E: 1331641155.575567 0003 0031 208
+E: 1331641155.575567 0003 0034 0
+E: 1331641155.575568 0003 0035 1625
+E: 1331641155.575569 0003 0036 -1207
+E: 1331641155.575569 0000 0002 0
+E: 1331641155.575570 0003 0039 3
+E: 1331641155.575571 0003 0030 168
+E: 1331641155.575571 0003 0031 164
+E: 1331641155.575572 0003 0034 0
+E: 1331641155.575573 0003 0035 -1025
+E: 1331641155.575573 0003 0036 -1243
+E: 1331641155.575574 0000 0002 0
+E: 1331641155.575575 0003 0039 8
+E: 1331641155.575575 0003 0030 172
+E: 1331641155.575576 0003 0031 168
+E: 1331641155.575576 0003 0034 0
+E: 1331641155.575577 0003 0035 245
+E: 1331641155.575578 0003 0036 -1591
+E: 1331641155.575578 0000 0002 0
+E: 1331641155.575581 0003 0000 -1928
+E: 1331641155.575582 0003 0001 -629
+E: 1331641155.575582 0000 0000 0
+E: 1331641155.578059 0003 0039 1
+E: 1331641155.578060 0003 0030 152
+E: 1331641155.578061 0003 0031 232
+E: 1331641155.578062 0003 0034 0
+E: 1331641155.578062 0003 0035 -1914
+E: 1331641155.578063 0003 0036 -549
+E: 1331641155.578064 0000 0002 0
+E: 1331641155.578064 0003 0039 2
+E: 1331641155.578065 0003 0030 116
+E: 1331641155.578066 0003 0031 196
+E: 1331641155.578066 0003 0034 0
+E: 1331641155.578067 0003 0035 1632
+E: 1331641155.578068 0003 0036 -1130
+E: 1331641155.578068 0000 0002 0
+E: 1331641155.578069 0003 0039 3
+E: 1331641155.578070 0003 0030 156
+E: 1331641155.578070 0003 0031 176
+E: 1331641155.578071 0003 0034 0
+E: 1331641155.578072 0003 0035 -999
+E: 1331641155.578072 0003 0036 -1120
+E: 1331641155.578073 0000 0002 0
+E: 1331641155.578074 0003 0039 8
+E: 1331641155.578074 0003 0030 188
+E: 1331641155.578074 0003 0031 188
+E: 1331641155.578075 0003 0034 0
+E: 1331641155.578076 0003 0035 253
+E: 1331641155.578076 0003 0036 -1511
+E: 1331641155.578077 0000 0002 0
+E: 1331641155.578080 0003 0000 -1914
+E: 1331641155.578080 0003 0001 -549
+E: 1331641155.578081 0000 0000 0
+E: 1331641155.585562 0003 0039 1
+E: 1331641155.585563 0003 0030 160
+E: 1331641155.585563 0003 0031 208
+E: 1331641155.585564 0003 0034 0
+E: 1331641155.585565 0003 0035 -1893
+E: 1331641155.585565 0003 0036 -424
+E: 1331641155.585566 0000 0002 0
+E: 1331641155.585567 0003 0039 2
+E: 1331641155.585567 0003 0030 124
+E: 1331641155.585568 0003 0031 200
+E: 1331641155.585569 0003 0034 0
+E: 1331641155.585569 0003 0035 1640
+E: 1331641155.585570 0003 0036 -1046
+E: 1331641155.585571 0000 0002 0
+E: 1331641155.585571 0003 0039 3
+E: 1331641155.585572 0003 0030 140
+E: 1331641155.585573 0003 0031 160
+E: 1331641155.585573 0003 0034 0
+E: 1331641155.585574 0003 0035 -958
+E: 1331641155.585575 0003 0036 -924
+E: 1331641155.585575 0000 0002 0
+E: 1331641155.585576 0003 0039 8
+E: 1331641155.585577 0003 0030 192
+E: 1331641155.585577 0003 0031 196
+E: 1331641155.585578 0003 0034 -30
+E: 1331641155.585578 0003 0035 267
+E: 1331641155.585579 0003 0036 -1391
+E: 1331641155.585580 0000 0002 0
+E: 1331641155.585582 0003 0000 -1893
+E: 1331641155.585583 0003 0001 -424
+E: 1331641155.585584 0000 0000 0
+E: 1331641155.605561 0003 0039 1
+E: 1331641155.605562 0003 0030 164
+E: 1331641155.605563 0003 0031 232
+E: 1331641155.605563 0003 0034 0
+E: 1331641155.605564 0003 0035 -1868
+E: 1331641155.605564 0003 0036 -286
+E: 1331641155.605565 0000 0002 0
+E: 1331641155.605566 0003 0039 2
+E: 1331641155.605567 0003 0030 116
+E: 1331641155.605567 0003 0031 204
+E: 1331641155.605568 0003 0034 0
+E: 1331641155.605568 0003 0035 1657
+E: 1331641155.605569 0003 0036 -877
+E: 1331641155.605570 0000 0002 0
+E: 1331641155.605571 0003 0039 3
+E: 1331641155.605571 0003 0030 160
+E: 1331641155.605571 0003 0031 160
+E: 1331641155.605572 0003 0034 0
+E: 1331641155.605573 0003 0035 -934
+E: 1331641155.605573 0003 0036 -805
+E: 1331641155.605574 0000 0002 0
+E: 1331641155.605575 0003 0039 8
+E: 1331641155.605575 0003 0030 196
+E: 1331641155.605576 0003 0031 184
+E: 1331641155.605577 0003 0034 32
+E: 1331641155.605577 0003 0035 285
+E: 1331641155.605578 0003 0036 -1253
+E: 1331641155.605578 0000 0002 0
+E: 1331641155.605581 0003 0000 -1868
+E: 1331641155.605582 0003 0001 -286
+E: 1331641155.605582 0000 0000 0
+E: 1331641155.608299 0003 0039 1
+E: 1331641155.608300 0003 0030 164
+E: 1331641155.608301 0003 0031 236
+E: 1331641155.608302 0003 0034 0
+E: 1331641155.608302 0003 0035 -1842
+E: 1331641155.608303 0003 0036 -135
+E: 1331641155.608304 0000 0002 0
+E: 1331641155.608304 0003 0039 2
+E: 1331641155.608305 0003 0030 132
+E: 1331641155.608306 0003 0031 224
+E: 1331641155.608306 0003 0034 0
+E: 1331641155.608307 0003 0035 1677
+E: 1331641155.608308 0003 0036 -724
+E: 1331641155.608308 0000 0002 0
+E: 1331641155.608309 0003 0039 3
+E: 1331641155.608310 0003 0030 176
+E: 1331641155.608310 0003 0031 160
+E: 1331641155.608311 0003 0034 32
+E: 1331641155.608311 0003 0035 -887
+E: 1331641155.608312 0003 0036 -562
+E: 1331641155.608313 0000 0002 0
+E: 1331641155.608313 0003 0039 8
+E: 1331641155.608314 0003 0030 200
+E: 1331641155.608315 0003 0031 204
+E: 1331641155.608315 0003 0034 0
+E: 1331641155.608316 0003 0035 307
+E: 1331641155.608317 0003 0036 -1102
+E: 1331641155.608317 0000 0002 0
+E: 1331641155.608320 0003 0000 -1842
+E: 1331641155.608321 0003 0001 -135
+E: 1331641155.608321 0000 0000 0
+E: 1331641155.628292 0003 0039 1
+E: 1331641155.628293 0003 0030 176
+E: 1331641155.628293 0003 0031 216
+E: 1331641155.628294 0003 0034 0
+E: 1331641155.628295 0003 0035 -1815
+E: 1331641155.628295 0003 0036 24
+E: 1331641155.628296 0000 0002 0
+E: 1331641155.628297 0003 0039 2
+E: 1331641155.628297 0003 0030 128
+E: 1331641155.628298 0003 0031 204
+E: 1331641155.628299 0003 0034 0
+E: 1331641155.628299 0003 0035 1700
+E: 1331641155.628300 0003 0036 -565
+E: 1331641155.628300 0000 0002 0
+E: 1331641155.628301 0003 0039 3
+E: 1331641155.628302 0003 0030 176
+E: 1331641155.628302 0003 0031 164
+E: 1331641155.628303 0003 0034 0
+E: 1331641155.628304 0003 0035 -863
+E: 1331641155.628304 0003 0036 -435
+E: 1331641155.628305 0000 0002 0
+E: 1331641155.628306 0003 0039 8
+E: 1331641155.628306 0003 0030 200
+E: 1331641155.628307 0003 0031 188
+E: 1331641155.628308 0003 0034 -30
+E: 1331641155.628308 0003 0035 332
+E: 1331641155.628309 0003 0036 -942
+E: 1331641155.628310 0000 0002 0
+E: 1331641155.628312 0003 0000 -1815
+E: 1331641155.628313 0003 0001 24
+E: 1331641155.628314 0000 0000 0
+E: 1331641155.630546 0003 0039 1
+E: 1331641155.630547 0003 0030 168
+E: 1331641155.630548 0003 0031 188
+E: 1331641155.630548 0003 0034 0
+E: 1331641155.630549 0003 0035 -1787
+E: 1331641155.630549 0003 0036 190
+E: 1331641155.630550 0000 0002 0
+E: 1331641155.630551 0003 0039 2
+E: 1331641155.630552 0003 0030 136
+E: 1331641155.630552 0003 0031 204
+E: 1331641155.630553 0003 0034 0
+E: 1331641155.630554 0003 0035 1725
+E: 1331641155.630554 0003 0036 -398
+E: 1331641155.630555 0000 0002 0
+E: 1331641155.630556 0003 0039 3
+E: 1331641155.630556 0003 0030 184
+E: 1331641155.630557 0003 0031 148
+E: 1331641155.630558 0003 0034 32
+E: 1331641155.630558 0003 0035 -830
+E: 1331641155.630559 0003 0036 -246
+E: 1331641155.630559 0000 0002 0
+E: 1331641155.630560 0003 0039 8
+E: 1331641155.630561 0003 0030 204
+E: 1331641155.630561 0003 0031 192
+E: 1331641155.630562 0003 0034 -31
+E: 1331641155.630563 0003 0035 359
+E: 1331641155.630563 0003 0036 -773
+E: 1331641155.630564 0000 0002 0
+E: 1331641155.630567 0003 0000 -1787
+E: 1331641155.630567 0003 0001 190
+E: 1331641155.630568 0000 0000 0
+E: 1331641155.636814 0003 0039 1
+E: 1331641155.636815 0003 0030 156
+E: 1331641155.636815 0003 0031 188
+E: 1331641155.636816 0003 0034 0
+E: 1331641155.636817 0003 0035 -1757
+E: 1331641155.636817 0003 0036 358
+E: 1331641155.636818 0000 0002 0
+E: 1331641155.636819 0003 0039 2
+E: 1331641155.636819 0003 0030 148
+E: 1331641155.636820 0003 0031 204
+E: 1331641155.636821 0003 0034 0
+E: 1331641155.636821 0003 0035 1751
+E: 1331641155.636822 0003 0036 -224
+E: 1331641155.636823 0000 0002 0
+E: 1331641155.636823 0003 0039 3
+E: 1331641155.636824 0003 0030 180
+E: 1331641155.636825 0003 0031 136
+E: 1331641155.636825 0003 0034 0
+E: 1331641155.636826 0003 0035 -800
+E: 1331641155.636826 0003 0036 -58
+E: 1331641155.636827 0000 0002 0
+E: 1331641155.636828 0003 0039 8
+E: 1331641155.636828 0003 0030 184
+E: 1331641155.636829 0003 0031 204
+E: 1331641155.636830 0003 0034 0
+E: 1331641155.636830 0003 0035 388
+E: 1331641155.636831 0003 0036 -601
+E: 1331641155.636832 0000 0002 0
+E: 1331641155.636834 0003 0000 -1757
+E: 1331641155.636835 0003 0001 358
+E: 1331641155.636836 0000 0000 0
+E: 1331641155.656821 0003 0039 1
+E: 1331641155.656822 0003 0030 156
+E: 1331641155.656822 0003 0031 156
+E: 1331641155.656823 0003 0034 0
+E: 1331641155.656824 0003 0035 -1729
+E: 1331641155.656824 0003 0036 529
+E: 1331641155.656825 0000 0002 0
+E: 1331641155.656826 0003 0039 2
+E: 1331641155.656826 0003 0030 144
+E: 1331641155.656827 0003 0031 188
+E: 1331641155.656828 0003 0034 0
+E: 1331641155.656828 0003 0035 1777
+E: 1331641155.656829 0003 0036 -47
+E: 1331641155.656830 0000 0002 0
+E: 1331641155.656830 0003 0039 3
+E: 1331641155.656831 0003 0030 160
+E: 1331641155.656832 0003 0031 132
+E: 1331641155.656832 0003 0034 0
+E: 1331641155.656833 0003 0035 -771
+E: 1331641155.656833 0003 0036 121
+E: 1331641155.656834 0000 0002 0
+E: 1331641155.656835 0003 0039 8
+E: 1331641155.656835 0003 0030 184
+E: 1331641155.656836 0003 0031 208
+E: 1331641155.656837 0003 0034 0
+E: 1331641155.656837 0003 0035 417
+E: 1331641155.656838 0003 0036 -425
+E: 1331641155.656839 0000 0002 0
+E: 1331641155.656842 0003 0000 -1729
+E: 1331641155.656842 0003 0001 529
+E: 1331641155.656843 0000 0000 0
+E: 1331641155.659312 0003 0039 1
+E: 1331641155.659313 0003 0030 148
+E: 1331641155.659314 0003 0031 172
+E: 1331641155.659315 0003 0034 0
+E: 1331641155.659315 0003 0035 -1703
+E: 1331641155.659316 0003 0036 696
+E: 1331641155.659317 0000 0002 0
+E: 1331641155.659317 0003 0039 2
+E: 1331641155.659318 0003 0030 144
+E: 1331641155.659319 0003 0031 204
+E: 1331641155.659319 0003 0034 0
+E: 1331641155.659320 0003 0035 1804
+E: 1331641155.659321 0003 0036 129
+E: 1331641155.659321 0000 0002 0
+E: 1331641155.659322 0003 0039 3
+E: 1331641155.659323 0003 0030 156
+E: 1331641155.659323 0003 0031 128
+E: 1331641155.659324 0003 0034 0
+E: 1331641155.659325 0003 0035 -746
+E: 1331641155.659325 0003 0036 298
+E: 1331641155.659326 0000 0002 0
+E: 1331641155.659327 0003 0039 8
+E: 1331641155.659327 0003 0030 180
+E: 1331641155.659328 0003 0031 160
+E: 1331641155.659328 0003 0034 0
+E: 1331641155.659329 0003 0035 448
+E: 1331641155.659330 0003 0036 -250
+E: 1331641155.659330 0000 0002 0
+E: 1331641155.659333 0003 0000 -1703
+E: 1331641155.659334 0003 0001 696
+E: 1331641155.659334 0000 0000 0
+E: 1331641155.666794 0003 0039 1
+E: 1331641155.666795 0003 0030 152
+E: 1331641155.666795 0003 0031 168
+E: 1331641155.666796 0003 0034 0
+E: 1331641155.666797 0003 0035 -1674
+E: 1331641155.666797 0003 0036 859
+E: 1331641155.666798 0000 0002 0
+E: 1331641155.666799 0003 0039 2
+E: 1331641155.666799 0003 0030 128
+E: 1331641155.666800 0003 0031 184
+E: 1331641155.666801 0003 0034 0
+E: 1331641155.666801 0003 0035 1830
+E: 1331641155.666802 0003 0036 306
+E: 1331641155.666803 0000 0002 0
+E: 1331641155.666803 0003 0039 3
+E: 1331641155.666804 0003 0030 144
+E: 1331641155.666805 0003 0031 124
+E: 1331641155.666805 0003 0034 0
+E: 1331641155.666806 0003 0035 -724
+E: 1331641155.666807 0003 0036 466
+E: 1331641155.666807 0000 0002 0
+E: 1331641155.666808 0003 0039 8
+E: 1331641155.666809 0003 0030 176
+E: 1331641155.666809 0003 0031 192
+E: 1331641155.666810 0003 0034 0
+E: 1331641155.666811 0003 0035 478
+E: 1331641155.666811 0003 0036 -75
+E: 1331641155.666812 0000 0002 0
+E: 1331641155.666815 0003 0000 -1674
+E: 1331641155.666815 0003 0001 859
+E: 1331641155.666816 0000 0000 0
+E: 1331641155.686806 0003 0039 1
+E: 1331641155.686807 0003 0030 140
+E: 1331641155.686808 0003 0031 148
+E: 1331641155.686808 0003 0034 0
+E: 1331641155.686809 0003 0035 -1644
+E: 1331641155.686810 0003 0036 1019
+E: 1331641155.686810 0000 0002 0
+E: 1331641155.686811 0003 0039 2
+E: 1331641155.686812 0003 0030 100
+E: 1331641155.686812 0003 0031 156
+E: 1331641155.686813 0003 0034 0
+E: 1331641155.686814 0003 0035 1859
+E: 1331641155.686814 0003 0036 482
+E: 1331641155.686815 0000 0002 0
+E: 1331641155.686816 0003 0039 3
+E: 1331641155.686816 0003 0030 132
+E: 1331641155.686817 0003 0031 124
+E: 1331641155.686818 0003 0034 0
+E: 1331641155.686818 0003 0035 -711
+E: 1331641155.686819 0003 0036 570
+E: 1331641155.686820 0000 0002 0
+E: 1331641155.686820 0003 0039 8
+E: 1331641155.686821 0003 0030 168
+E: 1331641155.686821 0003 0031 164
+E: 1331641155.686822 0003 0034 0
+E: 1331641155.686823 0003 0035 509
+E: 1331641155.686823 0003 0036 94
+E: 1331641155.686824 0000 0002 0
+E: 1331641155.686827 0003 0000 -1644
+E: 1331641155.686827 0003 0001 1019
+E: 1331641155.686828 0000 0000 0
+E: 1331641155.689315 0003 0039 1
+E: 1331641155.689316 0003 0030 140
+E: 1331641155.689316 0003 0031 160
+E: 1331641155.689317 0003 0034 0
+E: 1331641155.689317 0003 0035 -1622
+E: 1331641155.689318 0003 0036 1115
+E: 1331641155.689319 0000 0002 0
+E: 1331641155.689320 0003 0039 2
+E: 1331641155.689320 0003 0030 92
+E: 1331641155.689321 0003 0031 152
+E: 1331641155.689321 0003 0034 0
+E: 1331641155.689322 0003 0035 1887
+E: 1331641155.689323 0003 0036 654
+E: 1331641155.689323 0000 0002 0
+E: 1331641155.689324 0003 0039 3
+E: 1331641155.689325 0003 0030 120
+E: 1331641155.689325 0003 0031 140
+E: 1331641155.689326 0003 0034 0
+E: 1331641155.689327 0003 0035 -689
+E: 1331641155.689327 0003 0036 717
+E: 1331641155.689328 0000 0002 0
+E: 1331641155.689329 0003 0039 8
+E: 1331641155.689329 0003 0030 168
+E: 1331641155.689330 0003 0031 156
+E: 1331641155.689331 0003 0034 0
+E: 1331641155.689331 0003 0035 538
+E: 1331641155.689332 0003 0036 260
+E: 1331641155.689332 0000 0002 0
+E: 1331641155.689335 0003 0000 -1622
+E: 1331641155.689336 0003 0001 1115
+E: 1331641155.689336 0000 0000 0
+E: 1331641155.709313 0003 0039 1
+E: 1331641155.709314 0003 0030 128
+E: 1331641155.709315 0003 0031 136
+E: 1331641155.709316 0003 0034 0
+E: 1331641155.709316 0003 0035 -1579
+E: 1331641155.709317 0003 0036 1308
+E: 1331641155.709318 0000 0002 0
+E: 1331641155.709318 0003 0039 2
+E: 1331641155.709319 0003 0030 76
+E: 1331641155.709320 0003 0031 144
+E: 1331641155.709320 0003 0034 0
+E: 1331641155.709321 0003 0035 1915
+E: 1331641155.709321 0003 0036 823
+E: 1331641155.709322 0000 0002 0
+E: 1331641155.709323 0003 0039 3
+E: 1331641155.709323 0003 0030 124
+E: 1331641155.709324 0003 0031 132
+E: 1331641155.709325 0003 0034 0
+E: 1331641155.709325 0003 0035 -666
+E: 1331641155.709326 0003 0036 850
+E: 1331641155.709327 0000 0002 0
+E: 1331641155.709327 0003 0039 8
+E: 1331641155.709328 0003 0030 152
+E: 1331641155.709329 0003 0031 160
+E: 1331641155.709329 0003 0034 0
+E: 1331641155.709330 0003 0035 567
+E: 1331641155.709331 0003 0036 417
+E: 1331641155.709331 0000 0002 0
+E: 1331641155.709334 0003 0000 -1579
+E: 1331641155.709335 0003 0001 1308
+E: 1331641155.709335 0000 0000 0
+E: 1331641155.711809 0003 0039 1
+E: 1331641155.711810 0003 0030 108
+E: 1331641155.711811 0003 0031 120
+E: 1331641155.711811 0003 0034 0
+E: 1331641155.711812 0003 0035 -1556
+E: 1331641155.711813 0003 0036 1394
+E: 1331641155.711813 0000 0002 0
+E: 1331641155.711814 0003 0039 2
+E: 1331641155.711815 0003 0030 0
+E: 1331641155.711815 0003 0031 0
+E: 1331641155.711815 0003 0034 0
+E: 1331641155.711816 0003 0035 1915
+E: 1331641155.711817 0003 0036 823
+E: 1331641155.711817 0000 0002 0
+E: 1331641155.711818 0003 0039 3
+E: 1331641155.711819 0003 0030 100
+E: 1331641155.711819 0003 0031 112
+E: 1331641155.711820 0003 0034 0
+E: 1331641155.711820 0003 0035 -649
+E: 1331641155.711821 0003 0036 925
+E: 1331641155.711822 0000 0002 0
+E: 1331641155.711823 0003 0039 8
+E: 1331641155.711823 0003 0030 136
+E: 1331641155.711823 0003 0031 136
+E: 1331641155.711824 0003 0034 0
+E: 1331641155.711825 0003 0035 584
+E: 1331641155.711825 0003 0036 511
+E: 1331641155.711826 0000 0002 0
+E: 1331641155.711829 0003 0000 -1556
+E: 1331641155.711829 0003 0001 1394
+E: 1331641155.711830 0000 0000 0
+E: 1331641155.718302 0003 0039 1
+E: 1331641155.718303 0003 0030 48
+E: 1331641155.718303 0003 0031 88
+E: 1331641155.718304 0003 0034 0
+E: 1331641155.718305 0003 0035 -1523
+E: 1331641155.718305 0003 0036 1525
+E: 1331641155.718306 0000 0002 0
+E: 1331641155.718307 0003 0039 3
+E: 1331641155.718308 0003 0030 100
+E: 1331641155.718308 0003 0031 80
+E: 1331641155.718309 0003 0034 0
+E: 1331641155.718310 0003 0035 -616
+E: 1331641155.718310 0003 0036 1083
+E: 1331641155.718311 0000 0002 0
+E: 1331641155.718312 0003 0039 8
+E: 1331641155.718312 0003 0030 124
+E: 1331641155.718313 0003 0031 92
+E: 1331641155.718313 0003 0034 0
+E: 1331641155.718314 0003 0035 612
+E: 1331641155.718315 0003 0036 644
+E: 1331641155.718315 0000 0002 0
+E: 1331641155.718317 0001 014e 1
+E: 1331641155.718318 0001 014f 0
+E: 1331641155.718319 0003 0000 -1523
+E: 1331641155.718320 0003 0001 1525
+E: 1331641155.718320 0000 0000 0
+E: 1331641155.738295 0003 0039 1
+E: 1331641155.738296 0003 0030 0
+E: 1331641155.738297 0003 0031 0
+E: 1331641155.738297 0003 0034 0
+E: 1331641155.738297 0003 0035 -1523
+E: 1331641155.738298 0003 0036 1525
+E: 1331641155.738299 0000 0002 0
+E: 1331641155.738300 0003 0039 3
+E: 1331641155.738300 0003 0030 120
+E: 1331641155.738301 0003 0031 72
+E: 1331641155.738301 0003 0034 0
+E: 1331641155.738302 0003 0035 -596
+E: 1331641155.738303 0003 0036 1145
+E: 1331641155.738303 0000 0002 0
+E: 1331641155.738304 0003 0039 8
+E: 1331641155.738305 0003 0030 0
+E: 1331641155.738305 0003 0031 0
+E: 1331641155.738305 0003 0034 0
+E: 1331641155.738306 0003 0035 612
+E: 1331641155.738306 0003 0036 644
+E: 1331641155.738307 0000 0002 0
+E: 1331641155.738311 0000 0000 0
+E: 1331641155.740540 0003 0039 3
+E: 1331641155.740541 0003 0030 0
+E: 1331641155.740541 0003 0031 0
+E: 1331641155.740541 0003 0034 0
+E: 1331641155.740542 0003 0035 -596
+E: 1331641155.740543 0003 0036 1145
+E: 1331641155.740543 0000 0002 0
+E: 1331641155.740544 0001 0145 1
+E: 1331641155.740545 0001 014e 0
+E: 1331641155.740546 0000 0000 0
+E: 1331641155.748043 0001 014a 0
+E: 1331641155.748044 0001 0145 0
+E: 1331641155.748044 0000 0000 0

=== added file 'test/x11/no-premature-gestures.cpp'
--- test/x11/no-premature-gestures.cpp	1970-01-01 00:00:00 +0000
+++ test/x11/no-premature-gestures.cpp	2012-03-14 19:17:21 +0000
@@ -0,0 +1,215 @@
+/*****************************************************************************
+ *
+ * grail - Gesture Recognition And Instantiation Library
+ *
+ * Copyright (C) 2012 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ ****************************************************************************/
+
+/**
+ * @internal
+ * @file "No Premature Gestures" Test
+ *
+ * This test plays a four-touches' drag where the four fingers land almost in
+ * sync and checks that only 4-touches' slices are generated.
+ * Three subscriptions are used:
+ *   (A) An atomic two-touches Touch
+ *   (B) An atomic three-touches Touch
+ *   (C) An atomic four-touches Touch.
+ *
+ * It's a regression test for https://bugs.launchpad.net/utouch-grail/+bug/949916
+ *
+ * We don't want to see gestures being unnecessarily created (and therefore
+ * their slices) for subscriptions (A) and (B) since we already know from the
+ * very first events that there are four touches in total, not only two or three.
+ *
+ * Note that this logic holds only when atomic gesture rules are being used.
+ */
+
+#include <future>
+#include <gtest/gtest.h>
+#include <utouch/frame_x11.h>
+
+// evemu wrappers
+#include "device.h"
+#include "recording.h"
+
+#include "x11/fixture.h"
+
+class NoPrematureGestures : public utouch::grail::x11::testing::Test {
+ public:
+  NoPrematureGestures() : device_(nullptr) {}
+ protected:
+  virtual void ProcessFrameEvents();
+  virtual void ProcessGrailEvents();
+
+  // Holds the device we are interested in getting input from.
+  // More specifically, the fake one we will create via evemu.
+  UFDevice device_;
+
+ private:
+  void ProcessFrameEventDeviceAdded(UFEvent event);
+  void CreateSubscriptions();
+  void CreateSubscription(unsigned int num_touches,
+                          UGGestureTypeMask gesture_mask);
+  void CheckSlice(UGSlice slice);
+};
+
+void NoPrematureGestures::ProcessFrameEvents() {
+  UFEvent event;
+
+  UFStatus status;
+  while ((status = frame_get_event(frame_handle(), &event)) == UFStatusSuccess) {
+    grail_process_frame_event(grail_handle(), event);
+
+    if (frame_event_get_type(event) == UFEventTypeDeviceAdded) {
+      ProcessFrameEventDeviceAdded(event);
+    }
+
+    frame_event_unref(event);
+  }
+
+  EXPECT_EQ(UFStatusErrorNoEvent, status);
+}
+
+void NoPrematureGestures::ProcessFrameEventDeviceAdded(UFEvent event)
+{
+  UFStatus status;
+  UFDevice device;
+  const char* name;
+
+  status = frame_event_get_property(event, UFEventPropertyDevice, &device);
+  ASSERT_EQ(UFStatusSuccess, status);
+
+  status = frame_device_get_property(device, UFDevicePropertyName, &name);
+  ASSERT_EQ(UFStatusSuccess, status);
+
+  if (strcmp(name, "Apple Wireless Trackpad") == 0) {
+    EXPECT_EQ(nullptr, device_);
+    device_ = device;
+    CreateSubscriptions();
+  }
+}
+
+void NoPrematureGestures::CreateSubscriptions() {
+  CreateSubscription(2, UGGestureTypeTouch);
+  CreateSubscription(3, UGGestureTypeTouch);
+  CreateSubscription(4, UGGestureTypeTouch);
+}
+
+void NoPrematureGestures::CreateSubscription(unsigned int num_touches,
+                                        UGGestureTypeMask gesture_mask) {
+  UGSubscription subscription;
+  UGStatus status;
+
+  status = grail_subscription_new(&subscription);
+  ASSERT_EQ(UGStatusSuccess, status);
+
+  status = grail_subscription_set_property(subscription,
+                                           UGSubscriptionPropertyDevice,
+                                           &device_);
+  ASSERT_EQ(UFStatusSuccess, status);
+
+  UFWindowId window_id =
+      frame_x11_create_window_id(DefaultRootWindow(Display()));
+  status = grail_subscription_set_property(subscription,
+                                           UGSubscriptionPropertyWindow,
+                                           &window_id);
+  ASSERT_EQ(UFStatusSuccess, status);
+
+  status = grail_subscription_set_property(subscription,
+                                           UGSubscriptionPropertyTouchesStart,
+                                           &num_touches);
+  ASSERT_EQ(UFStatusSuccess, status);
+
+  status = grail_subscription_set_property(subscription,
+                                           UGSubscriptionPropertyTouchesMaximum,
+                                           &num_touches);
+  ASSERT_EQ(UFStatusSuccess, status);
+
+  status = grail_subscription_set_property(subscription,
+                                           UGSubscriptionPropertyTouchesMinimum,
+                                           &num_touches);
+  ASSERT_EQ(UFStatusSuccess, status);
+
+  status = grail_subscription_set_property(subscription,
+                                           UGSubscriptionPropertyMask,
+                                           &gesture_mask);
+  ASSERT_EQ(UFStatusSuccess, status);
+
+  int use_atomic_gestures = 1;
+  status = grail_subscription_set_property(subscription,
+                                           UGSubscriptionPropertyAtomicGestures,
+                                           &use_atomic_gestures);
+  ASSERT_EQ(UFStatusSuccess, status);
+
+  status = grail_subscription_activate(grail_handle(), subscription);
+  ASSERT_EQ(UFStatusSuccess, status);
+}
+
+void NoPrematureGestures::ProcessGrailEvents() {
+  UGEvent event;
+
+  UGStatus status;
+  while ((status = grail_get_event(grail_handle(), &event)) == UGStatusSuccess) {
+    ASSERT_EQ(UGEventTypeSlice, grail_event_get_type(event));
+
+    UGSlice slice;
+    status = grail_event_get_property(event, UGEventPropertySlice, &slice);
+    ASSERT_EQ(UGStatusSuccess, status);
+
+    CheckSlice(slice);
+
+    grail_event_unref(event);
+  }
+
+  EXPECT_EQ(UGStatusErrorNoEvent, status);
+}
+
+void NoPrematureGestures::CheckSlice(UGSlice slice) {
+  UGStatus status;
+  unsigned int num_touches;
+
+  status = grail_slice_get_property(slice, UGSlicePropertyNumTouches,
+                                    &num_touches);
+  ASSERT_EQ(UGStatusSuccess, status);
+
+  // The main point of this test:
+  // Check that we don't get any slices from a 2 or 3 touches gesture.
+  EXPECT_EQ(4, num_touches)
+    << "Got a slice with " << num_touches << " touches from a synced 4-fingers drag.";
+}
+
+TEST_F(NoPrematureGestures, Recording) {
+  utouch::evemu::Device device("recordings/apple-wireless-trackpad.prop");
+
+  /* Pump once to ensure the X server has initialized the device */
+  PumpEvents();
+  ASSERT_NE(device_, nullptr) << "X server failed to initialize trackpad";
+
+  utouch::evemu::Recording recording(device, "recordings/apple-wtrackpad-synced-4-drag.event");
+
+  /* We use the c++11 future module so any exceptions thrown by the thread can
+   * be caught later on. If we used the thread module, exceptions would take the
+   * whole thing down. */
+  std::future<void> future = std::async(std::launch::async,
+                                        &utouch::evemu::Recording::Play,
+                                        &recording);
+
+  PumpEvents();
+
+  future.wait();
+}