<itemvalue="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]."/>
<itemvalue="Creates a listener for a drag immediately following a pointer down event over the given child widget. This is most commonly used to wrap part of a list item like a drag handle."/>
<itemvalue="Draw the given picture onto the canvas. To create a picture, see [PictureRecorder]."/>
<itemvalue="If true: on desktop platforms, a drag handle is stacked over the center of each item's trailing edge; on mobile platforms, a long press anywhere on the item starts a drag. The default desktop drag handle is just an [Icons.drag_handle] wrapped by a [ReorderableDragStartListener]. On mobile platforms, the entire item is wrapped with a [ReorderableDelayedDragStartListener]. To change the appearance or the layout of the drag handles, make this parameter false and wrap each list item, or a widget within each list item, with [ReorderableDragStartListener] or [ReorderableDelayedDragStartListener], or a custom subclass of [ReorderableDragStartListener]. The following sample specifies `buildDefaultDragHandles: false`, and uses a [Card] at the leading edge of each item for the item's drag handle. {@tool dartpad} See code in examplesapilibmaterialreorderable_listreorderable_list_view.build_default_drag_handles.0.dart {@end-tool}"/>
<itemvalue="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."/>
<itemvalue="{@macro flutter.widgets.list_view.prototypeItem} final Widget? prototypeItem;"/>
<itemvalue="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]."/>
<itemvalue="This example demonstrates using the [ReorderableListView.proxyDecorator] callback to customize the appearance of a list item while it's being dragged."/>
<itemvalue="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."/>
<itemvalue="By default, on [TargetPlatformVariant.desktop] platforms each item will have a drag handle added on top of it that will allow the user to grab it to move the item. On [TargetPlatformVariant.mobile], no drag handle will be added, but when the user long presses anywhere on the item it will start moving the item. Displaying drag handles can be controlled with [ReorderableListView.buildDefaultDragHandles]."/>
<itemvalue="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._"/>
<itemvalue="A list whose items the user can interactively reorder by dragging. {@youtube 560 315 https:www.youtube.comwatch?v=3fB1mxOsqJE} This sample shows by dragging the user can reorder the items of the list. The [onReorder] parameter is required and will be called when a child widget is dragged to a new position."/>
<itemvalue="{@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."/>
<itemvalue="move toolbox to side navigator."/>
<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="emotion id"/>
<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="If [allowImplicitScrolling] is true, the [PageView] will participate in accessibility scrolling more like a [ListView], where implicit scroll actions will move to the next page rather than into the contents of the [PageView]."/>
<itemvalue="text field tap region"/>
<itemvalue="allow implicit scrolling"/>
<itemvalue="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}"/>
<itemvalue="Treat the [Viewport.cacheExtent] as a multiplier of the main axis extent."/>
<itemvalue="{@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}"/>
<itemvalue="Treat the [Viewport.cacheExtent] as logical pixels."/>
<itemvalue="usb device detach"/>
<itemvalue="Controls whether the widget's pages will respond to [RenderObject.showOnScreen], which will allow for implicit accessibility scrolling. 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. With this flag set to true, when accessibility focus reaches the end of the current page and user attempts to move it to the next element, focus will traverse to the next page in the page view."/>
<itemvalue="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)); ````"/>
<itemvalue="自定义指令"/>
<itemvalue="fatal"/>
<itemvalue="{@template flutter.widgets.pageview.viewportFraction} The fraction of the viewport that each page should occupy. Defaults to 1.0, which means each page fills the viewport in the scrolling direction. {@endtemplate}"/>
<itemvalue="with date"/>
<itemvalue="set rc action internal"/>
<itemvalue="full time"/>
<itemvalue="我在"/>
<itemvalue="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."/>
<itemvalue="有效数据"/>
<itemvalue="dust"/>
<itemvalue="amplitude"/>
<itemvalue="ssssssssss"/>
<itemvalue="64"/>
<itemvalue="hhhhhhhhhh"/>
<itemvalue="allow move the stick only in horizontal and vertical directions, not diagonal."/>
<itemvalue="absorption"/>
<itemvalue="interaction text symbol black list"/>
<itemvalue="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."/>
<itemvalue="优先级"/>
<itemvalue="If the argument [flush] is set to `true`, the data written will be flushed to the file system before the returned future completes."/>
<itemvalue="connection accepted"/>
<itemvalue="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."/>
<itemvalue="unaccepted protocol version"/>
<itemvalue="station location status locate fail"/>
<itemvalue="identifier rejected"/>
<itemvalue="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."/>
<itemvalue="broker unavailable"/>
<itemvalue="the arguments, a value supported by the channel's message codec. Possibly, null."/>
<itemvalue="bad username or password"/>
<itemvalue="Returns the modular multiplicative inverse of this integer modulo [modulus]. The [modulus] must be positive. It is an error if no modular inverse exists."/>
<itemvalue="not authorized"/>
<itemvalue="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."/>
<itemvalue="none specified"/>
<itemvalue="Starts a process and runs it non-interactively to completion. The process run is [executable] with the specified [arguments]."/>
<itemvalue="emoticon"/>
<itemvalue="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>"/>
<itemvalue="emotcion"/>
<itemvalue="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."/>
<itemvalue="get emoticon list"/>
<itemvalue="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."/>
<itemvalue="emoticon list"/>
<itemvalue="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)."/>
<itemvalue="standard"/>
<itemvalue="Consumes a successful event. Params: event – the event, possibly null."/>
<itemvalue="calibrate"/>
<itemvalue="get parity"/>
<itemvalue="Teleoperation"/>
<itemvalue="get baud"/>
<itemvalue="start teleoperation"/>
<itemvalue="a result (possibly null), on successful invocation; a [PlatformException], if the invocation failed in the platform plugin; a [MissingPluginException], if the method has not been implemented by a platform plugin."/>
<itemvalue="Please operate the standby station to lower the robot until both feet of the robot are in full contact with the ground."/>
<itemvalue="The generic argument `T` of the method can be inferred by the surrounding context, or provided explicitly. If it does not match the returned type of the channel, a [TypeError] will be thrown at runtime. `T` cannot be a class with generics other than `dynamic`. For example, `Map<String, String>` is not supported but `Map<dynamic, dynamic>` or `Map` is."/>
<itemvalue="微笑"/>
<itemvalue="The static type of [arguments] is `dynamic`, but only values supported by the [codec] of this channel can be used. The same applies to the returned result. The values supported by the default codec and their platform-specific counterparts are documented with [StandardMessageCodec]."/>
<itemvalue="smail"/>
<itemvalue="比心"/>
<itemvalue="握手"/>
<itemvalue="bump"/>
<itemvalue="taichi"/>
<itemvalue="salute"/>
<itemvalue="rl locomotion default disable"/>
<itemvalue="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."/>
<itemvalue="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."/>
<itemvalue="A pointer that has triggered a long-press with a primary button has stopped contacting the screen."/>
</histories>
</histories>
<optionname="languageScores">
<optionname="languageScores">
<map>
<map>
<entrykey="CHINESE_SIMPLIFIED"value="40"/>
<entrykey="CHINESE_SIMPLIFIED"value="54"/>
<entrykey="ENGLISH"value="41"/>
<entrykey="ENGLISH"value="54"/>
</map>
</map>
</option>
</option>
</component>
</component>
Reference in New Issue
Block a user
Blocking a user prevents them from interacting with repositories, such as opening or commenting on pull requests or issues. Learn more about blocking a user.
debuggerx