perch/src/view/table.rs

use crate::*;

pub struct TreeTable<'a>(pub(crate) &'a Taggart);

impl<'a> Content<TuiOut> for TreeTable<'a> {
    fn render (&self, to: &mut TuiOut) {
        let (active_x, active_w) = self.0.columns.xw(self.0.column);
        let active_w = active_w.saturating_sub(1);
        let area = to.area();
        Self::column_cursor(to, area, active_x, active_w);
        self.rows(to, area, active_x, active_w);
        to.area = area;
    }
}

impl<'a> TreeTable<'a> {
    const BG_COLUMN: Color = Color::Rgb(0, 0, 0);
    const FG_ROW:    Color = Color::Rgb(0, 0, 0);
    const BG_ROW:    Color = Color::Rgb(192, 128, 0);
    const BG_CELL:   Color = Color::Rgb(224, 192, 0);
    const BG_EDIT:   Color = Color::Rgb(48, 96, 0);
    const FG_EDIT:   Color = Color::Rgb(255, 255, 255);
    fn rows (&self, to: &mut TuiOut, area: [u16;4], active_x: u16, active_w: u16) {
        for (row_index, row_y) in area.iter_y().enumerate() {
            let row_index_scrolled = row_index + self.0.offset;
            let selected = self.0.cursor == row_index_scrolled;
            let mut column_x = area.x();
            if let Some(entry) = self.0.paths.get(row_index_scrolled) {
                for (index, _fragment) in entry.path.iter().enumerate() {
                    if index == entry.depth - 1 {
                        let _cursor = if selected { ">" } else { " " };
                        to.area[1] = row_y;
                        if selected {
                            Self::row_cursor(to, area.x(), row_y, area.w());
                            self.cell_cursor(to, area.x(), active_x, column_x, row_y, active_w);
                        }
                        self.row_data(to, entry, row_index_scrolled, &mut column_x);
                    }
                }
            } else {
                break
            }
        }
    }
    fn column_cursor (to: &mut TuiOut, area: [u16;4], active_x: u16, active_w: u16) {
        to.fill_bg([area.x() + active_x, area.y(), active_w, area.h()], Self::BG_COLUMN);
    }
    fn row_cursor (to: &mut TuiOut, x: u16, y: u16, w: u16) {
        let fill = [x, y, w, 1];
        to.fill_fg(fill, Self::FG_ROW);
        to.fill_bg(fill, Self::BG_ROW);
    }
    fn cell_cursor (&self, to: &mut TuiOut, xa: u16, x0: u16, x: u16, y: u16, w: u16) {
        let fill = [xa + x0, y, w, 1];
        to.fill_bg(fill, Self::BG_CELL);
        //if let Some((_index, value)) = &self.0.editing {
            //let x = xa + if x > 0 { x + 1 } else { x } as u16;
            //to.blit(&value, x, y, None)
        //}
    }
    fn row_data (&self, to: &mut TuiOut, entry: &Entry, row: usize, x: &mut u16) {
        for (column_index, Column { width, value, .. }) in self.0.columns.0.iter().enumerate() {
            to.area[0] = *x;
            if let Some((edit_index, value)) = self.0.editing.as_ref()
                && self.0.column == column_index
                && self.0.cursor == row
            {
                to.fill_bg([*x, to.area().y(), *width as u16, 1], Self::BG_EDIT);
                to.fill_fg([*x, to.area().y(), *width as u16, 1], Self::FG_EDIT);
                Content::render(&TrimStringRef(*width as u16, &value), to);
            } else if let Some(value) = value(entry) {
                Content::render(&TrimStringRef(*width as u16, &value), to);
            }
            *x += *width as u16 + 1;
        }
    }
}

pub struct Column<T> {
    pub title: Arc<str>,
    pub width: usize,
    pub value: Box<dyn Fn(&T)->Option<Arc<str>> + Send + Sync>,
}

impl<T> Column<T> {
    pub fn new (
        title: &impl AsRef<str>,
        width: usize,
        value: impl Fn(&T)->Option<Arc<str>> + Send + Sync + 'static
    ) -> Self {
        Self { width, value: Box::new(value), title: title.as_ref().into() }
    }
}

pub struct Columns<T>(pub Vec<Column<T>>);

impl Default for Columns<Entry> {
    fn default () -> Self {
        Self(vec![
            Column::new(&"HASH",    16, |entry: &Entry|entry.hash()),
            Column::new(&"FILE",    80, |entry: &Entry|entry.name()),
            Column::new(&"ARTIST",  30, |entry: &Entry|entry.artist()),
            Column::new(&"RELEASE", 30, |entry: &Entry|entry.album()),
            Column::new(&"TRACK",   5,  |entry: &Entry|entry.track()),
            Column::new(&"TITLE",   80, |entry: &Entry|entry.title()),
        ])
    }
}

impl<T> Columns<T> {
    pub fn header (&self) -> Arc<str> {
        let mut output = String::new();
        for Column { width, title, .. } in self.0.iter() {
            let cell = title.pad_to_width(*width);
            output = format!("{output}{cell}│");
        }
        output.into()
    }
    pub fn xw (&self, column: usize) -> (u16, u16) {
        let mut x: u16 = 0;
        for (index, Column { width, .. }) in self.0.iter().enumerate() {
            let w = *width as u16 + 1;
            if index == column {
                if x > 0 {
                    return (x - 1, w + 1)
                } else {
                    return (x, w)
                }
            } else {
                x += w;
            }
        }
        (0, 0)
    }
}