zhc_ir 0.1.8

Graph-based intermediate representation framework with dialect support
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

use super::*;
use std::marker::PhantomData;
use zhc_utils::graphics::{Frame, Height, Remaining, Size, Taken};

macro_rules! vstack_fixed {
    ($name:ident, $n:literal, [$($etype:ident, $efield:ident),*]) => {
        /// Fixed vertical stack of exactly $n elements with spacing.
        pub struct $name<$($etype: Element),*, C: Class = NoClass> {
            $(pub $efield: $etype,)*
            class: PhantomData<C>,
            variable: VariableCell,
        }

        impl<$($etype: Element),*, C: Class> $name<$($etype),*, C> {
            /// Creates a new vertical stack.
            pub fn new($($efield: $etype),*) -> Self {
                Self {
                    $($efield,)*
                    class: PhantomData,
                    variable: VariableCell::fresh(),
                }
            }
        }

        impl<$($etype: Element),*, C: Class> Element for $name<$($etype),*, C> {
            fn solve_size(&mut self, stylesheet: &StyleSheet) {
                let style = stylesheet.get::<C>();
                $(self.$efield.solve_size(stylesheet);)*

                let mut size = Size::ZERO.pad_top(style.padding);
                let mut first = true;
                $(
                    if !first {
                        size = size.pad_bottom(style.spacing);
                    }
                    size = size.stack_vertical(self.$efield.get_size());
                    first = false;
                )*
                size = size.pad_bottom(style.padding);
                self.variable.set_size(size);
            }

            fn solve_frame(&mut self, stylesheet: &StyleSheet, available: Frame) {
                let style = stylesheet.get::<C>();
                let size = self.get_size();
                let frame = available.resize(&size, style.halign, style.valign);
                self.variable.set_frame(frame.clone());

                let mut remaining = frame.crop_top(Height(style.padding));
                let mut first = true;
                $(
                    if !first {
                        remaining = remaining.crop_top(Height(style.spacing));
                    }
                    let (Taken(available), Remaining(new_remaining)) =
                        remaining.take_top(self.$efield.get_size().height);
                    self.$efield.solve_frame(stylesheet, available);
                    remaining = new_remaining;
                    #[allow(unused_assignments)]
                    {
                        first = false;
                    }
                )*
                let remaining = remaining.crop_top(Height(style.padding));
                remaining.assert_collapsed();
            }

            fn get_size(&self) -> Size {
                self.variable.get_size()
            }

            fn get_frame(&self) -> Frame {
                self.variable.get_frame()
            }

            fn get_variable_cell(&self) -> VariableCell {
                self.variable.clone()
            }
        }
    };
}

vstack_fixed!(V3, 3, [E1, e1, E2, e2, E3, e3]);
vstack_fixed!(V4, 4, [E1, e1, E2, e2, E3, e3, E4, e4]);