Report errors and warnings for hiding elements, issue 572.

client/touch/Momentum.dart

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 /**
  * Implementations can be used to simulate the deceleration of an element within
  * a certain region. To use this behavior you need to provide an initial
  * velocity that is meant to represent the gesture that is initiating this
  * deceleration. You also provide the bounds of the region that the element
  * exists in, and the current offset of the element within that region. The
@@ skipping 222 matching lines @@
    * constant used when guessing at the velocity required to throw to a specific
    * location. Chosen arbitrarily. All that really matters is that the velocity
    * is large enough that a throw gesture will occur.
    */
   static final _VELOCITY_GUESS = 20;
 
   SingleDimensionPhysics() : _bouncingState = BouncingState.NOT_BOUNCING {
   }
 
   void configure(num minCoord, num maxCoord,
-            num initialOffset, num customDecelerationFactor,
-            num velocity) {
+            num initialOffset, num customDecelerationFactor_,
+            num velocity_) {
     _bouncingState = BouncingState.NOT_BOUNCING;
     _minCoord = minCoord;
     _maxCoord = maxCoord;
     _currentOffset = initialOffset;
-    this.customDecelerationFactor = customDecelerationFactor;
-    _adjustInitialVelocityAndBouncingState(velocity);
+    this.customDecelerationFactor = customDecelerationFactor_;
+    _adjustInitialVelocityAndBouncingState(velocity_);
   }
 
   num solve(num initialOffset, num targetOffset,
-            num customDecelerationFactor) {
+            num customDecelerationFactor_) {
     initialOffset = initialOffset.round();
     targetOffset = targetOffset.round();
     if (initialOffset == targetOffset) {
       return 0;
     }
-    return Solver.solve((num velocity) {
+    return Solver.solve((num velocity_) {
         // Don't specify min and max coordinates as we don't need to bother
         // with the simulating bouncing off the edges.
         configure(null, null, initialOffset.round(),
-                  customDecelerationFactor, velocity);
+                  customDecelerationFactor_, velocity_);
         stepAll();
         return _currentOffset;
       },
       targetOffset,
       targetOffset > initialOffset ? _VELOCITY_GUESS : -_VELOCITY_GUESS);
   }
 
   /**
    * Helper method to calculate initial velocity.
    * The [velocity] passed here should be in terms of number of
@@ skipping 144 matching lines @@
     return _nextY != _previousOffset.y || _nextX != _previousOffset.x;
   }
 
   /**
    * The [TouchHandler] requires this function but we don't need to do
    * anything here.
    */
   void onTransitionEnd() {
   }
 
-  Coordinate calculateVelocity(Coordinate start, Coordinate target,
+  Coordinate calculateVelocity(Coordinate start_, Coordinate target,
                                [num decelerationFactor = null]) {
     return new Coordinate(
-        physicsX.solve(start.x, target.x, decelerationFactor),
-        physicsY.solve(start.y, target.y, decelerationFactor));
+        physicsX.solve(start_.x, target.x, decelerationFactor),
+        physicsY.solve(start_.y, target.y, decelerationFactor));
   }
 
   bool start(Coordinate velocity, Coordinate minCoord, Coordinate maxCoord,
              Coordinate initialOffset, [num decelerationFactor = null]) {
     _customDecelerationFactor = _defaultDecelerationFactor;
     if (decelerationFactor !== null) {
       _customDecelerationFactor = decelerationFactor;
     }
 
     if (_stepTimeout !== null) {
@@ skipping 101 matching lines @@
 
   Coordinate get destination() {
     if (!_moves.isEmpty()) {
       final lastMove = _moves.last();
       return new Coordinate(lastMove.x, lastMove.y);
     } else {
       return null;
     }
   }
 }