// Copyright 2014 The Flutter 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 'package:flutter/animation.dart';

import 'package:flutter/foundation.dart';

import 'package:flutter/gestures.dart';

import 'package:flutter/semantics.dart';

import 'package:vector_math/vector_math_64.dart';

import 'box.dart';

import 'object.dart';

import 'sliver.dart';

import 'viewport_offset.dart';

/// The unit of measurement for a [Viewport.cacheExtent].

enum CacheExtentStyle {

/// Treat the [Viewport.cacheExtent] as logical pixels.

pixel,

/// Treat the [Viewport.cacheExtent] as a multiplier of the main axis extent.

viewport,

}

/// An interface for render objects that are bigger on the inside.

///

/// Some render objects, such as [RenderViewport], present a portion of their

/// content, which can be controlled by a [ViewportOffset]. This interface lets

/// the framework recognize such render objects and interact with them without

/// having specific knowledge of all the various types of viewports.

abstract class RenderAbstractViewport extends RenderObject {

// This class is intended to be used as an interface, and should not be

// extended directly; this constructor prevents instantiation and extension.

// ignore: unused_element

factory RenderAbstractViewport._() => null;

/// Returns the [RenderAbstractViewport] that most tightly encloses the given

/// render object.

///

/// If the object does not have a [RenderAbstractViewport] as an ancestor,

/// this function returns null.

static RenderAbstractViewport of(RenderObject object) {

while (object != null) {

if (object is RenderAbstractViewport)

return object;

object = object.parent as RenderObject;

}

return null;

}

/// Returns the offset that would be needed to reveal the `target`

/// [RenderObject].

///

/// The optional `rect` parameter describes which area of that `target` object

/// should be revealed in the viewport. If `rect` is null, the entire

/// `target` [RenderObject] (as defined by its [RenderObject.paintBounds])

/// will be revealed. If `rect` is provided it has to be given in the

/// coordinate system of the `target` object.

///

/// The `alignment` argument describes where the target should be positioned

/// after applying the returned offset. If `alignment` is 0.0, the child must

/// be positioned as close to the leading edge of the viewport as possible. If

/// `alignment` is 1.0, the child must be positioned as close to the trailing

/// edge of the viewport as possible. If `alignment` is 0.5, the child must be

/// positioned as close to the center of the viewport as possible.

///

/// The `target` might not be a direct child of this viewport but it must be a

/// descendant of the viewport. Other viewports in between this viewport and

/// the `target` will not be adjusted.

///

/// This method assumes that the content of the viewport moves linearly, i.e.

/// when the offset of the viewport is changed by x then `target` also moves

/// by x within the viewport.

///

/// See also:

///

/// * [RevealedOffset], which describes the return value of this method.

RevealedOffset getOffsetToReveal(RenderObject target, double alignment, { Rect rect });

/// The default value for the cache extent of the viewport.

///

/// See also:

///

/// * [RenderViewportBase.cacheExtent] for a definition of the cache extent.

@protected

@visibleForTesting

static const double defaultCacheExtent = 250.0;

}

/// Return value for [RenderAbstractViewport.getOffsetToReveal].

///

/// It indicates the [offset] required to reveal an element in a viewport and

/// the [rect] position said element would have in the viewport at that

/// [offset].

class RevealedOffset {

/// Instantiates a return value for [RenderAbstractViewport.getOffsetToReveal].

const RevealedOffset({

@required this.offset,

@required this.rect,

}) : assert(offset != null),

assert(rect != null);

/// Offset for the viewport to reveal a specific element in the viewport.

///

/// See also:

///

/// * [RenderAbstractViewport.getOffsetToReveal], which calculates this

/// value for a specific element.

final double offset;

/// The [Rect] in the outer coordinate system of the viewport at which the

/// to-be-revealed element would be located if the viewport's offset is set

/// to [offset].

///

/// A viewport usually has two coordinate systems and works as an adapter

/// between the two:

///

/// The inner coordinate system has its origin at the top left corner of the

/// content that moves inside the viewport. The origin of this coordinate

/// system usually moves around relative to the leading edge of the viewport

/// when the viewport offset changes.

///

/// The outer coordinate system has its origin at the top left corner of the

/// visible part of the viewport. This origin stays at the same position

/// regardless of the current viewport offset.

///

/// In other words: [rect] describes where the revealed element would be

/// located relative to the top left corner of the visible part of the

/// viewport if the viewport's offset is set to [offset].

///

/// See also:

///

/// * [RenderAbstractViewport.getOffsetToReveal], which calculates this

/// value for a specific element.

final Rect rect;

@override

String toString() {

return '${objectRuntimeType(this, 'RevealedOffset')}(offset: $offset, rect: $rect)';

}

}

/// A base class for render objects that are bigger on the inside.

///

/// This render object provides the shared code for render objects that host

/// [RenderSliver] render objects inside a [RenderBox]. The viewport establishes

/// an [axisDirection], which orients the sliver's coordinate system, which is

/// based on scroll offsets rather than Cartesian coordinates.

///

/// The viewport also listens to an [offset], which determines the

/// [SliverConstraints.scrollOffset] input to the sliver layout protocol.

///

/// Subclasses typically override [performLayout] and call

/// [layoutChildSequence], perhaps multiple times.

///

/// See also:

///

/// * [RenderSliver], which explains more about the Sliver protocol.

/// * [RenderBox], which explains more about the Box protocol.

/// * [RenderSliverToBoxAdapter], which allows a [RenderBox] object to be

/// placed inside a [RenderSliver] (the opposite of this class).

abstract class RenderViewportBase<ParentDataClass extends ContainerParentDataMixin<RenderSliver>>

extends RenderBox with ContainerRenderObjectMixin<RenderSliver, ParentDataClass>

implements RenderAbstractViewport {

/// Initializes fields for subclasses.

RenderViewportBase({

AxisDirection axisDirection = AxisDirection.down,

@required AxisDirection crossAxisDirection,

@required ViewportOffset offset,

double cacheExtent,

CacheExtentStyle cacheExtentStyle = CacheExtentStyle.pixel,

}) : assert(axisDirection != null),

assert(crossAxisDirection != null),

assert(offset != null),

assert(axisDirectionToAxis(axisDirection) != axisDirectionToAxis(crossAxisDirection)),

assert(cacheExtentStyle != null),

assert(cacheExtent != null || cacheExtentStyle == CacheExtentStyle.pixel),

_axisDirection = axisDirection,

_crossAxisDirection = crossAxisDirection,

_offset = offset,

_cacheExtent = cacheExtent ?? RenderAbstractViewport.defaultCacheExtent,

_cacheExtentStyle = cacheExtentStyle;

@override

void describeSemanticsConfiguration(SemanticsConfiguration config) {

super.describeSemanticsConfiguration(config);

config.addTagForChildren(RenderViewport.useTwoPaneSemantics);

}

@override

void visitChildrenForSemantics(RenderObjectVisitor visitor) {

childrenInPaintOrder

.where((RenderSliver sliver) => sliver.geometry.visible || sliver.geometry.cacheExtent > 0.0)

.forEach(visitor);

}

/// The direction in which the [SliverConstraints.scrollOffset] increases.

///

/// For example, if the [axisDirection] is [AxisDirection.down], a scroll

/// offset of zero is at the top of the viewport and increases towards the

/// bottom of the viewport.

AxisDirection get axisDirection => _axisDirection;

AxisDirection _axisDirection;

set axisDirection(AxisDirection value) {

assert(value != null);

if (value == _axisDirection)

return;

_axisDirection = value;

markNeedsLayout();

}

/// The direction in which child should be laid out in the cross axis.

///

/// For example, if the [axisDirection] is [AxisDirection.down], this property

/// is typically [AxisDirection.left] if the ambient [TextDirection] is

/// [TextDirection.rtl] and [AxisDirection.right] if the ambient

/// [TextDirection] is [TextDirection.ltr].

AxisDirection get crossAxisDirection => _crossAxisDirection;

AxisDirection _crossAxisDirection;

set crossAxisDirection(AxisDirection value) {

assert(value != null);

if (value == _crossAxisDirection)

return;

_crossAxisDirection = value;

markNeedsLayout();

}

/// The axis along which the viewport scrolls.

///

/// For example, if the [axisDirection] is [AxisDirection.down], then the

/// [axis] is [Axis.vertical] and the viewport scrolls vertically.

Axis get axis => axisDirectionToAxis(axisDirection);

/// Which part of the content inside the viewport should be visible.

///

/// The [ViewportOffset.pixels] value determines the scroll offset that the

/// viewport uses to select which part of its content to display. As the user

/// scrolls the viewport, this value changes, which changes the content that

/// is displayed.

ViewportOffset get offset => _offset;

ViewportOffset _offset;

set offset(ViewportOffset value) {

assert(value != null);

if (value == _offset)

return;

if (attached)

_offset.removeListener(markNeedsLayout);

_offset = value;

if (attached)

_offset.addListener(markNeedsLayout);

// We need to go through layout even if the new offset has the same pixels

// value as the old offset so that we will apply our viewport and content

// dimensions.

markNeedsLayout();

}

/// {@template flutter.rendering.viewport.cacheExtent}

/// The viewport has an area before and after the visible area to cache items

/// that are about to become visible when the user scrolls.

///

/// Items that fall in this cache area are laid out even though they are not

/// (yet) visible on screen. The [cacheExtent] describes how many pixels

/// the cache area extends before the leading edge and after the trailing edge

/// of the viewport.

///

/// The total extent, which the viewport will try to cover with children, is

/// [cacheExtent] before the leading edge + extent of the main axis +

/// [cacheExtent] after the trailing edge.

///

/// The cache area is also used to implement implicit accessibility scrolling

/// on iOS: When the accessibility focus moves from an item in the visible

/// viewport to an invisible item in the cache area, the framework will bring

/// that item into view with an (implicit) scroll action.

/// {@endtemplate}

double get cacheExtent => _cacheExtent;

double _cacheExtent;

set cacheExtent(double value) {

value = value ?? RenderAbstractViewport.defaultCacheExtent;

assert(value != null);

if (value == _cacheExtent)

return;

_cacheExtent = value;

markNeedsLayout();

}

/// This value is set during layout based on the [CacheExtentStyle].

///

/// When the style is [CacheExtentStyle.viewport], it is the main axis extent

/// of the viewport multiplied by the requested cache extent, which is still

/// expressed in pixels.

double _calculatedCacheExtent;

/// {@template flutter.rendering.viewport.cacheExtentStyle}

/// Controls how the [cacheExtent] is interpreted.

///

/// If set to [CacheExtentStyle.pixels], the [cacheExtent] will be treated as

/// a logical pixels.

///

/// If set to [CacheExtentStyle.viewport], the [cacheExtent] will be treated

/// as a multiplier for the main axis extent of the viewport. In this case,

/// the [cacheExtent] must not be null.

/// {@endtemplate}

CacheExtentStyle get cacheExtentStyle => _cacheExtentStyle;

CacheExtentStyle _cacheExtentStyle;

set cacheExtentStyle(CacheExtentStyle value) {

assert(value != null);

if (value == _cacheExtentStyle) {

return;

}

_cacheExtentStyle = value;

markNeedsLayout();

}

@override

void attach(PipelineOwner owner) {

super.attach(owner);

_offset.addListener(markNeedsLayout);

}

@override

void detach() {

_offset.removeListener(markNeedsLayout);

super.detach();

}

/// Throws an exception saying that the object does not support returning

/// intrinsic dimensions if, in checked mode, we are not in the

/// [RenderObject.debugCheckingIntrinsics] mode.

///

/// This is used by [computeMinIntrinsicWidth] et al because viewports do not

/// generally support returning intrinsic dimensions. See the discussion at

/// [computeMinIntrinsicWidth].

@protected

bool debugThrowIfNotCheckingIntrinsics() {

assert(() {

if (!RenderObject.debugCheckingIntrinsics) {

assert(this is! RenderShrinkWrappingViewport); // it has its own message

throw FlutterError.fromParts(<DiagnosticsNode>[

ErrorSummary('$runtimeType does not support returning intrinsic dimensions.'),

ErrorDescription(

'Calculating the intrinsic dimensions would require instantiating every child of '

'the viewport, which defeats the point of viewports being lazy.',

),

ErrorHint(

'If you are merely trying to shrink-wrap the viewport in the main axis direction, '

'consider a RenderShrinkWrappingViewport render object (ShrinkWrappingViewport widget), '

'which achieves that effect without implementing the intrinsic dimension API.'

),

]);

}

return true;

}());

return true;

}

@override

double computeMinIntrinsicWidth(double height) {

assert(debugThrowIfNotCheckingIntrinsics());

return 0.0;

}

@override

double computeMaxIntrinsicWidth(double height) {

assert(debugThrowIfNotCheckingIntrinsics());

return 0.0;

}

@override

double computeMinIntrinsicHeight(double width) {

assert(debugThrowIfNotCheckingIntrinsics());

return 0.0;

}

@override

double computeMaxIntrinsicHeight(double width) {

assert(debugThrowIfNotCheckingIntrinsics());

return 0.0;

}

@override

bool get isRepaintBoundary => true;

/// Determines the size and position of some of the children of the viewport.

///

/// This function is the workhorse of `performLayout` implementations in

/// subclasses.

///

/// Layout starts with `child`, proceeds according to the `advance` callback,

/// and stops once `advance` returns null.

///

/// * `scrollOffset` is the [SliverConstraints.scrollOffset] to pass the

/// first child. The scroll offset is adjusted by

/// [SliverGeometry.scrollExtent] for subsequent children.

/// * `overlap` is the [SliverConstraints.overlap] to pass the first child.

/// The overlay is adjusted by the [SliverGeometry.paintOrigin] and

/// [SliverGeometry.paintExtent] for subsequent children.

/// * `layoutOffset` is the layout offset at which to place the first child.

/// The layout offset is updated by the [SliverGeometry.layoutExtent] for

/// subsequent children.

/// * `remainingPaintExtent` is [SliverConstraints.remainingPaintExtent] to

/// pass the first child. The remaining paint extent is updated by the

/// [SliverGeometry.layoutExtent] for subsequent children.

/// * `mainAxisExtent` is the [SliverConstraints.viewportMainAxisExtent] to

/// pass to each child.

/// * `crossAxisExtent` is the [SliverConstraints.crossAxisExtent] to pass to

/// each child.

/// * `growthDirection` is the [SliverConstraints.growthDirection] to pass to

/// each child.

///

/// Returns the first non-zero [SliverGeometry.scrollOffsetCorrection]

/// encountered, if any. Otherwise returns 0.0. Typical callers will call this

/// function repeatedly until it returns 0.0.

@protected

double layoutChildSequence({

@required RenderSliver child,

@required double scrollOffset,

@required double overlap,

@required double layoutOffset,

@required double remainingPaintExtent,

@required double mainAxisExtent,

@required double crossAxisExtent,

@required GrowthDirection growthDirection,

@required RenderSliver advance(RenderSliver child),

@required double remainingCacheExtent,

@required double cacheOrigin,

}) {

assert(scrollOffset.isFinite);

assert(scrollOffset >= 0.0);

final double initialLayoutOffset = layoutOffset;

final ScrollDirection adjustedUserScrollDirection =

applyGrowthDirectionToScrollDirection(offset.userScrollDirection, growthDirection);

assert(adjustedUserScrollDirection != null);

double maxPaintOffset = layoutOffset + overlap;

double precedingScrollExtent = 0.0;

while (child != null) {

final double sliverScrollOffset = scrollOffset <= 0.0 ? 0.0 : scrollOffset;

// If the scrollOffset is too small we adjust the paddedOrigin because it

// doesn't make sense to ask a sliver for content before its scroll

// offset.

final double correctedCacheOrigin = math.max(cacheOrigin, -sliverScrollOffset);

final double cacheExtentCorrection = cacheOrigin - correctedCacheOrigin;

assert(sliverScrollOffset >= correctedCacheOrigin.abs());

assert(correctedCacheOrigin <= 0.0);

assert(sliverScrollOffset >= 0.0);

assert(cacheExtentCorrection <= 0.0);

child.layout(SliverConstraints(

axisDirection: axisDirection,

growthDirection: growthDirection,

userScrollDirection: adjustedUserScrollDirection,

scrollOffset: sliverScrollOffset,

precedingScrollExtent: precedingScrollExtent,

overlap: maxPaintOffset - layoutOffset,

remainingPaintExtent: math.max(0.0, remainingPaintExtent - layoutOffset + initialLayoutOffset),

crossAxisExtent: crossAxisExtent,

crossAxisDirection: crossAxisDirection,

viewportMainAxisExtent: mainAxisExtent,

remainingCacheExtent: math.max(0.0, remainingCacheExtent + cacheExtentCorrection),

cacheOrigin: correctedCacheOrigin,

), parentUsesSize: true);

final SliverGeometry childLayoutGeometry = child.geometry;

assert(childLayoutGeometry.debugAssertIsValid());

// If there is a correction to apply, we'll have to start over.

if (childLayoutGeometry.scrollOffsetCorrection != null)

return childLayoutGeometry.scrollOffsetCorrection;

// We use the child's paint origin in our coordinate system as the

// layoutOffset we store in the child's parent data.

final double effectiveLayoutOffset = layoutOffset + childLayoutGeometry.paintOrigin;

// `effectiveLayoutOffset` becomes meaningless once we moved past the trailing edge

// because `childLayoutGeometry.layoutExtent` is zero. Using the still increasing

// 'scrollOffset` to roughly position these invisible slivers in the right order.

if (childLayoutGeometry.visible || scrollOffset > 0) {

updateChildLayoutOffset(child, effectiveLayoutOffset, growthDirection);

} else {

updateChildLayoutOffset(child, -scrollOffset + initialLayoutOffset, growthDirection);

}

maxPaintOffset = math.max(effectiveLayoutOffset + childLayoutGeometry.paintExtent, maxPaintOffset);

scrollOffset -= childLayoutGeometry.scrollExtent;

precedingScrollExtent += childLayoutGeometry.scrollExtent;

layoutOffset += childLayoutGeometry.layoutExtent;

if (childLayoutGeometry.cacheExtent != 0.0) {

remainingCacheExtent -= childLayoutGeometry.cacheExtent - cacheExtentCorrection;

cacheOrigin = math.min(correctedCacheOrigin + childLayoutGeometry.cacheExtent, 0.0);

}

updateOutOfBandData(growthDirection, childLayoutGeometry);

// move on to the next child

child = advance(child);

}

// we made it without a correction, whee!

return 0.0;

}

@override

Rect describeApproximatePaintClip(RenderSliver child) {

final Rect viewportClip = Offset.zero & size;

// The child's viewportMainAxisExtent can be infinite when a

// RenderShrinkWrappingViewport is given infinite constraints, such as when

// it is the child of a Row or Column (depending on orientation).

//

// For example, a shrink wrapping render sliver may have infinite

// constraints along the viewport's main axis but may also have bouncing

// scroll physics, which will allow for some scrolling effect to occur.

// We should just use the viewportClip - the start of the overlap is at

// double.infinity and so it is effectively meaningless.

if (child.constraints.overlap == 0 || !child.constraints.viewportMainAxisExtent.isFinite) {

return viewportClip;

}

// Adjust the clip rect for this sliver by the overlap from the previous sliver.

double left = viewportClip.left;

double right = viewportClip.right;

double top = viewportClip.top;

double bottom = viewportClip.bottom;

final double startOfOverlap = child.constraints.viewportMainAxisExtent - child.constraints.remainingPaintExtent;

final double overlapCorrection = startOfOverlap + child.constraints.overlap;

switch (applyGrowthDirectionToAxisDirection(axisDirection, child.constraints.growthDirection)) {

case AxisDirection.down:

top += overlapCorrection;

break;

case AxisDirection.up:

bottom -= overlapCorrection;

break;

case AxisDirection.right:

left += overlapCorrection;

break;

case AxisDirection.left:

right -= overlapCorrection;

break;

}

return Rect.fromLTRB(left, top, right, bottom);

}

@override

Rect describeSemanticsClip(RenderSliver child) {

assert(axis != null);

if (_calculatedCacheExtent == null) {

return semanticBounds;

}

switch (axis) {

case Axis.vertical:

return Rect.fromLTRB(

semanticBounds.left,

semanticBounds.top - _calculatedCacheExtent,

semanticBounds.right,

semanticBounds.bottom + _calculatedCacheExtent,

);

case Axis.horizontal:

return Rect.fromLTRB(

semanticBounds.left - _calculatedCacheExtent,

semanticBounds.top,

semanticBounds.right + _calculatedCacheExtent,

semanticBounds.bottom,

);

}

return null;

}

@override

void paint(PaintingContext context, Offset offset) {

if (firstChild == null)

return;

if (hasVisualOverflow) {

context.pushClipRect(needsCompositing, offset, Offset.zero & size, _paintContents);

} else {

_paintContents(context, offset);

}

}

void _paintContents(PaintingContext context, Offset offset) {

for (final RenderSliver child in childrenInPaintOrder) {

if (child.geometry.visible)

context.paintChild(child, offset + paintOffsetOf(child));

}

}

@override

void debugPaintSize(PaintingContext context, Offset offset) {

assert(() {

super.debugPaintSize(context, offset);

final Paint paint = Paint()

..style = PaintingStyle.stroke

..strokeWidth = 1.0

..color = const Color(0xFF00FF00);

final Canvas canvas = context.canvas;

RenderSliver child = firstChild;

while (child != null) {

Size size;

switch (axis) {

case Axis.vertical:

size = Size(child.constraints.crossAxisExtent, child.geometry.layoutExtent);

break;

case Axis.horizontal:

size = Size(child.geometry.layoutExtent, child.constraints.crossAxisExtent);

break;

}

assert(size != null);

canvas.drawRect(((offset + paintOffsetOf(child)) & size).deflate(0.5), paint);

child = childAfter(child);

}

return true;

}());

}

@override

bool hitTestChildren(BoxHitTestResult result, { Offset position }) {

double mainAxisPosition, crossAxisPosition;

switch (axis) {

case Axis.vertical:

mainAxisPosition = position.dy;

crossAxisPosition = position.dx;

break;

case Axis.horizontal:

mainAxisPosition = position.dx;

crossAxisPosition = position.dy;

break;

}

assert(mainAxisPosition != null);

assert(crossAxisPosition != null);

final SliverHitTestResult sliverResult = SliverHitTestResult.wrap(result);

for (final RenderSliver child in childrenInHitTestOrder) {

if (!child.geometry.visible) {

continue;

}

final Matrix4 transform = Matrix4.identity();

applyPaintTransform(child, transform);

final bool isHit = result.addWithPaintTransform(

transform: transform,

position: null, // Manually adapting from box to sliver position below.

hitTest: (BoxHitTestResult result, Offset _) {

return child.hitTest(

sliverResult,

mainAxisPosition: computeChildMainAxisPosition(child, mainAxisPosition),

crossAxisPosition: crossAxisPosition,

);

},

);

if (isHit) {

return true;

}

}

return false;

}

@override

RevealedOffset getOffsetToReveal(RenderObject target, double alignment, { Rect rect }) {

double leadingScrollOffset = 0.0;

double targetMainAxisExtent;

rect ??= target.paintBounds;

// Starting at `target` and walking towards the root:

// - `child` will be the last object before we reach this viewport, and

// - `pivot` will be the last RenderBox before we reach this viewport.

RenderObject child = target;

RenderBox pivot;

bool onlySlivers = target is RenderSliver; // ... between viewport and `target` (`target` included).

while (child.parent != this) {

final RenderObject parent = child.parent as RenderObject;

assert(parent != null, '$target must be a descendant of $this');

if (child is RenderBox) {

pivot = child;

}

if (parent is RenderSliver) {

leadingScrollOffset += parent.childScrollOffset(child);

} else {

onlySlivers = false;

leadingScrollOffset = 0.0;

}

child = parent;

}

if (pivot != null) {

assert(pivot.parent != null);

assert(pivot.parent != this);

assert(pivot != this);

assert(pivot.parent is RenderSliver); // TODO(abarth): Support other kinds of render objects besides slivers.

final RenderSliver pivotParent = pivot.parent as RenderSliver;

final Matrix4 transform = target.getTransformTo(pivot);

final Rect bounds = MatrixUtils.transformRect(transform, rect);

final GrowthDirection growthDirection = pivotParent.constraints.growthDirection;

switch (applyGrowthDirectionToAxisDirection(axisDirection, growthDirection)) {

case AxisDirection.up:

double offset;

switch (growthDirection) {

case GrowthDirection.forward:

offset = bounds.bottom;

break;

case GrowthDirection.reverse:

offset = bounds.top;

break;

}

leadingScrollOffset += pivot.size.height - offset;

targetMainAxisExtent = bounds.height;

break;

case AxisDirection.right:

double offset;

switch (growthDirection) {

case GrowthDirection.forward:

offset = bounds.left;

break;

case GrowthDirection.reverse:

offset = bounds.right;

break;

}

leadingScrollOffset += offset;

targetMainAxisExtent = bounds.width;

break;

case AxisDirection.down:

double offset;

switch (growthDirection) {

case GrowthDirection.forward:

offset = bounds.top;

break;

case GrowthDirection.reverse:

offset = bounds.bottom;

break;

}

leadingScrollOffset += offset;

targetMainAxisExtent = bounds.height;

break;

case AxisDirection.left:

double offset;

switch (growthDirection) {

case GrowthDirection.forward:

offset = bounds.right;

break;

case GrowthDirection.reverse:

offset = bounds.left;

break;

}

leadingScrollOffset += pivot.size.width - offset;

targetMainAxisExtent = bounds.width;

break;

}

} else if (onlySlivers) {

final RenderSliver targetSliver = target as RenderSliver;

targetMainAxisExtent = targetSliver.geometry.scrollExtent;

} else {

return RevealedOffset(offset: offset.pixels, rect: rect);

}

assert(child.parent == this);

assert(child is RenderSliver);

final RenderSliver sliver = child as RenderSliver;

final double extentOfPinnedSlivers = maxScrollObstructionExtentBefore(sliver);

leadingScrollOffset = scrollOffsetOf(sliver, leadingScrollOffset);

switch (sliver.constraints.growthDirection) {

case GrowthDirection.forward:

leadingScrollOffset -= extentOfPinnedSlivers;

break;

case GrowthDirection.reverse:

// Nothing to do.

break;

}

double mainAxisExtent;

switch (axis) {

case Axis.horizontal:

mainAxisExtent = size.width - extentOfPinnedSlivers;

break;

case Axis.vertical:

mainAxisExtent = size.height - extentOfPinnedSlivers;

break;

}

final double targetOffset = leadingScrollOffset - (mainAxisExtent - targetMainAxisExtent) * alignment;

final double offsetDifference = offset.pixels - targetOffset;

final Matrix4 transform = target.getTransformTo(this);

applyPaintTransform(child, transform);

Rect targetRect = MatrixUtils.transformRect(transform, rect);

switch (axisDirection) {

case AxisDirection.down:

targetRect = targetRect.translate(0.0, offsetDifference);

break;

case AxisDirection.right:

targetRect = targetRect.translate(offsetDifference, 0.0);

break;

case AxisDirection.up:

targetRect = targetRect.translate(0.0, -offsetDifference);

break;

case AxisDirection.left:

targetRect = targetRect.translate(-offsetDifference, 0.0);

break;

}

return RevealedOffset(offset: targetOffset, rect: targetRect);

}

/// The offset at which the given `child` should be painted.

///

/// The returned offset is from the top left corner of the inside of the

/// viewport to the top left corner of the paint coordinate system of the

/// `child`.

///

/// See also:

///

/// * [paintOffsetOf], which uses the layout offset and growth direction

/// computed for the child during layout.

@protected

Offset computeAbsolutePaintOffset(RenderSliver child, double layoutOffset, GrowthDirection growthDirection) {

assert(hasSize); // this is only usable once we have a size

assert(axisDirection != null);

assert(growthDirection != null);

assert(child != null);

assert(child.geometry != null);

switch (applyGrowthDirectionToAxisDirection(axisDirection, growthDirection)) {

case AxisDirection.up:

return Offset(0.0, size.height - (layoutOffset + child.geometry.paintExtent));

case AxisDirection.right:

return Offset(layoutOffset, 0.0);

case AxisDirection.down:

return Offset(0.0, layoutOffset);

case AxisDirection.left:

return Offset(size.width - (layoutOffset + child.geometry.paintExtent), 0.0);

}

return null;

}

@override

void debugFillProperties(DiagnosticPropertiesBuilder properties) {

super.debugFillProperties(properties);

properties.add(EnumProperty<AxisDirection>('axisDirection', axisDirection));

properties.add(EnumProperty<AxisDirection>('crossAxisDirection', crossAxisDirection));

properties.add(DiagnosticsProperty<ViewportOffset>('offset', offset));

}

@override

List<DiagnosticsNode> debugDescribeChildren() {

final List<DiagnosticsNode> children = <DiagnosticsNode>[];

RenderSliver child = firstChild;

if (child == null)

return children;

int count = indexOfFirstChild;

while (true) {

children.add(child.toDiagnosticsNode(name: labelForChild(count)));

if (child == lastChild)

break;

count += 1;

child = childAfter(child);

}

return children;

}

// API TO BE IMPLEMENTED BY SUBCLASSES

// setupParentData

// performLayout (and optionally sizedByParent and performResize)

/// Whether the contents of this viewport would paint outside the bounds of

/// the viewport if [paint] did not clip.

///

/// This property enables an optimization whereby [paint] can skip apply a

/// clip of the contents of the viewport are known to paint entirely within

/// the bounds of the viewport.

@protected

bool get hasVisualOverflow;

/// Called during [layoutChildSequence] for each child.

///

/// Typically used by subclasses to update any out-of-band data, such as the

/// max scroll extent, for each child.

@protected

void updateOutOfBandData(GrowthDirection growthDirection, SliverGeometry childLayoutGeometry);

/// Called during [layoutChildSequence] to store the layout offset for the

/// given child.

///

/// Different subclasses using different representations for their children's

/// layout offset (e.g., logical or physical coordinates). This function lets

/// subclasses transform the child's layout offset before storing it in the

/// child's parent data.

@protected

void updateChildLayoutOffset(RenderSliver child, double layoutOffset, GrowthDirection growthDirection);

/// The offset at which the given `child` should be painted.

///

/// The returned offset is from the top left corner of the inside of the

/// viewport to the top left corner of the paint coordinate system of the

/// `child`.

///

/// See also:

///

/// * [computeAbsolutePaintOffset], which computes the paint offset from an

/// explicit layout offset and growth direction instead of using the values

/// computed for the child during layout.

@protected

Offset paintOffsetOf(RenderSliver child);

/// Returns the scroll offset within the viewport for the given

/// `scrollOffsetWithinChild` within the given `child`.

///

/// The returned value is an estimate that assumes the slivers within the

/// viewport do not change the layout extent in response to changes in their

/// scroll offset.

@protected

double scrollOffsetOf(RenderSliver child, double scrollOffsetWithinChild);

/// Returns the total scroll obstruction extent of all slivers in the viewport

/// before [child].

///

/// This is the extent by which the actual area in which content can scroll

/// is reduced. For example, an app bar that is pinned at the top will reduce

/// the area in which content can actually scroll by the height of the app bar.

@protected

double maxScrollObstructionExtentBefore(RenderSliver child);

/// Converts the `parentMainAxisPosition` into the child's coordinate system.

///

/// The `parentMainAxisPosition` is a distance from the top edge (for vertical

/// viewports) or left edge (for horizontal viewports) of the viewport bounds.

/// This describes a line, perpendicular to the viewport's main axis, heretofor

/// known as the target line.

///

/// The child's coordinate system's origin in the main axis is at the leading

/// edge of the given child, as given by the child's

/// [SliverConstraints.axisDirection] and [SliverConstraints.growthDirection].

///

/// This method returns the distance from the leading edge of the given child to

/// the target line described above.

///

/// (The `parentMainAxisPosition` is not from the leading edge of the

/// viewport, it's always the top or left edge.)

@protected

double computeChildMainAxisPosition(RenderSliver child, double parentMainAxisPosition);

/// The index of the first child of the viewport relative to the center child.

///

/// For example, the center child has index zero and the first child in the

/// reverse growth direction has index -1.

@protected

int get indexOfFirstChild;

/// A short string to identify the child with the given index.

///

/// Used by [debugDescribeChildren] to label the children.

@protected

String labelForChild(int index);

/// Provides an iterable that walks the children of the viewport, in the order

/// that they should be painted.

///

/// This should be the reverse order of [childrenInHitTestOrder].

@protected

Iterable<RenderSliver> get childrenInPaintOrder;

/// Provides an iterable that walks the children of the viewport, in the order

/// that hit-testing should use.

///

/// This should be the reverse order of [childrenInPaintOrder].

@protected

Iterable<RenderSliver> get childrenInHitTestOrder;

@override

void showOnScreen({

RenderObject descendant,

Rect rect,

Duration duration = Duration.zero,

Curve curve = Curves.ease,

}) {

if (!offset.allowImplicitScrolling) {

return super.showOnScreen(

descendant: descendant,

rect: rect,

duration: duration,

curve: curve,

);

}

final Rect newRect = RenderViewportBase.showInViewport(

descendant: descendant,

viewport: this,

offset: offset,

rect: rect,

duration: duration,

curve: curve,

);

super.showOnScreen(

rect: newRect,

duration: duration,

curve: curve,