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());

[sadrul, 2012/04/10 20:32:51]

Should there also be a ScrollEnd here?

[tdresser, 2012/04/11 18:17:04]

And the related ScrollStart, when a finger from a three finger swipe is
released/cancelled.

Done.

+      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());
+      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 xVelocity,
+                                                         float yVelocity,
+                                                         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()),
+      xVelocity, yVelocity,
+      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;
@@ skipping 75 matching lines @@
   } 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 minVelocity = 20;

[sadrul, 2012/04/10 20:32:51]

min_velocity

[tdresser, 2012/04/11 18:17:04]

Done.

+
+  float vx1 = point1->XVelocity();
+  float vx2 = point2->XVelocity();
+  float vx3 = point3->XVelocity();
+  float vy1 = point1->YVelocity();
+  float vy2 = point2->YVelocity();
+  float vy3 = point3->YVelocity();
+

[sadrul, 2012/04/10 20:32:51]

I think we should check whether all points are moving in the same direction
here. Should we also check if the velocities of the three points are within a
certain ratio of each other?

[tdresser, 2012/04/11 18:17:04]

I feel like ensuring that the points are within a certain ratio of each other is
probably overkill.

They all have to be going above some minimum speed, and in the same direction. I
can't picture any case in which this would happen and the user would not be
trying to swipe.

I'll add it in if you feel it's necessary.

+  float vx = (vx1 + vx2 + vx3) / 3;
+  float vy = (vy1 + vy2 + vy3) / 3;
+
+  // Not moving fast enough
+  if (fabs(vx) < minVelocity && fabs(vy) < minVelocity)
+    return true;

[sadrul, 2012/04/10 20:32:51]

return false;

[tdresser, 2012/04/11 18:17:04]

Done.

+
+  // Diagonal swipe, no event fired
+  if (fabs(vx) >= minVelocity && fabs(vy) >= minVelocity) {
+    float ratio = fabs(vx) > fabs(vy) ? fabs(vx / vy) : fabs(vy / vx);
+    if (ratio < 3)
+      return true;

[sadrul, 2012/04/10 20:32:51]

return false;

Also, why this restriction?

[tdresser, 2012/04/11 18:17:04]

Done.

Added TODO to consider diagonal swipes.

+  }
+
+  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 minVelocity.
+    if (vx1 * sign < minVelocity ||
+        vx2 * sign < minVelocity ||
+        vx3 * sign < minVelocity)
+        return true;
+    AppendThreeFingerSwipeGestureEvent(*point1, *point2, *point3,
+                                       sign, 0, gestures);
+    three_finger_swipe_has_fired_ = true;
+  } else {
+    int sign = vy > 0 ? 1 : -1;
+    // ensure all touches are moving in the same direction, and are
+    // all moving faster than minVelocity.
+    if (vy1 * sign < minVelocity ||
+        vy2 * sign < minVelocity ||
+        vy3 * sign < minVelocity)
+      return true;
+    AppendThreeFingerSwipeGestureEvent(*point1, *point2, *point3,
+                                       0, sign, gestures);

[sadrul, 2012/04/10 20:32:51]

It looks like one of the velocities is always zero. Is that intentional? Do we
not foresee any use for diagonal swipes? Even if we don't, is this the correct
place to filter this?

[tdresser, 2012/04/11 18:17:04]

This implementation currently assumes that we aren't expecting diagonal swipes. 

+    three_finger_swipe_has_fired_ = true;
+  }
+  return true;
+}
+
 }  // namespace ui