Implement measurement using futures

client/view/view.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.
 
 #library("view");
 
 #import('../base/base.dart');
 #import('../observable/observable.dart');
 #import('../touch/touch.dart');
 #import('dart:html');
 #import('../layout/layout.dart');
 
 #source('CompositeView.dart');
 #source('ConveyorView.dart');
 #source('MeasureText.dart');
 #source('PagedViews.dart');
 #source('SliderMenu.dart');
 
+
 // TODO(rnystrom): Note! This class is undergoing heavy construction. It will
 // temporary support both some old and some new ways of doing things until all
 // subclasses are refactored to use the new way. There will be some scaffolding
 // and construction cones laying around. Try not to freak out.
 
 /** A generic view. */
 class View implements Positionable {
   Element _node;
   ViewLayout _layout;
 
@@ skipping 280 matching lines @@
   }
 
   void _unhookGlobalLayoutEvents() {
     if (_resizeHandler != null) {
       window.on.resize.remove(_resizeHandler);
       _resizeHandler = null;
     }
   }
 
   void doLayout() {
-    if (_measureLayout()) {
-      _applyLayoutToChildren();
-    }
+    _measureLayout().then((bool changed) {
+      if (changed) {
+        _applyLayoutToChildren();
+      }
+    });
   }
 
-  bool _measureLayout() {
+  Future<bool> _measureLayout() {

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

Yeah, this is cleaner than using a Callback like in the other file.

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

I agree that when there is some valid value to return a future for it is
cleaner. I'm not as sure for cases where void was returned.

+    final changed = new Completer<bool>();
+    _measureLayoutHelper(changed);
+
+    window.requestLayoutFrame(() {
+      if (!changed.future.isComplete) {
+        changed.complete(false);
+      }
+    });
+    return changed.future;
+  }
+
+  void _measureLayoutHelper(Completer<bool> changed) {
     windowResized();
 
     // TODO(jmesserly): this logic is more complex than it needs to be because
     // we're taking pains to not initialize _layout if it's not needed. Is that
     // a good tradeoff?
     if (ViewLayout.hasCustomLayout(this)) {
-      return layout.measureLayout(_node.clientWidth, _node.clientHeight);
+      Completer sizeCompleter = new Completer<Size>();
+      _node.rect.then((ElementRect rect) {
+        sizeCompleter.complete(
+            new Size(rect.client.width, rect.client.height));
+      });
+      layout.measureLayout(sizeCompleter.future, changed);
     } else {
-      bool changed = false;
       for (final child in childViews) {
-        if (child._measureLayout()) changed = true;
+        child._measureLayoutHelper(changed);
       }
-      return changed;
     }
   }
 
   void _applyLayoutToChildren() {
     for (final child in childViews) {
       child._applyLayout();
     }
   }
 
   void _applyLayout() {
     if (_layout != null) {
       _layout.applyLayout();
     }
     _applyLayoutToChildren();
   }
 }