Struct Tileview 

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

Full-area paged tile container. Snaps one tile per swipe.

Implementations

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

pub fn new() -> Self

Create an empty tileview paging horizontally. Add tiles via Tileview::push and supply the host state via Tileview::scroll_state. Position and size are assigned by the parent container via arrange.

pub fn direction(self, dir: ScrollDirection) -> Self

Paging direction. Only ScrollDirection::Horizontal and ScrollDirection::Vertical are meaningful; any other value is treated as horizontal.

pub fn push<W>(self, tile: W) -> Self

where W: Widget<C, M> + 'a,

Push a tile. Tiles are paged in insertion order.

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

Supply the host-owned ScrollState read this frame.

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

Width sizing intent (the tileview normally fills its parent).

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

Height sizing intent (the tileview normally fills its parent).

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_change<F>(self, f: F) -> Self

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

Callback fired with the active tile index when it changes. Drive it from update() via Tileview::change_msg / Tileview::current_for.

pub fn current_for( state: &ScrollState, viewport: Size, dir: ScrollDirection, count: usize, ) -> usize

The active tile index for a host ScrollState, the viewport size, the paging dir, and tile count. The host calls this in update() after applying a ScrollMsg/tick to learn which tile is showing, without rebuilding the widget tree.

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

Build the on_change message for the active tile when it differs from previous. Returns None when no callback is set or the tile is unchanged. The host calls this from update() after applying a ScrollMsg/tick.

Trait Implementations

impl<'a, C: PixelColor + 'a, M: Clone + 'a> Default for Tileview<'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 Tileview<'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 draw<'t>( &self, renderer: &mut dyn Renderer<C>, theme: &Theme<'t, C>, ) -> Result<(), RenderError>

Paint into renderer at rect.

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 collect_focusable(&self, out: &mut Vec<WidgetId>)

Append focusable widget ids in traversal order.

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

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

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

Handle a semantic action directed at this widget.

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.

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

Focusable widget id at point, if any.