bevy_quickmenu 0.2.0

A simple way of quickly creating nested menus in bevy that can be navigated with keys, gamepads and pointers
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

//! Lightweight abstractions over styles
//! Instead of using the bevy styles with all their properties, these simplified
//! styles are mostly used to define the looks of menus and the different
//! control states of buttons.

use bevy::prelude::*;

#[derive(Debug, Clone, Copy)]
pub struct ControlState {
    pub fg: Color,
    pub bg: Color,
}

impl ControlState {
    fn clear(fg: Color) -> Self {
        Self {
            fg,
            bg: Color::rgba(0.0, 0.0, 0.0, 0.0),
        }
    }
    fn normal() -> Self {
        Self {
            fg: Color::WHITE,
            bg: Color::NAVY,
        }
    }

    fn hover() -> Self {
        Self {
            fg: Color::YELLOW,
            bg: Color::NAVY,
        }
    }

    fn selected() -> Self {
        Self {
            fg: Color::NAVY,
            bg: Color::WHITE,
        }
    }
}

#[derive(Debug, Clone)]
pub struct IconStyle {
    /// The width of the icon
    pub width: Val,
    /// The size of the icon
    pub height: Val,
    /// The padding
    pub padding: UiRect,
    /// An alternative foreground color
    pub tint_color: Color,
}

impl Default for IconStyle {
    fn default() -> Self {
        Self {
            width: Val::Px(32.0),
            height: Val::Px(32.0),
            padding: UiRect::all(Val::Px(6.0)),
            tint_color: Color::WHITE,
        }
    }
}

#[derive(Debug, Clone)]
pub struct StyleEntry {
    pub size: f32,
    pub margin: UiRect,
    pub padding: UiRect,
    pub normal: ControlState,
    pub hover: ControlState,
    pub selected: ControlState,
    pub icon_style: IconStyle,
}

impl StyleEntry {
    pub fn button() -> Self {
        Self {
            size: 20.0,
            margin: UiRect::all(Val::Px(5.0)),
            padding: UiRect::all(Val::Px(5.0)),
            normal: ControlState::normal(),
            hover: ControlState::hover(),
            selected: ControlState::selected(),
            icon_style: IconStyle::default(),
        }
    }

    pub fn label() -> Self {
        let gray = Color::rgb(0.7, 0.7, 0.7);
        Self {
            size: 18.0,
            margin: UiRect::all(Val::Px(5.0)),
            padding: UiRect::all(Val::Px(5.0)),
            normal: ControlState::clear(gray),
            hover: ControlState::clear(gray),
            selected: ControlState::clear(gray),
            icon_style: IconStyle::default(),
        }
    }

    pub fn headline() -> Self {
        Self {
            size: 24.0,
            margin: UiRect::all(Val::Px(5.0)),
            padding: UiRect::all(Val::Px(5.0)),
            normal: ControlState::clear(Color::WHITE),
            hover: ControlState::clear(Color::WHITE),
            selected: ControlState::clear(Color::WHITE),
            icon_style: IconStyle::default(),
        }
    }
}

#[derive(Debug, Clone, Resource)]
pub struct Stylesheet {
    pub button: StyleEntry,
    pub label: StyleEntry,
    pub headline: StyleEntry,
    pub vertical_spacing: f32,
    pub style: Option<Style>,
    pub background: Option<BackgroundColor>,
}

impl Default for Stylesheet {
    fn default() -> Self {
        Self {
            button: StyleEntry::button(),
            label: StyleEntry::label(),
            headline: StyleEntry::headline(),
            vertical_spacing: 10.0,
            style: None,
            background: None,
        }
    }
}

impl Stylesheet {
    pub fn with_background(mut self, bg: BackgroundColor) -> Self {
        self.background = Some(bg);
        self
    }

    pub fn with_style(mut self, style: Style) -> Self {
        self.style = Some(style);
        self
    }
}