Skip to content

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.rs
index 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.rs
index 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: &[ItemI
Some(("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);