kk 0.0.1

A TUI text editor
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

use std::fmt::Write;

use orfail::OrFail;
use tuinix::{TerminalPosition, TerminalRegion, TerminalSize};

use crate::{config::Config, mame::TerminalFrame, state::State};

#[derive(Debug)]
pub struct LegendRenderer;

impl LegendRenderer {
    pub fn render(
        &self,
        config: &Config,
        state: &State,
        frame: &mut TerminalFrame,
    ) -> orfail::Result<()> {
        self.render_to_writer(config, state, Some(frame.size().cols), frame)
            .or_fail()?;
        Ok(())
    }

    pub fn region(&self, config: &Config, state: &State, size: TerminalSize) -> TerminalRegion {
        let mut detector = SizeDetector::default();
        detector.size.rows += 1; // for bottom border

        self.render_to_writer(config, state, None, &mut detector)
            .expect("bug");
        let legend_size = detector.finish();

        if !size.contains(legend_size.to_region().bottom_right()) {
            TerminalRegion::default()
        } else {
            size.to_region()
                .take_top(legend_size.rows)
                .take_right(legend_size.cols)
        }
    }

    fn render_to_writer<W: Write>(
        &self,
        config: &Config,
        state: &State,
        cols: Option<usize>,
        mut writer: W,
    ) -> orfail::Result<()> {
        for binding in config.keybindings.iter(&state.context).or_fail()? {
            if !binding.visible {
                continue;
            }

            let action = &binding.action;
            if let Some(label) = config.keylabels.get(&binding.key) {
                writeln!(writer, "│ {label}: {action} ").or_fail()?;
            } else {
                let label = binding.key;
                writeln!(writer, "│ {label}: {action} ").or_fail()?;
            }
        }

        if let Some(cols) = cols {
            writeln!(writer, "└{}", "─".repeat(cols.saturating_sub(1))).or_fail()?;
        }

        Ok(())
    }
}

#[derive(Debug, Default)]
struct SizeDetector {
    cursor: TerminalPosition,
    size: TerminalSize,
}

impl SizeDetector {
    fn finish(mut self) -> TerminalSize {
        if self.size.cols > 0 {
            self.size.rows += 1;
        }
        TerminalSize::rows_cols(self.size.rows, self.size.cols)
    }
}

impl Write for SizeDetector {
    fn write_str(&mut self, s: &str) -> std::fmt::Result {
        for ch in s.chars() {
            match ch {
                '\n' => {
                    self.size.rows += 1;
                    self.size.cols = self.size.cols.max(self.cursor.col);
                    self.cursor.col = 0;
                    self.cursor.row += 1;
                }
                _ => {
                    self.cursor.col += 1;
                }
            }
        }
        self.size.cols = self.size.cols.max(self.cursor.col);

        Ok(())
    }
}