Switch scroll physics over to using newton

sky/sdk/lib/animation/scroll_behavior.dart

 // Copyright 2015 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.
 
 import 'dart:math' as math;
 
-import 'mechanics.dart';
-import 'generators.dart';
+import 'package:newton/newton.dart';
 
-const double _kScrollFriction = 0.005;
-const double _kOverscrollFriction = 0.075;
-const double _kBounceSlopeAngle = math.PI / 512.0; // radians
+const double _kSecondsPerMillisecond = 1000.0;
 
 abstract class ScrollBehavior {
-  Simulation release(Particle particle) => null;
+  Simulation release(double position, double velocity) => null;
 
   // Returns the new scroll offset.
   double applyCurve(double scrollOffset, double scrollDelta);
 }
 
-class BoundedScrollBehavior extends ScrollBehavior {
-  double minOffset;
-  double maxOffset;
+class BoundedBehavior extends ScrollBehavior {
+  BoundedBehavior({ double contentsSize: 0.0, double containerSize: 0.0 })
+    : _contentsSize = contentsSize,
+      _containerSize = containerSize;
 
-  BoundedScrollBehavior({this.minOffset: 0.0, this.maxOffset});
-
-  double applyCurve(double scrollOffset, double scrollDelta) {
-    double newScrollOffset = scrollOffset + scrollDelta;
-    if (minOffset != null)
-      newScrollOffset = math.max(minOffset, newScrollOffset);
-    if (maxOffset != null)
-      newScrollOffset = math.min(maxOffset, newScrollOffset);
-    return newScrollOffset;
-  }
-}
-
-class OverscrollBehavior extends ScrollBehavior {
-
-  double _contentsHeight;
-  double get contentsHeight => _contentsHeight;
-  void set contentsHeight (double value) {
-    if (_contentsHeight != value) {
-      _contentsHeight = value;
+  double _contentsSize;
+  double get contentsSize => _contentsSize;
+  void set contentsSize (double value) {
+    if (_contentsSize != value) {
+      _contentsSize = value;
       // TODO(ianh) now what? what if we have a simulation ongoing?
     }
   }
 
-  double _containerHeight;
-  double get containerHeight => _containerHeight;
-  void set containerHeight (double value) {
-    if (_containerHeight != value) {
-      _containerHeight = value;
+  double _containerSize;
+  double get containerSize => _containerSize;
+  void set containerSize (double value) {
+    if (_containerSize != value) {
+      _containerSize = value;
       // TODO(ianh) now what? what if we have a simulation ongoing?
     }
   }
 
-  OverscrollBehavior({double contentsHeight: 0.0, double containerHeight: 0.0})
-    : _contentsHeight = contentsHeight,
-      _containerHeight = containerHeight;
+  final double minScrollOffset = 0.0;
+  double get maxScrollOffset => math.max(0.0, _contentsSize - _containerSize);
 
-  double get maxScrollOffset => math.max(0.0, _contentsHeight - _containerHeight);
+  double applyCurve(double scrollOffset, double scrollDelta) {
+    return (scrollOffset + scrollDelta).clamp(0.0, maxScrollOffset);
+  }
+}
 
-  Simulation release(Particle particle) {
-    System system;
-    if ((particle.position >= 0.0) && (particle.position < maxScrollOffset)) {
-      if (particle.velocity == 0.0)
-        return null;
-      System slowdownSystem = new ParticleInBoxWithFriction(
-        particle: particle,
-        friction: _kScrollFriction,
-        box: new GeofenceBox(min: 0.0, max: maxScrollOffset, onEscape: () {
-          (system as Multisystem).transitionToSystem(new ParticleInBoxWithFriction(
-            particle: particle,
-            friction: _kOverscrollFriction,
-            box: new ClosedBox(),
-            onStop: () => (system as Multisystem).transitionToSystem(getBounceBackSystem(particle))
-          ));
-        }));
-      system = new Multisystem(particle: particle, system: slowdownSystem);
-    } else {
-      system = getBounceBackSystem(particle);
-    }
-    return new Simulation(system, terminationCondition: () => particle.position == 0.0);
+Simulation createDefaultScrollSimulation(double position, double velocity, double minScrollOffset, double maxScrollOffset) {
+  double velocityPerSecond = velocity * _kSecondsPerMillisecond;
+  SpringDescription spring = new SpringDescription.withDampingRatio(
+      mass: 1.0, springConstant: 85.0, ratio: 1.1);
+  double drag = 0.4;
+  return new ScrollSimulation(position, velocityPerSecond, minScrollOffset, maxScrollOffset, spring, drag);
+}
+
+class FlingBehavior extends BoundedBehavior {
+  FlingBehavior({ double contentsSize: 0.0, double containerSize: 0.0 })
+    : super(contentsSize: contentsSize, containerSize: containerSize);
+
+  Simulation release(double position, double velocity) {
+    return createDefaultScrollSimulation(position, 0.0, minScrollOffset, maxScrollOffset);
   }
+}
 
-  System getBounceBackSystem(Particle particle) {
-    if (particle.position < 0.0)
-      return new ParticleClimbingRamp(
-        particle: particle,
-        box: new ClosedBox(max: 0.0),
-        theta: _kBounceSlopeAngle,
-        targetPosition: 0.0);
-    return new ParticleClimbingRamp(
-      particle: particle,
-      box: new ClosedBox(min: maxScrollOffset),
-      theta: _kBounceSlopeAngle,
-      targetPosition: maxScrollOffset);
+class OverscrollBehavior extends BoundedBehavior {
+  OverscrollBehavior({ double contentsSize: 0.0, double containerSize: 0.0 })
+    : super(contentsSize: contentsSize, containerSize: containerSize);
+
+  Simulation release(double position, double velocity) {
+    return createDefaultScrollSimulation(position, velocity, minScrollOffset, maxScrollOffset);
   }
 
   double applyCurve(double scrollOffset, double scrollDelta) {
     double newScrollOffset = scrollOffset + scrollDelta;
     // If we're overscrolling, we want move the scroll offset 2x
     // slower than we would otherwise. Therefore, we "rewind" the
     // newScrollOffset by half the amount that we moved it above.
     // Notice that we clap the "old" value to 0.0 so that we only
     // reduce the portion of scrollDelta that's applied beyond 0.0. We
     // do similar things for overscroll in the other direction.
     if (newScrollOffset < 0.0) {
       newScrollOffset -= (newScrollOffset - math.min(0.0, scrollOffset)) / 2.0;
     } else if (newScrollOffset > maxScrollOffset) {
       newScrollOffset -= (newScrollOffset - math.max(maxScrollOffset, scrollOffset)) / 2.0;
     }
     return newScrollOffset;
   }
 }