GitCorner

Code

ossartcraftfigcraft🌐
b45255bb6fe2
//! Accessibility, driven through egui headless: the AccessKit tree names the custom-painted widgets
//! (tools, layer rows, number fields, tabs, the canvas), and keyboard navigation: F6 cycles the
//! regions, Tab moves within one, arrows and Enter pick a tool, the arrows walk the layer rows,
//! a menu opened from the keyboard takes it and Escape gives it back, Escape returns to the
//! canvas where shortcuts work again, and a pointer press ends keyboard mode.

use egui::accesskit::{Node, Role, Toggled};
use egui::{Event, Key, Modifiers};
use figcraft_doc::NodeId;
use figcraft_engine::{Session, ToolId};
use serde_json::json;

use crate::a11y::{Region, focused_name};
use crate::layers_drag_tests::Ui;

fn id(v: serde_json::Value) -> NodeId {
    NodeId(v["id"].as_u64().unwrap())
}

fn press(u: &mut Ui, key: Key, modifiers: Modifiers) {
    u.frame(vec![
        Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers },
        Event::Key { key, physical_key: None, pressed: false, repeat: false, modifiers },
    ]);
}

fn f6(u: &mut Ui, back: bool) {
    press(u, Key::F6, if back { Modifiers::SHIFT } else { Modifiers::NONE });
}

fn name(u: &Ui) -> String {
    focused_name(&u.ctx)
}

fn region(u: &Ui) -> Region {
    u.app.ui.nav.region
}

/// Two rectangles, "Rect A" and "Rect B" (listed above A: it's on top), A selected.
fn setup() -> (Ui, NodeId, NodeId) {
    let mut s = Session::new();
    let a = id(s.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 40, "height": 30})).unwrap());
    let b = id(s.execute("shape.rectangle", &json!({"x": 100, "y": 30, "width": 20, "height": 20})).unwrap());
    s.execute("object.rename", &json!({"ids": [a], "name": "Rect A"})).unwrap();
    s.execute("object.rename", &json!({"ids": [b], "name": "Rect B"})).unwrap();
    s.execute("select.set", &json!({"ids": [a]})).unwrap();
    let mut u = Ui::new(s);
    u.frame(vec![]);
    (u, a, b)
}

/// The nodes of the AccessKit tree a screen reader would get now.
fn tree(u: &mut Ui) -> Vec<Node> {
    u.ctx.enable_accesskit();
    u.frame(vec![]);
    let out = u.frame_output(vec![]);
    out.platform_output.accesskit_update.expect("an AccessKit update").nodes.into_iter().map(|(_, n)| n).collect()
}

fn find<'a>(nodes: &'a [Node], role: Role, label: &str) -> &'a Node {
    nodes.iter().find(|n| n.role() == role && n.label() == Some(label)).unwrap_or_else(|| panic!("no {role:?} named {label:?}"))
}

#[test]
fn the_screen_reader_tree_names_tools_layers_fields_tabs_and_the_canvas() {
    let (mut u, ..) = setup();
    let nodes = tree(&mut u);
    // Regions are named containers.
    find(&nodes, Role::Toolbar, "Tools");
    find(&nodes, Role::Pane, "Layers");
    find(&nodes, Role::Pane, "Design");
    // Tools: toggle buttons with their key, the current one pressed.
    let mv = find(&nodes, Role::Button, "Move");
    assert_eq!(mv.toggled(), Some(Toggled::True));
    assert_eq!(mv.keyboard_shortcut(), Some("V"));
    assert_eq!(find(&nodes, Role::Button, "Rectangle").toggled(), Some(Toggled::False));
    assert_eq!(find(&nodes, Role::Button, "Shape tools").is_expanded(), Some(false));
    // Layer rows: tree items with their type, level and selection.
    let a = find(&nodes, Role::TreeItem, "Rect A");
    assert_eq!((a.level(), a.is_selected(), a.description()), (Some(1), Some(true), Some("Rectangle")));
    assert_eq!(find(&nodes, Role::TreeItem, "Rect B").is_selected(), Some(false));
    // Number fields: name and value.
    let w = find(&nodes, Role::SpinButton, "Width");
    assert_eq!((w.value(), w.numeric_value()), (Some("40"), Some(40.0)));
    assert_eq!(find(&nodes, Role::SpinButton, "Rotation").value(), Some("0°"));
    // Tabs and dropdowns.
    assert_eq!(find(&nodes, Role::Tab, "Design").is_selected(), Some(true));
    assert_eq!(find(&nodes, Role::Tab, "Prototype").is_selected(), Some(false));
    assert_eq!(find(&nodes, Role::ComboBox, "Zoom").is_expanded(), Some(false));
    // Icon buttons are named by their tooltip.
    find(&nodes, Role::Button, "Add new page");
    // The canvas describes the selection.
    let canvas = find(&nodes, Role::Group, "Canvas");
    assert_eq!(canvas.description(), Some("Rect A, Rectangle, 40 by 30, selected"));
}

#[test]
fn f6_cycles_the_regions_and_lands_on_the_active_tool_and_the_selected_row() {
    let (mut u, ..) = setup();
    assert_eq!(region(&u), Region::Canvas);
    assert!(!u.app.ui.nav.keyboard);
    f6(&mut u, false);
    assert_eq!(region(&u), Region::Properties);
    assert!(u.app.ui.nav.keyboard, "keyboard mode: the focus ring shows");
    assert!(!name(&u).is_empty(), "a control in the properties panel has the keyboard");
    f6(&mut u, false);
    assert_eq!((region(&u), name(&u)), (Region::Toolbar, "Move".to_string()));
    f6(&mut u, false);
    assert_eq!((region(&u), name(&u)), (Region::Layers, "Rect A".to_string()));
    f6(&mut u, false);
    assert_eq!(region(&u), Region::Canvas);
    assert_eq!(name(&u), "Canvas");
    // Shift+F6 goes back.
    f6(&mut u, true);
    assert_eq!(region(&u), Region::Layers);
    // The commands do the same (menus, the control channel, MCP).
    u.app.run("view.previousRegion", json!({}));
    u.frame(vec![]);
    assert_eq!(region(&u), Region::Toolbar);
    // Hidden panels are skipped.
    u.app.run("view.toggleUi", json!({"on": true}));
    u.frame(vec![]);
    f6(&mut u, false);
    assert_eq!(region(&u), Region::Canvas);
    f6(&mut u, false);
    assert_eq!(region(&u), Region::Canvas, "only the canvas is shown");
}

#[test]
fn tab_moves_between_the_properties_controls_and_wraps_without_leaving_the_panel() {
    let (mut u, a, _) = setup();
    f6(&mut u, false);
    let first = name(&u);
    let mut seen = vec![first.clone()];
    for _ in 0..200 {
        press(&mut u, Key::Tab, Modifiers::NONE);
        assert_eq!(region(&u), Region::Properties);
        if name(&u) == first {
            break;
        }
        seen.push(name(&u));
    }
    assert_eq!(name(&u), first, "Tab wraps round to the panel's first control");
    for want in ["Width", "Height", "Rotation", "Opacity"] {
        assert!(seen.iter().any(|n| n == want), "{want} not reached by Tab: {seen:?}");
    }
    // Shift+Tab steps back.
    press(&mut u, Key::Tab, Modifiers::SHIFT);
    assert_eq!(Some(&name(&u)), seen.last());
    // Tab moved the keyboard, not the selection.
    assert_eq!(u.app.session.selection(), vec![a]);
}

#[test]
fn enter_edits_a_focused_field_up_steps_it_and_tab_commits_and_moves_on() {
    let (mut u, a, _) = setup();
    f6(&mut u, false);
    for _ in 0..100 {
        if name(&u) == "Width" {
            break;
        }
        press(&mut u, Key::Tab, Modifiers::NONE);
    }
    assert_eq!(name(&u), "Width");
    press(&mut u, Key::Enter, Modifiers::NONE);
    u.frame(vec![]);
    // Typing replaces the value; Up steps it and the field keeps the keyboard (egui's own arrow
    // focus moves are off on the panels).
    u.frame(vec![Event::Text("64".into())]);
    press(&mut u, Key::ArrowUp, Modifiers::NONE);
    u.frame(vec![]);
    assert_eq!(u.app.session.doc().unwrap().node(a).unwrap().width, 65.0);
    assert!(crate::a11y::field_focused(&u.ctx), "still editing");
    press(&mut u, Key::Tab, Modifiers::NONE);
    u.frame(vec![]);
    assert_eq!(u.app.session.doc().unwrap().node(a).unwrap().width, 65.0, "the edited width is kept");
    assert_eq!(name(&u), "Height");
    assert_eq!(region(&u), Region::Properties);
}

#[test]
fn arrows_and_enter_pick_a_toolbar_tool() {
    let (mut u, ..) = setup();
    f6(&mut u, true);
    f6(&mut u, true);
    assert_eq!((region(&u), name(&u)), (Region::Toolbar, "Move".to_string()));
    // Move, its flyout button, Frame, its flyout button, Rectangle.
    for _ in 0..4 {
        press(&mut u, Key::ArrowRight, Modifiers::NONE);
    }
    assert_eq!(name(&u), "Rectangle");
    press(&mut u, Key::Enter, Modifiers::NONE);
    assert_eq!(u.app.session.tool.tool, ToolId::Rectangle);
    // Left wraps past the first control to the last; Home goes back to the first.
    press(&mut u, Key::Home, Modifiers::NONE);
    assert_eq!(name(&u), "Move");
    press(&mut u, Key::ArrowLeft, Modifiers::NONE);
    assert_ne!(name(&u), "Move");
    assert_eq!(region(&u), Region::Toolbar);
}

#[test]
fn escape_returns_to_the_canvas_where_shortcuts_and_tab_work_again() {
    let (mut u, a, b) = setup();
    f6(&mut u, true);
    f6(&mut u, true);
    assert_eq!(region(&u), Region::Toolbar);
    // A shortcut key while a toolbar button has the keyboard does nothing.
    press(&mut u, Key::R, Modifiers::NONE);
    assert_eq!(u.app.session.tool.tool, ToolId::Move);
    press(&mut u, Key::Escape, Modifiers::NONE);
    assert_eq!((region(&u), name(&u)), (Region::Canvas, "Canvas".to_string()));
    assert_eq!(u.app.session.selection(), vec![a], "leaving the toolbar doesn't deselect");
    // Tab on the canvas selects the next layer and keeps the keyboard there.
    press(&mut u, Key::Tab, Modifiers::NONE);
    assert_eq!(u.app.session.selection(), vec![b]);
    assert_eq!(name(&u), "Canvas");
    press(&mut u, Key::R, Modifiers::NONE);
    assert_eq!(u.app.session.tool.tool, ToolId::Rectangle);
}

#[test]
fn tab_on_the_canvas_selects_the_next_layer_without_keyboard_mode() {
    let (mut u, _, b) = setup();
    press(&mut u, Key::Tab, Modifiers::NONE);
    u.frame(vec![]);
    assert_eq!(u.app.session.selection(), vec![b]);
    assert!(u.ctx.memory(|m| m.focused()).is_none(), "Tab doesn't wander into the tab bar");
}

#[test]
fn arrows_walk_the_layer_rows_and_the_keyboard_follows_the_selection() {
    let (mut u, a, b) = setup();
    f6(&mut u, true);
    assert_eq!((region(&u), name(&u)), (Region::Layers, "Rect A".to_string()));
    // B is listed above A.
    press(&mut u, Key::ArrowUp, Modifiers::NONE);
    u.frame(vec![]);
    u.frame(vec![]);
    assert_eq!(u.app.session.selection(), vec![b]);
    assert_eq!(name(&u), "Rect B");
    press(&mut u, Key::ArrowDown, Modifiers::SHIFT);
    u.frame(vec![]);
    let mut sel = u.app.session.selection();
    sel.sort();
    assert_eq!(sel, vec![a, b], "Shift extends");
    // Nothing moved on the canvas.
    assert_eq!(u.app.session.doc().unwrap().node(a).unwrap().transform.translation().x, 0.0);
}

#[test]
fn a_menu_opened_from_the_keyboard_takes_it_and_escape_gives_it_back() {
    let (mut u, ..) = setup();
    f6(&mut u, false);
    for _ in 0..100 {
        if name(&u) == "Zoom" {
            break;
        }
        press(&mut u, Key::Tab, Modifiers::NONE);
    }
    assert_eq!(name(&u), "Zoom");
    press(&mut u, Key::Enter, Modifiers::NONE);
    u.frame(vec![]);
    u.frame(vec![]);
    assert_eq!(name(&u), "Zoom in", "the menu's first item has the keyboard");
    press(&mut u, Key::Escape, Modifiers::NONE);
    u.frame(vec![]);
    assert_eq!(name(&u), "Zoom");
    assert_eq!(region(&u), Region::Properties, "closing the menu stays in the panel");
}

#[test]
fn a_pointer_press_ends_keyboard_mode() {
    let (mut u, ..) = setup();
    f6(&mut u, false);
    assert!(u.app.ui.nav.keyboard);
    let p = u.app.canvas.rect.center();
    u.button(p, true);
    u.button(p, false);
    assert!(!u.app.ui.nav.keyboard);
    assert_eq!(region(&u), Region::Canvas);
}

#[test]
fn focus_region_from_the_control_channel() {
    let (mut u, ..) = setup();
    let ctx = u.ctx.clone();
    crate::control::handle(&mut u.app, &ctx, "ui.set", &json!({"focusRegion": "layers"})).unwrap();
    u.frame(vec![]);
    let v = crate::control::handle(&mut u.app, &ctx, "ui.inspect", &json!({})).unwrap();
    assert_eq!(v["focus"]["region"], "layers");
    assert_eq!(v["focus"]["keyboard"], true);
    assert_eq!(v["focus"]["control"], "Rect A");
    assert!(crate::control::handle(&mut u.app, &ctx, "ui.set", &json!({"focusRegion": "nowhere"})).is_err());
}

#[test]
fn reduce_motion_turns_egui_animations_off() {
    let (mut u, ..) = setup();
    assert!(u.ctx.global_style().animation_time > 0.0);
    u.app.run("pref.reduceMotion", json!({"on": true}));
    u.frame(vec![]);
    assert_eq!(u.ctx.global_style().animation_time, 0.0);
    assert_eq!(u.app.inspect()["reduceMotion"], true);
}

#[test]
fn a_tool_flyout_opened_from_the_keyboard_picks_a_tool() {
    let (mut u, ..) = setup();
    f6(&mut u, true);
    f6(&mut u, true);
    // Move, its flyout button, Frame, its flyout button, Rectangle, the shape tools' button.
    for _ in 0..5 {
        press(&mut u, Key::ArrowRight, Modifiers::NONE);
    }
    assert_eq!(name(&u), "Shape tools");
    press(&mut u, Key::Enter, Modifiers::NONE);
    u.frame(vec![]);
    u.frame(vec![]);
    assert_eq!(u.app.ui.tool_flyout, Some("shape"));
    assert_eq!(name(&u), "Rectangle", "the flyout's first tool has the keyboard");
    // egui moves the focus between a menu's items at the end of the frame.
    press(&mut u, Key::ArrowDown, Modifiers::NONE);
    u.frame(vec![]);
    assert_eq!(name(&u), "Line");
    press(&mut u, Key::Enter, Modifiers::NONE);
    u.frame(vec![]);
    u.frame(vec![]);
    assert_eq!(u.app.session.tool.tool, ToolId::Line);
    assert_eq!(u.app.ui.tool_flyout, None);
    assert_eq!((region(&u), name(&u)), (Region::Toolbar, "Shape tools".to_string()), "back on the flyout's button");
    // Escape closes an open flyout and stays in the toolbar.
    press(&mut u, Key::Enter, Modifiers::NONE);
    u.frame(vec![]);
    u.frame(vec![]);
    press(&mut u, Key::Escape, Modifiers::NONE);
    u.frame(vec![]);
    assert_eq!(u.app.ui.tool_flyout, None);
    assert_eq!((region(&u), name(&u)), (Region::Toolbar, "Shape tools".to_string()));
}

/// Every keyboard and naming path with the screen reader tree on: the node writers and the shared
/// state run under egui's context lock, and a nested context call there would deadlock (debug
/// builds turn it into a panic after 10 s, so this test fails instead of hanging).
#[test]
fn every_accessibility_path_runs_with_the_tree_on_without_nested_context_locks() {
    let (mut u, ..) = setup();
    u.ctx.enable_accesskit();
    u.app.run("pref.reduceMotion", json!({"on": true}));
    for _ in 0..5 {
        f6(&mut u, false);
        let out = u.frame_output(vec![]);
        assert!(out.platform_output.accesskit_update.is_some());
    }
    // Properties: Tab, a field edit, the zoom menu from the keyboard and back.
    while region(&u) != Region::Properties {
        f6(&mut u, false);
    }
    for _ in 0..100 {
        if name(&u) == "Zoom" {
            break;
        }
        press(&mut u, Key::Tab, Modifiers::NONE);
    }
    press(&mut u, Key::Enter, Modifiers::NONE);
    u.frame(vec![]);
    u.frame(vec![]);
    assert_eq!(name(&u), "Zoom in");
    press(&mut u, Key::ArrowDown, Modifiers::NONE);
    press(&mut u, Key::Escape, Modifiers::NONE);
    u.frame(vec![]);
    // Toolbar: a flyout; layers: the arrows; the canvas; a pointer press.
    while region(&u) != Region::Toolbar {
        f6(&mut u, false);
    }
    press(&mut u, Key::End, Modifiers::NONE);
    press(&mut u, Key::Home, Modifiers::NONE);
    while region(&u) != Region::Layers {
        f6(&mut u, false);
    }
    press(&mut u, Key::ArrowUp, Modifiers::NONE);
    u.frame(vec![]);
    press(&mut u, Key::Escape, Modifiers::NONE);
    assert_eq!(region(&u), Region::Canvas);
    let p = u.app.canvas.rect.center();
    u.button(p, true);
    u.button(p, false);
    let out = u.frame_output(vec![]);
    assert!(out.platform_output.accesskit_update.is_some());
}

#[test]
fn the_align_buttons_are_off_for_a_layer_alone_on_the_page() {
    let (mut u, a, b) = setup();
    let align_left = |nodes: &[Node]| {
        nodes.iter().find(|n| n.label().is_some_and(|l| l.starts_with("Align left"))).map(Node::is_disabled).expect("the Align left button")
    };
    assert!(align_left(&tree(&mut u)), "Rect A alone on the page: nothing to align to");
    u.app.run("select.set", json!({"ids": [a, b]}));
    assert!(!align_left(&tree(&mut u)), "two layers align to each other");
    let f = id(u.app.session.execute("frame.create", &json!({"x": 300, "y": 0, "width": 100, "height": 100})).unwrap());
    let inner = id(u.app.session.execute("shape.rectangle", &json!({"x": 10, "y": 10, "width": 10, "height": 10, "parent": f})).unwrap());
    u.app.run("select.set", json!({"ids": [inner]}));
    assert!(!align_left(&tree(&mut u)), "one in a frame aligns to it");
}

/// Asserts side-panel and Pages edges are not focusable, and Tab never stops on the
/// side-panel edges.
#[test]
fn the_custom_panel_edges_never_enter_the_keyboard_or_focus_order() {
    // FigCraft's panels are fixed, so egui makes no `panel.__resize` widgets; the draggable edges
    // are `Id::unique(("panel_edge", ...))`. They sense the pointer but must not be focusable, or
    // Tab/F6 would stop on an unnamed control.
    let (mut u, _, _) = setup();
    let (left, right) = (egui::Id::unique(("panel_edge", "left")), egui::Id::unique(("panel_edge", "right")));
    // The Pages list's edge has the same contract as the side panels' edges.
    let pages = egui::Id::unique("pages_edge");
    for f in [left, right, pages] {
        let focusable = u.ctx.viewport(|v| v.prev_pass.widgets.get(f).map(|w| w.sense.is_focusable()));
        assert_eq!(focusable, Some(false), "the panel/pages edge still senses clicks/drags but is not focusable");
    }
    let mut seen = Vec::new();
    for back in [false, true] {
        f6(&mut u, back);
        for _ in 0..30 {
            press(&mut u, Key::Tab, Modifiers::NONE);
            if let Some(id) = u.ctx.memory(|m| m.focused()) {
                seen.push(id);
            }
        }
    }
    assert!(!seen.contains(&left) && !seen.contains(&right), "Tab never stops on a panel edge: {seen:?}");
}

#[test]
fn a_mixed_checkbox_is_announced_as_mixed_and_a_checked_one_as_true() {
    let ctx = egui::Context::default();
    ctx.enable_accesskit();
    let mut out = ctx.run_ui(egui::RawInput::default(), |ui| {
        crate::widgets::checkbox_tri(ui, None, "Mixed one");
        crate::widgets::checkbox_tri(ui, Some(true), "Checked one");
        crate::widgets::checkbox_tri(ui, Some(false), "Plain one");
    });
    out.textures_delta.clear();
    let nodes: Vec<Node> = out.platform_output.accesskit_update.expect("an AccessKit update").nodes.into_iter().map(|(_, n)| n).collect();
    assert_eq!(find(&nodes, Role::CheckBox, "Mixed one").toggled(), Some(Toggled::Mixed));
    assert_eq!(find(&nodes, Role::CheckBox, "Checked one").toggled(), Some(Toggled::True));
    assert_eq!(find(&nodes, Role::CheckBox, "Plain one").toggled(), Some(Toggled::False));
}

/// Runs one headless frame of a lone tri-state checkbox; returns whether it was clicked.
fn tri_frame(ctx: &egui::Context, state: Option<bool>, events: Vec<Event>) -> bool {
    let mut clicked = false;
    let input = egui::RawInput { events, ..Default::default() };
    let mut out = ctx.run_ui(input, |ui| {
        clicked = crate::widgets::checkbox_tri(ui, state, "Keyed one");
    });
    out.textures_delta.clear();
    clicked
}

fn key(key: Key, pressed: bool) -> Event {
    Event::Key { key, physical_key: None, pressed, repeat: false, modifiers: Modifiers::NONE }
}

#[test]
fn a_checkbox_is_keyboard_operable_tab_to_it_then_space_or_enter_toggles_it() {
    for activate in [Key::Space, Key::Enter] {
        let ctx = egui::Context::default();
        tri_frame(&ctx, Some(false), vec![]);
        tri_frame(&ctx, Some(false), vec![key(Key::Tab, true), key(Key::Tab, false)]);
        assert!(ctx.memory(|m| m.focused()).is_some(), "Tab focuses the checkbox");
        tri_frame(&ctx, Some(false), vec![]);
        let clicked = tri_frame(&ctx, Some(false), vec![key(activate, true), key(activate, false)]);
        assert!(clicked, "{activate:?} on the focused checkbox toggles it");
    }
}

/// The marks (paths, meshes, segments) painted inside the 14-point box of a lone checkbox.
fn box_marks(state: Option<bool>) -> Vec<egui::Rect> {
    fn walk(s: &egui::Shape, out: &mut Vec<egui::Rect>) {
        match s {
            egui::Shape::Vec(v) => v.iter().for_each(|s| walk(s, out)),
            egui::Shape::Path(_) | egui::Shape::Mesh(_) | egui::Shape::LineSegment { .. } => out.push(s.visual_bounding_rect()),
            _ => {}
        }
    }
    let ctx = egui::Context::default();
    let mut out = Vec::new();
    for _ in 0..2 {
        let mut o = ctx.run_ui(egui::RawInput::default(), |ui| {
            crate::widgets::checkbox_tri(ui, state, "Painted one");
        });
        o.textures_delta.clear();
        out.clear();
        o.shapes.iter().for_each(|c| walk(&c.shape, &mut out));
    }
    out
}

#[test]
fn a_mixed_checkbox_paints_a_dash_and_a_checked_one_a_tick() {
    // Icon::Minus is one flat bar; Icon::Check is a taller path.
    let mixed = box_marks(None);
    assert!(mixed.iter().any(|r| r.width() >= 5.0 && r.height() <= 2.5), "a flat dash is painted for the mixed state: {mixed:?}");
    let checked = box_marks(Some(true));
    assert!(checked.iter().any(|r| r.width() >= 5.0 && r.height() > 3.5), "a tick is painted for the checked state: {checked:?}");
    assert!(!checked.iter().any(|r| r.width() >= 5.0 && r.height() <= 2.5), "no dash on a checked box: {checked:?}");
    assert!(box_marks(Some(false)).is_empty(), "an empty box paints no mark");
}