mix 0.2.1

mix - a rust ui library cooked up in half a day! (expect extra salt)
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

use crate::platform::math::Vec2;

#[derive(Clone, Copy, Debug, PartialEq)]
pub enum LayoutDirection {
    Horizontal,
    Vertical,
}

#[derive(Clone, Copy, Debug, PartialEq)]
pub enum LayoutSize {
    Fixed(f32),
    Flex(f32),
    Fill,
    Fit,
}

impl LayoutSize {
    pub fn resolve(&self, available: f32, content: f32) -> f32 {
        match self {
            LayoutSize::Fixed(size) => *size,
            LayoutSize::Flex(factor) => available * factor,
            LayoutSize::Fill => available,
            LayoutSize::Fit => content,
        }
    }
}

#[derive(Clone, Copy, Debug, PartialEq)]
pub enum LayoutAlign {
    Start,
    Center,
    End,
    Stretch,
}

impl LayoutAlign {
    pub fn resolve(&self, container: f32, item: f32) -> f32 {
        match self {
            LayoutAlign::Start => 0.0,
            LayoutAlign::Center => (container - item) * 0.5,
            LayoutAlign::End => container - item,
            LayoutAlign::Stretch => 0.0, // Item will be stretched to fill container
        }
    }
}

#[derive(Clone, Debug)]
pub struct Layout {
    pub direction: LayoutDirection,
    pub width: LayoutSize,
    pub height: LayoutSize,
    pub align_items: LayoutAlign,
    pub justify_content: LayoutAlign,
    pub padding: Vec2,
    pub spacing: f32,
}

impl Layout {
    pub fn horizontal() -> Self {
        Self {
            direction: LayoutDirection::Horizontal,
            width: LayoutSize::Fill,
            height: LayoutSize::Fit,
            align_items: LayoutAlign::Start,
            justify_content: LayoutAlign::Start,
            padding: Vec2::new(0.0, 0.0),
            spacing: 0.0,
        }
    }
    
    pub fn vertical() -> Self {
        Self {
            direction: LayoutDirection::Vertical,
            width: LayoutSize::Fill,
            height: LayoutSize::Fit,
            align_items: LayoutAlign::Start,
            justify_content: LayoutAlign::Start,
            padding: Vec2::new(0.0, 0.0),
            spacing: 0.0,
        }
    }
    
    pub fn with_width(mut self, width: LayoutSize) -> Self {
        self.width = width;
        self
    }
    
    pub fn with_height(mut self, height: LayoutSize) -> Self {
        self.height = height;
        self
    }
    
    pub fn with_align_items(mut self, align_items: LayoutAlign) -> Self {
        self.align_items = align_items;
        self
    }
    
    pub fn with_justify_content(mut self, justify_content: LayoutAlign) -> Self {
        self.justify_content = justify_content;
        self
    }
    
    pub fn with_padding(mut self, padding: Vec2) -> Self {
        self.padding = padding;
        self
    }
    
    pub fn with_spacing(mut self, spacing: f32) -> Self {
        self.spacing = spacing;
        self
    }
}