Skip to content

EffectCraft: An open-source motion graphics and compositing tool written by scratch in pure Rust

Merge upstream/main into feat-gap25-a11y-audit

vangel764f3851206ac8
diff --cc crates/ui-egui/src/menus.rs
index 1a8f59079,92893dcb6..a7a037f6e
--- a/crates/ui-egui/src/menus.rs
+++ b/crates/ui-egui/src/menus.rs
@@@ -253,9 -253,9 +253,9 @@@ fn reveal_targets(app: &EffectcraftApp
/// The arrow keys nudge the selected layers 1 pixel at the viewer's magnification (`up`,
/// `down`, `left`, `right`), 10 with Shift (`up10`…), as After Effects does, so zoomed in
-/// they move by fractions of a comp pixel. From any panel except Project (which owns the
-/// arrow keys for its own keyboard navigation, #961); not while typing, with a dialog or
-/// menu open. With mask points selected the arrows move the points instead (#1288).
+/// they move by fractions of a comp pixel. From any panel except Project, Effects & Presets and
+/// Render Queue (which own the arrow keys for their own keyboard navigation, #961); not while
- /// typing, with a dialog or menu open, or with mask points selected.
++/// typing, with a dialog or menu open. With mask points selected the arrows move the points instead (#1288).
fn nudge(app: &mut EffectcraftApp, ctx: &egui::Context, dir: &str) -> Result<Value, String> {
let (side, n) = match dir.strip_suffix("10") {
Some(side) => (side, 10.0),
@@@ -269,11 -269,7 +269,10 @@@
_ => return Err(format!("unknown nudge `{dir}`")),
};
let st = &app.session.state;
- if app.ui.focused == PanelKind::Project || (st.selected_layers.is_empty() && st.selected_vertices.is_empty()) || st.text_edit.is_some() {
+ if matches!(app.ui.focused, PanelKind::Project | PanelKind::EffectsPresets | PanelKind::RenderQueue)
- || st.selected_layers.is_empty()
++ || (st.selected_layers.is_empty() && st.selected_vertices.is_empty())
+ || st.text_edit.is_some()
- || !st.selected_vertices.is_empty()
+ {
return Ok(Value::Null);
}
// Screen pixels per comp pixel.
diff --cc crates/ui-egui/src/panels/effects_presets.rs
index d4e7ab909,d2058fbea..0d27b510a
--- a/crates/ui-egui/src/panels/effects_presets.rs
+++ b/crates/ui-egui/src/panels/effects_presets.rs
@@@ -10,9 -10,8 +10,9 @@@ use egui::{Align2, Color32, Rect, Sense
use serde_json::json;
use std::sync::Arc;
+use crate::a11y;
use crate::icons::{self, Icon};
- use crate::panels::DragPayload;
+ use crate::panels::{DragPayload, PresetRef};
use crate::theme::Tokens;
use crate::{EffectcraftApp, widgets};
@@@ -107,72 -106,12 +107,70 @@@ fn highlighted(p: &egui::Painter, pos:
p.text(pos, Align2::LEFT_CENTER, name, Tokens::ui(12.0), t.text);
}
+#[derive(Clone)]
enum Apply {
Effect(String),
- TextPreset(String),
- /// A built-in animation preset (Transitions…) by id.
- Builtin(String),
- PresetFile(String),
+ /// A text, built-in (Transitions…) or user file animation preset.
+ Preset(PresetRef),
}
+/// One row of the list as drawn this pass, including the rows scrolled out of view: what the
+/// arrow keys, Home / End and Enter work on (the rows are painted by hand, so this is the list).
+struct NavRow {
+ id: egui::Id,
+ /// The favourite star's widget, for an effect row.
+ star: Option<egui::Id>,
+ parent: Option<egui::Id>,
+ /// Where the row starts in the scrolled content.
+ top: f32,
+ /// A folder: (its key, open, forced open by a search).
+ folder: Option<(String, bool, bool)>,
+ /// What Enter applies, for an effect or preset row.
+ apply: Option<Apply>,
+}
+
+/// The list's keyboard state: the rows drawn, and the row the keys work from (the "cursor":
+/// selected, and the one Tab stop of the list).
+struct Nav {
+ rows: Vec<NavRow>,
+ /// The open folders on the way down to the row being drawn, by level.
+ stack: Vec<egui::Id>,
+ cursor: Option<egui::Id>,
+ /// The scroll offset and the list's top, to place rows in the content.
+ offset: f32,
+ list_top: f32,
+}
+
+impl Nav {
+ /// The row `id` is the list's Tab stop: the cursor row, or the first row while there is none.
+ fn tab_stop(&self, id: egui::Id) -> bool {
+ match self.cursor {
+ Some(c) => c == id,
+ None => self.rows.is_empty(),
+ }
+ }
+
+ /// Record the row drawn at `y`; returns whether it is the cursor row.
+ fn push(&mut self, id: egui::Id, y: f32, level: usize, folder: Option<(String, bool, bool)>, apply: Option<Apply>) -> bool {
+ let parent = level.checked_sub(2).and_then(|i| self.stack.get(i)).copied();
+ if folder.is_some() {
+ self.stack.truncate(level.saturating_sub(1));
+ self.stack.push(id);
+ }
+ self.rows.push(NavRow { id, star: None, parent, top: y - self.list_top + self.offset, folder, apply });
+ self.cursor == Some(id)
+ }
+}
+
+fn cursor_id() -> egui::Id {
+ egui::Id::new("fx-cursor")
+}
+
+/// The accessible name of a folder: what the row shows, in the interface language.
+fn folder_name(label: &str) -> &str {
+ tr(label)
+}
+
/// A folder row; returns whether it is open.
#[allow(clippy::too_many_arguments)]
fn folder_row(
@@@ -298,34 -192,20 +296,32 @@@ fn effect_row
lp.text(pos2(r.max.x - 10.0, r.center().y), Align2::RIGHT_CENTER, "32", Tokens::ui(9.5), t.text_faint);
}
app.auto.add(&format!("{auto_prefix}.{}", e.id), r, e.name);
- // Favourite star (always shown when starred, else on hover).
+ a11y::tree_item(&resp, &shown, selected, level, None);
+ row_focus(app, ui, lp, &resp, r, id);
+ // Favourite star (always shown when starred, else on hover or with the keyboard focus).
- let fav = app.ui.effects_favorites.contains(e.id);
+ let fav = app.session.prefs.is_effect_favorite(e.id);
- let sresp = ui.interact(star.intersect(list), egui::Id::new((auto_prefix, e.id, "star")), Sense::click());
- if fav || resp.hovered() || sresp.hovered() {
+ let sresp = ui.interact(star.intersect(list), star_id, if tab { Sense::click() } else { Sense::CLICK });
+ if fav || resp.hovered() || sresp.hovered() || sresp.has_focus() {
let gold = Color32::from_rgb(0xe8, 0xc0, 0x40);
filled_star(lp, star.center(), 6.0, fav.then_some(gold), if fav || sresp.hovered() { gold } else { t.text_faint });
}
app.auto.add(&format!("{auto_prefix}.{}.star", e.id), star, if fav { "Remove from Favorites" } else { "Add to Favorites" });
+ a11y::button(&sresp, &format!("{}: {shown}", tr(if fav { "Remove from favorites" } else { "Add to favorites" })), true);
+ if sresp.gained_focus() {
+ app.ui.focused = crate::dock::PanelKind::EffectsPresets;
+ }
+ if sresp.has_focus() {
+ widgets::focus_outline(ui, &sresp, &t);
+ }
if sresp.clicked() {
- if fav {
- app.ui.effects_favorites.remove(e.id);
- } else {
- app.ui.effects_favorites.insert(e.id.to_string());
- }
+ // Kept in the settings, so the stars are there next time (#1692).
+ app.session.prefs.toggle_effect_favorite(e.id);
+ app.session.save_prefs();
return;
}
+ if resp.clicked() {
+ nav_click(&ctx, app, id);
+ }
if resp.double_clicked() {
*apply = Some(Apply::Effect(e.id.to_string()));
}
@@@ -351,29 -230,22 +347,32 @@@ fn preset_row
) {
let t = app.tokens;
let r = Rect::from_min_size(pos2(list.min.x, *y), vec2(list.width(), ROW_H));
+ let id = egui::Id::new(("fxpreset", auto_id));
+ let tab = nav.tab_stop(id);
- let selected = nav.push(id, *y, 3, None, Some(on_apply()));
++ let selected = nav.push(id, *y, 3, None, Some(Apply::Preset(preset.clone())));
*y += ROW_H;
if r.max.y < list.min.y || r.min.y > list.max.y {
return;
}
- let resp = ui.interact(r.intersect(list), id, if tab { Sense::click() } else { Sense::CLICK });
- let resp = ui.interact(r.intersect(list), egui::Id::new(("fxpreset", auto_id)), Sense::click_and_drag());
- if resp.hovered() {
++ let resp = ui.interact(r.intersect(list), id, if tab { Sense::click_and_drag() } else { Sense::CLICK | Sense::DRAG });
+ if selected {
+ lp.rect_filled(r, 0.0, t.row_selected);
+ } else if resp.hovered() {
lp.rect_filled(r, 0.0, t.hover);
}
icons::paint(lp, Rect::from_center_size(pos2(r.min.x + 58.0, r.center().y), vec2(12.0, 12.0)), Icon::Keyframe, t.text_dim);
highlighted(lp, pos2(r.min.x + 70.0, r.center().y), name, query, &t);
app.auto.add(auto_id, r, name);
+ a11y::tree_item(&resp, name, selected, 3, None);
+ row_focus(app, ui, lp, &resp, r, id);
+ if resp.clicked() {
+ nav_click(ui.ctx(), app, id);
+ }
+ if resp.drag_started() {
+ egui::DragAndDrop::set_payload(ui.ctx(), DragPayload::Preset { preset: preset.clone(), name: name.to_string() });
+ }
if resp.double_clicked() {
- *apply = Some(on_apply());
+ *apply = Some(Apply::Preset(preset));
}
}
@@@ -619,8 -363,8 +618,8 @@@ pub fn show(app: &mut EffectcraftApp, u
let lookup = |id: &str| reg.iter().find(|e| e.id == id);
// Favorites and Recently Used.
- let favs: Vec<_> = app.ui.effects_favorites.iter().filter_map(|id| lookup(id)).filter(|e| keep(e)).collect();
+ let favs: Vec<_> = app.session.prefs.effects_favorites.iter().filter_map(|id| lookup(id)).filter(|e| keep(e)).collect();
- if !favs.is_empty() && folder_row(app, ui, &lp, list, &mut y, "favorites", "Favorites", 0.0, searching, Some(Icon::Star)) {
+ if !favs.is_empty() && folder_row(app, ui, &lp, list, &mut y, &mut nav, "favorites", "Favorites", 1, 0.0, searching, Some(Icon::Star)) {
let mut favs = favs;
favs.sort_by_key(|e| e.name);
for e in favs {
@@@ -649,22 -393,10 +648,22 @@@
let user = user_presets(&ctx, force_scan, || presets_dir().map(|d| scan_presets(&d)).unwrap_or_default());
let files: Vec<&PresetFile> = user.iter().filter(|f| query.is_empty() || f.name.to_lowercase().contains(&query)).collect();
let any = !text.is_empty() || !builtin.is_empty() || !files.is_empty();
- if any && folder_row(app, ui, &lp, list, &mut y, "presets", "* Animation Presets", 0.0, searching, None) {
- if !text.is_empty() && folder_row(app, ui, &lp, list, &mut y, "presets/Text", "Text", 14.0, searching, None) {
+ if any && folder_row(app, ui, &lp, list, &mut y, &mut nav, "presets", "* Animation Presets", 1, 0.0, searching, None) {
+ if !text.is_empty() && folder_row(app, ui, &lp, list, &mut y, &mut nav, "presets/Text", "Text", 2, 14.0, searching, None) {
for (id, name) in text {
- preset_row(app, ui, &lp, list, &mut y, &name, &format!("effects.preset.text.{id}"), &query, PresetRef::Text(id.clone()), &mut apply);
+ preset_row(
+ app,
+ ui,
+ &lp,
+ list,
+ &mut y,
+ &mut nav,
+ &name,
+ &format!("effects.preset.text.{id}"),
+ &query,
- || Apply::TextPreset(id.clone()),
++ PresetRef::Text(id.clone()),
+ &mut apply,
+ );
}
}
for cat in &categories {
@@@ -672,22 -404,10 +671,22 @@@
continue;
}
for (id, name, _) in builtin.iter().filter(|(_, _, c)| c == cat) {
- preset_row(app, ui, &lp, list, &mut y, name, &format!("effects.preset.builtin.{id}"), &query, PresetRef::Builtin(id.clone()), &mut apply);
+ preset_row(
+ app,
+ ui,
+ &lp,
+ list,
+ &mut y,
+ &mut nav,
+ name,
+ &format!("effects.preset.builtin.{id}"),
+ &query,
- || Apply::Builtin(id.clone()),
++ PresetRef::Builtin(id.clone()),
+ &mut apply,
+ );
}
}
- if !files.is_empty() && folder_row(app, ui, &lp, list, &mut y, "presets/User", "User Presets", 14.0, searching, None) {
+ if !files.is_empty() && folder_row(app, ui, &lp, list, &mut y, &mut nav, "presets/User", "User Presets", 2, 14.0, searching, None) {
for f in files {
preset_row(
app,
@@@ -737,13 -456,12 +736,15 @@@
}
let content = y + scroll.offset - list.min.y;
scroll.end(ui, &mut app.auto, "effects.scroll", content, &t);
+ if let Some(a) = list_keys(app, &ctx, &nav, list) {
+ apply = Some(a);
+ }
- if let Some(DragPayload::Effect(id)) = egui::DragAndDrop::payload::<DragPayload>(&ctx).as_deref()
- && let Some(pos) = ctx.pointer_hover_pos()
+ if let Some(name) = egui::DragAndDrop::payload::<DragPayload>(&ctx).and_then(|p| match p.as_ref() {
+ DragPayload::Effect(id) => Some(effectcraft_engine::effects::find(id).map(|e| crate::i18n::effects::name(e.id, e.name)).unwrap_or_default()),
+ DragPayload::Preset { name, .. } => Some(name.clone()),
+ _ => None,
+ }) && let Some(pos) = ctx.pointer_hover_pos()
{
- let name = effectcraft_engine::effects::find(id).map(|e| crate::i18n::effects::name(e.id, e.name)).unwrap_or_default();
let painter = ctx.layer_painter(egui::LayerId::new(egui::Order::Tooltip, egui::Id::new("dnd-fx")));
let g = painter.layout_no_wrap(name, Tokens::ui(12.0), t.text);
let r = Rect::from_min_size(pos + vec2(12.0, 8.0), g.size() + vec2(16.0, 8.0));
diff --cc crates/ui-egui/tests/ui_accessibility_audit.rs
index 012bf914f,000000000..f55722d1e
mode 100644,000000..100644
--- a/crates/ui-egui/tests/ui_accessibility_audit.rs
+++ b/crates/ui-egui/tests/ui_accessibility_audit.rs
@@@ -1,377 -1,0 +1,377 @@@
+//! Accessibility audit (docs/gaps.md gap 25): renders panels headless and walks the AccessKit
+//! tree of the frame. Every interactive node (button, check box, text input, combo box, slider,
+//! spin button, tree or list item, tab, link, ...) must have a non-empty name, a role that says
+//! what it is, and the state that role needs (checked, selected, a value).
+//!
+//! * The panels that had their pass (`FIXED`: Effects & Presets, Settings, Render Queue with its
+//! Templates dialog) must have **zero** findings.
+//! * Every other panel is counted and printed (run with `--nocapture`), and checked against
+//! [`BASELINE`], a ratchet that can only shrink: fixing a panel lowers its number, and a number
+//! must never go up. When a panel's count falls, lower its entry (the test says so).
+//!
+//! What this does not measure: how a real screen reader speaks the tree (none was run), colour
+//! contrast, focus order or keyboard operation (the `ui_*_keyboard.rs` tests cover those), or
+//! widgets that are scrolled out of view and not drawn.
+
+use std::collections::HashSet;
+
+use effectcraft_engine::Session;
+use effectcraft_ui_egui::EffectcraftApp;
+use effectcraft_ui_egui::dock::PanelKind;
+use egui::accesskit::{Action, Role, Toggled};
+use egui::{Rect, pos2};
+use egui_kittest::Harness;
+use egui_kittest::kittest::NodeT;
+use serde_json::json;
+
+/// Groups that must be clean. A group is the first part of a scenario name (before the `:`).
+const FIXED: &[&str] = &["EffectsPresets", "Settings", "RenderQueue", "Project"];
+
+/// (scenario, findings, of them unnamed controls) per not-yet-fixed scenario, as measured when
+/// this test was written (Effect Controls with one Gaussian Blur on the layer, every other panel
+/// as it opens). A ratchet: a number may only go down, never up; when a pass over a panel lowers
+/// it, lower its entry in the same change, and remove the entry (and add the panel to `FIXED`)
+/// when it reaches zero. A scenario that is not listed is held to zero.
+const BASELINE: &[(&str, usize, usize)] = &[
+ ("EffectControls:default", 25, 15),
+ ("Composition:default", 16, 14),
+ ("Layer:default", 4, 3),
+ ("Timeline:default", 83, 55),
+ ("Audio:default", 4, 2),
+ ("Preview:default", 5, 5),
+ ("Properties:default", 45, 28),
+ ("Character:default", 13, 9),
+ ("Paragraph:default", 24, 12),
+ ("Align:default", 18, 11),
+ ("Tracker:default", 1, 1),
+ ("Wiggler:default", 2, 2),
+ ("Smoother:default", 2, 1),
+ ("MotionSketch:default", 4, 2),
+ ("Paint:default", 5, 3),
+ ("Brushes:default", 16, 9),
+ ("Flowchart:default", 8, 4),
+ ("History:default", 10, 5),
+ ("Markers:default", 1, 1),
+ ("MaskInterpolation:default", 2, 2),
+ ("ScriptConsole:default", 5, 3),
+ ("EssentialGraphics:default", 2, 2),
+ ("Footage:default", 3, 2),
+ ("Progress:default", 1, 1),
+ ("VrCompEditor:default", 13, 7),
+];
+
+/// How many controls the fixed scenarios must at least show, so that "zero findings" is never
+/// the result of looking at nothing. Any scenario not listed needs 2.
+const MIN_CONTROLS: &[(&str, usize)] = &[
+ ("EffectsPresets:default", 10),
+ ("EffectsPresets:open", 10),
+ ("EffectsPresets:search", 5),
+ ("EffectsPresets:menu", 8),
+ ("Settings:general", 12),
+ ("Settings:appearance", 15),
+ ("Settings:labels", 30),
+ ("RenderQueue:queued", 8),
+ ("RenderQueue:expanded", 12),
+ ("RenderQueue:menu", 20),
+ ("RenderQueue:templates:renderSettings", 8),
+ ("RenderQueue:templates:outputModule", 8),
+];
+
+/// The roles that are controls: anything with one of these (or with a click or focus action) is
+/// held to the rules below.
+const CONTROL_ROLES: &[Role] = &[
+ Role::Button,
+ Role::CheckBox,
+ Role::ColorWell,
+ Role::ComboBox,
+ Role::Link,
+ Role::ListBoxOption,
+ Role::ListItem,
+ Role::MenuItem,
+ Role::MenuItemCheckBox,
+ Role::MenuItemRadio,
+ Role::MultilineTextInput,
+ Role::RadioButton,
+ Role::SearchInput,
+ Role::Slider,
+ Role::SpinButton,
+ Role::Switch,
+ Role::Tab,
+ Role::TextInput,
+ Role::TreeItem,
+];
+
+#[derive(Debug, Clone)]
+struct Finding {
+ scenario: String,
+ problem: &'static str,
+ role: Role,
+ name: String,
+ rect: [i32; 4],
+}
+
+impl std::fmt::Display for Finding {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ write!(f, "[{}] {}: {:?} {:?} at {:?}", self.scenario, self.problem, self.role, self.name, self.rect)
+ }
+}
+
+fn app_session() -> Session {
+ let mut s = Session::default();
+ s.execute("comp.new", json!({"name": "Main", "width": 320, "height": 180, "duration": 4})).unwrap();
+ s.execute("layer.newSolid", json!({"name": "Red", "color": "#c04040"})).unwrap();
+ s.execute("layer.newSolid", json!({"name": "Blue", "color": "#4040c0"})).unwrap();
+ s.execute("effect.apply", json!({"effect": "Gaussian Blur"})).ok();
+ s
+}
+
+fn harness() -> Harness<'static, EffectcraftApp> {
+ let mut h = Harness::builder().with_size(egui::vec2(1600.0, 1000.0)).build_eframe(|_| EffectcraftApp::new(app_session()));
+ h.run_steps(4);
+ h
+}
+
+fn invoke(h: &mut Harness<'_, EffectcraftApp>, id: &str, params: serde_json::Value) {
+ let ctx = h.ctx.clone();
+ effectcraft_ui_egui::menus::invoke(h.state_mut(), &ctx, id, params).unwrap();
+ h.run_steps(4);
+}
+
+fn panel_rect(h: &Harness<'_, EffectcraftApp>, p: PanelKind) -> Option<Rect> {
+ let e = h.state().auto.find(&format!("panel.{}", p.id()))?;
+ Some(Rect::from_min_size(pos2(e.rect[0], e.rect[1]), egui::vec2(e.rect[2], e.rect[3])))
+}
+
+fn dialog_rect(h: &Harness<'_, EffectcraftApp>, title: &str) -> Option<Rect> {
+ h.ctx.memory(|m| m.area_rect(egui::Id::new(("modal", title))))
+}
+
+/// The ids of every node now, so a later audit can look at what appeared since (a popup).
+fn node_ids(h: &Harness<'_, EffectcraftApp>) -> HashSet<String> {
+ h.root().children_recursive().map(|n| format!("{:?}", n.accesskit_node().id())).collect()
+}
+
+/// Walk the tree and check every control whose centre is inside `scope` (and, when `since` is
+/// given, that was not in the tree before).
+fn audit(h: &Harness<'_, EffectcraftApp>, scenario: &str, scope: Rect, since: Option<&HashSet<String>>) -> (Vec<Finding>, usize) {
+ let mut out = Vec::new();
+ let mut controls = 0;
+ for n in h.root().children_recursive() {
+ let a = n.accesskit_node();
+ if a.is_hidden() {
+ continue;
+ }
+ let Some(b) = a.bounding_box() else {
+ // No bounds: assistive technology cannot place it. Only a control is a finding (and
+ // it is one wherever it is: there is no position to scope it by).
+ if CONTROL_ROLES.contains(&a.role()) {
+ out.push(Finding { scenario: scenario.to_string(), problem: "no bounds", role: a.role(), name: a.label().unwrap_or_default(), rect: [0; 4] });
+ }
+ continue;
+ };
+ if !scope.contains(pos2(((b.x0 + b.x1) / 2.0) as f32, ((b.y0 + b.y1) / 2.0) as f32)) {
+ continue;
+ }
+ if since.is_some_and(|s| s.contains(&format!("{:?}", a.id()))) {
+ continue;
+ }
+ let role = a.role();
+ let actionable = a.data().supports_action(Action::Click) || a.data().supports_action(Action::Focus);
+ let control = CONTROL_ROLES.contains(&role);
+ if !control && !(actionable && matches!(role, Role::Unknown | Role::GenericContainer)) {
+ continue;
+ }
+ let name = a.label().unwrap_or_default();
+ controls += 1;
+ let finding = |problem: &'static str| Finding {
+ scenario: scenario.to_string(),
+ problem,
+ role,
+ name: name.clone(),
+ rect: [b.x0 as i32, b.y0 as i32, b.x1 as i32, b.y1 as i32],
+ };
+ if !control && matches!(role, Role::Unknown | Role::GenericContainer) {
+ // Something you can click or focus, that no role describes.
+ out.push(finding("clickable or focusable without a control role"));
+ }
+ if name.trim().is_empty() {
+ out.push(finding("no name"));
+ }
+ let state_missing = match role {
+ Role::CheckBox | Role::RadioButton | Role::Switch | Role::MenuItemCheckBox | Role::MenuItemRadio => {
+ a.toggled().is_none() || a.toggled() == Some(Toggled::Mixed)
+ }
+ Role::Slider | Role::SpinButton => a.numeric_value().is_none(),
+ Role::ComboBox => a.value().is_none_or(|v| v.trim().is_empty()),
+ Role::TreeItem | Role::ListItem | Role::ListBoxOption | Role::Tab => a.is_selected().is_none(),
+ _ => false,
+ };
+ if state_missing {
+ out.push(finding("no state or value"));
+ }
+ }
+ (out, controls)
+}
+
+fn count_unnamed(f: &[Finding]) -> usize {
+ f.iter().filter(|f| f.problem == "no name").count()
+}
+
+struct Report {
+ findings: Vec<Finding>,
+ /// (scenario, findings, of them unnamed, controls looked at)
+ rows: Vec<(String, usize, usize, usize)>,
+}
+
+impl Report {
+ fn add(&mut self, scenario: &str, (f, controls): (Vec<Finding>, usize)) {
+ self.rows.push((scenario.to_string(), f.len(), count_unnamed(&f), controls));
+ self.findings.extend(f);
+ }
+}
+
+fn group(scenario: &str) -> &str {
+ scenario.split(':').next().unwrap_or(scenario)
+}
+
+fn collect() -> Report {
+ let mut r = Report { findings: vec![], rows: vec![] };
+
+ // ---- Effects & Presets: closed, everything open, searching, the contents menu.
+ let mut h = harness();
+ h.state_mut().show_panel(PanelKind::EffectsPresets);
+ h.run_steps(4);
+ let rect = panel_rect(&h, PanelKind::EffectsPresets).expect("Effects & Presets is drawn");
+ r.add("EffectsPresets:default", audit(&h, "EffectsPresets:default", rect, None));
+ {
+ let s = h.state_mut();
- s.ui.effects_favorites.insert("ec.blur.gaussian".into());
++ s.session.prefs.toggle_effect_favorite("ec.blur.gaussian");
+ s.ui.effects_open.insert("favorites".into());
+ s.ui.effects_open.insert("presets".into());
+ s.ui.effects_open.insert("presets/Text".into());
+ s.ui.effects_open.insert("Blur & Sharpen".into());
+ }
+ h.run_steps(4);
+ r.add("EffectsPresets:open", audit(&h, "EffectsPresets:open", rect, None));
+ h.state_mut().ui.effects_search = "blur".into();
+ h.run_steps(4);
+ r.add("EffectsPresets:search", audit(&h, "EffectsPresets:search", rect, None));
+ let before = node_ids(&h);
+ h.ctx.data_mut(|d| d.insert_temp(egui::Id::new("fx-contents-menu").with("open"), true));
+ h.run_steps(4);
+ let screen = Rect::from_min_size(pos2(0.0, 0.0), egui::vec2(1600.0, 1000.0));
+ r.add("EffectsPresets:menu", audit(&h, "EffectsPresets:menu", screen, Some(&before)));
+
+ // ---- Settings: every page.
+ let mut h = harness();
+ let before = node_ids(&h);
+ for page in effectcraft_engine::prefs::pages() {
+ invoke(&mut h, "app.settings", json!({"page": page.id}));
+ let name = format!("Settings:{}", page.id);
+ let rect = dialog_rect(&h, "Settings").expect("the Settings dialog is open");
+ r.add(&name, audit(&h, &name, rect, Some(&before)));
+ }
+
+ // ---- Render Queue: empty, queued and expanded, a menu open, the Templates dialogs.
+ let mut h = harness();
+ h.state_mut().show_panel(PanelKind::RenderQueue);
+ h.run_steps(4);
+ let rect = panel_rect(&h, PanelKind::RenderQueue).expect("the Render Queue is drawn");
+ r.add("RenderQueue:empty", audit(&h, "RenderQueue:empty", rect, None));
+ let comp = h.state().session.active_comp_id().expect("a comp").0;
+ let mut items = vec![];
+ for _ in 0..2 {
+ let out = h.state_mut().session.execute("renderQueue.add", json!({"comp": comp})).unwrap();
+ items.push(out["item"].as_u64().or_else(|| out["items"][0].as_u64()).unwrap_or(0));
+ }
+ h.run_steps(4);
+ r.add("RenderQueue:queued", audit(&h, "RenderQueue:queued", rect, None));
+ let first = h.state().session.project.render_queue.first().map(|i| i.id).expect("a queue item");
+ h.ctx.data_mut(|d| d.insert_temp(egui::Id::new("rq-ui"), (vec![first], Some(first))));
+ h.run_steps(4);
+ r.add("RenderQueue:expanded", audit(&h, "RenderQueue:expanded", rect, None));
+ let before = node_ids(&h);
+ h.ctx.data_mut(|d| d.insert_temp(egui::Id::new(("rq-dd", first, 0)).with("open"), true));
+ h.run_steps(4);
+ r.add("RenderQueue:menu", audit(&h, "RenderQueue:menu", screen, Some(&before)));
+ h.ctx.data_mut(|d| d.insert_temp(egui::Id::new(("rq-dd", first, 0)).with("open"), false));
+ let before = node_ids(&h);
+ for (kind, title) in [("renderSettings", "Render Settings Templates"), ("outputModule", "Output Module Templates")] {
+ invoke(&mut h, "app.templates", json!({"kind": kind}));
+ let name = format!("RenderQueue:templates:{kind}");
+ let rect = dialog_rect(&h, title).expect("the Templates dialog is open");
+ r.add(&name, audit(&h, &name, rect, Some(&before)));
+ }
+ let _ = items;
+
+ // ---- Everything else, informational: each panel on its own.
+ let mut h = harness();
+ for p in PanelKind::ALL {
+ if matches!(p, PanelKind::EffectsPresets | PanelKind::RenderQueue) {
+ continue;
+ }
+ h.state_mut().show_panel(p);
+ h.run_steps(3);
+ let name = format!("{}:default", p.id());
+ let Some(rect) = panel_rect(&h, p) else {
+ r.rows.push((format!("{name} (not drawn)"), 0, 0, 0));
+ continue;
+ };
+ r.add(&name, audit(&h, &name, rect, None));
+ }
+ r
+}
+
+#[test]
+fn fixed_panels_have_no_unnamed_or_roleless_controls_and_the_others_do_not_get_worse() {
+ let report = collect();
+ println!("\nAccessibility audit: findings per scenario (unnamed in brackets)");
+ let mut by_group: Vec<(String, usize, usize, usize)> = vec![];
+ for (name, n, unnamed, controls) in &report.rows {
+ println!(" {name:<44} {n:>4} findings ({unnamed} unnamed) of {controls} controls");
+ let g = group(name).to_string();
+ match by_group.iter_mut().find(|(k, ..)| *k == g) {
+ Some(e) => {
+ e.1 += n;
+ e.2 += unnamed;
+ e.3 += controls;
+ }
+ None => by_group.push((g, *n, *unnamed, *controls)),
+ }
+ }
+ println!("\nBy panel (findings, unnamed controls, controls looked at):");
+ for (g, n, unnamed, controls) in &by_group {
+ let state = if FIXED.contains(&g.as_str()) { "fixed: must be 0" } else { "not yet audited" };
+ println!(" {g:<28} {n:>4} findings, {unnamed:>3} unnamed, {controls:>4} controls {state}");
+ }
+ let total_unnamed: usize = by_group.iter().map(|(_, _, u, _)| u).sum();
+ println!(" all panels: {total_unnamed} unnamed controls\n");
+
+ let mut failures = vec![];
+ for f in &report.findings {
+ if FIXED.contains(&group(&f.scenario)) {
+ failures.push(f.to_string());
+ }
+ }
+ assert!(failures.is_empty(), "{} accessibility findings in the fixed panels:\n{}", failures.len(), failures.join("\n"));
+
+ // A clean panel must not be clean because nothing was looked at.
+ for (name, _, _, controls) in &report.rows {
+ if FIXED.contains(&group(name)) {
+ let min = MIN_CONTROLS.iter().find(|(k, _)| k == name).map_or(2, |(_, v)| *v);
+ assert!(*controls >= min, "{name}: only {controls} controls found in the tree (expected {min}); the scenario is not showing the panel");
+ }
+ }
+
+ for (name, n, unnamed, _) in &report.rows {
+ if FIXED.contains(&group(name)) {
+ continue;
+ }
+ let (allowed, allowed_unnamed) = BASELINE.iter().find(|(k, ..)| k == name).map_or((0, 0), |(_, v, u)| (*v, *u));
+ assert!(*n <= allowed, "{name}: {n} findings, the baseline allows {allowed}; a panel must not get worse");
+ assert!(*unnamed <= allowed_unnamed, "{name}: {unnamed} unnamed controls, the baseline allows {allowed_unnamed}; a panel must not get worse");
+ if *n < allowed || *unnamed < allowed_unnamed {
+ println!("note: {name} improved to {n} findings ({unnamed} unnamed); lower its BASELINE entry from {allowed} ({allowed_unnamed})");
+ }
+ }
+}
diff --cc crates/ui-egui/tests/ui_effects_presets_keyboard.rs
index d6f1378d1,000000000..7c4c52413
mode 100644,000000..100644
--- a/crates/ui-egui/tests/ui_effects_presets_keyboard.rs
+++ b/crates/ui-egui/tests/ui_effects_presets_keyboard.rs
@@@ -1,271 -1,0 +1,271 @@@
+//! Effects & Presets keyboard operation and accessible names (docs/gaps.md gap 25): the list is one
+//! Tab stop; the arrow keys, Home / End, Right / Left, Enter and Space work it; the focus follows
+//! the cursor; rows are tree items with a name, a selected state, a depth and (folders) an open
+//! state; the favourite star is a named button.
+
+use effectcraft_engine::Session;
+use effectcraft_ui_egui::EffectcraftApp;
+use effectcraft_ui_egui::dock::PanelKind;
+use egui::accesskit::Role;
+use egui::{Event, Key, Modifiers, Pos2, pos2};
+use egui_kittest::Harness;
+use egui_kittest::kittest::{NodeT, Queryable};
+use serde_json::json;
+
+fn harness() -> Harness<'static, EffectcraftApp> {
+ let mut s = Session::default();
+ s.execute("comp.new", json!({"name": "Main", "width": 320, "height": 180, "duration": 4})).unwrap();
+ s.execute("layer.newSolid", json!({"name": "Red", "color": "#c04040"})).unwrap();
+ let mut h = Harness::builder().with_size(egui::vec2(1600.0, 1000.0)).build_eframe(|_| EffectcraftApp::new(s));
+ h.state_mut().show_panel(PanelKind::EffectsPresets);
+ h.run_steps(4);
+ h
+}
+
+fn center(h: &Harness<'_, EffectcraftApp>, id: &str) -> Pos2 {
+ let e = h.state().auto.find(id).unwrap_or_else(|| panic!("no {id}")).clone();
+ pos2(e.rect[0] + e.rect[2] / 2.0, e.rect[1] + e.rect[3] / 2.0)
+}
+
+fn click(h: &mut Harness<'_, EffectcraftApp>, id: &str) {
+ let p = center(h, id);
+ h.input_mut().events.push(Event::PointerMoved(p));
+ h.step();
+ for pressed in [true, false] {
+ h.input_mut().events.push(Event::PointerButton { pos: p, button: egui::PointerButton::Primary, pressed, modifiers: Modifiers::NONE });
+ h.step();
+ }
+ h.run_steps(3);
+}
+
+fn key(h: &mut Harness<'_, EffectcraftApp>, key: Key, modifiers: Modifiers) {
+ for pressed in [true, false] {
+ h.input_mut().events.push(Event::Key { key, physical_key: None, pressed, repeat: false, modifiers });
+ h.step();
+ }
+ h.run_steps(3);
+}
+
+/// The role and name of the node that has the keyboard focus.
+fn focused(h: &Harness<'_, EffectcraftApp>) -> Option<(Role, String)> {
+ h.root().children_recursive().find(|n| n.is_focused()).map(|n| (n.accesskit_node().role(), n.accesskit_node().label().unwrap_or_default()))
+}
+
+fn selected_rows(h: &Harness<'_, EffectcraftApp>) -> Vec<String> {
+ let panel = h.state().auto.find("panel.EffectsPresets").expect("the panel is drawn").rect;
+ let panel = egui::Rect::from_min_size(pos2(panel[0], panel[1]), egui::vec2(panel[2], panel[3]));
+ h.root()
+ .children_recursive()
+ .filter(|n| n.accesskit_node().role() == Role::TreeItem && n.accesskit_node().is_selected() == Some(true))
+ .filter(|n| n.accesskit_node().bounding_box().is_some_and(|b| panel.contains(pos2(b.x0 as f32 + 1.0, b.y0 as f32 + 1.0))))
+ .map(|n| n.accesskit_node().label().unwrap_or_default())
+ .collect()
+}
+
+/// Put the keyboard on the first row the way Tab does: from the search field, the menu button,
+/// then the list.
+fn tab_into_list(h: &mut Harness<'_, EffectcraftApp>) {
+ h.get_by_label("Search effects and presets").focus();
+ h.run_steps(3);
+ key(h, Key::Tab, Modifiers::NONE);
+ assert_eq!(focused(h).map(|f| f.1), Some("Effects & Presets options".to_string()), "Tab leaves the search field for the options button");
+ key(h, Key::Tab, Modifiers::NONE);
+}
+
+#[test]
+fn tab_reaches_the_list_once_and_leaves_it() {
+ let mut h = harness();
+ tab_into_list(&mut h);
+ let (role, name) = focused(&h).expect("a row has the focus");
+ assert_eq!(role, Role::TreeItem);
+ assert!(!name.is_empty());
+ // The first row is a folder: no star. The next Tab leaves the list instead of walking the
+ // hundreds of effects.
+ key(&mut h, Key::Tab, Modifiers::NONE);
+ let after = focused(&h);
+ assert!(after.as_ref().is_none_or(|(r, _)| *r != Role::TreeItem), "the second Tab is past the list: {after:?}");
+}
+
+#[test]
+fn arrows_home_end_move_the_cursor_and_the_focus() {
+ let mut h = harness();
+ tab_into_list(&mut h);
+ let first = focused(&h).unwrap().1;
+ assert_eq!(selected_rows(&h), Vec::<String>::new(), "Tab alone selects nothing");
+ key(&mut h, Key::ArrowDown, Modifiers::NONE);
+ let second = focused(&h).unwrap().1;
+ assert_ne!(first, second, "Down Arrow moves to the next row");
+ assert_eq!(selected_rows(&h), vec![second.clone()], "the row the cursor is on is selected");
+ key(&mut h, Key::ArrowUp, Modifiers::NONE);
+ assert_eq!(focused(&h).unwrap().1, first);
+ key(&mut h, Key::End, Modifiers::NONE);
+ let last = focused(&h).unwrap().1;
+ assert_ne!(last, first, "End goes to the last row");
+ key(&mut h, Key::ArrowDown, Modifiers::NONE);
+ assert_eq!(focused(&h).unwrap().1, last, "Down Arrow stays on the last row");
+ key(&mut h, Key::Home, Modifiers::NONE);
+ assert_eq!(focused(&h).unwrap().1, first, "Home goes to the first row");
+ key(&mut h, Key::PageDown, Modifiers::NONE);
+ assert_ne!(focused(&h).unwrap().1, first, "Page Down moves a page");
+ // The cursor row is scrolled into view: its node is on screen.
+ let name = focused(&h).unwrap().1;
+ let r = h.get_by_label(&name).rect();
+ assert!(r.min.y >= 0.0 && r.max.y <= 1000.0, "the focused row is on screen: {r:?}");
+}
+
+#[test]
+fn right_and_left_open_and_close_folders_and_step_through_the_tree() {
+ let mut h = harness();
+ h.state_mut().ui.effects_search.clear();
+ tab_into_list(&mut h);
+ // Walk to a category folder (not the presets folder).
+ let mut guard = 0;
+ loop {
+ let n = focused(&h).unwrap().1;
+ if n == "Blur & Sharpen" {
+ break;
+ }
+ key(&mut h, Key::ArrowDown, Modifiers::NONE);
+ guard += 1;
+ assert!(guard < 40, "no Blur & Sharpen folder reached");
+ }
+ let folder = h.get_by_label("Blur & Sharpen");
+ assert_eq!(folder.accesskit_node().data().is_expanded(), Some(false));
+ assert_eq!(folder.accesskit_node().data().level(), Some(1));
+ key(&mut h, Key::ArrowRight, Modifiers::NONE);
+ assert!(h.state().ui.effects_open.contains("Blur & Sharpen"), "Right Arrow opens the folder");
+ assert_eq!(h.get_by_label("Blur & Sharpen").accesskit_node().data().is_expanded(), Some(true));
+ key(&mut h, Key::ArrowRight, Modifiers::NONE);
+ let child = focused(&h).unwrap();
+ assert_eq!(child.0, Role::TreeItem);
+ assert_ne!(child.1, "Blur & Sharpen", "Right Arrow on an open folder steps into it");
+ assert_eq!(h.get_by_label(&child.1).accesskit_node().data().level(), Some(2));
+ key(&mut h, Key::ArrowLeft, Modifiers::NONE);
+ assert_eq!(focused(&h).unwrap().1, "Blur & Sharpen", "Left Arrow on an effect steps out to its folder");
+ key(&mut h, Key::ArrowLeft, Modifiers::NONE);
+ assert!(!h.state().ui.effects_open.contains("Blur & Sharpen"), "Left Arrow closes the folder");
+ key(&mut h, Key::Enter, Modifiers::NONE);
+ assert!(h.state().ui.effects_open.contains("Blur & Sharpen"), "Enter opens a closed folder");
+ key(&mut h, Key::Space, Modifiers::NONE);
+ assert!(!h.state().ui.effects_open.contains("Blur & Sharpen"), "Space closes it again");
+}
+
+#[test]
+fn enter_and_space_apply_an_effect_to_the_selected_layer() {
+ for apply_key in [Key::Enter, Key::Space] {
+ let mut h = harness();
+ tab_into_list(&mut h);
+ h.state_mut().ui.effects_open.insert("Blur & Sharpen".into());
+ h.run_steps(3);
+ let mut guard = 0;
+ while focused(&h).map(|f| f.1) != Some("Blur & Sharpen".to_string()) {
+ key(&mut h, Key::ArrowDown, Modifiers::NONE);
+ guard += 1;
+ assert!(guard < 40);
+ }
+ key(&mut h, Key::ArrowDown, Modifiers::NONE);
+ let effect = focused(&h).unwrap().1;
+ assert!(h.state().session.state.last_effect.is_none());
+ key(&mut h, apply_key, Modifiers::NONE);
+ let applied = h.state().session.state.last_effect.clone();
+ assert!(applied.is_some(), "{apply_key:?} on `{effect}` applies it to the selected layer");
+ let pb = &h.state().playback;
+ assert!(!pb.playing && !pb.caching && pb.plan.is_none(), "{apply_key:?} on a focused row is the row's, it does not start a preview");
+ }
+}
+
+#[test]
+fn the_star_is_a_named_button_on_the_cursor_row_and_enter_toggles_it() {
+ let mut h = harness();
+ tab_into_list(&mut h);
+ h.state_mut().ui.effects_open.insert("Blur & Sharpen".into());
+ h.run_steps(3);
+ while focused(&h).map(|f| f.1) != Some("Blur & Sharpen".to_string()) {
+ key(&mut h, Key::ArrowDown, Modifiers::NONE);
+ }
+ key(&mut h, Key::ArrowDown, Modifiers::NONE);
+ let effect = focused(&h).unwrap().1;
+ key(&mut h, Key::Tab, Modifiers::NONE);
+ let (role, name) = focused(&h).expect("the star has the focus");
+ assert_eq!(role, Role::Button);
+ assert_eq!(name, format!("Add to favorites: {effect}"));
+ key(&mut h, Key::Enter, Modifiers::NONE);
- assert_eq!(h.state().ui.effects_favorites.len(), 1, "Enter on the star adds the favourite");
++ assert_eq!(h.state().session.prefs.effects_favorites.len(), 1, "Enter on the star adds the favourite");
+ let (_, name) = focused(&h).expect("the star keeps the focus");
+ assert_eq!(name, format!("Remove from favorites: {effect}"));
+}
+
+#[test]
+fn the_search_field_keeps_its_arrows_and_the_layer_does_not_nudge() {
+ let mut h = harness();
+ h.get_by_label("Search effects and presets").focus();
+ h.run_steps(3);
+ h.get_by_label("Search effects and presets").type_text("blur");
+ h.run_steps(3);
+ assert_eq!(h.state().ui.effects_search, "blur");
+ key(&mut h, Key::ArrowDown, Modifiers::NONE);
+ assert!(selected_rows(&h).is_empty(), "arrows in the search field belong to the field");
+ // A click on a row, then the arrows: the list moves, the selected layer stays where it is.
+ let layer_before = layer_position(&h);
+ h.state_mut().ui.effects_search.clear();
+ h.run_steps(3);
+ click(&mut h, "effects.category.presets");
+ assert_eq!(h.state().ui.focused, PanelKind::EffectsPresets);
+ key(&mut h, Key::ArrowDown, Modifiers::NONE);
+ assert_eq!(selected_rows(&h).len(), 1, "the arrows work after a click, without keyboard focus on a row");
+ key(&mut h, Key::ArrowRight, Modifiers::NONE);
+ assert_eq!(layer_position(&h), layer_before, "the arrow keys did not nudge the selected layer");
+}
+
+fn layer_position(h: &Harness<'_, EffectcraftApp>) -> String {
+ let s = &h.state().session;
+ let comp = s.active_comp().expect("a comp");
+ let layer = comp.layers.first().expect("a layer");
+ format!("{:?}", layer.transform())
+}
+
+#[test]
+fn rows_and_controls_have_names_roles_and_states() {
+ let mut h = harness();
+ h.state_mut().ui.effects_open.insert("Blur & Sharpen".into());
- h.state_mut().ui.effects_favorites.insert("ec.blur.gaussian".into());
++ h.state_mut().session.prefs.toggle_effect_favorite("ec.blur.gaussian");
+ h.run_steps(4);
+ assert_eq!(h.get_by_label("Search effects and presets").accesskit_node().role(), Role::TextInput);
+ let menu = h.get_by_label("Effects & Presets options");
+ assert_eq!(menu.accesskit_node().role(), Role::Button);
+ assert_eq!(menu.accesskit_node().data().is_expanded(), Some(false), "the options button says its menu is closed");
+ let folder = h.get_by_label("Blur & Sharpen");
+ assert_eq!(folder.accesskit_node().role(), Role::TreeItem);
+ assert_eq!(folder.accesskit_node().data().is_expanded(), Some(true));
+ assert_eq!(folder.accesskit_node().is_selected(), Some(false));
+ let favorites = h.get_by_label("Favorites");
+ assert_eq!(favorites.accesskit_node().data().is_expanded(), Some(false));
+ // Every effect row in an open category is a leaf at depth 2.
+ let leaves: Vec<_> =
+ h.root().children_recursive().filter(|n| n.accesskit_node().role() == Role::TreeItem && n.accesskit_node().data().level() == Some(2)).collect();
+ assert!(!leaves.is_empty());
+ assert!(leaves.iter().all(|n| n.accesskit_node().data().is_expanded().is_none()), "effects are leaves: they have no open state");
+ assert!(h.query_by_label_contains("Remove from favorites: ").is_none(), "a favourite hidden in a closed Favorites folder draws no rows");
+ assert!(h.query_all_by_label_contains("Add to favorites: ").count() > 1, "the effects' stars are named");
+}
+
+/// A pick from the options menu with the mouse leaves no widget with the keyboard focus, and Enter
+/// after a click in the panel is the panel's: it opens or applies the row and does not start the
+/// layer rename the Timeline binds to Enter.
+#[test]
+fn mouse_picks_leave_no_focus_and_enter_after_a_click_is_the_panels() {
+ let mut h = harness();
+ click(&mut h, "effects.menu");
+ assert!(h.ctx.memory(|m| m.focused()).is_none(), "opening the menu with the mouse takes no keyboard focus");
+ h.get_by_label_contains("Alphabetical").click();
+ h.run_steps(4);
+ assert!(h.ctx.memory(|m| m.focused()).is_none(), "choosing an entry with the mouse leaves no keyboard focus");
+ assert!(h.state().ui.effects_view.alphabetical);
+ h.state_mut().ui.effects_view.alphabetical = false;
+ h.run_steps(3);
+ click(&mut h, "effects.category.presets");
+ let open = h.state().ui.effects_open.contains("presets");
+ key(&mut h, Key::Enter, Modifiers::NONE);
+ assert_ne!(h.state().ui.effects_open.contains("presets"), open, "Enter toggles the clicked folder");
+ assert!(h.state().auto.query("timeline.layer.").iter().all(|e| !e.id.ends_with(".nameEdit")), "no layer rename started");
+}
diff --cc docs/gaps.md
index dc686dfa7,fd92c22a4..4d789b2b7
--- a/docs/gaps.md
+++ b/docs/gaps.md
@@@ -1,6 -1,6 +1,6 @@@
# Where EffectCraft falls short
- > **Last reviewed:** 2026-10-13 · **Last updated:** 2026-10-13 · **Change:** minor (gap 25: an AccessKit audit test and a theme contrast test, Effects & Presets, Settings and Render Queue named and keyboard-operable, #1335; earlier change: issue, PR and catalog references gap 21: percentage guides and effect colour labels in; earlier change: re-audited against `upstream/main` 470ea7a3; ranked gap list from the 10 October re-measure otherwise unchanged) · **Target:** Adobe After Effects 2026 (26.5.0.89)
-> **Last reviewed:** 2026-10-12 · **Last updated:** 2026-10-13 · **Change:** minor (path-editing layer bounds, #1220; issue, PR and catalog references gap 21: percentage guides and effect colour labels in; earlier change: re-audited against `upstream/main` 470ea7a3; ranked gap list from the 10 October re-measure otherwise unchanged) · **Target:** Adobe After Effects 2026 (26.5.0.89)
++> **Last reviewed:** 2026-10-12 · **Last updated:** 2026-10-13 · **Change:** minor (gap 25: an AccessKit audit test and a theme contrast test, Effects & Presets, Settings and Render Queue named and keyboard-operable, #1335; earlier change: path-editing layer bounds, #1220; issue, PR and catalog references gap 21: percentage guides and effect colour labels in; earlier change: re-audited against `upstream/main` 470ea7a3; ranked gap list from the 10 October re-measure otherwise unchanged) · **Target:** Adobe After Effects 2026 (26.5.0.89)
An honest assessment of how far EffectCraft is from being a real replacement for After Effects,
and the work that closes the gap. This document is meant for contributors and agents choosing
@@@ -323,7 -335,8 +335,9 @@@ Issues #41–#47 (all from the Linux Ap
| Date | Change | Summary |
|---|---|---|
+ | 2026-10-16 | minor | Gap 8: #932 closed (Convert To Bezier Path converts a shape layer's parametric path, not only mask RotoBezier) |
+| 2026-10-13 | minor | Gap 25: an AccessKit audit test (per-panel counts, a ratchet for the unfixed panels) and a theme contrast test; Effects & Presets, Settings and Render Queue named and keyboard-operable (#1335); no screen reader tested |
+ | 2026-10-13 | patch | G2: layer bounds no longer compete with editable shape/mask path points (#1220) |
| 2026-10-12 | minor | Audited against `upstream/main` 470ea7a3: open-issue count and crash list, closed issues removed from rows 1, 3, 5, 6, 8–12, 15–17, 22–24, G8 and G9 (#759 `#include`), localization catalogs recounted (≈ 12% to ≈ 18%); rows 7, 14 and 21 left to open PRs #1102, #792 and #1098 |
| 2026-10-10 | minor | Alpha gate checked: no alpha blockers |
| 2026-10-12 | minor | Gap 21: percentage guides and effect colour labels added (#1095) |
diff --cc docs/ui-parity.md
index ae6ed5385,ccce70e0f..efd002ec9
--- a/docs/ui-parity.md
+++ b/docs/ui-parity.md
@@@ -1,6 -1,6 +1,6 @@@
# UI parity
- > **Last reviewed:** 2026-10-13 · **Last updated:** 2026-10-13 · **Change:** minor (accessibility row: an AccessKit audit and a contrast test, three more panels named and keyboard-operable, #1335; earlier change: closed issue references re-audited against `upstream/main` 470ea7a3) · **Target:** Adobe After Effects 2026
-> **Last reviewed:** 2026-10-12 · **Last updated:** 2026-10-13 · **Change:** minor (path-editing layer bounds, #1220; closed issue references re-audited against `upstream/main` 470ea7a3) · **Target:** Adobe After Effects 2026
++> **Last reviewed:** 2026-10-12 · **Last updated:** 2026-10-13 · **Change:** minor (accessibility row: an AccessKit audit and a contrast test, three more panels named and keyboard-operable, #1335; earlier change: path-editing layer bounds, #1220; closed issue references re-audited against `upstream/main` 470ea7a3) · **Target:** Adobe After Effects 2026
How closely EffectCraft's interaction matches After Effects: tools, handles, snapping, nudging,
modifier keys, shortcuts, drag behaviour, numeric entry, panels, context menus and feel. Evidence
@@@ -30,9 -30,15 +30,15 @@@ feel and platform differences, and the
| Preview feel | Spacebar / Numpad 0 previews, RAM preview, cache bars, adaptive resolution | 55% | `ui_ram_preview`, `ui_live_preview`; stutter (#595, #304); scrubbing lag (#329, closed by #784) |
| Home screen, Learn, templates | Home with recent projects, template gallery, interactive Learn tutorials | 70% | Layout nitpicks (#581); Home literals untranslated (#574) |
| Quick Apply (26.2) | Search to apply effects, presets or commands | partial | A command palette exists; not After Effects' Quick Apply |
-| Accessibility | AccessKit enabled; focus labels tested; Project panel keyboard navigation and accessible names (#776) | 20% | No screen-reader pass or keyboard-navigation audit of the other panels; no contrast check |
+| Accessibility | AccessKit enabled; `ui_accessibility_audit` counts unnamed or roleless controls per panel: Project (#776), Effects & Presets, Settings (all pages) and Render Queue with Templates are at zero, with names, roles, selected / open / checked state and arrow-key, Home / End, Enter, Space operation (#1335); `ui_contrast` checks theme tokens against WCAG 2 | 20% | No screen reader has been run on anything; the other panels are counted, not fixed (Timeline ≈ 55 unnamed controls); 13 of 48 token pairs are below WCAG 2 (primary button text, error text, control borders, Light theme warning colour); focus order across panels, colour-blindness and reduced motion are unchecked; app shortcuts pause while a widget has keyboard focus |
| UI scale | Settings ▸ Appearance ▸ UI Scale 75–200% | beyond | After Effects follows the system's scaling (#284) |
+ Path editing (#1220): the Composition viewer suppresses a selected layer’s transform box while
+ using a Pen-family tool on a visible path, or while selecting its vertices with the Selection
+ tool. Path points, Bézier handles and the path’s free-transform controls remain available.
+ Layer transform tools and ordinary layer selection restore the box. Headless `ui_viewer` tests
+ cover shape paths and masks, corner-vertex dragging and undo, and layers without visible paths.
+
## Estimate
**≈ 60–120 h**: the open interaction issues above (25–45 h, about 0.2–0.5 h each with a scripted
@@@ -44,7 -50,7 +50,8 @@@ Effects running; most of the rest paral
| Date | Change | Summary |
|---|---|---|
+| 2026-10-13 | minor | Accessibility row: AccessKit audit and contrast tests, Effects & Presets, Settings and Render Queue named and keyboard-operable (#1335); no screen reader tested |
+ | 2026-10-13 | patch | Layer bounds are suppressed during path-point editing (#1220); shape/mask interaction regressions |
| 2026-10-12 | minor | Closed issues (#302, #320, #491, #511, #553 and others) marked as closed instead of open; panels in their own windows (#486) |
| 2026-10-12 | minor | Percentage guides and effect colour labels (26.5) added; rows updated |
| 2026-10-10 | major | First UI parity checklist |