//! Question prompt rows — the options and the typed answer, measured and laid out into lines. use super::state::QuestionPromptState; use super::{CUSTOM_PLACEHOLDER, MAX_DESCRIPTION_ROWS, MIN_DESCRIPTION_WIDTH, RECOMMENDED_BADGE}; use crate::widgets::truncate_end as truncate; use ratatui::text::{Line, Span}; /// One selectable row laid out into terminal lines, so a click region can span its real height. pub(super) struct LaidOutRow { pub(super) lines: Vec>, } /// What every row is measured against. #[derive(Clone, Copy)] struct RowGeometry { indent: usize, text_width: usize, show_rationale: bool, custom_rows: usize, } /// One row's lines of spans: an option's label with its badge and rationale, or the typed answer. fn row_content( state: &QuestionPromptState, theme: &crate::theme::styles::ThemeStyles, i: usize, geometry: &RowGeometry, ) -> Vec>> { let RowGeometry { indent, text_width, show_rationale, custom_rows } = *geometry; let selected = i == state.selected(); let cursor_style = theme.accent_on(selected); let label_style = theme.label_on(selected); let mut spans = vec![Span::styled(crate::glyphs::Mark::Cursor.gutter(selected), cursor_style)]; if state.multi { let box_glyph = if state.is_checked(i) { format!("[{}] ", crate::glyphs::Mark::Yes) } else { "[ ] ".to_string() }; spans.push(Span::styled(box_glyph, cursor_style)); } let mut content: Vec>> = Vec::new(); match state.options.get(i) { Some(option) => { // The label outranks the badge: on a narrow panel the cursor already opens on // the recommendation, so a clipped label buys nothing. let label = format!("{}. {}", i + 1, option.label); let room = text_width.saturating_sub(indent); let badged = option.recommended && room >= label.chars().count() + RECOMMENDED_BADGE.len(); let label_width = if badged { room - RECOMMENDED_BADGE.len() } else { room }; spans.push(Span::styled(truncate(&label, label_width), label_style)); if badged { spans.push(Span::styled(RECOMMENDED_BADGE, theme.success)); } content.push(spans); if show_rationale { let rationale = option.description.as_deref().unwrap_or_default(); for line in wrapped_rows(rationale, room, MAX_DESCRIPTION_ROWS) { content .push(vec![Span::raw(" ".repeat(indent)), Span::styled(line, theme.muted)]); } } } // The typed answer, always last and numbered like the rest. It wraps rather than // truncating: an answer cut off at the right edge is one the reader cannot check // before sending it. None => { let number = format!("{}. ", i + 1); // The text column, wherever a longer number puts it let text_at = indent + number.chars().count().saturating_sub(3); let room = text_width.saturating_sub(text_at); let (mut wrapped, scrolled) = match state.editing() { true => { let styles = (label_style, theme.selected_bg); super::answer::editing_rows(state, room, custom_rows, styles) } false => { let body = match state.custom() { "" => CUSTOM_PLACEHOLDER, typed => typed, }; let rows = wrapped_rows(body, room, custom_rows); ( rows.into_iter().map(|row| vec![Span::styled(row, label_style)]).collect(), false, ) } }; // An answer of nothing but spaces still owns a row: it is the one the cursor // can land on, and the click regions are laid out over the rows there are. if wrapped.is_empty() { wrapped.push(Vec::new()); } for (index, row) in wrapped.into_iter().enumerate() { let mut line = if index == 0 { let mut first = std::mem::take(&mut spans); first.push(Span::styled(number.clone(), label_style)); first } else { vec![Span::raw(" ".repeat(text_at))] }; // Said in the row's first cell, so the text column holds still while the // window scrolls if scrolled { let lead = if index == 0 { "…" } else { " " }; line.push(Span::styled(lead, cursor_style)); } line.extend(row); content.push(line); } } } content } /// Lay out the options and the free-text row. /// /// `with_descriptions` keeps each option's rationale, and `custom_rows` is what the typed answer /// may spend before its window starts scrolling — the two knobs [`super::plan`] turns down to fit. pub(super) fn lay_out_rows( state: &QuestionPromptState, theme: &crate::theme::styles::ThemeStyles, inner_width: usize, with_descriptions: bool, custom_rows: usize, ) -> Vec { // `❯ `, the optional checkbox, and `1. ` — what a rationale has to clear to line up under // its label. let indent = 2 + if state.multi { 4 } else { 0 } + 3; // Whether a rationale is worth setting at all: what is left of the panel after the slab's // frame and the label's own indent has to be wide enough to read. A narrower panel shows the // labels alone rather than a column of two-word fragments. let roomy = inner_width.saturating_sub(crate::widgets::SELECTION_FRAME + indent) >= MIN_DESCRIPTION_WIDTH; let show_rationale = with_descriptions && roomy; let custom_rows = custom_rows.min(MAX_DESCRIPTION_ROWS + 1); // What a row's text may occupy: the panel, less the slab's two cap cells. let text_width = inner_width.saturating_sub(crate::widgets::SELECTION_FRAME); let geometry = RowGeometry { indent, text_width, show_rationale, custom_rows }; let rows: Vec<(bool, Vec>>)> = (0..state.row_count()) .map(|i| (i == state.selected(), row_content(state, theme, i, &geometry))) .collect(); debug_assert!( rows.iter().all(|(_, lines)| lines.len() <= MAX_DESCRIPTION_ROWS + 1), "a row is taller than the rationale budget" ); rows.into_iter() // One slab for the whole option, not one per line: the label and the rationale under it are // a single choice. .map(|(selected, content)| LaidOutRow { lines: crate::widgets::selection_block(content, inner_width, selected, theme), }) .collect() } /// Word-wrap `text` to `width` columns. fn wrap_rows(text: &str, width: usize) -> Vec { let text = text.trim(); if text.is_empty() || width == 0 { return Vec::new(); } let line = Line::from(Span::raw(text.to_string())); crate::widgets::wrap_line(&line, width) .into_iter() .map(|line| line.spans.iter().map(|span| span.content.as_ref()).collect()) .collect() } /// Word-wrap `text` to `width` columns, clipped to `max_rows` with an ellipsis on the last row. pub(super) fn wrapped_rows(text: &str, width: usize, max_rows: usize) -> Vec { if max_rows == 0 { return Vec::new(); } let mut rows = wrap_rows(text, width); if rows.len() > max_rows { rows.truncate(max_rows); if let Some(last) = rows.last_mut() { *last = truncate(&format!("{last}…"), width); } } rows }