wide.rs

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

//! Shows how far glyphs that stretch horizontally can stretch

use suki::font;

fn main() {
    let loaded = font::load(std::fs::read("font/latinmodern-math.otf").unwrap()).unwrap();
    let units = font::units_per_em(&loaded);

    for (name, character) in [
        ("\u{20d7} right arrow accent", '\u{20d7}'),
        ("\u{23de} top brace", '\u{23de}'),
        ("\u{302} hat", '\u{302}'),
        ("\u{303} tilde", '\u{303}'),
        ("\u{27f6} long right arrow", '\u{27f6}'),
        ("\u{2192} right arrow", '\u{2192}'),
    ] {
        let Some(glyph) = font::glyph_of(&loaded, character) else {
            println!("{name}: missing");
            continue;
        };

        print!("{name} glyph {glyph} advance {:.3}", font::advance(&loaded, glyph));

        match font::horizontal_growth(&loaded, glyph) {
            Some(growth) => {
                println!(" variants {} parts {}", growth.variant.len(), growth.part.len());

                for variant in &growth.variant {
                    println!("    variant {} length {:.3}", variant.glyph, variant.measure);
                }

                for part in &growth.part {
                    println!(
                        "    part {} full length {:.3} ends {:.3}/{:.3} extendable {}",
                        part.glyph, part.full_advance, part.start_connector,
                        part.end_connector, part.extender
                    );
                }
            }
            None => println!(" cannot stretch horizontally"),
        }
    }

    for text in ["AB", "xyz", "abc"] {
        let width: f64 = text
            .chars()
            .filter_map(suki::symbol::italic)
            .filter_map(|c| font::glyph_of(&loaded, c))
            .map(|g| font::advance(&loaded, g))
            .sum();
        println!("{text} width {width:.3}  (1em = {units})");
    }
}