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

import 'dart:async';

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

import 'package:flutter/animation.dart';

import 'package:flutter/foundation.dart';

import 'package:flutter/gestures.dart';

import 'package:flutter/painting.dart';

import 'package:flutter/semantics.dart';

import 'package:vector_math/vector_math_64.dart';

import 'binding.dart';

import 'box.dart';

import 'layer.dart';

import 'object.dart';

export 'package:flutter/gestures.dart' show

PointerEvent,

PointerDownEvent,

PointerMoveEvent,

PointerUpEvent,

PointerCancelEvent;

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

///

/// A proxy box has a single child and simply 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 simply 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 mix in other classes as well).

// TODO(ianh): Remove this class once https://github.com/dart-lang/sdk/issues/31543 is fixed

@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) {

if (child != null)

return child.getMinIntrinsicWidth(height);

return 0.0;

}

@override

double computeMaxIntrinsicWidth(double height) {

if (child != null)

return child.getMaxIntrinsicWidth(height);

return 0.0;

}

@override

double computeMinIntrinsicHeight(double width) {

if (child != null)

return child.getMinIntrinsicHeight(width);

return 0.0;

}

@override

double computeMaxIntrinsicHeight(double width) {

if (child != null)

return child.getMaxIntrinsicHeight(width);

return 0.0;

}

@override

double computeDistanceToActualBaseline(TextBaseline baseline) {

if (child != null)

return child.getDistanceToActualBaseline(baseline);

return super.computeDistanceToActualBaseline(baseline);

}

@override

void performLayout() {

if (child != null) {

child.layout(constraints, parentUsesSize: true);

size = child.size;

} else {

performResize();

}

}

@override

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

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

}

@override

void applyPaintTransform(RenderObject child, Matrix4 transform) { }

@override

void paint(PaintingContext context, Offset offset) {

if (child != null)

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.

HitTestBehavior behavior;

@override

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

bool 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 not be null and must be valid.

RenderConstrainedBox({

RenderBox child,

@required BoxConstraints additionalConstraints,

}) : assert(additionalConstraints != null),

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 != null);

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

void performLayout() {

if (child != null) {

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

size = child.size;

} else {

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

}

}

@override

void debugPaintSize(PaintingContext context, Offset offset) {

super.debugPaintSize(context, offset);

assert(() {

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 != null && maxWidth >= 0.0),

assert(maxHeight != null && 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 != null && 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 != null && 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),

);

}

@override

void performLayout() {

if (child != null) {

child.layout(_limitConstraints(constraints), parentUsesSize: true);

size = constraints.constrain(child.size);

} else {

size = _limitConstraints(constraints).constrain(Size.zero);

}

}

@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 != null),

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 != null);

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;

if (child != null)

return child.getMinIntrinsicWidth(height);

return 0.0;

}

@override

double computeMaxIntrinsicWidth(double height) {

if (height.isFinite)

return height * _aspectRatio;

if (child != null)

return child.getMaxIntrinsicWidth(height);

return 0.0;

}

@override

double computeMinIntrinsicHeight(double width) {

if (width.isFinite)

return width / _aspectRatio;

if (child != null)

return child.getMinIntrinsicHeight(width);

return 0.0;

}

@override

double computeMaxIntrinsicHeight(double width) {

if (width.isFinite)

return width / _aspectRatio;

if (child != null)

return child.getMaxIntrinsicHeight(width);

return 0.0;

}

Size _applyAspectRatio(BoxConstraints constraints) {

assert(constraints.debugAssertIsValid());

assert(() {

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

throw FlutterError.fromParts(<DiagnosticsNode>[

ErrorSummary('$runtimeType has unbounded constraints.'),

ErrorDescription(

'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

void performLayout() {

size = _applyAspectRatio(constraints);

if (child != null)

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 intrinsic width.

///

/// Sizes its child's width to the child's maximum intrinsic width. 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 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.

///

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

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 computeMaxIntrinsicWidth(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 = computeMaxIntrinsicWidth(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 = computeMaxIntrinsicWidth(double.infinity);

assert(width.isFinite);

final double height = child.getMaxIntrinsicHeight(width);

return _applyStep(height, _stepHeight);

}

@override

void performLayout() {

if (child != null) {

BoxConstraints childConstraints = constraints;

if (!childConstraints.hasTightWidth) {

final double width = child.getMaxIntrinsicWidth(childConstraints.maxHeight);

assert(width.isFinite);

childConstraints = childConstraints.tighten(width: _applyStep(width, _stepWidth));

}

if (_stepHeight != null) {

final double height = child.getMaxIntrinsicHeight(childConstraints.maxWidth);

assert(height.isFinite);

childConstraints = childConstraints.tighten(height: _applyStep(height, _stepHeight));

}

child.layout(childConstraints, parentUsesSize: true);

size = child.size;

} else {

performResize();

}

}

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

///

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

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 computeMaxIntrinsicHeight(width);

}

@override

void performLayout() {

if (child != null) {

BoxConstraints childConstraints = constraints;

if (!childConstraints.hasTightHeight) {

final double height = child.getMaxIntrinsicHeight(childConstraints.maxWidth);

assert(height.isFinite);

childConstraints = childConstraints.tighten(height: height);

}

child.layout(childConstraints, parentUsesSize: true);

size = child.size;

} else {

performResize();

}

}

}

/// 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 simply 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 != null),

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

assert(alwaysIncludeSemantics != null),

_opacity = opacity,

_alwaysIncludeSemantics = alwaysIncludeSemantics,

_alpha = ui.Color.getAlphaFromOpacity(opacity),

super(child);

@override

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

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

///

/// The opacity must not be null.

///

/// 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 != null);

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

if (_opacity == value)

return;

final bool didNeedCompositing = alwaysNeedsCompositing;

final bool wasVisible = _alpha != 0;

_opacity = value;

_alpha = ui.Color.getAlphaFromOpacity(_opacity);

if (didNeedCompositing != alwaysNeedsCompositing)

markNeedsCompositingBitsUpdate();

markNeedsPaint();

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

void paint(PaintingContext context, Offset offset) {

if (child != null) {

if (_alpha == 0) {

// No need to keep the layer. We'll create a new one if necessary.

layer = null;

return;

}

if (_alpha == 255) {

// No need to keep the layer. We'll create a new one if necessary.

layer = null;

context.paintChild(child, offset);

return;

}

assert(needsCompositing);

layer = context.pushOpacity(offset, _alpha, super.paint, oldLayer: layer as OpacityLayer);

}

}

@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].

///

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

/// of [RenderProxyBox] or [RenderProxySliver] is desired for animating opacity,

/// but would like to use the same methods for both types of render objects.

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

int _alpha;

@override

bool get alwaysNeedsCompositing => child != null && _currentlyNeedsCompositing;

bool _currentlyNeedsCompositing;

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

/// consider [RenderOpacity] instead.

Animation<double> get opacity => _opacity;

Animation<double> _opacity;

set opacity(Animation<double> value) {

assert(value != null);

if (_opacity == value)

return;

if (attached && _opacity != null)

_opacity.removeListener(_updateOpacity);

_opacity = value;

if (attached)

_opacity.addListener(_updateOpacity);

_updateOpacity();

}

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

void attach(PipelineOwner owner) {

super.attach(owner);

_opacity.addListener(_updateOpacity);

_updateOpacity(); // in case it changed while we weren't listening

}

@override

void detach() {

_opacity.removeListener(_updateOpacity);

super.detach();

}

void _updateOpacity() {

final int oldAlpha = _alpha;

_alpha = ui.Color.getAlphaFromOpacity(_opacity.value);

if (oldAlpha != _alpha) {

final bool didNeedCompositing = _currentlyNeedsCompositing;

_currentlyNeedsCompositing = _alpha > 0 && _alpha < 255;

if (child != null && didNeedCompositing != _currentlyNeedsCompositing)

markNeedsCompositingBitsUpdate();

markNeedsPaint();

if (oldAlpha == 0 || _alpha == 0)

markNeedsSemanticsUpdate();

}

}

@override

void paint(PaintingContext context, Offset offset) {

if (child != null) {

if (_alpha == 0) {

// No need to keep the layer. We'll create a new one if necessary.

layer = null;

return;

}

if (_alpha == 255) {

// No need to keep the layer. We'll create a new one if necessary.

layer = null;

context.paintChild(child, offset);

return;

}

assert(needsCompositing);

layer = context.pushOpacity(offset, _alpha, super.paint, oldLayer: layer as OpacityLayer);

}

}

@override

void visitChildrenForSemantics(RenderObjectVisitor visitor) {

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

visitor(child);

}

@override

void debugFillProperties(DiagnosticPropertiesBuilder properties) {

super.debugFillProperties(properties);

properties.add(DiagnosticsProperty<Animation<double>>('opacity', opacity));

properties.add(FlagProperty('alwaysIncludeSemantics', value: alwaysIncludeSemantics, ifTrue: 'alwaysIncludeSemantics'));

}

}

/// Makes its child partially transparent, driven from an [Animation].

///

/// This is a variant of [RenderOpacity] that uses an [Animation<double>] rather

/// than a [double] to control the opacity.

class RenderAnimatedOpacity extends RenderProxyBox with RenderProxyBoxMixin, RenderAnimatedOpacityMixin<RenderBox> {

/// Creates a partially transparent render object.

///

/// The [opacity] argument must not be null.

RenderAnimatedOpacity({

@required Animation<double> opacity,

bool alwaysIncludeSemantics = false,

RenderBox child,

}) : assert(opacity != null),

assert(alwaysIncludeSemantics != null),

super(child) {

this.opacity = opacity;

this.alwaysIncludeSemantics = alwaysIncludeSemantics;

}

}

/// Signature for a function that creates a [Shader] for a given [Rect].

///

/// Used by [RenderShaderMask] and the [ShaderMask] widget.

typedef ShaderCallback = Shader Function(Rect bounds);

/// Applies a mask generated by a [Shader] to its child.

///

/// For example, [RenderShaderMask] can be used to gradually fade out the edge

/// of a child by using a [new ui.Gradient.linear] mask.

class RenderShaderMask extends RenderProxyBox {

/// Creates a render object that applies a mask generated by a [Shader] to its child.

///

/// The [shaderCallback] and [blendMode] arguments must not be null.

RenderShaderMask({

RenderBox child,

@required ShaderCallback shaderCallback,

BlendMode blendMode = BlendMode.modulate,

}) : assert(shaderCallback != null),

assert(blendMode != null),

_shaderCallback = shaderCallback,

_blendMode = blendMode,

super(child);

@override

ShaderMaskLayer get layer => super.layer as ShaderMaskLayer;

/// Called to creates the [Shader] that generates the mask.

///

/// The shader callback is called with the current size of the child so that

/// it can customize the shader to the size and location of the child.

///

/// The rectangle will always be at the origin when called by

/// [RenderShaderMask].

// TODO(abarth): Use the delegate pattern here to avoid generating spurious

// repaints when the ShaderCallback changes identity.

ShaderCallback get shaderCallback => _shaderCallback;

ShaderCallback _shaderCallback;

set shaderCallback(ShaderCallback value) {

assert(value != null);

if (_shaderCallback == value)

return;

_shaderCallback = value;

markNeedsPaint();

}

/// The [BlendMode] to use when applying the shader to the child.

///

/// The default, [BlendMode.modulate], is useful for applying an alpha blend