ZlerpcurvedurationonEnd createStatedebugFillProperties controller animation _animation initStatedidUpdateWidget _createCurvedispose_constructTweens forEachTweendidUpdateTweens_handleAnimationChangedchild alignmentpadding decorationforegroundDecoration constraintsmargin transformtransformAlignment clipBehavior _alignment_padding _decoration_foregroundDecoration _constraints_margin _transform_transformAlignmentbuild heightFactor widthFactor_heightFactorTween_widthFactorTweenlefttoprightbottomwidthheight_left_top_right_bottom_width_heightstartend_start_endscale filterQuality_scale_scaleAnimationturns_turns_turnsAnimationoffset_offset_offsetAnimationopacityalwaysIncludeSemantics_opacity_opacityAnimationsliverstyle textAlignsoftWrapoverflowmaxLinestextWidthBasistextHeightBehavior_styleshape borderRadius elevationcolor animateColor shadowColoranimateShadowColor _borderRadius _elevation_color _shadowColor'BoxConstraintsTweenDecorationTweenEdgeInsetsTweenEdgeInsetsGeometryTweenBorderRadiusTween BorderTween Matrix4TweenTextStyleTweenImplicitlyAnimatedWidgetTweenConstructor TweenVisitorImplicitlyAnimatedWidgetStateAnimatedWidgetBaseStateAnimatedContainer_AnimatedContainerStateAnimatedPadding_AnimatedPaddingState AnimatedAlign_AnimatedAlignStateAnimatedPositioned_AnimatedPositionedStateAnimatedPositionedDirectional#_AnimatedPositionedDirectionalState AnimatedScale_AnimatedScaleStateAnimatedRotation_AnimatedRotationState AnimatedSlide_AnimatedSlideStateAnimatedOpacity_AnimatedOpacityStateSliverAnimatedOpacity_SliverAnimatedOpacityStateAnimatedDefaultTextStyle_AnimatedDefaultTextStyleStateAnimatedPhysicalModel_AnimatedPhysicalModelStateAnimatedFractionallySizedBox"_AnimatedFractionallySizedBoxStateTextHeightBehaviorBoxConstraintslerpTweenbeginendoverridedouble DecorationShapeDecorationlerpTolerpFromRoundedRectangleBorder CircleBorder StadiumBorder BoxBorder EdgeInsetsEdgeInsetsGeometry BorderRadiusBorderMatrix4Vector3zero Quaternionidentity decomposescaled normalizedcompose TextStyleStateAnimatedWidgetAnimationController AnimationTweenAnimationBuilderAlign ContainerDefaultTextStyle TransformscalerotateOpacityPadding PhysicalModel PositionedPositionedDirectional AnimatedThemeThemeAnimatedCrossFade AnimatedSizeAnimatedSwitcherStatefulWidgetCurveslinearCurveDuration VoidCallbackvoidDiagnosticPropertiesBuilderdebugFillPropertiesadd IntPropertyinMillisecondsunit forEachTweenObjectTSingleTickerProviderStateMixin protecteddurationwidget debugLabel kDebugMode toStringShortvsyncCurvedAnimation initStateaddStatusListenerAnimationStatusstatus isCompletedonEndcalldidUpdateWidgetcurvedisposedynamictweenevaluate targetValueforwardfromparentbool constructorbuild controller addListenersetStateDecoratedBoxTransitionStack alignmentColorClipnone isNonNegativedebugAssertIsValidcolor BoxDecorationwidthheighttightentightForWidget AlignmentAlignmentGeometryAlignmentDirectional decoration getClipPathUnsupportedErrorDiagnosticsPropertyshowName defaultValueObjectFlagPropertyhasAlignmentGeometryTweenvaluepaddingforegroundDecoration constraintsmargin transformtransformAlignment BuildContext animation clipBehaviorchild fastOutSlowIn easeInOutclampinfinityAlignTransition TextDirection heightFactor widthFactorSlideTransitionPositionedTransitionDirectionalityRectrectlefttopDoublePropertyrightbottomstartdebugCheckHasDirectionality directional textDirectionof FlutterLogoScaleTransitioncenter FilterQuality EnumPropertydrive filterQualityRotationTransitionturnsOffsetoffsetpositionFlow IgnorePointerFadeTransitionopacityalwaysIncludeSemantics SliverOpacityCustomScrollViewSliverFixedExtentListFloatingActionButtonSliverIgnorePointerSliverFadeTransitionsliverText elasticInOutDefaultTextStyleTransition TextOverflowclipTextWidthBasis TextAlignsoftWrapmaxLinesint FlagPropertyifTrueifFalsestyle textAlignoverflowtextWidthBasistextHeightBehaviorBoxShape rectangle ColorProperty ColorTween borderRadius elevation shadowColorshape animateColoranimateShadowColorFractionallySizedBoxTweenStatefulWidgetStateSingleTickerProviderStateMixinImplicitlyAnimatedWidgetStateImplicitlyAnimatedWidgetAnimatedWidgetBaseStated$r,t TextHeightBehavior݁uidart:uipackage:flutter/foundation.dart(package:flutter/rendering.dartQ'package:vector_math/vector_math_64.dart basic.dartcontainer.dart debug.dartframework.dart text.dartticker_provider.darttransitions.dartV<Հف)Ruˁ́'PƂ߂-.F{ „ÄIdhYbdeLˈω\%Wy΋l WYZٌ:>LP VQSTߐLP^b &iّڒ(4 #'mʓДBqr̕?C28{ʖ˗%]_`ؘ ?C֘ܙ(vęߙ@k˚Z+)-/0_cÝǞ VH_ڟ$&'pϡhx|Ϣ>BkoJ)sL<@ۧ*.w8L eѪ!qԫ1=iǭ KtƭCXYFq6a߰1eiղ$%y}:>Դ15ϴڴ޴DY]Ѷ*+quRV=O޹(5xӹ)ZԻ0NV^vѻ">agż0:OͽY]^kwӾ׾ؾ-Je@ @G@X@}@@@@@@@@@ADATAZA|AABBhBBBCCC1C7CCD*DxDDDEEeEFFLFmFsFFFG%GiGGGGGH.H=HCHQHHHHHII/IvIIIIIJ'JjJJJKK8KKKLL LQLnLxLLLLLLM.MHMNMMMNNNPNNO"O(OvOPPcPPQQQ!Q"QsQQQR)RWR[RRSSNS}SSSSSSSTT1TtT|TTTTTU/UzUUUV3VVWW2W6WyW}WWX$XLXPXXXXXYYAYYZ*ZCZZ[G[[\ \6\E\Y\k\}\\\\]]]%]B]R]u]]]]^$^j^^^_)___`$`g`````aEaabbbFb]b^bbbc+c{cccccd d2d~dddee;e`eaeeef)f9fYfZfffffg?grgxgggh h/h0hxhhhiiIiOi_ieiiijj#jojujjjk?kkklll"l{l|lllm m:mOmbm{mmmn ngnno o"o7oSolouo|op,p@pnpppppq!q%q'q(q{qqqrr5rYrurrrrrss"sBssssst t*ttttttuuluzuuuuvvfvtvvvvvwMw[wwwwwx1x?xhxyxxxy yy8yRycyyz zzAzEzFzRzyzzz{'{[{{||7|{||||||}}I}^}}}}}}}~~q~x~~LSh z;Xt}`d?CW!15CG 4m$ARxy <ST`2 @O`x+/0<cw R~JhlaF csw(/H#3J`q4:'u9?OU=bc6<z/LMY'{<=I~6Dl Td%o#`@U18MVZkS`dBF8$_cw|*KU *;K\mf5Pm]st-.x'>?Y_UVb\6 $>Wqr~<G/N\Jiw 0GoA\cght1zc TaeO4$C$a= "2@N_o€‘®¿=>ntåûü`uvĺ23LRŢPvƎƏƛdǏ_ȩ;?ABlɱ+EFRʇʔz˙ˤ-̮̻̏:Hͪ3V·α)SϚϡϥϦϲ$qкRџKҍґҥҩCGSӀӤӨӸ0JNjԤԬ԰9Ws՚B`֖ $26x?؎Kcrقٛ PVڇڞڟڷPVۦ8>~ܤܥܱ Z݅ݹ+2ޗޛޝޞ23?t߁,\`am7>BDEV Z`d Ja,;P(9HU`hnv*u'@g,CDp<=efr*RkDcght4W04r&*8<5(7Gar%&?'l2Lwx)HLMYt+/12 _im,26h 8ODSo*.x]rvi9/}^ :IYt >Du./z 0 x     : ; G       K f      G f j k w        ; x      9FJ>BVO_cvz`n M eA )8Idu.FGag4:SY;pa,Gst(GKLXs"?|&q~37   p !!g!""?""""##-#A#[#####$$"$S$T$$$$$$$%K%d%e%%%& & &E&K&&&&&''#'r''''(>(D(|(((()#)J)K)u))))*"*#*/*t**+#+7+K+_+x+++,, ,c,,,---E-N-U-i-----.....i...../6/V/Z/[/g////00:0[0000000111H1L11252l2p22233w344424844455565[5~555566)6:6W6h66666777!7'7L7d7e777778)8/8^88888993949W9l9m999999:#:D:E:Q:::;;/;k;;+>?>P>m>>??(?9?J?d????@@b@~@@@@A$A2ANARASA_AAAABBNBBBCC5C<C@CBCCCCD4DADEDDDDE EREEEF\FlFpF~FFGGGHH4HzHII9I?IIIIIJ J!J7JHJeJvJJJKK#KTKkKlKKKLL5L6LzLLLLM!M"M.MsMMN?NNNNNOO(OMOqOrO~OOOOPPkPyPPPPQQ?QQQQQRRR6RZRRRRRRRSS4SgSSSTTTTTXTTTUUUuU|UUUUV/// @docImport 'package:flutter/material.dart'; /// /// @docImport 'animated_cross_fade.dart'; /// @docImport 'animated_size.dart'; /// @docImport 'animated_switcher.dart'; /// @docImport 'scroll_view.dart'; /// @docImport 'sliver.dart'; /// @docImport 'tween_animation_builder.dart'; 'P%  /// Creates a [BoxConstraints] tween. /// /// The [begin] and [end] properties may be null; the null value /// is treated as a tight constraint of zero size.007†€+K/// Returns the value this variable has at the given animation clock value.ÄÂ/// An interpolation between two [BoxConstraints]. /// /// This class specializes the interpolation of [Tween] to use /// [BoxConstraints.lerp]. /// /// See [Tween] for a discussion on how to use interpolation objects.  YYb+/// Creates a decoration tween. /// /// The [begin] and [end] properties may be null. If both are null, then the /// result is always null. If [end] is not null, then its lerping logic is /// used (via [Decoration.lerpTo]). Otherwise, [begin]'s lerping logic is used /// (via [Decoration.lerpFrom]).))0 $K/// Returns the value this variable has at the given animation clock value.ee+/// An interpolation between two [Decoration]s. /// /// This class specializes the interpolation of [Tween] to use /// [Decoration.lerp]. /// /// For [ShapeDecoration]s which know how to [ShapeDecoration.lerpTo] or /// [ShapeDecoration.lerpFrom] each other, this will produce a smooth /// interpolation between decorations. /// /// See also: /// /// * [Tween] for a discussion on how to use interpolation objects. /// * [ShapeDecoration], [RoundedRectangleBorder], [CircleBorder], and /// [StadiumBorder] for examples of shape borders that can be smoothly /// interpolated. /// * [BoxBorder] for a border that can only be smoothly interpolated between other /// [BoxBorder]s.  /// Creates an [EdgeInsets] tween. /// /// The [begin] and [end] properties may be null; the null value /// is treated as an [EdgeInsets] with no inset.##*K/// Returns the value this variable has at the given animation clock value.ZZ[/// An interpolation between two [EdgeInsets]s. /// /// This class specializes the interpolation of [Tween] to use /// [EdgeInsets.lerp]. /// /// See [Tween] for a discussion on how to use interpolation objects. /// /// See also: /// /// * [EdgeInsetsGeometryTween], which interpolates between two /// [EdgeInsetsGeometry] objects. ̑ /// Creates an [EdgeInsetsGeometry] tween. /// /// The [begin] and [end] properties may be null; the null value /// is treated as an [EdgeInsetsGeometry] with no inset.NNU*+ܑ܀IK/// Returns the value this variable has at the given animation clock value.TT1\/// An interpolation between two [EdgeInsetsGeometry]s. /// /// This class specializes the interpolation of [Tween] to /// use [EdgeInsetsGeometry.lerp]. /// /// See [Tween] for a discussion on how to use interpolation objects. /// /// See also: /// /// * [EdgeInsetsTween], which interpolates between two [EdgeInsets] objects.DUWW ]dd j/// Creates a [BorderRadius] tween. /// /// The [begin] and [end] properties may be null; the null value /// is treated as a right angle (no radius).”ÔttK/// Returns the value this variable has at the given animation clock value.s/// An interpolation between two [BorderRadius]s. /// /// This class specializes the interpolation of [Tween] to use /// [BorderRadius.lerp]. /// /// See [Tween] for a discussion on how to use interpolation objects.  /// Creates a [Border] tween. /// /// The [begin] and [end] properties may be null; the null value /// is treated as having no border.44;͖̀/K/// Returns the value this variable has at the given animation clock value.K/// An interpolation between two [Border]s. /// /// This class specializes the interpolation of [Tween] to use /// [Border.lerp]. /// /// See [Tween] for a discussion on how to use interpolation objects.  /// Creates a [Matrix4] tween. /// /// The [begin] and [end] properties must be non-null before the tween is /// first used, but the arguments can be null if the values are going to be /// filled in later.әr``(/// An interpolation between two [Matrix4]s. /// /// This class specializes the interpolation of [Tween] to be /// appropriate for transformation matrices. /// /// Currently this class works only for translations. /// /// See [Tween] for a discussion on how to use interpolation objects.aoqq w~~ /// Creates a text style tween. /// /// The [begin] and [end] properties must be non-null before the tween is /// first used, but the arguments can be null if the values are going to be /// filled in later.ܟݟK/// Returns the value this variable has at the given animation clock value.00\%/// An interpolation between two [TextStyle]s. /// /// This class specializes the interpolation of [Tween] to use /// [TextStyle.lerp]. /// /// This will not work well if the styles don't set the same fields. /// /// See [Tween] for a discussion on how to use interpolation objects.| ʭ MM&/// Initializes fields for subclasses.Q[QG/// The curve to apply when animating the parameters of this container.[bH/// The duration over which to animate the parameters of this container.€/// Called every time an animation completes. /// /// This can be useful to trigger additional actions (e.g. another animation) /// at the end of the current animation.R &(''/// An abstract class for building widgets that animate changes to their /// properties. /// /// Widgets of this type will not animate when they are first added to the /// widget tree. Rather, when they are rebuilt with different values, they will /// respond to those _changes_ by animating the changes over a specified /// [duration]. /// /// Which properties are animated is left up to the subclass. Subclasses' [State]s /// must extend [ImplicitlyAnimatedWidgetState] and provide a way to visit the /// relevant fields to animate. /// /// ## Relationship to [AnimatedWidget]s /// /// [ImplicitlyAnimatedWidget]s (and their subclasses) automatically animate /// changes in their properties whenever they change. For this, /// they create and manage their own internal [AnimationController]s to power /// the animation. While these widgets are simple to use and don't require you /// to manually manage the lifecycle of an [AnimationController], they /// are also somewhat limited: Besides the target value for the animated /// property, developers can only choose a [duration] and [curve] for the /// animation. If you require more control over the animation (e.g. you want /// to stop it somewhere in the middle), consider using an /// [AnimatedWidget] or one of its subclasses. These widgets take an [Animation] /// as an argument to power the animation. This gives the developer full control /// over the animation at the cost of requiring you to manually manage the /// underlying [AnimationController]. /// /// ## Common implicitly animated widgets /// /// A number of implicitly animated widgets ship with the framework. They are /// usually named `AnimatedFoo`, where `Foo` is the name of the non-animated /// version of that widget. Commonly used implicitly animated widgets include: /// /// * [TweenAnimationBuilder], which animates any property expressed by /// a [Tween] to a specified target value. /// * [AnimatedAlign], which is an implicitly animated version of [Align]. /// * [AnimatedContainer], which is an implicitly animated version of /// [Container]. /// * [AnimatedDefaultTextStyle], which is an implicitly animated version of /// [DefaultTextStyle]. /// * [AnimatedScale], which is an implicitly animated version of [Transform.scale]. /// * [AnimatedRotation], which is an implicitly animated version of [Transform.rotate]. /// * [AnimatedSlide], which implicitly animates the position of a widget relative to its normal position. /// * [AnimatedOpacity], which is an implicitly animated version of [Opacity]. /// * [AnimatedPadding], which is an implicitly animated version of [Padding]. /// * [AnimatedPhysicalModel], which is an implicitly animated version of /// [PhysicalModel]. /// * [AnimatedPositioned], which is an implicitly animated version of /// [Positioned]. /// * [AnimatedPositionedDirectional], which is an implicitly animated version /// of [PositionedDirectional]. /// * [AnimatedTheme], which is an implicitly animated version of [Theme]. /// * [AnimatedCrossFade], which cross-fades between two given children and /// animates itself between their sizes. /// * [AnimatedSize], which automatically transitions its size over a given /// duration. /// * [AnimatedSwitcher], which fades from one widget to another.||"|*+cv湄|˹ȹɹ͹ܹ׹޹VVG/// The animation controller driving this widget's implicit animations.~q\0qmA { /// ColorTween? _colorTween; /// /// @override /// Widget build(BuildContext context) { /// return Text( /// 'Hello World', /// // Computes the value of the text color at any given time. /// style: TextStyle(color: _colorTween?.evaluate(animation)), /// ); /// } /// /// @override /// void forEachTween(TweenVisitor visitor) { /// // Update the tween using the provided visitor function. /// _colorTween = visitor( /// // The latest tween value. Can be `null`. /// _colorTween, /// // The color value toward which we are animating. /// widget.targetColor, /// // A function that takes a color value and returns a tween /// // beginning at that value. /// (dynamic value) => ColorTween(begin: value as Color?), /// ) as ColorTween?; /// /// // We could have more tweens than one by using the visitor /// // multiple times. /// } /// } /// ``` /// {@end-tool}PPLL>Q /// Optional hook for subclasses that runs after all tweens have been updated /// via [forEachTween]. /// /// Any properties that depend upon tweens created by [forEachTween] should be /// updated within [didUpdateTweens], not within [forEachTween]. /// /// This method will be called both: /// /// 1. After the tweens are _initially_ constructed (by /// the `constructor` argument to the [TweenVisitor] that's passed to /// [forEachTween]). In this case, the tweens are likely to contain only /// a [Tween.begin] value and not a [Tween.end]. /// /// 2. When the state's [widget] is updated, and one or more of the tweens /// visited by [forEachTween] specifies a target value that's different /// than the widget's current value, thus signaling that the [animation] /// should run. In this case, the [Tween.begin] value for each tween will /// an evaluation of the tween against the current [animation], and the /// [Tween.end] value for each tween will be the target value.++^#/// A base class for the `State` of widgets with implicit animations. /// /// [ImplicitlyAnimatedWidgetState] requires that subclasses respond to the /// animation themselves. If you would like `setState()` to be called /// automatically as the animation changes, use [AnimatedWidgetBaseState]. /// /// Properties that subclasses choose to animate are represented by [Tween] /// instances. Subclasses must implement the [forEachTween] method to allow /// [ImplicitlyAnimatedWidgetState] to iterate through the widget's fields and /// animate them.S*S*"S*SSSSSS{SSSTQ"Q"_S/// A base class for widgets with implicit animations that need to rebuild their /// widget tree as the animation runs. /// /// This class calls [build] each frame that the animation ticks. For a /// variant that does not rebuild each frame, consider subclassing /// [ImplicitlyAnimatedWidgetState] directly. /// /// Subclasses must implement the [forEachTween] method to allow /// [AnimatedWidgetBaseState] to iterate through the subclasses' widget's fields /// and animate them.\"\3\:\: \@\I\I\N\]\] \b\o\o \v\\\\\\\\ \\\\\\\]] ] ]]]])])].]F]F ]K]V]V][]y]y ]]]]]] ]s]j]n]o]]]]]]]]]]]]^!^ ^]^^ ^^^+^1^g^E^=^2^@^H^R^S^e^f^q^w^^^^x^^^^^^^^^_^^^^^^^^_2__________________`_`/```"`` `` ````d`1`<`>`E`b`K`F`M`Z`T`\`x```````````[[߄@/// Creates a container that animates its parameters implicitly. bV`ˁbVl/// The [child] contained by the container. /// /// If null, and if the [constraints] are unbounded or also null, the /// container will expand to fill all available space in its parent, unless /// the parent provides unbounded constraints, in which case the container /// will attempt to be as small as possible. /// /// {@macro flutter.widgets.ProxyWidget.child}db`gd(/// Align the [child] within the container. /// /// If non-null, the container will expand to fill its parent and position its /// child within itself according to the given value. If the incoming /// constraints are unbounded, then the child will be shrink-wrapped instead. /// /// Ignored if [child] is null. /// /// See also: /// /// * [Alignment], a class with convenient constants typically used to /// specify an [AlignmentGeometry]. /// * [AlignmentDirectional], like [Alignment] for specifying alignments /// relative to text direction.eWd̀eWl/// Empty space to inscribe inside the [decoration]. The [child], if any, is /// placed inside this padding.fMecfM/// The decoration to paint behind the [child]. /// /// A shorthand for specifying just a solid color is available in the /// constructor: set the `color` argument instead of the `decoration` /// argument.ff\[f2/// The decoration to paint in front of the child.gfg/// Additional constraints to apply to the child. /// /// The constructor `width` and `height` arguments are combined with the /// `constraints` argument to set this property. /// /// The [padding] goes inside the constraints.h'g\h'9/// Empty space to surround the [decoration] and [child].hh2`hE/// The transformation matrix to apply before painting the container.ih:i/// The alignment of the origin, relative to the size of the container, if [transform] is specified. /// /// When [transform] is null, the value of this property is ignored. /// /// See also: /// /// * [Transform.alignment], which is set by this property.liւ=l/// The clip behavior when [AnimatedContainer.decoration] is not null. /// /// Defaults to [Clip.none]. Must be [Clip.none] if [decoration] is null. /// /// Unlike other properties of [AnimatedContainer], changes to this property /// apply immediately and have no animation. /// /// If a clip is to be applied, the [Decoration.getClipPath] method /// for the provided decoration must return a clip path. (This is not /// supported by all decorations; the default implementation of that /// method throws an [UnsupportedError].)llllblOll&ll~ll~l~lTT[/// Animated version of [Container] that gradually changes its values over a period of time. /// /// The [AnimatedContainer] will automatically animate between the old and /// new values of properties when they change using the provided curve and /// duration. Properties that are null are not animated. Its child and /// descendants are not animated. /// /// This class is useful for generating simple implicit transitions between /// different parameters to [Container] with its internal [AnimationController]. /// For more complex animations, you'll likely want to use a subclass of /// [AnimatedWidget] such as the [DecoratedBoxTransition] or use your own /// [AnimationController]. /// /// {@youtube 560 315 https://www.youtube.com/watch?v=yI-8QHpGIP4} /// /// {@tool dartpad} /// The following example (depicted above) transitions an AnimatedContainer /// between two states. It adjusts the `height`, `width`, `color`, and /// [alignment] properties when tapped. /// /// ** See code in examples/api/lib/widgets/implicit_animations/animated_container.0.dart ** /// {@end-tool} /// /// See also: /// /// * [AnimatedPadding], which is a subset of this widget that only /// supports animating the [padding]. /// * The [catalog of layout widgets](https://flutter.dev/widgets/layout/). /// * [AnimatedPositioned], which, as a child of a [Stack], automatically /// transitions its child's position over a given duration whenever the given /// position changes. /// * [AnimatedAlign], which automatically transitions its child's /// position over a given duration whenever the given [AnimatedAlign.alignment] changes. /// * [AnimatedSwitcher], which switches out a child for a new one with a customizable transition. /// * [AnimatedCrossFade], which fades between two children and interpolates their sizes.qq}"qqq!qqqqqq&qr'r!r'rPr7 rPrir[rirrw+rrrrrrrrrzazaznzHzIzHzHz[||'}||||̈́|q(q(aq.    ((7EE KY_u`ghooS/// Creates a widget that insets its child by a value that animates /// implicitly.{W4/// The amount of space by which to inset the child.LzL`/// The widget below this widget in the tree. /// /// {@macro flutter.widgets.ProxyWidget.child}VWVV^&:/// Animated version of [Padding] which automatically transitions the /// indentation over a given duration whenever the given inset changes. /// /// {@youtube 560 315 https://www.youtube.com/watch?v=PY2m0fhGNz4} /// /// Here's an illustration of what using this widget looks like, using a [curve] /// of [Curves.fastOutSlowIn]. /// {@animation 250 266 https://flutter.github.io/assets-for-api-docs/assets/widgets/animated_padding.mp4} /// /// {@tool dartpad} /// The following code implements the [AnimatedPadding] widget, using a [curve] of /// [Curves.easeInOut]. /// /// ** See code in examples/api/lib/widgets/implicit_animations/animated_padding.0.dart ** /// {@end-tool} /// /// See also: /// /// * [AnimatedContainer], which can transition more values at once. /// * [AnimatedAlign], which automatically transitions its child's /// position over a given duration whenever the given /// [AnimatedAlign.alignment] changes.!5-KKX2322E'''Cr  '' ,77<NNSdd juu  [/// Creates a widget that positions its child by an alignment that animates /// implicitly.WHW/// How to align the child. /// /// The x and y values of the [Alignment] control the horizontal and vertical /// alignment, respectively. An x value of -1.0 means that the left edge of /// the child is aligned with the left edge of the parent whereas an x value /// of 1.0 means that the right edge of the child is aligned with the right /// edge of the parent. Other values interpolate (and extrapolate) linearly. /// For example, a value of 0.0 means that the center of the child is aligned /// with the center of the parent. /// /// See also: /// /// * [Alignment], which has more details and some convenience constants for /// common positions. /// * [AlignmentDirectional], which has a horizontal coordinate orientation /// that depends on the [TextDirection].ez`/// The widget below this widget in the tree. /// /// {@macro flutter.widgets.ProxyWidget.child}䀲/// If non-null, sets its height to the child's height multiplied by this factor. /// /// Must be greater than or equal to 0.0, defaults to null.??/// If non-null, sets its width to the child's width multiplied by this factor. /// /// Must be greater than or equal to 0.0, defaults to null.OPOOZ&NI/// Animated version of [Align] which automatically transitions the child's /// position over a given duration whenever the given [alignment] changes. /// /// Here's an illustration of what this can look like, using a [curve] of /// [Curves.fastOutSlowIn]. /// {@animation 250 266 https://flutter.github.io/assets-for-api-docs/assets/widgets/animated_align.mp4} /// /// For the animation, you can choose a [curve] as well as a [duration] and the /// widget will automatically animate to the new target [alignment]. If you require /// more control over the animation (e.g. if you want to stop it mid-animation), /// consider using an [AlignTransition] instead, which takes a provided /// [Animation] as argument. While that allows you to fine-tune the animation, /// it also requires more development overhead as you have to manually manage /// the lifecycle of the underlying [AnimationController]. /// /// {@tool dartpad} /// The following code implements the [AnimatedAlign] widget, using a [curve] of /// [Curves.fastOutSlowIn]. /// /// ** See code in examples/api/lib/widgets/implicit_animations/animated_align.0.dart ** /// {@end-tool} /// /// See also: /// /// * [AnimatedContainer], which can transition more values at once. /// * [AnimatedPadding], which can animate the padding instead of the /// alignment. /// * [AnimatedSlide], which can animate the translation of child by a given offset relative to its size. /// * [AnimatedPositioned], which, as a child of a [Stack], automatically /// transitions its child's position over a given duration whenever the given /// position changes."!) )]]s?@??jP'ā9   #.. 3?? DOO T`` fqq  $/// Creates a widget that animates its position implicitly. /// /// Only two out of the three horizontal values ([left], [right], /// [width]), and only two out of the three vertical values ([top], /// [bottom], [height]), can be set. In each case, at least one of /// the three must be null.hz    )%+/0B<DHI^W`dezt|z{H/// Creates a widget that animates the rectangle it occupies implicitly.y`/// The widget below this widget in the tree. /// /// {@macro flutter.widgets.ProxyWidget.child}mXmC/// The offset of the child's left edge from the left of the stack.vUA/// The offset of the child's top edge from the top of the stack.&[&E/// The offset of the child's right edge from the right of the stack.0^G/// The offset of the child's bottom edge from the bottom of the stack.77/// The child's width. /// /// Only two out of the three horizontal values ([left], [right], [width]) can /// be set. The third must be null.A倍/// The child's height. /// /// Only two out of the three vertical values ([top], [bottom], [height]) can /// be set. The third must be null.d(}}&XYXX+iQ/// Animated version of [Positioned] which automatically transitions the child's /// position over a given duration whenever the given position changes. /// /// {@youtube 560 315 https://www.youtube.com/watch?v=hC3s2YdtWt8} /// /// Only works if it's the child of a [Stack]. /// /// This widget is a good choice if the _size_ of the child would end up /// changing as a result of this animation. If the size is intended to remain /// the same, with only the _position_ changing over time, then consider /// [SlideTransition] instead. [SlideTransition] only triggers a repaint each /// frame of the animation, whereas [AnimatedPositioned] will trigger a relayout /// as well. /// /// Here's an illustration of what using this widget looks like, using a [curve] /// of [Curves.fastOutSlowIn]. /// {@animation 250 266 https://flutter.github.io/assets-for-api-docs/assets/widgets/animated_positioned.mp4} /// /// For the animation, you can choose a [curve] as well as a [duration] and the /// widget will automatically animate to the new target position. If you require /// more control over the animation (e.g. if you want to stop it mid-animation), /// consider using a [PositionedTransition] instead, which takes a provided /// [Animation] as an argument. While that allows you to fine-tune the animation, /// it also requires more development overhead as you have to manually manage /// the lifecycle of the underlying [AnimationController]. /// /// {@tool dartpad} /// The following example transitions an AnimatedPositioned /// between two states. It adjusts the `height`, `width`, and /// [Positioned] properties when tapped. /// /// ** See code in examples/api/lib/widgets/implicit_animations/animated_positioned.0.dart ** /// {@end-tool} /// /// See also: /// /// * [AnimatedPositionedDirectional], which adapts to the ambient /// [Directionality] (the same as this widget, but for animating /// [PositionedDirectional]). 5&5O@OhYhtutt%g'jkjjK{0  && +66;DDIRR Wcc hss x„„ Š••¤²² ¸ :) !$3,6/// Creates a widget that animates its position implicitly. /// /// Only two out of the three horizontal values ([start], [end], [width]), and /// only two out of the three vertical values ([top], [bottom], [height]), can /// be set. In each case, at least one of the three must be null.ô@yô`/// The widget below this widget in the tree. /// /// {@macro flutter.widgets.ProxyWidget.child}þ[E/// The offset of the child's start edge from the start of the stack.pUpA/// The offset of the child's top edge from the top of the stack.xUA/// The offset of the child's end edge from the end of the stack.*^*G/// The offset of the child's bottom edge from the bottom of the stack.5؀/// The child's width. /// /// Only two out of the three horizontal values ([start], [end], [width]) can /// be set. The third must be null.Ɔ‪Ɔ/// The child's height. /// /// Only two out of the three vertical values ([top], [bottom], [height]) can /// be set. The third must be null.ƑƒƑƑ::&V)&g/// Animated version of [PositionedDirectional] which automatically transitions /// the child's position over a given duration whenever the given position /// changes. /// /// The ambient [Directionality] is used to determine whether [start] is to the /// left or to the right. /// /// Only works if it's the child of a [Stack]. /// /// This widget is a good choice if the _size_ of the child would end up /// changing as a result of this animation. If the size is intended to remain /// the same, with only the _position_ changing over time, then consider /// [SlideTransition] instead. [SlideTransition] only triggers a repaint each /// frame of the animation, whereas [AnimatedPositionedDirectional] will trigger /// a relayout as well. ([SlideTransition] is also text-direction-aware.) /// /// Here's an illustration of what using this widget looks like, using a [curve] /// of [Curves.fastOutSlowIn]. /// {@animation 250 266 https://flutter.github.io/assets-for-api-docs/assets/widgets/animated_positioned_directional.mp4} /// /// See also: /// /// * [AnimatedPositioned], which specifies the widget's position visually (the /// same as this widget, but for animating [Positioned]).ɳ  ##<-<ff|HIHHYЁ'ϨϩϨϨIϹBBHS`gg mvv {ننٟٟٔ!٤  ٰٹٺ 8/// Creates a widget that animates its scale implicitly.ڗ"zڗ`/// The widget below this widget in the tree. /// /// {@macro flutter.widgets.ProxyWidget.child}ڡ*/// The target scale.Ёڀ/// The alignment of the origin of the coordinate system in which the scale /// takes place, relative to the size of the box. /// /// For example, to set the origin of the scale to bottom middle, you can use /// an alignment of (0.0, 1.0).ܕ耺ܕ/// The filter quality with which to apply the transform as a bitmap operation. /// /// {@macro flutter.widgets.Transform.optional.FilterQuality}ܧܨܧܧ`00&L ߆/// Animated version of [Transform.scale] which automatically transitions the child's /// scale over a given duration whenever the given scale changes. /// /// {@tool snippet} /// /// This code defines a widget that uses [AnimatedScale] to change the size /// of [FlutterLogo] gradually to a new scale whenever the button is pressed. /// /// ```dart /// class LogoScale extends StatefulWidget { /// const LogoScale({super.key}); /// /// @override /// State createState() => LogoScaleState(); /// } /// /// class LogoScaleState extends State { /// double scale = 1.0; /// /// void _changeScale() { /// setState(() => scale = scale == 1.0 ? 3.0 : 1.0); /// } /// /// @override /// Widget build(BuildContext context) { /// return Column( /// mainAxisAlignment: MainAxisAlignment.center, /// children: [ /// ElevatedButton( /// onPressed: _changeScale, /// child: const Text('Scale Logo'), /// ), /// Padding( /// padding: const EdgeInsets.all(50), /// child: AnimatedScale( /// scale: scale, /// duration: const Duration(seconds: 2), /// child: const FlutterLogo(), /// ), /// ), /// ], /// ); /// } /// } /// ``` /// {@end-tool} /// /// See also: /// /// * [AnimatedRotation], for animating the rotation of a child. /// * [AnimatedSize], for animating the resize of a child based on changes /// in layout. /// * [AnimatedSlide], for animating the translation of a child by a given offset relative to its size. /// * [ScaleTransition], an explicitly animated version of this widget, where /// an [Animation] is provided by the caller instead of being built in.! &!SSi5655FX||cdccvޞޞޤ   ++9DD!Ikkp  U^_籁;/// Creates a widget that animates its rotation implicitly.<z<`/// The widget below this widget in the tree. /// /// {@macro flutter.widgets.ProxyWidget.child}F/// The animation that controls the rotation of the child. /// /// If the current value of the turns animation is v, the child will be /// rotated v * 2 * pi radians before being painted.1!1/// The alignment of the origin of the coordinate system in which the rotation /// takes place, relative to the size of the box. /// /// For example, to set the origin of the rotation to bottom middle, you can use /// an alignment of (0.0, 1.0).?쀑/// The filter quality with which to apply the transform as a bitmap operation. /// /// {@macro flutter.widgets.Transform.optional.FilterQuality}f:&hihhyEE{//// Animated version of [Transform.rotate] which automatically transitions the child's /// rotation over a given duration whenever the given rotation changes. /// /// {@tool snippet} /// /// This code defines a widget that uses [AnimatedRotation] to rotate a [FlutterLogo] /// gradually by an eighth of a turn (45 degrees) with each press of the button. /// /// ```dart /// class LogoRotate extends StatefulWidget { /// const LogoRotate({super.key}); /// /// @override /// State createState() => LogoRotateState(); /// } /// /// class LogoRotateState extends State { /// double turns = 0.0; /// /// void _changeRotation() { /// setState(() => turns += 1.0 / 8.0); /// } /// /// @override /// Widget build(BuildContext context) { /// return Column( /// mainAxisAlignment: MainAxisAlignment.center, /// children: [ /// ElevatedButton( /// onPressed: _changeRotation, /// child: const Text('Rotate Logo'), /// ), /// Padding( /// padding: const EdgeInsets.all(50), /// child: AnimatedRotation( /// turns: turns, /// duration: const Duration(seconds: 1), /// child: const FlutterLogo(), /// ), /// ), /// ], /// ); /// } /// } /// ``` /// {@end-tool} /// /// See also: /// /// * [AnimatedScale], for animating the scale of a child. /// * [RotationTransition], an explicitly animated version of this widget, where /// an [Animation] is provided by the caller instead of being built in.cTcm&jkjjX{ƀ%,, 2;; @KKYee kvv ʀE/// Creates a widget that animates its offset translation implicitly.z`/// The widget below this widget in the tree. /// /// {@macro flutter.widgets.ProxyWidget.child}(t/// The target offset. /// The child will be translated horizontally by `width * dx` and vertically by `height * dy``BB&^.4/// Widget which automatically transitions the child's /// offset relative to its normal position whenever the given offset changes. /// /// The translation is expressed as an [Offset] scaled to the child's size. For /// example, an [Offset] with a `dx` of 0.25 will result in a horizontal /// translation of one quarter the width of the child. /// /// {@tool dartpad} /// This code defines a widget that uses [AnimatedSlide] to translate a [FlutterLogo] /// up or down and right or left by dragging the X and Y axis sliders. /// /// ** See code in examples/api/lib/widgets/implicit_animations/animated_slide.0.dart ** /// {@end-tool} /// /// See also: /// /// * [AnimatedPositioned], which, as a child of a [Stack], automatically /// transitions its child's position over a given duration whenever the given /// position changes. /// * [AnimatedAlign], which automatically transitions its child's /// position over a given duration whenever the given [AnimatedAlign.alignment] changes.C4CeN'ez{zzOPOOZ`O(7>> DMM R]]kxx ~ #  s/// Creates a widget that animates its opacity implicitly. /// /// The [opacity] argument must be between zero and one, inclusive.z`/// The widget below this widget in the tree. /// /// {@macro flutter.widgets.ProxyWidget.child}%%/// The target opacity. /// /// An opacity of 1.0 is fully opaque. An opacity of 0.0 is fully transparent /// (i.e., invisible). 1 m/// Whether the semantic information of the children is always included. /// /// Defaults to false. /// /// When true, regardless of the opacity settings the child semantic /// information is exposed as if the widget were fully visible. This is /// useful in cases where labels may be hidden during animations that /// would otherwise contribute relevant semantics.    d  b b& ~ = > = = N22d+/// Animated version of [Opacity] which automatically transitions the child's /// opacity over a given duration whenever the given opacity changes. /// /// {@youtube 560 315 https://www.youtube.com/watch?v=QZAvjqOqiLY} /// /// Animating an opacity is relatively expensive because it requires painting /// the child into an intermediate buffer. /// /// Here's an illustration of what using this widget looks like, using a [curve] /// of [Curves.fastOutSlowIn]. /// {@animation 250 266 https://flutter.github.io/assets-for-api-docs/assets/widgets/animated_opacity.mp4} /// /// {@tool snippet} /// /// ```dart /// class LogoFade extends StatefulWidget { /// const LogoFade({super.key}); /// /// @override /// State createState() => LogoFadeState(); /// } /// /// class LogoFadeState extends State { /// double opacityLevel = 1.0; /// /// void _changeOpacity() { /// setState(() => opacityLevel = opacityLevel == 0 ? 1.0 : 0.0); /// } /// /// @override /// Widget build(BuildContext context) { /// return Column( /// mainAxisAlignment: MainAxisAlignment.center, /// children: [ /// AnimatedOpacity( /// opacity: opacityLevel, /// duration: const Duration(seconds: 3), /// child: const FlutterLogo(), /// ), /// ElevatedButton( /// onPressed: _changeOpacity, /// child: const Text('Fade Logo'), /// ), /// ], /// ); /// } /// } /// ``` /// {@end-tool} /// /// ## Hit testing /// /// Setting the [opacity] to zero does not prevent hit testing from being /// applied to the descendants of the [AnimatedOpacity] widget. This can be /// confusing for the user, who may not see anything, and may believe the area /// of the interface where the [AnimatedOpacity] is hiding a widget to be /// non-interactive. /// /// With certain widgets, such as [Flow], that compute their positions only when /// they are painted, this can actually lead to bugs (from unexpected geometry /// to exceptions), because those widgets are not painted by the [AnimatedOpacity] /// widget at all when the [opacity] animation reaches zero. /// /// To avoid such problems, it is generally a good idea to use an /// [IgnorePointer] widget when setting the [opacity] to zero. This prevents /// interactions with any children in the subtree when the [child] is animating /// away. /// /// See also: /// /// * [AnimatedCrossFade], for fading between two children. /// * [AnimatedSwitcher], for fading between many children in sequence. /// * [FadeTransition], an explicitly animated version of this widget, where /// an [Animation] is provided by the caller instead of being built in. /// * [SliverAnimatedOpacity], for automatically transitioning a _sliver's_ /// opacity over a given duration whenever the given opacity changes. \ M \  h(          m n m m\ ~       ̀    &-- 3<< AMM[hh nyy # z/// Creates a widget that animates its opacity implicitly. /// /// The [opacity] argument must be between zero and one, inclusive.>D>-/// The sliver below this widget in the tree.I߀/// The target opacity. /// /// An opacity of 1.0 is fully opaque. An opacity of 0.0 is fully transparent /// (i.e., invisible).}끨}v/// Whether the semantic information of the children is always included. /// /// Defaults to false. /// /// When true, regardless of the opacity settings the sliver child's semantic /// information is exposed as if the widget were fully visible. This is /// useful in cases where labels may be hidden during animations that /// would otherwise contribute relevant semantics.v77&S#  (G/// Animated version of [SliverOpacity] which automatically transitions the /// sliver child's opacity over a given duration whenever the given opacity /// changes. /// /// Animating an opacity is relatively expensive because it requires painting /// the sliver child into an intermediate buffer. /// /// Here's an illustration of what using this widget looks like, using a [curve] /// of [Curves.fastOutSlowIn]. /// /// {@tool dartpad} /// Creates a [CustomScrollView] with a [SliverFixedExtentList] and a /// [FloatingActionButton]. Pressing the button animates the lists' opacity. /// /// ** See code in examples/api/lib/widgets/implicit_animations/sliver_animated_opacity.0.dart ** /// {@end-tool} /// /// ## Hit testing /// /// Setting the [opacity] to zero does not prevent hit testing from being /// applied to the descendants of the [SliverAnimatedOpacity] widget. This can /// be confusing for the user, who may not see anything, and may believe the /// area of the interface where the [SliverAnimatedOpacity] is hiding a widget /// to be non-interactive. /// /// With certain widgets, such as [Flow], that compute their positions only when /// they are painted, this can actually lead to bugs (from unexpected geometry /// to exceptions), because those widgets are not painted by the /// [SliverAnimatedOpacity] widget at all when the [opacity] animation reaches /// zero. /// /// To avoid such problems, it is generally a good idea to use a /// [SliverIgnorePointer] widget when setting the [opacity] to zero. This /// prevents interactions with any children in the subtree when the [sliver] is /// animating away. /// /// See also: /// /// * [SliverFadeTransition], an explicitly animated version of this widget, where /// an [Animation] is provided by the caller instead of being built in. /// * [AnimatedOpacity], for automatically transitioning a box child's /// opacity over a given duration whenever the given opacity changes.=.=`I(`vwvvNONN\_˂"" "" """# ###&#1#1#6#E#E#J#_#_!#d## ###+###### ###$$$ $#U#o#{#|###$)$/$P$A$9$0$<$M$D$O""E/// Creates a widget that animates the default text style implicitly.$$Vy$`/// The widget below this widget in the tree. /// /// {@macro flutter.widgets.ProxyWidget.child}%]$Ԁ%]r/// The target text style. /// /// When this property is changed, the style will be animated over [duration] time.&%g&/// How the text should be aligned horizontally. /// /// This property takes effect immediately when changed, it is not animated.&&&/// Whether the text should break at soft line breaks. /// /// This property takes effect immediately when changed, it is not animated. /// /// See [DefaultTextStyle.softWrap] for more details.'&'{/// How visual overflow should be handled. /// /// This property takes effect immediately when changed, it is not animated.('(/// An optional maximum number of lines for the text to span, wrapping if necessary. /// /// This property takes effect immediately when changed, it is not animated. /// /// See [DefaultTextStyle.maxLines] for more details.):():/// The strategy to use when calculating the width of the Text. /// /// See [TextWidthBasis] for possible values and their implications.))MY)'/// {@macro dart.ui.textHeightBehavior}))))v)*J*J&*f*%*&*%*%*6|"E/// Animated version of [DefaultTextStyle] which automatically transitions the /// default text style (the text style to apply to descendant [Text] widgets /// without explicit style) over a given duration whenever the given style /// changes. /// /// The [textAlign], [softWrap], [overflow], [maxLines], [textWidthBasis] /// and [textHeightBehavior] properties are not animated and take effect /// immediately when changed. /// /// Here's an illustration of what using this widget looks like, using a [curve] /// of [Curves.elasticInOut]. /// {@animation 250 266 https://flutter.github.io/assets-for-api-docs/assets/widgets/animated_default_text_style.mp4} /// /// For the animation, you can choose a [curve] as well as a [duration] and the /// widget will automatically animate to the new default text style. If you require /// more control over the animation (e.g. if you want to stop it mid-animation), /// consider using a [DefaultTextStyleTransition] instead, which takes a provided /// [Animation] as argument. While that allows you to fine-tune the animation, /// it also requires more development overhead as you have to manually manage /// the lifecycle of the underlying [AnimationController]..{.k.{......../v/v//]/^/]/]/p...45 55 55!5!5/5:5:5?5_5_5d5555555555555556 6 66-6- 636>6>6M6[6[ 6a5G5O5P5s5w5x556#6o6u666v633)/// Creates a widget that animates the properties of a [PhysicalModel]. /// /// The [elevation] must be non-negative. /// /// Animating [color] is optional and is controlled by the [animateColor] flag. /// /// Animating [shadowColor] is optional and is controlled by the [animateShadowColor] flag. 76y7`/// The widget below this widget in the tree. /// /// {@macro flutter.widgets.ProxyWidget.child}7]7 X7]=/// The type of shape. /// /// This property is not animated.77gr7T/// {@macro flutter.material.Material.clipBehavior} /// /// Defaults to [Clip.none].8t7ހ8t{/// The target border radius of the rounded corners for a rectangle shape. /// /// If null, treated as [BorderRadius.zero].9(89(/// The target z-coordinate relative to the parent at which to place this /// physical object. /// /// The value will always be non-negative.9e9649e /// The target background color.99oC9)/// Whether the color should be animated.9969/// The target shadow color.:09P:00/// Whether the shadow color should be animated.:G:H:G:Gj:::&:::::b:0033}/// Animated version of [PhysicalModel]. /// /// The [borderRadius] and [elevation] are animated. /// /// The [color] is animated if the [animateColor] property is set; otherwise, /// the color changes immediately at the start of the animation for the other /// two properties. This allows the color to be animated independently (e.g. /// because it is being driven by an [AnimatedTheme]). /// /// The [shape] is not animated. /// /// Here's an illustration of what using this widget looks like, using a [curve] /// of [Curves.fastOutSlowIn]. /// {@animation 250 266 https://flutter.github.io/assets-for-api-docs/assets/widgets/animated_physical_model.mp4}==x ==========> > > ====e=AnAnA{AUAVAUAUAh==&=!IIII III!III JJJJJ%J%J*J;J; JAJLJLJ[JiJi JoIIIJ}JJJJJJJJJJJJJJJJJJJH|H|o/// Creates a widget that sizes its child to a fraction of the total available /// space that animates implicitly, and positions its child by an alignment /// that animates implicitly. /// /// If non-null, the [widthFactor] and [heightFactor] arguments must be /// non-negative.KdJzKd`/// The widget below this widget in the tree. /// /// {@macro flutter.widgets.ProxyWidget.child}KKnaKD/// {@macro flutter.widgets.basic.fractionallySizedBox.heightFactor}L(K_L(C/// {@macro flutter.widgets.basic.fractionallySizedBox.widthFactor}LL8eLA/// {@macro flutter.widgets.basic.fractionallySizedBox.alignment}LLLL~LMIMI&MeM$M%M$M$mM5CCCCPH:/// Animated version of [FractionallySizedBox] which automatically transitions the /// child's size over a given duration whenever the given [widthFactor] or /// [heightFactor] changes, as well as the position whenever the given [alignment] /// changes. /// /// For the animation, you can choose a [curve] as well as a [duration] and the /// widget will automatically animate to the new target [widthFactor] or /// [heightFactor]. /// /// {@tool dartpad} /// The following example transitions an [AnimatedFractionallySizedBox] /// between two states. It adjusts the [heightFactor], [widthFactor], and /// [alignment] properties when tapped, using a [curve] of [Curves.fastOutSlowIn] /// /// ** See code in examples/api/lib/widgets/implicit_animations/animated_fractionally_sized_box.0.dart ** /// {@end-tool} /// /// See also: /// /// * [AnimatedAlign], which is an implicitly animated version of [Align]. /// * [AnimatedContainer], which can transition more values at once. /// * [AnimatedSlide], which can animate the translation of child by a given offset relative to its size. /// * [AnimatedPositioned], which, as a child of a [Stack], automatically /// transitions its child's position over a given duration whenever the given /// position changes.OO"OO9O*!O9O^OO O^OOOOtOuOtOtjORRSRRRR"RT-T-'TITT TTTNNjNi݁/// Signature for a [Tween] factory. /// /// This is the type of one of the arguments of [TweenVisitor], the signature /// used by [AnimatedWidgetBaseState.forEachTween]. /// /// Instances of this function are expected to take a value and return a tween /// beginning at that value.%%/// Signature for callbacks passed to [ImplicitlyAnimatedWidgetState.forEachTween]. /// /// {@template flutter.widgets.TweenVisitor.arguments} /// The `tween` argument should contain the current tween value. This will /// initially be null when the state is first initialized. /// /// The `targetValue` argument should contain the value toward which the state /// is animating. For instance, if the state is animating its widget's /// opacity value, then this argument should contain the widget's current /// opacity value. /// /// The `constructor` argument should contain a function that takes a value /// (the widget's value being animated) and returns a tween beginning at that /// value. /// /// {@endtemplate} /// /// `forEachTween()` is expected to update its tween value to the return value /// of this visitor. /// /// The `` parameter specifies the type of value that's being animated.package:flutter/material.dartanimated_cross_fade.dart animated_size.dart2animated_switcher.dart[scroll_view.dart~ sliver.darttween_animation_builder.dart<Հف)Ruˁ́'PƂ߂-.F{ „ÄIdhYbdeLˈω\%Wy΋l WYZٌ:>LP VQSTߐLP^b &iّڒ(4 #'mʓДBqr̕?C28{ʖ˗%]_`ؘ ?C֘ܙ(vęߙ@k˚Z+)-/0_cÝǞ VH_ڟ$&'pϡhx|Ϣ>BkoJ)sL<@ۧ*.w8L eѪ!qԫ1=iǭ KtƭCXYFq6a߰1eiղ$%y}:>Դ15ϴڴ޴DY]Ѷ*+quRV=O޹(5xӹ)ZԻ0NV^vѻ">agż0:OͽY]^kwӾ׾ؾ-Je@ @G@X@}@@@@@@@@@ADATAZA|AABBhBBBCCC1C7CCD*DxDDDEEeEFFLFmFsFFFG%GiGGGGGH.H=HCHQHHHHHII/IvIIIIIJ'JjJJJKK8KKKLL LQLnLxLLLLLLM.MHMNMMMNNNPNNO"O(OvOPPcPPQQQ!Q"QsQQQR)RWR[RRSSNS}SSSSSSSTT1TtT|TTTTTU/UzUUUV3VVWW2W6WyW}WWX$XLXPXXXXXYYAYYZ*ZCZZ[G[[\ \6\E\Y\k\}\\\\]]]%]B]R]u]]]]^$^j^^^_)___`$`g`````aEaabbbFb]b^bbbc+c{cccccd d2d~dddee;e`eaeeef)f9fYfZfffffg?grgxgggh h/h0hxhhhiiIiOi_ieiiijj#jojujjjk?kkklll"l{l|lllm m:mOmbm{mmmn ngnno o"o7oSolouo|op,p@pnpppppq!q%q'q(q{qqqrr5rYrurrrrrss"sBssssst t*ttttttuuluzuuuuvvfvtvvvvvwMw[wwwwwx1x?xhxyxxxy yy8yRycyyz zzAzEzFzRzyzzz{'{[{{||7|{||||||}}I}^}}}}}}}~~q~x~~LSh z;Xt}`d?CW!15CG 4m$ARxy <ST`2 @O`x+/0<cw R~JhlaF csw(/H#3J`q4:'u9?OU=bc6<z/LMY'{<=I~6Dl Td%o#`@U18MVZkS`dBF8$_cw|*KU *;K\mf5Pm]st-.x'>?Y_UVb\6 $>Wqr~<G/N\Jiw 0GoA\cght1zc TaeO4$C$a= "2@N_o€‘®¿=>ntåûü`uvĺ23LRŢPvƎƏƛdǏ_ȩ;?ABlɱ+EFRʇʔz˙ˤ-̮̻̏:Hͪ3V·α)SϚϡϥϦϲ$qкRџKҍґҥҩCGSӀӤӨӸ0JNjԤԬ԰9Ws՚B`֖ $26x?؎Kcrقٛ PVڇڞڟڷPVۦ8>~ܤܥܱ Z݅ݹ+2ޗޛޝޞ23?t߁,\`am7>BDEV Z`d Ja,;P(9HU`hnv*u'@g,CDp<=efr*RkDcght4W04r&*8<5(7Gar%&?'l2Lwx)HLMYt+/12 _im,26h 8ODSo*.x]rvi9/}^ :IYt >Du./z 0 x     : ; G       K f      G f j k w        ; x      9FJ>BVO_cvz`n M eA )8Idu.FGag4:SY;pa,Gst(GKLXs"?|&q~37   p !!g!""?""""##-#A#[#####$$"$S$T$$$$$$$%K%d%e%%%& & &E&K&&&&&''#'r''''(>(D(|(((()#)J)K)u))))*"*#*/*t**+#+7+K+_+x+++,, ,c,,,---E-N-U-i-----.....i...../6/V/Z/[/g////00:0[0000000111H1L11252l2p22233w344424844455565[5~555566)6:6W6h66666777!7'7L7d7e777778)8/8^88888993949W9l9m999999:#:D:E:Q:::;;/;k;;+>?>P>m>>??(?9?J?d????@@b@~@@@@A$A2ANARASA_AAAABBNBBBCC5C<C@CBCCCCD4DADEDDDDE EREEEF\FlFpF~FFGGGHH4HzHII9I?IIIIIJ J!J7JHJeJvJJJKK#KTKkKlKKKLL5L6LzLLLLM!M"M.MsMMN?NNNNNOO(OMOqOrO~OOOOPPkPyPPPPQQ?QQQQQRRR6RZRRRRRRRSS4SgSSSTTTTTXTTTUUUuU|UUUUV%BoxConstraintsTweenDecorationTweenEdgeInsetsTweenEdgeInsetsGeometryTweenBorderRadiusTween BorderTween Matrix4TweenTextStyleTweenImplicitlyAnimatedWidgetImplicitlyAnimatedWidgetStateAnimatedWidgetBaseStateAnimatedContainer_AnimatedContainerStateAnimatedPadding_AnimatedPaddingState AnimatedAlign_AnimatedAlignStateAnimatedPositioned_AnimatedPositionedStateAnimatedPositionedDirectional#_AnimatedPositionedDirectionalState AnimatedScale_AnimatedScaleStateAnimatedRotation_AnimatedRotationState AnimatedSlide_AnimatedSlideStateAnimatedOpacity_AnimatedOpacityStateSliverAnimatedOpacity_SliverAnimatedOpacityStateAnimatedDefaultTextStyle_AnimatedDefaultTextStyleStateAnimatedPhysicalModel_AnimatedPhysicalModelStateAnimatedFractionallySizedBox"_AnimatedFractionallySizedBoxState&flutter.widgets.TweenVisitor.argumentsThe `tween` argument should contain the current tween value. This will initially be null when the state is first initialized. The `targetValue` argument should contain the value toward which the state is animating. For instance, if the state is animating its widget's opacity value, then this argument should contain the widget's current opacity value. The `constructor` argument should contain a function that takes a value (the widget's value being animated) and returns a tween beginning at that value.ͥ