// Copyright 2014 The Flutter Authors. All rights reserved.

// Use of this source code is governed by a BSD-style license that can be

// found in the LICENSE file.

/// @docImport 'package:flutter/widgets.dart';

///

/// @docImport 'proxy_sliver.dart';

/// @docImport 'sliver.dart';

library;

import 'dart:ui' as ui show Color, Gradient, Image, ImageFilter;

import 'package:flutter/animation.dart';

import 'package:flutter/foundation.dart';

import 'package:flutter/gestures.dart';

import 'package:flutter/semantics.dart';

import 'package:flutter/services.dart';

import 'binding.dart';

import 'box.dart';

import 'image_filter_config.dart';

import 'layer.dart';

import 'layout_helper.dart';

import 'object.dart';

export 'package:flutter/gestures.dart'

show PointerCancelEvent, PointerDownEvent, PointerEvent, PointerMoveEvent, PointerUpEvent;

/// A base class for render boxes that resemble their children.

///

/// A proxy box has a single child and mimics all the properties of that

/// child by calling through to the child for each function in the render box

/// protocol. For example, a proxy box determines its size by asking its child

/// to layout with the same constraints and then matching the size.

///

/// A proxy box isn't useful on its own because you might as well just replace

/// the proxy box with its child. However, RenderProxyBox is a useful base class

/// for render objects that wish to mimic most, but not all, of the properties

/// of their child.

///

/// See also:

///

/// * [RenderProxySliver], a base class for render slivers that resemble their

/// children.

class RenderProxyBox extends RenderBox

with RenderObjectWithChildMixin<RenderBox>, RenderProxyBoxMixin<RenderBox> {

/// Creates a proxy render box.

///

/// Proxy render boxes are rarely created directly because they proxy

/// the render box protocol to [child]. Instead, consider using one of the

/// subclasses.

RenderProxyBox([RenderBox? child]) {

this.child = child;

}

}

/// Implementation of [RenderProxyBox].

///

/// Use this mixin in situations where the proxying behavior

/// of [RenderProxyBox] is desired but inheriting from [RenderProxyBox] is

/// impractical (e.g. because you want to inherit from a different class).

///

/// If a class already inherits from [RenderProxyBox] and also uses this mixin,

/// you can safely delete the use of the mixin.

@optionalTypeArgs

mixin RenderProxyBoxMixin<T extends RenderBox> on RenderBox, RenderObjectWithChildMixin<T> {

@override

void setupParentData(RenderObject child) {

// We don't actually use the offset argument in BoxParentData, so let's

// avoid allocating it at all.

if (child.parentData is! ParentData) {

child.parentData = ParentData();

}

}

@override

double computeMinIntrinsicWidth(double height) {

return child?.getMinIntrinsicWidth(height) ?? 0.0;

}

@override

double computeMaxIntrinsicWidth(double height) {

return child?.getMaxIntrinsicWidth(height) ?? 0.0;

}

@override

double computeMinIntrinsicHeight(double width) {

return child?.getMinIntrinsicHeight(width) ?? 0.0;

}

@override

double computeMaxIntrinsicHeight(double width) {

return child?.getMaxIntrinsicHeight(width) ?? 0.0;

}

@override

double? computeDistanceToActualBaseline(TextBaseline baseline) {

return child?.getDistanceToActualBaseline(baseline) ??

super.computeDistanceToActualBaseline(baseline);

}

@override

@protected

double? computeDryBaseline(covariant BoxConstraints constraints, TextBaseline baseline) {

final double? result = child?.getDryBaseline(constraints, baseline);

return result ?? super.computeDryBaseline(constraints, baseline);

}

@override

@protected

Size computeDryLayout(covariant BoxConstraints constraints) {

return child?.getDryLayout(constraints) ?? computeSizeForNoChild(constraints);

}

@override

void performLayout() {

size =

(child?..layout(constraints, parentUsesSize: true))?.size ??

computeSizeForNoChild(constraints);

return;

}

/// Calculate the size the [RenderProxyBox] would have under the given

/// [BoxConstraints] for the case where it does not have a child.

Size computeSizeForNoChild(BoxConstraints constraints) {

return constraints.smallest;

}

@override

bool hitTestChildren(BoxHitTestResult result, {required Offset position}) {

return child?.hitTest(result, position: position) ?? false;

}

@override

void applyPaintTransform(RenderObject child, Matrix4 transform) {}

@override

void paint(PaintingContext context, Offset offset) {

final RenderBox? child = this.child;

if (child == null) {

return;

}

context.paintChild(child, offset);

}

}

/// How to behave during hit tests.

enum HitTestBehavior {

/// Targets that defer to their children receive events within their bounds

/// only if one of their children is hit by the hit test.

deferToChild,

/// Opaque targets can be hit by hit tests, causing them to both receive

/// events within their bounds and prevent targets visually behind them from

/// also receiving events.

opaque,

/// Translucent targets both receive events within their bounds and permit

/// targets visually behind them to also receive events.

translucent,

}

/// A RenderProxyBox subclass that allows you to customize the

/// hit-testing behavior.

abstract class RenderProxyBoxWithHitTestBehavior extends RenderProxyBox {

/// Initializes member variables for subclasses.

///

/// By default, the [behavior] is [HitTestBehavior.deferToChild].

RenderProxyBoxWithHitTestBehavior({

this.behavior = HitTestBehavior.deferToChild,

RenderBox? child,

}) : super(child);

/// How to behave during hit testing when deciding how the hit test propagates

/// to children and whether to consider targets behind this one.

///

/// Defaults to [HitTestBehavior.deferToChild].

///

/// See [HitTestBehavior] for the allowed values and their meanings.

HitTestBehavior behavior;

@override

bool hitTest(BoxHitTestResult result, {required Offset position}) {

var hitTarget = false;

if (size.contains(position)) {

hitTarget = hitTestChildren(result, position: position) || hitTestSelf(position);

if (hitTarget || behavior == HitTestBehavior.translucent) {

result.add(BoxHitTestEntry(this, position));

}

}

return hitTarget;

}

@override

bool hitTestSelf(Offset position) => behavior == HitTestBehavior.opaque;

@override

void debugFillProperties(DiagnosticPropertiesBuilder properties) {

super.debugFillProperties(properties);

properties.add(EnumProperty<HitTestBehavior>('behavior', behavior, defaultValue: null));

}

}

/// Imposes additional constraints on its child.

///

/// A render constrained box proxies most functions in the render box protocol

/// to its child, except that when laying out its child, it tightens the

/// constraints provided by its parent by enforcing the [additionalConstraints]

/// as well.

///

/// 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

/// [additionalConstraints].

class RenderConstrainedBox extends RenderProxyBox {

/// Creates a render box that constrains its child.

///

/// The [additionalConstraints] argument must be valid.

RenderConstrainedBox({RenderBox? child, required BoxConstraints additionalConstraints})

: assert(additionalConstraints.debugAssertIsValid()),

_additionalConstraints = additionalConstraints,

super(child);

/// Additional constraints to apply to [child] during layout.

BoxConstraints get additionalConstraints => _additionalConstraints;

BoxConstraints _additionalConstraints;

set additionalConstraints(BoxConstraints value) {

assert(value.debugAssertIsValid());

if (_additionalConstraints == value) {

return;

}

_additionalConstraints = value;

markNeedsLayout();

}

@override

double computeMinIntrinsicWidth(double height) {

if (_additionalConstraints.hasBoundedWidth && _additionalConstraints.hasTightWidth) {

return _additionalConstraints.minWidth;

}

final double width = super.computeMinIntrinsicWidth(height);

assert(width.isFinite);

if (!_additionalConstraints.hasInfiniteWidth) {

return _additionalConstraints.constrainWidth(width);

}

return width;

}

@override

double computeMaxIntrinsicWidth(double height) {

if (_additionalConstraints.hasBoundedWidth && _additionalConstraints.hasTightWidth) {

return _additionalConstraints.minWidth;

}

final double width = super.computeMaxIntrinsicWidth(height);

assert(width.isFinite);

if (!_additionalConstraints.hasInfiniteWidth) {

return _additionalConstraints.constrainWidth(width);

}

return width;

}

@override

double computeMinIntrinsicHeight(double width) {

if (_additionalConstraints.hasBoundedHeight && _additionalConstraints.hasTightHeight) {

return _additionalConstraints.minHeight;

}

final double height = super.computeMinIntrinsicHeight(width);

assert(height.isFinite);

if (!_additionalConstraints.hasInfiniteHeight) {

return _additionalConstraints.constrainHeight(height);

}

return height;

}

@override

double computeMaxIntrinsicHeight(double width) {

if (_additionalConstraints.hasBoundedHeight && _additionalConstraints.hasTightHeight) {

return _additionalConstraints.minHeight;

}

final double height = super.computeMaxIntrinsicHeight(width);

assert(height.isFinite);

if (!_additionalConstraints.hasInfiniteHeight) {

return _additionalConstraints.constrainHeight(height);

}

return height;

}

@override

double? computeDryBaseline(covariant BoxConstraints constraints, TextBaseline baseline) {

return child?.getDryBaseline(_additionalConstraints.enforce(constraints), baseline);

}

@override

void performLayout() {

final BoxConstraints constraints = this.constraints;

if (child != null) {

child!.layout(_additionalConstraints.enforce(constraints), parentUsesSize: true);

size = child!.size;

} else {

size = _additionalConstraints.enforce(constraints).constrain(Size.zero);

}

}

@override

@protected

Size computeDryLayout(covariant BoxConstraints constraints) {

return child?.getDryLayout(_additionalConstraints.enforce(constraints)) ??

_additionalConstraints.enforce(constraints).constrain(Size.zero);

}

@override

void debugPaintSize(PaintingContext context, Offset offset) {

super.debugPaintSize(context, offset);

assert(() {

final Paint paint;

if (child == null || child!.size.isEmpty) {

paint = Paint()..color = const Color(0x90909090);

context.canvas.drawRect(offset & size, paint);

}

return true;

}());

}

@override

void debugFillProperties(DiagnosticPropertiesBuilder properties) {

super.debugFillProperties(properties);

properties.add(

DiagnosticsProperty<BoxConstraints>('additionalConstraints', additionalConstraints),

);

}

}

/// Constrains the child's [BoxConstraints.maxWidth] and

/// [BoxConstraints.maxHeight] if they're otherwise unconstrained.

///

/// 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).

class RenderLimitedBox extends RenderProxyBox {

/// Creates a render box that imposes a maximum width or maximum height on its

/// child if the child is otherwise unconstrained.

///

/// The [maxWidth] and [maxHeight] arguments not be null and must be

/// non-negative.

RenderLimitedBox({

RenderBox? child,

double maxWidth = double.infinity,

double maxHeight = double.infinity,

}) : assert(maxWidth >= 0.0),

assert(maxHeight >= 0.0),

_maxWidth = maxWidth,

_maxHeight = maxHeight,

super(child);

/// The value to use for maxWidth if the incoming maxWidth constraint is infinite.

double get maxWidth => _maxWidth;

double _maxWidth;

set maxWidth(double value) {

assert(value >= 0.0);

if (_maxWidth == value) {

return;

}

_maxWidth = value;

markNeedsLayout();

}

/// The value to use for maxHeight if the incoming maxHeight constraint is infinite.

double get maxHeight => _maxHeight;

double _maxHeight;

set maxHeight(double value) {

assert(value >= 0.0);

if (_maxHeight == value) {

return;

}

_maxHeight = value;

markNeedsLayout();

}

BoxConstraints _limitConstraints(BoxConstraints constraints) {

return BoxConstraints(

minWidth: constraints.minWidth,

maxWidth: constraints.hasBoundedWidth

? constraints.maxWidth

: constraints.constrainWidth(maxWidth),

minHeight: constraints.minHeight,

maxHeight: constraints.hasBoundedHeight

? constraints.maxHeight

: constraints.constrainHeight(maxHeight),

);

}

Size _computeSize({required BoxConstraints constraints, required ChildLayouter layoutChild}) {

if (child != null) {

final Size childSize = layoutChild(child!, _limitConstraints(constraints));

return constraints.constrain(childSize);

}

return _limitConstraints(constraints).constrain(Size.zero);

}

@override

@protected

Size computeDryLayout(covariant BoxConstraints constraints) {

return _computeSize(constraints: constraints, layoutChild: ChildLayoutHelper.dryLayoutChild);

}

@override

void performLayout() {

size = _computeSize(constraints: constraints, layoutChild: ChildLayoutHelper.layoutChild);

}

@override

void debugFillProperties(DiagnosticPropertiesBuilder properties) {

super.debugFillProperties(properties);

properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));

properties.add(DoubleProperty('maxHeight', maxHeight, defaultValue: double.infinity));

}

}

/// Attempts to size the child to a specific aspect ratio.

///

/// The render object first tries the largest width permitted by the layout

/// constraints. The height of the render object is determined by applying the

/// given aspect ratio to the width, 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. If the maximum width is infinite, the initial width is determined

/// by applying the aspect ratio to the maximum height.

///

/// Now consider a second example, this time with 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. We'll select a width of 100.0 (the

/// biggest allowed) and a height of 50.0 (to match the aspect ratio).

///

/// In that same situation, if the aspect ratio is 0.5, we'll also select a

/// width of 100.0 (still the biggest allowed) and we'll attempt to use a height

/// of 200.0. Unfortunately, that violates the constraints because the child can

/// be at most 100.0 pixels tall. The render object 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 render object would

/// continue iterating through the constraints. If the render object does not

/// find a feasible size after consulting each constraint, the render object

/// will eventually select a size for the child that meets the layout

/// constraints but fails to meet the aspect ratio constraints.

class RenderAspectRatio extends RenderProxyBox {

/// Creates as render object with a specific aspect ratio.

///

/// The [aspectRatio] argument must be a finite, positive value.

RenderAspectRatio({RenderBox? child, required double aspectRatio})

: assert(aspectRatio > 0.0),

assert(aspectRatio.isFinite),

_aspectRatio = aspectRatio,

super(child);

/// 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.

double get aspectRatio => _aspectRatio;

double _aspectRatio;

set aspectRatio(double value) {

assert(value > 0.0);

assert(value.isFinite);

if (_aspectRatio == value) {

return;

}

_aspectRatio = value;

markNeedsLayout();

}

@override

double computeMinIntrinsicWidth(double height) {

if (height.isFinite) {

return height * _aspectRatio;

}

return child?.getMinIntrinsicWidth(height) ?? 0.0;

}

@override

double computeMaxIntrinsicWidth(double height) {

if (height.isFinite) {

return height * _aspectRatio;

}

return child?.getMaxIntrinsicWidth(height) ?? 0.0;

}

@override

double computeMinIntrinsicHeight(double width) {

if (width.isFinite) {

return width / _aspectRatio;

}

return child?.getMinIntrinsicHeight(width) ?? 0.0;

}

@override

double computeMaxIntrinsicHeight(double width) {

if (width.isFinite) {

return width / _aspectRatio;

}

return child?.getMaxIntrinsicHeight(width) ?? 0.0;

}

Size _applyAspectRatio(BoxConstraints constraints) {

assert(constraints.debugAssertIsValid());

assert(() {

if (!constraints.hasBoundedWidth && !constraints.hasBoundedHeight) {

throw FlutterError(

'$runtimeType has unbounded constraints.\n'

'This $runtimeType was given an aspect ratio of $aspectRatio but was given '

'both unbounded width and unbounded height constraints. Because both '

"constraints were unbounded, this render object doesn't know how much "

'size to consume.',

);

}

return true;

}());

if (constraints.isTight) {

return constraints.smallest;

}

double width = constraints.maxWidth;

double height;

// We default to picking the height based on the width, but if the width

// would be infinite, that's not sensible so we try to infer the height

// from the width.

if (width.isFinite) {

height = width / _aspectRatio;

} else {

height = constraints.maxHeight;

width = height * _aspectRatio;

}

// Similar to RenderImage, we iteratively attempt to fit within the given

// constraints while maintaining the given aspect ratio. The order of

// applying the constraints is also biased towards inferring the height

// from the width.

if (width > constraints.maxWidth) {

width = constraints.maxWidth;

height = width / _aspectRatio;

}

if (height > constraints.maxHeight) {

height = constraints.maxHeight;

width = height * _aspectRatio;

}

if (width < constraints.minWidth) {

width = constraints.minWidth;

height = width / _aspectRatio;

}

if (height < constraints.minHeight) {

height = constraints.minHeight;

width = height * _aspectRatio;

}

return constraints.constrain(Size(width, height));

}

@override

@protected

Size computeDryLayout(covariant BoxConstraints constraints) {

return _applyAspectRatio(constraints);

}

@override

double? computeDryBaseline(BoxConstraints constraints, TextBaseline baseline) {

return super.computeDryBaseline(BoxConstraints.tight(getDryLayout(constraints)), baseline);

}

@override

void performLayout() {

size = getDryLayout(constraints);

child?.layout(BoxConstraints.tight(size));

}

@override

void debugFillProperties(DiagnosticPropertiesBuilder properties) {

super.debugFillProperties(properties);

properties.add(DoubleProperty('aspectRatio', aspectRatio));

}

}

/// 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.

///

/// The constraints that this object 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 render object 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.

class RenderIntrinsicWidth extends RenderProxyBox {

/// Creates a render object that sizes itself to its child's intrinsic width.

///

/// If [stepWidth] is non-null it must be > 0.0. Similarly If [stepHeight] is

/// non-null it must be > 0.0.

RenderIntrinsicWidth({double? stepWidth, double? stepHeight, RenderBox? child})

: assert(stepWidth == null || stepWidth > 0.0),

assert(stepHeight == null || stepHeight > 0.0),

_stepWidth = stepWidth,

_stepHeight = stepHeight,

super(child);

/// If non-null, force the child's width to be a multiple of this value.

///

/// This value must be null or > 0.0.

double? get stepWidth => _stepWidth;

double? _stepWidth;

set stepWidth(double? value) {

assert(value == null || value > 0.0);

if (value == _stepWidth) {

return;

}

_stepWidth = value;

markNeedsLayout();

}

/// If non-null, force the child's height to be a multiple of this value.

///

/// This value must be null or > 0.0.

double? get stepHeight => _stepHeight;

double? _stepHeight;

set stepHeight(double? value) {

assert(value == null || value > 0.0);

if (value == _stepHeight) {

return;

}

_stepHeight = value;

markNeedsLayout();

}

static double _applyStep(double input, double? step) {

assert(input.isFinite);

if (step == null) {

return input;

}

return (input / step).ceil() * step;

}

@override

double computeMinIntrinsicWidth(double height) {

return getMaxIntrinsicWidth(height);

}

@override

double computeMaxIntrinsicWidth(double height) {

if (child == null) {

return 0.0;

}

final double width = child!.getMaxIntrinsicWidth(height);

return _applyStep(width, _stepWidth);

}

@override

double computeMinIntrinsicHeight(double width) {

if (child == null) {

return 0.0;

}

if (!width.isFinite) {

width = getMaxIntrinsicWidth(double.infinity);

}

assert(width.isFinite);

final double height = child!.getMinIntrinsicHeight(width);

return _applyStep(height, _stepHeight);

}

@override

double computeMaxIntrinsicHeight(double width) {

if (child == null) {

return 0.0;

}

if (!width.isFinite) {

width = getMaxIntrinsicWidth(double.infinity);

}

assert(width.isFinite);

final double height = child!.getMaxIntrinsicHeight(width);

return _applyStep(height, _stepHeight);

}

BoxConstraints _childConstraints(RenderBox child, BoxConstraints constraints) {

return constraints.tighten(

width: constraints.hasTightWidth

? null

: _applyStep(child.getMaxIntrinsicWidth(constraints.maxHeight), _stepWidth),

height: stepHeight == null

? null

: _applyStep(child.getMaxIntrinsicHeight(constraints.maxWidth), _stepHeight),

);

}

Size _computeSize({required ChildLayouter layoutChild, required BoxConstraints constraints}) {

final RenderBox? child = this.child;

return child == null

? constraints.smallest

: layoutChild(child, _childConstraints(child, constraints));

}

@override

@protected

Size computeDryLayout(covariant BoxConstraints constraints) {

return _computeSize(layoutChild: ChildLayoutHelper.dryLayoutChild, constraints: constraints);

}

@override

double? computeDryBaseline(BoxConstraints constraints, TextBaseline baseline) {

final RenderBox? child = this.child;

return child?.getDryBaseline(_childConstraints(child, constraints), baseline);

}

@override

void performLayout() {

size = _computeSize(layoutChild: ChildLayoutHelper.layoutChild, constraints: constraints);

}

@override

void debugFillProperties(DiagnosticPropertiesBuilder properties) {

super.debugFillProperties(properties);

properties.add(DoubleProperty('stepWidth', stepWidth));

properties.add(DoubleProperty('stepHeight', stepHeight));

}

}

/// 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.

///

/// The constraints that this object 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 render object 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.

class RenderIntrinsicHeight extends RenderProxyBox {

/// Creates a render object that sizes itself to its child's intrinsic height.

RenderIntrinsicHeight({RenderBox? child}) : super(child);

@override

double computeMinIntrinsicWidth(double height) {

if (child == null) {

return 0.0;

}

if (!height.isFinite) {

height = child!.getMaxIntrinsicHeight(double.infinity);

}

assert(height.isFinite);

return child!.getMinIntrinsicWidth(height);

}

@override

double computeMaxIntrinsicWidth(double height) {

if (child == null) {

return 0.0;

}

if (!height.isFinite) {

height = child!.getMaxIntrinsicHeight(double.infinity);

}

assert(height.isFinite);

return child!.getMaxIntrinsicWidth(height);

}

@override

double computeMinIntrinsicHeight(double width) {

return getMaxIntrinsicHeight(width);

}

BoxConstraints _childConstraints(RenderBox child, BoxConstraints constraints) {

return constraints.hasTightHeight

? constraints

: constraints.tighten(height: child.getMaxIntrinsicHeight(constraints.maxWidth));

}

Size _computeSize({required ChildLayouter layoutChild, required BoxConstraints constraints}) {

final RenderBox? child = this.child;

return child == null

? constraints.smallest

: layoutChild(child, _childConstraints(child, constraints));

}

@override

@protected

Size computeDryLayout(covariant BoxConstraints constraints) {

return _computeSize(layoutChild: ChildLayoutHelper.dryLayoutChild, constraints: constraints);

}

@override

double? computeDryBaseline(BoxConstraints constraints, TextBaseline baseline) {

final RenderBox? child = this.child;

return child?.getDryBaseline(_childConstraints(child, constraints), baseline);

}

@override

void performLayout() {

size = _computeSize(layoutChild: ChildLayoutHelper.layoutChild, constraints: constraints);

}

}

/// Excludes the child from baseline computations in the parent.

class RenderIgnoreBaseline extends RenderProxyBox {

/// Create a render object that causes the parent to ignore the child for baseline computations.

RenderIgnoreBaseline({RenderBox? child}) : super(child);

@override

Null computeDistanceToActualBaseline(TextBaseline baseline) {

return null;

}

@override

Null computeDryBaseline(covariant BoxConstraints constraints, TextBaseline baseline) {

return null;

}

}

/// 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.

class RenderOpacity extends RenderProxyBox {

/// Creates a partially transparent render object.

///

/// The [opacity] argument must be between 0.0 and 1.0, inclusive.

RenderOpacity({double opacity = 1.0, bool alwaysIncludeSemantics = false, RenderBox? child})

: assert(opacity >= 0.0 && opacity <= 1.0),

_opacity = opacity,

_alwaysIncludeSemantics = alwaysIncludeSemantics,

_alpha = ui.Color.getAlphaFromOpacity(opacity),

super(child);

@override

bool get alwaysNeedsCompositing => child != null && _alpha > 0;

@override

bool get isRepaintBoundary => alwaysNeedsCompositing;

int _alpha;

/// The fraction to scale the child's alpha value.

///

/// An opacity of 1.0 is fully opaque. An opacity of 0.0 is fully transparent

/// (i.e., invisible).

///

/// Values 1.0 and 0.0 are painted with a fast path. Other values

/// require painting the child into an intermediate buffer, which is

/// expensive.

double get opacity => _opacity;

double _opacity;

set opacity(double value) {

assert(value >= 0.0 && value <= 1.0);

if (_opacity == value) {

return;

}

final bool didNeedCompositing = alwaysNeedsCompositing;

final wasVisible = _alpha != 0;

_opacity = value;

_alpha = ui.Color.getAlphaFromOpacity(_opacity);

if (didNeedCompositing != alwaysNeedsCompositing) {

markNeedsCompositingBitsUpdate();

}

markNeedsCompositedLayerUpdate();

if (wasVisible != (_alpha != 0) && !alwaysIncludeSemantics) {

markNeedsSemanticsUpdate();

}

}

/// Whether child semantics are included regardless of the opacity.

///

/// If false, semantics are excluded when [opacity] is 0.0.

///

/// Defaults to false.

bool get alwaysIncludeSemantics => _alwaysIncludeSemantics;

bool _alwaysIncludeSemantics;

set alwaysIncludeSemantics(bool value) {

if (value == _alwaysIncludeSemantics) {

return;

}

_alwaysIncludeSemantics = value;

markNeedsSemanticsUpdate();

}

@override

bool paintsChild(RenderBox child) {

assert(child.parent == this);

return _alpha > 0;

}

@override

OffsetLayer updateCompositedLayer({required covariant OpacityLayer? oldLayer}) {

final OpacityLayer layer = oldLayer ?? OpacityLayer();

layer.alpha = _alpha;

return layer;

}

@override

void paint(PaintingContext context, Offset offset) {

if (child == null || _alpha == 0) {

return;

}

super.paint(context, offset);

}

@override

void visitChildrenForSemantics(RenderObjectVisitor visitor) {

if (child != null && (_alpha != 0 || alwaysIncludeSemantics)) {

visitor(child!);

}

}

@override

void debugFillProperties(DiagnosticPropertiesBuilder properties) {

super.debugFillProperties(properties);

properties.add(DoubleProperty('opacity', opacity));

properties.add(

FlagProperty(

'alwaysIncludeSemantics',

value: alwaysIncludeSemantics,

ifTrue: 'alwaysIncludeSemantics',

),

);

}

}

/// Implementation of [RenderAnimatedOpacity] and [RenderSliverAnimatedOpacity].

///

/// This mixin allows the logic of animating opacity to be used with different

/// layout models, e.g. the way that [RenderAnimatedOpacity] uses it for [RenderBox]

/// and [RenderSliverAnimatedOpacity] uses it for [RenderSliver].

mixin RenderAnimatedOpacityMixin<T extends RenderObject> on RenderObjectWithChildMixin<T> {

int? _alpha;

@override

bool get isRepaintBoundary => child != null && _currentlyIsRepaintBoundary!;

bool? _currentlyIsRepaintBoundary;

@override

OffsetLayer updateCompositedLayer({required covariant OpacityLayer? oldLayer}) {

final OpacityLayer updatedLayer = oldLayer ?? OpacityLayer();

updatedLayer.alpha = _alpha;

return updatedLayer;

}

/// The animation that drives this render object's opacity.

///

/// An opacity of 1.0 is fully opaque. An opacity of 0.0 is fully transparent

/// (i.e., invisible).

///

/// To change the opacity of a child in a static manner, not animated,