X_attachedController_animationControllerssizepixels sizeToPixels isAttached pixelsToSize animateTojumpToreset_assertAttached_attach_onExtentReplaced_detach_disposeAnimationControllersinitialChildSize minChildSize maxChildSizeexpandsnap snapSizessnapAnimationDuration controllershouldCloseOnMinExtentbuilder createStateextent minExtent maxExtent initialExtentcontextdebugFillDescription_cancelActivityminSizemaxSize initialSize _currentSizeavailablePixels hasDragged hasChangedisAtMinisAtMax currentSize currentPixelspixelSnapSizes startActivity addPixelDelta updateSizedisposecopyWith_scrollController_extent initState_impliedSnapSizesdidUpdateWidgetdidChangeDependenciesbuild_replaceExtent_snapSizeErrorMessageonPositionDetachedcreateScrollPositionpositiondetach_dragCancelCallback getExtent_ballisticControllerslistShouldScrollabsorb beginActivityapplyUserOffset_getCurrentSnapSize _isAtSnapSize _shouldSnap goBallisticdragchild _notifier _wasCalled sendReset _sendReset shouldResetvelocity minimumSpeed_pixelSnapSizedxisDonex _getSnapSize ScrollableWidgetBuilderDraggableScrollableControllerDraggableScrollableSheetDraggableScrollableNotification_DraggableSheetExtent_DraggableScrollableSheetState)_DraggableScrollableSheetScrollController'_DraggableScrollableSheetScrollPositionDraggableScrollableActuator!_DraggableScrollableActuatorState_ResetNotifier_InheritedResetNotifier_SnappingSimulation BuildContextScrollControllerAxisscrollController ScrollViewSingleChildScrollViewListViewGridViewWidgetStatebuild ListenableChangeNotifier kFlutterMemoryAllocationsEnabledmaybeDispatchObjectCreationSetAnimationControllerdoubleextent currentSize currentPixels sizeToPixelsScrollPositionbool hasClients pixelsToSizesnapFuture WidgetTester pumpAndSettlevoidDurationCurvedurationzero unboundedvsyncpositioncontextvalueaddgoIdle hasDragged hasChanged startActivity onCanceled isAnimatingstop addListener updateSizenotificationContext animateTo clampDoubleminSizemaxSizecurveinitialChildSizereset _currentSizenotifyListenersonPositionDetached disposeExtentdisposeremoveListeneranimationControllerclear ScrollablejumpToListTileScaffoldScrollBehaviorPointerDeviceKindmouse dragDevicesStatefulWidgetCenterListoverride NotificationNotificationListenerdepthsetStateFloatingActionButtonViewportNotificationMixinStringdebugFillDescription ValueNotifierinfinitydebugMaybeDispatchCreated VoidCallbackmaptoListcall minExtent maxExtent initialExtentshouldCloseOnMinExtentdispatchdebugMaybeDispatchDisposed snapSizessnapAnimationDuration initialSize initStatewidget minChildSize maxChildSize controller_attachindexlengthisEmptyfirstlastdidUpdateWidget_detachdidChangeDependencies shouldResetValueListenableBuildervalueListenablebuilder LayoutBuilderBoxConstraintsavailablePixels constraintsbiggestheightFractionallySizedBox heightFactor alignment Alignment bottomCenterchildexpandSizedBoxcopyWith_onExtentReplacedWidgetsBindinginstanceaddPostFrameCallback positions elementAt goBallistic debugLabelintasMapkeystoStringPrimaryScrollController ScrollPhysics ScrollContextphysicsapplyToAlwaysScrollableScrollPhysics oldPosition getExtent_cancelActivityoffset millisecondsCurveslineardetachScrollActivityViewportScrollPositionWithSingleContextpixelsabsorb_dragCancelCallbackballisticController beginActivityisAtMinisAtMax addPixelDeltaapplyUserOffsetfirstWhereOrNullsnapSizeabs toleranceFordistance SimulationinitialVelocity pixelSnapSizepixelSnapSizes toleranceClampingScrollSimulationvelocityobjectRuntimeTypesign isCompleted animateWithwhenCompleteOrCancelcontainsremoveDragDragStartDetailsdrag"dependOnInheritedWidgetOfExactType _sendResetnotifier hasListenersInheritedNotifier sendResetInheritedWidget _wasCalledinMillisecondsminmax indexWheresize ChangeNotifierStatefulWidget NotificationViewportNotificationMixinStateScrollControllerScrollPositionWithSingleContextInheritedNotifier Simulation3s9Bq03math3 dart:math="package:collection/collection.dartkpackage:flutter/foundation.dartpackage:flutter/gestures.dart basic.dart binding.dartframework.dart inherited_notifier.dart,layout_builder.dartKnotification_listener.dartqscroll_activity.dartscroll_context.dartscroll_controller.dartscroll_notification.dartscroll_physics.dartscroll_position.dart5(scroll_position_with_single_context.dartiscroll_simulation.dartvalue_listenable_builder.dartd=ځKx:SSSTT-THTdTTTTTU!U8UOUxUUUVVNVyVVW W%W'WIWKWdW}WWWWXXLXgXiXXXYY%YoYYZZhZZZZ[*[`[b[[[\"\$\t\\]]S]d]]]]]^3^m^t^_ _F_q___``7`O`p`````aa5a<aaab(bVbeblbbbbc c.cGc~cccccccd$dRdWdYdmdddddee e9e_eeeefff8fKfhffgg-gXggggh.h6h;h>h@hhhhi i!i9i_iiiij&jSjjjk"k'k)kOkkkl4llllmNmXm_mmn1n8nNnno oooo&onooop)p0pPpUpWpdpppqq qqq qHqtqqrErrrs*sEsSssssssstttBt\tjttttttu/ujuuuuvvYvvvwwqwwxxCxbxzxxyHyyz3zgz{{"{^{{{|| |||F||}}:}C}a}s}}}~~~V~|~~$_dsx0)+Lqs"WN|68JoTn %'4^g;Z_ns*Wt+~2\^CJOQ^;Binp}"Q%Tw5>CEGmtJy(IKr%IxM 5R&CK =$r+QvFf09@B[v3]hsxz#Rg JO?YLNGgn@w]`b%ty{X CJ~5JQi7 >@'TF)Fl v03:?A[z|>@Mi 8t$BIbgif O C(/o^/// @docImport 'package:flutter/material.dart'; /// @docImport 'package:flutter_test/flutter_test.dart'; /// /// @docImport 'primary_scroll_controller.dart'; /// @docImport 'scroll_configuration.dart'; /// @docImport 'scroll_view.dart'; /// @docImport 'scrollable.dart'; /// @docImport 'single_child_scroll_view.dart'; /// @docImport 'viewport.dart';3<j+Jp4h 8/// Creates a controller for [DraggableScrollableSheet].>N{T/// Get the current size (as a fraction of the parent height) of the attached sheet.ٌـ7/// Get the current pixel height of the attached sheet.YY&/// Returns Whether any [DraggableScrollableController] objects have attached themselves to the /// [DraggableScrollableSheet]. /// /// If this is false, then members that interact with the [ScrollPosition], /// such as [sizeToPixels], [size], [animateTo], and [jumpTo], must not be /// called.  S/// Convert a sheet's size (fractional value of parent container height) to pixels.__ fRY/// Convert a sheet's pixel height to size (fractional value of parent container height).00 7>>PZZiАЉ& /// Animates the attached sheet from its current size to the given [size], a /// fractional value of the parent container's height. /// /// Any active sheet animation is canceled. If the sheet's internal scrollable /// is currently animating (e.g. responding to a user fling), that animation is /// canceled as well. /// /// An animation will be interrupted whenever the user attempts to scroll /// manually, whenever another activity is started, or when the sheet hits its /// max or min size (e.g. if you animate to 1 but the max size is .8, the /// animation will stop playing when it reaches .8). /// /// The duration must not be zero. To jump to a particular value without an /// animation, use [jumpTo]. /// /// The sheet will not snap after calling [animateTo] even if [DraggableScrollableSheet.snap] /// is true. Snapping only occurs after user drags. /// /// When calling [animateTo] in widget tests, `await`ing the returned /// [Future] may cause the test to hang and timeout. Instead, use /// [WidgetTester.pumpAndSettle]. rr[/// Jumps the attached sheet from its current size to the given [size], a /// fractional value of the parent container's height. /// /// If [size] is outside of a the attached sheet's min or max child size, /// [jumpTo] will jump the sheet to the nearest valid size instead. /// /// Any active sheet animation is canceled. If the sheet's inner scrollable /// is currently animating (e.g. responding to a user fling), that animation is /// canceled as well. /// /// The sheet will not snap after calling [jumpTo] even if [DraggableScrollableSheet.snap] /// is true. Snapping only occurs after user drags.fd/// Reset the attached sheet to its initial size (see: [DraggableScrollableSheet.initialChildSize]).̠:tt$]]?bŤ%ͥ̀q/// Controls a [DraggableScrollableSheet]. /// /// Draggable scrollable controllers are typically stored as member variables in /// [State] objects and are reused in each [State.build]. Controllers can only /// be used to control one sheet at a time. A controller can be reused with a /// new sheet if the previous sheet has been disposed. /// /// The controller's methods cannot be used until after the controller has been /// passed into a [DraggableScrollableSheet] and the sheet has run initState. /// /// A [DraggableScrollableController] is a [Listenable]. It notifies its /// listeners whenever an attached sheet changes sizes. It does not notify its /// listeners when a sheet is first attached or when an attached sheet's /// parameters change without affecting the sheet's current size. It does not /// fire when [pixels] changes without [size] changing. For example, if the /// constraints provided to an attached sheet change.`x ѳ %55:VV[ll"q*Ƴδȴ˴ٴߴ%06WH7Kbhi J/// Creates a widget that can be dragged and scrolled in a single gesture. TTw/// The initial fractional value of the parent container's height to use when /// displaying the widget. /// /// Rebuilding the sheet with a new [initialChildSize] will only move /// the sheet to the new value if the sheet has not yet been dragged since it /// was first built or since the last call to [DraggableScrollableActuator.reset]. /// /// The default value is `0.5`.k/// The minimum fractional value of the parent container's height to use when /// displaying the widget. /// /// The default value is `0.25`.˸%ˀ/// The maximum fractional value of the parent container's height to use when /// displaying the widget. /// /// The default value is `1.0`.DށlDB/// Whether the widget should expand to fill the available space in its parent /// or not. /// /// In most cases, this should be true. However, in the case of a parent /// widget that will position this one based on its desired size (such as a /// [Center]), this should be set to false. /// /// The default value is true.Q@/// Whether the widget should snap between [snapSizes] when the user lifts /// their finger during a drag. /// /// If the user's finger was still moving when they lifted it, the widget will /// snap to the next snap size (see [snapSizes]) in the direction of the drag. /// If their finger was still, the widget will snap to the nearest snap size. /// /// Snapping is not applied when the sheet is programmatically moved by /// calling [DraggableScrollableController.animateTo] or [DraggableScrollableController.jumpTo]. /// /// Rebuilding the sheet with snap newly enabled will immediately trigger a /// snap unless the sheet has not yet been dragged away from /// [initialChildSize] since first being built or since the last call to /// [DraggableScrollableActuator.reset].A5A5U/// A list of target sizes that the widget should snap to. /// /// Snap sizes are fractional values of the parent container's height. They /// must be listed in increasing order and be between [minChildSize] and /// [maxChildSize]. /// /// The [minChildSize] and [maxChildSize] are implicitly included in snap /// sizes and do not need to be specified here. For example, `snapSizes = [.5]` /// will result in a sheet that snaps between [minChildSize], `.5`, and /// [maxChildSize]. /// /// Any modifications to the [snapSizes] list will not take effect until the /// `build` function containing this widget is run again. /// /// Rebuilding with a modified or new list will trigger a snap unless the /// sheet has not yet been dragged away from [initialChildSize] since first /// being built or since the last call to [DraggableScrollableActuator.reset].BAEB/// Defines a duration for the snap animations. /// /// If it's not set, then the animation duration is the distance to the snap /// target divided by the velocity of the widget.BB0|BI/// A controller that can be used to programmatically control this sheet.CB"C/// Whether the sheet, when dragged (or flung) to its minimum size, should /// cause its parent sheet to close. /// /// Set on emitted [DraggableScrollableNotification]s. It is up to parent /// classes to properly read and handle this value.DC܀D/// The builder that creates a child to display in this widget, which will /// use the provided [ScrollController] to enable dragging and scrolling /// of the contents.DDDD_Dy׋/// A container for a [Scrollable] that responds to drag gestures by resizing /// the scrollable until a limit is reached, and then scrolling. /// /// {@youtube 560 315 https://www.youtube.com/watch?v=Hgw819mL_78} /// /// This widget can be dragged along the vertical axis between its /// [minChildSize], which defaults to `0.25` and [maxChildSize], which defaults /// to `1.0`. These sizes are percentages of the height of the parent container. /// /// The widget coordinates resizing and scrolling of the widget returned by /// builder as the user drags along the horizontal axis. /// /// The widget will initially be displayed at its initialChildSize which /// defaults to `0.5`, meaning half the height of its parent. Dragging will work /// between the range of minChildSize and maxChildSize (as percentages of the /// parent container's height) as long as the builder creates a widget which /// uses the provided [ScrollController]. If the widget created by the /// [ScrollableWidgetBuilder] does not use the provided [ScrollController], the /// sheet will remain at the initialChildSize. /// /// By default, the widget will stay at whatever size the user drags it to. To /// make the widget snap to specific sizes whenever they lift their finger /// during a drag, set [snap] to `true`. The sheet will snap between /// [minChildSize] and [maxChildSize]. Use [snapSizes] to add more sizes for /// the sheet to snap between. /// /// The snapping effect is only applied on user drags. Programmatically /// manipulating the sheet size via [DraggableScrollableController.animateTo] or /// [DraggableScrollableController.jumpTo] will ignore [snap] and [snapSizes]. /// /// By default, the widget will expand its non-occupied area to fill available /// space in the parent. If this is not desired, e.g. because the parent wants /// to position sheet based on the space it is taking, the [expand] property /// may be set to false. /// /// {@tool dartpad} /// /// This is a sample widget which shows a [ListView] that has 25 [ListTile]s. /// It starts out as taking up half the body of the [Scaffold], and can be /// dragged up to the full height of the scaffold or down to 25% of the height /// of the scaffold. Upon reaching full height, the list contents will be /// scrolled up or down, until they reach the top of the list again and the user /// drags the sheet back down. /// /// On desktop and web running on desktop platforms, dragging to scroll with a mouse is disabled by default /// to align with the natural behavior found in other desktop applications. /// /// This behavior is dictated by the [ScrollBehavior], and can be changed by adding /// [PointerDeviceKind.mouse] to [ScrollBehavior.dragDevices]. /// For more info on this, please refer to https://docs.flutter.dev/release/breaking-changes/default-scroll-behavior-drag /// /// Alternatively, this example illustrates how to add a drag handle for desktop applications. /// /// ** See code in examples/api/lib/widgets/draggable_scrollable_sheet/draggable_scrollable_sheet.0.dart ** /// {@end-tool}KKKKKKKKKKLLLLL2L2L@LNLN"LS%LlLzLLLLLLLLLLLLLLLLLLLMLLLMMM)MMM M4M:MUMIM;MLJJ/// Creates a notification that the extent of a [DraggableScrollableSheet] has /// changed. /// /// All parameters are required. The [minExtent] must be >= 0. The [maxExtent] /// must be <= 1.0. The [extent] must be between [minExtent] and [maxExtent].MM]`MI/// The current value of the extent, between [minExtent] and [maxExtent].NMKN1/// The minimum value of [extent], which is >= 0.NIN<NI"/// The maximum value of [extent].NNYMN//// The initially requested value for [extent].ON9O߁/// The build context of the widget that fired this notification. /// /// This can be used to find the sheet's render objects to determine the size /// of the viewport, for instance. A listener can only assume this context /// is live when it first gets the notification.POPր/// Whether the widget that fired this notification, when dragged (or flung) /// to minExtent, should cause its parent sheet to close. /// /// It is up to parent classes to properly read and handle this value.QQQ'PPPPQE E J-/// A [Notification] related to the extent, which is the size, and scroll /// offset, which is the position of the child list, of the /// [DraggableScrollableSheet]. /// /// [DraggableScrollableSheet] widgets notify their ancestors when the size of /// the sheet changes. When the extent of the sheet changes via a drag, /// this notification bubbles up through the tree, which means a given /// [NotificationListener] will receive notifications for all descendant /// [DraggableScrollableSheet] widgets. To focus on notifications from the /// nearest [DraggableScrollableSheet] descendant, check that the [depth] /// property of the notification is zero. /// /// When an extent notification is received by a [NotificationListener], the /// listener will already have completed build and layout, and it is therefore /// too late for that widget to call [State.setState]. Any attempt to adjust the /// build or layout based on an extent notification would result in a layout /// that lagged one frame behind, which is a poor user experience. Extent /// notifications are used primarily to drive animations. The [Scaffold] widget /// listens for extent notifications and responds by driving animations for the /// [FloatingActionButton] as the bottom sheet scrolls up.T/TD TLTLTZThThTvTTTTTTTTTTTTTT"UU%U%U+U<U<UBUSUS"UX3UqUUUUUUUUUUUUUUUUUUUUVUUUVV V&VV)V6V=V7V>VJV?VeVUVgVmVnVVVVVVVVVVT/T/ W7W)W7WZWMWZWsWfWsWWWWWWWW%WWWWXW!XX=X!(X=XUXNXUXXXZZZZZ2Z[,[,2[5[d[d-[o[[=[[[H[]z]z ]\&\&]k-/// Start an activity that affects the sheet and register a cancel call back /// that will be called if another activity starts. /// /// The `onCanceled` callback will get called even if the subsequent activity /// started after this one finished, so `onCanceled` must be safe to call at /// any time.__ _&_-_-_:]]_/// The scroll position gets inputs in terms of pixels, but the size is /// expected to be expressed as a number between 0..1. /// /// This should only be called to respond to a user drag. To update the /// size in response to a programmatic call, use [updateSize] directly.aaaaaa``̂a/// Set the size to the new value. [newSize] should be a number between /// [minSize] and [maxSize]. /// /// This can be triggered by a programmatic (e.g. controller triggered) change /// or a user drag.cc cccYcdd dddUdd[d[ad`dddeeee$e$e2e=e=eSececesee(eee$eddƒwdQQHT/// Manages state between [_DraggableScrollableSheetState], /// [_DraggableScrollableSheetScrollController], and /// [_DraggableScrollableSheetScrollPosition]. /// /// The State knows the pixels available along the axis the widget wants to /// scroll, but expects to get a fraction of those pixels to render the sheet. /// /// The ScrollPosition knows the number of pixels a user wants to move the sheet. /// /// The [currentSize] will never be null. /// The [availablePixels] will never be null, but may be `double.infinity`.hh@hhh"hiiii%ik+k+k8o=o=,o`oooo8o-pYpZpYpYpkq/q/q<qqqqq)ssssttt,u!tt$t|1|1|5|||h@h@hFBC-C\N \ uvuu11> ::?BBQ)*))v;~~/// A [ScrollController] suitable for use in a [ScrollableWidgetBuilder] created /// by a [DraggableScrollableSheet]. /// /// If a [DraggableScrollableSheet] contains content that is exceeds the height /// of its container, this controller will allow the sheet to both be dragged to /// fill the container and then scroll the child content. /// /// See also: /// /// * [_DraggableScrollableSheetScrollPosition], which manages the positioning logic for /// this controller. /// * [PrimaryScrollController], which can be used to establish a /// [_DraggableScrollableSheetScrollController] as the primary controller for /// descendants.,S[[jxx,,!0yzdxeL-NL*0 gssSTSSe rsrr_VV^GG6LKԀ|}||ׂ/// A scroll position that manages scroll activities for /// [_DraggableScrollableSheetScrollController]. /// /// This class is a concrete subclass of [ScrollPosition] logic that handles a /// single [ScrollContext], such as a [Scrollable]. An instance of this class /// manages [ScrollActivity] instances, which changes the /// [_DraggableSheetExtent.currentSize] or visible content offset in the /// [Scrollable]'s [Viewport] /// /// See also: /// /// * [_DraggableScrollableSheetScrollController], which uses this as its [ScrollPosition]. ')) /44B[[/// Creates a widget that can notify descendent [DraggableScrollableSheet]s /// to reset to their initial position. /// /// The [child] parameter is required.P/// This child's [DraggableScrollableSheet] descendant will be reset when the /// [reset] method is applied to a context that includes it.''4!/// Notifies any descendant [DraggableScrollableSheet] that it should reset /// to its initial position. /// /// Returns `true` if a [DraggableScrollableActuator] is available and /// some [DraggableScrollableSheet] is listening for updates, `false` /// otherwise.e&#}/// A widget that can notify a descendent [DraggableScrollableSheet] that it /// should reset its position to the initial state. /// /// The [Scaffold] uses this widget to notify a persistent bottom sheet that /// the user has tapped back if the sheet has started to cover more of the body /// than when at its initial position. This is important for users of assistive /// technology, where dragging may be difficult to communicate. /// /// This is just a wrapper on top of [DraggableScrollableController]. It is /// primarily useful for controlling a sheet in a part of the widget tree that /// the current code does not control (e.g. library code trying to affect a sheet /// in library users' code). Generally, it's easier to control the sheet /// directly by creating a controller and passing the controller to the sheet in /// its constructor (see [DraggableScrollableSheet.controller]).1 }~}}Rbbphc/// Whether someone called [sendReset] or not. /// /// This flag should be reset after checking it. _/// Fires a reset notification to descendants. /// /// Returns false if there are no listeners.ւ^/// A [ChangeNotifier] to use with [_InheritedResetNotifier] to notify /// descendants that they should reset to initial state.&!/// Creates an [InheritedNotifier] that the [DraggableScrollableSheet] will /// listen to for an indication that it should reset itself back to [DraggableScrollableSheet.initialChildSize].+BB/// Specifies whether the [DraggableScrollableSheet] should reset to its /// initial position. /// /// Returns true if the notifier requested a reset, false otherwise.?%--;JJZpp#+PCPo]o)- -YY `BCBBqV S(( /S&..5FFS!D/// The signature of a method that provides a [BuildContext] and /// [ScrollController] for building a widget that may overflow the draggable /// [Axis] of the containing [DraggableScrollableSheet]. /// /// Users should apply the [scrollController] to a [ScrollView] subclass, such /// as a [SingleChildScrollView], [ListView] or [GridView], to have the whole /// sheet be draggable.package:flutter/material.dart&package:flutter_test/flutter_test.dart"primary_scroll_controller.dartTscroll_configuration.dartscroll_view.dartscrollable.dartsingle_child_scroll_view.dart viewport.dart=ځKx:SSSTT-THTdTTTTTU!U8UOUxUUUVVNVyVVW W%W'WIWKWdW}WWWWXXLXgXiXXXYY%YoYYZZhZZZZ[*[`[b[[[\"\$\t\\]]S]d]]]]]^3^m^t^_ _F_q___``7`O`p`````aa5a<aaab(bVbeblbbbbc c.cGc~cccccccd$dRdWdYdmdddddee e9e_eeeefff8fKfhffgg-gXggggh.h6h;h>h@hhhhi i!i9i_iiiij&jSjjjk"k'k)kOkkkl4llllmNmXm_mmn1n8nNnno oooo&onooop)p0pPpUpWpdpppqq qqq qHqtqqrErrrs*sEsSssssssstttBt\tjttttttu/ujuuuuvvYvvvwwqwwxxCxbxzxxyHyyz3zgz{{"{^{{{|| |||F||}}:}C}a}s}}}~~~V~|~~$_dsx0)+Lqs"WN|68JoTn %'4^g;Z_ns*Wt+~2\^CJOQ^;Binp}"Q%Tw5>CEGmtJy(IKr%IxM 5R&CK =$r+QvFf09@B[v3]hsxz#Rg JO?YLNGgn@w]`b%ty{X CJ~5JQi7 >@'TF)Fl v03:?A[z|>@Mi 8t$BIbgif O C(/o DraggableScrollableControllerDraggableScrollableSheetDraggableScrollableNotification_DraggableSheetExtent_DraggableScrollableSheetState)_DraggableScrollableSheetScrollController'_DraggableScrollableSheetScrollPositionDraggableScrollableActuator!_DraggableScrollableActuatorState_ResetNotifier_InheritedResetNotifier_SnappingSimulationB