bevy_ui_bits 0.14.0

A tiny and opinionated collection of UI components for Bevy
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

use bevy::prelude::*;

/// Typical layout component [Bundle]
#[derive(Bundle)]
pub struct Container {
    node: Node,
    background_color: BackgroundColor,
    transform: Transform,
    visibility: Visibility,
}

impl Default for Container {
    /// Creates a new [Container] with:
    /// - auto width and height,
    /// - centered content and items,
    /// - and column flex direction.
    fn default() -> Self {
        Container {
            node: Node {
                height: Val::Auto,
                width: Val::Auto,
                flex_direction: FlexDirection::Column,
                justify_content: JustifyContent::Center,
                align_items: AlignItems::Center,
                ..default()
            },
            background_color: BackgroundColor::DEFAULT,
            transform: Transform::default(),
            visibility: Visibility::default(),
        }
    }
}

impl Container {
    /// Creates a new [Container] with:
    /// - auto width and height,
    /// - centered content and items,
    /// - and column flex direction.
    pub fn new() -> Self {
        Container::default()
    }

    /// Creates a [Container] with the provided width value
    pub fn width(width: Val) -> Self {
        let mut container = Self::default();
        container.node.width = width;
        container
    }

    /// Creates a [Container] with the provided height value
    pub fn height(height: Val) -> Self {
        let mut container = Self::default();
        container.node.height = height;
        container
    }

    /// Creates a [Container] with the provided width and height values
    pub fn size(width: Val, height: Val) -> Self {
        let mut container = Self::default();
        container.node.width = width;
        container.node.height = height;
        container
    }

    /// Sets the background color with the provided [Color]
    pub fn background_color(mut self, color: Color) -> Self {
        self.background_color = color.into();
        self
    }

    /// Sets position type as [PositionType::Absolute]
    pub fn absolute(mut self) -> Self {
        self.node.position_type = PositionType::Absolute;
        self
    }

    /// Sets flex direction as [FlexDirection::Row]
    pub fn row(mut self) -> Self {
        self.node.flex_direction = FlexDirection::Row;
        self
    }

    /// Sets justify content as [JustifyContent::FlexStart]
    pub fn justify_start(mut self) -> Self {
        self.node.justify_content = JustifyContent::FlexStart;
        self
    }

    /// Sets justify content as [JustifyContent::FlexEnd]
    pub fn justify_end(mut self) -> Self {
        self.node.justify_content = JustifyContent::FlexEnd;
        self
    }

    /// Sets justify content as [JustifyContent::SpaceBetween]
    pub fn justify_between(mut self) -> Self {
        self.node.justify_content = JustifyContent::SpaceBetween;
        self
    }

    /// Sets justify content as [JustifyContent::SpaceAround]
    pub fn justify_around(mut self) -> Self {
        self.node.justify_content = JustifyContent::SpaceAround;
        self
    }

    /// Sets align items as [AlignItems::FlexStart]
    pub fn items_start(mut self) -> Self {
        self.node.align_items = AlignItems::FlexStart;
        self
    }

    /// Sets align items as [AlignItems::FlexEnd]
    pub fn items_end(mut self) -> Self {
        self.node.align_items = AlignItems::FlexEnd;
        self
    }

    /// Sets align content as [AlignContent::FlexStart]
    pub fn content_start(mut self) -> Self {
        self.node.align_content = AlignContent::FlexStart;
        self
    }

    /// Sets flex wrap as [FlexWrap::Wrap]
    pub fn wrap(mut self) -> Self {
        self.node.flex_wrap = FlexWrap::Wrap;
        self
    }

    /// Sets the container padding with the provided [UiRect]
    pub fn padding(mut self, padding: UiRect) -> Self {
        self.node.padding = padding;
        self
    }

    /// Sets the container margin with the provided [UiRect]
    pub fn margin(mut self, margin: UiRect) -> Self {
        self.node.margin = margin;
        self
    }
}