Move VariableHeightScrollable to sdk/lib/widgets

sky/sdk/lib/widgets/block_viewport.dart

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+import 'dart:collection';
+
 import '../rendering/block.dart';
 import '../rendering/box.dart';
 import '../rendering/object.dart';
 import 'widget.dart';
 
 // return null if index is greater than index of last entry
 typedef Widget IndexedBuilder(int index);
 
+typedef void LayoutChangedCallback(
+  int firstVisibleChildIndex, 
+  int visibleChildCount,
+  UnmodifiableListView<double> childOffsets,
+  bool didReachLastChild
+);
+
 class _Key {
   const _Key(this.type, this.key);
   factory _Key.fromWidget(Widget widget) => new _Key(widget.runtimeType, widget.key);
   final Type type;
   final String key;
   bool operator ==(other) => other is _Key && other.type == type && other.key == key;
   int get hashCode => 373 * 37 * type.hashCode + key.hashCode;
 }
 
 class BlockViewport extends RenderObjectWrapper {
-  BlockViewport({ this.builder, this.startOffset, this.token, String key })
+  BlockViewport({ this.builder, this.startOffset, this.token, this.onLayoutChanged, String key })
     : super(key: key);
 
   IndexedBuilder builder;
   double startOffset;
   Object token;
+  LayoutChangedCallback onLayoutChanged;
 
   RenderBlockViewport get root => super.root;
   RenderBlockViewport createNode() => new RenderBlockViewport();
 
   Map<_Key, Widget> _childrenByKey = new Map<_Key, Widget>();  
 
   void walkChildren(WidgetTreeWalker walker) {
     for (Widget child in _childrenByKey.values)
       walker(child);
   }
@@ skipping 37 matching lines @@
     super.didUnmount();
   }
 
   // _offsets contains the offsets of each child from the top of the
   // list up to the last one we've ever created, and the offset of the
   // end of the last one. If there's no children, then the only offset
   // is 0.0.
   List<double> _offsets = <double>[0.0];
   int _currentStartIndex = 0;
   int _currentChildCount = 0;
+  bool _didReachLastChild = false;
 
   int _findIndexForOffsetBeforeOrAt(double offset) {
     int left = 0;
     int right = _offsets.length - 1;
     while (right >= left) {
       int middle = left + ((right - left) ~/ 2);
       if (_offsets[middle] < offset) {
         left = middle + 1;
       } else if (_offsets[middle] > offset) {
         right = middle - 1;
@@ skipping 10 matching lines @@
     retainStatefulRenderObjectWrapper(newNode);
     if (startOffset != newNode.startOffset) {
       _dirty = true;
       startOffset = newNode.startOffset;
     }
     if (token != newNode.token || builder != newNode.builder) {
       _dirty = true;
       builder = newNode.builder;
       token = newNode.token;
       _offsets = <double>[0.0];
+      _didReachLastChild = false;
     }
     return true;
   }
 
   void syncRenderObject(BlockViewport old) {
     super.syncRenderObject(old);
     if (_dirty) {
       root.markNeedsLayout();
     } else {
       if (_currentChildCount > 0) {
@@ skipping 63 matching lines @@
       if (_offsets.length > 1) {
         haveChildren = true;
       } else {
         Widget widget = _getWidget(startIndex, innerConstraints);
         if (widget != null) {
           newChildren[new _Key.fromWidget(widget)] = widget;
           builtChildren[startIndex] = widget;
           haveChildren = true;
         } else {
           haveChildren = false;
+          _didReachLastChild = true;
         }
       }
     } else {
       startIndex = _findIndexForOffsetBeforeOrAt(startOffset);
       if (startIndex == _offsets.length - 1) {
         // We don't have an offset on the list that is beyond the start offset.
         assert(_offsets.last <= startOffset);
         // Fill the list until this isn't true or until we know that the
         // list is complete (and thus we are overscrolled).
         while (true) {
           Widget widget = _getWidget(startIndex, innerConstraints);
-          if (widget == null)
+          if (widget == null) {
+            _didReachLastChild = true;
             break;
+          }
           _Key widgetKey = new _Key.fromWidget(widget);
           if (_offsets.last > startOffset) {
             newChildren[widgetKey] = widget;
             builtChildren[startIndex] = widget;
             break;
           }
           if (!_childrenByKey.containsKey(widgetKey)) {
             // we don't actually need this one, release it
             syncChild(null, widget, null);
           } // else we'll get rid of it later, when we remove old children
           startIndex += 1;
           assert(startIndex == _offsets.length - 1);
         }
         if (_offsets.last > startOffset) {
           // If we're here, we have at least one child, so our list has
           // at least two offsets, the top of the child and the bottom
           // of the child.
           assert(_offsets.length >= 2);
           assert(startIndex == _offsets.length - 2);
           haveChildren = true;
         } else {
           // If we're here, there are no children to show.
           haveChildren = false;
         }
       } else {
         haveChildren = true;
       }
     }
     assert(haveChildren != null);
+    assert(haveChildren || _didReachLastChild);
 
     assert(startIndex >= 0);
     assert(startIndex < _offsets.length);
 
     int index = startIndex;
     if (haveChildren) {
       // Build all the widgets we need.
       root.startOffset = _offsets[index] - startOffset;
       while (_offsets[index] < endOffset) {
         if (!builtChildren.containsKey(index)) {
           Widget widget = _getWidget(index, innerConstraints);
-          if (widget == null)
-            break; // reached the end of the list
+          if (widget == null) {
+            _didReachLastChild = true;
+            break;
+          }
           newChildren[new _Key.fromWidget(widget)] = widget;
           builtChildren[index] = widget;
         }
         assert(builtChildren[index] != null);
         index += 1;
       }
     }
 
     // Remove any old children.
     for (_Key oldChildKey in _childrenByKey.keys) {
@@ skipping 16 matching lines @@
           root.add(widget.root, before: nextSibling);
         }
         widget.updateSlot(nextSibling);
         nextSibling = widget.root;
       }      
     }
 
     _childrenByKey = newChildren;
     _currentStartIndex = startIndex;
     _currentChildCount = _childrenByKey.length;
+
+    if (onLayoutChanged != null) {
+      onLayoutChanged(
+        _currentStartIndex,
+        _currentChildCount, 
+        new UnmodifiableListView<double>(_offsets),
+        _didReachLastChild
+     );
+    }
   }
 
 }