library;

import 'dart:math' as math;

import 'package:flutter/gestures.dart';

import 'package:flutter/rendering.dart';

import 'basic.dart';

import 'debug.dart';

import 'focus_manager.dart';

import 'focus_scope.dart';

import 'framework.dart';

import 'media_query.dart';

import 'notification_listener.dart';

import 'primary_scroll_controller.dart';

import 'scroll_configuration.dart';

import 'scroll_controller.dart';

import 'scroll_delegate.dart';

import 'scroll_notification.dart';

import 'scroll_physics.dart';

import 'scrollable.dart';

import 'scrollable_helpers.dart';

import 'sliver.dart';

import 'sliver_prototype_extent_list.dart';

import 'viewport.dart';

enum ScrollViewKeyboardDismissBehavior {

/// `manual` means there is no automatic dismissal of the on-screen keyboard.

manual,

/// `onDrag` means that the [ScrollView] will dismiss an on-screen keyboard

onDrag,

}

abstract class ScrollView extends StatelessWidget {

/// Creates a widget that scrolls.

const ScrollView({

super.key,

this.scrollDirection = Axis.vertical,

this.reverse = false,

this.controller,

this.primary,

ScrollPhysics? physics,

this.scrollBehavior,

this.shrinkWrap = false,

this.center,

this.anchor = 0.0,

@Deprecated(

'Use scrollCacheExtent instead. '

'This feature was deprecated after v3.41.0-0.0.pre.',

)

this.cacheExtent,

this.scrollCacheExtent,

this.semanticChildCount,

this.paintOrder = SliverPaintOrder.firstIsTop,

this.dragStartBehavior = DragStartBehavior.start,

this.keyboardDismissBehavior,

this.restorationId,

this.clipBehavior = Clip.hardEdge,

this.hitTestBehavior = HitTestBehavior.opaque,

}) : assert(

!(controller != null && (primary ?? false)),

'Primary ScrollViews obtain their ScrollController via inheritance '

'from a PrimaryScrollController widget. You cannot both set primary to '

'true and pass an explicit controller.',

),

assert(!shrinkWrap || center == null),

assert(anchor >= 0.0 && anchor <= 1.0),

assert(semanticChildCount == null || semanticChildCount >= 0),

physics =

physics ??

((primary ?? false) ||

(primary == null &&

controller == null &&

identical(scrollDirection, Axis.vertical))

? const AlwaysScrollableScrollPhysics()

: null);

/// {@template flutter.widgets.scroll_view.scrollDirection}

final Axis scrollDirection;

/// {@template flutter.widgets.scroll_view.reverse}

final bool reverse;

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

final ScrollController? controller;

/// {@template flutter.widgets.scroll_view.primary}

final bool? primary;

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

final ScrollPhysics? physics;

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

final ScrollBehavior? scrollBehavior;

/// {@template flutter.widgets.scroll_view.shrinkWrap}

final bool shrinkWrap;

/// The first child in the [GrowthDirection.forward] growth direction.

final Key? center;

/// {@template flutter.widgets.scroll_view.anchor}

// TODO(framework): Replace the following block with a @dartpad directive

// when it's supported. https://github.com/dart-lang/dartdoc/issues/4123

/// <small>

final double anchor;

/// {@macro flutter.rendering.RenderViewportBase.cacheExtent}

@Deprecated(

'Use scrollCacheExtent instead. '

'This feature was deprecated after v3.41.0-0.0.pre.',

)

final double? cacheExtent;

/// {@macro flutter.rendering.RenderViewportBase.scrollCacheExtent}

final ScrollCacheExtent? scrollCacheExtent;

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

final int? semanticChildCount;

/// {@macro flutter.rendering.RenderViewportBase.paintOrder}

final SliverPaintOrder paintOrder;

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

final DragStartBehavior dragStartBehavior;

/// {@template flutter.widgets.scroll_view.keyboardDismissBehavior}

final ScrollViewKeyboardDismissBehavior? keyboardDismissBehavior;

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

final String? restorationId;

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

final Clip clipBehavior;

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

final HitTestBehavior hitTestBehavior;

/// Returns the [AxisDirection] in which the scroll view scrolls.

@protected

AxisDirection getDirection(BuildContext context) {

return getAxisDirectionFromAxisReverseAndDirectionality(context, scrollDirection, reverse);

}

/// Build the list of widgets to place inside the viewport.

@protected

List<Widget> buildSlivers(BuildContext context);

/// Build the viewport.

@protected

Widget buildViewport(

BuildContext context,

ViewportOffset offset,

AxisDirection axisDirection,

List<Widget> slivers,

) {

assert(() {

switch (axisDirection) {

case AxisDirection.up:

case AxisDirection.down:

return debugCheckHasDirectionality(

context,

why: 'to determine the cross-axis direction of the scroll view',

hint:

'Vertical scroll views create Viewport widgets that try to determine their cross axis direction '

'from the ambient Directionality.',

);

case AxisDirection.left:

case AxisDirection.right:

return true;

}

}());

final ScrollCacheExtent? effectiveScrollCacheExtent =

scrollCacheExtent ?? (cacheExtent != null ? ScrollCacheExtent.pixels(cacheExtent!) : null);

if (shrinkWrap) {

return ShrinkWrappingViewport(

axisDirection: axisDirection,

offset: offset,

slivers: slivers,

paintOrder: paintOrder,

clipBehavior: clipBehavior,

scrollCacheExtent: effectiveScrollCacheExtent,

);

}

return Viewport(

axisDirection: axisDirection,

offset: offset,

slivers: slivers,

scrollCacheExtent: effectiveScrollCacheExtent,

center: center,

anchor: anchor,

paintOrder: paintOrder,

clipBehavior: clipBehavior,

);

}

@override

Widget build(BuildContext context) {

final List<Widget> slivers = buildSlivers(context);

final AxisDirection axisDirection = getDirection(context);

final bool effectivePrimary =

primary ??

controller == null && PrimaryScrollController.shouldInherit(context, scrollDirection);

final ScrollController? scrollController = effectivePrimary

? PrimaryScrollController.maybeOf(context)

: controller;

final scrollable = Scrollable(

dragStartBehavior: dragStartBehavior,

axisDirection: axisDirection,

controller: scrollController,

physics: physics,

scrollBehavior: scrollBehavior,

semanticChildCount: semanticChildCount,

restorationId: restorationId,

hitTestBehavior: hitTestBehavior,

viewportBuilder: (BuildContext context, ViewportOffset offset) {

return buildViewport(context, offset, axisDirection, slivers);

},

clipBehavior: clipBehavior,

);

final Widget scrollableResult = effectivePrimary && scrollController != null

// Further descendant ScrollViews will not inherit the same PrimaryScrollController

? PrimaryScrollController.none(child: scrollable)

: scrollable;

final ScrollViewKeyboardDismissBehavior effectiveKeyboardDismissBehavior =

keyboardDismissBehavior ??

scrollBehavior?.getKeyboardDismissBehavior(context) ??

ScrollConfiguration.of(context).getKeyboardDismissBehavior(context);

if (effectiveKeyboardDismissBehavior == ScrollViewKeyboardDismissBehavior.onDrag) {

return NotificationListener<ScrollUpdateNotification>(

child: scrollableResult,

onNotification: (ScrollUpdateNotification notification) {

final FocusScopeNode currentScope = FocusScope.of(context);

if (notification.dragDetails != null &&

!currentScope.hasPrimaryFocus &&

currentScope.hasFocus) {

FocusManager.instance.primaryFocus?.unfocus();

}

return false;

},

);

} else {

return scrollableResult;

}

}

@override

void debugFillProperties(DiagnosticPropertiesBuilder properties) {

super.debugFillProperties(properties);

properties.add(EnumProperty<Axis>('scrollDirection', scrollDirection));

properties.add(FlagProperty('reverse', value: reverse, ifTrue: 'reversed', showName: true));

properties.add(

DiagnosticsProperty<ScrollController>(

'controller',

controller,

showName: false,

defaultValue: null,

),

);

properties.add(

FlagProperty('primary', value: primary, ifTrue: 'using primary controller', showName: true),

);

properties.add(

DiagnosticsProperty<ScrollPhysics>('physics', physics, showName: false, defaultValue: null),

);

properties.add(

FlagProperty('shrinkWrap', value: shrinkWrap, ifTrue: 'shrink-wrapping', showName: true),

);

properties.add(

DiagnosticsProperty<ScrollCacheExtent>(

'scrollCacheExtent',

scrollCacheExtent,

defaultValue: null,

),

);

}

}

class CustomScrollView extends ScrollView {

/// Creates a [ScrollView] that combines multiple slivers in one scrollable

const CustomScrollView({

super.key,

super.scrollDirection,

super.reverse,

super.controller,

super.primary,

super.physics,

super.scrollBehavior,

super.shrinkWrap,

super.center,

super.anchor,

@Deprecated(

'Use scrollCacheExtent instead. '

'This feature was deprecated after v3.41.0-0.0.pre.',

)

super.cacheExtent,

super.scrollCacheExtent,

super.paintOrder,

this.slivers = const <Widget>[],

super.semanticChildCount,

super.dragStartBehavior,

super.keyboardDismissBehavior,

super.restorationId,

super.clipBehavior,

super.hitTestBehavior,

});

/// The slivers to place inside the viewport.

final List<Widget> slivers;

@override

List<Widget> buildSlivers(BuildContext context) => slivers;

}

abstract class BoxScrollView extends ScrollView {

/// Creates a [ScrollView] uses a single child layout model.

const BoxScrollView({

super.key,

super.scrollDirection,

super.reverse,

super.controller,

super.primary,

super.physics,

super.shrinkWrap,

this.padding,

@Deprecated(

'Use scrollCacheExtent instead. '

'This feature was deprecated after v3.41.0-0.0.pre.',

)

super.cacheExtent,

super.scrollCacheExtent,

super.semanticChildCount,

super.dragStartBehavior,

super.keyboardDismissBehavior,

super.restorationId,

super.clipBehavior,

super.hitTestBehavior,

});

/// The amount of space by which to inset the children.

final EdgeInsetsGeometry? padding;

@override

List<Widget> buildSlivers(BuildContext context) {

Widget sliver = buildChildLayout(context);

EdgeInsetsGeometry? effectivePadding = padding;

if (padding == null) {

final MediaQueryData? mediaQuery = MediaQuery.maybeOf(context);

if (mediaQuery != null) {

// Automatically pad sliver with padding from MediaQuery.

final EdgeInsets mediaQueryHorizontalPadding = mediaQuery.padding.copyWith(

top: 0.0,

bottom: 0.0,

);

final EdgeInsets mediaQueryVerticalPadding = mediaQuery.padding.copyWith(

left: 0.0,

right: 0.0,

);

// Consume the main axis padding with SliverPadding.

effectivePadding = scrollDirection == Axis.vertical

? mediaQueryVerticalPadding

: mediaQueryHorizontalPadding;

// Leave behind the cross axis padding.

sliver = MediaQuery(

data: mediaQuery.copyWith(

padding: scrollDirection == Axis.vertical

? mediaQueryHorizontalPadding

: mediaQueryVerticalPadding,

),

child: sliver,

);

}

}

if (effectivePadding != null) {

sliver = SliverPadding(padding: effectivePadding, sliver: sliver);

}

return <Widget>[sliver];

}

/// Subclasses should override this method to build the layout model.

@protected

Widget buildChildLayout(BuildContext context);

@override

void debugFillProperties(DiagnosticPropertiesBuilder properties) {

super.debugFillProperties(properties);

properties.add(DiagnosticsProperty<EdgeInsetsGeometry>('padding', padding, defaultValue: null));

}

}