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
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 buoyant::focus::DefaultFocus;
use buoyant::font::CharacterBufferFont;
use buoyant::if_view;
use buoyant::primitives::{Point, Size};
use buoyant::render::Render as _;
use buoyant::render_target::FixedTextBuffer;
use buoyant::view::prelude::*;
use common::TestEnv;

use crate::common::tap;

mod common;

#[test]
fn test_conditional_view_layout() {
    let font = CharacterBufferFont;
    let make_view = |condition| {
        if_view!((condition) {
            Text::new("true\n!!!", &font)
        } else {
            Text::new("f", &font).foreground_color(' ')
        })
    };
    let mut buffer = FixedTextBuffer::<5, 5>::default();
    let env = TestEnv::default();

    let view = make_view(true);
    let mut state = view.build_state(&mut ());
    let layout = view.layout(&buffer.size().into(), &env, &mut (), &mut state);
    assert_eq!(layout.resolved_size, Size::new(4, 2).into());
    let tree = view.render_tree(&layout.sublayouts, Point::zero(), &env, &mut (), &mut state);
    tree.render(&mut buffer, &env.foreground_color);
    assert_eq!(buffer.text[0].iter().collect::<String>(), "true ");
    assert_eq!(buffer.text[1].iter().collect::<String>(), "!!!  ");
    assert_eq!(buffer.text[2].iter().collect::<String>(), "     ");

    buffer.clear();

    let view = make_view(false);
    let layout = view.layout(&buffer.size().into(), &env, &mut (), &mut state);
    assert_eq!(layout.resolved_size, Size::new(1, 1).into());
    let tree = view.render_tree(&layout.sublayouts, Point::zero(), &env, &mut (), &mut state);
    tree.render(&mut buffer, &env.foreground_color);
    assert_eq!(buffer.text[0].iter().collect::<String>(), "f    ");
    assert_eq!(buffer.text[1].iter().collect::<String>(), "     ");
    assert_eq!(buffer.text[2].iter().collect::<String>(), "     ");
}

fn one_arm_view(condition: bool) -> impl View<char, ()> {
    if_view!((condition) {
        Text::new("true\n!!!", &CharacterBufferFont).foreground_color(' ')
    })
}

#[test]
fn one_arm_if() {
    let mut buffer = FixedTextBuffer::<5, 5>::default();
    let env = TestEnv::default();

    let view = one_arm_view(true);
    assert!(!view.is_empty());
    let mut state = view.build_state(&mut ());
    let layout = view.layout(&buffer.size().into(), &env, &mut (), &mut state);
    assert_eq!(layout.resolved_size, Size::new(4, 2).into());
    let tree = view.render_tree(&layout.sublayouts, Point::zero(), &env, &mut (), &mut state);
    tree.render(&mut buffer, &env.foreground_color);
    assert_eq!(buffer.text[0].iter().collect::<String>(), "true ");
    assert_eq!(buffer.text[1].iter().collect::<String>(), "!!!  ");
    assert_eq!(buffer.text[2].iter().collect::<String>(), "     ");

    buffer.clear();

    let view = one_arm_view(false);
    assert!(view.is_empty());
    let layout = view.layout(&buffer.size().into(), &env, &mut (), &mut state);
    assert_eq!(layout.resolved_size, Size::new(0, 0).into());
    let tree = view.render_tree(&layout.sublayouts, Point::zero(), &env, &mut (), &mut state);
    tree.render(&mut buffer, &env.foreground_color);
    assert_eq!(buffer.text[0].iter().collect::<String>(), "     ");
    assert_eq!(buffer.text[1].iter().collect::<String>(), "     ");
    assert_eq!(buffer.text[2].iter().collect::<String>(), "     ");
}

fn if_else_view(condition: bool) -> impl View<char, i32> {
    if_view!((condition) {
        Button::new(|x: &mut i32| *x += 1, |_| Rectangle)
    } else {
        Button::new(|x: &mut i32| *x -= 1, |_| Rectangle)
    })
}

#[test]
fn if_else_event_routing() {
    let view = if_else_view(true);
    let mut x = 0;
    let mut state = view.build_state(&mut x);
    let size = Size::new(3, 3);

    tap(&view, &mut x, &mut state, size, 1, 1);
    assert_eq!(x, 1);

    let view = if_else_view(false);
    tap(&view, &mut x, &mut state, size, 1, 1);
    assert_eq!(x, 0);
}

// MARK: Focus tests

use buoyant::{
    event::EventResult,
    focus::{FocusAction, FocusDirection, Role},
};

#[test]
fn empty_view_returns_deferred() {
    fn view() -> impl View<char, ()> {
        EmptyView
    }

    let buffer = FixedTextBuffer::<5, 5>::default();
    let env = TestEnv::default();

    let view = view();
    let mut state = view.build_state(&mut ());
    let layout = view.layout(&buffer.size().into(), &env, &mut (), &mut state);
    let mut tree = view.render_tree(&layout.sublayouts, Point::zero(), &env, &mut (), &mut state);

    // EmptyView should return Deferred for focus events
    let result = view.handle_event(
        &FocusAction::Focus(FocusDirection::Forward).into(),
        &buoyant::event::EventContext::new(core::time::Duration::ZERO).with_roles(Role::Button),
        &mut tree,
        &mut (),
        &mut state,
        &mut DefaultFocus::default_first(),
    );

    assert!(
        matches!(result, EventResult::Deferred),
        "EmptyView should return Deferred for focus"
    );
}