utu 0.0.1

TUI pixel art editor using plain text files
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

use tuinix::KeyCode;

use unicode_width::UnicodeWidthChar;

pub type TerminalFrame = tuinix::TerminalFrame<UnicodeCharWidthEstimator>;

pub trait KeyInputExt {
    fn from_str(s: &str) -> Option<tuinix::KeyInput>;
    fn display(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result;
    fn to_string(&self) -> String;
}

impl KeyInputExt for tuinix::KeyInput {
    fn to_string(&self) -> String {
        struct DisplayWrapper<'a>(&'a tuinix::KeyInput);

        impl<'a> std::fmt::Display for DisplayWrapper<'a> {
            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                self.0.display(f)
            }
        }

        format!("{}", DisplayWrapper(self))
    }

    fn from_str(s: &str) -> Option<tuinix::KeyInput> {
        // Control
        let (ctrl, s) = if let Some(s) = s.strip_prefix("C-") {
            (true, s)
        } else {
            (false, s)
        };

        // Alt
        let (alt, s) = if let Some(s) = s.strip_prefix("M-") {
            (true, s)
        } else {
            (false, s)
        };

        let key = |code| tuinix::KeyInput { ctrl, alt, code };

        // Special keys
        match s {
            "↑" => return Some(key(KeyCode::Up)),
            "↓" => return Some(key(KeyCode::Down)),
            "←" => return Some(key(KeyCode::Left)),
            "→" => return Some(key(KeyCode::Right)),
            "↵" => return Some(key(KeyCode::Enter)),
            "⎋" => return Some(key(KeyCode::Escape)),
            "⌫" => return Some(key(KeyCode::Backspace)),
            "⇥" => return Some(key(KeyCode::Tab)),
            "⇤" => return Some(key(KeyCode::BackTab)),
            "⌦" => return Some(key(KeyCode::Delete)),
            "⎀" => return Some(key(KeyCode::Insert)),
            "⇱" => return Some(key(KeyCode::Home)),
            "⇲" => return Some(key(KeyCode::End)),
            "⇞" => return Some(key(KeyCode::PageUp)),
            "⇟" => return Some(key(KeyCode::PageDown)),
            _ => {}
        }

        // Normal keys
        let mut chars = s.chars();
        match (chars.next(), chars.next()) {
            (Some(c), None) if !c.is_control() => Some(key(KeyCode::Char(c))),
            _ => None,
        }
    }

    fn display(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        // Write modifiers
        if self.ctrl {
            write!(f, "C-")?;
        }
        if self.alt {
            write!(f, "M-")?;
        }

        // Write the key code
        match self.code {
            KeyCode::Up => write!(f, "↑"),
            KeyCode::Down => write!(f, "↓"),
            KeyCode::Left => write!(f, "←"),
            KeyCode::Right => write!(f, "→"),
            KeyCode::Enter => write!(f, "↵"),
            KeyCode::Escape => write!(f, "⎋"),
            KeyCode::Backspace => write!(f, "⌫"),
            KeyCode::Tab => write!(f, "⇥"),
            KeyCode::BackTab => write!(f, "⇤"),
            KeyCode::Delete => write!(f, "⌦"),
            KeyCode::Insert => write!(f, "⎀"),
            KeyCode::Home => write!(f, "⇱"),
            KeyCode::End => write!(f, "⇲"),
            KeyCode::PageUp => write!(f, "⇞"),
            KeyCode::PageDown => write!(f, "⇟"),
            KeyCode::Char(c) => write!(f, "{}", c),
        }
    }
}

#[derive(Debug, Default)]
pub struct UnicodeCharWidthEstimator;

impl tuinix::EstimateCharWidth for UnicodeCharWidthEstimator {
    fn estimate_char_width(&self, c: char) -> usize {
        c.width().unwrap_or(0)
    }
}