1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

use crate::default::*;
use crate::wrap::{self, Wrap};
use prototty_render::*;

pub struct TextView<W: Wrap> {
    pub style: Style,
    wrap: W,
}

impl<W: Wrap> TextView<W> {
    pub fn new(style: Style, wrap: W) -> Self {
        Self { style, wrap }
    }
    pub fn new_default_style(wrap: W) -> Self {
        Self::new(DEFAULT_STYLE, wrap)
    }
}

impl<S, I, W> View<I> for TextView<W>
where
    S: AsRef<str>,
    I: IntoIterator<Item = S>,
    W: Wrap,
{
    fn view<G: ViewGrid, R: ViewTransformRgb24>(
        &mut self,
        parts: I,
        context: ViewContext<R>,
        grid: &mut G,
    ) {
        self.wrap.clear();
        for part in parts {
            let part = part.as_ref();
            for character in part.chars() {
                self.wrap
                    .process_character(character, self.style, context, grid);
            }
        }
        self.wrap.flush(context, grid);
    }
}

pub struct StringView<W: Wrap> {
    pub style: Style,
    wrap: W,
}

impl<W: Wrap> StringView<W> {
    pub fn new(style: Style, wrap: W) -> Self {
        Self { style, wrap }
    }
    pub fn new_default_style(wrap: W) -> Self {
        Self::new(DEFAULT_STYLE, wrap)
    }
}

impl<'a, S, W> View<S> for StringView<W>
where
    S: AsRef<str>,
    W: Wrap,
{
    fn view<G: ViewGrid, R: ViewTransformRgb24>(
        &mut self,
        part: S,
        context: ViewContext<R>,
        grid: &mut G,
    ) {
        self.wrap.clear();
        let part = part.as_ref();
        for character in part.chars() {
            self.wrap
                .process_character(character, self.style, context, grid);
        }
        self.wrap.flush(context, grid);
    }
}

#[derive(Debug, Clone, Copy)]
pub struct StringViewSingleLine {
    pub style: Style,
}

impl Default for StringViewSingleLine {
    fn default() -> Self {
        Self {
            style: DEFAULT_STYLE,
        }
    }
}

impl StringViewSingleLine {
    pub const fn new(style: Style) -> Self {
        Self { style }
    }
}

impl<'a, S> View<S> for StringViewSingleLine
where
    S: AsRef<str>,
{
    fn view<G: ViewGrid, R: ViewTransformRgb24>(
        &mut self,
        part: S,
        context: ViewContext<R>,
        grid: &mut G,
    ) {
        StringView::new(self.style, wrap::None::new()).view(part, context, grid);
    }

    fn visible_bounds<R: ViewTransformRgb24>(
        &mut self,
        part: S,
        _context: ViewContext<R>,
    ) -> Size {
        let part = part.as_ref();
        let width = part.len() as u32;
        Size::new(width, 1)
    }
}