aleleba/deckcraft
1
0
Fork 0
mirror of https://github.com/storytold/deckcraft.git synced 2026-10-30 13:36:52 -06:00
Code Issues Packages Projects Releases Wiki Activity

Selection Pane: reorder by drag and drop, groups, Show/Hide All and Lock, as in PowerPoint (#133) (#332)

Browse Source 
* #133: Selection pane engine: restack inside groups, Show/Hide All, Lock like PowerPoint

- arrange.bringForward/sendBackward/bringToFront/sendToBack and arrange.reorder work on a
  group's children, which stay in their group (as PowerPoint's pane arrows and drag do);
  steps that change nothing leave no undo step.
- selection.select (pane click: Ctrl toggles, children and top-level objects don't mix,
  picking a hidden object shows it), selection.showAll (everything, children too) and
  selection.hideAll (top level).
- shape.lock cascades through groups; locked objects can be selected, formatted and typed
  in, but not moved, sized, rotated, flipped, reshaped or cropped (commands and canvas).
- PPTX: Lock reads and writes PowerPoint's full locking attribute set per element kind
  (observed by saving locked objects from PowerPoint); partial locks aren't Lock.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

* Front-most first with groups folding; drag a row to restack among its siblings (accent
insertion line); Bring Forward / Send Backward arrows; Show All / Hide All; per-row eye and
padlock; double-click or F2 renames in place; Ctrl+click toggles, Shift+click selects a run;
arrows, Home, End and Esc in the list; right-click menu. Lock/Unlock on the canvas menu,
greyed handles on locked objects. egui_kittest tests drive the pane.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
This commit is contained in:
Brandon Thomas
2026-10-12 22:05:44 -04:00
committed by GitHub
co-authored by Claude Opus 5.5
parent ea3b1159d5
commit 9d571ef644
19 changed files with 1550 additions and 130 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/engine/src/cmd/arrange.rs
+91 -37
View File
@@ -13,7 +13,15 @@ pub fn specs() -> Vec<CommandSpec> {
cmd!("arrange.bringForward", "Bring Forward", ["Arrange"], Some("Cmd+]"), "{ids?}", has_selection, |s, p| order(s, p, 1)),
cmd!("arrange.sendBackward", "Send Backward", ["Arrange"], Some("Cmd+["), "{ids?}", has_selection, |s, p| order(s, p, -1)),
cmd!("arrange.sendToBack", "Send to Back", ["Arrange"], Some("Cmd+Shift+["), "{ids?}", has_selection, |s, p| order(s, p, -2)),
cmd!("arrange.reorder", "Reorder Objects", ["Arrange"], None, "{id, index: position in the stack (0 = back)}", has_slide, reorder),
cmd!(
"arrange.reorder",
"Reorder Objects",
["Arrange"],
None,
"{id, index: position among its siblings (0 = back; a group's child stays in its group)} → {index}",
has_slide,
reorder
),
cmd!("arrange.group", "Group", ["Arrange"], Some("Cmd+Alt+G"), "{ids?}", has_two, group),
cmd!("arrange.ungroup", "Ungroup", ["Arrange"], Some("Cmd+Alt+Shift+G"), "{ids?}", has_selection, ungroup),
cmd!("arrange.regroup", "Regroup", ["Arrange"], Some("Cmd+Alt+J"), "{}", has_doc, regroup),
@@ -50,52 +58,98 @@ pub fn specs() -> Vec<CommandSpec> {
fn order(s: &mut Session, p: &Value, how: i32) -> Result<Value> {
let ids = targets(s, p)?;
// Already in place (front of its group, say): no change and no undo step.
let mut trial = s.doc()?.shapes().to_vec();
order_tree(&mut trial, &ids, how, 0);
if stacking(&trial) == stacking(s.doc()?.shapes()) {
return ok();
}
s.edit(|doc, sel| {
let list = crate::shapes_mut(doc, sel).ok_or_else(|| bad("arrange", "no slide"))?;
match how {
2 => {
let (mut moved, rest): (Vec<Shape>, Vec<Shape>) = list.drain(..).partition(|x| ids.contains(&x.id));
list.extend(rest);
list.append(&mut moved);
}
-2 => {
let (mut moved, rest): (Vec<Shape>, Vec<Shape>) = list.drain(..).partition(|x| ids.contains(&x.id));
moved.extend(rest);
*list = moved;
}
1 => {
for i in (0..list.len().saturating_sub(1)).rev() {
let (a, b) = (list.get(i).map(|x| ids.contains(&x.id)), list.get(i + 1).map(|x| ids.contains(&x.id)));
if a == Some(true) && b == Some(false) {
list.swap(i, i + 1);
}
}
}
_ => {
for i in 1..list.len() {
let (a, b) = (list.get(i - 1).map(|x| ids.contains(&x.id)), list.get(i).map(|x| ids.contains(&x.id)));
if a == Some(false) && b == Some(true) {
list.swap(i - 1, i);
}
}
}
}
order_tree(list, &ids, how, 0);
Ok(())
})?;
ok()
}
/// Every shape id with its depth, in tree order.
fn stacking(v: &[Shape]) -> Vec<(ShapeId, usize)> {
let mut out = vec![];
deckcraft_model::walk(v, &mut |sh, d| out.push((sh.id, d)));
out
}
/// Restack `ids` among their siblings, in every list of the tree: a shape inside a group moves
/// within its group and never leaves it (PowerPoint's Selection pane arrows work the same way).
fn order_tree(list: &mut Vec<Shape>, ids: &[ShapeId], how: i32, depth: usize) {
if depth > 64 {
return;
}
if list.iter().any(|x| ids.contains(&x.id)) {
order_list(list, ids, how);
}
for sh in list.iter_mut() {
if let Some(children) = sh.children_mut() {
order_tree(children, ids, how, depth + 1);
}
}
}
fn order_list(list: &mut Vec<Shape>, ids: &[ShapeId], how: i32) {
match how {
2 => {
let (mut moved, rest): (Vec<Shape>, Vec<Shape>) = list.drain(..).partition(|x| ids.contains(&x.id));
list.extend(rest);
list.append(&mut moved);
}
-2 => {
let (mut moved, rest): (Vec<Shape>, Vec<Shape>) = list.drain(..).partition(|x| ids.contains(&x.id));
moved.extend(rest);
*list = moved;
}
1 => {
for i in (0..list.len().saturating_sub(1)).rev() {
let (a, b) = (list.get(i).map(|x| ids.contains(&x.id)), list.get(i + 1).map(|x| ids.contains(&x.id)));
if a == Some(true) && b == Some(false) {
list.swap(i, i + 1);
}
}
}
_ => {
for i in 1..list.len() {
let (a, b) = (list.get(i - 1).map(|x| ids.contains(&x.id)), list.get(i).map(|x| ids.contains(&x.id)));
if a == Some(false) && b == Some(true) {
list.swap(i - 1, i);
}
}
}
}
}
/// Move one shape to `index` among its siblings (0 = back): the Selection pane's drag and drop.
/// A shape stays in the list that holds it, so a group's child stays in its group.
fn reorder(s: &mut Session, p: &Value) -> Result<Value> {
let id = id_param(p, "id").ok_or_else(|| bad("arrange.reorder", "missing `id`"))?;
let to = usize_param(p, "index").ok_or_else(|| bad("arrange.reorder", "missing `index`"))?;
let st = s.doc()?;
let siblings: &[Shape] = match deckcraft_model::parent_of(st.shapes(), id) {
None => return Err(bad("arrange.reorder", "no such shape")),
Some(None) => st.shapes(),
Some(Some(g)) => st.shape(g).map(Shape::children).unwrap_or(&[]),
};
let from = siblings.iter().position(|x| x.id == id).ok_or_else(|| bad("arrange.reorder", "no such shape"))?;
if from == to.min(siblings.len().saturating_sub(1)) {
return Ok(json!({"index": from}));
}
s.edit(|doc, sel| {
let list = crate::shapes_mut(doc, sel).ok_or_else(|| bad("arrange.reorder", "no slide"))?;
let i = list.iter().position(|x| x.id == id).ok_or_else(|| bad("arrange.reorder", "not a top-level shape"))?;
let tree = crate::shapes_mut(doc, sel).ok_or_else(|| bad("arrange.reorder", "no slide"))?;
let list = deckcraft_model::sibling_list_mut(tree, id).ok_or_else(|| bad("arrange.reorder", "no such shape"))?;
let i = list.iter().position(|x| x.id == id).ok_or_else(|| bad("arrange.reorder", "no such shape"))?;
let sh = list.remove(i);
list.insert(to.min(list.len()), sh);
Ok(())
})?;
ok()
let at = to.min(list.len());
list.insert(at, sh);
Ok(json!({"index": at}))
})
}
/// Bounds of shapes (rotation included).
@@ -221,7 +275,7 @@ fn align(s: &mut Session, p: &Value) -> Result<Value> {
} else {
union_bounds(&boxes.iter().map(|b| b.1).collect::<Vec<_>>()).unwrap_or_default()
};
edit_shapes(s, p, "arrange.align", |sh| {
edit_geometry(s, p, "arrange.align", |sh| {
if let Some(x) = sh.xfrm.as_mut() {
let b = x.bounds();
let (dx, dy) = match edge.as_str() {
@@ -273,7 +327,7 @@ fn distribute(s: &mut Session, p: &Value) -> Result<Value> {
targets_pos.push((*id, d));
cur += (if horiz { b.width() } else { b.height() }) + gap;
}
edit_shapes(s, p, "arrange.distribute", |sh| {
edit_geometry(s, p, "arrange.distribute", |sh| {
if let (Some(x), Some((_, d))) = (sh.xfrm.as_mut(), targets_pos.iter().find(|(i, _)| *i == sh.id)) {
if horiz {
x.x += d;
crates/engine/src/cmd/mod.rs
+14
View File
@@ -11,6 +11,7 @@ pub mod inspect;
pub mod media;
pub mod merge;
pub mod review;
pub mod selection;
pub mod shape;
pub mod slide;
pub mod table;
@@ -130,6 +131,7 @@ pub fn command_specs() -> &'static [CommandSpec] {
v.extend(insert::specs());
v.extend(shape::specs());
v.extend(arrange::specs());
v.extend(selection::specs());
v.extend(merge::specs());
v.extend(text::specs());
v.extend(format::specs());
@@ -309,6 +311,18 @@ pub(crate) fn edit_shapes(s: &mut Session, p: &Value, cmd: &str, f: impl Fn(&mut
})
}
/// [`edit_shapes`] for edits a locked object refuses (move, size, rotate, flip, reshape, crop):
/// locked targets are left out, and when every target is locked nothing changes.
pub(crate) fn edit_geometry(s: &mut Session, p: &Value, cmd: &str, f: impl Fn(&mut deckcraft_model::Shape) -> Result<()>) -> Result<Value> {
let ids = targets(s, p)?;
let st = s.doc()?;
let free: Vec<u32> = ids.iter().filter(|id| !st.shape(**id).is_some_and(|x| x.locked)).map(|id| id.0).collect();
if !ids.is_empty() && free.is_empty() {
return Err(bad(cmd, "the object is locked"));
}
edit_shapes(s, &with_param(p, "ids", Value::from(free)), cmd, f)
}
pub(crate) fn current_shapes<'a>(doc: &'a deckcraft_model::Presentation, sel: &crate::Selection) -> Option<&'a Vec<deckcraft_model::Shape>> {
match sel.target {
crate::Target::Slides => doc.slides.get(sel.slide).map(|s| &s.shapes),
crates/engine/src/cmd/selection.rs
+126
View File
@@ -0,0 +1,126 @@
//! Selection pane: picking objects from the list, Show All and Hide All. Its other actions are
//! ordinary commands: `shape.visible` (eye), `shape.lock` (padlock), `shape.rename`,
//! `arrange.bringForward` / `arrange.sendBackward` (arrows) and `arrange.reorder` (drag and drop).
use deckcraft_model::{Shape, ShapeId};
use serde_json::{Value, json};
use super::*;
use crate::{Result, Session};
pub fn specs() -> Vec<CommandSpec> {
vec![
cmd!(
"selection.select",
"Select",
["Selection Pane"],
None,
"{ids | id, toggle?: bool (Ctrl+click), add?: bool} → {selected}: objects in groups too; a hidden object picked from the list is shown",
has_slide,
select
),
cmd!("selection.showAll", "Show All", ["Selection Pane"], None, "{} shows every object on the slide, inside groups too", has_slide, show_all),
cmd!("selection.hideAll", "Hide All", ["Selection Pane"], None, "{} hides every top-level object on the slide", has_slide, hide_all),
]
}
/// The Selection pane's click. Objects inside groups and top-level objects can't be selected
/// together (Ctrl+click on the other kind is ignored, as in PowerPoint), and picking a hidden
/// object from the list shows it again.
fn select(s: &mut Session, p: &Value) -> Result<Value> {
let ids = ids_param(p, "ids").or_else(|| id_param(p, "id").map(|i| vec![i])).unwrap_or_default();
let (toggle, add) = (bool_or(p, "toggle", false), bool_or(p, "add", false));
let st = s.doc()?;
let in_group = |id: &ShapeId| deckcraft_model::parent_of(st.shapes(), *id).map(|p| p.is_some());
let mut valid: Vec<ShapeId> = ids.iter().copied().filter(|i| in_group(i).is_some()).collect();
if valid.is_empty() {
return Err(bad("selection.select", "no such shape"));
}
let kind = valid.first().and_then(in_group);
valid.retain(|i| in_group(i) == kind);
let keep: Vec<ShapeId> = if toggle || add {
let current = st.selection.shapes.clone();
if current.first().is_some_and(|c| in_group(c) != kind) {
// Can't mix objects in groups with top-level ones: nothing changes.
return Ok(json!({"selected": current}));
}
current
} else {
vec![]
};
let mut next = keep;
for i in &valid {
match next.iter().position(|x| x == i) {
Some(k) if toggle => {
next.remove(k);
}
Some(_) => {}
None => next.push(*i),
}
}
let reveal: Vec<ShapeId> = next.iter().copied().filter(|i| valid.contains(i) && st.shape(*i).is_some_and(|x| x.hidden)).collect();
if reveal.is_empty() {
s.select(|_, sel| {
sel.text = None;
sel.cells = None;
sel.shapes = next.clone();
})?;
} else {
s.edit(|doc, sel| {
let shapes = crate::shapes_mut(doc, sel).ok_or_else(|| bad("selection.select", "no slide"))?;
for id in &reveal {
if let Some(sh) = deckcraft_model::find_shape_mut(shapes, *id) {
sh.hidden = false;
}
}
sel.text = None;
sel.cells = None;
sel.shapes = next.clone();
Ok(())
})?;
}
Ok(json!({"selected": s.doc()?.selection.shapes}))
}
fn show_all(s: &mut Session, _p: &Value) -> Result<Value> {
fn any_hidden(v: &[Shape]) -> bool {
let mut found = false;
deckcraft_model::walk(v, &mut |sh, _| found |= sh.hidden);
found
}
if !any_hidden(s.doc()?.shapes()) {
return ok();
}
s.edit(|doc, sel| {
fn rec(v: &mut [Shape], depth: usize) {
for sh in v {
sh.hidden = false;
if depth < 64
&& let Some(c) = sh.children_mut()
{
rec(c, depth + 1);
}
}
}
rec(crate::shapes_mut(doc, sel).ok_or_else(|| bad("selection.showAll", "no slide"))?, 0);
Ok(())
})?;
ok()
}
fn hide_all(s: &mut Session, _p: &Value) -> Result<Value> {
if s.doc()?.shapes().iter().all(|x| x.hidden) {
return ok();
}
s.edit(|doc, sel| {
for sh in crate::shapes_mut(doc, sel).ok_or_else(|| bad("selection.hideAll", "no slide"))? {
sh.hidden = true;
}
Ok(())
})?;
ok()
}
#[cfg(test)]
#[path = "selection_tests.rs"]
mod tests;
crates/engine/src/cmd/selection_tests.rs
+264
View File
@@ -0,0 +1,264 @@
//! Selection pane: reorder, groups, hide/show, lock and undo.
use serde_json::{Value, json};
use crate::tools::{Mods, PointerEvent, PointerKind};
use crate::*;
/// A blank slide with A, B, C (back to front) and G = group [D, H = group [E, F]] in front.
fn deck() -> (Session, Vec<u32>) {
let mut s = Session::with_new();
s.execute("slide.new", &json!({"layout": "blank"})).unwrap();
let mut ids = vec![];
for (i, n) in ["A", "B", "C", "D", "E", "F"].iter().enumerate() {
let x = 20.0 + 110.0 * i as f64;
let r = s.execute("shape.insert", &json!({"preset": "rect", "rect": [x, 50, 100, 80]})).unwrap();
let id = r["id"].as_u64().unwrap() as u32;
s.execute("shape.rename", &json!({"id": id, "name": n})).unwrap();
ids.push(id);
}
let h = s.execute("arrange.group", &json!({"ids": [ids[4], ids[5]]})).unwrap()["id"].as_u64().unwrap() as u32;
s.execute("shape.rename", &json!({"id": h, "name": "H"})).unwrap();
let g = s.execute("arrange.group", &json!({"ids": [ids[3], h]})).unwrap()["id"].as_u64().unwrap() as u32;
s.execute("shape.rename", &json!({"id": g, "name": "G"})).unwrap();
ids.extend([h, g]);
(s, ids)
}
/// The tree as text, back to front: `A B C G[D H[E F]]`.
fn tree(s: &Session) -> String {
fn rec(v: &[deckcraft_model::Shape]) -> String {
v.iter().map(|x| if x.is_group() { format!("{}[{}]", x.name, rec(x.children())) } else { x.name.clone() }).collect::<Vec<_>>().join(" ")
}
rec(s.doc().unwrap().shapes())
}
/// (hidden, locked)
fn flags(s: &Session, id: u32) -> (bool, bool) {
let sh = s.doc().unwrap().shape(deckcraft_model::ShapeId(id)).unwrap();
(sh.hidden, sh.locked)
}
fn selected(s: &Session) -> Vec<u32> {
s.doc().unwrap().selection.shapes.iter().map(|i| i.0).collect()
}
fn undo(s: &mut Session) {
s.execute("edit.undo", &json!({})).unwrap();
}
fn bx(s: &mut Session, id: u32) -> Value {
s.execute("shape.inspect", &json!({"id": id})).unwrap()["box"].clone()
}
#[test]
fn bring_forward_and_send_backward_stay_inside_the_group() {
let (mut s, ids) = deck();
let (a, d, e, h) = (ids[0], ids[3], ids[4], ids[6]);
assert_eq!(tree(&s), "A B C G[D H[E F]]");
s.execute("arrange.bringForward", &json!({"ids": [a]})).unwrap();
assert_eq!(tree(&s), "B A C G[D H[E F]]");
// A child moves among its siblings only and stops at the group's front.
s.execute("arrange.bringForward", &json!({"ids": [d]})).unwrap();
assert_eq!(tree(&s), "B A C G[H[E F] D]");
s.execute("arrange.bringForward", &json!({"ids": [d]})).unwrap();
assert_eq!(tree(&s), "B A C G[H[E F] D]");
s.execute("arrange.sendBackward", &json!({"ids": [e]})).unwrap();
assert_eq!(tree(&s), "B A C G[H[E F] D]", "E is already at the back of H");
s.execute("arrange.bringToFront", &json!({"ids": [e]})).unwrap();
assert_eq!(tree(&s), "B A C G[H[F E] D]");
s.execute("arrange.sendToBack", &json!({"ids": [d]})).unwrap();
assert_eq!(tree(&s), "B A C G[D H[F E]]");
s.execute("arrange.bringForward", &json!({"ids": [h]})).unwrap();
assert_eq!(tree(&s), "B A C G[D H[F E]]", "H is already in front inside G");
// Steps that changed nothing left no undo step.
undo(&mut s);
assert_eq!(tree(&s), "B A C G[H[F E] D]");
undo(&mut s);
undo(&mut s);
assert_eq!(tree(&s), "B A C G[D H[E F]]");
}
#[test]
fn reorder_is_the_drag_and_drop_among_siblings() {
let (mut s, ids) = deck();
let (a, c, d, f, g) = (ids[0], ids[2], ids[3], ids[5], ids[7]);
// Drag A to the front of the slide (an index past the end clamps).
assert_eq!(s.execute("arrange.reorder", &json!({"id": a, "index": 99})).unwrap()["index"], 3);
assert_eq!(tree(&s), "B C G[D H[E F]] A");
s.execute("arrange.reorder", &json!({"id": g, "index": 0})).unwrap();
assert_eq!(tree(&s), "G[D H[E F]] B C A");
// A child is dragged within its group: it never leaves it.
s.execute("arrange.reorder", &json!({"id": d, "index": 5})).unwrap();
assert_eq!(tree(&s), "G[H[E F] D] B C A");
s.execute("arrange.reorder", &json!({"id": f, "index": 0})).unwrap();
assert_eq!(tree(&s), "G[H[F E] D] B C A");
// Dropping where it already is changes nothing (no undo step).
let n = s.doc().unwrap().history.undo.len();
s.execute("arrange.reorder", &json!({"id": c, "index": 2})).unwrap();
assert_eq!(s.doc().unwrap().history.undo.len(), n);
// One undo step per drop.
undo(&mut s);
assert_eq!(tree(&s), "G[H[E F] D] B C A");
undo(&mut s);
undo(&mut s);
undo(&mut s);
assert_eq!(tree(&s), "A B C G[D H[E F]]");
assert!(s.execute("arrange.reorder", &json!({"id": 4242, "index": 0})).is_err());
assert!(s.execute("arrange.reorder", &json!({"id": a})).is_err());
}
#[test]
fn eye_show_all_and_hide_all() {
let (mut s, ids) = deck();
let (a, b, d, e, g) = (ids[0], ids[1], ids[3], ids[4], ids[7]);
s.execute("shape.visible", &json!({"id": b, "visible": false})).unwrap();
assert!(flags(&s, b).0);
// Hiding a group hides only the group; its children keep their own flags.
s.execute("shape.visible", &json!({"id": g})).unwrap();
assert!(flags(&s, g).0 && !flags(&s, d).0);
s.execute("shape.visible", &json!({"id": e, "visible": false})).unwrap();
// Hide All hides the top level only.
s.execute("selection.hideAll", &json!({})).unwrap();
assert!(flags(&s, a).0 && flags(&s, g).0 && !flags(&s, d).0 && flags(&s, e).0);
// Show All shows everything, children included.
s.execute("selection.showAll", &json!({})).unwrap();
for id in &ids {
assert!(!flags(&s, *id).0, "{id} still hidden");
}
let n = s.doc().unwrap().history.undo.len();
s.execute("selection.showAll", &json!({})).unwrap();
assert_eq!(s.doc().unwrap().history.undo.len(), n, "nothing to show: no undo step");
undo(&mut s);
assert!(flags(&s, a).0 && flags(&s, e).0);
undo(&mut s);
assert!(!flags(&s, a).0 && flags(&s, g).0 && flags(&s, e).0);
}
#[test]
fn lock_cascades_through_groups_and_undoes() {
let (mut s, ids) = deck();
let (a, d, e, h, g) = (ids[0], ids[3], ids[4], ids[6], ids[7]);
s.execute("shape.lock", &json!({"id": a})).unwrap();
assert!(flags(&s, a).1);
s.execute("shape.lock", &json!({"id": a})).unwrap();
assert!(!flags(&s, a).1, "toggles");
// Locking a group locks everything in it.
s.execute("shape.lock", &json!({"id": g, "locked": true})).unwrap();
assert!(flags(&s, g).1 && flags(&s, d).1 && flags(&s, h).1 && flags(&s, e).1);
// A child can be unlocked on its own.
s.execute("shape.lock", &json!({"id": d, "locked": false})).unwrap();
assert!(flags(&s, g).1 && !flags(&s, d).1);
// Unlocking the group unlocks everything in it.
s.execute("shape.lock", &json!({"id": g})).unwrap();
assert!(!flags(&s, g).1 && !flags(&s, h).1 && !flags(&s, e).1);
undo(&mut s);
assert!(flags(&s, g).1 && !flags(&s, d).1 && flags(&s, e).1);
undo(&mut s);
undo(&mut s);
assert!(!flags(&s, g).1 && !flags(&s, e).1);
}
#[test]
fn locked_objects_refuse_moving_sizing_rotating_but_take_formatting() {
let (mut s, ids) = deck();
let (a, b) = (ids[0], ids[1]);
s.execute("shape.lock", &json!({"id": a, "locked": true})).unwrap();
let before = bx(&mut s, a);
for (cmd, p) in [
("shape.move", json!({"ids": [a], "dx": 10})),
("shape.resize", json!({"ids": [a], "w": 300})),
("shape.setBounds", json!({"ids": [a], "x": 1, "y": 1, "w": 2, "h": 2})),
("shape.rotate", json!({"ids": [a], "deg": 45})),
("shape.flip", json!({"ids": [a], "axis": "vertical"})),
("arrange.align", json!({"ids": [a], "edge": "right"})),
("shape.change", json!({"ids": [a], "preset": "ellipse"})),
] {
assert!(s.execute(cmd, &p).is_err(), "{cmd} changed a locked shape");
}
assert_eq!(bx(&mut s, a), before);
// Mixed selections: the unlocked ones move, the locked one stays.
let bb = bx(&mut s, b);
s.execute("shape.move", &json!({"ids": [a, b], "dx": 10})).unwrap();
assert_eq!(bx(&mut s, a), before);
assert_eq!(bx(&mut s, b)["x"].as_f64().unwrap(), bb["x"].as_f64().unwrap() + 10.0);
// Formatting and the name still change.
s.execute("shape.fill", &json!({"ids": [a], "color": "#00ff00"})).unwrap();
s.execute("shape.rename", &json!({"id": a, "name": "Anchor"})).unwrap();
assert_eq!(s.doc().unwrap().shape(deckcraft_model::ShapeId(a)).unwrap().name, "Anchor");
// The arrow keys don't nudge it.
s.execute("edit.select", &json!({"ids": [a]})).unwrap();
let _ = s.key("ArrowRight", Mods::default());
assert_eq!(bx(&mut s, a), before);
}
#[test]
fn locked_objects_are_picked_on_the_canvas_but_not_dragged() {
let (mut s, ids) = deck();
let a = ids[0];
s.prefs.snap_to_grid = false;
s.prefs.smart_guides = false;
s.execute("shape.lock", &json!({"id": a, "locked": true})).unwrap();
s.execute("edit.select", &json!({"ids": []})).unwrap();
let n = s.doc().unwrap().history.undo.len();
let ev = |kind, x, y| PointerEvent { kind, x, y, mods: Mods::default(), tol: 3.0 };
// A: x 20..120, y 50..130.
s.pointer(ev(PointerKind::Down, 60.0, 90.0)).unwrap();
assert_eq!(selected(&s), vec![a], "a click selects a locked object");
s.pointer(ev(PointerKind::Drag, 160.0, 190.0)).unwrap();
s.pointer(ev(PointerKind::Up, 160.0, 190.0)).unwrap();
assert_eq!(bx(&mut s, a)["x"], 20.0);
// No resize handle: pressing on the SE corner and dragging doesn't size it.
s.pointer(ev(PointerKind::Down, 120.0, 130.0)).unwrap();
s.pointer(ev(PointerKind::Drag, 200.0, 200.0)).unwrap();
s.pointer(ev(PointerKind::Up, 200.0, 200.0)).unwrap();
assert_eq!(bx(&mut s, a)["w"], 100.0);
assert_eq!(s.doc().unwrap().history.undo.len(), n, "no undo steps for gestures that changed nothing");
}
#[test]
fn select_from_the_pane() {
let (mut s, ids) = deck();
let (a, b, c, d, e, g) = (ids[0], ids[1], ids[2], ids[3], ids[4], ids[7]);
s.execute("selection.select", &json!({"id": b})).unwrap();
assert_eq!(selected(&s), vec![b]);
s.execute("selection.select", &json!({"id": c, "toggle": true})).unwrap();
assert_eq!(selected(&s), vec![b, c]);
s.execute("selection.select", &json!({"id": b, "toggle": true})).unwrap();
assert_eq!(selected(&s), vec![c]);
s.execute("selection.select", &json!({"ids": [a, b], "add": true})).unwrap();
assert_eq!(selected(&s), vec![c, a, b]);
// A child inside a group; children across nesting levels go together.
s.execute("selection.select", &json!({"id": d})).unwrap();
assert_eq!(selected(&s), vec![d]);
s.execute("selection.select", &json!({"id": e, "toggle": true})).unwrap();
assert_eq!(selected(&s), vec![d, e]);
// ...but not with top-level objects: Ctrl+click on one is ignored.
s.execute("selection.select", &json!({"id": g, "toggle": true})).unwrap();
assert_eq!(selected(&s), vec![d, e]);
s.execute("selection.select", &json!({"id": a})).unwrap();
s.execute("selection.select", &json!({"id": d, "toggle": true})).unwrap();
assert_eq!(selected(&s), vec![a]);
// Picking makes no undo step...
let n = s.doc().unwrap().history.undo.len();
s.execute("selection.select", &json!({"id": b})).unwrap();
assert_eq!(s.doc().unwrap().history.undo.len(), n);
// ...unless it shows a hidden object again.
s.execute("shape.visible", &json!({"id": c, "visible": false})).unwrap();
s.execute("selection.select", &json!({"id": c})).unwrap();
assert_eq!(selected(&s), vec![c]);
assert!(!flags(&s, c).0, "picking a hidden object shows it");
undo(&mut s);
assert!(flags(&s, c).0);
assert!(s.execute("selection.select", &json!({"id": 4242})).is_err());
}
#[test]
fn rename_from_the_pane_undoes() {
let (mut s, ids) = deck();
let e = ids[4];
s.execute("shape.rename", &json!({"id": e, "name": "Eagle"})).unwrap();
assert_eq!(s.doc().unwrap().shape(deckcraft_model::ShapeId(e)).unwrap().name, "Eagle");
undo(&mut s);
assert_eq!(s.doc().unwrap().shape(deckcraft_model::ShapeId(e)).unwrap().name, "E");
}
crates/engine/src/cmd/shape.rs
+34 -10
View File
@@ -76,7 +76,15 @@ pub fn specs() -> Vec<CommandSpec> {
cmd!("shape.rename", "Rename", ["Selection Pane"], None, "{name, id?}", has_selection, rename),
cmd!("shape.altText", "Alt Text", ["Shape Format", "Accessibility"], None, "{text, decorative?: bool, ids?}", has_selection, alt_text),
cmd!("shape.visible", "Show/Hide", ["Selection Pane"], None, "{visible?: bool, ids?}", has_selection, visible),
cmd!("shape.lock", "Lock", [], None, "{locked?: bool, ids?}", has_selection, lock),
cmd!(
"shape.lock",
"Lock",
["Selection Pane"],
None,
"{locked?: bool (default: toggle), ids?} (a group locks or unlocks with everything in it)",
has_selection,
lock
),
cmd!("shape.setDefault", "Set as Default Shape", [], None, "{}", has_selection, set_default),
cmd!("picture.crop", "Crop", ["Picture Format", "Size"], None, "{left?, top?, right?, bottom?: fraction 0..1, ids?}", has_selection, crop),
cmd!(
@@ -113,7 +121,7 @@ pub fn specs() -> Vec<CommandSpec> {
fn move_by(s: &mut Session, p: &Value) -> Result<Value> {
let (dx, dy) = (f64_param(p, "dx"), f64_param(p, "dy"));
let (ax, ay) = (f64_param(p, "x"), f64_param(p, "y"));
edit_shapes(s, p, "shape.move", |sh| {
edit_geometry(s, p, "shape.move", |sh| {
if let Some(x) = sh.xfrm.as_mut() {
x.x = ax.unwrap_or(x.x) + dx.unwrap_or(0.0);
x.y = ay.unwrap_or(x.y) + dy.unwrap_or(0.0);
@@ -125,7 +133,7 @@ fn move_by(s: &mut Session, p: &Value) -> Result<Value> {
fn resize(s: &mut Session, p: &Value) -> Result<Value> {
let (w, h) = (f64_param(p, "w").map(|v| v.max(0.0)), f64_param(p, "h").map(|v| v.max(0.0)));
let lock = bool_or(p, "lockAspect", false);
edit_shapes(s, p, "shape.resize", |sh| {
edit_geometry(s, p, "shape.resize", |sh| {
if let Some(x) = sh.xfrm.as_mut() {
let ar = if x.h > 0.0 { x.w / x.h } else { 1.0 };
let (cx, cy) = (x.x + x.w / 2.0, x.y + x.h / 2.0);
@@ -154,7 +162,7 @@ fn resize(s: &mut Session, p: &Value) -> Result<Value> {
}
fn set_bounds(s: &mut Session, p: &Value) -> Result<Value> {
edit_shapes(s, p, "shape.setBounds", |sh| {
edit_geometry(s, p, "shape.setBounds", |sh| {
if let Some(x) = sh.xfrm.as_mut() {
x.x = f64_param(p, "x").unwrap_or(x.x);
x.y = f64_param(p, "y").unwrap_or(x.y);
@@ -167,7 +175,7 @@ fn set_bounds(s: &mut Session, p: &Value) -> Result<Value> {
fn rotate(s: &mut Session, p: &Value) -> Result<Value> {
let (abs, by) = (f64_param(p, "deg"), f64_param(p, "by"));
edit_shapes(s, p, "shape.rotate", |sh| {
edit_geometry(s, p, "shape.rotate", |sh| {
if let Some(x) = sh.xfrm.as_mut() {
let r = abs.unwrap_or(x.rot) + by.unwrap_or(0.0);
x.rot = ((r % 360.0) + 360.0) % 360.0;
@@ -178,7 +186,7 @@ fn rotate(s: &mut Session, p: &Value) -> Result<Value> {
fn flip(s: &mut Session, p: &Value) -> Result<Value> {
let v = str_param(p, "axis").unwrap_or("horizontal").starts_with('v');
edit_shapes(s, p, "shape.flip", |sh| {
edit_geometry(s, p, "shape.flip", |sh| {
if let Some(x) = sh.xfrm.as_mut() {
if v {
x.flip_v = !x.flip_v;
@@ -193,7 +201,7 @@ fn flip(s: &mut Session, p: &Value) -> Result<Value> {
fn adjust(s: &mut Session, p: &Value) -> Result<Value> {
let i = usize_param(p, "index").unwrap_or(0).min(16);
let v = f64_param(p, "value").ok_or_else(|| bad("shape.adjust", "missing `value`"))?;
edit_shapes(s, p, "shape.adjust", |sh| {
edit_geometry(s, p, "shape.adjust", |sh| {
if let Geom::Preset { name, adj } = &mut sh.geom {
let defaults = deckcraft_geom::preset::info(name).map(|x| x.defaults).unwrap_or(&[]);
while adj.len() <= i {
@@ -211,7 +219,7 @@ fn adjust(s: &mut Session, p: &Value) -> Result<Value> {
fn change(s: &mut Session, p: &Value) -> Result<Value> {
let name = str_param(p, "preset").ok_or_else(|| bad("shape.change", "missing `preset`"))?;
let info = deckcraft_geom::preset::info(name).ok_or_else(|| bad("shape.change", format!("unknown preset `{name}`")))?;
edit_shapes(s, p, "shape.change", |sh| {
edit_geometry(s, p, "shape.change", |sh| {
sh.geom = Geom::preset(info.name);
Ok(())
})
@@ -570,14 +578,30 @@ fn visible(s: &mut Session, p: &Value) -> Result<Value> {
})
}
/// Lock: a locked object can be selected, formatted and typed in, but not moved, sized, rotated,
/// flipped, reshaped or cropped. Locking or unlocking a group does the same to everything in it
/// (a child can still be unlocked on its own afterwards), as PowerPoint does.
fn lock(s: &mut Session, p: &Value) -> Result<Value> {
let v = bool_param(p, "locked");
edit_shapes(s, p, "shape.lock", |sh| {
sh.locked = v.unwrap_or(!sh.locked);
let to = v.unwrap_or(!sh.locked);
set_locked(sh, to, 0);
Ok(())
})
}
fn set_locked(sh: &mut deckcraft_model::Shape, to: bool, depth: usize) {
sh.locked = to;
if depth > 64 {
return;
}
if let Some(children) = sh.children_mut() {
for c in children {
set_locked(c, to, depth + 1);
}
}
}
fn set_default(s: &mut Session, _p: &Value) -> Result<Value> {
let st = s.doc()?;
let Some(sh) = st.selected_shapes().first().map(|x| (*x).clone()) else { return ok() };
@@ -595,7 +619,7 @@ fn set_default(s: &mut Session, _p: &Value) -> Result<Value> {
fn crop(s: &mut Session, p: &Value) -> Result<Value> {
let c = [f64_param(p, "left"), f64_param(p, "top"), f64_param(p, "right"), f64_param(p, "bottom")];
edit_shapes(s, p, "picture.crop", |sh| {
edit_geometry(s, p, "picture.crop", |sh| {
if let deckcraft_model::ShapeKind::Picture { fill } = &mut sh.kind {
for (i, v) in c.iter().enumerate() {
if let (Some(v), Some(slot)) = (v, fill.crop.get_mut(i)) {