[Effen] Prevent scrolling past the bottom of a scrollable list.

sky/framework/animation/mechanics.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;
 
 const double kGravity = -0.980; // m^s-2
 
 abstract class System {
   void update(double deltaT);
 }
 
 class Particle extends System {
   final double mass;
   double velocity;
   double position;
 
   Particle({this.mass: 1.0, this.velocity: 0.0, this.position: 0.0});
 
   void applyImpulse(double impulse) {
     velocity += impulse / mass;
   }
 
   void update(double deltaT) {
     position += velocity * deltaT;
   }
 
-  double get energy => 0.5 * mass * velocity * velocity;
-         set energy(double e) { // J
-    assert(e >= 0.0);
-    velocity = math.sqrt(2.0 * e / mass);
+  void setVelocityFromEnergy({double energy, double direction}) {

[eseidel, 2015/04/21 19:52:33]

Why the {}?  Doesn't that make them optional named args?  Does energy=1.0 not
work when they're non-optional?

[Hixie, 2015/04/21 20:18:52]

It makes them named, yes. (They're always "optional" in the sense that even
non-optional arguments can just be passed "null" without anything in Dart
complaining, hence the asserts.)

+    assert(direction == -1.0 || direction == 1.0);
+    assert(energy >= 0.0);
+    velocity = math.sqrt(2.0 * energy / mass) * direction;
   }
 }
 
 abstract class Box {
   void confine(Particle p);
 }
 
 class ClosedBox extends Box {
   final double min; // m
   final double max; // m
@@ skipping 125 matching lines @@
     assert(theta > 0.0);
     assert(theta < math.PI / 2.0);
     double deltaPosition = targetPosition - particle.position;
     double tanTheta = math.tan(theta);
     // We need to give the particle exactly as much (kinetic) energy
     // as it needs to get to the top of the slope and stop with
     // energy=0. This is exactly the same amount of energy as the
     // potential energy at the top of the slope, which is g*h*m.
     // If the slope's horizontal component is delta P long, then
     // the height is delta P times tan theta.
-    particle.energy = -kGravity * (deltaPosition * tanTheta) * particle.mass;
+    particle.setVelocityFromEnergy(
+      energy: (kGravity * (deltaPosition * tanTheta) * particle.mass).abs(),
+      direction: deltaPosition > 0.0 ? 1.0 : -1.0
+    );
     box.confine(particle);
   }
 
   void update(double deltaT) {
     particle.update(deltaT);
     // Note that we apply the impulse from gravity after updating the particle's
     // position so that we overestimate the distance traveled by the particle.
     // That ensures that we actually hit the edge of the box and don't wind up
     // reversing course.
     particle.applyImpulse(particle.mass * kGravity * _sinTheta * deltaT);
@@ skipping 13 matching lines @@
 
   void update(double deltaT) {
     _currentSystem.update(deltaT);
   }
 
   void transitionToSystem(System system) {
     assert(system != null);
     _currentSystem = system;
   }
 }