x_owner_canBeUsedByParentminWidthmaxWidth minHeight maxHeightcopyWithdeflateloosenenforcetightenflippedwidthConstraintsheightConstraintsconstrainWidthconstrainHeight_debugPropagateDebugSize constrainconstrainDimensions,constrainSizeAndAttemptToPreserveAspectRatiobiggestsmallest hasTightWidthhasTightHeightisTighthasBoundedWidthhasBoundedHeighthasInfiniteWidthhasInfiniteHeight isSatisfiedBy*/~/%lerp isNormalizeddebugAssertIsValid normalize==hashCodetoStringaddWithPaintTransformaddWithPaintOffsetaddWithRawTransformaddWithOutOfBandPosition localPositionoffset noBaseline+minOf dryLayoutbaselinememoizedebugFillTimelineArguments eventLabel_cachedIntrinsicDimensions_cachedDryLayoutSizes_cachedAlphabeticBaseline_cachedIdeoBaselineclearsetupParentData_layoutCacheStorage_debugIntrinsicsDepth_computeIntrinsics_computeWithTimelinegetMinIntrinsicWidthcomputeMinIntrinsicWidthgetMaxIntrinsicWidthcomputeMaxIntrinsicWidthgetMinIntrinsicHeightcomputeMinIntrinsicHeightgetMaxIntrinsicHeightcomputeMaxIntrinsicHeight getDryLayout_computingThisDryLayout_computeDryLayoutcomputeDryLayoutgetDryBaseline_computingThisDryBaseline_computeDryBaselinecomputeDryBaseline_debugDryLayoutCalculationValiddebugCannotComputeDryLayouthasSizesize_sizedebugAdoptSizesemanticBoundsdebugResetSize_debugDoingBaseline_debugSetDoingBaselinegetDistanceToBaselinegetDistanceToActualBaselinecomputeDistanceToActualBaseline constraintsdebugAssertDoesMeetConstraints_debugVerifyDryBaselinesmarkNeedsLayout performResize performLayouthitTest hitTestSelfhitTestChildrenapplyPaintTransform globalToLocal localToGlobal paintBounds handleEvent_debugActivePointersdebugHandleEvent debugPaintdebugPaintSizedebugPaintBaselinesdebugPaintPointersdebugFillProperties+defaultComputeDistanceToFirstActualBaseline-defaultComputeDistanceToHighestActualBaselinedefaultHitTestChildren defaultPaintgetChildrenAsList _DebugSizeBoxConstraints BoxHitTestBoxHitTestWithOutOfBandPositionBoxHitTestResultBoxHitTestEntry BoxParentDataContainerBoxParentDataBaselineOffset_CachedLayoutCalculation _DryLayout _Baseline_IntrinsicDimension_LayoutCacheStorage RenderBoxRenderBoxContainerDefaultsMixinViewConstraints lerpDoubleSizecopyboolwidthheightdoubleinfinitytightForFinitelooseexpand ConstraintstightForminWidthmaxWidth minHeight maxHeightEdgeInsetsGeometry horizontalverticalmax clampDouble_owner_canBeUsedByParentisEmptyoverridesizetoDouble identicaldebugAssertIsValidisFiniteInformationCollectorvoidDiagnosticsNode FlutterError fromPartsinformationCollectorDiagnosticsPropertystyleDiagnosticsTreeStyle errorPropertyisNaNListString isNotEmptylengthadd removeLastsinglejoin ErrorSummaryisAppliedConstraint isInfiniteObject runtimeTypeinthashtoStringAsFixedaddWithPaintTransformhitTestOffsetRenderSliverSingleBoxAdapterhitTestBoxChild RenderSliver HitTestResult RenderObject HitTestEntrywrapSliverHitTestResult PointerEventremovePerspectiveTransformhitTestChildrenMatrix4 transform tryInvertpositionzerooffset pushOffset popTransform MatrixUtilstransformPoint pushTransform paintOffsetpaintTransform rawTransformtargetdescribeIdentity ParentDataContainerRenderObjectMixinContainerParentDataMixin noBaselinelhsrhscomputeDryLayoutlayoutMap_cachedDryLayoutSizes putIfAbsent TextBaseline$2 alphabetic_cachedAlphabeticBaseline ideographic_cachedIdeoBaseline$1_cachedIntrinsicDimensionsnameclearmarkNeedsPaint RenderImageRenderParagraphRenderProxyBoxRenderShiftedBoxRenderObjectWithChildMixin RenderOpacityalwaysNeedsCompositingvisitChildrenForSemanticsopacity parentData dropChild adoptChildattachdetachredepthChildren redepthChild visitChildrendebugDescribeChildren sizedByParentisTightpaintPaintingContextcanvas TextPainter paintImagemarkNeedsCompositingBitsUpdate paintChilddefaultHitTestChildrendescribeApproximatePaintClipdescribeSemanticsConfigurationdebugCheckIntrinsicSizesdebugCheckingIntrinsicsdebugDoingThisResize#debugEnhanceLayoutTimelineArgumentstoDiagnosticsNodetoTimelineArgumentsdebugFillTimelineArguments kReleaseModedebugProfileLayoutsEnabledFlutterTimeline startSync eventLabel argumentsmemoize finishSync mustCallSuperErrorDescription ErrorHintbiggest LayoutBuilderRenderViewportBase!debugThrowIfNotCheckingIntrinsics protectedvisibleForOverriding dryLayouterrorobjectRuntimeTypebaselinecomputeDistanceToActualBaselinereasonparentdebugActiveLayout debugDoingThisLayoutWithCallbackdebugDoingThisLayout_computingThisDryLayout_computingThisDryBaseline StateError shortHashownerdebugDoingLayoutdescribeForErrordebugCanParentUseSizeRectdebugNeedsLayout PipelineOwnerdebugActivePaintdebugDoingThisPaintonlyRealpair+defaultComputeDistanceToFirstActualBaseline constraintshasBoundedWidthhasBoundedHeight isSatisfiedByvaluesmethodReturnedNullmethodReturnedNonNullmarkParentNeedsLayoutmarkNeedsLayoutaddWithPaintOffsetaddWithRawTransformcontains translatedxdygetTransformToancestorinvertVector3perspectiveTransformdotxyPointerDownEventdebugPaintPointersEnabled handleEventPointerUpEventPointerCancelEventdebugPaintSizeEnableddebugPaintBaselinesEnabledvisibleForTestingPaint PaintingStylestroke strokeWidthcolorColordrawRectdeflatePathmoveTolineTodrawPathdepthDiagnosticPropertiesBuilderdebugFillProperties missingIfNull ChildTypeParentDataType firstChildgetDistanceToActualBaseline nextSiblingminOf defaultPaint lastChild transformedpreviousSibling Size Constraints HitTestResult HitTestEntry ParentData BoxParentDataContainerParentDataMixin_CachedLayoutCalculation RenderObjectContainerRenderObjectMixin Ks=0r[Ámath dart:mathViewConstraints lerpDoubleށuidart:ui package:flutter/foundation.dart5package:flutter/gestures.dart`'package:vector_math/vector_math_64.dart debug.dart object.dartff5A=ـހ@d͂ 4]_Â܃.MO368rwDŽ܄DIȆ HMjoBG49B.|ъ֋&\ڋߌ+}05Ҏ `=yŏېB\vސ0Sqϑђ07ϒ%EqÔ.5FM7]ߖgiٖ&FHSٙ O9;tɚК IdfʛMjȜМDs9\Plӟ=EJLà,13fjrwyɤ3p4?_{ϦB_ &ݩ>aQtkt '8?խ(9q)0&+-}mְ VlyбױٱKMjв6Ot{}ܳ.?w+-f46MO7YԸ۸8k X~)I]"):Aо/1jؿ@$@I@N@P@@@@AAEAkAsAxAzAABB4BXB~BBBBCCNCjCCDD6D>DCDEDDDEE#EHEmEuEzE|EEFF7F>FbFFFFFGGG0GMGTGyGGGH/HHHHIInIvIIJ J^JfJsJJKNKVKrKL:LLLLM M(M-M/MoMMMN*N[NbNNO2OMOZOuOOOOP P0PaPiPzPPPQAQqQQQQRRRRfRRRS$SQS]SSTTT\TTTTUUUUUUUUVVtVVVVWWW.WWWWX<XHXQXsXXXYWY`YYZ#Z.ZRZZZ[%[0[9[V[j[u[[[[[\%\n\\\\] ]W]s]]]^(^0^5^7^D^h^^^^^_ __V_}___`` `"`/`E`h`````aaeaaaaab&b`bgbbbbcBcIcKccddd d dAdFdddddee%eteveeef?fnfsffffg>g@g{ggghhehhhiii_ijjjYjjjjjkIklkll=l?llllmCmbmimmn(nqnnno%osop pp#pnpq qXq_qqqrr=rDrSrrrrs-saslsssst t:t[tttuuuu$u7u>uOuVuuv-vrvvvvvwwuwwwwxxaxfxhxxxyybyyyzzz\zczzzz{{a{~{{{{|<|W|s|z||||}}} }T}r}y}~ ~,~3~~~Za>\~Hf i,?F`X_p*aivr(LZ3ZaCy{9<>w| j,}(KPIK+2{8z|Bj$n@]bUdQKACBn !#0Ah >FKMZ#(*7)Dk/Q&Y*1Oze (*7>CER?DFSOCUp$Y[p058:tyg@QAO16"?DB_py] [Qjo ^FKBbLbgp"CH5TYbNS`AF5x}¨­LÂÇ[`mĔ<ņ=Ə*{dzǸ NȖ(fɴ;@Mʒ2ˁAFS̫+9@IN͜:`erΞ0eϙRТ:joѴѹRWҧҬgӮӳ!mԌԑԡԦ;ՈզիJ֖j׷ >CR؋دضؿ Z٧Oڛ2ۄ3܅$GLݜ5{q߸߽?,rLQch>(s `eQF!o`0}kJ+0&;@#rc [C1OTgl7EJlqFK$aAinI4er \^.5BOu).0n#P3GRl=D>GNbgiRR:A; ]    +     ! ( y    \   3     B I   ?szdEL _M*1|3:)x@cLZ%E [AHSaE /    !4!t!{!!""+"="m"~""#(###$F$$$$$$%"%'%)%x%%&&`&&&'5'''()(h(((()<))** *Y***+,+3++++, ,,S,l,z,,,,--W-^--.K.[.b../?/F////0 090J0d001W1m122K2Y2f2o222223F3334.4c4j445J5556*6v66667F77788 8o888899@999::7:H:M:O::;+;2;;< >>8>q>?+?A??@@-@:@C@W@b@@@AA[AbABBPBBBC!CqCxCDD*D1DDDE&ExEEEFHF|FFFG GmGGGGGH HHLH]HbHdHHHI'IpIIIJ(JhJoJKKSKZKKKL LJLLLLMM'MPMwMMMMNN/NCNNNbNgNiNNNO?OOPPP_PPPQ-QhQoQRRSRZRRRS(SVS]SSTBTfTTTTTU9URUUUV5VVVVVVVVW@WWWXXdXYYNYUYYZ:ZZZZ[K[[\?\\\]]m]^^Q^^__'_<_e_``g```aaa;a@aBamaaabb3b>bbbbccc/c4c6cncucddCdJdde:eef/ffg ghggghLhhi9iMiTiijDjjk k9kGkkkll(lllm m|mmmmmmmmmnMnnnoGooooooopPpuppqq9qXqzqqr1rArrrrrrs ss(s:s?sAssssstAtttu2uuuuv4vEvfvvvw,wJwswwxx>xcxxxy1yyz#zrzz{{5{M{{{{||l|}C}O}Q}}}~$~5~c~e~~]/Q2C.r|:FVp(4m+9DMi)9Sp5@Qw 7>4}(z9^x;(I>gy653`rQh d#.7w\(-/jIZa R-cJ +bs  SZ&8x!)Isn3w8KRU\a#gt*/1t-Vt +S_t 6cv f-}'zJZhsFSUqJe-;aKXaL|Xn2@MV}`b/Lg~MeB^y 2BOZ\k ;_?d|:`yž®»2kvxÜ.I`ŝŷ'ƘƨƷ4jǍǜ +uȰUeɄL\ʦʾˇ˗˦˱˺W̝̱r~͈͊:kΏδNcϜϧ/DOЏNўqӖ/>PԋԦ#xՈ:֖@vן%057D`شWٖٞBږ7KS۞B|ܜܫܲiݺWނޞޣޥ޲3ߕ8ydKR<V],}qa&a-(L>N]h:WYa >EM JXE`g/6jqC-n|%X_7>!.sb,:Y(Re/6]:$qQ?x [=[`b@$u  Q V X    P     _    - : i k    s  V]l8_jq 13x #N^ex!(8ALS*;c'2MVjuA3K9` 5dm07%Qr  DK-Y|/_w#,J  K       !;!h!o!!""S"a"""#C#{#######$)$}$$$$% %%_%%%&&=&@&&&''@''''(D(((())).)3)5)r)y))*<*\***+-+U++,,,?,D,F,,,-2-9-J-Q--..3.P../)/R/o//070C0M0a0w000000111&1-1~1122<22233 3 3Q3X3344F4y445 545`5g5{55/// @docImport 'package:flutter/widgets.dart'; /// /// @docImport 'image.dart'; /// @docImport 'paragraph.dart'; /// @docImport 'proxy_box.dart'; /// @docImport 'shifted_box.dart'; /// @docImport 'sliver.dart'; /// @docImport 'viewport.dart';́ 4_ N  8_Џc/// Immutable layout constraints for [RenderBox] layout. /// /// A [Size] respects a [BoxConstraints] if, and only if, all of the following /// relations hold: /// /// * [minWidth] <= [Size.width] <= [maxWidth] /// * [minHeight] <= [Size.height] <= [maxHeight] /// /// The constraints themselves must satisfy these relations: /// /// * 0.0 <= [minWidth] <= [maxWidth] <= [double.infinity] /// * 0.0 <= [minHeight] <= [maxHeight] <= [double.infinity] /// /// [double.infinity] is a legal value for each constraint. /// /// ## The box layout model /// /// Render objects in the Flutter framework are laid out by a one-pass layout /// model which walks down the render tree passing constraints, then walks back /// up the render tree passing concrete geometry. /// /// For boxes, the constraints are [BoxConstraints], which, as described herein, /// consist of four numbers: a minimum width [minWidth], a maximum width /// [maxWidth], a minimum height [minHeight], and a maximum height [maxHeight]. /// /// The geometry for boxes consists of a [Size], which must satisfy the /// constraints described above. /// /// Each [RenderBox] (the objects that provide the layout models for box /// widgets) receives [BoxConstraints] from its parent, then lays out each of /// its children, then picks a [Size] that satisfies the [BoxConstraints]. /// /// Render objects position their children independently of laying them out. /// Frequently, the parent will use the children's sizes to determine their /// position. A child does not know its position and will not necessarily be /// laid out again, or repainted, if its position changes. /// /// ## Terminology /// /// When the minimum constraints and the maximum constraint in an axis are the /// same, that axis is _tightly_ constrained. See: [ /// BoxConstraints.tightFor], [BoxConstraints.tightForFinite], [tighten], /// [hasTightWidth], [hasTightHeight], [isTight]. /// /// An axis with a minimum constraint of 0.0 is _loose_ (regardless of the /// maximum constraint; if it is also 0.0, then the axis is simultaneously tight /// and loose!). See: [BoxConstraints.loose], [loosen]. /// /// An axis whose maximum constraint is not infinite is _bounded_. See: /// [hasBoundedWidth], [hasBoundedHeight]. /// /// An axis whose maximum constraint is infinite is _unbounded_. An axis is /// _expanding_ if it is tightly infinite (its minimum and maximum constraints /// are both infinite). See: [BoxConstraints.expand]. /// /// An axis whose _minimum_ constraint is infinite is just said to be _infinite_ /// (since by definition the maximum constraint must also be infinite in that /// case). See: [hasInfiniteWidth], [hasInfiniteHeight]. /// /// A size is _constrained_ when it satisfies a [BoxConstraints] description. /// See: [constrain], [constrainWidth], [constrainHeight], /// [constrainDimensions], [constrainSizeAndAttemptToPreserveAspectRatio], /// [isSatisfiedBy]. ڐJJX7/// Creates box constraints with the given constraints.`fez p̐ҐӐ2@AFAE/// Creates box constraints that is respected only by the given size.G MLbYdhiwőƑӁ/// Creates box constraints that require the given width or height. /// /// See also: /// /// * [BoxConstraints.tightForFinite], which is similar but instead of /// being tight if the value is non-null, is tight if the value is not /// infinite.  4+<6?TK\V_efwł/// Creates box constraints that require the given width or height, except if /// they are infinite. /// /// See also: /// /// * [BoxConstraints.tightFor], which is similar but instead of being /// tight if the value is not infinite, is tight if the value is non-null.;CB6%+,KQRmduox~Õ˕ŕ͕ӕԕ .$JS70:@ALU[\kٖƖI/// Creates box constraints that forbid sizes larger than the given size. ߖ 6,8<=J)*0*/// Creates box constraints that expand to fill another box constraints. /// /// If width or height is given, the constraints will require exactly the /// given value in the given dimension.2 ;:AJIbYjdmstĘǘ͘Θߘ ,Q_`s`B/// Creates box constraints that match the given view constraints.t̙ÙΙٙڙ!,-=N5/// The minimum width that satisfies the constraints.xY/// The maximum width that satisfies the constraints. /// /// Might be [double.infinity].PXX6/// The minimum height that satisfies the constraints.hzZ/// The maximum height that satisfies the constraints. /// /// Might be [double.infinity]. TTD/// A box constraints with the width and height constraints flipped.v4/// The biggest size that satisfies the constraints./~qq5/// The smallest size that satisfies the constraints.  L/// Whether there is exactly one width value that satisfies the constraints.8M/// Whether there is exactly one height value that satisfies the constraints.  E/// Whether there is exactly one size that satisfies the constraints. QAdd/// Whether there is an upper bound on the maximum width. /// /// See also: /// /// * [hasBoundedHeight], the equivalent for the vertical axis. /// * [hasInfiniteWidth], which describes whether the minimum width /// constraint is infinite.G/// Whether there is an upper bound on the maximum height. /// /// See also: /// /// * [hasBoundedWidth], the equivalent for the horizontal axis. /// * [hasInfiniteHeight], which describes whether the minimum height /// constraint is infinite.傟TT>/// Whether the width constraint is infinite. /// /// Such a constraint is used to indicate that a box should grow as large as /// some other constraint (in this case, horizontally). If constraints are /// infinite, then they must have other (non-infinite) constraints [enforce]d /// upon them, or must be [tighten]ed, before they can be used to derive a /// [Size] for a [RenderBox.size]. /// /// See also: /// /// * [hasInfiniteHeight], the equivalent for the vertical axis. /// * [hasBoundedWidth], which describes whether the maximum width /// constraint is finite.@/// Whether the height constraint is infinite. /// /// Such a constraint is used to indicate that a box should grow as large as /// some other constraint (in this case, vertically). If constraints are /// infinite, then they must have other (non-infinite) constraints [enforce]d /// upon them, or must be [tighten]ed, before they can be used to derive a /// [Size] for a [RenderBox.size]. /// /// See also: /// /// * [hasInfiniteWidth], the equivalent for the horizontal axis. /// * [hasBoundedHeight], which describes whether the maximum height /// constraint is finite.M1OeOe/// Returns whether the object's constraints are normalized. /// Constraints are normalized if the minimums are less than or /// equal to the corresponding maximums. /// /// For example, a BoxConstraints object with a minWidth of 100.0 /// and a maxWidth of 90.0 is not normalized. /// /// Most of the APIs on BoxConstraints expect the constraints to be /// normalized and have undefined behavior when they are not. In /// debug mode, many of these APIs will assert if the constraints /// are not normalized.OOOP`$`9`9`$`%Ĝ^^b/// Creates a copy of this box constraints but with the given fields replaced with the new values.nwvN/// Returns new box constraints that are smaller by the given edge dimensions.0/NᠷV/// Returns new box constraints that remove the minimum width and height requirements.5@π/// Returns new box constraints that respect the given constraints while being /// as close as possible to the original constraints.{xDD/// Returns new box constraints with a tight width and/or height as close to /// the given width and height as possible while still respecting the original /// box constraints.M VU\edpp^/// Returns box constraints with the same width constraints but with /// unconstrained height.Àƨ77^/// Returns box constraints with the same height constraints but with /// unconstrained width.  m/// Returns the width that both satisfies the constraints and is as close as /// possible to the given width."!)/0o/// Returns the height that both satisfies the constraints and is as close as /// possible to the given height.,43/// Pass-through method for adding a hit test while manually managing /// the position transformation logic. /// /// The actual hit testing of the child needs to be implemented in the /// provided `hitTest` callback. The position needs to be handled by /// the caller. /// /// The function returns the return value of the `hitTest` callback. /// /// A `paintOffset`, `paintTransform`, or `rawTransform` should be /// passed to the method to update the hit test stack. /// /// * `paintOffset` has the semantics of the `offset` passed to /// [addWithPaintOffset]. /// /// * `paintTransform` has the semantics of the `transform` passed to /// [addWithPaintTransform], except that it must be invertible; it /// is the responsibility of the caller to ensure this. /// /// * `rawTransform` has the semantics of the `transform` passed to /// [addWithRawTransform]. /// /// Exactly one of these must be non-null. /// /// See also: /// /// * [addWithPaintTransform], which takes a generic paint transform matrix and /// documents the intended usage of this API in more detail..0XW)/// A hit test entry used by [RenderBox]. WEET!/// Creates a box hit test entry.U \[cih}dF/// The position of the hit test in the local coordinates of [target].O>/// Parent data used by [RenderBox] and its subclasses. /// /// {@tool dartpad} /// Parent data is used to communicate to a render object about its /// children. In this example, there are two render objects that perform /// text layout. They use parent data to identify the kind of child they /// are laying out, and space the children accordingly. /// /// ** See code in examples/api/lib/rendering/box/parent_data.0.dart ** /// {@end-tool}.lM/// The offset at which to paint the child in the parent's coordinate system.3ہlʀ/// Abstract [ParentData] subclass for [RenderBox] subclasses that want the /// [ContainerRenderObjectMixin]. /// /// This is a convenience class that mixes in the relevant classes with /// the relevant type arguments.v/// An interface that represents a memoized layout computation run by a [RenderBox]. /// /// Each subclass is inhabited by a single object. Each object represents the /// signature of a memoized layout computation run by [RenderBox]. For instance, /// the [dryLayout] object of the [_DryLayout] subclass represents the signature /// of the [RenderBox.computeDryLayout] method: it takes a [BoxConstraints] (the /// subclass's `Input` type parameter) and returns a [Size] (the subclass's /// `Output` type parameter). /// /// Subclasses do not own their own cache storage. Rather, their [memoize] /// implementation takes a `cacheStorage`. If a prior computation with the same /// input values has already been memoized in `cacheStorage`, it returns the /// memoized value without running `computer`. Otherwise the method runs the /// `computer` to compute the return value, and caches the result to /// `cacheStorage`. /// /// The layout cache storage is typically cleared in `markNeedsLayout`, but is /// usually kept across [RenderObject.layout] calls because the incoming /// [BoxConstraints] is always an input of every layout computation.0 -((3<=E_LLT ihv }|s%%F%[Zr yx' %$77E ZYl|{&%&Opp%OP,_@@KVU,- q::H ]\o$@%$#"aF077Q>vv8EJJ:yICCN\/// A render object in a 2D Cartesian coordinate system. /// /// The [size] of each box is expressed as a width and a height. Each box has /// its own coordinate system in which its upper left corner is placed at (0, /// 0). The lower right corner of the box is therefore at (width, height). The /// box contains all the points including the upper left corner and extending /// to, but not including, the lower right corner. /// /// Box layout is performed by passing a [BoxConstraints] object down the tree. /// The box constraints establish a min and max value for the child's width and /// height. In determining its size, the child must respect the constraints /// given to it by its parent. /// /// This protocol is sufficient for expressing a number of common box layout /// data flows. For example, to implement a width-in-height-out data flow, call /// your child's [layout] function with a set of box constraints with a tight /// width value (and pass true for parentUsesSize). After the child determines /// its height, use the child's height to determine your size. /// /// ## Writing a RenderBox subclass /// /// One would implement a new [RenderBox] subclass to describe a new layout /// model, new paint model, new hit-testing model, or new semantics model, while /// remaining in the Cartesian space defined by the [RenderBox] protocol. /// /// To create a new protocol, consider subclassing [RenderObject] instead. /// /// ### Constructors and properties of a new RenderBox subclass /// /// The constructor will typically take a named argument for each property of /// the class. The value is then passed to a private field of the class and the /// constructor asserts its correctness (e.g. if it should not be null, it /// asserts it's not null). /// /// Properties have the form of a getter/setter/field group like the following: /// /// ```dart /// AxisDirection get axis => _axis; /// AxisDirection _axis = AxisDirection.down; // or initialized in constructor /// set axis(AxisDirection value) { /// if (value == _axis) { /// return; /// } /// _axis = value; /// markNeedsLayout(); /// } /// ``` /// /// The setter will typically finish with either a call to [markNeedsLayout], if /// the layout uses this property, or [markNeedsPaint], if only the painter /// function does. (No need to call both, [markNeedsLayout] implies /// [markNeedsPaint].) /// /// Consider layout and paint to be expensive; be conservative about calling /// [markNeedsLayout] or [markNeedsPaint]. They should only be called if the /// layout (or paint, respectively) has actually changed. /// /// ### Children /// /// If a render object is a leaf, that is, it cannot have any children, then /// ignore this section. (Examples of leaf render objects are [RenderImage] and /// [RenderParagraph].) /// /// For render objects with children, there are four possible scenarios: /// /// * A single [RenderBox] child. In this scenario, consider inheriting from /// [RenderProxyBox] (if the render object sizes itself to match the child) or /// [RenderShiftedBox] (if the child will be smaller than the box and the box /// will align the child inside itself). /// /// * A single child, but it isn't a [RenderBox]. Use the /// [RenderObjectWithChildMixin] mixin. /// /// * A single list of children. Use the [ContainerRenderObjectMixin] mixin. /// /// * A more complicated child model. /// /// #### Using RenderProxyBox /// /// By default, a [RenderProxyBox] render object sizes itself to fit its child, or /// to be as small as possible if there is no child; it passes all hit testing /// and painting on to the child, and intrinsic dimensions and baseline /// measurements similarly are proxied to the child. /// /// A subclass of [RenderProxyBox] just needs to override the parts of the /// [RenderBox] protocol that matter. For example, [RenderOpacity] just /// overrides the paint method (and [alwaysNeedsCompositing] to reflect what the /// paint method does, and the [visitChildrenForSemantics] method so that the /// child is hidden from accessibility tools when it's invisible), and adds an /// [RenderOpacity.opacity] field. /// /// [RenderProxyBox] assumes that the child is the size of the parent and /// positioned at 0,0. If this is not true, then use [RenderShiftedBox] instead. /// /// See /// [proxy_box.dart](https://github.com/flutter/flutter/blob/main/packages/flutter/lib/src/rendering/proxy_box.dart) /// for examples of inheriting from [RenderProxyBox]. /// /// #### Using RenderShiftedBox /// /// By default, a [RenderShiftedBox] acts much like a [RenderProxyBox] but /// without assuming that the child is positioned at 0,0 (the actual position /// recorded in the child's [parentData] field is used), and without providing a /// default layout algorithm. /// /// See /// [shifted_box.dart](https://github.com/flutter/flutter/blob/main/packages/flutter/lib/src/rendering/shifted_box.dart) /// for examples of inheriting from [RenderShiftedBox]. /// /// #### Kinds of children and child-specific data /// /// A [RenderBox] doesn't have to have [RenderBox] children. One can use another /// subclass of [RenderObject] for a [RenderBox]'s children. See the discussion /// at [RenderObject]. /// /// Children can have additional data owned by the parent but stored on the /// child using the [parentData] field. The class used for that data must /// inherit from [ParentData]. The [setupParentData] method is used to /// initialize the [parentData] field of a child when the child is attached. /// /// By convention, [RenderBox] objects that have [RenderBox] children use the /// [BoxParentData] class, which has a [BoxParentData.offset] field to store the /// position of the child relative to the parent. ([RenderProxyBox] does not /// need this offset and therefore is an exception to this rule.) /// /// #### Using RenderObjectWithChildMixin /// /// If a render object has a single child but it isn't a [RenderBox], then the /// [RenderObjectWithChildMixin] class, which is a mixin that will handle the /// boilerplate of managing a child, will be useful. /// /// It's a generic class with one type argument, the type of the child. For /// example, if you are building a `RenderFoo` class which takes a single /// `RenderBar` child, you would use the mixin as follows: /// /// ```dart /// class RenderFoo extends RenderBox /// with RenderObjectWithChildMixin { /// // ... /// } /// ``` /// /// Since the `RenderFoo` class itself is still a [RenderBox] in this case, you /// still have to implement the [RenderBox] layout algorithm, as well as /// features like intrinsics and baselines, painting, and hit testing. /// /// #### Using ContainerRenderObjectMixin /// /// If a render box can have multiple children, then the /// [ContainerRenderObjectMixin] mixin can be used to handle the boilerplate. It /// uses a linked list to model the children in a manner that is easy to mutate /// dynamically and that can be walked efficiently. Random access is not /// efficient in this model; if you need random access to the children consider /// the next section on more complicated child models. /// /// The [ContainerRenderObjectMixin] class has two type arguments. The first is /// the type of the child objects. The second is the type for their /// [parentData]. The class used for [parentData] must itself have the /// [ContainerParentDataMixin] class mixed into it; this is where /// [ContainerRenderObjectMixin] stores the linked list. A [ParentData] class /// can extend [ContainerBoxParentData]; this is essentially /// [BoxParentData] mixed with [ContainerParentDataMixin]. For example, if a /// `RenderFoo` class wanted to have a linked list of [RenderBox] children, one /// might create a `FooParentData` class as follows: /// /// ```dart /// class FooParentData extends ContainerBoxParentData { /// // (any fields you might need for these children) /// } /// ``` /// /// When using [ContainerRenderObjectMixin] in a [RenderBox], consider mixing in /// [RenderBoxContainerDefaultsMixin], which provides a collection of utility /// methods that implement common parts of the [RenderBox] protocol (such as /// painting the children). /// /// The declaration of the `RenderFoo` class itself would thus look like this: /// /// ```dart /// // continuing from previous example... /// class RenderFoo extends RenderBox with /// ContainerRenderObjectMixin, /// RenderBoxContainerDefaultsMixin { /// // ... /// } /// ``` /// /// When walking the children (e.g. during layout), the following pattern is /// commonly used (in this case assuming that the children are all [RenderBox] /// objects and that this render object uses `FooParentData` objects for its /// children's [parentData] fields): /// /// ```dart /// // continuing from previous example... /// RenderBox? child = firstChild; /// while (child != null) { /// final FooParentData childParentData = child.parentData! as FooParentData; /// // ...operate on child and childParentData... /// assert(child.parentData == childParentData); /// child = childParentData.nextSibling; /// } /// ``` /// /// #### More complicated child models /// /// Render objects can have more complicated models, for example a map of /// children keyed on an enum, or a 2D grid of efficiently randomly-accessible /// children, or multiple lists of children, etc. If a render object has a model /// that can't be handled by the mixins above, it must implement the /// [RenderObject] child protocol, as follows: /// /// * Any time a child is removed, call [dropChild] with the child. /// /// * Any time a child is added, call [adoptChild] with the child. /// /// * Implement the [attach] method such that it calls [attach] on each child. /// /// * Implement the [detach] method such that it calls [detach] on each child. /// /// * Implement the [redepthChildren] method such that it calls [redepthChild] /// on each child. /// /// * Implement the [visitChildren] method such that it calls its argument for /// each child, typically in paint order (back-most to front-most). /// /// * Implement [debugDescribeChildren] such that it outputs a [DiagnosticsNode] /// for each child. /// /// Implementing these seven bullet points is essentially all that the two /// aforementioned mixins do. /// /// ### Layout /// /// [RenderBox] classes implement a layout algorithm. They have a set of /// constraints provided to them, and they size themselves based on those /// constraints and whatever other inputs they may have (for example, their /// children or properties). /// /// When implementing a [RenderBox] subclass, one must make a choice. Does it /// size itself exclusively based on the constraints, or does it use any other /// information in sizing itself? An example of sizing purely based on the /// constraints would be growing to fit the parent. /// /// Sizing purely based on the constraints allows the system to make some /// significant optimizations. Classes that use this approach should override /// [sizedByParent] to return true, and then override [computeDryLayout] to /// compute the [Size] using nothing but the constraints, e.g.: /// /// ```dart /// @override /// bool get sizedByParent => true; /// /// @override /// Size computeDryLayout(BoxConstraints constraints) { /// return constraints.smallest; /// } /// ``` /// /// Otherwise, the size is set in the [performLayout] function. /// /// The [performLayout] function is where render boxes decide, if they are not /// [sizedByParent], what [size] they should be, and also where they decide /// where their children should be. /// /// #### Layout of RenderBox children /// /// The [performLayout] function should call the [layout] function of each (box) /// child, passing it a [BoxConstraints] object describing the constraints /// within which the child can render. Passing tight constraints (see /// [BoxConstraints.isTight]) to the child will allow the rendering library to /// apply some optimizations, as it knows that if the constraints are tight, the /// child's dimensions cannot change even if the layout of the child itself /// changes. /// /// If the [performLayout] function will use the child's size to affect other /// aspects of the layout, for example if the render box sizes itself around the /// child, or positions several children based on the size of those children, /// then it must specify the `parentUsesSize` argument to the child's [layout] /// function, setting it to true. /// /// This flag turns off some optimizations; algorithms that do not rely on the /// children's sizes will be more efficient. (In particular, relying on the /// child's [size] means that if the child is marked dirty for layout, the /// parent will probably also be marked dirty for layout, unless the /// [constraints] given by the parent to the child were tight constraints.) /// /// For [RenderBox] classes that do not inherit from [RenderProxyBox], once they /// have laid out their children, they should also position them, by setting the /// [BoxParentData.offset] field of each child's [parentData] object. /// /// #### Layout of non-RenderBox children /// /// The children of a [RenderBox] do not have to be [RenderBox]es themselves. If /// they use another protocol (as discussed at [RenderObject]), then instead of /// [BoxConstraints], the parent would pass in the appropriate [Constraints] /// subclass, and instead of reading the child's size, the parent would read /// whatever the output of [layout] is for that layout protocol. The /// `parentUsesSize` flag is still used to indicate whether the parent is going /// to read that output, and optimizations still kick in if the child has tight /// constraints (as defined by [Constraints.isTight]). /// /// ### Painting /// /// To describe how a render box paints, implement the [paint] method. It is /// given a [PaintingContext] object and an [Offset]. The painting context /// provides methods to affect the layer tree as well as a /// [PaintingContext.canvas] which can be used to add drawing commands. The /// canvas object should not be cached across calls to the [PaintingContext]'s /// methods; every time a method on [PaintingContext] is called, there is a /// chance that the canvas will change identity. The offset specifies the /// position of the top left corner of the box in the coordinate system of the /// [PaintingContext.canvas]. /// /// To draw text on a canvas, use a [TextPainter]. /// /// To draw an image to a canvas, use the [paintImage] method. /// /// A [RenderBox] that uses methods on [PaintingContext] that introduce new /// layers should override the [alwaysNeedsCompositing] getter and set it to /// true. If the object sometimes does and sometimes does not, it can have that /// getter return true in some cases and false in others. In that case, whenever /// the return value would change, call [markNeedsCompositingBitsUpdate]. (This /// is done automatically when a child is added or removed, so you don't have to /// call it explicitly if the [alwaysNeedsCompositing] getter only changes value /// based on the presence or absence of children.) /// /// Anytime anything changes on the object that would cause the [paint] method /// to paint something different (but would not cause the layout to change), /// the object should call [markNeedsPaint]. /// /// #### Painting children /// /// The [paint] method's `context` argument has a [PaintingContext.paintChild] /// method, which should be called for each child that is to be painted. It /// should be given a reference to the child, and an [Offset] giving the /// position of the child relative to the parent. /// /// If the [paint] method applies a transform to the painting context before /// painting children (or generally applies an additional offset beyond the /// offset it was itself given as an argument), then the [applyPaintTransform] /// method should also be overridden. That method must adjust the matrix that it /// is given in the same manner as it transformed the painting context and /// offset before painting the given child. This is used by the [globalToLocal] /// and [localToGlobal] methods. /// /// #### Hit Tests /// /// Hit testing for render boxes is implemented by the [hitTest] method. The /// default implementation of this method defers to [hitTestSelf] and /// [hitTestChildren]. When implementing hit testing, you can either override /// these latter two methods, or ignore them and just override [hitTest]. /// /// The [hitTest] method itself is given an [Offset], and must return true if the /// object or one of its children has absorbed the hit (preventing objects below /// this one from being hit), or false if the hit can continue to other objects /// below this one. /// /// For each child [RenderBox], the [hitTest] method on the child should be /// called with the same [HitTestResult] argument and with the point transformed /// into the child's coordinate space (in the same manner that the /// [applyPaintTransform] method would). The default implementation defers to /// [hitTestChildren] to call the children. [RenderBoxContainerDefaultsMixin] /// provides a [RenderBoxContainerDefaultsMixin.defaultHitTestChildren] method /// that does this assuming that the children are axis-aligned, not transformed, /// and positioned according to the [BoxParentData.offset] field of the /// [parentData]; more elaborate boxes can override [hitTestChildren] /// accordingly. /// /// If the object is hit, then it should also add itself to the [HitTestResult] /// object that is given as an argument to the [hitTest] method, using /// [HitTestResult.add]. The default implementation defers to [hitTestSelf] to /// determine if the box is hit. If the object adds itself before the children /// can add themselves, then it will be as if the object was above the children. /// If it adds itself after the children, then it will be as if it was below the /// children. Entries added to the [HitTestResult] object should use the /// [BoxHitTestEntry] class. The entries are subsequently walked by the system /// in the order they were added, and for each entry, the target's [handleEvent] /// method is called, passing in the [HitTestEntry] object. /// /// Hit testing cannot rely on painting having happened. /// /// ### Semantics /// /// For a render box to be accessible, implement the /// [describeApproximatePaintClip], [visitChildrenForSemantics], and /// [describeSemanticsConfiguration] methods. The default implementations are /// sufficient for objects that only affect layout, but nodes that represent /// interactive components or information (diagrams, text, images, etc) should /// provide more complete implementations. For more information, see the /// documentation for these members. /// /// ### Intrinsics and Baselines /// /// The layout, painting, hit testing, and semantics protocols are common to all /// render objects. [RenderBox] objects must implement two additional protocols: /// intrinsic sizing and baseline measurements. /// /// There are four methods to implement for intrinsic sizing, to compute the /// minimum and maximum intrinsic width and height of the box. The documentation /// for these methods discusses the protocol in detail: /// [computeMinIntrinsicWidth], [computeMaxIntrinsicWidth], /// [computeMinIntrinsicHeight], [computeMaxIntrinsicHeight]. /// /// Be sure to set [debugCheckIntrinsicSizes] to true in your unit tests if you /// do override any of these methods, which will add additional checks to /// help validate your implementation. /// /// In addition, if the box has any children, it must implement /// [computeDistanceToActualBaseline]. [RenderProxyBox] provides a simple /// implementation that forwards to the child; [RenderShiftedBox] provides an /// implementation that offsets the child's baseline information by the position /// of the child relative to the parent. If you do not inherited from either of /// these classes, however, you must implement the algorithm yourself.E..DWX`$kkL$LLLaD&aIaIaem2mmm '-sCkssE/// Whether this render object has undergone layout and has a [size].suu/// The size of this render box computed during layout. /// /// This value is stale whenever this object is marked as needing layout. /// During [performLayout], do not read the size of a child unless you pass /// true for parentUsesSize when calling the child's [layout] function. /// /// The size of a box should be set only during the box's [performLayout] or /// [performResize] functions. If you wish to change the size of a box outside /// of those functions, call [markNeedsLayout] instead to schedule a layout of /// the box.;3?/// The box constraints most recently received from the parent.vw Z  E E/// Returns a rectangle that contains all the pixels painted by this box. /// /// The paint bounds can be larger or smaller than [size], which is the amount /// of space this box takes up during layout. For example, if this box casts a /// shadow, that shadow might extend beyond the space allocated to this box /// during layout. /// /// The paint bounds are used to size the buffers into which this box paints. /// If the box attempts to paints outside its paint bounds, there might not be /// enough memory allocated to represent the box's visual appearance, which /// can lead to undefined behavior. /// /// The returned paint bounds are in the local coordinate system of this box. / 0`/// Setting the size, in debug mode, triggers some analysis of the render box, /// as implemented by [debugAssertDoesMeetConstraints], including calling the intrinsic /// sizing methods and checking that they meet certain invariants. *gyygh,  $#2399NNNdddr, k#/// Returns the minimum width that this box could be without failing to /// correctly paint its contents within itself, without clipping. /// /// The height argument may give a specific height to assume. The given height /// can be infinite, meaning that the intrinsic width in an unconstrained /// environment is being requested. The given height should never be negative /// or null. /// /// This function should only be called on one's children. Calling this /// function couples the child with the parent so that when the child's layout /// changes, the parent is notified (via [markNeedsLayout]). /// /// Calling this function is expensive as it can result in O(N^2) behavior. /// /// Do not override this method. Instead, implement [computeMinIntrinsicWidth].  jj/// Computes the value returned by [getMinIntrinsicWidth]. Do not call this /// function directly, instead, call [getMinIntrinsicWidth]. /// /// Override in subclasses that implement [performLayout]. This method should /// return the minimum width that this box could be without failing to /// correctly paint its contents within itself, without clipping. /// /// If the layout algorithm is independent of the context (e.g. it always /// tries to be a particular size), or if the layout algorithm is /// width-in-height-out, or if the layout algorithm uses both the incoming /// width and height constraints (e.g. it always sizes itself to /// [BoxConstraints.biggest]), then the `height` argument should be ignored. /// /// If the layout algorithm is strictly height-in-width-out, or is /// height-in-width-out when the width is unconstrained, then the height /// argument is the height to use. /// /// The `height` argument will never be negative or null. It may be infinite. /// /// If this algorithm depends on the intrinsic dimensions of a child, the /// intrinsic dimensions of that child should be obtained using the functions /// whose names start with `get`, not `compute`. /// /// This function should never return a negative or infinite value. /// /// Be sure to set [debugCheckIntrinsicSizes] to true in your unit tests if /// you do override this method, which will add additional checks to help /// validate your implementation. /// /// ## Examples /// /// ### Text /// /// English text is the canonical example of a width-in-height-out algorithm. /// The `height` argument is therefore ignored. /// /// Consider the string "Hello World". The _maximum_ intrinsic width (as /// returned from [computeMaxIntrinsicWidth]) would be the width of the string /// with no line breaks. /// /// The minimum intrinsic width would be the width of the widest word, "Hello" /// or "World". If the text is rendered in an even narrower width, however, it /// might still not overflow. For example, maybe the rendering would put a /// line-break half-way through the words, as in "Hel⁞lo⁞Wor⁞ld". However, /// this wouldn't be a _correct_ rendering, and [computeMinIntrinsicWidth] is /// defined as returning the minimum width that the box could be without /// failing to _correctly_ paint the contents within itself. /// /// The minimum intrinsic _height_ for a given width _smaller_ than the /// minimum intrinsic width could therefore be greater than the minimum /// intrinsic height for the minimum intrinsic width. /// /// ### Viewports (e.g. scrolling lists) /// /// Some render boxes are intended to clip their children. For example, the /// render box for a scrolling list might always size itself to its parents' /// size (or rather, to the maximum incoming constraints), regardless of the /// children's sizes, and then clip the children and position them based on /// the current scroll offset. /// /// The intrinsic dimensions in these cases still depend on the children, even /// though the layout algorithm sizes the box in a way independent of the /// children. It is the size that is needed to paint the box's contents (in /// this case, the children) _without clipping_ that matters. /// /// ### When the intrinsic dimensions cannot be known /// /// There are cases where render objects do not have an efficient way to /// compute their intrinsic dimensions. For example, it may be prohibitively /// expensive to reify and measure every child of a lazy viewport (viewports /// generally only instantiate the actually visible children), or the /// dimensions may be computed by a callback about which the render object /// cannot reason. /// /// In such cases, it may be impossible (or at least impractical) to actually /// return a valid answer. In such cases, the intrinsic functions should throw /// when [RenderObject.debugCheckingIntrinsics] is false and asserts are /// enabled, and return 0.0 otherwise. /// /// See the implementations of [LayoutBuilder] or [RenderViewportBase] for /// examples (in particular, /// [RenderViewportBase.debugThrowIfNotCheckingIntrinsics]). /// /// ### Aspect-ratio-driven boxes /// /// Some boxes always return a fixed size based on the constraints. For these /// boxes, the intrinsic functions should return the appropriate size when the /// incoming `height` or `width` argument is finite, treating that as a tight /// constraint in the respective direction and treating the other direction's /// constraints as unbounded. This is because the definitions of /// [computeMinIntrinsicWidth] and [computeMinIntrinsicHeight] are in terms of /// what the dimensions _could be_, and such boxes can only be one size in /// such cases. /// /// When the incoming argument is not finite, then they should return the /// actual intrinsic dimensions based on the contents, as any other box would. /// /// See also: /// /// * [computeMaxIntrinsicWidth], which computes the smallest width beyond /// which increasing the width never decreases the preferred height. UVv"F"FJ/// Returns the smallest width beyond which increasing the width never /// decreases the preferred height. The preferred height is the value that /// would be returned by [getMinIntrinsicHeight] for that width. /// /// The height argument may give a specific height to assume. The given height /// can be infinite, meaning that the intrinsic width in an unconstrained /// environment is being requested. The given height should never be negative /// or null. /// /// This function should only be called on one's children. Calling this /// function couples the child with the parent so that when the child's layout /// changes, the parent is notified (via [markNeedsLayout]). /// /// Calling this function is expensive as it can result in O(N^2) behavior. /// /// Do not override this method. Instead, implement /// [computeMaxIntrinsicWidth]."[ "c"b"-".%+,,/// Computes the value returned by [getMaxIntrinsicWidth]. Do not call this /// function directly, instead, call [getMaxIntrinsicWidth]. /// /// Override in subclasses that implement [performLayout]. This should return /// the smallest width beyond which increasing the width never decreases the /// preferred height. The preferred height is the value that would be returned /// by [computeMinIntrinsicHeight] for that width. /// /// If the layout algorithm is strictly height-in-width-out, or is /// height-in-width-out when the width is unconstrained, then this should /// return the same value as [computeMinIntrinsicWidth] for the same height. /// /// Otherwise, the height argument should be ignored, and the returned value /// should be equal to or bigger than the value returned by /// [computeMinIntrinsicWidth]. /// /// The `height` argument will never be negative or null. It may be infinite. /// /// The value returned by this method might not match the size that the object /// would actually take. For example, a [RenderBox] subclass that always /// exactly sizes itself using [BoxConstraints.biggest] might well size itself /// bigger than its max intrinsic size. /// /// If this algorithm depends on the intrinsic dimensions of a child, the /// intrinsic dimensions of that child should be obtained using the functions /// whose names start with `get`, not `compute`. /// /// This function should never return a negative or infinite value. /// /// Be sure to set [debugCheckIntrinsicSizes] to true in your unit tests if /// you do override this method, which will add additional checks to help /// validate your implementation. /// /// See also: /// /// * [computeMinIntrinsicWidth], which has usage examples., ,,,U,V,n,o,Ȇ*00/// Returns the minimum height that this box could be without failing to /// correctly paint its contents within itself, without clipping. /// /// The width argument may give a specific width to assume. The given width /// can be infinite, meaning that the intrinsic height in an unconstrained /// environment is being requested. The given width should never be negative /// or null. /// /// This function should only be called on one's children. Calling this /// function couples the child with the parent so that when the child's layout /// changes, the parent is notified (via [markNeedsLayout]). /// /// Calling this function is expensive as it can result in O(N^2) behavior. /// /// Do not override this method. Instead, implement /// [computeMinIntrinsicHeight].0( 000///2S: : /// Computes the value returned by [getMinIntrinsicHeight]. Do not call this /// function directly, instead, call [getMinIntrinsicHeight]. /// /// Override in subclasses that implement [performLayout]. Should return the /// minimum height that this box could be without failing to correctly paint /// its contents within itself, without clipping. /// /// If the layout algorithm is independent of the context (e.g. it always /// tries to be a particular size), or if the layout algorithm is /// height-in-width-out, or if the layout algorithm uses both the incoming /// height and width constraints (e.g. it always sizes itself to /// [BoxConstraints.biggest]), then the `width` argument should be ignored. /// /// If the layout algorithm is strictly width-in-height-out, or is /// width-in-height-out when the height is unconstrained, then the width /// argument is the width to use. /// /// The `width` argument will never be negative or null. It may be infinite. /// /// If this algorithm depends on the intrinsic dimensions of a child, the /// intrinsic dimensions of that child should be obtained using the functions /// whose names start with `get`, not `compute`. /// /// This function should never return a negative or infinite value. /// /// Be sure to set [debugCheckIntrinsicSizes] to true in your unit tests if /// you do override this method, which will add additional checks to help /// validate your implementation. /// /// See also: /// /// * [computeMinIntrinsicWidth], which has usage examples. /// * [computeMaxIntrinsicHeight], which computes the smallest height beyond /// which increasing the height never decreases the preferred width.:& :.:-9999:Qu==H/// Returns the smallest height beyond which increasing the height never /// decreases the preferred width. The preferred width is the value that /// would be returned by [getMinIntrinsicWidth] for that height. /// /// The width argument may give a specific width to assume. The given width /// can be infinite, meaning that the intrinsic height in an unconstrained /// environment is being requested. The given width should never be negative /// or null. /// /// This function should only be called on one's children. Calling this /// function couples the child with the parent so that when the child's layout /// changes, the parent is notified (via [markNeedsLayout]). /// /// Calling this function is expensive as it can result in O(N^2) behavior. /// /// Do not override this method. Instead, implement /// [computeMaxIntrinsicHeight].= >>==@̇H!H!/// Computes the value returned by [getMaxIntrinsicHeight]. Do not call this /// function directly, instead, call [getMaxIntrinsicHeight]. /// /// Override in subclasses that implement [performLayout]. Should return the /// smallest height beyond which increasing the height never decreases the /// preferred width. The preferred width is the value that would be returned /// by [computeMinIntrinsicWidth] for that height. /// /// If the layout algorithm is strictly width-in-height-out, or is /// width-in-height-out when the height is unconstrained, then this should /// return the same value as [computeMinIntrinsicHeight] for the same width. /// /// Otherwise, the width argument should be ignored, and the returned value /// should be equal to or bigger than the value returned by /// [computeMinIntrinsicHeight]. /// /// The `width` argument will never be negative or null. It may be infinite. /// /// The value returned by this method might not match the size that the object /// would actually take. For example, a [RenderBox] subclass that always /// exactly sizes itself using [BoxConstraints.biggest] might well size itself /// bigger than its max intrinsic size. /// /// If this algorithm depends on the intrinsic dimensions of a child, the /// intrinsic dimensions of that child should be obtained using the functions /// whose names start with `get`, not `compute`. /// /// This function should never return a negative or infinite value. /// /// Be sure to set [debugCheckIntrinsicSizes] to true in your unit tests if /// you do override this method, which will add additional checks to help /// validate your implementation. /// /// See also: /// /// * [computeMinIntrinsicWidth], which has usage examples.H; HCHBGGH H HfKLL`/// Returns the [Size] that this [RenderBox] would like to be given the /// provided [BoxConstraints]. /// /// The size returned by this method is guaranteed to be the same size that /// this [RenderBox] computes for itself during layout given the same /// constraints. /// /// This function should only be called on one's children. Calling this /// function couples the child with the parent so that when the child's layout /// changes, the parent is notified (via [markNeedsLayout]). /// /// This layout is called "dry" layout as opposed to the regular "wet" layout /// run performed by [performLayout] because it computes the desired size for /// the given constraints without changing any internal state. /// /// Calling this function is expensive as it can result in O(N^2) behavior. /// /// Do not override this method. Instead, implement [computeDryLayout].L!$L;L:KKLLLLMMNkTT/// Computes the value returned by [getDryLayout]. Do not call this /// function directly, instead, call [getDryLayout]. /// /// Override in subclasses that implement [performLayout] or [performResize] /// or when setting [sizedByParent] to true without overriding /// [performResize]. This method should return the [Size] that this /// [RenderBox] would like to be given the provided [BoxConstraints]. /// /// The size returned by this method must match the [size] that the /// [RenderBox] will compute for itself in [performLayout] (or /// [performResize], if [sizedByParent] is true). /// /// If this algorithm depends on the size of a child, the size of that child /// should be obtained using its [getDryLayout] method. /// /// This layout is called "dry" layout as opposed to the regular "wet" layout /// run performed by [performLayout] because it computes the desired size for /// the given constraints without changing any internal state. /// /// ### When the size cannot be known /// /// There are cases where render objects do not have an efficient way to /// compute their size. For example, the size may computed by a callback about /// which the render object cannot reason. /// /// In such cases, it may be impossible (or at least impractical) to actually /// return a valid answer. In such cases, the function should call /// [debugCannotComputeDryLayout] from within an assert and return a dummy /// value of `const Size(0, 0)`.T$TTThTiTTVM^[^[ /// Returns the distance from the top of the box to the first baseline of the /// box's contents for the given `constraints`, or `null` if this [RenderBox] /// does not have any baselines. /// /// This method calls [computeDryBaseline] under the hood and caches the result. /// [RenderBox] subclasses typically don't overridden [getDryBaseline]. Instead, /// consider overriding [computeDryBaseline] such that it returns a baseline /// location that is consistent with [getDistanceToActualBaseline]. See the /// documentation for the [computeDryBaseline] method for more details. /// /// This method is usually called by the [computeDryBaseline] or the /// [computeDryLayout] implementation of a parent [RenderBox] to get the /// baseline location of a [RenderBox] child. Unlike [getDistanceToBaseline], /// this method takes a [BoxConstraints] as an argument and computes the /// baseline location as if the [RenderBox] was laid out by the parent using /// that [BoxConstraints]. /// /// The "dry" in the method name means this method, like [getDryLayout], has /// no observable side effects when called, as opposed to "wet" layout methods /// such as [performLayout] (which changes this [RenderBox]'s [size], and the /// offsets of its children if any). Since this method does not depend on the /// current layout, unlike [getDistanceToBaseline], it's ok to call this method /// when this [RenderBox]'s layout is outdated. /// /// Similar to the intrinsic width/height and [getDryLayout], calling this /// function in [performLayout] is expensive, as it can result in O(N^2) layout /// performance, where N is the number of render objects in the render subtree. /// Typically this method should be only called by the parent [RenderBox]'s /// [computeDryBaseline] or [computeDryLayout] implementation.^j$^^^^^aoa~a~a#aac8kQkQ/// Computes the value returned by [getDryBaseline]. /// /// This method is for overriding only and shouldn't be called directly. To /// get this [RenderBox]'s speculative baseline location for the given /// `constraints`, call [getDryBaseline] instead. /// /// The "dry" in the method name means the implementation must not produce /// observable side effects when called. For example, it must not change the /// [size] of the [RenderBox], or its children's paint offsets, otherwise that /// would results in UI changes when [paint] is called, or hit-testing behavior /// changes when [hitTest] is called. Moreover, accessing the current layout /// of this [RenderBox] or child [RenderBox]es (including accessing [size], or /// `child.size`) usually indicates a bug in the implementation, as the current /// layout is typically calculated using a set of [BoxConstraints] that's /// different from the `constraints` given as the first parameter. To get the /// size of this [RenderBox] or a child [RenderBox] in this method's /// implementation, use the [getDryLayout] method instead. /// /// The implementation must return a value that represents the distance from /// the top of the box to the first baseline of the box's contents, for the /// given `constraints`, or `null` if the [RenderBox] has no baselines. It's /// the same exact value [RenderBox.computeDistanceToActualBaseline] would /// return, when this [RenderBox] was laid out at `constraints` in the same /// exact state. /// /// Not all [RenderBox]es support dry baseline computation. For example, to /// compute the dry baseline of a [LayoutBuilder], its `builder` may have to /// be called with different constraints, which may have side effects such as /// updating the widget tree, violating the "dry" contract. In such cases the /// [RenderBox] must call [debugCannotComputeDryLayout] in an assert, and /// return a dummy baseline offset value (such as `null`).kd$k~k}kkkk"k#k;k<m@p|p|O/// Called from [computeDryLayout] or [computeDryBaseline] within an assert if /// the given [RenderBox] subclass does not support calculating a dry layout. /// /// When asserts are enabled and [debugCheckingIntrinsics] is not true, this /// method will either throw the provided [FlutterError] or it will create and /// throw a [FlutterError] with the provided `reason`. Otherwise, it will /// return true. /// /// One of the arguments has to be provided. /// /// See also: /// /// * [computeDryLayout], which lists some reasons why it may not be feasible /// to compute the dry layout.pppppp @@/// Claims ownership of the given [Size]. /// /// In debug mode, the [RenderBox] class verifies that [Size] objects obtained /// from other [RenderBox] objects are only used according to the semantics of /// the [RenderBox] protocol, namely that a [Size] from a [RenderBox] can only /// be used by its parent, and then only if `parentUsesSize` was set. /// /// Sometimes, a [Size] that can validly be used ends up no longer being valid /// over time. The common example is a [Size] taken from a child that is later /// removed from the parent. In such cases, this method can be called to first /// check whether the size can legitimately be used, and if so, to then create /// a new [Size] that can be used going forward, regardless of what happens to /// the original owner.O UTi 1/// Returns the distance from the y-coordinate of the position of the box to /// the y-coordinate of the first given baseline in the box's contents. /// /// Used by certain layout models to align adjacent boxes on a common /// baseline, regardless of padding, font size differences, etc. If there is /// no baseline, this function returns the distance from the y-coordinate of /// the position of the box to the y-coordinate of the bottom of the box /// (i.e., the height of the box) unless the caller passes true /// for `onlyReal`, in which case the function returns null. /// /// Only call this function after calling [layout] on this box. You /// are only allowed to call this from the parent of this box during /// that parent's [performLayout] or [paint] functions. /// /// When implementing a [RenderBox] subclass, to override the baseline /// computation, override [computeDistanceToActualBaseline]. /// /// See also: /// /// * [getDryBaseline], which returns the baseline location of this /// [RenderBox] at a certain [BoxConstraints]. BB/// Calls [computeDistanceToActualBaseline] and caches the result. /// /// This function must only be called from [getDistanceToBaseline] and /// [computeDistanceToActualBaseline]. Do not call this function directly from /// outside those two methods.^lk() --/// Returns the distance from the y-coordinate of the position of the box to /// the y-coordinate of the first given baseline in the box's contents, if /// any, or null otherwise. /// /// Do not call this function directly. If you need to know the baseline of a /// child from an invocation of [performLayout] or [paint], call /// [getDistanceToBaseline]. /// /// Subclasses should override this method to supply the distances to their /// baselines. When implementing this method, there are generally three /// strategies: /// /// * For classes that use the [ContainerRenderObjectMixin] child model, /// consider mixing in the [RenderBoxContainerDefaultsMixin] class and /// using /// [RenderBoxContainerDefaultsMixin.defaultComputeDistanceToFirstActualBaseline]. /// /// * For classes that define a particular baseline themselves, return that /// value directly. /// /// * For classes that have a child to which they wish to defer the /// computation, call [getDistanceToActualBaseline] on the child (not /// [computeDistanceToActualBaseline], the internal implementation, and not /// [getDistanceToBaseline], the public entry point for this API).M[Zϡ Q9KK9:ف/// {@macro flutter.rendering.RenderObject.performResize} /// /// By default this method sets [size] to the result of [computeDryLayout] /// called with the current [constraints]. Instead of overriding this method, /// consider overriding [computeDryLayout].ާ޹޹ާިō杅/// Determines the set of render objects located at the given position. /// /// Returns true, and adds any render objects that contain the point to the /// given hit test result, if this render object or one of its descendants /// absorbs the hit (preventing objects below this one from being hit). /// Returns false if the hit can continue to other objects below this one. /// /// The caller is responsible for transforming [position] from global /// coordinates to its location relative to the origin of this [RenderBox]. /// This [RenderBox] is responsible for checking whether the given position is /// within its bounds. /// /// If transforming is necessary, [BoxHitTestResult.addWithPaintTransform], /// [BoxHitTestResult.addWithPaintOffset], or /// [BoxHitTestResult.addWithRawTransform] need to be invoked by the caller /// to record the required transform operations in the [HitTestResult]. These /// methods will also help with applying the transform to `position`. /// /// Hit testing requires layout to be up-to-date but does not require painting /// to be up-to-date. That means a render object can rely upon [performLayout] /// having been called in [hitTest] but cannot rely upon [paint] having been /// called. For example, a render object might be a child of a [RenderOpacity] /// object, which calls [hitTest] on its children when its opacity is zero /// even though it does not [paint] its children.ق__K/// Override this method if this render object can be hit even if its /// children were not hit. /// /// Returns true if the specified `position` should be considered a hit /// on this render object. /// /// The caller is responsible for transforming [position] from global /// coordinates to its location relative to the origin of this [RenderBox]. /// This [RenderBox] is responsible for checking whether the given position is /// within its bounds. /// /// Used by [hitTest]. If you override [hitTest] and do not call this /// function, then you don't need to implement this function.ksrLMF/// Override this method to check whether any children are located at the /// given position. /// /// Subclasses should return true if at least one child reported a hit at the /// specified position. /// /// Typically children should be hit-tested in reverse paint order so that /// hit tests at locations where children overlap hit the child that is /// visually "on top" (i.e., paints later). /// /// The caller is responsible for transforming [position] from global /// coordinates to its location relative to the origin of this [RenderBox]. /// Likewise, this [RenderBox] is responsible for transforming the position /// that it passes to its children when it calls [hitTest] on each child. /// /// If transforming is necessary, [BoxHitTestResult.addWithPaintTransform], /// [BoxHitTestResult.addWithPaintOffset], or /// [BoxHitTestResult.addWithRawTransform] need to be invoked by subclasses to /// record the required transform operations in the [BoxHitTestResult]. These /// methods will also help with applying the transform to `position`. /// /// Used by [hitTest]. If you override [hitTest] and do not call this /// function, then you don't need to implement this function.pqׇ55-/// Multiply the transform from the parent's coordinate system to this box's /// coordinate system into the given transform. /// /// This function is used to convert coordinate systems between boxes. /// Subclasses that apply transforms during painting should override this /// function to factor those transforms into the calculation. /// /// The [RenderBox] implementation takes care of adjusting the matrix for the /// position of the given child as determined during layout and stored on the /// child's [parentData] in the [BoxParentData.offset] field.IWV]fe#$ff/// Convert the given point from the global coordinate system in logical pixels /// to the local coordinate system for this box. /// /// This method will un-project the point from the screen onto the widget, /// which makes it different from [MatrixUtils.transformPoint]. /// /// If the transform from global coordinates to local coordinates is /// degenerate, this function returns [Offset.zero]. /// /// If `ancestor` is non-null, this function converts the given point from the /// coordinate system of `ancestor` (which must be an ancestor of this render /// object) instead of from the global coordinate system. /// /// This method is implemented in terms of [getTransformTo].t |{dςE/// Convert the given point from the local coordinate system for this box to /// the global coordinate system in logical pixels. /// /// If `ancestor` is non-null, this function converts the given point to the /// coordinate system of `ancestor` (which must be an ancestor of this render /// object) instead of to the global coordinate system. /// /// This method is implemented in terms of [getTransformTo]. If the transform /// matrix puts the given `point` on the line at infinity (for instance, when /// the transform matrix is the zero matrix), this method returns (NaN, NaN).  m/// Override this method to handle pointer events that hit this render object. /// /// For [RenderBox] objects, the `entry` argument is a [BoxHitTestEntry]. From this /// object you can determine the [PointerDownEvent]'s position in local coordinates. /// (This is useful because [PointerEvent.position] is in global coordinates.) /// /// Implementations of this method should call [debugHandleEvent] as follows, /// so that they support [debugPaintPointersEnabled]: /// /// ```dart /// class RenderFoo extends RenderBox { /// // ... /// /// @override /// void handleEvent(PointerEvent event, HitTestEntry entry) { /// assert(debugHandleEvent(event, entry)); /// // ... handle the event ... /// } /// /// // ... /// } /// ```5Ut/// Implements the [debugPaintPointersEnabled] debugging feature. /// /// [RenderBox] subclasses that implement [handleEvent] should call /// [debugHandleEvent] from their [handleEvent] method, as follows: /// /// ```dart /// class RenderFoo extends RenderBox { /// // ... /// /// @override /// void handleEvent(PointerEvent event, HitTestEntry entry) { /// assert(debugHandleEvent(event, entry)); /// // ... handle the event ... /// } /// /// // ... /// } /// ``` /// /// If you call this for a [PointerDownEvent], make sure you also call it for /// the corresponding [PointerUpEvent] or [PointerCancelEvent].  ! ^ /// In debug mode, paints a border around this render box. /// /// Called for every [RenderBox] when [debugPaintSizeEnabled] is true. /// In debug mode, paints a line for each baseline. /// /// Called for every [RenderBox] when [debugPaintBaselinesEnabled] is true.  "h"hO/// In debug mode, paints a rectangle if this render box has counted more /// pointer downs than pointer up events. /// /// Called for every [RenderBox] when [debugPaintPointersEnabled] is true. /// /// By default, events are not counted. For details on how to ensure that /// events are counted for your class, see [debugHandleEvent]."{""" """U"V####&####  ,@@H ]\j rqx ,-Ghh% GHH]\\grqHIKE/// A wrapper that represents the baseline location of a `RenderBox`.ˁVVY/// A value that indicates that the associated `RenderBox` does not have any /// baselines. /// /// [BaselineOffset.noBaseline] is an identity element in most binary /// operations involving two [BaselineOffset]s (such as [minOf]), for render /// objects with no baselines typically do not contribute to the baseline /// offset of their parents.cqvr~2../// Returns a new baseline location that is `offset` pixels further away from /// the origin than `this`, or unchanged if `this` is [noBaseline].0 87J$/// Compares this [BaselineOffset] and `other`, and returns whichever is closer /// to the origin. /// /// When both `this` and `other` are [noBaseline], this method returns /// [noBaseline]. When one of them is [noBaseline], this method returns the /// other operand that's not [noBaseline].d fe-e-/// Method signature for hit testing a [RenderBox]. /// /// Used by [BoxHitTestResult.addWithPaintTransform] to hit test children /// of a [RenderBox]. /// /// See also: /// /// * [RenderBox.hitTest], which documents more details around hit testing /// [RenderBox]es.eHeZeYeaeiehevffj/// Method signature for hit testing a [RenderBox] with a manually /// managed position (one that is passed out-of-band). /// /// Used by [RenderSliverSingleBoxAdapter.hitTestBoxChild] to hit test /// [RenderBox] children of a [RenderSliver]. /// /// See also: /// /// * [RenderBox.hitTest], which documents more details around hit testing /// [RenderBox]es.g#g5g4$%%+/// A mixin that provides useful default behaviors for boxes with children /// managed by the [ContainerRenderObjectMixin] mixin. /// /// By convention, this class doesn't override any members of the superclass. /// Instead, it provides helpful functions that subclasses can call as /// appropriate.%%%&8&&&'J'J/// Returns the baseline of the first child with a baseline. /// /// Useful when the children are displayed vertically in the same order they /// appear in the child list.'v'')7 ))/// Returns the minimum baseline value among every child. /// /// Useful when the vertical position of the children isn't determined by the /// order in the child list.*"*0*/,H--X/// Performs a hit test on each child by walking the child list backwards. /// /// Stops walking once after the first child reports that it contains the /// given point. Returns whether any children contain the given point. /// /// See also: /// /// * [defaultPaint], which paints the children appropriate for this /// hit-testing strategy.----..0ӂ511À/// Paints each child by walking the child list forwards. /// /// See also: /// /// * [defaultHitTestChildren], which implements hit-testing of the children /// in a manner appropriate for this painting strategy.1111 113p4/4//// Returns a list containing the children of this render object. /// /// This function is useful when you need random-access to the children of /// this render object. If you're accessing the children in order, consider /// walking the child list directly.package:flutter/widgets.dart image.dartparagraph.dart'proxy_box.dartIshifted_box.dartm sliver.dart viewport.dartA=ـހ@d͂ 4]_Â܃.MO368rwDŽ܄DIȆ HMjoBG49B.|ъ֋&\ڋߌ+}05Ҏ `=yŏېB\vސ0Sqϑђ07ϒ%EqÔ.5FM7]ߖgiٖ&FHSٙ O9;tɚК IdfʛMjȜМDs9\Plӟ=EJLà,13fjrwyɤ3p4?_{ϦB_ &ݩ>aQtkt '8?խ(9q)0&+-}mְ VlyбױٱKMjв6Ot{}ܳ.?w+-f46MO7YԸ۸8k X~)I]"):Aо/1jؿ@$@I@N@P@@@@AAEAkAsAxAzAABB4BXB~BBBBCCNCjCCDD6D>DCDEDDDEE#EHEmEuEzE|EEFF7F>FbFFFFFGGG0GMGTGyGGGH/HHHHIInIvIIJ J^JfJsJJKNKVKrKL:LLLLM M(M-M/MoMMMN*N[NbNNO2OMOZOuOOOOP P0PaPiPzPPPQAQqQQQQRRRRfRRRS$SQS]SSTTT\TTTTUUUUUUUUVVtVVVVWWW.WWWWX<XHXQXsXXXYWY`YYZ#Z.ZRZZZ[%[0[9[V[j[u[[[[[\%\n\\\\] ]W]s]]]^(^0^5^7^D^h^^^^^_ __V_}___`` `"`/`E`h`````aaeaaaaab&b`bgbbbbcBcIcKccddd d dAdFdddddee%eteveeef?fnfsffffg>g@g{ggghhehhhiii_ijjjYjjjjjkIklkll=l?llllmCmbmimmn(nqnnno%osop pp#pnpq qXq_qqqrr=rDrSrrrrs-saslsssst t:t[tttuuuu$u7u>uOuVuuv-vrvvvvvwwuwwwwxxaxfxhxxxyybyyyzzz\zczzzz{{a{~{{{{|<|W|s|z||||}}} }T}r}y}~ ~,~3~~~Za>\~Hf i,?F`X_p*aivr(LZ3ZaCy{9<>w| j,}(KPIK+2{8z|Bj$n@]bUdQKACBn !#0Ah >FKMZ#(*7)Dk/Q&Y*1Oze (*7>CER?DFSOCUp$Y[p058:tyg@QAO16"?DB_py] [Qjo ^FKBbLbgp"CH5TYbNS`AF5x}¨­LÂÇ[`mĔ<ņ=Ə*{dzǸ NȖ(fɴ;@Mʒ2ˁAFS̫+9@IN͜:`erΞ0eϙRТ:joѴѹRWҧҬgӮӳ!mԌԑԡԦ;ՈզիJ֖j׷ >CR؋دضؿ Z٧Oڛ2ۄ3܅$GLݜ5{q߸߽?,rLQch>(s `eQF!o`0}kJ+0&;@#rc [C1OTgl7EJlqFK$aAinI4er \^.5BOu).0n#P3GRl=D>GNbgiRR:A; ]    +     ! ( y    \   3     B I   ?szdEL _M*1|3:)x@cLZ%E [AHSaE /    !4!t!{!!""+"="m"~""#(###$F$$$$$$%"%'%)%x%%&&`&&&'5'''()(h(((()<))** *Y***+,+3++++, ,,S,l,z,,,,--W-^--.K.[.b../?/F////0 090J0d001W1m122K2Y2f2o222223F3334.4c4j445J5556*6v66667F77788 8o888899@999::7:H:M:O::;+;2;;< >>8>q>?+?A??@@-@:@C@W@b@@@AA[AbABBPBBBC!CqCxCDD*D1DDDE&ExEEEFHF|FFFG GmGGGGGH HHLH]HbHdHHHI'IpIIIJ(JhJoJKKSKZKKKL LJLLLLMM'MPMwMMMMNN/NCNNNbNgNiNNNO?OOPPP_PPPQ-QhQoQRRSRZRRRS(SVS]SSTBTfTTTTTU9URUUUV5VVVVVVVVW@WWWXXdXYYNYUYYZ:ZZZZ[K[[\?\\\]]m]^^Q^^__'_<_e_``g```aaa;a@aBamaaabb3b>bbbbccc/c4c6cncucddCdJdde:eef/ffg ghggghLhhi9iMiTiijDjjk k9kGkkkll(lllm m|mmmmmmmmmnMnnnoGooooooopPpuppqq9qXqzqqr1rArrrrrrs ss(s:s?sAssssstAtttu2uuuuv4vEvfvvvw,wJwswwxx>xcxxxy1yyz#zrzz{{5{M{{{{||l|}C}O}Q}}}~$~5~c~e~~]/Q2C.r|:FVp(4m+9DMi)9Sp5@Qw 7>4}(z9^x;(I>gy653`rQh d#.7w\(-/jIZa R-cJ +bs  SZ&8x!)Isn3w8KRU\a#gt*/1t-Vt +S_t 6cv f-}'zJZhsFSUqJe-;aKXaL|Xn2@MV}`b/Lg~MeB^y 2BOZ\k ;_?d|:`yž®»2kvxÜ.I`ŝŷ'ƘƨƷ4jǍǜ +uȰUeɄL\ʦʾˇ˗˦˱˺W̝̱r~͈͊:kΏδNcϜϧ/DOЏNўqӖ/>PԋԦ#xՈ:֖@vן%057D`شWٖٞBږ7KS۞B|ܜܫܲiݺWނޞޣޥ޲3ߕ8ydKR<V],}qa&a-(L>N]h:WYa >EM JXE`g/6jqC-n|%X_7>!.sb,:Y(Re/6]:$qQ?x [=[`b@$u  Q V X    P     _    - : i k    s  V]l8_jq 13x #N^ex!(8ALS*;c'2MVjuA3K9` 5dm07%Qr  DK-Y|/_w#,J  K       !;!h!o!!""S"a"""#C#{#######$)$}$$$$% %%_%%%&&=&@&&&''@''''(D(((())).)3)5)r)y))*<*\***+-+U++,,,?,D,F,,,-2-9-J-Q--..3.P../)/R/o//070C0M0a0w000000111&1-1~1122<22233 3 3Q3X3344F4y445 545`5g5{55 _DebugSizeBoxConstraintsBoxHitTestResultBoxHitTestEntry BoxParentDataContainerBoxParentData_CachedLayoutCalculation _DryLayout _Baseline_IntrinsicDimension_LayoutCacheStorage RenderBoxRenderBoxContainerDefaultsMixin!