mplusfonts-macros 0.3.4

Procedural macros re-exported in the mplusfonts crate
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

use proc_macro2::TokenStream;
use quote::{ToTokens, quote};
use swash::GlyphId;

use crate::mplus::bitmap::ImageList;

pub struct Glyph {
    pub x_offset: f32,
    pub y_offset: f32,
    pub positions: u8,
    pub bit_depth: u8,
    pub id: GlyphId,
    pub advance_width: f32,
    pub images: ImageList,
}

pub struct GlyphList(pub Vec<Glyph>);

impl ToTokens for GlyphList {
    fn to_tokens(&self, tokens: &mut TokenStream) {
        let Self(vec) = self;
        let mut previous_glyph = None;
        for glyph in vec.iter().rev() {
            let Glyph {
                x_offset,
                y_offset,
                positions,
                bit_depth,
                id,
                advance_width: _,
                images,
            } = glyph;

            let next_glyph = match previous_glyph.take() {
                Some((x_offset, y_offset, glyph)) => {
                    let value = next_glyph(x_offset, y_offset, *positions, *bit_depth, glyph);

                    quote!(Some(#value))
                }
                None => quote!(None),
            };
            let glyph = quote! {
                ::mplusfonts::glyph::Glyph {
                    id: #id,
                    images: #images,
                    next: #next_glyph,
                }
            };

            let glyph = previous_glyph.replace((*x_offset, *y_offset, glyph));
            debug_assert!(glyph.is_none(), "expected token stream to be taken");
        }

        let glyph = match previous_glyph {
            Some((x_offset, y_offset, glyph)) => {
                debug_assert_eq!(0.0, x_offset, "expected glyph with no horizontal offset",);
                debug_assert_eq!(0.0, y_offset, "expected glyph with no vertical offset",);

                glyph
            }
            None => quote! {
                ::mplusfonts::glyph::Glyph::NULL
            },
        };

        tokens.extend(glyph);
    }
}

fn next_glyph(
    x_offset: f32,
    y_offset: f32,
    positions: u8,
    bit_depth: u8,
    glyph: impl ToTokens,
) -> impl ToTokens {
    let positions = positions as usize;
    let params = match bit_depth {
        1 => quote!(::embedded_graphics::pixelcolor::BinaryColor, #positions),
        2 => quote!(::embedded_graphics::pixelcolor::Gray2, #positions),
        4 => quote!(::embedded_graphics::pixelcolor::Gray4, #positions),
        8 => quote!(::embedded_graphics::pixelcolor::Gray8, #positions),
        x => panic!("expected one of: `1`, `2`, `4`, `8`; found: `{x}`"),
    };
    let next_glyph = quote! {
        ::mplusfonts::glyph::NextGlyph {
            x_offset: #x_offset,
            y_offset: #y_offset,
            glyph: #glyph,
        }
    };
    let value = quote!(const {
        const DATA: ::mplusfonts::glyph::NextGlyph<#params> = #next_glyph;

        &DATA
    });

    value
}