library;

import 'dart:async';

import 'dart:collection';

import 'package:flutter/foundation.dart';

import 'package:flutter/rendering.dart';

import 'binding.dart';

import 'debug.dart';

import 'focus_manager.dart';

import 'inherited_model.dart';

import 'notification_listener.dart';

import 'widget_inspector.dart';

export 'package:flutter/foundation.dart'

show

factory,

immutable,

mustCallSuper,

optionalTypeArgs,

protected,

required,

visibleForTesting;

export 'package:flutter/foundation.dart'

show ErrorDescription, ErrorHint, ErrorSummary, FlutterError, debugPrint, debugPrintStack;

export 'package:flutter/foundation.dart' show DiagnosticLevel, DiagnosticsNode;

export 'package:flutter/foundation.dart' show Key, LocalKey, ValueKey;

export 'package:flutter/foundation.dart' show ValueChanged, ValueGetter, ValueSetter, VoidCallback;

export 'package:flutter/rendering.dart'

show RenderBox, RenderObject, debugDumpLayerTree, debugDumpRenderTree;

class _DebugOnly {

const _DebugOnly();

}

const _DebugOnly _debugOnly = _DebugOnly();

class ObjectKey extends LocalKey {

/// Creates a key that uses [identical] on [value] for its [operator==].

const ObjectKey(this.value);

/// The object whose identity is used by this key's [operator==].

final Object? value;

@override

bool operator ==(Object other) {

if (other.runtimeType != runtimeType) {

return false;

}

return other is ObjectKey && identical(other.value, value);

}

@override

int get hashCode => Object.hash(runtimeType, identityHashCode(value));

@override

String toString() {

if (runtimeType == ObjectKey) {

return '[${describeIdentity(value)}]';

}

return '[${objectRuntimeType(this, 'ObjectKey')} ${describeIdentity(value)}]';

}

}

abstract class GlobalKey<T extends State<StatefulWidget>> extends Key {

/// Creates a [LabeledGlobalKey], which is a [GlobalKey] with a label used for

factory GlobalKey({String? debugLabel}) => LabeledGlobalKey<T>(debugLabel);

/// Creates a global key without a label.

const GlobalKey.constructor() : super.empty();

Element? get _currentElement => WidgetsBinding.instance.buildOwner!._globalKeyRegistry[this];

/// The build context in which the widget with this key builds.

BuildContext? get currentContext => _currentElement;

/// The widget in the tree that currently has this global key.

Widget? get currentWidget => _currentElement?.widget;

/// The [State] for the widget in the tree that currently has this global key.

T? get currentState => switch (_currentElement) {

StatefulElement(:final T state) => state,

_ => null,

};

}

class LabeledGlobalKey<T extends State<StatefulWidget>> extends GlobalKey<T> {

/// Creates a global key with a debugging label.

// ignore: prefer_const_constructors_in_immutables , never use const for this class

LabeledGlobalKey(this._debugLabel) : super.constructor();

final String? _debugLabel;

@override

String toString() {

final label = _debugLabel != null ? ' $_debugLabel' : '';

if (runtimeType == LabeledGlobalKey) {

return '[GlobalKey#${shortHash(this)}$label]';

}

return '[${describeIdentity(this)}$label]';

}

}

class GlobalObjectKey<T extends State<StatefulWidget>> extends GlobalKey<T> {

/// Creates a global key that uses [identical] on [value] for its [operator==].

const GlobalObjectKey(this.value) : super.constructor();

/// The object whose identity is used by this key's [operator==].

final Object value;

@override

bool operator ==(Object other) {

if (other.runtimeType != runtimeType) {

return false;

}

return other is GlobalObjectKey<T> && identical(other.value, value);

}

@override

int get hashCode => identityHashCode(value);

@override

String toString() {

String selfType = objectRuntimeType(this, 'GlobalObjectKey');

// The runtimeType string of a GlobalObjectKey() returns 'GlobalObjectKey<State<StatefulWidget>>'

// because GlobalObjectKey is instantiated to its bounds. To avoid cluttering the output

// we remove the suffix.

const suffix = '<State<StatefulWidget>>';

if (selfType.endsWith(suffix)) {

selfType = selfType.substring(0, selfType.length - suffix.length);

}

return '[$selfType ${describeIdentity(value)}]';

}

}

@pragma('track-creation-locations')

abstract class Widget extends DiagnosticableTree {

/// Initializes [key] for subclasses.

const Widget({this.key});

/// Controls how one widget replaces another widget in the tree.

final Key? key;

/// Inflates this configuration to a concrete instance.

@protected

@factory

Element createElement();

/// A short, textual description of this widget.

@override

String toStringShort() {

final String type = objectRuntimeType(this, 'Widget');

return key == null ? type : '$type-$key';

}

@override

void debugFillProperties(DiagnosticPropertiesBuilder properties) {

super.debugFillProperties(properties);

properties.defaultDiagnosticsTreeStyle = DiagnosticsTreeStyle.dense;

}

@override

@nonVirtual

bool operator ==(Object other) => super == other;

@override

@nonVirtual

int get hashCode => super.hashCode;

/// Whether the `newWidget` can be used to update an [Element] that currently

static bool canUpdate(Widget oldWidget, Widget newWidget) {

return oldWidget.runtimeType == newWidget.runtimeType && oldWidget.key == newWidget.key;

}

// Return a numeric encoding of the specific `Widget` concrete subtype.

// This is used in `Element.updateChild` to determine if a hot reload modified the

// superclass of a mounted element's configuration. The encoding of each `Widget`

// must match the corresponding `Element` encoding in `Element._debugConcreteSubtype`.

static int _debugConcreteSubtype(Widget widget) {

return widget is StatefulWidget

? 1

: widget is StatelessWidget

? 2

: 0;

}

}

abstract class StatelessWidget extends Widget {

/// Initializes [key] for subclasses.

const StatelessWidget({super.key});

/// Creates a [StatelessElement] to manage this widget's location in the tree.

@override

StatelessElement createElement() => StatelessElement(this);

/// Describes the part of the user interface represented by this widget.

@protected

Widget build(BuildContext context);

}

abstract class StatefulWidget extends Widget {

/// Initializes [key] for subclasses.

const StatefulWidget({super.key});

/// Creates a [StatefulElement] to manage this widget's location in the tree.

@override

StatefulElement createElement() => StatefulElement(this);

/// Creates the mutable state for this widget at a given location in the tree.

@protected

@factory

State createState();

}

enum _StateLifecycle {

/// The [State] object has been created. [State.initState] is called at this

created,

/// The [State.initState] method has been called but the [State] object is

initialized,

/// The [State] object is ready to build and [State.dispose] has not yet been

ready,

/// The [State.dispose] method has been called and the [State] object is

defunct,

}

typedef StateSetter = void Function(VoidCallback fn);

abstract class State<T extends StatefulWidget> with Diagnosticable {

/// The current configuration.

T get widget => _widget!;

T? _widget;

/// The current stage in the lifecycle for this state object.

_StateLifecycle _debugLifecycleState = _StateLifecycle.created;

/// Verifies that the [State] that was created is one that expects to be

bool _debugTypesAreRight(Widget widget) => widget is T;

/// The location in the tree where this widget builds.

BuildContext get context {

assert(() {

if (_element == null) {

throw FlutterError(

'This widget has been unmounted, so the State no longer has a context (and should be considered defunct). \n'

'Consider canceling any active work during "dispose" or using the "mounted" getter to determine if the State is still active.',

);

}

return true;

}());

return _element!;

}

StatefulElement? _element;

/// Whether this [State] object is currently in a tree.

bool get mounted => _element != null;

/// Called when this object is inserted into the tree.