gesture: Include velocity in scroll-update gestures.

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"
@@ skipping 255 matching lines @@
 
 unsigned int ComputeTouchBitmask(const GesturePoint* points) {
   unsigned int touch_bitmask = 0;
   for (int i = 0; i < GestureSequence::kMaxGesturePoints; ++i) {
     if (points[i].in_use())
       touch_bitmask |= 1 << points[i].touch_id();
   }
   return touch_bitmask;
 }
 
+float CalibrateVelocity(float velocity) {

[rjkroege, 2012/08/20 14:52:17]

thanks for pulling this out. Since odds are that we'll be tinkering with it for
days.

nit: Could we call this CalibrateFlingVelocity? Because it's for fling only
right?

[sadrul, 2012/08/20 15:48:34]

We are also using the same calibration for the scroll-update velocities.

+  // TODO(sad|rjkroege): fling-curve is currently configured to work well with
+  // touchpad scroll-events. This curve needs to be adjusted to work correctly
+  // with both touchpad and touchscreen. Until then, scale quadratically.
+  // http://crbug.com/120154
+  const float velocity_scaling  = 1.f / 900.f;
+  return velocity_scaling * velocity * fabsf(velocity);
+}
+
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // GestureSequence Public:
 
 GestureSequence::GestureSequence(GestureEventHelper* helper)
     : state_(GS_NO_GESTURE),
       flags_(0),
       pinch_distance_start_(0.f),
       pinch_distance_current_(0.f),
@@ skipping 362 matching lines @@
                                              float y_velocity) {
   float railed_x_velocity = x_velocity;
   float railed_y_velocity = y_velocity;
 
   if (scroll_type_ == ST_HORIZONTAL)
     railed_y_velocity = 0;
   else if (scroll_type_ == ST_VERTICAL)
     railed_x_velocity = 0;
 
   if (railed_x_velocity != 0 || railed_y_velocity != 0) {
-    // TODO(sad|rjkroege): fling-curve is currently configured to work well with
-    // touchpad scroll-events. This curve needs to be adjusted to work correctly
-    // with both touchpad and touchscreen. Until then, scale quadratically.
-    // http://crbug.com/120154
-    const float velocity_scaling  = 1.f / 900.f;
 
     gestures->push_back(CreateGestureEvent(
         GestureEventDetails(ui::ET_SCROLL_FLING_START,
-            velocity_scaling * railed_x_velocity * fabsf(railed_x_velocity),
-            velocity_scaling * railed_y_velocity * fabsf(railed_y_velocity)),
+            CalibrateVelocity(railed_x_velocity),
+            CalibrateVelocity(railed_y_velocity)),
         location,
         flags_,
         base::Time::FromDoubleT(point.last_touch_time()),
         1 << point.touch_id()));
   } else {
     gestures->push_back(CreateGestureEvent(
         GestureEventDetails(ui::ET_GESTURE_SCROLL_END, 0, 0),
         location,
         flags_,
         base::Time::FromDoubleT(point.last_touch_time()),
         1 << point.touch_id()));
   }
 }
 
-void GestureSequence::AppendScrollGestureUpdate(const GesturePoint& point,
+void GestureSequence::AppendScrollGestureUpdate(GesturePoint& point,
                                                 const gfx::Point& location,
                                                 Gestures* gestures) {
   gfx::Point current_center = bounding_box_.CenterPoint();
   int dx = current_center.x() - bounding_box_last_center_.x();
   int dy = current_center.y() - bounding_box_last_center_.y();
   if (scroll_type_ == ST_HORIZONTAL)
     dy = 0;
   else if (scroll_type_ == ST_VERTICAL)
     dx = 0;
   if (dx == 0 && dy == 0)
     return;
 
+  GestureEventDetails details(ui::ET_GESTURE_SCROLL_UPDATE, dx, dy);
+  details.SetScrollVelocity(
+      scroll_type_ == ST_VERTICAL ? 0 : CalibrateVelocity(point.XVelocity()),
+      scroll_type_ == ST_HORIZONTAL ? 0 : CalibrateVelocity(point.YVelocity()));
   gestures->push_back(CreateGestureEvent(
-      GestureEventDetails(ui::ET_GESTURE_SCROLL_UPDATE, dx, dy),
+      details,
       location,
       flags_,
       base::Time::FromDoubleT(point.last_touch_time()),
       ComputeTouchBitmask(points_)));
 }
 
 void GestureSequence::AppendPinchGestureBegin(const GesturePoint& p1,
                                               const GesturePoint& p2,
                                               Gestures* gestures) {
   gfx::Point center = bounding_box_.CenterPoint();
@@ skipping 47 matching lines @@
   const GesturePoint* point = GetPointByPointId(0);
   gestures->push_back(CreateGestureEvent(
       GestureEventDetails(ui::ET_GESTURE_TWO_FINGER_TAP, 0, 0),
       point->enclosing_rectangle().CenterPoint(),
       flags_,
       base::Time::FromDoubleT(point->last_touch_time()),
       1 << point->touch_id()));
 }
 
 bool GestureSequence::Click(const TouchEvent& event,
-    const GesturePoint& point, Gestures* gestures) {
+                            const GesturePoint& point,
+                            Gestures* gestures) {
   DCHECK(state_ == GS_PENDING_SYNTHETIC_CLICK);
   if (point.IsInClickWindow(event)) {
     bool double_tap = point.IsInDoubleClickWindow(event);
     AppendClickGestureEvent(point, double_tap ? 2 : 1, gestures);
     if (double_tap)
       AppendDoubleClickGestureEvent(point, gestures);
     return true;
   }
   return false;
 }
 
 bool GestureSequence::ScrollStart(const TouchEvent& event,
-    GesturePoint& point, Gestures* gestures) {
+                                  GesturePoint& point,
+                                  Gestures* gestures) {
   DCHECK(state_ == GS_PENDING_SYNTHETIC_CLICK);
   if (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;
 }
 
 void GestureSequence::BreakRailScroll(const TouchEvent& event,
-    GesturePoint& point, Gestures* gestures) {
+                                      GesturePoint& point,
+                                      Gestures* gestures) {
   DCHECK(state_ == GS_SCROLL);
   if (scroll_type_ == ST_HORIZONTAL &&
       point.BreaksHorizontalRail())
     scroll_type_ = ST_FREE;
   else if (scroll_type_ == ST_VERTICAL &&
            point.BreaksVerticalRail())
     scroll_type_ = ST_FREE;
 }
 
 bool GestureSequence::ScrollUpdate(const TouchEvent& event,
-    const GesturePoint& point, Gestures* gestures) {
+                                   GesturePoint& point,
+                                   Gestures* gestures) {
   DCHECK(state_ == GS_SCROLL);
   if (!point.DidScroll(event, 0))
     return false;
   AppendScrollGestureUpdate(point, point.last_touch_position(), gestures);
   return true;
 }
 
 bool GestureSequence::TouchDown(const TouchEvent& event,
-    const GesturePoint& point, Gestures* gestures) {
+                                const GesturePoint& point,
+                                Gestures* gestures) {
   DCHECK(state_ == GS_NO_GESTURE);
   AppendTapDownGestureEvent(point, gestures);
   long_press_timer_->Start(
       FROM_HERE,
       base::TimeDelta::FromMilliseconds(
           GestureConfiguration::long_press_time_in_seconds() * 1000),
       this,
       &GestureSequence::AppendLongPressGestureEvent);
   return true;
 }
 
 bool GestureSequence::TwoFingerTouchDown(const TouchEvent& event,
-    const GesturePoint& point, Gestures* gestures) {
+                                         const GesturePoint& point,
+                                         Gestures* gestures) {
   DCHECK(state_ == GS_PENDING_SYNTHETIC_CLICK || state_ == GS_SCROLL);
   if (state_ == GS_SCROLL) {
     AppendScrollGestureEnd(point, point.last_touch_position(), gestures,
         0.f, 0.f);
   }
   second_touch_time_ = event.time_stamp();
   return true;
 }
 
 bool GestureSequence::TwoFingerTouchMove(const TouchEvent& event,
-    const GesturePoint& point, Gestures* gestures) {
+                                         const GesturePoint& point,
+                                         Gestures* gestures) {
   DCHECK(state_ == GS_PENDING_TWO_FINGER_TAP);
 
   base::TimeDelta time_delta = event.time_stamp() - second_touch_time_;
   base::TimeDelta max_delta = base::TimeDelta::FromMilliseconds(1000 *
       ui::GestureConfiguration::max_touch_down_duration_in_seconds_for_click());
   if (time_delta > max_delta || !point.IsInsideManhattanSquare(event)) {
     PinchStart(event, point, gestures);
     return true;
   }
   return false;
 }
 
 bool GestureSequence::TwoFingerTouchReleased(const TouchEvent& event,
-    const GesturePoint& point, Gestures* gestures) {
+                                             const GesturePoint& point,
+                                             Gestures* gestures) {
   DCHECK(state_ == GS_PENDING_TWO_FINGER_TAP);
   base::TimeDelta time_delta = event.time_stamp() - second_touch_time_;
   base::TimeDelta max_delta = base::TimeDelta::FromMilliseconds(1000 *
       ui::GestureConfiguration::max_touch_down_duration_in_seconds_for_click());
   if (time_delta < max_delta && point.IsInsideManhattanSquare(event))
     AppendTwoFingerTapGestureEvent(gestures);
   return true;
 }
 
 void GestureSequence::AppendLongPressGestureEvent() {
   const GesturePoint* point = GetPointByPointId(0);
   scoped_ptr<GestureEvent> gesture(CreateGestureEvent(
       GestureEventDetails(ui::ET_GESTURE_LONG_PRESS, 0, 0),
       point->first_touch_position(),
       flags_,
       base::Time::FromDoubleT(point->last_touch_time()),
       1 << point->touch_id()));
   helper_->DispatchLongPressGestureEvent(gesture.get());
 }
 
 bool GestureSequence::ScrollEnd(const TouchEvent& event,
-    GesturePoint& point, Gestures* gestures) {
+                                GesturePoint& point,
+                                Gestures* gestures) {
   DCHECK(state_ == GS_SCROLL);
   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) {
+                                 const GesturePoint& point,
+                                 Gestures* gestures) {
   DCHECK(state_ == GS_SCROLL ||
          state_ == GS_PENDING_SYNTHETIC_CLICK ||
          state_ == GS_PENDING_TWO_FINGER_TAP);
 
   // Once pinch starts, we immediately break rail scroll.
   scroll_type_ = ST_FREE;
 
   const GesturePoint* point1 = GetPointByPointId(0);
   const GesturePoint* point2 = GetPointByPointId(1);
 
   pinch_distance_current_ = BoundingBoxDiagonal(bounding_box_);
   pinch_distance_start_ = pinch_distance_current_;
   AppendPinchGestureBegin(*point1, *point2, gestures);
 
   if (state_ == GS_PENDING_SYNTHETIC_CLICK ||
       state_ == GS_PENDING_TWO_FINGER_TAP) {
     gfx::Point center = bounding_box_.CenterPoint();
     AppendScrollGestureBegin(point, center, gestures);
   }
 
   return true;
 }
 
 bool GestureSequence::PinchUpdate(const TouchEvent& event,
-    const GesturePoint& point, Gestures* gestures) {
+                                  GesturePoint& point,
+                                  Gestures* gestures) {
   DCHECK(state_ == GS_PINCH);
 
   // It is possible that the none of the touch-points changed their position,
   // but their radii changed, and that caused the bounding box to also change.
   // But in such cases, we do not want to either pinch or scroll.
   // To avoid small jiggles, it is also necessary to make sure that at least one
   // of the fingers moved enough before a pinch or scroll update is created.
   bool did_scroll = false;
   for (int i = 0; i < kMaxGesturePoints; ++i) {
     if (!points_[i].in_use() || !points_[i].DidScroll(event, 2))
@@ skipping 14 matching lines @@
     pinch_distance_current_ = distance;
   } else {
     gfx::Point center = bounding_box_.CenterPoint();
     AppendScrollGestureUpdate(point, center, gestures);
   }
 
   return true;
 }
 
 bool GestureSequence::PinchEnd(const TouchEvent& event,
-    const GesturePoint& point, Gestures* gestures) {
+                               const GesturePoint& point,
+                               Gestures* gestures) {
   DCHECK(state_ == GS_PINCH);
 
   GesturePoint* point1 = GetPointByPointId(0);
   GesturePoint* point2 = GetPointByPointId(1);
 
   float distance = BoundingBoxDiagonal(bounding_box_);
   AppendPinchGestureEnd(*point1, *point2,
       distance / pinch_distance_start_, gestures);
 
   pinch_distance_start_ = 0;
@@ skipping 74 matching lines @@
     return;
 
   // Since long press timer has been started, there should be a non-NULL point.
   const GesturePoint* point = GetPointByPointId(0);
   if (!ui::gestures::IsInsideManhattanSquare(point->first_touch_position(),
       event.location()))
     long_press_timer_->Stop();
 }
 
 }  // namespace ui