You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
68 lines
15 KiB
68 lines
15 KiB
<application>
|
|
<component name="Translation.Cache">
|
|
<option name="lastTrimTime" value="1740993668572" />
|
|
</component>
|
|
<component name="Translation.Settings">
|
|
<option name="translator" value="GOOGLE" />
|
|
</component>
|
|
<component name="Translation.States">
|
|
<histories>
|
|
<item value="Usually, this means that the Expanded widget has the wrong ancestor RenderObjectWidget. Typically, Expanded widgets are placed directly inside Flex widgets. The offending Expanded is currently placed inside a Opacity widget." />
|
|
<item value="Draws a shadow for a [Path] representing the given material elevation. The `transparentOccluder` argument should be true if the occluding object is not opaque. The arguments must not be null." />
|
|
<item value="A pointer that has triggered a long-press with a primary button has stopped contacting the screen." />
|
|
<item value="A pointer that has triggered a long-press with a primary button has stopped contacting the screen. This is equivalent to (and is called immediately after) [onLongPressEnd]. The only difference between the two is that this callback does not contain details of the state of the pointer when it stopped contacting the screen." />
|
|
<item value="Frequency of calling [listener] from the moment the stick is dragged, by default 100 milliseconds." />
|
|
<item value="AM control panel view model" />
|
|
<item value="AM control pannel view model" />
|
|
<item value="Arabic" />
|
|
<item value="If true, tells the focus traversal policy to skip over this node for purposes of the traversal algorithm. This may be used to place nodes in the focus tree that may be focused, but not traversed, allowing them to receive key events as part of the focus chain, but not be traversed to via focus traversal. This is different from [canRequestFocus] because it only implies that the node can't be reached via traversal, not that it can't be focused. It may still be focused explicitly." />
|
|
<item value="Draws the subset of the given image described by the `src` argument into the canvas in the axis-aligned rectangle given by the `dst` argument. This might sample from outside the `src` rect by up to half the width of an applied filter. Multiple calls to this method with different arguments (from the same image) can be batched into a single call to [drawAtlas] to improve performance." />
|
|
<item value="Draws the given [Image] into the canvas with its top-left corner at the given [Offset]. The image is composited into the canvas using the given [Paint]." />
|
|
<item value="initial capacity" />
|
|
<item value="List based [Queue]. Keeps a cyclic buffer of elements, and grows to a larger buffer when it fills up. This guarantees constant time peek and remove operations, and amortized constant time add operations." />
|
|
<item value="A [Queue] that delegates all operations to a base queue. This class can be used to hide non-`Queue` methods of a queue object, or it can be extended to add extra functionality on top of an existing queue object." />
|
|
<item value="A class that efficiently implements both [Queue] and [List]." />
|
|
<item value="A [Queue] is a collection that can be manipulated at both ends. One can iterate over the elements of a queue through [forEach] or with an [Iterator]." />
|
|
<item value="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." />
|
|
<item value="Records a [Picture] containing a sequence of graphical operations. To begin recording, construct a [Canvas] to record the commands. To end recording, use the [PictureRecorder.endRecording] method. Use with the Flutter framework The Flutter framework's [RendererBinding] provides a hook for creating [PictureRecorder] objects ([RendererBinding.createPictureRecorder]) that allows tests to hook into the scene creation logic. When creating a [PictureRecorder] and [Canvas] that will be used with a [PictureLayer] as part of the [Scene] in the context of the Flutter framework, consider calling [RendererBinding.createPictureRecorder] instead of calling the [PictureRecorder.new] constructor directly. This does not apply when using a canvas to generate a bitmap for other purposes, e.g. for generating a PNG image using [Picture.toImage]." />
|
|
<item value="Draw the given picture onto the canvas. To create a picture, see [PictureRecorder]." />
|
|
<item value="Draws many parts of an image - the [atlas] - onto the canvas. This method allows for optimization when you want to draw many parts of an image onto the canvas, such as when using sprites or zooming. It is more efficient than using multiple calls to [drawImageRect] and provides more functionality to individually transform each image part by a separate rotation or scale and blend or modulate those parts with a solid color." />
|
|
<item value="Called whenever the widget configuration changes. If the parent widget rebuilds and requests that this location in the tree update to display a new widget with the same [runtimeType] and [Widget.key], the framework will update the [widget] property of this [State] object to refer to the new widget and then call this method with the previous widget as an argument. Override this method to respond when the [widget] changes (e.g., to start implicit animations). The framework always calls [build] after calling [didUpdateWidget], which means any calls to [setState] in [didUpdateWidget] are redundant. {@macro flutter.widgets.State.initState} Implementations of this method should start with a call to the inherited method, as in `super.didUpdateWidget(oldWidget)`. _See the discussion at [Element.rebuild] for more information on when this method is called._" />
|
|
<item value="{@macro flutter.widgets.editableText.onTapOutside} {@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 [TextField] without causing the text field to lose keyboard focus. This example includes a generic `SpinnerField<T>` class that you can copy into your own project and customize. See code in examplesapilibwidgetstap_regiontext_field_tap_region.0.dart {@end-tool} See also: [TapRegion] for how the region group is determined." />
|
|
<item value="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." />
|
|
<item value="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." />
|
|
<item value="text field tap region" />
|
|
<item value="A widget that absorbs pointers during hit testing. When [absorbing] is true, this widget prevents its subtree from receiving pointer events by terminating hit testing at itself. It still consumes space during layout and paints its child as usual. It just prevents its children from being the target of located events, because it returns true from [RenderBox.hitTest]. When [ignoringSemantics] is true, the subtree will be invisible to the semantics layer (and thus e.g. accessibility tools). {@youtube 560 315 https:www.youtube.comwatch?v=65HoWqBboI8} {@tool dartpad} The following sample has an [AbsorbPointer] widget wrapping the button on top of the stack, which absorbs pointer events, preventing its child button __and__ the button below it in the stack from receiving the pointer events. See code in examplesapilibwidgetsbasicabsorb_pointer.0.dart {@end-tool}" />
|
|
<item value="{@template flutter.cupertino.CupertinoSwitch.applyTheme} Whether to apply the ambient [CupertinoThemeData]. If true, the track uses [CupertinoThemeData.primaryColor] for the track when the switch is on. Defaults to [CupertinoThemeData.applyThemeToAll]. {@endtemplate}" />
|
|
<item value="usb device detach" />
|
|
<item value="Groups elements by [keyOf] then folds the elements in each group. A key is found for each element using [keyOf]. Then the elements with the same key are all folded using [combine]. The first call to [combine] for a particular key receives `null` as the previous value, the remaining ones receive the result of the previous call. Can be used to _group_ elements into arbitrary collections. For example [groupSetsBy] could be written as: ```dart iterable.groupFoldBy(keyOf, (Set<T>? previous, T element) => (previous ?? <T>{})..add(element)); ````" />
|
|
<item value="fatal" />
|
|
<item value="with date" />
|
|
<item value="full time" />
|
|
<item value="A Material Design primary tab bar. Primary tabs are placed at the top of the content pane under a top app bar. They display the main content destinations. Typically created as the [AppBar.bottom] part of an [AppBar] and in conjunction with a [TabBarView]. {@youtube 560 315 https:www.youtube.comwatch?v=POtoEH-5l40} If a [TabController] is not provided, then a [DefaultTabController] ancestor must be provided instead. The tab controller's [TabController.length] must equal the length of the [tabs] list and the length of the [TabBarView.children] list." />
|
|
<item value="dust" />
|
|
<item value="ssssssssss" />
|
|
<item value="hhhhhhhhhh" />
|
|
<item value="absorption" />
|
|
<item value="A widget that manages a [FocusNode] to allow keyboard focus to be given to this widget and its descendants. {@youtube 560 315 https:www.youtube.comwatch?v=JCDfh5bs1xc} When the focus is gained or lost, [onFocusChange] is called. For keyboard events, [onKey] and [onKeyEvent] are called if [FocusNode.hasFocus] is true for this widget's [focusNode], unless a focused descendant's [onKey] or [onKeyEvent] callback returned [KeyEventResult.handled] when called. This widget does not provide any visual indication that the focus has changed. Any desired visual changes should be made when [onFocusChange] is called." />
|
|
<item value="If the argument [flush] is set to `true`, the data written will be flushed to the file system before the returned future completes." />
|
|
<item value="Path to a directory where the application may place data that is user-generated, or that cannot otherwise be recreated by your application. Consider using another path, such as [getApplicationSupportDirectory], [getApplicationCacheDirectory], or [getExternalStorageDirectory], if the data is not user-generated. Example implementations: - `NSDocumentDirectory` on iOS and macOS. - The Flutter engine's `PathUtils.getDataDirectory` API on Android. Throws a [MissingPlatformDirectoryException] if the system is unable to provide the directory." />
|
|
<item value="station location status locate fail" />
|
|
<item value="Arguments for the call. Consider using arguments() for cases where a particular run-time type is expected. Consider using argument(String) when that run-time type is Map or JSONObject." />
|
|
<item value="the arguments, a value supported by the channel's message codec. Possibly, null." />
|
|
<item value="Returns the modular multiplicative inverse of this integer modulo [modulus]. The [modulus] must be positive. It is an error if no modular inverse exists." />
|
|
<item value="The mode of the file system object. Permissions are encoded in the lower 16 bits of this number, and can be decoded using the [modeString] getter." />
|
|
<item value="Starts a process and runs it non-interactively to completion. The process run is [executable] with the specified [arguments]." />
|
|
<item value="A named channel for communicating with platform plugins using event streams. Stream setup requests are encoded into binary before being sent, and binary events and errors received are decoded into Dart values. The [MethodCodec] used must be compatible with the one used by the platform plugin. This can be achieved by creating an [EventChannel] counterpart of this channel on the platform side. The Dart type of events sent and received is `dynamic`, but only values supported by the specified [MethodCodec] can be used. The logical identity of the channel is given by its name. Identically named channels will interfere with each other's communication. See: <https:flutter.devtoplatform-channels>" />
|
|
<item value="Creates an [EventChannel] with the specified [name]. The [codec] used will be [StandardMethodCodec], unless otherwise specified. Neither [name] nor [codec] may be null. The default [ServicesBinding.defaultBinaryMessenger] instance is used if [binaryMessenger] is null." />
|
|
<item value="Handler of stream setup and teardown requests. Implementations must be prepared to accept sequences of alternating calls to onListen(Object, EventChannel. EventSink) and onCancel(Object). Implementations should ideally consume no resources when the last such call is not onListen. In typical situations, this means that the implementation should register itself with platform-specific event sources onListen and deregister again onCancel." />
|
|
<item value="Event callback. Supports dual use: Producers of events to be sent to Flutter act as clients of this interface for sending events. Consumers of events sent from Flutter implement this interface for handling received events (the latter facility has not been implemented yet)." />
|
|
</histories>
|
|
<option name="languageScores">
|
|
<map>
|
|
<entry key="CHINESE_SIMPLIFIED" value="48" />
|
|
<entry key="ENGLISH" value="49" />
|
|
</map>
|
|
</option>
|
|
</component>
|
|
</application> |