<itemvalue="Whether this range is empty (but still potentially placed inside the text)."/>
<itemvalue="The index of the first character in the range. If [start] and [end] are both -1, the text range is empty."/>
<itemvalue="A widget that defines a region that can detect taps inside or outside of itself and any group of regions it belongs to, without participating in the [gesture disambiguation](https:flutter.devgesturesgesture-disambiguation) system (other than to consume tap down events if [consumeOutsideTaps] is true). This widget indicates to the nearest ancestor [TapRegionSurface] that the region occupied by its child will participate in the tap detection for that surface. If this region belongs to a group (by virtue of its [groupId]), all the regions in the group will act as one. If there is no [TapRegionSurface] ancestor, [TapRegion] will do nothing."/>
<itemvalue="A [TapRegion] that adds its children to the tap region group for widgets based on the [EditableText] text editing widget, such as [TextField] and [CupertinoTextField]. Widgets that are wrapped with a [TextFieldTapRegion] are considered to be part of a text field for purposes of unfocus behavior. So, when the user taps on them, the currently focused text field won't be unfocused by default. This allows controls like spinners, copy buttons, and formatting buttons to be associated with a text field without causing the text field to lose focus when they are interacted with. {@tool dartpad} This example shows how to use a [TextFieldTapRegion] to wrap a set of "spinner" buttons that increment and decrement a value in the text field without causing the text field to lose keyboard focus. This example includes a generic `SpinnerField<T>` class that you can copypaste into your own project and customize. See code in examplesapilibwidgetstap_regiontext_field_tap_region.0.dart {@end-tool} See also: [TapRegion], the widget that this widget uses to add widgets to the group of text fields."/>
<itemvalue="An interface for implementing text input controls that receive text editing state changes and visual input control requests. Editing state changes and input control requests are sent by the framework when the editing state of the attached text input client changes, or it requests the input control to be shown or hidden, for example. The input control can be installed with [TextInput.setInputControl], and the default platform text input control can be restored with [TextInput.restorePlatformInputControl]. The [TextInputControl] class must be extended. [TextInputControl] implementations should call [TextInput.updateEditingValue] to send user input to the attached input client."/>
@ -59,13 +61,11 @@
<itemvalue="The [padding] property is computed from both [viewInsets] and [viewPadding]. It will allow a view inset to consume view padding where appropriate, such as when a phone's keyboard is covering the bottom view padding and so "absorbs" it. Clients that want to position elements relative to the view padding regardless of the view insets should use the [viewPadding] property, e.g. if you wish to draw a widget at the center of the screen with respect to the iPhone "safe area" regardless of whether the keyboard is showing. [padding] is useful for clients that want to know how much padding should be accounted for without concern for the current inset(s) state, e.g. determining whether a gesture should be considered for scrolling purposes. This value varies based on the current state of the insets. For example, a visible keyboard will consume all gestures in the bottom part of the [viewPadding] anyway, so there is no need to account for that in the [padding], which is always safe to use for such calculations."/>
<itemvalue="The parts of the display that are completely obscured by system UI, typically by the device's keyboard. When a mobile device's keyboard is visible `viewInsets.bottom` corresponds to the top of the keyboard. This value is independent of the [padding] and [viewPadding]. viewPadding is measured from the edges of the [MediaQuery] widget's bounds. Padding is calculated based on the viewPadding and viewInsets. The bounds of the top level MediaQuery created by [WidgetsApp] are the same as the window (often the mobile device screen) that contains the app. {@youtube 560 315 https:www.youtube.comwatch?v=ceCo8U0XHqw} See also: [FlutterView], which provides some additional detail about this property and how it relates to [padding] and [viewPadding]."/>
<itemvalue="{@template dio.CancelToken} Controls cancellation of [Dio]'s requests. The same token can be shared between different requests. When [cancel] is invoked, requests bound to this token will be cancelled. {@endtemplate}"/>
<itemvalue="An optional maximum number of lines for the text to span, wrapping if necessary. If the text exceeds the given number of lines, it will be truncated according to [overflow]. If this is 1, text will not wrap. Otherwise, text will be wrapped at the edge of the box. If this is null, but there is an ambient [DefaultTextStyle] that specifies an explicit number for its [DefaultTextStyle.maxLines], then the [DefaultTextStyle] value will take precedence. You can use a [RichText] widget directly to entirely override the [DefaultTextStyle]."/>
<itemvalue="Whether to show or hide a child. By default, the [visible] property controls whether the [child] is included in the subtree or not; when it is not [visible], the [replacement] child (typically a zero-sized box) is included instead. A variety of flags can be used to tweak exactly how the child is hidden. (Changing the flags dynamically is discouraged, as it can cause the [child] subtree to be rebuilt, with any state in the subtree being discarded. Typically, only the [visible] flag is changed dynamically.)"/>
debuggerx
1 year ago