comb-tui 0.2.0

A tiny native terminal-UI engine — surfaces, layers, widgets.
Documentation
//! A scrollable, selectable list of text rows — the building block for menus.

use crate::core::buffer::Buffer;
use crate::core::geom::Rect;
use crate::term::event::MouseKind;
use crate::widgets::scrollbar::Scrollbar;
use crate::widgets::Palette;

#[derive(Default)]
pub struct List {
    pub items: Vec<String>,
    pub selected: usize,
    pub offset: usize,
    pub scrollbar: Scrollbar,
}

impl List {
    pub fn new(items: Vec<String>) -> Self {
        List {
            items,
            selected: 0,
            offset: 0,
            scrollbar: Scrollbar::default(),
        }
    }

    pub fn is_empty(&self) -> bool {
        self.items.is_empty()
    }

    pub fn len(&self) -> usize {
        self.items.len()
    }

    pub fn selected_item(&self) -> Option<&str> {
        self.items.get(self.selected).map(String::as_str)
    }

    pub fn select_up(&mut self) {
        self.selected = self.selected.saturating_sub(1);
    }

    pub fn select_down(&mut self) {
        if self.selected + 1 < self.items.len() {
            self.selected += 1;
        }
    }

    pub fn select(&mut self, idx: usize) {
        if idx < self.items.len() {
            self.selected = idx;
        }
    }

    fn ensure_visible(&mut self, h: usize) {
        if h == 0 {
            return;
        }
        if self.selected < self.offset {
            self.offset = self.selected;
        } else if self.selected >= self.offset + h {
            self.offset = self.selected + 1 - h;
        }
    }

    pub fn index_at(&self, area: Rect, row: u16) -> Option<usize> {
        if row < area.y || row >= area.bottom() {
            return None;
        }
        let idx = self.offset + (row - area.y) as usize;
        (idx < self.items.len()).then_some(idx)
    }

    pub fn render(&mut self, buf: &mut Buffer, area: Rect, pal: &Palette) {
        if area.is_empty() {
            return;
        }
        // Opaque base so a list drawn in a stacked window never leaks layers below.
        buf.paint(area, pal.panel);
        let h = area.height as usize;
        let overflow = self.items.len() > h;
        let list_w = self.scrollbar.content_area(area, overflow).width;
        self.ensure_visible(h);
        self.offset = self.offset.min(self.items.len().saturating_sub(h));

        for row in 0..area.height {
            let idx = self.offset + row as usize;
            let y = area.y + row;
            let Some(text) = self.items.get(idx) else {
                buf.paint(Rect::new(area.x, y, list_w, 1), pal.panel);
                continue;
            };
            let st = if idx == self.selected {
                pal.selected
            } else {
                pal.normal.patch(pal.panel)
            };
            buf.paint(Rect::new(area.x, y, list_w, 1), st);
            let mut line = String::with_capacity(text.len() + 1);
            line.push(' ');
            line.push_str(text);
            buf.set_str(area.x, y, &line, st);
        }

        if overflow {
            let mut bar = self.scrollbar.clone();
            if bar.style.track == crate::core::style::Style::new() {
                bar.style.track = pal.track;
                bar.style.thumb = pal.thumb;
                bar.style.thumb_active = pal.thumb;
            }
            bar.render(buf, bar.area(area), self.items.len(), h, self.offset);
        }
    }

    pub fn handle_mouse(&mut self, area: Rect, kind: MouseKind, col: u16, row: u16) -> bool {
        let h = area.height as usize;
        let overflow = self.items.len() > h;
        if !overflow {
            return false;
        }
        let bar_area = self.scrollbar.area(area);
        if self.scrollbar.is_dragging() || bar_area.contains(col, row) {
            return self.scrollbar.on_mouse(
                bar_area,
                self.items.len(),
                h,
                &mut self.offset,
                kind,
                col,
                row,
            );
        }
        let content = self.scrollbar.content_area(area, true);
        if !content.contains(col, row) {
            return false;
        }
        match kind {
            MouseKind::ScrollUp => {
                self.select_up();
                true
            }
            MouseKind::ScrollDown => {
                self.select_down();
                true
            }
            MouseKind::Up => {
                self.scrollbar.end_drag();
                false
            }
            _ => false,
        }
    }
}