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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

use alloc::{collections::VecDeque, string::String};

use crate::{elements::flexbox::FlexBox, style::border};

/// A single rendering command.
#[derive(Debug, Clone)]
pub enum RenderCommand<Color>
where
    Color: Default + Copy + PartialEq + crate::style::KaolinColor<Color>,
{
    /// Draws a rectangle on the screen.
    DrawRectangle {
        id: String,
        /// The absolute x position of the rectangle.
        x: f64,
        /// The absolute y position of the rectangle.
        y: f64,
        /// The width of the rectangle.
        width: f64,
        /// The height of the rectangle.
        height: f64,
        /// The background color of the rectangle.
        color: Color,
        /// The corner radius of the rectangle.
        corner_radius: f32,
        /// The border settings of the rectangle (width, color).
        border: border::Border<Color>,
    },
    /// Draws text on the screen.
    ///
    /// Multiple DrawText commands can be issued to draw a single text element
    /// on different lines.
    DrawText {
        /// The text to be drawn, in a single line. This is only converted to a
        /// String when generating the specific command to allow for safe deallocation
        /// of the input string within the [`KaolinScope::text`] call. Internally,
        /// calculations are performed with `&str` slices.
        text: String,
        /// The absolute x position of the text.  
        x: f64,
        /// The absolute y position of the text.
        y: f64,
        /// The font ID of the text, passed through from the style.
        /// Interpretation of this value depends on the renderer.
        font_id: u32,
        /// The font size of the text.
        font_size: f32,
        /// The color of the text.
        color: Color,
    },
}

impl<Color> PartialEq for RenderCommand<Color>
where
    Color: Default + Copy + PartialEq + crate::style::KaolinColor<Color>,
{
    fn eq(&self, other: &Self) -> bool {
        match (self, other) {
            (
                RenderCommand::DrawRectangle {
                    x,
                    y,
                    width,
                    height,
                    color,
                    corner_radius,
                    ..
                },
                RenderCommand::DrawRectangle {
                    x: other_x,
                    y: other_y,
                    width: other_width,
                    height: other_height,
                    color: other_color,
                    corner_radius: other_corner_radius,
                    ..
                },
            ) => {
                x == other_x
                    && y == other_y
                    && width == other_width
                    && height == other_height
                    && color == other_color
                    && corner_radius == other_corner_radius
            }
            (
                RenderCommand::DrawText {
                    text,
                    x,
                    y,
                    font_id,
                    font_size,
                    color,
                },
                RenderCommand::DrawText {
                    text: other_text,
                    x: other_x,
                    y: other_y,
                    font_id: other_font_id,
                    font_size: other_font_size,
                    color: other_color,
                },
            ) => {
                text == other_text
                    && x == other_x
                    && y == other_y
                    && font_id == other_font_id
                    && font_size == other_font_size
                    && color == other_color
            }
            _ => false,
        }
    }
}

/// Represents a series of rendering commands.
///
/// This struct implements an iterator of the render commands, which should be processed in order.
#[derive(Debug, Clone, PartialEq)]
pub struct RenderCommands<Color>
where
    Color: Default + Copy + PartialEq + crate::style::KaolinColor<Color>,
{
    commands: VecDeque<RenderCommand<Color>>,
}

impl<Color> RenderCommands<Color>
where
    Color: Default + Copy + PartialEq + crate::style::KaolinColor<Color>,
{
    /// Creates a new set of render commands from a root layout.
    pub(crate) fn new(root: FlexBox<Color>) -> Self {
        let children = root.children;
        RenderCommands {
            commands: children.render_nodes().collect::<VecDeque<_>>(),
        }
    }

    pub fn is_empty(&self) -> bool {
        self.commands.is_empty()
    }

    pub fn len(&self) -> usize {
        self.commands.len()
    }
}

impl<Color> Iterator for RenderCommands<Color>
where
    Color: Default + Copy + PartialEq + crate::style::KaolinColor<Color>,
{
    type Item = RenderCommand<Color>;

    fn next(&mut self) -> Option<Self::Item> {
        self.commands.pop_front()
    }
}