Struct Roller 

pub struct Roller<'a, C: PixelColor, M: Clone> { /* private fields */ }

Vertical wheel / drum selector.

Renders its options as a vertically scrollable drum with a fixed center highlight band. The host owns the ScrollState and the selected index; the roller reads the state, draws, and emits messages.

Implementations

impl<'a, C: PixelColor + 'a, M: Clone + 'a> Roller<'a, C, M>

pub fn new() -> Self

Create an empty roller. Supply options via Roller::options or Roller::option, and the host state via Roller::scroll_state. Position and size are assigned by the parent container via arrange.

pub fn options(self, options: &[&str]) -> Self

Replace all options from a slice of string slices.

pub fn option(self, label: impl Into<String>) -> Self

Append a single option label.

pub fn scroll_state(self, state: &ScrollState) -> Self

Supply the host-owned ScrollState read this frame.

pub fn selected(self, index: usize) -> Self

The host’s currently selected option index. Used to colour the centered row at rest before any scroll has happened.

pub fn id(self, id: WidgetId) -> Self

Set a stable id so this roller can participate in focus traversal.

pub fn item_height(self, height: u32) -> Self

Pixel height of one option row (default 36).

pub fn visible_count(self, count: u32) -> Self

Number of rows shown in the viewport (default 5). Kept odd so exactly one row sits under the highlight band.

pub fn font(self, font: &'a MonoFont<'a>) -> Self

Override the option font (defaults to theme.typography.body).

pub fn width(self, width: impl Into<Length>) -> Self

Width sizing intent (height is driven by visible * item_height).

pub fn on_scroll<F>(self, f: F) -> Self

where F: Fn(ScrollMsg) -> M + 'a,

Callback mapping a ScrollMsg to the host message. Apply the message to the owned ScrollState in update().

pub fn on_select<F>(self, f: F) -> Self

where F: Fn(usize) -> M + 'a,

Callback fired with the centered option index whenever it changes (during drag, fling, or settle).

pub fn on_action<F>(self, f: F) -> Self

where F: Fn(UiAction) -> M + 'a,

Callback fired with semantic actions while the roller is focused.

impl<'a, C: PixelColor + 'a, M: Clone + 'a> Roller<'a, C, M>

pub fn centered_for( state: &ScrollState, item_height: u32, count: usize, ) -> usize

The option index currently under the highlight band for a given host ScrollState and item_height. The host calls this in its update() after applying a ScrollMsg (or after a ScrollState::tick) to learn which option is centered, without rebuilding the widget tree.

item_height must match the value configured on the widget (default: 36 pixels).

pub fn select_msg(&self, previous: usize) -> Option<M>

Build the on_select message for the currently-centered option when it differs from previous, or whenever the drum has settled to rest. Returns None if no on_select callback is set or the selection is unchanged mid-motion.

The host typically calls this from update() after applying a ScrollMsg/tick so the selection follows the drum as it spins and commits when it settles.

Trait Implementations

impl<'a, C: PixelColor + 'a, M: Clone + 'a> Default for Roller<'a, C, M>

fn default() -> Self

Returns the “default value” for a type.

impl<'a, C: PixelColor + 'a, M: Clone + 'a> Widget<C, M> for Roller<'a, C, M>

fn measure(&mut self, constraints: Constraints) -> Size

Report the size this widget wants within constraints.

fn preferred_size(&self) -> (Length, Length)

Per-axis sizing intent set via .width(...) / .height(...). Containers consult this during layout to allocate fixed slots, query intrinsic sizes, and split residual space among Fill / FillPortion children. Default is Length::Fill on both axes.

fn arrange(&mut self, rect: Rectangle)

Commit the final rectangle, recursively arranging any children.

fn rect(&self) -> Rectangle

The current arranged rectangle.

fn handle_touch(&mut self, point: Point, phase: TouchPhase) -> Option<M>

Dispatch a touch event. Returns a message if consumed.

fn mark_pressed(&mut self, _point: Point)

Set this widget’s pressed flag if point hits. No message emit. Containers forward to children. Default no-op.

fn widget_id(&self) -> Option<WidgetId>

Stable id of this widget, if it participates in focus.

fn is_focusable(&self) -> bool

True if this widget should appear in focus traversal.

fn handle_action(&mut self, action: UiAction) -> Option<M>

Handle a semantic action directed at this widget.

fn sync_focus(&mut self, focused: Option<WidgetId>)

Synchronize focused state against the runtime’s currently-focused id.

fn focus_at(&self, point: Point) -> Option<WidgetId>

Focusable widget id at point, if any.

fn draw<'t>( &self, renderer: &mut dyn Renderer<C>, theme: &Theme<'t, C>, ) -> Result<(), RenderError>

Paint into renderer at rect.

fn collect_focusable(&self, out: &mut Vec<WidgetId>)

Append focusable widget ids in traversal order.

fn route_action(&mut self, target: WidgetId, action: UiAction) -> Option<M>

Route a semantic action to the widget with id target.

fn navigate_focus(&self, target: WidgetId, action: UiAction) -> Option<WidgetId>

Request a focus movement relative to target for directional actions.

fn focus_rect(&self, target: WidgetId) -> Option<Rectangle>

Rectangle currently occupied by the focusable target, if any.