Skip to content

armgit / klad

Public Imported from GitHub
0

A drawing app built for agent/human collaboration

Rust

A: a shift box takes the points of every shape on the layer

Indicode BV86d829284d1c
diff --git a/Cargo.lock b/Cargo.lock
index 05e0cfe..f7f0074 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1744,7 +1744,7 @@ dependencies = [
[[package]]
name = "klad-app"
-version = "0.1.12"
+version = "0.1.13"
dependencies = [
"anyhow",
"block2 0.6.2",
@@ -1773,7 +1773,7 @@ dependencies = [
[[package]]
name = "klad-brush"
-version = "0.1.12"
+version = "0.1.13"
dependencies = [
"anyhow",
"bytemuck",
@@ -1789,7 +1789,7 @@ dependencies = [
[[package]]
name = "klad-cli"
-version = "0.1.12"
+version = "0.1.13"
dependencies = [
"anyhow",
"clap",
@@ -1815,7 +1815,7 @@ dependencies = [
[[package]]
name = "klad-core"
-version = "0.1.12"
+version = "0.1.13"
dependencies = [
"anyhow",
"half",
@@ -1827,7 +1827,7 @@ dependencies = [
[[package]]
name = "klad-render"
-version = "0.1.12"
+version = "0.1.13"
dependencies = [
"anyhow",
"bytemuck",
diff --git a/Cargo.toml b/Cargo.toml
index 343e10d..9109912 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -3,7 +3,7 @@ resolver = "3"
members = ["crates/*"]
[workspace.package]
-version = "0.1.12"
+version = "0.1.13"
edition = "2024"
license-file = "LICENSE"
repository = "https://github.com/klad-app/klad"
diff --git a/crates/app/src/editor.rs b/crates/app/src/editor.rs
index 42ea2f0..a43ac8d 100644
--- a/crates/app/src/editor.rs
+++ b/crates/app/src/editor.rs
@@ -201,6 +201,7 @@ fn union_box(a: Option<[f32; 4]>, b: Option<[f32; 4]>) -> Option<[f32; 4]> {
struct Direct {
node: String,
points: BTreeSet<usize>,
+ also: BTreeMap<String, BTreeSet<usize>>,
}
#[derive(Clone, Copy, Debug, PartialEq)]
@@ -223,9 +224,11 @@ struct PathCommit {
ops: Vec<Op>,
cel: String,
preview: Vec<Subpath>,
+ also: Vec<Shaped>,
node: String,
}
+#[derive(Clone)]
struct Shaped {
node: String,
rev: u64,
@@ -688,6 +691,7 @@ pub(crate) struct Editor {
shaped: Option<Shaped>,
point_drag: Option<PointDrag>,
pick_later: bool,
+ also_shaped: Vec<Shaped>,
path_commit: Option<PathCommit>,
simplify_px: f32,
under: Vec<String>,
@@ -867,6 +871,7 @@ impl Editor {
shaped: None,
point_drag: None,
pick_later: false,
+ also_shaped: Vec::new(),
path_commit: None,
simplify_px: 1.5,
under: Vec::new(),
@@ -2017,37 +2022,56 @@ impl Editor {
Ok(())
}
- fn refresh_shape(&mut self) {
+ fn shape_of(&self, id: &str) -> Option<Shaped> {
let rev = self.scene.bundle.doc.rev;
- let Some(id) = self.direct.as_ref().map(|d| d.node.clone()) else {
- self.shaped = None;
- return;
- };
- if self.shaped.as_ref().is_some_and(|s| s.node == id && s.rev == rev) {
- return;
- }
- if let Some(subs) = self.stroke_path(&id) {
- self.shaped = Some(Shaped {
- node: id,
+ if let Some(subs) = self.stroke_path(id) {
+ return Some(Shaped {
+ node: id.to_string(),
rev,
subs,
matrix: [1.0, 0.0, 0.0, 1.0, 0.0, 0.0],
});
- return;
}
let doc = &self.scene.bundle.doc;
- self.shaped = match doc.item(&id) {
+ match doc.item(id) {
Some(Item::Node(_, _, node)) => pathedit::from_shape(&node.shape)
.ok()
- .zip(overlay::local_to_canvas(doc, &id).ok().flatten())
+ .zip(overlay::local_to_canvas(doc, id).ok().flatten())
.map(|(subs, matrix)| Shaped {
- node: id,
+ node: id.to_string(),
rev,
subs,
matrix,
}),
_ => None,
+ }
+ }
+
+ fn refresh_shape(&mut self) {
+ let rev = self.scene.bundle.doc.rev;
+ let Some(direct) = self.direct.as_ref() else {
+ self.shaped = None;
+ self.also_shaped.clear();
+ return;
};
+ let (id, also): (String, Vec<String>) = (direct.node.clone(), direct.also.keys().cloned().collect());
+ if !self.shaped.as_ref().is_some_and(|s| s.node == id && s.rev == rev) {
+ self.shaped = self.shape_of(&id);
+ }
+ let kept = std::mem::take(&mut self.also_shaped);
+ self.also_shaped = also
+ .iter()
+ .filter_map(|id| {
+ kept.iter()
+ .find(|s| s.node == *id && s.rev == rev)
+ .cloned()
+ .or_else(|| self.shape_of(id))
+ })
+ .collect();
+ let alive: Vec<&String> = self.also_shaped.iter().map(|s| &s.node).collect();
+ if let Some(d) = self.direct.as_mut() {
+ d.also.retain(|id, points| alive.contains(&id) && !points.is_empty());
+ }
}
fn point_edit(&self, drag: &PointDrag) -> Option<PathEdit> {
@@ -2069,6 +2093,31 @@ impl Editor {
}
}
+ fn spread(&self, edit: &PathEdit) -> Vec<(Shaped, PathEdit)> {
+ let (Some(direct), Some(first)) = (self.direct.as_ref(), self.shaped.as_ref()) else {
+ return Vec::new();
+ };
+ let all = |points: &[usize]| points.iter().copied().collect::<BTreeSet<usize>>() == direct.points;
+ self.also_shaped
+ .iter()
+ .filter_map(|shaped| {
+ let points: Vec<usize> = direct.also.get(&shaped.node)?.iter().copied().collect();
+ let theirs = match edit {
+ PathEdit::Move { points: of, by } if all(of) => {
+ let moved = to_canvas(first.matrix, *by) - to_canvas(first.matrix, [0.0, 0.0]);
+ let by = to_local(shaped.matrix, to_canvas(shaped.matrix, [0.0, 0.0]) + moved);
+ PathEdit::Move { points, by }
+ }
+ PathEdit::Remove { points: of } if all(of) => PathEdit::Remove { points },
+ PathEdit::Corner { points: of } if all(of) => PathEdit::Corner { points },
+ PathEdit::Smooth { points: of } if all(of) => PathEdit::Smooth { points },
+ _ => return None,
+ };
+ Some((shaped.clone(), theirs))
+ })
+ .collect()
+ }
+
fn shown_subs(&self) -> Option<Vec<Subpath>> {
if let Some(commit) = self.path_commit.as_ref() {
return Some(commit.preview.clone());
@@ -2080,9 +2129,58 @@ impl Editor {
Some(subs)
}
+ fn shown_also(&self) -> Vec<Shaped> {
+ if let Some(commit) = self.path_commit.as_ref() {
+ return commit.also.clone();
+ }
+ let moved = self
+ .point_drag
+ .as_ref()
+ .and_then(|d| self.point_edit(d))
+ .map_or(Vec::new(), |edit| self.spread(&edit));
+ self.also_shaped
+ .iter()
+ .map(|shaped| {
+ let mut shown = shaped.clone();
+ if let Some((_, edit)) = moved.iter().find(|(s, _)| s.node == shaped.node) {
+ let _ = edit.apply(&mut shown.subs);
+ }
+ shown
+ })
+ .collect()
+ }
+
+ fn promote(&mut self, view: View, rect: Rect, pos: Pos2) {
+ let Some(direct) = self.direct.as_ref() else {
+ return;
+ };
+ let found = self.also_shaped.iter().find_map(|shaped| {
+ let chosen = direct.also.get(&shaped.node)?;
+ pathedit::anchors(&shaped.subs)
+ .iter()
+ .enumerate()
+ .any(|(i, (_, a))| {
+ chosen.contains(&i)
+ && self.screen(view, rect, to_canvas(shaped.matrix, a.at)).distance(pos) <= HANDLE
+ })
+ .then(|| shaped.node.clone())
+ });
+ let (Some(id), Some(d)) = (found, self.direct.as_mut()) else {
+ return;
+ };
+ let points = d.also.remove(&id).unwrap_or_default();
+ let before = (
+ std::mem::replace(&mut d.node, id),
+ std::mem::replace(&mut d.points, points),
+ );
+ d.also.insert(before.0, before.1);
+ self.refresh_shape();
+ }
+
fn direct_down(&mut self, view: View, rect: Rect, pos: Pos2, c: Vec2) -> Result<()> {
let (alt, shift) = (self.modifiers.alt, self.modifiers.shift);
self.pick_later = false;
+ self.promote(view, rect, pos);
enum Action {
Handle(usize, Side),
Anchor(usize, bool),
@@ -2142,6 +2240,7 @@ impl Editor {
}
} else if !d.points.contains(&i) {
d.points = BTreeSet::from([i]);
+ d.also.clear();
}
if d.points.contains(&i) {
self.point_drag = Some(PointDrag {
@@ -2155,7 +2254,7 @@ impl Editor {
}
Action::Insert(segment, t) => return self.commit_path(PathEdit::Insert { segment, t }),
Action::Elsewhere => {
- let on_shape = match self.direct.is_some() && !self.on_picked_shape(c)? {
+ let on_shape = match shift || (self.direct.is_some() && !self.on_picked_shape(c)?) {
true => {
self.pick_later = true;
Some(false)
@@ -2408,6 +2507,7 @@ impl Editor {
self.direct = Some(Direct {
node: id,
points: BTreeSet::new(),
+ also: BTreeMap::new(),
});
self.refresh_shape();
}
@@ -2438,31 +2538,52 @@ impl Editor {
(true, None) => {
if let Some(d) = self.direct.as_mut() {
d.points.clear();
+ d.also.clear();
}
}
(false, _) => self.direct = None,
}
return Ok(());
}
- let Some(shaped) = self.shaped.as_ref() else {
- return Ok(());
- };
let (lo, hi) = (drag.start.min(drag.now), drag.start.max(drag.now));
- let inside: Vec<usize> = pathedit::anchors(&shaped.subs)
- .iter()
- .enumerate()
- .filter(|(_, (_, a))| {
- let p = to_canvas(shaped.matrix, a.at);
- p.x >= lo.x && p.x <= hi.x && p.y >= lo.y && p.y <= hi.y
- })
- .map(|(i, _)| i)
- .collect();
- let adding = self.modifiers.shift;
- if let Some(d) = self.direct.as_mut() {
- if !adding {
- d.points.clear();
+ let boxed = |shaped: &Shaped| -> BTreeSet<usize> {
+ pathedit::anchors(&shaped.subs)
+ .iter()
+ .enumerate()
+ .filter(|(_, (_, a))| {
+ let p = to_canvas(shaped.matrix, a.at);
+ p.x >= lo.x && p.x <= hi.x && p.y >= lo.y && p.y <= hi.y
+ })
+ .map(|(i, _)| i)
+ .collect()
+ };
+ if self.modifiers.shift {
+ let found: Vec<(String, BTreeSet<usize>)> = self
+ .layer_shapes([lo.x, lo.y, hi.x, hi.y])
+ .iter()
+ .filter_map(|id| self.shape_of(id))
+ .map(|shaped| (boxed(&shaped), shaped.node))
+ .filter(|(points, _)| !points.is_empty())
+ .map(|(points, id)| (id, points))
+ .collect();
+ if self.direct.is_none()
+ && let Some((id, _)) = found.first()
+ {
+ self.pick_shape(id.clone());
+ }
+ if let Some(d) = self.direct.as_mut() {
+ found.into_iter().for_each(|(id, points)| match id == d.node {
+ true => d.points.extend(points),
+ false => d.also.entry(id).or_default().extend(points),
+ });
}
- d.points.extend(inside);
+ self.refresh_shape();
+ return Ok(());
+ }
+ let inside = self.shaped.as_ref().map(boxed);
+ if let (Some(d), Some(inside)) = (self.direct.as_mut(), inside) {
+ d.points = inside;
+ d.also.clear();
}
Ok(())
}
@@ -2499,7 +2620,7 @@ impl Editor {
)])
}
- fn reshape_stroke(&mut self, id: String, edit: PathEdit) -> Result<()> {
+ fn reshape_stroke(&mut self, id: String, edit: PathEdit, also: Vec<(Shaped, PathEdit)>) -> Result<()> {
let Some(shaped) = self.shaped.as_ref().filter(|s| s.node == id) else {
return Ok(());
};
@@ -2514,16 +2635,38 @@ impl Editor {
{
d.points.clear();
}
- let props: Map<String, Value> = [("path".to_string(), json!(pathedit::to_d(&subs)))]
+ let removing = matches!(edit, PathEdit::Remove { .. });
+ let bent: Vec<Shaped> = also
.into_iter()
+ .filter_map(|(mut shaped, edit)| edit.apply(&mut shaped.subs).is_ok().then_some(shaped))
.collect();
- self.apply(vec![Op::Set { id: id.clone(), props }])?;
+ let set = |id: &str, subs: &[Subpath]| Op::Set {
+ id: id.to_string(),
+ props: [("path".to_string(), json!(pathedit::to_d(subs)))]
+ .into_iter()
+ .collect(),
+ };
+ let ops = std::iter::once(set(&id, &subs))
+ .chain(bent.iter().map(|shaped| set(&shaped.node, &shaped.subs)))
+ .collect();
+ self.apply(ops)?;
+ let rev = self.scene.bundle.doc.rev;
self.shaped = Some(Shaped {
node: id,
- rev: self.scene.bundle.doc.rev,
+ rev,
subs,
matrix: [1.0, 0.0, 0.0, 1.0, 0.0, 0.0],
});
+ self.also_shaped = std::mem::take(&mut self.also_shaped)
+ .into_iter()
+ .map(|shaped| {
+ let now = bent.iter().find(|b| b.node == shaped.node).cloned().unwrap_or(shaped);
+ Shaped { rev, ..now }
+ })
+ .collect();
+ if removing && let Some(d) = self.direct.as_mut() {
+ d.also.clear();
+ }
Ok(())
}
@@ -2534,8 +2677,10 @@ impl Editor {
if self.path_commit.is_some() {
return Ok(());
}
+ let also = self.spread(&edit);
+ let removing = matches!(edit, PathEdit::Remove { .. });
if markedit::parse_address(&id).is_some() {
- return self.reshape_stroke(id, edit);
+ return self.reshape_stroke(id, edit, also);
}
let doc = &self.scene.bundle.doc;
let Some(Loc::Node(path, c, _)) = doc.locate(&id) else {
@@ -2553,7 +2698,13 @@ impl Editor {
return Ok(());
}
let cel = layer.cels()[c].id.clone();
- let ops = vector::pinned(doc, &[Op::Path { id: id.clone(), edit }])?;
+ let edits: Vec<Op> = std::iter::once(Op::Path { id: id.clone(), edit })
+ .chain(also.iter().map(|(shaped, edit)| Op::Path {
+ id: shaped.node.clone(),
+ edit: edit.clone(),
+ }))
+ .collect();
+ let ops = vector::pinned(doc, &edits)?;
let (next, _) = apply_all(doc, &ops)?;
let nodes = match next.locate(&cel) {
Some(Loc::Cel(p, c)) => next.layer_at(&p).cels()[c].nodes.clone(),
@@ -2569,12 +2720,27 @@ impl Editor {
{
d.points.clear();
}
+ let also = self
+ .also_shaped
+ .iter()
+ .map(|shaped| Shaped {
+ subs: match next.item(&shaped.node) {
+ Some(Item::Node(_, _, n)) => pathedit::from_shape(&n.shape).unwrap_or_default(),
+ _ => Vec::new(),
+ },
+ ..shaped.clone()
+ })
+ .collect();
+ if removing && let Some(d) = self.direct.as_mut() {
+ d.also.clear();
+ }
let job = lift::render(nodes, self.scene.size(), self.ctx.clone());
self.path_commit = Some(PathCommit {
job,
ops,
cel,
preview,
+ also,
node: id,
});
Ok(())
@@ -3398,21 +3564,15 @@ impl Editor {
};
let m = shaped.matrix;
let screen = |p: [f32; 2]| self.screen(view, rect, to_canvas(m, p));
- let step = (2.0 / (view.zoom * (m[0] * m[3] - m[1] * m[2]).abs().sqrt()).max(1e-3)).clamp(0.05, 8.0);
- pathedit::flatten(&subs, step)
- .iter()
- .zip(&subs)
- .for_each(|(line, sub)| {
- let points: Vec<Pos2> = line.iter().map(|p| screen(*p)).collect();
- let shape = if sub.closed {
- egui::Shape::closed_line(points, egui::Stroke::new(1.5, accent))
- } else {
- egui::Shape::line(points, egui::Stroke::new(1.5, accent))
- };
- painter.add(shape);
- });
- let anchors = pathedit::anchors(&subs);
let thin = egui::Stroke::new(1.0, accent);
+ let none = BTreeSet::new();
+ self.shown_also().iter().for_each(|shown| {
+ self.outline_points(painter, view, rect, accent, &shown.subs, shown.matrix);
+ let chosen = direct.also.get(&shown.node).unwrap_or(&none);
+ self.square_points(painter, view, rect, accent, &shown.subs, shown.matrix, chosen);
+ });
+ self.outline_points(painter, view, rect, accent, &subs, m);
+ let anchors = pathedit::anchors(&subs);
direct.points.iter().filter_map(|&i| anchors.get(i)).for_each(|(_, a)| {
let at = screen(a.at);
[(a.inn, a.has_in()), (a.out, a.has_out())]
@@ -3425,17 +3585,7 @@ impl Editor {
painter.circle_stroke(h, HANDLE / 2.0 - 0.5, thin);
});
});
- let size = HANDLE - 2.0;
- anchors.iter().enumerate().for_each(|(i, (_, a))| {
- let square = Rect::from_center_size(screen(a.at), vec2(size, size));
- let fill = if direct.points.contains(&i) {
- accent
- } else {
- Color32::WHITE
- };
- painter.rect_filled(square, 0.0, fill);
- painter.rect_stroke(square, 0.0, thin, egui::StrokeKind::Middle);
- });
+ self.square_points(painter, view, rect, accent, &subs, m, &direct.points);
if let Some(drag) = self.point_drag.filter(|d| matches!(d.grab, PointGrab::Marquee { .. })) {
let (a, b) = (self.screen(view, rect, drag.start), self.screen(view, rect, drag.now));
let area = Rect::from_two_pos(a, b);
@@ -3444,6 +3594,95 @@ impl Editor {
}
}
+ fn outline_points(
+ &self,
+ painter: &egui::Painter,
+ view: View,
+ rect: Rect,
+ accent: Color32,
+ subs: &[Subpath],
+ m: [f32; 6],
+ ) {
+ let screen = |p: [f32; 2]| self.screen(view, rect, to_canvas(m, p));
+ let step = (2.0 / (view.zoom * (m[0] * m[3] - m[1] * m[2]).abs().sqrt()).max(1e-3)).clamp(0.05, 8.0);
+ pathedit::flatten(subs, step).iter().zip(subs).for_each(|(line, sub)| {
+ let points: Vec<Pos2> = line.iter().map(|p| screen(*p)).collect();
+ let shape = if sub.closed {
+ egui::Shape::closed_line(points, egui::Stroke::new(1.5, accent))
+ } else {
+ egui::Shape::line(points, egui::Stroke::new(1.5, accent))
+ };
+ painter.add(shape);
+ });
+ }
+
+ #[allow(clippy::too_many_arguments)]
+ fn square_points(
+ &self,
+ painter: &egui::Painter,
+ view: View,
+ rect: Rect,
+ accent: Color32,
+ subs: &[Subpath],
+ m: [f32; 6],
+ chosen: &BTreeSet<usize>,
+ ) {
+ let size = HANDLE - 2.0;
+ let thin = egui::Stroke::new(1.0, accent);
+ pathedit::anchors(subs).iter().enumerate().for_each(|(i, (_, a))| {
+ let at = self.screen(view, rect, to_canvas(m, a.at));
+ let square = Rect::from_center_size(at, vec2(size, size));
+ let fill = if chosen.contains(&i) { accent } else { Color32::WHITE };
+ painter.rect_filled(square, 0.0, fill);
+ painter.rect_stroke(square, 0.0, thin, egui::StrokeKind::Middle);
+ });
+ }
+
+ fn layer_shapes(&self, bounds: [f32; 4]) -> Vec<String> {
+ fn leaves(node: &Node, out: &mut Vec<String>) {
+ match &node.shape {
+ Shape::Group { children } => children.iter().for_each(|child| leaves(child, out)),
+ Shape::Rect { .. } | Shape::Ellipse { .. } | Shape::Path { .. } => out.push(node.id.clone()),
+ _ => {}
+ }
+ }
+ let doc = &self.scene.bundle.doc;
+ let of_cel = |nodes: &[Node]| {
+ let mut out = Vec::new();
+ nodes.iter().for_each(|node| leaves(node, &mut out));
+ out
+ };
+ if let Some(Loc::Node(path, c, _)) = self.direct.as_ref().and_then(|d| doc.locate(&d.node)) {
+ let layer = doc.layer_at(&path);
+ return match layer.locked {
+ true => Vec::new(),
+ false => of_cel(&layer.cels()[c].nodes),
+ };
+ }
+ let Some(layer) = self.scene.active_layer().filter(|l| !l.locked) else {
+ return Vec::new();
+ };
+ match (layer.kind(), self.scene.active_cel()) {
+ (Kind::Vector, _) => layer
+ .content_at(self.scene.frame)
+ .map_or(Vec::new(), |cel| of_cel(&cel.nodes)),
+ (_, Some(cel)) => self
+ .scene
+ .active_marks()
+ .iter()
+ .filter_map(|m| m.as_stroke())
+ .filter(|stroke| {
+ stroke.samples.iter().any(|sample| {
+ let (x, y) = sample.pos();
+ x >= bounds[0] && y >= bounds[1] && x <= bounds[2] && y <= bounds[3]
+ })
+ })
+ .map(|stroke| markedit::address(&cel, stroke.id))
+ .collect(),
+ _ => Vec::new(),
+ }
+ }
+
fn chosen_marks(&self) -> Option<(Picked, Vec<(String, Mark)>)> {
let picked = self.picked.clone()?;
let parts = self.picked_parts();
@@ -3804,6 +4043,13 @@ impl Editor {
},
direct.points.len()
));
+ if !direct.also.is_empty() {
+ ui.label(format!(
+ "and {} points on {} more on this layer: drag one to move them all",
+ direct.also.values().map(BTreeSet::len).sum::<usize>(),
+ direct.also.len()
+ ));
+ }
if !is_path {
ui.label(format!("any point edit turns this {kind} into a path"));
}
@@ -3834,7 +4080,7 @@ impl Editor {
}
}
ui.small(
- "drag points or handles; drag a box around points to select them, shift adds to the selection; drag one to move them all\n\
+ "drag points or handles; drag a box to select points of this shape, shift and drag a box for the points of every shape on the layer; drag one to move them all\n\
alt click the outline: new point; alt click a point: corner or smooth; alt drag a handle: break it",
);
if self.path_commit.is_some() {
diff --git a/crates/app/src/editor/ui_tests.rs b/crates/app/src/editor/ui_tests.rs
index 01fab7e..50bab1d 100644
--- a/crates/app/src/editor/ui_tests.rs
+++ b/crates/app/src/editor/ui_tests.rs
@@ -531,6 +531,7 @@ fn every_control_is_pen_sized_and_has_a_hover_hint() {
h.state_mut().direct = Some(Direct {
node: rect,
points: BTreeSet::from([0, 1]),
+ also: Default::default(),
});
h.run_steps(2);
checked += audit(&h, "points selected");
@@ -2608,6 +2609,129 @@ fn a_box_dragged_from_another_shape_picks_points_and_shift_adds_to_them() {
let _ = std::fs::remove_dir_all(&path);
}
+#[test]
+fn a_shift_box_picks_the_points_of_every_shape_on_the_layer_and_they_move_together() {
+ let path = sample("layer-box");
+ let mut bundle = Bundle::open(&path).unwrap();
+ let shapes = bundle.doc.find_layer("shapes").unwrap().id.clone();
+ bundle
+ .apply(
+ &parse_lines(&format!(
+ r##"{{"op":"add","node":{{"type":"rect","x":0,"y":0,"w":512,"h":384,"fill":"#203040"}},"in":"{shapes}","frame":0}}
+{{"op":"add","node":{{"type":"rect","x":200,"y":150,"w":80,"h":60,"fill":"#d0b040"}},"in":"{shapes}","frame":0}}
+{{"op":"add","node":{{"type":"rect","x":320,"y":150,"w":80,"h":60,"fill":"#40b0d0"}},"in":"{shapes}","frame":0}}"##
+ ))
+ .unwrap(),
+ )
+ .unwrap();
+ let (left, right) = {
+ let nodes = &bundle.doc.find_layer("shapes").unwrap().cels()[0].nodes;
+ (nodes[nodes.len() - 2].id.clone(), nodes[nodes.len() - 1].id.clone())
+ };
+ let mut h = harness(editor(&path), vec2(1440.0, 900.0));
+ activate(&mut h, "shapes");
+ h.key_press(Key::A);
+ h.run_steps(2);
+ let view = h.state().view.unwrap();
+ let rect = h.state().canvas_rect;
+ let at = |x: f32, y: f32| rect.min + view.to_screen(egui::Vec2::new(x, y), rect.size());
+ let chosen = |h: &Harness<'static, Editor>| -> Vec<(String, usize)> {
+ let direct = h.state().direct.clone().unwrap();
+ let mut all: Vec<(String, usize)> = std::iter::once((direct.node, direct.points.len()))
+ .chain(direct.also.into_iter().map(|(id, points)| (id, points.len())))
+ .collect();
+ all.sort();
+ all
+ };
+ let top = |h: &Harness<'static, Editor>, id: &str| match h.state().scene.bundle.doc.item(id) {
+ Some(klad_core::doc::Item::Node(_, _, node)) => klad_core::pathedit::from_shape(&node.shape)
+ .unwrap()
+ .iter()
+ .flat_map(|sub| sub.anchors.iter().map(|a| a.at[1]))
+ .fold(f32::MAX, f32::min),
+ _ => f32::NAN,
+ };
+ assert!(h.state().direct.is_none());
+ h.event(egui::Event::ModifiersChanged(Modifiers::SHIFT));
+ drag(&mut h, at(190.0, 140.0), at(410.0, 170.0));
+ h.event(egui::Event::ModifiersChanged(Modifiers::NONE));
+ h.run_steps(2);
+ let mut both = vec![(left.clone(), 2), (right.clone(), 2)];
+ both.sort();
+ assert_eq!(chosen(&h), both, "the top corners of both, and none of the background");
+ let corner = at(320.0, 150.0);
+ drag(&mut h, corner, corner + vec2(0.0, -30.0));
+ settle(&mut h, |ed| ed.point_drag.is_none() && ed.path_commit.is_none());
+ h.run_steps(2);
+ let lifted = 150.0 - 30.0 / view.zoom;
+ assert!((top(&h, &left) - lifted).abs() < 1.0, "left top at {}", top(&h, &left));
+ assert!(
+ (top(&h, &right) - lifted).abs() < 1.0,
+ "right top at {}",
+ top(&h, &right)
+ );
+ assert_eq!(chosen(&h), both, "the points stay selected after the move");
+ h.state_mut().invoke(Cmd::Undo).unwrap();
+ settle(&mut h, |ed| ed.path_commit.is_none());
+ h.run_steps(2);
+ assert_eq!(
+ (top(&h, &left), top(&h, &right)),
+ (150.0, 150.0),
+ "one undo takes both back"
+ );
+ let picked = h.state().direct.as_ref().unwrap().node.clone();
+ let x = if picked == left { 190.0 } else { 310.0 };
+ drag(&mut h, at(x, 195.0), at(x + 100.0, 225.0));
+ h.run_steps(2);
+ assert_eq!(chosen(&h), vec![(picked, 2)], "a plain box picks on the one shape only");
+ let _ = std::fs::remove_dir_all(&path);
+}
+
+#[test]
+fn a_shift_box_on_a_paint_layer_bends_several_strokes_at_once() {
+ let path = sample("stroke-box");
+ let mut h = harness(editor(&path), vec2(1440.0, 900.0));
+ activate(&mut h, "lines");
+ h.key_press(Key::A);
+ h.run_steps(2);
+ let view = h.state().view.unwrap();
+ let rect = h.state().canvas_rect;
+ let at = |x: f32, y: f32| rect.min + view.to_screen(egui::Vec2::new(x, y), rect.size());
+ let starts = |h: &Harness<'static, Editor>| -> Vec<(f32, f32)> {
+ h.state()
+ .scene
+ .bundle
+ .read_marks("l6", "c6")
+ .unwrap()
+ .iter()
+ .filter_map(|m| m.as_stroke())
+ .map(|stroke| stroke.samples[0].pos())
+ .collect()
+ };
+ let before = starts(&h);
+ h.event(egui::Event::ModifiersChanged(Modifiers::SHIFT));
+ drag(&mut h, at(25.0, 25.0), at(75.0, 315.0));
+ h.event(egui::Event::ModifiersChanged(Modifiers::NONE));
+ h.run_steps(2);
+ let direct = h.state().direct.clone().unwrap();
+ assert_eq!(
+ (direct.points.len(), direct.also.len()),
+ (1, 1),
+ "the start of each stroke"
+ );
+ let first = h.state().shaped.as_ref().unwrap().subs[0].anchors[0].at;
+ let start = at(first[0], first[1]);
+ drag(&mut h, start, start + vec2(40.0, 0.0));
+ settle(&mut h, |ed| ed.point_drag.is_none());
+ h.run_steps(2);
+ let moved: Vec<f32> = starts(&h).iter().zip(&before).map(|(a, b)| a.0 - b.0).collect();
+ assert!(
+ moved.iter().all(|by| (by - 40.0 / view.zoom).abs() < 3.0),
+ "both starts moved: {moved:?}"
+ );
+ let _ = std::fs::remove_dir_all(&path);
+}
+
#[test]
fn a_bends_a_brush_stroke_and_the_stroke_keeps_its_pressure() {
let path = sample("reshape");
diff --git a/docs/guide/shapes-and-text.md b/docs/guide/shapes-and-text.md
index c980e0a..c8d5620 100644
--- a/docs/guide/shapes-and-text.md
+++ b/docs/guide/shapes-and-text.md
@@ -1,4 +1,4 @@
-_Last updated: 2026-11-10 09:30_
+_Last updated: 2026-11-10 10:30_
# Shapes, paths and text
@@ -16,7 +16,7 @@ Press **P**, click to place corners and drag to pull out curves. Click the first
Press **A**, click the shape and drag its points and handles. Alt click on the outline adds a point.
-To move several points together, drag a box around them, then drag one of them. **Shift** adds a box or a click to the points you have.
+To move several points together, drag a box around them, then drag one of them. Hold **shift** while you drag the box to take the points of every shape on the layer, not only the one you clicked.
## Fill a shape with a gradient