Three Finger Swipe

ui/base/gestures/gesture_sequence.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/base/gestures/gesture_sequence.h"
 
+#include <cmath>
+
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/time.h"
 #include "ui/base/events.h"
 #include "ui/base/gestures/gesture_configuration.h"
 
 namespace ui {
 
 namespace {
 
@@ skipping 78 matching lines @@
       G(GS_PINCH, 0, TS_RELEASED, false),
 
   GST_PINCH_SECOND_RELEASED =
       G(GS_PINCH, 1, TS_RELEASED, false),
 
   GST_PINCH_FIRST_CANCELLED =
       G(GS_PINCH, 0, TS_CANCELLED, false),
 
   GST_PINCH_SECOND_CANCELLED =
       G(GS_PINCH, 1, TS_CANCELLED, false),
+
+  GST_PINCH_THIRD_PRESSED =
+      G(GS_PINCH, 2, TS_PRESSED, false),
+
+  GST_THREE_FINGER_SWIPE_FIRST_RELEASED =
+      G(GS_THREE_FINGER_SWIPE, 0, TS_RELEASED, false),
+
+  GST_THREE_FINGER_SWIPE_SECOND_RELEASED =
+      G(GS_THREE_FINGER_SWIPE, 1, TS_RELEASED, false),
+
+  GST_THREE_FINGER_SWIPE_THIRD_RELEASED =
+      G(GS_THREE_FINGER_SWIPE, 2, TS_RELEASED, false),
+
+  GST_THREE_FINGER_SWIPE_FIRST_MOVED =
+      G(GS_THREE_FINGER_SWIPE, 0, TS_MOVED, false),
+
+  GST_THREE_FINGER_SWIPE_SECOND_MOVED =
+      G(GS_THREE_FINGER_SWIPE, 1, TS_MOVED, false),
+
+  GST_THREE_FINGER_SWIPE_THIRD_MOVED =
+      G(GS_THREE_FINGER_SWIPE, 2, TS_MOVED, false),
+
+  GST_THREE_FINGER_SWIPE_FIRST_CANCELLED =
+      G(GS_THREE_FINGER_SWIPE, 0, TS_CANCELLED, false),
+
+  GST_THREE_FINGER_SWIPE_SECOND_CANCELLED =
+      G(GS_THREE_FINGER_SWIPE, 1, TS_CANCELLED, false),
+
+  GST_THREE_FINGER_SWIPE_THIRD_CANCELLED =
+      G(GS_THREE_FINGER_SWIPE, 2, TS_CANCELLED, false),
 };
 
 // Builds a signature. Signatures are assembled by joining together
 // multiple bits.
 // 1 LSB bit so that the computed signature is always greater than 0
 // 3 bits for the |type|.
 // 1 bit for |touch_handled|
 // 12 bits for |touch_id|
 // 15 bits for the |gesture_state|.
 EdgeStateSignatureType Signature(GestureState gesture_state,
@@ skipping 105 matching lines @@
     case GST_PINCH_SECOND_RELEASED:
     case GST_PINCH_FIRST_CANCELLED:
     case GST_PINCH_SECOND_CANCELLED:
       PinchEnd(event, point, gestures.get());
 
       // Once pinch ends, it should still be possible to scroll with the
       // remaining finger on the screen.
       scroll_type_ = ST_FREE;
       set_state(GS_SCROLL);
       break;
+    case GST_PINCH_THIRD_PRESSED:
+      PinchEnd(event, point, gestures.get());
+      ScrollEnd(event, point, gestures.get());
+      three_finger_swipe_has_fired_ = false;
+      set_state(GS_THREE_FINGER_SWIPE);
+      break;
+    case GST_THREE_FINGER_SWIPE_FIRST_RELEASED:
+    case GST_THREE_FINGER_SWIPE_SECOND_RELEASED:
+    case GST_THREE_FINGER_SWIPE_THIRD_RELEASED:
+    case GST_THREE_FINGER_SWIPE_FIRST_CANCELLED:
+    case GST_THREE_FINGER_SWIPE_SECOND_CANCELLED:
+    case GST_THREE_FINGER_SWIPE_THIRD_CANCELLED:
+      PinchStart(event, point, gestures.get());
+      ScrollStart(event, point, gestures.get());

[sadrul, 2012/04/11 19:07:26]

Do we want ScrollStart here? It might be better to update PinchStart to
AppendScrollGestureBegin when state is GS_PENDING_SYNTHETIC_CLICK or
GS_THREE_FINGER_SWIPE (with that done, you may not need to change ScrollStart)

[tdresser, 2012/04/12 13:36:16]

It's clearer what's happening if the scroll begin gesture and scroll end gesture
are appended in the same way. We need the fling logic from ScrollEnd, which
makes me think that calling ScrollStart is the right thing to do. It does make
ScrollStart a little uglier, but following the logic in
ProcessTouchEventForGesture is easier this way.

Though, I did notice that the rail logic in ScrollStart should also be
conditional on the current state.

Do you have an idea that keeps ProcessTouchEventForGesture this readable while
not having to mess with ScrollStart?

[sadrul, 2012/04/13 11:34:20]

Since PinchStart already appends scroll-start for some cases, I think it makes
sense to do it for some other cases too. PinchEnd never does a scroll-end, so if
we do want to end scroll, explicitly calling ScrollEnd sounds OK to me.

Having said that ... what happens if we don't pinch-end/scroll-end in ~263/264
at all (and then don't start either here either)?

[tdresser, 2012/04/16 14:09:24]

You're right, there's no reason to call pinch/scroll start or end. I've removed
the calls.

+      set_state(GS_PINCH);
+      break;
+    case GST_THREE_FINGER_SWIPE_FIRST_MOVED:
+    case GST_THREE_FINGER_SWIPE_SECOND_MOVED:
+    case GST_THREE_FINGER_SWIPE_THIRD_MOVED:
+      if (!three_finger_swipe_has_fired_) {
+        ThreeFingerSwipeUpdate(event, point, gestures.get());
+        GetPointByPointId(0)->UpdateForScroll();
+        GetPointByPointId(1)->UpdateForScroll();
+        GetPointByPointId(2)->UpdateForScroll();
+      }
+      break;
   }
 
   if (state_ != last_state)
     VLOG(4) << "Gesture Sequence"
             << " State: " << state_
             << " touch id: " << event.GetTouchId();
 
   if (last_state == GS_PENDING_SYNTHETIC_CLICK && state_ != last_state)
     long_press_timer_->Stop();
 
@@ skipping 162 matching lines @@
   // http://crbug.com/113145
   gfx::Point center = p1.last_touch_position().Middle(p2.last_touch_position());
   gestures->push_back((helper_->CreateGestureEvent(
       ui::ET_GESTURE_PINCH_UPDATE,
       center,
       flags_,
       base::Time::FromDoubleT(p1.last_touch_time()),
       scale, 0.f, 1 << p1.touch_id() | 1 << p2.touch_id())));
 }
 
+void GestureSequence::AppendThreeFingerSwipeGestureEvent(const GesturePoint& p1,
+                                                         const GesturePoint& p2,
+                                                         const GesturePoint& p3,
+                                                         float x_velocity,
+                                                         float y_velocity,
+                                                         Gestures* gestures) {
+  int x = (
+      p1.last_touch_position().x() +
+      p2.last_touch_position().x() +
+      p3.last_touch_position().x()) / 3;
+  int y = (
+      p1.last_touch_position().y() +
+      p2.last_touch_position().y() +
+      p3.last_touch_position().y()) / 3;
+  gfx::Point center(x, y);
+  gestures->push_back(helper_->CreateGestureEvent(
+      ui::ET_GESTURE_THREE_FINGER_SWIPE,
+      center,
+      flags_,
+      base::Time::FromDoubleT(p1.last_touch_time()),
+      x_velocity, y_velocity,
+      1 << p1.touch_id() | 1 << p2.touch_id() | 1 << p3.touch_id()));
+}
+
 bool GestureSequence::Click(const TouchEvent& event,
     const GesturePoint& point, Gestures* gestures) {
   DCHECK(state_ == GS_PENDING_SYNTHETIC_CLICK);
   if (point.IsInClickWindow(event)) {
     AppendClickGestureEvent(point, gestures);
     if (point.IsInDoubleClickWindow(event))
       AppendDoubleClickGestureEvent(point, gestures);
     return true;
   }
   return false;
 }
 
 bool GestureSequence::ScrollStart(const TouchEvent& event,
     GesturePoint& point, Gestures* gestures) {
-  DCHECK(state_ == GS_PENDING_SYNTHETIC_CLICK);
-  if (point.IsInClickWindow(event) ||
-      !point.IsInScrollWindow(event) ||
-      !point.HasEnoughDataToEstablishRail())
+  DCHECK(state_ == GS_PENDING_SYNTHETIC_CLICK ||
+         state_ == GS_THREE_FINGER_SWIPE);
+  if (state_ == GS_PENDING_SYNTHETIC_CLICK &&
+      (point.IsInClickWindow(event) ||
+       !point.IsInScrollWindow(event) ||
+       !point.HasEnoughDataToEstablishRail()))
     return false;
   AppendScrollGestureBegin(point, point.first_touch_position(), gestures);
   if (point.IsInHorizontalRailWindow())
     scroll_type_ = ST_HORIZONTAL;
   else if (point.IsInVerticalRailWindow())
     scroll_type_ = ST_VERTICAL;
   else
     scroll_type_ = ST_FREE;
   return true;
 }
@@ skipping 43 matching lines @@
       ui::ET_GESTURE_LONG_PRESS,
       point->first_touch_position(),
       flags_,
       base::Time::FromDoubleT(point->last_touch_time()),
       point->point_id(), 0.f, 1 << point->touch_id()));
   helper_->DispatchLongPressGestureEvent(gesture.get());
 }
 
 bool GestureSequence::ScrollEnd(const TouchEvent& event,
     GesturePoint& point, Gestures* gestures) {
-  DCHECK(state_ == GS_SCROLL);
+  DCHECK(state_ == GS_SCROLL || state_ == GS_PINCH);
   if (point.IsInFlickWindow(event)) {
     AppendScrollGestureEnd(point, point.last_touch_position(), gestures,
         point.XVelocity(), point.YVelocity());
   } else {
     AppendScrollGestureEnd(point, point.last_touch_position(), gestures,
         0.f, 0.f);
   }
   return true;
 }
 
 bool GestureSequence::PinchStart(const TouchEvent& event,
     const GesturePoint& point, Gestures* gestures) {
   DCHECK(state_ == GS_SCROLL ||
-         state_ == GS_PENDING_SYNTHETIC_CLICK);
+         state_ == GS_PENDING_SYNTHETIC_CLICK ||
+         state_ == GS_THREE_FINGER_SWIPE);
   AppendTapDownGestureEvent(point, gestures);
 
   const GesturePoint* point1 = GetPointByPointId(0);
   const GesturePoint* point2 = GetPointByPointId(1);
 
   pinch_distance_current_ = point1->Distance(*point2);
   pinch_distance_start_ = pinch_distance_current_;
   AppendPinchGestureBegin(*point1, *point2, gestures);
 
   if (state_ == GS_PENDING_SYNTHETIC_CLICK) {
@@ skipping 44 matching lines @@
 
   float distance = point1->Distance(*point2);
   AppendPinchGestureEnd(*point1, *point2,
       distance / pinch_distance_start_, gestures);
 
   pinch_distance_start_ = 0;
   pinch_distance_current_ = 0;
   return true;
 }
 
+bool GestureSequence::ThreeFingerSwipeUpdate(const TouchEvent& event,
+    const GesturePoint& point, Gestures* gestures) {
+  DCHECK(state_ == GS_THREE_FINGER_SWIPE);
+
+  GesturePoint* point1 = GetPointByPointId(0);
+  GesturePoint* point2 = GetPointByPointId(1);
+  GesturePoint* point3 = GetPointByPointId(2);
+
+  int min_velocity = GestureConfiguration::min_swipe_speed();
+
+  float vx1 = point1->XVelocity();
+  float vx2 = point2->XVelocity();
+  float vx3 = point3->XVelocity();
+  float vy1 = point1->YVelocity();
+  float vy2 = point2->YVelocity();
+  float vy3 = point3->YVelocity();
+
+  float vx = (vx1 + vx2 + vx3) / 3;
+  float vy = (vy1 + vy2 + vy3) / 3;
+
+  // Not moving fast enough
+  if (fabs(vx) < min_velocity && fabs(vy) < min_velocity)
+    return false;
+
+  // Diagonal swipe, no event fired
+  // TODO(tdresser|sadrul): consider adding diagonal swipes
+  float ratio = fabs(vx) > fabs(vy) ? fabs(vx / vy) : fabs(vy / vx);
+  if (ratio < GestureConfiguration::max_swipe_deviation_ratio())
+    return false;
+
+  if (fabs(vx) > fabs(vy)) {
+    int sign = vx > 0 ? 1 : -1;
+    // ensure all touches are moving in the same direction, and are
+    // all moving faster than min_velocity.
+    if (vx1 * sign < min_velocity ||
+        vx2 * sign < min_velocity ||
+        vx3 * sign < min_velocity)
+        return false;
+    AppendThreeFingerSwipeGestureEvent(*point1, *point2, *point3,
+                                       sign, 0, gestures);
+  } else {
+    int sign = vy > 0 ? 1 : -1;
+    // ensure all touches are moving in the same direction, and are
+    // all moving faster than min_velocity.
+    if (vy1 * sign < min_velocity ||
+        vy2 * sign < min_velocity ||
+        vy3 * sign < min_velocity)
+      return false;
+    AppendThreeFingerSwipeGestureEvent(*point1, *point2, *point3,
+                                       0, sign, gestures);
+  }
+  three_finger_swipe_has_fired_ = true;
+  return true;
+}
+
 }  // namespace ui