buoyant 0.7.0

SwiftUI-like UIs in Rust for embedded devices
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

use buoyant::{
    app::{App, Harness as _},
    event::EventResult,
    focus::Role,
    layout::Alignment,
    primitives::Size,
    render::ContentShape,
    view::prelude::*,
};

struct State {
    foreground_tapped: bool,
    background_tapped: bool,
}

/// Both background and foreground have focusable buttons
fn view_with_both_focusable(_: &State) -> impl View<(), State> + use<> {
    Button::new(|s: &mut State| s.foreground_tapped = true, |_| Circle).background(
        Alignment::Center,
        Button::new(|s: &mut State| s.background_tapped = true, |_| Rectangle),
    )
}

fn view_with_empty_background(_: &State) -> impl View<(), State> + use<> {
    VStack::new((
        Button::new(|s: &mut State| s.foreground_tapped = true, |_| Circle),
        Rectangle,
    ))
    .background(Alignment::Center, EmptyView)
}

#[test]
fn navigate_forward_through_background() {
    let state = State {
        foreground_tapped: false,
        background_tapped: false,
    };
    let mut harness =
        App::new(state, Size::new(100, 100), view_with_both_focusable).with_roles(Role::Button);

    // Background receives focus first
    assert!(matches!(
        harness.focus_forward().shape(),
        Some(ContentShape::Rectangle(_))
    ));

    harness.select();
    assert!(harness.state().background_tapped);
    assert!(!harness.state().foreground_tapped);

    // Next moves to foreground
    assert!(matches!(
        harness.next().shape(),
        Some(ContentShape::Circle(_))
    ));

    harness.select();
    assert!(harness.state().foreground_tapped);

    // Past foreground returns deferred
    assert!(matches!(harness.next(), EventResult::Deferred));
}

#[test]
fn navigate_backward_through_background() {
    let state = State {
        foreground_tapped: false,
        background_tapped: false,
    };
    let mut harness =
        App::new(state, Size::new(100, 100), view_with_both_focusable).with_roles(Role::Button);

    // Navigate to the end
    harness.focus_forward();
    harness.next();

    // Previous moves from foreground to background
    assert!(matches!(
        harness.previous().shape(),
        Some(ContentShape::Rectangle(_))
    ));

    harness.select();
    assert!(harness.state().background_tapped);
    assert!(!harness.state().foreground_tapped);

    // Past background returns deferred
    assert!(matches!(harness.previous(), EventResult::Deferred));
}

#[test]
fn empty_background_skips_to_foreground() {
    let state = State {
        foreground_tapped: false,
        background_tapped: false,
    };
    let mut harness =
        App::new(state, Size::new(100, 100), view_with_empty_background).with_roles(Role::Button);

    assert!(matches!(
        harness.focus_forward().shape(),
        Some(ContentShape::Circle(_))
    ));
}