<itemvalue="How wide to make edges drawn when [style] is set to [PaintingStyle.stroke]. The width is given in logical pixels measured in the direction orthogonal to the direction of the path. Defaults to 0.0, which correspond to a hairline width."/>
<itemvalue="A [Comparator] may compare objects as equal (return zero), even if they are distinct objects. The sort function is not guaranteed to be stable, so distinct objects that compare as equal may occur in any order in the result: ```dart final numbers = <String>['one', 'two', 'three', 'four']; numbers.sort((a, b) => a.length.compareTo(b.length)); print(numbers); [one, two, four, three] OR [two, one, four, three]"/>
<itemvalue="The default [List] implementations use [Comparable.compare] if [compare] is omitted. ```dart final numbers = <int>[13, 2, -11, 0]; numbers.sort(); print(numbers); [-11, 0, 2, 13] ``` In that case, the elements of the list must be [Comparable] to each other."/>
<itemvalue="Sorts this list according to the order specified by the [compare] function. The [compare] function must act as a [Comparator]. ```dart final numbers = <String>['two', 'three', 'four']; Sort from shortest to longest. numbers.sort((a, b) => a.length.compareTo(b.length)); print(numbers); [two, four, three]"/>
<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="A wrapper widget that will recognize the start of a drag operation by looking for a long press event. Once it is recognized, it will start a drag operation on the wrapped item in the reorderable list."/>
<itemvalue="Translucent targets both receive events within their bounds and permit targets visually behind them to also receive events."/>
<itemvalue="Opaque targets can be hit by hit tests, causing them to both receive events within their bounds and prevent targets visually behind them from also receiving events."/>
<itemvalue="Targets that defer to their children receive events within their bounds only if one of their children is hit by the hit test."/>
<itemvalue="Set the initial offset at the position where the first down event was detected."/>
<itemvalue="Set the initial position at the position where this gesture recognizer won the arena."/>
<itemvalue="Creates a listener for an drag following a long press event over the given child widget. This is most commonly used to wrap an entire list item in a reorderable list."/>
<itemvalue="The `wasSynchronouslyLoaded` argument specifies whether the image was available synchronously (on the same [rendering pipeline frame](renderingRendererBindingdrawFrame.html) as the `Image` widget itself was created) and thus able to be painted immediately. If this is false, then there was one or more rendering pipeline frames where the image wasn't yet available to be painted. For multi-frame images (such as animated GIFs), the value of this argument will be the same for all image frames. In other words, if the first image frame was available immediately, then this argument will be true for all image frames."/>
<itemvalue="The `child` argument contains the default image widget and is guaranteed to be non-null. Typically, this builder will wrap the `child` widget in some way and return the wrapped widget. If this builder returns `child` directly, it will yield the same result as if [Image.frameBuilder] was null. The `frame` argument specifies the index of the current image frame being rendered. It will be null before the first image frame is ready, and zero for the first image frame. For single-frame images, it will never be greater than zero. For multi-frame images (such as animated GIFs), it will increase by one every time a new image frame is shown (including when the image animates in a loop)."/>
<itemvalue="Signature used by [Image.frameBuilder] to control the widget that will be used when an [Image] is built."/>
<itemvalue="{@tool dartpad} The following sample demonstrates how to use this builder to implement an image that fades in once it's been loaded. This sample contains a limited subset of the functionality that the [FadeInImage] widget provides out of the box. See code in examplesapilibwidgetsimageimage.frame_builder.0.dart {@end-tool}"/>
<itemvalue="If a [loadingBuilder] has _also_ been specified for an image, the two builders will be chained together: the _result_ of this builder will be passed as the `child` argument to the [loadingBuilder]. For example, consider the following builders used in conjunction:"/>
<itemvalue="A builder function responsible for creating the widget that represents this image. If this is null, this widget will display an image that is painted as soon as the first image frame is available (and will appear to "pop" in if it becomes available asynchronously). Callers might use this builder to add effects to the image (such as fading the image in when it becomes available) or to display a placeholder widget while the image is loading. To have finer-grained control over the way that an image's loading progress is communicated to the user, see [loadingBuilder]."/>
<itemvalue="A builder function responsible for creating the widget that represents this image. If this is null, this widget will display an image that is painted as soon as the first image frame is available (and will appear to "pop" in if it becomes available asynchronously). Callers might use this builder to add effects to the image (such as fading the image in when it becomes available) or to display a placeholder widget while the image is loading."/>
<itemvalue="A builder function responsible for creating the widget that represents this image."/>
<itemvalue="Whether this widget should prevent other [MouseRegion]s visually behind it from detecting the pointer. This changes the list of regions that a pointer hovers, thus affecting how their [onHover], [onEnter], [onExit], and [cursor] behave. If [opaque] is true, this widget will absorb the mouse pointer and prevent this widget's siblings (or any other widgets that are not ancestors or descendants of this widget) from detecting the mouse pointer even when the pointer is within their areas. If [opaque] is false, this object will not affect how [MouseRegion]s behind it behave, which will detect the mouse pointer as long as the pointer is within their areas. This defaults to true."/>
<itemvalue="Creates a widget that forwards mouse events to callbacks. By default, all callbacks are empty, [cursor] is [MouseCursor.defer], and [opaque] is true."/>
<itemvalue="Layout behavior _See [BoxConstraints] for an introduction to box layout models._ If it has a child, this widget defers to the child for sizing behavior. If it does not have a child, it grows to fit the parent instead. {@tool dartpad} This example makes a [Container] react to being entered by a mouse pointer, showing a count of the number of entries and exits. See code in examplesapilibwidgetsbasicmouse_region.0.dart {@end-tool} See also: [Listener], a similar widget that tracks pointer events when the pointer has buttons pressed."/>
<itemvalue="A widget that tracks the movement of mice. {@youtube 560 315 https:www.youtube.comwatch?v=1oF3pI5umck} [MouseRegion] is used when it is needed to compare the list of objects that a mouse pointer is hovering over between this frame and the last frame. This means entering events, exiting events, and mouse cursors. To listen to general pointer events, use [Listener], or more preferably, [GestureDetector]."/>
<itemvalue="All list items must have a key. This example demonstrates using the [ReorderableListView.proxyDecorator] callback to customize the appearance of a list item while it's being dragged."/>
<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="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. {@tool dartpad}"/>
<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="Creates a widget that animates its position implicitly. Only two out of the three horizontal values ([left], [right], [width]), and only two out of the three vertical values ([top], [bottom], [height]), can be set. In each case, at least one of the three must be null."/>
<itemvalue="The grade (granular stroke weight) for drawing the icon. Requires the underlying icon font to support the `GRAD` [FontVariation] axis, otherwise has no effect. Variable font filenames often indicate the supported axes. Can be negative. Grade and [weight] both affect a symbol's stroke weight (thickness), but grade has a smaller impact on the size of the symbol. Grade is also available in some text fonts. One can match grade levels between text and symbols for a harmonious visual effect. For example, if the text font has a -25 grade value, the symbols can match it with a suitable value, say -25."/>
<itemvalue="See also: [fill], for controlling fill. [grade], for controlling stroke weight in a more granular way. [opticalSize], for controlling optical size. https:fonts.google.comknowledgeglossaryweight_axis"/>
<itemvalue="The stroke weight for drawing the icon. Requires the underlying icon font to support the `wght` [FontVariation] axis, otherwise has no effect. Variable font filenames often indicate the supported axes. Must be greater than 0. Defaults to nearest [IconTheme]'s [IconThemeData.weight]."/>
<itemvalue="The fill for drawing the icon. Requires the underlying icon font to support the `FILL` [FontVariation] axis, otherwise has no effect. Variable font filenames often indicate the supported axes. Must be between 0.0 (unfilled) and 1.0 (filled), inclusive. Can be used to convey a state transition for animation or interaction. Defaults to nearest [IconTheme]'s [IconThemeData.fill]. See also: [weight], for controlling stroke weight. [grade], for controlling stroke weight in a more granular way. [opticalSize], for controlling optical size."/>
<itemvalue="The size of the icon in logical pixels. Icons occupy a square with width and height equal to size. Defaults to the nearest [IconTheme]'s [IconThemeData.size]. If this [Icon] is being placed inside an [IconButton], then use [IconButton.iconSize] instead, so that the [IconButton] can make the splash area the appropriate size as well. The [IconButton] uses an [IconTheme] to pass down the size to the [Icon]."/>
<itemvalue=""/>
<itemvalue="This widget assumes that the rendered icon is squared. Non-squared icons may render incorrectly. {@tool snippet} This example shows how to create a [Row] of [Icon]s in different colors and sizes. The first [Icon] uses a [semanticLabel] to announce in accessibility modes like TalkBack and VoiceOver."/>
<itemvalue="A graphical icon widget drawn with a glyph from a font described in an [IconData] such as material's predefined [IconData]s in [Icons]. Icons are not interactive. For an interactive icon, consider material's [IconButton]. There must be an ambient [Directionality] widget when using [Icon]. Typically this is introduced automatically by the [WidgetsApp] or [MaterialApp]."/>
<itemvalue="To make sure that listeners removed during this iteration are not called, we set them to null, but we don't shrink the list right away. By doing this, we can continue to iterate on our list until it reaches the last listener added before the call to this method. To allow potential listeners to recursively call notifyListener, we track the number of times this method is called in _notificationCallStackDepth. Once every recursive iteration is finished (i.e. when _notificationCallStackDepth == 0), we can safely shrink our list so that it will only contain not null listeners."/>
<itemvalue="Call all the registered listeners. Call this method whenever the object changes, to notify any clients the object may have changed. Listeners that are added during this iteration will not be visited. Listeners that are removed during this iteration will not be visited after they are removed. Exceptions thrown by listeners will be caught and reported using [FlutterError.reportError]. This method must not be called after [dispose] has been called. Surprising behavior can result when reentrantly removing a listener (e.g. in response to a notification) that has been registered multiple times. See the discussion at [removeListener]."/>
