zenthra-text 0.2.0

Typography, font shaping, and text layout for the Zenthra UI framework
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

use cosmic_text::{Buffer, CacheKey};

#[derive(Debug, Clone)]
pub struct GlyphPosition {
    pub cache_key: CacheKey,
    pub x: f32,
    pub y: f32,
    pub width: f32,
    pub color: [u8; 4],
    pub start: usize,
    pub end: usize,
}

/// Per-line metrics — used for bg highlight rect generation.
#[derive(Debug, Clone)]
pub struct LineInfo {
    pub x: f32,
    pub y: f32,
    pub width: f32,
}

#[derive(Debug, Clone, Default)]
pub struct TextLayout {
    pub glyphs: Vec<GlyphPosition>,
    pub lines: Vec<LineInfo>,
    pub width: f32,
    pub height: f32,
}

impl TextLayout {
    pub fn from_buffer(buffer: &Buffer) -> Self {
        let mut glyphs = Vec::new();
        let mut lines = Vec::new();
        let mut max_width = 0.0f32;
        let mut max_y = 0.0f32;

        for run in buffer.layout_runs() {
            let mut line_width = 0.0f32;
            let mut line_x = f32::MAX;

            for glyph in run.glyphs.iter() {
                let physical = glyph.physical((0.0, 0.0), 1.0);
                let color = match glyph.color_opt {
                    Some(c) => [c.r(), c.g(), c.b(), c.a()],
                    None => [255u8, 255, 255, 255],
                };
                glyphs.push(GlyphPosition {
                    cache_key: physical.cache_key,
                    x: glyph.x,
                    y: run.line_y,
                    width: glyph.w,
                    color,
                    start: glyph.start,
                    end: glyph.end,
                });
                let right = glyph.x + glyph.w;
                line_width = line_width.max(right);
                line_x = line_x.min(glyph.x);
                max_width = max_width.max(right);
            }

            if line_x == f32::MAX {
                line_x = 0.0;
            }

            lines.push(LineInfo {
                x: line_x,
                y: run.line_y,
                width: line_width - line_x,
            });

            max_y = max_y.max(run.line_y);
        }

        Self {
            glyphs,
            lines,
            width: max_width,
            height: max_y,
        }
    }
}