wavedrom 0.1.0

A Pure Rust Digital Timing Diagram Generator based on WaveDrom-JS
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
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

use std::marker::PhantomData;

#[cfg(feature = "embed_font")]
static EMBEDDED_HELVETICA: std::sync::OnceLock<ttf_parser::Face<'static>> = std::sync::OnceLock::new(); 

/// The font that is used by the svg assembler to calculate text widths.
///
/// The `embed_font` feature (that is enabled by default)` includes a [Helvetica][helvetica] [TTF
/// file][ttf] into the binary, which enables better width calculations even when using more exotic
/// characters. When this feature is disabled, only the width of [ASCII][ascii] characters is
/// property calculated. Other characters widths are overestimated.
///
/// [helvetica]: https://en.wikipedia.org/wiki/Helvetica
/// [ttf]: https://en.wikipedia.org/wiki/TrueType
/// [ascii]: https://en.wikipedia.org/wiki/ASCII
#[derive(Debug, Default, Clone, Copy)]
pub struct Font {
    _marker: PhantomData<()>,
}

impl Font {
    /// Get an upperbound on the text width for a given string `s` and `font_size`.
    ///
    /// Given a `font_size` of *x* units the width of the string `s` without letter spacing is
    /// `get_text_width(s, font_size)` units.
    pub fn get_text_width(&self, s: &str, font_size: u32) -> u32 {
        let width = f64::from(self.get_pts_text_width(s));

        let pts_per_em = f64::from(font_size) / f64::from(self.units_per_em());
        let width = width * pts_per_em;

        width.ceil() as u32
    }
}

#[cfg(not(feature = "embed_font"))]
impl Font {
    #[inline]
    fn units_per_em(&self) -> u16 {
        2048
    }

    fn get_pts_text_width(&self, s: &'_ str) -> u32 {
        static ADVANCE_LUT: [u16; 128] = [
            0, 0, 0, 0, 0, 0, 0, 0, 0, 569, 569, 0, 0, 569, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
            0, 0, 0, 0, 0, 569, 569, 727, 1139, 1139, 1821, 1366, 391, 682, 682, 797, 1196, 569,
            682, 569, 569, 1139, 1139, 1139, 1139, 1139, 1139, 1139, 1139, 1139, 1139, 569, 569,
            1196, 1196, 1196, 1139, 2079, 1366, 1366, 1479, 1479, 1366, 1251, 1593, 1479, 569,
            1024, 1366, 1139, 1706, 1479, 1593, 1366, 1593, 1479, 1366, 1251, 1479, 1366, 1933,
            1366, 1366, 1251, 569, 569, 569, 961, 1139, 682, 1139, 1139, 1024, 1139, 1139, 569,
            1139, 1139, 455, 455, 1024, 455, 1706, 1139, 1139, 1139, 1139, 682, 1024, 569, 1139,
            1024, 1479, 1024, 1024, 1024, 684, 532, 684, 1196, 0,
        ];

        s.chars()
            .map(|c| {
                if c.is_ascii() {
                    u32::from(ADVANCE_LUT[c as usize])
                } else {
                    2052
                }
            })
            .sum()
    }

    /// Get a string representing the Font Family of the font.
    #[inline]
    pub fn get_font_family_name(&self) -> Option<String> {
        Some("Helvetica".to_string())
    }
}

#[cfg(feature = "embed_font")]
impl Font {
    fn get_face(&self) -> &ttf_parser::Face<'static> {
        EMBEDDED_HELVETICA.get_or_init(|| {
            ttf_parser::Face::parse(include_bytes!("../../helvetica.ttf"), 0).unwrap()
        })
    }

    #[inline]
    fn units_per_em(&self) -> u16 {
        self.get_face().units_per_em()
    }

    fn get_pts_text_width(&self, s: &'_ str) -> u32 {
        let face = self.get_face();

        s.chars()
            .map(|c| {
                face
                    .glyph_index(c)
                    .and_then(|g| face.glyph_hor_advance(g))
                    .map(u32::from)
                    .unwrap_or(face.global_bounding_box().width() as u32)
            })
            .sum()
    }

    /// Get a string representing the Font Family of the font.
    pub fn get_font_family_name(&self) -> Option<String> {
        self.get_face()
            .names()
            .into_iter()
            .find(|item| item.name_id == 1)
            .and_then(|name| {
                if !name.is_unicode() {
                    return None;
                }

                // Invalid UTF16 check
                if name.name.len() % 2 != 0 {
                    return None;
                }

                let utf16_bytes = name
                    .name
                    .chunks_exact(2)
                    .map(|chunk| u16::from_be_bytes([chunk[0], chunk[1]]))
                    .collect::<Vec<u16>>();

                String::from_utf16(&utf16_bytes).ok()
            })
    }
}

#[ignore]
#[test]
#[cfg(all(feature = "gen_lut", feature = "embed_font"))]
fn generate_lookup_table() {
    let face = ttf_parser::Face::parse(include_bytes!("../helvetica.ttf"), 0).unwrap();

    println!("[");
    for c in 0..128u8 {
        let c = c as char;
        println!(
            "\t{},",
            face.glyph_index(c)
                .and_then(|g| face.glyph_hor_advance(g))
                .map(u32::from)
                .unwrap_or(0)
        );
    }
    println!("]");
    println!("units_per_em: {:?}", face.units_per_em());
    println!("Rest Advance: {:?}", face.global_bounding_box().width());

    assert!(false);
}