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 _sendResetnotifierInheritedResetNotifier hasListenersInheritedNotifier sendResetInheritedWidget _wasCalledinMillisecondsminmax indexWheresize ChangeNotifierStatefulWidget NotificationViewportNotificationMixinStateScrollControllerScrollPositionWithSingleContextInheritedNotifier SimulationP?R- C`math dart:mathpackage:flutter/foundation.dartpackage:flutter/gestures.dart basic.dart5 binding.dartMframework.dartginherited_notifier.dartlayout_builder.dartnotification_listener.dartscroll_activity.dartscroll_context.dartscroll_controller.dart0scroll_notification.dartTscroll_physics.dartsscroll_position.dart(scroll_position_with_single_context.dartscroll_simulation.dartvalue_listenable_builder.dartcn=ƀȀ4Lf΁ /SrƂU݃2΄ ?D5mrÇaJΉ HmӉډ߉$wyъ38:uۋ9_w@GMOԎ*/1gԑ&s!(ǓUzʓ 0X&[ۖDݗ 09BlA՘ݘ1kr \Țϛ-dIvߝNSUϝ -:MkؠQ9A¢ܢ4bpȣ><~ǥ̦a?D/}ũFK-{;0~R?_dѯ#x38 TƱֱ5Nf{۲CvUszõjq '.Rprö )+}߸.]dh ]ȻWϻ#*yżܼ0νO@OMOOP*P/P2P4PqPPPQ)QyQ~QQRRNRmRRRRRSS8SaSxSSSSTTHTTTUUWUUUV/V]VtV~VVVVVVVVWWAW^WWWWXX*X,X{XXXY.Y}YZZCZWZYZZZZ[9[;[[[\\\h\\]]#]F]K]M]]]^$^o^^^__b______`(`-`/`z```a aEaaaaabb9bTbpbbbbccc,c\caccccccccdNdUdrdwdyddddee:e`eeeeeeffKflffggOgjggggggghAhhhhhhii5iZitiijjBjJjjjjkkPkklHlllm8mzmmmmmmnEnbnnnnnoo<oroooooop p-pQpppppppqqIqqrCryrrrrsCsOsYssssssstttItPtrttttuu9u^uuuvv-v5vvwwOwqwwwx7x`xixyyPyyz!zuz{{C{N{{{{{||2|~||||}}}x}}}}}~ ~%~v~w&; "/pNg+TY[h>^/=q2Spuxz;.3BG+He}R02p#%2g=BDQy!drq{Nt{O~ -NPw*N}R:W?\d%V=*PuFT).0==BEGnR?^ e/6~ v279FZtDZ9UW $<NSVXf Wpw^ycEoO ] 5TV'C\mtN#<AC@p3y Ecs29fkn4Lf /Sr ֈԃ/// 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.ωJJg8/// Creates a controller for [DraggableScrollableSheet].>&NEErs]q^{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.&/// 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. ҌBBS/// Convert a sheet's size (fractional value of parent container height) to pixels.O WVQ܎Y/// Convert a sheet's pixel height to size (fractional value of parent container height). 3 /// 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]. kkk[/// 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.r zyWd/// Reset the attached sheet to its initial size (see: [DraggableScrollableSheet.initialChildSize]).$$,:WV?$%Ϥ~!!/// 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}VJ/// Creates a widget that can be dragged and scrolled in a single gesture. ! 9?>RXWjpo"*/G^Բ%+?9,= 0. The [maxExtent] /// must be <= 1.0. The [extent] must be between [minExtent] and [maxExtent].JJJJ#J2J1JAJPJOJ_JnJmJJJJ"JJ%JJJJJJJJJKJJJK KK'KKK!K2K8KSKCK9KFK^KdKxKlKeKoKKKKKKK`LLI/// The current value of the extent, between [minExtent] and [maxExtent].LKLULU1/// The minimum value of [extent], which is >= 0.Le<LL"/// The maximum value of [extent].LMLL//// The initially requested value for [extent].L9N.N./// 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.N<O%O%/// 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.OBOTOTOiOwOvOBOCP4RTRT/// 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`.RoRoRoR RRRRRRRRRRRRRS S SS!S S<"STSSSeSlSkS|SSS"SS3SSSSSSSSSSSSSSTTT TTT'T-TDT:T.T=T]TPTkT_TnT{TT|TTTTTTTTTTTTTTTU TU VVVVVVVVVVVVVW W W%W)W)WCWPWPW`!WkWkW(WWWWWXXXZEZJZJZ[2ZdZdZ2ZZZ-ZZZ=[[[=H[N[N[\\Ё-/// 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.\ \\]O^v^v/// 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.^ ^^^^^`1aa/// 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.aa$a#a,a:a9cYc c c c"c!ceUclclcy cccccd{odddddddddddde e ee-e,e>eIeHed"ejeieggghC@hrhrh"hhh%hhhhj܃jjn8nnn,oonnpppppppppppppssssstttt,tt{ {{{{{}AA/// 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.M  ]]^$YYt$%v&%z/// 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].'/?>L\[ipo!0N  MN8L9T*]]0Kg'99GXW'(F[XXh poFGۀn2DDI[Zcqp23Gك}/// 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])./// Creates a widget that can notify descendent [DraggableScrollableSheet]s /// to reset to their initial position. /// /// The [child] parameter is required. /// This child's [DraggableScrollableSheet] descendant will be reset when the /// [reset] method is applied to a context that includes it./// 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 p&&x1;RMM;<~/// A [ChangeNotifier] to use with [InheritedResetNotifier] to notify /// descendants that they should reset to initial state.FFFT΀@@c/// Whether someone called [sendReset] or not. /// /// This flag should be reset after checking it.MY_/// Fires a reset notification to descendants. /// /// Returns false if there are no listeners.X]^^1nn/// 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.,#43I#`_s~}**7II) q003 ;:S S  u .-/// 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.!=ƀȀ4Lf΁ /SrƂU݃2΄ ?D5mrÇaJΉ HmӉډ߉$wyъ38:uۋ9_w@GMOԎ*/1gԑ&s!(ǓUzʓ 0X&[ۖDݗ 09BlA՘ݘ1kr \Țϛ-dIvߝNSUϝ -:MkؠQ9A¢ܢ4bpȣ><~ǥ̦a?D/}ũFK-{;0~R?_dѯ#x38 TƱֱ5Nf{۲CvUszõjq '.Rprö )+}߸.]dh ]ȻWϻ#*yżܼ0νO@OMOOP*P/P2P4PqPPPQ)QyQ~QQRRNRmRRRRRSS8SaSxSSSSTTHTTTUUWUUUV/V]VtV~VVVVVVVVWWAW^WWWWXX*X,X{XXXY.Y}YZZCZWZYZZZZ[9[;[[[\\\h\\]]#]F]K]M]]]^$^o^^^__b______`(`-`/`z```a aEaaaaabb9bTbpbbbbccc,c\caccccccccdNdUdrdwdyddddee:e`eeeeeeffKflffggOgjggggggghAhhhhhhii5iZitiijjBjJjjjjkkPkklHlllm8mzmmmmmmnEnbnnnnnoo<oroooooop p-pQpppppppqqIqqrCryrrrrsCsOsYssssssstttItPtrttttuu9u^uuuvv-v5vvwwOwqwwwx7x`xixyyPyyz!zuz{{C{N{{{{{||2|~||||}}}x}}}}}~ ~%~v~w&; "/pNg+TY[h>^/=q2Spuxz;.3BG+He}R02p#%2g=BDQy!drq{Nt{O~ -NPw*N}R:W?\d%V=*PuFT).0==BEGnR?^ e/6~ v279FZtDZ9UW $<NSVXf Wpw^ycEoO ] 5TV'C\mtN#<AC@p3y Ecs29fkn DraggableScrollableControllerDraggableScrollableSheetDraggableScrollableNotification_DraggableSheetExtent_DraggableScrollableSheetState)_DraggableScrollableSheetScrollController'_DraggableScrollableSheetScrollPositionDraggableScrollableActuator!_DraggableScrollableActuatorState_ResetNotifier_InheritedResetNotifier_SnappingSimulation