Skip to content

DesignCraft: An open-source page and layout design editor written by scratch in pure Rust

PARITY-ARRANGE: step past same-layer siblings in Arrange

sanyamsingh001b4db4286085d
diff --git a/crates/engine/src/cmd/object.rs b/crates/engine/src/cmd/object.rs
index cd13be117..bc01aabb7 100644
--- a/crates/engine/src/cmd/object.rs
+++ b/crates/engine/src/cmd/object.rs
@@ -1318,6 +1318,43 @@ fn arrange(s: &mut Session, p: &Value) -> Result<Value> {
let ids = targets(s, p)?;
let to = str_param(p, "to").unwrap_or("front").to_string();
s.edit(|d, _| {
+ if matches!(to.as_str(), "forward" | "backward") {
+ let selected: HashSet<ItemId> = ids.iter().copied().collect();
+ let mut positions: Vec<_> = selected
+ .iter()
+ .filter_map(|id| {
+ let loc = d.find(*id)?;
+ match loc.path.as_slice() {
+ [i] => Some((loc.spread, *i)),
+ _ => None,
+ }
+ })
+ .collect();
+ // Move the leading selected items first, independently of selection/click order.
+ // Swapping only with unselected siblings leaves the other selected indices valid.
+ positions.sort_by_key(|(_, i)| *i);
+ let forward = to == "forward";
+ if forward {
+ positions.reverse();
+ }
+ for (spread, i) in positions {
+ let Some(sp) = d.spread_mut(spread) else { continue };
+ let Some(it) = sp.items.get(i) else { continue };
+ let layer = it.layer;
+ let sibling = if forward {
+ sp.items.iter().enumerate().skip(i.saturating_add(1)).find(|(_, it)| it.layer == layer)
+ } else {
+ sp.items.iter().enumerate().take(i).rev().find(|(_, it)| it.layer == layer)
+ };
+ if let Some((j, it)) = sibling
+ && !selected.contains(&it.id)
+ {
+ // Keep every other layer's slots and relative stacking order untouched.
+ sp.items.swap(i, j);
+ }
+ }
+ return ok();
+ }
for id in &ids {
let Some(loc) = d.find(*id) else { continue };
if loc.path.len() != 1 {
@@ -1330,7 +1367,6 @@ fn arrange(s: &mut Session, p: &Value) -> Result<Value> {
let j = match to.as_str() {
"front" => n - 1,
"back" => 0,
- "forward" => (i + 1).min(n - 1),
_ => i.saturating_sub(1),
};
sp.items.insert(j, it);
@@ -2121,6 +2157,148 @@ fn step_and_repeat(s: &mut Session, p: &Value) -> Result<Value> {
})
}
+#[cfg(test)]
+mod arrange_tests {
+ use super::*;
+
+ fn fixture<const N: usize>(layers: [usize; N]) -> (Session, [ItemId; N]) {
+ let mut s = Session::new();
+ s.execute("file.new", &json!({"pages": 1, "facingPages": false})).unwrap();
+ let first = s.doc().unwrap().doc.default_layer().0;
+ let second = s.execute("layer.new", &json!({"name": "Other layer"})).unwrap()["id"].as_u64().unwrap();
+ let layer_ids = [first, second];
+ let mut ids = [ItemId(0); N];
+ for (id, layer) in ids.iter_mut().zip(layers) {
+ // Overlap objects within each layer; separate layers spatially for hit testing.
+ let x = if layer == 0 { 0 } else { 200 };
+ *id = ItemId(s.execute("frame.create", &json!({"rect": [x, 0, x + 100, 100]})).unwrap()["id"].as_u64().unwrap());
+ s.execute("object.setLayer", &json!({"ids": [id.0], "layer": layer_ids[layer]})).unwrap();
+ }
+ (s, ids)
+ }
+
+ fn stack(s: &Session) -> Vec<ItemId> {
+ s.doc().unwrap().doc.spreads[0].items.iter().map(|it| it.id).collect()
+ }
+
+ fn snapshot(s: &Session) -> Value {
+ let st = s.doc().unwrap();
+ json!({"document": &*st.doc, "selection": &st.selection})
+ }
+
+ fn assert_items_unchanged(before: &Document, after: &Document) {
+ assert_eq!(serde_json::to_value(&before.layers).unwrap(), serde_json::to_value(&after.layers).unwrap());
+ for it in &before.spreads[0].items {
+ assert_eq!(serde_json::to_value(it).unwrap(), serde_json::to_value(after.item(it.id).unwrap()).unwrap());
+ }
+ }
+
+ #[test]
+ fn arrange_steps_past_other_layers_change_hit_order_and_undo() {
+ for direction in ["forward", "backward"] {
+ let (mut s, [a, x, y, b]) = fixture([0, 1, 1, 0]);
+ let selected = if direction == "forward" { a } else { b };
+ s.execute("selection.set", &json!({"ids": [selected.0]})).unwrap();
+ let before = snapshot(&s);
+ let doc = s.doc().unwrap().doc.clone();
+ let undo_len = s.doc().unwrap().history.undo.len();
+ let hit = |s: &Session| s.doc().unwrap().doc.hit_item(0, Point::new(50.0, 50.0), 0.0);
+ assert_eq!(hit(&s), Some(b));
+
+ s.execute("object.arrange", &json!({"to": direction})).unwrap();
+ assert_eq!(stack(&s), [b, x, y, a], "{direction}");
+ assert_eq!(hit(&s), Some(a), "the visible topmost object must change");
+ assert_items_unchanged(&doc, &s.doc().unwrap().doc);
+ assert_eq!(s.doc().unwrap().history.undo.len(), undo_len + 1);
+ assert_eq!(s.doc().unwrap().selection.items, [selected]);
+ let after = snapshot(&s);
+
+ s.execute("edit.undo", &json!({})).unwrap();
+ assert_eq!(snapshot(&s), before);
+ assert_eq!(hit(&s), Some(b));
+ s.execute("edit.redo", &json!({})).unwrap();
+ assert_eq!(snapshot(&s), after);
+ assert_eq!(hit(&s), Some(a));
+ }
+ }
+
+ #[test]
+ fn arrange_multiple_selection_preserves_order_independent_of_input_order() {
+ // Layer 0: a, b, c, d. Layer 1: x, y. Arrays name the original stack indices.
+ let cases = [
+ ("forward", [0, 2], [4, 1, 0, 3, 2, 5]), // a,b cross c as a block
+ ("backward", [2, 4], [2, 1, 4, 3, 0, 5]), // b,c cross a as a block
+ ("forward", [0, 4], [2, 1, 0, 3, 5, 4]), // separate selected blocks
+ ("backward", [2, 5], [2, 1, 0, 3, 5, 4]),
+ ("forward", [4, 5], [0, 1, 2, 3, 4, 5]), // front block is already at its endpoint
+ ("backward", [0, 2], [0, 1, 2, 3, 4, 5]), // back block is already at its endpoint
+ ];
+ for (direction, selected, expected) in cases {
+ for reverse in [false, true] {
+ let (mut s, ids) = fixture([0, 1, 0, 1, 0, 0]);
+ let doc = s.doc().unwrap().doc.clone();
+ let mut selected = selected.map(|i| ids[i].0).to_vec();
+ if reverse {
+ selected.reverse();
+ }
+ // Explicit command targets may contain duplicates: an item still moves once.
+ selected.push(selected[0]);
+ s.execute("object.arrange", &json!({"to": direction, "ids": selected})).unwrap();
+ assert_eq!(stack(&s), expected.map(|i| ids[i]), "{direction}, reverse={reverse}");
+ assert_items_unchanged(&doc, &s.doc().unwrap().doc);
+ }
+ }
+ }
+
+ #[test]
+ fn arrange_same_layer_steps_stop_at_layer_endpoints() {
+ let cases = [
+ ("forward", vec![1], [0, 2, 1, 3, 4]),
+ ("backward", vec![3], [0, 1, 3, 2, 4]),
+ ("forward", vec![3], [0, 1, 2, 3, 4]),
+ ("backward", vec![1], [0, 1, 2, 3, 4]),
+ ("forward", vec![3, 1, 2], [0, 1, 2, 3, 4]),
+ ("backward", vec![3, 1, 2], [0, 1, 2, 3, 4]),
+ ];
+ for (direction, selected, expected) in cases {
+ let (mut s, ids) = fixture([1, 0, 0, 0, 1]);
+ let selected: Vec<_> = selected.into_iter().map(|i| ids[i].0).collect();
+ s.execute("object.arrange", &json!({"to": direction, "ids": selected})).unwrap();
+ assert_eq!(stack(&s), expected.map(|i| ids[i]));
+ }
+ for direction in ["forward", "backward"] {
+ let (mut s, [x, a, y]) = fixture([1, 0, 1]);
+ s.execute("object.arrange", &json!({"to": direction, "ids": [a.0]})).unwrap();
+ assert_eq!(stack(&s), [x, a, y], "only object on its layer");
+ }
+ }
+
+ #[test]
+ fn arrange_selection_on_two_layers_moves_each_layer_independently() {
+ for direction in ["forward", "backward"] {
+ let (mut s, [a, x, b, y]) = fixture([0, 1, 0, 1]);
+ let selected = if direction == "forward" { [x.0, a.0] } else { [b.0, y.0] };
+ s.execute("object.arrange", &json!({"to": direction, "ids": selected})).unwrap();
+ assert_eq!(stack(&s), [b, y, a, x]);
+ let doc = &s.doc().unwrap().doc;
+ assert_eq!(doc.hit_item(0, Point::new(50.0, 50.0), 0.0), Some(a));
+ assert_eq!(doc.hit_item(0, Point::new(250.0, 50.0), 0.0), Some(x));
+ }
+ }
+
+ #[test]
+ fn arrange_menu_steps_use_same_layer_order() {
+ for command in ["object.bringForward", "object.sendBackward"] {
+ let (mut s, [a, x, b]) = fixture([0, 1, 0]);
+ let selected = if command == "object.bringForward" { a } else { b };
+ s.execute("selection.set", &json!({"ids": [selected.0]})).unwrap();
+ s.execute(command, &json!({})).unwrap();
+ assert_eq!(stack(&s), [b, x, a]);
+ assert_eq!(s.doc().unwrap().doc.hit_item(0, Point::new(50.0, 50.0), 0.0), Some(a));
+ }
+ }
+}
+
#[cfg(test)]
mod step_repeat_tests {
use super::*;