uzor-tui 1.0.6

Terminal UI backend for uzor
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
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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

//! Bridge from vt100 virtual terminal to TerminalBuffer.

use crate::buffer::TerminalBuffer;
use crate::cell::Cell;
use crate::style::{Color, Modifier, Style};

/// Copy the entire vt100 screen into a TerminalBuffer.
///
/// Reads every cell from the vt100 screen and writes it into the buffer,
/// converting colors and attributes to our types.
pub fn vt100_to_buffer(screen: &vt100::Screen, buf: &mut TerminalBuffer) {
    let (rows, cols) = screen.size();

    for row in 0..rows {
        for col in 0..cols {
            let vt_cell = screen.cell(row, col);
            let cell = match vt_cell {
                Some(vc) => convert_cell(vc),
                None => Cell::default(),
            };
            // buffer uses (col, row) ordering
            if col < buf.width() && row < buf.height() {
                buf.set(col, row, cell);
            }
        }
    }
}

/// Convert a vt100 cell to our Cell.
fn convert_cell(vc: &vt100::Cell) -> Cell {
    let symbol = vc.contents();
    // Empty string means no content (use space)
    let symbol: compact_str::CompactString = if symbol.is_empty() {
        " ".into()
    } else {
        symbol.into()
    };

    let fg = convert_color(vc.fgcolor());
    let bg = convert_color(vc.bgcolor());

    let mut modifiers = Modifier::empty();
    if vc.bold() {
        modifiers |= Modifier::BOLD;
    }
    if vc.italic() {
        modifiers |= Modifier::ITALIC;
    }
    if vc.underline() {
        modifiers |= Modifier::UNDERLINE;
    }
    if vc.inverse() {
        modifiers |= Modifier::REVERSE;
    }

    let style = Style {
        fg,
        bg,
        modifiers,
    };

    Cell { symbol, style }
}

/// Convert vt100 color to our Color.
fn convert_color(color: vt100::Color) -> Color {
    match color {
        vt100::Color::Default => Color::Reset,
        vt100::Color::Idx(i) => {
            // Map standard 16 colors to named colors
            match i {
                0 => Color::Black,
                1 => Color::Red,
                2 => Color::Green,
                3 => Color::Yellow,
                4 => Color::Blue,
                5 => Color::Magenta,
                6 => Color::Cyan,
                7 => Color::White,
                // 8-15: bright variants, use indexed
                _ => Color::Indexed(i),
            }
        }
        vt100::Color::Rgb(r, g, b) => Color::Rgb(r, g, b),
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_empty_screen_to_buffer() {
        let parser = vt100::Parser::new(24, 80, 0);
        let mut buf = TerminalBuffer::new(80, 24);
        vt100_to_buffer(parser.screen(), &mut buf);

        // All cells should be spaces
        assert_eq!(buf.get(0, 0).symbol, " ");
        assert_eq!(buf.get(79, 23).symbol, " ");
    }

    #[test]
    fn test_text_to_buffer() {
        let mut parser = vt100::Parser::new(24, 80, 0);
        parser.process(b"Hello, world!");
        let mut buf = TerminalBuffer::new(80, 24);
        vt100_to_buffer(parser.screen(), &mut buf);

        assert_eq!(buf.get(0, 0).symbol, "H");
        assert_eq!(buf.get(1, 0).symbol, "e");
        assert_eq!(buf.get(4, 0).symbol, "o");
        assert_eq!(buf.get(12, 0).symbol, "!");
    }

    #[test]
    fn test_colored_text_to_buffer() {
        let mut parser = vt100::Parser::new(24, 80, 0);
        // ESC[31m = red foreground, then "Hi", then reset ESC[0m
        parser.process(b"\x1b[31mHi\x1b[0m");
        let mut buf = TerminalBuffer::new(80, 24);
        vt100_to_buffer(parser.screen(), &mut buf);

        assert_eq!(buf.get(0, 0).symbol, "H");
        assert_eq!(buf.get(0, 0).style.fg, Color::Red);
        assert_eq!(buf.get(1, 0).symbol, "i");
        assert_eq!(buf.get(1, 0).style.fg, Color::Red);
        // After reset, next cell should be default
        assert_eq!(buf.get(2, 0).style.fg, Color::Reset);
    }

    #[test]
    fn test_bold_text_to_buffer() {
        let mut parser = vt100::Parser::new(24, 80, 0);
        // ESC[1m = bold
        parser.process(b"\x1b[1mBold\x1b[0m");
        let mut buf = TerminalBuffer::new(80, 24);
        vt100_to_buffer(parser.screen(), &mut buf);

        assert!(buf.get(0, 0).style.modifiers.contains(Modifier::BOLD));
        assert_eq!(buf.get(0, 0).symbol, "B");
    }
}