Another project
feat(ui): button + checkbox widgets
Lewis: May this revision serve well! <lu5a@proton.me>
+927
+325
crates/bone-ui/src/widgets/checkbox.rs
+325
crates/bone-ui/src/widgets/checkbox.rs
···
1
+
use serde::Serialize;
2
+
3
+
use crate::frame::{FrameCtx, InteractDeclaration};
4
+
use crate::hit_test::{Interaction, Sense};
5
+
use crate::layout::LayoutRect;
6
+
use crate::strings::StringKey;
7
+
use crate::widget_id::WidgetId;
8
+
9
+
use super::keys::take_activation;
10
+
use super::paint::{GlyphMark, WidgetPaint};
11
+
use super::visuals::{Indicator, push_indicator};
12
+
13
+
#[derive(Copy, Clone, Debug, PartialEq, Eq, Serialize)]
14
+
pub enum CheckboxState {
15
+
Unchecked,
16
+
Checked,
17
+
Indeterminate,
18
+
}
19
+
20
+
impl CheckboxState {
21
+
#[must_use]
22
+
pub const fn next(self) -> Self {
23
+
match self {
24
+
Self::Unchecked => Self::Checked,
25
+
Self::Checked | Self::Indeterminate => Self::Unchecked,
26
+
}
27
+
}
28
+
29
+
#[must_use]
30
+
pub const fn is_active(self) -> bool {
31
+
matches!(self, Self::Checked | Self::Indeterminate)
32
+
}
33
+
}
34
+
35
+
#[derive(Copy, Clone, Debug, PartialEq)]
36
+
pub struct Checkbox {
37
+
pub id: WidgetId,
38
+
pub rect: LayoutRect,
39
+
pub label: StringKey,
40
+
pub state: CheckboxState,
41
+
pub disabled: bool,
42
+
}
43
+
44
+
impl Checkbox {
45
+
#[must_use]
46
+
pub const fn new(
47
+
id: WidgetId,
48
+
rect: LayoutRect,
49
+
label: StringKey,
50
+
state: CheckboxState,
51
+
) -> Self {
52
+
Self {
53
+
id,
54
+
rect,
55
+
label,
56
+
state,
57
+
disabled: false,
58
+
}
59
+
}
60
+
61
+
#[must_use]
62
+
pub const fn disabled(self, disabled: bool) -> Self {
63
+
Self { disabled, ..self }
64
+
}
65
+
}
66
+
67
+
#[derive(Clone, Debug, PartialEq)]
68
+
pub struct CheckboxResponse {
69
+
pub interaction: Interaction,
70
+
pub state: CheckboxState,
71
+
pub toggled: bool,
72
+
pub paint: Vec<WidgetPaint>,
73
+
}
74
+
75
+
#[must_use]
76
+
pub fn show_checkbox(ctx: &mut FrameCtx<'_>, checkbox: Checkbox) -> CheckboxResponse {
77
+
let interactive = !checkbox.disabled;
78
+
let interaction = ctx.interact(
79
+
InteractDeclaration::new(checkbox.id, checkbox.rect, Sense::INTERACTIVE)
80
+
.focusable(interactive)
81
+
.disabled(!interactive)
82
+
.active(checkbox.state.is_active()),
83
+
);
84
+
let live_focused = ctx.is_focused(checkbox.id);
85
+
let toggled = interactive
86
+
&& (interaction.click() || (live_focused && take_activation(ctx.input)));
87
+
let next_state = if toggled {
88
+
checkbox.state.next()
89
+
} else {
90
+
checkbox.state
91
+
};
92
+
let paint = build_paint(ctx, &checkbox, interaction, live_focused, next_state);
93
+
CheckboxResponse {
94
+
interaction,
95
+
state: next_state,
96
+
toggled,
97
+
paint,
98
+
}
99
+
}
100
+
101
+
fn build_paint(
102
+
ctx: &FrameCtx<'_>,
103
+
checkbox: &Checkbox,
104
+
interaction: Interaction,
105
+
live_focused: bool,
106
+
state: CheckboxState,
107
+
) -> Vec<WidgetPaint> {
108
+
let mark = match state {
109
+
CheckboxState::Checked => Some(GlyphMark::Checkmark),
110
+
CheckboxState::Indeterminate => Some(GlyphMark::Indeterminate),
111
+
CheckboxState::Unchecked => None,
112
+
};
113
+
let mut paint = Vec::new();
114
+
push_indicator(
115
+
ctx,
116
+
&mut paint,
117
+
Indicator {
118
+
rect: checkbox.rect,
119
+
label: checkbox.label,
120
+
mark,
121
+
active: state.is_active(),
122
+
disabled: checkbox.disabled,
123
+
radius: ctx.theme.radius.sm,
124
+
},
125
+
interaction,
126
+
live_focused,
127
+
);
128
+
paint
129
+
}
130
+
131
+
#[cfg(test)]
132
+
mod tests {
133
+
use std::sync::Arc;
134
+
135
+
use super::{Checkbox, CheckboxState, show_checkbox};
136
+
use crate::focus::FocusManager;
137
+
use crate::frame::FrameCtx;
138
+
use crate::hit_test::{HitFrame, HitState, resolve};
139
+
use crate::hotkey::HotkeyTable;
140
+
use crate::input::{
141
+
FrameInstant, InputSnapshot, KeyCode, KeyEvent, ModifierMask, NamedKey, PointerButton,
142
+
PointerButtonMask, PointerSample,
143
+
};
144
+
use crate::layout::{LayoutPos, LayoutPx, LayoutRect, LayoutSize};
145
+
use crate::strings::StringKey;
146
+
use crate::strings::StringTable;
147
+
use crate::theme::Theme;
148
+
use crate::widget_id::{WidgetId, WidgetKey};
149
+
150
+
const LABEL: StringKey = StringKey::new("checkbox.label");
151
+
152
+
fn rect() -> LayoutRect {
153
+
LayoutRect::new(
154
+
LayoutPos::new(LayoutPx::ZERO, LayoutPx::ZERO),
155
+
LayoutSize::new(LayoutPx::new(48.0), LayoutPx::new(20.0)),
156
+
)
157
+
}
158
+
159
+
fn id_widget() -> WidgetId {
160
+
WidgetId::ROOT.child(WidgetKey::new("checkbox"))
161
+
}
162
+
163
+
#[test]
164
+
fn next_cycles_through_states() {
165
+
assert_eq!(CheckboxState::Unchecked.next(), CheckboxState::Checked);
166
+
assert_eq!(CheckboxState::Checked.next(), CheckboxState::Unchecked);
167
+
assert_eq!(CheckboxState::Indeterminate.next(), CheckboxState::Unchecked);
168
+
}
169
+
170
+
#[test]
171
+
fn space_key_when_focused_toggles() {
172
+
let theme = Arc::new(Theme::light());
173
+
let table = HotkeyTable::new();
174
+
let mut hits = HitFrame::new();
175
+
let state = HitState::new();
176
+
let mut focus = FocusManager::new();
177
+
focus.register_focusable(id_widget());
178
+
focus.request_focus(id_widget());
179
+
focus.end_frame();
180
+
let mut input = InputSnapshot::idle(FrameInstant::ZERO);
181
+
input.keys_pressed.push(KeyEvent::new(
182
+
KeyCode::Named(NamedKey::Space),
183
+
ModifierMask::NONE,
184
+
));
185
+
let checkbox = Checkbox::new(id_widget(), rect(), LABEL, CheckboxState::Unchecked);
186
+
let response = {
187
+
let mut ctx = FrameCtx::new(
188
+
theme,
189
+
&mut input,
190
+
&mut focus,
191
+
&table,
192
+
StringTable::empty(),
193
+
&mut hits,
194
+
&state,
195
+
);
196
+
show_checkbox(&mut ctx, checkbox)
197
+
};
198
+
assert!(response.toggled);
199
+
assert_eq!(response.state, CheckboxState::Checked);
200
+
}
201
+
202
+
#[test]
203
+
fn pointer_click_through_three_frames_flips_state() {
204
+
let theme = Arc::new(Theme::light());
205
+
let table = HotkeyTable::new();
206
+
let mut focus = FocusManager::new();
207
+
let mut hits = HitFrame::new();
208
+
let mut state = HitState::new();
209
+
let mut current = CheckboxState::Unchecked;
210
+
[press_snap(), release_snap(), idle_snap()]
211
+
.into_iter()
212
+
.for_each(|mut input| {
213
+
hits.clear();
214
+
let checkbox = Checkbox::new(id_widget(), rect(), LABEL, current);
215
+
let response = {
216
+
let mut ctx = FrameCtx::new(
217
+
theme.clone(),
218
+
&mut input,
219
+
&mut focus,
220
+
&table,
221
+
StringTable::empty(),
222
+
&mut hits,
223
+
&state,
224
+
);
225
+
show_checkbox(&mut ctx, checkbox)
226
+
};
227
+
current = response.state;
228
+
state = resolve(&state, &hits, &input, focus.focused());
229
+
});
230
+
assert_eq!(current, CheckboxState::Checked);
231
+
}
232
+
233
+
#[test]
234
+
fn indeterminate_checkbox_paints_indeterminate_mark() {
235
+
let theme = Arc::new(Theme::light());
236
+
let table = HotkeyTable::new();
237
+
let mut focus = FocusManager::new();
238
+
let mut hits = HitFrame::new();
239
+
let state = HitState::new();
240
+
let mut input = InputSnapshot::idle(FrameInstant::ZERO);
241
+
let checkbox = Checkbox::new(id_widget(), rect(), LABEL, CheckboxState::Indeterminate);
242
+
let response = {
243
+
let mut ctx = FrameCtx::new(
244
+
theme,
245
+
&mut input,
246
+
&mut focus,
247
+
&table,
248
+
StringTable::empty(),
249
+
&mut hits,
250
+
&state,
251
+
);
252
+
show_checkbox(&mut ctx, checkbox)
253
+
};
254
+
let has_indeterminate = response.paint.iter().any(|p| {
255
+
matches!(
256
+
p,
257
+
super::WidgetPaint::Mark {
258
+
kind: super::GlyphMark::Indeterminate,
259
+
..
260
+
}
261
+
)
262
+
});
263
+
assert!(has_indeterminate);
264
+
}
265
+
266
+
#[test]
267
+
fn disabled_checkbox_ignores_keys() {
268
+
let theme = Arc::new(Theme::light());
269
+
let table = HotkeyTable::new();
270
+
let mut hits = HitFrame::new();
271
+
let state = HitState::new();
272
+
let mut focus = FocusManager::new();
273
+
focus.register_focusable(id_widget());
274
+
focus.request_focus(id_widget());
275
+
focus.end_frame();
276
+
let mut input = InputSnapshot::idle(FrameInstant::ZERO);
277
+
let event = KeyEvent::new(KeyCode::Named(NamedKey::Space), ModifierMask::NONE);
278
+
input.keys_pressed.push(event);
279
+
let checkbox =
280
+
Checkbox::new(id_widget(), rect(), LABEL, CheckboxState::Unchecked).disabled(true);
281
+
let response = {
282
+
let mut ctx = FrameCtx::new(
283
+
theme,
284
+
&mut input,
285
+
&mut focus,
286
+
&table,
287
+
StringTable::empty(),
288
+
&mut hits,
289
+
&state,
290
+
);
291
+
show_checkbox(&mut ctx, checkbox)
292
+
};
293
+
assert!(!response.toggled);
294
+
assert_eq!(input.keys_pressed, vec![event]);
295
+
}
296
+
297
+
fn press_snap() -> InputSnapshot {
298
+
let mut s = InputSnapshot::idle(FrameInstant::ZERO);
299
+
s.pointer = Some(PointerSample::new(LayoutPos::new(
300
+
LayoutPx::new(10.0),
301
+
LayoutPx::new(10.0),
302
+
)));
303
+
s.buttons_pressed = PointerButtonMask::just(PointerButton::Primary);
304
+
s
305
+
}
306
+
307
+
fn release_snap() -> InputSnapshot {
308
+
let mut s = InputSnapshot::idle(FrameInstant::ZERO);
309
+
s.pointer = Some(PointerSample::new(LayoutPos::new(
310
+
LayoutPx::new(12.0),
311
+
LayoutPx::new(12.0),
312
+
)));
313
+
s.buttons_released = PointerButtonMask::just(PointerButton::Primary);
314
+
s
315
+
}
316
+
317
+
fn idle_snap() -> InputSnapshot {
318
+
let mut s = InputSnapshot::idle(FrameInstant::ZERO);
319
+
s.pointer = Some(PointerSample::new(LayoutPos::new(
320
+
LayoutPx::new(12.0),
321
+
LayoutPx::new(12.0),
322
+
)));
323
+
s
324
+
}
325
+
}