mirror of
https://github.com/storytold/photocraft.git
synced 2026-11-21 09:26:43 +00:00
Pen: carry on a shape's or vector mask's open path, and show the continue pointer (#9356)
A Pen press on an endpoint of an open path carried it on only for the Work Path or a saved path (#6593). In Shape mode the press started a new shape layer, and on a targeted vector mask a new subpath, so a pen shape could not be continued once drawing stopped. Now the selected shape layer's path (Shape mode) and the targeted vector mask resume like the Work Path, and the commit updates the same layer in one History step (shape.edit / layer.vectorMask.edit). Nothing showed that the endpoints can be clicked, either: the Pen now shows Photoshop's continue-path pointer (the cross with a slash) over an endpoint it would carry on from. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_016NgLQVizswqgNnzBv1taRD
This commit is contained in:
1 parent
b0622d20ca
commit
6cbcd89f0c
5 files changed
+150
-16
No files matched your search
@@ -4835,6 +4835,15 @@ pub fn canvas_view(app: &mut PhotocraftApp, ui: &mut egui::Ui, idx: usize, rect:
|
||||
{
|
||||
crate::tool_cursor::close_path(&painter, p)
|
||||
}
|
||||
// Over an endpoint of an open path, the continue-path pointer (#9356).
|
||||
Tool::Pen
|
||||
if {
|
||||
let [x, y] = xf.to_doc(p);
|
||||
crate::vector_ui::continues_path_at(app, tool, x, y)
|
||||
} =>
|
||||
{
|
||||
crate::tool_cursor::continue_path(&painter, p)
|
||||
}
|
||||
// The pen tools: their own icon with its nib on the point, or the crosshair for
|
||||
// precise Other Cursors (#4639).
|
||||
Tool::Pen | Tool::FreeformPen | Tool::CurvaturePen | Tool::AddAnchorPoint | Tool::DeleteAnchorPoint | Tool::ConvertPoint => {
|
||||
|
||||
@@ -273,3 +273,65 @@ fn undo_in_a_resumed_draft_stops_at_the_paths_own_anchors() {
|
||||
assert!(app.ui.direct_selection.anchors.is_empty());
|
||||
assert_eq!(work_path(&app), before, "the path is as it was");
|
||||
}
|
||||
|
||||
/// #9356: in Shape mode a Pen press on an endpoint of the selected shape layer's open path carries
|
||||
/// that path on, from either end, and the commit updates the same layer in one History step
|
||||
/// instead of making a new shape layer. Elsewhere the press starts a new shape as before.
|
||||
#[test]
|
||||
fn shape_mode_carries_on_the_selected_shapes_open_path() {
|
||||
let mut app = app(Tool::Pen);
|
||||
app.ui.tool_options.vector_mode = "shape".into();
|
||||
let layers = |app: &PhotocraftApp| app.session.active().unwrap().doc.layers.len();
|
||||
let shape = |app: &PhotocraftApp| {
|
||||
let st = app.session.active().unwrap();
|
||||
match &st.doc.layer(st.active_layer.unwrap()).unwrap().content {
|
||||
LayerContent::Shape(sh) => {
|
||||
sh.path.subpaths.iter().map(|s| s.knots.iter().map(|k| [k.anchor.x, k.anchor.y]).collect::<Vec<_>>()).collect::<Vec<_>>()
|
||||
}
|
||||
other => panic!("not a shape layer: {other:?}"),
|
||||
}
|
||||
};
|
||||
let steps = |app: &PhotocraftApp| app.session.active().unwrap().history.past_len();
|
||||
click(&mut app, 20.0, 20.0);
|
||||
click(&mut app, 80.0, 20.0);
|
||||
crate::vector_ui::pen_commit(&mut app, false);
|
||||
let (n, before) = (layers(&app), steps(&app));
|
||||
assert!(crate::vector_ui::continues_path_at(&app, Tool::Pen, 81.0, 21.0), "the continue pointer over the endpoint");
|
||||
assert!(!crate::vector_ui::continues_path_at(&app, Tool::Pen, 50.0, 20.0), "not mid-segment");
|
||||
click(&mut app, 80.0, 20.0);
|
||||
click(&mut app, 80.0, 80.0);
|
||||
crate::vector_ui::pen_commit(&mut app, false);
|
||||
assert_eq!(layers(&app), n, "no new shape layer");
|
||||
assert_eq!(steps(&app), before + 1, "one History step");
|
||||
assert_eq!(shape(&app), [vec![[20.0, 20.0], [80.0, 20.0], [80.0, 80.0]]]);
|
||||
// From the first anchor, reversed.
|
||||
click(&mut app, 20.0, 20.0);
|
||||
click(&mut app, 20.0, 80.0);
|
||||
crate::vector_ui::pen_commit(&mut app, false);
|
||||
assert_eq!(shape(&app), [vec![[80.0, 80.0], [80.0, 20.0], [20.0, 20.0], [20.0, 80.0]]]);
|
||||
// Anywhere else: a new shape layer.
|
||||
click(&mut app, 150.0, 150.0);
|
||||
click(&mut app, 200.0, 150.0);
|
||||
crate::vector_ui::pen_commit(&mut app, false);
|
||||
assert_eq!(layers(&app), n + 1);
|
||||
}
|
||||
|
||||
/// #9356: with a vector mask targeted, the Pen carries on the mask's open subpath in place.
|
||||
#[test]
|
||||
fn a_targeted_vector_mask_carries_on_its_open_path() {
|
||||
let mut app = app(Tool::Pen);
|
||||
let id = app.session.active().unwrap().active_layer.unwrap();
|
||||
let open = json!({"subpaths": [{"closed": false, "knots": [{"anchor": [20.0, 20.0]}, {"anchor": [80.0, 20.0]}]}]});
|
||||
app.run("layer.vectorMask.add", json!({"layer": id.0, "path": open})).unwrap();
|
||||
app.ui.vector_mask_target = true;
|
||||
let mask = |app: &PhotocraftApp| {
|
||||
let st = app.session.active().unwrap();
|
||||
let p = &st.doc.layer(id).unwrap().vector_mask.as_ref().unwrap().path;
|
||||
p.subpaths.iter().map(|s| s.knots.len()).collect::<Vec<_>>()
|
||||
};
|
||||
assert_eq!(mask(&app), [2]);
|
||||
click(&mut app, 80.0, 20.0);
|
||||
click(&mut app, 80.0, 80.0);
|
||||
crate::vector_ui::pen_commit(&mut app, false);
|
||||
assert_eq!(mask(&app), [3], "the same subpath, extended");
|
||||
}
|
||||
@@ -88,6 +88,16 @@ pub(crate) fn close_path(painter: &Painter, at: Pos2) -> CursorIcon {
|
||||
outline(painter, at, vec![close_ring()], true)
|
||||
}
|
||||
|
||||
/// The Pen's pointer over an endpoint a click would carry the path on from (#9356): the centre
|
||||
/// cross with a short slash below right, as Photoshop's pen shows one there.
|
||||
pub(crate) fn continue_path(painter: &Painter, at: Pos2) -> CursorIcon {
|
||||
outline(painter, at, vec![continue_slash()], true)
|
||||
}
|
||||
|
||||
fn continue_slash() -> Vec<Vec2> {
|
||||
[(6.5, 12.5), (11.5, 5.5), (12.5, 6.5), (7.5, 13.5)].into_iter().map(|(x, y)| vec2(x, y)).collect()
|
||||
}
|
||||
|
||||
fn close_ring() -> Vec<Vec2> {
|
||||
(0..16).map(|i| (i as f32 / 16.0 * std::f32::consts::TAU, vec2(9.0, 9.0))).map(|(a, c)| c + vec2(a.cos(), a.sin()) * 3.5).collect()
|
||||
}
|
||||
|
||||
@@ -599,3 +599,16 @@ fn type_path_cursors_are_small_and_centred() {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// #9356: the continue-path pointer is the centre cross with a slash below right.
|
||||
#[test]
|
||||
fn continue_path_bitmap_has_the_centre_cross_and_a_slash_beside_it() {
|
||||
for scale in [1.0, 2.0] {
|
||||
let image = rasterize(&Shape::Outline { rings: vec![continue_slash()].into(), centre: true }, scale).unwrap();
|
||||
let [x, y] = image.hotspot;
|
||||
let at = |dx: f32, dy: f32| alpha(&image, x + (dx * scale) as u16, y + (dy * scale) as u16);
|
||||
assert!(at(0.0, 0.0) > 230, "the centre cross");
|
||||
assert!(at(9.5, 9.5) > 0, "the slash");
|
||||
assert_eq!(at(0.0, 9.0), 0, "apart from the cross");
|
||||
}
|
||||
}
|
||||
@@ -52,6 +52,10 @@ pub struct Resumed {
|
||||
pub path: String,
|
||||
pub index: usize,
|
||||
pub was: photocraft_doc::vector::Subpath,
|
||||
/// The layer whose shape path (Shape mode) or targeted vector mask the subpath is in (#9356);
|
||||
/// `None` for the Paths panel's path `path`.
|
||||
#[serde(default)]
|
||||
pub layer: Option<u64>,
|
||||
}
|
||||
|
||||
impl PenPath {
|
||||
@@ -237,6 +241,12 @@ pub fn closes_path_at(app: &PhotocraftApp, tool: Tool, x: f64, y: f64) -> bool {
|
||||
}
|
||||
}
|
||||
|
||||
/// Would a Pen click at `(x, y)` carry on an open path from its endpoint there (#6593)? The canvas
|
||||
/// shows Photoshop's continue-path pointer there (#9356), as the endpoints look like any anchor.
|
||||
pub fn continues_path_at(app: &PhotocraftApp, tool: Tool, x: f64, y: f64) -> bool {
|
||||
tool == Tool::Pen && app.ui.pen.as_ref().is_none_or(|p| p.knots.is_empty()) && resume_at(app, x, y, 6.0 / app.point_zoom().max(0.01) as f64).is_some()
|
||||
}
|
||||
|
||||
/// Pen press: close on the first anchor, reshape the last anchor's outgoing handle,
|
||||
/// or add a new anchor (dragging a new anchor pulls symmetrical handles). With ⇧ a new anchor
|
||||
/// lands on the nearest 45° ray from the previous one, at the pointer's projection onto it.
|
||||
@@ -546,7 +556,12 @@ fn commit_path(app: &mut PhotocraftApp, pen: &PenPath, closed: bool) {
|
||||
return;
|
||||
}
|
||||
let path = pen_to_json(pen, closed);
|
||||
let r = if app.ui.tool_options.vector_mode == "shape" {
|
||||
let resumed = pen.resumes.as_ref().and_then(|r| app.session.active().and_then(|st| with_resumed_subpath(&st.doc, r, &path)).map(|p| (r, p)));
|
||||
let r = if let Some((Resumed { layer: Some(id), .. }, p)) = &resumed {
|
||||
// A shape layer's path or a vector mask carried on (#9356): the same layer, one step.
|
||||
let shape = app.session.active().and_then(|st| st.doc.layer(photocraft_doc::LayerId(*id))).is_some_and(|l| matches!(l.content, LayerContent::Shape(_)));
|
||||
app.run(if shape { "shape.edit" } else { "layer.vectorMask.edit" }, json!({"layer": id, "path": p}))
|
||||
} else if app.ui.tool_options.vector_mode == "shape" {
|
||||
let fill = if closed { fill_param(app) } else { Value::Null };
|
||||
let stroke = if closed {
|
||||
stroke_param(app)
|
||||
@@ -557,10 +572,9 @@ fn commit_path(app: &mut PhotocraftApp, pen: &PenPath, closed: bool) {
|
||||
stroke
|
||||
};
|
||||
app.run("shape.create", json!({"kind": "path", "path": path, "fill": fill, "stroke": stroke}))
|
||||
} else if let Some((name, p)) =
|
||||
pen.resumes.as_ref().and_then(|r| app.session.active().and_then(|st| with_resumed_subpath(&st.doc, r, &path)).map(|p| (r.path.clone(), p)))
|
||||
{
|
||||
} else if let Some((r, p)) = resumed {
|
||||
// The resumed subpath, carried on, takes its old place: one step, no second subpath.
|
||||
let name = r.path.clone();
|
||||
app.run("path.set", json!({"name": name, "path": p})).inspect(|_| app.ui.selected_path = Some(name))
|
||||
} else if let Some((id, existing)) = targeted_vector_mask(app) {
|
||||
// A targeted vector mask takes the new subpath (#196), as in Photoshop.
|
||||
@@ -576,7 +590,8 @@ fn commit_path(app: &mut PhotocraftApp, pen: &PenPath, closed: bool) {
|
||||
// A resumed draft whose subpath changed meanwhile joins the path it came from, as a new
|
||||
// subpath, even with nothing selected in the Paths panel.
|
||||
let exists = |n: &String| app.session.active().is_some_and(|st| path_exists(&st.doc, n));
|
||||
let resumed_from = pen.resumes.as_ref().filter(|r| app.session.active().is_some_and(|st| st.doc.id.0 == r.doc)).map(|r| r.path.clone());
|
||||
let resumed_from =
|
||||
pen.resumes.as_ref().filter(|r| r.layer.is_none() && app.session.active().is_some_and(|st| st.doc.id.0 == r.doc)).map(|r| r.path.clone());
|
||||
let target = resumed_from.filter(exists).or_else(|| app.ui.selected_path.clone().filter(exists));
|
||||
let name = target.clone().unwrap_or_else(|| "work".into());
|
||||
let mut params = json!({"name": name, "path": path});
|
||||
@@ -601,19 +616,44 @@ fn doc_path<'a>(doc: &'a Document, name: &str) -> Option<&'a Path> {
|
||||
if name == "work" { doc.work_path.as_ref() } else { doc.paths.iter().find(|p| p.name == name).map(|p| &p.path) }
|
||||
}
|
||||
|
||||
/// The open subpath of the path a new Pen path would join (the one selected in the Paths panel,
|
||||
/// else the work path) that has its first or last anchor at `(x, y)`, as a Pen path to carry on
|
||||
/// drawing from there (#6593). Its knots run towards that anchor: reversed, handles swapped, when
|
||||
/// it is the first. Shape mode and a targeted vector mask take new paths, so they resume nothing.
|
||||
fn resume_at(app: &PhotocraftApp, x: f64, y: f64, tol: f64) -> Option<PenPath> {
|
||||
if app.ui.tool_options.vector_mode == "shape" || targeted_vector_mask(app).is_some() {
|
||||
return None;
|
||||
/// The path of `layer` that the Pen draws into: a shape layer's own path, else its vector mask.
|
||||
fn layer_path(doc: &Document, layer: u64) -> Option<&Path> {
|
||||
let l = doc.layer(photocraft_doc::LayerId(layer))?;
|
||||
match &l.content {
|
||||
LayerContent::Shape(sh) => Some(&sh.path),
|
||||
_ => l.vector_mask.as_ref().map(|m| &m.path),
|
||||
}
|
||||
}
|
||||
|
||||
/// The path a resumed subpath is in, if it is still in `r`'s document.
|
||||
fn resumed_path<'a>(doc: &'a Document, r: &Resumed) -> Option<&'a Path> {
|
||||
(doc.id.0 == r.doc).then_some(())?;
|
||||
match r.layer {
|
||||
Some(id) => layer_path(doc, id),
|
||||
None => doc_path(doc, &r.path),
|
||||
}
|
||||
}
|
||||
|
||||
/// The open subpath of the path a new Pen path would go into that has its first or last anchor at
|
||||
/// `(x, y)`, as a Pen path to carry on drawing from there (#6593). That path is the selected shape
|
||||
/// layer's in Shape mode, the targeted vector mask's (#9356), else the one selected in the Paths
|
||||
/// panel or the work path. Its knots run towards that anchor: reversed, handles swapped, when it is
|
||||
/// the first.
|
||||
fn resume_at(app: &PhotocraftApp, x: f64, y: f64, tol: f64) -> Option<PenPath> {
|
||||
let st = app.session.active()?;
|
||||
let doc = st.doc.id.0;
|
||||
let name = app.ui.selected_path.clone().filter(|n| path_exists(&st.doc, n)).unwrap_or_else(|| "work".into());
|
||||
let (name, layer, path) = if app.ui.tool_options.vector_mode == "shape" {
|
||||
let (id, _) = active_shape_path(app)?;
|
||||
("layer".to_string(), Some(id), layer_path(&st.doc, id)?)
|
||||
} else if let Some((id, _)) = targeted_vector_mask(app) {
|
||||
("layer".to_string(), Some(id), layer_path(&st.doc, id)?)
|
||||
} else {
|
||||
let name = app.ui.selected_path.clone().filter(|n| path_exists(&st.doc, n)).unwrap_or_else(|| "work".into());
|
||||
let path = doc_path(&st.doc, &name)?;
|
||||
(name, None, path)
|
||||
};
|
||||
let near = |k: &photocraft_doc::Knot| (k.anchor.x - x).hypot(k.anchor.y - y) < tol;
|
||||
doc_path(&st.doc, &name)?.subpaths.iter().enumerate().filter(|(_, s)| !s.closed).find_map(|(i, s)| {
|
||||
path.subpaths.iter().enumerate().filter(|(_, s)| !s.closed).find_map(|(i, s)| {
|
||||
let reversed = if s.knots.last().is_some_and(near) {
|
||||
false
|
||||
} else if s.knots.first().is_some_and(near) {
|
||||
@@ -629,7 +669,7 @@ fn resume_at(app: &PhotocraftApp, x: f64, y: f64, tol: f64) -> Option<PenPath> {
|
||||
}
|
||||
}
|
||||
let unlinked = knots.iter().enumerate().filter(|(_, (_, smooth))| !smooth).map(|(i, _)| i).collect();
|
||||
let resumes = Resumed { doc, path: name.clone(), index: i, was: s.clone() };
|
||||
let resumes = Resumed { doc, path: name.clone(), index: i, was: s.clone(), layer };
|
||||
Some(PenPath { knots: knots.into_iter().map(|(k, _)| k).collect(), unlinked, resumes: Some(resumes), ..Default::default() })
|
||||
})
|
||||
}
|
||||
@@ -638,7 +678,7 @@ fn resume_at(app: &PhotocraftApp, x: f64, y: f64, tol: f64) -> Option<PenPath> {
|
||||
/// anchors and closing, which keeps its other settings (its path operation). `None` when the
|
||||
/// subpath is no longer the one drawing resumed (another document, or the path changed).
|
||||
fn with_resumed_subpath(doc: &Document, r: &Resumed, drawn: &Value) -> Option<Value> {
|
||||
let path = doc_path(doc, &r.path).filter(|_| doc.id.0 == r.doc)?;
|
||||
let path = resumed_path(doc, r)?;
|
||||
if path.subpaths.get(r.index) != Some(&r.was) {
|
||||
return None;
|
||||
}
|
||||
|
||||
Reference in new issue
Block a user