Format samples and samples-dev directories.

samples-dev/swarm/swarm_ui_lib/touch/Scroller.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.
 
 part of touch;
 
 /**
  * Implementation of a custom scrolling behavior.
  * This behavior overrides native scrolling for an area. This area can be a
  * single defined part of a page, the entire page, or several different parts
@@ skipping 26 matching lines @@
 // Helper method to await the completion of 2 futures.
 void joinFutures(List<Future> futures, Callback callback) {
   int count = 0;
   int len = futures.length;
   void helper(value) {
     count++;
     if (count == len) {
       callback();
     }
   }
+
   for (Future p in futures) {
     p.then(helper);
   }
 }
 
 class Scroller implements Draggable, MomentumDelegate {
-
   /** Pixels to move each time an arrow key is pressed. */
   static const ARROW_KEY_DELTA = 30;
   static const SCROLL_WHEEL_VELOCITY = 0.01;
   static const FAST_SNAP_DECELERATION_FACTOR = 0.84;
   static const PAGE_KEY_SCROLL_FRACTION = .85;
 
   // TODO(jacobr): remove this static variable.
   static bool _dragInProgress = false;
 
   /** The node that will actually scroll. */
@@ skipping 70 matching lines @@
 
   Size _scrollSize;
   Size _contentSize;
   Coordinate _minPoint;
   bool _isStopping = false;
   Coordinate _contentStartOffset;
   bool _started = false;
   bool _activeGesture = false;
   ScrollWatcher _scrollWatcher;
 
-  Scroller(Element scrollableElem, [this.verticalEnabled = false,
-           this.horizontalEnabled = false,
-           momentumEnabled = true,
-           lookupContentSizeDelegate = null,
-           num defaultDecelerationFactor = 1,
-           int scrollTechnique = null, bool capture = false])
+  Scroller(Element scrollableElem,
+      [this.verticalEnabled = false,
+      this.horizontalEnabled = false,
+      momentumEnabled = true,
+      lookupContentSizeDelegate = null,
+      num defaultDecelerationFactor = 1,
+      int scrollTechnique = null,
+      bool capture = false])
       : _momentumEnabled = momentumEnabled,
         _lookupContentSizeDelegate = lookupContentSizeDelegate,
         _element = scrollableElem,
         _frame = scrollableElem.parent,
         _scrollTechnique = scrollTechnique != null
-            ? scrollTechnique : ScrollerScrollTechnique.TRANSFORM_3D,
+            ? scrollTechnique
+            : ScrollerScrollTechnique.TRANSFORM_3D,
         _minPoint = new Coordinate(0, 0),
         _maxPoint = new Coordinate(0, 0),
         _maxOffset = new Coordinate(0, 0),
         _minOffset = new Coordinate(0, 0),
         _contentOffset = new Coordinate(0, 0) {
     _touchHandler = new TouchHandler(this, scrollableElem.parent);
     _momentum = new Momentum(this, defaultDecelerationFactor);
 
     Element parentElem = scrollableElem.parent;
     assert(parentElem != null);
     _setOffsetFunction = _getOffsetFunction(_scrollTechnique);
     _touchHandler.setDraggable(this);
     _touchHandler.enable(capture);
 
     _frame.onMouseWheel.listen((e) {
       if (e.deltaY != 0 && verticalEnabled ||
           e.deltaX != 0 && horizontalEnabled) {
         num x = horizontalEnabled ? e.deltaX : 0;
         num y = verticalEnabled ? e.deltaY : 0;
         throwDelta(x, y, FAST_SNAP_DECELERATION_FACTOR);
         e.preventDefault();
       }
     });
 
     _frame.onKeyDown.listen((KeyboardEvent e) {
-        bool handled = false;
-        // We ignore key events where further scrolling in that direction
-        // would have no impact which matches default browser behavior with
-        // nested scrollable areas.
+      bool handled = false;
+      // We ignore key events where further scrolling in that direction
+      // would have no impact which matches default browser behavior with
+      // nested scrollable areas.
 
-        switch(e.keyCode) {
-          case 33: // page-up
-            throwDelta(
-                0,
-                _scrollSize.height * PAGE_KEY_SCROLL_FRACTION);
-            handled = true;
-            break;
-          case 34: // page-down
-            throwDelta(
-                0, -_scrollSize.height * PAGE_KEY_SCROLL_FRACTION);
-            handled = true;
-            break;
-          case 35: // End
-             throwTo(_maxPoint.x, _minPoint.y,
-                FAST_SNAP_DECELERATION_FACTOR);
-            handled = true;
-            break;
-          case 36: // Home
-            throwTo(_maxPoint.x,_maxPoint.y,
-                FAST_SNAP_DECELERATION_FACTOR);
-            handled = true;
-            break;
+      switch (e.keyCode) {
+        case 33: // page-up
+          throwDelta(0, _scrollSize.height * PAGE_KEY_SCROLL_FRACTION);
+          handled = true;
+          break;
+        case 34: // page-down
+          throwDelta(0, -_scrollSize.height * PAGE_KEY_SCROLL_FRACTION);
+          handled = true;
+          break;
+        case 35: // End
+          throwTo(_maxPoint.x, _minPoint.y, FAST_SNAP_DECELERATION_FACTOR);
+          handled = true;
+          break;
+        case 36: // Home
+          throwTo(_maxPoint.x, _maxPoint.y, FAST_SNAP_DECELERATION_FACTOR);
+          handled = true;
+          break;
 /* TODO(jacobr): enable arrow keys when the don't conflict with other
    application keyboard shortcuts.
           case 38: // up
             handled = throwDelta(
                 0,
                 ARROW_KEY_DELTA,
                 FAST_SNAP_DECELERATION_FACTOR);
             break;
           case 40: // down
             handled = throwDelta(
                 0, -ARROW_KEY_DELTA,
                 FAST_SNAP_DECELERATION_FACTOR);
             break;
           case 37: // left
             handled = throwDelta(
                 ARROW_KEY_DELTA, 0,
                 FAST_SNAP_DECELERATION_FACTOR);
             break;
           case 39: // right
             handled = throwDelta(
                 -ARROW_KEY_DELTA,
                 0,
                 FAST_SNAP_DECELERATION_FACTOR);
             break;
             */
-        }
-        if (handled) {
-          e.preventDefault();
-        }
-      });
+      }
+      if (handled) {
+        e.preventDefault();
+      }
+    });
     // The scrollable element must be relatively positioned.
     // TODO(jacobr): this assert fires asynchronously which could be confusing.
     if (_scrollTechnique == ScrollerScrollTechnique.RELATIVE_POSITIONING) {
       assert(_element.getComputedStyle().position != "static");
     }
 
     _initLayer();
   }
 
   Stream<Event> get onScrollerStart {
@@ skipping 29 matching lines @@
   }
 
   Stream<Event> get onDecelStart {
     if (_onDecelStart == null) {
       _onDecelStart = new StreamController<Event>.broadcast(sync: true);
       _onDecelStartStream = _onDecelStart.stream;
     }
     return _onDecelStartStream;
   }
 
-
   /**
    * Add a scroll listener. This allows other classes to subscribe to scroll
    * notifications from this scroller.
    */
   void addScrollListener(ScrollListener listener) {
     if (_scrollWatcher == null) {
       _scrollWatcher = new ScrollWatcher(this);
       _scrollWatcher.initialize();
     }
     _scrollWatcher.addListener(listener);
   }
 
   /**
    * Adjust the new calculated scroll position based on the minimum allowed
    * position and returns the adjusted scroll value.
    */
-  num _adjustValue(num newPosition, num minPosition,
-                      num maxPosition) {
+  num _adjustValue(num newPosition, num minPosition, num maxPosition) {
     assert(minPosition <= maxPosition);
 
     if (newPosition < minPosition) {
       newPosition -= (newPosition - minPosition) / 2;
     } else {
       if (newPosition > maxPosition) {
         newPosition -= (newPosition - maxPosition) / 2;
       }
     }
     return newPosition;
@@ skipping 24 matching lines @@
       // deceleration factor specified by the momentum simulator.
       if (decelerationFactor == null) {
         decelerationFactor = _momentum.decelerationFactor;
       }
 
       if (snappedTarget != currentTarget) {
         _momentum.abort();
 
         _startDeceleration(
             _momentum.calculateVelocity(
-                _contentOffset,
-                snappedTarget,
-                decelerationFactor),
+                _contentOffset, snappedTarget, decelerationFactor),
             decelerationFactor);
         if (_onDecelStart != null) {
           _onDecelStart.add(new Event(ScrollerEventType.DECEL_START));
         }
       }
     });
   }
 
   void throwDelta(num deltaX, num deltaY, [num decelerationFactor = null]) {
     Coordinate start = _contentOffset;
@@ skipping 13 matching lines @@
     throwTo(x, y, decelerationFactor);
   }
 
   void setPosition(num x, num y) {
     _momentum.abort();
     _contentOffset.x = x;
     _contentOffset.y = y;
     _snapContentOffsetToBounds();
     _setContentOffset(_contentOffset.x, _contentOffset.y);
   }
+
   /**
    * Adjusted content size is a size with the combined largest height and width
    * of both the content and the frame.
    */
   Size _getAdjustedContentSize() {
     return new Size(Math.max(_scrollSize.width, _contentSize.width),
-                    Math.max(_scrollSize.height, _contentSize.height));
+        Math.max(_scrollSize.height, _contentSize.height));
   }
 
   // TODO(jmesserly): these should be properties instead of get* methods
-  num getDefaultVerticalOffset() =>  _maxPoint.y;
+  num getDefaultVerticalOffset() => _maxPoint.y;
   Element getElement() => _element;
   Element getFrame() => _frame;
   num getHorizontalOffset() => _contentOffset.x;
 
   /**
    * [x] Value to use as reference for percent measurement. If
    *      none is provided then the content's current x offset will be used.
    * Returns the percent of the page scrolled horizontally.
    */
   num getHorizontalScrollPercent([num x = null]) {
     x = x != null ? x : _contentOffset.x;
     return (x - _minPoint.x) / (_maxPoint.x - _minPoint.x);
   }
 
-  num getMaxPointY()=> _maxPoint.y;
+  num getMaxPointY() => _maxPoint.y;
   num getMinPointY() => _minPoint.y;
   Momentum get momentum => _momentum;
 
   /**
    * Provide access to the touch handler that the scroller created to manage
    * touch events.
    */
   TouchHandler getTouchHandler() => _touchHandler;
   num getVerticalOffset() => _contentOffset.y;
 
@@ skipping 58 matching lines @@
 
   void onDragMove() {
     if (_isStopping || (!_activeGesture && _dragInProgress)) {
       return;
     }
 
     assert(_contentStartOffset != null); // Content start not set
     Coordinate contentStart = _contentStartOffset;
     num newX = contentStart.x + _touchHandler.getDragDeltaX();
     num newY = contentStart.y + _touchHandler.getDragDeltaY();
-    newY = _shouldScrollVertically() ?
-        _adjustValue(newY, _minPoint.y, _maxPoint.y) : 0;
-    newX = _shouldScrollHorizontally() ?
-        _adjustValue(newX, _minPoint.x, _maxPoint.x) : 0;
+    newY = _shouldScrollVertically()
+        ? _adjustValue(newY, _minPoint.y, _maxPoint.y)
+        : 0;
+    newX = _shouldScrollHorizontally()
+        ? _adjustValue(newX, _minPoint.x, _maxPoint.x)
+        : 0;
     if (!_activeGesture) {
       _activeGesture = true;
       _dragInProgress = true;
     }
     if (!_started) {
       _started = true;
       if (_onScrollerStart != null) {
         _onScrollerStart.add(new Event(ScrollerEventType.SCROLLER_START));
       }
     }
     _setContentOffset(newX, newY);
   }
 
   bool onDragStart(TouchEvent e) {
     if (e.touches.length > 1) {
       return false;
     }
     bool shouldHorizontal = _shouldScrollHorizontally();
     bool shouldVertical = _shouldScrollVertically();
     bool verticalish = _touchHandler.getDragDeltaY().abs() >
         _touchHandler.getDragDeltaX().abs();
     return !!(shouldVertical || shouldHorizontal && !verticalish);
   }
 
-  void onTouchEnd() {
-  }
+  void onTouchEnd() {}
 
   /**
    * Prepare the scrollable area for possible movement.
    */
   bool onTouchStart(TouchEvent e) {
     reconfigure(() {
       final touch = e.touches[0];
       if (_momentum.decelerating) {
         e.preventDefault();
         e.stopPropagation();
@@ skipping 33 matching lines @@
    * and maxPoint allowed for scrolling.
    */
   void _resize(Callback callback) {
     scheduleMicrotask(() {
       if (_lookupContentSizeDelegate != null) {
         _contentSize = _lookupContentSizeDelegate();
       } else {
         _contentSize = new Size(_element.scrollWidth, _element.scrollHeight);
       }
 
-      _scrollSize = new Size(_frame.offset.width,
-                             _frame.offset.height);
+      _scrollSize = new Size(_frame.offset.width, _frame.offset.height);
       Size adjusted = _getAdjustedContentSize();
       _maxPoint = new Coordinate(-_maxOffset.x, -_maxOffset.y);
       _minPoint = new Coordinate(
           Math.min(
               _scrollSize.width - adjusted.width + _minOffset.x, _maxPoint.x),
-          Math.min(
-              _scrollSize.height - adjusted.height + _minOffset.y, _maxPoint.y));
+          Math.min(_scrollSize.height - adjusted.height + _minOffset.y,
+              _maxPoint.y));
       callback();
     });
   }
 
   Coordinate _snapToBounds(num x, num y) {
     num clampX = GoogleMath.clamp(_minPoint.x, x, _maxPoint.x);
     num clampY = GoogleMath.clamp(_minPoint.y, y, _maxPoint.y);
     return new Coordinate(clampX, clampY);
   }
 
@@ skipping 17 matching lines @@
   }
 
   /**
    * Sets the vertical scrolled offset of the element where [y] is the amount
    * of vertical space to be scrolled, in pixels.
    */
   void setVerticalOffset(num y) {
     _setContentOffset(_contentOffset.x, y);
   }
 
-   /**
+  /**
    * Whether the scrollable area should scroll horizontally. Only
    * returns true if the client has enabled horizontal scrolling, and the
    * content is wider than the frame.
    */
   bool _shouldScrollHorizontally() {
     return horizontalEnabled && _scrollSize.width < _contentSize.width;
   }
 
   /**
    * Whether the scrollable area should scroll vertically. Only
    * returns true if the client has enabled vertical scrolling.
    * Vertical bouncing will occur even if frame is taller than content, because
    * this is what iPhone web apps tend to do. If this is not the desired
    * behavior, either disable vertical scrolling for this scroller or add a
    * 'bouncing' parameter to this interface.
    */
   bool _shouldScrollVertically() {
     return verticalEnabled;
   }
 
   /**
    * In the event that the content is currently beyond the bounds of
    * the frame, snap it back in to place.
    */
   void _snapContentOffsetToBounds() {
-    num clampX =
-        GoogleMath.clamp(_minPoint.x, _contentOffset.x, _maxPoint.x);
-    num clampY =
-        GoogleMath.clamp(_minPoint.y, _contentOffset.y, _maxPoint.y);
+    num clampX = GoogleMath.clamp(_minPoint.x, _contentOffset.x, _maxPoint.x);
+    num clampY = GoogleMath.clamp(_minPoint.y, _contentOffset.y, _maxPoint.y);
     if (_contentOffset.x != clampX || _contentOffset.y != clampY) {
       _setContentOffset(clampX, clampY);
     }
   }
 
   /**
    * Initiate the deceleration behavior given a flick [velocity].
    * Returns true if deceleration has been initiated.
    */
   bool _startDeceleration(Coordinate velocity,
-                          [num decelerationFactor = null]) {
+      [num decelerationFactor = null]) {
     if (!_shouldScrollHorizontally()) {
       velocity.x = 0;
     }
     if (!_shouldScrollVertically()) {
       velocity.y = 0;
     }
     assert(_minPoint != null); // Min point is not set
     assert(_maxPoint != null); // Max point is not set
-    return _momentum.start(velocity, _minPoint, _maxPoint, _contentOffset,
-                           decelerationFactor);
+    return _momentum.start(
+        velocity, _minPoint, _maxPoint, _contentOffset, decelerationFactor);
   }
 
   Coordinate stop() {
     return _momentum.stop();
   }
 
   /**
    * Stop the deceleration of the scrollable content given a new position in px.
    */
   void _stopDecelerating(num x, num y) {
     _momentum.stop();
     _setContentOffset(x, y);
   }
 
   static Function _getOffsetFunction(int scrollTechnique) {
-    return scrollTechnique == ScrollerScrollTechnique.TRANSFORM_3D ?
-        (el, x, y) { FxUtil.setTranslate(el, x, y, 0); } :
-        (el, x, y) { FxUtil.setLeftAndTop(el, x, y); };
+    return scrollTechnique == ScrollerScrollTechnique.TRANSFORM_3D
+        ? (el, x, y) {
+            FxUtil.setTranslate(el, x, y, 0);
+          }
+        : (el, x, y) {
+            FxUtil.setLeftAndTop(el, x, y);
+          };
   }
 }
 
 // TODO(jacobr): cleanup this class of enum constants.
 class ScrollerEventType {
   static const SCROLLER_START = "scroller:scroll_start";
   static const SCROLLER_END = "scroller:scroll_end";
   static const DRAG_END = "scroller:drag_end";
   static const CONTENT_MOVED = "scroller:content_moved";
   static const DECEL_START = "scroller:decel_start";
 }
 
 class ScrollerScrollTechnique {
   static const TRANSFORM_3D = 1;
   static const RELATIVE_POSITIONING = 2;
 }