Files
photocraft/crates/ui-egui/src/vector_ui.rs
T
David MannandClaude Opus 5.5 f5533e5d82 Integration: merge main into batch 6
Main merged #5940, #6472, #7838 and #7922 directly. Kept from the batch:
the snapshot/History-follow identity at the history limit (#5940,
c7ef3676a; main still had the 3-tuple HistorySpot) and the strokeless
shape at a 0 px width step (#6472, 962539607; main still added the
stroke). Main already carries the other two fix-ups (34c9d0ea4, dff8bfd0e).

Overlaps with main resolved:
- #5842 vs main's #5568: one path, apply_color, tool-gated as #5842
  has it, with #5568's float fill, kept fill opacity and lock skip;
  shape_fill_ui's duplicate foreground_changed/gesture dropped; #5568's
  tests run with a shape tool.
- #6230 vs main's #5180: one Type tool path click (path_target), no
  second type.attachToPath; vertical type does not start type on a path,
  as main has it; main's path_at/path_cursor and canvas arm dropped.
- #5452 moved the shape swatch to shape_paint_ui.rs: main's hex field
  (#6201) ported there.
- type_extra_cmds::with_text takes main's dpi form, pub(crate) for
  type_area_cmds.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-22 19:20:26 +02:00

3347 lines
164 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! Vector tools: Shape tools (U), Pen (P), Path Selection (A), path overlays and the Paths panel.
//! Direct Selection (A) lives in `direct_select`.
//! All edits go through the engine's `shape.*` / `path.*` commands.
use egui::{Color32, Pos2, Rect, Sense, Stroke, pos2, vec2};
use photocraft_doc::vector::Path;
use photocraft_doc::{Document, LayerContent};
use photocraft_geom::Affine;
use serde::{Deserialize, Serialize};
use serde_json::{Value, json};
use crate::PhotocraftApp;
use crate::canvas::ViewXform;
use crate::shape_paint_ui::{PaintChange, swatch};
use crate::state::{Tool, ToolOptions};
use crate::theme::Tokens;
/// Pen tool path under construction: knots as [anchor, in, out] (document px).
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
pub struct PenPath {
pub knots: Vec<[[f64; 2]; 3]>,
/// Indices of cusp knots whose incoming and outgoing handles are not linked.
#[serde(default)]
pub unlinked: Vec<usize>,
#[serde(skip)]
pub dragging: bool,
/// Re-dragging the final anchor changes its outgoing control only; the incoming curve stays put.
#[serde(skip)]
pub adjusting_last: bool,
/// ⌥/Alt-dragging the final anchor's incoming handle: it turns alone (#6077).
#[serde(skip)]
pub adjusting_in: bool,
/// Drawn with the Curvature Pen: handles follow the anchors (`curvature_refresh`) and
/// `unlinked` lists its corner points.
#[serde(default)]
pub curvature: bool,
/// Curvature Pen: the anchor being dragged.
#[serde(skip)]
pub moving: Option<usize>,
/// Drawing carries on from an endpoint of this open subpath of a document path (#6593): the
/// commit replaces that subpath instead of adding one.
#[serde(default)]
pub resumes: Option<Resumed>,
}
/// The subpath a Pen path carries on: where it is and what it was when drawing resumed. The
/// commit replaces it only while it is still that subpath of that document; otherwise (another
/// document, or the path changed meanwhile) the drawing is added as a new subpath.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Resumed {
pub doc: u64,
pub path: String,
pub index: usize,
pub was: photocraft_doc::vector::Subpath,
}
impl PenPath {
/// Does `tool` keep drawing this path? Another tool finishes it.
pub fn drawn_with(&self, tool: Tool) -> bool {
tool == if self.curvature { Tool::CurvaturePen } else { Tool::Pen }
}
}
pub fn is_shape_tool(t: Tool) -> bool {
matches!(t, Tool::Rectangle | Tool::EllipseShape | Tool::Triangle | Tool::Polygon | Tool::Line | Tool::CustomShape)
}
fn rgb32(c: [f32; 4]) -> Color32 {
let b = |v: f32| (v.clamp(0.0, 1.0) * 255.0).round() as u8;
Color32::from_rgb(b(c[0]), b(c[1]), b(c[2]))
}
fn hex(c: [f32; 4]) -> String {
let c = rgb32(c);
format!("#{:02x}{:02x}{:02x}", c.r(), c.g(), c.b())
}
fn stroke_param(app: &PhotocraftApp) -> Value {
let o = &app.ui.tool_options;
if o.stroke_width <= 0.0 {
return Value::Null;
}
let mut p = o.shape_stroke.params();
p["width"] = json!(o.stroke_width);
p["color"] = json!(app.session.tools.background);
p
}
/// Geometry of a Shape-tool drag as `shape.create` params, without fill and stroke (None when too
/// small): ⇧ constrains proportions, ⌥ draws from the centre. Custom shapes give their box as a `rect`.
fn shape_geometry(o: &ToolOptions, tool: Tool, start: [f64; 2], end: [f64; 2], mods: egui::Modifiers) -> Option<Value> {
Some(if tool == Tool::Line {
let (mut dx, mut dy) = (end[0] - start[0], end[1] - start[1]);
if mods.shift {
// Snap to 45°.
let a = (dy.atan2(dx) / std::f64::consts::FRAC_PI_4).round() * std::f64::consts::FRAC_PI_4;
let len = dx.hypot(dy);
(dx, dy) = (len * a.cos(), len * a.sin());
}
if dx.hypot(dy) < 1.0 {
return None;
}
json!({"kind": "line", "from": start, "to": [start[0] + dx, start[1] + dy], "weight": o.line_weight.max(1.0)})
} else {
let (mut w, mut h) = (end[0] - start[0], end[1] - start[1]);
if mods.shift {
let m = w.abs().max(h.abs());
(w, h) = (m * w.signum(), m * h.signum());
}
let (x0, y0) = if mods.alt { (start[0] - w, start[1] - h) } else { (start[0], start[1]) };
let (w, h) = if mods.alt { (w * 2.0, h * 2.0) } else { (w, h) };
let rect = [x0.min(x0 + w).round(), y0.min(y0 + h).round(), w.abs().round(), h.abs().round()];
if rect[2] < 1.0 || rect[3] < 1.0 {
return None;
}
match tool {
Tool::Rectangle if o.corner_radius > 0.0 => json!({"kind": "roundedRect", "rect": rect, "radii": vec![o.corner_radius; 4]}),
Tool::Rectangle | Tool::CustomShape => json!({"kind": "rect", "rect": rect}),
Tool::EllipseShape => json!({"kind": "ellipse", "rect": rect}),
Tool::Triangle => json!({"kind": "polygon", "rect": rect, "sides": 3}),
_ => json!({"kind": "polygon", "rect": rect, "sides": o.polygon_sides.max(3)}),
}
})
}
/// The box `[x0, y0, x1, y1]` a Shape-tool drag draws (a line's: its ends'), which snaps while
/// Space repositions it (`snap_ui`). None when too small to draw.
pub fn shape_bounds(o: &ToolOptions, tool: Tool, start: [f64; 2], end: [f64; 2], mods: egui::Modifiers) -> Option<[f64; 4]> {
let g = shape_geometry(o, tool, start, end, mods)?;
if tool == Tool::Line {
let a: [f64; 2] = serde_json::from_value(g["from"].clone()).ok()?;
let b: [f64; 2] = serde_json::from_value(g["to"].clone()).ok()?;
return Some([a[0].min(b[0]), a[1].min(b[1]), a[0].max(b[0]), a[1].max(b[1])]);
}
let [x, y, w, h]: [f64; 4] = serde_json::from_value(g["rect"].clone()).ok()?;
Some([x, y, x + w, y + h])
}
/// Finish a Shape-tool drag: ⇧ constrains proportions, ⌥ draws from the centre.
pub fn finish_shape(app: &mut PhotocraftApp, tool: Tool, start: [f64; 2], end: [f64; 2], mods: egui::Modifiers) {
let Some(mut p) = shape_geometry(&app.ui.tool_options, tool, start, end, mods) else { return };
if tool == Tool::CustomShape {
// ⇧ keeps the shape's proportions (the rect is already squared).
if let Ok(rect) = serde_json::from_value(p["rect"].take()) {
let (fill, stroke) = (fill_param(app), stroke_param(app));
crate::preset_panels::finish_custom_shape(app, rect, mods.shift, fill, stroke);
}
return;
}
if let Err(e) = create_shape(app, p) {
app.ui.status = e;
app.ui.status_error = true;
}
}
fn fill_param(app: &PhotocraftApp) -> Value {
if app.ui.tool_options.shape_fill { json!(app.session.tools.foreground) } else { Value::Null }
}
/// Create a shape layer from `shape.create` geometry with the options bar's fill and stroke: the
/// end of a drag, and the Create Rectangle / Ellipse / … dialogs (`shape_dialog`).
pub fn create_shape(app: &mut PhotocraftApp, mut geometry: Value) -> Result<Value, String> {
geometry["fill"] = fill_param(app);
geometry["stroke"] = stroke_param(app);
app.run("shape.create", geometry)
}
/// The preview and command both use the full float tool colours, including transparent paint.
fn shape_preview(app: &PhotocraftApp, tool: Tool, start: [f64; 2], end: [f64; 2], mods: egui::Modifiers) -> Option<photocraft_doc::ShapeLayer> {
let o = &app.ui.tool_options;
let geometry = shape_geometry(o, tool, start, end, mods)?;
let path = if tool == Tool::CustomShape {
let rect = geometry.get("rect").and_then(|r| serde_json::from_value::<[f64; 4]>(r.clone()).ok())?;
let groups = photocraft_engine::presets::shapes::all_groups(&app.session);
let shape = groups.iter().flat_map(|g| &g.items).find(|s| s.name == app.ui.presets_ui.shape())?;
photocraft_engine::presets::shapes::fit(&shape.path, rect, mods.shift)
} else {
photocraft_engine::vector_cmds::shape_path(&geometry).ok()?
};
Some(photocraft_doc::ShapeLayer {
path,
fill: o.shape_fill.then(|| solid_paint(app.session.tools.foreground)),
stroke: (o.stroke_width > 0.0).then(|| o.shape_stroke.stroke(o.stroke_width, solid_paint(app.session.tools.background))),
..Default::default()
})
}
/// Shape-tool drag preview using the same path and vector stroke geometry as the commit.
pub fn draw_shape_preview(app: &PhotocraftApp, painter: &egui::Painter, xf: &ViewXform, tool: Tool, start: [f64; 2], end: [f64; 2], mods: egui::Modifiers) {
let Some(mut shape) = shape_preview(app, tool, start, end, mods) else { return };
let path = shape.path.clone();
let origin = xf.to_screen(0.0, 0.0);
let x = xf.to_screen(1.0, 0.0) - origin;
let y = xf.to_screen(0.0, 1.0) - origin;
let transform = Affine { m: [x.x as f64, x.y as f64, y.x as f64, y.y as f64, origin.x as f64, origin.y as f64] };
shape.path = shape.path.transform(&transform);
if let Some(stroke) = &mut shape.stroke {
stroke.width *= xf.zoom;
}
// This lightweight screen overlay retains the existing display-colour behaviour; document
// rendering still goes through its format/profile path when the shape is committed.
crate::shape_stroke_ui::paint_shape_preview(painter, &shape);
let accent = Tokens::get(painter.ctx()).accent;
for (pts, _) in path_lines(&path, &|q| xf.to_screen(q[0] as f32, q[1] as f32)) {
// The accent path over a dark halo: visible on any pixels (#172).
painter.extend(crate::tool_feedback::contrast_path(pts, true, accent));
}
}
// ---------------------------------------------------------------------------------------------
// Pen
fn pen_to_json(pen: &PenPath, closed: bool) -> Value {
let folded = fold_close(pen);
let (pen, closed) = match &folded {
Some(p) => (p, true),
None => (pen, closed),
};
json!({"subpaths": [{"closed": closed, "knots": pen.knots.iter().enumerate().map(|(i, k)| json!({"anchor": k[0], "in": k[1], "out": k[2], "smooth": !pen.unlinked.contains(&i) && (k[1] != k[0] || k[2] != k[0])})).collect::<Vec<_>>()}]})
}
/// Is `(x, y)` on the first anchor of a Pen path that a click there would close (two anchors or
/// more)? `tol` is the anchors' hit radius in document pixels.
fn on_closing_anchor(pen: &PenPath, x: f64, y: f64, tol: f64) -> bool {
pen.knots.len() >= 2 && pen.knots.first().is_some_and(|k| (k[0][0] - x).hypot(k[0][1] - y) < tol)
}
/// Would a click at `(x, y)` with `tool` close the path being drawn: the Pen over the first
/// anchor, or the Curvature Pen over the first of three anchors or more? The canvas shows the
/// close-path pointer there, as Photoshop does (#4596).
pub fn closes_path_at(app: &PhotocraftApp, tool: Tool, x: f64, y: f64) -> bool {
let Some(pen) = app.ui.pen.as_ref().filter(|p| !p.dragging && p.moving.is_none()) else { return false };
match tool {
Tool::Pen => !pen.curvature && on_closing_anchor(pen, x, y, 6.0 / app.point_zoom().max(0.01) as f64),
Tool::CurvaturePen => pen.curvature && pen.knots.len() >= 3 && curvature_hit(app, x, y) == Some(0),
_ => false,
}
}
/// 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.
pub fn pen_down(app: &mut PhotocraftApp, x: f64, y: f64, shift: bool) {
if !cancel_stale(app) {
return;
}
let tol = 6.0 / app.point_zoom().max(0.01) as f64;
if app.ui.pen.is_none() {
app.ui.pen_doc = app.session.active().map(|st| st.doc.id);
}
// A press on an endpoint of an open path carries on drawing it, as in Photoshop (#6593): the
// press then acts on its last anchor, so a drag pulls out the next segment's handle.
if app.ui.pen.as_ref().is_none_or(|p| p.knots.is_empty())
&& let Some(resumed) = resume_at(app, x, y, tol)
{
app.ui.pen = Some(resumed);
}
let pen = app.ui.pen.get_or_insert_with(PenPath::default);
pen.adjusting_in = false;
if let Some(first) = pen.knots.first().map(|k| k[0])
&& on_closing_anchor(pen, x, y, tol)
{
// Pressing the first anchor closes the path on release. Until then a stand-in for it
// takes the drag, which pulls out that anchor's handles (close-drag, #3306).
pen.knots.push([first; 3]);
pen.dragging = true;
pen.adjusting_last = false;
return;
}
// Clicking the last anchor breaks its outgoing handle without throwing away the incoming
// curve. Dragging from that anchor then sets the outgoing handle independently (#1482).
// This must precede adding a point, or a re-click creates a zero-length segment.
if let Some((i, last)) = pen.knots.len().checked_sub(1).zip(pen.knots.last_mut())
&& (last[0][0] - x).hypot(last[0][1] - y) < tol
{
last[2] = last[0];
if !pen.unlinked.contains(&i) {
pen.unlinked.push(i);
}
pen.dragging = true;
pen.adjusting_last = true;
return;
}
let p = match pen.knots.last() {
Some(prev) => shift_45(prev[0], [x, y], shift),
None => [x, y],
};
pen.knots.push([p; 3]);
pen.dragging = true;
pen.adjusting_last = false;
}
/// Pen drag: pull out the handles of the anchor just placed. ⇧ (read live, as it is held)
/// turns the handle to the nearest 45° direction from its anchor.
pub fn pen_move(app: &mut PhotocraftApp, x: f64, y: f64, shift: bool) {
if let Some(pen) = app.ui.pen.as_mut()
&& pen.dragging
{
let (adjusting_last, adjusting_in) = (pen.adjusting_last, pen.adjusting_in);
if let Some(k) = pen.knots.last_mut() {
let a = k[0];
let [x, y] = shift_45(a, [x, y], shift);
if adjusting_in {
k[1] = [x, y];
return;
}
k[2] = [x, y];
if !adjusting_last {
k[1] = [2.0 * a[0] - x, 2.0 * a[1] - y];
}
}
}
}
/// `p`, or with ⇧ `p` projected onto the nearest 45° ray from `origin` (Pen tool constraint).
fn shift_45(origin: [f64; 2], p: [f64; 2], shift: bool) -> [f64; 2] {
if shift { crate::stroke_constraint::snap45(origin, p) } else { p }
}
/// Undo the most recently placed Pen anchor while its path is still in progress.
/// These knots are editor-only gesture state, not document history until Enter or
/// clicking the first anchor commits the path. Therefore Cmd/Ctrl+Z must consume one
/// knot rather than undoing an unrelated, already committed document operation.
pub fn pen_undo_last_point(app: &mut PhotocraftApp) -> bool {
if !cancel_stale(app) {
return false;
}
let Some(pen) = app.ui.pen.as_mut() else { return false };
// A resumed path's own anchors are not the draft's to take back: undoing past the ones added
// since it resumed drops the draft and leaves the path as it was (#6593).
if pen.resumes.as_ref().is_some_and(|r| pen.knots.len() <= r.was.knots.len()) {
// A ⌘/Ctrl selection on the draft goes with it.
if app.ui.direct_selection.target == Some(crate::direct_select::PathRef::Pen) {
app.ui.direct_selection = Default::default();
}
app.ui.pen = None;
return true;
}
if pen.knots.pop().is_none() {
return false;
}
let n = pen.knots.len();
let ds = &mut app.ui.direct_selection;
if ds.target == Some(crate::direct_select::PathRef::Pen) {
// A ⌘/Ctrl selection on the path being drawn loses the removed anchor.
ds.anchors.retain(|a| a[1] < n);
ds.segment = ds.segment.filter(|s| s[1] + 1 < n);
}
pen.unlinked.retain(|&i| i < pen.knots.len());
if pen.curvature {
pen.moving = None;
curvature_refresh(pen, false);
}
pen.dragging = false;
if pen.knots.is_empty() {
app.ui.pen = None;
}
true
}
pub fn pen_up(app: &mut PhotocraftApp) {
let jitter = 2.0 / f64::from(app.point_zoom().max(0.01));
let Some(pen) = app.ui.pen.as_mut() else { return };
pen.dragging = false;
pen.adjusting_last = false;
pen.adjusting_in = false;
if closing(pen) {
// A click on the first anchor closes the path and leaves that anchor's handles alone.
if let Some(k) = pen.knots.last_mut()
&& (k[2][0] - k[0][0]).hypot(k[2][1] - k[0][1]) < jitter
{
k[1] = k[0];
k[2] = k[0];
}
pen_commit(app, true);
}
}
/// ⌥/Alt during a Pen drag breaks the pair of handles being pulled out: from then on only the
/// outgoing handle follows the pointer and the incoming curve stays as it is (#3306).
pub fn pen_break_handle(app: &mut PhotocraftApp) {
let Some(pen) = app.ui.pen.as_mut().filter(|p| p.dragging && !p.adjusting_last) else { return };
let Some(i) = pen.knots.len().checked_sub(1) else { return };
if !pen.unlinked.contains(&i) {
pen.unlinked.push(i);
}
pen.adjusting_last = true;
}
/// ⌥/Alt-press on one of the last anchor's handles while drawing grabs that handle alone: the
/// drag turns it and the other handle stays put (#3306, #6077). False when the press misses both.
pub fn pen_grab_handle(app: &mut PhotocraftApp, x: f64, y: f64) -> bool {
let tol = 6.0 / f64::from(app.point_zoom().max(0.01));
let Some(pen) = app.ui.pen.as_mut() else { return false };
let Some((i, k)) = pen.knots.len().checked_sub(1).zip(pen.knots.last()) else { return false };
let dist = |p: [f64; 2]| (p[0] - x).hypot(p[1] - y);
// Both handles show only while the outgoing one is pulled out (`draw_overlay`).
if k[2] == k[0] {
return false;
}
let grabbed = |h: [f64; 2]| h != k[0] && dist(h) < tol && dist(h) < dist(k[0]);
let incoming = if grabbed(k[2]) && dist(k[2]) <= dist(k[1]) {
false
} else if grabbed(k[1]) {
true
} else {
return false;
};
if !pen.unlinked.contains(&i) {
pen.unlinked.push(i);
}
pen.dragging = true;
pen.adjusting_last = true;
pen.adjusting_in = incoming;
true
}
/// Would a press at `at` close the Pen path: is the pointer on the first anchor of a path that
/// already has a segment, and no drag is under way? The canvas then shows the close cue (#4193).
pub(crate) fn over_first_anchor(pen: &PenPath, at: [f64; 2], tol: f64) -> bool {
!pen.dragging && pen.moving.is_none() && pen.knots.len() >= 2 && pen.knots.first().is_some_and(|k| (k[0][0] - at[0]).hypot(k[0][1] - at[1]) < tol)
}
/// Is a close-drag in progress: does the path end in the stand-in for its first anchor?
fn closing(pen: &PenPath) -> bool {
pen.knots.len() >= 3 && pen.knots.first().map(|k| k[0]) == pen.knots.last().map(|k| k[0])
}
/// The path with a close-drag's stand-in folded into the first knot, which takes the dragged
/// handles (smooth, or a cusp after ⌥/Alt); `None` when no close-drag is in progress.
fn fold_close(pen: &PenPath) -> Option<PenPath> {
if !closing(pen) {
return None;
}
let mut p = pen.clone();
let stand_in = p.knots.pop()?;
let broken = p.unlinked.contains(&p.knots.len());
p.unlinked.retain(|&i| i < p.knots.len());
if stand_in[1] != stand_in[0] || stand_in[2] != stand_in[0] {
let first = p.knots.first_mut()?;
first[1] = stand_in[1];
first[2] = stand_in[2];
p.unlinked.retain(|&i| i != 0);
if broken {
p.unlinked.push(0);
}
}
Some(p)
}
/// The Pen path being drawn as a document path (one open subpath), so ⌘/Ctrl (Direct Selection)
/// can edit it in place while drawing (#4022).
pub(crate) fn pen_path(pen: &PenPath) -> Path {
let pt = |q: [f64; 2]| photocraft_geom::Point::new(q[0], q[1]);
let knots = pen
.knots
.iter()
.enumerate()
.map(|(i, k)| photocraft_doc::Knot {
anchor: pt(k[0]),
in_ctrl: pt(k[1]),
out_ctrl: pt(k[2]),
smooth: !pen.unlinked.contains(&i) && (k[1] != k[0] || k[2] != k[0]),
})
.collect();
Path::new(vec![photocraft_doc::vector::Subpath { closed: false, knots, op: Default::default() }])
}
/// The Pen path being drawn becomes `path`'s first subpath, edited with ⌘/Ctrl (Direct Selection);
/// drawing carries on from its last anchor. A Curvature Pen path keeps following its anchors.
pub(crate) fn pen_replace(app: &mut PhotocraftApp, path: &Path) {
let Some(pen) = app.ui.pen.as_mut() else { return };
let knots = path.subpaths.first().map(|s| s.knots.as_slice()).unwrap_or_default();
pen.knots = knots.iter().map(knot_points).collect();
pen.unlinked = knots.iter().enumerate().filter(|(_, k)| !k.smooth).map(|(i, _)| i).collect();
pen.dragging = false;
pen.adjusting_last = false;
pen.adjusting_in = false;
pen.moving = None;
if pen.curvature {
curvature_refresh(pen, false);
}
if pen.knots.is_empty() {
app.ui.pen = None;
}
}
/// Preserve a foreign document's draft as its Work Path before another document can edit it.
/// A failed commit retains the draft and blocks the caller until it can be retried.
pub fn cancel_stale(app: &mut PhotocraftApp) -> bool {
let active = app.session.active().map(|st| st.doc.id);
if app.ui.pen.is_none() {
app.ui.pen_doc = None;
return true;
}
let Some(owner) = app.ui.pen_doc.filter(|d| Some(*d) != active) else { return true };
if let Some(index) = app.session.documents().iter().position(|d| d.doc.id == owner) {
let Some(mut pen) = app.ui.pen.clone() else { return true };
if pen.curvature {
curvature_refresh(&mut pen, false);
}
let active = app.session.active_index();
app.session.set_active(index);
// Bypass shell targets and sync_views: both belong to the newly active document.
let result = app.session.execute("path.set", json!({"name": "work", "op": "combine", "path": pen_to_json(&pen, false)}));
if let Some(index) = active {
app.session.set_active(index);
}
if let Err(e) = result {
app.ui.status = e.to_string();
app.ui.status_error = true;
return false;
}
}
app.ui.pen = None;
app.ui.pen_doc = None;
if app.ui.direct_selection.target == Some(crate::direct_select::PathRef::Pen) {
app.ui.direct_selection = Default::default();
}
true
}
/// Finish the pen path: a work path (Path mode) or a new shape layer (Shape mode).
pub fn pen_commit(app: &mut PhotocraftApp, closed: bool) {
// The control channel is drained after `sync_views`, so a document switch in this frame has
// not been seen yet: never commit the path into the document it was not drawn on.
if !cancel_stale(app) {
return;
}
let Some(mut pen) = app.ui.pen.take() else { return };
app.ui.pen_doc = None;
if app.ui.direct_selection.target == Some(crate::direct_select::PathRef::Pen) {
// Its anchors are no longer the Pen's: the committed path is another path.
app.ui.direct_selection = Default::default();
}
if pen.curvature {
curvature_refresh(&mut pen, closed);
}
commit_path(app, &pen, closed);
}
/// Commit a finished Pen, Freeform Pen or Curvature Pen path, as one History step: a new shape
/// layer (Shape mode), else a subpath of the targeted vector mask, else the work path.
fn commit_path(app: &mut PhotocraftApp, pen: &PenPath, closed: bool) {
if pen.knots.len() < 2 {
return;
}
let path = pen_to_json(pen, closed);
let r = 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)
} else {
let mut stroke = app.ui.tool_options.shape_stroke.params();
stroke["width"] = json!(app.ui.tool_options.stroke_width.max(1.0));
stroke["color"] = json!(app.session.tools.foreground);
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)))
{
// The resumed subpath, carried on, takes its old place: one step, no second subpath.
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.
let mut p = photocraft_engine::vector_cmds::path_json(&existing);
if let (Some(subs), Some(new)) = (p.get_mut("subpaths").and_then(Value::as_array_mut), path.get("subpaths").and_then(Value::as_array)) {
subs.extend(new.iter().cloned());
}
app.run("layer.vectorMask.edit", json!({"layer": id, "path": p}))
} else {
// Photoshop adds the new subpath to the path selected in the Paths panel, which is the
// Work Path right after drawing one, so path after path builds up there (#4721). With no
// path selected, a new Work Path replaces the old one. The drawn path ends up selected.
// 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 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});
if target.is_some() {
params["op"] = json!("combine");
}
app.run("path.set", params).inspect(|_| app.ui.selected_path = Some(name))
};
if let Err(e) = r {
app.ui.status = e;
app.ui.status_error = true;
}
}
/// Does `doc` have the path the Paths panel calls `name`: "work", or a saved path's name?
fn path_exists(doc: &Document, name: &str) -> bool {
doc_path(doc, name).is_some()
}
/// The path the Paths panel calls `name`: "work", or a saved path's name.
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;
}
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 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)| {
let reversed = if s.knots.last().is_some_and(near) {
false
} else if s.knots.first().is_some_and(near) {
true
} else {
return None;
};
let mut knots: Vec<_> = s.knots.iter().map(|k| (knot_points(k), k.smooth)).collect();
if reversed {
knots.reverse();
for (k, _) in &mut knots {
k.swap(1, 2);
}
}
let unlinked = knots.iter().enumerate().filter(|(_, (_, smooth))| !smooth).map(|(i, _)| i).collect();
let resumes = Resumed { doc, path: name.clone(), index: i, was: s.clone() };
Some(PenPath { knots: knots.into_iter().map(|(k, _)| k).collect(), unlinked, resumes: Some(resumes), ..Default::default() })
})
}
/// The resumed path with its subpath carried on: the one subpath of `drawn` takes the old one's
/// 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)?;
if path.subpaths.get(r.index) != Some(&r.was) {
return None;
}
let mut p = photocraft_engine::vector_cmds::path_json(path);
let slot = p.get_mut("subpaths")?.as_array_mut()?.get_mut(r.index)?.as_object_mut()?;
let new = drawn.get("subpaths")?.get(0)?;
for key in ["closed", "knots"] {
slot.insert(key.into(), new.get(key)?.clone());
}
Some(p)
}
// ---------------------------------------------------------------------------------------------
// Freeform Pen and Curvature Pen
/// Freeform Pen release: fit the drag's trace within the options bar's Curve Fit and commit it
/// as the Pen does. Releasing on the start point closes the path; a click draws nothing. The
/// points at indices `straight` were ⌥-clicked: the segment into each one stays straight.
pub fn freeform_finish(app: &mut PhotocraftApp, points: &[[f64; 3]], straight: &[usize]) {
let trace: Vec<[f64; 2]> = points.iter().map(|p| [p[0], p[1]]).collect();
let (Some(first), Some(last)) = (trace.first(), trace.last()) else { return };
let tol = 6.0 / app.point_zoom().max(0.01) as f64;
let length: f64 = trace.windows(2).map(|w| (w[1][0] - w[0][0]).hypot(w[1][1] - w[0][1])).sum();
let closed = (first[0] - last[0]).hypot(first[1] - last[1]) < tol && length > 4.0 * tol;
let fit = f64::from(app.ui.tool_options.curve_fit);
let pen = if straight.is_empty() {
let Some(sub) = photocraft_vector::trace::fit_trace(&trace, fit, closed) else { return };
let knots = sub.knots.iter().map(knot_points).collect();
let unlinked = sub.knots.iter().enumerate().filter(|(_, k)| !k.smooth).map(|(i, _)| i).collect();
(PenPath { knots, unlinked, ..Default::default() }, sub.closed)
} else {
fit_with_straight_segments(&trace, straight, fit, closed.then_some(tol))
};
commit_path(app, &pen.0, pen.1);
}
fn knot_points(k: &photocraft_doc::Knot) -> [[f64; 2]; 3] {
[[k.anchor.x, k.anchor.y], [k.in_ctrl.x, k.in_ctrl.y], [k.out_ctrl.x, k.out_ctrl.y]]
}
/// A Freeform Pen trace with ⌥-clicked straight segments (into the points at `straight`): each
/// freehand run between them is fitted on its own, and the runs are joined by straight lines
/// between corner anchors. `close` (a reach) closes the path when it ends on its start point.
fn fit_with_straight_segments(trace: &[[f64; 2]], straight: &[usize], fit: f64, close: Option<f64>) -> (PenPath, bool) {
let mut cuts: Vec<usize> = straight.iter().copied().filter(|&i| i > 0 && i < trace.len()).collect();
cuts.sort_unstable();
cuts.dedup();
cuts.push(trace.len());
let (mut knots, mut corners): (Vec<[[f64; 2]; 3]>, Vec<usize>) = (Vec::new(), Vec::new());
let mut start = 0;
for end in cuts {
let run = trace.get(start..end).unwrap_or_default();
let first = knots.len();
match photocraft_vector::trace::fit_trace(run, fit, false) {
Some(sub) => {
corners.extend(sub.knots.iter().enumerate().filter(|(_, k)| !k.smooth).map(|(i, _)| first + i));
knots.extend(sub.knots.iter().map(knot_points));
}
// A single click (or a run that never moved): one corner anchor.
None => knots.extend(run.first().map(|p| [*p; 3])),
}
// Where a straight segment meets the run: a corner with no handle on that side.
if let Some(k) = knots.get_mut(first).filter(|_| first > 0) {
k[1] = k[0];
corners.push(first);
}
if end < trace.len()
&& let Some(k) = knots.last_mut()
{
k[2] = k[0];
corners.push(knots.len() - 1);
}
start = end;
}
// Ended on the start point: the last anchor is the first one.
let ends_on_start = |k: &[[[f64; 2]; 3]], reach: f64| match (k.first(), k.last()) {
(Some(a), Some(b)) => k.len() > 3 && (a[0][0] - b[0][0]).hypot(a[0][1] - b[0][1]) < reach,
_ => false,
};
let closed = close.is_some_and(|reach| ends_on_start(&knots, reach));
if closed && let Some(last) = knots.pop() {
if let Some(k) = knots.first_mut() {
k[1] = [last[1][0] - last[0][0] + k[0][0], last[1][1] - last[0][1] + k[0][1]];
}
corners.retain(|&i| i < knots.len());
corners.push(0);
}
corners.sort_unstable();
corners.dedup();
(PenPath { knots, unlinked: corners, ..Default::default() }, closed)
}
/// Recompute a Curvature Pen path's handles from its anchors and corner points.
fn curvature_refresh(pen: &mut PenPath, closed: bool) {
let anchors: Vec<[f64; 2]> = pen.knots.iter().map(|k| k[0]).collect();
let corners: Vec<bool> = (0..anchors.len()).map(|i| pen.unlinked.contains(&i)).collect();
pen.knots = photocraft_vector::edit::curvature_knots(&anchors, &corners, closed);
}
/// The anchor of the Curvature Pen path being drawn under (x, y), for the cursor.
pub(crate) fn curvature_anchor_at(app: &PhotocraftApp, x: f64, y: f64) -> Option<usize> {
curvature_hit(app, x, y)
}
/// The Curvature Pen's anchor within a few screen pixels of (x, y).
fn curvature_hit(app: &PhotocraftApp, x: f64, y: f64) -> Option<usize> {
let tol = 6.0 / app.point_zoom().max(0.01) as f64;
let pen = app.ui.pen.as_ref().filter(|p| p.curvature)?;
pen.knots
.iter()
.enumerate()
.map(|(i, k)| (i, (k[0][0] - x).hypot(k[0][1] - y)))
.filter(|(_, d)| *d < tol)
.min_by(|a, b| a.1.total_cmp(&b.1))
.map(|(i, _)| i)
}
/// Curvature Pen press: clicking the first anchor closes the path, pressing another anchor
/// grabs it to move, anywhere else adds a smooth anchor (still draggable until the release).
pub fn curvature_down(app: &mut PhotocraftApp, x: f64, y: f64) {
if !cancel_stale(app) {
return;
}
if app.ui.pen.as_ref().is_some_and(|p| !p.curvature) {
pen_commit(app, false);
}
let hit = curvature_hit(app, x, y);
if hit == Some(0) && app.ui.pen.as_ref().is_some_and(|p| p.knots.len() >= 3) {
pen_commit(app, true);
return;
}
if app.ui.pen.is_none() {
app.ui.pen_doc = app.session.active().map(|st| st.doc.id);
}
let pen = app.ui.pen.get_or_insert_with(|| PenPath { curvature: true, ..Default::default() });
if hit.is_none() {
pen.knots.push([[x, y]; 3]);
}
pen.moving = hit.or(pen.knots.len().checked_sub(1));
curvature_refresh(pen, false);
}
pub fn curvature_move(app: &mut PhotocraftApp, x: f64, y: f64) {
if let Some(pen) = app.ui.pen.as_mut().filter(|p| p.curvature)
&& let Some(k) = pen.moving.and_then(|i| pen.knots.get_mut(i))
{
k[0] = [x, y];
curvature_refresh(pen, false);
}
}
pub fn curvature_up(app: &mut PhotocraftApp) {
if let Some(pen) = app.ui.pen.as_mut() {
pen.moving = None;
}
}
/// Curvature Pen double-click: toggle the anchor under the pointer between smooth and corner
/// (double-clicking empty canvas therefore places a corner point, as in Photoshop). With no path
/// being drawn, an anchor of the active path toggles the same way and its subpath reflows
/// (`path.convertPoint` with `curvature`), so a Pen-drawn corner rounds off.
pub fn curvature_toggle(app: &mut PhotocraftApp, x: f64, y: f64) {
if app.ui.pen.as_ref().is_none_or(|p| p.knots.is_empty()) {
crate::direct_select::curvature_toggle_active(app, [x, y]);
return;
}
let Some(i) = curvature_hit(app, x, y) else { return };
let Some(pen) = app.ui.pen.as_mut() else { return };
if let Some(at) = pen.unlinked.iter().position(|&c| c == i) {
pen.unlinked.remove(at);
} else {
pen.unlinked.push(i);
}
curvature_refresh(pen, false);
}
/// The path that path commands act on without a name: the one selected in the Paths panel, else
/// the work path, else the selected layer's shape path or vector mask; `None` when there's none.
pub fn active_path_name(app: &PhotocraftApp) -> Option<String> {
let st = app.session.active()?;
let rows = path_rows(&st.doc, st.active_layer);
let key = |r: &PathEntry| match r.kind {
PathRow::Work => "work".to_string(),
PathRow::Layer => "layer".to_string(),
PathRow::Saved => r.name.clone(),
};
let selected = app.ui.selected_path.as_deref().filter(|s| rows.iter().any(|r| key(r) == *s)).map(str::to_string);
selected.or_else(|| rows.iter().find(|r| r.kind == PathRow::Work).map(key)).or_else(|| rows.iter().find(|r| r.kind == PathRow::Layer).map(key))
}
/// The commands that create a fill or adjustment layer and take a `"path"` as its vector mask.
pub fn takes_path_mask(id: &str) -> bool {
id.starts_with("layer.newFillLayer.") || id.starts_with("layer.newAdjustmentLayer.")
}
/// The work or saved path explicitly selected in the Paths panel (not a layer's own path).
pub fn selected_document_path(app: &PhotocraftApp) -> Option<String> {
let st = app.session.active()?;
let sel = app.ui.selected_path.as_deref()?;
let listed = path_rows(&st.doc, st.active_layer).iter().any(|r| match r.kind {
PathRow::Work => sel == "work",
PathRow::Saved => r.name == sel,
PathRow::Layer => false,
});
listed.then(|| sel.to_string())
}
/// New fill and adjustment layers take the path selected in the Paths panel as their vector mask,
/// as in Photoshop (#1419): the command gets it as `"path"` unless the caller set one (`null`
/// opts out). Only an explicitly selected work or saved path counts; deselect it by clicking the
/// panel's empty area.
pub fn with_active_path(app: &PhotocraftApp, id: &str, params: Value) -> Value {
if !takes_path_mask(id) || params.get("path").is_some() {
return params;
}
let Some(sel) = selected_document_path(app) else { return params };
match params {
Value::Object(mut m) => {
m.insert("path".into(), json!(sel));
Value::Object(m)
}
_ => json!({ "path": sel }),
}
}
/// ⌘↩ / Ctrl+Enter (#306): load a path as a selection, like Photoshop with a Pen or Path
/// Selection tool or a path selected in the Paths panel. A path being drawn with the Pen is
/// finished first and loads; otherwise [`active_path_name`]. `params` may set feather, mode…
pub fn path_to_selection(app: &mut PhotocraftApp, params: Value) -> Result<Value, String> {
if app.ui.pen.as_ref().is_some_and(|p| p.knots.len() >= 2) {
// The finished path becomes the work path, or a shape layer's path or a vector mask.
let on_layer = app.ui.tool_options.vector_mode == "shape" || targeted_vector_mask(app).is_some();
pen_commit(app, false);
app.ui.selected_path = Some(if on_layer { "layer" } else { "work" }.into());
}
let name = active_path_name(app)
.ok_or_else(|| tl!("No path to make a selection from: draw one with the Pen tool or select one in the Paths panel.").to_string())?;
let mut p = params.as_object().cloned().unwrap_or_default();
p.insert("name".into(), json!(name));
app.run("path.toSelection", Value::Object(p))
}
// ---------------------------------------------------------------------------------------------
// Path Selection
/// What Path Selection edits.
enum PathTarget {
Shape(u64),
/// The active layer's vector mask, when its Layers thumbnail is targeted (#196).
VectorMask(u64),
Work,
}
/// The targeted vector mask of the active layer, if the Layers panel targets it.
pub(crate) fn targeted_vector_mask(app: &PhotocraftApp) -> Option<(u64, Path)> {
let st = app.session.active()?;
let l = st.active_layer.and_then(|id| st.doc.layer(id))?;
let targeted = app.ui.vector_mask_target || st.channel_view.target == photocraft_engine::channel_cmds::ChannelTarget::VectorMask;
(targeted && !matches!(l.content, LayerContent::Shape(_))).then_some(())?;
l.vector_mask.as_ref().map(|m| (l.id.0, m.path.clone()))
}
/// The active shape layer's path, if the active layer is a shape layer.
pub(crate) fn active_shape_path(app: &PhotocraftApp) -> Option<(u64, Path)> {
let st = app.session.active()?;
let l = st.active_layer.and_then(|id| st.doc.layer(id))?;
match &l.content {
LayerContent::Shape(sh) => Some((l.id.0, sh.path.clone())),
_ => None,
}
}
/// Does ⌫ / Delete delete the work path? With the Pen, Freeform Pen or Path Selection tool, no
/// path being drawn and the work path the one these tools show and edit (no shape layer or
/// targeted vector mask in front of it), as in Photoshop (#5702). It was drawn whenever one of
/// these tools was active, but the key reached Edit › Clear, so it looked impossible to delete.
/// Direct Selection and the Curvature Pen delete selected anchors in Photoshop, not the path.
pub(crate) fn delete_key_deletes_work_path(app: &PhotocraftApp) -> bool {
matches!(app.ui.tool, Tool::Pen | Tool::FreeformPen | Tool::PathSelection)
&& app.ui.pen.is_none()
&& app.ui.transform.is_none()
&& app.ui.view.shows(app.ui.view.show.target_path)
&& matches!(target_path(app), Some((PathTarget::Work, _)))
}
/// The path Path Selection edits: the targeted vector mask, the active shape layer's path, else
/// the work path.
fn target_path(app: &PhotocraftApp) -> Option<(PathTarget, Path)> {
if let Some((id, p)) = targeted_vector_mask(app) {
return Some((PathTarget::VectorMask(id), p));
}
if let Some((id, p)) = active_shape_path(app) {
return Some((PathTarget::Shape(id), p));
}
app.session.active()?.doc.work_path.clone().map(|p| (PathTarget::Work, p))
}
/// Edit › Free Transform Path (⌘T with Path Selection or Direct Selection): the path the
/// box transforms (the one Path Selection edits) and `path.transform`'s params that name it.
pub(crate) fn free_transform_path(app: &PhotocraftApp) -> Option<(Value, Path)> {
if !matches!(app.ui.tool, Tool::PathSelection | Tool::DirectSelection) {
return None;
}
let (target, path) = target_path(app)?;
path.control_bounds()?;
let params = match target {
PathTarget::Shape(id) | PathTarget::VectorMask(id) => json!({"name": "layer", "layer": id}),
PathTarget::Work => json!({"name": "work"}),
};
Some((params, path))
}
fn point_in_subpath(sp: &photocraft_doc::vector::Subpath, pt: [f64; 2]) -> bool {
if !sp.closed || sp.knots.len() < 3 {
return false;
}
let mut inside = false;
let n = sp.knots.len();
for i in 0..n {
let j = (i + 1) % n;
let xi = sp.knots[i].anchor.x;
let yi = sp.knots[i].anchor.y;
let xj = sp.knots[j].anchor.x;
let yj = sp.knots[j].anchor.y;
let intersect = ((yi > pt[1]) != (yj > pt[1])) && (pt[0] < (xj - xi) * (pt[1] - yi) / (yj - yi) + xi);
if intersect {
inside = !inside;
}
}
inside
}
/// The topmost visible shape layer under `at` (document coordinates):
/// hits the shape path or anchor within `tol`, or any non-transparent pixel of the shape's raster surface,
/// or point inside the shape's filled geometry.
pub fn pick_shape_at(doc: &Document, at: [f64; 2], tol: f64) -> Option<photocraft_doc::LayerId> {
let (x, y) = (at[0].floor() as i32, at[1].floor() as i32);
for (path, _, l) in doc.walk().iter().rev() {
if !l.visible || !(1..=path.len()).all(|n| doc.layer_at(&path[..n]).is_some_and(|a| a.visible)) {
continue;
}
let board = path.first().and_then(|i| doc.layers.get(*i)).and_then(|t| t.artboard());
if board.is_some_and(|a| !a.rect.contains(x, y)) {
continue;
}
if let LayerContent::Shape(sh) = &l.content {
if photocraft_vector::edit::hit(&sh.path, photocraft_geom::Point::new(at[0], at[1]), tol, &[]).is_some() {
return Some(l.id);
}
if sh.fill.is_some() {
if let Some(surf) = l.surface() {
let mut px = [[0.0f32; 4]; 1];
surf.read_rgba_into(photocraft_doc::Rect::from_xywh(x, y, 1, 1), &mut px);
if px[0][3] > 0.0 {
return Some(l.id);
}
}
if let Some(photocraft_doc::LiveShape::Rect { rect, .. }) = &sh.live {
let x0 = rect[0].min(rect[0] + rect[2]);
let x1 = rect[0].max(rect[0] + rect[2]);
let y0 = rect[1].min(rect[1] + rect[3]);
let y1 = rect[1].max(rect[1] + rect[3]);
if at[0] >= x0 && at[0] <= x1 && at[1] >= y0 && at[1] <= y1 {
return Some(l.id);
}
}
if let Some(photocraft_doc::LiveShape::Ellipse { rect }) = &sh.live {
let rx = rect[2].abs() / 2.0;
let ry = rect[3].abs() / 2.0;
if rx > 1e-6 && ry > 1e-6 {
let cx = rect[0] + rect[2] / 2.0;
let cy = rect[1] + rect[3] / 2.0;
let dx = (at[0] - cx) / rx;
let dy = (at[1] - cy) / ry;
if dx * dx + dy * dy <= 1.0 {
return Some(l.id);
}
}
}
if sh.path.subpaths.iter().any(|sp| point_in_subpath(sp, at)) {
return Some(l.id);
}
}
}
}
None
}
pub fn path_selection_finish(app: &mut PhotocraftApp, start: [f64; 2], end: [f64; 2]) {
let (dx, dy) = (end[0] - start[0], end[1] - start[1]);
let tol = 6.0 / f64::from(app.point_zoom().max(0.01));
if dx.abs() + dy.abs() < 0.5 {
let Some(st) = app.session.active() else { return };
if let Some(id) = pick_shape_at(&st.doc, start, tol) {
let _ = app.run("layer.select", json!({"layer": id.0}));
}
return;
}
if target_path(app).is_none() {
let Some(st) = app.session.active() else { return };
if let Some(id) = pick_shape_at(&st.doc, start, tol) {
let _ = app.run("layer.select", json!({"layer": id.0}));
}
}
let Some((target, path)) = target_path(app) else { return };
let _ = match target {
PathTarget::Shape(id) => app.run("shape.edit", json!({"layer": id, "move": [dx.round(), dy.round()]})),
PathTarget::VectorMask(id) => {
let moved = path.transform(&Affine::translate(dx.round(), dy.round()));
app.run("layer.vectorMask.edit", json!({"layer": id, "path": photocraft_engine::vector_cmds::path_json(&moved)}))
}
PathTarget::Work => {
let moved = path.transform(&Affine::translate(dx.round(), dy.round()));
app.run("path.set", json!({"name": "work", "path": photocraft_engine::vector_cmds::path_json(&moved)}))
}
};
}
// ---------------------------------------------------------------------------------------------
// Drawing
fn bezier(p0: [f64; 2], c0: [f64; 2], c1: [f64; 2], p1: [f64; 2], t: f64) -> [f64; 2] {
let u = 1.0 - t;
let f = |a: f64, b: f64, c: f64, d: f64| u * u * u * a + 3.0 * u * u * t * b + 3.0 * u * t * t * c + t * t * t * d;
[f(p0[0], c0[0], c1[0], p1[0]), f(p0[1], c0[1], c1[1], p1[1])]
}
/// `q` lies on the chord from `a` to `d` (within a thousandth of a pixel).
fn on_chord(a: [f64; 2], q: [f64; 2], d: [f64; 2]) -> bool {
let (dx, dy, vx, vy) = (d[0] - a[0], d[1] - a[1], q[0] - a[0], q[1] - a[1]);
let len = dx.hypot(dy);
if len < 1e-9 {
return vx.hypot(vy) < 1e-3;
}
let t = (vx * dx + vy * dy) / (len * len);
(vx * dy - vy * dx).abs() / len < 1e-3 && (-1e-9..=1.0 + 1e-9).contains(&t)
}
/// How far (in screen pixels) a drawn chord may stray from the true curve.
const CURVE_TOLERANCE: f64 = 0.3;
/// Pieces per segment at most: 0.3 px holds for curves bending up to about 1.4 million px on screen.
const MAX_CURVE_PIECES: usize = 1024;
/// Screen points along one cubic segment (both ends included). The control points are mapped to
/// the screen first (`xf` is affine, so the curve maps exactly), and the number of chords follows
/// how much the curve bends there: a straight segment is one chord, and a curve zoomed in stays
/// smooth instead of showing a fixed 16 chords (#4084). Uses the bound
/// `max|B''| / 8n² <= tol` with `max|B''| <= 6·max(|p0−2c0+c1|, |c0−2c1+p1|)`.
pub(crate) fn curve_points(p0: [f64; 2], c0: [f64; 2], c1: [f64; 2], p1: [f64; 2], xf: &dyn Fn([f64; 2]) -> Pos2) -> Vec<Pos2> {
let [a, b, c, d] = [p0, c0, c1, p1].map(|q| {
let s = xf(q);
[f64::from(s.x), f64::from(s.y)]
});
let second = |p: [f64; 2], q: [f64; 2], r: [f64; 2]| (p[0] - 2.0 * q[0] + r[0]).hypot(p[1] - 2.0 * q[1] + r[1]);
let n = (0.75 * second(a, b, c).max(second(b, c, d)) / CURVE_TOLERANCE).sqrt().ceil();
// A straight segment (controls on the chord, like the Pen's retracted handles) is one chord;
// NaN (a non-finite point) falls back to one too.
let n = if n.is_finite() && !(on_chord(a, b, d) && on_chord(a, c, d)) { (n as usize).clamp(1, MAX_CURVE_PIECES) } else { 1 };
(0..=n)
.map(|k| {
let q = bezier(a, b, c, d, k as f64 / n as f64);
pos2(q[0] as f32, q[1] as f32)
})
.collect()
}
/// Screen polylines for a path (one per subpath).
pub(crate) fn path_lines(path: &Path, xf: &dyn Fn([f64; 2]) -> Pos2) -> Vec<(Vec<Pos2>, bool)> {
path.subpaths
.iter()
.map(|s| {
let n = s.knots.len();
let mut pts = Vec::new();
let segs = if s.closed { n } else { n.saturating_sub(1) };
for i in 0..segs {
let (a, b) = (&s.knots[i], &s.knots[(i + 1) % n]);
pts.extend(curve_points([a.anchor.x, a.anchor.y], [a.out_ctrl.x, a.out_ctrl.y], [b.in_ctrl.x, b.in_ctrl.y], [b.anchor.x, b.anchor.y], xf));
}
if pts.is_empty()
&& let Some(k) = s.knots.first()
{
pts.push(xf([k.anchor.x, k.anchor.y]));
}
(pts, s.closed)
})
.collect()
}
/// A path's outline in the accent colour.
pub(crate) fn draw_outline(painter: &egui::Painter, p: &Path, to_scr: &dyn Fn([f64; 2]) -> Pos2, accent: Color32) {
for (pts, closed) in path_lines(p, to_scr) {
if closed {
painter.add(egui::Shape::closed_line(pts, Stroke::new(1.0, accent)));
} else {
painter.add(egui::Shape::line(pts, Stroke::new(1.0, accent)));
}
}
}
/// An anchor point's square: filled with the accent when selected, else hollow (white).
pub(crate) fn draw_anchor(painter: &egui::Painter, c: Pos2, selected: bool, accent: Color32) {
let r = Rect::from_center_size(c, vec2(6.0, 6.0));
painter.rect_filled(r, 0.0, if selected { accent } else { Color32::WHITE });
painter.rect_stroke(r, 0.0, Stroke::new(1.0, accent), egui::StrokeKind::Inside);
}
/// A direction handle: the line from its anchor and the round handle end.
pub(crate) fn draw_handle(painter: &egui::Painter, anchor: Pos2, handle: Pos2, accent: Color32) {
painter.line_segment([anchor, handle], Stroke::new(1.0, accent));
painter.circle_filled(handle, 3.0, accent);
}
/// Does `tool` draw the anchor squares of the paths it can edit? Path Selection does, and so do
/// the Pen tools: as in Photoshop, a path finished with Enter or by closing it keeps its anchors
/// on screen, so it can still be edited (⌘/Ctrl-drag, Auto Add/Delete) (#6884, #4716).
pub(crate) fn shows_anchors(tool: Tool) -> bool {
// Add/Delete Anchor Point and Convert Point draw Direct Selection's overlay instead.
matches!(tool, Tool::PathSelection | Tool::Pen | Tool::FreeformPen | Tool::CurvaturePen)
}
/// The saved path selected in the Paths panel: Photoshop's target path, drawn on the canvas with
/// any tool (#6550). `None` when the panel selects the work path, a layer's path or nothing.
pub(crate) fn selected_saved_path(app: &PhotocraftApp) -> Option<&Path> {
let sel = app.ui.selected_path.as_deref().filter(|s| !matches!(*s, "work" | "layer"))?;
app.session.active()?.doc.paths.iter().find(|p| p.name == sel).map(|p| &p.path)
}
/// Work path / active shape path / selected saved path outlines, anchors, and the pen path in
/// progress.
pub fn draw_overlay(app: &PhotocraftApp, painter: &egui::Painter, xf: &ViewXform, doc: &Document) {
let tool = app.ui.tool;
let accent = Tokens::get(painter.ctx()).accent;
let to_scr = |q: [f64; 2]| xf.to_screen(q[0] as f32, q[1] as f32);
let draw_path = |p: &Path, anchors: bool| {
draw_outline(painter, p, &to_scr, accent);
if anchors {
for k in p.subpaths.iter().flat_map(|s| &s.knots) {
draw_anchor(painter, to_scr([k.anchor.x, k.anchor.y]), false, accent);
}
}
};
// View › Show › Target Path (under Extras) hides the paths; the Pen's path in progress stays.
// Free Transform Path draws the path through its box instead (transform_tool).
let paths = app.ui.view.shows(app.ui.view.show.target_path) && app.ui.transform.as_ref().is_none_or(|t| t.path.is_none());
if app.session.active().is_some_and(|st| st.doc.id == doc.id) && crate::direct_select::shows(app, painter.ctx().input(|i| i.modifiers)) {
// Direct Selection (or the Pen with ⌘/Ctrl held) draws the paths it edits (#790).
crate::direct_select::draw_overlay(app, painter, &to_scr, accent, paths);
if paths {
// The selected saved path shows too, though Direct Selection doesn't edit it yet.
if let Some(p) = selected_saved_path(app) {
draw_path(p, true);
}
crate::anchor_tools::draw_hover(app, painter, &to_scr, accent, painter.ctx().input(|i| i.modifiers));
}
} else if paths {
// The shape's or vector mask's path stays visible as an outline with any tool. Path
// Selection and the Pen tools add anchor squares; Direct Selection has its own overlay
// above. The Work Path is drawn only while it is the path selected in the Paths panel or
// a path tool is active, as in Photoshop: a Work Path left unselected (one a PSD arrived
// with, or after Ctrl-click Load as Selection) would otherwise cover the marching ants (#6551).
let anchors = shows_anchors(tool);
if let Some(wp) = &doc.work_path
&& (anchors || app.ui.selected_path.as_deref() == Some("work"))
{
draw_path(wp, anchors);
}
// The saved path selected in the Paths panel is the target path (#6550).
if let Some(p) = selected_saved_path(app) {
draw_path(p, anchors);
}
let st = app.session.active();
if let Some(l) = st.and_then(|s| s.active_layer.and_then(|id| s.doc.layer(id)))
&& let LayerContent::Shape(sh) = &l.content
{
draw_path(&sh.path, anchors);
}
// A targeted vector mask shows its path with any tool (#196).
if let Some((_, p)) = targeted_vector_mask(app) {
draw_path(&p, anchors);
}
crate::corner_radius::draw(app, painter, &to_scr, accent);
}
// Pen path in progress, with handles of the last knot and a rubber band to the pointer. While
// ⌘/Ctrl drags it, Direct Selection draws its preview instead.
let edited = matches!(&app.ui.direct_selection.drag, Some(crate::direct_select::Drag::Edit { target: crate::direct_select::PathRef::Pen, .. }));
// Only on the document it is drawn on: a view of another document never shows it (#5373).
if let Some(pen) = app.ui.pen.as_ref().filter(|_| !edited).filter(|_| app.ui.pen_doc.is_none_or(|d| d == doc.id)) {
let mut pts = Vec::new();
// A close-drag shows the first segment bending with the handle being pulled out.
let mut knots = pen.knots.clone();
if closing(pen)
&& let Some(&[a, _, out]) = pen.knots.last()
&& out != a
&& let Some(first) = knots.first_mut()
{
first[2] = out;
}
for w in knots.windows(2) {
pts.extend(curve_points(w[0][0], w[0][2], w[1][1], w[1][0], &to_scr));
}
painter.add(egui::Shape::line(pts, Stroke::new(1.5, accent)));
// No rubber band where a click adds or deletes an anchor of this path instead (#6140).
let auto = app.hover_doc.is_some_and(|h| crate::anchor_tools::pen_auto(app, tool, painter.ctx().input(|i| i.modifiers), h).is_some());
if let (Some(last), Some(h)) = (pen.knots.last(), app.hover_doc)
&& !pen.dragging
&& pen.moving.is_none()
&& !auto
{
if pen.curvature && pen.knots.len() >= 2 {
// The Curvature Pen previews the curve the next click makes through the pointer.
let mut next = pen.clone();
next.knots.push([h; 3]);
curvature_refresh(&mut next, false);
if let [.., a, b] = next.knots.as_slice() {
let pts = curve_points(a[0], a[2], b[1], b[0], &to_scr);
painter.add(egui::Shape::dashed_line(&pts, Stroke::new(1.0, accent), 4.0, 3.0));
}
} else {
// The rubber band ends where a ⇧-click would put the next anchor.
let shift = painter.ctx().input(|i| i.modifiers.shift);
let h = if pen.curvature { h } else { shift_45(last[0], h, shift) };
painter.add(egui::Shape::dashed_line(&[to_scr(last[0]), to_scr(h)], Stroke::new(1.0, accent), 4.0, 3.0));
}
}
for (i, k) in pen.knots.iter().enumerate() {
let c = to_scr(k[0]);
let last = i + 1 == pen.knots.len();
if last && k[2] != k[0] && !pen.curvature {
for hnd in [k[1], k[2]] {
draw_handle(painter, c, to_scr(hnd), accent);
}
}
draw_anchor(painter, c, last, accent);
}
// Hovering the first anchor: Photoshop's close cue, a small ring beside the pointer.
let tol = 6.0 / f64::from(app.point_zoom().max(0.01));
if let Some(h) = app.hover_doc
&& over_first_anchor(pen, h, tol)
&& let Some(first) = pen.knots.first()
{
let c = to_scr(first[0]);
painter.rect_filled(Rect::from_center_size(c, vec2(8.0, 8.0)), 0.0, accent);
painter.circle_stroke(c + vec2(11.0, 11.0), 3.5, Stroke::new(1.5, accent));
}
}
// The segment the Pen's Auto Add/Delete would add an anchor to, or the anchor it would delete,
// over the path being drawn. While drawing, the other paths can be hidden: it edits none of them.
if paths || app.ui.pen.is_some() {
crate::anchor_tools::draw_pen_hover(app, painter, &to_scr, accent, painter.ctx().input(|i| i.modifiers));
}
}
// ---------------------------------------------------------------------------------------------
// Options bars
/// Options bar for vector tools; false for other tools.
pub fn options_bar(app: &mut PhotocraftApp, ui: &mut egui::Ui, tool: Tool) -> bool {
if !(is_shape_tool(tool)
|| matches!(
tool,
Tool::Pen | Tool::FreeformPen | Tool::CurvaturePen | Tool::AddAnchorPoint | Tool::DeleteAnchorPoint | Tool::PathSelection | Tool::DirectSelection
))
{
return false;
}
let t = Tokens::get(ui.ctx());
let lbl = |ui: &mut egui::Ui, s: &str| {
ui.label(egui::RichText::new(s).color(t.text_dim).size(12.0));
};
let o = &mut app.ui.tool_options;
let target = selected_shape(&app.session);
if tool == Tool::PathSelection && target.is_none() {
lbl(ui, if app.ui.vector_mask_target { "Drag to move the targeted vector mask" } else { tl!("Drag to move the active shape's path or the Work Path") });
return true;
}
if tool == Tool::DirectSelection && target.is_none() {
let (shift, alt) = (crate::shortcuts::pretty("Shift"), crate::shortcuts::pretty("Alt"));
lbl(
ui,
&crate::i18n::fmt(
tl!("Click: select anchor · Drag: move anchor, handle or segment · {shift}-click: add · {alt}-click: whole subpath"),
&[("shift", &shift), ("alt", &alt)],
),
);
return true;
}
if matches!(tool, Tool::AddAnchorPoint | Tool::DeleteAnchorPoint) {
let hint = if tool == Tool::AddAnchorPoint {
tl!("Click a segment to add an anchor point · {alt}-click an anchor to delete it")
} else {
tl!("Click an anchor point to delete it · {alt}-click a segment to add one")
};
lbl(ui, &crate::i18n::fmt(hint, &[("alt", &crate::shortcuts::pretty("Alt"))]));
return true;
}
if matches!(tool, Tool::Pen | Tool::FreeformPen | Tool::CurvaturePen) {
let opts = [("path".to_string(), tl!("Path")), ("shape".to_string(), tl!("Shape"))];
crate::widgets::dropdown(ui, "pen-mode", &mut o.vector_mode, &opts, 80.0);
crate::widgets::vline(ui, 22.0);
if o.vector_mode == "shape" {
crate::widgets::value_field(ui, &mut o.stroke_width, 0.0..=288.0, "px", 58.0);
if let Some(change) =
crate::shape_stroke_ui::button(ui, "pen-stroke", &o.shape_stroke, &mut app.ui.stroke_editor, false, true, None, o.stroke_width > 0.0)
{
o.shape_stroke = change.options;
o.stroke_width = enabled_stroke_width(o.stroke_width);
}
}
if tool == Tool::Pen {
crate::widgets::vline(ui, 22.0);
crate::widgets::checkbox(ui, &mut o.pen_auto_add_delete, tl!("Auto Add/Delete"));
}
let enter = crate::shortcuts::pretty("Enter");
match tool {
Tool::FreeformPen => {
crate::widgets::vline(ui, 22.0);
lbl(ui, tl!("Curve Fit:"));
crate::widgets::value_field(ui, &mut o.curve_fit, 0.5..=10.0, "px", 58.0);
let alt = crate::shortcuts::pretty("Alt");
lbl(ui, &crate::i18n::fmt(tl!("Drag: draw freehand · {alt}-click: straight segment · Release on the start point: close"), &[("alt", &alt)]));
}
Tool::CurvaturePen => lbl(
ui,
&crate::i18n::fmt(
tl!("Click: smooth point · Double-click: corner · Drag a point: move · Click first point: close · {key} finish"),
&[("key", &enter)],
),
),
_ => lbl(
ui,
&crate::i18n::fmt(
tl!("Click: corner · Drag: smooth · {alt}-drag: break handle · Click or drag first point: close · {key} finish · Esc cancel"),
&[("alt", &crate::shortcuts::pretty("Alt")), ("key", &enter)],
),
),
}
// Path mode: Make Selection from the path being drawn or the active path, as Photoshop's
// options bar's "Make: Selection…" does (#5703).
if app.ui.tool_options.vector_mode == "path" {
crate::widgets::vline(ui, 22.0);
let has_path = active_path_name(app).is_some() || app.ui.pen.as_ref().is_some_and(|p| p.knots.len() >= 2);
if ui.add_enabled(has_path, egui::Button::new(tl!("Make Selection"))).clicked()
&& let Err(e) = crate::canvas_tool_menu::make_selection(app)
{
app.ui.status = e;
app.ui.status_error = true;
}
}
return true;
}
let mut mode = "shape".to_string();
crate::widgets::dropdown(ui, "shape-mode", &mut mode, &[("shape".to_string(), tl!("Shape"))], 80.0);
crate::widgets::vline(ui, 22.0);
crate::shape_options::options_bar(app, ui, tool);
true
}
/// Whether the active layer supplies the selected-shape options.
fn selected_shape(session: &photocraft_engine::Session) -> Option<photocraft_doc::LayerId> {
let st = session.active()?;
let layer = st.active_layer?;
matches!(st.doc.layer(layer)?.content, LayerContent::Shape(_)).then_some(layer)
}
// ---------------------------------------------------------------------------------------------
// Properties (shape layers)
fn solid_paint(c: [f32; 4]) -> photocraft_doc::Fill {
photocraft_doc::Fill::Solid(photocraft_doc::Color::rgba(c[0], c[1], c[2], c[3]))
}
pub(crate) fn enabled_stroke_width(width: f32) -> f32 {
if width.is_finite() && width > 0.0 { width } else { 3.0 }
}
/// One corner of the live rectangle, preserving the other three radii.
/// The engine takes the full [top-left, top-right, bottom-right, bottom-left] array.
fn corner_radii_patch(radii: [f64; 4], corner: usize, radius: f32) -> Value {
let mut next = radii;
if let Some(r) = next.get_mut(corner) {
*r = f64::from(radius.max(0.0));
}
json!({"radii": next})
}
/// Follow the existing brush/mask continuous-edit convention: one history state per press or
/// keyboard edit, with every value tick of a held-pointer gesture sharing its key.
pub(crate) fn paint_gesture(ui: &egui::Ui, key: egui::Id) -> u64 {
let pass = ui.ctx().cumulative_pass_nr();
let pressed = ui.input(|i| i.pointer.any_pressed());
ui.data_mut(|d| {
let gesture = d.get_temp_mut_or_default::<(u64, u64)>(key);
if pressed && gesture.1 != pass {
gesture.0 = gesture.0.wrapping_add(1);
gesture.1 = pass;
}
gesture.0
})
}
/// Properties panel for a shape layer: Appearance (fill, stroke) and live shape geometry.
pub fn shape_properties(app: &mut PhotocraftApp, ui: &mut egui::Ui, id: photocraft_doc::LayerId) {
if app.session.active().is_some_and(|st| {
let locks = st.doc.effective_locks(id);
locks.all || locks.pixels
}) {
ui.disable();
}
let Some(sh) = app.session.active().and_then(|s| s.doc.layer(id)).and_then(|l| match &l.content {
LayerContent::Shape(sh) => Some(sh.clone()),
_ => None,
}) else {
return;
};
let t = Tokens::get(ui.ctx());
let mut edit: Option<Value> = None;
let doc_id = app.session.active().map(|st| st.doc.id);
let key = |k: &str| format!("shape-{doc_id:?}-{}-{k}", id.0);
let gesture_key = ui.id().with(key("paint-gesture"));
let gesture = paint_gesture(ui, gesture_key);
let coalesce = |field: &str| format!("{}:{}:{gesture}", key(field), gesture_key.value());
// The shared collapsible section headers (#155).
// Prefs "Appearance" is theme chrome (Giao diện); shape fill/stroke is Diện mạo.
if crate::props_layout::section(ui, "appearance", crate::i18n::tr_ctx(crate::i18n::current(), "shape", "Appearance")) {
ui.horizontal(|ui| {
ui.label(egui::RichText::new(tl!("Fill")).color(t.text_dim).size(12.0));
if let Some(change) = swatch(ui, sh.fill.as_ref(), app.session.tools.foreground, tl!("Set shape fill type")) {
let fill = match change {
PaintChange::None => Value::Null,
PaintChange::Color(color) => json!(color),
};
edit = Some(json!({"fill": fill, "coalesce": coalesce("fill")}));
}
ui.add_space(12.0);
ui.label(egui::RichText::new(tl!("Stroke")).color(t.text_dim).size(12.0));
if let Some(change) = swatch(ui, sh.stroke.as_ref().map(|s| &s.paint), app.session.tools.foreground, tl!("Set shape stroke type")) {
let stroke = match change {
PaintChange::None => Value::Null,
PaintChange::Color(color) => json!({"color": color, "width": enabled_stroke_width(sh.stroke.as_ref().map_or(0.0, |s| s.width))}),
};
edit = Some(json!({"stroke": stroke, "coalesce": coalesce("stroke")}));
}
let mut w = sh.stroke.as_ref().map_or(0.0, |s| s.width);
if crate::widgets::value_field(ui, &mut w, 0.0..=288.0, "px", 60.0).changed() && (sh.stroke.is_some() || w > 0.0) {
edit = Some(json!({"stroke": {"width": w}, "coalesce": coalesce("stroke-w")}));
}
});
let style = sh.stroke.as_ref().map(crate::shape_stroke_ui::StrokeOptions::from).unwrap_or_default();
let stroke_enabled = sh.stroke.as_ref().is_some_and(|stroke| stroke.width > 0.0);
if let Some(change) = crate::shape_stroke_ui::button(
ui,
&key("style"),
&style,
&mut app.ui.stroke_editor,
sh.path.subpaths.iter().all(|s| s.closed),
!matches!(sh.live, Some(photocraft_doc::LiveShape::Ellipse { .. })),
app.session.active().map(|st| (st.doc.id, id)),
stroke_enabled,
) {
let mut stroke = change.options.params();
if !stroke_enabled {
stroke["width"] = json!(3.0);
}
edit = Some(json!({"stroke": stroke, "coalesce": change.coalesce}));
}
}
if let Some(live) = &sh.live
&& crate::props_layout::section(ui, "liveShape", tl!("Shape"))
{
let num = |ui: &mut egui::Ui, label: &str, v: &mut f32, range: std::ops::RangeInclusive<f32>, unit: &str| -> bool {
ui.label(egui::RichText::new(tl!(&label)).color(t.text_dim).size(12.0));
crate::widgets::value_field(ui, v, range, unit, 64.0).changed()
};
match live {
photocraft_doc::vector::LiveShape::Rect { rect, .. }
| photocraft_doc::vector::LiveShape::Ellipse { rect }
| photocraft_doc::vector::LiveShape::Polygon { rect, .. } => {
ui.horizontal(|ui| {
let (mut w, mut h) = (rect[2] as f32, rect[3] as f32);
let cw = num(ui, "W", &mut w, 1.0..=300000.0, "px");
let ch = num(ui, "H", &mut h, 1.0..=300000.0, "px");
if cw || ch {
edit = Some(json!({"rect": [rect[0], rect[1], w.round(), h.round()], "coalesce": key("wh")}));
}
});
}
photocraft_doc::vector::LiveShape::Line { .. } => {}
}
ui.vertical(|ui| match live {
photocraft_doc::vector::LiveShape::Rect { radii, .. } => {
// Keep the uniform workflow available after independent corner edits too.
ui.horizontal(|ui| {
let mut all = radii[0] as f32;
if num(ui, tl!("Corner radius"), &mut all, 0.0..=100000.0, "px") {
edit = Some(json!({"radii": all, "coalesce": key("radius-all")}));
}
});
// Separate rows also fit the narrow Properties dock. The labels use the
// localized corner names, rather than untranslated abbreviations.
for (index, label) in [(0, tl!("Top Left")), (1, tl!("Top Right")), (3, tl!("Bottom Left")), (2, tl!("Bottom Right"))] {
ui.horizontal(|ui| {
let mut radius = radii[index] as f32;
if num(ui, label, &mut radius, 0.0..=100000.0, "px") {
let mut patch = corner_radii_patch(*radii, index, radius);
patch["coalesce"] = json!(key(&format!("radius-{index}")));
edit = Some(patch);
}
});
}
}
photocraft_doc::vector::LiveShape::Polygon { sides, star_ratio, corner_radius, .. } => {
// One radius rounds every vertex of a triangle, polygon or star, as in Photoshop.
ui.horizontal(|ui| {
let mut r = *corner_radius as f32;
if num(ui, tl!("Corner radius"), &mut r, 0.0..=100000.0, "px") {
edit = Some(json!({"cornerRadius": r, "coalesce": key("corner-radius")}));
}
});
ui.horizontal(|ui| {
let mut n = *sides as f32;
if num(ui, tl!("Sides"), &mut n, 3.0..=100.0, "") {
edit = Some(json!({"sides": n.round() as u32, "coalesce": key("sides")}));
}
let mut sr = (*star_ratio * 100.0) as f32;
if num(ui, tl!("Star ratio"), &mut sr, 1.0..=100.0, "%") {
edit = Some(json!({"starRatio": sr as f64 / 100.0, "coalesce": key("star")}));
}
})
.inner
}
photocraft_doc::vector::LiveShape::Line { weight, .. } => {
ui.horizontal(|ui| {
let mut w = *weight as f32;
if num(ui, tl!("Weight"), &mut w, 1.0..=10000.0, "px") {
edit = Some(json!({"weight": w, "coalesce": key("weight")}));
}
})
.inner
}
_ => {}
});
}
if let Some(mut p) = edit {
p["layer"] = json!(id.0);
if let Err(e) = app.run("shape.edit", p) {
app.ui.status = e;
app.ui.status_error = true;
}
if !ui.input(|i| i.pointer.any_down()) {
ui.data_mut(|d| {
let gesture = d.get_temp_mut_or_default::<(u64, u64)>(gesture_key);
gesture.0 = gesture.0.wrapping_add(1);
});
}
}
}
// ---------------------------------------------------------------------------------------------
// Paths panel
fn thumb(ui: &egui::Ui, r: Rect, path: &Path, doc: &Document) {
let t = Tokens::get(ui.ctx());
// At the document's aspect ratio, like the Channels thumbnails.
let r = crate::channels_panel::fit_thumb(r, doc.size.width, doc.size.height).0;
ui.painter().rect_filled(r, 0.0, Color32::from_gray(if t.pro { 222 } else { 240 }));
let (w, h) = (doc.size.width.max(1) as f64, doc.size.height.max(1) as f64);
let s = (r.width() as f64 / w).min(r.height() as f64 / h);
let off = r.center() - vec2((w * s) as f32 / 2.0, (h * s) as f32 / 2.0);
let map = |q: [f64; 2]| pos2(off.x + (q[0] * s) as f32, off.y + (q[1] * s) as f32);
for (pts, closed) in path_lines(path, &map) {
if closed && pts.len() >= 3 {
ui.painter().add(egui::Shape::closed_line(pts, Stroke::new(1.0, Color32::from_gray(40))));
} else {
ui.painter().add(egui::Shape::line(pts, Stroke::new(1.0, Color32::from_gray(40))));
}
}
}
/// What a Paths panel row is.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum PathRow {
Saved,
Work,
/// The selected layer's shape path or vector mask (temporary, italic).
Layer,
}
/// A Paths panel row.
#[derive(Clone, Debug)]
pub struct PathEntry {
pub name: String,
pub path: Path,
pub kind: PathRow,
}
/// The Paths panel's rows, top to bottom: saved paths, the work path, then the selected layer's
/// shape path ("<Layer> Shape Path") or vector mask ("<Layer> Vector Mask"), like Photoshop.
pub fn path_rows(doc: &Document, active: Option<photocraft_doc::LayerId>) -> Vec<PathEntry> {
let mut rows: Vec<_> = doc.paths.iter().map(|p| PathEntry { name: p.name.clone(), path: p.path.clone(), kind: PathRow::Saved }).collect();
if let Some(wp) = &doc.work_path {
rows.push(PathEntry { name: "Work Path".into(), path: wp.clone(), kind: PathRow::Work });
}
if let Some(l) = active.and_then(|id| doc.layer(id)) {
let layer_path = match &l.content {
LayerContent::Shape(sh) => Some((format!("{} Shape Path", l.name), sh.path.clone())),
_ => l.vector_mask.as_ref().map(|v| (format!("{} Vector Mask", l.name), v.path.clone())),
};
if let Some((name, path)) = layer_path {
rows.push(PathEntry { name, path, kind: PathRow::Layer });
}
}
rows
}
fn footer_id() -> egui::Id {
egui::Id::new("paths-footer")
}
/// A Paths panel row being dragged, for a drop on the trash (#6553): its name and the command
/// that deletes it.
#[derive(Clone, Debug)]
struct PathDrag {
name: String,
cmd: &'static str,
params: Value,
}
fn path_drag_key() -> egui::Id {
egui::Id::new("paths-drag")
}
fn ctx_data_footer(ctx: &egui::Context, r: Rect) {
ctx.data_mut(|d| d.insert_temp(footer_id(), r));
}
/// Where the Paths panel's footer buttons were drawn last frame (the rect around them all).
pub fn paths_footer(ctx: &egui::Context) -> Option<Rect> {
ctx.data(|d| d.get_temp(footer_id()))
}
/// Photoshop's default name for a saved path: the first free "Path N", counting from the number of
/// saved paths.
fn free_path_name(doc: &Document) -> String {
let mut n = doc.paths.len().saturating_add(1);
while doc.paths.iter().any(|p| p.name == format!("Path {n}")) {
n = n.saturating_add(1);
if n == usize::MAX {
break;
}
}
format!("Path {n}")
}
/// A Paths panel name being typed in place: the row's key ("work" or the saved path's name) and
/// the text so far. It lives in egui's temp data, like the Channels panel's rename field.
#[derive(Clone)]
struct PathRename {
key: String,
text: String,
focused: bool,
}
fn rename_id(doc: &Document) -> egui::Id {
egui::Id::new(("path-rename", doc.id.0))
}
/// Commands offered by a Paths row's context menu. The row's path is passed explicitly so a
/// right-click acts on that row even when another path is selected in the panel. `layer` is the
/// layer a `PathRow::Layer` row belongs to (the active layer).
fn path_context_actions(entry: &PathEntry, doc: &Document, layer: Option<photocraft_doc::LayerId>) -> Vec<(&'static str, &'static str, Value)> {
let key = match entry.kind {
PathRow::Work => "work".to_string(),
PathRow::Layer => "layer".to_string(),
PathRow::Saved => entry.name.clone(),
};
let mut actions = vec![
("Make Selection", "path.toSelection", json!({"name": key})),
("Fill Path", "path.fill", json!({"name": key})),
("Stroke Path…", "path.stroke", json!({"name": key})),
];
if entry.kind == PathRow::Work {
actions.push(("Save Path", "path.rename", json!({"name": "work", "to": free_path_name(doc)})));
} else {
let mut n = 1usize;
while doc.paths.iter().any(|p| p.name == format!("{} copy {n}", entry.name)) {
n = n.saturating_add(1);
if n == usize::MAX {
break;
}
}
let copy_name = format!("{} copy {n}", entry.name);
actions.push(("Duplicate Path", "path.set", json!({"name": copy_name, "path": photocraft_engine::vector_cmds::path_json(&entry.path)})));
}
if entry.kind == PathRow::Saved {
// No `to`: the panel asks for the new name in place.
actions.push(("Rename Path…", "path.rename", json!({"name": key})));
}
if entry.kind != PathRow::Layer {
actions.push(("Delete Path", "path.delete", json!({"name": key})));
} else if entry.name.ends_with(" Vector Mask") {
actions.push(("Delete Vector Mask", "layer.vectorMask.delete", json!({})));
} else if let Some(id) = layer {
// A shape layer's path is the shape: Photoshop's Delete Path deletes the layer (#6552).
actions.push(("Delete Path", "layer.delete", json!({"layer": id.0})));
}
actions
}
pub fn paths_panel(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
let t = Tokens::get(ui.ctx());
let Some(st) = app.session.active() else {
ui.label(egui::RichText::new(tl!("No document")).color(t.text_faint));
return;
};
let doc = st.doc.clone();
let st_layer = st.active_layer;
let rows = path_rows(&doc, st_layer);
let has_layer_path = rows.iter().any(|r| r.kind == PathRow::Layer);
let mut action: Option<(&str, Value)> = None;
let mut stroke_dialog: Option<String> = None;
// A row dragged onto the trash is deleted (#6553); a drag that never saw its release must not
// outlive it.
let ctx = ui.ctx().clone();
if !ctx.input(|i| i.pointer.primary_down() || i.pointer.any_released()) {
ctx.data_mut(|d| d.remove::<PathDrag>(path_drag_key()));
}
let drag = ctx.data(|d| d.get_temp::<PathDrag>(path_drag_key()));
let rename_id = rename_id(&doc);
// The buttons sit in a footer at the panel's bottom, like Photoshop's.
let footer = crate::widgets::footer_height(ui) + ui.spacing().item_spacing.y;
let fill = ui.available_height() > footer + 60.0;
let rows_h = if fill { ui.available_height() - footer } else { f32::INFINITY };
egui::ScrollArea::vertical().id_salt("path-rows").max_height(rows_h).min_scrolled_height(if fill { rows_h } else { 0.0 }).auto_shrink([false, !fill]).show(
ui,
|ui| {
if rows.is_empty() {
ui.label(egui::RichText::new(tl!("Draw with the Pen tool (P) or make a work path from a selection.")).color(t.text_faint).size(11.5));
}
for PathEntry { name, path, kind } in &rows {
// What dropping the row on the trash runs; a shape layer's path is not dragged.
let delete = match kind {
PathRow::Work => Some(("path.delete", json!({"name": "work"}))),
PathRow::Saved => Some(("path.delete", json!({"name": name}))),
PathRow::Layer if name.ends_with(" Vector Mask") => Some(("layer.vectorMask.delete", json!({}))),
PathRow::Layer => None,
};
let sense = if delete.is_some() { Sense::click_and_drag() } else { Sense::click() };
let (r, resp) = ui.allocate_exact_size(vec2(ui.available_width(), 36.0), sense);
let key = match kind {
PathRow::Work => "work".to_string(),
PathRow::Layer => "layer".to_string(),
PathRow::Saved => name.clone(),
};
if resp.drag_started()
&& let Some((cmd, params)) = delete
{
let name = if *kind == PathRow::Work { tl!(name).to_string() } else { name.clone() };
ui.ctx().data_mut(|d| d.insert_temp(path_drag_key(), PathDrag { name, cmd, params }));
}
// Rows are painted: name them for screen readers and UI tests.
resp.widget_info(|| egui::WidgetInfo::labeled(egui::WidgetType::SelectableLabel, true, name));
let sel = app.ui.selected_path.as_deref() == Some(key.as_str());
if sel {
ui.painter().rect_filled(r, 0.0, t.row_selected);
} else if resp.hovered() {
ui.painter().rect_filled(r, 0.0, t.hover.gamma_multiply(0.5));
}
let thumbnail = Rect::from_min_size(pos2(r.left() + 8.0, r.top() + 4.0), vec2(28.0, 28.0));
thumb(ui, thumbnail, path, &doc);
let mut job = egui::text::LayoutJob::default();
// Temporary paths (the work path, the selected layer's shape path or vector mask) are italic.
let italics = *kind != PathRow::Saved;
job.append(
if *kind == PathRow::Work { tl!(name) } else { name },
0.0,
egui::TextFormat { font_id: egui::FontId::proportional(12.0), color: t.text, italics, ..Default::default() },
);
let renaming = ui.ctx().data(|d| d.get_temp::<PathRename>(rename_id)).filter(|e| e.key == key);
if let Some(mut edit) = renaming {
let field = Rect::from_min_max(pos2(r.left() + 43.0, r.center().y - 11.0), pos2(r.right() - 8.0, r.center().y + 11.0));
let id = rename_id.with("field");
let te = ui.put(field, egui::TextEdit::singleline(&mut edit.text).id(id).font(egui::FontId::proportional(12.0)));
let (enter, esc) = ui.input(|i| (i.key_pressed(egui::Key::Enter), i.key_pressed(egui::Key::Escape)));
if !edit.focused {
te.request_focus();
// Like Photoshop, the whole name starts selected so typing replaces it.
if let Some(mut state) = egui::TextEdit::load_state(ui.ctx(), id) {
let all = egui::text::CCursorRange::two(egui::text::CCursor::new(0), egui::text::CCursor::new(edit.text.chars().count()));
state.cursor.set_char_range(Some(all));
state.store(ui.ctx(), id);
}
edit.focused = true;
ui.ctx().data_mut(|d| d.insert_temp(rename_id, edit));
} else if esc {
ui.ctx().data_mut(|d| d.remove::<PathRename>(rename_id));
} else if enter || te.lost_focus() || !te.has_focus() {
ui.ctx().data_mut(|d| d.remove::<PathRename>(rename_id));
let to = edit.text.trim();
// The Work Path is saved even under its proposed name; an unchanged saved name is left alone.
if !to.is_empty() && (*kind == PathRow::Work || to != name) {
action = Some(("path.rename", json!({"name": key, "to": to})));
}
} else {
ui.ctx().data_mut(|d| d.insert_temp(rename_id, edit));
}
} else {
let g = ui.painter().layout_job(job);
ui.painter().galley(pos2(r.left() + 46.0, r.center().y - g.size().y / 2.0), g, t.text);
}
// Ctrl/Cmd-click loads only the thumbnail's path, without changing the panel target.
let modifiers = ui.input(|i| i.modifiers);
let load = resp.clicked() && modifiers.command && resp.interact_pointer_pos().is_some_and(|p| thumbnail.contains(p));
if load {
let mode = match crate::channels_panel::load_operation(modifiers) {
"new" => "replace",
mode => mode,
};
action = Some(("path.toSelection", json!({"name": key, "mode": mode})));
} else if resp.clicked() {
app.ui.selected_path = Some(key.clone());
}
// As in Photoshop, double-clicking a saved path's name renames it, and double-clicking
// the Work Path asks for the name to save it under (#6238).
let proposed = match kind {
PathRow::Work => Some(free_path_name(&doc)),
PathRow::Saved => Some(name.clone()),
PathRow::Layer => None,
};
if !load
&& resp.double_clicked()
&& let Some(text) = proposed
{
ui.ctx().data_mut(|d| d.insert_temp(rename_id, PathRename { key: key.clone(), text, focused: false }));
}
resp.context_menu(|ui| {
crate::widgets::menu_scroll(ui, |ui| {
ui.set_min_width(190.0);
let entry = PathEntry { name: name.clone(), path: path.clone(), kind: *kind };
let can_paint = app.session.active().and_then(|s| s.active_layer.and_then(|id| s.doc.layer(id))).is_some_and(|l| l.surface().is_some());
for (label, cmd, params) in path_context_actions(&entry, &doc, st_layer) {
let enabled = !matches!(cmd, "path.fill" | "path.stroke") || can_paint;
if ui.add_enabled(enabled, egui::Button::new(tl!(label))).clicked() {
if cmd == "path.stroke" {
// Stroke Path… asks for the tool first, as in Photoshop (#2978).
stroke_dialog = Some(params.get("name").and_then(Value::as_str).unwrap_or("work").to_string());
} else if cmd == "path.rename" && params.get("to").is_none() {
let edit = PathRename { key: key.clone(), text: name.clone(), focused: false };
ui.ctx().data_mut(|d| d.insert_temp(rename_id, edit));
} else {
action = Some((cmd, params));
}
ui.close();
}
}
});
});
ui.painter().line_segment([r.left_bottom(), r.right_bottom()], Stroke::new(1.0, t.separator));
}
// Clicking the empty area deselects the path, as in Photoshop: new fill and
// adjustment layers then take the selection as their mask instead (#1419).
let rest = ui.available_rect_before_wrap();
let rest = rest.intersect(Rect::from_min_size(rest.min, vec2(rest.width(), rest.height().min(4000.0))));
if rest.is_positive() && ui.interact(rest, ui.id().with("paths-empty"), Sense::click()).clicked() {
app.ui.selected_path = None;
}
},
);
// The dragged row follows the cursor.
if let Some(drag) = &drag
&& let Some(p) = ctx.input(|i| i.pointer.interact_pos())
{
crate::layer_transfer::ghost(&ctx, p, &drag.name);
}
let sel = app.ui.selected_path.clone().filter(|s| s != "layer" || has_layer_path).unwrap_or_else(|| "work".into());
let buttons = crate::widgets::panel_footer(ui, |ui| {
let fg = hex(app.session.tools.foreground);
let mut n = doc.paths.len() + 1;
while doc.paths.iter().any(|p| p.name == format!("Path {n}")) {
n += 1;
}
let items: [(&str, &str, &str, Value); 7] = [
("paint-bucket", "Fill path with foreground color", "path.fill", json!({"name": sel, "color": fg})),
("circle", "Stroke path with brush", "path.stroke", json!({"name": sel, "tool": "brush"})),
("square-dashed", "Load path as a selection", "path.toSelection", json!({"name": sel})),
("spline", "Make work path from selection", "select.toWorkPath", json!({"tolerance": 2.0})),
("square", "Add vector mask", "layer.vectorMask.fromPath", json!({"name": sel})),
("square-plus", "Create new path", "path.set", json!({"name": format!("Path {n}"), "path": {"subpaths": []}})),
("trash", "Delete path", "path.delete", json!({"name": sel})),
];
// The layer's own path: deleting it deletes the vector mask (a shape keeps its path).
let shape = rows.iter().any(|r| r.kind == PathRow::Layer && r.name.ends_with(" Shape Path"));
let delete_layer_path = sel == "layer" && !shape;
let items = items.map(|(icon, tip, cmd, p)| {
if cmd == "path.delete" && delete_layer_path { (icon, "Delete vector mask", "layer.vectorMask.delete", json!({})) } else { (icon, tip, cmd, p) }
});
// Laid out from the right, so the last button goes first.
let mut buttons = Rect::NOTHING;
for (icon, tip, cmd, p) in items.into_iter().rev() {
let icon = if crate::icons::exists(icon) { icon } else { "square" };
let b = crate::icons::button(ui, icon, 26.0, false, tip);
if b.clicked() {
if cmd == "path.stroke" && ui.input(|i| i.modifiers.alt) {
// Alt-click opens the Stroke Path dialog, as in Photoshop (#2978).
stroke_dialog = Some(sel.clone());
} else {
action = Some((cmd, p));
}
}
// A row dropped on the trash deletes that row's path, selected or not (#6553).
if matches!(cmd, "path.delete" | "layer.vectorMask.delete")
&& let Some(drag) = &drag
&& crate::panels::dropped_on(ui, &b)
{
action = Some((drag.cmd, drag.params.clone()));
}
buttons = buttons.union(b.rect);
}
buttons
});
ctx_data_footer(ui.ctx(), buttons);
if ctx.input(|i| i.pointer.any_released()) {
ctx.data_mut(|d| d.remove::<PathDrag>(path_drag_key()));
}
if let Some(name) = stroke_dialog {
crate::canvas_tool_menu::stroke_path_dialog(app, &name);
}
if let Some((cmd, p)) = action {
let renamed = if cmd == "path.rename" { p.get("to").and_then(Value::as_str).map(str::to_string) } else { None };
match app.run(cmd, p) {
// The renamed (or just saved) path stays the panel's target.
Ok(_) => {
if renamed.is_some() {
app.ui.selected_path = renamed;
}
}
Err(e) => {
app.ui.status = e;
app.ui.status_error = true;
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
/// #4084: zoomed in, a curve's chords stay within a fraction of a pixel of the true curve
/// (16 fixed chords showed corners), and a straight segment stays one chord.
#[test]
fn path_curves_stay_smooth_at_any_zoom() {
let (p0, c0, c1, p1) = ([0.0, 100.0], [20.0, -60.0], [80.0, -60.0], [100.0, 100.0]);
for zoom in [0.25, 1.0, 8.0, 64.0, 320.0] {
let xf = move |q: [f64; 2]| pos2((q[0] * zoom) as f32 + 10.0, (q[1] * zoom) as f32 - 5.0);
let pts = curve_points(p0, c0, c1, p1, &xf);
let n = pts.len() - 1;
assert_eq!((pts[0], pts[n]), (xf(p0), xf(p1)), "the ends are the anchors");
for (k, w) in pts.windows(2).enumerate() {
let curve = xf(bezier(p0, c0, c1, p1, (k as f64 + 0.5) / n as f64));
let chord = w[0] + (w[1] - w[0]) * 0.5;
assert!((chord - curve).length() <= 0.35, "zoom {zoom}: chord {k} of {n} is {} px off", (chord - curve).length());
}
// Zoomed out it stays cheap.
if zoom <= 1.0 {
assert!(n <= 32, "zoom {zoom}: {n} chords");
}
}
let xf = |q: [f64; 2]| pos2((q[0] * 320.0) as f32, (q[1] * 320.0) as f32);
// Retracted handles, and handles along the line: one chord.
assert_eq!(curve_points([0.0, 0.0], [0.0, 0.0], [50.0, 50.0], [50.0, 50.0], &xf).len(), 2);
assert_eq!(curve_points([0.0, 0.0], [10.0, 10.0], [40.0, 40.0], [50.0, 50.0], &xf).len(), 2);
// A handle past the end is a curve that doubles back, not a line.
assert!(curve_points([0.0, 0.0], [0.0, 0.0], [80.0, 80.0], [50.0, 50.0], &xf).len() > 2);
// Hostile coordinates: no panic, a bounded number of points.
for bad in [f64::NAN, f64::INFINITY, 1e300] {
assert!(curve_points([0.0, 0.0], [bad, 0.0], [0.0, bad], [1.0, 1.0], &xf).len() <= MAX_CURVE_PIECES + 1);
}
// Through path_lines too: a closed subpath of two curved segments.
let mut path = Path::default();
path.subpaths.push(photocraft_doc::vector::Subpath {
knots: vec![
photocraft_doc::vector::Knot {
anchor: photocraft_geom::Point::new(0.0, 0.0),
in_ctrl: photocraft_geom::Point::new(0.0, 40.0),
out_ctrl: photocraft_geom::Point::new(0.0, -40.0),
smooth: true,
},
photocraft_doc::vector::Knot {
anchor: photocraft_geom::Point::new(60.0, 0.0),
in_ctrl: photocraft_geom::Point::new(60.0, -40.0),
out_ctrl: photocraft_geom::Point::new(60.0, 40.0),
smooth: true,
},
],
closed: true,
..Default::default()
});
let lines = path_lines(&path, &xf);
assert!(lines[0].1 && lines[0].0.len() > 2 * 17, "zoomed in, more than the old 16 chords per segment: {}", lines[0].0.len());
}
#[test]
fn all_shape_tools_and_open_pen_use_the_complete_stroke_defaults() {
for tool in [Tool::Rectangle, Tool::EllipseShape, Tool::Triangle, Tool::Polygon, Tool::Line, Tool::CustomShape] {
let mut a = app();
a.ui.tool_options.stroke_width = 5.0;
a.ui.tool_options.shape_stroke = crate::shape_stroke_ui::StrokeOptions {
cap: photocraft_doc::LineCap::Square,
join: photocraft_doc::LineJoin::Bevel,
dashes: vec![4.0, 2.0, 1.0, 3.0],
dash_offset: -0.5,
opacity: 0.4,
..Default::default()
};
let history = a.session.active().unwrap().history.past_len();
finish_shape(&mut a, tool, [20.0, 20.0], [120.0, 100.0], Default::default());
let info = a.run("shape.info", json!({})).unwrap();
assert_eq!(info["stroke"]["dashes"], json!([4.0, 2.0, 1.0, 3.0]));
assert_eq!(info["stroke"]["cap"], "square");
assert_eq!(info["stroke"]["width"], 5.0);
assert_eq!(a.session.active().unwrap().history.past_len(), history + 1);
a.run("edit.undo", json!({})).unwrap();
a.run("edit.redo", json!({})).unwrap();
assert_eq!(a.run("shape.info", json!({})).unwrap(), info);
a.ui.tool_options.vector_mode = "shape".into();
a.ui.pen = Some(PenPath { knots: vec![[[30.0, 40.0]; 3], [[80.0, 40.0]; 3]], ..Default::default() });
pen_commit(&mut a, false);
let open = a.run("shape.info", json!({})).unwrap();
assert_eq!(open["stroke"]["dashes"], info["stroke"]["dashes"]);
assert_eq!(open["path"]["subpaths"][0]["closed"], false);
}
}
fn app() -> PhotocraftApp {
let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
app.session.execute("file.new", json!({"width": 200, "height": 200})).unwrap();
app.sync_views();
app
}
#[test]
fn paths_context_menu_uses_the_clicked_row_and_dispatches_commands() {
let mut app = app();
let path = json!({"subpaths": [{"closed": true, "knots": [
{"anchor": [10, 10], "in": [10, 10], "out": [10, 10]},
{"anchor": [80, 10], "in": [80, 10], "out": [80, 10]},
{"anchor": [80, 80], "in": [80, 80], "out": [80, 80]}
]}]});
app.run("path.set", json!({"name": "First", "path": path})).unwrap();
app.run("path.set", json!({"name": "Second", "path": path})).unwrap();
let doc = &app.session.active().unwrap().doc;
let first = path_rows(doc, None).into_iter().find(|r| r.name == "First").unwrap();
let entries = path_context_actions(&first, doc, None);
assert_eq!(entries[0].1, "path.toSelection");
assert_eq!(entries[0].2["name"], "First");
assert!(entries.iter().all(|(_, id, _)| photocraft_engine::commands::find(id).is_some()));
let (_, id, params) = entries.into_iter().find(|(_, id, _)| *id == "path.toSelection").unwrap();
app.run(id, params).unwrap();
assert!(app.session.active().unwrap().doc.selection.is_some());
assert_eq!(app.session.journal.last().map(|(id, _)| id.as_str()), Some("path.toSelection"));
app.run("path.set", json!({"name": "First copy 1", "path": path})).unwrap();
let doc = &app.session.active().unwrap().doc;
let first = path_rows(doc, None).into_iter().find(|r| r.name == "First").unwrap();
let (_, _, duplicate) = path_context_actions(&first, doc, None).into_iter().find(|(_, id, _)| *id == "path.set").unwrap();
assert_eq!(duplicate["name"], "First copy 2", "duplicate must not overwrite an existing path");
}
#[test]
fn work_path_context_save_and_layer_path_deletion_rules() {
let mut app = app();
let path = json!({"subpaths": []});
app.run("path.set", json!({"name": "work", "path": path})).unwrap();
let doc = &app.session.active().unwrap().doc;
let work = path_rows(doc, None).into_iter().find(|r| r.kind == PathRow::Work).unwrap();
let entries = path_context_actions(&work, doc, None);
assert!(entries.iter().any(|(_, id, _)| *id == "path.rename"));
assert!(!entries.iter().any(|(_, id, _)| *id == "path.set"));
let layer = PathEntry { kind: PathRow::Layer, ..work };
let entries = path_context_actions(&layer, doc, None);
assert!(!entries.iter().any(|(_, id, _)| *id == "path.delete"));
}
/// #6552: a shape layer's "<Layer> Shape Path" row offers Delete Path, and it deletes the
/// shape layer, as Photoshop's Delete Path does (measured: one "Delete Layer" step).
#[test]
fn shape_path_row_delete_path_deletes_the_shape_layer() {
let mut app = app();
app.run("shape.create", json!({"kind": "ellipse", "rect": [20, 20, 100, 70]})).unwrap();
let st = app.session.active().unwrap();
let (doc, shape) = (st.doc.clone(), st.active_layer);
let layers = doc.layers.len();
let row = path_rows(&doc, shape).into_iter().find(|r| r.kind == PathRow::Layer).unwrap();
assert!(row.name.ends_with(" Shape Path"), "{}", row.name);
let (_, id, params) =
path_context_actions(&row, &doc, shape).into_iter().find(|(label, _, _)| *label == "Delete Path").expect("Delete Path is offered");
app.run(id, params).unwrap();
let doc = &app.session.active().unwrap().doc;
assert_eq!(doc.layers.len(), layers - 1);
assert!(shape.and_then(|id| doc.layer(id)).is_none(), "the shape layer is gone");
app.run("edit.undo", json!({})).unwrap();
assert!(shape.and_then(|id| app.session.active().unwrap().doc.layer(id)).is_some(), "one undo step brings it back");
}
/// #6238: double-clicking a saved path's name renames it in place, and double-clicking the
/// Work Path saves it under the name typed (it used to save it as "Path N" straight away).
#[test]
fn double_clicking_a_path_name_renames_it_in_place() {
use egui_kittest::{Harness, kittest::Queryable};
let mut app = app();
let path = json!({"subpaths": [{"closed": true, "knots": [
{"anchor": [10, 10], "in": [10, 10], "out": [10, 10]},
{"anchor": [80, 10], "in": [80, 10], "out": [80, 10]},
{"anchor": [80, 80], "in": [80, 80], "out": [80, 80]}
]}]});
app.run("path.set", json!({"name": "First", "path": path})).unwrap();
app.run("path.set", json!({"name": "work", "path": path})).unwrap();
// 60 fps steps, so two clicks a frame apart count as a double-click.
let mut h = Harness::builder().with_size(vec2(320.0, 260.0)).with_step_dt(1.0 / 60.0).build_ui_state(|ui, app| paths_panel(app, ui), app);
h.run_steps(3);
let rename = |h: &mut Harness<'_, PhotocraftApp>, row: &str, text: &str| {
let name = h.get_by_label(row).rect().left_center() + vec2(60.0, 0.0);
h.event(egui::Event::PointerMoved(name));
h.run_steps(30);
for pressed in [true, false, true, false] {
h.event(egui::Event::PointerButton { pos: name, button: egui::PointerButton::Primary, pressed, modifiers: egui::Modifiers::NONE });
h.step();
}
h.run_steps(3);
h.event(egui::Event::Text(text.into()));
h.run_steps(1);
h.key_press(egui::Key::Enter);
h.run_steps(3);
};
let names = |h: &Harness<'_, PhotocraftApp>| h.state().session.active().unwrap().doc.paths.iter().map(|p| p.name.clone()).collect::<Vec<_>>();
rename(&mut h, "First", "Outline");
assert_eq!(names(&h), ["Outline"]);
assert!(h.state().session.active().unwrap().doc.work_path.is_some(), "renaming a saved path leaves the work path alone");
rename(&mut h, "Work Path", "Circle");
assert_eq!(names(&h), ["Outline", "Circle"]);
assert!(h.state().session.active().unwrap().doc.work_path.is_none());
assert_eq!(h.state().ui.selected_path.as_deref(), Some("Circle"));
}
/// #6238: a saved path's context menu offers Rename Path…, as the Layers panel's does.
#[test]
fn saved_path_context_menu_offers_rename() {
let mut app = app();
app.run("path.set", json!({"name": "First", "path": {"subpaths": []}})).unwrap();
app.run("path.set", json!({"name": "work", "path": {"subpaths": []}})).unwrap();
let doc = &app.session.active().unwrap().doc;
let rename = |kind| {
let entry = path_rows(doc, None).into_iter().find(|r| r.kind == kind).unwrap();
path_context_actions(&entry, doc, None).into_iter().find(|(label, _, _)| *label == "Rename Path…").map(|(_, id, p)| (id, p))
};
assert_eq!(rename(PathRow::Saved), Some(("path.rename", json!({"name": "First"}))));
assert_eq!(rename(PathRow::Work), None, "the work path is saved, not renamed");
}
/// How many shapes the path overlay paints for `app` this frame.
fn overlay_shapes(app: &PhotocraftApp, ctx: &egui::Context) -> usize {
let doc = app.session.active().unwrap().doc.clone();
let mut out = ctx.run_ui(egui::RawInput::default(), |ui| {
let rect = Rect::from_min_size(Pos2::ZERO, vec2(400.0, 400.0));
let painter = ui.ctx().layer_painter(egui::LayerId::background()).with_clip_rect(rect);
let xf = ViewXform { rect, zoom: 1.0, center: [100.0, 100.0], flip: false, rotation: 0.0, aspect: 1.0 };
draw_overlay(app, &painter, &xf, &doc);
});
out.textures_delta.clear();
out.shapes.len()
}
#[test]
fn pen_keeps_anchors_of_a_finished_path() {
// #6884: a path finished with Enter, or by closing it, lost its anchor squares while the
// Pen stayed active, so it looked gone and could not be edited.
let ctx = egui::Context::default();
let mut app = app();
app.ui.tool = Tool::Pen;
let knots = vec![[[10.0, 10.0]; 3], [[80.0, 10.0]; 3], [[80.0, 80.0]; 3]];
app.ui.pen = Some(PenPath { knots, ..Default::default() });
pen_commit(&mut app, true);
assert!(app.ui.pen.is_none());
assert!(app.session.active().unwrap().doc.work_path.is_some());
let with_pen = overlay_shapes(&app, &ctx);
app.ui.tool = Tool::Brush;
let outline_only = overlay_shapes(&app, &ctx);
assert!(outline_only > 0, "the outline is drawn with any tool");
// Each of the three anchors adds its square (fill and stroke).
assert!(with_pen >= outline_only + 3, "Pen draws the anchors: {with_pen} vs {outline_only}");
for tool in [Tool::Pen, Tool::FreeformPen, Tool::CurvaturePen, Tool::PathSelection] {
assert!(shows_anchors(tool), "{tool:?}");
}
assert!(!shows_anchors(Tool::Brush) && !shows_anchors(Tool::Move));
}
#[test]
fn an_unselected_work_path_is_not_drawn_over_the_canvas() {
// #6551: Ctrl-click Load as Selection leaves the Paths panel's selection alone, yet the Work
// Path stayed drawn over the new selection's edge. Photoshop draws it only while selected
// in the Paths panel (or a path tool is active).
let ctx = egui::Context::default();
let mut app = app();
let path = json!({"subpaths": [{"closed": true, "knots": [
{"anchor": [20, 20], "in": [20, 20], "out": [20, 20]},
{"anchor": [90, 20], "in": [90, 20], "out": [90, 20]},
{"anchor": [90, 90], "in": [90, 90], "out": [90, 90]}
]}]});
app.run("path.set", json!({"name": "work", "path": path})).unwrap();
app.run("path.toSelection", json!({"name": "work", "mode": "replace"})).unwrap();
assert!(app.ui.selected_path.is_none());
for tool in [Tool::Move, Tool::Brush, Tool::Rectangle, Tool::Zoom] {
app.ui.tool = tool;
assert_eq!(overlay_shapes(&app, &ctx), 0, "{tool:?}: an unselected Work Path stays off the canvas");
}
// Selected in the Paths panel: drawn with any tool.
app.ui.selected_path = Some("work".into());
for tool in [Tool::Move, Tool::Brush] {
app.ui.tool = tool;
assert!(overlay_shapes(&app, &ctx) > 0, "{tool:?}: the selected Work Path is drawn");
}
// Another path selected: the Work Path is not the target path.
app.ui.selected_path = Some("Saved".into());
app.ui.tool = Tool::Move;
assert_eq!(overlay_shapes(&app, &ctx), 0);
// A path tool shows the Work Path it edits even when the panel selection was cleared.
app.ui.selected_path = None;
for tool in [Tool::Pen, Tool::PathSelection] {
app.ui.tool = tool;
assert!(overlay_shapes(&app, &ctx) > 0, "{tool:?}: path tools draw the Work Path");
}
}
#[test]
fn show_target_path_and_extras_hide_the_path_outlines() {
// #1119: View › Show › Target Path only flipped its checkmark; the canvas kept drawing the
// work path and the active shape's path.
let ctx = egui::Context::default();
let mut app = app();
let path = json!({"subpaths": [{"closed": true, "knots": [
{"anchor": [10, 10], "in": [10, 10], "out": [10, 10]},
{"anchor": [80, 10], "in": [80, 10], "out": [80, 10]},
{"anchor": [80, 80], "in": [80, 80], "out": [80, 80]}
]}]});
app.run("path.set", json!({"path": path})).unwrap();
assert!(app.session.active().unwrap().doc.work_path.is_some());
finish_shape(&mut app, Tool::Rectangle, [100.0, 100.0], [160.0, 150.0], egui::Modifiers::NONE);
let toggle = |app: &mut PhotocraftApp, id: &str| crate::menus::invoke(app, &ctx, id, Value::Null).unwrap();
for tool in [Tool::Pen, Tool::PathSelection, Tool::DirectSelection, Tool::Rectangle] {
app.ui.tool = tool;
assert!(app.ui.view.show.target_path && app.ui.view.extras);
assert!(overlay_shapes(&app, &ctx) > 0, "{tool:?}: the paths are drawn by default");
toggle(&mut app, "view.show.targetPath");
assert!(!app.ui.view.show.target_path);
assert_eq!(overlay_shapes(&app, &ctx), 0, "{tool:?}: Target Path off");
toggle(&mut app, "view.show.targetPath");
toggle(&mut app, "view.extras");
assert!(!app.ui.view.extras);
assert_eq!(overlay_shapes(&app, &ctx), 0, "{tool:?}: Extras off");
toggle(&mut app, "view.extras");
assert!(overlay_shapes(&app, &ctx) > 0, "{tool:?}: shown again");
}
// The Pen's path in progress is a gesture, not the target path: it stays visible.
app.ui.tool = Tool::Pen;
app.ui.pen = Some(PenPath { knots: vec![[[20.0, 20.0]; 3], [[60.0, 40.0]; 3]], ..Default::default() });
toggle(&mut app, "view.show.targetPath");
assert!(overlay_shapes(&app, &ctx) > 0, "the pen path in progress is still drawn");
}
#[test]
fn the_saved_path_selected_in_the_paths_panel_is_drawn() {
// #6550: selecting a saved path in the Paths panel drew nothing on the canvas.
let ctx = egui::Context::default();
let mut app = app();
let tri = |o: f64| {
json!({"subpaths": [{"closed": true, "knots": [
{"anchor": [20.0 + o, 20], "in": [20.0 + o, 20], "out": [20.0 + o, 20]},
{"anchor": [90.0 + o, 20], "in": [90.0 + o, 20], "out": [90.0 + o, 20]},
{"anchor": [90.0 + o, 90], "in": [90.0 + o, 90], "out": [90.0 + o, 90]}
]}]})
};
app.run("path.set", json!({"name": "Path 1", "path": tri(0.0)})).unwrap();
app.run("path.set", json!({"name": "Path 2", "path": tri(10.0)})).unwrap();
assert!(app.session.active().unwrap().doc.work_path.is_none());
for tool in [Tool::Move, Tool::Brush, Tool::Pen, Tool::PathSelection, Tool::DirectSelection] {
app.ui.tool = tool;
app.ui.selected_path = None;
assert_eq!(overlay_shapes(&app, &ctx), 0, "{tool:?}: nothing selected, nothing drawn");
app.ui.selected_path = Some("Path 1".into());
assert_eq!(selected_saved_path(&app).map(|p| p.subpaths[0].knots[0].anchor.x), Some(20.0));
assert!(overlay_shapes(&app, &ctx) > 0, "{tool:?}: the selected saved path is drawn");
app.ui.selected_path = Some("Path 2".into());
assert_eq!(selected_saved_path(&app).map(|p| p.subpaths[0].knots[0].anchor.x), Some(30.0));
app.ui.selected_path = Some("Gone".into());
assert_eq!(overlay_shapes(&app, &ctx), 0, "{tool:?}: a missing path draws nothing");
app.ui.selected_path = Some("Path 1".into());
app.ui.view.show.target_path = false;
assert_eq!(overlay_shapes(&app, &ctx), 0, "{tool:?}: View > Show > Target Path off");
app.ui.view.show.target_path = true;
}
// Path Selection (and the Pen tools, as for the work path) add anchor squares.
app.ui.tool = Tool::Move;
let plain = overlay_shapes(&app, &ctx);
app.ui.tool = Tool::PathSelection;
assert!(overlay_shapes(&app, &ctx) > plain);
app.ui.tool = Tool::Pen;
assert!(overlay_shapes(&app, &ctx) > plain);
}
#[test]
fn shape_drag_creates_layers_with_modifiers() {
let mut app = app();
finish_shape(&mut app, Tool::Rectangle, [10.0, 10.0], [60.0, 30.0], egui::Modifiers::SHIFT);
let st = app.session.active().unwrap();
let b = st.doc.layer(st.active_layer.unwrap()).unwrap().surface().unwrap().content_bounds();
assert_eq!((b.width(), b.height()), (50, 50), "shift = square");
finish_shape(&mut app, Tool::EllipseShape, [100.0, 100.0], [120.0, 110.0], egui::Modifiers::ALT);
let st = app.session.active().unwrap();
let b = st.doc.layer(st.active_layer.unwrap()).unwrap().surface().unwrap().content_bounds();
assert!(b.x0.abs_diff(80) <= 1 && b.width().abs_diff(40) <= 1, "alt = from centre: {b:?}");
finish_shape(&mut app, Tool::Line, [10.0, 150.0], [90.0, 152.0], egui::Modifiers::SHIFT);
assert_eq!(app.session.active().unwrap().doc.layers.len(), 4);
}
#[test]
fn shift_pressed_during_a_shape_drag_constrains_it() {
// #668: ⇧ only counted when held at the press; Photoshop constrains when it is pressed
// mid-drag (and stops when it is released).
use crate::canvas::{ToolEvent, tool_event};
for (tool, sides) in [(Tool::Polygon, 6), (Tool::Rectangle, 4), (Tool::EllipseShape, 0)] {
let mut app = app();
app.ui.tool = tool;
app.ui.tool_options.polygon_sides = 6;
let none = egui::Modifiers::NONE;
tool_event(&mut app, ToolEvent::Down { x: 10.0, y: 10.0, pressure: 1.0 }, none);
tool_event(&mut app, ToolEvent::Move { x: 40.0, y: 30.0, pressure: 1.0 }, none);
tool_event(&mut app, ToolEvent::Move { x: 70.0, y: 40.0, pressure: 1.0 }, egui::Modifiers::SHIFT);
tool_event(&mut app, ToolEvent::Up { x: 70.0, y: 40.0 }, egui::Modifiers::SHIFT);
let st = app.session.active().unwrap();
let l = st.doc.layer(st.active_layer.unwrap()).unwrap();
assert!(matches!(l.content, LayerContent::Shape(_)), "{tool:?} ({sides} sides): a shape layer");
let b = l.surface().unwrap().content_bounds();
// The drag is 60 × 30; constrained, the shape's box is 60 × 60 (a hexagon is narrower
// than its box, so the height tells).
assert!(b.height().abs_diff(60) <= 1 && b.width() <= 61, "{tool:?}: ⇧ mid-drag keeps proportions: {b:?}");
}
}
#[test]
fn shape_preview_is_the_committed_path() {
let mut app = app();
app.ui.tool_options.corner_radius = 8.0;
let preview = |app: &PhotocraftApp, tool, end| {
shape_geometry(&app.ui.tool_options, tool, [10.0, 10.0], end, egui::Modifiers::ALT)
.and_then(|p| photocraft_engine::vector_cmds::shape_path(&p).ok())
};
for tool in [Tool::Rectangle, Tool::EllipseShape, Tool::Triangle, Tool::Polygon, Tool::Line] {
let shown = preview(&app, tool, [60.0, 30.0]).unwrap();
finish_shape(&mut app, tool, [10.0, 10.0], [60.0, 30.0], egui::Modifiers::ALT);
let st = app.session.active().unwrap();
let LayerContent::Shape(sh) = &st.doc.layer(st.active_layer.unwrap()).unwrap().content else { panic!("{tool:?}: no shape layer") };
assert_eq!(sh.path, shown, "{tool:?}");
}
assert!(preview(&app, Tool::Rectangle, [10.2, 40.0]).is_none(), "too thin to draw");
assert!(photocraft_engine::vector_cmds::shape_path(&json!({"kind": "nope", "rect": [0, 0, 5, 5]})).is_err());
assert!(photocraft_engine::vector_cmds::shape_path(&json!({"kind": "rect"})).is_err());
}
#[test]
fn pen_shows_the_close_cue_only_over_the_first_anchor_of_a_real_segment() {
let mut app = app();
app.ui.tool = Tool::Pen;
pen_down(&mut app, 20.0, 20.0, false);
pen_up(&mut app);
let one = app.ui.pen.clone().unwrap();
assert!(!over_first_anchor(&one, [20.0, 20.0], 6.0), "a single anchor has nothing to close");
pen_down(&mut app, 120.0, 20.0, false);
pen_up(&mut app);
let two = app.ui.pen.clone().unwrap();
assert!(over_first_anchor(&two, [22.0, 21.0], 6.0));
assert!(!over_first_anchor(&two, [60.0, 60.0], 6.0));
}
#[test]
fn pen_builds_and_closes_a_work_path() {
let mut app = app();
app.ui.tool = Tool::Pen;
for (x, y) in [(20.0, 20.0), (120.0, 20.0)] {
pen_down(&mut app, x, y, false);
pen_up(&mut app);
}
pen_down(&mut app, 120.0, 120.0, false);
pen_move(&mut app, 140.0, 140.0, false); // smooth knot
pen_up(&mut app);
pen_down(&mut app, 20.5, 20.5, false); // click the first anchor: close
pen_up(&mut app);
assert!(app.ui.pen.is_none());
let wp = app.session.active().unwrap().doc.work_path.clone().unwrap();
assert!(wp.subpaths[0].closed && wp.subpaths[0].knots.len() == 3);
assert!(wp.subpaths[0].knots[2].smooth);
// Path Selection moves it.
path_selection_finish(&mut app, [50.0, 50.0], [60.0, 55.0]);
let wp = app.session.active().unwrap().doc.work_path.clone().unwrap();
assert_eq!((wp.subpaths[0].knots[0].anchor.x, wp.subpaths[0].knots[0].anchor.y), (30.0, 25.0));
}
fn close(a: [f64; 2], b: [f64; 2]) -> bool {
(a[0] - b[0]).abs() < 1e-9 && (a[1] - b[1]).abs() < 1e-9
}
#[test]
fn pen_shift_click_puts_the_next_anchor_on_a_45_degree_ray() {
let mut app = app();
app.ui.tool = Tool::Pen;
// The first anchor has nothing to constrain against: it lands where clicked.
pen_down(&mut app, 20.0, 20.0, true);
pen_up(&mut app);
assert_eq!(app.ui.pen.as_ref().unwrap().knots[0][0], [20.0, 20.0]);
// ~30° below horizontal snaps to the 45° diagonal at the pointer's projection.
let (dx, dy) = (100.0 * 30f64.to_radians().cos(), 100.0 * 30f64.to_radians().sin());
pen_down(&mut app, 20.0 + dx, 20.0 + dy, true);
pen_up(&mut app);
let k = app.ui.pen.as_ref().unwrap().knots[1];
let t = 100.0 * 15f64.to_radians().cos() / std::f64::consts::SQRT_2;
assert!(close(k[0], [20.0 + t, 20.0 + t]), "{:?}", k[0]);
assert!(k[1] == k[0] && k[2] == k[0], "a click stays a corner");
// ~10° off vertical snaps to straight down from the previous anchor.
let prev = k[0];
pen_down(&mut app, prev[0] + 8.0, prev[1] + 50.0, true);
pen_up(&mut app);
assert!(close(app.ui.pen.as_ref().unwrap().knots[2][0], [prev[0], prev[1] + 50.0]));
// Without ⇧ the anchor stays at the pointer.
pen_down(&mut app, 200.0, 190.0, false);
pen_up(&mut app);
assert_eq!(app.ui.pen.as_ref().unwrap().knots[3][0], [200.0, 190.0]);
// ⇧ does not stop a click on the first anchor from closing the path.
pen_down(&mut app, 20.5, 20.5, true);
pen_up(&mut app);
assert!(app.ui.pen.is_none());
assert!(app.session.active().unwrap().doc.work_path.as_ref().unwrap().subpaths[0].closed);
}
#[test]
fn pen_shift_drag_turns_handles_to_45_degrees_live() {
let mut app = app();
app.ui.tool = Tool::Pen;
pen_down(&mut app, 20.0, 20.0, false);
pen_up(&mut app);
pen_down(&mut app, 100.0, 100.0, false);
// Without ⇧ the handle follows the pointer.
pen_move(&mut app, 130.0, 110.0, false);
assert_eq!(app.ui.pen.as_ref().unwrap().knots[1][2], [130.0, 110.0]);
// Pressing ⇧ mid-drag snaps the handle (~18°) to horizontal; the opposite handle mirrors it.
pen_move(&mut app, 130.0, 110.0, true);
let k = app.ui.pen.as_ref().unwrap().knots[1];
assert!(close(k[2], [130.0, 100.0]) && close(k[1], [70.0, 100.0]), "{k:?}");
assert_eq!(k[0], [100.0, 100.0], "the anchor does not move");
// Releasing ⇧ frees it again.
pen_move(&mut app, 120.0, 140.0, false);
assert_eq!(app.ui.pen.as_ref().unwrap().knots[1][2], [120.0, 140.0]);
// ⌥ breaks the pair; ⇧ then constrains the outgoing handle alone (~63° → 45°).
pen_break_handle(&mut app);
pen_move(&mut app, 120.0, 140.0, true);
let k = app.ui.pen.as_ref().unwrap().knots[1];
assert!(close(k[2], [130.0, 130.0]), "{k:?}");
assert_eq!(k[1], [80.0, 60.0], "the incoming handle stays where it was");
pen_up(&mut app);
// Degenerate: ⇧ with the pointer on the anchor leaves the handle on it.
pen_down(&mut app, 200.0, 100.0, false);
pen_move(&mut app, 200.0, 100.0, true);
let k = app.ui.pen.as_ref().unwrap().knots[2];
assert!(k.iter().all(|p| *p == [200.0, 100.0]), "{k:?}");
pen_up(&mut app);
}
/// #5373: an unfinished path stays with its own document through same-frame switches.
#[test]
fn an_unclosed_path_stays_with_its_document() {
// Both pens claim the document at their first anchor.
let open_path = |app: &mut PhotocraftApp| {
for (x, y) in [(20.0, 20.0), (120.0, 60.0)] {
if app.ui.tool == Tool::CurvaturePen {
curvature_down(app, x, y);
curvature_up(app);
} else {
pen_down(app, x, y, false);
pen_up(app);
}
}
};
let work = |app: &PhotocraftApp, i: usize| app.session.documents()[i].doc.work_path.clone();
// File › New commits the path to its original document.
for tool in [Tool::Pen, Tool::CurvaturePen] {
let mut app = app();
app.ui.tool = tool;
open_path(&mut app);
assert!(app.ui.pen.is_some() && app.ui.pen_doc.is_some(), "{tool:?}: claimed by its document");
app.run("file.new", json!({"width": 300, "height": 150})).unwrap();
assert!(app.ui.pen.is_none() && app.ui.pen_doc.is_none(), "{tool:?}: the first document's path is gone");
assert!(work(&app, 0).is_some(), "{tool:?}: the original keeps its Work Path");
assert_eq!(work(&app, 1), None, "{tool:?}: the new document is blank");
}
// Two documents; the path below is drawn on the second (active) one.
let mut app = app();
app.ui.tool = Tool::Pen;
app.run("file.new", json!({"width": 300, "height": 150})).unwrap();
open_path(&mut app);
assert!(app.session.set_active(0));
pen_commit(&mut app, false);
assert!(app.ui.pen.is_none());
assert!(work(&app, 0).is_none(), "the active document stays untouched");
assert!(work(&app, 1).is_some(), "the owner keeps its Work Path");
// Staying on its own document, the path still commits there.
open_path(&mut app);
pen_commit(&mut app, false);
assert!(work(&app, 0).is_some(), "it commits to the document it was drawn on");
assert!(work(&app, 1).is_some());
for act in [0, 1, 2] {
open_path(&mut app);
assert!(app.session.set_active(1));
match act {
0 => pen_down(&mut app, 50.0, 50.0, false),
1 => curvature_down(&mut app, 50.0, 50.0),
_ => assert!(!pen_undo_last_point(&mut app), "nothing of this document's to undo"),
}
let knots = app.ui.pen.as_ref().map_or(0, |p| p.knots.len());
assert!(knots <= 1, "act {act}: a new path, not the other document's (knots {knots})");
// The two drawing entry points start a path of their own here; undo has none to take.
let expected = if act == 2 { None } else { app.session.active().map(|st| st.doc.id) };
assert_eq!(app.ui.pen_doc, expected, "act {act}");
app.ui.pen = None;
app.ui.pen_doc = None;
assert!(app.session.set_active(0));
}
open_path(&mut app);
let shapes = |app: &PhotocraftApp| {
let ctx = egui::Context::default();
let doc = app.session.active().unwrap().doc.clone();
let xf = ViewXform {
rect: egui::Rect::from_min_size(egui::pos2(0.0, 0.0), egui::vec2(400.0, 300.0)),
zoom: 1.0,
center: [100.0, 75.0],
flip: false,
rotation: 0.0,
aspect: 1.0,
};
let mut out = ctx.run_ui(Default::default(), |ui| draw_overlay(app, ui.painter(), &xf, &doc));
out.textures_delta.clear();
out.shapes.len()
};
// Same view, pen present vs absent: the difference is the path itself, nothing else.
let drawn = |app: &mut PhotocraftApp| {
let with_pen = shapes(app);
let pen = app.ui.pen.take();
let without = shapes(app);
app.ui.pen = pen;
with_pen - without
};
assert!(drawn(&mut app) > 0, "its own document draws the path");
assert!(app.session.set_active(1));
assert_eq!(drawn(&mut app), 0, "the other document draws nothing of it");
assert!(app.session.set_active(0));
app.ui.pen = None;
app.ui.pen_doc = None;
open_path(&mut app);
app.ui.direct_selection.target = Some(crate::direct_select::PathRef::Pen);
app.ui.direct_selection.anchors = vec![[0, 1]];
app.run("file.new", json!({"width": 120, "height": 90})).unwrap();
assert_eq!(app.ui.direct_selection, Default::default(), "the anchors went with the path");
}
#[test]
fn pen_overlay_uses_the_view_document_even_during_direct_selection() {
let mut app = app();
app.ui.tool = Tool::Pen;
pen_down(&mut app, 20.0, 20.0, false);
pen_up(&mut app);
pen_down(&mut app, 80.0, 60.0, false);
pen_up(&mut app);
let owner = app.session.active().unwrap().doc.clone();
app.session.execute("file.new", json!({"width": 200, "height": 200})).unwrap();
let other = app.session.active().unwrap().doc.clone();
let xf =
ViewXform { rect: Rect::from_min_size(Pos2::ZERO, vec2(400.0, 300.0)), zoom: 1.0, center: [100.0, 100.0], flip: false, rotation: 0.0, aspect: 1.0 };
let shapes = |app: &PhotocraftApp, doc: &Document, modifiers| {
let ctx = egui::Context::default();
let mut output = ctx.run_ui(egui::RawInput { events: vec![egui::Event::ModifiersChanged(modifiers)], ..Default::default() }, |ui| {
draw_overlay(app, ui.painter(), &xf, doc)
});
output.textures_delta.clear();
output.shapes.len()
};
for active in [0, 1] {
assert!(app.session.set_active(active));
for tool in [Tool::Pen, Tool::DirectSelection] {
app.ui.tool = tool;
for modifiers in [egui::Modifiers::NONE, egui::Modifiers::COMMAND] {
for (doc, visible) in [(&owner, true), (&other, false)] {
let with_pen = shapes(&app, doc, modifiers);
let pen = app.ui.pen.take();
let without = shapes(&app, doc, modifiers);
app.ui.pen = pen;
assert_eq!(with_pen > without, visible, "active {active}, {tool:?}, {modifiers:?}");
}
}
}
}
}
#[test]
fn failed_stale_pen_commit_preserves_the_draft_until_retry() {
for action in ["pen", "curvature", "undo", "commit", "command"] {
let mut app = app();
app.run("path.set", json!({"name": "work", "path": {"subpaths": [{"closed": false, "knots": [[5, 5], [10, 10]]}]}})).unwrap();
let original = app.session.active().unwrap().doc.work_path.clone().unwrap();
app.ui.tool = Tool::Pen;
for (x, y) in [(20.0, 20.0), (80.0, 60.0)] {
pen_down(&mut app, x, y, false);
pen_up(&mut app);
}
let draft = app.ui.pen.clone();
let owner = app.ui.pen_doc;
app.session.execute("file.new", json!({"width": 200, "height": 200})).unwrap();
app.ui.tool_options.vector_mode = "shape".into();
app.ui.selected_path = Some("foreign named path".into());
app.session.authorize = Some(|_, _| Err(photocraft_engine::EngineError::Other("test rejection".into())));
match action {
"pen" => pen_down(&mut app, 150.0, 150.0, false),
"curvature" => curvature_down(&mut app, 150.0, 150.0),
"undo" => assert!(!pen_undo_last_point(&mut app)),
"commit" => pen_commit(&mut app, true),
_ => {
assert!(app.run("file.close", json!({})).is_err());
}
}
assert_eq!(app.ui.pen, draft, "{action}: failed save retains all anchors");
assert_eq!(app.ui.pen_doc, owner);
assert_eq!(app.session.active_index(), Some(1));
assert_eq!(app.session.documents()[0].doc.work_path.as_ref(), Some(&original));
assert!(app.session.documents()[1].doc.work_path.is_none());
assert!(app.ui.status_error);
assert!(!crate::direct_select::candidates(&app).iter().any(|(target, _)| *target == crate::direct_select::PathRef::Pen));
app.session.authorize = None;
app.sync_views();
assert!(app.ui.pen.is_none());
assert_eq!(app.session.active_index(), Some(1));
assert_eq!(app.ui.selected_path.as_deref(), Some("foreign named path"));
let saved = app.session.documents()[0].doc.work_path.clone().unwrap();
assert_eq!(saved.subpaths.len(), original.subpaths.len() + 1);
assert_eq!(saved.subpaths[0], original.subpaths[0]);
app.sync_views();
assert_eq!(app.session.documents()[0].doc.work_path.as_ref(), Some(&saved), "retry never duplicates the path");
assert!(app.session.set_active(0));
assert!(app.session.undo());
assert_eq!(app.session.active().unwrap().doc.work_path.as_ref(), Some(&original));
}
}
#[test]
fn new_document_reports_a_failed_work_path_save_and_retains_the_draft() {
let mut app = app();
pen_down(&mut app, 20.0, 20.0, false);
pen_up(&mut app);
pen_down(&mut app, 80.0, 60.0, false);
pen_up(&mut app);
let draft = app.ui.pen.clone();
app.session.authorize = Some(|id, _| if id == "path.set" { Err(photocraft_engine::EngineError::Other("test rejection".into())) } else { Ok(()) });
app.run("file.new", json!({"width": 200, "height": 200})).unwrap();
assert!(app.ui.status_error);
assert!(app.ui.status.contains("test rejection"));
assert_eq!(app.ui.pen, draft);
assert_eq!(app.session.active_index(), Some(1));
assert!(app.session.documents().iter().all(|d| d.doc.work_path.is_none()));
app.session.authorize = None;
app.sync_views();
assert!(app.ui.pen.is_none());
assert!(app.session.documents()[0].doc.work_path.is_some());
assert!(app.session.documents()[1].doc.work_path.is_none());
}
#[test]
fn new_document_preserves_a_single_pen_anchor_as_a_work_path() {
for tool in [Tool::Pen, Tool::CurvaturePen] {
let mut app = app();
app.ui.tool = tool;
if tool == Tool::Pen {
pen_down(&mut app, 20.0, 30.0, false);
pen_up(&mut app);
} else {
curvature_down(&mut app, 20.0, 30.0);
curvature_up(&mut app);
}
app.run("file.new", json!({"width": 200, "height": 200})).unwrap();
assert!(app.ui.pen.is_none());
let path = app.session.documents()[0].doc.work_path.as_ref().unwrap();
assert_eq!(path.subpaths[0].knots.len(), 1);
assert_eq!(path.subpaths[0].knots[0].anchor, photocraft_geom::Point::new(20.0, 30.0));
assert!(app.session.active().unwrap().doc.work_path.is_none());
}
}
#[test]
fn stale_pen_commits_to_its_owner_across_document_changes() {
use photocraft_doc::{ColorMode, SampleType, Size};
for tool in [Tool::Pen, Tool::CurvaturePen] {
for action in ["switch", "open", "closeOther", "pen", "curvature", "undo", "commit"] {
let mut app = app();
app.run("file.new", json!({"width": 200, "height": 200})).unwrap();
app.ui.tool = tool;
for (x, y) in [(20.0, 20.0), (80.0, 60.0), (120.0, 30.0)] {
if tool == Tool::Pen {
pen_down(&mut app, x, y, false);
pen_up(&mut app);
} else {
curvature_down(&mut app, x, y);
curvature_up(&mut app);
}
}
let owner = app.ui.pen_doc.unwrap();
let expected = photocraft_engine::vector_cmds::parse_path(&pen_to_json(app.ui.pen.as_ref().unwrap(), false)).unwrap();
app.ui.direct_selection.target = Some(crate::direct_select::PathRef::Pen);
app.ui.direct_selection.anchors = vec![[0, 1]];
assert!(app.session.set_active(0));
match action {
"open" => {
app.services.import =
Some(Box::new(|name, _, _| Ok((Document::new(name, Size::new(4, 4), ColorMode::Rgb, SampleType::U8), Vec::new()))));
app.open_file("synthetic.png", &[]).unwrap();
}
"closeOther" => {
app.run("file.close", json!({"document": 0})).unwrap();
}
"pen" => pen_down(&mut app, 150.0, 150.0, false),
"curvature" => curvature_down(&mut app, 150.0, 150.0),
"undo" => assert!(!pen_undo_last_point(&mut app)),
"commit" => pen_commit(&mut app, true),
_ => app.sync_views(),
}
let source = app.session.documents().iter().find(|d| d.doc.id == owner).unwrap();
let path = source.doc.work_path.as_ref().expect("the owner keeps the unfinished path");
assert_eq!(path, &expected, "{tool:?} {action}");
assert!(app.session.documents().iter().filter(|d| d.doc.id != owner).all(|d| d.doc.work_path.is_none()));
if action != "closeOther" {
assert_ne!(app.session.active().unwrap().doc.id, owner, "the active document is restored");
}
assert_eq!(app.ui.direct_selection, Default::default());
let index = app.session.documents().iter().position(|d| d.doc.id == owner).unwrap();
assert!(app.session.set_active(index));
assert!(app.session.undo());
assert!(app.session.active().unwrap().doc.work_path.is_none());
assert!(app.session.redo());
assert!(app.session.active().unwrap().doc.work_path.is_some());
}
}
}
/// #4721: a second Pen path joins the Work Path it was drawn after (still selected), as a new
/// subpath, instead of replacing it; a saved path that is selected takes it instead; with no
/// path selected, the new path replaces the Work Path, as in Photoshop.
#[test]
fn a_new_pen_path_joins_the_selected_path() {
let mut app = app();
app.ui.tool = Tool::Pen;
let draw = |app: &mut PhotocraftApp, x: f64| {
for (dx, dy) in [(0.0, 0.0), (40.0, 0.0), (40.0, 40.0)] {
pen_down(app, x + dx, 20.0 + dy, false);
pen_up(app);
}
pen_down(app, x + 0.5, 20.5, false); // close
pen_up(app);
};
let work = |app: &PhotocraftApp| app.session.active().unwrap().doc.work_path.clone().unwrap();
draw(&mut app, 20.0);
assert_eq!(app.ui.selected_path.as_deref(), Some("work"));
draw(&mut app, 120.0);
let wp = work(&app);
assert_eq!(wp.subpaths.len(), 2, "the first path stays");
assert!(wp.subpaths.iter().all(|s| s.closed && s.knots.len() == 3));
assert_eq!(wp.subpaths[0].knots[0].anchor.x, 20.0);
assert_eq!(wp.subpaths[1].knots[0].anchor.x, 120.0);
// One History step per path.
app.session.undo();
assert_eq!(work(&app).subpaths.len(), 1, "undo takes back only the second path");
app.session.redo();
// A selected saved path takes the next one.
app.run("path.set", json!({"name": "Saved", "path": {"subpaths": [{"knots": [[2, 2], [12, 2], [12, 8]]}]}})).unwrap();
app.ui.selected_path = Some("Saved".into());
draw(&mut app, 220.0);
let saved = app.session.active().unwrap().doc.paths.iter().find(|p| p.name == "Saved").unwrap().path.clone();
assert_eq!(saved.subpaths.len(), 2);
assert_eq!(work(&app).subpaths.len(), 2, "the Work Path is left alone");
assert_eq!(app.ui.selected_path.as_deref(), Some("Saved"));
// No path selected: a new Work Path replaces the old one.
app.ui.selected_path = None;
draw(&mut app, 320.0);
let wp = work(&app);
assert_eq!(wp.subpaths.len(), 1);
assert_eq!(wp.subpaths[0].knots[0].anchor.x, 320.0);
assert_eq!(app.ui.selected_path.as_deref(), Some("work"));
}
/// #4596: the close-path pointer shows where a click would close the path, and only there:
/// over the first anchor once the Pen has two anchors (the Curvature Pen three), not while an
/// anchor is being dragged.
#[test]
fn close_path_pointer_shows_where_a_click_closes() {
let mut app = app();
app.ui.tool = Tool::Pen;
assert!(!closes_path_at(&app, Tool::Pen, 20.0, 20.0), "no path yet");
pen_down(&mut app, 20.0, 20.0, false);
pen_up(&mut app);
assert!(!closes_path_at(&app, Tool::Pen, 20.0, 20.0), "one anchor: a click there doesn't close");
pen_down(&mut app, 120.0, 20.0, false);
assert!(!closes_path_at(&app, Tool::Pen, 20.0, 20.0), "not while dragging the new anchor");
pen_up(&mut app);
assert!(closes_path_at(&app, Tool::Pen, 21.0, 22.0), "over the first anchor");
assert!(!closes_path_at(&app, Tool::Pen, 120.0, 20.0) && !closes_path_at(&app, Tool::Pen, 60.0, 60.0), "the last anchor and empty canvas");
assert!(!closes_path_at(&app, Tool::CurvaturePen, 20.0, 20.0), "a Pen path isn't the Curvature Pen's");
pen_down(&mut app, 21.0, 22.0, false);
pen_up(&mut app);
assert!(app.ui.pen.is_none() && !closes_path_at(&app, Tool::Pen, 20.0, 20.0), "the click closed it");
app.ui.tool = Tool::CurvaturePen;
for (x, y) in [(20.0, 20.0), (120.0, 20.0)] {
curvature_down(&mut app, x, y);
curvature_up(&mut app);
}
assert!(!closes_path_at(&app, Tool::CurvaturePen, 20.0, 20.0), "two anchors: the Curvature Pen moves the first");
curvature_down(&mut app, 120.0, 120.0);
curvature_up(&mut app);
assert!(closes_path_at(&app, Tool::CurvaturePen, 20.0, 20.0));
assert!(!closes_path_at(&app, Tool::CurvaturePen, 120.0, 120.0));
}
#[test]
fn pen_point_undo_preserves_earlier_knots_and_document_history() {
let mut app = app();
app.ui.tool = Tool::Pen;
app.run("shape.create", json!({"kind": "rect", "rect": [10, 10, 40, 40], "fill": "#ff0000"})).unwrap();
let old_history = app.session.active().unwrap().history.past_len();
pen_down(&mut app, 20.0, 20.0, false);
pen_up(&mut app);
pen_down(&mut app, 120.0, 20.0, false);
pen_move(&mut app, 120.0, 60.0, false);
pen_up(&mut app);
pen_down(&mut app, 120.0, 120.0, false);
pen_up(&mut app);
let original_first_two = app.ui.pen.as_ref().unwrap().knots[..2].to_vec();
assert!(pen_undo_last_point(&mut app));
let pen = app.ui.pen.as_ref().unwrap();
assert_eq!(pen.knots, original_first_two);
assert!(!pen.dragging, "undo releases the current Pen drag");
assert_eq!(app.session.active().unwrap().history.past_len(), old_history, "undo must not roll back previous document changes");
assert!(app.session.active().unwrap().doc.work_path.is_none(), "path is not committed yet");
pen_commit(&mut app, false);
let work = app.session.active().unwrap().doc.work_path.as_ref().unwrap();
assert_eq!(work.subpaths[0].knots.len(), 2);
assert!(work.subpaths[0].knots[1].smooth, "retained smooth handles are unchanged");
}
#[test]
fn pen_undo_of_first_anchor_cancels_empty_draft() {
let mut app = app();
assert!(!pen_undo_last_point(&mut app));
pen_down(&mut app, 15.0, 17.0, false);
pen_up(&mut app);
assert!(pen_undo_last_point(&mut app));
assert!(app.ui.pen.is_none());
assert!(!pen_undo_last_point(&mut app));
assert_eq!(app.session.active().unwrap().history.past_len(), 0);
assert!(app.session.active().unwrap().doc.work_path.is_none());
}
/// #1419: Solid Color (and every new fill or adjustment layer) made while a path is selected
/// in the Paths panel takes it as its vector mask; with the path deselected, the selection
/// is its layer mask again.
#[test]
fn new_fill_layer_takes_the_selected_path_as_its_vector_mask() {
let mut app = app();
let layer = |app: &PhotocraftApp, r: Result<Value, String>| {
let id = photocraft_doc::LayerId(r.unwrap()["layer"].as_u64().unwrap());
app.session.active().unwrap().doc.layer(id).unwrap().clone()
};
// Drawing a work path with the Pen selects it.
app.ui.tool = Tool::Pen;
for (x, y) in [(20.0, 20.0), (120.0, 20.0), (120.0, 120.0)] {
pen_down(&mut app, x, y, false);
pen_up(&mut app);
}
pen_down(&mut app, 20.5, 20.5, false);
pen_up(&mut app);
assert_eq!(app.ui.selected_path.as_deref(), Some("work"));
let wp = app.session.active().unwrap().doc.work_path.clone().unwrap();
app.run("select.rect", json!({"x": 150, "y": 150, "width": 20, "height": 20})).unwrap();
for id in ["layer.newFillLayer.solidColor", "layer.newFillLayer.gradient", "layer.newAdjustmentLayer.invert"] {
app.ui.selected_path = Some("work".into());
let r = app.run(id, json!({}));
let l = layer(&app, r);
assert_eq!(l.vector_mask.as_ref().map(|v| &v.path), Some(&wp), "{id}: the work path is the vector mask");
assert!(l.mask.is_none(), "{id}: the path wins over the selection");
// The new layer's vector mask is now the active path, not the work path.
assert_eq!(app.ui.selected_path.as_deref(), Some("layer"), "{id}");
}
// So the next fill layer isn't masked by the work path again.
let r = app.run("layer.newFillLayer.solidColor", json!({}));
assert!(layer(&app, r).vector_mask.is_none());
// A caller can opt out.
let r = app.run("layer.newFillLayer.solidColor", json!({"path": null}));
assert!(layer(&app, r).vector_mask.is_none());
// A selected saved path is used.
app.run("path.set", json!({"name": "Saved", "path": {"subpaths": [{"closed": true, "knots": [[0, 0], [9, 0], [9, 9]]}]}})).unwrap();
app.ui.selected_path = Some("Saved".into());
let saved = app.session.active().unwrap().doc.paths[0].path.clone();
let r = app.run("layer.newFillLayer.solidColor", json!({}));
assert_eq!(layer(&app, r).vector_mask.map(|v| v.path), Some(saved));
// Deselected (or a stale name): the selection is the layer mask, no vector mask.
for sel in [None, Some("Gone".to_string())] {
app.ui.selected_path = sel;
let r = app.run("layer.newFillLayer.solidColor", json!({}));
let l = layer(&app, r);
assert!(l.vector_mask.is_none() && l.mask.is_some());
}
// Make Work Path selects the new work path.
app.run("select.toWorkPath", json!({"tolerance": 2.0})).unwrap();
assert_eq!(app.ui.selected_path.as_deref(), Some("work"));
}
/// #1482: clicking an existing final Pen anchor breaks its outgoing handle without
/// deleting the preceding curve or creating another knot; dragging changes only that handle.
#[test]
fn pen_last_anchor_can_be_broken_and_reshaped_while_drawing() {
use crate::canvas::{ToolEvent, tool_event};
let mut app = app();
app.ui.tool = Tool::Pen;
let down = |app: &mut PhotocraftApp, x, y| tool_event(app, ToolEvent::Down { x, y, pressure: 1.0 }, egui::Modifiers::NONE);
let move_to = |app: &mut PhotocraftApp, x, y| tool_event(app, ToolEvent::Move { x, y, pressure: 1.0 }, egui::Modifiers::NONE);
let up = |app: &mut PhotocraftApp, x, y| tool_event(app, ToolEvent::Up { x, y }, egui::Modifiers::NONE);
down(&mut app, 20.0, 20.0);
up(&mut app, 20.0, 20.0);
down(&mut app, 100.0, 20.0);
move_to(&mut app, 120.0, 40.0);
up(&mut app, 120.0, 40.0);
let original = app.ui.pen.as_ref().unwrap().knots[1];
assert_eq!(original, [[100.0, 20.0], [80.0, 0.0], [120.0, 40.0]]);
// Bare click breaks the outgoing handle, preserving the preceding segment's tangent.
down(&mut app, 100.0, 20.0);
up(&mut app, 100.0, 20.0);
let pen = app.ui.pen.as_ref().unwrap();
assert_eq!(pen.knots.len(), 2);
assert_eq!(pen.knots[1], [[100.0, 20.0], [80.0, 0.0], [100.0, 20.0]]);
assert!(!pen.dragging && !pen.adjusting_last);
// Re-dragging the same final anchor moves only its outgoing handle (a cusp).
down(&mut app, 100.0, 20.0);
move_to(&mut app, 110.0, 60.0);
up(&mut app, 110.0, 60.0);
let pen = app.ui.pen.as_ref().unwrap();
assert_eq!(pen.knots.len(), 2);
assert_eq!(pen.knots[1], [[100.0, 20.0], [80.0, 0.0], [110.0, 60.0]]);
// Drawing on still adds a separate next anchor and keeps the cusp in the work path.
down(&mut app, 150.0, 100.0);
up(&mut app, 150.0, 100.0);
assert_eq!(app.ui.pen.as_ref().unwrap().knots.len(), 3);
pen_commit(&mut app, false);
let work = app.session.active().unwrap().doc.work_path.as_ref().unwrap();
let k = &work.subpaths[0].knots[1];
assert_eq!([k.in_ctrl.x, k.in_ctrl.y], [80.0, 0.0]);
assert_eq!([k.out_ctrl.x, k.out_ctrl.y], [110.0, 60.0]);
assert!(!k.smooth, "breaking the handle must persist as an unlinked PSD/vector knot");
}
#[test]
fn pen_last_anchor_hit_tolerance_tracks_zoom_and_draft_round_trips() {
for zoom in [0.25, 1.0, 4.0] {
let mut app = app();
app.ui.views[0].zoom = zoom;
pen_down(&mut app, 20.0, 20.0, false);
pen_up(&mut app);
pen_down(&mut app, 100.0, 100.0, false);
pen_move(&mut app, 110.0, 120.0, false);
pen_up(&mut app);
let incoming = app.ui.pen.as_ref().unwrap().knots[1][1];
pen_down(&mut app, 100.0 + 5.0 / f64::from(zoom), 100.0, false);
pen_up(&mut app);
let pen = app.ui.pen.as_ref().unwrap();
assert_eq!(pen.knots.len(), 2);
assert_eq!(pen.knots[1][1], incoming);
assert_eq!(pen.knots[1][2], pen.knots[1][0]);
let saved = serde_json::to_value(pen).unwrap();
let restored: PenPath = serde_json::from_value(saved).unwrap();
assert_eq!(restored, *pen);
assert_eq!(pen_to_json(&restored, false)["subpaths"][0]["knots"][1]["smooth"], false);
pen_down(&mut app, 100.0 + 7.0 / f64::from(zoom), 100.0, false);
assert_eq!(app.ui.pen.as_ref().unwrap().knots.len(), 3);
}
let legacy: PenPath = serde_json::from_value(json!({"knots": [[[10, 10], [10, 10], [10, 10]]]})).unwrap();
assert!(legacy.unlinked.is_empty());
assert!(!legacy.dragging && !legacy.adjusting_last);
}
/// #1520: changing one corner through the Properties command must keep the other three
/// independent, remain a live rectangle, and undo/redo as one geometry edit.
#[test]
fn live_rectangle_corner_radius_edit_preserves_other_corners_and_history() {
let mut app = app();
let created = app.run("shape.create", json!({"kind": "roundedRect", "rect": [10, 10, 150, 100], "radii": [5, 10, 15, 20]})).unwrap();
let id = created["layer"].as_u64().unwrap();
let get_radii = |app: &PhotocraftApp| {
let st = app.session.active().unwrap();
let shape = st.doc.layer(photocraft_doc::LayerId(id)).unwrap();
match &shape.content {
LayerContent::Shape(sh) => match &sh.live {
Some(photocraft_doc::vector::LiveShape::Rect { radii, .. }) => *radii,
_ => panic!("rectangle must remain a live shape"),
},
_ => panic!("expected shape layer"),
}
};
assert_eq!(get_radii(&app), [5.0, 10.0, 15.0, 20.0]);
let mut patch = corner_radii_patch(get_radii(&app), 1, 30.0);
patch["layer"] = json!(id);
app.run("shape.edit", patch).unwrap();
assert_eq!(get_radii(&app), [5.0, 30.0, 15.0, 20.0]);
app.run("edit.undo", json!({})).unwrap();
assert_eq!(get_radii(&app), [5.0, 10.0, 15.0, 20.0]);
app.run("edit.redo", json!({})).unwrap();
assert_eq!(get_radii(&app), [5.0, 30.0, 15.0, 20.0]);
for corner in 0..4 {
let before = get_radii(&app);
let radius = 35.0 + corner as f32;
let mut expected = before;
expected[corner] = f64::from(radius);
let mut patch = corner_radii_patch(before, corner, radius);
patch["layer"] = json!(id);
app.run("shape.edit", patch).unwrap();
assert_eq!(get_radii(&app), expected);
app.run("edit.undo", json!({})).unwrap();
assert_eq!(get_radii(&app), before);
app.run("edit.redo", json!({})).unwrap();
assert_eq!(get_radii(&app), expected);
}
app.run("shape.edit", json!({"layer": id, "radii": 12})).unwrap();
assert_eq!(get_radii(&app), [12.0; 4]);
}
/// #534: dragging in a shape's fill picker, opened from the Properties panel at the right edge
/// of the window, keeps the picker in place (it flipped from side to side as its width
/// followed the colour readouts, which moved it under the pointer).
#[test]
fn shape_colour_picker_stays_put_while_dragging() {
use egui::{PointerButton, vec2};
use egui_kittest::kittest::Queryable;
let mut app = app();
let id = app.run("shape.create", json!({"kind": "rect", "rect": [10, 10, 100, 60], "fill": "#3070c0"})).unwrap()["layer"].as_u64().unwrap();
let mut h = egui_kittest::Harness::builder().with_size(vec2(1440.0, 900.0)).build_ui_state(
move |ui, app: &mut PhotocraftApp| {
// Fonts set up after the first frame only apply from the next one.
if !ui.ctx().fonts(|f| f.families().contains(&egui::FontFamily::Name("medium".into()))) {
return;
}
egui::Panel::right("properties").resizable(false).exact_size(285.0).show(ui, |ui| shape_properties(app, ui, photocraft_doc::LayerId(id)));
},
app,
);
PhotocraftApp::setup_context(&h.ctx, crate::theme::ThemeKind::Pro);
h.run_steps(4);
let label = h.query_all(egui_kittest::kittest::by().label("Fill").include_labels()).next().expect("the Fill label").rect();
// The swatch is right of its label.
let swatch = egui::pos2(label.right() + 17.0, label.center().y);
let press = |h: &mut egui_kittest::Harness<'_, PhotocraftApp>, pos, pressed| {
h.event(egui::Event::PointerButton { pos, button: PointerButton::Primary, pressed, modifiers: egui::Modifiers::NONE });
h.step();
};
h.hover_at(swatch);
h.step();
press(&mut h, swatch, true);
press(&mut h, swatch, false);
h.run_steps(3);
let popup = |h: &egui_kittest::Harness<'_, PhotocraftApp>| {
h.ctx.memory(|m| m.areas().visible_layer_ids().into_iter().filter(|l| l.order == egui::Order::Foreground).find_map(|l| m.area_rect(l.id)))
};
let opened = popup(&h).expect("the picker opened");
let fill = |h: &egui_kittest::Harness<'_, PhotocraftApp>| {
let st = h.state().session.active().unwrap();
match &st.doc.layer(photocraft_doc::LayerId(id)).unwrap().content {
LayerContent::Shape(sh) => sh.fill.clone(),
_ => None,
}
};
let before = fill(&h);
// Drag across the picker's colour area.
let start = opened.min + vec2(60.0, opened.height() * 0.5);
h.hover_at(start);
h.step();
press(&mut h, start, true);
for i in 1..=10 {
h.event(egui::Event::PointerMoved(start + vec2(i as f32 * 5.0, i as f32)));
h.step();
let r = popup(&h).expect("the picker stays open");
assert_eq!(r.left_top(), opened.left_top(), "step {i}: the picker moved from {opened:?} to {r:?}");
assert!(h.ctx.content_rect().contains_rect(r), "step {i}: {r:?} runs off the window");
}
press(&mut h, start, false);
assert_ne!(fill(&h), before, "the drag picked a colour");
}
/// The options bar edits the selected shape's fill and stroke.
#[test]
fn shape_options_bar_edits_the_selected_shape() {
use egui::accesskit::Role;
use egui_kittest::kittest::Queryable;
let mut app = app();
app.run("tools.setColors", json!({"foreground": "#ff0000", "background": "#0000ff"})).unwrap();
finish_shape(&mut app, Tool::Rectangle, [20.0, 20.0], [120.0, 100.0], Default::default());
let shape = |app: &PhotocraftApp| {
let st = app.session.active().unwrap();
match &st.doc.layer(st.active_layer.unwrap()).unwrap().content {
LayerContent::Shape(sh) => (sh.fill.clone(), sh.stroke.clone()),
_ => panic!("not a shape layer"),
}
};
assert!(shape(&app).0.is_some() && shape(&app).1.is_none());
let mut h = egui_kittest::Harness::builder().with_size(vec2(1100.0, 48.0)).build_ui_state(
|ui, app: &mut PhotocraftApp| {
if ui.ctx().fonts(|f| f.families().contains(&egui::FontFamily::Name("medium".into()))) {
ui.horizontal_centered(|ui| options_bar(app, ui, Tool::Rectangle));
}
},
app,
);
PhotocraftApp::setup_context(&h.ctx, crate::theme::ThemeKind::Studio);
h.run_steps(4);
let click_fill = |h: &mut egui_kittest::Harness<'_, PhotocraftApp>| {
let label = h.query_all(egui_kittest::kittest::by().label("Fill:").include_labels()).next().expect("the Fill label").rect();
let at = egui::pos2(label.right() + h.ctx.global_style().spacing.item_spacing.x + 7.0, label.center().y);
h.hover_at(at);
h.step();
for pressed in [true, false] {
h.event(egui::Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed, modifiers: egui::Modifiers::NONE });
h.step();
}
h.run_steps(2);
};
// Stroke width.
h.get_all_by_role(Role::SpinButton).next().expect("the stroke width").click();
h.run();
for c in "6".chars() {
h.event(egui::Event::Text(c.to_string()));
h.run();
}
h.key_press(egui::Key::Enter);
h.run_steps(2);
let stroke = shape(h.state()).1.expect("the width field stroked the shape");
assert_eq!(stroke.width, 6.0);
assert_eq!(stroke.paint, photocraft_doc::Fill::Solid(photocraft_doc::Color::rgba(0.0, 0.0, 1.0, 1.0)));
// Fill off.
click_fill(&mut h);
assert_eq!(shape(h.state()).0, None, "unchecking Fill removed the shape's fill");
assert!(!h.state().ui.tool_options.shape_fill, "and the next shape has none either");
h.state_mut().run("edit.undo", json!({})).unwrap();
assert!(shape(h.state()).0.is_some());
// No shape selected: no edit.
h.state_mut().run("layer.new.layer", json!({})).unwrap();
let history = h.state().session.active().unwrap().history.past_len();
h.run_steps(2);
click_fill(&mut h);
assert_eq!(h.state().session.active().unwrap().history.past_len(), history);
}
/// #3915: Path Selection and Direct Selection options bars show Fill, Stroke, and Radius
/// controls when a shape is selected, and editing them edits the selected shape.
#[test]
fn path_selection_options_bar_edits_the_selected_shape() {
use egui::accesskit::Role;
use egui_kittest::kittest::Queryable;
let mut app = app();
app.run("tools.setColors", json!({"foreground": "#ff0000", "background": "#0000ff"})).unwrap();
finish_shape(&mut app, Tool::Rectangle, [20.0, 20.0], [120.0, 100.0], Default::default());
let shape = |app: &PhotocraftApp| {
let st = app.session.active().unwrap();
match &st.doc.layer(st.active_layer.unwrap()).unwrap().content {
LayerContent::Shape(sh) => (sh.fill.clone(), sh.stroke.clone()),
_ => panic!("not a shape layer"),
}
};
assert!(shape(&app).0.is_some() && shape(&app).1.is_none());
let mut h = egui_kittest::Harness::builder().with_size(vec2(1100.0, 48.0)).build_ui_state(
|ui, app: &mut PhotocraftApp| {
if ui.ctx().fonts(|f| f.families().contains(&egui::FontFamily::Name("medium".into()))) {
ui.horizontal_centered(|ui| options_bar(app, ui, Tool::PathSelection));
}
},
app,
);
PhotocraftApp::setup_context(&h.ctx, crate::theme::ThemeKind::Studio);
h.run_steps(4);
let click_fill = |h: &mut egui_kittest::Harness<'_, PhotocraftApp>| {
let label = h.query_all(egui_kittest::kittest::by().label("Fill:").include_labels()).next().expect("the Fill label").rect();
let at = egui::pos2(label.right() + h.ctx.global_style().spacing.item_spacing.x + 7.0, label.center().y);
h.hover_at(at);
h.step();
for pressed in [true, false] {
h.event(egui::Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed, modifiers: egui::Modifiers::NONE });
h.step();
}
h.run_steps(2);
};
// Stroke width field is available on Path Selection bar too.
h.get_all_by_role(Role::SpinButton).next().expect("the stroke width").click();
h.run();
for c in "6".chars() {
h.event(egui::Event::Text(c.to_string()));
h.run();
}
h.key_press(egui::Key::Enter);
h.run_steps(2);
let stroke = shape(h.state()).1.expect("the width field stroked the shape");
assert_eq!(stroke.width, 6.0);
assert_eq!(stroke.paint, photocraft_doc::Fill::Solid(photocraft_doc::Color::rgba(0.0, 0.0, 1.0, 1.0)));
// Fill toggle.
click_fill(&mut h);
assert_eq!(shape(h.state()).0, None, "unchecking Fill removed the shape's fill");
// No shape selected: renders hint text instead.
h.state_mut().run("layer.new.layer", json!({})).unwrap();
h.run_steps(2);
assert!(h.query_all(egui_kittest::kittest::by().label("Fill:").include_labels()).next().is_none());
}
/// #6553: a Paths row dragged onto the footer's trash is deleted, whichever row is selected,
/// and a shape layer's path row does not start a drag.
#[test]
fn path_rows_dragged_onto_the_trash_are_deleted() {
use egui_kittest::kittest::Queryable;
let mut app = app();
let path = json!({"subpaths": [{"closed": true, "knots": [
{"anchor": [10, 10], "in": [10, 10], "out": [10, 10]},
{"anchor": [80, 10], "in": [80, 10], "out": [80, 10]},
{"anchor": [80, 80], "in": [80, 80], "out": [80, 80]}
]}]});
app.run("path.set", json!({"name": "Path 1", "path": path})).unwrap();
app.run("path.set", json!({"name": "work", "path": path})).unwrap();
app.ui.selected_path = Some("work".into());
let mut h = egui_kittest::Harness::builder().with_size(vec2(300.0, 400.0)).build_ui_state(|ui, app: &mut PhotocraftApp| paths_panel(app, ui), app);
h.run_steps(3);
let trash = |h: &egui_kittest::Harness<'_, PhotocraftApp>| {
let buttons: Vec<Rect> = h
.ctx
.viewport(|v| v.prev_pass.widgets.layers().flat_map(|(_, w)| w.iter()).filter(|w| w.rect.size() == vec2(26.0, 26.0)).map(|w| w.rect).collect());
buttons.into_iter().max_by(|a, b| a.center().x.total_cmp(&b.center().x)).unwrap().center()
};
let drag = |h: &mut egui_kittest::Harness<'_, PhotocraftApp>, from: Pos2, to: Pos2| {
h.event(egui::Event::PointerMoved(from));
h.event(egui::Event::PointerButton { pos: from, button: egui::PointerButton::Primary, pressed: true, modifiers: egui::Modifiers::NONE });
h.step();
for k in 1..=10 {
h.event(egui::Event::PointerMoved(from + (to - from) * (k as f32 / 10.0)));
h.step();
}
h.event(egui::Event::PointerButton { pos: to, button: egui::PointerButton::Primary, pressed: false, modifiers: egui::Modifiers::NONE });
h.run_steps(3);
};
// The saved path, while the work path is selected: only the dragged row goes.
let (row, to) = (h.get_by_label("Path 1").rect().center(), trash(&h));
drag(&mut h, row, to);
let doc = &h.state().session.active().unwrap().doc;
assert!(doc.paths.is_empty(), "the dragged saved path is deleted");
assert!(doc.work_path.is_some(), "the selected work path is kept");
// The work path.
let (row, to) = (h.get_by_label("Work Path").rect().center(), trash(&h));
drag(&mut h, row, to);
assert!(h.state().session.active().unwrap().doc.work_path.is_none(), "the dragged work path is deleted");
// A drop elsewhere deletes nothing.
h.state_mut().run("path.set", json!({"name": "Path 2", "path": path})).unwrap();
h.run_steps(2);
let row = h.get_by_label("Path 2").rect().center();
drag(&mut h, row, row + vec2(0.0, 120.0));
assert_eq!(h.state().session.active().unwrap().doc.paths.len(), 1, "a drop off the trash keeps the path");
// A shape layer's path row is not dragged onto the trash (its deletion is #6552's).
h.state_mut().run("shape.create", json!({"kind": "ellipse", "rect": [20, 20, 100, 70]})).unwrap();
h.run_steps(2);
let layers = h.state().session.active().unwrap().doc.layers.len();
let (row, to) = (h.get_by_label("Ellipse 1 Shape Path").rect().center(), trash(&h));
drag(&mut h, row, to);
let doc = &h.state().session.active().unwrap().doc;
assert_eq!((doc.layers.len(), doc.paths.len()), (layers, 1), "nothing is deleted");
}
}
#[cfg(test)]
#[path = "path_selection_tests.rs"]
mod path_selection_tests;
#[cfg(test)]
#[path = "pen_draw_tests.rs"]
mod pen_draw_tests;
#[cfg(test)]
#[path = "vector_paint_tests.rs"]
mod paint_tests;