<itemvalue="The [address] can either be a [String] or an [InternetAddress]. If [address] is a [String], [bind] will perform a [InternetAddress.lookup] and use the first value in the list. To listen on the loopback adapter, which will allow only incoming connections from the local host, use the value [InternetAddress.loopbackIPv4] or [InternetAddress.loopbackIPv6]. To allow for incoming connection from the network use either one of the values [InternetAddress.anyIPv4] or [InternetAddress.anyIPv6] to bind to all interfaces or the IP address of a specific interface. If an IP version 6 (IPv6) address is used, both IP version 6 (IPv6) and version 4 (IPv4) connections will be accepted. To restrict this to version 6 (IPv6) only, use [v6Only] to set version 6 only. However, if the address is [InternetAddress.loopbackIPv6], only IP version 6 (IPv6) connections will be accepted."/>
<itemvalue="The [address] can either be a [String] or an [InternetAddress]. If [address] is a [String], [bind] will perform a [InternetAddress.lookup] and use the first value in the list. To listen on the loopback adapter, which will allow only incoming connections from the local host, use the value [InternetAddress.loopbackIPv4] or [InternetAddress.loopbackIPv6]. To allow for incoming connection from the network use either one of the values [InternetAddress.anyIPv4] or [InternetAddress.anyIPv6] to bind to all interfaces or the IP address of a specific interface."/>
<itemvalue="Starts listening for HTTP requests on the specified [address] and [port]. The [address] can either be a [String] or an [InternetAddress]. If [address] is a [String], [bind] will perform a [InternetAddress.lookup] and use the first value in the list. To listen on the loopback adapter, which will allow only incoming connections from the local host, use the value [InternetAddress.loopbackIPv4] or [InternetAddress.loopbackIPv6]. To allow for incoming connection from the network use either one of the values [InternetAddress.anyIPv4] or [InternetAddress.anyIPv6] to bind to all interfaces or the IP address of a specific interface."/>
<itemvalue="Starts the clock for this [Ticker]. If the ticker is not [muted], then this also starts calling the ticker's callback once per animation frame. The returned future resolves once the ticker [stop]s ticking. If the ticker is disposed, the future does not resolve. A derivative future is available from the returned [TickerFuture] object that resolves with an error in that case, via [TickerFuture.orCancel]. Calling this sets [isActive] to true. This method cannot be called while the ticker is active. To restart the ticker, first [stop] it. By convention, this method is used by the object that receives the ticks (as opposed to the [TickerProvider] which created the ticker)."/>
<itemvalue="Same as [render], but takes both the position and the size as a single [Rect]. Note: only use this if you are already using [Rect]'s to represent both the position and dimension of your [Sprite]. If you are using [Vector2]s, prefer the other method."/>
<itemvalue="Fill the target box by distorting the source's aspect ratio. "/>
<itemvalue="As small as possible while still covering the entire target box. {@template flutter.painting.BoxFit.cover} To actually clip the content, use `clipBehavior: Clip.hardEdge` alongside this in a [FittedBox]. {@endtemplate} "/>
<itemvalue="A [Sprite] is a region of an [Image] that can be rendered in the Canvas. It might represent the entire image or be one of the pieces a spritesheet is composed of. It holds a reference to the source image from which the region is extracted, and the [src] rectangle is the portion inside that image that is to be rendered (not to be confused with the `dest` rect, which is where in the Canvas the sprite is rendered). It also has a [paint] field that can be overwritten to apply a tint to this [Sprite] (default is white, meaning no tint)."/>
<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 [load], 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. @nonVirtual"/>
<itemvalue="Schedules [component] to be added as a child to this component. This method is robust towards being called from any place in the user code: you can call it while iterating over the component tree, during mounting or async loading, when the Game object is already loaded or not. The cost of this flexibility is that the component won't be added right away. Instead, it will be placed into a queue, and then added later, after it has finished loading, but no sooner than on the next game tick. When multiple children are scheduled to be added to the same parent, we start loading all of them as soon as possible. Nevertheless, the children will end up being added to the parent in exactly the same order as they were originally scheduled by the user, regardless of how fast or slow each of them loads. A component can be added to a parent which may not be mounted to the game tree yet. In such case, the component will start loading immediately, but its mounting will be delayed until such time when the parent becomes mounted. This method returns a future that completes when the component is done loading, and mounting if the parent is currently mounted. However, this future will not guarantee that the component will become "fully mounted": it still needs to be added to the parent's children list, and that operation will only be done on the next game tick. A component can only be added to one parent at a time. It is an error to try to add it to multiple parents, or even to the same parent multiple times. If you need to change the parent of a component, use the [changeParent] method."/>
<itemvalue="A way to produce Future objects and to complete them later with a value or error. Most of the time, the simplest way to create a future is to just use one of the [Future] constructors to capture the result of a single asynchronous computation: ```dart Future(() { doSomething(); return result; }); ``` or, if the future represents the result of a sequence of asynchronous computations, they can be chained using [Future.then] or similar functions on [Future]: ```dart Future doStuff(){ return someAsyncOperation().then((result) { return someOtherAsyncOperation(result); }); } ``` If you do need to create a Future from scratch — for example, when you're converting a callback-based API into a Future-based one — you can use a Completer as follows: ```dart class AsyncOperation { final Completer _completer = new Completer(); Future<T> doOperation() { _startOperation(); return _completer.future; Send future object back to client. } Something calls this when the value is ready. void _finishOperation(T result) { _completer.complete(result); } If something goes wrong, call this. void _errorHappened(error) { _completer.completeError(error); } } ```"/>
<itemvalue="Creates a new completer. The general workflow for creating a new future is to 1) create a new completer, 2) hand out its future, and, at a later point, 3) invoke either [complete] or [completeError]. The completer completes the future asynchronously. That means that callbacks registered on the future are not called immediately when [complete] or [completeError] is called. Instead the callbacks are delayed until a later microtask. Example: ```dart var completer = new Completer(); handOut(completer.future); later: { completer.complete('completion value'); } ```"/>
<itemvalue="Loads the specified image with [fileName] into the cache. By default the key in the cache is the [fileName], if another key is desired, specify the optional [key] argument."/>
<itemvalue="A Material Design linear progress indicator, also known as a progress bar. {@youtube 560 315 https:www.youtube.comwatch?v=O-rhXZLtpv0} A widget that shows progress along a line. There are two kinds of linear progress indicators: _Determinate_. Determinate progress indicators have a specific value at each point in time, and the value should increase monotonically from 0.0 to 1.0, at which time the indicator is complete. To create a determinate progress indicator, use a non-null [value] between 0.0 and 1.0. _Indeterminate_. Indeterminate progress indicators do not have a specific value at each point in time and instead indicate that progress is being made without indicating how much progress remains. To create an indeterminate progress indicator, use a null [value]. The indicator line is displayed with [valueColor], an animated value. To specify a constant color value use: `AlwaysStoppedAnimation<Color>(color)`. The minimum height of the indicator can be specified using [minHeight]. The indicator can be made taller by wrapping the widget with a [SizedBox]. {@tool dartpad} This example shows a [LinearProgressIndicator] with a changing value. See code in examplesapilibmaterialprogress_indicatorlinear_progress_indicator.0.dart {@end-tool} See also: [CircularProgressIndicator], which shows progress along a circular arc. [RefreshIndicator], which automatically displays a [CircularProgressIndicator] when the underlying vertical scrollable is overscrolled. <https:material.iodesigncomponentsprogress-indicators.htmllinear-progress-indicators>"/>
<itemvalue="The handler for [SemanticsAction.tap]. This is the semantic equivalent of a user briefly tapping the screen with the finger without moving it. For example, a button should implement this action. VoiceOver users on iOS and TalkBack users on Android can trigger this action by double-tapping the screen while an element is focused."/>
<itemvalue="Creates an image filter that applies a matrix transformation. For example, applying a positive scale matrix (see [Matrix4.diagonal3]) when used with [BackdropFilter] would magnify the background image."/>
<itemvalue="Composes the `inner` filter with `outer`, to combine their effects. Creates a single [ImageFilter] that when applied, has the same effect as subsequently applying `inner` and `outer`, i.e., result = outer(inner(source))."/>
<itemvalue="[BackdropFilter], a widget that applies [ImageFilter] to its rendering. [ImageFiltered], a widget that applies [ImageFilter] to its children. [SceneBuilder.pushBackdropFilter], which is the low-level API for using this class as a backdrop filter. [SceneBuilder.pushImageFilter], which is the low-level API for using this class as a child layer filter."/>
<itemvalue="Whether this entry occludes the entire overlay. If an entry claims to be opaque, then, for efficiency, the overlay will skip building entries below that entry unless they have [maintainState] set."/>
<itemvalue="Schedule a callback for the end of this frame. Does not request a new frame. This callback is run during a frame, just after the persistent frame callbacks (which is when the main rendering pipeline has been flushed). If a frame is in progress and post-frame callbacks haven't been executed yet, then the registered callback is still executed during the frame. Otherwise, the registered callback is executed during the next frame. The callbacks are executed in the order in which they have been added. Post-frame callbacks cannot be unregistered. They are called exactly once. See also: [scheduleFrameCallback], which registers a callback for the start of the next frame."/>
<itemvalue="Fullscreen display with status and navigation elements rendered over the application. Available starting at SDK 29 or Android 10. Earlier versions of Android will not be affected by this setting. For applications running on iOS, the status bar and home indicator will be visible. The system overlays will not disappear or reappear in this mode as they are permanently displayed on top of the application. See also: [SystemUiOverlayStyle], can be used to configure transparent status and navigation bars with or without a contrast scrim."/>
<itemvalue="Creates a widget that scales its child along the 2D plane. The `scaleX` argument provides the scalar by which to multiply the `x` axis, and the `scaleY` argument provides the scalar by which to multiply the `y` axis. Either may be omitted, in which case that axis defaults to 1.0. For convenience, to scale the child uniformly, instead of providing `scaleX` and `scaleY`, the `scale` parameter may be used. At least one of `scale`, `scaleX`, and `scaleY` must be non-null. If `scale` is provided, the other two must be null; similarly, if it is not provided, one of the other two must be provided. The [alignment] controls the origin of the scale; by default, this is the center of the box. {@tool snippet} This example shrinks an orange box containing text such that each dimension is half the size it would otherwise be."/>
<itemvalue="An interface for widgets that can return the size this widget would prefer if it were otherwise unconstrained. There are a few cases, notably [AppBar] and [TabBar], where it would be undesirable for the widget to constrain its own size but where the widget needs to expose a preferred or "default" size. For example a primary [Scaffold] sets its app bar height to the app bar's preferred height plus the height of the system status bar. Widgets that need to know the preferred size of their child can require that their child implement this interface by using this class rather than [Widget] as the type of their `child` property. Use [PreferredSize] to give a preferred size to an arbitrary widget. (We ignore `avoid_implementing_value_types` here because the superclass doesn't really implement `operator ==`, it just overrides it to _prevent_ it from being implemented, which is the exact opposite of the spirit of the `avoid_implementing_value_types` lint.) ignore: avoid_implementing_value_types"/>
<itemvalue="The build context in which the widget with this key builds. The current context is null if there is no widget in the tree that matches this global key."/>
<itemvalue="The `transitionDuration` argument is used to determine how long it takes for the route to arrive on or leave off the screen. This argument defaults to 200 milliseconds. The `transitionBuilder` argument is used to define how the route arrives on and leaves off the screen. By default, the transition is a linear fade of the page's contents. The `routeSettings` will be used in the construction of the dialog's route. See [RouteSettings] for more details. {@macro flutter.widgets.RawDialogRoute} Returns a [Future] that resolves to the value (if any) that was passed to [Navigator.pop] when the dialog was closed. State Restoration in Dialogs Using this method will not enable state restoration for the dialog. In order to enable state restoration for a dialog, use [Navigator.restorablePush] or [Navigator.restorablePushNamed] with [RawDialogRoute]. For more information about state restoration, see [RestorationManager]. {@tool sample} This sample demonstrates how to create a restorable dialog. This is accomplished by enabling state restoration by specifying [WidgetsApp.restorationScopeId] and using [Navigator.restorablePush] to push [RawDialogRoute] when the button is tapped. {@macro flutter.widgets.RestorationManager} See code in examplesapilibwidgetsroutesshow_general_dialog.0.dart {@end-tool}"/>
<itemvalue="Displays a dialog above the current contents of the app. This function allows for customization of aspects of the dialog popup. This function takes a `pageBuilder` which is used to build the primary content of the route (typically a dialog widget). Content below the dialog is dimmed with a [ModalBarrier]. The widget returned by the `pageBuilder` does not share a context with the location that `showGeneralDialog` is originally called from. Use a [StatefulBuilder] or a custom [StatefulWidget] if the dialog needs to update dynamically. The `pageBuilder` argument can not be null. The `context` argument is used to look up the [Navigator] for the dialog. It is only used when the method is called. Its corresponding widget can be safely removed from the tree before the dialog is closed. The `useRootNavigator` argument is used to determine whether to push the dialog to the [Navigator] furthest from or nearest to the given `context`. By default, `useRootNavigator` is `true` and the dialog route created by this method is pushed to the root navigator. If the application has multiple [Navigator] objects, it may be necessary to call `Navigator.of(context, rootNavigator: true).pop(result)` to close the dialog rather than just `Navigator.pop(context, result)`. The `barrierDismissible` argument is used to determine whether this route can be dismissed by tapping the modal barrier. This argument defaults to false. If `barrierDismissible` is true, a non-null `barrierLabel` must be provided. The `barrierLabel` argument is the semantic label used for a dismissible barrier. This argument defaults to `null`. The `barrierColor` argument is the color used for the modal barrier. This argument defaults to `Color(0x80000000)`."/>
<itemvalue="The [TransactionHandler] may be executed multiple times; it should be able to handle multiple executions. typedef TransactionHandler<T> = Future<T> Function(Transaction transaction); Transaction class which is created from a call to [runTransaction()]."/>
<itemvalue="The optional argument [shared] specifies whether additional `HttpServer` objects can bind to the same combination of `address`, `port` and `v6Only`. If `shared` is `true` and more `HttpServer`s from this isolate or other isolates are bound to the port, then the incoming connections will be distributed among all the bound `HttpServer`s. Connections can be distributed over multiple isolates this way."/>
<itemvalue="To transform a stream of [HttpRequest] events as it implements a stream transformer that transforms a stream of HttpRequest into a stream of WebSockets by upgrading each HttpRequest from the HTTP or HTTPS server, to the WebSocket protocol. server.transform(new WebSocketTransformer()).listen((webSocket) => ...); This transformer strives to implement WebSockets as specified by RFC6455."/>
<itemvalue="A [Notification] related to scrolling. [Scrollable] widgets notify their ancestors about scrolling-related changes. The notifications have the following lifecycle: A [ScrollStartNotification], which indicates that the widget has started scrolling. Zero or more [ScrollUpdateNotification]s, which indicate that the widget has changed its scroll position, mixed with zero or more [OverscrollNotification]s, which indicate that the widget has not changed its scroll position because the change would have caused its scroll position to go outside its scroll bounds. Interspersed with the [ScrollUpdateNotification]s and [OverscrollNotification]s are zero or more [UserScrollNotification]s, which indicate that the user has changed the direction in which they are scrolling. A [ScrollEndNotification], which indicates that the widget has stopped scrolling. A [UserScrollNotification], with a [UserScrollNotification.direction] of [ScrollDirection.idle]. Notifications bubble up through the tree, which means a given [NotificationListener] will receive notifications for all descendant [Scrollable] widgets. To focus on notifications from the nearest [Scrollable] descendant, check that the [depth] property of the notification is zero. When a scroll notification is received by a [NotificationListener], the listener will have already completed build and layout, and it is therefore too late for that widget to call [State.setState]. Any attempt to adjust the build or layout based on a scroll notification would result in a layout that lagged one frame behind, which is a poor user experience. Scroll notifications are therefore primarily useful for paint effects (since paint happens after layout). The [GlowingOverscrollIndicator] and [Scrollbar] widgets are examples of paint effects that use scroll notifications. To drive layout based on the scroll position, consider listening to the [ScrollPosition] directly (or indirectly via a [ScrollController])."/>
