Struct SearchList 

pub struct SearchList<R: SearchRow> { /* private fields */ }

Implementations

impl<R: SearchRow> SearchList<R>

pub fn builder( source: impl RowSource<R>, redraw: Arc<dyn Fn() + Send + Sync>, ) -> SearchListBuilder<R>

pub fn poll(&mut self)

pub fn visible_len(&self) -> usize

Length of the visible sequence [leading?] ++ display.

pub fn match_count(&self) -> usize

Number of real matches — the visible rows minus the synthetic leading affordance (“Create: …”), for result-count displays.

pub fn rows(&self) -> &[R]

The source-delivered rows only (NOT the leading row). Prefer visible_len/visible_rows for visible counts.

pub fn selected_row(&self) -> Option<&R>

pub fn visible_rows(&self) -> Vec<&R>

pub fn query(&self) -> &str

pub fn take_accepted_saved_search(&mut self) -> Option<String>

Take the name of a just-accepted saved search, if any. The host calls this after a Consumed key to learn whether to pin (or refresh) the saved-search breadcrumb. Returns None once read.

pub fn is_loading(&self) -> bool

pub fn set_query(&mut self, q: impl Into<String>)

Set the query programmatically: updates the visible input widget (cursor to end) AND the query string, then starts a load (for reload_on_query sources) or recomputes the display. This is the setter every external caller wants — a saved search applied, a sort directive rewritten — so the input bar always reflects the query. The interactive keystroke path uses sync_query_from_input instead, because the input widget already holds the typed text (and its cursor must not jump back to the end on every keystroke).

pub fn reload(&mut self)

Re-run the source load for the current query (e.g. after a mutation).

pub fn update_rows(&mut self, mutate: impl FnMut(&mut R) -> bool) -> bool

Mutate rows in place. mutate is called for each row and returns true for each row it changed; if any did, the display order is recomputed (re-filter, no re-sort) so an active filter stays correct. Returns whether anything changed.

This is the one seam that touches rows outside the RowSource; every other change rebuilds from the source. Structural changes (add/remove/ reorder) must still reload. See adr/0010.

pub fn select_next(&mut self)

pub fn select_prev(&mut self)

pub fn scroll_down(&mut self)

Scroll the viewport one row down, carrying the selection along so the selected row keeps its on-screen position. No-op once the last row is in view — the shared mouse-wheel behavior for every list surface.

pub fn scroll_up(&mut self)

Scroll the viewport one row up, carrying the selection along so the selected row keeps its on-screen position. No-op at the top.

pub fn handle_key(&mut self, key: &KeyEvent) -> KeyReaction

pub fn render_query( &mut self, f: &mut Frame<'_>, area: Rect, theme: &Theme, focused: bool, )

pub fn render( &mut self, f: &mut Frame<'_>, area: Rect, theme: &Theme, focused: bool, )

pub fn set_list_rect(&mut self, rect: Rect)

Override the rect used for mouse hit-testing. The recorded rect must be the area where list ITEMS actually render — row 0 is the first item, NOT a block border. Hosts that draw the list inside a bordered block pass the block’s INNER rect; borderless hosts pass the list area directly. The recorded rect and the rendered-items rect MUST be identical, so handle_mouse maps a click at row to visual offset row - rect.y.

pub fn set_panel_rect(&mut self, rect: Rect)

Record the host panel’s full bounds so the wheel scrolls the list from anywhere within the panel — header, query box, preview — not just over the list items. Hosts call this each render with the same rect they were drawn into. Never set = wheel hit-tests list_rect only.

pub fn set_content_rect(&mut self, rect: Rect)

Record a host-owned scrollable sub-region (e.g. an expanded preview): wheel events inside it are routed back to the host as SearchMouse::ContentScrollUp/ContentScrollDown instead of scrolling the list. Hosts re-record it every render (empty when the sub-region is not drawn) so the hit-test never sees a stale rect.

pub fn render_autocomplete( &mut self, f: &mut Frame<'_>, clamp: Rect, theme: &Theme, )

pub fn close_autocomplete(&mut self)

Close an open autocomplete popup. handle_mouse does this for every event it sees (“any mouse interaction dismisses the popup”); hosts that consume a mouse event WITHOUT routing it through the engine call this to keep that rule intact.

pub fn handle_mouse(&mut self, m: &MouseEvent) -> SearchMouse