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.lockindex 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.tomlindex 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.rsindex 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.rsindex 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.mdindex 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 firstPress **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