tuviv/terminal/

buffer.rs

//! Terminal representation.

use std::fmt::{self, Display};

use le::layout::{Rect, Vec2};
use unicode_segmentation::UnicodeSegmentation;
use unicode_width::UnicodeWidthStr;

use super::{Style, StyledText};

/// The text stored in a cell
#[derive(Default, Debug, Clone, PartialEq, Eq)]
pub enum CellText {
    /// Only used if you start with the zero width chars
    String(String),
    /// A character
    Char(char),
    /// Literally nothing
    #[default]
    None,
}

impl CellText {
    /// Determines if the cell is empty
    pub fn is_empty(&self) -> bool {
        match self {
            CellText::String(x) => x.is_empty(),
            CellText::Char(_) => false,
            CellText::None => true,
        }
    }
}

impl Display for CellText {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            CellText::String(x) => x.fmt(f),
            CellText::Char(x) => x.fmt(f),
            CellText::None => ' '.fmt(f),
        }
    }
}

/// A single cell on the buffer with text and style.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct Cell {
    /// The text.
    ///
    /// This is a string because certain combinations
    /// of unicode characters may still fit in a cell.
    pub text: CellText,
    /// The style of the cell
    pub style: Style,
}

/// A buffer of cells storing its size and text.
#[derive(Debug, Clone)]
pub struct Buffer {
    /// The size of the buffer
    size: Vec2,
    /// The text in the buffer
    // TODO: Make this a 1d array
    text: Vec<Vec<Cell>>,
}

impl Buffer {
    /// Creates a new buffer of the given size.
    ///
    /// The size will normally be the size of the terminal.
    pub fn new(size: Vec2) -> Self {
        Self {
            size,
            text: vec![vec![Cell::default(); size.y]; size.x],
        }
    }

    /// Clears the buffer, writing all cells as empty.
    pub fn clear(&mut self) {
        for column in &mut self.text {
            for cell in column {
                *cell = Cell::default();
            }
        }
    }

    /// Gets the size of the Buffer
    pub fn size(&self) -> Vec2 {
        self.size
    }

    /// Gets all the text
    pub fn text(&self) -> &[Vec<Cell>] {
        &self.text
    }

    /// Gets a specfic cell
    pub fn get(&self, pos: Vec2) -> Option<&Cell> {
        self.text.get(pos.x).and_then(|x| x.get(pos.y))
    }

    /// Gets a mutable version of a cell
    pub fn get_mut(&mut self, pos: Vec2) -> Option<&mut Cell> {
        self.text.get_mut(pos.x).and_then(|x| x.get_mut(pos.y))
    }

    /// Writes the text to the buffer. The text should **NOT**
    /// be multiline. Multiline text will not be handled correctly.
    pub fn write<'a>(&mut self, pos: Vec2, text: impl Into<StyledText<'a>>) {
        self.write_span(pos, &text.into());
    }

    /// Writes the span to the buffer. The text should **NOT**
    /// be multiline. Multiline text will not be handled correctly.
    pub fn write_span(&mut self, mut pos: Vec2, text: &StyledText) {
        let graphemes = text.text.graphemes(true);
        for grapheme in graphemes {
            if let Some(previous) = self.get_mut(pos) {
                let mut grapheme_chars = grapheme.chars();
                let char1 = grapheme_chars.next();
                let char2 = grapheme_chars.next();
                match (char1, char2) {
                    (Some(_char1), Some(_char2)) => {
                        previous.text = CellText::String(grapheme.to_owned());
                    }
                    (Some(char1), None) => {
                        previous.text = CellText::Char(char1);
                    }
                    _ => (),
                }
                previous.style = previous.style.overlay(text.style);
            }
            pos.x += grapheme.width();
        }
    }

    /// Writes another buffer over this buffer
    pub fn write_buffer(&mut self, them: Buffer, pos: Vec2) {
        for (x, column) in them.text.into_iter().enumerate() {
            for (y, cell) in column.into_iter().enumerate() {
                let cell_pos = pos + Vec2::new(x, y);

                if let Some(previous) = self.get_mut(cell_pos) {
                    previous.text = cell.text;
                    previous.style = previous.style.overlay(cell.style);
                };
            }
        }
    }

    /// Writes another buffer over this buffer, only cloning when need be
    pub fn write_buffer_ref(&mut self, them: &Buffer, pos: Vec2) {
        for (x, column) in them.text.iter().enumerate() {
            for (y, cell) in column.iter().enumerate() {
                let cell_pos = pos + Vec2::new(x, y);

                if let Some(previous) = self.get_mut(cell_pos) {
                    previous.text = cell.text.clone();
                    previous.style = previous.style.overlay(cell.style);
                };
            }
        }
    }

    /// Writes a character to the buffer
    pub fn write_char(&mut self, c: char, pos: Vec2) {
        if let Some(cell) = self.get_mut(pos) {
            cell.text = CellText::Char(c);
        }
    }

    /// Style a specific cell
    pub fn style_cell(&mut self, style: Style, pos: Vec2) {
        if let Some(cell) = self.get_mut(pos) {
            cell.style = style;
        }
    }

    /// Subtracts the positions of some vectors on this buffer.
    ///
    /// This is not particularly cheap.
    pub fn subtract_pos(&mut self, pos: Vec2) {
        for _x in 0..(pos.x.min(self.text.len())) {
            self.text.remove(0);
        }
        for column in &mut self.text {
            for _y in 0..(pos.y.min(column.len())) {
                column.remove(0);
            }
        }
    }

    /// Clips a buffer to a specific size, discarding the
    /// other information.
    pub fn clip(&mut self, clip: Vec2) {
        let mut column = 0;
        self.text.retain(|_| {
            column += 1;
            (column - 1) < clip.x
        });

        for column in &mut self.text {
            let mut row = 0;
            column.retain(|_| {
                row += 1;
                (row - 1) < clip.y
            });
        }
    }

    /// Crops the buffer to a specific rect
    pub fn crop(&mut self, crop: Rect) {
        let mut column = 0;
        self.text.retain(|_| {
            let res = crop.start.x <= column && column < crop.end().x;
            column += 1;
            res
        });

        for column in &mut self.text {
            let mut row = 0;
            column.retain(|_| {
                let res = crop.start.y <= row && row < crop.end().y;
                row += 1;
                res
            });
        }
    }
}