kaolin 0.1.10

A Rust library for flexible layouts, inspired by Clay
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

use kaolin::style::{KaolinColor, TextStyle};

#[derive(Debug, Clone, Copy, PartialEq, Default)]
pub enum TestColor {
    Black,
    #[default]
    Transparent,
    #[allow(dead_code)]
    Red,
}

impl KaolinColor<TestColor> for TestColor {
    fn default_foreground_color() -> Self {
        TestColor::Black
    }

    fn default_background_color() -> Self {
        TestColor::Transparent
    }
}

#[allow(dead_code)]
pub fn measure_text(text: &str, _config: &TextStyle<TestColor>) -> (f64, f64) {
    (text.len() as f64 * 10.0, 20.0)
}

#[macro_export]
macro_rules! assert_render_commands {
    ($output:expr, $expected:expr $(,)?) => {{
        let o: kaolin::commands::RenderCommands<TestColor> = $output;
        let e: Vec<kaolin::commands::RenderCommand<TestColor>> = $expected;
        for (command, expected_command) in o.zip(e.into_iter()) {
            assert_eq!(command, expected_command, "Render command mismatch");
        }
    }};
}

#[macro_export]
macro_rules! assert_position {
    ($command:expr, ($x:expr, $y:expr)) => {{
        let c: kaolin::commands::RenderCommand<TestColor> = $command.unwrap();
        let (x, y) = match c {
            kaolin::commands::RenderCommand::DrawRectangle { x, y, .. } => (x, y),
            kaolin::commands::RenderCommand::DrawText { x, y, .. } => (x, y),
            // _ => panic!("Expected DrawRectangle or DrawText command"),
        };
        assert_eq!(x, $x, "X position mismatch");
        assert_eq!(y, $y, "Y position mismatch");
    }};
}

#[macro_export]
macro_rules! assert_size {
    ($command:expr, ($w:expr, _)) => {{
        let c: kaolin::commands::RenderCommand<TestColor> = $command.unwrap();
        match c {
            kaolin::commands::RenderCommand::DrawRectangle { width, .. } => {
                assert_eq!(width, $w, "Width mismatch");
            }
            _ => panic!("Expected DrawRectangle command"),
        }
    }};
    ($command:expr, (_, $h:expr)) => {{
        let c: kaolin::commands::RenderCommand<TestColor> = $command.unwrap();
        match c {
            kaolin::commands::RenderCommand::DrawRectangle { height, .. } => {
                assert_eq!(height, $h, "Height mismatch");
            }
            _ => panic!("Expected DrawRectangle command"),
        }
    }};

    ($command:expr, ($w:expr, $h:expr)) => {{
        let c: kaolin::commands::RenderCommand<TestColor> = $command.unwrap();
        match c {
            kaolin::commands::RenderCommand::DrawRectangle { width, height, .. } => {
                assert_eq!(width, $w, "Width mismatch");
                assert_eq!(height, $h, "Height mismatch");
            }
            _ => panic!("Expected DrawRectangle command"),
        }
    }};
}

#[macro_export]
macro_rules! assert_text_content {
    ($command:expr, $text:expr) => {{
        let c: kaolin::commands::RenderCommand<TestColor> = $command.unwrap();
        match c {
            kaolin::commands::RenderCommand::DrawText { text, .. } => {
                assert_eq!(text, $text, "Text content mismatch");
            }
            _ => panic!("Expected DrawText command"),
        }
    }};
}

#[macro_export]
macro_rules! assert_color {
    ($command:expr, $color:expr) => {{
        let c: kaolin::commands::RenderCommand<TestColor> = $command.unwrap();
        let color = match c {
            kaolin::commands::RenderCommand::DrawRectangle { color, .. } => color,
            kaolin::commands::RenderCommand::DrawText { color, .. } => color,
        };
        assert_eq!(color, $color, "Color mismatch");
    }};
}

#[macro_export]
macro_rules! assert_multiple {
    ($command:expr, $($statement:ident($arg:tt)),+ $(,)?) => {{
        let command: kaolin::commands::RenderCommand<TestColor> = $command.unwrap();
        $(
            $statement!(Some(command.clone()), $arg);
        )+
    }};
}