Implement measurement using futures

client/layout/GridLayout.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.
 
 /**
  * Implements a grid-based layout system based on:
  * [http://dev.w3.org/csswg/css3-grid-align/]
  *
  * This layout is designed to support animations and work on browsers that
  * don't support grid natively. As such, we implement it on top of absolute
@@ skipping 67 matching lines @@
       rowSizing = _GridTrackParser.parseTrackSizing(
           view.customStyle['grid-row-sizing']),
 
       columnSizing = _GridTrackParser.parseTrackSizing(
           view.customStyle['grid-column-sizing']) {
 
     _rowTracks = rows != null ? rows.tracks : new List<GridTrack>();
     _columnTracks = columns != null ? columns.tracks : new List<GridTrack>();
   }
 
+
   int get currentWidth() => _gridWidth;
   int get currentHeight() => _gridHeight;
 
+  void cacheExistingBrowserLayout() {
+    // We don't need to do anything as we don't rely on the _cachedViewRect
+    // when the grid layout is used.
+  }
+
   /** The main entry point for layout computation. */
-  bool measureLayout(int width, int height) {
-    _gridWidth = width;
-    _gridHeight = height;
+  void measureLayout(Future<Size> size, Completer<bool> changed) {

[nweiz, 2011/10/28 03:58:38]

Passing in a Completer seems wrong... isn't the pattern for these sorts of
things to return a Future instead?

[Jacob, 2011/10/31 22:09:50]

I agree this is a bit odd looking.
However, for this case, returning futures would be much much uglier as you end
up having non-leaf views listening on the futures returned by each of their
subviews and then aggregating that into a new future.
This way things are far simpler and more efficient as we only care that at least
one of the leaf views set complete to true.

[nweiz, 2011/11/01 00:49:22]

I would argue that the correct pattern here is to return a future, then have a
library function that aggregates futures in the way you describe (it takes a
list of futures and returns a new future that will fire once any of the input
futures fire). That way this function has a type signature that matches its
semantics, and doesn't build in knowledge of the surrounding code structure.

Another thing: this function never returns false, so the bool value seems
out-of-place.

[Jacob, 2011/11/01 02:42:39]

Btw, the bool value is required as the completer is set to false if it was not
set to true before the next call to requestLayoutFrame. However, this suggests
the code isn't very readable as written. I've added a TODO to simplify the
logic.

+    _ensureAllTracks();
+    window.requestLayoutFrame(() {
+      _gridWidth = size.value.width;
+      _gridHeight = size.value.height;
 
-    _ensureAllTracks();
-
-    if (_rowTracks.length < 1 || _columnTracks.length < 1) {
-      return false; // nothing to do
-    }
-
-    _measureTracks();
-    _setBoundsOfChildren();
-    return true;
+      if (_rowTracks.length > 0 && _columnTracks.length > 0) {
+        _measureTracks();
+        _setBoundsOfChildren();
+        if (null != changed) {
+          changed.complete(true);
+        }
+      }
+    });
   }
 
   /**
    * The top level measurement function.
    * [http://dev.w3.org/csswg/css3-grid-align/#calculating-size-of-grid-tracks]
    */
   void _measureTracks() {
     // Resolve logical width, then height. Width comes first so we can use
     // the width when determining the content-sized height.
     try {
@@ skipping 296 matching lines @@
   void _ensureAllTracks() {
     final items = CollectionUtils.map(view.childViews, (view) => view.layout);
 
     for (final child in items) {
       if (child.layoutParams == null) {
         final p = new GridLayoutParams(child.view, this);
         _ensureTrack(_rowTracks, rowSizing, p.row, p.rowSpan);
         _ensureTrack(_columnTracks, columnSizing, p.column, p.columnSpan);
         child.layoutParams = p;
       }
+      child.cacheExistingBrowserLayout();
     }
   }
 
   /**
    * Given the track sizes that were computed, position children in the grid.
    */
   void _setBoundsOfChildren() {
     final items = CollectionUtils.map(view.childViews, (view) => view.layout);
 
     for (final item in items) {
@@ skipping 70 matching lines @@
     }
     return result;
   }
 
   int _getSpanCount(ViewLayout item) {
     GridLayoutParams childLayout = item.layoutParams;
     return (_dimension == Dimension.WIDTH ?
         childLayout.columnSpan : childLayout.rowSpan);
   }
 }