inlyne 0.1.4

Introducing Inlyne, a GPU powered yet browsless tool to help you quickly view markdown files in the blink of an eye.
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
144
145
146
147
148
149
150
151

use wgpu_glyph::GlyphCruncher;
use winit::window::CursorIcon;

use crate::{text::TextBox, utils::Rect};

pub const TABLE_ROW_GAP: f32 = 20.;
pub const TABLE_COL_GAP: f32 = 20.;

#[derive(Default)]
pub struct Table {
    pub headers: Vec<TextBox>,
    pub rows: Vec<Vec<TextBox>>,
}

impl Table {
    pub fn new() -> Table {
        Table::default()
    }

    pub fn hovering_over<T: GlyphCruncher>(
        &self,
        glyph_brush: &mut T,
        loc: (f32, f32),
        pos: (f32, f32),
        bounds: (f32, f32),
        click: bool,
    ) -> CursorIcon {
        let row_heights = self.row_heights(glyph_brush, pos, bounds);
        let column_widths = self.column_widths(glyph_brush, pos, bounds);
        let mut x = 0.;
        let mut y = 0.;
        for (i, header) in self.headers.iter().enumerate() {
            let size = header.size(
                glyph_brush,
                (pos.0 + x, pos.1 + y),
                (bounds.0 - x, bounds.1),
            );
            if Rect::new((pos.0 + x, pos.1 + y), size).contains(loc) {
                return header.hovering_over(
                    glyph_brush,
                    loc,
                    (pos.0 + x, pos.1 + y),
                    (bounds.0 - x, bounds.1),
                    click,
                );
            }
            x += column_widths.get(i).unwrap() + TABLE_COL_GAP;
        }
        y += row_heights.first().unwrap() + TABLE_ROW_GAP;
        for (row_num, row) in self.rows.iter().enumerate() {
            let mut x = 0.;
            for (i, row_text_box) in row.iter().enumerate() {
                let size = row_text_box.size(
                    glyph_brush,
                    (pos.0 + x, pos.1 + y),
                    (bounds.0 - x, bounds.1),
                );
                if Rect::new((pos.0 + x, pos.1 + y), size).contains(loc) {
                    return row_text_box.hovering_over(
                        glyph_brush,
                        loc,
                        (pos.0 + x, pos.1 + y),
                        (bounds.0 - x, bounds.1),
                        click,
                    );
                }
                x += column_widths[i] + TABLE_COL_GAP;
            }
            y += row_heights.get(row_num + 1).unwrap() + TABLE_ROW_GAP;
        }
        CursorIcon::Default
    }

    pub fn column_widths<T: GlyphCruncher>(
        &self,
        glyph_brush: &mut T,
        screen_position: (f32, f32),
        bounds: (f32, f32),
    ) -> Vec<f32> {
        let mut widths = Vec::with_capacity(self.headers.len());
        for (i, header_text_box) in self.headers.iter().enumerate() {
            let mut max_width = header_text_box.size(glyph_brush, screen_position, bounds).0;
            for row in &self.rows {
                if let Some(text_box) = row.get(i) {
                    let width = text_box.size(glyph_brush, screen_position, bounds).0;
                    if width > max_width {
                        max_width = width;
                    }
                }
            }
            widths.push(max_width);
        }
        widths
    }

    pub fn row_heights<T: GlyphCruncher>(
        &self,
        glyph_brush: &mut T,
        screen_position: (f32, f32),
        bounds: (f32, f32),
    ) -> Vec<f32> {
        let widths = self.column_widths(glyph_brush, screen_position, bounds);
        let mut heights = Vec::with_capacity(self.rows.len() + 1);
        let mut max_height = 0.;
        let mut x = 0.;
        let mut y = 0.;
        for (i, header_text_box) in self.headers.iter().enumerate() {
            let height = header_text_box
                .size(
                    glyph_brush,
                    (screen_position.0 + x, screen_position.1 + y),
                    (bounds.0 - x, bounds.1),
                )
                .1;
            if height > max_height {
                max_height = height;
            }
            x += widths[i] + TABLE_COL_GAP;
        }
        y += max_height + TABLE_COL_GAP;
        heights.push(max_height);
        for row in &self.rows {
            let mut x = 0.;
            let mut max_height = 0.;
            for (i, row_text_box) in row.iter().enumerate() {
                let height = row_text_box
                    .size(
                        glyph_brush,
                        (screen_position.0 + x, screen_position.1 + y),
                        (bounds.0 - x, bounds.1),
                    )
                    .1;
                if height > max_height {
                    max_height = height;
                }
                x += widths[i] + TABLE_COL_GAP;
            }
            y += max_height + TABLE_ROW_GAP;
            heights.push(max_height);
        }
        heights
    }

    pub fn push_header(&mut self, header: TextBox) {
        self.headers.push(header);
    }

    pub fn push_row(&mut self, row: Vec<TextBox>) {
        self.rows.push(row);
    }
}