tengri/src/text.rs

use crate::{Usually, draw::Draw, space::*};
pub(crate) use ::unicode_width::*;

#[cfg(feature = "term")] mod impl_term {
    use super::*;
    use crate::term::Tui;
    use ratatui::prelude::Position;

    impl Draw<Tui> for &str {
        fn draw (self, to: &mut Tui) -> Usually<XYWH<u16>> {
            let XYWH(x, y, w, ..) = to.1.centered_xy([width_chars_max(to.w(), self), 1]);
            to.text(&self, x, y, w)
        }
    }
    impl Draw<Tui> for String {
        fn draw (self, to: &mut Tui) -> Usually<XYWH<u16>> {
            self.as_str().draw(to)
        }
    }
    impl Draw<Tui> for std::sync::Arc<str> {
        fn draw (self, to: &mut Tui) -> Usually<XYWH<u16>> {
            self.as_ref().draw(to)
        }
    }
    impl Draw<Tui> for &std::sync::Arc<str> {
        fn draw (self, to: &mut Tui) -> Usually<XYWH<u16>> {
            self.as_ref().draw(to)
        }
    }

    impl<T: AsRef<str>> Draw<Tui> for TrimString<T> {
        fn draw (self, to: &mut Tui) -> Usually<XYWH<u16>> { self.as_ref().draw(to) }
    }

    impl<T: AsRef<str>> Draw<Tui> for TrimStringRef<'_, T> {
        fn draw (self, to: &mut Tui) -> Usually<XYWH<u16>> {
            let XYWH(x, y, w, ..) = to.1;
            let mut width: u16 = 1;
            let mut chars = self.1.as_ref().chars();
            while let Some(c) = chars.next() {
                if width > self.0 || width > w {
                    break
                }
                let pos = Position { x: x + width - 1, y };
                if let Some(cell) = to.0.cell_mut(pos) {
                    cell.set_char(c);
                }
                width += c.width().unwrap_or(0) as u16;
            }
            let XYWH(x, y, w, ..) = XYWH(to.x(), to.y(), to.w().min(self.0).min(self.1.as_ref().width() as u16), to.h());
            to.text(&self.as_ref(), x, y, w)
        }
    }

    impl Tui {
        /// Write a line of text
        ///
        /// TODO: do a paragraph (handle newlines)
        pub fn text (&mut self, text: &impl AsRef<str>, x0: u16, y: u16, max_width: u16) -> Usually<XYWH<u16>> {
            let text = text.as_ref();
            let mut string_width: u16 = 0;
            for character in text.chars() {
                let x = x0 + string_width;
                let character_width = character.width().unwrap_or(0) as u16;
                string_width += character_width;
                if string_width > max_width {
                    break
                }
                if let Some(cell) = self.0.cell_mut(ratatui::prelude::Position { x, y }) {
                    cell.set_char(character);
                } else {
                    break
                }
            }
            Ok(XYWH(x0, y, string_width, 1))
        }
    }
}

/// Trim string with [unicode_width].
pub fn trim_string (max_width: usize, input: impl AsRef<str>) -> String {
    let input = input.as_ref();
    let mut output = Vec::with_capacity(input.len());
    let mut width: usize = 1;
    let mut chars = input.chars();
    while let Some(c) = chars.next() {
        if width > max_width {
            break
        }
        output.push(c);
        width += c.width().unwrap_or(0);
    }
    return output.into_iter().collect()
}

/// Displays an owned [str]-like with fixed maximum width.
///
/// Width is computed using [unicode_width].
pub struct TrimString<T: AsRef<str>>(pub u16, pub T);
impl<T: AsRef<str>> AsRef<str> for TrimString<T> { fn as_ref (&self) -> &str { self.1.as_ref() } }
impl<'a, T: AsRef<str>> TrimString<T> {
    fn to_ref (&self) -> TrimStringRef<'_, T> { TrimStringRef(self.0, &self.1) }
}

/// Displays a borrowed [str]-like with fixed maximum width
///
/// Width is computed using [unicode_width].
pub struct TrimStringRef<'a, T: AsRef<str>>(pub u16, pub &'a T);
impl<T: AsRef<str>> AsRef<str> for TrimStringRef<'_, T> {
    fn as_ref (&self) -> &str { self.1.as_ref() }
}

pub(crate) fn width_chars_max (max: u16, text: impl AsRef<str>) -> u16 {
    let mut width: u16 = 0;
    let mut chars = text.as_ref().chars();
    while let Some(c) = chars.next() {
        width += c.width().unwrap_or(0) as u16;
        if width > max {
            break
        }
    }
    return width
}