ttf-parser 0.25.1

A high-level, safe, zero-allocation font parser for TrueType, OpenType, and AAT.
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

use std::num::NonZeroU16;
use ttf_parser::{GlyphId, RasterImageFormat};
use ttf_parser::sbix::Table;
use crate::{convert, Unit::*};

#[test]
fn single_glyph() {
    let data = convert(&[
        UInt16(1), // version
        UInt16(0), // flags
        UInt32(1), // number of strikes
        UInt32(12), // strike offset [0]

        // Strike [0]
        UInt16(20), // pixels_per_em
        UInt16(72), // ppi
        UInt32(12), // glyph data offset [0]
        UInt32(44), // glyph data offset [1]

        // Glyph Data [0]
        UInt16(1), // x
        UInt16(2), // y
        Raw(b"png "), // type tag
        // PNG data, just the part we need
        Raw(&[0x89, 0x50, 0x4E, 0x47]),
        Raw(&[0x0D, 0x0A, 0x1A, 0x0A]),
        Raw(&[0x00, 0x00, 0x00, 0x0D]),
        Raw(&[0x49, 0x48, 0x44, 0x52]),
        UInt32(20), // width
        UInt32(30), // height
    ]);

    let table = Table::parse(NonZeroU16::new(1).unwrap(), &data).unwrap();
    assert_eq!(table.strikes.len(), 1);

    let strike = table.strikes.get(0).unwrap();
    assert_eq!(strike.pixels_per_em, 20);
    assert_eq!(strike.ppi, 72);
    assert_eq!(strike.len(), 1);

    let glyph_data = strike.get(GlyphId(0)).unwrap();
    assert_eq!(glyph_data.x, 1);
    assert_eq!(glyph_data.y, 2);
    assert_eq!(glyph_data.width, 20);
    assert_eq!(glyph_data.height, 30);
    assert_eq!(glyph_data.pixels_per_em, 20);
    assert_eq!(glyph_data.format, RasterImageFormat::PNG);
    assert_eq!(glyph_data.data.len(), 24);
}

#[test]
fn duplicate_glyph() {
    let data = convert(&[
        UInt16(1), // version
        UInt16(0), // flags
        UInt32(1), // number of strikes
        UInt32(12), // strike offset [0]

        // Strike [0]
        UInt16(20), // pixels_per_em
        UInt16(72), // ppi
        UInt32(16), // glyph data offset [0]
        UInt32(48), // glyph data offset [1]
        UInt32(58), // glyph data offset [2]

        // Glyph Data [0]
        UInt16(1), // x
        UInt16(2), // y
        Raw(b"png "), // type tag
        // PNG data, just the part we need
        Raw(&[0x89, 0x50, 0x4E, 0x47]),
        Raw(&[0x0D, 0x0A, 0x1A, 0x0A]),
        Raw(&[0x00, 0x00, 0x00, 0x0D]),
        Raw(&[0x49, 0x48, 0x44, 0x52]),
        UInt32(20), // width
        UInt32(30), // height

        // Glyph Data [1]
        UInt16(3), // x
        UInt16(4), // y
        Raw(b"dupe"), // type tag
        UInt16(0), // glyph id
    ]);

    let table = Table::parse(NonZeroU16::new(2).unwrap(), &data).unwrap();
    assert_eq!(table.strikes.len(), 1);

    let strike = table.strikes.get(0).unwrap();
    assert_eq!(strike.pixels_per_em, 20);
    assert_eq!(strike.ppi, 72);
    assert_eq!(strike.len(), 2);

    let glyph_data = strike.get(GlyphId(1)).unwrap();
    assert_eq!(glyph_data.x, 1);
    assert_eq!(glyph_data.y, 2);
    assert_eq!(glyph_data.width, 20);
    assert_eq!(glyph_data.height, 30);
    assert_eq!(glyph_data.pixels_per_em, 20);
    assert_eq!(glyph_data.format, RasterImageFormat::PNG);
    assert_eq!(glyph_data.data.len(), 24);
}

#[test]
fn recursive() {
    let data = convert(&[
        UInt16(1), // version
        UInt16(0), // flags
        UInt32(1), // number of strikes
        UInt32(12), // strike offset [0]

        // Strike [0]
        UInt16(20), // pixels_per_em
        UInt16(72), // ppi
        UInt32(16), // glyph data offset [0]
        UInt32(26), // glyph data offset [1]
        UInt32(36), // glyph data offset [2]

        // Glyph Data [0]
        UInt16(1), // x
        UInt16(2), // y
        Raw(b"dupe"), // type tag
        UInt16(0), // glyph id

        // Glyph Data [1]
        UInt16(1), // x
        UInt16(2), // y
        Raw(b"dupe"), // type tag
        UInt16(0), // glyph id
    ]);

    let table = Table::parse(NonZeroU16::new(2).unwrap(), &data).unwrap();
    let strike = table.strikes.get(0).unwrap();
    assert!(strike.get(GlyphId(0)).is_none());
    assert!(strike.get(GlyphId(1)).is_none());
}