import 'dart:math' as math;

import 'dart:ui' as ui show Image, ImageFilter, 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,

BoxConstraints,

BoxConstraintsTransform,

CrossAxisAlignment,

CustomClipper,

CustomPainter,

CustomPainterSemantics,

DecorationPosition,

FlexFit,

FlowDelegate,

FlowPaintingContext,

FractionalOffsetTween,

HitTestBehavior,

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 BackdropFilter extends SingleChildRenderObjectWidget {

/// Creates a backdrop filter.

const BackdropFilter({

super.key,

required this.filter,

super.child,

this.blendMode = BlendMode.srcOver,

});

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

final ui.ImageFilter filter;

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

final BlendMode blendMode;

@override

RenderBackdropFilter createRenderObject(BuildContext context) {

return RenderBackdropFilter(filter: filter, blendMode: blendMode);

}

@override

void updateRenderObject(BuildContext context, RenderBackdropFilter renderObject) {

renderObject

..filter = filter

..blendMode = blendMode;

}

}

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

}

}

class ClipRRect extends SingleChildRenderObjectWidget {

/// Creates a rounded-rectangular clip.

const ClipRRect({

super.key,

this.borderRadius = BorderRadius.zero,

this.clipper,

this.clipBehavior = Clip.antiAlias,

super.child,

});

/// The border radius of the rounded corners.

final BorderRadiusGeometry borderRadius;

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

final CustomClipper<RRect>? clipper;

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

final Clip clipBehavior;

@override

RenderClipRRect createRenderObject(BuildContext context) {

return RenderClipRRect(

borderRadius: borderRadius,

clipper: clipper,

clipBehavior: clipBehavior,

textDirection: Directionality.maybeOf(context),

);

}

@override

void updateRenderObject(BuildContext context, RenderClipRRect renderObject) {

renderObject

..borderRadius = borderRadius

..clipBehavior = clipBehavior

..clipper = clipper

..textDirection = Directionality.maybeOf(context);

}

@override

void debugFillProperties(DiagnosticPropertiesBuilder properties) {

super.debugFillProperties(properties);

properties.add(DiagnosticsProperty<BorderRadiusGeometry>('borderRadius', borderRadius, showName: false, defaultValue: null));

properties.add(DiagnosticsProperty<CustomClipper<RRect>>('clipper', clipper, defaultValue: null));

}

}

class ClipOval extends SingleChildRenderObjectWidget {

/// Creates an oval-shaped clip.

const ClipOval({

super.key,

this.clipper,

this.clipBehavior = Clip.antiAlias,

super.child,

});

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

final CustomClipper<Rect>? clipper;

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

final Clip clipBehavior;

@override

RenderClipOval createRenderObject(BuildContext context) {

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

}

@override

void updateRenderObject(BuildContext context, RenderClipOval renderObject) {

renderObject

..clipper = clipper

..clipBehavior = clipBehavior;

}

@override

void didUnmountRenderObject(RenderClipOval renderObject) {

renderObject.clipper = null;

}

@override

void debugFillProperties(DiagnosticPropertiesBuilder properties) {

super.debugFillProperties(properties);

properties.add(DiagnosticsProperty<CustomClipper<Rect>>('clipper', clipper, defaultValue: null));

}

}

class ClipPath extends SingleChildRenderObjectWidget {

/// Creates a path clip.

const ClipPath({

super.key,

this.clipper,

this.clipBehavior = Clip.antiAlias,

super.child,

});