Struct List 

pub struct List<T, K>
where
    T: 'static,
    K: 'static,
{ /* private fields */ }

A native recycling list: the platform widget owns scrolling + cell reuse; Day builds each visible row once and rebinds it (a slot-write into its ItemSlot) as cells recycle. Shares the ItemSlot row contract with each; migrating is a one-word change.

Implementations

impl<T, K> List<T, K>

where T: Clone + 'static, K: Clone + Hash + 'static,

pub fn row_height(self, h: RowHeight) -> List<T, K>

Row sizing: Uniform(h) (fastest) or Automatic (self-sizing).

pub fn on_select(self, f: impl Fn(K) + 'static) -> List<T, K>

Called with the selected row’s key when the native list reports a selection.

pub fn multi_select(self, on: bool) -> List<T, K>

Allow selecting several rows at once, where the toolkit supports it (docs/list.md has the matrix; single-selection backends fall back to one row at a time). Every selection change calls Self::on_selection with the FULL set of selected keys.

pub fn on_selection(self, f: impl Fn(Vec<K>) + 'static) -> List<T, K>

Called with the full set of selected keys (row order, empty = cleared) whenever the selection changes — the multi-select analogue of Self::on_select. Also fired by single-selection backends with a one-element (or empty) set.

pub fn selected_rows( self, rows: impl Fn() -> Vec<usize> + 'static, ) -> List<T, K>

Reactively sync the native selection to rows (row indices; empty clears). Re-runs whenever the closure’s tracked reads change; the toolkit applies the sync without re-emitting a selection event — drive it from app state to build “Clear selection”.

pub fn scroll_to_end(self, trigger: Trigger) -> List<T, K>

Scroll the list so its LAST row is fully visible whenever trigger fires — e.g. a chat timeline sticking to the newest message. Fire it with day_reactive::Trigger::notify after appending. No-op while the list is empty. The scroll targets the native list (NSTableView/UITableView/GtkListView/QListView/RecyclerView), so it respects the platform’s own scroll physics.

pub fn stick_to_bottom(self, on: bool) -> List<T, K>

Best-effort auto-stick: after a data reload, scroll to the end so freshly appended rows stay visible. Convenience over Self::scroll_to_end for feeds that always follow the newest row; for finer control (only stick when the user is already near the bottom) drive scroll_to_end from your own logic instead. Off by default.

pub fn scroll_to_row(self, sig: Signal<Option<usize>>) -> List<T, K>

Programmatic scroll-to-row (docs/list.md): set the signal to Some(row) and the native list scrolls that row into view, realizing it if it was virtualized away — the row rail’s counterpart to scroll(...).scroll_target(...). The signal is left as written; setting the same row again re-fires.

pub fn reorderable(self, on: bool) -> List<T, K>

Let the user drag rows into a new order with the platform’s native mechanism — the macOS drop gap, the iOS long-press lift, Android’s ItemTouchHelper — where the backend supports it (probe Cap::ListReorder; docs/list.md has the matrix). Pair with on_reorder so the app’s data follows the move, and optionally reorder_guard to veto or retarget drops.

pub fn on_reorder(self, f: impl Fn(usize, usize) + 'static) -> List<T, K>

A committed move: row from now sits at row to. Apply the same rotation to the backing data (let it = v.remove(from); v.insert(to, it);) — and persist it if the order should survive a relaunch. Runs on the main thread at the next event drain, never inside the native drop callback.

pub fn reorder_guard( self, g: impl Fn(usize, usize) -> Reorder + 'static, ) -> List<T, K>

Veto or override drops while the drag is live: called synchronously from the native validate hook with (from, proposed_to). Return Reorder::Deny to refuse, Reorder::Retarget to accept at a different index (a “pinned rows” pattern), or Reorder::Allow to accept as proposed (the default when no guard is set). Keep it pure — read state, decide, return; it runs inside the platform’s drag callback.

Trait Implementations

impl<T, K> Piece for List<T, K>

where T: Clone + 'static, K: Clone + Hash + 'static,

fn build(self, cx: &mut BuildCx) -> RNode