mdfried 0.22.1

A markdown viewer for the terminal that renders images and big headers
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

use std::fmt::Write as _;

use ratatui::{buffer::CellDiffOption, layout::Rect, style::Color, widgets::Widget};
use unicode_width::UnicodeWidthChar as _;

/// Yields slices of chars where each chunk has unicode width <= max_width.
/// Wide characters (width > 1) are always in their own chunk due to Kitty limitations (or perhaps
/// this is problem with the implementation - in any case this solves it).
fn unicode_chunks(chars: &[char], max_width: u8) -> impl Iterator<Item = (&[char], u8)> {
    let mut start = 0;
    std::iter::from_fn(move || {
        if start >= chars.len() {
            return None;
        }
        let mut end = start;
        let mut width = 0;
        while end < chars.len() {
            let char_width = chars[end].width().unwrap_or(1) as u8;
            if char_width > 1 {
                if width > 0 {
                    break; // end current chunk, wide char starts next chunk
                }
                // wide char alone
                width = char_width;
                end += 1;
                break;
            }
            if width + char_width > max_width {
                break;
            }
            width += char_width;
            end += 1;
        }
        let chunk = &chars[start..end];
        start = end;
        Some((chunk, width))
    })
}

pub struct BigText<'a> {
    text: &'a str,
    tier: u8,
    color: Option<Color>,
}

impl<'a> BigText<'a> {
    pub fn new(text: &'a str, tier: u8, color: Option<Color>) -> Self {
        BigText { text, tier, color }
    }

    /// When wrapping with text-wrap, the final line width must be known in advance before
    /// rendering.
    pub fn size_ratio(tier: u8) -> (u8, u8) {
        match tier {
            1 => (7, 7),
            2 => (5, 6),
            3 => (3, 4),
            4 => (2, 3),
            5 => (3, 5),
            _ => (1, 3),
        }
    }

    fn text_sizing_sequence(&self, area_width: u16) -> String {
        let (n, d) = BigText::size_ratio(self.tier);

        let mut symbol = String::new();

        // Erase-character dance.
        // We must erase anything inside area, which is 2 lines high and `area.width` wide.
        // This must be done before we write the text.
        // Also disable DECAWM, unsure if really necessary.
        write!(symbol, "\x1b[{}X\x1B[?7l", area_width).expect("write to string");
        write!(symbol, "\x1b[1B").expect("write to string");
        write!(symbol, "\x1b[{}X\x1B[?7l", area_width).expect("write to string");
        write!(symbol, "\x1b[1A").expect("write to string");

        if let Some(color) = self.color {
            match color {
                Color::Indexed(ansi_index) => {
                    write!(symbol, "\x1b[{ansi_index}m").expect("write to string");
                }
                Color::Rgb(r, g, b) => {
                    write!(symbol, "\x1b[38;2;{r};{g};{b}m").expect("write to string");
                }
                _ => {}
            }
        }

        let chars: Vec<char> = self.text.chars().collect();
        for (chunk, chunk_width) in unicode_chunks(&chars, d) {
            // w=n for full chunks (width == d), round up for partial chunks to avoid clipping
            let w = if chunk_width == d {
                n
            } else {
                (chunk_width * n).div_ceil(d)
            };

            write!(symbol, "\x1b]66;s=2:n={n}:d={d}:w={w};").expect("write to string");
            symbol.extend(chunk);
            write!(symbol, "\x1b\\").expect("write to string");
        }

        if self.color.is_some() {
            // Reset color
            write!(symbol, "\x1b[0m").expect("write to string");
        }

        symbol
    }
}

impl Widget for BigText<'_> {
    fn render(self, area: Rect, buf: &mut ratatui::buffer::Buffer) {
        if area.width == 0 || area.height == 0 {
            return;
        }

        let symbol = self.text_sizing_sequence(area.width);

        // Skip entire text area except first cell
        let mut skip_first = false;

        for y in area.top()..area.bottom() {
            for x in area.left()..area.right() {
                if skip_first {
                    buf.cell_mut((x, y))
                        .map(|cell| cell.set_diff_option(CellDiffOption::Skip));
                } else {
                    skip_first = true;
                    buf.cell_mut((x, y)).map(|cell| cell.set_symbol(&symbol));
                }
            }
        }
    }
}