setDependenciesgetDependencies notifyClients_recurseChildren createElement textDirectionofmaybeOfupdateShouldNotifydebugFillPropertiesopacityalwaysIncludeSemanticscreateRenderObjectupdateRenderObjectshaderCallback blendModefilterenabledpainterforegroundPaintersize isComplex willChangedidUnmountRenderObjectclipper clipBehavior borderRadiusshape elevationcolor shadowColor_computeRotation_createZRotation transformorigin alignmenttransformHitTests filterQualitylinkshowWhenUnlinked targetAnchorfollowerAnchoroffsetfit translation quarterTurnspadding widthFactor heightFactordelegateidapplyParentDatadebugTypicalAncestorWidgetClasswidthheight_additionalConstraints toStringShort constraints unmodified unconstrainedwidthUnconstrainedheightUnconstrainedmaxHeightUnconstrainedmaxWidthUnconstrainedmaxUnconstrained_debugKnownTransformsconstraintsTransform_debugTransformLabelconstrainedAxischild_axisToTransformbuildmaxWidth maxHeightminWidth minHeightoffstagedebugVisitOnstageChildren aspectRatio stepWidth stepHeight _stepWidth _stepHeightbaseline baselineTypemainAxisreverse _getDirection_debugCheckHasDirectionalitysizingindexchildrenwidgetlefttoprightbottomstartend directionmainAxisAlignment mainAxisSizecrossAxisAlignmentverticalDirection textBaselinespacing_needTextDirectiongetEffectiveTextDirectionflex runAlignment runSpacing_effectiveTextScalerFromtext textAlignsoftWrapoverflowtextScaleFactor textScalermaxLineslocale strutStyletextWidthBasistextHeightBehaviorselectionRegistrarselectionColorimagedebugImageLabelscalecolorBlendModerepeat centerSlicematchTextDirection invertColors isAntiAliasbundle renderBoxonBuild onUnmount onPointerDown onPointerMove onPointerUponPointerHoveronPointerCancelonPointerPanZoomStartonPointerPanZoomUpdateonPointerPanZoomEndonPointerSignalbehavioronEnteronHoveronExitcursoropaquehitTestBehaviorwrapAllignoringignoringSemantics absorbingmetaData properties containerexplicitChildNodesexcludeSemanticsblockUserActions_getTextDirectionblocking excludingensureUniqueKeysForListbuilder createState_colorpaintO_UbiquitousInheritedElement_UbiquitousInheritedWidgetDirectionalityOpacity ShaderMaskBackdropFilter CustomPaintClipRect ClipRRectClipOvalClipPath PhysicalModel PhysicalShape TransformCompositedTransformTargetCompositedTransformFollower FittedBoxFractionalTranslation RotatedBoxPaddingAlignCenterCustomSingleChildLayoutLayoutIdCustomMultiChildLayoutSizedBoxConstrainedBoxConstraintsTransformBoxUnconstrainedBoxFractionallySizedBox LimitedBox OverflowBoxSizedOverflowBoxOffstage_OffstageElement AspectRatioIntrinsicWidthIntrinsicHeightBaselineIgnoreBaselineSliverToBoxAdapter SliverPadding0getAxisDirectionFromAxisReverseAndDirectionalityListBodyStack IndexedStack_RawIndexedStack_IndexedStackElement PositionedPositionedDirectionalFlexRowColumnFlexibleExpandedWrapFlowRichTextRawImageDefaultAssetBundleWidgetToRenderBoxAdapterListener MouseRegionRepaintBoundary IgnorePointer AbsorbPointerMetaData SemanticsMergeSemanticsBlockSemanticsExcludeSemanticsIndexedSemantics KeyedSubtreeBuilderStatefulWidgetBuilderStatefulBuilder_StatefulBuilderState ColoredBox_RenderColoredBoxwImage ImageFilterTextHeightBehaviorChangeNotifierFlutterErrorDetails ListenableTargetPlatform ValueNotifierAlignmentGeometryTweenAlignmentTweenAxisBoxConstraintsBoxConstraintsTransformCrossAxisAlignment CustomClipper CustomPainterCustomPainterSemanticsDecorationPositionFlexFit FlowDelegateFlowPaintingContextFractionalOffsetTweenHitTestBehavior LayerLinkMainAxisAlignment MainAxisSize MouseCursorMultiChildLayoutDelegatePaintingContextPointerCancelEventPointerCancelEventListenerPointerDownEventPointerDownEventListener PointerEventPointerMoveEventPointerMoveEventListenerPointerUpEventPointerUpEventListener RelativeRectSemanticsBuilderCallbackShaderCallbackShapeBorderClipperSingleChildLayoutDelegateStackFitSystemMouseCursors TextOverflow ValueChanged ValueGetter WrapAlignmentWrapCrossAlignment AssetBundleInheritedElementWidgetoverridevoidElementObjectInheritedWidgetelementdoesDependOnInheritedElementnotifyDependentElementVisitor visitChildrenchildEdgeInsetsDirectional EdgeInsets TextDirection FlutterError BuildContextdebugCheckHasDirectionality"dependOnInheritedWidgetOfExactType textDirectionboolDiagnosticPropertiesBuilderdebugFillPropertiesadd EnumProperty blendModeTextAnimatedOpacityFadeTransitionColor Visibilitymaintain SliverOpacitySingleChildRenderObjectWidgetdouble RenderOpacityopacityalwaysIncludeSemanticsDoubleProperty FlagPropertyvalueifTrueShaderGradientlinear DecoratedBox BlendModemodulateLinearGradientRadialGradient SweepGradientRenderShaderMaskshaderCallbacksrcOversrc ImageFilteredblurRenderBackdropFilterfilterenabledSizezeromayCanvasRenderCustomPaintpainterforegroundPainter preferredSize isComplex willChange widthFactor heightFactorClipnonehardEdgeRectRenderClipRectclipper clipBehaviorDiagnosticsProperty defaultValue BorderRadius antiAliasBorderRadiusGeometryRRectRenderClipRRect borderRadiusmaybeOfshowNameRenderClipOval ShapeBordershapeKeykeybuildercontextPathRenderClipPathAnimatedPhysicalModelBoxShape rectangleRenderPhysicalModel elevationcolor shadowColor ColorPropertyRenderPhysicalShapeBoxFitRotationTransition AlignmentcenterangleOffsetMatrix4translationValuesoffsetdxdyScaleTransitionscalescaleXscaleYdiagonal3ValuesflipXflipYisFiniteidentitysincosstorageAlignmentDirectional centerStartxofltrrtl centerEndAlignmentGeometrymatrix FilterQualityRenderTransform transformorigin alignmenttransformHitTests filterQualityWidgetsBinding drawFrame LeaderLayerRenderLeaderLayerlink OverlayEntryOverlay MaterialApp Navigator FollowerLayertopLeft bottomLeftRenderFollowerLayershowWhenUnlinked leaderAnchorfollowerAnchor Placeholder ContainercontainRenderFittedBoxfit translateRenderFractionalTranslation translationrotateintRenderRotatedBox quarterTurnsCardpadding decorationAnimatedPaddingEdgeInsetsGeometry RenderPadding bottomRighttopRight FlutterLogoAFractionalOffset AnimatedAlignRenderPositionedBox RenderCustomSingleChildLayoutBoxdelegatehasChild layoutChild positionChildParentDataWidgetMultiChildLayoutParentDataValueKey RenderObject parentDataidparentmarkNeedsLayoutTypeMultiChildRenderObjectWidgetRenderCustomMultiChildLayoutBoxexpandinfinitysizewidthheight dimensionRenderConstrainedBoxadditionalConstraintstightForStringobjectRuntimeTypeDiagnosticLevelhiddeninfoleveldebugAssertIsValiddebugTransformType horizontalheightConstraintsverticalwidthConstraintscopyWith maxHeightmaxWidthMap isNormalizedRenderConstraintsTransformBoxconstraintsTransform isNotEmptyStatelessWidgetheightUnconstrainedwidthUnconstrained unconstrained"RenderFractionallySizedOverflowBoxRenderLimitedBoxRenderConstrainedOverflowBoxOverflowBoxFitmax deferToChildminWidth minHeightRenderSizedOverflowBox requestedSizeSnackBar TickerModeSliverOffstageRenderOffstageoffstageSingleChildRenderObjectElementwidgetdebugVisitOnstageChildrenRenderAspectRatio aspectRatioRenderIntrinsicWidthstretch RenderBoxgetMaxIntrinsicWidth stepWidth stepHeightRenderIntrinsicHeight TextBaselineRenderBaselinebaseline baselineTypeRenderIgnoreBaselineCustomScrollViewslivers SliverListSliverFixedExtentListSliverPrototypeExtentList SliverGridRenderSliverToBoxAdaptersliverRenderSliverPadding AxisDirectiondownupleftrightListViewGridViewPageViewSingleChildScrollViewtextDirectionToAxisDirectionflipAxisDirection axisDirectionRenderListBody RenderStacktopStartloosewhyhint alternative runtimeTypechildrenListgeneratelengthvisibleisizingindexRenderIndexedStack_debugCheckHasDirectionalityMultiChildRenderObjectElement elementAtStatefulWidgetRenderObjectWidgetAnimatedPositionedPositionedTransition AnimationStackParentData directionalrecttopbottomendstartAnimatedPositionedDirectionaltightmin spaceBetweenSpacerVerticalDirection identical TextStylefontSize RenderFlex protected directionmainAxisAlignment mainAxisSizecrossAxisAlignmentverticalDirection textBaselinespacingIcon IconThemeFlexParentDataflex IntPropertyChip RenderWrap runAlignment runSpacinggetSizegetConstraintsForChild paintChildrenwrapAll RenderFlowTextSpanDefaultTextStylerich SelectionAreaSelectableRegionSelectionRegistrarselectionRegistrarSelectionContainer TextAlignclip Deprecated TextScaler noScalingTextWidthBasis WidgetSpanextractFromInlineSpanscaler InlineSpantextScaleFactorRenderParagraphlocaleLocale StrutStyle textAlignsoftWrapoverflow textScalermaxLines strutStyletextWidthBasistextHeightBehavior Localizations maybeLocaleOf registrarselectionColortextifFalseifNullStringProperty toPlainText paintImageLeafRenderObjectWidget ImageRepeatnoRepeatmediumsrcIn drawImageRectPaint invertColors RenderImagedebugGetOpenHandleStackTracesimageclonedebugImageLabelcolorBlendModerepeat centerSlicematchTextDirection isAntiAlias AssetImage rootBundlebundleGlobalObjectKeydispose VoidCallbackRenderObjectElementunmountcallGestureDetectorPointerHoverEventListener PointerPanZoomStartEventListener!PointerPanZoomUpdateEventListenerPointerPanZoomEndEventListenerPointerSignalEventPointerSignalEventListenerRenderPointerListener onPointerDown onPointerMove onPointerUponPointerHoveronPointerCancelonPointerPanZoomStartonPointerPanZoomUpdateonPointerPanZoomEndonPointerSignalbehaviorIterablePropertyifEmptydeferMouseTrackerAnnotationonEnterPointerEnterEventListeneronExitStatesetStateRenderMouseRegionPointerExitEventListeneropaqueonHovercursorhitTestBehaviorpaintLayermarkNeedsPaintisRepaintBoundary paintChildDrawerdebugRepaintRainbowEnableddebugProfilePaintsEnabledwrapRenderRepaintBoundaryhitTestSemanticsActionSemanticsPropertiesSliverIgnorePointer SemanticsNodeRenderIgnorePointerignoringignoringSemanticsRenderAbsorbPointer absorbingdynamicRenderMetaDatametaDatadescribeSemanticsConfigurationSemanticsDebugger WidgetsAppshowSemanticsDebugger CupertinoApp immutablefromPropertiesSemanticsSortKeyUriAttributedString SemanticsTagMoveCursorHandlerSetSelectionHandlerSetTextHandlerCustomSemanticsAction containerexplicitChildNodesexcludeSemanticsblockUserActions propertiescheckedmixedexpandedtoggledselectedbuttonslider keyboardKeylinkUrlheader headingLevel textFieldreadOnly focusablefocusedinMutuallyExclusiveGroupobscured multiline scopesRoute namesRoute liveRegionmaxValueLengthcurrentValueLength identifierlabelattributedLabelattributedValueincreasedValueattributedIncreasedValuedecreasedValueattributedDecreasedValueattributedHinttooltipsortKeytagForChildrenonTap onLongPress onScrollLeft onScrollRight onScrollUp onScrollDown onIncrease onDecreaseonCopyonCutonPasteonMoveCursorForwardByCharacteronMoveCursorBackwardByCharacteronDidGainAccessibilityFocusonDidLoseAccessibilityFocusonFocus onDismissonSetSelection onSetTextcustomSemanticsActions hintOverrides onTapHintonLongPressHintSemanticsHintOverridesSemanticsConfigurationisSemanticBoundarytapRenderSemanticsAnnotationsCheckboxRenderMergeSemanticsRenderBlockSemanticsblockingRenderExcludeSemantics excludingRenderIndexedSemanticsisEmptyindexeditem baseIndexdebugItemsHaveDuplicateKeysScaffold ScaffoldState WidgetBuilder StateSetter!RenderProxyBoxWithHitTestBehaviorcanvasdrawRectInheritedElementInheritedWidget_UbiquitousInheritedWidgetSingleChildRenderObjectWidgetAlignParentDataWidgetMultiChildRenderObjectWidgetStatelessWidgetSingleChildRenderObjectElementStackMultiChildRenderObjectElementFlexFlexibleLeafRenderObjectWidgetStatefulWidgetState!RenderProxyBoxWithHitTestBehaviorXWl$fnpackage:flutter/animation.dartqChangeNotifierFlutterErrorDetails ListenableTargetPlatform ValueNotifierHpackage:flutter/foundation.dartpackage:flutter/painting.dart s*AlignmentGeometryTweenAlignmentTweenAxisBoxConstraintsBoxConstraintsTransformCrossAxisAlignment CustomClipper CustomPainterCustomPainterSemanticsDecorationPositionFlexFit FlowDelegateFlowPaintingContextFractionalOffsetTweenHitTestBehavior LayerLinkMainAxisAlignment MainAxisSize MouseCursorMultiChildLayoutDelegatePaintingContextPointerCancelEventPointerCancelEventListenerPointerDownEventPointerDownEventListener PointerEventPointerMoveEventPointerMoveEventListenerPointerUpEventPointerUpEventListener RelativeRectSemanticsBuilderCallbackShaderCallbackShapeBorderClipperSingleChildLayoutDelegateStackFitSystemMouseCursors TextOverflow ValueChanged ValueGetter WrapAlignmentWrapCrossAlignmentpackage:flutter/rendering.dart AssetBundleupackage:flutter/services.dart Zlmatho dart:mathImage ImageFilterTextHeightBehaviorvuidart:uipackage:flutter/animation.dartpackage:flutter/foundation.dartpackage:flutter/gestures.dart6package:flutter/rendering.dart_package:flutter/services.dart binding.dart debug.dartframework.dartlocalizations.dartvisibility.dartwidget_span.dartf< OXYu 5^̂HvЃ%?QYk؄ 9LYn~҅ 0D`rʆ /?N_uɈ]z.LMkl<@ۋ)wŌhw+,8s-HLMY܏ CpxϏ#+AEGHVZ;nnnnnno@oDooooooopNppq qq#qmqqqqqqqr#rhrrrs(s.s~sssst+t?tNtyttttttuuLugumuuuvv'v(vdvjvvvvvww1wIwkwwwwwx xx>xbx|xxxxy y6yzz#z%z&zWz[zzz{9{{{{{|#|X||||};}X}^}}}}}~~~~H~N~~~~7x78D):Ty}~>i JBY] QSH[j|+F^l3ZtLR./kqBFGS@aefrHLNO8|IbZ`:Ra#4UVo/5Vdj Yy!(,-90SWXdehlT|0Y]#A}/GVq)*NT 12hn ,FGcxy*Jb@Qk<g(gkmno)p=AUY0W >IRX`pt3`/g!9JPQf};oz%:Idu[a 4]w &>Mi-.ouac?X^tz%9S %vAYj;ABJTfy#I1e 5Ktz,2Y]^:Xv‰Ž6ntciĵXš3vƼ_ǀu%&2oɋɧɽ;_fjkw,d˒˹˽˿ W̢A͆͊L{΍Α!iϝϣ#GVnЅІWyёђў %wҕҙқҜ&qӷVԡ>x|A֊*uyׇ׋cح8pv1P{ڨڹڿ1IJە!gmܻ34zݤݪ:ފb߭"#r=>Ggy m~#')*osd{;M.BQp./hnAGmsHm So [l~ Oz OS"&c#6Rag Nno{ 8?CDP`dIM'+7Md*l.=]ntuRS_"eiG rv 8<1>B1yEIjQ @deq ,z4_#'v26 # m   J N b   1 5       5 U q           % ) { (,@)Y!t,0Z^jv!?Ubmv|Rm %)PIMYe}5KXclrzVm-x"VfuPQoubOtz J x    !<!Y!Z!!!"""%"f""""##!#%#&#2#####$4$8$9$E$$% %]%%%%%%&B&&'('v'(( (((f(())g)))*(*{*}*~**++f+++++,",m,,-<---.,.X.z....../#/$/0/~////010W0[0]0^00011P1111122?2@2y222223393|3444M4S4W4X4d44445'5b5f5h5i5566Q6667 7R77888h8z8~889-919999999:Q:f::;;o;;<<<<]><>@>B>C>d>h>? ?Z??@G@|@@A#AbAfABBMBQBBC CCSCWCkCoCCCDDD-DBDrDxDDDDDDE:EEEFFVFFG&GsGGH2HHHI4I5IyIIIIJ1JeJxJJJJKK.K/KiKKKKL$L;L<LLLLLMM<MCMGMHMvMMMMNN_NcNdNpNNOO`OOOOOOPPFPgPPPQQ,Q2QQQQQR&R*RzRRRSS!S5S9SSSSSTTOTUT]TmTqTTTTUU`UtUUV5VVWWcWWWX X*X;XlXmXXXXYY^YbYcYoYYYYZ ZPZ{ZZZZ[7[[[\\T\\]=]]]^*^c^g^^^__^__`M````aa^aab bbb)bqbbcc@cHcNcVcfcjcxc|ccd)dYddeebeeef,f2ffffffgg>gaggghh+h1hhii iWiiijMjajjk kk kmkklKlLllllm<mmmmn(n9n?nnnosotooop&pppq q qUqqqrr^rrscsssttKttttuu;uAuuuuv'v?vEvvvvvvwAwfwgwwwwx9x^xdxxxy y yByHyyz-zyzzzz{{{:{;{G{{|||Q|s|z|~|||}}M}}}}}}~~E~~~Gd"(,./|: ;? U 1(xV #FLMiu{=>ou_w >Du=%Ie7b{/3vz#SWOK6JixST<w}R/5| '-{f*0V\lr1Vk8Xz+<Z|/ZX\^_7|c`ptO F!GXxW <CGHTGr&*,-w%)q@6Jz=Sb 06!o39_eu{:_)*vZuvFL8ze&\cght8Vt@0^GVb(O`fg'vcC´ +oÒîizĘĵ?jžaư0LPǟ9ȅfɶ"&k{ʍʑ6r˿,pq̴̮P}̓KΚΠbcoϾ:eЪЮЯл  Juvтѽ!#$mqKOӛ9aeԪAEՋn֙֝/׀ׄט9y}HX\pbڔژ X۩@ܑ0mqݺ _ޯJ߃ߑߕ]kV!2TU89E=ABNOS<L/W[59%37EI-@P&,u56(.v JPw&h0Oquwx ]fOe)q"f7uFGSMa}&Ul3Ohi]abna|i !"-.^bERV3~  h1Y F H I     k u y      F      $ A B       * [ b f g s   &*+7|T#;?jgRjw1'+-. UX\ C#=QWX-z6aefrP,} <  !!!r!"")"-"z"##^##$$ $T$X$$%<%%%%%%&&&&&&'''6'A'T'i''''''((((('(7(;(O(S((()))))))***.*G*h*u***++8+d+++,,",5,F,U,t,,,,-- ---(-,-:->--..%.q.../1/d////000J0b00000111%1s122W2]223@3\3b333334$4p444445-5S5T5556$6?6U6V6667,7}788d88888997989t999:):;;;;;;;;<-=q====> >$>%>1>v>>?Z?????@=@A@@@@@A-A1AEAAAB-B=BABOBSBBBC7CNC]CCCCDD,D2D3DDDDDEE%E&EbEhEEEEEFF9F:FvF|FFFFFGGGSGgGhGGGGHHH H,HSHHHIIII6IRIvIIIIIIIIJ)JPJJJJJKK&K:KUKVK|KKKKLL/LCLSLuLLLLLLMCMvMMMMMN;N?N@NLN~NNNNNO&O'O3OvOwOOOP2PPPPPPPPPQQOQQRRRGRKRRS<S{SSTToTUUAUEUUUVVRVVVdVhVVWLWWXXdXjXXY9YWY]YmYsYZZWZZZZZZZZ[[)[h[[[[\<\\\\\\]]]8]U]j]]]]^%^v^^^^^__*_G_\_r_s__` ``1`E`[`r````aa aPaaaabMbbc3cdcjczcccdd+d>dOd`dtddddee)eReYepeeeeeeef ffffifofffg=gQggghgghh5h;hhhhi iiciiiijj j`jfjjjk3kEk]k^kwk}kkklKl_lvlwlllm mmdmvmmmmnn[nynznnnnnnoo3o9o:o_oooooopp p p/pOpipoppppppppqq%q)q*q6qkqlqxqqr.rrrssLssssstttktttu(uuuuuv8vvvvw6wwx#xhxxxxyyPyyz3zCzyzz{{W{{{{{|&|u|||||||}}}!}"}r}}}~~~~k~q~~~~JciLRSv$<=msBVfv r`mq ['+uJ?CrvP(vX9%>%u\-{F,za$KQ>-W4WoJDV\ :;u{U[Ht%kqQ2ab$q !'w;ARXe#$s.xnSzIvw%j:RSs=z]O:|hu$\s Dp9Jh%Sw 7wBK0SWBvz Z3xc%4N`"4Pr_­MÖ+/CGz~ĊęijżOƟ<PTǤBȎȴȸ aɜɠɬɻ2;AIM˞?̐.x|+΂%gϣϧϳ-(3ajpx|?҄҈ҶҺ Wӓ XԦCՓ3i׺Cؓ2zٸTڟVjۻ Sܡ5;݀ݧݭMޛ5M[j߇ߟ߽K^r7Z^O/3dht>KV_em} k04@LM,jPT@bW(yXDcg YB7;gkU HLdh,0 WlE)w.oY H-QUcgH'[>DV3QjIM3-}  ^3   3 9    g y z    T   " 7 8 D x     C a {        %+/0<pq} "#e:)zDH\Tim'u0zMQ;&cg"&:>4N\^*5Ca  ! o   !:!!"""#"I"s"""# ###X#{#####$$b$$%%%\%b%&&&/&5&E&K&&' 'K'l'm''( (=(C(()))<)B)Y)q)r))**U*[*****+#+r+++,",(,u,,,-L-----..$.*.q.// /9/?/O/U//0)0K0z0{011171=1122=2C2233D3J334+4p4445*5m566&6'6v6667L77788i8o899R999::S::; ;8;9;o;u;;;;;< <'>(>L>l>>??8?<?=?I???@B@z@AAgABOBSBUBVBBBC C C\CjCnCDD7DkDoDEEWEEF1F5FFG GMGQGeGHH8H<H}HHHHI IYI]IIIJ3JJJKKNKKKL!LrLMMMMMgMMN=NTNNNO0OMOSOOOOPP2PYPPPPPQAQQQQQRR+R1R2RRRRRRSSS#SSSSTTDTHTJTKTiTmTTUURUUVVVdVWWFWJWWX8XXXXXXYJYYYYYYZZ(Z[ZZZ[[ [[['[+[=[A[[[\,\t\\\]&]I]M]a]e]]]^/^3^?^M^x^^^^_____Q__``^`aa7a_aeaaab=bhbubbbbbcc,cMcccd dRdedvddddee@eefAffggKg{gh hhhhAhZh[hhhhhiiDiJiij5j~jjjk3kgkkkkl3lJlKlxllllmm8m>mmmmnInnnnnooorooop0pGp^p_pppq$qvq|qqqrr%r&rarrrrrs's-sfsssstttRtttttuu^uuuuvv/vIvgvvvwwDwKwOwPw\wwxxx:x~xxxxyy:yjyyyyyz zPz{z{D{|S|}}}~"~>BfMQbu3Ah7=>Z`AZ[<Pgh !lrRhiJ]  9?5XYKQ@#Y_^v|1}34ciP=C4< ;<{kqm2>EYo7e3:>?K2FM^}CUsGk7VZ[gb:Lx8%]auy]am OYu} ,Wt&*t @o#=W]^M C=?@(IM4N*>mn =>"<[\cM.XABN 7;=>?QR#r1dh]au7G~!0H`v"TeklHI8efT‡ˆ=>Ã12YĖė<MłŃū?cƇƧ)_ǏǷ?PvȜȾF~ɰMxʥGt˭JQ̪)-pt͎(W[Ψο#'vϸϼX\Хей7qѱѷ5DVgyҞҶ&,w DwԾL՜&vLו׶3JP؟`fٱLڠڱ-BHۓ+rxܸEK݁݇ =Cޒ0߀ag<A;AW9[a/yi,2qw,{KLhi3tz S*OUr&e$()5?CDP3W^hlno@P?C.?Co[DI1uybO}8g&n/5E <@(LP[#48dw{ R1?C  0 4      / 3 A E    F      ! \ b ~      $ l r     (AG8quJQUVb#hCGIJ$s!^b [ #p Pcg>z~,0 "s !/36N]x6GMN-=Cz\b  G K l m y   !"!)!-!.!:!!!!!!!"B"m"####%#&#U#Y##$F$k$$$%%%8%G%Z%%%%%%%&&<&=&I&&&&&&&&';'L'h'''''((O((((((())))g))))))*M**++M++,,J,,--M---. ..K.y..../3//////00&0I0\0o0000000111-1B1V1k1~111112 2212E2^2{222233#3S3o333344 4B4a4444455:5X5v555566P6y66677W7s777788)8N8f8~888889 9*9<9T9j99999:0:J:f:::::;;@;^;r;;;;<6<\<<<<= ="=H=\=|===>> >>>T>h>>??N????@@:@~@@@@AAA AJAmA|AAAABB2B8B9BBBBC CLCCCD=DYDqDrDDEEPEEFFDFhFnFFG GGtGGGH%H+HDHJHHI,IKILIIIJ'JkJqJK KBKHKKKKLLL'LELKLvLLLLMM8MEMPMXMbMhMMMMMNDNkNNNO O'OXO_OcOdOOOOOP=PwPPQ$Q%Q>QQQWQXQQQQQRRROR{RRRRSS SQS|ST TUTYT[T\TTTU%UhUUV1VuVVVWW@WDWPWdWvWWWWWXX"X+X1X9XIXMXXYYUYYZZ.ZkZZZZ[L[N[O[[[\\c\\]] ].]2]z]^^1^{^|^^___ ____````&`k`````a a$aqaaabbWbzb~bbbccecccccccddd$dddde#e'e(e4eyeeeeef1f5ffgghgggggh7hhhhhhhiiJi\iiiiiiiiij(jgjjjjkkkkWkjkkkwkkklFlfljlvllm$m(m*m+mOmSmmmnnnnnno'o-o^otouoopYprpppppq,q3q4qsqqqqqqqrrHrLrrrs s$s0sXsvsssssstt t8tWt_tcttttttu9uBuHuPuTuuvvavvvw)wgwkwwwwwwxxIxwxxxxxyy yyy`yyyyyyz!z<z]z}zzz{ {{&{1{:{@{H{L{Z{^{{||O|a|p|||||}}a}}~~=~>~J~~~~~lm]=AUY'GcY~:Qfz!PkUy0<1yNz~ eI_-3G]abn=0Z`df/// @docImport 'dart:ui'; /// @docImport 'package:flutter/cupertino.dart'; /// @docImport 'package:flutter/material.dart'; /// @docImport 'package:flutter/widgets.dart'; Ypu 5^Hq΃ suMlڌ} /// An [InheritedElement] that has hundreds of dependencies but will /// infrequently change. This provides a performance tradeoff where building /// the [Widget]s is faster but performing updates is slower. /// /// | | _UbiquitousInheritedElement | InheritedElement | /// |---------------------|------------------------------|------------------| /// | insert (best case) | O(1) | O(1) | /// | insert (worst case) | O(1) | O(n) | /// | search (best case) | O(n) | O(1) | /// | search (worst case) | O(n) | O(n) | /// /// Insert happens when building the [Widget] tree, search happens when updating /// [Widget]s.tG/// Creates an element that uses the given widget as its configuration. #.?OXb k./OMcs|OP㎱HJg/// See also: /// /// * [_UbiquitousInheritedElement], the [Element] for [_UbiquitousInheritedWidget].D #3>R[>?/// A widget that determines the ambient directionality of text and /// text-direction-sensitive render objects. /// /// For example, [Padding] depends on the [Directionality] to resolve /// [EdgeInsetsDirectional] objects into absolute [EdgeInsets] objects.ӀN\p/// Creates a widget that determines the directionality of text and /// text-direction-sensitive render objects.c jrL(/// The text direction for this subtree.)Z/// The text direction from the closest instance of this class that encloses /// the given context. /// /// If there is no [Directionality] ancestor widget in the tree at the given /// context, then this will throw a descriptive [FlutterError] in debug mode /// and an exception in release mode. /// /// Typical usage is as follows: /// /// ```dart /// TextDirection textDirection = Directionality.of(context); /// ``` /// /// See also: /// /// * [maybeOf], which will return null if no [Directionality] ancestor /// widget is in the tree.]k07/// The text direction from the closest instance of this class that encloses /// the given context. /// /// If there is no [Directionality] ancestor widget in the tree at the given /// context, then this will return null. /// /// Typical usage is as follows: /// /// ```dart /// TextDirection? textDirection = Directionality.maybeOf(context); /// ``` /// /// See also: /// /// * [of], which will throw if no [Directionality] ancestor widget is in the /// tree.?MjOΚ`t&OP54O/// A widget that makes its child partially transparent. /// /// This class paints its child into an intermediate buffer and then blends the /// child back into the scene partially transparent. /// /// For values of opacity other than 0.0 and 1.0, this class is relatively /// expensive because it requires painting the child into an intermediate /// buffer. For the value 0.0, the child is not painted at all. For the /// value 1.0, the child is painted immediately without an intermediate buffer. /// /// The presence of the intermediate buffer which has a transparent background /// by default may cause some child widgets to behave differently. For example /// a [BackdropFilter] child will only be able to apply its filter to the content /// between this widget and the backdrop child and may require adjusting the /// [BackdropFilter.blendMode] property to produce the desired results. /// /// {@youtube 560 315 https://www.youtube.com/watch?v=9hltevOHQBw} /// /// {@tool snippet} /// /// This example shows some [Text] when the `_visible` member field is true, and /// hides it when it is false: /// /// ```dart /// Opacity( /// opacity: _visible ? 1.0 : 0.0, /// child: const Text("Now you see me, now you don't!"), /// ) /// ``` /// {@end-tool} /// /// This is more efficient than adding and removing the child widget from the /// tree on demand. /// /// ## Performance considerations for opacity animation /// /// Animating an [Opacity] widget directly causes the widget (and possibly its /// subtree) to rebuild each frame, which is not very efficient. Consider using /// one of these alternative widgets instead: /// /// * [AnimatedOpacity], which uses an animation internally to efficiently /// animate opacity. /// * [FadeTransition], which uses a provided animation to efficiently animate /// opacity. /// /// ## Transparent image /// /// If only a single [Image] or [Color] needs to be composited with an opacity /// between 0.0 and 1.0, it's much faster to directly use them without [Opacity] /// widgets. /// /// For example, `Container(color: Color.fromRGBO(255, 0, 0, 0.5))` is much /// faster than `Opacity(opacity: 0.5, child: Container(color: Colors.red))`. /// /// {@tool snippet} /// /// The following example draws an [Image] with 0.5 opacity without using /// [Opacity]: /// /// ```dart /// Image.network( /// 'https://raw.githubusercontent.com/flutter/assets-for-api-docs/main/packages/diagrams/assets/blend_mode_destination.jpeg', /// color: const Color.fromRGBO(255, 255, 255, 0.5), /// colorBlendMode: BlendMode.modulate /// ) /// ``` /// /// {@end-tool} /// /// Directly drawing an [Image] or [Color] with opacity is faster than using /// [Opacity] on top of them because [Opacity] could apply the opacity to a /// group of widgets and therefore a costly offscreen buffer will be used. /// Drawing content into the offscreen buffer may also trigger render target /// switches and such switching is particularly slow in older GPUs. /// /// ## Hit testing /// /// Setting the [opacity] to zero does not prevent hit testing from being applied /// to the descendants of the [Opacity] widget. This can be confusing for the /// user, who may not see anything, and may believe the area of the interface /// where the [Opacity] 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 [Opacity] /// widget at all when the [opacity] is 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. /// /// See also: /// /// * [Visibility], which can hide a child more efficiently (albeit less /// subtly, because it is either visible or hidden, rather than allowing /// fractional opacity values). Specifically, the [Visibility.maintain] /// constructor is equivalent to using an opacity widget with values of /// `0.0` or `1.0`. /// * [ShaderMask], which can apply more elaborate effects to its child. /// * [Transform], which applies an arbitrary transform to its child widget at /// paint time. /// * [SliverOpacity], the sliver version of this widget.3/// Creates a widget that makes its child partially transparent. /// /// The [opacity] argument must be between zero and one, inclusive.$ +3BN#Tw ~ lV3/// The fraction to scale the child's alpha value. /// /// An opacity of one is fully opaque. An opacity of zero is fully transparent /// (i.e., invisible). /// /// Values one and zero are painted with a fast path. Other values require /// painting the child into an intermediate buffer, which is expensive.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.rrs52FZ&w56kЄ^/// A widget that applies a mask generated by a [Shader] to its child. /// /// For example, [ShaderMask] can be used to gradually fade out the edge /// of a child by using a [ui.Gradient.linear] mask. /// /// {@youtube 560 315 https://www.youtube.com/watch?v=7sUL66pTQ7Q} /// /// {@tool snippet} /// /// This example makes the text look like it is on fire: /// /// ```dart /// ShaderMask( /// shaderCallback: (Rect bounds) { /// return RadialGradient( /// center: Alignment.topLeft, /// radius: 1.0, /// colors: [Colors.yellow, Colors.deepOrange.shade900], /// tileMode: TileMode.mirror, /// ).createShader(bounds); /// }, /// child: const Text( /// "I'm burning the memories", /// style: TextStyle(color: Colors.white), /// ), /// ) /// ``` /// {@end-tool} /// /// See also: /// /// * [Opacity], which can apply a uniform alpha effect to its child. /// * [CustomPaint], which lets you draw directly on the canvas. /// * [DecoratedBox], for another approach at decorating child widgets. /// * [BackdropFilter], which applies an image filter to the background.\fN/// Creates a widget that applies a mask generated by a [Shader] to its child.m t|# ݁ʺ/// Called to create the [dart:ui.Shader] that generates the mask. /// /// The shader callback is called with the current size of the child so that /// it can customize the shader to the size and location of the child. /// /// Typically this will use a [LinearGradient], [RadialGradient], or /// [SweepGradient] to create the [dart:ui.Shader], though the /// [dart:ui.ImageShader] class could also be used./// The [BlendMode] to use when applying the shader to the child. /// /// The default, [BlendMode.modulate], is useful for applying an alpha blend /// to the child. Other blend modes can be used to create other effects.ctcdKn/// A widget that applies a filter to the existing painted content and then /// paints [child]. /// /// The filter will be applied to all the area within its parent or ancestor /// widget's clip. If there's no clip, the filter will be applied to the full /// screen. /// /// The results of the filter will be blended back into the background using /// the [blendMode] parameter. /// {@template flutter.widgets.BackdropFilter.blendMode} /// The only value for [blendMode] that is supported on all platforms is /// [BlendMode.srcOver] which works well for most scenes. But that value may /// produce surprising results when a parent of the [BackdropFilter] uses a /// temporary buffer, or save layer, as does an [Opacity] widget. In that /// situation, a value of [BlendMode.src] can produce more pleasing results, /// but at the cost of incompatibility with some platforms, most notably the /// html renderer for web applications. /// {@endtemplate} /// /// {@youtube 560 315 https://www.youtube.com/watch?v=dYRs7Q1vfYI} /// /// {@tool snippet} /// If the [BackdropFilter] needs to be applied to an area that exactly matches /// its child, wraps the [BackdropFilter] with a clip widget that clips exactly /// to that child. /// /// ```dart /// Stack( /// fit: StackFit.expand, /// children: [ /// Text('0' * 10000), /// Center( /// child: ClipRect( // <-- clips to the 200x200 [Container] below /// child: BackdropFilter( /// filter: ui.ImageFilter.blur( /// sigmaX: 5.0, /// sigmaY: 5.0, /// ), /// child: Container( /// alignment: Alignment.center, /// width: 200.0, /// height: 200.0, /// child: const Text('Hello World'), /// ), /// ), /// ), /// ), /// ], /// ) /// ``` /// {@end-tool} /// /// This effect is relatively expensive, especially if the filter is non-local, /// such as a blur. /// /// If all you want to do is apply an [ImageFilter] to a single widget /// (as opposed to applying the filter to everything _beneath_ a widget), use /// [ImageFiltered] instead. For that scenario, [ImageFiltered] is both /// easier to use and less expensive than [BackdropFilter]. /// /// {@tool snippet} /// /// This example shows how the common case of applying a [BackdropFilter] blur /// to a single sibling can be replaced with an [ImageFiltered] widget. This code /// is generally simpler and the performance will be improved dramatically for /// complex filters like blurs. /// /// The implementation below is unnecessarily expensive. /// /// ```dart /// Widget buildBackdrop() { /// return Stack( /// children: [ /// Positioned.fill(child: Image.asset('image.png')), /// Positioned.fill( /// child: BackdropFilter( /// filter: ui.ImageFilter.blur(sigmaX: 6, sigmaY: 6), /// ), /// ), /// ], /// ); /// } /// ``` /// {@end-tool} /// {@tool snippet} /// Instead consider the following approach which directly applies a blur /// to the child widget. /// /// ```dart /// Widget buildFilter() { /// return ImageFiltered( /// imageFilter: ui.ImageFilter.blur(sigmaX: 6, sigmaY: 6), /// child: Image.asset('image.png'), /// ); /// } /// ``` /// /// {@end-tool} /// /// See also: /// /// * [ImageFiltered], which applies an [ImageFilter] to its child. /// * [DecoratedBox], which draws a background under (or over) a widget. /// * [Opacity], which changes the opacity of the widget itself. /// * https://flutter.dev/go/ios-platformview-backdrop-filter-blur for details and restrictions when an iOS PlatformView needs to be blurred.Kˁ)LcLq/// Creates a backdrop filter. /// /// The [blendMode] argument will default to [BlendMode.srcOver] and must not be /// null if provided.Lx LLLL LL"LLLLLLLLMˀ/// The image filter to apply to the existing painted content before painting the child. /// /// For example, consider using [ImageFilter.blur] to create a backdrop /// blur effect.MրN/// The blend mode to use to apply the filtered background content onto the background /// surface. /// /// {@macro flutter.widgets.BackdropFilter.blendMode}NO{/// Whether or not to apply the backdrop filter operation to the child of this /// widget. /// /// Prefer setting enabled to `false` instead of creating a "no-op" filter /// type for performance reasons.OOOOOOP3PDPWPePm!PP3P4P8Y/// A widget that provides a canvas on which to draw during the paint phase. /// /// When asked to paint, [CustomPaint] first asks its [painter] to paint on the /// current canvas, then it paints its child, and then, after painting its /// child, it asks its [foregroundPainter] to paint. The coordinate system of the /// canvas matches the coordinate system of the [CustomPaint] object. The /// painters are expected to paint within a rectangle starting at the origin and /// encompassing a region of the given size. (If the painters paint outside /// those bounds, there might be insufficient memory allocated to rasterize the /// painting commands and the resulting behavior is undefined.) To enforce /// painting within those bounds, consider wrapping this [CustomPaint] with a /// [ClipRect] widget. /// /// Painters are implemented by subclassing [CustomPainter]. /// /// {@youtube 560 315 https://www.youtube.com/watch?v=kp14Y4uHpHs} /// /// Because custom paint calls its painters during paint, you cannot call /// `setState` or `markNeedsLayout` during the callback (the layout for this /// frame has already happened). /// /// Custom painters normally size themselves to their [child]. If they do not /// have a child, they attempt to size themselves to the specified [size], which /// defaults to [Size.zero]. The parent [may enforce constraints on this /// size](https://docs.flutter.dev/ui/layout/constraints). /// /// The [isComplex] and [willChange] properties are hints to the compositor's /// raster cache. /// /// {@tool snippet} /// /// This example shows how the sample custom painter shown at [CustomPainter] /// could be used in a [CustomPaint] widget to display a background to some /// text. /// /// ```dart /// CustomPaint( /// painter: Sky(), /// child: const Center( /// child: Text( /// 'Once upon a time...', /// style: TextStyle( /// fontSize: 40.0, /// fontWeight: FontWeight.w900, /// color: Color(0xFFFFFFFF), /// ), /// ), /// ), /// ) /// ``` /// {@end-tool} /// /// See also: /// /// * [CustomPainter], the class to extend when creating custom painters. /// * [Canvas], the class that a custom painter uses to paint.YځEZZ1/// Creates a widget that delegates its painting.Z& Z-Z5 Z;ZGZMZcZiZ~ZZZZ ZZoZsZtZZZZ[ZZZZZZZZ[[[[[[[[#O[k0/// The painter that paints before the children.[wX[//// The painter that paints after the children.[ԁ\׀/// The size that this [CustomPaint] should aim for, given the layout /// constraints, if there is no child. /// /// Defaults to [Size.zero]. /// /// If there's a child, this is ignored, and the size of the child is used /// instead.\N_%%/// Whether the painting is complex enough to benefit from caching. /// /// The compositor contains a raster cache that holds bitmaps of layers in /// order to avoid the cost of repeatedly rendering those layers on each /// frame. If this flag is not set, then the compositor will apply its own /// heuristics to decide whether the layer containing this widget is complex /// enough to benefit from caching. /// /// This flag can't be set to true if both [painter] and [foregroundPainter] /// are null because this flag will be ignored in such case._3<ae/// Whether the raster cache should be told that this painting is likely /// to change in the next frame. /// /// This hint tells the compositor not to cache the layer containing this /// widget because the cache will not be used in the future. If this hint is /// not set, the compositor will apply its own heuristics to decide whether /// the layer is likely to be reused in the future. /// /// This flag can't be set to true if both [painter] and [foregroundPainter] /// are null because this flag will be ignored in such case.at aaaataubbbbbbbbccccccd5xh/// A widget that clips its child using a rectangle. /// /// By default, [ClipRect] prevents its child from painting outside its /// bounds, but the size and location of the clip rect can be customized using a /// custom [clipper]. /// /// [ClipRect] is commonly used with these widgets, which commonly paint outside /// their bounds: /// /// * [CustomPaint] /// * [CustomSingleChildLayout] /// * [CustomMultiChildLayout] /// * [Align] and [Center] (e.g., if [Align.widthFactor] or /// [Align.heightFactor] is less than 1.0). /// * [OverflowBox] /// * [SizedOverflowBox] /// /// {@tool snippet} /// /// For example, by combining a [ClipRect] with an [Align], one can show just /// the top half of an [Image]: /// /// ```dart /// ClipRect( /// child: Align( /// alignment: Alignment.topCenter, /// heightFactor: 0.5, /// child: Image.network(userAvatarUrl), /// ), /// ) /// ``` /// {@end-tool} /// /// See also: /// /// * [CustomClipper], for information about creating custom clips. /// * [ClipRRect], for a clip with rounded corners. /// * [ClipOval], for an elliptical clip. /// * [ClipPath], for an arbitrarily shaped clip.hCiiՀ/// Creates a rectangular clip. /// /// If [clipper] is null, the clip will match the layout size and position of /// the child. /// /// If [clipBehavior] is [Clip.none], no clipping will be applied.i ii ii!jj$ j+jjjj:Sj./// If non-null, determines which clip to use.j|k^/// {@macro flutter.rendering.ClipRectLayer.clipBehavior} /// /// Defaults to [Clip.hardEdge].kk.kAkOkkkkkkkkkklYkljlllYlZlȀll&m llmur̅/// A widget that clips its child using a rounded rectangle. /// /// By default, [ClipRRect] uses its own bounds as the base rectangle for the /// clip, but the size and location of the clip can be customized using a custom /// [clipper]. /// /// {@youtube 560 315 https://www.youtube.com/watch?v=eI43jkQkrvs} /// /// {@tool dartpad} /// This example shows various [ClipRRect]s applied to containers. /// /// ** See code in examples/api/lib/widgets/basic/clip_rrect.0.dart ** /// {@end-tool} /// /// ## Troubleshooting /// /// ### Why doesn't my [ClipRRect] child have rounded corners? /// /// When a [ClipRRect] is bigger than the child it contains, its rounded corners /// could be drawn in unexpected positions. Make sure that [ClipRRect] and its child /// have the same bounds (by shrinking the [ClipRRect] with a [FittedBox] or by /// growing the child). /// /// {@tool dartpad} /// This example shows a [ClipRRect] that adds round corners to an image. /// /// ** See code in examples/api/lib/widgets/basic/clip_rrect.1.dart ** /// {@end-tool} /// /// See also: /// /// * [CustomClipper], for information about creating custom clips. /// * [ClipRect], for more efficient clips without rounded corners. /// * [ClipOval], for an elliptical clip. /// * [ClipPath], for an arbitrarily shaped clip.st3t</// Creates a rounded-rectangular clip. /// /// The [borderRadius] defaults to [BorderRadius.zero], i.e. a rectangle with /// right-angled corners. /// /// If [clipper] is non-null, then [borderRadius] is ignored. /// /// If [clipBehavior] is [Clip.none], no clipping will be applied.tC tJtR%tXt} tt"tt ttftrtstttt̀u/// The border radius of the rounded corners. /// /// Values are clamped so that horizontal and vertical radii sums do not /// exceed width/height. /// /// This value is ignored if [clipper] is non-null.uTv./// If non-null, determines which clip to use.v*}v_/// {@macro flutter.rendering.ClipRectLayer.clipBehavior} /// /// Defaults to [Clip.antiAlias].vvvvvvw wwwwwwwxfxx&xxxz&|d/// A widget that clips its child using an oval. /// /// {@youtube 560 315 https://www.youtube.com/watch?v=vzWWDO6whIM} /// /// By default, inscribes an axis-aligned oval into its layout dimensions and /// prevents its child from painting outside that oval, but the size and /// location of the clip oval can be customized using a custom [clipper]. /// /// See also: /// /// * [CustomClipper], for information about creating custom clips. /// * [ClipRect], for more efficient clips without rounded corners. /// * [ClipRRect], for a clip with rounded corners. /// * [ClipPath], for an arbitrarily shaped clip.|āQ}}/// Creates an oval-shaped clip. /// /// If [clipper] is null, the oval will be inscribed into the layout size and /// position of the child. /// /// If [clipBehavior] is [Clip.none], no clipping will be applied.} }} }}"}~ ~ }}}~e/// If non-null, determines which clip to use. /// /// The delegate returns a rectangle that describes the axis-aligned /// bounding box of the oval. The oval's axes will themselves also /// be axis-aligned. /// /// If the [clipper] delegate is null, then the oval uses the /// widget's bounding box (the layout dimensions of the render /// object) instead.})_/// {@macro flutter.rendering.ClipRectLayer.clipBehavior} /// /// Defaults to [Clip.antiAlias].:Uhv:;Ѐ k&1֋w/// A widget that clips its child using a path. /// /// Calls a callback on a delegate whenever the widget is to be /// painted. The callback returns a path and the widget prevents the /// child from painting outside the path. /// /// {@youtube 560 315 https://www.youtube.com/watch?v=oAUebVIb-7s} /// /// Clipping to a path is expensive. Certain shapes have more /// optimized widgets: /// /// * To clip to a rectangle, consider [ClipRect]. /// * To clip to an oval or circle, consider [ClipOval]. /// * To clip to a rounded rectangle, consider [ClipRRect]. /// /// To clip to a particular [ShapeBorder], consider using either the /// [ClipPath.shape] static method or the [ShapeBorderClipper] custom clipper /// class.PXV/// Creates a path clip. /// /// If [clipper] is null, the clip will be a rectangle that matches the layout /// size and location of the child. However, rather than use this default, /// consider using a [ClipRect], which can achieve the same effect more /// efficiently. /// /// If [clipBehavior] is [Clip.none], no clipping will be applied._ fn t" %/// If non-null, determines which clip to use. /// /// The default clip, which is used if this property is null, is the /// bounding box rectangle of the widget. [ClipRect] is a more /// efficient way of obtaining that effect.1}_/// {@macro flutter.rendering.ClipRectLayer.clipBehavior} /// /// Defaults to [Clip.antiAlias].[V/// Creates a shape clip. /// /// Uses a [ShapeBorderClipper] to configure the [ClipPath] to clip to the /// given [ShapeBorder].bhp" IZm{IJk !1hy&hiO䂎/// A widget representing a physical layer that clips its children to a shape. /// /// {@youtube 560 315 https://www.youtube.com/watch?v=XgUOSS30OQk} /// /// Physical layers cast shadows based on an [elevation] which is nominally in /// logical pixels, coming vertically out of the rendering surface. /// /// For shapes that cannot be expressed as a rectangle with rounded corners use /// [PhysicalShape]. /// /// See also: /// /// * [AnimatedPhysicalModel], which animates property changes smoothly over /// a given duration. /// * [DecoratedBox], which can apply more arbitrary shadow effects. /// * [ClipRect], which applies a clip to its child.8BO/// Creates a physical model with a rounded-rectangular clip. /// /// The [color] is required; physical things have a color. /// /// The [shape], [elevation], [color], [clipBehavior], and [shadowColor] must /// not be null. Additionally, the [elevation] must be non-negative.V ]ek*' .rz{  ;ARLBOX-/// The type of shape.rT/// {@macro flutter.material.Material.clipBehavior} /// /// Defaults to [Clip.none]./// The border radius of the rounded corners. /// /// Values are clamped so that horizontal and vertical radii sums do not /// exceed width/height. /// /// This is ignored if the [shape] is not [BoxShape.rectangle]. z/// The z-coordinate relative to the parent at which to place this physical /// object. /// /// The value is non-negative.-/// The background color.//// The shadow color..AO/'@Sai ~/0Zk&Z[RG&/// A widget representing a physical layer that clips its children to a path. /// /// Physical layers cast shadows based on an [elevation] which is nominally in /// logical pixels, coming vertically out of the rendering surface. /// /// [PhysicalModel] does the same but only supports shapes that can be expressed /// as rectangles with rounded corners. /// /// {@tool dartpad} /// This example shows how to use a [PhysicalShape] on a centered [SizedBox] /// to clip it to a rounded rectangle using a [ShapeBorderClipper] and give it /// an orange color along with a shadow. /// /// ** See code in examples/api/lib/widgets/basic/physical_shape.0.dart ** /// {@end-tool} /// /// See also: /// /// * [ShapeBorderClipper], which converts a [ShapeBorder] to a [CustomClipper], as /// needed by this widget.7D/// Creates a physical model with an arbitrary shape clip. /// /// The [color] is required; physical things have a color. /// /// The [elevation] must be non-negative.K RZiu{* & #,(/// Determines which clip to use. /// /// If the path in question is expressed as a [ShapeBorder] subclass, /// consider using the [ShapeBorderClipper] delegate class to adapt the /// shape for use with this widget.4rT/// {@macro flutter.material.Material.clipBehavior} /// /// Defaults to [Clip.none].;z/// The z-coordinate relative to the parent at which to place this physical /// object. /// /// The value is non-negative.I-q/// The background color.{_E/// When elevation is non zero the color to use for the shadow color.߀  1}&/.5/// A widget that applies a transformation before painting its child. /// /// Unlike [RotatedBox], which applies a rotation prior to layout, this object /// applies its transformation just prior to painting, which means the /// transformation is not taken into account when calculating how much space /// this widget's child (and thus this widget) consumes. /// /// {@youtube 560 315 https://www.youtube.com/watch?v=9z_YNlRlWfA} /// /// {@tool snippet} /// /// This example rotates and skews an orange box containing text, keeping the /// top right corner pinned to its original position. /// /// ```dart /// ColoredBox( /// color: Colors.black, /// child: Transform( /// alignment: Alignment.topRight, /// transform: Matrix4.skewY(0.3)..rotateZ(-math.pi / 12.0), /// child: Container( /// padding: const EdgeInsets.all(8.0), /// color: const Color(0xFFE8581C), /// child: const Text('Apartment for rent!'), /// ), /// ), /// ) /// ``` /// {@end-tool} /// /// See also: /// /// * [RotatedBox], which rotates the child widget during layout, not just /// during painting. /// * [FractionalTranslation], which applies a translation to the child /// that is relative to the child's size. /// * [FittedBox], which sizes and positions its child widget to fit the parent /// according to a given [BoxFit] discipline. /// * The [catalog of layout widgets](https://flutter.dev/widgets/layout/).i//// Creates a widget that transforms its child.  %+= DS017/// Creates a widget that transforms its child using a rotation around the /// center. /// /// The `angle` argument gives the rotation in clockwise radians. /// /// {@tool snippet} /// /// This example rotates an orange box containing text around its center by /// fifteen degrees. /// /// ```dart /// Transform.rotate( /// angle: -math.pi / 12.0, /// child: Container( /// padding: const EdgeInsets.all(8.0), /// color: const Color(0xFFE8581C), /// child: const Text('Apartment for rent!'), /// ), /// ) /// ``` /// {@end-tool} /// /// See also: /// /// * [RotationTransition], which animates changes in rotation smoothly /// over a given duration.> EM^h ny!  12;/// Creates a widget that transforms its child using a translation. /// /// The `offset` argument specifies the translation. /// /// {@tool snippet} /// /// This example shifts the silver-colored child down by fifteen pixels. /// /// ```dart /// Transform.translate( /// offset: const Offset(0.0, 15.0), /// child: Container( /// padding: const EdgeInsets.all(8.0), /// color: const Color(0xFF7F7F7F), /// child: const Text('Quarter'), /// ), /// ) /// ``` /// {@end-tool}B IQbms  %'0 /// Creates a widget that scales its child along the 2D plane. /// /// The `scaleX` argument provides the scalar by which to multiply the `x` /// axis, and the `scaleY` argument provides the scalar by which to multiply /// the `y` axis. Either may be omitted, in which case the scaling factor for /// that axis defaults to 1.0. /// /// For convenience, to scale the child uniformly, instead of providing /// `scaleX` and `scaleY`, the `scale` parameter may be used. /// /// At least one of `scale`, `scaleX`, and `scaleY` must be non-null. If /// `scale` is provided, the other two must be null; similarly, if it is not /// provided, one of the other two must be provided. /// /// The [alignment] controls the origin of the scale; by default, this is the /// center of the box. /// /// {@tool snippet} /// /// This example shrinks an orange box containing text such that each /// dimension is half the size it would otherwise be. /// /// ```dart /// Transform.scale( /// scale: 0.5, /// child: Container( /// padding: const EdgeInsets.all(8.0), /// color: const Color(0xFFE8581C), /// child: const Text('Bad Idea Bears'), /// ), /// ) /// ``` /// {@end-tool} /// /// See also: /// /// * [ScaleTransition], which animates changes in scale smoothly over a given /// duration.  !"(EK] d; ;rxyz{ ? >-%(70:AqrvS/// Creates a widget that mirrors its child about the widget's center point. /// /// If `flipX` is true, the child widget will be flipped horizontally. Defaults to false. /// /// If `flipY` is true, the child widget will be flipped vertically. Defaults to false. /// /// If both are true, the child widget will be flipped both vertically and horizontally, equivalent to a 180 degree rotation. /// /// {@tool snippet} /// /// This example flips the text horizontally. /// /// ```dart /// Transform.flip( /// flipX: true, /// child: const Text('Horizontal Flip'), /// ) /// ``` /// {@end-tool}   5+7@A[Q]det{u}~S9/// The matrix to transform the child by during painting.4/// The origin of the coordinate system (relative to the upper left corner of /// this render object) in which to apply the matrix. /// /// Setting an origin is equivalent to conjugating the transform matrix by a /// translation. This property is provided just for convenience.!/// The alignment of the origin, relative to the size of the box. /// /// This is equivalent to setting an origin based on the size of the box. /// If it is specified at the same time as the [origin], both are applied. /// /// An [AlignmentDirectional.centerStart] value is the same as an [Alignment] /// whose [Alignment.x] value is `-1.0` if [Directionality.of] returns /// [TextDirection.ltr], and `1.0` if [Directionality.of] returns /// [TextDirection.rtl]. Similarly [AlignmentDirectional.centerEnd] is the /// same as an [Alignment] whose [Alignment.x] value is `1.0` if /// [Directionality.of] returns [TextDirection.ltr], and `-1.0` if /// [Directionality.of] returns [TextDirection.rtl].alB/// Whether to apply the transformation when performing hit tests.ǂp/// The filter quality with which to apply the transform as a bitmap operation. /// /// {@template flutter.widgets.Transform.optional.FilterQuality} /// The transform will be applied by re-rendering the child if [filterQuality] is null, /// otherwise it controls the quality of an [ImageFilter.matrix] applied to a bitmap /// rendering of the child. /// {@endtemplate}3)BS[`,o (ADWe()mO~ʑʟʧʸmn'`/// A widget that can be targeted by a [CompositedTransformFollower]. /// /// When this widget is composited during the compositing phase (which comes /// after the paint phase, as described in [WidgetsBinding.drawFrame]), it /// updates the [link] object so that any [CompositedTransformFollower] widgets /// that are subsequently composited in the same frame and were given the same /// [LayerLink] can position themselves at the same screen location. /// /// A single [CompositedTransformTarget] can be followed by multiple /// [CompositedTransformFollower] widgets. /// /// The [CompositedTransformTarget] must come earlier in the paint order than /// any linked [CompositedTransformFollower]s. /// /// See also: /// /// * [CompositedTransformFollower], the widget that can target this one. /// * [LeaderLayer], the layer that implements this widget's logic.k+D/// Creates a composited transform target widget. /// /// The [link] property must not be currently used by any other /// [CompositedTransformTarget] object that is in the tree.K RZir yЈы/// The link object that connects this [CompositedTransformTarget] with one or /// more [CompositedTransformFollower]s. /// /// The link must not be associated with another [CompositedTransformTarget] /// that is also being painted.єѲєѕ},?MUhҜi/// A widget that follows a [CompositedTransformTarget]. /// /// When this widget is composited during the compositing phase (which comes /// after the paint phase, as described in [WidgetsBinding.drawFrame]), it /// applies a transformation that brings [targetAnchor] of the linked /// [CompositedTransformTarget] and [followerAnchor] of this widget together. /// The two anchor points will have the same global coordinates, unless [offset] /// is not [Offset.zero], in which case [followerAnchor] will be offset by /// [offset] in the linked [CompositedTransformTarget]'s coordinate space. /// /// The [LayerLink] object used as the [link] must be the same object as that /// provided to the matching [CompositedTransformTarget]. /// /// The [CompositedTransformTarget] must come earlier in the paint order than /// this [CompositedTransformFollower]. /// /// Hit testing on descendants of this widget will only work if the target /// position is within the box that this widget's parent considers to be /// hittable. If the parent covers the screen, this is trivially achievable, so /// this widget is usually used as the root of an [OverlayEntry] in an app-wide /// [Overlay] (e.g. as created by the [MaterialApp] widget's [Navigator]). /// /// See also: /// /// * [CompositedTransformTarget], the widget that this widget can target. /// * [FollowerLayer], the layer that implements this widget's logic. /// * [Transform], which applies an arbitrary transform to a child.د/// Creates a composited transform target widget. /// /// If the [link] property was also provided to a [CompositedTransformTarget], /// that widget must come earlier in the paint order. /// /// The [showWhenUnlinked] and [offset] properties must also not be null.  5;T%Z'څڬ ڳ +CIJhqrڕڞڟ€Cl/// The link object that connects this [CompositedTransformFollower] with a /// [CompositedTransformTarget].L!/// Whether to show the widget's contents when there is no corresponding /// [CompositedTransformTarget] with the same [link]. /// /// When the widget is linked, the child is positioned such that it has the /// same global position as the linked [CompositedTransformTarget]. /// /// When the widget is not linked, then: if [showWhenUnlinked] is true, the /// child is visible and not repositioned; if it is false, then child is /// hidden.6/// The anchor point on the linked [CompositedTransformTarget] that /// [followerAnchor] will line up with. /// /// {@template flutter.widgets.CompositedTransformFollower.targetAnchor} /// For example, when [targetAnchor] and [followerAnchor] are both /// [Alignment.topLeft], this widget will be top left aligned with the linked /// [CompositedTransformTarget]. When [targetAnchor] is /// [Alignment.bottomLeft] and [followerAnchor] is [Alignment.topLeft], this /// widget will be left aligned with the linked [CompositedTransformTarget], /// and its top edge will line up with the [CompositedTransformTarget]'s /// bottom edge. /// {@endtemplate} /// /// Defaults to [Alignment.topLeft].%-/// The anchor point on this widget that will line up with [targetAnchor] on /// the linked [CompositedTransformTarget]. /// /// {@macro flutter.widgets.CompositedTransformFollower.targetAnchor} /// /// Defaults to [Alignment.topLeft].@/// The additional offset to apply to the [targetAnchor] of the linked /// [CompositedTransformTarget] to obtain this widget's [followerAnchor] /// position./= 3AI ^*柂n/// Scales and positions its child within itself according to [fit]. /// /// {@youtube 560 315 https://www.youtube.com/watch?v=T4Uehk3_wlY} /// /// {@tool dartpad} /// In this example, the [Placeholder] is stretched to fill the entire /// [Container]. Try changing the fit types to see the effect on the layout of /// the [Placeholder]. /// /// ** See code in examples/api/lib/widgets/basic/fitted_box.0.dart ** /// {@end-tool} /// /// See also: /// /// * [Transform], which applies an arbitrary transform to its child widget at /// paint time. /// * The [catalog of layout widgets](https://flutter.dev/widgets/layout/).Ӏ6?Z/// Creates a widget that scales and positions its child within itself according to [fit].F MU[t!z `fgX)E/// How to inscribe the child into the space allocated during layout.1_ꇂ!/// How to align the child within its parent's bounds. /// /// An alignment of (-1.0, -1.0) aligns the child to the top-left corner of its /// parent's bounds. An alignment of (1.0, 0.0) aligns the child to the middle /// of the right edge of its parent's bounds. /// /// Defaults to [Alignment.center]. /// /// See also: /// /// * [Alignment], a class with convenient constants typically used to /// specify an [AlignmentGeometry]. /// * [AlignmentDirectional], like [Alignment] for specifying alignments /// relative to text direction.rT/// {@macro flutter.material.Material.clipBehavior} /// /// Defaults to [Clip.none]. (;I %3;L%&B /// Applies a translation transformation before painting its child. /// /// The translation is expressed as a [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. /// /// Hit tests will only be detected inside the bounds of the /// [FractionalTranslation], even if the contents are offset such that /// they overflow. /// /// See also: /// /// * [Transform], which applies an arbitrary transform to its child widget at /// paint time. /// * [Transform.translate], which applies an absolute offset translation /// transformation instead of an offset scaled to the child. /// * The [catalog of layout widgets](https://flutter.dev/widgets/layout/).T:/// Creates a widget that translates its child's painting.  /// The translation to apply to the child, 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.^[?/// Whether to apply the translation when performing hit tests.qqrFWjx(FG/// A widget that rotates its child by a integral number of quarter turns. /// /// Unlike [Transform], which applies a transform just prior to painting, /// this object applies its rotation prior to layout, which means the entire /// rotated box consumes only as much space as required by the rotated child. /// /// {@youtube 560 315 https://www.youtube.com/watch?v=BFE6_UglLfQ} /// /// {@tool snippet} /// /// This snippet rotates the child (some [Text]) so that it renders from bottom /// to top, like an axis label on a graph: /// /// ```dart /// const RotatedBox( /// quarterTurns: 3, /// child: Text('Hello World!'), /// ) /// ``` /// {@end-tool} /// /// See also: /// /// * [Transform], which is a paint effect that allows you to apply an /// arbitrary transform to a child. /// * [Transform.rotate], which applies a rotation paint effect. /// * The [catalog of layout widgets](https://flutter.dev/widgets/layout/).!+$/// A widget that rotates its child.2 9APa hw_F/// The number of clockwise quarter turns the child should be rotated.v UfyUVWk/// A widget that insets its child by the given padding. /// /// {@youtube 560 315 https://www.youtube.com/watch?v=oD5RtLhhubg} /// /// When passing layout constraints to its child, padding shrinks the /// constraints by the given padding, causing the child to layout at a smaller /// size. Padding then sizes itself to its child's size, inflated by the /// padding, effectively creating empty space around the child. /// /// {@tool snippet} /// /// This snippet creates "Hello World!" [Text] inside a [Card] that is indented /// by sixteen pixels in each direction. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/widgets/padding.png) /// /// ```dart /// const Card( /// child: Padding( /// padding: EdgeInsets.all(16.0), /// child: Text('Hello World!'), /// ), /// ) /// ``` /// {@end-tool} /// /// ## Design discussion /// /// ### Why use a [Padding] widget rather than a [Container] with a [Container.padding] property? /// /// There isn't really any difference between the two. If you supply a /// [Container.padding] argument, [Container] builds a [Padding] widget /// for you. /// /// [Container] doesn't implement its properties directly. Instead, [Container] /// combines a number of simpler widgets together into a convenient package. For /// example, the [Container.padding] property causes the container to build a /// [Padding] widget and the [Container.decoration] property causes the /// container to build a [DecoratedBox] widget. If you find [Container] /// convenient, feel free to use it. If not, feel free to build these simpler /// widgets in whatever combination meets your needs. /// /// In fact, the majority of widgets in Flutter are combinations of other /// simpler widgets. Composition, rather than inheritance, is the primary /// mechanism for building up widgets. /// /// See also: /// /// * [EdgeInsets], the class that is used to describe the padding dimensions. /// * [AnimatedPadding], which animates changes in [padding] over a given /// duration. /// * [SliverPadding], the sliver equivalent of this widget. /// * The [catalog of layout widgets](https://flutter.dev/widgets/layout/).~+/// Creates a widget that insets its child.   W[4/// The amount of space by which to inset the child.ggh"3FT\k"# &'˕ /// A widget that aligns its child within itself and optionally sizes itself /// based on the child's size. /// /// For example, to align a box at the bottom right, you would pass this box a /// tight constraint that is bigger than the child's natural size, /// with an alignment of [Alignment.bottomRight]. /// /// {@youtube 560 315 https://www.youtube.com/watch?v=g2E7yl3MwMk} /// /// This widget will be as big as possible if its dimensions are constrained and /// [widthFactor] and [heightFactor] are null. If a dimension is unconstrained /// and the corresponding size factor is null then the widget will match its /// child's size in that dimension. If a size factor is non-null then the /// corresponding dimension of this widget will be the product of the child's /// dimension and the size factor. For example if widthFactor is 2.0 then /// the width of this widget will always be twice its child's width. /// /// {@tool snippet} /// The [Align] widget in this example uses one of the defined constants from /// [Alignment], [Alignment.topRight]. This places the [FlutterLogo] in the top /// right corner of the parent blue [Container]. /// /// ![A blue square container with the Flutter logo in the top right corner.](https://flutter.github.io/assets-for-api-docs/assets/widgets/align_constant.png) /// /// ```dart /// Center( /// child: Container( /// height: 120.0, /// width: 120.0, /// color: Colors.blue[50], /// child: const Align( /// alignment: Alignment.topRight, /// child: FlutterLogo( /// size: 60, /// ), /// ), /// ), /// ) /// ``` /// {@end-tool} /// /// ## How it works /// /// The [alignment] property describes a point in the `child`'s coordinate system /// and a different point in the coordinate system of this widget. The [Align] /// widget positions the `child` such that both points are lined up on top of /// each other. /// /// {@tool snippet} /// The [Alignment] used in the following example defines two points: /// /// * (0.2 * width of [FlutterLogo]/2 + width of [FlutterLogo]/2, 0.6 * height /// of [FlutterLogo]/2 + height of [FlutterLogo]/2) = (36.0, 48.0) in the /// coordinate system of the [FlutterLogo]. /// * (0.2 * width of [Align]/2 + width of [Align]/2, 0.6 * height /// of [Align]/2 + height of [Align]/2) = (72.0, 96.0) in the /// coordinate system of the [Align] widget (blue area). /// /// The [Align] widget positions the [FlutterLogo] such that the two points are on /// top of each other. In this example, the top left of the [FlutterLogo] will /// be placed at (72.0, 96.0) - (36.0, 48.0) = (36.0, 48.0) from the top left of /// the [Align] widget. /// /// ![A blue square container with the Flutter logo positioned according to the /// Alignment specified above. A point is marked at the center of the container /// for the origin of the Alignment coordinate system.](https://flutter.github.io/assets-for-api-docs/assets/widgets/align_alignment.png) /// /// ```dart /// Center( /// child: Container( /// height: 120.0, /// width: 120.0, /// color: Colors.blue[50], /// child: const Align( /// alignment: Alignment(0.2, 0.6), /// child: FlutterLogo( /// size: 60, /// ), /// ), /// ), /// ) /// ``` /// {@end-tool} /// /// {@tool snippet} /// The [FractionalOffset] used in the following example defines two points: /// /// * (0.2 * width of [FlutterLogo], 0.6 * height of [FlutterLogo]) = (12.0, 36.0) /// in the coordinate system of the [FlutterLogo]. /// * (0.2 * width of [Align], 0.6 * height of [Align]) = (24.0, 72.0) in the /// coordinate system of the [Align] widget (blue area). /// /// The [Align] widget positions the [FlutterLogo] such that the two points are on /// top of each other. In this example, the top left of the [FlutterLogo] will /// be placed at (24.0, 72.0) - (12.0, 36.0) = (12.0, 36.0) from the top left of /// the [Align] widget. /// /// The [FractionalOffset] class uses a coordinate system with an origin in the top-left /// corner of the [Container] in difference to the center-oriented system used in /// the example above with [Alignment]. /// /// ![A blue square container with the Flutter logo positioned according to the /// FractionalOffset specified above. A point is marked at the top left corner /// of the container for the origin of the FractionalOffset coordinate system.](https://flutter.github.io/assets-for-api-docs/assets/widgets/align_fractional_offset.png) /// /// ```dart /// Center( /// child: Container( /// height: 120.0, /// width: 120.0, /// color: Colors.blue[50], /// child: const Align( /// alignment: FractionalOffset(0.2, 0.6), /// child: FlutterLogo( /// size: 60, /// ), /// ), /// ), /// ) /// ``` /// {@end-tool} /// /// See also: /// /// * [AnimatedAlign], which animates changes in [alignment] smoothly over a /// given duration. /// * [CustomSingleChildLayout], which uses a delegate to control the layout of /// a single child. /// * [Center], which is the same as [Align] but with the [alignment] always /// set to [Alignment.center]. /// * [FractionallySizedBox], which sizes its child based on a fraction of its /// own size and positions the child according to an [Alignment] value. /// * The [catalog of layout widgets](https://flutter.dev/widgets/layout/).T^cV/// Creates an alignment widget. /// /// The alignment defaults to [Alignment.center].j qy!  !M7/"2G:JSH /// 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]. !L/// If non-null, sets its width to the child's width multiplied by this factor. /// /// Can be both greater and less than 1.0 but must be non-negative.!\" /// If non-null, sets its height to the child's height multiplied by this factor. /// /// Can be both greater and less than 1.0 but must be non-negative." ";"N"\""#(#9#L#Z#b #w#(#)$;{$L$`&$}$;$<%)!/// A widget that centers its child within itself. /// /// This widget will be as big as possible if its dimensions are constrained and /// [widthFactor] and [heightFactor] are null. If a dimension is unconstrained /// and the corresponding size factor is null then the widget will match its /// child's size in that dimension. If a size factor is non-null then the /// corresponding dimension of this widget will be the product of the child's /// dimension and the size factor. For example if widthFactor is 2.0 then /// the width of this widget will always be twice its child's width. /// /// See also: /// /// * [Align], which lets you arbitrarily position a child within itself, /// rather than just centering it. /// * [Row], a widget that displays its children in a horizontal array. /// * [Column], a widget that displays its children in a vertical array. /// * [Container], a convenience widget that combines common painting, /// positioning, and sizing widgets. /// * The [catalog of layout widgets](https://flutter.dev/widgets/layout/).)*0*6,/// Creates a widget that centers its child.*9 *@*D*K*W*^*k *r*~-g/// A widget that defers the layout of its single child to a delegate. /// /// The delegate can determine the layout constraints for the child and can /// decide where to position the child. The delegate can also determine the size /// of the parent, but the size of the parent cannot depend on the size of the /// child. /// /// See also: /// /// * [SingleChildLayoutDelegate], which controls the layout of the child. /// * [Align], which sizes itself based on its child's size and positions /// the child according to an [Alignment] value. /// * [FractionallySizedBox], which sizes its child based on a fraction of its own /// size and positions the child according to an [Alignment] value. /// * [CustomMultiChildLayout], which uses a delegate to position multiple /// children. /// * The [catalog of layout widgets](https://flutter.dev/widgets/layout/)....`.w)/// Creates a custom single child layout..~ .... ..b/7/// The delegate that controls the layout of the child./&/S/f/t/&/'/ƀ///0-0"//0^ 1V/// Metadata for identifying children in a [CustomMultiChildLayout]. /// /// The [MultiChildLayoutDelegate.hasChild], /// [MultiChildLayoutDelegate.layoutChild], and /// [MultiChildLayoutDelegate.positionChild] methods use these identifiers.111+/// Marks a child with a layout identifier.111112 222<222%2!2(202721282;292B2/// An object representing the identity of this child. /// /// The [id] needs to be unique among the children that the /// [CustomMultiChildLayout] manages.4ZO4o4Z4[2[3 33*22444&4445i;ӆc/// A widget that uses a delegate to size and position multiple children. /// /// The delegate can determine the layout constraints for each child and can /// decide where to position each child. The delegate can also determine the /// size of the parent, but the size of the parent cannot depend on the sizes of /// the children. /// /// [CustomMultiChildLayout] is appropriate when there are complex relationships /// between the size and positioning of multiple widgets. To control the /// layout of a single child, [CustomSingleChildLayout] is more appropriate. For /// simple cases, such as aligning a widget to one or another edge, the [Stack] /// widget is more appropriate. /// /// Each child must be wrapped in a [LayoutId] widget to identify the widget for /// the delegate. /// /// {@tool dartpad} /// This example shows a [CustomMultiChildLayout] widget being used to lay out /// colored blocks from start to finish in a cascade that has some overlap. /// /// It responds to changes in [Directionality] by re-laying out its children. /// /// ** See code in examples/api/lib/widgets/basic/custom_multi_child_layout.0.dart ** /// {@end-tool} /// /// See also: /// /// * [MultiChildLayoutDelegate], for details about how to control the layout of /// the children. /// * [CustomSingleChildLayout], which uses a delegate to control the layout of /// a single child. /// * [Stack], which arranges children relative to the edges of the container. /// * [Flow], which provides paint-time control of its children using transform /// matrices. /// * The [catalog of layout widgets](https://flutter.dev/widgets/layout/).<==>CH/// A box with a specified size. /// /// If given a child, this widget forces it to have a specific width and/or height. /// These values will be ignored if this widget's parent does not permit them. /// For example, this happens if the parent is the screen (forces the child to /// be the same size as the parent), or another [SizedBox] (forces its child to /// have a specific width and/or height). This can be remedied by wrapping the /// child [SizedBox] in a widget that does permit it to be any size up to the /// size of the parent, such as [Center] or [Align]. /// /// If either the width or height is null, this widget will try to size itself to /// match the child's size in that dimension. If the child's size depends on the /// size of its parent, the height and width must be provided. /// /// If not given a child, [SizedBox] will try to size itself as close to the /// specified height and width as possible given the parent's constraints. If /// [height] or [width] is null or unspecified, it will be treated as zero. /// /// The [SizedBox.expand] constructor can be used to make a [SizedBox] that /// sizes itself to fit the parent. It is equivalent to setting [width] and /// [height] to [double.infinity]. /// /// {@youtube 560 315 https://www.youtube.com/watch?v=EHPu_DzRfqA} /// /// {@tool snippet} /// /// This snippet makes the child widget (a [Card] with some [Text]) have the /// exact size 200x300, parental constraints permitting: /// /// ```dart /// const SizedBox( /// width: 200.0, /// height: 300.0, /// child: Card(child: Text('Hello World!')), /// ) /// ``` /// {@end-tool} /// /// See also: /// /// * [ConstrainedBox], a more generic version of this class that takes /// arbitrary [BoxConstraints] instead of an explicit width and height. /// * [UnconstrainedBox], a container that tries to let its child draw without /// constraints. /// * [FractionallySizedBox], a widget that sizes its child to a fraction of /// the total available space. /// * [AspectRatio], a widget that attempts to fit within the parent's /// constraints while also sizing its child to match a given aspect ratio. /// * [FittedBox], which sizes and positions its child widget to fit the parent /// according to a given [BoxFit] discipline. /// * The [catalog of layout widgets](https://flutter.dev/widgets/layout/). /// * [Understanding constraints](https://docs.flutter.dev/ui/layout/constraints), /// an in-depth article about layout in Flutter.H4HH/// Creates a fixed size box. The [width] and [height] parameters can be null /// to indicate that the size of the box should not be constrained in /// the corresponding dimension.I II II II$ I+I7IIIA/// Creates a box that will become as large as its parent allows.I II I IIIIIIIIIIIJAJBJHA/// Creates a box that will become as small as its parent allows.JK JRJV J]JqJkJsJJ~JJJJJ*/// Creates a box with the specified size.J JJ JJ J KJKKK KKK K$K&K1KyKzK7/// Creates a box whose [width] and [height] are equal.K KK KKKKKKKKKKUL4?/// If non-null, requires the child to have exactly this width.L>WL@/// If non-null, requires the child to have exactly this height.MJqM]LLLLLLMMMMM!NMMNfbNyNfNgÔOO&POOQWi{/// A widget that imposes additional constraints on its child. /// /// For example, if you wanted [child] to have a minimum height of 50.0 logical /// pixels, you could use `const BoxConstraints(minHeight: 50.0)` as the /// [constraints]. /// /// {@youtube 560 315 https://www.youtube.com/watch?v=o2KveVr7adg} /// /// {@tool snippet} /// /// This snippet makes the child widget (a [Card] with some [Text]) fill the /// parent, by applying [BoxConstraints.expand] constraints: /// /// ```dart /// ConstrainedBox( /// constraints: const BoxConstraints.expand(), /// child: const Card(child: Text('Hello World!')), /// ) /// ``` /// {@end-tool} /// /// The same behavior can be obtained using the [SizedBox.expand] widget. /// /// See also: /// /// * [BoxConstraints], the class that describes constraints. /// * [UnconstrainedBox], a container that tries to let its child draw without /// constraints. /// * [SizedBox], which lets you specify tight constraints by explicitly /// specifying the height or width. /// * [FractionallySizedBox], which sizes its child based on a fraction of its /// own size and positions the child according to an [Alignment] value. /// * [AspectRatio], a widget that attempts to fit within the parent's /// constraints while also sizing its child to match a given aspect ratio. /// * The [catalog of layout widgets](https://flutter.dev/widgets/layout/).WWWF/// Creates a widget that imposes additional constraints on its child.X XXXX. X5XBXHXiXIXTXUXgXhXoYX6/// The additional constraints to impose on the child.X̀XYYXXYeYvYYY!YYeYfZZZ&&ZCZZZEd։/// A container widget that applies an arbitrary transform to its constraints, /// and sizes its child using the resulting [BoxConstraints], optionally /// clipping, or treating the overflow as an error. /// /// This container sizes its child using a [BoxConstraints] created by applying /// [constraintsTransform] to its own constraints. This container will then /// attempt to adopt the same size, within the limits of its own constraints. If /// it ends up with a different size, it will align the child based on /// [alignment]. If the container cannot expand enough to accommodate the entire /// child, the child will be clipped if [clipBehavior] is not [Clip.none]. /// /// In debug mode, if [clipBehavior] is [Clip.none] and the child overflows the /// container, a warning will be printed on the console, and black and yellow /// striped areas will appear where the overflow occurs. /// /// When [child] is null, this widget becomes as small as possible and never /// overflows. /// /// This widget can be used to ensure some of [child]'s natural dimensions are /// honored, and get an early warning otherwise during development. For /// instance, if [child] requires a minimum height to fully display its content, /// [constraintsTransform] can be set to [maxHeightUnconstrained], so that if /// the parent [RenderObject] fails to provide enough vertical space, a warning /// will be displayed in debug mode, while still allowing [child] to grow /// vertically: /// /// {@tool snippet} /// In the following snippet, the [Card] is guaranteed to be at least as tall as /// its "natural" height. Unlike [UnconstrainedBox], it will become taller if /// its "natural" height is smaller than 40 px. If the [Container] isn't high /// enough to show the full content of the [Card], in debug mode a warning will /// be given. /// /// ```dart /// Container( /// constraints: const BoxConstraints(minHeight: 40, maxHeight: 100), /// alignment: Alignment.center, /// child: const ConstraintsTransformBox( /// constraintsTransform: ConstraintsTransformBox.maxHeightUnconstrained, /// child: Card(child: Text('Hello World!')), /// ) /// ) /// ``` /// {@end-tool} /// /// See also: /// /// * [ConstrainedBox], which renders a box which imposes constraints /// on its child. /// * [OverflowBox], a widget that imposes additional constraints on its child, /// and allows the child to overflow itself. /// * [UnconstrainedBox] which allows its children to render themselves /// unconstrained and expands to fit them.effn/// Creates a widget that uses a function to transform the constraints it /// passes to its child. If the child overflows the parent's constraints, a /// warning will be given in debug mode. /// /// The `debugTransformType` argument adds a debug label to this widget. /// /// The `alignment`, `clipBehavior` and `constraintsTransform` arguments must /// not be null.f ff ffff!fg"g)gBgHgegm gg ggVgZg[ggggrs(sats@s`sAsZsqsgssssssssssst*tt,tetOtgttttсuƀ/// The text direction to use when interpreting the [alignment] if it is an /// [AlignmentDirectional]. /// /// Defaults to null, in which case [Directionality.maybeOf] is used to determine /// the text direction.u؁w[V/// The alignment to use when laying out the child, if it has a different size /// than this widget. /// /// If this is an [AlignmentDirectional], then [textDirection] must not be /// null. /// /// See also: /// /// * [Alignment] for non-[Directionality]-aware alignments. /// * [AlignmentDirectional] for [Directionality]-aware alignments.wixY/// {@template flutter.widgets.constraintsTransform} /// The function used to transform the incoming [BoxConstraints], to size /// [child]. /// /// The function must return a [BoxConstraints] that is /// [BoxConstraints.isNormalized]. /// /// See [ConstraintsTransformBox] for predefined common /// [BoxConstraintsTransform]s. /// {@endtemplate}y{/// {@macro flutter.material.Material.clipBehavior} /// /// {@template flutter.widgets.ConstraintsTransformBox.clipBehavior} /// In debug mode, if [clipBehavior] is [Clip.none], and the child overflows /// its constraints, a warning will be printed on the console, and black and /// yellow striped areas will appear where the overflow occurs. For other /// values of [clipBehavior], the contents are clipped accordingly. /// {@endtemplate} /// /// Defaults to [Clip.none].{!{$ gMhр/// A [BoxConstraintsTransform] that always returns its argument as-is (i.e., /// it is an identity function). /// /// The [ConstraintsTransformBox] becomes a proxy widget that has no effect on /// layout if [constraintsTransform] is set to this.hhi jyK/// A [BoxConstraintsTransform] that always returns a [BoxConstraints] that /// imposes no constraints on either dimension (i.e. `const BoxConstraints()`). /// /// Setting [constraintsTransform] to this allows [child] to render at its /// "natural" size (equivalent to an [UnconstrainedBox] with `constrainedAxis` /// set to null).jjjk/// A [BoxConstraintsTransform] that removes the width constraints from the /// input. /// /// Setting [constraintsTransform] to this allows [child] to render at its /// "natural" width (equivalent to an [UnconstrainedBox] with /// `constrainedAxis` set to [Axis.horizontal]).l llNm/// A [BoxConstraintsTransform] that removes the height constraints from the /// input. /// /// Setting [constraintsTransform] to this allows [child] to render at its /// "natural" height (equivalent to an [UnconstrainedBox] with /// `constrainedAxis` set to [Axis.vertical]).mmmہo /// A [BoxConstraintsTransform] that removes the `maxHeight` constraint from /// the input. /// /// Setting [constraintsTransform] to this allows [child] to render at its /// "natural" height or the `minHeight` of the incoming [BoxConstraints], /// whichever is larger.o"o2ovp /// A [BoxConstraintsTransform] that removes the `maxWidth` constraint from /// the input. /// /// Setting [constraintsTransform] to this allows [child] to render at its /// "natural" width or the `minWidth` of the incoming [BoxConstraints], /// whichever is larger.ppq rvG/// A [BoxConstraintsTransform] that removes both the `maxWidth` and the /// `maxHeight` constraints from the input. /// /// Setting [constraintsTransform] to this allows [child] to render at least /// its "natural" size, and grow along an axis if the incoming /// [BoxConstraints] has a larger minimum constraint on that axis.rr{=@{g{z{{={>|F||||4|||}˂`}}&~ }}/Q^/// A widget that imposes no constraints on its child, allowing it to render /// at its "natural" size. /// /// This allows a child to render at the size it would render if it were alone /// on an infinite canvas with no constraints. This container will then attempt /// to adopt the same size, within the limits of its own constraints. If it ends /// up with a different size, it will align the child based on [alignment]. /// If the box cannot expand enough to accommodate the entire child, the /// child will be clipped. /// /// In debug mode, if the child overflows the container, a warning will be /// printed on the console, and black and yellow striped areas will appear where /// the overflow occurs. /// /// See also: /// /// * [ConstrainedBox], for a box which imposes constraints on its child. /// * [Align], which loosens the constraints given to the child rather than /// removing them entirely. /// * [Container], a convenience widget that combines common painting, /// positioning, and sizing widgets. /// * [OverflowBox], a widget that imposes different constraints on its child /// than it gets from its parent, possibly allowing the child to overflow /// the parent. /// * [ConstraintsTransformBox], a widget that sizes its child using a /// transformed [BoxConstraints], and shows a warning if the child overflows /// in debug mode./// Creates a widget that imposes no constraints on its child, allowing it to /// render at its "natural" size. If the child overflows the parents /// constraints, a warning will be given in debug mode.  ! '-;?@Og/// The text direction to use when interpreting the [alignment] if it is an /// [AlignmentDirectional].Y2%/// The alignment to use when laying out the child. /// /// If this is an [AlignmentDirectional], then [textDirection] must not be /// null. /// /// See also: /// /// * [Alignment] for non-[Directionality]-aware alignments. /// * [AlignmentDirectional] for [Directionality]-aware alignments.@T,/// The axis to retain constraints on, if any. /// /// If not set, or set to null (the default), neither axis will retain its /// constraints. If set to [Axis.vertical], then vertical constraints will /// be retained, and if set to [Axis.horizontal], then horizontal constraints /// will be retained.rT/// {@macro flutter.material.Material.clipBehavior} /// /// Defaults to [Clip.none].z`/// The widget below this widget in the tree. /// /// {@macro flutter.widgets.ProxyWidget.child}=Ё聖 &*Q/// A widget that sizes its child to a fraction of the total available space. /// For more details about the layout algorithm, see /// [RenderFractionallySizedOverflowBox]. /// /// {@youtube 560 315 https://www.youtube.com/watch?v=PEsY654EGZ0} /// /// {@tool dartpad} /// This sample shows a [FractionallySizedBox] whose one child is 50% of /// the box's size per the width and height factor parameters, and centered /// within that box by the alignment parameter. /// /// ** See code in examples/api/lib/widgets/basic/fractionally_sized_box.0.dart ** /// {@end-tool} /// /// See also: /// /// * [Align], which sizes itself based on its child's size and positions /// the child according to an [Alignment] value. /// * [OverflowBox], a widget that imposes different constraints on its child /// than it gets from its parent, possibly allowing the child to overflow the /// parent. /// * The [catalog of layout widgets](https://flutter.dev/widgets/layout/).Rf/// Creates a widget that sizes its child to a fraction of the total available space. /// /// If non-null, the [widthFactor] and [heightFactor] arguments must be /// non-negative.m t|! $P:2%5J=MV/// {@template flutter.widgets.basic.fractionallySizedBox.widthFactor} /// If non-null, the fraction of the incoming width given to the child. /// /// If non-null, the child is given a tight width constraint that is the max /// incoming width constraint multiplied by this factor. /// /// If null, the incoming width constraints are passed to the child /// unmodified. /// {@endtemplate} /// {@template flutter.widgets.basic.fractionallySizedBox.heightFactor} /// If non-null, the fraction of the incoming height given to the child. /// /// If non-null, the child is given a tight height constraint that is the max /// incoming height constraint multiplied by this factor. /// /// If null, the incoming height constraints are passed to the child /// unmodified. /// {@endtemplate}ă/// {@template flutter.widgets.basic.fractionallySizedBox.alignment} /// 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. /// /// Defaults to [Alignment.center]. /// /// See also: /// /// * [Alignment], a class with convenient constants typically used to /// specify an [AlignmentGeometry]. /// * [AlignmentDirectional], like [Alignment] for specifying alignments /// relative to text direction. /// {@endtemplate}'/{&"_/// A box that limits its size only when it's unconstrained. /// /// If this widget's maximum width is unconstrained then its child's width is /// limited to [maxWidth]. Similarly, if this widget's maximum height is /// unconstrained then its child's height is limited to [maxHeight]. /// /// This has the effect of giving the child a natural dimension in unbounded /// environments. For example, by providing a [maxHeight] to a widget that /// normally tries to be as big as possible, the widget will normally size /// itself to fit its parent, but when placed in a vertical list, it will take /// on the given height. /// /// This is useful when composing widgets that normally try to match their /// parents' size, so that they behave reasonably in lists (which are /// unbounded). /// /// {@youtube 560 315 https://www.youtube.com/watch?v=uVki2CIzBTs} /// /// See also: /// /// * [ConstrainedBox], which applies its constraints in all cases, not just /// when the incoming constraints are unbounded. /// * [SizedBox], which lets you specify tight constraints by explicitly /// specifying the height or width. /// * The [catalog of layout widgets](https://flutter.dev/widgets/layout/).HPꀋ/// Creates a box that limits its size only when it's unconstrained. /// /// The [maxWidth] and [maxHeight] arguments must not be negative. % +K R6<=_euofr|b/// The maximum width limit to apply in the absence of a /// [BoxConstraints.maxWidth] constraint.d/// The maximum height limit to apply in the absence of a /// [BoxConstraints.maxHeight] constraint.J[n|JK1 &:-̓/// A widget that imposes different constraints on its child than it gets /// from its parent, possibly allowing the child to overflow the parent. /// /// {@tool dartpad} /// This example shows how an [OverflowBox] is used, and what its effect is. /// /// ** See code in examples/api/lib/widgets/basic/overflowbox.0.dart ** /// {@end-tool} /// /// See also: /// /// * [RenderConstrainedOverflowBox] for details about how [OverflowBox] is /// rendered. /// * [SizedOverflowBox], a widget that is a specific size but passes its /// original constraints through to its child, which may then overflow. /// * [ConstrainedBox], a widget that imposes additional constraints on its /// child. /// * [UnconstrainedBox], a container that tries to let its child draw without /// constraints. /// * [SizedBox], a box with a specified size. /// * The [catalog of layout widgets](https://flutter.dev/widgets/layout/). EP9/// Creates a widget that lets its child overflow itself.W ^f!l   wny(/// 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. /// /// Defaults to [Alignment.center]. /// /// See also: /// /// * [Alignment], a class with convenient constants typically used to /// specify an [AlignmentGeometry]. /// * [AlignmentDirectional], like [Alignment] for specifying alignments /// relative to text direction./// The minimum width constraint to give the child. Set this to null (the /// default) to use the constraint from the parent instead.,Ā/// The maximum width constraint to give the child. Set this to null (the /// default) to use the constraint from the parent instead.рj/// The minimum height constraint to give the child. Set this to null (the /// default) to use the constraint from the parent instead.x/// The maximum height constraint to give the child. Set this to null (the /// default) to use the constraint from the parent instead. /// The way to size the render object. /// /// This only affects scenario when the child does not indeed overflow. /// If set to [OverflowBoxFit.deferToChild], the render object will size itself to /// match the size of its child within the constraints of its parent or be /// as small as the parent allows if no child is set. If set to /// [OverflowBoxFit.max] (the default), the render object will size itself /// to be as large as the parent allows.U:M[jX{)jkƂK&hL/// A widget that is a specific size but passes its original constraints /// through to its child, which may then overflow. /// /// See also: /// /// * [OverflowBox], A widget that imposes different constraints on its child /// than it gets from its parent, possibly allowing the child to overflow the /// parent. /// * [ConstrainedBox], a widget that imposes additional constraints on its /// child. /// * [UnconstrainedBox], a container that tries to let its child draw without /// constraints. /// * The [catalog of layout widgets](https://flutter.dev/widgets/layout/).B/// Creates a widget of a given size that lets its child overflow.  #,!2S Z=FGin΃(/// 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. /// /// Defaults to [Alignment.center]. /// /// See also: /// /// * [Alignment], a class with convenient constants typically used to /// specify an [AlignmentGeometry]. /// * [AlignmentDirectional], like [Alignment] for specifying alignments /// relative to text direction.@./// The size this widget should attempt to be.!DWe!",:B#Z "&2Ņ/// A widget that lays the child out as if it was in the tree, but without /// painting anything, without making the child available for hit testing, and /// without taking any room in the parent. /// /// Offstage children are still active: they can receive focus and have keyboard /// input directed to them. /// /// Animations continue to run in offstage children, and therefore use battery /// and CPU time, regardless of whether the animations end up being visible. /// /// [Offstage] can be used to measure the dimensions of a widget without /// bringing it on screen (yet). To hide a widget from view while it is not /// needed, prefer removing the widget from the tree entirely rather than /// keeping it alive in an [Offstage] subtree. /// /// {@tool dartpad} /// This example shows a [FlutterLogo] widget when the `_offstage` member field /// is false, and hides it without any room in the parent when it is true. When /// offstage, this app displays a button to get the logo size, which will be /// displayed in a [SnackBar]. /// /// ** See code in examples/api/lib/widgets/basic/offstage.0.dart ** /// {@end-tool} /// /// See also: /// /// * [Visibility], which can hide a child more efficiently (albeit less /// subtly). /// * [TickerMode], which can be used to disable animations in a subtree. /// * [SliverOffstage], the sliver version of this widget. /// * The [catalog of layout widgets](https://flutter.dev/widgets/layout/).w4<3/// Creates a widget that visually hides its child.? FJP` gZsQ/// Whether the child is hidden from the rest of the tree. /// /// If true, the child is laid out as if it was in the tree, but without /// painting anything, without making the child available for hit testing, and /// without taking any room in the parent. /// /// Offstage children are still active: they can receive focus and have keyboard /// input directed to them. /// /// Animations continue to run in offstage children, and therefore use battery /// and CPU time, regardless of whether the animations end up being visible. /// /// If false, the child is included in the tree as normal.j%3evωϗϟϯef&-бUбв L(L\]mxщѣѳxy$"/// A widget that attempts to size the child to a specific aspect ratio. /// /// The aspect ratio is expressed as a ratio of width to height. For example, a /// 16:9 width:height aspect ratio would have a value of 16.0/9.0. /// /// {@youtube 560 315 https://www.youtube.com/watch?v=XcnP3_mO_Ms} /// /// The [AspectRatio] widget uses a finite iterative process to compute the /// appropriate constraints for the child, and then lays the child out a single /// time with those constraints. This iterative process is efficient and does /// not require multiple layout passes. /// /// The widget first tries the largest width permitted by the layout /// constraints, and determines the height of the widget by applying the given /// aspect ratio to the width, expressed as a ratio of width to height. /// /// If the maximum width is infinite, the initial width is determined /// by applying the aspect ratio to the maximum height instead. /// /// The widget then examines if the computed dimensions are compatible with the /// parent's constraints; if not, the dimensions are recomputed a second time, /// taking those constraints into account. /// /// If the widget does not find a feasible size after consulting each /// constraint, the widget will eventually select a size for the child that /// meets the layout constraints but fails to meet the aspect ratio constraints. /// /// {@tool dartpad} /// This examples shows how [AspectRatio] sets the width when its parent's width /// constraint is infinite. Since the parent's allowed height is a fixed value, /// the actual width is determined via the given [aspectRatio]. /// /// In this example, the height is fixed at 100.0 and the aspect ratio is set to /// 16 / 9, making the width 100.0 / 9 * 16. /// /// ** See code in examples/api/lib/widgets/basic/aspect_ratio.0.dart ** /// {@end-tool} /// /// {@tool dartpad} /// This second example uses an aspect ratio of 2.0, and layout constraints that /// require the width to be between 0.0 and 100.0, and the height to be between /// 0.0 and 100.0. The widget selects a width of 100.0 (the biggest allowed) and /// a height of 50.0 (to match the aspect ratio). /// /// ** See code in examples/api/lib/widgets/basic/aspect_ratio.1.dart ** /// {@end-tool} /// /// {@tool dartpad} /// This third example is similar to the second, but with the aspect ratio set /// to 0.5. The widget still selects a width of 100.0 (the biggest allowed), and /// attempts to use a height of 200.0. Unfortunately, that violates the /// constraints because the child can be at most 100.0 pixels tall. The widget /// will then take that value and apply the aspect ratio again to obtain a width /// of 50.0. That width is permitted by the constraints and the child receives a /// width of 50.0 and a height of 100.0. If the width were not permitted, the /// widget would continue iterating through the constraints. /// /// ** See code in examples/api/lib/widgets/basic/aspect_ratio.2.dart ** /// {@end-tool} /// /// ## Setting the aspect ratio in unconstrained situations /// /// When using a widget such as [FittedBox], the constraints are unbounded. This /// results in [AspectRatio] being unable to find a suitable set of constraints /// to apply. In that situation, consider explicitly setting a size using /// [SizedBox] instead of setting the aspect ratio using [AspectRatio]. The size /// is then scaled appropriately by the [FittedBox]. /// /// See also: /// /// * [Align], a widget that aligns its child within itself and optionally /// sizes itself based on the child's size. /// * [ConstrainedBox], a widget that imposes additional constraints on its /// child. /// * [UnconstrainedBox], a container that tries to let its child draw without /// constraints. /// * The [catalog of layout widgets](https://flutter.dev/widgets/layout/).X/// Creates a widget with a specific aspect ratio. /// /// The [aspectRatio] argument must be a finite number greater than zero. % ,9?QL@NW+/// The aspect ratio to attempt to use. /// /// The aspect ratio is expressed as a ratio of width to height. For example, /// a 16:9 width:height aspect ratio would have a value of 16.0/9.0.;vYlz;<㵀DUi&DEq죇/// A widget that sizes its child to the child's maximum intrinsic width. /// /// This class is useful, for example, when unlimited width is available and /// you would like a child that would otherwise attempt to expand infinitely to /// instead size itself to a more reasonable width. Additionally, putting a /// [Column] inside an [IntrinsicWidth] will allow all [Column] children to be /// as wide as the widest child. /// /// The constraints that this widget passes to its child will adhere to the /// parent's constraints, so if the constraints are not large enough to satisfy /// the child's maximum intrinsic width, then the child will get less width /// than it otherwise would. Likewise, if the minimum width constraint is /// larger than the child's maximum intrinsic width, the child will be given /// more width than it otherwise would. /// /// If [stepWidth] is non-null, the child's width will be snapped to a multiple /// of the [stepWidth]. Similarly, if [stepHeight] is non-null, the child's /// height will be snapped to a multiple of the [stepHeight]. /// /// This class is relatively expensive, because it adds a speculative layout /// pass before the final layout phase. Avoid using it where possible. In the /// worst case, this widget can result in a layout that is O(N²) in the depth of /// the tree. /// /// See also: /// /// * [Align], a widget that aligns its child within itself. This can be used /// to loosen the constraints passed to the [RenderIntrinsicWidth], /// allowing the [RenderIntrinsicWidth]'s child to be smaller than that of /// its parent. /// * [Row], which when used with [CrossAxisAlignment.stretch] can be used /// to loosen just the width constraints that are passed to the /// [RenderIntrinsicWidth], allowing the [RenderIntrinsicWidth]'s child's /// width to be smaller than that of its parent. /// * [The catalog of layout widgets](https://flutter.dev/widgets/layout/).܁X}틀/// Creates a widget that sizes its child to the child's intrinsic width. /// /// This class is relatively expensive. Avoid using it where possible.   2 ,!/8|贈N/// If non-null, force the child's width to be a multiple of this value. /// /// If null or 0.0 the child's width will be the same as its maximum /// intrinsic width. /// /// This value must not be negative. /// /// See also: /// /// * [RenderBox.getMaxIntrinsicWidth], which defines a widget's max /// intrinsic width in general.﹀/// If non-null, force the child's height to be a multiple of this value. /// /// If null or 0.0 the child's height will not be constrained. /// /// This value must not be negative.>A=P^!x9=/// A widget that sizes its child to the child's intrinsic height. /// /// This class is useful, for example, when unlimited height is available and /// you would like a child that would otherwise attempt to expand infinitely to /// instead size itself to a more reasonable height. Additionally, putting a /// [Row] inside an [IntrinsicHeight] will allow all [Row] children to be as tall /// as the tallest child. /// /// The constraints that this widget passes to its child will adhere to the /// parent's constraints, so if the constraints are not large enough to satisfy /// the child's maximum intrinsic height, then the child will get less height /// than it otherwise would. Likewise, if the minimum height constraint is /// larger than the child's maximum intrinsic height, the child will be given /// more height than it otherwise would. /// /// This class is relatively expensive, because it adds a speculative layout /// pass before the final layout phase. Avoid using it where possible. In the /// worst case, this widget can result in a layout that is O(N²) in the depth of /// the tree. /// /// See also: /// /// * [Align], a widget that aligns its child within itself. This can be used /// to loosen the constraints passed to the [RenderIntrinsicHeight], /// allowing the [RenderIntrinsicHeight]'s child to be smaller than that of /// its parent. /// * [Column], which when used with [CrossAxisAlignment.stretch] can be used /// to loosen just the height constraints that are passed to the /// [RenderIntrinsicHeight], allowing the [RenderIntrinsicHeight]'s child's /// height to be smaller than that of its parent. /// * [The catalog of layout widgets](https://flutter.dev/widgets/layout/).w(/// Creates a widget that sizes its child to the child's intrinsic height. /// /// This class is relatively expensive. Avoid using it where possible.+ 26 =Ifk~IJa./// A widget that positions its child according to the child's baseline. /// /// This widget shifts the child down such that the child's baseline (or the /// bottom of the child, if the child has no baseline) is [baseline] /// logical pixels below the top of this box, then sizes this box to /// contain the child. If [baseline] is less than the distance from /// the top of the child to the baseline of the child, then the child /// is top-aligned instead. /// /// {@youtube 560 315 https://www.youtube.com/watch?v=8ZaFk0yvNlI} /// /// See also: /// /// * [Align], a widget that aligns its child within itself and optionally /// sizes itself based on the child's size. /// * [Center], a widget that centers its child within itself. /// * The [catalog of layout widgets](https://flutter.dev/widgets/layout/).t|P/// Creates a widget that positions its child according to the child's baseline.  䀂^h/// The number of logical pixels from the top of this box at which to position /// the child's baseline.k\:/// The type of baseline to use for positioning the child.̀dude /// A widget that causes the parent to ignore the [child] for the purposes /// of baseline alignment. /// /// See also: /// /// * [Baseline], a widget that positions a child relative to a baseline.qL/// Creates a widget that ignores the child for baseline alignment purposes.  r./// A sliver that contains a single box widget. /// /// Slivers are special-purpose widgets that can be combined using a /// [CustomScrollView] to create custom scroll effects. A [SliverToBoxAdapter] /// is a basic sliver that creates a bridge back to one of the usual box-based /// widgets. /// /// _To learn more about slivers, see [CustomScrollView.slivers]._ /// /// Rather than using multiple [SliverToBoxAdapter] widgets to display multiple /// box widgets in a [CustomScrollView], consider using [SliverList], /// [SliverFixedExtentList], [SliverPrototypeExtentList], or [SliverGrid], /// which are more efficient because they instantiate only those children that /// are actually visible through the scroll view's viewport. /// /// See also: /// /// * [CustomScrollView], which displays a scrollable list of slivers. /// * [SliverList], which displays multiple box widgets in a linear array. /// * [SliverFixedExtentList], which displays multiple box widgets with the /// same main-axis extent in a linear array. /// * [SliverPrototypeExtentList], which displays multiple box widgets with the /// same main-axis extent as a prototype item, in a linear array. /// * [SliverGrid], which displays multiple box widgets in arbitrary positions.[z7/// Creates a sliver that contains a single box widget.  l   I L/// A sliver that applies padding on each side of another sliver. /// /// Slivers are special-purpose widgets that can be combined using a /// [CustomScrollView] to create custom scroll effects. A [SliverPadding] /// is a basic sliver that insets another sliver by applying padding on each /// side. /// /// {@macro flutter.rendering.RenderSliverEdgeInsetsPadding} /// /// See also: /// /// * [CustomScrollView], which displays a scrollable list of slivers. /// * [Padding], the box version of this widget.   I/// Creates a sliver that applies padding on each side of another sliver.       + 0 > 6 1 8 D^ ;/// The amount of space by which to inset the child sliver.       i z     i j->R&o-..`/// A widget that arranges its children sequentially along a given axis, forcing /// them to the dimension of the parent in the other axis. /// /// This widget is rarely used directly. Instead, consider using [ListView], /// which combines a similar layout algorithm with scrolling behavior, or /// [Column], which gives you more flexible control over the layout of a /// vertical set of boxes. /// /// See also: /// /// * [RenderListBody], which implements this layout algorithm and the /// documentation for which describes some of its subtleties. /// * [SingleChildScrollView], which is sometimes used with [ListBody] to /// make the contents scrollable. /// * [Column] and [Row], which implement a more elaborate version of /// this layout algorithm (at the cost of being slightly less efficient). /// * [ListView], which implements an efficient scrolling version of this /// layout algorithm. /// * The [catalog of layout widgets](https://flutter.dev/widgets/layout/).E/// Creates a layout widget that arranges its children sequentially along a /// given axis. /// /// By default, the [mainAxis] is [Axis.vertical].  '-AH6Z@*/// The direction to use as the main axis.0Ȃ/// Whether the list body positions children in the reading direction. /// /// For example, if the reading direction is left-to-right and /// [mainAxis] is [Axis.horizontal], then the list body positions children /// from left to right when [reverse] is false and from right to left when /// [reverse] is true. /// /// Similarly, if [mainAxis] is [Axis.vertical], then the list body positions /// from top to bottom when [reverse] is false and from bottom to top when /// [reverse] is true. /// /// Defaults to false.Ԁhhi)1Aj/7/// A widget that positions its children relative to the edges of its box. /// /// This class is useful if you want to overlap several children in a simple /// way, for example having some text and an image, overlaid with a gradient and /// a button attached to the bottom. /// /// {@youtube 560 315 https://www.youtube.com/watch?v=liEGSeD3Zt8} /// /// Each child of a [Stack] widget is either _positioned_ or _non-positioned_. /// Positioned children are those wrapped in a [Positioned] widget that has at /// least one non-null property. The stack sizes itself to contain all the /// non-positioned children, which are positioned according to [alignment] /// (which defaults to the top-left corner in left-to-right environments and the /// top-right corner in right-to-left environments). The positioned children are /// then placed relative to the stack according to their top, right, bottom, and /// left properties. /// /// The stack paints its children in order with the first child being at the /// bottom. If you want to change the order in which the children paint, you /// can rebuild the stack with the children in the new order. If you reorder /// the children in this way, consider giving the children non-null keys. /// These keys will cause the framework to move the underlying objects for /// the children to their new locations rather than recreate them at their /// new location. /// /// For more details about the stack layout algorithm, see [RenderStack]. /// /// If you want to lay a number of children out in a particular pattern, or if /// you want to make a custom layout manager, you probably want to use /// [CustomMultiChildLayout] instead. In particular, when using a [Stack] you /// can't position children relative to their size or the stack's own size. /// /// {@tool snippet} /// /// Using a [Stack] you can position widgets over one another. /// /// ![The sample creates a blue box that overlaps a larger green box, which itself overlaps an even larger red box.](https://flutter.github.io/assets-for-api-docs/assets/widgets/stack.png) /// /// ```dart /// Stack( /// children: [ /// Container( /// width: 100, /// height: 100, /// color: Colors.red, /// ), /// Container( /// width: 90, /// height: 90, /// color: Colors.green, /// ), /// Container( /// width: 80, /// height: 80, /// color: Colors.blue, /// ), /// ], /// ) /// ``` /// {@end-tool} /// /// {@tool snippet} /// /// This example shows how [Stack] can be used to enhance text visibility /// by adding gradient backdrops. /// /// ![The gradient fades from transparent to dark grey at the bottom, with white text on top of the darker portion.](https://flutter.github.io/assets-for-api-docs/assets/widgets/stack_with_gradient.png) /// /// ```dart /// SizedBox( /// width: 250, /// height: 250, /// child: Stack( /// children: [ /// Container( /// width: 250, /// height: 250, /// color: Colors.white, /// ), /// Container( /// padding: const EdgeInsets.all(5.0), /// alignment: Alignment.bottomCenter, /// decoration: BoxDecoration( /// gradient: LinearGradient( /// begin: Alignment.topCenter, /// end: Alignment.bottomCenter, /// colors: [ /// Colors.black.withAlpha(0), /// Colors.black12, /// Colors.black45 /// ], /// ), /// ), /// child: const Text( /// 'Foreground Text', /// style: TextStyle(color: Colors.white, fontSize: 20.0), /// ), /// ), /// ], /// ), /// ) /// ``` /// {@end-tool} /// /// See also: /// /// * [Align], which sizes itself based on its child's size and positions /// the child according to an [Alignment] value. /// * [CustomSingleChildLayout], which uses a delegate to control the layout of /// a single child. /// * [CustomMultiChildLayout], which uses a delegate to position multiple /// children. /// * [Flow], which provides paint-time control of its children using transform /// matrices. /// * The [catalog of layout widgets](https://flutter.dev/widgets/layout/)./f[/0/// Creates a stack layout widget. /// /// By default, the non-positioned children of the stack are aligned by their /// top left corners.0 00.0 0N0T0f0l0!000 0+0?0@0q0y0z0000Ń4/// How to align the non-positioned and partially-positioned children in the /// stack. /// /// The non-positioned children are placed relative to each other such that /// the points determined by [alignment] are co-located. For example, if the /// [alignment] is [Alignment.topLeft], then the top left corner of /// each non-positioned child will be located at the same global coordinate. /// /// Partially-positioned children, those that do not specify an alignment in a /// particular axis (e.g. that have neither `top` nor `bottom` set), use the /// alignment to determine how they should be positioned in that /// under-specified axis. /// /// Defaults to [AlignmentDirectional.topStart]. /// /// See also: /// /// * [Alignment], a class with convenient constants typically used to /// specify an [AlignmentGeometry]. /// * [AlignmentDirectional], like [Alignment] for specifying alignments /// relative to text direction.45Dk/// The text direction with which to resolve [alignment]. /// /// Defaults to the ambient [Directionality].5V6P/// How to size the non-positioned children in the stack. /// /// The constraints passed into the [Stack] from its parent are either /// loosened ([StackFit.loose]) or tightened to their biggest size /// ([StackFit.expand]).6X9)/// {@macro flutter.material.Material.clipBehavior} /// /// Stacks only clip children whose _geometry_ overflows the stack. A child /// that paints outside its bounds (e.g. a box with a shadow) will not be /// clipped, regardless of the value of this property. Similarly, a child that /// itself has a descendant that overflows the stack will not be clipped, as /// only the geometry of the stack's direct children are considered. /// [Transform] is an example of a widget that can cause its children to paint /// outside its geometry. /// /// To clip children whose geometry does not overflow the stack, consider /// using a [ClipRect] widget. /// /// Defaults to [Clip.hardEdge].9:y9?9\9j;-;;;;;<;<= =="=/<<>'>8>L&>i>'>(?BՂ/// A [Stack] that shows a single child from a list of children. /// /// The displayed child is the one with the given [index]. The stack is /// always as big as the largest child. /// /// If value is null, then nothing is displayed. /// /// {@youtube 560 315 https://www.youtube.com/watch?v=_O0PPD1Xfbk} /// /// {@tool dartpad} /// This example shows a [IndexedStack] widget being used to lay out one card /// at a time from a series of cards, each keeping their respective states. /// /// ** See code in examples/api/lib/widgets/basic/indexed_stack.0.dart ** /// {@end-tool} /// /// See also: /// /// * [Stack], for more details about stacks. /// * The [catalog of layout widgets](https://flutter.dev/widgets/layout/).B3C?CK8/// Creates a [Stack] widget that paints a single child.CR CYCa.CgCCC!CCCCCD DCrCCCCCCCCDDD(D)D D'D!D5E/// How to align the non-positioned and partially-positioned children in the /// stack. /// /// Defaults to [AlignmentDirectional.topStart]. /// /// See [Stack.alignment] for more information.E(Ek/// The text direction with which to resolve [alignment]. /// /// Defaults to the ambient [Directionality].EvF+X/// {@macro flutter.material.Material.clipBehavior} /// /// Defaults to [Clip.hardEdge].F<F」/// How to size the non-positioned children in the stack. /// /// Defaults to [StackFit.loose]. /// /// See [Stack.fit] for more information.FwG``/// The index of the child to show. /// /// If this is null, none of the children will be shown.GjH/// The child widgets of the stack. /// /// Only the child at index [index] will be shown. /// /// See [Stack.children] for more information.H"H5H;HIH"H#IJ/7/// The render object widget that backs [IndexedStack].JRJJ8/// Creates a [Stack] widget that paints a single child.JJJJJJJ JKKK*K1 KK K K#KAKFKRKJKGKLKX6K#/// The index of the child to show.KOKKKKKLXLM MM M4LLNBfNlNBNCN NN4NOOOO)LOJO)O*Oy:OOOOyOzPWއ /// A widget that controls where a child of a [Stack] is positioned. /// /// A [Positioned] widget must be a descendant of a [Stack], and the path from /// the [Positioned] widget to its enclosing [Stack] must contain only /// [StatelessWidget]s or [StatefulWidget]s (not other kinds of widgets, like /// [RenderObjectWidget]s). /// /// {@youtube 560 315 https://www.youtube.com/watch?v=EgtPleVwxBQ} /// /// If a widget is wrapped in a [Positioned], then it is a _positioned_ widget /// in its [Stack]. If the [top] property is non-null, the top edge of this child /// will be positioned [top] layout units from the top of the stack widget. The /// [right], [bottom], and [left] properties work analogously. /// /// If both the [top] and [bottom] properties are non-null, then the child will /// be forced to have exactly the height required to satisfy both constraints. /// Similarly, setting the [right] and [left] properties to non-null values will /// force the child to have a particular width. Alternatively the [width] and /// [height] properties can be used to give the dimensions, with one /// corresponding position property (e.g. [top] and [height]). /// /// If all three values on a particular axis are null, then the /// [Stack.alignment] property is used to position the child. /// /// If all six values are null, the child is a non-positioned child. The [Stack] /// uses only the non-positioned children to size itself. /// /// See also: /// /// * [AnimatedPositioned], which automatically transitions the child's /// position over a given duration whenever the given position changes. /// * [PositionedTransition], which takes a provided [Animation] to transition /// changes in the child's position over a given duration. /// * [PositionedDirectional], which adapts to the ambient [Directionality].XZZ\/// Creates a widget that controls where a child of a [Stack] is positioned. /// /// 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. /// /// See also: /// /// * [Positioned.directional], which specifies the widget's horizontal /// position using `start` and `end` rather than `left` and `right`. /// * [PositionedDirectional], which is similar to [Positioned.directional] /// but adapts to the ambient [Directionality].Z ZZ ZZZZ ZZ ZZ Z[ [[[#[0[6[e[U[D[<[7[?[M[G[P[^[X[a[o[u[[[[z[v[}[[[[[[[\\\/// Creates a Positioned object with the values from the given [Rect]. /// /// This sets the [left], [top], [width], and [height] properties /// from the given [Rect]. The [right] and [bottom] properties are /// set to null.\ \\\\\\\\\]]] ]]]]*]$],]0]1]F]?]H]L]M]b]\]d]x]q]z]^^^/// Creates a Positioned object with the values from the given [RelativeRect]. /// /// This sets the [left], [top], [right], and [bottom] properties from the /// given [RelativeRect]. The [height] and [width] properties are set to null.^ ^^^^^^^^^^_^__ _ ____"_#_8_1_:_>_?_T_N_V_j_c_l_uA``` {/// Creates a Positioned object with [left], [top], [right], and [bottom] set /// to 0.0 unless a value for them is passed.` `` `&`5`;`I`O`_`e`v` `,`@`V`m```````Zccc/// Creates a widget that controls where a child of a [Stack] is positioned. /// /// 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. /// /// If `textDirection` is [TextDirection.rtl], then the `start` argument is /// used for the [right] property and the `end` argument is used for the /// [left] property. Otherwise, if `textDirection` is [TextDirection.ltr], /// then the `start` argument is used for the [left] property and the `end` /// argument is used for the [right] property. /// /// See also: /// /// * [PositionedDirectional], which adapts to the ambient [Directionality]. ccd$dd/ d8dB dKdS d\dddmdx dddddfMga,/// The distance that the child's left edge is inset from the left of the stack. /// /// Only two out of the three horizontal values ([left], [right], [width]) can be /// set. The third must be null. /// /// If all three are null, the [Stack.alignment] is used to position the child /// horizontally.gjGh'/// The distance that the child's top edge is inset from the top of the stack. /// /// Only two out of the three vertical values ([top], [bottom], [height]) can be /// set. The third must be null. /// /// If all three are null, the [Stack.alignment] is used to position the child /// vertically.hPj./// The distance that the child's right edge is inset from the right of the stack. /// /// Only two out of the three horizontal values ([left], [right], [width]) can be /// set. The third must be null. /// /// If all three are null, the [Stack.alignment] is used to position the child /// horizontally.j PkU-/// The distance that the child's bottom edge is inset from the bottom of the stack. /// /// Only two out of the three vertical values ([top], [bottom], [height]) can be /// set. The third must be null. /// /// If all three are null, the [Stack.alignment] is used to position the child /// vertically.k`lo/// The child's width. /// /// Only two out of the three horizontal values ([left], [right], [width]) can be /// set. The third must be null. /// /// If all three are null, the [Stack.alignment] is used to position the child /// horizontally.lym/// The child's height. /// /// Only two out of the three vertical values ([top], [bottom], [height]) can be /// set. The third must be null. /// /// If all three are null, the [Stack.alignment] is used to position the child /// vertically.q,>qAq,q-mmmmmmqn+qq&qqnqos9zI/// A widget that controls where a child of a [Stack] is positioned without /// committing to a specific [TextDirection]. /// /// The ambient [Directionality] is used to determine whether [start] is to the /// left or to the right. /// /// A [PositionedDirectional] widget must be a descendant of a [Stack], and the /// path from the [PositionedDirectional] widget to its enclosing [Stack] must /// contain only [StatelessWidget]s or [StatefulWidget]s (not other kinds of /// widgets, like [RenderObjectWidget]s). /// /// If a widget is wrapped in a [PositionedDirectional], then it is a /// _positioned_ widget in its [Stack]. If the [top] property is non-null, the /// top edge of this child/ will be positioned [top] layout units from the top /// of the stack widget. The [start], [bottom], and [end] properties work /// analogously. /// /// If both the [top] and [bottom] properties are non-null, then the child will /// be forced to have exactly the height required to satisfy both constraints. /// Similarly, setting the [start] and [end] properties to non-null values will /// force the child to have a particular width. Alternatively the [width] and /// [height] properties can be used to give the dimensions, with one /// corresponding position property (e.g. [top] and [height]). /// /// See also: /// /// * [Positioned], which specifies the widget's position visually. /// * [Positioned.directional], which also specifies the widget's horizontal /// position using [start] and [end] but has an explicit [TextDirection]. /// * [AnimatedPositionedDirectional], which automatically transitions /// the child's position over a given duration whenever the given position /// changes.z{|}|/// Creates a widget that controls where a child of a [Stack] is positioned. /// /// 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. /// /// See also: /// /// * [Positioned.directional], which also specifies the widget's horizontal /// position using [start] and [end] but has an explicit [TextDirection].| || |||||| || || |}}}$~/// The distance that the child's leading edge is inset from the leading edge /// of the stack. /// /// Only two out of the three horizontal values ([start], [end], [width]) can be /// set. The third must be null.~~/// The distance that the child's top edge is inset from the top of the stack. /// /// Only two out of the three vertical values ([top], [bottom], [height]) can be /// set. The third must be null.~/// The distance that the child's trailing edge is inset from the trailing /// edge of the stack. /// /// Only two out of the three horizontal values ([start], [end], [width]) can be /// set. The third must be null.؀/// The distance that the child's bottom edge is inset from the bottom of the stack. /// /// Only two out of the three vertical values ([top], [bottom], [height]) can be /// set. The third must be null.〨/// The child's width. /// /// Only two out of the three horizontal values ([start], [end], [width]) can be /// set. The third must be null.4/// The child's height. /// /// Only two out of the three vertical values ([top], [bottom], [height]) can be /// set. The third must be null.?y`/// The widget below this widget in the tree. /// /// {@macro flutter.widgets.ProxyWidget.child}ضg/// A widget that displays its children in a one-dimensional array. /// /// The [Flex] widget allows you to control the axis along which the children are /// placed (horizontal or vertical). This is referred to as the _main axis_. If /// you know the main axis in advance, then consider using a [Row] (if it's /// horizontal) or [Column] (if it's vertical) instead, because that will be less /// verbose. /// /// To cause a child to expand to fill the available space in the [direction] /// of this widget's main axis, wrap the child in an [Expanded] widget. /// /// The [Flex] widget does not scroll (and in general it is considered an error /// to have more children in a [Flex] than will fit in the available room). If /// you have some widgets and want them to be able to scroll if there is /// insufficient room, consider using a [ListView]. /// /// The [Flex] widget does not allow its children to wrap across multiple /// horizontal or vertical runs. For a widget that allows its children to wrap, /// consider using the [Wrap] widget instead of [Flex]. /// /// If you only have one child, then rather than using [Flex], [Row], or /// [Column], consider using [Align] or [Center] to position the child. /// /// ## Layout algorithm /// /// _This section describes how a [Flex] is rendered by the framework._ /// _See [BoxConstraints] for an introduction to box layout models._ /// /// Layout for a [Flex] proceeds in six steps: /// /// 1. Layout each child with a null or zero flex factor (e.g., those that are /// not [Expanded]) with unbounded main axis constraints and the incoming /// cross axis constraints. If the [crossAxisAlignment] is /// [CrossAxisAlignment.stretch], instead use tight cross axis constraints /// that match the incoming max extent in the cross axis. /// 2. Divide the remaining main axis space among the children with non-zero /// flex factors (e.g., those that are [Expanded]) according to their flex /// factor. For example, a child with a flex factor of 2.0 will receive twice /// the amount of main axis space as a child with a flex factor of 1.0. /// 3. Layout each of the remaining children with the same cross axis /// constraints as in step 1, but instead of using unbounded main axis /// constraints, use max axis constraints based on the amount of space /// allocated in step 2. Children with [Flexible.fit] properties that are /// [FlexFit.tight] are given tight constraints (i.e., forced to fill the /// allocated space), and children with [Flexible.fit] properties that are /// [FlexFit.loose] are given loose constraints (i.e., not forced to fill the /// allocated space). /// 4. The cross axis extent of the [Flex] is the maximum cross axis extent of /// the children (which will always satisfy the incoming constraints). /// 5. The main axis extent of the [Flex] is determined by the [mainAxisSize] /// property. If the [mainAxisSize] property is [MainAxisSize.max], then the /// main axis extent of the [Flex] is the max extent of the incoming main /// axis constraints. If the [mainAxisSize] property is [MainAxisSize.min], /// then the main axis extent of the [Flex] is the sum of the main axis /// extents of the children (subject to the incoming constraints). /// 6. Determine the position for each child according to the /// [mainAxisAlignment] and the [crossAxisAlignment]. For example, if the /// [mainAxisAlignment] is [MainAxisAlignment.spaceBetween], any main axis /// space that has not been allocated to children is divided evenly and /// placed between the children. /// /// See also: /// /// * [Row], for a version of this widget that is always horizontal. /// * [Column], for a version of this widget that is always vertical. /// * [Expanded], to indicate children that should take all the remaining room. /// * [Flexible], to indicate children that should share the remaining room. /// * [Spacer], a widget that takes up space proportional to its flex value. /// that may be sized smaller (leaving some remaining room unused). /// * [Wrap], for a widget that allows its children to wrap over multiple _runs_. /// * The [catalog of layout widgets](https://flutter.dev/widgets/layout/).Ȃ/// Creates a flex layout. /// /// The [direction] is required. /// /// If [crossAxisAlignment] is [CrossAxisAlignment.baseline], then /// [textBaseline] must not be null. /// /// The [textDirection] argument defaults to the ambient [Directionality], if /// any. If there is no ambient directionality, and a text direction is going /// to be necessary to decide which direction to lay the children in or to /// disambiguate `start` or `end` values for the main or cross axis /// directions, the [textDirection] must not be null.  01$7[3a/8>[asz!%&EQRuLPQjG ǁO ./// The direction to use as the main axis. /// /// If you know the axis in advance, then consider using a [Row] (if it's /// horizontal) or [Column] (if it's vertical) instead of a [Flex], since that /// will be less verbose. (For [Row] and [Column] this property is fixed to /// the appropriate axis.)'/// How the children should be placed along the main axis. /// /// For example, [MainAxisAlignment.start], the default, places the children /// at the start (i.e., the left for a [Row] or the top for a [Column]) of the /// main axis.=X$/// How much space should be occupied in the main axis. /// /// After allocating space to children, there might be some remaining free /// space. This value controls whether to maximize or minimize the amount of /// free space, subject to the incoming layout constraints. /// /// If some children have a non-zero flex factors (and none have a fit of /// [FlexFit.loose]), they will expand to consume all the available space and /// there will be no remaining free space to maximize or minimize, making this /// value irrelevant to the final layout.M/// How the children should be placed along the cross axis. /// /// For example, [CrossAxisAlignment.center], the default, centers the /// children in the cross axis (e.g., horizontally for a [Column]). /// /// When the cross axis is vertical (as for a [Row]) and the children /// contain text, consider using [CrossAxisAlignment.baseline] instead. /// This typically produces better visual results if the different children /// have text with different font metrics, for example because they differ in /// [TextStyle.fontSize] or other [TextStyle] properties, or because /// they use different fonts due to being written in different scripts.dd/// Determines the order to lay children out horizontally and how to interpret /// `start` and `end` in the horizontal direction. /// /// Defaults to the ambient [Directionality]. /// /// If [textDirection] is [TextDirection.rtl], then the direction in which /// text flows starts from right to left. Otherwise, if [textDirection] is /// [TextDirection.ltr], then the direction in which text flows starts from /// left to right. /// /// If the [direction] is [Axis.horizontal], this controls the order in which /// the children are positioned (left-to-right or right-to-left), and the /// meaning of the [mainAxisAlignment] property's [MainAxisAlignment.start] and /// [MainAxisAlignment.end] values. /// /// If the [direction] is [Axis.horizontal], and either the /// [mainAxisAlignment] is either [MainAxisAlignment.start] or /// [MainAxisAlignment.end], or there's more than one child, then the /// [textDirection] (or the ambient [Directionality]) must not be null. /// /// If the [direction] is [Axis.vertical], this controls the meaning of the /// [crossAxisAlignment] property's [CrossAxisAlignment.start] and /// [CrossAxisAlignment.end] values. /// /// If the [direction] is [Axis.vertical], and the [crossAxisAlignment] is /// either [CrossAxisAlignment.start] or [CrossAxisAlignment.end], then the /// [textDirection] (or the ambient [Directionality]) must not be null.&Nc/// Determines the order to lay children out vertically and how to interpret /// `start` and `end` in the vertical direction. /// /// Defaults to [VerticalDirection.down]. /// /// If the [direction] is [Axis.vertical], this controls which order children /// are painted in (down or up), the meaning of the [mainAxisAlignment] /// property's [MainAxisAlignment.start] and [MainAxisAlignment.end] values. /// /// If the [direction] is [Axis.vertical], and either the [mainAxisAlignment] /// is either [MainAxisAlignment.start] or [MainAxisAlignment.end], or there's /// more than one child, then the [verticalDirection] must not be null. /// /// If the [direction] is [Axis.horizontal], this controls the meaning of the /// [crossAxisAlignment] property's [CrossAxisAlignment.start] and /// [CrossAxisAlignment.end] values. /// /// If the [direction] is [Axis.horizontal], and the [crossAxisAlignment] is /// either [CrossAxisAlignment.start] or [CrossAxisAlignment.end], then the /// [verticalDirection] must not be null.y/// If aligning items according to their baseline, which baseline to use. /// /// This must be set if using baseline alignment. There is no default because there is no /// way for the framework to know the correct baseline _a priori_.rT/// {@macro flutter.material.Material.clipBehavior} /// /// Defaults to [Clip.none].HI1/// {@macro flutter.rendering.RenderFlex.spacing}U.^/// The value to pass to [RenderFlex.textDirection]. /// /// This value is derived from the [textDirection] property and the ambient /// [Directionality]. The value is null if there is no need to specify the /// text direction. In practice there's always a need to specify the direction /// except for vertical flexes (e.g. [Column]s) whose [crossAxisAlignment] is /// not dependent on the text direction (not `start` or `end`). In particular, /// a [Row] always needs a text direction because the text direction controls /// its layout order. (For [Column]s, the layout order is controlled by /// [verticalDirection], which is always specified as it does not depend on an /// inherited widget and defaults to [VerticalDirection.down].) /// /// This method exists so that subclasses of [Flex] that create their own /// render objects that are derived from [RenderFlex] can do so and still use /// the logic for providing a text direction only when it is necessary.jk1DRځ !*& P/// A widget that displays its children in a horizontal array. /// /// To cause a child to expand to fill the available horizontal space, wrap the /// child in an [Expanded] widget. /// /// The [Row] widget does not scroll (and in general it is considered an error /// to have more children in a [Row] than will fit in the available room). If /// you have a line of widgets and want them to be able to scroll if there is /// insufficient room, consider using a [ListView]. /// /// For a vertical variant, see [Column]. /// /// If you only have one child, then consider using [Align] or [Center] to /// position the child. /// /// By default, [crossAxisAlignment] is [CrossAxisAlignment.center], which /// centers the children in the vertical axis. If several of the children /// contain text, this is likely to make them visually misaligned if /// they have different font metrics (for example because they differ in /// [TextStyle.fontSize] or other [TextStyle] properties, or because /// they use different fonts due to being written in different scripts). /// Consider using [CrossAxisAlignment.baseline] instead. /// /// {@tool snippet} /// /// This example divides the available space into three (horizontally), and /// places text centered in the first two cells and the Flutter logo centered in /// the third: /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/widgets/row.png) /// /// ```dart /// const Row( /// children: [ /// Expanded( /// child: Text('Deliver features faster', textAlign: TextAlign.center), /// ), /// Expanded( /// child: Text('Craft beautiful UIs', textAlign: TextAlign.center), /// ), /// Expanded( /// child: FittedBox( /// child: FlutterLogo(), /// ), /// ), /// ], /// ) /// ``` /// {@end-tool} /// /// ## Troubleshooting /// /// ### Why does my row have a yellow and black warning stripe? /// /// If the non-flexible contents of the row (those that are not wrapped in /// [Expanded] or [Flexible] widgets) are together wider than the row itself, /// then the row is said to have overflowed. When a row overflows, the row does /// not have any remaining space to share between its [Expanded] and [Flexible] /// children. The row reports this by drawing a yellow and black striped /// warning box on the edge that is overflowing. If there is room on the outside /// of the row, the amount of overflow is printed in red lettering. /// /// #### Story time /// /// Suppose, for instance, that you had this code: /// /// ```dart /// const Row( /// children: [ /// FlutterLogo(), /// Text("Flutter's hot reload helps you quickly and easily experiment, build UIs, add features, and fix bug faster. Experience sub-second reload times, without losing state, on emulators, simulators, and hardware for iOS and Android."), /// Icon(Icons.sentiment_very_satisfied), /// ], /// ) /// ``` /// /// The row first asks its first child, the [FlutterLogo], to lay out, at /// whatever size the logo would like. The logo is friendly and happily decides /// to be 24 pixels to a side. This leaves lots of room for the next child. The /// row then asks that next child, the text, to lay out, at whatever size it /// thinks is best. /// /// At this point, the text, not knowing how wide is too wide, says "Ok, I will /// be thiiiiiiiiiiiiiiiiiiiis wide.", and goes well beyond the space that the /// row has available, not wrapping. The row responds, "That's not fair, now I /// have no more room available for my other children!", and gets angry and /// sprouts a yellow and black strip. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/widgets/row_error.png) /// /// The fix is to wrap the second child in an [Expanded] widget, which tells the /// row that the child should be given the remaining room: /// /// ```dart /// const Row( /// children: [ /// FlutterLogo(), /// Expanded( /// child: Text("Flutter's hot reload helps you quickly and easily experiment, build UIs, add features, and fix bug faster. Experience sub-second reload times, without losing state, on emulators, simulators, and hardware for iOS and Android."), /// ), /// Icon(Icons.sentiment_very_satisfied), /// ], /// ) /// ``` /// /// Now, the row first asks the logo to lay out, and then asks the _icon_ to lay /// out. The [Icon], like the logo, is happy to take on a reasonable size (also /// 24 pixels, not coincidentally, since both [FlutterLogo] and [Icon] honor the /// ambient [IconTheme]). This leaves some room left over, and now the row tells /// the text exactly how wide to be: the exact width of the remaining space. The /// text, now happy to comply to a reasonable request, wraps the text within /// that width, and you end up with a paragraph split over several lines. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/widgets/row_fixed.png) /// /// The [textDirection] property controls the direction that children are rendered in. /// [TextDirection.ltr] is the default [textDirection] of [Row] children, so the first /// child is rendered at the `start` of the [Row], to the left, with subsequent children /// following to the right. If you want to order children in the opposite /// direction (right to left), then [textDirection] can be set to /// [TextDirection.rtl]. This is shown in the example below /// /// ```dart /// const Row( /// textDirection: TextDirection.rtl, /// children: [ /// FlutterLogo(), /// Expanded( /// child: Text("Flutter's hot reload helps you quickly and easily experiment, build UIs, add features, and fix bug faster. Experience sub-second reload times, without losing state, on emulators, simulators, and hardware for iOS and Android."), /// ), /// Icon(Icons.sentiment_very_satisfied), /// ], /// ) /// ``` /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/widgets/row_textDirection.png) /// /// ## Layout algorithm /// /// _This section describes how a [Row] is rendered by the framework._ /// _See [BoxConstraints] for an introduction to box layout models._ /// /// Layout for a [Row] proceeds in six steps: /// /// 1. Layout each child with a null or zero flex factor (e.g., those that are /// not [Expanded]) with unbounded horizontal constraints and the incoming /// vertical constraints. If the [crossAxisAlignment] is /// [CrossAxisAlignment.stretch], instead use tight vertical constraints that /// match the incoming max height. /// 2. Divide the remaining horizontal space among the children with non-zero /// flex factors (e.g., those that are [Expanded]) according to their flex /// factor. For example, a child with a flex factor of 2.0 will receive twice /// the amount of horizontal space as a child with a flex factor of 1.0. /// 3. Layout each of the remaining children with the same vertical constraints /// as in step 1, but instead of using unbounded horizontal constraints, use /// horizontal constraints based on the amount of space allocated in step 2. /// Children with [Flexible.fit] properties that are [FlexFit.tight] are /// given tight constraints (i.e., forced to fill the allocated space), and /// children with [Flexible.fit] properties that are [FlexFit.loose] are /// given loose constraints (i.e., not forced to fill the allocated space). /// 4. The height of the [Row] is the maximum height of the children (which will /// always satisfy the incoming vertical constraints). /// 5. The width of the [Row] is determined by the [mainAxisSize] property. If /// the [mainAxisSize] property is [MainAxisSize.max], then the width of the /// [Row] is the max width of the incoming constraints. If the [mainAxisSize] /// property is [MainAxisSize.min], then the width of the [Row] is the sum /// of widths of the children (subject to the incoming constraints). /// 6. Determine the position for each child according to the /// [mainAxisAlignment] and the [crossAxisAlignment]. For example, if the /// [mainAxisAlignment] is [MainAxisAlignment.spaceBetween], any horizontal /// space that has not been allocated to children is divided evenly and /// placed between the children. /// /// See also: /// /// * [Column], for a vertical equivalent. /// * [Flex], if you don't know in advance if you want a horizontal or vertical /// arrangement. /// * [Expanded], to indicate children that should take all the remaining room. /// * [Flexible], to indicate children that should share the remaining room but /// that may by sized smaller (leaving some remaining room unused). /// * [Spacer], a widget that takes up space proportional to its flex value. /// * The [catalog of layout widgets](https://flutter.dev/widgets/layout/). UX//// Creates a horizontal array of children. /// /// If [crossAxisAlignment] is [CrossAxisAlignment.baseline], then /// [textBaseline] must not be null. /// /// The [textDirection] argument defaults to the ambient [Directionality], if /// any. If there is no ambient directionality, and a text direction is going /// to be necessary to determine the layout order (which is always the case /// unless the row has no children or only one child) or to disambiguate /// `start` or `end` values for the [mainAxisAlignment], the [textDirection] /// must not be null. _ fnuߋߒߣߪO Vbiy~ਣPM/// A widget that displays its children in a vertical array. /// /// To cause a child to expand to fill the available vertical space, wrap the /// child in an [Expanded] widget. /// /// The [Column] widget does not scroll (and in general it is considered an error /// to have more children in a [Column] than will fit in the available room). If /// you have a line of widgets and want them to be able to scroll if there is /// insufficient room, consider using a [ListView]. /// /// For a horizontal variant, see [Row]. /// /// If you only have one child, then consider using [Align] or [Center] to /// position the child. /// /// {@tool snippet} /// /// This example uses a [Column] to arrange three widgets vertically, the last /// being made to fill all the remaining space. /// /// ![Using the Column in this way creates two short lines of text with a large Flutter underneath.](https://flutter.github.io/assets-for-api-docs/assets/widgets/column.png) /// /// ```dart /// const Column( /// children: [ /// Text('Deliver features faster'), /// Text('Craft beautiful UIs'), /// Expanded( /// child: FittedBox( /// child: FlutterLogo(), /// ), /// ), /// ], /// ) /// ``` /// {@end-tool} /// {@tool snippet} /// /// In the sample above, the text and the logo are centered on each line. In the /// following example, the [crossAxisAlignment] is set to /// [CrossAxisAlignment.start], so that the children are left-aligned. The /// [mainAxisSize] is set to [MainAxisSize.min], so that the column shrinks to /// fit the children. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/widgets/column_properties.png) /// /// ```dart /// Column( /// crossAxisAlignment: CrossAxisAlignment.start, /// mainAxisSize: MainAxisSize.min, /// children: [ /// const Text('We move under cover and we move as one'), /// const Text('Through the night, we have one shot to live another day'), /// const Text('We cannot let a stray gunshot give us away'), /// const Text('We will fight up close, seize the moment and stay in it'), /// const Text("It's either that or meet the business end of a bayonet"), /// const Text("The code word is 'Rochambeau,' dig me?"), /// Text('Rochambeau!', style: DefaultTextStyle.of(context).style.apply(fontSizeFactor: 2.0)), /// ], /// ) /// ``` /// {@end-tool} /// /// ## Troubleshooting /// /// ### When the incoming vertical constraints are unbounded /// /// When a [Column] has one or more [Expanded] or [Flexible] children, and is /// placed in another [Column], or in a [ListView], or in some other context /// that does not provide a maximum height constraint for the [Column], you will /// get an exception at runtime saying that there are children with non-zero /// flex but the vertical constraints are unbounded. /// /// The problem, as described in the details that accompany that exception, is /// that using [Flexible] or [Expanded] means that the remaining space after /// laying out all the other children must be shared equally, but if the /// incoming vertical constraints are unbounded, there is infinite remaining /// space. /// /// The key to solving this problem is usually to determine why the [Column] is /// receiving unbounded vertical constraints. /// /// One common reason for this to happen is that the [Column] has been placed in /// another [Column] (without using [Expanded] or [Flexible] around the inner /// nested [Column]). When a [Column] lays out its non-flex children (those that /// have neither [Expanded] or [Flexible] around them), it gives them unbounded /// constraints so that they can determine their own dimensions (passing /// unbounded constraints usually signals to the child that it should /// shrink-wrap its contents). The solution in this case is typically to just /// wrap the inner column in an [Expanded] to indicate that it should take the /// remaining space of the outer column, rather than being allowed to take any /// amount of room it desires. /// /// Another reason for this message to be displayed is nesting a [Column] inside /// a [ListView] or other vertical scrollable. In that scenario, there really is /// infinite vertical space (the whole point of a vertical scrolling list is to /// allow infinite space vertically). In such scenarios, it is usually worth /// examining why the inner [Column] should have an [Expanded] or [Flexible] /// child: what size should the inner children really be? The solution in this /// case is typically to remove the [Expanded] or [Flexible] widgets from around /// the inner children. /// /// {@youtube 560 315 https://www.youtube.com/watch?v=jckqXR5CrPI} /// /// For more discussion about constraints, see [BoxConstraints]. /// /// ### The yellow and black striped banner /// /// When the contents of a [Column] exceed the amount of space available, the /// [Column] overflows, and the contents are clipped. In debug mode, a yellow /// and black striped bar is rendered at the overflowing edge to indicate the /// problem, and a message is printed below the [Column] saying how much /// overflow was detected. /// /// The usual solution is to use a [ListView] rather than a [Column], to enable /// the contents to scroll when vertical space is limited. /// /// ## Layout algorithm /// /// _This section describes how a [Column] is rendered by the framework._ /// _See [BoxConstraints] for an introduction to box layout models._ /// /// Layout for a [Column] proceeds in six steps: /// /// 1. Layout each child with a null or zero flex factor (e.g., those that are /// not [Expanded]) with unbounded vertical constraints and the incoming /// horizontal constraints. If the [crossAxisAlignment] is /// [CrossAxisAlignment.stretch], instead use tight horizontal constraints /// that match the incoming max width. /// 2. Divide the remaining vertical space among the children with non-zero /// flex factors (e.g., those that are [Expanded]) according to their flex /// factor. For example, a child with a flex factor of 2.0 will receive twice /// the amount of vertical space as a child with a flex factor of 1.0. /// 3. Layout each of the remaining children with the same horizontal /// constraints as in step 1, but instead of using unbounded vertical /// constraints, use vertical constraints based on the amount of space /// allocated in step 2. Children with [Flexible.fit] properties that are /// [FlexFit.tight] are given tight constraints (i.e., forced to fill the /// allocated space), and children with [Flexible.fit] properties that are /// [FlexFit.loose] are given loose constraints (i.e., not forced to fill the /// allocated space). /// 4. The width of the [Column] is the maximum width of the children (which /// will always satisfy the incoming horizontal constraints). /// 5. The height of the [Column] is determined by the [mainAxisSize] property. /// If the [mainAxisSize] property is [MainAxisSize.max], then the height of /// the [Column] is the max height of the incoming constraints. If the /// [mainAxisSize] property is [MainAxisSize.min], then the height of the /// [Column] is the sum of heights of the children (subject to the incoming /// constraints). /// 6. Determine the position for each child according to the /// [mainAxisAlignment] and the [crossAxisAlignment]. For example, if the /// [mainAxisAlignment] is [MainAxisAlignment.spaceBetween], any vertical /// space that has not been allocated to children is divided evenly and /// placed between the children. /// /// See also: /// /// * [Row], for a horizontal equivalent. /// * [Flex], if you don't know in advance if you want a horizontal or vertical /// arrangement. /// * [Expanded], to indicate children that should take all the remaining room. /// * [Flexible], to indicate children that should share the remaining room but /// that may size smaller (leaving some remaining room unused). /// * [SingleChildScrollView], whose documentation discusses some ways to /// use a [Column] inside a scrolling container. /// * [Spacer], a widget that takes up space proportional to its flex value. /// * The [catalog of layout widgets](https://flutter.dev/widgets/layout/).쁹/// Creates a vertical array of children. /// /// If [crossAxisAlignment] is [CrossAxisAlignment.baseline], then /// [textBaseline] must not be null. /// /// The [textDirection] argument defaults to the ambient [Directionality], if /// any. If there is no ambient directionality, and a text direction is going /// to be necessary to disambiguate `start` or `end` values for the /// [crossAxisAlignment], the [textDirection] must not be null.   &7>U\nu '/// A widget that controls how a child of a [Row], [Column], or [Flex] flexes. /// /// Using a [Flexible] widget gives a child of a [Row], [Column], or [Flex] /// the flexibility to expand to fill the available space in the main axis /// (e.g., horizontally for a [Row] or vertically for a [Column]), but, unlike /// [Expanded], [Flexible] does not require the child to fill the available /// space. /// /// A [Flexible] widget must be a descendant of a [Row], [Column], or [Flex], /// and the path from the [Flexible] widget to its enclosing [Row], [Column], or /// [Flex] must contain only [StatelessWidget]s or [StatefulWidget]s (not other /// kinds of widgets, like [RenderObjectWidget]s). /// /// {@youtube 560 315 https://www.youtube.com/watch?v=CI7x0mAZiY0} /// /// See also: /// /// * [Expanded], which forces the child to expand to fill the available space. /// * [Spacer], a widget that takes up space proportional to its flex value. /// * The [catalog of layout widgets](https://flutter.dev/widgets/layout/).5Z/// Creates a widget that controls how a child of a [Row], [Column], or [Flex] /// flexes.   o sT/// The flex factor to use for this child. /// /// If null or zero, the child is inflexible and determines its own size. If /// non-zero, the amount of space the child can occupy in the main axis is /// determined by dividing the free space (after placing the inflexible /// children) according to the flex factors of the flexible children. | 2/// How a flexible child is inscribed into the available space. /// /// If [flex] is non-zero, the [fit] determines whether the child fills the /// space the parent makes available during layout. If the fit is /// [FlexFit.tight], the child is required to fill the available space. If the /// fit is [FlexFit.loose], the child can be at most as large as the available /// space (but is allowed to be smaller).2=G23 : K [ i : ;s&st#ȇ/// A widget that expands a child of a [Row], [Column], or [Flex] /// so that the child fills the available space. /// /// Using an [Expanded] widget makes a child of a [Row], [Column], or [Flex] /// expand to fill the available space along the main axis (e.g., horizontally for /// a [Row] or vertically for a [Column]). If multiple children are expanded, /// the available space is divided among them according to the [flex] factor. /// /// An [Expanded] widget must be a descendant of a [Row], [Column], or [Flex], /// and the path from the [Expanded] widget to its enclosing [Row], [Column], or /// [Flex] must contain only [StatelessWidget]s or [StatefulWidget]s (not other /// kinds of widgets, like [RenderObjectWidget]s). /// /// {@youtube 560 315 https://www.youtube.com/watch?v=_rnZaagadyo} /// /// {@tool dartpad} /// This example shows how to use an [Expanded] widget in a [Column] so that /// its middle child, a [Container] here, expands to fill the space. /// /// ![This results in two thin blue boxes with a larger amber box in between.](https://flutter.github.io/assets-for-api-docs/assets/widgets/expanded_column.png) /// /// ** See code in examples/api/lib/widgets/basic/expanded.0.dart ** /// {@end-tool} /// /// {@tool dartpad} /// This example shows how to use an [Expanded] widget in a [Row] with multiple /// children expanded, utilizing the [flex] factor to prioritize available space. /// /// ![This results in a wide amber box, followed by a thin blue box, with a medium width amber box at the end.](https://flutter.github.io/assets-for-api-docs/assets/widgets/expanded_row.png) /// /// ** See code in examples/api/lib/widgets/basic/expanded.1.dart ** /// {@end-tool} /// /// See also: /// /// * [Flexible], which does not force the child to fill the available space. /// * [Spacer], a widget that takes up space proportional to its flex value. /// * The [catalog of layout widgets](https://flutter.dev/widgets/layout/)./// Creates a widget that expands a child of a [Row], [Column], or [Flex] /// so that the child fills the available space along the flex widget's /// main axis.  X҇/// A widget that displays its children in multiple horizontal or vertical runs. /// /// A [Wrap] lays out each child and attempts to place the child adjacent to the /// previous child in the main axis, given by [direction], leaving [spacing] /// space in between. If there is not enough space to fit the child, [Wrap] /// creates a new _run_ adjacent to the existing children in the cross axis. /// /// After all the children have been allocated to runs, the children within the /// runs are positioned according to the [alignment] in the main axis and /// according to the [crossAxisAlignment] in the cross axis. /// /// The runs themselves are then positioned in the cross axis according to the /// [runSpacing] and [runAlignment]. /// /// {@youtube 560 315 https://www.youtube.com/watch?v=z5iw2SeFx2M} /// /// {@tool snippet} /// /// This example renders some [Chip]s representing four contacts in a [Wrap] so /// that they flow across lines as necessary. /// /// ```dart /// Wrap( /// spacing: 8.0, // gap between adjacent chips /// runSpacing: 4.0, // gap between lines /// children: [ /// Chip( /// avatar: CircleAvatar(backgroundColor: Colors.blue.shade900, child: const Text('AH')), /// label: const Text('Hamilton'), /// ), /// Chip( /// avatar: CircleAvatar(backgroundColor: Colors.blue.shade900, child: const Text('ML')), /// label: const Text('Lafayette'), /// ), /// Chip( /// avatar: CircleAvatar(backgroundColor: Colors.blue.shade900, child: const Text('HM')), /// label: const Text('Mulligan'), /// ), /// Chip( /// avatar: CircleAvatar(backgroundColor: Colors.blue.shade900, child: const Text('JL')), /// label: const Text('Laurens'), /// ), /// ], /// ) /// ``` /// {@end-tool} /// /// See also: /// /// * [Row], which places children in one line, and gives control over their /// alignment and spacing. /// * The [catalog of layout widgets](https://flutter.dev/widgets/layout/). " "/// Creates a wrap layout. /// /// By default, the wrap layout is horizontal and both the children and the /// runs are aligned to the start. /// /// The [textDirection] argument defaults to the ambient [Directionality], if /// any. If there is no ambient directionality, and a text direction is going /// to be necessary to decide which direction to lay the children in or to /// disambiguate `start` or `end` values for the main or cross axis /// directions, the [textDirection] must not be null. " ""' "-"M$"S"w"}"'""""2"###'/#-#\#b##"8"<"="^"k"l""""""###@#Q#R#p#t#u #z% Y/// The direction to use as the main axis. /// /// For example, if [direction] is [Axis.horizontal], the default, the /// children are placed adjacent to one another in a horizontal run until the /// available horizontal space is consumed, at which point a subsequent /// children are placed in a new run vertically adjacent to the previous run.%S'a/// How the children within a run should be placed in the main axis. /// /// For example, if [alignment] is [WrapAlignment.center], the children in /// each run are grouped together in the center of their run in the main axis. /// /// Defaults to [WrapAlignment.start]. /// /// See also: /// /// * [runAlignment], which controls how the runs are placed relative to each /// other in the cross axis. /// * [crossAxisAlignment], which controls how the children within each run /// are placed relative to each other in the cross axis.'o)h/// How much space to place between children in a run in the main axis. /// /// For example, if [spacing] is 10.0, the children will be spaced at least /// 10.0 logical pixels apart in the main axis. /// /// If there is additional free space in a run (e.g., because the wrap has a /// minimum size that is not filled or because some runs are longer than /// others), the additional free space will be allocated according to the /// [alignment]. /// /// Defaults to 0.0.)t^+Ƃ#/// How the runs themselves should be placed in the cross axis. /// /// For example, if [runAlignment] is [WrapAlignment.center], the runs are /// grouped together in the center of the overall [Wrap] in the cross axis. /// /// Defaults to [WrapAlignment.start]. /// /// See also: /// /// * [alignment], which controls how the children within each run are placed /// relative to each other in the main axis. /// * [crossAxisAlignment], which controls how the children within each run /// are placed relative to each other in the cross axis.+ׁ-/// How much space to place between the runs themselves in the cross axis. /// /// For example, if [runSpacing] is 10.0, the runs will be spaced at least /// 10.0 logical pixels apart in the cross axis. /// /// If there is additional free space in the overall [Wrap] (e.g., because /// the wrap has a minimum size that is not filled), the additional free space /// will be allocated according to the [runAlignment]. /// /// Defaults to 0.0.-0fn/// How the children within a run should be aligned relative to each other in /// the cross axis. /// /// For example, if this is set to [WrapCrossAlignment.end], and the /// [direction] is [Axis.horizontal], then the children within each /// run will have their bottom edges aligned to the bottom edge of the run. /// /// Defaults to [WrapCrossAlignment.start]. /// /// See also: /// /// * [alignment], which controls how the children within each run are placed /// relative to each other in the main axis. /// * [runAlignment], which controls how the runs are placed relative to each /// other in the cross axis.0}6P/// Determines the order to lay children out horizontally and how to interpret /// `start` and `end` in the horizontal direction. /// /// Defaults to the ambient [Directionality]. /// /// If the [direction] is [Axis.horizontal], this controls order in which the /// children are positioned (left-to-right or right-to-left), and the meaning /// of the [alignment] property's [WrapAlignment.start] and /// [WrapAlignment.end] values. /// /// If the [direction] is [Axis.horizontal], and either the /// [alignment] is either [WrapAlignment.start] or [WrapAlignment.end], or /// there's more than one child, then the [textDirection] (or the ambient /// [Directionality]) must not be null. /// /// If the [direction] is [Axis.vertical], this controls the order in which /// runs are positioned, the meaning of the [runAlignment] property's /// [WrapAlignment.start] and [WrapAlignment.end] values, as well as the /// [crossAxisAlignment] property's [WrapCrossAlignment.start] and /// [WrapCrossAlignment.end] values. /// /// If the [direction] is [Axis.vertical], and either the /// [runAlignment] is either [WrapAlignment.start] or [WrapAlignment.end], the /// [crossAxisAlignment] is either [WrapCrossAlignment.start] or /// [WrapCrossAlignment.end], or there's more than one child, then the /// [textDirection] (or the ambient [Directionality]) must not be null.6) ;%/// Determines the order to lay children out vertically and how to interpret /// `start` and `end` in the vertical direction. /// /// If the [direction] is [Axis.vertical], this controls which order children /// are painted in (down or up), the meaning of the [alignment] property's /// [WrapAlignment.start] and [WrapAlignment.end] values. /// /// If the [direction] is [Axis.vertical], and either the [alignment] /// is either [WrapAlignment.start] or [WrapAlignment.end], or there's /// more than one child, then the [verticalDirection] must not be null. /// /// If the [direction] is [Axis.horizontal], this controls the order in which /// runs are positioned, the meaning of the [runAlignment] property's /// [WrapAlignment.start] and [WrapAlignment.end] values, as well as the /// [crossAxisAlignment] property's [WrapCrossAlignment.start] and /// [WrapCrossAlignment.end] values. /// /// If the [direction] is [Axis.horizontal], and either the /// [runAlignment] is either [WrapAlignment.start] or [WrapAlignment.end], the /// [crossAxisAlignment] is either [WrapCrossAlignment.start] or /// [WrapCrossAlignment.end], or there's more than one child, then the /// [verticalDirection] must not be null.;;r;T/// {@macro flutter.material.Material.clipBehavior} /// /// Defaults to [Clip.none].;;;;;;=l=}=====l=m???P?d&????@BVO/// A widget that sizes and positions children efficiently, according to the /// logic in a [FlowDelegate]. /// /// {@youtube 560 315 https://www.youtube.com/watch?v=NG6pvXpnIso} /// /// Flow layouts are optimized for repositioning children using transformation /// matrices. /// /// The flow container is sized independently from the children by the /// [FlowDelegate.getSize] function of the delegate. The children are then sized /// independently given the constraints from the /// [FlowDelegate.getConstraintsForChild] function. /// /// Rather than positioning the children during layout, the children are /// positioned using transformation matrices during the paint phase using the /// matrices from the [FlowDelegate.paintChildren] function. The children can be /// repositioned efficiently by only _repainting_ the flow, which happens /// without the children being laid out again (contrast this with a [Stack], /// which does the sizing and positioning together during layout). /// /// The most efficient way to trigger a repaint of the flow is to supply an /// animation to the constructor of the [FlowDelegate]. The flow will listen to /// this animation and repaint whenever the animation ticks, avoiding both the /// build and layout phases of the pipeline. /// /// {@tool dartpad} /// This example uses the [Flow] widget to create a menu that opens and closes /// as it is interacted with, shown above. The color of the button in the menu /// changes to indicate which one has been selected. /// /// ** See code in examples/api/lib/widgets/basic/flow.0.dart ** /// {@end-tool} /// /// ## Hit testing and hidden [Flow] widgets /// /// The [Flow] widget recomputes its children's positions (as used by hit /// testing) during the _paint_ phase rather than during the _layout_ phase. /// /// Widgets like [Opacity] avoid painting their children when those children /// would be invisible due to their opacity being zero. /// /// Unfortunately, this means that hiding a [Flow] widget using an [Opacity] /// widget will cause bugs when the user attempts to interact with the hidden /// region, for example, by tapping it or clicking it. /// /// Such bugs will manifest either as out-of-date geometry (taps going to /// different widgets than might be expected by the currently-specified /// [FlowDelegate]s), or exceptions (e.g. if the last time the [Flow] was /// painted, a different set of children was specified). /// /// To avoid this, when hiding a [Flow] widget with an [Opacity] widget (or /// [AnimatedOpacity] or similar), it is wise to also disable hit testing on the /// widget by using [IgnorePointer]. This is generally good advice anyway as /// hit-testing invisible widgets is often confusing for the user. /// /// See also: /// /// * [Wrap], which provides the layout model that some other frameworks call /// "flow", and is otherwise unrelated to [Flow]. /// * [Stack], which arranges children relative to the edges of the container. /// * [CustomSingleChildLayout], which uses a delegate to control the layout of /// a single child. /// * [CustomMultiChildLayout], which uses a delegate to position multiple /// children. /// * The [catalog of layout widgets](https://flutter.dev/widgets/layout/).O2aOOր/// Creates a flow layout. /// /// Wraps each of the given children in a [RepaintBoundary] to avoid /// repainting the children when the flow repaints.O OOOP(PP6!P<P P.P/P&P-P'PJPNPOP`PePPnPfPpPPPPPPρaQQQ€/// Creates a flow layout. /// /// Does not wrap the given children in repaint boundaries, unlike the default /// constructor. Useful when the child is trivial to paint or already contains /// a repaint boundary.Q QQQQQR!RRR R!R4iRK/// The delegate that controls the transformation matrices of the children.RrST/// {@macro flutter.material.Material.clipBehavior} /// /// Defaults to [Clip.none].S~S0SCSQSSSSSSSSSSTKa/// A paragraph of rich text. /// /// {@youtube 560 315 https://www.youtube.com/watch?v=rykDVh-QFfw} /// /// The [RichText] widget displays text that uses multiple different styles. The /// text to display is described using a tree of [TextSpan] objects, each of /// which has an associated style that is used for that subtree. The text might /// break across multiple lines or might all be displayed on the same line /// depending on the layout constraints. /// /// Text displayed in a [RichText] widget must be explicitly styled. When /// picking which style to use, consider using [DefaultTextStyle.of] the current /// [BuildContext] to provide defaults. For more details on how to style text in /// a [RichText] widget, see the documentation for [TextStyle]. /// /// Consider using the [Text] widget to integrate with the [DefaultTextStyle] /// automatically. When all the text uses the same style, the default constructor /// is less verbose. The [Text.rich] constructor allows you to style multiple /// spans with the default text style while still allowing specified styles per /// span. /// /// {@tool snippet} /// /// This sample demonstrates how to mix and match text with different text /// styles using the [RichText] Widget. It displays the text "Hello bold world," /// emphasizing the word "bold" using a bold font weight. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/widgets/rich_text.png) /// /// ```dart /// RichText( /// text: TextSpan( /// text: 'Hello ', /// style: DefaultTextStyle.of(context).style, /// children: const [ /// TextSpan(text: 'bold', style: TextStyle(fontWeight: FontWeight.bold)), /// TextSpan(text: ' world!'), /// ], /// ), /// ) /// ``` /// {@end-tool} /// /// ## Selections /// /// To make this [RichText] Selectable, the [RichText] needs to be in the /// subtree of a [SelectionArea] or [SelectableRegion] and a /// [SelectionRegistrar] needs to be assigned to the /// [RichText.selectionRegistrar]. One can use /// [SelectionContainer.maybeOf] to get the [SelectionRegistrar] from a /// context. This enables users to select the text in [RichText]s with mice or /// touch events. /// /// The [selectionColor] also needs to be set if the selection is enabled to /// draw the selection highlights. /// /// {@tool snippet} /// /// This sample demonstrates how to assign a [SelectionRegistrar] for RichTexts /// in the SelectionArea subtree. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/widgets/rich_text.png) /// /// ```dart /// RichText( /// text: const TextSpan(text: 'Hello'), /// selectionRegistrar: SelectionContainer.maybeOf(context), /// selectionColor: const Color(0xAF6694e8), /// ) /// ``` /// {@end-tool} /// /// See also: /// /// * [TextStyle], which discusses how to style text. /// * [TextSpan], which is used to describe the text in a paragraph. /// * [Text], which automatically applies the ambient styles described by a /// [DefaultTextStyle] to a single string. /// * [Text.rich], a const text widget that provides similar functionality /// as [RichText]. [Text.rich] will inherit [TextStyle] from [DefaultTextStyle]. /// * [SelectableRegion], which provides an overview of the selection system.a9~bjbr"/// Creates a paragraph of rich text. /// /// The [maxLines] property may be null (and indeed defaults to null), but if /// it is not null, it must be greater than zero. /// /// The [textDirection], if null, defaults to the ambient [Directionality], /// which in that case must not be null.by bbbb bbbbbb!bcd d$,d0dV d\di dodzdd+ddddddePbbbbccccc c*cc2cScdd<dFdGdddeee=e.e&ee)e:e1e<eGeMeeieaeNede{ele~eeeeeeeeeeeeeeeefef f"f>f#f/fHfMffVfNfXfbfcfxffyfffff h?hT'/// The text to display in this widget.h]Lh0/// How the text should be aligned horizontally.hk~/// The directionality of the text. /// /// This decides how [textAlign] values like [TextAlign.start] and /// [TextAlign.end] are interpreted. /// /// This is also used to disambiguate how to render bidirectional text. For /// example, if the [text] is an English phrase followed by a Hebrew phrase, /// in a [TextDirection.ltr] context the English phrase will be on the left /// and the Hebrew phrase to its right, while in a [TextDirection.rtl] /// context, the English phrase will be on the right and the Hebrew phrase on /// its left. /// /// Defaults to the ambient [Directionality], if any. If there is no ambient /// [Directionality], then this must not be null.kl@/// Whether the text should break at soft line breaks. /// /// If false, the glyphs in the text will be positioned as if there was unlimited horizontal space.lMHl*/// How visual overflow should be handled.nRo4/// {@macro flutter.painting.textPainter.textScaler}o?pT/// An optional maximum number of lines for the text to span, wrapping if necessary. /// If the text exceeds the given number of lines, it will be truncated according /// to [overflow]. /// /// If this is 1, text will not wrap. Otherwise, text will be wrapped at the /// edge of the box.pajqŁG/// Used to select a font when the same Unicode character can /// be rendered differently, depending on the locale. /// /// It's rarely necessary to set this property. By default its value /// is inherited from the enclosing app with `Localizations.localeOf(context)`. /// /// See [RenderParagraph.locale] for more information.qSr4/// {@macro flutter.painting.textPainter.strutStyle}r(^rx8/// {@macro flutter.painting.textPainter.textWidthBasis}rYr'/// {@macro dart.ui.textHeightBehavior}r逫sx/// The [SelectionRegistrar] this rich text is subscribed to. /// /// If this is set, [selectionColor] must be non-null.s.t/// The color to use when painting the selection. /// /// This is ignored if [selectionRegistrar] is null. /// /// See the section on selections in the [RichText] top-level API /// documentation for more details on enabling selection in [RichText] /// widgets.l(n/// Deprecated. Will be removed in a future version of Flutter. Use /// [textScaler] instead. /// /// The number of font pixels for each logical pixel. /// /// For example, if the text scale factor is 1.5, text will be 50% larger than /// the specified font size.mmmnmmnMfZffffgt̂ttu ttwRwcwvwwwwRwSzzz&&zCzz/// A widget that displays a [dart:ui.Image] directly. /// /// The image is painted using [paintImage], which describes the meanings of the /// various fields on this class in more detail. /// /// The [image] is not disposed of by this widget. Creators of the widget are /// expected to call [dart:ui.Image.dispose] on the [image] once the [RawImage] /// is no longer buildable. /// /// The `scale` argument specifies the linear scale factor for drawing this /// image at its intended size and applies to both the width and the height. /// {@macro flutter.painting.imageInfo.scale} /// /// This widget is rarely used directly. Instead, consider using [Image].͂o}/// Creates a widget that displays an image. /// /// The [scale], [alignment], [repeat], [matchTextDirection] and [filterQuality] arguments must /// not be null.      $7=E!Kl"r)# V_`z0@S/// The image to display. /// /// Since a [RawImage] is stateless, it does not ever dispose this image. /// Creators of a [RawImage] are expected to call [dart:ui.Image.dispose] on /// this image handle when the [RawImage] will no longer be needed.]Q1/// A string identifying the source of the image.`/// If non-null, require the image to have this width. /// /// If null, the image will pick a size that best preserves its intrinsic /// aspect ratio.j/// If non-null, require the image to have this height. /// /// If null, the image will pick a size that best preserves its intrinsic /// aspect ratio.#/// The linear scale factor for drawing this image at its intended size. /// /// The scale factor applies to the width and the height. /// /// {@macro flutter.painting.imageInfo.scale}iaT/// If non-null, this color is blended with each image pixel using [colorBlendMode].kx/// If non-null, the value from the [Animation] is multiplied with the opacity /// of each image pixel before painting onto the canvas. /// /// This is more efficient than using [FadeTransition] to change the opacity /// of an image.[/// Used to set the filterQuality of the image. /// /// Defaults to [FilterQuality.medium]. JH/// Used to combine [color] with this image. /// /// The default is [BlendMode.srcIn]. In terms of the blend mode, [color] is /// the source and this image is the destination. /// /// See also: /// /// * [BlendMode], which includes an illustration of the effect of each blend mode.[/// How to inscribe the image into the space allocated during layout. /// /// The default varies based on the other fields. See the discussion at /// [paintImage].T/// How to align the image within its bounds. /// /// The alignment aligns the given position in the image to the given position /// in the layout bounds. For example, an [Alignment] alignment of (-1.0, /// -1.0) aligns the image to the top-left corner of its layout bounds, while a /// [Alignment] alignment of (1.0, 1.0) aligns the bottom right of the /// image with the bottom right corner of its layout bounds. Similarly, an /// alignment of (0.0, 1.0) aligns the bottom middle of the image with the /// middle of the bottom edge of its layout bounds. /// /// To display a subpart of an image, consider using a [CustomPainter] and /// [Canvas.drawImageRect]. /// /// If the [alignment] is [TextDirection]-dependent (i.e. if it is a /// [AlignmentDirectional]), then an ambient [Directionality] widget /// must be in scope. /// /// Defaults to [Alignment.center]. /// /// See also: /// /// * [Alignment], a class with convenient constants typically used to /// specify an [AlignmentGeometry]. /// * [AlignmentDirectional], like [Alignment] for specifying alignments /// relative to text direction.g+L/// How to paint any portions of the layout bounds not covered by the image.6偔/// The center slice for a nine-patch image. /// /// The region of the image inside the center slice will be stretched both /// horizontally and vertically to fit the image into its destination. The /// region of the image above and below the center slice will be stretched /// only horizontally and the region of the image to the left and right of /// the center slice will be stretched only vertically.D'/// Whether to paint the image in the direction of the [TextDirection]. /// /// If this is true, then in [TextDirection.ltr] contexts, the image will be /// drawn with its origin in the top left (the "normal" painting direction for /// images); and in [TextDirection.rtl] contexts, the image will be drawn with /// a scaling factor of -1 in the horizontal direction so that the origin is /// in the top right. /// /// This is occasionally used with images in right-to-left environments, for /// images that were designed for left-to-right locales. Be careful, when /// using this, to not flip images with integral shadows, text, or other /// effects that will look incorrect when flipped. /// /// If this is true, there must be an ambient [Directionality] widget in /// scope.>Ӂw/// Whether the colors of the image are inverted when drawn. /// /// Inverting the colors of an image applies a new color filter to the paint. /// If there is another specified color filter, the invert will be applied /// after it. This is primarily used for implementing smart invert on iOS. /// /// See also: /// /// * [Paint.invertColors], for the dart:ui implementation.䀡z/// Whether to paint the image with anti-aliasing. /// /// Anti-aliasing alleviates the sawtooth artifact when the image is rotated.AvRes{AB]/n&]^u/// A widget that determines the default asset bundle for its descendants. /// /// For example, used by [Image] to determine which bundle to use for /// [AssetImage]s if no bundle is specified explicitly. /// /// {@tool snippet} /// /// This can be used in tests to override what the current asset bundle is, thus /// allowing specific resources to be injected into the widget under test. /// /// For example, a test could create a test asset bundle like this: /// /// ```dart /// class TestAssetBundle extends CachingAssetBundle { /// @override /// Future load(String key) async { /// if (key == 'resources/test') { /// return ByteData.sublistView(utf8.encode('Hello World!')); /// } /// return ByteData(0); /// } /// } /// ``` /// {@end-tool} /// {@tool snippet} /// /// ...then wrap the widget under test with a [DefaultAssetBundle] using this /// bundle implementation: /// /// ```dart /// // continuing from previous example... /// await tester.pumpWidget( /// MaterialApp( /// home: DefaultAssetBundle( /// bundle: TestAssetBundle(), /// child: const TestWidget(), /// ), /// ), /// ); /// ``` /// {@end-tool} /// /// Assuming that `TestWidget` uses [DefaultAssetBundle.of] to obtain its /// [AssetBundle], it will now see the `TestAssetBundle`'s "Hello World!" data /// when requesting the "resources/test" asset. /// /// See also: /// /// * [AssetBundle], the interface for asset bundles. /// * [rootBundle], the default asset bundle.R/// Creates a widget that determines the default asset bundle for its descendants. '6AQ`>#/// The bundle to use as a default.5([/// The bundle from the closest instance of this class that encloses /// the given context. /// /// If there is no [DefaultAssetBundle] ancestor widget in the tree /// at the given context, then this will return the [rootBundle]. /// /// Typical usage is as follows: /// /// ```dart /// AssetBundle bundle = DefaultAssetBundle.of(context); /// ```+9`@T /// An adapter for placing a specific [RenderBox] in the widget tree. /// /// A given render object can be placed at most once in the widget tree. This /// widget enforces that restriction by keying itself using a [GlobalObjectKey] /// for the given render object. /// /// This widget will call [RenderObject.dispose] on the [renderBox] when it is /// unmounted. After that point, the [renderBox] will be unusable. If any /// children have been added to the [renderBox], they must be disposed in the /// [onUnmount] callback.M/// Creates an adapter for placing a specific [RenderBox] in the widget tree. ".4 EJjNKP_i`p2/// The render box to place in the widget tree. /// /// This widget takes ownership of the render object. When it is unmounted, /// it also calls [RenderObject.dispose].@R/// Called when it is safe to update the render box and its descendants. If /// you update the RenderObject subtree under this widget outside of /// invocations of this callback, features like hit-testing will fail as the /// tree will be dirty.^Q/// Called when it is safe to dispose of children that were manually added to /// the [renderBox]. /// /// Do not dispose the [renderBox] itself, as it will be disposed by the /// framework automatically. However, during that process the framework will /// check that all children of the [renderBox] have also been disposed. /// Typically, child [RenderObject]s are disposed by corresponding [Element]s /// when they are unmounted. However, child render objects that were manually /// added do not have corresponding [Element]s to manage their lifecycle, and /// need to be manually disposed here. /// /// See also: /// /// * [RenderObjectElement.unmount], which invokes this callback before /// disposing of its render object. /// * [RenderObject.dispose], which instructs a render object to release /// any resources it may be holding.L +DlUhv~DERM/// A widget that calls callbacks in response to common pointer events. /// /// It listens to events that can construct gestures, such as when the /// pointer is pressed, moved, then released or canceled. /// /// It does not listen to events that are exclusive to mouse, such as when the /// mouse enters, exits or hovers a region without pressing any buttons. For /// these events, use [MouseRegion]. /// /// Rather than listening for raw pointer events, consider listening for /// higher-level gestures using [GestureDetector]. /// /// ## Layout behavior /// /// _See [BoxConstraints] for an introduction to box layout models._ /// /// If it has a child, this widget defers to the child for sizing behavior. If /// it does not have a child, it grows to fit the parent instead. /// /// {@tool dartpad} /// This example makes a [Container] react to being touched, showing a count of /// the number of pointer downs and ups. /// /// ** See code in examples/api/lib/widgets/basic/listener.0.dart ** /// {@end-tool}/// Creates a widget that forwards point events to callbacks. /// /// The [behavior] argument defaults to [HitTestBehavior.deferToChild]. % ,4:LRdjz &,,X _6EF n9/// Called when a pointer comes into contact with the screen (for touch /// pointers), or has its button pressed (for mouse pointers) at this widget's /// location.K}M/// Called when a pointer that triggered an [onPointerDown] changes position.̀Xh/// Called when a pointer that triggered an [onPointerDown] is no longer in /// contact with the screen.hw/// Called when a pointer that has not triggered an [onPointerDown] changes /// position. /// /// This is only fired for pointers which report their location when not down /// (e.g. mouse pointers, but not most touch pointers).Š,{/// Called when the input from a pointer that triggered an [onPointerDown] is /// no longer directed towards this receiver.@íB/// Called when a pan/zoom begins such as from a trackpad gesture.h&/// Called when a pan/zoom is updated.4`ā$/// Called when a pan/zoom finishes.ęq/// Called when a pointer signal occurs over this object. /// /// See also: /// /// * [PointerSignalEvent], which goes into more detail on pointer signal /// events.ŅF%/// How to behave during hit testing.Ђ ߂"0#&@s=&[Jn/// A widget that absorbs pointers during hit testing. /// /// When [absorbing] is true, this widget prevents its subtree from receiving /// pointer events by terminating hit testing at itself. It still consumes space /// during layout and paints its child as usual. It just prevents its children /// from being the target of located events, because it returns true from /// [RenderBox.hitTest]. /// /// When [ignoringSemantics] is true, the subtree will be invisible to /// the semantics layer (and thus e.g. accessibility tools). /// /// {@youtube 560 315 https://www.youtube.com/watch?v=65HoWqBboI8} /// /// {@tool dartpad} /// The following sample has an [AbsorbPointer] widget wrapping the button on /// top of the stack, which absorbs pointer events, preventing its child button /// __and__ the button below it in the stack from receiving the pointer events. /// /// ** See code in examples/api/lib/widgets/basic/absorb_pointer.0.dart ** /// {@end-tool} /// /// ## Semantics /// /// Using this class may also affect how the semantics subtree underneath is /// collected. /// /// {@template flutter.widgets.AbsorbPointer.semantics} /// If [absorbing] is true, pointer-related [SemanticsAction]s are removed from /// the semantics subtree. Otherwise, the subtree remains untouched. /// {@endtemplate} /// /// {@template flutter.widgets.AbsorbPointer.ignoringSemantics} /// The usages of [ignoringSemantics] are deprecated and not recommended. This /// property was introduced to workaround the semantics behavior of the /// [IgnorePointer] and its friends before v3.8.0-12.0.pre. /// /// Before that version, entire semantics subtree is dropped if [absorbing] is /// true. Developers can only use [ignoringSemantics] to preserver the semantics /// subtrees. /// /// After that version, with [absorbing] set to true, it only prevents semantics /// user actions in the semantics subtree but leaves the other /// [SemanticsProperties] intact. Therefore, the [ignoringSemantics] is no /// longer needed. /// /// If [ignoringSemantics] is true, the semantics subtree is dropped. Therefore, /// the subtree will be invisible to assistive technologies. /// /// If [ignoringSemantics] is false, the semantics subtree is collected as /// usual. /// {@endtemplate} /// /// See also: /// /// * [IgnorePointer], which also prevents its children from receiving pointer /// events but is itself invisible to hit testing.U>K>/// Creates a widget that absorbs pointers during hit testing.R Yag|$: Ar|}P^7/// Whether this widget absorbs pointers during hit testing. /// /// Regardless of whether this render object absorbs pointers during hit /// testing, it will still consume space during layout and be visible during /// painting. /// /// {@macro flutter.widgets.AbsorbPointer.semantics} /// /// Defaults to true. Y/// Whether the semantics of this render object is ignored when compiling the /// semantics tree. /// /// {@macro flutter.widgets.AbsorbPointer.ignoringSemantics} /// /// See [SemanticsNode] for additional information about the semantics tree. I  o    o p!0!A!T!b!j !!0!1!/""&"5!!#&v$qD/// Holds opaque meta data in the render tree. /// /// Useful for decorating the render tree with information that will be consumed /// later. For example, you could store information in the render tree that will /// be used when the user interacts with the render tree but has no visual /// impact prior to the interaction.$%-%5|/// Creates a widget that hold opaque meta data. /// /// The [behavior] argument defaults to [HitTestBehavior.deferToChild].%< %C%K %Q%^,%d% %%n%}%~%I%0/// Opaque meta data ignored by the render tree.%F&2%/// How to behave during hit testing.&?&Z&m&{&?&@&…&'''',&&'''&'''(-/// A widget that annotates the widget tree with a description of the meaning of /// the widgets. /// /// Used by assistive technologies, search engines, and other semantic analysis /// software to determine the meaning of the application. /// /// {@youtube 560 315 https://www.youtube.com/watch?v=NvtMt_DtFrQ} /// /// See also: /// /// * [SemanticsProperties], which contains a complete documentation for each /// of the constructor parameters that belongs to semantics properties. /// * [MergeSemantics], which marks a subtree as being a single node for /// accessibility purposes. /// * [ExcludeSemantics], which excludes a subtree from the semantics tree /// (which might be useful if it is, e.g., totally decorative and not /// important to the user). /// * [RenderObject.describeSemanticsConfiguration], the rendering library API /// through which the [Semantics] widget is actually implemented. /// * [SemanticsNode], the object used by the rendering library to represent /// semantics in the semantics tree. /// * [SemanticsDebugger], an overlay to help visualize the semantics tree. Can /// be enabled using [WidgetsApp.showSemanticsDebugger], /// [MaterialApp.showSemanticsDebugger], or [CupertinoApp.showSemanticsDebugger].- ///// Creates a semantic annotation. /// /// To create a `const` instance of [Semantics], use the /// [Semantics.fromProperties] constructor. /// /// See also: /// /// * [SemanticsProperties], which contains a complete documentation for each /// of the constructor parameters that belongs to semantics properties. /// * [SemanticsSortKey] for a class that determines accessibility traversal /// order.F/// /////00 0*000M 0T0` 0g0s 0z000 00 00 0000 00 01 111 11181F1M1Z1a1o 1v11111111111 22 222&252<2I2O2b2h222 22!22 22!23 33'*3:3W3`3s*33 33 33333444$444F4Y4e4t444444445555-5>5M5\5k5z555555551562606T#6j6}66)66)667 7@7@//00B7^7b7c7qA7z7w7|777777777777888878-898LA8[8T8]8s8l8u8888888888888889899999490969I9B9K9`9Z9b9|9p9~999999999999:9::>:6:@:Y:P:[:w:l:y::::::::::::;:;;*;;,;P;F;R;i;d;k;;x;;;;;;;;;;<<<>>>0>&>2>J>D>L>_>Z>a>u>n>w>>>>>>?/??1?o?T?q????????????@ @ @"@M@@@|@@a@Y@O@\@t@d@w@@@@@@@@@@A ,A[A\Aj>/// Creates a semantic annotation using [SemanticsProperties].Aq AxA AAAAAAAAABB'AAAB B;Bc/// Contains properties used by assistive technologies to make the application /// more accessible.B́Df/// If [container] is true, this widget will introduce a new /// node in the semantics tree. Otherwise, the semantics will be /// merged with the semantics of any ancestors (if the ancestor allows that). /// /// Whether descendants of this widget can add their semantic information to the /// [SemanticsNode] introduced by this configuration is controlled by /// [explicitChildNodes].DtqGӃ3/// Whether descendants of this widget are allowed to add semantic information /// to the [SemanticsNode] annotated by this widget. /// /// When set to false descendants are allowed to annotate [SemanticsNode]s of /// their parent with the semantic information they want to contribute to the /// semantic tree. /// When set to true the only way for descendants to contribute semantic /// information to the semantic tree is to introduce new explicit /// [SemanticsNode]s to the tree. /// /// If the semantics properties of this node include /// [SemanticsProperties.scopesRoute] set to true, then [explicitChildNodes] /// must be true also. /// /// This setting is often used in combination with [SemanticsConfiguration.isSemanticBoundary] /// to create semantic boundaries that are either writable or not for children.G_I95/// Whether to replace all child semantics with this node. /// /// Defaults to false. /// /// When this flag is set to true, all child semantics nodes are ignored. /// This can be used as a convenience for cases where a child is wrapped in /// an [ExcludeSemantics] widget and then another [Semantics] widget.INM݄A/// Whether to block user interactions for the rendering subtree. /// /// Setting this to true will prevent users from interacting with The /// rendering object configured by this widget and its subtree through /// pointer-related [SemanticsAction]s in assistive technologies. /// /// The [SemanticsNode] created from this widget is still focusable by /// assistive technologies. Only pointer-related [SemanticsAction]s, such as /// [SemanticsAction.tap] or its friends, are blocked. /// /// If this widget is merged into a parent semantics node, only the /// [SemanticsAction]s of this widget and the widgets in the subtree are /// blocked. /// /// For example: /// ```dart /// void _myTap() { } /// void _myLongPress() { } /// /// Widget build(BuildContext context) { /// return Semantics( /// onTap: _myTap, /// child: Semantics( /// blockUserActions: true, /// onLongPress: _myLongPress, /// child: const Text('label'), /// ), /// ); /// } /// ``` /// /// The result semantics node will still have `_myTap`, but the `_myLongPress` /// will be blocked.MpNN,N:MMOf!OuOOQsQQQQ'QQQSVSS'&SDSS--T\Z4/// A widget that merges the semantics of its descendants. /// /// Causes all the semantics of the subtree rooted at this node to be /// merged into one node in the semantics tree. For example, if you /// have a widget with a Text node next to a checkbox widget, this /// could be used to merge the label from the Text node with the /// "checked" semantic state of the checkbox into a single node that /// had both the label and the checked state. Otherwise, the label /// would be presented as a separate feature than the checkbox, and /// the user would not be able to be sure that they were related. /// /// {@tool snippet} /// This snippet shows how to use [MergeSemantics] to merge the semantics of /// a [Checkbox] and [Text] widget. /// /// ```dart /// MergeSemantics( /// child: Row( /// children: [ /// Checkbox( /// value: true, /// onChanged: (bool? value) {}, /// ), /// const Text('Settings'), /// ], /// ), /// ) /// ``` /// {@end-tool} /// /// Be aware that if two nodes in the subtree have conflicting /// semantics, the result may be nonsensical. For example, a subtree /// with a checked checkbox and an unchecked checkbox will be /// presented as checked. All the labels will be merged into a single /// string (with newlines separating each label from the other). If /// multiple nodes in the merged subtree can handle semantic gestures, /// the first one in tree order will be the one to receive the /// callbacks.ZmvZZB/// Creates a widget that merges the semantics of its descendants.Z ZZ ZZd[[[)ZZ[O]*/// A widget that drops the semantics of all widget that were painted before it /// in the same semantic container. /// /// This is useful to hide widgets from accessibility tools that are painted /// behind a certain widget, e.g. an alert should usually disallow interaction /// with any widget located "behind" the alert (even when they are still /// partially visible). Similarly, an open [Drawer] blocks interactions with /// any widget outside the drawer. /// /// See also: /// /// * [ExcludeSemantics] which drops all semantics of its descendants.]^9^Gu/// Creates a widget that excludes the semantics of all widgets painted before /// it in the same semantic container.^J ^Q^U^[^k ^r^e^~_ {/// Whether this widget is blocking semantics of all widget that were painted /// before it in the same semantic container._v_7_J_X_______!___``-`A&`^```b/// A widget that drops all the semantics of its descendants. /// /// When [excluding] is true, this widget (and its subtree) is excluded from /// the semantics tree. /// /// This can be used to hide descendant widgets that would otherwise be /// reported but that would only be confusing. For example, the /// material library's [Chip] widget hides the avatar since it is /// redundant with the chip label. /// /// See also: /// /// * [BlockSemantics] which drops semantics of widgets earlier in the tree.ccmc}E/// Creates a widget that drops all the semantics of its descendants.c cccc cccQd :/// Whether this widget is excluded in the semantics tree.d|d=dPd^ddddddd#ddde*e;eO&ele*e+e7j.5/// A widget that annotates the child semantics with an index. /// /// Semantic indexes are used by TalkBack/Voiceover to make announcements about /// the current scroll state. Certain widgets like the [ListView] will /// automatically provide a child index for building semantics. A user may wish /// to manually provide semantic indexes if not all child of the scrollable /// contribute semantics. /// /// {@tool snippet} /// /// The example below handles spacers in a scrollable that don't contribute /// semantics. The automatic indexes would give the spaces a semantic index, /// causing scroll announcements to erroneously state that there are four items /// visible. /// /// ```dart /// ListView( /// addSemanticIndexes: false, /// semanticChildCount: 2, /// children: const [ /// IndexedSemantics(index: 0, child: Text('First')), /// Spacer(), /// IndexedSemantics(index: 1, child: Text('Second')), /// Spacer(), /// ], /// ) /// ``` /// {@end-tool} /// /// See also: /// /// * [CustomScrollView], for an explanation of index semantics.jijjQ/// Creates a widget that annotated the first child semantics node with an index.j jjjk k kPkc>/// The index used to annotate the first child semantics node.kmtkkkkmknk倄kl ll#l7kklll}l&llllmm+m]/// A widget that builds its child. /// /// Useful for attaching a key to an existing widget.mcmm+/// Creates a widget that builds its child.m nnnnnnng/// Creates a KeyedSubtree for child with a key that's based on the child's existing key or childIndex.n nnnnnnnnnnnnnnnnnnnnyom`/// The widget below this widget in the tree. /// /// {@macro flutter.widgets.ProxyWidget.child}owp/// Wrap each item in a KeyedSubtree whose key is based on the item's existing key or /// the sum of its list index and `baseIndex`.p,p:pBpGpRq8qqqqqq֌{/// A stateless utility widget whose [build] method uses its /// [builder] callback to create the widget's child. /// /// {@youtube 560 315 https://www.youtube.com/watch?v=xXNOkIuSYuA} /// /// This widget is an inline alternative to defining a [StatelessWidget] /// subclass. For example, instead of defining a widget as follows: /// /// ```dart /// class Foo extends StatelessWidget { /// const Foo({super.key}); /// @override /// Widget build(BuildContext context) => const Text('foo'); /// } /// ``` /// /// ...and using it in the usual way: /// /// ```dart /// // continuing from previous example... /// const Center(child: Foo()) /// ``` /// /// ...one could instead define and use it in a single step, without /// defining a new widget class: /// /// ```dart /// Center( /// child: Builder( /// builder: (BuildContext context) => const Text('foo'), /// ), /// ) /// ``` /// /// The difference between either of the previous examples and /// creating a child directly without an intervening widget, is the /// extra [BuildContext] element that the additional widget adds. This /// is particularly noticeable when the tree contains an inherited /// widget that is referred to by a method like [Scaffold.of], /// which visits the child widget's BuildContext ancestors. /// /// In the following example the button's `onPressed` callback is unable /// to find the enclosing [ScaffoldState] with [Scaffold.of]: /// /// ```dart /// Widget build(BuildContext context) { /// return Scaffold( /// body: Center( /// child: TextButton( /// onPressed: () { /// // Fails because Scaffold.of() doesn't find anything /// // above this widget's context. /// print(Scaffold.of(context).hasAppBar); /// }, /// child: const Text('hasAppBar'), /// ) /// ), /// ); /// } /// ``` /// /// A [Builder] widget introduces an additional [BuildContext] element /// and so the [Scaffold.of] method succeeds. /// /// ```dart /// Widget build(BuildContext context) { /// return Scaffold( /// body: Builder( /// builder: (BuildContext context) { /// return Center( /// child: TextButton( /// onPressed: () { /// print(Scaffold.of(context).hasAppBar); /// }, /// child: const Text('hasAppBar'), /// ), /// ); /// }, /// ), /// ); /// } /// ``` /// /// See also: /// /// * [StatefulBuilder], A stateful utility widget whose [build] method uses its /// [builder] callback to create the widget's child.|~|W|^( /// context: context, /// builder: (BuildContext context) { /// int? selectedRadio = 0; /// return AlertDialog( /// content: StatefulBuilder( /// builder: (BuildContext context, StateSetter setState) { /// return Column( /// mainAxisSize: MainAxisSize.min, /// children: List.generate(4, (int index) { /// return Radio( /// value: index, /// groupValue: selectedRadio, /// onChanged: (int? value) { /// setState(() => selectedRadio = value); /// }, /// ); /// }), /// ); /// }, /// ), /// ); /// }, /// ); /// ``` /// {@end-tool} /// /// See also: /// /// * [Builder], the platonic stateless widget.RO/// Creates a widget that both has state and delegates its build to a callback. }/// Called to obtain the child widget. /// /// This function is called whenever this widget is included in its parent's /// build and the old widget (if any) that it synchronizes with has a distinct /// object identity. Typically the parent's build method will construct /// a new tree of widgets and so a new Builder child will not be [identical] /// to the corresponding old one.L2TEKY23Km/// A widget that paints its area with a specified [Color] and then draws its /// child on top of that color.3E/// Creates a widget that paints its area with the specified [Color].  D0/// The color to paint the background area with. s#6D  ';&X׃p.1A VOXejsku G*/// The fill color for this render object.u du{ de /// Returns the [AxisDirection] in the given [Axis] in the current /// [Directionality] (or the reverse if `reverse` is true). /// /// If `axis` is [Axis.vertical], this function returns [AxisDirection.down] /// unless `reverse` is true, in which case this function returns /// [AxisDirection.up]. /// /// If `axis` is [Axis.horizontal], this function checks the current /// [Directionality]. If the current [Directionality] is right-to-left, then /// this function returns [AxisDirection.left] (unless `reverse` is true, in /// which case it returns [AxisDirection.right]). Similarly, if the current /// [Directionality] is left-to-right, then this function returns /// [AxisDirection.right] (unless `reverse` is true, in which case it returns /// [AxisDirection.left]). /// /// This function is used by a number of scrolling widgets (e.g., [ListView], /// [GridView], [PageView], and [SingleChildScrollView]) as well as [ListBody] /// to translate their [Axis] and `reverse` properties into a concrete /// [AxisDirection].Tbl ry ~/// Signature for the builder callback used by [StatefulBuilder]. /// /// Call `setState` to schedule the [StatefulBuilder] to rebuild.?MUbdart:uipackage:flutter/cupertino.dartpackage:flutter/material.dart)package:flutter/widgets.dart< OXYu 5^̂HvЃ%?QYk؄ 9LYn~҅ 0D`rʆ /?N_uɈ]z.LMkl<@ۋ)wŌhw+,8s-HLMY܏ CpxϏ#+AEGHVZ;nnnnnno@oDooooooopNppq qq#qmqqqqqqqr#rhrrrs(s.s~sssst+t?tNtyttttttuuLugumuuuvv'v(vdvjvvvvvww1wIwkwwwwwx xx>xbx|xxxxy y6yzz#z%z&zWz[zzz{9{{{{{|#|X||||};}X}^}}}}}~~~~H~N~~~~7x78D):Ty}~>i JBY] QSH[j|+F^l3ZtLR./kqBFGS@aefrHLNO8|IbZ`:Ra#4UVo/5Vdj Yy!(,-90SWXdehlT|0Y]#A}/GVq)*NT 12hn ,FGcxy*Jb@Qk<g(gkmno)p=AUY0W >IRX`pt3`/g!9JPQf};oz%:Idu[a 4]w &>Mi-.ouac?X^tz%9S %vAYj;ABJTfy#I1e 5Ktz,2Y]^:Xv‰Ž6ntciĵXš3vƼ_ǀu%&2oɋɧɽ;_fjkw,d˒˹˽˿ W̢A͆͊L{΍Α!iϝϣ#GVnЅІWyёђў %wҕҙқҜ&qӷVԡ>x|A֊*uyׇ׋cح8pv1P{ڨڹڿ1IJە!gmܻ34zݤݪ:ފb߭"#r=>Ggy m~#')*osd{;M.BQp./hnAGmsHm So [l~ Oz OS"&c#6Rag Nno{ 8?CDP`dIM'+7Md*l.=]ntuRS_"eiG rv 8<1>B1yEIjQ @deq ,z4_#'v26 # m   J N b   1 5       5 U q           % ) { (,@)Y!t,0Z^jv!?Ubmv|Rm %)PIMYe}5KXclrzVm-x"VfuPQoubOtz J x    !<!Y!Z!!!"""%"f""""##!#%#&#2#####$4$8$9$E$$% %]%%%%%%&B&&'('v'(( (((f(())g)))*(*{*}*~**++f+++++,",m,,-<---.,.X.z....../#/$/0/~////010W0[0]0^00011P1111122?2@2y222223393|3444M4S4W4X4d44445'5b5f5h5i5566Q6667 7R77888h8z8~889-919999999:Q:f::;;o;;<<<<]><>@>B>C>d>h>? ?Z??@G@|@@A#AbAfABBMBQBBC CCSCWCkCoCCCDDD-DBDrDxDDDDDDE:EEEFFVFFG&GsGGH2HHHI4I5IyIIIIJ1JeJxJJJJKK.K/KiKKKKL$L;L<LLLLLMM<MCMGMHMvMMMMNN_NcNdNpNNOO`OOOOOOPPFPgPPPQQ,Q2QQQQQR&R*RzRRRSS!S5S9SSSSSTTOTUT]TmTqTTTTUU`UtUUV5VVWWcWWWX X*X;XlXmXXXXYY^YbYcYoYYYYZ ZPZ{ZZZZ[7[[[\\T\\]=]]]^*^c^g^^^__^__`M````aa^aab bbb)bqbbcc@cHcNcVcfcjcxc|ccd)dYddeebeeef,f2ffffffgg>gaggghh+h1hhii iWiiijMjajjk kk kmkklKlLllllm<mmmmn(n9n?nnnosotooop&pppq q qUqqqrr^rrscsssttKttttuu;uAuuuuv'v?vEvvvvvvwAwfwgwwwwx9x^xdxxxy y yByHyyz-zyzzzz{{{:{;{G{{|||Q|s|z|~|||}}M}}}}}}~~E~~~Gd"(,./|: ;? U 1(xV #FLMiu{=>ou_w >Du=%Ie7b{/3vz#SWOK6JixST<w}R/5| '-{f*0V\lr1Vk8Xz+<Z|/ZX\^_7|c`ptO F!GXxW <CGHTGr&*,-w%)q@6Jz=Sb 06!o39_eu{:_)*vZuvFL8ze&\cght8Vt@0^GVb(O`fg'vcC´ +oÒîizĘĵ?jžaư0LPǟ9ȅfɶ"&k{ʍʑ6r˿,pq̴̮P}̓KΚΠbcoϾ:eЪЮЯл  Juvтѽ!#$mqKOӛ9aeԪAEՋn֙֝/׀ׄט9y}HX\pbڔژ X۩@ܑ0mqݺ _ޯJ߃ߑߕ]kV!2TU89E=ABNOS<L/W[59%37EI-@P&,u56(.v JPw&h0Oquwx ]fOe)q"f7uFGSMa}&Ul3Ohi]abna|i !"-.^bERV3~  h1Y F H I     k u y      F      $ A B       * [ b f g s   &*+7|T#;?jgRjw1'+-. UX\ C#=QWX-z6aefrP,} <  !!!r!"")"-"z"##^##$$ $T$X$$%<%%%%%%&&&&&&'''6'A'T'i''''''((((('(7(;(O(S((()))))))***.*G*h*u***++8+d+++,,",5,F,U,t,,,,-- ---(-,-:->--..%.q.../1/d////000J0b00000111%1s122W2]223@3\3b333334$4p444445-5S5T5556$6?6U6V6667,7}788d88888997989t999:):;;;;;;;;<-=q====> >$>%>1>v>>?Z?????@=@A@@@@@A-A1AEAAAB-B=BABOBSBBBC7CNC]CCCCDD,D2D3DDDDDEE%E&EbEhEEEEEFF9F:FvF|FFFFFGGGSGgGhGGGGHHH H,HSHHHIIII6IRIvIIIIIIIIJ)JPJJJJJKK&K:KUKVK|KKKKLL/LCLSLuLLLLLLMCMvMMMMMN;N?N@NLN~NNNNNO&O'O3OvOwOOOP2PPPPPPPPPQQOQQRRRGRKRRS<S{SSTToTUUAUEUUUVVRVVVdVhVVWLWWXXdXjXXY9YWY]YmYsYZZWZZZZZZZZ[[)[h[[[[\<\\\\\\]]]8]U]j]]]]^%^v^^^^^__*_G_\_r_s__` ``1`E`[`r````aa aPaaaabMbbc3cdcjczcccdd+d>dOd`dtddddee)eReYepeeeeeeef ffffifofffg=gQggghgghh5h;hhhhi iiciiiijj j`jfjjjk3kEk]k^kwk}kkklKl_lvlwlllm mmdmvmmmmnn[nynznnnnnnoo3o9o:o_oooooopp p p/pOpipoppppppppqq%q)q*q6qkqlqxqqr.rrrssLssssstttktttu(uuuuuv8vvvvw6wwx#xhxxxxyyPyyz3zCzyzz{{W{{{{{|&|u|||||||}}}!}"}r}}}~~~~k~q~~~~JciLRSv$<=msBVfv r`mq ['+uJ?CrvP(vX9%>%u\-{F,za$KQ>-W4WoJDV\ :;u{U[Ht%kqQ2ab$q !'w;ARXe#$s.xnSzIvw%j:RSs=z]O:|hu$\s Dp9Jh%Sw 7wBK0SWBvz Z3xc%4N`"4Pr_­MÖ+/CGz~ĊęijżOƟ<PTǤBȎȴȸ aɜɠɬɻ2;AIM˞?̐.x|+΂%gϣϧϳ-(3ajpx|?҄҈ҶҺ Wӓ XԦCՓ3i׺Cؓ2zٸTڟVjۻ Sܡ5;݀ݧݭMޛ5M[j߇ߟ߽K^r7Z^O/3dht>KV_em} k04@LM,jPT@bW(yXDcg YB7;gkU HLdh,0 WlE)w.oY H-QUcgH'[>DV3QjIM3-}  ^3   3 9    g y z    T   " 7 8 D x     C a {        %+/0<pq} "#e:)zDH\Tim'u0zMQ;&cg"&:>4N\^*5Ca  ! o   !:!!"""#"I"s"""# ###X#{#####$$b$$%%%\%b%&&&/&5&E&K&&' 'K'l'm''( (=(C(()))<)B)Y)q)r))**U*[*****+#+r+++,",(,u,,,-L-----..$.*.q.// /9/?/O/U//0)0K0z0{011171=1122=2C2233D3J334+4p4445*5m566&6'6v6667L77788i8o899R999::S::; ;8;9;o;u;;;;;< <'>(>L>l>>??8?<?=?I???@B@z@AAgABOBSBUBVBBBC C C\CjCnCDD7DkDoDEEWEEF1F5FFG GMGQGeGHH8H<H}HHHHI IYI]IIIJ3JJJKKNKKKL!LrLMMMMMgMMN=NTNNNO0OMOSOOOOPP2PYPPPPPQAQQQQQRR+R1R2RRRRRRSSS#SSSSTTDTHTJTKTiTmTTUURUUVVVdVWWFWJWWX8XXXXXXYJYYYYYYZZ(Z[ZZZ[[ [[['[+[=[A[[[\,\t\\\]&]I]M]a]e]]]^/^3^?^M^x^^^^_____Q__``^`aa7a_aeaaab=bhbubbbbbcc,cMcccd dRdedvddddee@eefAffggKg{gh hhhhAhZh[hhhhhiiDiJiij5j~jjjk3kgkkkkl3lJlKlxllllmm8m>mmmmnInnnnnooorooop0pGp^p_pppq$qvq|qqqrr%r&rarrrrrs's-sfsssstttRtttttuu^uuuuvv/vIvgvvvwwDwKwOwPw\wwxxx:x~xxxxyy:yjyyyyyz zPz{z{D{|S|}}}~"~>BfMQbu3Ah7=>Z`AZ[<Pgh !lrRhiJ]  9?5XYKQ@#Y_^v|1}34ciP=C4< ;<{kqm2>EYo7e3:>?K2FM^}CUsGk7VZ[gb:Lx8%]auy]am OYu} ,Wt&*t @o#=W]^M C=?@(IM4N*>mn =>"<[\cM.XABN 7;=>?QR#r1dh]au7G~!0H`v"TeklHI8efT‡ˆ=>Ã12YĖė<MłŃū?cƇƧ)_ǏǷ?PvȜȾF~ɰMxʥGt˭JQ̪)-pt͎(W[Ψο#'vϸϼX\Хей7qѱѷ5DVgyҞҶ&,w DwԾL՜&vLו׶3JP؟`fٱLڠڱ-BHۓ+rxܸEK݁݇ =Cޒ0߀ag<A;AW9[a/yi,2qw,{KLhi3tz S*OUr&e$()5?CDP3W^hlno@P?C.?Co[DI1uybO}8g&n/5E <@(LP[#48dw{ R1?C  0 4      / 3 A E    F      ! \ b ~      $ l r     (AG8quJQUVb#hCGIJ$s!^b [ #p Pcg>z~,0 "s !/36N]x6GMN-=Cz\b  G K l m y   !"!)!-!.!:!!!!!!!"B"m"####%#&#U#Y##$F$k$$$%%%8%G%Z%%%%%%%&&<&=&I&&&&&&&&';'L'h'''''((O((((((())))g))))))*M**++M++,,J,,--M---. ..K.y..../3//////00&0I0\0o0000000111-1B1V1k1~111112 2212E2^2{222233#3S3o333344 4B4a4444455:5X5v555566P6y66677W7s777788)8N8f8~888889 9*9<9T9j99999:0:J:f:::::;;@;^;r;;;;<6<\<<<<= ="=H=\=|===>> >>>T>h>>??N????@@:@~@@@@AAA AJAmA|AAAABB2B8B9BBBBC CLCCCD=DYDqDrDDEEPEEFFDFhFnFFG GGtGGGH%H+HDHJHHI,IKILIIIJ'JkJqJK KBKHKKKKLLL'LELKLvLLLLMM8MEMPMXMbMhMMMMMNDNkNNNO O'OXO_OcOdOOOOOP=PwPPQ$Q%Q>QQQWQXQQQQQRRROR{RRRRSS SQS|ST TUTYT[T\TTTU%UhUUV1VuVVVWW@WDWPWdWvWWWWWXX"X+X1X9XIXMXXYYUYYZZ.ZkZZZZ[L[N[O[[[\\c\\]] ].]2]z]^^1^{^|^^___ ____````&`k`````a a$aqaaabbWbzb~bbbccecccccccddd$dddde#e'e(e4eyeeeeef1f5ffgghgggggh7hhhhhhhiiJi\iiiiiiiiij(jgjjjjkkkkWkjkkkwkkklFlfljlvllm$m(m*m+mOmSmmmnnnnnno'o-o^otouoopYprpppppq,q3q4qsqqqqqqqrrHrLrrrs s$s0sXsvsssssstt t8tWt_tcttttttu9uBuHuPuTuuvvavvvw)wgwkwwwwwwxxIxwxxxxxyy yyy`yyyyyyz!z<z]z}zzz{ {{&{1{:{@{H{L{Z{^{{||O|a|p|||||}}a}}~~=~>~J~~~~~lm]=AUY'GcY~:Qfz!PkUy0<1yNz~ eI_-3G]abn=0Z`dfN_UbiquitousInheritedElement_UbiquitousInheritedWidgetDirectionalityOpacity ShaderMaskBackdropFilter CustomPaintClipRect ClipRRectClipOvalClipPath PhysicalModel PhysicalShape TransformCompositedTransformTargetCompositedTransformFollower FittedBoxFractionalTranslation RotatedBoxPaddingAlignCenterCustomSingleChildLayoutLayoutIdCustomMultiChildLayoutSizedBoxConstrainedBoxConstraintsTransformBoxUnconstrainedBoxFractionallySizedBox LimitedBox OverflowBoxSizedOverflowBoxOffstage_OffstageElement AspectRatioIntrinsicWidthIntrinsicHeightBaselineIgnoreBaselineSliverToBoxAdapter SliverPadding0getAxisDirectionFromAxisReverseAndDirectionalityListBodyStack IndexedStack_RawIndexedStack_IndexedStackElement PositionedPositionedDirectionalFlexRowColumnFlexibleExpandedWrapFlowRichTextRawImageDefaultAssetBundleWidgetToRenderBoxAdapterListener MouseRegionRepaintBoundary IgnorePointer AbsorbPointerMetaData SemanticsMergeSemanticsBlockSemanticsExcludeSemanticsIndexedSemantics KeyedSubtreeBuilderStatefulBuilder_StatefulBuilderState ColoredBox_RenderColoredBoxDG