diff --git a/assets/icons/anicraft-parent.svg b/assets/icons/anicraft-parent.svg new file mode 100644 index 00000000..fac4c0b1 --- /dev/null +++ b/assets/icons/anicraft-parent.svg @@ -0,0 +1,7 @@ + + + + + + + diff --git a/docs/guide/reference/commands.md b/docs/guide/reference/commands.md index 338198d4..ccdab683 100644 --- a/docs/guide/reference/commands.md +++ b/docs/guide/reference/commands.md @@ -1,6 +1,6 @@ # Command reference -Everything you can do in AniCraft is a command: the menus, the shortcuts, the command palette (**Ctrl+K**, macOS **⌘K**), `anicraft-cli` and AI assistants over MCP all run the same 373 commands, listed here by menu. The id is what scripts and [working headless](../working-headless.md) use; the parameters are what a command takes as JSON. Commands that change the document are one undo step each. Your own shortcuts (**Help › Keyboard Shortcuts**) replace the defaults shown here; see the [shortcut reference](shortcuts.md). +Everything you can do in AniCraft is a command: the menus, the shortcuts, the command palette (**Ctrl+K**, macOS **⌘K**), `anicraft-cli` and AI assistants over MCP all run the same 376 commands, listed here by menu. The id is what scripts and [working headless](../working-headless.md) use; the parameters are what a command takes as JSON. Commands that change the document are one undo step each. Your own shortcuts (**Help › Keyboard Shortcuts**) replace the defaults shown here; see the [shortcut reference](shortcuts.md). This page is generated from the command registry, so it always matches the version of AniCraft it came with. @@ -9,7 +9,7 @@ This page is generated from the command registry, so it always matches the versi - **New** `file.new` · **Ctrl+N** (macOS **⌘N**) Parameters: `{width?, height?, fps?}` - **New from Sample** `file.new_sample` - Parameters: `{which?: demo (default) | interactive (a menu with a Play button, for Test Movie)}` + Parameters: `{which?: demo (default) | interactive (a menu with a Play button, for Test Movie) | arm (three parented layers, ADR 0113)}` - **New from Template…** `file.new_from_template` Parameters: `{template? (a built-in template's id, from file.templates) | path? (a template file: any .anicraft opens as a new, untitled document)}` - **Open…** `file.open` · **Ctrl+O** (macOS **⌘O**) @@ -164,6 +164,8 @@ This page is generated from the command registry, so it always matches the versi Parameters: `{layer?, name?, type?: normal|mask|masked|guide|guided, mask?: coverage|alpha|luminance (a mask layer's mask type), color?, outline?: bool (view as outlines), height?: 100|200|300, opacity?: 0..100 (percent), visible?, locked?, onion?} sets several at once, as one undo step; answers with the layer's properties` - **Remove Camera** `camera.remove` · Modify › Timeline · changes the document Parameters: `{} (removes the camera layer and its moves; asks first when the camera is animated)` +- **Remove Parent** `layer.remove_parent` · Modify › Timeline · changes the document + Parameters: `{layer? (default: the active layer), layers?: [ids], keep?: bool (default true)} the layer stops following its parent layer and stays where it is on stage at the playhead (layer.set_parent with parent: null)` - **Add Warp Mesh** `warp.add` · Modify › Asset Warp · changes the document Parameters: `{element? (a shape or bitmap; default the one selected), resolution? (cells along the longer side, 2…48; default 12)} → {element, created, resolution, columns, rows}. Covers the artwork with a warp mesh on every keyframe of its layer that holds it (it becomes a drawing object); on artwork that has one, changes the mesh's resolution` - **Remove Warp** `warp.remove` · Modify › Asset Warp · changes the document @@ -375,6 +377,10 @@ These commands have no menu item: the panels, the stage and the timeline use the Parameters: `{attached?: bool (default: toggles), layer?} an attached layer stays where it is on screen while the camera moves (titles, HUDs); its depth plays no part (ADR 0082)` - **Layer Depths** `layer.depths` Parameters: `{frame?} → {camera: bool, layers: [{layer, name, depth, keyed, key_here, attached}]} the layers that can have a depth, nearest first (ties in timeline order), at the frame` +- **Parent Layer** `layer.set_parent` · changes the document + Parameters: ``{parent: layer id | null (null removes the parent), layer? (default: the active layer), layers?: [ids] (several at once), keep?: bool (default true)} layer parenting (ADR 0113): the layer's artwork follows the first object on the parent layer at every frame (position, rotation, scale, skew; not colour or filters), while keeping its own keys and tweens. With `keep` the layer stays where it is on stage at the playhead: every key is re-expressed for the new parent, in one undo step. A layer can't follow itself or a layer that follows it; folders, guides, the camera and armature layers can't follow, and folders, guides and the camera can't lead`` +- **Layer Parents** `layer.parents` + Parameters: `{frame?} → {layers: [{layer, name, parent, parent_name, ancestors: [ids, nearest first], children: [ids], can_follow, can_lead, space: [a, b, c, d, tx, ty] (the layer's own coordinates → the stage's at the frame)}]} top to bottom` - **Add Bone** `bone.add` · changes the document Parameters: ``{from? (instance or shape id: the bone starts on it) | parent? (bone id: the bone starts on its end; for a bone inside a shape, on its joint), to (instance or shape id: the bone moves it as a whole), head?: [x, y] (the joint on a root, stage px, default its registration point; from something that hangs from a bone the joint is always that bone's end, so chains stay joined), tail?: [x, y] (default `to`'s registration point), name?} → {bone, layer}. Both go to an armature layer (made for the first bone). Instances and shapes mix in one armature: a bone inside a shape can carry an instance (parent), and a bone can end on a shape that then gets bones of its own (bone.add_in_shape with parent)`` - **Add Bone in Shape** `bone.add_in_shape` · changes the document diff --git a/src/a11y.rs b/src/a11y.rs index 91dfa468..e91bdf38 100644 --- a/src/a11y.rs +++ b/src/a11y.rs @@ -471,6 +471,7 @@ mod tests { a.open_panel(Some("testmovie")); })); // The layer depth row shows on artwork layers once the scene has a camera. + found.extend(check("parenting view", |a, _| a.open_panel(Some("parenting")))); found.extend(check("layer depth", |a, _| { a.open_panel(Some("camera")); a.run("layer.select", serde_json::json!({"index": 1})); diff --git a/src/app.rs b/src/app.rs index 34d95fd9..6a39c645 100644 --- a/src/app.rs +++ b/src/app.rs @@ -505,6 +505,10 @@ pub struct App { pub tl_drag: timeline::TlDrag, /// The layer being dragged by its name to another place in the stack (#407). pub tl_layer_drag: Option, + /// The layer whose dot is being dragged to its new parent layer in the parenting view + /// (ADR 0113), and where the dots were drawn this frame. + pub tl_parent_drag: Option, + pub tl_parent_dots: Vec, /// The layer column's width while its edge is dragged (#384); the preference takes it on /// release. pub tl_layer_w_drag: Option, @@ -814,6 +818,8 @@ impl App { frame_sel: None, tl_drag: timeline::TlDrag::None, tl_layer_drag: None, + tl_parent_drag: None, + tl_parent_dots: Vec::new(), tl_layer_w_drag: None, dock: prefs.workspaces.layout(), dock_view: Default::default(), @@ -2055,6 +2061,16 @@ impl App { self.raw_ends = Vec::new(); self.raw_anchors = vec![anicraft_engine::geom::Vec2::new(620.0, 270.0)]; } + Some("parenting") | Some("parentmenu") => { + // Layer parenting (ADR 0113): an arm of three parented layers, mid-tween, the + // timeline's parenting view open and the forearm selected. + self.run("file.new_sample", json!({"which": "arm"})); + self.prefs.timeline_parenting = true; + self.run("timeline.goto", json!({"frame": 12})); + let fore = self.s.timeline().layers.get(1).map(|l| l.id.0); + self.run("layer.select", json!({"layer": fore, "select": true})); + self.view.fit = true; + } Some("rawsnap") => { // Snapping while drawing (ADR 0045): a line being drawn from a corner of a raw // square, its end snapping onto the square's other corner (the ring). diff --git a/src/icons.rs b/src/icons.rs index 25898e4a..c193d8dd 100644 --- a/src/icons.rs +++ b/src/icons.rs @@ -73,6 +73,7 @@ pub enum Icon { Warp, EditMultiple, Layer, + Parent, InsertFrame, InsertKeyframe, InsertBlankKeyframe, @@ -92,7 +93,7 @@ pub enum Icon { impl Icon { #[cfg(test)] - pub const ALL: [Icon; 74] = [ + pub const ALL: [Icon; 75] = [ Icon::PanelProperties, Icon::PanelSwatches, Icon::PanelLibrary, @@ -111,6 +112,7 @@ impl Icon { Icon::InsertBlankKeyframe, Icon::Bind, Icon::Layer, + Icon::Parent, Icon::EditMultiple, Icon::Bone, Icon::Magnet, @@ -257,6 +259,9 @@ impl Icon { Icon::FolderOpen => ("folder-open", false), // A layer: a row with a keyframe and its span (AniCraft original, on Lucide's grid). Icon::Layer => ("anicraft-layer", false), + // A layer's dot joined to the layers that follow it (AniCraft original, on Lucide's + // grid): the timeline's parenting view (ADR 0113). + Icon::Parent => ("anicraft-parent", false), // Insert Frame / Keyframe / Blank Keyframe: the timeline's own marks (a frame cell, a // filled keyframe dot, a hollow blank-keyframe dot), each with a plus (AniCraft // originals, on Lucide's grid). @@ -343,6 +348,7 @@ static FILES: &[(&str, &str)] = &[ ("anicraft-camera", include_str!("../assets/icons/anicraft-camera.svg")), ("anicraft-bone", include_str!("../assets/icons/anicraft-bone.svg")), ("anicraft-bind", include_str!("../assets/icons/anicraft-bind.svg")), + ("anicraft-parent", include_str!("../assets/icons/anicraft-parent.svg")), ("anicraft-warp", include_str!("../assets/icons/anicraft-warp.svg")), ("anicraft-edit-multiple", include_str!("../assets/icons/anicraft-edit-multiple.svg")), ("folder", include_str!("../assets/icons/folder.svg")), diff --git a/src/main.rs b/src/main.rs index f063538d..26f4d844 100644 --- a/src/main.rs +++ b/src/main.rs @@ -63,6 +63,7 @@ mod mixed; mod motion_editor; mod movie_explorer; mod panels; +mod parenting; mod motion_path; mod onion; mod pathtools; @@ -479,6 +480,8 @@ mod retime_ui_tests; #[cfg(test)] mod layer_ui_tests; #[cfg(test)] +mod parenting_ui_tests; +#[cfg(test)] mod tilt_ui_tests; #[cfg(test)] mod zoom_tests; diff --git a/src/menus.rs b/src/menus.rs index 1ceea2a3..c58462e3 100644 --- a/src/menus.rs +++ b/src/menus.rs @@ -644,6 +644,9 @@ pub(crate) fn menu_contents(app: &mut App, ui: &mut egui::Ui, top: &str, cmds: & crate::onion::toggle_edit_multiple(app); } ui.menu_button(tr!("Onion Skin Options"), |ui| crate::onion::menu(app, ui)); + if ui_item(ui, tr!("Parenting View"), "", Some(app.prefs.timeline_parenting)) { + crate::parenting::toggle_view(app); + } if ui_item(ui, tr!("Clip Content Outside the Stage"), "", Some(app.view.clip_to_stage)) { app.view.clip_to_stage = !app.view.clip_to_stage; } diff --git a/src/parenting.rs b/src/parenting.rs new file mode 100644 index 00000000..687c6701 --- /dev/null +++ b/src/parenting.rs @@ -0,0 +1,202 @@ +//! The timeline's parenting view (ADR 0113): a column in the layer list where each layer has a +//! dot, joined to its parent layer's dot by a line in its colour. +//! +//! Drag from a layer's dot to another layer to parent it; click the dot (or focus it and press +//! Enter or Space) to pick the parent from a menu, or remove it. The same menu is in every +//! layer's context menu, parenting view open or not. Everything runs `layer.set_parent`, so the +//! layer stays where it is on stage and the change is one undo step. + +use crate::a11y; +use crate::app::App; +use crate::icons::{self, Icon}; +use crate::menus; +use crate::theme::{T, to_color32}; +use anicraft_engine::doc::{Layer, LayerId, Timeline}; +use egui::{Pos2, Rect, Sense, Stroke, StrokeKind, WidgetType, pos2, vec2}; +use serde_json::json; + +/// Width of one step of the tree, and the most steps drawn (deeper chains share the last). +const LANE: f32 = 9.0; +const MAX_LANES: usize = 6; +/// The dot's radius. +const DOT: f32 = 4.5; + +/// Where the parent column is in the layer list. +#[derive(Clone, Copy, Debug)] +pub struct Column { + pub left: f32, + pub right: f32, +} + +impl Column { + /// How wide the column is for `tl`: as wide as its deepest chain needs. + pub fn width(tl: &Timeline) -> f32 { + let lanes = tl.layers.iter().map(|l| tl.rig_ancestors(l.id).len()).max().unwrap_or(0).min(MAX_LANES - 1) + 1; + 2.0 * DOT + 8.0 + lanes as f32 * LANE + } + + /// The column for `tl`, ending at `right`. + pub fn new(tl: &Timeline, right: f32) -> Column { + Column { left: right - Column::width(tl), right } + } + + fn dot(&self, tl: &Timeline, layer: LayerId, y: f32) -> Pos2 { + let lane = tl.rig_ancestors(layer).len().min(MAX_LANES - 1); + pos2(self.left + DOT + 4.0 + lane as f32 * LANE, y) + } +} + +/// A layer's dot as drawn this frame. +#[derive(Clone, Copy, Debug)] +pub struct Dot { + pub layer: LayerId, + pub at: Pos2, +} + +/// The toggle beside the "Layers" heading: opens and closes the parenting view. +pub fn head_toggle(app: &mut App, ui: &mut egui::Ui, painter: &egui::Painter, rect: Rect) { + let on = app.prefs.timeline_parenting; + let r = ui.interact(rect, ui.id().with("parenting_view"), Sense::click()); + if r.hovered() || on { + painter.rect_filled(rect, T.rc(), if on { T.accent_dim } else { T.hover }); + } + icons::paint(painter, Rect::from_center_size(rect.center(), vec2(15.0, 15.0)), Icon::Parent, if on { T.accent_text } else { T.text_dim }); + a11y::control(ui, &r, WidgetType::Checkbox, tr!("Parenting view"), Some(on)); + if r.on_hover_text(tr!("Parenting View: show which layer each layer follows. Drag from a layer's dot to another layer to parent it; click the dot to pick or remove the parent")).clicked() { + toggle_view(app); + } +} + +/// Opens or closes the parenting view (kept with the preferences). +pub fn toggle_view(app: &mut App) { + let on = !app.prefs.timeline_parenting; + app.prefs.timeline_parenting = on; + app.save_prefs(); + if on { + app.status_ok(tr!("Parenting view: drag from a layer's dot to another layer, or click the dot to pick its parent")); + } +} + +/// What a screen reader hears for a layer's dot. +fn dot_name(tl: &Timeline, layer: &Layer) -> String { + match layer.rig_parent.and_then(|p| tl.layer(p)) { + Some(p) => tr!("Parent of {name}: {parent}", name = layer.name, parent = p.name), + None => tr!("Parent of {name}: none", name = layer.name), + } +} + +/// One row of the parent column: the dot's target, its name for assistive technology, the +/// start of a drag, and its menu. `None` for a layer that can neither follow nor lead. +pub fn row(app: &mut App, ui: &mut egui::Ui, tl: &Timeline, layer: &Layer, col: Column, y: f32, size: f32) -> Option { + if !layer.can_follow() && !layer.can_lead() { + return None; + } + let at = col.dot(tl, layer.id, y); + let hit = Rect::from_center_size(at, vec2(size, size)); + let r = ui.interact(hit, ui.id().with(("parent_dot", layer.id.0)), Sense::click_and_drag()); + a11y::control(ui, &r, WidgetType::Button, &dot_name(tl, layer), None); + if r.drag_started_by(egui::PointerButton::Primary) && layer.can_follow() { + app.tl_parent_drag = Some(layer.id); + } + let tip = match layer.rig_parent.and_then(|p| tl.layer(p)) { + Some(p) => tr!("{name} follows {parent}. Drag to another layer to change its parent; click to pick or remove it", name = layer.name, parent = p.name), + None if layer.can_follow() => tr!("Drag to another layer to make it the parent of {name}; click to pick one", name = layer.name), + None => tr!("{name} can lead other layers: drag from their dots to this layer", name = layer.name), + }; + let r = r.on_hover_text(tip); + let id = layer.id; + let shown = egui::Popup::menu(&r).id(egui::Id::new(("layer_parent", id.0))).show(|ui| menu(app, ui, id)); + if let Some(m) = shown { + ui.ctx().accesskit_node_builder(m.response.id, |node| { + node.set_role(egui::accesskit::Role::Menu); + node.set_label(tr!("Parent layer")); + }); + } + Some(Dot { layer: id, at }) +} + +/// The parent picker: no parent, then every layer, the ones this layer can't follow greyed. +pub fn menu(app: &mut App, ui: &mut egui::Ui, layer: LayerId) { + ui.set_min_width(180.0); + let tl = app.s.timeline().clone(); + let Some(me) = tl.layer(layer) else { return }; + if !me.can_follow() { + ui.add_enabled(false, egui::Button::new(tr!("This kind of layer can't follow a parent"))); + return; + } + if menus::check_item(ui, tr!("No Parent"), me.rig_parent.is_none(), true) && me.rig_parent.is_some() { + app.run("layer.remove_parent", json!({"layer": layer.0})); + } + ui.separator(); + for cand in tl.layers.iter().filter(|l| l.id != layer && l.can_lead()) { + let current = me.rig_parent == Some(cand.id); + let ok = current || tl.rig_check(layer, cand.id).is_ok(); + if menus::check_item(ui, &cand.name, current, ok) && !current { + app.run("layer.set_parent", json!({"layer": layer.0, "parent": cand.id.0})); + } + } +} + +/// After the rows: the tree's lines and dots, and a dot being dragged to its new parent. +/// `rows` are the layer rows on screen; `left` is the layer list's area. +pub fn finish(app: &mut App, ui: &mut egui::Ui, painter: &egui::Painter, tl: &Timeline, dots: &[Dot], rows: &[(Rect, LayerId)], left: Rect) { + let at = |id: LayerId| dots.iter().find(|d| d.layer == id).map(|d| d.at); + let p = painter.with_clip_rect(left); + // Lines first, each in the follower's colour: down (or up) the parent's lane, then across. + for d in dots { + let Some(layer) = tl.layer(d.layer) else { continue }; + let Some(parent) = layer.rig_parent else { continue }; + let stroke = Stroke::new(1.5, to_color32(layer.color)); + match at(parent) { + Some(from) => { + p.line_segment([from, pos2(from.x, d.at.y)], stroke); + p.line_segment([pos2(from.x, d.at.y), d.at], stroke); + } + // Its parent's row isn't showing (scrolled away, or in a closed folder): a stub. + None => { + p.line_segment([pos2(d.at.x - LANE, d.at.y), d.at], stroke); + } + } + } + for d in dots { + let Some(layer) = tl.layer(d.layer) else { continue }; + let c = to_color32(layer.color); + let linked = layer.rig_parent.is_some() || tl.layers.iter().any(|l| l.rig_parent == Some(layer.id)); + if linked { + p.circle_filled(d.at, DOT, c); + p.circle_stroke(d.at, DOT, Stroke::new(1.0, T.panel)); + } else { + // A free layer: a ring, so a rig's dots stand out. + p.circle_filled(d.at, DOT, T.panel); + p.circle_stroke(d.at, DOT - 0.5, Stroke::new(1.5, if layer.can_follow() { c } else { T.text_faint })); + } + } + let Some(dragged) = app.tl_parent_drag else { return }; + let (pointer, down, cancel) = ui.input(|i| (i.pointer.latest_pos(), i.pointer.primary_down(), i.key_pressed(egui::Key::Escape))); + let Some(from) = at(dragged).filter(|_| !cancel) else { + app.tl_parent_drag = None; + return; + }; + let over = pointer.filter(|q| left.contains(*q)).and_then(|q| rows.iter().find(|(r, _)| q.y >= r.top() && q.y < r.bottom())).map(|(r, id)| (*r, *id)).filter(|(_, id)| *id != dragged); + if !down { + app.tl_parent_drag = None; + // The engine says why when the layer can't follow that one (shown in the status bar). + if let Some((_, target)) = over { + app.run("layer.set_parent", json!({"layer": dragged.0, "parent": target.0})); + } + return; + } + let ok = over.is_some_and(|(_, t)| tl.rig_check(dragged, t).is_ok()); + ui.ctx().set_cursor_icon(if ok { egui::CursorIcon::Grabbing } else if over.is_some() { egui::CursorIcon::NoDrop } else { egui::CursorIcon::Grabbing }); + if let Some((r, _)) = over.filter(|_| ok) { + let band = Rect::from_min_max(pos2(left.left(), r.top()), pos2(left.right(), r.bottom())); + painter.rect_filled(band, 0.0, T.accent.gamma_multiply(0.22)); + painter.rect_stroke(band, 0.0, Stroke::new(1.0, T.accent), StrokeKind::Inside); + } + if let Some(q) = pointer { + let c = tl.layer(dragged).map_or(T.accent, |l| to_color32(l.color)); + painter.line_segment([from, q], Stroke::new(2.0, c)); + painter.circle_filled(q, 3.0, c); + } + ui.ctx().request_repaint(); +} diff --git a/src/parenting_ui_tests.rs b/src/parenting_ui_tests.rs new file mode 100644 index 00000000..9e7588ae --- /dev/null +++ b/src/parenting_ui_tests.rs @@ -0,0 +1,158 @@ +//! The timeline's parenting view (ADR 0113), driven by pointer events and by assistive +//! technology: a dot dragged to another layer parents it, a cycle is refused, and every dot is a +//! named button whose menu picks the parent without a pointer. + +use crate::app::App; +use anicraft_engine::doc::LayerId; +use egui::accesskit::{Action, ActionRequest, Node, Role, TreeId}; +use egui::{Event, Modifiers, PointerButton, Pos2, Rect, pos2, vec2}; +use serde_json::json; + +/// The arm sample with its links removed (the limbs where they stand), parenting view open. +fn opened() -> (App, egui::Context) { + let ctx = egui::Context::default(); + ctx.enable_accesskit(); + let mut session = anicraft_engine::Session::new(anicraft_engine::doc::sample::arm()); + let ids: Vec = session.timeline().layers.iter().map(|l| l.id.0).collect(); + session.execute("layer.remove_parent", &json!({"layers": ids})).expect("unparented"); + let mut app = App::with_context(&ctx, session, Some(std::path::PathBuf::from("unused.png"))); + app.prefs.timeline_parenting = true; + settle(&ctx, &mut app); + (app, ctx) +} + +fn frame(ctx: &egui::Context, app: &mut App, events: Vec) -> Vec<(egui::accesskit::NodeId, Node)> { + let mut all = vec![Event::ModifiersChanged(Modifiers::NONE)]; + all.extend(events); + let input = egui::RawInput { screen_rect: Some(Rect::from_min_size(Pos2::ZERO, vec2(1600.0, 940.0))), events: all, ..Default::default() }; + let mut out = ctx.run_ui(input, |ui| app.frame(ui)); + out.textures_delta.clear(); + out.platform_output.accesskit_update.map(|u| u.nodes).unwrap_or_default() +} + +fn settle(ctx: &egui::Context, app: &mut App) -> Vec<(egui::accesskit::NodeId, Node)> { + let mut nodes = Vec::new(); + for _ in 0..3 { + nodes = frame(ctx, app, Vec::new()); + } + nodes +} + +fn button(pos: Pos2, pressed: bool) -> Event { + Event::PointerButton { pos, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE } +} + +fn drag(ctx: &egui::Context, app: &mut App, from: Pos2, to: Pos2) { + frame(ctx, app, vec![Event::PointerMoved(from)]); + frame(ctx, app, vec![button(from, true)]); + for i in 1..=10 { + frame(ctx, app, vec![Event::PointerMoved(from + (to - from) * (i as f32 / 10.0))]); + } + frame(ctx, app, vec![button(to, false)]); + settle(ctx, app); +} + +fn layer(app: &App, name: &str) -> LayerId { + app.s.timeline().layers.iter().find(|l| l.name == name).map(|l| l.id).expect("the layer") +} + +fn parent(app: &App, name: &str) -> Option { + let tl = app.s.timeline(); + tl.layer(layer(app, name)).and_then(|l| l.rig_parent).and_then(|p| tl.layer(p)).map(|l| l.name.clone()) +} + +fn dot(app: &App, name: &str) -> Pos2 { + let id = layer(app, name); + app.tl_parent_dots.iter().find(|d| d.layer == id).map(|d| d.at).expect("its dot shows") +} + +/// A point on the layer's name. +fn on_row(app: &App, name: &str) -> Pos2 { + let geo = app.drop.timeline.as_ref().expect("the timeline is drawn"); + let id = layer(app, name); + let r = geo.rows.iter().find(|(_, l)| *l == id).map(|(r, _)| *r).expect("its row shows"); + pos2(r.left() + 60.0, r.center().y) +} + +/// Where the layer's object shows on stage at the playhead. +fn shown(app: &App, name: &str) -> anicraft_engine::geom::Affine { + let id = layer(app, name); + app.s.display_list().items.iter().find(|i| i.layer == id).map(|i| i.transform).expect("it shows") +} + +#[test] +fn a_dot_dragged_to_another_layer_parents_it_in_one_undo_step() { + let (mut app, ctx) = opened(); + assert_eq!(app.tl_parent_dots.len(), 3, "every layer with artwork has a dot"); + let before = shown(&app, "Forearm"); + let steps = app.s.info()["history"]["undo"].as_u64().unwrap_or(0); + let (from, to) = (dot(&app, "Forearm"), on_row(&app, "Upper arm")); + drag(&ctx, &mut app, from, to); + assert_eq!(parent(&app, "Forearm").as_deref(), Some("Upper arm")); + assert_eq!(app.s.info()["history"]["undo"].as_u64().unwrap_or(0), steps + 1, "one step"); + // It stays where it was on stage. + let after = shown(&app, "Forearm"); + assert!(before.m.iter().zip(after.m).all(|(a, b)| (a - b).abs() < 1e-2), "{before:?} → {after:?}"); + // A chain: the hand onto the forearm; its dot moves one lane in. + let (from, to) = (dot(&app, "Hand"), on_row(&app, "Forearm")); + drag(&ctx, &mut app, from, to); + assert_eq!(parent(&app, "Hand").as_deref(), Some("Forearm")); + assert!(dot(&app, "Hand").x > dot(&app, "Forearm").x && dot(&app, "Forearm").x > dot(&app, "Upper arm").x, "the tree steps in with each link"); + assert!(app.tl_parent_drag.is_none()); +} + +#[test] +fn a_drop_on_a_follower_or_on_nothing_changes_nothing() { + let (mut app, ctx) = opened(); + let (from, to) = (dot(&app, "Forearm"), on_row(&app, "Upper arm")); + drag(&ctx, &mut app, from, to); + let doc = app.s.doc.clone(); + // The upper arm can't follow the forearm that follows it: refused, and said so. + let (from, to) = (dot(&app, "Upper arm"), on_row(&app, "Forearm")); + drag(&ctx, &mut app, from, to); + assert_eq!(app.s.doc, doc); + assert!(app.status.as_ref().is_some_and(|s| s.error && s.text.contains("follows")), "{:?}", app.status.as_ref().map(|s| s.text.clone())); + // Released away from the layers, or back on itself: nothing. + let from = dot(&app, "Hand"); + drag(&ctx, &mut app, from, pos2(900.0, 300.0)); + let (from, to) = (dot(&app, "Hand"), on_row(&app, "Hand")); + drag(&ctx, &mut app, from, to); + assert_eq!(app.s.doc, doc); + assert!(app.tl_parent_drag.is_none()); +} + +#[test] +fn the_view_closes_and_the_column_goes() { + let (mut app, ctx) = opened(); + crate::parenting::toggle_view(&mut app); + settle(&ctx, &mut app); + assert!(!app.prefs.timeline_parenting && app.tl_parent_dots.is_empty()); +} + +fn named<'a>(nodes: &'a [(egui::accesskit::NodeId, Node)], label: &str) -> Option<&'a (egui::accesskit::NodeId, Node)> { + nodes.iter().find(|(_, n)| n.label().is_some_and(|l| l.trim() == label)) +} + +#[test] +fn every_dot_is_a_named_button_and_its_menu_picks_the_parent_without_a_pointer() { + let (mut app, ctx) = opened(); + let nodes = settle(&ctx, &mut app); + let toggle = named(&nodes, "Parenting view").expect("the view's toggle is named"); + assert_eq!(toggle.1.role(), Role::CheckBox); + for l in ["Hand", "Forearm", "Upper arm"] { + let n = named(&nodes, &format!("Parent of {l}: none")).unwrap_or_else(|| panic!("no dot named for {l}")); + assert_eq!(n.1.role(), Role::Button); + assert!(n.1.supports_action(Action::Focus) && n.1.supports_action(Action::Click), "{l}: reachable and pressable by keyboard"); + } + // Pressing the hand's dot opens its menu; choosing the forearm there parents it. + let request = |id, action| Event::AccessKitActionRequest(ActionRequest { action, target_tree: TreeId::ROOT, target_node: id, data: None }); + let hand = named(&nodes, "Parent of Hand: none").map(|n| n.0).expect("the dot"); + frame(&ctx, &mut app, vec![request(hand, Action::Click)]); + let nodes = settle(&ctx, &mut app); + assert!(named(&nodes, "✔ No Parent").is_some(), "the menu is open, No Parent ticked"); + let pick = named(&nodes, "Forearm").map(|n| n.0).expect("the forearm is offered"); + frame(&ctx, &mut app, vec![request(pick, Action::Click)]); + let nodes = settle(&ctx, &mut app); + assert_eq!(parent(&app, "Hand").as_deref(), Some("Forearm")); + assert!(named(&nodes, "Parent of Hand: Forearm").is_some(), "the dot says what it follows"); +} diff --git a/src/prefs.rs b/src/prefs.rs index 6a8b493f..16966290 100644 --- a/src/prefs.rs +++ b/src/prefs.rs @@ -132,6 +132,8 @@ pub struct Prefs { /// How wide the timeline's layer column is, in points: the line between the layers and /// the frames drags (#384). A narrow dock still takes what it needs for the frames. pub timeline_layer_w: f32, + /// The timeline's parenting view (ADR 0113): the layer list shows each layer's parent. + pub timeline_parenting: bool, /// Keyboard shortcuts the user changed: action id → its full list of keys (empty = /// unbound). Actions not listed keep their defaults (`keymap`). pub shortcuts: std::collections::BTreeMap>, @@ -242,6 +244,7 @@ impl Default for Prefs { timeline_start_gap: 0.0, timeline_short_rows: false, timeline_layer_w: LAYER_W_DEFAULT, + timeline_parenting: false, shortcuts: Default::default(), autosave: true, autosave_secs: 60, diff --git a/src/timeline.rs b/src/timeline.rs index eda0070c..88d6bc0a 100644 --- a/src/timeline.rs +++ b/src/timeline.rs @@ -474,7 +474,9 @@ pub fn show(app: &mut App, ui: &mut egui::Ui) { // In a narrow dock (ADR 0087) the layer column gives up width to keep a strip of frames; // the layers' toggles stay whole and their names are cut short. // Its width is the user's (the line between the layers and the frames drags, #384). - let layer_w = app.tl_layer_w_drag.unwrap_or(app.prefs.timeline_layer_w).min(body.width() - MIN_FRAMES_W).max(MIN_LAYER_W); + // The parenting view's column (ADR 0113) is added to it while open, so names keep their room. + let parent_w = if app.prefs.timeline_parenting { crate::parenting::Column::width(app.s.timeline()) } else { 0.0 }; + let layer_w = (app.tl_layer_w_drag.unwrap_or(app.prefs.timeline_layer_w) + parent_w).min(body.width() - MIN_FRAMES_W).max(MIN_LAYER_W); let grid = Rect::from_min_max(pos2(body.left() + layer_w, body.top()), body.right_bottom()); let frames_total = app.s.frame_count(); app.tl_cell_w = app.tl_cell_w.clamp(*CELL_RANGE.start(), *CELL_RANGE.end()); @@ -578,7 +580,12 @@ pub fn show(app: &mut App, ui: &mut egui::Ui) { let ruler = Rect::from_min_max(grid.left_top(), pos2(grid.right(), grid.top() + RULER_H)); painter.rect_filled(ruler, 0.0, T.panel_alt); painter.rect_filled(Rect::from_min_max(body.left_top(), pos2(grid.left(), ruler.bottom())), 0.0, T.panel_alt); - painter.text(pos2(body.left() + 10.0, ruler.center().y), Align2::LEFT_CENTER, tr!("Layers"), font(Type::Heading), color(Type::Heading)); + let heading = painter.text(pos2(body.left() + 10.0, ruler.center().y), Align2::LEFT_CENTER, tr!("Layers"), font(Type::Heading), color(Type::Heading)); + // The parenting view's toggle sits beside the heading, as in Animate (ADR 0113). + { + let side = TOGGLE.min(RULER_H); + crate::parenting::head_toggle(app, ui, &painter, Rect::from_center_size(pos2(heading.right() + 8.0 + side * 0.5, ruler.center().y), vec2(side, side))); + } // The eye, the padlock and the square above the columns they head show, lock or outline // every layer at once, as in Animate (#422). Each shows its other face once every layer // is that way, and the next click brings them all back. @@ -678,6 +685,15 @@ pub fn show(app: &mut App, ui: &mut egui::Ui) { let rows_top = ruler.bottom(); let rows_bottom = body.bottom() - FOOTER_H; let tl_now = app.s.timeline().clone(); + // The parenting view (ADR 0113): a column of dots left of the toggles, the same place on + // every row (a row has at most six toggles). + let parent_col = app.prefs.timeline_parenting.then(|| { + // Left of the leftmost toggle any row of this timeline has: eye, lock, outline and onion, + // a speaker when a layer has sounds, the camera's attach toggle when there is a camera. + let most = 3.0 + f32::from(u8::from(tl_now.layers.iter().any(|l| l.has_sounds()))) + f32::from(u8::from(tl_now.camera_layer().is_some() && app.s.editing.is_empty())); + crate::parenting::Column::new(&tl_now, grid.left() - 16.0 - most * (TOGGLE + 2.0) - TOGGLE * 0.5 - 4.0) + }); + let mut parent_dots: Vec = Vec::new(); let mut next_y = rows_top; // Where each row is, for files dropped on a layer's frame (ADR 0065). let mut drop_rows = Vec::new(); @@ -788,7 +804,17 @@ pub fn show(app: &mut App, ui: &mut egui::Ui) { } else { painter.rect_filled(sw, 0.0, to_color32(layer.color)); } - let name_rect = Rect::from_min_max(left.left_top(), pos2(attach_t.or(speaker).or(onion_t).unwrap_or(eye).left() - 4.0, left.bottom())); + let name_end = match parent_col { + Some(col) => col.left - 2.0, + None => attach_t.or(speaker).or(onion_t).unwrap_or(eye).left() - 4.0, + }; + let name_rect = Rect::from_min_max(left.left_top(), pos2(name_end.max(left.left() + 8.0), left.bottom())); + if let Some(col) = parent_col { + // The name gives way to the column: what is under it is painted over. + let until = attach_t.or(speaker).or(onion_t).unwrap_or(eye).left() - 1.0; + painter.rect_filled(Rect::from_min_max(pos2(col.left - 2.0, left.top()), pos2(until.max(col.right), left.bottom())), 0.0, if is_active { T.accent_dim } else if r % 2 == 0 { T.panel } else { T.panel_alt }); + parent_dots.extend(crate::parenting::row(app, ui, &tl_now, layer, col, left.center().y, tg)); + } // The name is the row's handle too: drag it to move the layer (#407). The camera stays // on top. let nr = ui.interact(name_rect, ui.id().with(("lname", layer.id.0)), if layer.kind == LayerKind::Camera { Sense::click() } else { Sense::click_and_drag() }); @@ -968,6 +994,10 @@ pub fn show(app: &mut App, ui: &mut egui::Ui) { crate::layer_props::open(app, Some(layer.id)); ui.close(); } + // Layer parenting (ADR 0113): the layer follows the object on its parent layer. + if layer.can_follow() { + ui.menu_button(tr!("Parent"), |ui| crate::parenting::menu(app, ui, layer.id)); + } ui.separator(); // Layer type, as check items: Mask (masks the layer below) and Masked. if menus::check_item(ui, tr!("Mask"), layer.kind == LayerKind::Mask, !is_folder) { @@ -1412,6 +1442,14 @@ pub fn show(app: &mut App, ui: &mut egui::Ui) { }); painter.line_segment([row.left_bottom(), row.right_bottom()], Stroke::new(1.0, T.separator)); } + // The parenting view's tree, and a dot being dragged to its new parent (ADR 0113). + if parent_col.is_some() { + let list = Rect::from_min_max(pos2(body.left(), rows_top), pos2(grid.left(), rows_bottom)); + crate::parenting::finish(app, ui, &painter, &tl_now, &parent_dots, &drop_rows, list); + } else { + app.tl_parent_drag = None; + } + app.tl_parent_dots = parent_dots; // A layer dragged by its name (#407): a line shows where it will land, a folder lights up // when it goes inside. Released there it moves in one undo step; Esc, or a release away // from the layers, leaves it where it was. @@ -1501,7 +1539,7 @@ pub fn show(app: &mut App, ui: &mut egui::Ui) { if sr.dragged() && let Some(p) = sr.interact_pointer_pos() { - app.tl_layer_w_drag = Some((p.x - body.left()).clamp(*range.start(), *range.end())); + app.tl_layer_w_drag = Some((p.x - body.left() - parent_w).clamp(*range.start(), *range.end())); } let set = if sr.double_clicked() { app.tl_layer_w_drag = None;