library;

import 'dart:math' as math;

import 'dart:ui'

as ui

show Image, ImageFilter, SemanticsHitTestBehavior, SemanticsInputType, TextHeightBehavior;

import 'package:flutter/animation.dart';

import 'package:flutter/foundation.dart';

import 'package:flutter/gestures.dart';

import 'package:flutter/rendering.dart';

import 'package:flutter/services.dart';

import 'binding.dart';

import 'debug.dart';

import 'framework.dart';

import 'localizations.dart';

import 'visibility.dart';

import 'widget_span.dart';

export 'package:flutter/animation.dart';

export 'package:flutter/foundation.dart'

show ChangeNotifier, FlutterErrorDetails, Listenable, TargetPlatform, ValueNotifier;

export 'package:flutter/painting.dart';

export 'package:flutter/rendering.dart'

show

AlignmentGeometryTween,

AlignmentTween,

Axis,

BackdropKey,

BoxConstraints,

BoxConstraintsTransform,

CrossAxisAlignment,

CustomClipper,

CustomPainter,

CustomPainterSemantics,

DecorationPosition,

FlexFit,

FlowDelegate,

FlowPaintingContext,

FractionalOffsetTween,

HitTestBehavior,

ImageFilterConfig,

LayerLink,

MainAxisAlignment,

MainAxisSize,

MouseCursor,

MultiChildLayoutDelegate,

PaintingContext,

PointerCancelEvent,

PointerCancelEventListener,

PointerDownEvent,

PointerDownEventListener,

PointerEvent,

PointerMoveEvent,

PointerMoveEventListener,

PointerUpEvent,

PointerUpEventListener,

RelativeRect,

SemanticsBuilderCallback,

ShaderCallback,

ShapeBorderClipper,

SingleChildLayoutDelegate,

StackFit,

SystemMouseCursors,

TextOverflow,

ValueChanged,

ValueGetter,

WrapAlignment,

WrapCrossAlignment;

export 'package:flutter/services.dart' show AssetBundle;

class _UbiquitousInheritedElement extends InheritedElement {

/// Creates an element that uses the given widget as its configuration.

_UbiquitousInheritedElement(super.widget);

@override

void setDependencies(Element dependent, Object? value) {

// This is where the cost of [InheritedElement] is incurred during build

// time of the widget tree. Omitting this bookkeeping is where the

// performance savings come from.

assert(value == null);

}

@override

Object? getDependencies(Element dependent) {

return null;

}

@override

void notifyClients(InheritedWidget oldWidget) {

_recurseChildren(this, (Element element) {

if (element.doesDependOnInheritedElement(this)) {

notifyDependent(oldWidget, element);

}

});

}

static void _recurseChildren(Element element, ElementVisitor visitor) {

element.visitChildren((Element child) {

_recurseChildren(child, visitor);

});

visitor(element);

}

}

abstract class _UbiquitousInheritedWidget extends InheritedWidget {

const _UbiquitousInheritedWidget({super.key, required super.child});

@override

InheritedElement createElement() => _UbiquitousInheritedElement(this);

}

class Directionality extends _UbiquitousInheritedWidget {

/// Creates a widget that determines the directionality of text and

const Directionality({super.key, required this.textDirection, required super.child});

/// The text direction for this subtree.

final TextDirection textDirection;

/// The text direction from the closest instance of this class that encloses

static TextDirection of(BuildContext context) {

assert(debugCheckHasDirectionality(context));

final Directionality widget = context.dependOnInheritedWidgetOfExactType<Directionality>()!;

return widget.textDirection;

}

/// The text direction from the closest instance of this class that encloses

static TextDirection? maybeOf(BuildContext context) {

final Directionality? widget = context.dependOnInheritedWidgetOfExactType<Directionality>();

return widget?.textDirection;

}

@override

bool updateShouldNotify(Directionality oldWidget) => textDirection != oldWidget.textDirection;

@override

void debugFillProperties(DiagnosticPropertiesBuilder properties) {

super.debugFillProperties(properties);

properties.add(EnumProperty<TextDirection>('textDirection', textDirection));

}

}

class Opacity extends SingleChildRenderObjectWidget {

/// Creates a widget that makes its child partially transparent.

const Opacity({

super.key,

required this.opacity,

this.alwaysIncludeSemantics = false,

super.child,

}) : assert(opacity >= 0.0 && opacity <= 1.0);

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

final double opacity;

/// Whether the semantic information of the children is always included.

final bool alwaysIncludeSemantics;

@override

RenderOpacity createRenderObject(BuildContext context) {

return RenderOpacity(opacity: opacity, alwaysIncludeSemantics: alwaysIncludeSemantics);

}

@override

void updateRenderObject(BuildContext context, RenderOpacity renderObject) {

renderObject

..opacity = opacity

..alwaysIncludeSemantics = alwaysIncludeSemantics;

}

@override

void debugFillProperties(DiagnosticPropertiesBuilder properties) {

super.debugFillProperties(properties);

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

properties.add(

FlagProperty(

'alwaysIncludeSemantics',

value: alwaysIncludeSemantics,

ifTrue: 'alwaysIncludeSemantics',

),

);

}

}

class ShaderMask extends SingleChildRenderObjectWidget {

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

const ShaderMask({

super.key,

required this.shaderCallback,

this.blendMode = BlendMode.modulate,

super.child,

});

/// Called to create the [dart:ui.Shader] that generates the mask.

final ShaderCallback shaderCallback;

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

final BlendMode blendMode;

@override

RenderShaderMask createRenderObject(BuildContext context) {

return RenderShaderMask(shaderCallback: shaderCallback, blendMode: blendMode);

}

@override

void updateRenderObject(BuildContext context, RenderShaderMask renderObject) {

renderObject

..shaderCallback = shaderCallback

..blendMode = blendMode;

}

}

class BackdropGroup extends InheritedWidget {

/// Create a new [BackdropGroup] widget.

BackdropGroup({super.key, required super.child, BackdropKey? backdropKey})

: backdropKey = backdropKey ?? BackdropKey();

/// The backdrop key this backdrop group will use with shared child layers.

final BackdropKey backdropKey;

@override

bool updateShouldNotify(covariant BackdropGroup oldWidget) {

return oldWidget.backdropKey != backdropKey;

}

/// Look up the nearest [BackdropGroup], or `null` if there is not one.

static BackdropGroup? of(BuildContext context) {

return context.dependOnInheritedWidgetOfExactType<BackdropGroup>();

}

}

class BackdropFilter extends SingleChildRenderObjectWidget {

/// Creates a backdrop filter.

const BackdropFilter({

super.key,

this.filter,

this.filterConfig,

super.child,

this.blendMode = BlendMode.srcOver,

this.enabled = true,

this.backdropGroupKey,

}) : assert(

filter != null || filterConfig != null,

'Either filter or filterConfig must be provided.',

),

assert(

filter == null || filterConfig == null,

'Cannot provide both a filter and a filterConfig.',

),

_useSharedKey = false;

/// Creates a backdrop filter that groups itself with the nearest parent

const BackdropFilter.grouped({

super.key,

this.filter,

this.filterConfig,

super.child,

this.blendMode = BlendMode.srcOver,

this.enabled = true,

}) : assert(

filter != null || filterConfig != null,

'Either filter or filterConfig must be provided.',

),

assert(

filter == null || filterConfig == null,

'Cannot provide both a filter and a filterConfig.',

),

backdropGroupKey = null,

_useSharedKey = true;

/// The image filter to apply to the existing painted content before painting the child.

final ui.ImageFilter? filter;

/// The configuration for the image filter to apply to the existing painted content.

final ImageFilterConfig? filterConfig;

/// The blend mode to use to apply the filtered background content onto the background

final BlendMode blendMode;

/// Whether or not to apply the backdrop filter operation to the child of this

final bool enabled;

/// The [BackdropKey] that identifies the backdrop this filter will apply to.

final BackdropKey? backdropGroupKey;

// Whether to look up the [backdropKey] from a parent [BackdropGroup].

final bool _useSharedKey;

BackdropKey? _getBackdropGroupKey(BuildContext context) {

if (_useSharedKey) {

return BackdropGroup.of(context)?.backdropKey;

}

return backdropGroupKey;

}

ImageFilterConfig get _effectiveFilterConfig {

return filterConfig ?? ImageFilterConfig(filter!);

}

@override

RenderBackdropFilter createRenderObject(BuildContext context) {

return RenderBackdropFilter(

filterConfig: _effectiveFilterConfig,

blendMode: blendMode,

enabled: enabled,

backdropKey: _getBackdropGroupKey(context),

);

}

@override

void updateRenderObject(BuildContext context, RenderBackdropFilter renderObject) {

renderObject

..filterConfig = _effectiveFilterConfig

..enabled = enabled

..blendMode = blendMode

..backdropKey = _getBackdropGroupKey(context);

}

@override

void debugFillProperties(DiagnosticPropertiesBuilder properties) {

super.debugFillProperties(properties);

properties.add(DiagnosticsProperty<ui.ImageFilter>('filter', filter, defaultValue: null));

properties.add(

DiagnosticsProperty<ImageFilterConfig>('filterConfig', filterConfig, defaultValue: null),

);

properties.add(EnumProperty<BlendMode>('blendMode', blendMode));

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

}

}

class CustomPaint extends SingleChildRenderObjectWidget {

/// Creates a widget that delegates its painting.

const CustomPaint({

super.key,

this.painter,

this.foregroundPainter,

this.size = Size.zero,

this.isComplex = false,

this.willChange = false,

super.child,

}) : assert(painter != null || foregroundPainter != null || (!isComplex && !willChange));

/// The painter that paints before the children.

final CustomPainter? painter;

/// The painter that paints after the children.

final CustomPainter? foregroundPainter;

/// The size that this [CustomPaint] should aim for, given the layout

final Size size;

/// Whether the painting is complex enough to benefit from caching.

final bool isComplex;

/// Whether the raster cache should be told that this painting is likely

final bool willChange;

@override

RenderCustomPaint createRenderObject(BuildContext context) {

return RenderCustomPaint(

painter: painter,

foregroundPainter: foregroundPainter,

preferredSize: size,

isComplex: isComplex,

willChange: willChange,

);

}

@override

void updateRenderObject(BuildContext context, RenderCustomPaint renderObject) {

renderObject

..painter = painter

..foregroundPainter = foregroundPainter

..preferredSize = size

..isComplex = isComplex

..willChange = willChange;

}

@override

void didUnmountRenderObject(RenderCustomPaint renderObject) {

renderObject

..painter = null

..foregroundPainter = null;

}

}

class ClipRect extends SingleChildRenderObjectWidget {

/// Creates a rectangular clip.

const ClipRect({super.key, this.clipper, this.clipBehavior = Clip.hardEdge, super.child});

/// If non-null, determines which clip to use.

final CustomClipper<Rect>? clipper;

/// {@macro flutter.rendering.ClipRectLayer.clipBehavior}

final Clip clipBehavior;

@override

RenderClipRect createRenderObject(BuildContext context) {

return RenderClipRect(clipper: clipper, clipBehavior: clipBehavior);

}

@override

void updateRenderObject(BuildContext context, RenderClipRect renderObject) {

renderObject

..clipper = clipper

..clipBehavior = clipBehavior;

}

@override

void didUnmountRenderObject(RenderClipRect renderObject) {

renderObject.clipper = null;

}

@override

void debugFillProperties(DiagnosticPropertiesBuilder properties) {

super.debugFillProperties(properties);

properties.add(

DiagnosticsProperty<CustomClipper<Rect>>('clipper', clipper, defaultValue: null),

);

}

}