<itemvalue="Resolves this image provider using the given `configuration`, returning an [ImageStream]. This is the public entry-point of the [ImageProvider] class hierarchy. Subclasses should implement [obtainKey] and [loadImage], which are used by this method. If they need to change the implementation of [ImageStream] used, they should override [createStream]. If they need to manage the actual resolution of the image, they should override [resolveStreamForKey]. See the Lifecycle documentation on [ImageProvider] for more information."/>
<itemvalue="was synchronously loaded"/>
<itemvalue="If a [loadingBuilder] has _also_ been specified for an image, the two builders will be chained together: the _result_ of this builder will be passed as the `child` argument to the [loadingBuilder]. For example, consider the following builders used in conjunction:"/>
<itemvalue="To have finer-grained control over the way that an image's loading progress is communicated to the user, see [loadingBuilder]."/>
<itemvalue="For more information on how to interpret the arguments that are passed to this builder, see the documentation on [ImageFrameBuilder]."/>
<itemvalue="If this is null, this widget will display an image that is painted as soon as the first image frame is available (and will appear to "pop" in if it becomes available asynchronously). Callers might use this builder to add effects to the image (such as fading the image in when it becomes available) or to display a placeholder widget while the image is loading."/>
<itemvalue="A builder function responsible for creating the widget that represents this image."/>
<itemvalue="The `callback`, the `message` given to it as well as the result have to be objects that can be sent across isolates (as they may be transitively copied if needed). The majority of objects can be sent across isolates."/>
<itemvalue="On native platforms `await compute(fun, message)` is equivalent to `await Isolate.run(() => fun(message))`. See also [Isolate.run]."/>
<itemvalue="{@template flutter.foundation.compute.usecase} This is useful for operations that take longer than a few milliseconds, and which would therefore risk skipping frames. For tasks that will only take a few milliseconds, consider [SchedulerBinding.scheduleTask] instead. {@endtemplate}"/>
<itemvalue="Asynchronously runs the given [callback] - with the provided [message] - in the background and completes with the result."/>
<itemvalue="{@template widget_preview_size} Artificial constraints to be applied to the previewed widget. If not provided, the previewed widget will attempt to set its own constraints. If a dimension has a value of `double.infinity`, the previewed widget will attempt to set its own constraints in the relevant dimension. To set a single dimension and allow the other to set its own constraints, use [Size.fromHeight] or [Size.fromWidth]. {@endtemplate}"/>
<itemvalue="2: Fit mode. The priority is to ensure that all video content is displayed. Any areas of the window that are not filled due to the mismatch between video size and window size will be filled with black."/>
<itemvalue="The angle of this offset as radians clockwise from the positive x-axis, in the range -[pi] to [pi], assuming positive values of the x-axis go to the right and positive values of the y-axis go down. Zero means that [dy] is zero and [dx] is zero or positive. Values from zero to [pi]2 indicate positive values of [dx] and [dy], the bottom-right quadrant. Values from [pi]2 to [pi] indicate negative values of [dx] and positive values of [dy], the bottom-left quadrant. Values from zero to -[pi]2 indicate positive values of [dx] and negative values of [dy], the top-right quadrant. Values from -[pi]2 to -[pi] indicate negative values of [dx] and [dy], the top-left quadrant. When [dy] is zero and [dx] is negative, the [direction] is [pi]. When [dx] is zero, [direction] is [pi]2 if [dy] is positive and -[pi]2 if [dy] is negative."/>
<itemvalue="The angle of this offset as radians clockwise from the positive x-axis, in the range -[pi] to [pi], assuming positive values of the x-axis go to the right and positive values of the y-axis go down."/>
<itemvalue="If non-null, the style to use for this text. If the style's "inherit" property is true, the style will be merged with the closest enclosing [DefaultTextStyle]. Otherwise, the style will replace the closest enclosing [DefaultTextStyle]."/>
<itemvalue="Instantiating non-const instances of this class in your app will mean the app cannot be built in release mode with icon tree-shaking (it need to be explicitly opted out at build time). See [staticIconProvider] for more context."/>
<itemvalue="A description of an icon fulfilled by a font glyph. See [Icons] for a number of predefined icons available for material design applications. In release builds, the Flutter tool will tree shake out of bundled fonts the code points (or instances of [IconData]) which are not referenced from Dart app code. See the [staticIconProvider] annotation for more details."/>
<itemvalue="When looking to easily toggle the default decorations, you can use [ScrollBehavior.copyWith] instead of creating your own [ScrollBehavior] class. The `scrollbar` and `overscrollIndicator` flags can turn these decorations off. {@endtemplate}"/>
<itemvalue="This class can be extended to further customize a [ScrollBehavior] for a subtree. For example, overriding [ScrollBehavior.getScrollPhysics] sets the default [ScrollPhysics] for [Scrollable]s that inherit this [ScrollConfiguration]. Overriding [ScrollBehavior.buildOverscrollIndicator] can be used to add or change the default [GlowingOverscrollIndicator] decoration, while [ScrollBehavior.buildScrollbar] can be changed to modify the default [Scrollbar]."/>
<itemvalue="Describes how [Scrollable] widgets should behave. {@template flutter.widgets.scrollBehavior} Used by [ScrollConfiguration] to configure the [Scrollable] widgets in a subtree."/>
<itemvalue="Set the initial position at the position where this gesture recognizer won the arena."/>
<itemvalue="Set the initial offset at the position where the first down event was detected."/>
<itemvalue="With this flag set to false, when accessibility focus reaches the end of the current page and the user attempts to move it to the next element, the focus will traverse to the next widget outside of the page view."/>
<itemvalue="Controls whether the widget's pages will respond to [RenderObject.showOnScreen], which will allow for implicit accessibility scrolling."/>
<itemvalue="allow implicit scrolling"/>
<itemvalue="Save the current [page] with [PageStorage] and restore it if this controller's scrollable is recreated. If this property is set to false, the current [page] is never saved and [initialPage] is always used to initialize the scroll offset. If true (the default), the initial page is used the first time the controller's scrollable is created, since there's isn't a page to restore yet. Subsequently the saved page is restored and [initialPage] is ignored."/>
<itemvalue="viewport fraction"/>
<itemvalue="Scroll views attempt to persist their scroll position using [PageStorage]. For a [PageView], this can be disabled by setting [PageController.keepPage] to false on the [controller]. If it is enabled, using a [PageStorageKey] for the [key] of this widget is recommended to help disambiguate different scroll views from each other."/>
<itemvalue="{@tool dartpad} Here is an example of [PageView]. It creates a centered [Text] in each of the three pages which scroll horizontally."/>
<itemvalue="The [PageController] can also be used to control the [PageController.initialPage], which determines which page is shown when the [PageView] is first constructed, and the [PageController.viewportFraction], which determines the size of the pages as a fraction of the viewport size."/>
<itemvalue="A scrollable list that works page by page. Each child of a page view is forced to be the same size as the viewport. You can use a [PageController] to control which page is visible in the view. In addition to being able to control the pixel offset of the content inside the [PageView], a [PageController] also lets you control the offset in terms of pages, which are increments of the viewport size."/>
<itemvalue="Initialize the gradient's colors and stops. The [colors] argument must have at least two colors (the length is not verified until the [createShader] method is called). If specified, the [stops] argument must have the same number of entries as [colors] (this is also not verified until the [createShader] method is called). The [transform] argument can be applied to transform _only_ the gradient, without rotating the canvas itself or other geometry on the canvas. For example, a `GradientRotation(math.pi4)` will result in a [SweepGradient] that starts from a position of 6 o'clock instead of 3 o'clock, assuming no other rotation or perspective transformations have been applied to the [Canvas]. If null, no transformation is applied."/>