<itemvalue="Replaces the top-most page of the page stack with the given URL location w optional query parameters, e.g. `familyf2personp1?color=blue`. See also: [go] which navigates to the location. [push] which pushes the given location onto the page stack. [replace] which replaces the top-most page of the page stack but treats it as the same page. The page key will be reused. This will preserve the state and not run any page animation."/>
<itemvalue="Controls how one widget replaces another widget in the tree. If the [runtimeType] and [key] properties of the two widgets are [operator==], respectively, then the new widget replaces the old widget by updating the underlying element (i.e., by calling [Element.update] with the new widget). Otherwise, the old element is removed from the tree, the new widget is inflated into an element, and the new element is inserted into the tree. In addition, using a [GlobalKey] as the widget's [key] allows the element to be moved around the tree (changing parent) without losing state. When a new widget is found (its key and type do not match a previous widget in the same location), but there was a widget with that same global key elsewhere in the tree in the previous frame, then that widget's element is moved to the new location. Generally, a widget that is the only child of another widget does not need an explicit key. See also: The discussions at [Key] and [GlobalKey]."/>
<itemvalue="The absolute URI of the script being run in this isolate. If the script argument on the command line is relative, it is resolved to an absolute URI before fetching the script, and that absolute URI is returned. URI resolution only does string manipulation on the script path, and this may be different from the file system's path resolution behavior. For example, a symbolic link immediately followed by '..' will not be looked up. If a compiled Dart script is being executed the URI to the compiled script is returned, for example, `file:fullpathtoscript_name.exe`. If running on the Dart VM the URI to the running Dart script is returned, for example, `file:fullpathtoscript_name.dart`. If the executable environment does not support [script], the URI is empty."/>
<itemvalue="The path of the executable used to run the script in this isolate. Usually `dart` when running on the Dart VM or the compiled script name (`script_name.exe`). The literal path used to identify the executable. This path might be relative or just be a name from which the executable was found by searching the system path. Use [resolvedExecutable] to get an absolute path to the executable."/>
<itemvalue="The path of the executable used to run the script in this isolate after it has been resolved by the OS. This is the absolute path, with all symlinks resolved, to the executable used to run the script. See [executable] for the unresolved version."/>
<itemvalue="The initialization type can be dynamically set, which is suitable for some special scenarios; for example: for a desktop application, initializing the global only needs to initialize the Attach Dialog, and initializing a block area does not need to initialize the Attach Dialog 可动态设置初始化类型, 适用于一些特殊场景; 例如: 某桌面端应用, 初始化全局只需要初始化Attach Dialog, 初始化某块区域不需要初始化Attach Dialog"/>
<itemvalue="Each pixel is 32 bits, with the highest 8 bits encoding red, the next 8 bits encoding green, the next 8 bits encoding blue, and the lowest 8 bits encoding alpha. Premultiplied alpha is used."/>
<itemvalue="Scaling the image to larger than its intrinsic size should usually be avoided, since it causes the image to use more memory than necessary. Instead, prefer scaling the [Canvas] transform. If the image must be scaled up, the `allowUpscaling` parameter must be set to true."/>
<itemvalue="The `targetWidth` and `targetHeight` arguments specify the size of the output image, in image pixels. If they are not equal to the intrinsic dimensions of the image, then the image will be scaled after being decoded. If the `allowUpscaling` parameter is not set to true, both dimensions will be capped at the intrinsic dimensions of the image, even if only one of them would have exceeded those intrinsic dimensions. If exactly one of these two arguments is specified, then the aspect ratio will be maintained while forcing the image to match the other given dimension. If neither is specified, then the image maintains its intrinsic size."/>
<itemvalue="The `rowBytes` parameter is the number of bytes consumed by each row of pixels in the data buffer. If unspecified, it defaults to `width` multiplied by the number of bytes per pixel in the provided `format`."/>
<itemvalue="Convert an array of pixel values into an [Image] object. The `pixels` parameter is the pixel data. They are packed in bytes in the order described by `format`, then grouped in rows, from left to right, then top to bottom."/>
<itemvalue="Standard output from the process. The value used for the `stdoutEncoding` argument to [Process.run] determines the type. If `null` was used, this value is of type [Uint8List] otherwise it is of type `String`."/>
<itemvalue="A rectangle upon which a backend texture is mapped. Backend textures are images that can be applied (mapped) to an area of the Flutter view. They are created, managed, and updated using a platform-specific texture registry. This is typically done by a plugin that integrates with host platform video player, camera, or OpenGL APIs, or similar image sources. A texture widget refers to its backend texture using an integer ID. Texture IDs are obtained from the texture registry and are scoped to the Flutter view. Texture IDs may be reused after deregistration, at the discretion of the registry. The use of texture IDs currently unknown to the registry will silently result in a blank rectangle. Texture widgets are repainted autonomously as dictated by the backend (e.g. on arrival of a video frame). Such repainting generally does not involve executing Dart code. The size of the rectangle is determined by its parent widget, and the texture is automatically scaled to fit."/>
<itemvalue="A [TextInputFormatter] can be optionally injected into an [EditableText] to provide as-you-type validation and formatting of the text being edited. Text modification should only be applied when text is being committed by the IME and not on text under composition (i.e., only when [TextEditingValue.composing] is collapsed). See also the [FilteringTextInputFormatter], a subclass that removes characters that the user tries to enter if they do, or do not, match a given pattern (as applicable). To create custom formatters, extend the [TextInputFormatter] class and implement the [formatEditUpdate] method. Handling emojis and other complex characters {@macro flutter.widgets.EditableText.onChanged} See also: [EditableText] on which the formatting apply. [FilteringTextInputFormatter], a provided formatter for filtering characters."/>
<itemvalue="The behavior of the pattern depends on the [allow] property. If it is true, then this is an allow list, specifying a pattern that characters must match to be accepted. Otherwise, it is a deny list, specifying a pattern that characters must not match to be accepted."/>
<itemvalue="Creates a formatter that replaces banned patterns with the given [replacementString]. If [allow] is true, then the filter pattern is an allow list, and characters must match the pattern to be accepted. See also the [FilteringTextInputFormatter.allow()] constructor. If [allow] is false, then the filter pattern is a deny list, and characters that match the pattern are rejected. See also the [FilteringTextInputFormatter.deny] constructor."/>
<itemvalue="Creates a formatter that only allows characters matching a pattern."/>
<itemvalue="If `mode` is [ProcessStartMode.detached] a detached process will be created. A detached process has no connection to its parent, and can keep running on its own when the parent dies. The only information available from a detached process is its `pid`. There is no connection to its `stdin`, `stdout` or `stderr`, nor will the process' exit code become available when it terminates."/>
<itemvalue="If [mode] is [ProcessStartMode.normal] (the default) a child process will be started with `stdin`, `stdout` and `stderr` connected to its parent. The parent process will not exit so long as the child is running, unless [exit] is called by the parent. If [exit] is called by the parent then the parent will be terminated but the child will continue running."/>
<itemvalue="Using an absolute path for [executable] is recommended since resolving the [executable] path is platform-specific. On Windows, both any `PATH` set in the [environment] map parameter and the path set in [workingDirectory] parameter are ignored for the purposes of resolving the [executable] path."/>
<itemvalue="Returns a `Future<Process>` that completes with a [Process] instance when the process has been successfully started. That [Process] object can be used to interact with the process. If the process cannot be started the returned [Future] completes with an exception."/>
<itemvalue="Starts a process running the [executable] with the specified [arguments]."/>
<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."/>