DesignCraft: An open-source page and layout design editor written by scratch in pure Rust
Layers: group members move with their group; no-op reorders leave history alone; Cmd for locked layers
aionggb84a58391fb4
diff --git a/crates/engine/src/cmd/object.rs b/crates/engine/src/cmd/object.rsindex 64ed1a827..770663aae 100644--- a/crates/engine/src/cmd/object.rs+++ b/crates/engine/src/cmd/object.rs@@ -792,16 +792,21 @@ pub fn specs() -> Vec<CommandSpec> {}Ok(json!({"ids": ids}))}),- cmd!("object.setLayer", "Move to Layer", [], None, "{layer, ids?}", has_selection, |s, p| {- let l = designcraft_doc::LayerId(p.get("layer").and_then(Value::as_u64).unwrap_or(0));- set_flag(s, p, move |i| i.layer = l, false)- }),+ cmd!(+ "object.setLayer",+ "Move to Layer",+ [],+ None,+ "{layer, ids?} — a group member moves its whole top-level group",+ has_selection,+ set_layer+ ),cmd!("object.reorder","Reorder Objects",[],None,- "{ids?, above?: id | below?: id | index?: n (0 = top of the layer), layer?} — moves the objects (siblings on one spread) in the stacking order: in front of `above` or behind `below` (onto that object's layer), or to `index` in `layer` counted from the top (default: the first object's layer, index 0). Group members stay in their group.",+ "{ids?, above?: id | below?: id | index?: n (0 = top of the layer), layer?} — moves the objects (siblings on one spread) in the stacking order: in front of `above` or behind `below` (onto that object's layer), or to `index` in `layer` counted from the top (default: the first object's layer, index 0). Group members stay in their group. Leaves the document (and undo history) alone when nothing would change.",has_doc,reorder),@@ -1342,7 +1347,8 @@ fn reorder(s: &mut Session, p: &Value) -> Result<Value> {return Err(bad(C, "give only one of above, below and index"));}let target = above.map(|t| (t, true)).or(below.map(|t| (t, false)));- s.edit(|d, _| {+ let d = s.doc()?.doc.clone();+ let (spread, parent, new_items) = {let no_object = |id: ItemId| bad(C, format!("no object {}", id.0));let loc = d.find(first).ok_or_else(|| no_object(first))?;let Some((_, parent)) = loc.path.split_last() else { return Err(no_object(first)) };@@ -1394,7 +1400,8 @@ fn reorder(s: &mut Session, p: &Value) -> Result<Value> {{return Err(bad(C, "group members stay on their group's layer"));}- let items = siblings_mut(d, loc.spread, &parent).ok_or_else(|| no_object(first))?;+ let items = d.spread(loc.spread).map(|sp| sp.items.clone()).ok_or_else(|| no_object(first))?;+ let items = parent.iter().try_fold(items, |items, &i| items.get(i).map(|g| g.children().to_vec())).ok_or_else(|| no_object(first))?;// Moved objects keep their relative stacking order.let moved: Vec<Arc<Item>> = items.iter().filter(|i| ids.contains(&i.id)).cloned().collect();let rest: Vec<Arc<Item>> = items.iter().filter(|i| !ids.contains(&i.id)).cloned().collect();@@ -1419,16 +1426,62 @@ fn reorder(s: &mut Session, p: &Value) -> Result<Value> {};let (back, front) = rest.split_at(at.min(rest.len()));let moved = moved.into_iter().map(|mut it| {- if !in_group {- Arc::make_mut(&mut it).layer = target_layer;+ if !in_group && it.layer != target_layer {+ set_layer_deep(Arc::make_mut(&mut it), target_layer, 0);}it});- *items = back.iter().cloned().chain(moved).chain(front.iter().cloned()).collect();+ let new_items: Vec<Arc<Item>> = back.iter().cloned().chain(moved).chain(front.iter().cloned()).collect();+ if new_items.iter().zip(items.iter()).all(|(a, b)| a.id == b.id && a.layer == b.layer) {+ return ok();+ }+ (loc.spread, parent, new_items)+ };+ s.edit(|d, _| {+ let items = siblings_mut(d, spread, &parent).ok_or_else(|| bad(C, "the objects moved"))?;+ *items = new_items;ok()})}+/// Sets the layer of `it` and its group members (nesting is bounded).+fn set_layer_deep(it: &mut Item, l: designcraft_doc::LayerId, depth: usize) {+ it.layer = l;+ if depth < 64+ && let Some(kids) = it.children_mut()+ {+ for k in kids {+ set_layer_deep(Arc::make_mut(k), l, depth + 1);+ }+ }+}++/// `object.setLayer`: moves the objects, or the top-level groups of group members, to a layer.+fn set_layer(s: &mut Session, p: &Value) -> Result<Value> {+ const C: &str = "object.setLayer";+ let l = designcraft_doc::LayerId(p.get("layer").and_then(Value::as_u64).ok_or_else(|| bad(C, "missing layer"))?);+ let ids = targets(s, p)?;+ s.edit(|d, _| {+ if d.layer(l).is_none() {+ return Err(bad(C, "no such layer"));+ }+ let mut tops: Vec<ItemId> = Vec::new();+ for id in &ids {+ if let Some(t) = d.top_level_of(*id)+ && !tops.contains(&t)+ {+ tops.push(t);+ }+ }+ for t in &tops {+ if let Some(it) = d.item_mut(*t) {+ set_layer_deep(it, l, 0);+ }+ }+ Ok(json!({"changed": tops.len()}))+ })+}+fn group(s: &mut Session, p: &Value) -> Result<Value> {let ids = targets(s, p)?;if ids.len() < 2 {@@ -2895,6 +2948,14 @@ mod reorder_tests {// The bottom of a layer is index = its count.s.execute("object.reorder", &json!({"ids": [b], "index": 3})).unwrap();assert_eq!(stack(&s, l1), [c, y, x, b]);+ // A reorder that changes nothing adds no undo step.+ let undo = |s: &Session| s.doc().unwrap().history.undo.len();+ let steps = undo(&s);+ s.execute("object.reorder", &json!({"ids": [x], "index": 2})).unwrap();+ s.execute("object.reorder", &json!({"ids": [y], "above": x})).unwrap();+ s.execute("object.reorder", &json!({"ids": [c], "layer": l1, "index": 0})).unwrap();+ assert_eq!(stack(&s, l1), [c, y, x, b]);+ assert_eq!(undo(&s), steps);// One undo step per reorder.s.execute("edit.undo", &json!({})).unwrap();assert_eq!(stack(&s, l1), [b, c, y, x]);@@ -2920,4 +2981,18 @@ mod reorder_tests {assert!(s.execute("object.reorder", &json!({"ids": [a, c], "index": 0})).is_err(), "mixed parents");assert_eq!(*s.doc().unwrap().doc, *before);}++ #[test]+ fn moving_a_group_member_to_a_layer_moves_its_group() {+ let mut s = Session::new();+ s.execute("file.new", &json!({})).unwrap();+ let (a, b) = (frame(&mut s), frame(&mut s));+ let g = s.execute("object.group", &json!({"ids": [a, b]})).unwrap()["id"].as_u64().unwrap();+ let art = s.execute("layer.new", &json!({"name": "Art"})).unwrap()["id"].as_u64().unwrap();+ let r = s.execute("object.setLayer", &json!({"ids": [a, b], "layer": art})).unwrap();+ assert_eq!(r["changed"], 1, "the group, once");+ let d = &s.doc().unwrap().doc;+ assert!([g, a, b].iter().all(|i| d.item(ItemId(*i)).unwrap().layer.0 == art));+ assert!(s.execute("object.setLayer", &json!({"ids": [a], "layer": 999})).is_err());+ }}diff --git a/crates/ui-egui/src/panels/layers.rs b/crates/ui-egui/src/panels/layers.rsindex 6121bb210..0abe12c9d 100644--- a/crates/ui-egui/src/panels/layers.rs+++ b/crates/ui-egui/src/panels/layers.rs@@ -3,7 +3,9 @@//! lock columns per layer and per object and a selection square in the layer colour. Drag a//! layer row to reorder layers, an object row to restack it or move it to another layer (group//! members restack within their group), and a filled selection square onto another layer to move-//! the selection there.+//! the selection there. A selected row drags the selected objects that share its parent (for a+//! top-level row, those on its layer). Locked and hidden layers take drops only with Cmd/Ctrl+//! held.use designcraft_doc::{Content, Document, Item, ItemId, LayerId};use egui::{Color32, Rect, Sense, Stroke, StrokeKind, Ui, pos2, vec2};@@ -144,6 +146,8 @@ struct Row {layer: LayerId,/// Index of `layer` in `doc.layers`.layer_index: usize,+ /// The layer is locked or hidden.+ closed: bool,kind: RowKind,/// Bottom of the row's block: the last row of an open layer or group, else the row itself.end: f32,@@ -155,9 +159,13 @@ enum Indicator {}/// The drop for `drag` with the pointer at `p`, and how to show it. `None` where it can't land.-fn drop_target(drag: &LayersDrag, rows: &[Row], p: egui::Pos2) -> Option<(DropAt, Indicator)> {+/// Objects land on a locked or hidden layer only with `force` (Cmd/Ctrl held).+fn drop_target(drag: &LayersDrag, rows: &[Row], p: egui::Pos2, force: bool) -> Option<(DropAt, Indicator)> {let r = rows.iter().find(|r| r.rect.contains(p))?;let header = rows.iter().find(|h| h.layer == r.layer && matches!(h.kind, RowKind::Layer))?;+ if r.closed && !force && !matches!(drag, LayersDrag::Layer(_)) {+ return None;+ }match drag {LayersDrag::Layer(src) => {let before = p.y < (header.rect.min.y + header.end) / 2.0;@@ -190,8 +198,15 @@ fn drop_command(drag: &LayersDrag, at: DropAt, doc: &Document, selected: &[ItemISome(("layer.move", json!({"id": id.0, "to": to})))}(LayersDrag::Selection, DropAt::OntoLayer(l)) => {- let moves = selected.iter().any(|i| doc.item(*i).is_some_and(|it| it.layer != l));- moves.then(|| ("object.setLayer", json!({"layer": l.0, "ids": ids(selected)})))+ // Group members move with their group.+ let mut tops: Vec<ItemId> = Vec::new();+ for t in selected.iter().filter_map(|i| doc.top_level_of(*i)) {+ if !tops.contains(&t) {+ tops.push(t);+ }+ }+ let moves = tops.iter().any(|i| doc.item(*i).is_some_and(|it| it.layer != l));+ moves.then(|| ("object.setLayer", json!({"layer": l.0, "ids": ids(&tops)})))}(LayersDrag::Objects { ids: o, .. }, DropAt::OntoLayer(l)) => Some(("object.reorder", json!({"ids": ids(o), "layer": l.0, "index": 0}))),(LayersDrag::Objects { ids: o, .. }, DropAt::Object { id, above }) => {@@ -213,6 +228,7 @@ struct Listing<'a> {layer_index: usize,layer_color: Color32,layer_visible: bool,+ layer_closed: bool,}/// Rows for `items` (topmost first) under `group` at `depth`; the commands their clicks run go@@ -254,7 +270,8 @@ fn object_rows(if it.hidden { t.text_dim } else { t.text },);let sq = selection_square(ui, ls.language, row, ls.layer_color, is_sel, true, ("item", it.id.0)).clicked();- // Dragging a selected row drags the selected objects that share its parent.+ // Dragging a selected row drags the selected objects that share its parent (top-level+ // rows: those on this layer).let dragged: Vec<ItemId> = if is_sel {let siblings: &[std::sync::Arc<Item>] = items;siblings.iter().map(|i| i.id).filter(|i| ls.selected.contains(i)).collect()@@ -276,7 +293,14 @@ fn object_rows(cmds.push(("selection.set", json!({"ids": [it.id.0], "add": add})));}let at = rows.len();- rows.push(Row { rect: row, layer: ls.layer, layer_index: ls.layer_index, kind: RowKind::Object { id: it.id, group }, end: row.max.y });+ rows.push(Row {+ rect: row,+ layer: ls.layer,+ layer_index: ls.layer_index,+ closed: ls.layer_closed,+ kind: RowKind::Object { id: it.id, group },+ end: row.max.y,+ });if open {object_rows(ui, ls, it.children(), Some(it.id), depth + 1, rows, cmds);let end = rows.last().map_or(row.max.y, |r| r.end.max(r.rect.max.y));@@ -393,14 +417,22 @@ pub fn show(app: &mut DesignApp, ui: &mut Ui) {}});let at = rows.len();- rows.push(Row { rect: row, layer: l.id, layer_index: li, kind: RowKind::Layer, end: row.max.y });+ rows.push(Row { rect: row, layer: l.id, layer_index: li, closed: l.locked || !l.visible, kind: RowKind::Layer, end: row.max.y });if !open {continue;}// The layer's objects keep their spread order; the panel lists them topmost first.let on_layer: Vec<std::sync::Arc<Item>> = spread_items.iter().filter(|i| i.layer == l.id).cloned().collect();- let ls =- Listing { doc: &doc, language: &language, selected: &selected, layer: l.id, layer_index: li, layer_color: lc, layer_visible: l.visible };+ let ls = Listing {+ doc: &doc,+ language: &language,+ selected: &selected,+ layer: l.id,+ layer_index: li,+ layer_color: lc,+ layer_visible: l.visible,+ layer_closed: l.locked || !l.visible,+ };object_rows(ui, &ls, &on_layer, None, 0, &mut rows, &mut cmds);let end = rows.last().map_or(row.max.y, |r| r.end.max(r.rect.max.y));if let Some(r) = rows.get_mut(at) {@@ -411,7 +443,7 @@ pub fn show(app: &mut DesignApp, ui: &mut Ui) {// one command on release.if let Some(drag) = egui::DragAndDrop::payload::<LayersDrag>(ui.ctx())&& let Some(p) = ui.ctx().pointer_latest_pos()- && let Some((at, indicator)) = drop_target(&drag, &rows, p)+ && let Some((at, indicator)) = drop_target(&drag, &rows, p, ui.input(|i| i.modifiers.command)){let x = ui.max_rect().x_range();match indicator {@@ -548,6 +580,30 @@ mod tests {assert_eq!(layer_of(&h, a), l1);}+ #[test]+ fn locked_layers_take_drops_with_cmd_and_group_members_move_with_their_group() {+ let mut app = app();+ let l1 = app.session.active().unwrap().active_layer;+ let a = app.run("frame.create", json!({"rect": [0, 0, 10, 10]})).unwrap()["id"].as_u64().unwrap();+ let b = app.run("frame.create", json!({"rect": [0, 0, 10, 10]})).unwrap()["id"].as_u64().unwrap();+ let g = app.run("object.group", json!({"ids": [a, b]})).unwrap()["id"].as_u64().unwrap();+ let art = LayerId(app.run("layer.new", json!({"name": "Art"})).unwrap()["id"].as_u64().unwrap());+ app.run("layer.set", json!({"id": art.0, "locked": true})).unwrap();+ // Select a group member directly.+ app.run("selection.set", json!({"ids": [a]})).unwrap();+ let mut h = panel(app);+ let layer_of =+ |h: &egui_kittest::Harness<'static, DesignApp>, id: u64| h.state().session.active().unwrap().doc.item(ItemId(id)).unwrap().layer;+ // Rows: Art (open, empty), Layer 1. Without Cmd the locked layer refuses the drop.+ drag(&mut h, row(1, 0.5, true), row(0, 0.5, false));+ assert_eq!(layer_of(&h, g), l1);+ h.event(egui::Event::ModifiersChanged(egui::Modifiers::COMMAND));+ drag(&mut h, row(1, 0.5, true), row(0, 0.5, false));+ h.event(egui::Event::ModifiersChanged(egui::Modifiers::NONE));+ h.run_steps(1);+ assert!([g, a, b].iter().all(|i| layer_of(&h, *i) == art), "the whole group moved");+ }+fn click(h: &mut egui_kittest::Harness<'static, DesignApp>, p: egui::Pos2) {h.hover_at(p);h.drag_at(p);