Implement measurement using futures

client/samples/total/src/SelectionManager.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.
 
 // The callback method type invoked when the selection changes.
 typedef void SelectionCallback();
 
 // The method type for the SelectionManager.applyToSelectedCells method.
 typedef void SelectionApply(CellLocation location);
 
@@ skipping 84 matching lines @@
 
   // Hide the selection marquee and empty the selection range
   void clearSelection() {
     _selectionDiv.style.setProperty("display", "none");
     _selectedCell = _selectionCorner = null;
     selectionChanged();
   }
 
   // Return a BoundingBox for the given CellRange, clipped to the visible region of the table
   // TODO:  deal with full row and/or column selection
-  BoundingBox getBoundingBoxForRange(CellRange r) {
+  Future<BoundingBox> getBoundingBoxForRange(CellRange r) {
     // Modify the overlay for entire row/column selection
     int minRow = r.minCorner.row;
     int maxRow = r.maxCorner.row;
     int minCol = r.minCorner.col;
     int maxCol = r.maxCorner.col;
 
     // FIXME - provide the table size to this class in a better way
     int maxVisibleRow = _table.numRows() - 1;
     TableRowElement tableRow = _table.getRowElement(0);
     int maxVisibleCol = tableRow.cells.length - 1;
@@ skipping 14 matching lines @@
     if (maxRow <= _originRow) {
       return null;
     }
     if (minCol > _originColumn + maxVisibleCol) {
       return null;
     }
     if (minRow > _originRow + maxVisibleRow) {
       return null;
     }
 
+    final completer = new Completer<BoundingBox>(); 
+
     // Clip the range to the visible region
     int minPinned = _pin(minRow - _originRow, 1, maxVisibleRow);
     TableRowElement minRowElmt = _table.getRowElement(minPinned);
     TableCellElement minCellElmt =
         minRowElmt.cells[_pin(minCol - _originColumn, 1, maxVisibleCol)];
     int maxPinned = _pin(maxRow - _originRow, 1, maxVisibleRow);
     TableRowElement maxRowElmt = _table.getRowElement(maxPinned);
     TableCellElement maxCellElmt =
         maxRowElmt.cells[_pin(maxCol - _originColumn, 1, maxVisibleCol)];
 
-    // We need bounding box relative to the container which will be offset by css
-    ClientRect orgP = _table.getBoundingClientRect();
-    ClientRect minP = minCellElmt.getBoundingClientRect();
-    ClientRect maxP = maxCellElmt.getBoundingClientRect();
-    return new BoundingBox(
-        (minP.left - orgP.left).toInt(),
-        (minP.top - orgP.top).toInt(),
-        (maxP.left - minP.left + maxCellElmt.clientWidth).toInt(),
-        (maxP.top - minP.top + maxCellElmt.clientHeight).toInt());
+    // We need bounding box relative to the container which will be offset by
+    // css.
+    final tableRect = _table.rect;
+    final minCellElmtRect = minCellElmt.rect;
+    final maxCellElmtRect = maxCellElmt.rect;
+
+    window.requestLayoutFrame(() {
+      ClientRect orgP = tableRect.bounding;
+      ClientRect minP = minCellElmtRect.bounding;
+      ClientRect maxP = maxCellElmtRect.bounding;
+      completer.complete(new BoundingBox(
+          (minP.left - orgP.left).toInt(),
+          (minP.top - orgP.top).toInt(),
+          (maxP.left - minP.left + maxCellElmtRect.client.width).toInt(),
+          (maxP.top - minP.top + maxCellElmtRect.client.height).toInt()));
+    });
+    return completer.future;
   }
 
   CellRange getSelectionRange() => _getSelectionRange(_selectedCell, _selectionCorner);
 
   bool isColumnSelected(int column) {
     CellRange r = _getSelectionRange(_selectedCell, _selectionCorner);
     if (r == null) {
       return false;
     }
     return r.minCorner.col <= column && r.maxCorner.col >= column;
@@ skipping 41 matching lines @@
   }
 
   // Draw or hide the selection marquee using current cell metrics
   void updateSelection() {
     CellRange r = _getSelectionRange(_selectedCell, _selectionCorner);
     if (r == null) {
       clearSelection();
       return;
     }
 
-    BoundingBox box = getBoundingBoxForRange(r);
-    if (box != null) {
-      _selectionDiv.style.setProperty("left", HtmlUtils.toPx(box.left));
-      _selectionDiv.style.setProperty("top", HtmlUtils.toPx(box.top));
-      _selectionDiv.style.setProperty("width", HtmlUtils.toPx(box.width));
-      _selectionDiv.style.setProperty("height", HtmlUtils.toPx(box.height));
-      _selectionDiv.style.removeProperty("display");
-    } else {
-      _selectionDiv.style.setProperty("display", "none");
-    }
+    getBoundingBoxForRange(r).then((BoundingBox box) {
+      if (box != null) {
+        _selectionDiv.style.setProperty("left", HtmlUtils.toPx(box.left));
+        _selectionDiv.style.setProperty("top", HtmlUtils.toPx(box.top));
+        _selectionDiv.style.setProperty("width", HtmlUtils.toPx(box.width));
+        _selectionDiv.style.setProperty("height", HtmlUtils.toPx(box.height));
+        _selectionDiv.style.removeProperty("display");
+      } else {
+        _selectionDiv.style.setProperty("display", "none");
+      }
+    });
   }
 
   // Return the selection range for the given corners.
   // If the first corner is on a row header, it is assumed that the entire
   // row is selected, and the returned range has min.col == 0 and max.col == 0.
   // If the first corner is on a column header, it is assumed that the entire
   // column is selected, and the returned range has min.row == 0 and max.row == 0.
   CellRange _getSelectionRange(CellLocation corner1, CellLocation corner2) {
     if (corner1 == null || corner2 == null) {
       return null;
@@ skipping 18 matching lines @@
       return new CellRange.columns(corner1.spreadsheet, minCol, maxCol);
     }
 
     return new CellRange(corner1.spreadsheet, new RowCol(minRow, minCol),
         new RowCol(maxRow, maxCol));
   }
 
   // Return the value closest to x in the range [min, max]
   int _pin(int x, int min, int max) => Math.max(Math.min(x, max), min);
 }