anathema-backend 0.2.11

Various backends for Anathema
Documentation 
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

use anathema_geometry::{Pos, Size};
use anathema_value_resolver::Attributes;
use anathema_widgets::paint::Glyph;
use anathema_widgets::{GlyphMap, Style, WidgetRenderer};

#[derive(Debug)]
pub struct TestSurface {
    pub(super) size: Size,
    lines: Vec<Glyph>,
    prev_lines: Vec<Glyph>,
}

impl TestSurface {
    pub fn new(size: Size) -> Self {
        let len = size.width * size.height;
        let lines = vec![Glyph::space(); len as usize];
        Self {
            size,
            lines,
            prev_lines: vec![],
        }
    }

    pub(crate) fn resize(&mut self, new_size: Size, _glyph_map: &mut GlyphMap) {
        self.size = new_size;
        // TODO: this should pop and truncate the lines to fit the new size
    }

    // Get from previous lines as the clear function has most likely
    // been called by the time this is relevant
    pub(crate) fn get(&self, x: usize, y: usize) -> Option<&Glyph> {
        let index = y * self.size.width as usize + x;
        self.prev_lines.get(index)
    }

    // Look at the old lines as the surface has been cleared
    // by the time we can inspect the lines
    pub(crate) fn line(&self, index: usize) -> &[Glyph] {
        let from = index * self.size.width as usize;
        let to = from + self.size.width as usize;
        &self.prev_lines[from..to]
    }

    pub(crate) fn clear(&mut self) {
        let len = self.size.width * self.size.height;
        let mut lines = vec![Glyph::space(); len as usize];
        std::mem::swap(&mut lines, &mut self.lines);
        std::mem::swap(&mut lines, &mut self.prev_lines);
    }
}

impl WidgetRenderer for TestSurface {
    fn draw_glyph(&mut self, mut glyph: Glyph, local_pos: Pos) {
        let index = self.size.width as i32 * local_pos.y + local_pos.x;
        let index = index as usize;
        std::mem::swap(&mut glyph, &mut self.lines[index]);
    }

    fn set_attributes(&mut self, attribs: &Attributes<'_>, local_pos: Pos) {
        let style = Style::from_cell_attribs(attribs);
        self.set_style(style, local_pos)
    }

    fn set_style(&mut self, _style: Style, _local_pos: Pos) {}

    fn size(&self) -> Size {
        self.size
    }
}