First Implementation of Snapped Points

ui/events/android/scroller.cc

 // Copyright 2014 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/events/android/scroller.h"
 
 #include <cmath>
 
 #include "base/lazy_instance.h"
 #include "base/macros.h"
@@ skipping 190 matching lines @@
     *offset = gfx::Vector2dF(GetFinalX(), GetFinalY());
     *velocity = gfx::Vector2dF();
     return false;
   }
 
   *offset = gfx::Vector2dF(GetCurrX(), GetCurrY());
   *velocity = gfx::Vector2dF(GetCurrVelocityX(), GetCurrVelocityY());
   return true;
 }
 
+void Scroller::ComputeTotalScrollOffset(gfx::Vector2dF& offset) {
+  offset.set_x(final_x_);
+  offset.set_y(final_y_);
+}
+
+bool Scroller::ResetCurveBySnappedOffset(const gfx::Vector2dF& offset) {
+  final_x_ = offset.x();
+  final_y_ = offset.y();
+  distance_ = std::sqrt(final_x_ * final_x_ + final_y_ * final_y_);
+
+  velocity_ = GetSplineVelocityFromDistance(distance_);
+  duration_ = GetSplineFlingDuration(velocity_);
+  if (duration_.ToInternalValue() <= 0)
+    return false;
+  duration_seconds_reciprocal_ = 1.0 / duration_.InSecondsF();
+  RecomputeDeltas();
+  return true;
+}
+
 void Scroller::StartScroll(float start_x,
                            float start_y,
                            float dx,
                            float dy,
                            base::TimeTicks start_time) {
   StartScroll(start_x,
               start_y,
               dx,
               dy,
               start_time,
@@ skipping 66 matching lines @@
   max_x_ = max_x;
   min_y_ = min_y;
   max_y_ = max_y;
 
   final_x_ = start_x + total_distance * coeff_x;
   final_x_ = Clamped(final_x_, min_x_, max_x_);
 
   final_y_ = start_y + total_distance * coeff_y;
   final_y_ = Clamped(final_y_, min_y_, max_y_);
 
+  // LOG(ERROR) << final_x_ << ".." << final_y_;
+
   RecomputeDeltas();
 }
 
 void Scroller::ExtendDuration(base::TimeDelta extend) {
   base::TimeDelta passed = GetTimePassed();
   duration_ = passed + extend;
   duration_seconds_reciprocal_ = 1.0 / duration_.InSecondsF();
   finished_ = false;
 }
 
@@ skipping 160 matching lines @@
                                            base::Time::kMicrosecondsPerSecond);
 }
 
 double Scroller::GetSplineFlingDistance(float velocity) const {
   const double l = GetSplineDeceleration(velocity);
   const double decel_minus_one = kDecelerationRate - 1.0;
   return fling_friction_ * tuning_coeff_ *
          std::exp(kDecelerationRate / decel_minus_one * l);
 }
 
+double Scroller::GetSplineVelocityFromDeceleration(float deceleration) const {
+  return std::exp(deceleration) * (fling_friction_ * tuning_coeff_) /
+         kInflexion;
+}
+
+double Scroller::GetSplineVelocityFromDistance(float distance) const {
+  double decel_minus_one = kDecelerationRate - 1.0;
+  double deceleration = std::log(distance / (fling_friction_ * tuning_coeff_)) /
+                        (kDecelerationRate / decel_minus_one);
+  return GetSplineVelocityFromDeceleration(deceleration);
+}
+
 }  // namespace ui