performLayout method

Implementation

@override
void performLayout() {
  final BoxConstraints childConstraints =
    constraints.copyWith(
      minHeight: _itemExtent,
      maxHeight: _itemExtent,
      minWidth: 0.0,
    );

  // The height, in pixel, that children will be visible and might be laid out
  // and painted.
  double visibleHeight = size.height;
  // If renderChildrenOutsideViewport is true, we spawn extra children by
  // doubling the visibility range, those that are in the backside of the
  // cylinder won't be painted anyway.
  if (renderChildrenOutsideViewport)
    visibleHeight *= 2;

  final double firstVisibleOffset =
      offset.pixels + _itemExtent / 2 - visibleHeight / 2;
  final double lastVisibleOffset = firstVisibleOffset + visibleHeight;

  // The index range that we want to spawn children. We find indexes that
  // are in the interval [firstVisibleOffset, lastVisibleOffset).
  int targetFirstIndex = scrollOffsetToIndex(firstVisibleOffset);
  int targetLastIndex = scrollOffsetToIndex(lastVisibleOffset);
  // Because we exclude lastVisibleOffset, if there's a new child starting at
  // that offset, it is removed.
  if (targetLastIndex * _itemExtent == lastVisibleOffset)
    targetLastIndex--;

  // Validates the target index range.
  while (!childManager.childExistsAt(targetFirstIndex) && targetFirstIndex <= targetLastIndex)
    targetFirstIndex++;
  while (!childManager.childExistsAt(targetLastIndex) && targetFirstIndex <= targetLastIndex)
    targetLastIndex--;

  // If it turns out there's no children to layout, we remove old children and
  // return.
  if (targetFirstIndex > targetLastIndex) {
    while (firstChild != null)
      _destroyChild(firstChild);
    return;
  }

  // Now there are 2 cases:
  //  - The target index range and our current index range have intersection:
  //    We shorten and extend our current child list so that the two lists
  //    match. Most of the time we are in this case.
  //  - The target list and our current child list have no intersection:
  //    We first remove all children and then add one child from the target
  //    list => this case becomes the other case.

  // Case when there is no intersection.
  if (childCount > 0 &&
      (indexOf(firstChild) > targetLastIndex || indexOf(lastChild) < targetFirstIndex)) {
    while (firstChild != null)
      _destroyChild(firstChild);
  }

  // If there is no child at this stage, we add the first one that is in
  // target range.
  if (childCount == 0) {
    _createChild(targetFirstIndex);
    _layoutChild(firstChild, childConstraints, targetFirstIndex);
  }

  int currentFirstIndex = indexOf(firstChild);
  int currentLastIndex = indexOf(lastChild);

  // Remove all unnecessary children by shortening the current child list, in
  // both directions.
  while (currentFirstIndex < targetFirstIndex) {
    _destroyChild(firstChild);
    currentFirstIndex++;
  }
  while (currentLastIndex > targetLastIndex) {
    _destroyChild(lastChild);
    currentLastIndex--;
  }

  // Relayout all active children.
  RenderBox child = firstChild;
  while (child != null) {
    child.layout(childConstraints, parentUsesSize: true);
    child = childAfter(child);
  }

  // Spawning new children that are actually visible but not in child list yet.
  while (currentFirstIndex > targetFirstIndex) {
    _createChild(currentFirstIndex - 1);
    _layoutChild(firstChild, childConstraints, --currentFirstIndex);
  }
  while (currentLastIndex < targetLastIndex) {
    _createChild(currentLastIndex + 1, after: lastChild);
    _layoutChild(lastChild, childConstraints, ++currentLastIndex);
  }

  offset.applyViewportDimension(_viewportExtent);

  // Applying content dimensions bases on how the childManager builds widgets:
  // if it is available to provide a child just out of target range, then
  // we don't know whether there's a limit yet, and set the dimension to the
  // estimated value. Otherwise, we set the dimension limited to our target
  // range.
  final double minScrollExtent = childManager.childExistsAt(targetFirstIndex - 1)
    ? _minEstimatedScrollExtent
    : indexToScrollOffset(targetFirstIndex);
  final double maxScrollExtent = childManager.childExistsAt(targetLastIndex + 1)
      ? _maxEstimatedScrollExtent
      : indexToScrollOffset(targetLastIndex);
  offset.applyContentDimensions(minScrollExtent, maxScrollExtent);
}