Introduce BlockViewport.

sky/sdk/lib/rendering/block.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:math' as math;
 
 import 'box.dart';
 import 'object.dart';
 
 class BlockParentData extends BoxParentData with ContainerParentDataMixin<RenderBox> { }
 
-class RenderBlock extends RenderBox with ContainerRenderObjectMixin<RenderBox, BlockParentData>,
-                                         RenderBoxContainerDefaultsMixin<RenderBox, BlockParentData> {
+abstract class RenderBlockBase extends RenderBox with ContainerRenderObjectMixin<RenderBox, BlockParentData>,
+                                                      RenderBoxContainerDefaultsMixin<RenderBox, BlockParentData> {
+
   // lays out RenderBox children in a vertical stack
   // uses the maximum width provided by the parent
-  // sizes itself to the height of its child stack
 
-  RenderBlock({
+  RenderBlockBase({
     List<RenderBox> children
   }) {
     addAll(children);
   }
 
   void setupParentData(RenderBox child) {
     if (child.parentData is! BlockParentData)
       child.parentData = new BlockParentData();
   }
 
@@ skipping 45 matching lines @@
   }
 
   double getMaxIntrinsicHeight(BoxConstraints constraints) {
     return _getIntrinsicHeight(constraints);
   }
 
   double computeDistanceToActualBaseline(TextBaseline baseline) {
     return defaultComputeDistanceToFirstActualBaseline(baseline);
   }
 
+  double _childrenHeight;
+  double get childrenHeight => _childrenHeight;
+
+  void markNeedsLayout() {
+    _childrenHeight = null;
+    super.markNeedsLayout();
+  }
+
   void performLayout() {
     assert(constraints is BoxConstraints);
     double width = constraints.constrainWidth(constraints.maxWidth);
     BoxConstraints innerConstraints = _getInnerConstraintsForWidth(width);
     double y = 0.0;
     RenderBox child = firstChild;
     while (child != null) {
       child.layout(innerConstraints, parentUsesSize: true);
       assert(child.parentData is BlockParentData);
       child.parentData.position = new Point(0.0, y);
       y += child.size.height;
       child = child.parentData.nextSibling;
     }
-    size = new Size(width, constraints.constrainHeight(y));
-    assert(!size.isInfinite);
+    _childrenHeight = y;
   }
 
   void hitTestChildren(HitTestResult result, { Point position }) {
     defaultHitTestChildren(result, position: position);
   }
 
   void paint(PaintingCanvas canvas, Offset offset) {
     defaultPaint(canvas, offset);
   }
 
 }
 
+class RenderBlock extends RenderBlockBase {
+
+  // sizes itself to the height of its child stack
+
+  RenderBlock({ List<RenderBox> children }) : super(children: children);
+
+  void performLayout() {
+    super.performLayout();
+    size = constraints.constrain(new Size(constraints.maxWidth, childrenHeight));
+    assert(!size.isInfinite);
+  }
+
+}
+
+class RenderBlockViewport extends RenderBlockBase {
+
+  // sizes itself to the given constraints
+  // at the start of layout, calls callback
+
+  RenderBlockViewport({
+    LayoutCallback callback,
+    List<RenderBox> children,
+    double startOffset: 0.0
+  }) : _callback = callback, _startOffset = startOffset, super(children: children);
+
+  bool _inCallback = false;
+
+  LayoutCallback _callback;
+  LayoutCallback get callback => _callback;
+  void set callback(LayoutCallback value) {
+    assert(!_inCallback);
+    if (value == _callback)
+      return;
+    _callback = value;
+    markNeedsLayout();
+  }
+
+  // you can set this from within the callback if necessary
+  double _startOffset;
+  double get startOffset => _startOffset;
+  void set startOffset(double value) {
+    if (value == _startOffset)
+      return;
+    _startOffset = value;
+    if (!_inCallback)
+      markNeedsLayout();
+  }
+
+  bool get sizedByParent => true;
+
+  void performResize() {
+    size = constraints.biggest;
+    assert(!size.isInfinite);
+  }
+
+  bool get debugDoesLayoutWithCallback => true;
+  void performLayout() {
+    if (_callback != null) {
+      try {
+        _inCallback = true;
+        invokeLayoutCallback(_callback);
+      } finally {
+        _inCallback = false;
+      }
+    }
+    super.performLayout();
+  }
+
+  void paint(PaintingCanvas canvas, Offset offset) {
+    canvas.save();
+    canvas.clipRect(offset & size);
+    super.paint(canvas, offset.translate(0.0, _startOffset));
+    canvas.restore();
+  }
+
+}