Struct Slider 

pub struct Slider<Msg = Callback> { /* private fields */ }

A linear slider over min..=max, controlled and draggable.

Implementations

impl<Msg> Slider<Msg>

pub fn new(value: f32) -> Self

Creates a slider at the given value, over 0.0..=1.0 until range says otherwise.

pub fn active_color(self, color: Color) -> Self

The travelled part of the track; the theme’s primary otherwise. The thumb’s ring follows it unless thumb_border_color says otherwise.

pub fn inactive_color(self, color: Color) -> Self

The part of the track still to travel.

pub fn thumb_color(self, color: Color) -> Self

The thumb’s fill; white otherwise.

pub fn thumb_border_color(self, color: Color) -> Self

The ring around the thumb; the travelled track’s colour otherwise.

pub fn thumb_elevation(self, elevation: f32) -> Self

How far the thumb sits off the track at rest. Unset, the theme’s, then the reference’s 1; 0.0 casts no shadow.

pub fn pressed_thumb_elevation(self, elevation: f32) -> Self

How far it rises while it is held. Unset, the theme’s, then the reference’s 6.

pub fn range(self, min: f32, max: f32) -> Self

The travel this slider covers; 0.0..=1.0 by default.

Everything the application sees is in these units — the value it is given, the value a step lands on, what a reader is told — rather than a fraction it would have to convert back on both sides of every message. The two arguments are sorted, so a range written backwards is not a silent empty one.

The value is held inside the travel rather than rejected: a caller that lowers the ceiling under a value it already had gets the ceiling, not a panic.

pub fn divisions(self, n: usize) -> Self

Splits the travel into n steps: the value snaps to min + k·(max−min)/n, and an arrow key moves by one of them. Without this call the travel is continuous and an arrow moves by 5 %.

pub fn value_label(self, label: impl Fn(f32) -> String + 'static) -> Self

Shows a value tooltip above the thumb, formatted by label(value) — a percentage, a price, a duration. It appears on hover or focus and reserves the room above the track, so a slider that has one is taller than one that does not.

pub fn width(self, width: f32) -> Self

Width, in logical pixels.

pub fn on_change<R: IntoMsg<Msg>>( self, on_change: impl Fn(f32) -> R + 'static, ) -> Self

A closure producing a message from the new value (0..=1).

pub fn on_change_start<R: IntoMsg<Msg>>( self, on_start: impl Fn(f32) -> R + 'static, ) -> Self

Sent once, when a drag begins — before the first on_change, with the value the press landed on.

With on_change_end it brackets the stream. on_change fires on every pixel of the movement, so an application that seeks a video, writes a setting to disk or asks the network on each of them does it sixty times a second; the bracket is what lets it show a preview while the finger is down and commit when it lifts.

pub fn on_change_end<R: IntoMsg<Msg>>( self, on_end: impl Fn(f32) -> R + 'static, ) -> Self

Sent once, when the drag ends — after the last on_change, with the value it settled on.

A press that never moved still gets one: it changed the value, and a caller waiting for the release would otherwise never be told it happened.

pub fn enabled(self, enabled: bool) -> Self

Whether the slider can be moved. Disabled it is inert — it takes no drag and answers no key — and it still shows where it is set.

A slider is the control that makes the point of crate::disabled’s contract: greying it out while it still answered a drag would leave it inert only to the gesture nobody was using on it.

Trait Implementations

impl<Msg> Widget<Msg> for Slider<Msg>

fn style(&self) -> Style

Layout style (handed to frus-layout).

fn children(&self) -> &[Box<dyn Widget<Msg>>]

The widget’s children (possibly empty).

fn paint(&self, bounds: Rect, status: Status, theme: &Theme, scene: &mut Scene)

Paints the widget’s own decoration, according to its status (hover / focus / cursor / selection) and the current theme.

fn on_click(&self) -> Option<Msg>

Message to emit on click (None = not clickable).

fn semantics(&self) -> Option<SemanticsProperties>

The widget’s accessibility annotation (role, label, value, state), exposed to assistive technologies through the AccessKit tree. None = no semantics of its own (a layout container — its children, though, may have some). See frus_core::SemanticsProperties.

fn draggable(&self) -> bool

If true, the widget responds to pointer dragging (sliders, handles).

fn focusable(&self) -> bool

If true, the widget can take keyboard focus (click or Tab).

fn on_key(&self, key: &Key) -> KeyResponse<Msg>

Key received while bubbling leaf→root: the focused widget gets it first, then each ancestor as long as the response is Ignored. (E.g. an OverlayPortal consumes Escape to close itself.)

fn on_drag(&self, fraction: f32) -> Option<Msg>

Message produced while dragging, fraction being the relative horizontal position (0.0..=1.0) within the widget’s bounds.

fn on_drag_start(&self, fraction: f32) -> Option<Msg>

Message produced when a value drag begins — on the press, before the first on_drag.

fn on_drag_end(&self, fraction: f32) -> Option<Msg>

Message produced when a value drag ends — on the release, with the fraction the pointer finished on.

fn opaque(&self) -> bool

Whether a press that lands on this widget and on nothing inside it stops here.

fn key(&self) -> Option<u64>

Stable identity key (independent of the position among siblings). None = positional identity. See crate::Keyed.

fn debug_name(&self) -> &'static str

Short name of the widget — for the inspector and diagnostic dumps. Defaults to the name of the concrete type, without module path or generics (each implementation gets its own monomorphised copy of this default body). Transparent wrappers (Box, crate::Keyed…) delegate to their content.

fn describes(&self) -> Option<Description>

What this widget says about its child’s subtree, when it knows something the child cannot know about itself — the crate::Semantics wrapper, and nothing else so far.

fn on_edit(&self, _edit: &mut Edit, _key: &Key) -> Option<Msg>

Applies a key to the focused widget: mutates the edit state (cursor/selection) and returns a message if the value changes.

fn positional_click( &self, _local_x: f32, _local_y: f32, _width: f32, _height: f32, ) -> Option<Msg>

Positional click: a message emitted according to where the click landed (local coordinates from the widget’s top-left corner, within the width × height box), taking priority over on_click. For clickable sub-regions — e.g. the suffix icon of a crate::TextField (clear / reveal) or a chart point (milestone 221). None (the default) = no sub-region; the shell falls back to on_click.

fn cursor_icon( &self, _local_x: f32, _local_y: f32, _width: f32, _height: f32, ) -> Option<Cursor>

Shape of the system cursor wanted at the local position (local_x, local_y) inside the widget’s width × height box (milestone 205): Some(Cursor::Pointer) over a clickable sub-region (a suffix icon…), None (the default) = no opinion, the shell keeps the default cursor. Does not affect clicking; this is purely the pointer’s appearance on hover.

fn cursor_at( &self, _local_x: f32, _local_y: f32, _width: f32, _scroll_cursor: usize, ) -> Option<usize>

Cursor index matching a local position (px from the widget’s top-left corner) — for placing the caret on click. local_y picks the line in a multi-line field (ignored on a single line).

fn text_metrics( &self, _width: f32, _cursor: usize, ) -> Option<(f32, f32, f32, f32)>

SingleChildScrollView metrics of a multi-line field, for a widget width and a cursor: (content height, visible box height, caret top, caret height), in content space (px). The shell uses them to register the scrollable region and to keep the caret in view. None otherwise.

fn text_viewport(&self, _rect: Rect) -> Option<Rect>

Frame (input box) of a multi-line field within its rect — the area where the text scrolls, below the label. Used to place the scrollbar and the scrollable region exactly on the box. None otherwise.

fn caret_vertical( &self, _width: f32, _cursor: usize, _down: bool, _page: bool, _goal_x: Option<f32>, ) -> Option<(usize, f32)>

Moves the caret vertically in a multi-line field and returns (new index, visual column used).

fn selected_text(&self, _edit: &Edit) -> Option<String>

The currently selected text (for copy/cut).

fn text_value(&self) -> Option<&str>

The field’s whole value, if this widget is a text field — to give the IME its input context (suggestions). None otherwise.

fn replace_value(&self, _value: String) -> Option<Msg>

The message that puts value in this field: the one typing would have produced, for a value the framework restores rather than the user typing it.

fn word_at(&self, _index: usize) -> Option<(usize, usize)>

Range (start, end) of the word around the given index (for double-click).

fn selection_handles( &self, _width: f32, _edit: &Edit, _scroll_y: f32, ) -> Option<[SelectionHandle; 2]>

The two handles of the selection in edit, start then end, for a field width wide whose content is scrolled down by scroll_y — where they are painted, and so where a finger takes them. None when there is no selection, or this is not a text field.

fn shortcut_bindings(&self) -> &[(KeyStroke, Intent)]

Keystrokes this subtree binds to intents — see crate::Shortcuts.

fn shortcut_callbacks(&self) -> &[(KeyStroke, Msg)]

Keystrokes this subtree binds straight to messages — see crate::CallbackShortcuts.

fn action_bindings(&self) -> &[(Intent, Msg)]

Intents this subtree answers — see crate::Actions.

fn action_listeners(&self) -> &[(Intent, Msg)]

Intents this subtree watches without answering — see crate::ActionListener.

fn on_keystroke(&self) -> Option<Rc<dyn Fn(KeyStroke) -> Option<Msg>>>

Every keystroke reaching this subtree, handed to a closure — see crate::KeyboardListener. None (the default) is not a listener.

fn descendants_focusable(&self) -> bool

If false, nothing inside this subtree can take focus — the reference’s ExcludeFocus. A dimmed panel behind a sheet is still drawn and still measured; it simply stops being somewhere Tab can land.

fn focus_skip_traversal(&self) -> bool

If true, this subtree’s focus stops are skipped by Tab while remaining focusable by a click — the reference’s ExcludeFocusTraversal. The two are separate questions: a toolbar button may be reachable with the pointer and still not belong in the keyboard’s order.

fn focus_order(&self) -> Option<f32>

A traversal order for this subtree’s focus stops, smallest first — the reference’s NumericFocusOrder. None leaves them in tree order, which is where everything sits until someone says otherwise.

fn focus_group(&self) -> bool

If true, this subtree is a traversal group: an order set inside it is resolved among its own members and nowhere else, so a reordered dialog does not reshuffle the page behind it.

fn autofill_hints(&self) -> &[AutofillHint]

What this field is for, so the platform can fill it in — see AutofillHint. Empty (the default) is a field that takes no part in autofill at all.

fn autofill_group(&self) -> bool

If true, this subtree’s fields are one form — the reference’s AutofillGroup. A service shown a password with no username beside it has nothing to save the pair under.

fn draws_own_focus(&self) -> bool

If true, the widget draws its focus indicator itself (the driver then does not stroke the generic ring). E.g. TextField.

fn on_drag_delta(&self, _dx: f32) -> Option<Msg>

Message produced by a horizontal drag expressed as a delta: dx is the movement (logical px) since the last event. For handles that accumulate (column resizing), unlike on_drag (an absolute fraction, e.g. a slider). The shell tries it before on_drag; a widget implements only one of the two.

fn hero_tag(&self) -> Option<u64>

If this widget is a shared element, its tag. Two heroes with the same tag on the two sides of a route transition are one thing in two places. See crate::Hero.

fn drag_payload(&self) -> Option<u64>

If this widget can be picked up and dropped elsewhere, what it carries. See crate::Draggable.

fn drag_needs_long_press(&self) -> bool

Does this item lift on a long press rather than on the first movement? The answer inside a scrollable, where a plain drag belongs to the scroll.

fn drag_ghost_opacity(&self) -> f32

How solid the item left behind looks while a copy of it is being dragged.

fn on_dropped(&self, _accepted: bool) -> Option<Msg>

Message sent when a drag of this item ends, true if a target took it.

fn drop_zone(&self) -> bool

Is this widget a drop target? See crate::DragTarget.

fn accepts_drag(&self, _payload: u64) -> bool

Would this target take payload? Only asked of a drop target.

fn on_drop(&self, _payload: u64) -> Option<Msg>

Message sent when an accepted item is dropped on this target.

fn reorder_index(&self) -> Option<usize>

If this widget is a reorderable header, its column index. The shell uses it to identify the source column (on press) and the target column (under the pointer on release) of a reordering drag.

fn on_reorder(&self, _to: usize) -> Option<Msg>

Message emitted when this header (the source) is dropped on column to. The widget knows its own index and the on_reorder(from, to) callback.

fn reorder_axis(&self) -> ReorderAxis

Movement axis of this reorderable (default ReorderAxis::Horizontal): the shell orients the drag preview (ghost + insertion indicator) accordingly. Kanban cards return ReorderAxis::Vertical.

fn reorder_inserts(&self) -> bool

Is a horizontal reorderable dropped between its neighbours, like a list’s row, rather than into the place of the one under the pointer, like a table’s column? false by default, which is the table.

fn reorder_draggable(&self) -> bool

Can this reorderable be picked up as a drag source? true by default for every reorderable. A target-only slot — the drop zone at the end of a Kanban column — returns false: a card can be dropped there, not lifted from it (otherwise the drag would raise an empty ghost that moves nothing).

fn reorder_droppable(&self) -> bool

Can this reorderable be dropped onto? true by default, and the mirror image of reorder_draggable: a source-only grip — a list row’s drag handle — returns false.

fn reorder_announcement(&self, _to: usize) -> Option<String>

What to say to a screen reader once this reorderable has been moved to to — the spoken counterpart of the ghost, for someone who cannot see it land.

fn announce(&self) -> Option<String>

Text to announce to the screen reader when this widget is activated (mouse click or Enter/Space) — a live region reads it out loud. Describes the effect the activation produced (“Sorted by Name ascending”, “All rows selected”), for the blind user who cannot perceive the visual change. None = nothing to announce (the default).

fn stack(&self) -> bool

If true, the widget is a stack: its children are superimposed layers (the same box), rendered in order (the last one on top).

fn continuous(&self) -> bool

If true, the widget animates continuously (driven by time, not by a target): the framework keeps redrawing. E.g. CircularProgressIndicator.

fn repaint_boundary(&self) -> bool

If true, this widget is a repaint boundary: its subtree is cached (primitives + interaction maps) and reused as is as long as its geometry and the interaction state of its descendants do not change — a widget animating elsewhere no longer forces it to repaint. See crate::Container::repaint_boundary and paintcache.rs.

fn scroll_content(&self) -> Option<&dyn Widget<Msg>>

If the widget is a scrollable container, returns its content.

fn virtual_list(&self, _viewport: Size) -> Option<VirtualList<'_, Msg>>

If the widget is a virtualised list, returns its description (item count, height, factory). Only the visible items are built.

fn page_view(&self) -> Option<PagedView<'_, Msg>>

If the widget is a paged view, returns its description (page count, axis, factory). Like a virtualised list, only the visible pages are built.

fn on_page_changed(&self, _page: usize) -> Option<Msg>

Message sent by a paged view when the page on screen changes.

fn on_scroll(&self, _position: ScrollPosition) -> Option<Msg>

Message sent by a scroll region when its offset changes — the reading half of crate::ScrollPosition.

fn scroll_grain(&self) -> f32

How far this region must move before it says so again, in pixels; 0 — the default — reports every change.

fn intrinsic(&self) -> Option<(IntrinsicAxis, Option<f32>)>

If the widget takes one axis from its content’s preferred size, returns that axis and the step its measurement is rounded up to. See crate::Intrinsic.

fn overflow_box(&self) -> Option<Overflow>

If the widget lays its child out to constraints of its own, which the child may exceed, returns them. See crate::OverflowBox.

fn constraints_transform(&self) -> Option<ConstraintsTransform>

The box this widget gives its child as a function of the box it was offered, with the child laid out in it separately and the box then sized to what came back. None — the default — means the child shares this node’s layout, as everything ordinary does. See crate::ConstraintsTransformBox.

fn layout_builder(&self) -> Option<&dyn Fn(Size) -> Box<dyn Widget<Msg>>>

If the widget builds its content from its actual box, returns the size → widget factory. The content is built on the fly: no retained state and no overlay (like a virtualised list item).

fn scroll_overlay(&self) -> Option<&OverlayBuilder<Msg>>

If the widget draws something over its scroll region, returns the offset → overlay factory. See crate::ScrollOverlay.

fn scroll_axis(&self) -> Axis

SingleChildScrollView axis (or axes), for a scrollable container.

fn scroll_physics(&self) -> Option<ScrollPhysics>

The edge and fling behaviour of a scrollable container, when this widget wants one in particular. None — the usual answer — leaves the choice to the application, which defaults to what the platform does.

fn scrollbars(&self) -> Option<Scrollbars>

Whether this area draws a scrollbar, when it wants its own answer rather than the application’s. None — the default — follows the application, which follows the platform. See crate::Scrollbars.

fn thumb_visibility(&self) -> Option<bool>

Keep this area’s scrollbar on screen, instead of letting it fade away when the area stops moving (scrollbar.dart:214).

fn ime(&self) -> Ime

What the software keyboard should be, when this widget is the focused editable one.

fn overlay(&self) -> Option<(&dyn Widget<Msg>, Placement)>

If the widget is a portal, returns its floating content and its placement.

fn overlay_dismiss(&self) -> Option<Msg>

Message emitted when the scrim of a modal is clicked (dismissal), if any.

fn overlay_scrim(&self, _theme: &Theme) -> Option<Color>

The colour of the scrim behind this widget’s modal overlay, when it wants one in particular. None — the usual answer — leaves it to the scheme’s scrim role at the framework’s own opacity.

fn overlay_traps_focus(&self) -> bool

If true, this widget’s anchored overlay (a menu…) traps focus: Tab and the arrow keys cycle within its focusables while it is open (the keyboard pattern of menus). Modal (scrimmed) overlays already trap by default; a tooltip or an autocomplete list (focus stays on the field) do not. Default: false.

fn anim_target(&self) -> Option<f32>

Target of the widget’s own animated value (e.g. 1.0 for a switch that is on, 0.0 for off). The runtime drives the retained value towards this target and hands it back through Status::value. None = no animated value.

fn anim_transform(&self) -> Option<TransformValues>

Target transform of an animated one (Transform::animated): the runtime tweens the scales and the turn through anim_duration/anim_curve and hands the interpolated value back through Runtime::anim_transform, which the paint walk reads in place of the static transform_scale/transform_rotate. None = the transform does not move.

fn anim_duration(&self) -> f32

Duration (seconds) of the animated value’s transition (anim_target). Default: the framework’s standard duration.

fn anim_curve(&self) -> Curve

Easing curve of the animated value’s transition (anim_target). Default: linear.

fn opacity_group(&self) -> Option<f32>

If the widget is an opacity group, returns the (target) opacity [0,1] applied to its whole subtree as one: the paint walk wraps its primitives in a composited layer at that opacity — no double-blending where they overlap. None = not a group. Combined with anim_target, the opacity animates (a group fade).

fn anim_color(&self) -> Option<Color>

Target background colour of an animated background (Container::animated_color): the runtime tweens it (through anim_duration/anim_curve) and hands the interpolated value back in Status::anim_color. None = no animated colour.

fn anim_size(&self) -> Option<Size>

Target size of an animated size (Container::animated_size): the runtime tweens it (through anim_duration/anim_curve) and the interpolated size is injected at layout (see effective_style). None = fixed size.

fn anim_radius(&self) -> Option<BorderRadius>

Target corner radius of an animated radius (Container::animated_radius): the runtime tweens it and hands the interpolated value back in Status::anim_radius. None = fixed radius.

fn anim_padding(&self) -> Option<Insets>

Target padding of an animated padding (Container::animated_padding): the runtime tweens it and the interpolated padding is injected at layout (see effective_style). None = fixed padding.

fn anim_offset(&self) -> Option<(f32, f32)>

The pair of fractions this node’s offset rule is made of, animated: an alignment’s two fractions, or a slide’s. None — the default — leaves the rule reading the widget’s own numbers.

fn anim_pins(&self) -> Option<Positioning>

Target pins of an animated stack layer (crate::AnimatedPositioned): the runtime tweens them and the interpolated pins are read where the stack lays its layers out. None — the default — leaves Widget::positioned alone.

fn anim_fractions(&self) -> Option<(Option<f32>, Option<f32>)>

Target fractions of an animated share of the parent (FractionallySizedBox::animated), as (width factor, height factor): the runtime tweens them and the interpolated pair is injected at layout (see effective_style), like the size and the padding. None = fixed factors.

fn anim_text_style(&self) -> Option<TextStyle>

Target text style an animated subtree is heading for (AnimatedDefaultTextStyle). None = the subtree inherits whatever it inherits.

fn alignment_geometry(&self) -> Option<AlignmentGeometry>

Alignment of the single child within the box: the walk offsets the child through the free space according to the alignment’s fractions, resolved against the reading direction (physical or directional — see frus_core::AlignmentGeometry). Being continuous, a Tween<Alignment> read in view() slides the child. None = default flex placement.

fn transform_translate(&self) -> Option<(f32, f32)>

Paint offset (dx, dy) applied to the widget’s whole subtree: the render and the hit-test are offset without touching layout (siblings do not move, the child may overflow its box). Continuous → a Tween read in view() slides the subtree. None = no offset. See crate::Transform.

fn translate_fraction(&self) -> Option<(f32, f32)>

Paint offset as a fraction of the child’s own size (fx, fy): (0.5, 0.0) slides the subtree half its own width to the right. Added to Widget::transform_translate, and offsetting the render and the hit-test the same way, without touching layout. None = no offset.

fn transform_scale(&self) -> Option<(f32, f32, Alignment)>

Paint scaling (sx, sy, pivot) of the whole subtree: the render and the hit-test are scaled — per axis — around the pivot (a frus_core::Alignment within the box), without touching layout. Stays axis-aligned (a scaled rect is still a rect). None = no scaling. See crate::Transform.

fn transform_rotate(&self) -> Option<(f32, Alignment)>

Paint rotation (angle, pivot) of the whole subtree: the subtree is painted rotated by angle radians (clockwise) around the pivot (a frus_core::Alignment within the box), without touching layout. The render goes through a rotated composited layer; the hit-test counter-rotates the point. None = no rotation. See crate::Transform.

fn clip_shape(&self) -> Option<ClipShape>

Shape clip of the whole subtree: the paint walk wraps its primitives in a composited layer whose frus_core::ClipShape (rounded corners, ellipse) modulates the alpha — whatever falls outside the shape is erased, edges antialiased. None = no shape clip. See crate::ClipRRect, crate::ClipOval.

fn style_themed(&self, _theme: &Theme) -> Style

The widget’s style once the theme has had its say — the layout half of the caller ?? theme ?? framework chain.

fn theme_override(&self, _inherited: &Theme) -> Option<Box<Theme>>

The theme this widget imposes on itself and its subtree, given the one it inherits. None — the default — means “whatever came down from above”, which is what every widget but crate::Themed answers.

fn media_override(&self, _inherited: MediaQuery) -> Option<MediaQuery>

The surface this widget imposes on itself and its subtree, given the one it inherits. None — the default — means “whatever came down from above”, which is what every widget but MediaScope answers.

fn scaffold_override(&self) -> Option<ScaffoldInfo>

The shell this widget imposes on its subtree: what a Scaffold knows about itself and its slots do not.

fn build_themed(&self, _theme: &Theme)

Builds this widget’s subtree from the ambient theme, for the widgets that defer that decision — see ThemeBuilder. Does nothing by default, which is what all but a handful of widgets want.

fn build_in(&self, _id: WidgetId, _runtime: &Runtime, theme: &Theme)

Self::build_themed, for the few widgets that also need who they are and what the frame remembers to compose their subtree. An AnimatedSwitcher keeps what it is letting go of in the runtime, under its own identity, and that is reachable nowhere else before its children are read.

fn expand(&self, _id: WidgetId, _runtime: &Runtime, _theme: &Theme)

Builds what this node stands for, before anything else is asked of it.

fn switches(&self) -> bool

Whether this node is an AnimatedSwitcher. An identity is a position, so a switcher and the widget that comes to stand where it stood have the same one: this is how the runtime tells the switcher still being there from its having gone, and forgets what it kept for it.

fn system_ui_style(&self) -> Option<SystemUiOverlayStyle>

What the system bars over this widget should look like — see AnnotatedRegion. None for every widget but that one; a transparent wrapper forwards it, or a keyed region would say nothing.

fn ink(&self, _theme: &Theme) -> Option<InkStyle>

If the widget takes ink — the splash a tap leaves on a material surface — the shape and colour to splash in. None = no ink, which is the default: a widget has to ask.

fn foreground(&self, _theme: &Theme) -> Option<BoxDecoration>

A decoration painted over this widget’s children rather than behind them: the reference’s foregroundDecoration.

fn layer_filter(&self, _cx: FilterContext) -> Option<LayerFilter>

The pixel effects this widget applies to its whole subtree: a blur, a colour transform, a mask, or a filter over what is painted underneath. The paint walk drains the subtree into a composited layer and hands the filter to the renderer, exactly as it does for an opacity group or a shape clip.

fn backdrop_group(&self) -> bool

true when this widget is a backdrop group: the backdrops below it that ask to be shared are filtered once between them. See crate::BackdropGroup.

fn text_baseline(&self, _theme: &Theme) -> Option<f32>

The widget’s own text baseline: the distance from the top of its box down to the line its letters sit on. None — the default — means this widget has no text of its own, and whatever is inside it answers instead.

fn ignores_baseline(&self) -> bool

true when this subtree should be left out of a parent’s baseline alignment: it has a baseline, and the parent is to pretend it does not. An icon beside a label, where the label is what the row should line up on. See crate::IgnoreBaseline.

fn fill_axes(&self, _theme: &Theme) -> FillAxes

The axes this widget asks to fill: on each, it takes the room the parent leaves it rather than shrink-wrapping its children. FillAxes::NONE means shrink-wrap on both.

fn main_axis_floor(&self, _theme: &Theme) -> Option<f32>

The width below which this widget must not be squeezed when its parent runs horizontally — a line of text that would rather run past the end of a row than be folded into a column of single words. None means squeeze freely.

fn tile_shape(&self) -> Option<f32>

If this container gives all of its children the shape of a tile, the width / height ratio to impose on each of them. None = each child keeps its own shape.

fn positioned(&self) -> Option<Positioning>

If this is a layer pinned against its crate::Stack’s edges (crate::Positioned), what it pins. None = an ordinary layer, sized and placed by the stack’s own fit and alignment.

fn stack_loose(&self) -> bool

Whether this stack sizes its unpinned layers loosely — asking each what it would like to be — rather than handing each of them the whole box. See crate::StackFit. Meaningless unless Widget::stack is true.

fn stack_visible(&self) -> Option<usize>

Which layer of this stack is shown: the one at that index paints and takes input, and every other one is laid out and then silenced — not drawn, not clickable, not read out. None, the default, shows all of them.

fn keep_visible(&self, _size: Size, _theme: &Theme) -> Option<KeepVisible>

The box this widget asks the scroll region around it to keep in view, in its own coordinates, with a key naming which box it is.

fn scroll_reverse(&self) -> bool

Whether this scrollable runs from the far end (crate::SingleChildScrollView::reverse): the content is anchored to the end of the viewport and offsets are counted from there. Meaningless unless Widget::scroll_content is Some.

fn scroll_padding(&self) -> Insets

The insets a scrollable area puts around its content, inside the viewport.

fn baseline_target(&self) -> Option<f32>

If the widget positions its child by the child’s baseline (crate::Baseline), the distance from the top of this box at which that baseline should land. None = not a baseline box.

fn clip_path(&self) -> Option<&Path>

If the widget clips its child to an arbitrary path (ClipPath), returns the path in local coordinates (origin at the box’s top-left corner). The walk offsets it to the screen and wraps it in a layer whose mask (the path) erases the outside. Takes priority over Widget::clip_shape. None = no path clip. See crate::ClipPath.

fn dismissible(&self) -> Option<DismissSpec>

If the widget is a dismissible item (crate::Dismissible), its configuration for this frame. The shell gives a mostly-sideways drag on it to the dismissal and a mostly-up-and-down one to the enclosing scrollable. None = not dismissible.

fn on_dismissed(&self, _direction: DismissDirection) -> Option<Msg>

The message a dismissed item dispatches, once it has flown out and its gap has closed. None = the swipe is shown but removes nothing.

fn sheet(&self) -> Option<&SheetSpec>

If the widget is the moving panel of a crate::DraggableScrollableSheet, its configuration for this frame. The layout makes it as tall as the retained height, and the shell shares a finger on it between the sheet and the scroll areas inside. None = not a sheet.

fn on_sheet_dismissed(&self) -> Option<Msg>

The message a sheet dispatches once it has been lowered to nothing. None = it cannot be dismissed, or says nothing when it is.

fn refresh(&self) -> Option<RefreshSpec>

If the widget is a refresh area (crate::RefreshIndicator), its configuration for this frame. Any scrollable inside it routes the movement its physics refuses at the top edge into the pull, instead of into the overscroll glow. None = not a refresh area.

fn on_refresh(&self) -> Option<Msg>

The message a refresh area dispatches when an armed pull is released. None = the pull is shown but asks for nothing, which is what an area still waiting for its on_refresh looks like.

fn barrier(&self) -> Option<ModalBarrier>

What the widget withholds from the frame on behalf of its whole subtree: input targets, primitives, accessibility nodes. The walk visits the subtree normally and then discards whatever it added to the selected registries, so a target registered deep inside is caught just as surely as one at the top. None = nothing withheld (the default). See crate::ModalBarrier, crate::IgnorePointer, crate::AbsorbPointer, crate::Visibility, crate::ExcludeSemantics.

fn interactive(&self) -> Option<(f32, f32)>

If the widget is an interactive viewport (InteractiveViewer), returns its scale bounds (min, max). The paint walk renders its child in a transformed layer (retained scale + translation, clipped to the viewport); the shell routes drag → pan and wheel/pinch → zoom. None = not an interactive viewport. See crate::InteractiveViewer.

fn fitted(&self) -> Option<BoxFit>

If the widget fits its child to its box (FittedBox), returns the frus_core::BoxFit: the walk measures the child at its natural size, scales it according to the fit and centres it (composited layer, hit-test through M⁻¹). None = not a fitter. See crate::FittedBox.

fn rotated_quarter_turns(&self) -> Option<i32>

If the widget rotates its child by quarter turns (RotatedBox), returns the number of quarters. Unlike Transform, this affects layout: the box swaps its dimensions for an odd number. None = not a RotatedBox. See crate::RotatedBox.

fn navigator(&self) -> Option<(f32, bool)>

If the widget is a screen navigator, returns (progress, push?). Its children ([screen] or [outgoing, incoming]) are rendered full-window with a sliding transition.

fn navigator_clips(&self) -> bool

Whether a navigator clips its pages to its own box. true, which is the reference’s default (Clip.hardEdge) and the only sane one: a screen sliding in comes from outside the box and has to stop at its edge.

fn navigator_retained(&self) -> usize

How many of a navigator’s first children are kept but not shown: the pages under the one on show. They are built, so what their components hold survives, and they are not laid out, drawn or given input. 0, the default, is a navigator that shows every page it holds.

fn on_long_press(&self) -> Option<Msg>

Message emitted by a long press (a press held ~500 ms without movement). The long press pre-empts the click: the release that follows does not emit on_click.

fn measure(&self, _theme: &Theme) -> Option<MeasureFn<'_>>

Measure under constraints: for a widget whose size depends on the space offered (a paragraph that wraps…), returns the closure wired into taffy. None = size fixed by style(). Contract: must be Some if and only if Widget::measure_key is.

fn measure_key(&self, _theme: &Theme) -> Option<u64>

Fingerprint of the content Widget::measure depends on (text, style…), mixed into the relayout fingerprint: without it, two different contents with the same style would be conflated by the cache and would keep a stale geometry. Contract: Some if and only if measure() is.