egui 0.28.1

An easy-to-use immediate mode GUI that runs on both web and native
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

//! Tests the accesskit accessibility output of egui.
#![cfg(feature = "accesskit")]

use accesskit::{Role, TreeUpdate};
use egui::{CentralPanel, Context, RawInput};

/// Baseline test that asserts there are no spurious nodes in the
/// accesskit output when the ui is empty.
///
/// This gives reasonable certainty that any nodes appearing in the other accesskit outputs
/// are put there because of the widgets rendered.
#[test]
fn empty_ui_should_return_tree_with_only_root_window() {
    let output = accesskit_output_single_egui_frame(|ctx| {
        CentralPanel::default().show(ctx, |_| {});
    });

    assert_eq!(
        output.nodes.len(),
        1,
        "Empty ui should produce only the root window."
    );
    let (id, root) = &output.nodes[0];

    assert_eq!(*id, output.tree.unwrap().root);
    assert_eq!(root.role(), Role::Window);
}

#[test]
fn button_node() {
    let button_text = "This is a test button!";

    let output = accesskit_output_single_egui_frame(|ctx| {
        CentralPanel::default().show(ctx, |ui| ui.button(button_text));
    });

    assert_eq!(
        output.nodes.len(),
        2,
        "Expected only the root node and the button."
    );

    let (_, button) = output
        .nodes
        .iter()
        .find(|(_, node)| node.role() == Role::Button)
        .expect("Button should exist in the accesskit output");

    assert_eq!(button.name(), Some(button_text));
    assert!(!button.is_disabled());
}

#[test]
fn disabled_button_node() {
    let button_text = "This is a test button!";

    let output = accesskit_output_single_egui_frame(|ctx| {
        CentralPanel::default().show(ctx, |ui| {
            ui.add_enabled(false, egui::Button::new(button_text))
        });
    });

    assert_eq!(
        output.nodes.len(),
        2,
        "Expected only the root node and the button."
    );

    let (_, button) = output
        .nodes
        .iter()
        .find(|(_, node)| node.role() == Role::Button)
        .expect("Button should exist in the accesskit output");

    assert_eq!(button.name(), Some(button_text));
    assert!(button.is_disabled());
}

#[test]
fn toggle_button_node() {
    let button_text = "A toggle button";

    let mut selected = false;
    let output = accesskit_output_single_egui_frame(|ctx| {
        CentralPanel::default().show(ctx, |ui| ui.toggle_value(&mut selected, button_text));
    });

    assert_eq!(
        output.nodes.len(),
        2,
        "Expected only the root node and the button."
    );

    let (_, toggle) = output
        .nodes
        .iter()
        .find(|(_, node)| node.role() == Role::ToggleButton)
        .expect("Toggle button should exist in the accesskit output");

    assert_eq!(toggle.name(), Some(button_text));
    assert!(!toggle.is_disabled());
}

#[test]
fn multiple_disabled_widgets() {
    let output = accesskit_output_single_egui_frame(|ctx| {
        CentralPanel::default().show(ctx, |ui| {
            ui.add_enabled_ui(false, |ui| {
                let _ = ui.button("Button 1");
                let _ = ui.button("Button 2");
                let _ = ui.button("Button 3");
            })
        });
    });

    assert_eq!(
        output.nodes.len(),
        4,
        "Expected the root node and all the child widgets."
    );

    assert_eq!(
        output
            .nodes
            .iter()
            .filter(|(_, node)| node.is_disabled())
            .count(),
        3,
        "All widgets should be disabled."
    );
}

fn accesskit_output_single_egui_frame(run_ui: impl FnOnce(&Context)) -> TreeUpdate {
    let ctx = Context::default();
    ctx.enable_accesskit();

    let output = ctx.run(RawInput::default(), run_ui);

    output
        .platform_output
        .accesskit_update
        .expect("Missing accesskit update")
}