Lightweight coding agent that runs in your terminal
Rust
//! Render selectable lists with shared picker controls and full-width focus rows.
//! Selection and scrolling use filtered row indices; actions map back to source items.
//! Controls and overflow indicators keep their own rows outside the result viewport.
//! Letter-labeled children are indented and do not consume numeric shortcuts.
use crossterm::event::KeyCode;
use crossterm::event::KeyEvent;
use crossterm::event::KeyModifiers;
use itertools::Itertools as _;
use ratatui::buffer::Buffer;
use ratatui::layout::Constraint;
use ratatui::layout::Layout;
use ratatui::layout::Rect;
use ratatui::style::Stylize;
use ratatui::text::Line;
use ratatui::text::Span;
use ratatui::widgets::Paragraph;
use ratatui::widgets::Widget;
use ratatui::widgets::Wrap;
use super::selection_picker_layout::PickerLayoutSizes;
use super::selection_picker_layout::picker_areas;
use super::selection_popup_common::wrap_styled_line;
use crate::app_event_sender::AppEventSender;
use crate::clipboard_paste::normalize_pasted_search_query;
use crate::key_hint::KeyBinding;
use crate::key_hint::KeyBindingListExt;
use crate::key_hint::ShortcutHint;
use crate::key_hint::is_plain_text_key_event;
use crate::keymap::ListKeymap;
use crate::render::Insets;
use crate::render::RectExt as _;
use crate::render::renderable::ColumnRenderable;
use crate::render::renderable::Renderable;
use crate::wrapping::word_wrap_lines;
use super::CancellationEvent;
use super::bottom_pane_view::BottomPaneView;
use super::bottom_pane_view::ViewCompletion;
pub(crate) use super::picker_style::PickerSurface;
use super::picker_style::render_scroll_indicators;
use super::picker_style::selection_style;
use super::popup_consts::MAX_POPUP_ROWS;
use super::scroll_state::ScrollState;
use super::selection_popup_common::ColumnWidthConfig;
pub(crate) use super::selection_popup_common::ColumnWidthMode;
use super::selection_popup_common::GenericDisplayRow;
use super::selection_popup_common::measure_rows_height_with_col_width_mode;
use super::selection_popup_common::render_rows_single_line_with_col_width_mode;
use super::selection_popup_common::render_rows_with_col_width_mode;
use super::selection_popup_common::should_show_selected_description_below;
pub(crate) use super::selection_row_layout::SelectionDescriptionLayout;
use super::selection_tabs::SelectionTab;
use super::selection_tabs::render_tab_bar;
use super::selection_tabs::tab_bar_height;
use std::cell::Cell;
use unicode_width::UnicodeWidthStr;
/// Minimum list width (in content columns) required before the side-by-side
/// layout is activated. Keeps the list usable even when sharing horizontal
/// space with the side content panel.
const MIN_LIST_WIDTH_FOR_SIDE: u16 = 40;
/// Horizontal gap (in columns) between the list area and the side content
/// panel when side-by-side layout is active.
const SIDE_CONTENT_GAP: u16 = 2;
/// Shared menu-surface horizontal inset (2 cells per side) used by selection popups.
const MENU_SURFACE_HORIZONTAL_INSET: u16 = 4;
/// Controls how the side content panel is sized relative to the popup width.
///
/// When the computed side width falls below `side_content_min_width` or the
/// remaining list area would be narrower than [`MIN_LIST_WIDTH_FOR_SIDE`], the
/// side-by-side layout is abandoned and the stacked fallback is used instead.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum SideContentWidth {
/// Fixed number of columns. `Fixed(0)` disables side content entirely.
Fixed(u16),
/// Exact 50/50 split of the content area (minus the inter-column gap).
Half,
}
impl Default for SideContentWidth {
fn default() -> Self {
Self::Fixed(0)
}
}
/// Returns the popup content width after subtracting the shared menu-surface
/// horizontal inset (2 columns on each side).
pub(crate) fn popup_content_width(total_width: u16) -> u16 {
total_width.saturating_sub(MENU_SURFACE_HORIZONTAL_INSET)
}
/// Returns side-by-side layout widths as `(list_width, side_width)` when the
/// layout can fit. Returns `None` when the side panel is disabled/too narrow or
/// when the remaining list width would become unusably small.
pub(crate) fn side_by_side_layout_widths(
content_width: u16,
side_content_width: SideContentWidth,
side_content_min_width: u16,
) -> Option<(u16, u16)> {
let side_width = match side_content_width {
SideContentWidth::Fixed(0) => return None,
SideContentWidth::Fixed(width) => width,
SideContentWidth::Half => content_width.saturating_sub(SIDE_CONTENT_GAP) / 2,
};
if side_width < side_content_min_width {
return None;
}
let list_width = content_width.saturating_sub(SIDE_CONTENT_GAP + side_width);
(list_width >= MIN_LIST_WIDTH_FOR_SIDE).then_some((list_width, side_width))
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub(crate) enum SelectionRowDisplay {
#[default]
Wrapped,
SingleLine,
}
/// One selectable item in the generic selection list.
pub(crate) type SelectionAction = Box<dyn Fn(&AppEventSender) + Send + Sync>;
/// A second way to accept the highlighted row, sharing its dismissal behavior.
pub(crate) struct SelectionSecondaryAction {
pub key: KeyBinding,
pub action: SelectionAction,
pub footer_hint: Line<'static>,
}
enum SelectionActionKind {
Primary,
Secondary,
}
pub(crate) type SelectionToggleAction = dyn Fn(bool, &AppEventSender) + Send + Sync;
pub(crate) struct SelectionToggle {
pub is_on: bool,
pub action: Box<SelectionToggleAction>,
}
/// A displayed toggle value with the number of its save actions still in flight.
#[derive(Clone, Copy)]
pub(crate) struct SelectionToggleState {
pub is_on: bool,
pub pending_actions: usize,
}
/// Callback invoked whenever the highlighted item changes (arrow keys, search
/// filter, number-key jump). Receives the *actual* index into the unfiltered
/// `items` list and the event sender. Used by the theme picker for live preview.
pub(crate) type OnSelectionChangedCallback =
Option<Box<dyn Fn(usize, &AppEventSender) + Send + Sync>>;
/// Callback invoked when the picker is dismissed without accepting (Esc or
/// Ctrl+C). Used by the theme picker to restore the pre-open theme.
pub(crate) type OnCancelCallback = Option<Box<dyn Fn(&AppEventSender) + Send + Sync>>;
/// One row in a [`ListSelectionView`] selection list.
///
/// This is the source-of-truth model for row state before filtering and
/// formatting into render rows. A row is treated as disabled when either
/// `is_disabled` is true or `disabled_reason` is present; disabled rows cannot
/// be accepted and are skipped by keyboard navigation.
#[derive(Default)]
pub(crate) struct SelectionItem {
pub name: String,
/// Indent beneath the preceding parent, using this letter instead of a numeric shortcut.
pub child_label: Option<char>,
pub name_prefix_spans: Vec<Span<'static>>,
pub toggle: Option<SelectionToggle>,
/// Render `[x]` and treat the primary accept key as a toggle action.
pub checkbox_toggle: bool,
/// Toggle actions sent from this row that have not finished saving yet.
pub pending_toggle_actions: usize,
pub toggle_placeholder: Option<&'static str>,
pub display_shortcut: Option<ShortcutHint>,
/// Required row metadata retained when the secondary description hides.
pub category_tag: Option<String>,
pub description: Option<String>,
pub selected_description: Option<String>,
pub is_current: bool,
pub is_disabled: bool,
pub actions: Vec<SelectionAction>,
pub secondary_action: Option<SelectionSecondaryAction>,
/// Footer hint shown while this row is selected.
pub footer_hint: Option<Line<'static>>,
/// Footer hint shown instead while on-demand search is active.
pub search_footer_hint: Option<Line<'static>>,
pub dismiss_on_select: bool,
/// Require an explicit accept key after a direct shortcut highlights this sensitive item.
pub require_explicit_confirmation: bool,
pub dismiss_parent_on_child_accept: bool,
pub search_value: Option<String>,
pub disabled_reason: Option<String>,
/// Optional marker rendered in place of the number for a disabled row.
pub disabled_gutter_marker: Option<&'static str>,
}
/// Construction-time configuration for [`ListSelectionView`].
///
/// This config is consumed once by [`ListSelectionView::new`]. After
/// construction, mutable interaction state (filtering, scrolling, and selected
/// row) lives on the view itself.
///
/// `col_width_mode` controls column width mode in selection lists:
/// `AutoVisible` (default) measures only rows visible in the viewport
/// `AutoAllRows` measures all rows to ensure stable column widths as the user scrolls
/// `row_display` controls whether rows can wrap or stay single-line with ellipsis truncation
/// `description_layout` optionally hides descriptions when their column would become too narrow.
pub(crate) struct SelectionViewParams {
pub presentation: super::ViewPresentation,
pub picker_surface: PickerSurface,
/// Upper row budget; compact completion menus retain the default of eight.
pub max_visible_rows: usize,
/// Keep the result area at its configured row budget when filtering shrinks it.
pub reserve_result_rows: bool,
/// Whether this picker can continue handling input without the app server.
pub allow_input_when_disconnected: bool,
pub view_id: Option<&'static str>,
pub title: Option<String>,
pub subtitle: Option<String>,
pub footer_note: Option<Line<'static>>,
pub footer_hint: Option<Line<'static>>,
pub tab_footer_hints: Vec<(String, Line<'static>)>,
pub items: Vec<SelectionItem>,
/// Optional flat item list used while a tabbed picker has a non-empty search query.
pub search_items: Vec<SelectionItem>,
pub tabs: Vec<SelectionTab>,
pub initial_tab_id: Option<String>,
pub is_searchable: bool,
/// Optional non-text key that can toggle a row while printable keys edit the search query.
pub search_toggle_key: Option<KeyBinding>,
pub search_mode: SearchMode,
/// Use ordinal digits in the gutter; when false, use only each row's explicit shortcut.
pub auto_number_shortcuts: bool,
pub search_placeholder: Option<String>,
pub col_width_mode: ColumnWidthMode,
pub row_display: SelectionRowDisplay,
pub description_layout: SelectionDescriptionLayout,
/// Rendered left-column width to use for auto-sized rows.
pub name_column_width: Option<usize>,
pub header: Box<dyn Renderable>,
/// Optional shortcut to the complete header, shown when its text is clipped.
pub header_view_all_hint: Option<ShortcutHint>,
/// Blank rows after the header; defaults to one. Inline banners use zero.
pub header_gap: u16,
pub initial_selected_idx: Option<usize>,
/// Restore a filter together with its actual selected item after a source refresh.
pub initial_search_query: Option<String>,
/// Rich content rendered beside (wide terminals) or below (narrow terminals)
/// the list items, inside the bordered menu surface. Used by the theme picker
/// to show a syntax-highlighted preview.
pub side_content: Box<dyn Renderable>,
/// Width mode for side content when side-by-side layout is active.
pub side_content_width: SideContentWidth,
/// Minimum side panel width required before side-by-side layout activates.
pub side_content_min_width: u16,
/// Optional fallback content rendered when side-by-side does not fit.
/// When absent, `side_content` is reused.
pub stacked_side_content: Option<Box<dyn Renderable>>,
/// Keep side-content background colors after rendering in side-by-side mode.
/// Disabled by default so existing popups preserve their reset-background look.
pub preserve_side_content_bg: bool,
/// Called when the highlighted item changes (navigation, filter, number-key).
/// Receives the *actual* item index, not the filtered/visible index.
pub on_selection_changed: OnSelectionChangedCallback,
/// Whether cancellation keys can dismiss the picker.
pub allow_cancel: bool,
/// Called when the picker is dismissed via Esc/Ctrl+C without selecting.
pub on_cancel: OnCancelCallback,
}
impl Default for SelectionViewParams {
fn default() -> Self {
Self {
picker_surface: PickerSurface::default(),
max_visible_rows: MAX_POPUP_ROWS,
reserve_result_rows: false,
allow_input_when_disconnected: false,
presentation: super::ViewPresentation::Inline,
view_id: None,
title: None,
subtitle: None,
footer_note: None,
footer_hint: None,
tab_footer_hints: Vec::new(),
items: Vec::new(),
search_items: Vec::new(),
tabs: Vec::new(),
initial_tab_id: None,
is_searchable: false,
search_toggle_key: None,
search_mode: SearchMode::default(),
auto_number_shortcuts: true,
search_placeholder: None,
col_width_mode: ColumnWidthMode::AutoVisible,
row_display: SelectionRowDisplay::Wrapped,
description_layout: SelectionDescriptionLayout::Columns,
name_column_width: None,
header: Box::new(()),
header_view_all_hint: None,
header_gap: 1,
initial_selected_idx: None,
initial_search_query: None,
side_content: Box::new(()),
side_content_width: SideContentWidth::default(),
side_content_min_width: 0,
stacked_side_content: None,
preserve_side_content_bg: false,
on_selection_changed: None,
allow_cancel: true,
on_cancel: None,
}
}
}
/// Controls whether a searchable list starts in search mode or waits for a shortcut.
#[derive(Clone, Copy, Default)]
pub(crate) enum SearchMode {
#[default]
Immediate,
OnDemand(KeyBinding),
}
/// Runtime state for rendering and interacting with a list-based selection popup.
///
/// This type is the single authority for filtered index mapping between
/// visible rows and source items and for preserving selection while filters
/// change.
pub(crate) struct ListSelectionView {
presentation: super::ViewPresentation,
picker_surface: PickerSurface,
max_visible_rows: usize,
reserve_result_rows: bool,
allow_input_when_disconnected: bool,
view_id: Option<&'static str>,
footer_note: Option<Line<'static>>,
footer_hint: Option<Line<'static>>,
tab_footer_hints: Vec<(String, Line<'static>)>,
items: Vec<SelectionItem>,
search_items: Vec<SelectionItem>,
tabs: Vec<SelectionTab>,
active_tab_idx: Option<usize>,
state: ScrollState,
completion: Option<ViewCompletion>,
pub(super) dismiss_after_child_accept: bool,
pub(super) app_event_tx: AppEventSender,
is_searchable: bool,
search_toggle_key: Option<KeyBinding>,
search_mode: SearchMode,
search_active: bool,
auto_number_shortcuts: bool,
search_query: String,
search_placeholder: Option<String>,
col_width_mode: ColumnWidthMode,
row_display: SelectionRowDisplay,
description_layout: SelectionDescriptionLayout,
name_column_width: Option<usize>,
filtered_indices: Vec<usize>,
last_selected_actual_idx: Option<usize>,
rendered_item_count: Cell<usize>,
search_cursor: Cell<Option<(u16, u16)>>,
header: Box<dyn Renderable>,
header_view_all_hint: Option<ShortcutHint>,
header_gap: u16,
initial_selected_idx: Option<usize>,
side_content: Box<dyn Renderable>,
side_content_width: SideContentWidth,
side_content_min_width: u16,
stacked_side_content: Option<Box<dyn Renderable>>,
preserve_side_content_bg: bool,
/// Called when the highlighted item changes (navigation, filter, number-key).
on_selection_changed: OnSelectionChangedCallback,
allow_cancel: bool,
/// Called when the picker is dismissed via Esc/Ctrl+C without selecting.
on_cancel: OnCancelCallback,
keymap: ListKeymap,
}
const SELECTION_TOGGLE_ON_PREFIX: &str = "[*] ";
const SELECTION_CHECKBOX_ON_PREFIX: &str = "[x] ";
const SELECTION_TOGGLE_OFF_PREFIX: &str = "[ ] ";
pub(crate) const SELECTION_TOGGLE_UNAVAILABLE_PREFIX: &str = "[-] ";
pub(crate) const SELECTION_TOGGLE_BLOCKED_PREFIX: &str = "[!] ";
fn selection_toggle_prefix(item: &SelectionItem, toggle: &SelectionToggle) -> &'static str {
if toggle.is_on {
if item.checkbox_toggle {
SELECTION_CHECKBOX_ON_PREFIX
} else {
SELECTION_TOGGLE_ON_PREFIX
}
} else {
SELECTION_TOGGLE_OFF_PREFIX
}
}
fn selection_item_toggle_prefix(item: &SelectionItem) -> Option<&'static str> {
item.toggle_placeholder.or_else(|| {
item.toggle
.as_ref()
.map(|toggle| selection_toggle_prefix(item, toggle))
})
}
impl ListSelectionView {
fn selected_item_has_toggle(&self) -> bool {
self.selected_actual_idx()
.and_then(|actual_idx| self.active_items().get(actual_idx))
.is_some_and(|item| item.toggle.is_some() && Self::item_is_enabled(item))
}
fn selected_item_has_toggle_placeholder(&self) -> bool {
self.selected_actual_idx()
.and_then(|actual_idx| self.active_items().get(actual_idx))
.is_some_and(|item| {
item.toggle.is_none()
&& item.toggle_placeholder.is_some()
&& Self::item_is_enabled(item)
})
}
fn toggle_selected(&mut self) {
let Some(actual_idx) = self.selected_actual_idx() else {
return;
};
let app_event_tx = self.app_event_tx.clone();
let Some(item) = self.active_items_mut().get_mut(actual_idx) else {
return;
};
if !Self::item_is_enabled(item) {
return;
}
let Some(toggle) = item.toggle.as_mut() else {
return;
};
toggle.is_on = !toggle.is_on;
item.pending_toggle_actions = item.pending_toggle_actions.saturating_add(/*rhs*/ 1);
(toggle.action)(toggle.is_on, &app_event_tx);
}
}
impl ListSelectionView {
/// Create a selection popup view with filtering, scrolling, and callbacks wired.
///
/// The constructor normalizes header/title composition and immediately
/// applies filtering so `ScrollState` starts in a valid visible range.
/// When search is enabled, rows without `search_value` will disappear as
/// soon as the query is non-empty, which can look like dropped data unless
/// callers intentionally populate that field.
pub fn new(
params: SelectionViewParams,
app_event_tx: AppEventSender,
keymap: ListKeymap,
) -> Self {
let mut header = params.header;
if params.title.is_some() || params.subtitle.is_some() {
let title = params.title.map(|title| Line::from(title.bold()));
let subtitle = params.subtitle.map(|subtitle| Line::from(subtitle.dim()));
header = Box::new(ColumnRenderable::with([
header,
Box::new(
Paragraph::new(title.into_iter().chain(subtitle).collect::<Vec<_>>())
.wrap(Wrap { trim: false }),
),
]));
}
let active_tab_idx = params.initial_tab_id.as_ref().and_then(|initial_tab_id| {
params
.tabs
.iter()
.position(|tab| tab.id.as_str() == initial_tab_id.as_str())
});
let active_tab_idx = if params.tabs.is_empty() {
None
} else {
Some(active_tab_idx.unwrap_or(0))
};
let has_initial_selected_idx = params.initial_selected_idx.is_some();
let search_active = matches!(params.search_mode, SearchMode::Immediate)
|| params.initial_search_query.is_some();
let search_query = params.initial_search_query.unwrap_or_default();
let mut s = Self {
picker_surface: params.picker_surface,
max_visible_rows: params.max_visible_rows.max(/*other*/ 1),
reserve_result_rows: params.reserve_result_rows,
allow_input_when_disconnected: params.allow_input_when_disconnected,
presentation: params.presentation,
view_id: params.view_id,
footer_note: params.footer_note,
footer_hint: params.footer_hint,
tab_footer_hints: params.tab_footer_hints,
items: params.items,
search_items: params.search_items,
tabs: params.tabs,
active_tab_idx,
state: ScrollState::new(),
completion: None,
dismiss_after_child_accept: false,
app_event_tx,
is_searchable: params.is_searchable,
search_toggle_key: params.search_toggle_key,
search_mode: params.search_mode,
search_active,
search_query,
auto_number_shortcuts: params.auto_number_shortcuts,
search_placeholder: if params.is_searchable {
params.search_placeholder
} else {
None
},
col_width_mode: params.col_width_mode,
row_display: params.row_display,
description_layout: params.description_layout,
name_column_width: params.name_column_width,
filtered_indices: Vec::new(),
last_selected_actual_idx: None,
rendered_item_count: Cell::new(/*value*/ 0),
search_cursor: Cell::new(/*value*/ None),
header,
header_view_all_hint: params.header_view_all_hint,
header_gap: params.header_gap,
initial_selected_idx: params.initial_selected_idx,
side_content: params.side_content,
side_content_width: params.side_content_width,
side_content_min_width: params.side_content_min_width,
stacked_side_content: params.stacked_side_content,
preserve_side_content_bg: params.preserve_side_content_bg,
on_selection_changed: params.on_selection_changed,
allow_cancel: params.allow_cancel,
on_cancel: params.on_cancel,
keymap,
};
s.apply_filter();
if s.tabs_enabled() && !has_initial_selected_idx && s.state.selected_idx.is_none() {
s.select_first_enabled_row();
}
s
}
fn visible_len(&self) -> usize {
self.filtered_indices.len()
}
fn tabs_enabled(&self) -> bool {
self.active_tab_idx.is_some()
}
fn search_items_active(&self) -> bool {
!self.search_query.is_empty() && !self.search_items.is_empty()
}
fn edit_search_query(&mut self, edit: impl FnOnce(&mut String)) {
let search_items_were_active = self.search_items_active();
edit(&mut self.search_query);
if search_items_were_active != self.search_items_active() {
self.state.reset();
}
self.apply_filter();
}
fn active_items(&self) -> &[SelectionItem] {
if self.search_items_active() {
return self.search_items.as_slice();
}
self.active_tab_idx
.and_then(|idx| self.tabs.get(idx))
.map(|tab| tab.items.as_slice())
.unwrap_or(self.items.as_slice())
}
fn active_items_mut(&mut self) -> &mut [SelectionItem] {
if self.search_items_active() {
return self.search_items.as_mut_slice();
}
if let Some(idx) = self.active_tab_idx
&& let Some(tab) = self.tabs.get_mut(idx)
{
return tab.items.as_mut_slice();
}
self.items.as_mut_slice()
}
fn active_header(&self, width: u16) -> &dyn Renderable {
self.active_tab_idx
.and_then(|idx| self.tabs.get(idx))
.filter(|tab| tab.header.desired_height(width) > 0)
.map(|tab| tab.header.as_ref())
.unwrap_or(self.header.as_ref())
}
fn header_height(&self, width: u16) -> u16 {
let active_height = self.active_header(width).desired_height(width);
if self.reserve_result_rows {
self.tabs
.iter()
.map(|tab| tab.header.desired_height(width))
.max()
.unwrap_or(active_height)
.max(active_height)
} else {
active_height
}
}
fn active_footer_hint(&self) -> Option<&Line<'static>> {
if let Some(item) = self
.selected_actual_idx()
.and_then(|idx| self.active_items().get(idx))
{
if self.on_demand_search_active()
&& let Some(hint) = item.search_footer_hint.as_ref()
{
return Some(hint);
}
if let Some(hint) = item.footer_hint.as_ref() {
return Some(hint);
}
if let Some(action) = item.secondary_action.as_ref() {
return Some(&action.footer_hint);
}
}
self.active_tab_id()
.and_then(|active_tab_id| {
self.tab_footer_hints
.iter()
.find_map(|(tab_id, hint)| (tab_id.as_str() == active_tab_id).then_some(hint))
})
.or(self.footer_hint.as_ref())
}
fn active_tab_id(&self) -> Option<&str> {
self.active_tab_idx
.and_then(|idx| self.tabs.get(idx))
.map(|tab| tab.id.as_str())
}
fn visible_rows(&self, len: usize) -> usize {
let rendered = self.rendered_item_count.get();
let limit = if rendered > 0 {
self.max_visible_rows.min(rendered)
} else {
self.max_visible_rows
};
limit.min(len.max(/*other*/ 1))
}
fn selected_actual_idx(&self) -> Option<usize> {
self.state
.selected_idx
.and_then(|visible_idx| self.filtered_indices.get(visible_idx).copied())
}
fn apply_filter(&mut self) {
let previously_selected = self
.selected_actual_idx()
.filter(|actual_idx| self.enabled_actual_idx(*actual_idx).is_some())
.or_else(|| {
self.initial_selected_idx
.take()
.filter(|actual_idx| self.enabled_actual_idx(*actual_idx).is_some())
})
.or_else(|| {
(!self.is_searchable)
.then(|| {
self.active_items()
.iter()
.position(|item| item.is_current && Self::item_is_enabled(item))
})
.flatten()
});
if self.is_searchable && !self.search_query.is_empty() {
let query_lower = self.search_query.to_lowercase();
self.filtered_indices = self
.active_items()
.iter()
.positions(|item| {
item.search_value
.as_ref()
.is_some_and(|v| v.to_lowercase().contains(&query_lower))
})
.collect();
} else {
self.filtered_indices = (0..self.active_items().len()).collect();
}
let len = self.filtered_indices.len();
let selected_visible_idx = self
.state
.selected_idx
.and_then(|visible_idx| {
self.filtered_indices
.get(visible_idx)
.and_then(|idx| self.filtered_indices.iter().position(|cur| cur == idx))
})
.or_else(|| {
previously_selected.and_then(|actual_idx| {
self.filtered_indices
.iter()
.position(|idx| *idx == actual_idx)
})
});
self.state.selected_idx = selected_visible_idx
.filter(|visible_idx| {
self.filtered_indices
.get(*visible_idx)
.and_then(|actual_idx| self.active_items().get(*actual_idx))
.is_some_and(Self::item_is_enabled)
})
.or_else(|| self.first_enabled_visible_idx())
.or_else(|| (len > 0).then_some(0));
let visible = self.visible_rows(len);
self.state.clamp_selection(len);
self.state.ensure_visible(len, visible);
// Notify the callback when filtering changes the selected actual item
// so live preview stays in sync (e.g. typing in the theme picker).
let new_actual = self.selected_actual_idx();
if new_actual != previously_selected {
self.fire_selection_changed();
}
}
fn build_rows(&self) -> Vec<GenericDisplayRow> {
let enabled_row_number_width = self
.filtered_indices
.iter()
.filter(|actual_idx| {
self.active_items()
.get(**actual_idx)
.is_some_and(|item| Self::item_is_enabled(item) && item.child_label.is_none())
})
.count()
.max(1)
.to_string()
.len();
let mut enabled_row_number = 0;
let row_selection_style = Some(selection_style());
self.filtered_indices
.iter()
.enumerate()
.filter_map(|(visible_idx, actual_idx)| {
self.active_items().get(*actual_idx).map(|item| {
let is_selected = self.state.selected_idx == Some(visible_idx);
let prefix = if is_selected { '›' } else { ' ' };
let name = item.name.as_str();
let marker = if item.is_current { " (current)" } else { "" };
let name_with_marker = format!("{name}{marker}");
let is_disabled = item.is_disabled || item.disabled_reason.is_some();
let wrap_prefix = if self.is_searchable {
// The number keys don't work when search is enabled (since we let the
// numbers be used for the search query).
format!("{prefix} ")
} else if !self.auto_number_shortcuts {
item.display_shortcut.map_or_else(
|| format!("{prefix} "),
|shortcut| format!("{prefix} {}. ", shortcut.display_label()),
)
} else if is_disabled {
if let Some(disabled_gutter_marker) = item.disabled_gutter_marker {
let marker_width = UnicodeWidthStr::width(disabled_gutter_marker);
let marker_padding =
" ".repeat(enabled_row_number_width.saturating_sub(marker_width));
format!("{prefix} {marker_padding}{disabled_gutter_marker} ")
} else {
format!("{prefix} {}", " ".repeat(enabled_row_number_width + 2))
}
} else if let Some(label) = item.child_label {
format!("{prefix} {label}. ")
} else {
enabled_row_number += 1;
let n = enabled_row_number;
format!("{prefix} {n}. ")
};
let wrap_prefix_width = UnicodeWidthStr::width(wrap_prefix.as_str());
let mut name_prefix_spans = Vec::new();
name_prefix_spans.push(wrap_prefix.into());
if let Some(toggle_prefix) = selection_item_toggle_prefix(item) {
name_prefix_spans.push(toggle_prefix.into());
}
name_prefix_spans.extend(item.name_prefix_spans.clone());
let description = is_selected
.then(|| item.selected_description.clone())
.flatten()
.or_else(|| item.description.clone());
let wrap_indent = (description.is_none() && item.disabled_reason.is_none())
.then_some(wrap_prefix_width);
GenericDisplayRow {
category_tag: item.category_tag.clone(),
selection_style: row_selection_style,
name: name_with_marker,
name_prefix_spans,
display_shortcut: self
.auto_number_shortcuts
.then_some(item.display_shortcut)
.flatten(),
match_indices: None,
description,
wrap_indent,
is_disabled,
disabled_reason: item.disabled_reason.clone(),
}
})
})
.collect()
}
fn switch_tab(&mut self, step: isize) {
let Some(active_idx) = self.active_tab_idx else {
return;
};
let len = self.tabs.len();
if len == 0 {
return;
}
let next_idx = if step.is_negative() {
active_idx.checked_sub(1).unwrap_or(len - 1)
} else {
(active_idx + 1) % len
};
self.active_tab_idx = Some(next_idx);
if self.search_items.is_empty() {
self.search_query.clear();
}
self.rendered_item_count.set(/*val*/ 0);
self.state.reset();
self.apply_filter();
if self.state.selected_idx.is_none() {
self.select_first_enabled_row();
}
self.fire_selection_changed();
}
fn select_first_enabled_row(&mut self) {
let selected_visible_idx = self
.first_enabled_visible_idx()
.or_else(|| (!self.filtered_indices.is_empty()).then_some(0));
self.state.selected_idx = selected_visible_idx;
self.state.scroll_top = 0;
}
fn first_enabled_visible_idx(&self) -> Option<usize> {
self.filtered_indices.iter().position(|actual_idx| {
self.active_items()
.get(*actual_idx)
.is_some_and(Self::item_is_enabled)
})
}
fn enabled_actual_idx(&self, actual_idx: usize) -> Option<usize> {
self.active_items()
.get(actual_idx)
.is_some_and(Self::item_is_enabled)
.then_some(actual_idx)
}
fn item_is_enabled(item: &SelectionItem) -> bool {
item.disabled_reason.is_none() && !item.is_disabled
}
fn actual_idx_for_enabled_number(&self, number: usize) -> Option<usize> {
if number == 0 {
return None;
}
self.active_items()
.iter()
.enumerate()
.filter(|(_, item)| Self::item_is_enabled(item) && item.child_label.is_none())
.nth(number - 1)
.map(|(idx, _)| idx)
}
fn move_up(&mut self) {
let before = self.selected_actual_idx();
let len = self.visible_len();
self.state.move_up_wrap(len);
let visible = self.visible_rows(len);
self.skip_disabled_up();
self.state.ensure_visible(len, visible);
if self.selected_actual_idx() != before {
self.fire_selection_changed();
}
}
fn move_down(&mut self) {
let before = self.selected_actual_idx();
let len = self.visible_len();
self.state.move_down_wrap(len);
let visible = self.visible_rows(len);
self.skip_disabled_down();
self.state.ensure_visible(len, visible);
if self.selected_actual_idx() != before {
self.fire_selection_changed();
}
}
fn page_up(&mut self) {
let before = self.selected_actual_idx();
let len = self.visible_len();
let visible = self.visible_rows(len);
self.state.page_up_clamped(len, visible);
self.skip_disabled_up_clamped();
self.state.ensure_visible(len, visible);
if self.selected_actual_idx() != before {
self.fire_selection_changed();
}
}
fn page_down(&mut self) {
let before = self.selected_actual_idx();
let len = self.visible_len();
let visible = self.visible_rows(len);
self.state.page_down_clamped(len, visible);
self.skip_disabled_down_clamped();
self.state.ensure_visible(len, visible);
if self.selected_actual_idx() != before {
self.fire_selection_changed();
}
}
fn jump_top(&mut self) {
let before = self.selected_actual_idx();
let len = self.visible_len();
let visible = self.visible_rows(len);
self.state.jump_top(len, visible);
self.skip_disabled_down_clamped();
self.state.ensure_visible(len, visible);
if self.selected_actual_idx() != before {
self.fire_selection_changed();
}
}
fn jump_bottom(&mut self) {
let before = self.selected_actual_idx();
let len = self.visible_len();
let visible = self.visible_rows(len);
self.state.jump_bottom(len, visible);
self.skip_disabled_up_clamped();
self.state.ensure_visible(len, visible);
if self.selected_actual_idx() != before {
self.fire_selection_changed();
}
}
fn fire_selection_changed(&self) {
if let Some(cb) = &self.on_selection_changed
&& let Some(actual) = self.selected_actual_idx()
{
cb(actual, &self.app_event_tx);
}
}
fn accept(&mut self, kind: SelectionActionKind) {
let selected_actual_idx = self.selected_actual_idx();
if matches!(kind, SelectionActionKind::Primary)
&& selected_actual_idx
.and_then(|idx| self.active_items().get(idx))
.is_some_and(|item| item.checkbox_toggle)
{
self.toggle_selected();
self.last_selected_actual_idx = selected_actual_idx;
return;
}
if let Some(item) = selected_actual_idx.and_then(|idx| self.active_items().get(idx)) {
if item.is_disabled || item.disabled_reason.is_some() {
return;
}
match kind {
SelectionActionKind::Primary => {
for act in &item.actions {
act(&self.app_event_tx);
}
}
SelectionActionKind::Secondary => {
let Some(action) = &item.secondary_action else {
return;
};
(action.action)(&self.app_event_tx);
}
}
if item.dismiss_on_select {
self.completion = Some(ViewCompletion::Accepted);
} else if item.dismiss_parent_on_child_accept {
self.dismiss_after_child_accept = true;
}
self.last_selected_actual_idx = selected_actual_idx;
} else if selected_actual_idx.is_none() {
if let Some(cb) = &self.on_cancel {
cb(&self.app_event_tx);
}
self.completion = Some(ViewCompletion::Cancelled);
}
}
fn select_shortcut(&mut self, actual_idx: usize) {
let previously_selected = self.selected_actual_idx();
self.state.selected_idx = Some(actual_idx);
if self
.active_items()
.get(actual_idx)
.is_some_and(|item| item.require_explicit_confirmation)
{
if self.selected_actual_idx() != previously_selected {
self.fire_selection_changed();
}
} else {
self.accept(SelectionActionKind::Primary);
}
}
/// Preserve a searchable picker's filter when its parent rebuilds the view.
pub(crate) fn search_query(&self) -> Option<&str> {
self.search_field_visible()
.then_some(self.search_query.as_str())
}
fn search_field_visible(&self) -> bool {
self.is_searchable && self.search_active
}
fn on_demand_search_active(&self) -> bool {
self.search_active && matches!(self.search_mode, SearchMode::OnDemand(_))
}
fn stop_on_demand_search(&mut self) {
self.search_active = false;
self.edit_search_query(String::clear);
}
pub(crate) fn set_search_query(&mut self, query: String) {
let selected_actual_idx = self.selected_actual_idx();
let changes_item_source =
self.search_items_active() != (!query.is_empty() && !self.search_items.is_empty());
self.search_active = true;
self.search_query = query;
if changes_item_source {
self.state.reset();
self.initial_selected_idx = None;
} else {
self.state.selected_idx = None;
self.initial_selected_idx = selected_actual_idx;
}
self.apply_filter();
}
pub(crate) fn take_last_selected_index(&mut self) -> Option<usize> {
self.last_selected_actual_idx.take()
}
fn footer_hint_lines(&self, width: u16) -> Vec<Line<'_>> {
let Some(hint) = self.active_footer_hint() else {
return Vec::new();
};
let mut lines = wrap_styled_line(hint, width);
if self.reserve_result_rows {
let height = self
.tab_footer_hints
.iter()
.map(|(_, hint)| wrap_styled_line(hint, width).len())
.chain(
self.footer_hint
.iter()
.map(|hint| wrap_styled_line(hint, width).len()),
)
.chain(
self.items
.iter()
.chain(self.search_items.iter())
.chain(self.tabs.iter().flat_map(|tab| tab.items.iter()))
.flat_map(|item| {
[
item.footer_hint.as_ref().or_else(|| {
item.secondary_action
.as_ref()
.map(|action| &action.footer_hint)
}),
item.search_footer_hint.as_ref(),
]
.into_iter()
.flatten()
})
.map(|hint| wrap_styled_line(hint, width).len()),
)
.max()
.unwrap_or(lines.len());
lines.resize(height.max(lines.len()), Line::default());
}
lines
}
fn footer_note_lines(&self, width: u16, show_selected_description: bool) -> Vec<Line<'static>> {
let wrap = |line| word_wrap_lines([line], usize::from(width.max(1)));
let note = if show_selected_description {
self.selected_actual_idx()
.and_then(|idx| self.active_items().get(idx))
.and_then(|item| item.description.as_ref())
.map(|description| Line::from(description.clone()).dim())
} else {
None
}
.or_else(|| self.footer_note.clone());
let mut lines = note.map(wrap).unwrap_or_default();
if self.reserve_result_rows && show_selected_description {
let height = self
.items
.iter()
.chain(self.search_items.iter())
.chain(self.tabs.iter().flat_map(|tab| tab.items.iter()))
.filter_map(|item| item.description.as_deref())
.map(|description| wrap(Line::from(description).dim()).len())
.chain(self.footer_note.iter().map(|note| wrap(note.clone()).len()))
.max()
.unwrap_or(lines.len());
lines.resize(height.max(lines.len()), Line::default());
}
lines
}
fn result_area_height(&self, measured_height: u16) -> u16 {
if self.reserve_result_rows {
let reserved_height = self.max_visible_rows.min(usize::from(u16::MAX)) as u16;
measured_height.max(reserved_height)
} else {
measured_height
}
}
fn clear_to_terminal_bg(buf: &mut Buffer, area: Rect) {
let buf_area = buf.area();
let min_x = area.x.max(buf_area.x);
let min_y = area.y.max(buf_area.y);
let max_x = area
.x
.saturating_add(area.width)
.min(buf_area.x.saturating_add(buf_area.width));
let max_y = area
.y
.saturating_add(area.height)
.min(buf_area.y.saturating_add(buf_area.height));
for y in min_y..max_y {
for x in min_x..max_x {
buf[(x, y)]
.set_symbol(" ")
.set_style(ratatui::style::Style::reset());
}
}
}
fn force_bg_to_terminal_bg(buf: &mut Buffer, area: Rect) {
let buf_area = buf.area();
let min_x = area.x.max(buf_area.x);
let min_y = area.y.max(buf_area.y);
let max_x = area
.x
.saturating_add(area.width)
.min(buf_area.x.saturating_add(buf_area.width));
let max_y = area
.y
.saturating_add(area.height)
.min(buf_area.y.saturating_add(buf_area.height));
for y in min_y..max_y {
for x in min_x..max_x {
buf[(x, y)].set_bg(ratatui::style::Color::Reset);
}
}
}
fn stacked_side_content(&self) -> &dyn Renderable {
self.stacked_side_content
.as_deref()
.unwrap_or_else(|| self.side_content.as_ref())
}
/// Returns `Some(side_width)` when the content area is wide enough for a
/// side-by-side layout (list + gap + side panel), `None` otherwise.
fn side_layout_width(&self, content_width: u16) -> Option<u16> {
side_by_side_layout_widths(
content_width,
self.side_content_width,
self.side_content_min_width,
)
.map(|(_, side_width)| side_width)
}
fn skip_disabled_down(&mut self) {
let len = self.visible_len();
for _ in 0..len {
if self.selected_visible_idx_is_disabled() {
self.state.move_down_wrap(len);
} else {
break;
}
}
}
fn skip_disabled_up(&mut self) {
let len = self.visible_len();
for _ in 0..len {
if self.selected_visible_idx_is_disabled() {
self.state.move_up_wrap(len);
} else {
break;
}
}
}
fn skip_disabled_down_clamped(&mut self) {
let Some(start) = self.state.selected_idx else {
return;
};
if !self.visible_idx_is_disabled(start) {
return;
}
let len = self.visible_len();
self.state.selected_idx = ((start + 1)..len)
.find(|idx| !self.visible_idx_is_disabled(*idx))
.or_else(|| {
(0..start)
.rev()
.find(|idx| !self.visible_idx_is_disabled(*idx))
})
.or(Some(start));
}
fn skip_disabled_up_clamped(&mut self) {
let Some(start) = self.state.selected_idx else {
return;
};
if !self.visible_idx_is_disabled(start) {
return;
}
let len = self.visible_len();
self.state.selected_idx = (0..start)
.rev()
.find(|idx| !self.visible_idx_is_disabled(*idx))
.or_else(|| ((start + 1)..len).find(|idx| !self.visible_idx_is_disabled(*idx)))
.or(Some(start));
}
fn selected_visible_idx_is_disabled(&self) -> bool {
self.state
.selected_idx
.is_some_and(|idx| self.visible_idx_is_disabled(idx))
}
fn visible_idx_is_disabled(&self, idx: usize) -> bool {
self.filtered_indices
.get(idx)
.and_then(|actual_idx| self.active_items().get(*actual_idx))
.is_some_and(|item| item.disabled_reason.is_some() || item.is_disabled)
}
}
impl BottomPaneView for ListSelectionView {
fn presentation(&self) -> super::ViewPresentation {
self.presentation
}
fn keymap_contexts(&self) -> crate::keymap::KeymapContextSet {
crate::keymap::KeymapContextSet::new(crate::keymap::KeymapContext::List)
}
fn accepts_input_when_disconnected(&self) -> bool {
self.allow_input_when_disconnected
}
fn handle_key_event(&mut self, key_event: KeyEvent) {
// An active search reserves printable keys for the query. On-demand search leaves the
// configured list bindings untouched until its shortcut is pressed.
let search_field_visible = self.search_field_visible();
let allow_plain_char_navigation =
!search_field_visible || !is_plain_text_key_event(key_event);
let allow_plain_char_actions =
!self.on_demand_search_active() || !is_plain_text_key_event(key_event);
match key_event {
_ if self
.search_toggle_key
.is_some_and(|key| key.is_press(key_event))
&& self.keymap.action_for(key_event).is_none()
&& self.selected_item_has_toggle() =>
{
self.toggle_selected();
}
_ if allow_plain_char_navigation && self.keymap.move_up.is_pressed(key_event) => {
self.move_up()
}
_ if allow_plain_char_navigation && self.keymap.move_down.is_pressed(key_event) => {
self.move_down()
}
_ if allow_plain_char_navigation && self.keymap.page_up.is_pressed(key_event) => {
self.page_up()
}
_ if allow_plain_char_navigation && self.keymap.page_down.is_pressed(key_event) => {
self.page_down()
}
_ if allow_plain_char_navigation && self.keymap.jump_top.is_pressed(key_event) => {
self.jump_top()
}
_ if allow_plain_char_navigation && self.keymap.jump_bottom.is_pressed(key_event) => {
self.jump_bottom()
}
_ if allow_plain_char_navigation
&& self.tabs_enabled()
&& self.keymap.move_left.is_pressed(key_event) =>
{
self.switch_tab(/*step*/ -1)
}
_ if allow_plain_char_navigation
&& self.tabs_enabled()
&& self.keymap.move_right.is_pressed(key_event) =>
{
self.switch_tab(/*step*/ 1)
}
KeyEvent {
code: KeyCode::Esc,
modifiers: KeyModifiers::NONE,
..
} if self.on_demand_search_active() => self.stop_on_demand_search(),
KeyEvent {
code: KeyCode::Enter,
modifiers: KeyModifiers::NONE,
..
} if self.on_demand_search_active() => self.accept(SelectionActionKind::Primary),
KeyEvent {
code: KeyCode::Backspace,
..
} if search_field_visible => {
self.edit_search_query(|query| {
query.pop();
});
}
KeyEvent {
code: KeyCode::Char(' '),
modifiers: KeyModifiers::NONE,
..
} if self.selected_item_has_toggle()
&& self.keymap.action_for(key_event).is_none()
&& (!search_field_visible
|| matches!(self.search_mode, SearchMode::Immediate)
&& self.search_query.is_empty()) =>
{
self.toggle_selected()
}
KeyEvent {
code: KeyCode::Char(' '),
modifiers: KeyModifiers::NONE,
..
} if search_field_visible
&& matches!(self.search_mode, SearchMode::Immediate)
&& self.search_query.is_empty()
&& self.selected_item_has_toggle_placeholder() => {}
_ if allow_plain_char_actions
&& self.allow_cancel
&& self.keymap.cancel.is_pressed(key_event) =>
{
self.on_ctrl_c();
}
_ if allow_plain_char_actions && self.keymap.accept.is_pressed(key_event) => {
self.accept(SelectionActionKind::Primary)
}
_ if allow_plain_char_navigation
&& self
.selected_actual_idx()
.and_then(|idx| self.active_items().get(idx))
.and_then(|item| item.secondary_action.as_ref())
.is_some_and(|action| action.key.is_press(key_event)) =>
{
self.accept(SelectionActionKind::Secondary);
}
_ if self.is_searchable
&& !self.search_active
&& matches!(
self.search_mode,
SearchMode::OnDemand(binding) if binding.is_press(key_event)
)
&& !self.keymap.has_chord_prefix(key_event) =>
{
self.search_active = true;
}
KeyEvent {
code: KeyCode::Char(c),
..
} if c.is_ascii_control() => {}
KeyEvent {
code: KeyCode::Char(c),
modifiers,
..
} if search_field_visible
&& !modifiers.contains(KeyModifiers::CONTROL)
&& !modifiers.contains(KeyModifiers::ALT) =>
{
self.edit_search_query(|query| query.push(c));
}
KeyEvent {
code: KeyCode::Char(c),
modifiers,
..
} if !self.is_searchable
&& !modifiers.contains(KeyModifiers::CONTROL)
&& !modifiers.contains(KeyModifiers::ALT) =>
{
if let Some(idx) = self.items.iter().position(|item| {
(item
.display_shortcut
.is_some_and(|shortcut| shortcut.is_press(key_event))
|| item.child_label == Some(c))
&& Self::item_is_enabled(item)
}) {
self.select_shortcut(idx);
return;
}
if self.auto_number_shortcuts
&& let Some(idx) = c
.to_digit(/*radix*/ 10)
.map(|d| d as usize)
.and_then(|number| self.actual_idx_for_enabled_number(number))
{
self.select_shortcut(idx);
}
}
_ => {}
}
}
fn handle_paste(&mut self, pasted: String) -> bool {
if !self.search_field_visible() {
return false;
}
let Some(pasted) = normalize_pasted_search_query(&pasted) else {
return false;
};
self.edit_search_query(|query| query.push_str(&pasted));
true
}
fn is_complete(&self) -> bool {
self.completion.is_some()
}
fn completion(&self) -> Option<ViewCompletion> {
self.completion
}
fn dismiss_after_child_accept(&self) -> bool {
self.dismiss_after_child_accept
}
fn clear_dismiss_after_child_accept(&mut self) {
self.dismiss_after_child_accept = false;
}
fn view_id(&self) -> Option<&'static str> {
self.view_id
}
fn selected_index(&self) -> Option<usize> {
self.selected_actual_idx()
}
fn selection_toggle_states(&self) -> Vec<Option<SelectionToggleState>> {
self.active_items()
.iter()
.map(|item| {
item.toggle
.as_ref()
.filter(|_| item.pending_toggle_actions > 0)
.map(|toggle| SelectionToggleState {
is_on: toggle.is_on,
pending_actions: item.pending_toggle_actions,
})
})
.collect()
}
fn complete_selection_toggle(&mut self, index: usize) {
if let Some(item) = self.active_items_mut().get_mut(index) {
item.pending_toggle_actions =
item.pending_toggle_actions.saturating_sub(/*rhs*/ 1);
}
}
fn search_query(&self) -> Option<&str> {
self.is_searchable.then_some(self.search_query.as_str())
}
fn active_tab_id(&self) -> Option<&str> {
ListSelectionView::active_tab_id(self)
}
fn prefer_esc_to_handle_key_event(&self) -> bool {
true
}
fn on_ctrl_c(&mut self) -> CancellationEvent {
if self.on_demand_search_active() {
self.stop_on_demand_search();
return CancellationEvent::Handled;
}
if !self.allow_cancel {
return CancellationEvent::NotHandled;
}
if let Some(cb) = &self.on_cancel {
cb(&self.app_event_tx);
}
self.completion = Some(ViewCompletion::Cancelled);
CancellationEvent::Handled
}
}
impl Renderable for ListSelectionView {
fn cursor_pos(&self, _area: Rect) -> Option<(u16, u16)> {
if self.on_demand_search_active() {
self.search_cursor.get()
} else {
None
}
}
fn desired_height(&self, width: u16) -> u16 {
// Inner content width after menu surface horizontal insets (2 per side).
let inner_width = popup_content_width(width);
// When side-by-side is active, measure the list at the reduced width
// that accounts for the gap and side panel.
let effective_rows_width = if let Some(side_w) = self.side_layout_width(inner_width) {
// Leave the preview's right inset outside the full-width focus row.
width.saturating_sub(MENU_SURFACE_HORIZONTAL_INSET / 2 + SIDE_CONTENT_GAP + side_w)
} else {
width
};
// Measure at the same width as the painted rows, including any side panel.
let rows = self.build_rows();
let column_width = ColumnWidthConfig::new(self.col_width_mode, self.name_column_width)
.with_description_layout(self.description_layout);
let rows_height = match self.row_display {
SelectionRowDisplay::Wrapped => measure_rows_height_with_col_width_mode(
&rows,
&self.state,
self.max_visible_rows,
effective_rows_width,
column_width,
),
SelectionRowDisplay::SingleLine => {
rows.len().clamp(/*min*/ 1, self.max_visible_rows) as u16
}
};
let rows_height = self.result_area_height(rows_height);
let tab_height = tab_bar_height(&self.tabs, inner_width);
let search_field_visible = self.search_field_visible();
let mut height = self.header_height(inner_width);
let header_gap = if height == 0 { 0 } else { self.header_gap };
let tab_gap = u16::from(tab_height > 0 && search_field_visible);
height = height.saturating_add(tab_height + tab_gap);
height = height.saturating_add(rows_height + 2 + header_gap);
if self.picker_surface == PickerSurface::Panel {
height = height.saturating_add(/*rhs*/ 1);
}
if search_field_visible {
height = height.saturating_add(/*rhs*/ 1);
}
// Side content: when the terminal is wide enough the panel sits beside
// the list and shares vertical space; otherwise it stacks below.
if self.side_layout_width(inner_width).is_some() {
// Side-by-side — side content shares list rows vertically so it
// doesn't add to total height.
} else {
let side_h = self.stacked_side_content().desired_height(inner_width);
if side_h > 0 {
height = height.saturating_add(1 + side_h);
}
}
let show_selected_description = should_show_selected_description_below(
&rows,
&self.state,
self.max_visible_rows,
effective_rows_width,
column_width,
);
height = height.saturating_add(
self.footer_note_lines(width.saturating_sub(/*rhs*/ 2), show_selected_description)
.len() as u16,
);
height = height.saturating_add(
self.footer_hint_lines(width.saturating_sub(/*rhs*/ 2))
.len() as u16,
);
height
}
fn render(&self, area: Rect, buf: &mut Buffer) {
self.rendered_item_count.set(/*val*/ 0);
self.search_cursor.set(/*val*/ None);
if area.height == 0 || area.width == 0 {
return;
}
let search_field_visible = self.search_field_visible();
let inner_width = popup_content_width(area.width);
let side_w = self.side_layout_width(inner_width);
let effective_rows_width = if let Some(sw) = side_w {
area.width
.saturating_sub(MENU_SURFACE_HORIZONTAL_INSET / 2 + SIDE_CONTENT_GAP + sw)
} else {
area.width
};
let rows = self.build_rows();
let column_width = ColumnWidthConfig::new(self.col_width_mode, self.name_column_width)
.with_description_layout(self.description_layout);
let show_selected_description = should_show_selected_description_below(
&rows,
&self.state,
self.max_visible_rows,
effective_rows_width,
column_width,
);
let note_width = area.width.saturating_sub(2);
let note_lines = self.footer_note_lines(note_width, show_selected_description);
let note_height = note_lines.len() as u16;
let hint_lines = self.footer_hint_lines(note_width);
let hint_height = hint_lines.len() as u16;
let header_height = self.header_height(inner_width);
let tab_height = tab_bar_height(&self.tabs, inner_width);
let mut footer_rows = note_height + hint_height;
// Wrapped hints yield before the title, controls, and selected result.
let minimum_content = u16::from(self.picker_surface == PickerSurface::Panel)
+ header_height.min(/*other*/ 1)
+ tab_height
+ u16::from(search_field_visible)
+ 1;
footer_rows = footer_rows.min(area.height.saturating_sub(minimum_content));
let [content_area, footer_area] =
Layout::vertical([Constraint::Fill(1), Constraint::Length(footer_rows)]).areas(area);
let outer_content_area = content_area;
Self::clear_to_terminal_bg(buf, outer_content_area);
if self.picker_surface == PickerSurface::Panel {
ratatui::widgets::Block::default()
.style(crate::style::user_message_style())
.render(outer_content_area, buf);
}
// The list owns its vertical spacer rows so hints remain adjacent
// to results even when search, tabs, or a header are present.
let content_area = outer_content_area.inset(Insets::vh(/*v*/ 0, /*h*/ 2));
let content_area = if self.picker_surface == PickerSurface::Panel {
// At tiny heights, leave room for both the clipped header and selected row.
let top_gap = u16::from(content_area.height > 2);
Rect::new(
content_area.x,
content_area.y.saturating_add(top_gap),
content_area.width,
content_area.height.saturating_sub(top_gap),
)
} else {
content_area
};
let header = self.active_header(inner_width);
let rows_height = match self.row_display {
SelectionRowDisplay::Wrapped => measure_rows_height_with_col_width_mode(
&rows,
&self.state,
self.max_visible_rows,
effective_rows_width,
column_width,
),
SelectionRowDisplay::SingleLine => {
rows.len().clamp(/*min*/ 1, self.max_visible_rows) as u16
}
};
let rows_height = self.result_area_height(rows_height);
// Stacked (fallback) side content height — only used when not side-by-side.
let stacked_side_h = if side_w.is_none() {
self.stacked_side_content().desired_height(inner_width)
} else {
0
};
let [
header_area,
_,
tabs_area,
_,
search_area,
above_area,
list_area,
below_area,
_,
stacked_side_area,
] = picker_areas(
content_area,
PickerLayoutSizes {
header: header_height,
header_gap: self.header_gap,
tabs: tab_height,
search: u16::from(search_field_visible),
rows: rows_height,
side: stacked_side_h,
},
);
if !search_field_visible && header_area.height < header_height {
let [header_area, elision_area] =
Layout::vertical([Constraint::Fill(1), Constraint::Length(1)]).areas(header_area);
header.render(header_area, buf);
let mut spans = vec![format!("[… {header_height} lines]").into()];
if let Some(hint) = &self.header_view_all_hint {
spans.push(" ".into());
spans.extend(hint.spans());
spans.push(" view all".into());
}
Line::from(spans).dim().render(elision_area, buf);
} else {
header.render(header_area, buf);
}
// -- Tabs --
if tab_height > 0 {
render_tab_bar(
&self.tabs,
self.active_tab_idx.unwrap_or(/*default*/ 0),
tabs_area,
buf,
);
}
// -- Search bar --
if search_field_visible {
let query_span: Span<'static> = if self.search_query.is_empty() {
self.search_placeholder
.as_ref()
.map(|placeholder| placeholder.clone().dim())
.unwrap_or_else(|| "".into())
} else {
self.search_query.clone().into()
};
if self.on_demand_search_active() {
let label = "Search › ";
buf.set_style(search_area, crate::bottom_pane::active_tab_style());
Line::from(vec![label.cyan().bold(), query_span]).render(search_area, buf);
let cursor_offset = (label.width() + self.search_query.width())
.min(usize::from(search_area.width.saturating_sub(/*rhs*/ 1)));
self.search_cursor.set(Some((
search_area.x.saturating_add(cursor_offset as u16),
search_area.y,
)));
} else {
Line::from(query_span).render(search_area, buf);
}
}
// -- List rows --
if list_area.height > 0 {
let render_area = Rect {
x: list_area.x.saturating_sub(/*rhs*/ 2),
y: list_area.y,
width: effective_rows_width.max(1),
height: list_area.height,
};
let rendered_rows = match self.row_display {
SelectionRowDisplay::Wrapped => render_rows_with_col_width_mode(
render_area,
buf,
&rows,
&self.state,
render_area.height as usize,
"no matches",
column_width,
),
SelectionRowDisplay::SingleLine => render_rows_single_line_with_col_width_mode(
render_area,
buf,
&rows,
&self.state,
render_area.height as usize,
"no matches",
column_width,
),
};
self.rendered_item_count.set(rendered_rows.items);
if above_area.height > 0 && below_area.height > 0 {
render_scroll_indicators(
Rect::new(
render_area.x,
above_area.y,
render_area.width,
below_area.bottom().saturating_sub(above_area.y),
),
buf,
rendered_rows,
);
}
}
// -- Side content (preview panel) --
if let Some(sw) = side_w {
// Side-by-side: render to the right half of the popup content
// area so preview content can center vertically in that panel.
let side_x = content_area.x + content_area.width - sw;
let side_area = Rect::new(side_x, content_area.y, sw, content_area.height);
// Clear the menu-surface background behind the side panel so the
// preview appears on the terminal's own background.
let clear_x = side_x.saturating_sub(SIDE_CONTENT_GAP);
let clear_w = outer_content_area
.x
.saturating_add(outer_content_area.width)
.saturating_sub(clear_x);
Self::clear_to_terminal_bg(
buf,
Rect::new(
clear_x,
outer_content_area.y,
clear_w,
outer_content_area.height,
),
);
self.side_content.render(side_area, buf);
if !self.preserve_side_content_bg {
Self::force_bg_to_terminal_bg(
buf,
Rect::new(
clear_x,
outer_content_area.y,
clear_w,
outer_content_area.height,
),
);
}
} else if stacked_side_area.height > 0 {
// Stacked fallback: render below the list (same as old footer_content).
let clear_height = (outer_content_area.y + outer_content_area.height)
.saturating_sub(stacked_side_area.y);
let clear_area = Rect::new(
outer_content_area.x,
stacked_side_area.y,
outer_content_area.width,
clear_height,
);
Self::clear_to_terminal_bg(buf, clear_area);
self.stacked_side_content().render(stacked_side_area, buf);
}
if footer_area.height > 0 {
let [note_area, hint_area] = Layout::vertical([
Constraint::Length(note_height),
Constraint::Length(hint_height),
])
.areas(footer_area);
if !note_lines.is_empty() {
let note_area = Rect {
x: note_area.x + 2,
y: note_area.y,
width: note_area.width.saturating_sub(2),
height: note_area.height,
};
for (idx, line) in note_lines.iter().enumerate() {
if idx as u16 >= note_area.height {
break;
}
let line_area = Rect {
x: note_area.x,
y: note_area.y + idx as u16,
width: note_area.width,
height: 1,
};
line.clone().render(line_area, buf);
}
}
if !hint_lines.is_empty() {
let hint_area = Rect {
x: hint_area.x + 2,
y: hint_area.y,
width: hint_area.width.saturating_sub(2),
height: hint_area.height,
};
Paragraph::new(hint_lines).dim().render(hint_area, buf);
}
}
}
}
impl ListSelectionView {
pub(crate) fn rendered_item_count(&self) -> usize {
self.rendered_item_count.get()
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::app_event::AppEvent;
use crate::bottom_pane::popup_consts::standard_popup_hint_line;
use crossterm::event::KeyCode;
use crossterm::event::KeyEvent;
use crossterm::event::KeyModifiers;
use insta::assert_snapshot;
use pretty_assertions::assert_eq;
use ratatui::buffer::Buffer;
use ratatui::layout::Rect;
use ratatui::style::Color;
use ratatui::style::Style;
use tokio::sync::mpsc::unbounded_channel;
struct MarkerRenderable {
marker: &'static str,
height: u16,
}
impl Renderable for MarkerRenderable {
fn render(&self, area: Rect, buf: &mut Buffer) {
for y in area.y..area.y.saturating_add(area.height) {
for x in area.x..area.x.saturating_add(area.width) {
if x < buf.area().width && y < buf.area().height {
buf[(x, y)].set_symbol(self.marker);
}
}
}
}
fn desired_height(&self, _width: u16) -> u16 {
self.height
}
}
struct StyledMarkerRenderable {
marker: &'static str,
style: Style,
height: u16,
}
impl Renderable for StyledMarkerRenderable {
fn render(&self, area: Rect, buf: &mut Buffer) {
for y in area.y..area.y.saturating_add(area.height) {
for x in area.x..area.x.saturating_add(area.width) {
if x < buf.area().width && y < buf.area().height {
buf[(x, y)].set_symbol(self.marker).set_style(self.style);
}
}
}
}
fn desired_height(&self, _width: u16) -> u16 {
self.height
}
}
fn new_view(params: SelectionViewParams, tx: AppEventSender) -> ListSelectionView {
ListSelectionView::new(params, tx, crate::keymap::RuntimeKeymap::defaults().list)
}
#[test]
fn secondary_action_respects_search_disabled_rows_and_dismissal() {
for (is_searchable, is_disabled, key, expected) in [
(false, false, KeyCode::Char('s'), Some("secondary")),
(false, false, KeyCode::Enter, Some("primary")),
(false, true, KeyCode::Char('s'), None),
(true, false, KeyCode::Char('s'), None),
] {
let (tx, mut rx) = unbounded_channel();
let mut view = new_view(
SelectionViewParams {
is_searchable,
items: vec![SelectionItem {
name: "Selection".into(),
is_disabled,
dismiss_on_select: true,
actions: vec![Box::new(|tx| {
tx.send(AppEvent::UpdateModel("primary".into()))
})],
secondary_action: Some(SelectionSecondaryAction {
key: crate::key_hint::plain(KeyCode::Char('s')),
action: Box::new(|tx| {
tx.send(AppEvent::UpdateModel("secondary".into()))
}),
footer_hint: "s for secondary".into(),
}),
..Default::default()
}],
..Default::default()
},
AppEventSender::new(tx),
);
view.handle_key_event(KeyEvent::from(key));
let actual = rx.try_recv().ok().map(|event| match event {
AppEvent::UpdateModel(model) => model,
event => panic!("unexpected event: {event:?}"),
});
assert_eq!(actual.as_deref(), expected);
assert_eq!(view.completion, expected.map(|_| ViewCompletion::Accepted));
assert_eq!(view.search_query, if is_searchable { "s" } else { "" });
}
}
#[test]
fn searchable_list_honors_configured_printable_accept_alternative() {
let (tx, mut rx) = unbounded_channel();
let mut keymap = crate::keymap::RuntimeKeymap::defaults().list;
keymap.accept = vec![
crate::key_hint::plain(KeyCode::Char('z')),
crate::key_hint::plain(KeyCode::Enter),
];
let mut view = ListSelectionView::new(
SelectionViewParams {
is_searchable: true,
items: vec![SelectionItem {
name: "Selection".into(),
actions: vec![Box::new(|tx| {
tx.send(AppEvent::UpdateModel("accepted".into()))
})],
..Default::default()
}],
..Default::default()
},
AppEventSender::new(tx),
keymap,
);
view.handle_key_event(KeyEvent::from(KeyCode::Char('z')));
assert!(matches!(
rx.try_recv(),
Ok(AppEvent::UpdateModel(model)) if model == "accepted"
));
assert_eq!(view.search_query(), Some(""));
}
fn make_selection_view(subtitle: Option<&str>) -> ListSelectionView {
let (tx_raw, _rx) = unbounded_channel::<AppEvent>();
let tx = AppEventSender::new(tx_raw);
let items = vec![
SelectionItem {
name: "Read Only".to_string(),
description: Some("Codex can read files".to_string()),
is_current: true,
dismiss_on_select: true,
..Default::default()
},
SelectionItem {
name: "Full Access".to_string(),
description: Some("Codex can edit files".to_string()),
is_current: false,
dismiss_on_select: true,
..Default::default()
},
];
new_view(
SelectionViewParams {
title: Some("Select Approval Mode".to_string()),
subtitle: subtitle.map(str::to_string),
footer_hint: Some(standard_popup_hint_line()),
items,
..Default::default()
},
tx,
)
}
fn render_lines(view: &ListSelectionView) -> String {
render_lines_with_width(view, /*width*/ 48)
}
fn render_lines_with_width(view: &ListSelectionView, width: u16) -> String {
render_lines_in_area(view, width, view.desired_height(width))
}
fn render_lines_in_area(view: &ListSelectionView, width: u16, height: u16) -> String {
let area = Rect::new(0, 0, width, height);
let mut buf = Buffer::empty(area);
view.render(area, &mut buf);
let lines: Vec<String> = (0..area.height)
.map(|row| {
let mut line = String::new();
for col in 0..area.width {
let symbol = buf[(area.x + col, area.y + row)].symbol();
if symbol.is_empty() {
line.push(' ');
} else {
line.push_str(symbol);
}
}
line
})
.collect();
lines.join("\n")
}
fn description_col(rendered: &str, item_marker: &str, description: &str) -> usize {
let line = rendered
.lines()
.find(|line| line.contains(item_marker) && line.contains(description))
.expect("expected rendered line to contain row marker and description");
line.find(description)
.expect("expected rendered line to contain description")
}
fn make_scrolling_width_items() -> Vec<SelectionItem> {
let mut items: Vec<SelectionItem> = (1..=8)
.map(|idx| SelectionItem {
name: format!("Item {idx}"),
description: Some(format!("desc {idx}")),
dismiss_on_select: true,
..Default::default()
})
.collect();
items.push(SelectionItem {
name: "Item 9 with an intentionally much longer name".to_string(),
description: Some("desc 9".to_string()),
dismiss_on_select: true,
..Default::default()
});
items
}
fn render_before_after_scroll_snapshot(col_width_mode: ColumnWidthMode, width: u16) -> String {
let (tx_raw, _rx) = unbounded_channel::<AppEvent>();
let tx = AppEventSender::new(tx_raw);
let mut view = ListSelectionView::new(
SelectionViewParams {
title: Some("Debug".to_string()),
items: make_scrolling_width_items(),
col_width_mode,
..Default::default()
},
tx,
crate::keymap::RuntimeKeymap::defaults().list,
);
let before_scroll = render_lines_with_width(&view, width);
for _ in 0..8 {
view.handle_key_event(KeyEvent::from(KeyCode::Down));
}
let after_scroll = render_lines_with_width(&view, width);
format!("before scroll:\n{before_scroll}\n\nafter scroll:\n{after_scroll}")
}
#[test]
fn renders_blank_line_between_title_and_items_without_subtitle() {
let view = make_selection_view(/*subtitle*/ None);
assert_snapshot!(
"list_selection_spacing_without_subtitle",
render_lines(&view)
);
}
#[test]
fn renders_blank_line_between_subtitle_and_items() {
let view = make_selection_view(Some("Switch between Codex approval presets"));
assert_snapshot!("list_selection_spacing_with_subtitle", render_lines(&view));
}
#[test]
fn theme_picker_subtitle_uses_fallback_text_in_94x35_terminal() {
let (tx_raw, _rx) = unbounded_channel::<AppEvent>();
let tx = AppEventSender::new(tx_raw);
let home = dirs::home_dir().expect("home directory should be available");
let codex_home = home.join(".codex");
let params = crate::theme_picker::build_theme_picker_params(
/*current_name*/ None,
Some(&codex_home),
Some(94),
);
let view = new_view(params, tx);
let rendered = render_lines_in_area(&view, /*width*/ 94, /*height*/ 35);
assert!(rendered.contains("Move up/down to live preview themes"));
}
#[test]
fn theme_picker_enables_side_content_background_preservation() {
let params = crate::theme_picker::build_theme_picker_params(
/*current_name*/ None,
/*codex_home*/ None,
Some(120),
);
assert!(
params.preserve_side_content_bg,
"theme picker should preserve side-content backgrounds to keep diff preview styling",
);
}
#[test]
fn preserve_side_content_bg_keeps_rendered_background_colors() {
let (tx_raw, _rx) = unbounded_channel::<AppEvent>();
let tx = AppEventSender::new(tx_raw);
let view = new_view(
SelectionViewParams {
title: Some("Debug".to_string()),
items: vec![SelectionItem {
name: "Item 1".to_string(),
dismiss_on_select: true,
..Default::default()
}],
side_content: Box::new(StyledMarkerRenderable {
marker: "+",
style: Style::default().bg(Color::Blue),
height: 1,
}),
side_content_width: SideContentWidth::Half,
side_content_min_width: 10,
preserve_side_content_bg: true,
..Default::default()
},
tx,
);
let area = Rect::new(0, 0, 120, 35);
let mut buf = Buffer::empty(area);
view.render(area, &mut buf);
let plus_bg = (0..area.height)
.flat_map(|y| (0..area.width).map(move |x| (x, y)))
.find_map(|(x, y)| {
let cell = &buf[(x, y)];
(cell.symbol() == "+").then(|| cell.style().bg)
})
.expect("expected side content to render at least one '+' marker");
assert_eq!(
plus_bg,
Some(Color::Blue),
"expected side-content marker to preserve custom background styling",
);
}
#[test]
fn snapshot_footer_note_wraps() {
let (tx_raw, _rx) = unbounded_channel::<AppEvent>();
let tx = AppEventSender::new(tx_raw);
let items = vec![SelectionItem {
name: "Read Only".to_string(),
description: Some("Codex can read files".to_string()),
is_current: true,
dismiss_on_select: true,
..Default::default()
}];
let footer_note = Line::from(vec![
"Note: ".dim(),
"Use /setup-default-sandbox".cyan(),
" to allow network access.".dim(),
]);
let view = new_view(
SelectionViewParams {
title: Some("Select Approval Mode".to_string()),
footer_note: Some(footer_note),
footer_hint: Some(standard_popup_hint_line()),
items,
..Default::default()
},
tx,
);
assert_snapshot!(
"list_selection_footer_note_wraps",
render_lines_with_width(&view, /*width*/ 40)
);
}
#[test]
fn renders_search_query_line_when_enabled() {
let (tx_raw, _rx) = unbounded_channel::<AppEvent>();
let tx = AppEventSender::new(tx_raw);
let items = vec![SelectionItem {
name: "Read Only".to_string(),
description: Some("Codex can read files".to_string()),
is_current: false,
dismiss_on_select: true,
..Default::default()
}];
let mut view = new_view(
SelectionViewParams {
title: Some("Select Approval Mode".to_string()),
footer_hint: Some(standard_popup_hint_line()),
items,
is_searchable: true,
search_placeholder: Some("Type to search branches".to_string()),
..Default::default()
},
tx,
);
view.set_search_query("filters".to_string());
let lines = render_lines(&view);
assert!(
lines.contains("filters"),
"expected search query line to include rendered query, got {lines:?}"
);
}
#[test]
fn empty_searchable_list_keeps_search_and_no_matches_visible() {
let (tx_raw, _rx) = unbounded_channel::<AppEvent>();
let tx = AppEventSender::new(tx_raw);
let view = new_view(
SelectionViewParams {
title: Some("Select a base branch".to_string()),
footer_hint: Some(standard_popup_hint_line()),
is_searchable: true,
search_placeholder: Some("Type to search branches".to_string()),
..Default::default()
},
tx,
);
let rendered = render_lines_with_width(&view, /*width*/ 48)
.lines()
.map(str::trim_end)
.collect::<Vec<_>>()
.join("\n");
assert_snapshot!("list_selection_empty_searchable", rendered);
}
#[test]
fn paste_appends_to_search_query_and_filters_items() {
let (tx_raw, _rx) = unbounded_channel::<AppEvent>();
let tx = AppEventSender::new(tx_raw);
let mut view = new_view(
SelectionViewParams {
items: vec![
SelectionItem {
name: "main -> feature/other".to_string(),
search_value: Some("feature/other".to_string()),
..Default::default()
},
SelectionItem {
name: "main -> feature/paste-support".to_string(),
search_value: Some("feature/paste-support".to_string()),
..Default::default()
},
],
is_searchable: true,
..Default::default()
},
tx,
);
view.handle_key_event(KeyEvent::new(KeyCode::Char('f'), KeyModifiers::NONE));
assert!(view.handle_paste("eature/paste-support\n".to_string()));
assert_eq!(view.search_query, "feature/paste-support");
assert_eq!(view.filtered_indices, vec![1]);
assert_eq!(view.selected_actual_idx(), Some(1));
}
#[test]
fn whitespace_only_paste_is_ignored() {
let (tx_raw, _rx) = unbounded_channel::<AppEvent>();
let tx = AppEventSender::new(tx_raw);
let mut view = new_view(
SelectionViewParams {
items: vec![SelectionItem {
name: "main".to_string(),
search_value: Some("main".to_string()),
..Default::default()
}],
is_searchable: true,
..Default::default()
},
tx,
);
assert!(!view.handle_paste(" \n\t ".to_string()));
assert_eq!(view.search_query, "");
assert_eq!(view.filtered_indices, vec![0]);
}
#[test]
fn switching_tabs_changes_visible_items_and_clears_search() {
let (tx_raw, _rx) = unbounded_channel::<AppEvent>();
let tx = AppEventSender::new(tx_raw);
let mut view = ListSelectionView::new(
SelectionViewParams {
tabs: vec![
SelectionTab {
id: "alpha".to_string(),
label: "Alpha".to_string(),
header: Box::new(()),
items: vec![SelectionItem {
name: "Alpha Item".to_string(),
dismiss_on_select: true,
..Default::default()
}],
},
SelectionTab {
id: "beta".to_string(),
label: "Beta".to_string(),
header: Box::new(()),
items: vec![SelectionItem {
name: "Beta Item".to_string(),
dismiss_on_select: true,
..Default::default()
}],
},
],
initial_tab_id: Some("beta".to_string()),
is_searchable: true,
..Default::default()
},
tx,
crate::keymap::RuntimeKeymap::defaults().list,
);
view.set_search_query("beta".to_string());
view.handle_key_event(KeyEvent::from(KeyCode::Left));
assert_eq!(view.active_tab_id(), Some("alpha"));
assert_eq!(view.search_query, "");
view.handle_key_event(KeyEvent::new(KeyCode::Char('l'), KeyModifiers::CONTROL));
assert_eq!(view.active_tab_id(), Some("beta"));
view.handle_key_event(KeyEvent::new(KeyCode::Char('h'), KeyModifiers::CONTROL));
assert_eq!(view.active_tab_id(), Some("alpha"));
let rendered = render_lines(&view);
assert!(
rendered.contains("Alpha Item") && !rendered.contains("Beta Item"),
"expected switched tab to render the alpha items, got:\n{rendered}"
);
}
#[test]
fn tabbed_view_preserves_current_row_on_initial_selection_and_tab_switch() {
let (tx_raw, _rx) = unbounded_channel::<AppEvent>();
let tx = AppEventSender::new(tx_raw);
let mut view = ListSelectionView::new(
SelectionViewParams {
tabs: vec![
SelectionTab {
id: "alpha".to_string(),
label: "Alpha".to_string(),
header: Box::new(()),
items: vec![
SelectionItem {
name: "Alpha First".to_string(),
dismiss_on_select: true,
..Default::default()
},
SelectionItem {
name: "Alpha Current".to_string(),
is_current: true,
dismiss_on_select: true,
..Default::default()
},
],
},
SelectionTab {
id: "beta".to_string(),
label: "Beta".to_string(),
header: Box::new(()),
items: vec![
SelectionItem {
name: "Beta First".to_string(),
dismiss_on_select: true,
..Default::default()
},
SelectionItem {
name: "Beta Current".to_string(),
is_current: true,
dismiss_on_select: true,
..Default::default()
},
],
},
],
initial_tab_id: Some("beta".to_string()),
..Default::default()
},
tx,
crate::keymap::RuntimeKeymap::defaults().list,
);
assert_eq!(view.active_tab_id(), Some("beta"));
assert_eq!(view.selected_actual_idx(), Some(1));
view.handle_key_event(KeyEvent::from(KeyCode::Left));
assert_eq!(view.active_tab_id(), Some("alpha"));
assert_eq!(view.selected_actual_idx(), Some(1));
}
#[test]
fn space_appends_to_active_search_instead_of_toggling_selected_item() {
let (tx_raw, mut rx) = unbounded_channel::<AppEvent>();
let tx = AppEventSender::new(tx_raw);
let mut view = ListSelectionView::new(
SelectionViewParams {
items: vec![SelectionItem {
name: "Plugin".to_string(),
toggle: Some(SelectionToggle {
is_on: false,
action: Box::new(|_enabled, tx: &_| {
tx.send(AppEvent::OpenApprovalsPopup);
}),
}),
..Default::default()
}],
is_searchable: true,
..Default::default()
},
tx,
crate::keymap::RuntimeKeymap::defaults().list,
);
view.set_search_query("plugin".to_string());
view.handle_key_event(KeyEvent::new(KeyCode::Char(' '), KeyModifiers::NONE));
assert_eq!(view.search_query, "plugin ");
assert!(
!view.active_items()[0]
.toggle
.as_ref()
.is_some_and(|toggle| toggle.is_on),
"expected Space to leave the toggle state unchanged while search is active"
);
assert!(
rx.try_recv().is_err(),
"expected Space with an active search query to avoid firing the toggle action"
);
}
#[test]
fn configured_list_binding_takes_precedence_over_search_toggle_key() {
let (tx_raw, mut rx) = unbounded_channel::<AppEvent>();
let tx = AppEventSender::new(tx_raw);
let mut keymap = crate::keymap::RuntimeKeymap::defaults().list;
keymap.move_down = vec![crate::key_hint::plain(KeyCode::Tab)];
let mut view = ListSelectionView::new(
SelectionViewParams {
items: vec![
SelectionItem {
name: "Plugin".to_string(),
toggle: Some(SelectionToggle {
is_on: false,
action: Box::new(|_enabled, tx: &_| {
tx.send(AppEvent::OpenApprovalsPopup);
}),
}),
..Default::default()
},
SelectionItem {
name: "Next".to_string(),
..Default::default()
},
],
is_searchable: true,
search_toggle_key: Some(crate::key_hint::plain(KeyCode::Tab)),
..Default::default()
},
tx,
keymap,
);
view.handle_key_event(KeyEvent::from(KeyCode::Tab));
assert_eq!(view.selected_actual_idx(), Some(1));
assert!(
!view.active_items()[0]
.toggle
.as_ref()
.is_some_and(|toggle| toggle.is_on),
"expected the configured move-down binding to leave the toggle unchanged"
);
assert!(
rx.try_recv().is_err(),
"expected the configured move-down binding not to fire the toggle action"
);
}
#[test]
fn configured_cancel_binding_takes_precedence_over_space_toggle() {
let (tx_raw, mut rx) = unbounded_channel::<AppEvent>();
let tx = AppEventSender::new(tx_raw);
let mut keymap = crate::keymap::RuntimeKeymap::defaults().list;
keymap.cancel = vec![crate::key_hint::plain(KeyCode::Char(' '))];
let mut view = ListSelectionView::new(
SelectionViewParams {
items: vec![SelectionItem {
name: "Animations".to_string(),
toggle: Some(SelectionToggle {
is_on: true,
action: Box::new(|_enabled, tx: &_| {
tx.send(AppEvent::OpenApprovalsPopup);
}),
}),
checkbox_toggle: true,
..Default::default()
}],
..Default::default()
},
tx,
keymap,
);
view.handle_key_event(KeyEvent::new(KeyCode::Char(' '), KeyModifiers::NONE));
assert_eq!(view.completion, Some(ViewCompletion::Cancelled));
assert!(
view.active_items()[0]
.toggle
.as_ref()
.is_some_and(|toggle| toggle.is_on)
);
assert!(rx.try_recv().is_err());
}
#[test]
fn single_line_row_display_truncates_instead_of_wrapping() {
let (tx_raw, _rx) = unbounded_channel::<AppEvent>();
let tx = AppEventSender::new(tx_raw);
let single_line_view = ListSelectionView::new(
SelectionViewParams {
title: Some("Debug".to_string()),
items: vec![SelectionItem {
name: "A very long plugin name".to_string(),
description: Some(
"A very long description that would normally wrap onto another line."
.to_string(),
),
dismiss_on_select: true,
..Default::default()
}],
row_display: SelectionRowDisplay::SingleLine,
..Default::default()
},
tx,
crate::keymap::RuntimeKeymap::defaults().list,
);
let (wrapped_tx_raw, _wrapped_rx) = unbounded_channel::<AppEvent>();
let wrapped_tx = AppEventSender::new(wrapped_tx_raw);
let wrapped_view = ListSelectionView::new(
SelectionViewParams {
title: Some("Debug".to_string()),
items: vec![SelectionItem {
name: "A very long plugin name".to_string(),
description: Some(
"A very long description that would normally wrap onto another line."
.to_string(),
),
dismiss_on_select: true,
..Default::default()
}],
..Default::default()
},
wrapped_tx,
crate::keymap::RuntimeKeymap::defaults().list,
);
let rendered = render_lines_with_width(&single_line_view, /*width*/ 36);
assert!(
rendered.contains("…"),
"expected single-line rendering to truncate with an ellipsis, got:\n{rendered}"
);
assert!(
single_line_view.desired_height(/*width*/ 36)
< wrapped_view.desired_height(/*width*/ 36),
"expected single-line rendering to reserve less height than wrapped rendering:\nsingle-line:\n{rendered}\n\nwrapped:\n{}",
render_lines_with_width(&wrapped_view, /*width*/ 36)
);
}
#[test]
fn name_column_width_override_moves_description_column_right() {
let auto_items = vec![
SelectionItem {
name: "Short".to_string(),
description: Some("desc".to_string()),
dismiss_on_select: true,
..Default::default()
},
SelectionItem {
name: "Longer".to_string(),
description: Some("desc".to_string()),
dismiss_on_select: true,
..Default::default()
},
];
let widened_items = vec![
SelectionItem {
name: "Short".to_string(),
description: Some("desc".to_string()),
dismiss_on_select: true,
..Default::default()
},
SelectionItem {
name: "Longer".to_string(),
description: Some("desc".to_string()),
dismiss_on_select: true,
..Default::default()
},
];
let (auto_tx_raw, _auto_rx) = unbounded_channel::<AppEvent>();
let auto_tx = AppEventSender::new(auto_tx_raw);
let auto_view = ListSelectionView::new(
SelectionViewParams {
items: auto_items,
row_display: SelectionRowDisplay::SingleLine,
col_width_mode: ColumnWidthMode::AutoVisible,
..Default::default()
},
auto_tx,
crate::keymap::RuntimeKeymap::defaults().list,
);
let (widened_tx_raw, _widened_rx) = unbounded_channel::<AppEvent>();
let widened_tx = AppEventSender::new(widened_tx_raw);
let widened_view = ListSelectionView::new(
SelectionViewParams {
items: widened_items,
row_display: SelectionRowDisplay::SingleLine,
col_width_mode: ColumnWidthMode::AutoVisible,
name_column_width: Some(18),
..Default::default()
},
widened_tx,
crate::keymap::RuntimeKeymap::defaults().list,
);
let auto_rendered = render_lines_with_width(&auto_view, /*width*/ 48);
let widened_rendered = render_lines_with_width(&widened_view, /*width*/ 48);
let auto_col = description_col(&auto_rendered, "1. Short", "desc");
let widened_col = description_col(&widened_rendered, "1. Short", "desc");
assert!(
widened_col > auto_col,
"expected name column override to push the description right:\nauto:\n{auto_rendered}\n\nwidened:\n{widened_rendered}"
);
}
#[test]
fn enter_with_no_matches_triggers_cancel_callback() {
let (tx_raw, mut rx) = unbounded_channel::<AppEvent>();
let tx = AppEventSender::new(tx_raw);
let mut view = new_view(
SelectionViewParams {
items: vec![SelectionItem {
name: "Read Only".to_string(),
dismiss_on_select: true,
..Default::default()
}],
is_searchable: true,
on_cancel: Some(Box::new(|tx: &_| {
tx.send(AppEvent::OpenApprovalsPopup);
})),
..Default::default()
},
tx,
);
view.set_search_query("no-matches".to_string());
view.handle_key_event(KeyEvent::from(KeyCode::Enter));
assert!(view.is_complete());
match rx.try_recv() {
Ok(AppEvent::OpenApprovalsPopup) => {}
Ok(other) => panic!("expected OpenApprovalsPopup cancel event, got {other:?}"),
Err(err) => panic!("expected cancel callback event, got {err}"),
}
}
#[test]
fn move_down_without_selection_change_does_not_fire_callback() {
let (tx_raw, mut rx) = unbounded_channel::<AppEvent>();
let tx = AppEventSender::new(tx_raw);
let mut view = new_view(
SelectionViewParams {
items: vec![SelectionItem {
name: "Only choice".to_string(),
dismiss_on_select: true,
..Default::default()
}],
on_selection_changed: Some(Box::new(|_idx, tx: &_| {
tx.send(AppEvent::OpenApprovalsPopup);
})),
..Default::default()
},
tx,
);
while rx.try_recv().is_ok() {}
view.handle_key_event(KeyEvent::from(KeyCode::Down));
assert!(
rx.try_recv().is_err(),
"moving down in a single-item list should not fire on_selection_changed",
);
}
#[test]
fn disabled_current_rows_skip_default_selection_and_number_shortcuts() {
let (tx_raw, _rx) = unbounded_channel::<AppEvent>();
let tx = AppEventSender::new(tx_raw);
let mut view = ListSelectionView::new(
SelectionViewParams {
items: vec![
SelectionItem {
name: "Unavailable".to_string(),
description: Some("Not available right now.".to_string()),
is_current: true,
is_disabled: true,
..Default::default()
},
SelectionItem {
name: "Alpha".to_string(),
dismiss_on_select: true,
..Default::default()
},
SelectionItem {
name: "Busy".to_string(),
description: Some("Still disabled.".to_string()),
disabled_reason: Some("Try again later.".to_string()),
..Default::default()
},
SelectionItem {
name: "Beta".to_string(),
dismiss_on_select: true,
..Default::default()
},
],
..Default::default()
},
tx,
crate::keymap::RuntimeKeymap::defaults().list,
);
assert_eq!(view.selected_actual_idx(), Some(1));
let rendered = render_lines_with_width(&view, /*width*/ 60);
assert!(
rendered.contains("› 1. Alpha"),
"expected first enabled row to be selected and numbered 1, got:\n{rendered}"
);
assert!(
rendered.contains(" 2. Beta"),
"expected second enabled row to be numbered 2, got:\n{rendered}"
);
assert!(
!rendered.contains("1. Unavailable") && !rendered.contains("3. Beta"),
"expected disabled rows to be skipped by numbering, got:\n{rendered}"
);
view.handle_key_event(KeyEvent::new(KeyCode::Char('2'), KeyModifiers::NONE));
assert_eq!(view.take_last_selected_index(), Some(3));
}
#[test]
fn c0_ctrl_p_respects_unbound_list_move_up() {
let (tx_raw, _rx) = unbounded_channel::<AppEvent>();
let tx = AppEventSender::new(tx_raw);
let mut keymap = crate::keymap::RuntimeKeymap::defaults().list;
keymap.move_up.clear();
let mut view = ListSelectionView::new(
SelectionViewParams {
items: vec![
SelectionItem {
name: "First".to_string(),
..Default::default()
},
SelectionItem {
name: "Second".to_string(),
..Default::default()
},
],
initial_selected_idx: Some(1),
is_searchable: true,
..Default::default()
},
tx,
keymap,
);
view.handle_key_event(KeyEvent::new(KeyCode::Char('\u{0010}'), KeyModifiers::NONE));
assert_eq!(view.selected_actual_idx(), Some(1));
assert_eq!(view.search_query, "");
}
#[test]
fn c0_ctrl_n_respects_unbound_list_move_down() {
let (tx_raw, _rx) = unbounded_channel::<AppEvent>();
let tx = AppEventSender::new(tx_raw);
let mut keymap = crate::keymap::RuntimeKeymap::defaults().list;
keymap.move_down.clear();
let mut view = ListSelectionView::new(
SelectionViewParams {
items: vec![
SelectionItem {
name: "First".to_string(),
..Default::default()
},
SelectionItem {
name: "Second".to_string(),
..Default::default()
},
],
is_searchable: true,
..Default::default()
},
tx,
keymap,
);
view.handle_key_event(KeyEvent::new(KeyCode::Char('\u{000e}'), KeyModifiers::NONE));
assert_eq!(view.selected_actual_idx(), Some(0));
assert_eq!(view.search_query, "");
}
#[test]
fn c0_ctrl_p_respects_remapped_list_move_down() {
let (tx_raw, _rx) = unbounded_channel::<AppEvent>();
let tx = AppEventSender::new(tx_raw);
let mut keymap = crate::keymap::RuntimeKeymap::defaults().list;
keymap.move_up.clear();
keymap.move_down = vec![crate::key_hint::ctrl(KeyCode::Char('p'))];
let mut view = ListSelectionView::new(
SelectionViewParams {
items: vec![
SelectionItem {
name: "First".to_string(),
..Default::default()
},
SelectionItem {
name: "Second".to_string(),
..Default::default()
},
],
is_searchable: true,
..Default::default()
},
tx,
keymap,
);
view.handle_key_event(KeyEvent::new(KeyCode::Char('\u{0010}'), KeyModifiers::NONE));
assert_eq!(view.selected_actual_idx(), Some(1));
}
#[test]
fn page_and_jump_navigation_use_list_keymap() {
let (tx_raw, _rx) = unbounded_channel::<AppEvent>();
let tx = AppEventSender::new(tx_raw);
let mut keymap = crate::keymap::RuntimeKeymap::defaults().list;
keymap.page_down = vec![crate::key_hint::ctrl(KeyCode::Char('d'))];
keymap.page_up = vec![crate::key_hint::ctrl(KeyCode::Char('u'))];
keymap.jump_bottom = vec![crate::key_hint::ctrl(KeyCode::Char('e'))];
keymap.jump_top = vec![crate::key_hint::ctrl(KeyCode::Char('a'))];
let mut view = ListSelectionView::new(
SelectionViewParams {
items: (0..12)
.map(|idx| SelectionItem {
name: format!("Item {idx}"),
..Default::default()
})
.collect(),
..Default::default()
},
tx,
keymap,
);
view.handle_key_event(KeyEvent::from(KeyCode::PageDown));
assert_eq!(view.selected_actual_idx(), Some(0));
view.handle_key_event(KeyEvent::new(KeyCode::Char('d'), KeyModifiers::CONTROL));
assert_eq!(view.selected_actual_idx(), Some(8));
view.handle_key_event(KeyEvent::new(KeyCode::Char('u'), KeyModifiers::CONTROL));
assert_eq!(view.selected_actual_idx(), Some(0));
view.handle_key_event(KeyEvent::new(KeyCode::Char('e'), KeyModifiers::CONTROL));
assert_eq!(view.selected_actual_idx(), Some(11));
view.handle_key_event(KeyEvent::new(KeyCode::Char('a'), KeyModifiers::CONTROL));
assert_eq!(view.selected_actual_idx(), Some(0));
}
#[test]
fn page_and_jump_navigation_skip_trailing_disabled_rows_without_wrapping() {
let (tx_raw, _rx) = unbounded_channel::<AppEvent>();
let tx = AppEventSender::new(tx_raw);
let mut view = ListSelectionView::new(
SelectionViewParams {
items: (0..12)
.map(|idx| SelectionItem {
name: format!("Item {idx}"),
is_disabled: idx >= 8,
..Default::default()
})
.collect(),
..Default::default()
},
tx,
crate::keymap::RuntimeKeymap::defaults().list,
);
view.handle_key_event(KeyEvent::from(KeyCode::PageDown));
assert_eq!(view.selected_actual_idx(), Some(7));
let selected = view.state.selected_idx.expect("selection should be set");
assert!(view.state.scroll_top <= selected);
assert!(selected < view.state.scroll_top + view.visible_rows(/*len*/ 12));
view.handle_key_event(KeyEvent::from(KeyCode::End));
assert_eq!(view.selected_actual_idx(), Some(7));
let selected = view.state.selected_idx.expect("selection should be set");
assert!(view.state.scroll_top <= selected);
assert!(selected < view.state.scroll_top + view.visible_rows(/*len*/ 12));
}
#[test]
fn wraps_long_option_without_overflowing_columns() {
let (tx_raw, _rx) = unbounded_channel::<AppEvent>();
let tx = AppEventSender::new(tx_raw);
let items = vec![
SelectionItem {
name: "Yes, proceed".to_string(),
dismiss_on_select: true,
..Default::default()
},
SelectionItem {
name: "Yes, and don't ask again for commands that start with `python -mpre_commit run --files eslint-plugin/no-mixed-const-enum-exports.js`".to_string(),
dismiss_on_select: true,
..Default::default()
},
];
let view = new_view(
SelectionViewParams {
title: Some("Approval".to_string()),
items,
..Default::default()
},
tx,
);
let rendered = render_lines_with_width(&view, /*width*/ 60);
let command_line = rendered
.lines()
.find(|line| line.contains("python -mpre_commit run"))
.expect("rendered lines should include wrapped command");
assert!(
command_line.starts_with(" `python -mpre_commit run"),
"wrapped command line should align under the numbered prefix:\n{rendered}"
);
assert!(
rendered.contains("eslint-plugin/no-")
&& rendered.contains("mixed-const-enum-exports.js"),
"long command should not be truncated even when wrapped:\n{rendered}"
);
}
#[test]
fn width_changes_do_not_hide_rows() {
let (tx_raw, _rx) = unbounded_channel::<AppEvent>();
let tx = AppEventSender::new(tx_raw);
let items = vec![
SelectionItem {
name: "gpt-5.1-codex".to_string(),
description: Some(
"Optimized for Codex. Balance of reasoning quality and coding ability."
.to_string(),
),
is_current: true,
dismiss_on_select: true,
..Default::default()
},
SelectionItem {
name: "gpt-5.1-codex-mini".to_string(),
description: Some(
"Optimized for Codex. Cheaper, faster, but less capable.".to_string(),
),
dismiss_on_select: true,
..Default::default()
},
SelectionItem {
name: "gpt-4.1-codex".to_string(),
description: Some(
"Legacy model. Use when you need compatibility with older automations."
.to_string(),
),
dismiss_on_select: true,
..Default::default()
},
];
let view = new_view(
SelectionViewParams {
title: Some("Select Model and Effort".to_string()),
items,
..Default::default()
},
tx,
);
let mut missing: Vec<u16> = Vec::new();
for width in 60..=90 {
let rendered = render_lines_with_width(&view, width);
if !rendered.contains("3.") {
missing.push(width);
}
}
assert!(
missing.is_empty(),
"third option missing at widths {missing:?}"
);
}
#[test]
fn narrow_width_keeps_all_rows_visible() {
let (tx_raw, _rx) = unbounded_channel::<AppEvent>();
let tx = AppEventSender::new(tx_raw);
let desc = "x".repeat(10);
let items: Vec<SelectionItem> = (1..=3)
.map(|idx| SelectionItem {
name: format!("Item {idx}"),
description: Some(desc.clone()),
dismiss_on_select: true,
..Default::default()
})
.collect();
let view = new_view(
SelectionViewParams {
title: Some("Debug".to_string()),
items,
..Default::default()
},
tx,
);
let rendered = render_lines_with_width(&view, /*width*/ 24);
assert!(
rendered.contains("3."),
"third option missing for width 24:\n{rendered}"
);
}
#[test]
fn snapshot_model_picker_width_80() {
let (tx_raw, _rx) = unbounded_channel::<AppEvent>();
let tx = AppEventSender::new(tx_raw);
let items = vec![
SelectionItem {
name: "gpt-5.1-codex".to_string(),
description: Some(
"Optimized for Codex. Balance of reasoning quality and coding ability."
.to_string(),
),
is_current: true,
dismiss_on_select: true,
..Default::default()
},
SelectionItem {
name: "gpt-5.1-codex-mini".to_string(),
description: Some(
"Optimized for Codex. Cheaper, faster, but less capable.".to_string(),
),
dismiss_on_select: true,
..Default::default()
},
SelectionItem {
name: "gpt-4.1-codex".to_string(),
description: Some(
"Legacy model. Use when you need compatibility with older automations."
.to_string(),
),
dismiss_on_select: true,
..Default::default()
},
];
let view = new_view(
SelectionViewParams {
title: Some("Select Model and Effort".to_string()),
items,
..Default::default()
},
tx,
);
assert_snapshot!(
"list_selection_model_picker_width_80",
render_lines_with_width(&view, /*width*/ 80)
);
}
#[test]
fn snapshot_narrow_width_preserves_third_option() {
let (tx_raw, _rx) = unbounded_channel::<AppEvent>();
let tx = AppEventSender::new(tx_raw);
let desc = "x".repeat(10);
let items: Vec<SelectionItem> = (1..=3)
.map(|idx| SelectionItem {
name: format!("Item {idx}"),
description: Some(desc.clone()),
dismiss_on_select: true,
..Default::default()
})
.collect();
let view = new_view(
SelectionViewParams {
title: Some("Debug".to_string()),
items,
..Default::default()
},
tx,
);
assert_snapshot!(
"list_selection_narrow_width_preserves_rows",
render_lines_with_width(&view, /*width*/ 24)
);
}
#[test]
fn snapshot_narrow_width_counts_halfwidth_sound_marks() {
let (tx_raw, _rx) = unbounded_channel::<AppEvent>();
let tx = AppEventSender::new(tx_raw);
let items = vec![
SelectionItem {
name: "abガc".to_string(),
description: Some("dakuten description".to_string()),
dismiss_on_select: true,
..Default::default()
},
SelectionItem {
name: "aパc".to_string(),
description: Some("handakuten description".to_string()),
dismiss_on_select: true,
..Default::default()
},
];
let view = new_view(
SelectionViewParams {
title: Some("Halfwidth sound marks".to_string()),
items,
..Default::default()
},
tx,
);
let rendered = format!(
"width 20:\n{}\n\nwidth 24:\n{}",
render_lines_with_width(&view, /*width*/ 20),
render_lines_with_width(&view, /*width*/ 24)
);
assert_snapshot!("list_selection_halfwidth_sound_marks_narrow", rendered);
}
#[test]
fn snapshot_auto_visible_col_width_mode_scroll_behavior() {
assert_snapshot!(
"list_selection_col_width_mode_auto_visible_scroll",
render_before_after_scroll_snapshot(ColumnWidthMode::AutoVisible, /*width*/ 96)
);
}
#[test]
fn snapshot_auto_all_rows_col_width_mode_scroll_behavior() {
assert_snapshot!(
"list_selection_col_width_mode_auto_all_rows_scroll",
render_before_after_scroll_snapshot(ColumnWidthMode::AutoAllRows, /*width*/ 96)
);
}
#[test]
fn auto_all_rows_col_width_does_not_shift_when_scrolling() {
let (tx_raw, _rx) = unbounded_channel::<AppEvent>();
let tx = AppEventSender::new(tx_raw);
let mut view = ListSelectionView::new(
SelectionViewParams {
title: Some("Debug".to_string()),
items: make_scrolling_width_items(),
col_width_mode: ColumnWidthMode::AutoAllRows,
..Default::default()
},
tx,
crate::keymap::RuntimeKeymap::defaults().list,
);
let before_scroll = render_lines_with_width(&view, /*width*/ 96);
for _ in 0..8 {
view.handle_key_event(KeyEvent::from(KeyCode::Down));
}
let after_scroll = render_lines_with_width(&view, /*width*/ 96);
assert!(
after_scroll.contains("9. Item 9 with an intentionally much longer name"),
"expected the scrolled view to include the longer row:\n{after_scroll}"
);
let before_col = description_col(&before_scroll, "8. Item 8", "desc 8");
let after_col = description_col(&after_scroll, "8. Item 8", "desc 8");
assert_eq!(
before_col, after_col,
"description column changed across scroll:\nbefore:\n{before_scroll}\nafter:\n{after_scroll}"
);
}
#[test]
fn side_layout_width_half_uses_exact_split() {
let (tx_raw, _rx) = unbounded_channel::<AppEvent>();
let tx = AppEventSender::new(tx_raw);
let view = new_view(
SelectionViewParams {
items: vec![SelectionItem {
name: "Item 1".to_string(),
dismiss_on_select: true,
..Default::default()
}],
side_content: Box::new(MarkerRenderable {
marker: "W",
height: 1,
}),
side_content_width: SideContentWidth::Half,
side_content_min_width: 10,
..Default::default()
},
tx,
);
let content_width: u16 = 120;
let expected = content_width.saturating_sub(SIDE_CONTENT_GAP) / 2;
assert_eq!(view.side_layout_width(content_width), Some(expected));
}
#[test]
fn side_layout_width_half_falls_back_when_list_would_be_too_narrow() {
let (tx_raw, _rx) = unbounded_channel::<AppEvent>();
let tx = AppEventSender::new(tx_raw);
let view = new_view(
SelectionViewParams {
items: vec![SelectionItem {
name: "Item 1".to_string(),
dismiss_on_select: true,
..Default::default()
}],
side_content: Box::new(MarkerRenderable {
marker: "W",
height: 1,
}),
side_content_width: SideContentWidth::Half,
side_content_min_width: 50,
..Default::default()
},
tx,
);
assert_eq!(view.side_layout_width(/*content_width*/ 80), None);
}
#[test]
fn stacked_side_content_is_used_when_side_by_side_does_not_fit() {
let (tx_raw, _rx) = unbounded_channel::<AppEvent>();
let tx = AppEventSender::new(tx_raw);
let view = new_view(
SelectionViewParams {
title: Some("Debug".to_string()),
items: vec![SelectionItem {
name: "Item 1".to_string(),
dismiss_on_select: true,
..Default::default()
}],
side_content: Box::new(MarkerRenderable {
marker: "W",
height: 1,
}),
stacked_side_content: Some(Box::new(MarkerRenderable {
marker: "N",
height: 1,
})),
side_content_width: SideContentWidth::Half,
side_content_min_width: 60,
..Default::default()
},
tx,
);
let rendered = render_lines_with_width(&view, /*width*/ 70);
assert!(
rendered.contains('N'),
"expected stacked marker to be rendered:\n{rendered}"
);
assert!(
!rendered.contains('W'),
"wide marker should not render in stacked mode:\n{rendered}"
);
}
#[test]
fn side_content_clearing_resets_symbols_and_style() {
let (tx_raw, _rx) = unbounded_channel::<AppEvent>();
let tx = AppEventSender::new(tx_raw);
let view = new_view(
SelectionViewParams {
title: Some("Debug".to_string()),
items: vec![SelectionItem {
name: "Item 1".to_string(),
dismiss_on_select: true,
..Default::default()
}],
side_content: Box::new(MarkerRenderable {
marker: "W",
height: 1,
}),
side_content_width: SideContentWidth::Half,
side_content_min_width: 10,
..Default::default()
},
tx,
);
let width = 120;
let height = view.desired_height(width);
let area = Rect::new(0, 0, width, height);
let mut buf = Buffer::empty(area);
for y in 0..height {
for x in 0..width {
buf[(x, y)]
.set_symbol("X")
.set_style(Style::default().bg(Color::Red));
}
}
view.render(area, &mut buf);
let cell = &buf[(width - 1, 0)];
assert_eq!(cell.symbol(), " ");
let style = cell.style();
assert_eq!(style.fg, Some(Color::Reset));
assert_eq!(style.bg, Some(Color::Reset));
assert_eq!(style.underline_color, Some(Color::Reset));
let mut saw_marker = false;
for y in 0..height {
for x in 0..width {
let cell = &buf[(x, y)];
if cell.symbol() == "W" {
saw_marker = true;
assert_eq!(cell.style().bg, Some(Color::Reset));
}
}
}
assert!(
saw_marker,
"expected side marker renderable to draw into buffer"
);
}
#[test]
fn side_content_clearing_handles_non_zero_buffer_origin() {
let (tx_raw, _rx) = unbounded_channel::<AppEvent>();
let tx = AppEventSender::new(tx_raw);
let view = new_view(
SelectionViewParams {
title: Some("Debug".to_string()),
items: vec![SelectionItem {
name: "Item 1".to_string(),
dismiss_on_select: true,
..Default::default()
}],
side_content: Box::new(MarkerRenderable {
marker: "W",
height: 1,
}),
side_content_width: SideContentWidth::Half,
side_content_min_width: 10,
..Default::default()
},
tx,
);
let width = 120;
let height = view.desired_height(width);
let area = Rect::new(0, 20, width, height);
let mut buf = Buffer::empty(area);
for y in area.y..area.y + height {
for x in area.x..area.x + width {
buf[(x, y)]
.set_symbol("X")
.set_style(Style::default().bg(Color::Red));
}
}
view.render(area, &mut buf);
let cell = &buf[(area.x + width - 1, area.y)];
assert_eq!(cell.symbol(), " ");
assert_eq!(cell.style().bg, Some(Color::Reset));
}
}
#[cfg(test)]
#[path = "selection_picker_tests.rs"]
mod picker_tests;