// 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.

/// @docImport 'package:flutter/material.dart';

///

/// @docImport 'page_storage.dart';

/// @docImport 'page_view.dart';

/// @docImport 'scroll_metrics.dart';

/// @docImport 'scroll_notification.dart';

/// @docImport 'scroll_view.dart';

/// @docImport 'single_child_scroll_view.dart';

/// @docImport 'two_dimensional_scroll_view.dart';

/// @docImport 'two_dimensional_viewport.dart';

library;

import 'dart:async';

import 'dart:math' as math;

import 'package:flutter/foundation.dart';

import 'package:flutter/gestures.dart';

import 'package:flutter/rendering.dart';

import 'package:flutter/scheduler.dart';

import 'package:flutter/services.dart';

import 'basic.dart';

import 'framework.dart';

import 'gesture_detector.dart';

import 'media_query.dart';

import 'notification_listener.dart';

import 'restoration.dart';

import 'restoration_properties.dart';

import 'scroll_activity.dart';

import 'scroll_configuration.dart';

import 'scroll_context.dart';

import 'scroll_controller.dart';

import 'scroll_physics.dart';

import 'scroll_position.dart';

import 'scrollable_helpers.dart';

import 'selectable_region.dart';

import 'selection_container.dart';

import 'ticker_provider.dart';

import 'view.dart';

import 'viewport.dart';

export 'package:flutter/physics.dart' show Tolerance;

// Examples can assume:

// late BuildContext context;

/// Signature used by [Scrollable] to build the viewport through which the

/// scrollable content is displayed.

typedef ViewportBuilder = Widget Function(BuildContext context, ViewportOffset position);

/// Signature used by [TwoDimensionalScrollable] to build the viewport through

/// which the scrollable content is displayed.

typedef TwoDimensionalViewportBuilder =

Widget Function(

BuildContext context,

ViewportOffset verticalPosition,

ViewportOffset horizontalPosition,

);

// The return type of _performEnsureVisible.

//

// The list of futures represents each pending ScrollPosition call to

// ensureVisible. The returned ScrollableState's context is used to find the

// next potential ancestor Scrollable.

typedef _EnsureVisibleResults = (List<Future<void>>, ScrollableState);

/// A widget that manages scrolling in one dimension and informs the [Viewport]

/// through which the content is viewed.

///

/// [Scrollable] implements the interaction model for a scrollable widget,

/// including gesture recognition, but does not have an opinion about how the

/// viewport, which actually displays the children, is constructed.

///

/// It's rare to construct a [Scrollable] directly. Instead, consider [ListView]

/// or [GridView], which combine scrolling, viewporting, and a layout model. To

/// combine layout models (or to use a custom layout mode), consider using

/// [CustomScrollView].

///

/// The static [Scrollable.of] and [Scrollable.ensureVisible] functions are

/// often used to interact with the [Scrollable] widget inside a [ListView] or

/// a [GridView].

///

/// To further customize scrolling behavior with a [Scrollable]:

///

/// 1. You can provide a [viewportBuilder] to customize the child model. For

/// example, [SingleChildScrollView] uses a viewport that displays a single

/// box child whereas [CustomScrollView] uses a [Viewport] or a

/// [ShrinkWrappingViewport], both of which display a list of slivers.

///

/// 2. You can provide a custom [ScrollController] that creates a custom

/// [ScrollPosition] subclass. For example, [PageView] uses a

/// [PageController], which creates a page-oriented scroll position subclass

/// that keeps the same page visible when the [Scrollable] resizes.

///

/// ## Persisting the scroll position during a session

///

/// Scrollables attempt to persist their scroll position using [PageStorage].

/// This can be disabled by setting [ScrollController.keepScrollOffset] to false

/// on the [controller]. If it is enabled, using a [PageStorageKey] for the

/// [key] of this widget (or one of its ancestors, e.g. a [ScrollView]) is

/// recommended to help disambiguate different [Scrollable]s from each other.

///

/// See also:

///

/// * [ListView], which is a commonly used [ScrollView] that displays a

/// scrolling, linear list of child widgets.

/// * [PageView], which is a scrolling list of child widgets that are each the

/// size of the viewport.

/// * [GridView], which is a [ScrollView] that displays a scrolling, 2D array

/// of child widgets.

/// * [CustomScrollView], which is a [ScrollView] that creates custom scroll

/// effects using slivers.

/// * [SingleChildScrollView], which is a scrollable widget that has a single

/// child.

/// * [ScrollNotification] and [NotificationListener], which can be used to watch

/// the scroll position without using a [ScrollController].

class Scrollable extends StatefulWidget {

/// Creates a widget that scrolls.

const Scrollable({

super.key,

this.axisDirection = AxisDirection.down,

this.controller,

this.physics,

required this.viewportBuilder,

this.incrementCalculator,

this.excludeFromSemantics = false,

this.semanticChildCount,

this.dragStartBehavior = DragStartBehavior.start,

this.restorationId,

this.scrollBehavior,

this.clipBehavior = Clip.hardEdge,

this.hitTestBehavior = HitTestBehavior.opaque,

}) : assert(semanticChildCount == null || semanticChildCount >= 0);

/// {@template flutter.widgets.Scrollable.axisDirection}

/// The direction in which this widget scrolls.

///

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

/// increasing the scroll position will cause content below the bottom of the

/// viewport to become visible through the viewport. Similarly, if the

/// axisDirection is [AxisDirection.right], increasing the scroll position

/// will cause content beyond the right edge of the viewport to become visible

/// through the viewport.

///

/// Defaults to [AxisDirection.down].

/// {@endtemplate}

final AxisDirection axisDirection;

/// {@template flutter.widgets.Scrollable.controller}

/// An object that can be used to control the position to which this widget is

/// scrolled.

///

/// A [ScrollController] serves several purposes. It can be used to control

/// the initial scroll position (see [ScrollController.initialScrollOffset]).

/// It can be used to control whether the scroll view should automatically

/// save and restore its scroll position in the [PageStorage] (see

/// [ScrollController.keepScrollOffset]). It can be used to read the current

/// scroll position (see [ScrollController.offset]), or change it (see

/// [ScrollController.animateTo]).

///

/// If null, a [ScrollController] will be created internally by [Scrollable]

/// in order to create and manage the [ScrollPosition].

///

/// See also:

///

/// * [Scrollable.ensureVisible], which animates the scroll position to

/// reveal a given [BuildContext].

/// {@endtemplate}

final ScrollController? controller;

/// {@template flutter.widgets.Scrollable.physics}

/// How the widgets should respond to user input.

///

/// For example, determines how the widget continues to animate after the

/// user stops dragging the scroll view.

///

/// Defaults to matching platform conventions via the physics provided from

/// the ambient [ScrollConfiguration].

///

/// If an explicit [ScrollBehavior] is provided to

/// [Scrollable.scrollBehavior], the [ScrollPhysics] provided by that behavior

/// will take precedence after [Scrollable.physics].

///

/// The physics can be changed dynamically, but new physics will only take

/// effect if the _class_ of the provided object changes. Merely constructing

/// a new instance with a different configuration is insufficient to cause the

/// physics to be reapplied. (This is because the final object used is

/// generated dynamically, which can be relatively expensive, and it would be

/// inefficient to speculatively create this object each frame to see if the

/// physics should be updated.)

///

/// See also:

///

/// * [AlwaysScrollableScrollPhysics], which can be used to indicate that the

/// scrollable should react to scroll requests (and possible overscroll)

/// even if the scrollable's contents fit without scrolling being necessary.

/// {@endtemplate}

final ScrollPhysics? physics;

/// Builds the viewport through which the scrollable content is displayed.

///

/// A typical viewport uses the given [ViewportOffset] to determine which part

/// of its content is actually visible through the viewport.

///

/// See also:

///

/// * [Viewport], which is a viewport that displays a list of slivers.

/// * [ShrinkWrappingViewport], which is a viewport that displays a list of

/// slivers and sizes itself based on the size of the slivers.

final ViewportBuilder viewportBuilder;

/// {@template flutter.widgets.Scrollable.incrementCalculator}

/// An optional function that will be called to calculate the distance to

/// scroll when the scrollable is asked to scroll via the keyboard using a

/// [ScrollAction].

///

/// If not supplied, the [Scrollable] will scroll a default amount when a

/// keyboard navigation key is pressed (e.g. pageUp/pageDown, control-upArrow,

/// etc.), or otherwise invoked by a [ScrollAction].

///

/// If [incrementCalculator] is null, the default for

/// [ScrollIncrementType.page] is 80% of the size of the scroll window, and

/// for [ScrollIncrementType.line], 50 logical pixels.

/// {@endtemplate}

final ScrollIncrementCalculator? incrementCalculator;

/// {@template flutter.widgets.scrollable.excludeFromSemantics}

/// Whether the scroll actions introduced by this [Scrollable] are exposed

/// in the semantics tree.

///

/// Text fields with an overflow are usually scrollable to make sure that the

/// user can get to the beginning/end of the entered text. However, these

/// scrolling actions are generally not exposed to the semantics layer.

/// {@endtemplate}

///

/// See also:

///

/// * [GestureDetector.excludeFromSemantics], which is used to accomplish the

/// exclusion.

final bool excludeFromSemantics;

/// {@template flutter.widgets.scrollable.hitTestBehavior}

/// Defines the behavior of gesture detector used in this [Scrollable].

///

/// This defaults to [HitTestBehavior.opaque] which means it prevents targets

/// behind this [Scrollable] from receiving events.

/// {@endtemplate}

///

/// See also:

///

/// * [HitTestBehavior], for an explanation on different behaviors.

final HitTestBehavior hitTestBehavior;

/// The number of children that will contribute semantic information.

///

/// The value will be null if the number of children is unknown or unbounded.

///

/// Some subtypes of [ScrollView] can infer this value automatically. For

/// example [ListView] will use the number of widgets in the child list,

/// while the [ListView.separated] constructor will use half that amount.

///

/// For [CustomScrollView] and other types which do not receive a builder

/// or list of widgets, the child count must be explicitly provided.

///

/// See also:

///

/// * [CustomScrollView], for an explanation of scroll semantics.

/// * [SemanticsConfiguration.scrollChildCount], the corresponding semantics property.

final int? semanticChildCount;

// TODO(jslavitz): Set the DragStartBehavior default to be start across all widgets.

/// {@template flutter.widgets.scrollable.dragStartBehavior}

/// Determines the way that drag start behavior is handled.

///

/// If set to [DragStartBehavior.start], scrolling drag behavior will

/// begin at the position where the drag gesture won the arena. If set to

/// [DragStartBehavior.down] it will begin at the position where a down

/// event is first detected.

///

/// In general, setting this to [DragStartBehavior.start] will make drag

/// animation smoother and setting it to [DragStartBehavior.down] will make

/// drag behavior feel slightly more reactive.

///

/// By default, the drag start behavior is [DragStartBehavior.start].

///

/// See also:

///

/// * [DragGestureRecognizer.dragStartBehavior], which gives an example for

/// the different behaviors.

///

/// {@endtemplate}

final DragStartBehavior dragStartBehavior;

/// {@template flutter.widgets.scrollable.restorationId}

/// Restoration ID to save and restore the scroll offset of the scrollable.

///

/// If a restoration id is provided, the scrollable will persist its current

/// scroll offset and restore it during state restoration.

///

/// The scroll offset is persisted in a [RestorationBucket] claimed from

/// the surrounding [RestorationScope] using the provided restoration ID.

///

/// See also:

///

/// * [RestorationManager], which explains how state restoration works in

/// Flutter.

/// {@endtemplate}

final String? restorationId;

/// {@template flutter.widgets.scrollable.scrollBehavior}

/// A [ScrollBehavior] that will be applied to this widget individually.

///

/// Defaults to null, wherein the inherited [ScrollBehavior] is copied and

/// modified to alter the viewport decoration, like [Scrollbar]s.

///

/// [ScrollBehavior]s also provide [ScrollPhysics]. If an explicit

/// [ScrollPhysics] is provided in [physics], it will take precedence,

/// followed by [scrollBehavior], and then the inherited ancestor

/// [ScrollBehavior].

/// {@endtemplate}

final ScrollBehavior? scrollBehavior;

/// {@macro flutter.material.Material.clipBehavior}

///

/// Defaults to [Clip.hardEdge].

///

/// This is passed to decorators in [ScrollableDetails], and does not directly affect

/// clipping of the [Scrollable]. This reflects the same [Clip] that is provided

/// to [ScrollView.clipBehavior] and is supplied to the [Viewport].

final Clip clipBehavior;

/// The axis along which the scroll view scrolls.

///

/// Determined by the [axisDirection].

Axis get axis => axisDirectionToAxis(axisDirection);

@override

ScrollableState createState() => ScrollableState();

@override

void debugFillProperties(DiagnosticPropertiesBuilder properties) {

super.debugFillProperties(properties);

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

properties.add(DiagnosticsProperty<ScrollPhysics>('physics', physics));

properties.add(StringProperty('restorationId', restorationId));

}

/// The state from the closest instance of this class that encloses the given

/// context, or null if none is found.

///

/// Typical usage is as follows:

///

/// ```dart

/// ScrollableState? scrollable = Scrollable.maybeOf(context);

/// ```

///

/// Calling this method will create a dependency on the [ScrollableState]

/// that is returned, if there is one. This is typically the closest

/// [Scrollable], but may be a more distant ancestor if [axis] is used to

/// target a specific [Scrollable].

///

/// Using the optional [Axis] is useful when Scrollables are nested and the

/// target [Scrollable] is not the closest instance. When [axis] is provided,

/// the nearest enclosing [ScrollableState] in that [Axis] is returned, or

/// null if there is none.

///

/// This finds the nearest _ancestor_ [Scrollable] of the `context`. This

/// means that if the `context` is that of a [Scrollable], it will _not_ find

/// _that_ [Scrollable].

///

/// See also:

///

/// * [Scrollable.of], which is similar to this method, but asserts

/// if no [Scrollable] ancestor is found.

static ScrollableState? maybeOf(BuildContext context, {Axis? axis}) {

// This is the context that will need to establish the dependency.

final originalContext = context;

InheritedElement? element = context.getElementForInheritedWidgetOfExactType<_ScrollableScope>();

while (element != null) {

final ScrollableState scrollable = (element.widget as _ScrollableScope).scrollable;

if (axis == null || axisDirectionToAxis(scrollable.axisDirection) == axis) {

// Establish the dependency on the correct context.

originalContext.dependOnInheritedElement(element);

return scrollable;

}

context = scrollable.context;

element = context.getElementForInheritedWidgetOfExactType<_ScrollableScope>();

}

return null;

}

/// The state from the closest instance of this class that encloses the given

/// context.

///

/// Typical usage is as follows:

///

/// ```dart

/// ScrollableState scrollable = Scrollable.of(context);

/// ```

///

/// Calling this method will create a dependency on the [ScrollableState]

/// that is returned, if there is one. This is typically the closest

/// [Scrollable], but may be a more distant ancestor if [axis] is used to

/// target a specific [Scrollable].

///

/// Using the optional [Axis] is useful when Scrollables are nested and the

/// target [Scrollable] is not the closest instance. When [axis] is provided,

/// the nearest enclosing [ScrollableState] in that [Axis] is returned.

///

/// This finds the nearest _ancestor_ [Scrollable] of the `context`. This

/// means that if the `context` is that of a [Scrollable], it will _not_ find

/// _that_ [Scrollable].

///

/// If no [Scrollable] ancestor is found, then this method will assert in

/// debug mode, and throw an exception in release mode.

///

/// See also:

///

/// * [Scrollable.maybeOf], which is similar to this method, but returns null

/// if no [Scrollable] ancestor is found.

static ScrollableState of(BuildContext context, {Axis? axis}) {

final ScrollableState? scrollableState = maybeOf(context, axis: axis);

assert(() {

if (scrollableState == null) {

throw FlutterError.fromParts(<DiagnosticsNode>[

ErrorSummary(

'Scrollable.of() was called with a context that does not contain a '

'Scrollable widget.',

),

ErrorDescription(

'No Scrollable widget ancestor could be found '

'${axis == null ? '' : 'for the provided Axis: $axis '}'

'starting from the context that was passed to Scrollable.of(). This '

'can happen because you are using a widget that looks for a Scrollable '

'ancestor, but no such ancestor exists.\n'

'The context used was:\n'

' $context',

),

if (axis != null)

ErrorHint(

'When specifying an axis, this method will only look for a Scrollable '

'that matches the given Axis.',

),

]);

}

return true;

}());

return scrollableState!;

}

/// Provides a heuristic to determine if expensive frame-bound tasks should be

/// deferred for the [context] at a specific point in time.

///

/// Calling this method does _not_ create a dependency on any other widget.

/// This also means that the value returned is only good for the point in time

/// when it is called, and callers will not get updated if the value changes.

///

/// The heuristic used is determined by the [physics] of this [Scrollable]

/// via [ScrollPhysics.recommendDeferredLoading]. That method is called with

/// the current [ScrollPosition.activity]'s [ScrollActivity.velocity].

///

/// The optional [Axis] allows targeting of a specific [Scrollable] of that

/// axis, useful when Scrollables are nested. When [axis] is provided,

/// [ScrollPosition.recommendDeferredLoading] is called for the nearest

/// [Scrollable] in that [Axis].

///

/// If there is no [Scrollable] in the widget tree above the [context], this

/// method returns false.

static bool recommendDeferredLoadingForContext(BuildContext context, {Axis? axis}) {

_ScrollableScope? widget = context.getInheritedWidgetOfExactType<_ScrollableScope>();

while (widget != null) {

if (axis == null || axisDirectionToAxis(widget.scrollable.axisDirection) == axis) {

return widget.position.recommendDeferredLoading(context);

}

context = widget.scrollable.context;

widget = context.getInheritedWidgetOfExactType<_ScrollableScope>();

}

return false;

}

/// Scrolls all scrollables that enclose the given context so as to make the

/// given context visible.

///

/// If a [Scrollable] enclosing the provided [BuildContext] is a

/// [TwoDimensionalScrollable], both vertical and horizontal axes will ensure

/// the target is made visible.

static Future<void> ensureVisible(

BuildContext context, {

double alignment = 0.0,

Duration duration = Duration.zero,

Curve curve = Curves.ease,

ScrollPositionAlignmentPolicy alignmentPolicy = ScrollPositionAlignmentPolicy.explicit,

}) {

final futures = <Future<void>>[];

// The targetRenderObject is used to record the first target renderObject.

// If there are multiple scrollable widgets nested, the targetRenderObject

// is made to be as visible as possible to improve the user experience. If

// the targetRenderObject is already visible, then let the outer

// renderObject be as visible as possible.

//

// Also see https://github.com/flutter/flutter/issues/65100

RenderObject? targetRenderObject;

ScrollableState? scrollable = Scrollable.maybeOf(context);

while (scrollable != null) {

final List<Future<void>> newFutures;

(newFutures, scrollable) = scrollable._performEnsureVisible(

context.findRenderObject()!,

alignment: alignment,

duration: duration,

curve: curve,

alignmentPolicy: alignmentPolicy,

targetRenderObject: targetRenderObject,

);

futures.addAll(newFutures);

targetRenderObject ??= context.findRenderObject();

context = scrollable.context;

scrollable = Scrollable.maybeOf(context);

}

if (futures.isEmpty || duration == Duration.zero) {

return Future<void>.value();

}

if (futures.length == 1) {

return futures.single;

}

return Future.wait<void>(futures).then<void>((List<void> _) => null);

}

}

// Enable Scrollable.of() to work as if ScrollableState was an inherited widget.

// ScrollableState.build() always rebuilds its _ScrollableScope.

class _ScrollableScope extends InheritedWidget {

const _ScrollableScope({required this.scrollable, required this.position, required super.child});

final ScrollableState scrollable;

final ScrollPosition position;

@override

bool updateShouldNotify(_ScrollableScope old) {

return position != old.position;

}

}

/// State object for a [Scrollable] widget.

///

/// To manipulate a [Scrollable] widget's scroll position, use the object

/// obtained from the [position] property.

///

/// To be informed of when a [Scrollable] widget is scrolling, use a

/// [NotificationListener] to listen for [ScrollNotification] notifications.

///

/// This class is not intended to be subclassed. To specialize the behavior of a

/// [Scrollable], provide it with a [ScrollPhysics].

class ScrollableState extends State<Scrollable>

with TickerProviderStateMixin, RestorationMixin

implements ScrollContext {

// GETTERS

/// The manager for this [Scrollable] widget's viewport position.

///

/// To control what kind of [ScrollPosition] is created for a [Scrollable],

/// provide it with custom [ScrollController] that creates the appropriate

/// [ScrollPosition] in its [ScrollController.createScrollPosition] method.

ScrollPosition get position => _position!;

ScrollPosition? _position;

/// The resolved [ScrollPhysics] of the [ScrollableState].

ScrollPhysics? get resolvedPhysics => _physics;

ScrollPhysics? _physics;

/// An [Offset] that represents the absolute distance from the origin, or 0,

/// of the [ScrollPosition] expressed in the associated [Axis].

///

/// Used by [EdgeDraggingAutoScroller] to progress the position forward when a

/// drag gesture reaches the edge of the [Viewport].

Offset get deltaToScrollOrigin => switch (axisDirection) {

AxisDirection.up => Offset(0, -position.pixels),

AxisDirection.down => Offset(0, position.pixels),

AxisDirection.left => Offset(-position.pixels, 0),

AxisDirection.right => Offset(position.pixels, 0),

};

ScrollController get _effectiveScrollController =>

widget.controller ?? _fallbackScrollController!;

@override

AxisDirection get axisDirection => widget.axisDirection;

@override

TickerProvider get vsync => this;

@override

double get devicePixelRatio => _devicePixelRatio;

late double _devicePixelRatio;

@override

BuildContext? get notificationContext => _gestureDetectorKey.currentContext;

@override

BuildContext get storageContext => context;

@override

String? get restorationId => widget.restorationId;

final _RestorableScrollOffset _persistedScrollOffset = _RestorableScrollOffset();

late ScrollBehavior _configuration;

ScrollController? _fallbackScrollController;

DeviceGestureSettings? _mediaQueryGestureSettings;

// Only call this from places that will definitely trigger a rebuild.

void _updatePosition() {

_configuration = widget.scrollBehavior ?? ScrollConfiguration.of(context);

final ScrollPhysics? physicsFromWidget =

widget.physics ?? widget.scrollBehavior?.getScrollPhysics(context);

_physics = _configuration.getScrollPhysics(context);

_physics = physicsFromWidget?.applyTo(_physics) ?? _physics;

final ScrollPosition? oldPosition = _position;

if (oldPosition != null) {

_effectiveScrollController.detach(oldPosition);

// It's important that we not dispose the old position until after the

// viewport has had a chance to unregister its listeners from the old

// position. So, schedule a microtask to do it.

scheduleMicrotask(oldPosition.dispose);

}

_position = _effectiveScrollController.createScrollPosition(_physics!, this, oldPosition);

assert(_position != null);

_effectiveScrollController.attach(position);

}

@protected

@override

void restoreState(RestorationBucket? oldBucket, bool initialRestore) {

registerForRestoration(_persistedScrollOffset, 'offset');

assert(_position != null);

if (_persistedScrollOffset.value != null) {

position.restoreOffset(_persistedScrollOffset.value!, initialRestore: initialRestore);

}

}

@protected

@override

void saveOffset(double offset) {

assert(debugIsSerializableForRestoration(offset));

_persistedScrollOffset.value = offset;

// [saveOffset] is called after a scrolling ends and it is usually not

// followed by a frame. Therefore, manually flush restoration data.

ServicesBinding.instance.restorationManager.flushData();

}

@protected

@override

void initState() {

if (widget.controller == null) {

_fallbackScrollController = ScrollController();

}

super.initState();

}

@protected

@override

void didChangeDependencies() {

_mediaQueryGestureSettings = MediaQuery.maybeGestureSettingsOf(context);

_devicePixelRatio =

MediaQuery.maybeDevicePixelRatioOf(context) ?? View.of(context).devicePixelRatio;

_updatePosition();

super.didChangeDependencies();

}

bool _shouldUpdatePosition(Scrollable oldWidget) {

if ((widget.scrollBehavior == null) != (oldWidget.scrollBehavior == null)) {

return true;

}

if (widget.scrollBehavior != null &&

oldWidget.scrollBehavior != null &&

widget.scrollBehavior!.shouldNotify(oldWidget.scrollBehavior!)) {

return true;

}

ScrollPhysics? newPhysics = widget.physics ?? widget.scrollBehavior?.getScrollPhysics(context);

ScrollPhysics? oldPhysics =

oldWidget.physics ?? oldWidget.scrollBehavior?.getScrollPhysics(context);

do {

if (newPhysics?.runtimeType != oldPhysics?.runtimeType) {

return true;

}

newPhysics = newPhysics?.parent;

oldPhysics = oldPhysics?.parent;

} while (newPhysics != null || oldPhysics != null);

return widget.controller?.runtimeType != oldWidget.controller?.runtimeType;

}

@protected

@override

void didUpdateWidget(Scrollable oldWidget) {

super.didUpdateWidget(oldWidget);

if (widget.controller != oldWidget.controller) {

if (oldWidget.controller == null) {

// The old controller was null, meaning the fallback cannot be null.

// Dispose of the fallback.

assert(_fallbackScrollController != null);

assert(widget.controller != null);

_fallbackScrollController!.detach(position);

_fallbackScrollController!.dispose();

_fallbackScrollController = null;

} else {

// The old controller was not null, detach.

oldWidget.controller?.detach(position);

if (widget.controller == null) {

// If the new controller is null, we need to set up the fallback

// ScrollController.

_fallbackScrollController = ScrollController();

}

}

// Attach the updated effective scroll controller.

_effectiveScrollController.attach(position);

}

if (_shouldUpdatePosition(oldWidget)) {

_updatePosition();

}

}

@protected

@override

void dispose() {

if (widget.controller != null) {

widget.controller!.detach(position);

} else {

_fallbackScrollController?.detach(position);

_fallbackScrollController?.dispose();

}

position.dispose();

_persistedScrollOffset.dispose();

super.dispose();

}

// SEMANTICS

final GlobalKey _scrollSemanticsKey = GlobalKey();

@override

@protected

void setSemanticsActions(Set<SemanticsAction> actions) {

if (_gestureDetectorKey.currentState != null) {

_gestureDetectorKey.currentState!.replaceSemanticsActions(actions);

}

}

// GESTURE RECOGNITION AND POINTER IGNORING

final GlobalKey<RawGestureDetectorState> _gestureDetectorKey =

GlobalKey<RawGestureDetectorState>();

final GlobalKey _ignorePointerKey = GlobalKey();

// This field is set during layout, and then reused until the next time it is set.

Map<Type, GestureRecognizerFactory> _gestureRecognizers =

const <Type, GestureRecognizerFactory>{};

bool _shouldIgnorePointer = false;

bool? _lastCanDrag;

Axis? _lastAxisDirection;

@override

@protected

void setCanDrag(bool value) {

if (value == _lastCanDrag && (!value || widget.axis == _lastAxisDirection)) {

return;

}

if (!value) {

_gestureRecognizers = const <Type, GestureRecognizerFactory>{};

// Cancel the active hold/drag (if any) because the gesture recognizers

// will soon be disposed by our RawGestureDetector, and we won't be

// receiving pointer up events to cancel the hold/drag.

_handleDragCancel();

} else {

switch (widget.axis) {

case Axis.vertical:

_gestureRecognizers = <Type, GestureRecognizerFactory>{

VerticalDragGestureRecognizer:

GestureRecognizerFactoryWithHandlers<VerticalDragGestureRecognizer>(

() => VerticalDragGestureRecognizer(supportedDevices: _configuration.dragDevices),

(VerticalDragGestureRecognizer instance) {

instance

..onDown = _handleDragDown

..onStart = _handleDragStart

..onUpdate = _handleDragUpdate

..onEnd = _handleDragEnd

..onCancel = _handleDragCancel

..minFlingDistance = _physics?.minFlingDistance

..minFlingVelocity = _physics?.minFlingVelocity

..maxFlingVelocity = _physics?.maxFlingVelocity

..velocityTrackerBuilder = _configuration.velocityTrackerBuilder(context)

..dragStartBehavior = widget.dragStartBehavior

..multitouchDragStrategy = _configuration.getMultitouchDragStrategy(context)

..gestureSettings = _mediaQueryGestureSettings

..supportedDevices = _configuration.dragDevices;

},

),

};

case Axis.horizontal:

_gestureRecognizers = <Type, GestureRecognizerFactory>{

HorizontalDragGestureRecognizer:

GestureRecognizerFactoryWithHandlers<HorizontalDragGestureRecognizer>(

() =>

HorizontalDragGestureRecognizer(supportedDevices: _configuration.dragDevices),

(HorizontalDragGestureRecognizer instance) {

instance

..onDown = _handleDragDown

..onStart = _handleDragStart

..onUpdate = _handleDragUpdate

..onEnd = _handleDragEnd

..onCancel = _handleDragCancel

..minFlingDistance = _physics?.minFlingDistance

..minFlingVelocity = _physics?.minFlingVelocity

..maxFlingVelocity = _physics?.maxFlingVelocity

..velocityTrackerBuilder = _configuration.velocityTrackerBuilder(context)

..dragStartBehavior = widget.dragStartBehavior

..multitouchDragStrategy = _configuration.getMultitouchDragStrategy(context)

..gestureSettings = _mediaQueryGestureSettings

..supportedDevices = _configuration.dragDevices;

},

),

};

}

}

_lastCanDrag = value;

_lastAxisDirection = widget.axis;

if (_gestureDetectorKey.currentState != null) {

_gestureDetectorKey.currentState!.replaceGestureRecognizers(_gestureRecognizers);

}

}

@override

@protected

void setIgnorePointer(bool value) {

if (_shouldIgnorePointer == value) {

return;

}

_shouldIgnorePointer = value;

if (_ignorePointerKey.currentContext != null) {

final renderBox =

_ignorePointerKey.currentContext!.findRenderObject()! as RenderIgnorePointer;

renderBox.ignoring = _shouldIgnorePointer;

}

}

// TOUCH HANDLERS

Drag? _drag;

ScrollHoldController? _hold;

void _handleDragDown(DragDownDetails details) {

assert(_drag == null);

assert(_hold == null);

_hold = position.hold(_disposeHold);

}

void _handleDragStart(DragStartDetails details) {

// It's possible for _hold to become null between _handleDragDown and

// _handleDragStart, for example if some user code calls jumpTo or otherwise

// triggers a new activity to begin.

assert(_drag == null);

_drag = position.drag(details, _disposeDrag);

assert(_drag != null);

// _hold might be non-null if the scroll position is currently animating.

if (_hold != null) {

_disposeHold();

}

}

void _handleDragUpdate(DragUpdateDetails details) {

// _drag might be null if the drag activity ended and called _disposeDrag.

assert(_hold == null || _drag == null);

_drag?.update(details);

}

void _handleDragEnd(DragEndDetails details) {

// _drag might be null if the drag activity ended and called _disposeDrag.

assert(_hold == null || _drag == null);

_drag?.end(details);

assert(_drag == null);

}

void _handleDragCancel() {

if (_gestureDetectorKey.currentContext == null) {

// The cancel was caused by the GestureDetector getting disposed, which

// means we will get disposed momentarily as well and shouldn't do

// any work.

return;

}

// _hold might be null if the drag started.

// _drag might be null if the drag activity ended and called _disposeDrag.

assert(_hold == null || _drag == null);

_hold?.cancel();

_drag?.cancel();

assert(_hold == null);

assert(_drag == null);

}

void _disposeHold() {

_hold = null;

}

void _disposeDrag() {

_drag = null;

}

// SCROLL WHEEL

// Returns the offset that should result from applying [event] to the current

// position, taking min/max scroll extent into account.

double _targetScrollOffsetForPointerScroll(double delta) {

return math.min(

math.max(position.pixels + delta, position.minScrollExtent),

position.maxScrollExtent,

);

}

// Returns the delta that should result from applying [event] with axis,

// direction, and any modifiers specified by the ScrollBehavior taken into

// account.

double _pointerSignalEventDelta(PointerScrollEvent event) {

final Set<LogicalKeyboardKey> pressed = HardwareKeyboard.instance.logicalKeysPressed;

final bool flipAxes =

pressed.any(_configuration.pointerAxisModifiers.contains) &&

// Axes are only flipped for physical mouse wheel input.

// On some platforms, like web, trackpad input is handled through pointer

// signals, but should not be included in this axis modifying behavior.

// This is because on a trackpad, all directional axes are available to

// the user, while mouse scroll wheels typically are restricted to one

// axis.

event.kind == PointerDeviceKind.mouse;

final Axis axis = flipAxes ? flipAxis(widget.axis) : widget.axis;

final double delta = switch (axis) {

Axis.horizontal => event.scrollDelta.dx,

Axis.vertical => event.scrollDelta.dy,

};

return axisDirectionIsReversed(widget.axisDirection) ? -delta : delta;

}

void _receivedPointerSignal(PointerSignalEvent event) {

if (event is PointerScrollEvent && _position != null) {

if (_physics != null && !_physics!.shouldAcceptUserOffset(position)) {

return;

}

final double delta = _pointerSignalEventDelta(event);

final double targetScrollOffset = _targetScrollOffsetForPointerScroll(delta);

// Only express interest in the event if it would actually result in a scroll.

if (delta != 0.0 && targetScrollOffset != position.pixels) {

GestureBinding.instance.pointerSignalResolver.register(event, _handlePointerScroll);

return;

}

} else if (event is PointerScrollInertiaCancelEvent) {

position.pointerScroll(0);

// Don't use the pointer signal resolver, all hit-tested scrollables should stop.

}

}

void _handlePointerScroll(PointerEvent event) {

assert(event is PointerScrollEvent);

final scrollEvent = event as PointerScrollEvent;

final double delta = _pointerSignalEventDelta(scrollEvent);

final double targetScrollOffset = _targetScrollOffsetForPointerScroll(delta);

if (delta != 0.0 && targetScrollOffset != position.pixels) {

position.pointerScroll(delta);

// Tell engine this scrollable handled the event.

// This prevents parent page from scrolling when nested scrollables exist.

scrollEvent.respond(allowPlatformDefault: false);

}

}

bool _handleScrollMetricsNotification(ScrollMetricsNotification notification) {

if (notification.depth == 0) {

final RenderObject? scrollSemanticsRenderObject = _scrollSemanticsKey.currentContext

?.findRenderObject();

if (scrollSemanticsRenderObject != null) {

scrollSemanticsRenderObject.markNeedsSemanticsUpdate();

}

}

return false;

}

Widget _buildChrome(BuildContext context, Widget child) {

final details = ScrollableDetails(

direction: widget.axisDirection,

controller: _effectiveScrollController,

decorationClipBehavior: widget.clipBehavior,

);