Implement measurement using futures

client/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.
 
 /**
  * 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
  * of a page.
  *
@@ skipping 12 matching lines @@
  * positioning (setting the left and top styles).
  *
  * For this to work properly you need to set -webkit-text-size-adjust to 'none'
  * on an ancestor element of the frame, or on the frame itself. If you forget
  * this you may see the text content of the scrollable area changing size as it
  * moves.
  *
  * The behavior is intended to support vertical and horizontal scrolling, and
  * scrolling with momentum when a touch gesture flicks with enough velocity.
  */
+typedef void Callback();
+
+// 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 final ARROW_KEY_DELTA = 30;
   static final SCROLL_WHEEL_VELOCITY = 0.01;
   static final FAST_SNAP_DECELERATION_FACTOR = 0.84;
   static final PAGE_KEY_SCROLL_FRACTION = .85;
 
   // TODO(jacobr): remove this static variable.
@@ skipping 62 matching lines @@
   Function _setOffsetFunction;
   /**
    * Function that returns the content size that can be specified instead of
    * querying the DOM.
    */
   Function _lookupContentSizeDelegate;
 
   Size _scrollSize;
   Size _contentSize;
   Coordinate _minPoint;
-  bool _activeTransition = false;
   bool _isStopping = false;
   Coordinate _contentStartOffset;
   bool _started = false;
   bool _activeGesture = false;
   ScrollWatcher _scrollWatcher;
 
   Scroller(Element scrollableElem, [this.verticalEnabled = false,
            this.horizontalEnabled = false,
            this._momentumEnabled = true,
            this._lookupContentSizeDelegate = null,
            num defaultDecelerationFactor = 1,
            int scrollTechnique = null, bool capture = false])
       : _element = scrollableElem,
         _frame = scrollableElem.parent,
         _scrollTechnique = scrollTechnique !== null
             ? 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);
-    _element.on.transitionEnd.add((event) { onTransitionEnd(event); });
     _touchHandler.setDraggable(this);
     _touchHandler.enable(capture);
 
     _frame.on.mouseWheel.add((e) {
       if (e.wheelDeltaY != 0 && verticalEnabled ||
           e.wheelDeltaX != 0 && horizontalEnabled) {
         num x = horizontalEnabled ? e.wheelDeltaX : 0;
         num y = verticalEnabled ? e.wheelDeltaY : 0;
-        if (throwDelta(x, y, FAST_SNAP_DECELERATION_FACTOR)) {
-          e.preventDefault();
-        }
+        throwDelta(x, y, FAST_SNAP_DECELERATION_FACTOR);
+        e.preventDefault();
       }
     });
 
     _frame.on.keyDown.add((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.
 
         switch(e.keyCode) {
           case 33: // page-up
-            handled = throwDelta(
+            throwDelta(
                 0,
                 _scrollSize.height * PAGE_KEY_SCROLL_FRACTION);
+            handled = true;
             break;
           case 34: // page-down
-            handled = throwDelta(
+            throwDelta(
                 0, -_scrollSize.height * PAGE_KEY_SCROLL_FRACTION);
+            handled = true;
             break;
           case 35: // End
-            handled = throwTo(_maxPoint.x, _minPoint.y,
+             throwTo(_maxPoint.x, _minPoint.y,
                 FAST_SNAP_DECELERATION_FACTOR);
+            handled = true;
             break;
           case 36: // Home
-            handled = throwTo(_maxPoint.x,_maxPoint.y,
+            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
@@ skipping 12 matching lines @@
                 0,
                 FAST_SNAP_DECELERATION_FACTOR);
             break;
             */
         }
         if (handled) {
           e.preventDefault();
         }
       });
     // The scrollable element must be relatively positioned.
-    assert(_scrollTechnique != ScrollerScrollTechnique.RELATIVE_POSITIONING ||
-           window.getComputedStyle(_element, null).position != "static");
+    // TODO(jacobr): this assert fires asynchronously which could be confusing.
+    if (_scrollTechnique == ScrollerScrollTechnique.RELATIVE_POSITIONING) {
+      _element.computedStyle.then((CSSStyleDeclaration style) {
+        assert(style.position != "static");
+      });
+    }
+
     _initLayer();
   }
 
   EventListenerList get onScrollerStart() {
     if (_onScrollerStart === null) {
       _onScrollerStart = new SimpleEventListenerList();
     }
     return _onScrollerStart;
   }
 
@@ skipping 66 matching lines @@
     }
     return end;
   }
 
   Coordinate get contentOffset() => _contentOffset;
 
   /**
    * Animate the position of the scroller to the specified [x], [y] coordinates
    * by applying the throw gesture with the correct velocity to end at that
    * location.
-   * Return false if no delta needs to be applied.
    */
-  bool throwTo(num x, num y,
-               [num decelerationFactor = null]) {
-    reconfigure();
-    final snappedTarget = _snapToBounds(x, y);
-    // If a deceleration factor is not specified, use the existing
-    // deceleration factor specified by the momentum simulator.
-    if (decelerationFactor == null) {
-      decelerationFactor = _momentum.decelerationFactor;
-    }
+  void throwTo(num x, num y, [num decelerationFactor = null]) {
+    reconfigure(() {
+      final snappedTarget = _snapToBounds(x, y);
+      // If a deceleration factor is not specified, use the existing
+      // deceleration factor specified by the momentum simulator.
+      if (decelerationFactor == null) {
+        decelerationFactor = _momentum.decelerationFactor;
+      }
 
-    if (snappedTarget != currentTarget) {
-      _momentum.abort();
-      reconfigure();
+      if (snappedTarget != currentTarget) {
+        _momentum.abort();
 
-      _startDeceleration(
-          _momentum.calculateVelocity(
-              _contentOffset,
-              snappedTarget,
-              decelerationFactor),
-          decelerationFactor);
-      onDecelStart.dispatch(
-          EventUtil.createEvent(ScrollerEventType.DECEL_START));
-      return true;
-    } else {
-      return false;
-    }
+        _startDeceleration(
+            _momentum.calculateVelocity(
+                _contentOffset,
+                snappedTarget,
+                decelerationFactor),
+            decelerationFactor);
+        onDecelStart.dispatch(
+            EventUtil.createEvent(ScrollerEventType.DECEL_START));
+      }
+    });
   }
 
-  bool throwDelta(num deltaX, num deltaY, [num decelerationFactor = null]) {
+  void throwDelta(num deltaX, num deltaY, [num decelerationFactor = null]) {
     Coordinate start = _contentOffset;
     Coordinate end = currentTarget;
     int x = end.x.toInt();
     int y = end.y.toInt();
     // If we are throwing in the opposite direction of the existing momentum,
     // cancel the current momentum.
     if (deltaX != 0 && deltaX.isNegative() != (end.x - start.x).isNegative()) {
       x = start.x;
     }
     if (deltaY != 0 && deltaY.isNegative() != (end.y - start.y).isNegative()) {
       y = start.y;
     }
     x += deltaX.toInt();
     y += deltaY.toInt();
-    return throwTo(x, y, decelerationFactor);
-  }
-
-  void animateTo(num x, num y, [num duration = null,
-                 String timingFunction = null]) {
-    if (duration !== null && duration != 0
-        && _scrollTechnique == ScrollerScrollTechnique.TRANSFORM_3D) {
-      _setWebkitTransition(_element, duration, StyleUtil.TRANSFORM_STYLE,
-                           timingFunction);
-    }
-    _setContentOffset(x, y);
+    throwTo(x, y, decelerationFactor);
   }
 
   void setPosition(num x, num y) {
     _momentum.abort();
     _contentOffset.x = x;
     _contentOffset.y = y;
     _snapContentOffsetToBounds();
     _setContentOffset(_contentOffset.x, _contentOffset.y);
   }
   /**
@@ skipping 45 matching lines @@
    * Initialize the dom elements necessary for the scrolling to work.
    */
   void _initLayer() {
     // The scrollable node provided to Scroller must be a direct child
     // of the scrollable frame.
     // TODO(jacobr): Figure out why this is failing on dartium.
     // assert(_element.parent == _frame);
     _setContentOffset(_maxPoint.x, _maxPoint.y);
   }
 
-  void onDecelerate(num x, num y, [num duration = 0,
-                    String timingFunction = null]) {
-    // TODO(jacobr): remove once dartc fixes default args.
-    if (duration === null) {
-      duration = 0;
-    }
-    animateTo(x, y, duration, timingFunction);
+  void onDecelerate(num x, num y) {
+    _setContentOffset(x, y);
   }
 
   void onDecelerationEnd() {
-    _setWebkitTransition(_element, 0);
     onScrollerEnd.dispatch(
         EventUtil.createEvent(ScrollerEventType.SCROLLER_END));
     _started = false;
   }
 
   void onDragEnd() {
     _dragInProgress = false;
 
     bool decelerating = false;
     if (_activeGesture) {
-      if (_momentumEnabled && !_activeTransition) {
+      if (_momentumEnabled) {
         decelerating = _startDeceleration(_touchHandler.getEndVelocity());
       }
     }
 
     onScrollerDragEnd.dispatch(
         EventUtil.createEvent(ScrollerEventType.DRAG_END));
 
     if (!decelerating) {
       _snapContentOffsetToBounds();
       onScrollerEnd.dispatch(
@@ skipping 42 matching lines @@
     return !!(shouldVertical || shouldHorizontal && !verticalish);
   }
 
   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();
-      stop();
-    } else {
-      _setWebkitTransition(_element, 0);
-    }
-    _contentStartOffset = _contentOffset.clone();
-    _snapContentOffsetToBounds();
+    reconfigure(() {
+      final touch = e.touches[0];
+      if (_momentum.decelerating) {
+        e.preventDefault();
+        e.stopPropagation();
+        stop();
+      }
+      _contentStartOffset = _contentOffset.clone();
+      _snapContentOffsetToBounds();
+    });
     return true;
   }
 
   /**
-   * Transition end event handler.
-   */
-  void onTransitionEnd(Event e) {
-    if (e.target == _element) {
-      _activeTransition = false;
-      _momentum.onTransitionEnd();
-    }
-  }
-
-  /**
    * Recalculate dimensions of the frame and the content. Adjust the minPoint
    * and maxPoint allowed for scrolling and scroll to a valid position. Call
    * this method if you know the frame or content has been updated. Called
    * internally on every touchstart event the frame receives.
    */
-  void reconfigure() {
-    _resize();
-    _snapContentOffsetToBounds();
+  void reconfigure(Callback callback) {
+    _resize(() {
+      _snapContentOffsetToBounds();
+      callback();
+    });
   }
 
   void reset() {
     stop();
     _touchHandler.reset();
-    _setWebkitTransition(_element, 0);
-    setMinOffset(0, 0);
-    setMaxOffset(0, 0);
-    reconfigure();
-    _setContentOffset(_maxPoint.x, _maxPoint.y);
+    _maxOffset.x = 0;
+    _maxOffset.y = 0;
+    _minOffset.x = 0;
+    _minOffset.y = 0;
+    reconfigure(() => _setContentOffset(_maxPoint.x, _maxPoint.y));
   }
 
   /**
    * Recalculate dimensions of the frame and the content. Adjust the minPoint
    * and maxPoint allowed for scrolling.
    */
-  void _resize() {
-    _scrollSize = new Size(_frame.offsetWidth, _frame.offsetHeight);
-    _contentSize = _lookupContentSizeDelegate !== null ?
-        _lookupContentSizeDelegate() :
-        new Size(_element.scrollWidth, _element.scrollHeight);
-    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));
+  void _resize(Callback callback) {

[arv (Not doing code reviews), 2011/10/27 05:50:24]

Maybe this should just return a future instead?

[Jacob, 2011/10/27 20:59:25]

What would it return a future of?
Future<void> seems a bit odd and creating some arbitrary value to return a
future of seems ugly.

+    final frameRect = _frame.rect;
+    Future contentSizeFuture;
+
+    if (_lookupContentSizeDelegate !== null) {
+      contentSizeFuture = _lookupContentSizeDelegate();
+      contentSizeFuture.then((Size size) {
+        _contentSize = size;
+      });
+    } else {
+      contentSizeFuture = _element.rect;
+      contentSizeFuture.then((ElementRect rect) {
+        _contentSize = new Size(rect.scroll.width, rect.scroll.height);
+      });
+    }
+
+    joinFutures(<Future>[frameRect, contentSizeFuture], () {
+      _scrollSize = new Size(frameRect.value.offset.width,
+                             frameRect.value.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));
+      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);
   }
 
   /**
    * Translate the content to a new position specified in px.
    */
   void _setContentOffset(num x, num y) {
     _contentOffset.x = x;
     _contentOffset.y = y;
     _setOffsetFunction(_element, x, y);
     onContentMoved.dispatch(
         EventUtil.createEvent(ScrollerEventType.CONTENT_MOVED));
   }
 
   /**
-   * Sets the offset to subtract from the maximum coordinate that the left upper
-   * corner of the content can scroll to.
-   */
-  void setMaxOffset(num x, num y) {
-    _maxOffset.x = x;
-    _maxOffset.y = y;
-    _resize();
-  }
-
-  /**
-   * Sets the offset to add to the minimum coordinate that the left upper corner
-   * of the content can scroll to.
-   */
-  void setMinOffset(num x, num y) {
-    _minOffset.x = x;
-    _minOffset.y = y;
-    _resize();
-  }
-
-  /**
    * Enable or disable momentum.
    */
   void setMomentum(bool enable) {
     _momentumEnabled = enable;
   }
 
   /**
-   * Update the scroll technique used for animating the scrollable area.
-   */
-  void setScrollTechnique(int technique) {
-    _scrollTechnique = technique;
-    _setOffsetFunction = _getOffsetFunction(technique);
-
-    // The scrollable element must be relatively positioned.
-    assert(technique != ScrollerScrollTechnique.RELATIVE_POSITIONING ||
-        window.getComputedStyle(_element, null).position != "static");
-
-    if (technique != ScrollerScrollTechnique.TRANSFORM_3D) {
-      FxUtil.clearWebkitTransition(_element);
-      FxUtil.clearWebkitTransform(_element);
-    }
-    if (technique != ScrollerScrollTechnique.RELATIVE_POSITIONING) {
-      FxUtil.setLeftAndTop(_element, 0, 0);
-    }
-    _setOffsetFunction(_element, _contentOffset.x, _contentOffset.y);
-  }
-
-  /**
    * 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);
   }
 
-  /**
-   * Applies a webkit transition on the element where the [duration] of the
-   * animation is specified in ms.
-   */
-  void _setWebkitTransition(Element el, num duration, [String property = null,
-                            String timingFunction = null]) {
-    _activeTransition = duration > 0;
-    FxUtil.setWebkitTransition(el, duration, property, timingFunction);
-  }
-
-  /**
+   /**
    * 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
@@ skipping 33 matching lines @@
     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);
   }
 
   Coordinate stop() {
-    Coordinate velocity = _momentum.stop();
-
-    if (_momentum.decelerating) {
-      CSSMatrix transform1 = StyleUtil.getCurrentTransformMatrix(
-          _element);
-      if (!_activeTransition) {
-        _stopDecelerating(transform1.m41, transform1.m42);
-        return velocity;
-      }
-      _contentOffset.x = transform1.m41;
-      _contentOffset.y = transform1.m42;
-      _isStopping = true;
-      window.setTimeout(() {
-        CSSMatrix transform2 = StyleUtil.getCurrentTransformMatrix(
-            _element);
-        _setWebkitTransition(_element, 0);
-        window.setTimeout(function() { _isStopping = false; }, 0);
-        num deltaX = transform2.m41 - transform1.m41;
-        num deltaY = transform2.m42 - transform1.m42;
-        num newX = transform2.m41 + 2 * deltaX;
-        num newY = transform2.m42 + 2 * deltaY;
-        newX = GoogleMath.clamp(newX, _minPoint.x, _maxPoint.x);
-        newY = GoogleMath.clamp(newY, _minPoint.y, _maxPoint.y);
-        _stopDecelerating(newX, newY);
-      }, 0);
-    }
-    return velocity;
+    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);
   }
 
@@ skipping 53 matching lines @@
     for (EventListener listener in _listeners) {
       listener(evt);
     }
   }
 }
 
 class ScrollerScrollTechnique {
   static final TRANSFORM_3D = 1;
   static final RELATIVE_POSITIONING = 2;
 }