W_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 _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 ValueNotifierinfinityFlutterMemoryAllocationsinstancedispatchObjectCreatedlibrary classNameobject VoidCallbackmaptoListcall minExtent maxExtent initialExtentshouldCloseOnMinExtentdispatchdispatchObjectDisposed snapSizessnapAnimationDuration initialSize initStatewidget minChildSize maxChildSize controller_attachintindexlengthisEmptyfirstlastdidUpdateWidget_detachdidChangeDependencies shouldResetValueListenableBuildervalueListenablebuilder LayoutBuilderBoxConstraintsavailablePixels constraintsbiggestheightFractionallySizedBox heightFactor alignment Alignment bottomCenterchildexpandSizedBoxcopyWith_onExtentReplacedWidgetsBindingaddPostFrameCallback positions elementAt goBallistic debugLabelasMapkeystoStringPrimaryScrollController ScrollPhysics ScrollContextphysicsapplyToAlwaysScrollableScrollPhysics oldPosition getExtent_cancelActivityoffset millisecondsCurveslineardetachScrollActivityViewportScrollPositionWithSingleContextpixelsabsorb_dragCancelCallbackballisticController beginActivityisAtMinisAtMax addPixelDeltaapplyUserOffsetanysnapSizeabs toleranceFordistance SimulationinitialVelocity pixelSnapSizepixelSnapSizes toleranceClampingScrollSimulationvelocityobjectRuntimeTypesign isCompleted animateWithwhenCompleteOrCancelcontainsremoveDragDragStartDetailsdrag"dependOnInheritedWidgetOfExactType _sendResetnotifier hasListenersInheritedNotifier sendResetInheritedWidget _wasCalledinMillisecondsminmax indexWheresize ChangeNotifierStatefulWidget NotificationViewportNotificationMixinStateScrollControllerScrollPositionWithSingleContextInheritedNotifier Simulationj :!math$ dart:math,package:flutter/foundation.dartVpackage:flutter/gestures.dart basic.dart binding.dartframework.dartinherited_notifier.dartlayout_builder.dartnotification_listener.dart)scroll_activity.dartHscroll_context.dartfscroll_controller.dartscroll_notification.dartscroll_physics.dartscroll_position.dart(scroll_position_with_single_context.dartscroll_simulation.dart;value_listenable_builder.dart`o+<ՁCo *+U}~Â(Geǃ:bc*.}˅.SVWׇ&tMQ2̊?zʋ O $X\]ČUz̍Ѝю3U[]^59:ȑkՒ&r"JnՔDіBn'fHvݘz9?њכ%w(E\Ɲ4h uÞĞߞ`ßǟȠDHIۢ,Cߣ(^w}ʣTZ~˥CIlprsIM15X: W TGfJ*vzΰ Zj!B`}8]>?Jǵ9V\ 2OPN|(.к &pӺٻ'fܻ-3̼4н;w}ɿh@@E@n@o@@@A<AcAiAABBB^BBBBBCKCMCNCCCCDGDDEEjEEEF/F~FGGfGHHAHHHIITIIIIJJ=JXJJJJKK5K`KaKKKKLLL9LSLTLLLLLM?MMMMN-NiNoNNNNO"OOOOOOPP<PkPoPQ QQ`QdQQQRR-RHR`R}RRRRSS8SVStSSTT9TcTTUU2UqUUUUUUUVVV3VKV^V~VVVWW.W/WvWWWWX/X>XXY$YqYYYYZZZGZZZZ[#[Y[_[[\\I\f\\\\]]]`]]^^,^H^^^^____W_[_\___``2`l````aa?aYasaaaabbbbCbrbvbwbbbbbc c[cac}ccccccdd=dbddddddeeEeeeeffDf^f|ffffffg-gqgggggghh=hVh|hhi i'i{iiiij'j_jkk`kkllIl`l}llllm m)mwm~mmmmmn1nXnnnnnnnoo?o`ofojokowooopQppq"qIqxqqqqqr4r;r?r@rLr_rrrrrsss!s"shssstt*tPtttu uauuuv/vMvavvvw4w}wxxOxxy/yyyyyzzz6zzz{{:{D{c{l{|{|||||Y|~||}#}]}a}o}s}}~(~y~~ &'GklxI7d*Nm.GXe(QqQ"@DRV 7SoU+,iw}~ !U&*+7^{DQu{HQX\BHkBesy 3J3pT2;AB<=m5%E ?]ekl&e [EI6vzgB}$JYrxy n$5anpq/}V8>q!5;Riz~)*u w3v*OxR \,JK 0HX^swx-hcBzE|+:S[a%)+^/// @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';%+U~(Ge: W/// 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.A|8/// Creates a controller for [DraggableScrollableSheet].>:QNpT/// 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.Ӂ&/// 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.k s`؏Y/// Convert a sheet's pixel height to size (fractional value of parent container height). |d/// Reset the attached sheet to its initial size (see: [DraggableScrollableSheet.initialChildSize]).Ɓʁ}:K5Pb$yʤsٱp/// 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}J/// Creates a widget that can be dragged and scrolled in a single gesture.  %+FLdj"!0*=Zx@FZTGWekyl|³Գó׳; ,.67 Aցw/// 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`.뀯/// The minimum fractional value of the parent container's height to use when /// displaying the widget. /// /// The default value is `0.25`.A/// The maximum fractional value of the parent container's height to use when /// displaying the widget. /// /// The default value is `1.0`.RdB/// 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.2/// 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].򃕿~U/// 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].@W/// 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.@q{@I/// A controller that can be used to programmatically control this sheet.@A/// 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.BB/// 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.B^CBBCN{HG/// 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.HIIŀ/// 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].IIIIJJJ J/JAJPJ\"Jb%JzJJJJJJJJJJJJJJJJJJJJKJJKKKK2K&KK)K<KBK]KQKCKTKc_KI/// The current value of the extent, between [minExtent] and [maxExtent].KJL1/// The minimum value of [extent], which is >= 0.L;LH"/// The maximum value of [extent].LVLL//// The initially requested value for [extent].L4Mԁ/// 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.MNŀ/// 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.NNOONNO˗Q/// 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`.QQR RR%R1R@RLR[RdRsRRRRR"RRRRSS"S3S2S@SFSSSOSGSRS^SdSqSmSeSpS|SSSSSSSSSSSSSSSSSSSST TT&TT(T.T/TLTATYTNT\TvTkTTxT UV VV*V5VBVMVXV`VsV%VVVV!VV(WWWWxW}YYY2YY2YZ-Z$ZI=ZTZHZZց\-/// 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.] ]]]_^`9/// 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.`D`L`T`bbWb%b2 b:bySbb bbЀbcVccccccccdd d1dAdLdf"dldfޕ(fg/@g^gs"gggggiim0mm,mmmnnnnomoooomonrBrSrBrCs$s)s8,s\zz z"z'|~/// 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.~K~ )?I Wnno) r/6F./// 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]. 4;KWgsz!0N$QR<P=W*`0^KgZ(6G-Q>N V-., ćH}/// 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]).,G/// Creates a widget that can notify descendent [DraggableScrollableSheet]s /// to reset to their initial position. /// /// The [child] parameter is required.N U]l{/// This child's [DraggableScrollableSheet] descendant will be reset when the /// [reset] method is applied to a context that includes it."C/// 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.IW d8 qcw1%Nւ\/// A [ChangeNotifier] to use with [_InheritedResetNotifier] to notify /// descendants that they should reset to initial state. xc/// 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.D́,/// Creates an [InheritedNotifier] that the [DraggableScrollableSheet] will /// listen to for an indication that it should reset itself back to [DraggableScrollableSheet.initialChildSize].&+,耧/// Specifies whether the [DraggableScrollableSheet] should reset to its /// initial position. /// /// Returns true if the notifier requested a reset, false otherwise.NJc !.?S#j|".@)  k! ) zP z{΁J ȃ`c/// 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.&0!Bpackage:flutter/material.dart&package:flutter_test/flutter_test.dartprimary_scroll_controller.dartLscroll_configuration.dartxscroll_view.dartscrollable.dartsingle_child_scroll_view.dart viewport.dart<ՁCo *+U}~Â(Geǃ:bc*.}˅.SVWׇ&tMQ2̊?zʋ O $X\]ČUz̍Ѝю3U[]^59:ȑkՒ&r"JnՔDіBn'fHvݘz9?њכ%w(E\Ɲ4h uÞĞߞ`ßǟȠDHIۢ,Cߣ(^w}ʣTZ~˥CIlprsIM15X: W TGfJ*vzΰ Zj!B`}8]>?Jǵ9V\ 2OPN|(.к &pӺٻ'fܻ-3̼4н;w}ɿh@@E@n@o@@@A<AcAiAABBB^BBBBBCKCMCNCCCCDGDDEEjEEEF/F~FGGfGHHAHHHIITIIIIJJ=JXJJJJKK5K`KaKKKKLLL9LSLTLLLLLM?MMMMN-NiNoNNNNO"OOOOOOPP<PkPoPQ QQ`QdQQQRR-RHR`R}RRRRSS8SVStSSTT9TcTTUU2UqUUUUUUUVVV3VKV^V~VVVWW.W/WvWWWWX/X>XXY$YqYYYYZZZGZZZZ[#[Y[_[[\\I\f\\\\]]]`]]^^,^H^^^^____W_[_\___``2`l````aa?aYasaaaabbbbCbrbvbwbbbbbc c[cac}ccccccdd=dbddddddeeEeeeeffDf^f|ffffffg-gqgggggghh=hVh|hhi i'i{iiiij'j_jkk`kkllIl`l}llllm m)mwm~mmmmmn1nXnnnnnnnoo?o`ofojokowooopQppq"qIqxqqqqqr4r;r?r@rLr_rrrrrsss!s"shssstt*tPtttu uauuuv/vMvavvvw4w}wxxOxxy/yyyyyzzz6zzz{{:{D{c{l{|{|||||Y|~||}#}]}a}o}s}}~(~y~~ &'GklxI7d*Nm.GXe(QqQ"@DRV 7SoU+,iw}~ !U&*+7^{DQu{HQX\BHkBesy 3J3pT2;AB<=m5%E ?]ekl&e [EI6vzgB}$JYrxy n$5anpq/}V8>q!5;Riz~)*u w3v*OxR \,JK 0HX^swx-hcBzE|+:S[a%)+ DraggableScrollableControllerDraggableScrollableSheetDraggableScrollableNotification_DraggableSheetExtent_DraggableScrollableSheetState)_DraggableScrollableSheetScrollController'_DraggableScrollableSheetScrollPositionDraggableScrollableActuator!_DraggableScrollableActuatorState_ResetNotifier_InheritedResetNotifier_SnappingSimulation4R