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 firstVisibleWidgetIndex, 
+  int visibleWidgetCount,
+  UnmodifiableListView<double> widgetOffsets,
+  bool lastWidgetReached);

[Hixie, 2015/07/10 22:51:38]

paren on its own line

[hansmuller, 2015/07/10 23:42:05]

Done.

+
 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 _lastWidgetReached = false;

[Hixie, 2015/07/10 22:51:37]

lastWidgetReached would store a Widget. If you want to store a boolean, call it
something like didReachLastWidget or some such. Sine you call it a child count
and not a widget count, maybe didReachLastChild?

[hansmuller, 2015/07/10 23:42:05]

I've changed all the fooWidget names I added to fooChild.

 
   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];
+      _lastWidgetReached = false;
     }
     return true;
   }
 
   void syncRenderObject(BlockViewport old) {
     super.syncRenderObject(old);
     if (_dirty) {
       root.markNeedsLayout();
     } else {
       if (_currentChildCount > 0) {
@@ skipping 62 matching lines @@
       startIndex = 0;
       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;

[Hixie, 2015/07/10 22:51:37]

i think this also means we've reached the end, no?

[hansmuller, 2015/07/10 23:42:05]

Yes.

         }
       }
     } 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)
             break;

[Hixie, 2015/07/10 22:51:37]

i think you have to also flag the end here?

[hansmuller, 2015/07/10 23:42:05]

Oops, yes.

           _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);

[Hixie, 2015/07/10 22:51:37]

assert that if haveChildren is false, that we've also set the "reached the end"
flag.

[hansmuller, 2015/07/10 23:42:06]

Done.

 
     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) {
+            _lastWidgetReached = 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,

[Hixie, 2015/07/10 22:51:38]

this should be indented with two spaces.

[hansmuller, 2015/07/10 23:42:05]

Done.

+          _currentChildCount, 
+          new UnmodifiableListView<double>(_offsets),
+          _lastWidgetReached);

[Hixie, 2015/07/10 22:51:37]

closing paren should be on its own line.

[hansmuller, 2015/07/10 23:42:05]

Done.

+    }
   }
 
 }