sliver_multi_box_adaptor.dart 26.9 KB
Newer Older
Ian Hickson's avatar
Ian Hickson committed
1
// Copyright 2014 The Flutter Authors. All rights reserved.
Adam Barth's avatar
Adam Barth committed
2 3 4
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

5 6
// @dart = 2.8

Adam Barth's avatar
Adam Barth committed
7 8 9 10
import 'package:flutter/foundation.dart';
import 'package:flutter/gestures.dart';
import 'package:vector_math/vector_math_64.dart';

11
import 'box.dart';
Adam Barth's avatar
Adam Barth committed
12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35
import 'object.dart';
import 'sliver.dart';

/// A delegate used by [RenderSliverMultiBoxAdaptor] to manage its children.
///
/// [RenderSliverMultiBoxAdaptor] objects reify their children lazily to avoid
/// spending resources on children that are not visible in the viewport. This
/// delegate lets these objects create and remove children as well as estimate
/// the total scroll offset extent occupied by the full child list.
abstract class RenderSliverBoxChildManager {
  /// Called during layout when a new child is needed. The child should be
  /// inserted into the child list in the appropriate position, after the
  /// `after` child (at the start of the list if `after` is null). Its index and
  /// scroll offsets will automatically be set appropriately.
  ///
  /// The `index` argument gives the index of the child to show. It is possible
  /// for negative indices to be requested. For example: if the user scrolls
  /// from child 0 to child 10, and then those children get much smaller, and
  /// then the user scrolls back up again, this method will eventually be asked
  /// to produce a child for index -1.
  ///
  /// If no child corresponds to `index`, then do nothing.
  ///
  /// Which child is indicated by index zero depends on the [GrowthDirection]
36 37
  /// specified in the `constraints` of the [RenderSliverMultiBoxAdaptor]. For
  /// example if the children are the alphabet, then if
Adam Barth's avatar
Adam Barth committed
38 39
  /// [SliverConstraints.growthDirection] is [GrowthDirection.forward] then
  /// index zero is A, and index 25 is Z. On the other hand if
40 41
  /// [SliverConstraints.growthDirection] is [GrowthDirection.reverse] then
  /// index zero is Z, and index 25 is A.
Adam Barth's avatar
Adam Barth committed
42 43 44 45 46 47 48 49 50 51
  ///
  /// During a call to [createChild] it is valid to remove other children from
  /// the [RenderSliverMultiBoxAdaptor] object if they were not created during
  /// this frame and have not yet been updated during this frame. It is not
  /// valid to add any other children to this render object.
  void createChild(int index, { @required RenderBox after });

  /// Remove the given child from the child list.
  ///
  /// Called by [RenderSliverMultiBoxAdaptor.collectGarbage], which itself is
52
  /// called from [RenderSliverMultiBoxAdaptor]'s `performLayout`.
Adam Barth's avatar
Adam Barth committed
53 54 55
  ///
  /// The index of the given child can be obtained using the
  /// [RenderSliverMultiBoxAdaptor.indexOf] method, which reads it from the
56 57
  /// [SliverMultiBoxAdaptorParentData.index] field of the child's
  /// [RenderObject.parentData].
Adam Barth's avatar
Adam Barth committed
58 59 60 61 62 63 64
  void removeChild(RenderBox child);

  /// Called to estimate the total scrollable extents of this object.
  ///
  /// Must return the total distance from the start of the child with the
  /// earliest possible index to the end of the child with the last possible
  /// index.
65 66
  double estimateMaxScrollOffset(
    SliverConstraints constraints, {
Adam Barth's avatar
Adam Barth committed
67 68 69 70 71 72
    int firstIndex,
    int lastIndex,
    double leadingScrollOffset,
    double trailingScrollOffset,
  });

73 74 75 76 77 78 79 80 81 82 83 84
  /// Called to obtain a precise measure of the total number of children.
  ///
  /// Must return the number that is one greater than the greatest `index` for
  /// which `createChild` will actually create a child.
  ///
  /// This is used when [createChild] cannot add a child for a positive `index`,
  /// to determine the precise dimensions of the sliver. It must return an
  /// accurate and precise non-null value. It will not be called if
  /// [createChild] is always able to create a child (e.g. for an infinite
  /// list).
  int get childCount;

85 86
  /// Called during [RenderSliverMultiBoxAdaptor.adoptChild] or
  /// [RenderSliverMultiBoxAdaptor.move].
Adam Barth's avatar
Adam Barth committed
87 88
  ///
  /// Subclasses must ensure that the [SliverMultiBoxAdaptorParentData.index]
89 90
  /// field of the child's [RenderObject.parentData] accurately reflects the
  /// child's index in the child list after this function returns.
Adam Barth's avatar
Adam Barth committed
91 92
  void didAdoptChild(RenderBox child);

93 94 95 96 97 98 99 100 101 102 103
  /// Called during layout to indicate whether this object provided insufficient
  /// children for the [RenderSliverMultiBoxAdaptor] to fill the
  /// [SliverConstraints.remainingPaintExtent].
  ///
  /// Typically called unconditionally at the start of layout with false and
  /// then later called with true when the [RenderSliverMultiBoxAdaptor]
  /// fails to create a child required to fill the
  /// [SliverConstraints.remainingPaintExtent].
  ///
  /// Useful for subclasses to determine whether newly added children could
  /// affect the visible contents of the [RenderSliverMultiBoxAdaptor].
104 105
  void setDidUnderflow(bool value);

106 107 108 109 110 111 112
  /// Called at the beginning of layout to indicate that layout is about to
  /// occur.
  void didStartLayout() { }

  /// Called at the end of layout to indicate that layout is now complete.
  void didFinishLayout() { }

Adam Barth's avatar
Adam Barth committed
113 114 115 116 117 118 119 120 121 122
  /// In debug mode, asserts that this manager is not expecting any
  /// modifications to the [RenderSliverMultiBoxAdaptor]'s child list.
  ///
  /// This function always returns true.
  ///
  /// The manager is not required to track whether it is expecting modifications
  /// to the [RenderSliverMultiBoxAdaptor]'s child list and can simply return
  /// true without making any assertions.
  bool debugAssertChildListLocked() => true;
}
123 124
/// Parent data structure used by [RenderSliverWithKeepAliveMixin].
mixin KeepAliveParentDataMixin implements ParentData {
125 126 127
  /// Whether to keep the child alive even when it is no longer visible.
  bool keepAlive = false;

128 129
  /// Whether the widget is currently being kept alive, i.e. has [keepAlive] set
  /// to true and is offscreen.
130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151
  bool get keptAlive;
}

/// This class exists to dissociate [KeepAlive] from [RenderSliverMultiBoxAdaptor].
///
/// [RenderSliverWithKeepAliveMixin.setupParentData] must be implemented to use
/// a parentData class that uses the right mixin or whatever is appropriate.
mixin RenderSliverWithKeepAliveMixin implements RenderSliver {
  /// Alerts the developer that the child's parentData needs to be of type
  /// [KeepAliveParentDataMixin].
  @override
  void setupParentData(RenderObject child) {
    assert(child.parentData is KeepAliveParentDataMixin);
  }
}

/// Parent data structure used by [RenderSliverMultiBoxAdaptor].
class SliverMultiBoxAdaptorParentData extends SliverLogicalParentData with ContainerParentDataMixin<RenderBox>, KeepAliveParentDataMixin {
  /// The index of this child according to the [RenderSliverBoxChildManager].
  int index;

  @override
152
  bool get keptAlive => _keptAlive;
153 154
  bool _keptAlive = false;

Adam Barth's avatar
Adam Barth committed
155
  @override
156
  String toString() => 'index=$index; ${keepAlive == true ? "keepAlive; " : ""}${super.toString()}';
Adam Barth's avatar
Adam Barth committed
157 158
}

159 160 161 162 163 164 165 166 167 168 169 170 171 172
/// A sliver with multiple box children.
///
/// [RenderSliverMultiBoxAdaptor] is a base class for slivers that have multiple
/// box children. The children are managed by a [RenderSliverBoxChildManager],
/// which lets subclasses create children lazily during layout. Typically
/// subclasses will create only those children that are actually needed to fill
/// the [SliverConstraints.remainingPaintExtent].
///
/// The contract for adding and removing children from this render object is
/// more strict than for normal render objects:
///
/// * Children can be removed except during a layout pass if they have already
///   been laid out during that layout pass.
/// * Children cannot be added except during a call to [childManager], and
173
///   then only if there is no child corresponding to that index (or the child
174 175 176 177 178 179 180 181 182 183
///   child corresponding to that index was first removed).
///
/// See also:
///
///  * [RenderSliverToBoxAdapter], which has a single box child.
///  * [RenderSliverList], which places its children in a linear
///    array.
///  * [RenderSliverFixedExtentList], which places its children in a linear
///    array with a fixed extent in the main axis.
///  * [RenderSliverGrid], which places its children in arbitrary positions.
Adam Barth's avatar
Adam Barth committed
184 185
abstract class RenderSliverMultiBoxAdaptor extends RenderSliver
  with ContainerRenderObjectMixin<RenderBox, SliverMultiBoxAdaptorParentData>,
186
       RenderSliverHelpers, RenderSliverWithKeepAliveMixin {
Adam Barth's avatar
Adam Barth committed
187

188 189 190
  /// Creates a sliver with multiple box children.
  ///
  /// The [childManager] argument must not be null.
Adam Barth's avatar
Adam Barth committed
191
  RenderSliverMultiBoxAdaptor({
192
    @required RenderSliverBoxChildManager childManager,
193
  }) : assert(childManager != null),
194 195 196 197 198 199
       _childManager = childManager {
    assert(() {
      _debugDanglingKeepAlives = <RenderBox>[];
      return true;
    }());
  }
Adam Barth's avatar
Adam Barth committed
200 201 202 203

  @override
  void setupParentData(RenderObject child) {
    if (child.parentData is! SliverMultiBoxAdaptorParentData)
204
      child.parentData = SliverMultiBoxAdaptorParentData();
Adam Barth's avatar
Adam Barth committed
205 206
  }

207 208 209 210 211 212
  /// The delegate that manages the children of this object.
  ///
  /// Rather than having a concrete list of children, a
  /// [RenderSliverMultiBoxAdaptor] uses a [RenderSliverBoxChildManager] to
  /// create children during layout in order to fill the
  /// [SliverConstraints.remainingPaintExtent].
Adam Barth's avatar
Adam Barth committed
213 214 215 216
  @protected
  RenderSliverBoxChildManager get childManager => _childManager;
  final RenderSliverBoxChildManager _childManager;

217 218 219
  /// The nodes being kept alive despite not being visible.
  final Map<int, RenderBox> _keepAliveBucket = <int, RenderBox>{};

220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240
  List<RenderBox> _debugDanglingKeepAlives;

  /// Indicates whether integrity check is enabled.
  ///
  /// Setting this property to true will immediately perform an integrity check.
  ///
  /// The integrity check consists of:
  ///
  /// 1. Verify that the children index in childList is in ascending order.
  /// 2. Verify that there is no dangling keepalive child as the result of [move].
  bool get debugChildIntegrityEnabled => _debugChildIntegrityEnabled;
  bool _debugChildIntegrityEnabled = true;
  set debugChildIntegrityEnabled(bool enabled) {
    assert(enabled != null);
    assert(() {
      _debugChildIntegrityEnabled = enabled;
      return _debugVerifyChildOrder() &&
        (!_debugChildIntegrityEnabled || _debugDanglingKeepAlives.isEmpty);
    }());
  }

Adam Barth's avatar
Adam Barth committed
241 242 243
  @override
  void adoptChild(RenderObject child) {
    super.adoptChild(child);
244
    final SliverMultiBoxAdaptorParentData childParentData = child.parentData as SliverMultiBoxAdaptorParentData;
245
    if (!childParentData._keptAlive)
246
      childManager.didAdoptChild(child as RenderBox);
Adam Barth's avatar
Adam Barth committed
247 248 249 250
  }

  bool _debugAssertChildListLocked() => childManager.debugAssertChildListLocked();

251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266
  /// Verify that the child list index is in strictly increasing order.
  ///
  /// This has no effect in release builds.
  bool _debugVerifyChildOrder(){
    if (_debugChildIntegrityEnabled) {
      RenderBox child = firstChild;
      int index;
      while (child != null) {
        index = indexOf(child);
        child = childAfter(child);
        assert(child == null || indexOf(child) > index);
      }
    }
    return true;
  }

Adam Barth's avatar
Adam Barth committed
267 268
  @override
  void insert(RenderBox child, { RenderBox after }) {
269
    assert(!_keepAliveBucket.containsValue(child));
Adam Barth's avatar
Adam Barth committed
270 271
    super.insert(child, after: after);
    assert(firstChild != null);
272 273 274 275 276 277 278 279 280 281 282 283 284 285
    assert(_debugVerifyChildOrder());
  }

  @override
  void move(RenderBox child, { RenderBox after }) {
    // There are two scenarios:
    //
    // 1. The child is not keptAlive.
    // The child is in the childList maintained by ContainerRenderObjectMixin.
    // We can call super.move and update parentData with the new slot.
    //
    // 2. The child is keptAlive.
    // In this case, the child is no longer in the childList but might be stored in
    // [_keepAliveBucket]. We need to update the location of the child in the bucket.
286
    final SliverMultiBoxAdaptorParentData childParentData = child.parentData as SliverMultiBoxAdaptorParentData;
287 288 289 290 291 292 293 294 295 296 297
    if (!childParentData.keptAlive) {
      super.move(child, after: after);
      childManager.didAdoptChild(child); // updates the slot in the parentData
      // Its slot may change even if super.move does not change the position.
      // In this case, we still want to mark as needs layout.
      markNeedsLayout();
    } else {
      // If the child in the bucket is not current child, that means someone has
      // already moved and replaced current child, and we cannot remove this child.
      if (_keepAliveBucket[childParentData.index] == child) {
        _keepAliveBucket.remove(childParentData.index);
Adam Barth's avatar
Adam Barth committed
298
      }
299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314
      assert(() {
        _debugDanglingKeepAlives.remove(child);
        return true;
      }());
      // Update the slot and reinsert back to _keepAliveBucket in the new slot.
      childManager.didAdoptChild(child);
      // If there is an existing child in the new slot, that mean that child will
      // be moved to other index. In other cases, the existing child should have been
      // removed by updateChild. Thus, it is ok to overwrite it.
      assert(() {
        if (_keepAliveBucket.containsKey(childParentData.index))
          _debugDanglingKeepAlives.add(_keepAliveBucket[childParentData.index]);
        return true;
      }());
      _keepAliveBucket[childParentData.index] = child;
    }
Adam Barth's avatar
Adam Barth committed
315 316
  }

317 318
  @override
  void remove(RenderBox child) {
319
    final SliverMultiBoxAdaptorParentData childParentData = child.parentData as SliverMultiBoxAdaptorParentData;
320 321 322 323 324
    if (!childParentData._keptAlive) {
      super.remove(child);
      return;
    }
    assert(_keepAliveBucket[childParentData.index] == child);
325 326 327 328
    assert(() {
      _debugDanglingKeepAlives.remove(child);
      return true;
    }());
329 330 331 332 333 334 335
    _keepAliveBucket.remove(childParentData.index);
    dropChild(child);
  }

  @override
  void removeAll() {
    super.removeAll();
336
    _keepAliveBucket.values.forEach(dropChild);
337 338 339 340 341 342 343 344
    _keepAliveBucket.clear();
  }

  void _createOrObtainChild(int index, { RenderBox after }) {
    invokeLayoutCallback<SliverConstraints>((SliverConstraints constraints) {
      assert(constraints == this.constraints);
      if (_keepAliveBucket.containsKey(index)) {
        final RenderBox child = _keepAliveBucket.remove(index);
345
        final SliverMultiBoxAdaptorParentData childParentData = child.parentData as SliverMultiBoxAdaptorParentData;
346 347 348 349 350 351 352 353 354 355 356 357
        assert(childParentData._keptAlive);
        dropChild(child);
        child.parentData = childParentData;
        insert(child, after: after);
        childParentData._keptAlive = false;
      } else {
        _childManager.createChild(index, after: after);
      }
    });
  }

  void _destroyOrCacheChild(RenderBox child) {
358
    final SliverMultiBoxAdaptorParentData childParentData = child.parentData as SliverMultiBoxAdaptorParentData;
359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375
    if (childParentData.keepAlive) {
      assert(!childParentData._keptAlive);
      remove(child);
      _keepAliveBucket[childParentData.index] = child;
      child.parentData = childParentData;
      super.adoptChild(child);
      childParentData._keptAlive = true;
    } else {
      assert(child.parent == this);
      _childManager.removeChild(child);
      assert(child.parent == null);
    }
  }

  @override
  void attach(PipelineOwner owner) {
    super.attach(owner);
376
    for (final RenderBox child in _keepAliveBucket.values)
377 378 379 380 381 382
      child.attach(owner);
  }

  @override
  void detach() {
    super.detach();
383
    for (final RenderBox child in _keepAliveBucket.values)
384 385 386 387 388 389
      child.detach();
  }

  @override
  void redepthChildren() {
    super.redepthChildren();
390
    _keepAliveBucket.values.forEach(redepthChild);
391 392 393 394 395
  }

  @override
  void visitChildren(RenderObjectVisitor visitor) {
    super.visitChildren(visitor);
396
    _keepAliveBucket.values.forEach(visitor);
397 398
  }

399 400 401 402 403 404
  @override
  void visitChildrenForSemantics(RenderObjectVisitor visitor) {
    super.visitChildren(visitor);
    // Do not visit children in [_keepAliveBucket].
  }

Adam Barth's avatar
Adam Barth committed
405 406 407 408
  /// Called during layout to create and add the child with the given index and
  /// scroll offset.
  ///
  /// Calls [RenderSliverBoxChildManager.createChild] to actually create and add
409 410
  /// the child if necessary. The child may instead be obtained from a cache;
  /// see [SliverMultiBoxAdaptorParentData.keepAlive].
Adam Barth's avatar
Adam Barth committed
411
  ///
412 413
  /// Returns false if there was no cached child and `createChild` did not add
  /// any child, otherwise returns true.
Adam Barth's avatar
Adam Barth committed
414 415 416
  ///
  /// Does not layout the new child.
  ///
417 418 419 420
  /// When this is called, there are no visible children, so no children can be
  /// removed during the call to `createChild`. No child should be added during
  /// that call either, except for the one that is created and returned by
  /// `createChild`.
Adam Barth's avatar
Adam Barth committed
421
  @protected
422
  bool addInitialChild({ int index = 0, double layoutOffset = 0.0 }) {
Adam Barth's avatar
Adam Barth committed
423 424
    assert(_debugAssertChildListLocked());
    assert(firstChild == null);
425 426 427 428
    _createOrObtainChild(index, after: null);
    if (firstChild != null) {
      assert(firstChild == lastChild);
      assert(indexOf(firstChild) == index);
429
      final SliverMultiBoxAdaptorParentData firstChildParentData = firstChild.parentData as SliverMultiBoxAdaptorParentData;
430 431 432 433 434
      firstChildParentData.layoutOffset = layoutOffset;
      return true;
    }
    childManager.setDidUnderflow(true);
    return false;
Adam Barth's avatar
Adam Barth committed
435 436 437 438 439 440
  }

  /// Called during layout to create, add, and layout the child before
  /// [firstChild].
  ///
  /// Calls [RenderSliverBoxChildManager.createChild] to actually create and add
441 442
  /// the child if necessary. The child may instead be obtained from a cache;
  /// see [SliverMultiBoxAdaptorParentData.keepAlive].
Adam Barth's avatar
Adam Barth committed
443
  ///
444
  /// Returns the new child or null if no child was obtained.
Adam Barth's avatar
Adam Barth committed
445 446 447 448
  ///
  /// The child that was previously the first child, as well as any subsequent
  /// children, may be removed by this call if they have not yet been laid out
  /// during this layout pass. No child should be added during that call except
449
  /// for the one that is created and returned by `createChild`.
Adam Barth's avatar
Adam Barth committed
450
  @protected
451 452
  RenderBox insertAndLayoutLeadingChild(
    BoxConstraints childConstraints, {
453
    bool parentUsesSize = false,
Adam Barth's avatar
Adam Barth committed
454 455 456
  }) {
    assert(_debugAssertChildListLocked());
    final int index = indexOf(firstChild) - 1;
457
    _createOrObtainChild(index, after: null);
Adam Barth's avatar
Adam Barth committed
458 459 460 461
    if (indexOf(firstChild) == index) {
      firstChild.layout(childConstraints, parentUsesSize: parentUsesSize);
      return firstChild;
    }
462
    childManager.setDidUnderflow(true);
Adam Barth's avatar
Adam Barth committed
463 464 465 466 467 468 469
    return null;
  }

  /// Called during layout to create, add, and layout the child after
  /// the given child.
  ///
  /// Calls [RenderSliverBoxChildManager.createChild] to actually create and add
470 471
  /// the child if necessary. The child may instead be obtained from a cache;
  /// see [SliverMultiBoxAdaptorParentData.keepAlive].
Adam Barth's avatar
Adam Barth committed
472 473 474 475 476 477 478
  ///
  /// Returns the new child. It is the responsibility of the caller to configure
  /// the child's scroll offset.
  ///
  /// Children after the `after` child may be removed in the process. Only the
  /// new child may be added.
  @protected
479 480
  RenderBox insertAndLayoutChild(
    BoxConstraints childConstraints, {
Adam Barth's avatar
Adam Barth committed
481
    @required RenderBox after,
482
    bool parentUsesSize = false,
Adam Barth's avatar
Adam Barth committed
483 484 485 486
  }) {
    assert(_debugAssertChildListLocked());
    assert(after != null);
    final int index = indexOf(after) + 1;
487
    _createOrObtainChild(index, after: after);
Adam Barth's avatar
Adam Barth committed
488 489 490 491 492
    final RenderBox child = childAfter(after);
    if (child != null && indexOf(child) == index) {
      child.layout(childConstraints, parentUsesSize: parentUsesSize);
      return child;
    }
493
    childManager.setDidUnderflow(true);
Adam Barth's avatar
Adam Barth committed
494 495 496 497 498
    return null;
  }

  /// Called after layout with the number of children that can be garbage
  /// collected at the head and tail of the child list.
499 500 501 502 503 504 505
  ///
  /// Children whose [SliverMultiBoxAdaptorParentData.keepAlive] property is
  /// set to true will be removed to a cache instead of being dropped.
  ///
  /// This method also collects any children that were previously kept alive but
  /// are now no longer necessary. As such, it should be called every time
  /// [performLayout] is run, even if the arguments are both zero.
Adam Barth's avatar
Adam Barth committed
506 507 508 509 510 511
  @protected
  void collectGarbage(int leadingGarbage, int trailingGarbage) {
    assert(_debugAssertChildListLocked());
    assert(childCount >= leadingGarbage + trailingGarbage);
    invokeLayoutCallback<SliverConstraints>((SliverConstraints constraints) {
      while (leadingGarbage > 0) {
512
        _destroyOrCacheChild(firstChild);
Adam Barth's avatar
Adam Barth committed
513 514 515
        leadingGarbage -= 1;
      }
      while (trailingGarbage > 0) {
516
        _destroyOrCacheChild(lastChild);
Adam Barth's avatar
Adam Barth committed
517 518
        trailingGarbage -= 1;
      }
519 520 521 522
      // Ask the child manager to remove the children that are no longer being
      // kept alive. (This should cause _keepAliveBucket to change, so we have
      // to prepare our list ahead of time.)
      _keepAliveBucket.values.where((RenderBox child) {
523
        final SliverMultiBoxAdaptorParentData childParentData = child.parentData as SliverMultiBoxAdaptorParentData;
524 525 526
        return !childParentData.keepAlive;
      }).toList().forEach(_childManager.removeChild);
      assert(_keepAliveBucket.values.where((RenderBox child) {
527
        final SliverMultiBoxAdaptorParentData childParentData = child.parentData as SliverMultiBoxAdaptorParentData;
528 529
        return !childParentData.keepAlive;
      }).isEmpty);
Adam Barth's avatar
Adam Barth committed
530 531 532 533 534 535 536
    });
  }

  /// Returns the index of the given child, as given by the
  /// [SliverMultiBoxAdaptorParentData.index] field of the child's [parentData].
  int indexOf(RenderBox child) {
    assert(child != null);
537
    final SliverMultiBoxAdaptorParentData childParentData = child.parentData as SliverMultiBoxAdaptorParentData;
Adam Barth's avatar
Adam Barth committed
538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557
    assert(childParentData.index != null);
    return childParentData.index;
  }

  /// Returns the dimension of the given child in the main axis, as given by the
  /// child's [RenderBox.size] property. This is only valid after layout.
  @protected
  double paintExtentOf(RenderBox child) {
    assert(child != null);
    assert(child.hasSize);
    switch (constraints.axis) {
      case Axis.horizontal:
        return child.size.width;
      case Axis.vertical:
        return child.size.height;
    }
    return null;
  }

  @override
558
  bool hitTestChildren(SliverHitTestResult result, { @required double mainAxisPosition, @required double crossAxisPosition }) {
Adam Barth's avatar
Adam Barth committed
559
    RenderBox child = lastChild;
560
    final BoxHitTestResult boxResult = BoxHitTestResult.wrap(result);
Adam Barth's avatar
Adam Barth committed
561
    while (child != null) {
562
      if (hitTestBoxChild(boxResult, child, mainAxisPosition: mainAxisPosition, crossAxisPosition: crossAxisPosition))
Adam Barth's avatar
Adam Barth committed
563 564 565 566 567 568 569
        return true;
      child = childBefore(child);
    }
    return false;
  }

  @override
570
  double childMainAxisPosition(RenderBox child) {
571 572 573 574 575 576 577
    return childScrollOffset(child) - constraints.scrollOffset;
  }

  @override
  double childScrollOffset(RenderObject child) {
    assert(child != null);
    assert(child.parent == this);
578
    final SliverMultiBoxAdaptorParentData childParentData = child.parentData as SliverMultiBoxAdaptorParentData;
579
    return childParentData.layoutOffset;
Adam Barth's avatar
Adam Barth committed
580 581 582
  }

  @override
583 584 585 586 587 588 589 590 591 592
  void applyPaintTransform(RenderBox child, Matrix4 transform) {
    if (_keepAliveBucket.containsKey(indexOf(child))) {
      // It is possible that widgets under kept alive children want to paint
      // themselves. For example, the Material widget tries to paint all
      // InkFeatures under its subtree as long as they are not disposed. In
      // such case, we give it a zero transform to prevent them from painting.
      transform.setZero();
    } else {
      applyPaintTransformForBoxChild(child, transform);
    }
Adam Barth's avatar
Adam Barth committed
593 594 595 596 597 598 599 600
  }

  @override
  void paint(PaintingContext context, Offset offset) {
    if (firstChild == null)
      return;
    // offset is to the top-left corner, regardless of our axis direction.
    // originOffset gives us the delta from the real origin to the origin in the axis direction.
601
    Offset mainAxisUnit, crossAxisUnit, originOffset;
Adam Barth's avatar
Adam Barth committed
602 603 604
    bool addExtent;
    switch (applyGrowthDirectionToAxisDirection(constraints.axisDirection, constraints.growthDirection)) {
      case AxisDirection.up:
605 606
        mainAxisUnit = const Offset(0.0, -1.0);
        crossAxisUnit = const Offset(1.0, 0.0);
607
        originOffset = offset + Offset(0.0, geometry.paintExtent);
Adam Barth's avatar
Adam Barth committed
608 609 610
        addExtent = true;
        break;
      case AxisDirection.right:
611 612
        mainAxisUnit = const Offset(1.0, 0.0);
        crossAxisUnit = const Offset(0.0, 1.0);
Adam Barth's avatar
Adam Barth committed
613 614 615 616
        originOffset = offset;
        addExtent = false;
        break;
      case AxisDirection.down:
617 618
        mainAxisUnit = const Offset(0.0, 1.0);
        crossAxisUnit = const Offset(1.0, 0.0);
Adam Barth's avatar
Adam Barth committed
619 620 621 622
        originOffset = offset;
        addExtent = false;
        break;
      case AxisDirection.left:
623 624
        mainAxisUnit = const Offset(-1.0, 0.0);
        crossAxisUnit = const Offset(0.0, 1.0);
625
        originOffset = offset + Offset(geometry.paintExtent, 0.0);
Adam Barth's avatar
Adam Barth committed
626 627 628
        addExtent = true;
        break;
    }
629
    assert(mainAxisUnit != null);
Adam Barth's avatar
Adam Barth committed
630 631 632
    assert(addExtent != null);
    RenderBox child = firstChild;
    while (child != null) {
633 634
      final double mainAxisDelta = childMainAxisPosition(child);
      final double crossAxisDelta = childCrossAxisPosition(child);
635
      Offset childOffset = Offset(
636 637 638
        originOffset.dx + mainAxisUnit.dx * mainAxisDelta + crossAxisUnit.dx * crossAxisDelta,
        originOffset.dy + mainAxisUnit.dy * mainAxisDelta + crossAxisUnit.dy * crossAxisDelta,
      );
Adam Barth's avatar
Adam Barth committed
639
      if (addExtent)
640
        childOffset += mainAxisUnit * paintExtentOf(child);
641

642
      // If the child's visible interval (mainAxisDelta, mainAxisDelta + paintExtentOf(child))
643
      // does not intersect the paint extent interval (0, constraints.remainingPaintExtent), it's hidden.
644
      if (mainAxisDelta < constraints.remainingPaintExtent && mainAxisDelta + paintExtentOf(child) > 0)
645 646
        context.paintChild(child, childOffset);

Adam Barth's avatar
Adam Barth committed
647 648 649 650 651
      child = childAfter(child);
    }
  }

  @override
652 653
  void debugFillProperties(DiagnosticPropertiesBuilder properties) {
    super.debugFillProperties(properties);
654
    properties.add(DiagnosticsNode.message(firstChild != null ? 'currently live children: ${indexOf(firstChild)} to ${indexOf(lastChild)}' : 'no children current live'));
Adam Barth's avatar
Adam Barth committed
655 656
  }

657 658 659 660
  /// Asserts that the reified child list is not empty and has a contiguous
  /// sequence of indices.
  ///
  /// Always returns true.
Adam Barth's avatar
Adam Barth committed
661 662 663 664 665 666 667 668 669 670 671
  bool debugAssertChildListIsNonEmptyAndContiguous() {
    assert(() {
      assert(firstChild != null);
      int index = indexOf(firstChild);
      RenderBox child = childAfter(firstChild);
      while (child != null) {
        index += 1;
        assert(indexOf(child) == index);
        child = childAfter(child);
      }
      return true;
672
    }());
Adam Barth's avatar
Adam Barth committed
673 674
    return true;
  }
675 676

  @override
677 678
  List<DiagnosticsNode> debugDescribeChildren() {
    final List<DiagnosticsNode> children = <DiagnosticsNode>[];
679 680
    if (firstChild != null) {
      RenderBox child = firstChild;
681
      while (true) {
682
        final SliverMultiBoxAdaptorParentData childParentData = child.parentData as SliverMultiBoxAdaptorParentData;
683
        children.add(child.toDiagnosticsNode(name: 'child with index ${childParentData.index}'));
684 685
        if (child == lastChild)
          break;
686 687 688 689 690
        child = childParentData.nextSibling;
      }
    }
    if (_keepAliveBucket.isNotEmpty) {
      final List<int> indices = _keepAliveBucket.keys.toList()..sort();
691
      for (final int index in indices) {
692
        children.add(_keepAliveBucket[index].toDiagnosticsNode(
693
          name: 'child with index $index (kept alive but not laid out)',
694 695
          style: DiagnosticsTreeStyle.offstage,
        ));
696 697
      }
    }
698
    return children;
699
  }
700
}