mirror of
https://github.com/storytold/vectorcraft.git
synced 2026-10-25 10:17:02 -06:00
dotCooCoo
caa6962508
object.transformEach refused reflectX, reflectY, random and copy given
as text, but read strokes, corners, objects and patterns given as text
as the key left out. With Scale Strokes & Effects on,
{"scaleH": 200, "scaleV": 200, "strokes": "false"} scaled the stroke,
recorded an undo step and kept the params for Transform Again, which
repeated the call. artboard.rearrange, artboard.move and
artboard.duplicate read their patterns option the same way, and
artboard.setProps reads its patterns, strokes and corners options the
same way.
These commands now refuse such a value with "`<key>` must be true or
false" before they change anything. So do the other options and
numbers of artboard.setProps and artboard.move, the art of Duplicate,
Copy and Cut Artboard, the shape commands and path.create, path.close,
path.setHandle, path.moveAnchors, the Pencil, Curvature, Reshape
Segment and Blob Brush options, text.create, text.createInPath,
text.setRangeStyle, text.editRange, text.getRange, text.touchType,
text.areaOptions, type.step, the font size steps,
type.opticalMarginAlignment, type.systemLayout, type.fractionalWidths,
type.ruby, the symbol and swatch commands, the Appearance panel's
commands, the gradient and freeform gradient commands, Shape Builder,
Live Paint, Image Trace, the opacity of object.setProps, the radius,
sides and relativeRadii of object.setLiveShape, the reference point of
object.setBounds and the artboard of Align, Distribute and Distribute
Spacing. They refuse a number given as text with "`<key>` must be a
number, not <value>", and a gradient stop's tint with "stop <n>:
`tint` must be a number". A null still reads as the key left out.
Docs: docs/mcp.md, docs/target-app-parity.md.
843 lines
35 KiB
Rust
843 lines
35 KiB
Rust
//! Path editing commands (used by the Pen and Direct Selection tools and Object → Path).
|
||
|
||
use std::collections::BTreeSet;
|
||
|
||
use serde_json::{Value, json};
|
||
use vectorcraft_doc::{NodeId, NodeKind, Scaling};
|
||
use vectorcraft_geom::{Anchor, AnchorKind, PathData, Point, SubPath, Vec2};
|
||
|
||
use super::create::anchor_from_json;
|
||
use super::draw2::usize_opt;
|
||
use super::pathops::Beside;
|
||
use super::*;
|
||
use crate::EngineError;
|
||
|
||
pub fn specs() -> Vec<CommandSpec> {
|
||
vec![
|
||
cmd!(
|
||
"path.appendAnchor",
|
||
"Add Anchor (Pen)",
|
||
[],
|
||
None,
|
||
"{id, x, y, in?: [x,y], out?: [x,y]} append to the end of the last open subpath",
|
||
has_doc,
|
||
append_anchor
|
||
),
|
||
cmd!("path.close", "Close Path", [], None, "{id, in?: [x,y] (handle into the first anchor), independent?: bool}", has_doc, close),
|
||
cmd!(
|
||
"path.moveAnchors",
|
||
"Move Anchors",
|
||
[],
|
||
None,
|
||
"{dx, dy, patterns?: bool (Transform Patterns: pattern fills and strokes transform with the objects that move whole; default: prefs transformPatternTiles)} move direct-selected anchors (whole paths if fully selected)",
|
||
has_selection,
|
||
move_anchors
|
||
),
|
||
cmd!(
|
||
"path.setHandle",
|
||
"Move Direction Handle",
|
||
[],
|
||
None,
|
||
"{id, subpath?, anchor, which: \"in\"|\"out\", x, y, independent?: bool}",
|
||
has_doc,
|
||
set_handle
|
||
),
|
||
cmd!(
|
||
"path.moveAnchor",
|
||
"Move Anchor Point",
|
||
[],
|
||
None,
|
||
"{id, subpath?, anchor, x, y} move one anchor to (x, y), its handles with it",
|
||
has_doc,
|
||
move_anchor
|
||
),
|
||
cmd!(
|
||
"path.setAnchors",
|
||
"Set Anchors",
|
||
[],
|
||
None,
|
||
"{id, subpaths: [{anchors: [{x,y,in?,out?}], closed}]} replace a path's geometry",
|
||
has_doc,
|
||
set_anchors
|
||
),
|
||
cmd!(
|
||
"path.reverse",
|
||
"Reverse Path Direction",
|
||
["Object", "Path"],
|
||
None,
|
||
"{ids?|id?, reversed?: bool (true: every subpath runs counter-clockwise on screen, false: clockwise, the Attributes panel's Reverse Path Direction On / Off; omitted: flip each path)} the paths in ids or the selection (groups and compound paths: the paths inside), as one undo step → {changed: paths}",
|
||
has_doc,
|
||
reverse
|
||
),
|
||
cmd!(
|
||
"path.join",
|
||
"Join",
|
||
["Object", "Path"],
|
||
Some("Cmd+J"),
|
||
"{ids?: [path, path] (default: the selected paths), ends?: [\"first\"|\"last\", \"first\"|\"last\"] (which end of each path to join, as the Pen joins them; default: the nearest pair), to?: \"corner\"|\"smooth\" (the joined anchor: corner retracts both handles, smooth pulls handles in line with the neighbours)} join two open paths into one (the first keeps its id, selected), or close a single open path; without ids, direct-selected anchors lying on one another along a path merge into one anchor instead",
|
||
has_selection,
|
||
join
|
||
),
|
||
cmd!(
|
||
"path.average",
|
||
"Average…",
|
||
["Object", "Path"],
|
||
Some("Cmd+Alt+J"),
|
||
"{axis?: \"horizontal\"|\"vertical\"|\"both\"}",
|
||
has_selection,
|
||
average
|
||
),
|
||
cmd!(
|
||
"path.convertAnchors",
|
||
"Convert Anchor Points",
|
||
[],
|
||
None,
|
||
"{to: \"corner\"|\"smooth\"} convert the direct-selected anchors (all anchors of fully selected paths) as one undo step: corner retracts both handles, smooth pulls handles in line with the neighbours (smooth anchors keep theirs)",
|
||
has_selection,
|
||
convert_anchors
|
||
),
|
||
cmd!(
|
||
"path.deleteAnchors",
|
||
"Delete Anchor Points",
|
||
[],
|
||
None,
|
||
"{} delete the direct-selected anchors and their segments, opening closed paths there, and delete objects selected whole alongside them; what remains of a path stays selected, so a second Delete removes it (the Delete key)",
|
||
has_anchors,
|
||
delete_anchors
|
||
),
|
||
cmd!(
|
||
"path.reshape",
|
||
"Reshape",
|
||
[],
|
||
None,
|
||
"{id, x, y, dx, dy, tol=3, radius?} Reshape tool: grab the path at (x, y) (adding an anchor there unless one is within tol) and drag it by (dx, dy); nearby anchors follow with a smooth falloff over radius, measured along the path (default: half the subpath's size)",
|
||
has_doc,
|
||
reshape
|
||
),
|
||
cmd!("path.insertAnchor", "Add Anchor Point", [], None, "{id, subpath?, segment, t: 0..1}", has_doc, insert_anchor),
|
||
cmd!(
|
||
"path.cutAtAnchors",
|
||
"Cut Path at Selected Anchor Points",
|
||
[],
|
||
None,
|
||
"{} cut the paths at their direct-selected anchors (one undo step): a closed path opens there, an open one becomes one path per piece; one of each cut's two coincident anchors stays selected → {ids}",
|
||
has_anchors,
|
||
cut_at_anchors
|
||
),
|
||
]
|
||
}
|
||
|
||
pub(super) fn path_mut(d: &mut vectorcraft_doc::Document, id: NodeId) -> Result<&mut PathData> {
|
||
let n = d.node_mut(id).ok_or(EngineError::NoNode(id))?;
|
||
match &mut n.kind {
|
||
NodeKind::Path { path, live, .. } => {
|
||
*live = None; // editing anchors expands a live shape
|
||
Ok(path)
|
||
}
|
||
_ => Err(EngineError::Other(format!("object {id} is not a path"))),
|
||
}
|
||
}
|
||
|
||
fn append_anchor(s: &mut Session, p: &Value) -> Result<Value> {
|
||
let id = id_param(p, "id").ok_or_else(|| bad("path.appendAnchor", "missing id"))?;
|
||
let a = anchor_from_json(p, "path.appendAnchor")?;
|
||
s.edit("Pen", |d, sel| {
|
||
let path = path_mut(d, id)?;
|
||
match path.subpaths.last_mut() {
|
||
Some(sp) if !sp.closed => sp.anchors.push(a),
|
||
_ => path.subpaths.push(SubPath::new(vec![a], false)),
|
||
}
|
||
sel.set([id]);
|
||
let last = path.subpaths.len() - 1;
|
||
let ai = path.subpaths[last].anchors.len() - 1;
|
||
sel.anchors.insert(id, BTreeSet::from([(last, ai)]));
|
||
Ok(())
|
||
})?;
|
||
ok()
|
||
}
|
||
|
||
fn close(s: &mut Session, p: &Value) -> Result<Value> {
|
||
let id = id_param(p, "id").ok_or_else(|| bad("path.close", "missing id"))?;
|
||
let h_in = match p.get("in").filter(|h| !h.is_null()) {
|
||
None => None,
|
||
Some(h) => Some(finite_numbers(h).map(|[x, y]| Point::new(x, y)).ok_or_else(|| bad("path.close", "`in` must be [x, y]"))?),
|
||
};
|
||
let independent = switch_or(p, "independent", false, "path.close")?;
|
||
s.edit("Close Path", |d, sel| {
|
||
let path = path_mut(d, id)?;
|
||
let sp = path.subpaths.iter_mut().rev().find(|s| !s.closed).ok_or_else(|| EngineError::Other("path is already closed".into()))?;
|
||
sp.closed = true;
|
||
if let (Some(h), Some(first)) = (h_in, sp.anchors.first_mut()) {
|
||
first.h_in = h;
|
||
if !independent {
|
||
first.h_out = first.p - (h - first.p);
|
||
first.kind = AnchorKind::Smooth;
|
||
}
|
||
}
|
||
sel.set([id]);
|
||
Ok(())
|
||
})?;
|
||
ok()
|
||
}
|
||
|
||
pub(crate) fn move_anchors(s: &mut Session, p: &Value) -> Result<Value> {
|
||
let d = Vec2::new(number_or(p, "dx", 0.0, "path.moveAnchors")?, number_or(p, "dy", 0.0, "path.moveAnchors")?);
|
||
check_switches(p, &["patterns"], "path.moveAnchors")?;
|
||
// Objects selected whole move as objects, and their pattern tiles move with them when
|
||
// `patterns` (default: General › Transform Pattern Tiles) is on.
|
||
let whole = s.doc()?.selection.whole();
|
||
let sc = Scaling { patterns: super::object::transform_patterns(s, p, &whole)?, ..Scaling::default() };
|
||
transform_anchors(s, "Move", vectorcraft_geom::Affine::translate(d), sc)?;
|
||
ok()
|
||
}
|
||
|
||
/// Apply `xf` to the direct-selected anchors, their handles with them, and (with `sc`) to the
|
||
/// objects selected whole (those with no entry in the selection's `anchors`).
|
||
pub(crate) fn transform_anchors(s: &mut Session, label: &str, xf: vectorcraft_geom::Affine, sc: Scaling) -> Result<()> {
|
||
let sel = s.doc()?.selection.clone();
|
||
let c = xf.as_coeffs();
|
||
let is_translation = (c[0] - 1.0).abs() < 1e-9 && c[1].abs() < 1e-9 && c[2].abs() < 1e-9 && (c[3] - 1.0).abs() < 1e-9;
|
||
let delta = vectorcraft_geom::Vec2::new(c[4], c[5]);
|
||
s.edit(label, |doc, _| {
|
||
for id in &sel.objects {
|
||
match sel.anchors.get(id) {
|
||
Some(set) => {
|
||
let path = path_mut(doc, *id)?;
|
||
for &(si, ai) in set {
|
||
if let Some(a) = path.anchor_mut(si, ai) {
|
||
*a = a.transform(xf);
|
||
}
|
||
}
|
||
}
|
||
None => {
|
||
if let Some(n) = doc.node_mut(*id) {
|
||
n.transform(xf, sc);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if is_translation && (delta.x != 0.0 || delta.y != 0.0) {
|
||
for &i in &sel.guides {
|
||
if let Some(g) = doc.guides.get_mut(i) {
|
||
*g = g.moved(delta);
|
||
}
|
||
}
|
||
}
|
||
Ok(())
|
||
})
|
||
}
|
||
|
||
fn set_handle(s: &mut Session, p: &Value) -> Result<Value> {
|
||
let id = id_param(p, "id").ok_or_else(|| bad("path.setHandle", "missing id"))?;
|
||
let si = usize_opt(p, "subpath", "path.setHandle")?.unwrap_or(0);
|
||
let ai = p.get("anchor").and_then(Value::as_u64).map(index).ok_or_else(|| bad("path.setHandle", "missing anchor"))?;
|
||
let out = str_param(p, "which") != Some("in");
|
||
let pos = Point::new(f64_req(p, "x", "path.setHandle")?, f64_req(p, "y", "path.setHandle")?);
|
||
let independent = switch_or(p, "independent", false, "path.setHandle")?;
|
||
s.edit("Reshape", |d, _| {
|
||
let path = path_mut(d, id)?;
|
||
let a = path.anchor_mut(si, ai).ok_or_else(|| EngineError::Other("no such anchor".into()))?;
|
||
a.set_handle(out, pos, independent);
|
||
Ok(())
|
||
})?;
|
||
ok()
|
||
}
|
||
|
||
/// `path.moveAnchor`: one anchor to (x, y), its handles keeping their offsets (the Anchor Point
|
||
/// tool's Shift-drag).
|
||
fn move_anchor(s: &mut Session, p: &Value) -> Result<Value> {
|
||
let id = id_param(p, "id").ok_or_else(|| bad("path.moveAnchor", "missing id"))?;
|
||
let si = usize_opt(p, "subpath", "path.moveAnchor")?.unwrap_or(0);
|
||
let ai = p.get("anchor").and_then(Value::as_u64).map(index).ok_or_else(|| bad("path.moveAnchor", "missing anchor"))?;
|
||
let pos = Point::new(f64_req(p, "x", "path.moveAnchor")?, f64_req(p, "y", "path.moveAnchor")?);
|
||
s.edit("Move", |d, _| {
|
||
let path = path_mut(d, id)?;
|
||
let a = path.anchor_mut(si, ai).ok_or_else(|| EngineError::Other("no such anchor".into()))?;
|
||
*a = a.transform(vectorcraft_geom::Affine::translate(pos - a.p));
|
||
Ok(())
|
||
})?;
|
||
ok()
|
||
}
|
||
|
||
fn set_anchors(s: &mut Session, p: &Value) -> Result<Value> {
|
||
let id = id_param(p, "id").ok_or_else(|| bad("path.setAnchors", "missing id"))?;
|
||
let subs = p.get("subpaths").and_then(Value::as_array).ok_or_else(|| bad("path.setAnchors", "missing subpaths"))?;
|
||
let data = PathData::new(
|
||
subs.iter()
|
||
.map(|sp| {
|
||
let anchors = sp
|
||
.get("anchors")
|
||
.and_then(Value::as_array)
|
||
.ok_or_else(|| bad("path.setAnchors", "each subpath needs an anchors array"))?
|
||
.iter()
|
||
.map(|a| anchor_from_json(a, "path.setAnchors"))
|
||
.collect::<Result<Vec<_>>>()?;
|
||
let closed = match sp.get("closed") {
|
||
None | Some(Value::Null) => false,
|
||
Some(Value::Bool(v)) => *v,
|
||
Some(_) => return Err(bad("path.setAnchors", "closed must be a boolean")),
|
||
};
|
||
Ok(SubPath::new(anchors, closed))
|
||
})
|
||
.collect::<Result<Vec<_>>>()?,
|
||
);
|
||
s.edit("Reshape", |d, _| {
|
||
*path_mut(d, id)? = data;
|
||
Ok(())
|
||
})?;
|
||
ok()
|
||
}
|
||
|
||
fn selected_paths(s: &Session) -> Result<Vec<NodeId>> {
|
||
let st = s.doc()?;
|
||
Ok(st.selection.objects.iter().copied().filter(|id| matches!(st.doc.node(*id).map(|n| &n.kind), Some(NodeKind::Path { .. }))).collect())
|
||
}
|
||
|
||
/// The paths in the subtrees of `ids` (in groups and compound paths too), each once.
|
||
pub(super) fn paths_in(d: &vectorcraft_doc::Document, ids: &[NodeId]) -> Vec<NodeId> {
|
||
let mut out = BTreeSet::new();
|
||
for n in ids.iter().filter_map(|id| d.node(*id)) {
|
||
n.walk(&mut |c| {
|
||
if matches!(c.kind, NodeKind::Path { guide: false, .. }) {
|
||
out.insert(c.id);
|
||
}
|
||
});
|
||
}
|
||
out.into_iter().collect()
|
||
}
|
||
|
||
fn reverse(s: &mut Session, p: &Value) -> Result<Value> {
|
||
const C: &str = "path.reverse";
|
||
let want = p.get("reversed").map(|v| v.as_bool().ok_or_else(|| bad(C, "`reversed` must be true or false"))).transpose()?;
|
||
let ids = paths_in(&s.doc()?.doc, &targets(s, p)?);
|
||
if ids.is_empty() {
|
||
return Err(bad(C, "select paths"));
|
||
}
|
||
let changed = super::overprint::edit_counted(s, "Reverse Path Direction", |d| {
|
||
let mut changed = 0;
|
||
for id in &ids {
|
||
// The subpaths to flip: all, or those not yet running the wanted way.
|
||
let flip: Vec<bool> = d
|
||
.node(*id)
|
||
.and_then(|n| n.path_data())
|
||
.map_or(vec![], |pd| pd.subpaths.iter().map(|sp| want.is_none_or(|ccw| (sp.signed_area() < 0.0) != ccw)).collect());
|
||
if flip.contains(&true) {
|
||
for (sp, f) in path_mut(d, *id)?.subpaths.iter_mut().zip(flip) {
|
||
if f {
|
||
sp.reverse();
|
||
}
|
||
}
|
||
changed += 1;
|
||
}
|
||
}
|
||
Ok(changed)
|
||
})?;
|
||
Ok(json!({ "changed": changed }))
|
||
}
|
||
|
||
/// First and last anchor points of a subpath.
|
||
fn end_points(sp: &SubPath) -> Option<(Point, Point)> {
|
||
Some((sp.anchors.first()?.p, sp.anchors.last()?.p))
|
||
}
|
||
|
||
/// Corner or smooth on an anchor a join leaves behind.
|
||
fn join_point(sp: &mut SubPath, ai: usize, smooth: bool) {
|
||
if smooth {
|
||
sp.smooth_anchor(ai);
|
||
} else if let Some(a) = sp.anchors.get_mut(ai) {
|
||
a.retract();
|
||
}
|
||
}
|
||
|
||
/// Merge each run of `picked` neighbours of `sp` that lie on one another into one anchor, which
|
||
/// keeps the first one's incoming handle and the last one's outgoing handle. Returns how many
|
||
/// anchors went.
|
||
fn merge_coincident(sp: &mut SubPath, picked: impl Fn(usize) -> bool, join_kind: Option<bool>) -> usize {
|
||
let same = |a: &Anchor, b: &Anchor| a.p.distance(b.p) < 1e-6;
|
||
let before = sp.anchors.len();
|
||
// The closing pair of a closed path first: taking the last anchor moves no other index.
|
||
if sp.closed
|
||
&& before > 2
|
||
&& picked(0)
|
||
&& picked(before - 1)
|
||
&& let [first, .., last] = sp.anchors.as_mut_slice()
|
||
&& same(first, last)
|
||
{
|
||
first.h_in = last.h_in;
|
||
sp.anchors.pop();
|
||
if let Some(smooth) = join_kind {
|
||
join_point(sp, 0, smooth);
|
||
}
|
||
}
|
||
// Back to front, so the indices `picked` knows stay true for the anchors still to visit.
|
||
for i in (1..sp.anchors.len()).rev() {
|
||
if picked(i - 1)
|
||
&& picked(i)
|
||
&& let Some([a, b]) = sp.anchors.get_mut(i - 1..=i)
|
||
&& same(a, b)
|
||
{
|
||
a.h_out = b.h_out;
|
||
sp.anchors.remove(i);
|
||
if let Some(smooth) = join_kind {
|
||
join_point(sp, i - 1, smooth);
|
||
}
|
||
}
|
||
}
|
||
before - sp.anchors.len()
|
||
}
|
||
|
||
fn join(s: &mut Session, p: &Value) -> Result<Value> {
|
||
const C: &str = "path.join";
|
||
let join_kind = match p.get("to").and_then(Value::as_str) {
|
||
None => None,
|
||
Some("smooth") => Some(true),
|
||
Some("corner") => Some(false),
|
||
Some(_) => return Err(bad(C, "`to` must be \"corner\" or \"smooth\"")),
|
||
};
|
||
let ids = match ids_param(p, "ids") {
|
||
Some(ids) => {
|
||
let st = s.doc()?;
|
||
if let Some(id) = ids.iter().find(|id| !matches!(st.doc.node(**id).map(|n| &n.kind), Some(NodeKind::Path { .. }))) {
|
||
return Err(bad(C, format!("{} isn't a path", id.0)));
|
||
}
|
||
ids
|
||
}
|
||
None => selected_paths(s)?,
|
||
};
|
||
// Direct-selected anchors lying on one another along a path (two corners brought together by
|
||
// Average) become one anchor; the paths themselves are joined only when there are none.
|
||
if p.get("ids").is_none() {
|
||
let st = s.doc()?;
|
||
let mut merged = vec![];
|
||
for (id, picked) in &st.selection.anchors {
|
||
let Some(mut path) = st.doc.node(*id).and_then(|n| n.path_data()).cloned() else { continue };
|
||
let n: usize =
|
||
path.subpaths.iter_mut().enumerate().map(|(si, sp)| merge_coincident(sp, |ai| picked.contains(&(si, ai)), join_kind)).sum();
|
||
if n > 0 {
|
||
merged.push((*id, path));
|
||
}
|
||
}
|
||
if !merged.is_empty() {
|
||
let objects = st.selection.objects.clone();
|
||
s.edit("Join", |d, sel| {
|
||
for (id, path) in merged {
|
||
*path_mut(d, id)? = path;
|
||
}
|
||
// The anchor indices changed: the paths stay selected, whole.
|
||
sel.set(objects);
|
||
Ok(())
|
||
})?;
|
||
return ok();
|
||
}
|
||
}
|
||
// The ends to join, as (reverse the first path, reverse the second): the first path's end
|
||
// must come last, the second's first.
|
||
let ends = match p.get("ends") {
|
||
None => None,
|
||
Some(e) => match e.as_array().map(|a| a.iter().map(Value::as_str).collect::<Vec<_>>()).as_deref() {
|
||
Some([Some(a @ ("first" | "last")), Some(b @ ("first" | "last"))]) => Some((*a == "first", *b == "last")),
|
||
_ => return Err(bad(C, "ends must be two of \"first\" and \"last\"")),
|
||
},
|
||
};
|
||
match ids.as_slice() {
|
||
[one] => {
|
||
let id = *one;
|
||
s.edit("Join", |d, _| {
|
||
let path = path_mut(d, id)?;
|
||
let sp = path.subpaths.iter_mut().find(|s| !s.closed).ok_or_else(|| EngineError::Other("path is already closed".into()))?;
|
||
// Merge coincident end points.
|
||
if sp.anchors.len() > 2
|
||
&& end_points(sp).is_some_and(|(f, l)| f.distance(l) < 1e-6)
|
||
&& let Some(last) = sp.anchors.pop()
|
||
&& let Some(first) = sp.anchors.first_mut()
|
||
{
|
||
first.h_in = last.h_in;
|
||
// Closed first, so the merged anchor smooths between both its neighbours.
|
||
sp.closed = true;
|
||
if let Some(smooth) = join_kind {
|
||
join_point(sp, 0, smooth);
|
||
}
|
||
}
|
||
sp.closed = true;
|
||
Ok(())
|
||
})?;
|
||
}
|
||
[a, b, ..] => {
|
||
let (a, b) = (*a, *b);
|
||
if a == b {
|
||
return Err(bad(C, "join two different paths"));
|
||
}
|
||
s.edit("Join", |d, sel| {
|
||
let pb = d.node(b).and_then(|n| n.path_data()).cloned().ok_or(EngineError::NoNode(b))?;
|
||
let pa = path_mut(d, a)?;
|
||
let (Some(sa), Some(sb)) = (pa.subpaths.iter().position(|s| !s.closed), pb.subpaths.iter().position(|s| !s.closed)) else {
|
||
return Err(EngineError::Other("join needs open paths".into()));
|
||
};
|
||
let mut x = pa.subpaths[sa].clone();
|
||
let mut y = pb.subpaths[sb].clone();
|
||
let (Some((xf, xl)), Some((yf, yl))) = (end_points(&x), end_points(&y)) else {
|
||
return Err(EngineError::Other("join needs open paths".into()));
|
||
};
|
||
// The ends asked for, else the closest pair.
|
||
let cands =
|
||
[(xl.distance(yf), false, false), (xl.distance(yl), false, true), (xf.distance(yf), true, false), (xf.distance(yl), true, true)];
|
||
let (rx, ry) =
|
||
ends.unwrap_or_else(|| cands.into_iter().min_by(|p, q| p.0.total_cmp(&q.0)).map_or((false, false), |(_, rx, ry)| (rx, ry)));
|
||
if rx {
|
||
x.reverse();
|
||
}
|
||
if ry {
|
||
y.reverse();
|
||
}
|
||
let junction = x.anchors.len() - 1;
|
||
if let (Some(xe), Some(ys)) = (x.anchors.last().map(|a| a.p), y.anchors.first().map(|a| a.p))
|
||
&& xe.distance(ys) < 1e-6
|
||
{
|
||
let first = y.anchors.remove(0);
|
||
if let Some(l) = x.anchors.last_mut() {
|
||
l.h_out = first.h_out;
|
||
}
|
||
}
|
||
x.anchors.extend(y.anchors);
|
||
if let Some(smooth) = join_kind {
|
||
join_point(&mut x, junction, smooth);
|
||
}
|
||
pa.subpaths[sa] = x;
|
||
d.remove(b)?;
|
||
sel.set([a]);
|
||
Ok(())
|
||
})?;
|
||
}
|
||
[] => return Err(EngineError::Other("select paths to join".into())),
|
||
}
|
||
ok()
|
||
}
|
||
|
||
pub(super) type AnchorTargets = Vec<(NodeId, Vec<(usize, usize)>)>;
|
||
|
||
pub(super) fn anchor_targets(s: &Session) -> Result<AnchorTargets> {
|
||
let st = s.doc()?;
|
||
let mut out = vec![];
|
||
for id in &st.selection.objects {
|
||
let Some(pd) = st.doc.node(*id).and_then(|n| n.path_data()) else { continue };
|
||
let v: Vec<(usize, usize)> = match st.selection.anchors.get(id) {
|
||
Some(set) => set.iter().copied().collect(),
|
||
None => pd.anchors().map(|(s, a, _)| (s, a)).collect(),
|
||
};
|
||
out.push((*id, v));
|
||
}
|
||
Ok(out)
|
||
}
|
||
|
||
fn average(s: &mut Session, p: &Value) -> Result<Value> {
|
||
let t = anchor_targets(s)?;
|
||
let d0 = &s.doc()?.doc;
|
||
let pts: Vec<Point> = t
|
||
.iter()
|
||
.flat_map(|(id, v)| v.iter().filter_map(move |(si, ai)| d0.node(*id)?.path_data()?.subpaths.get(*si)?.anchors.get(*ai).map(|a| a.p)))
|
||
.collect();
|
||
if pts.is_empty() {
|
||
return ok();
|
||
}
|
||
let c = Point::new(pts.iter().map(|p| p.x).sum::<f64>() / pts.len() as f64, pts.iter().map(|p| p.y).sum::<f64>() / pts.len() as f64);
|
||
let axis = str_param(p, "axis").unwrap_or("both").to_string();
|
||
s.edit("Average", |d, _| {
|
||
for (id, v) in &t {
|
||
let path = path_mut(d, *id)?;
|
||
for &(si, ai) in v {
|
||
if let Some(a) = path.anchor_mut(si, ai) {
|
||
let target = match axis.as_str() {
|
||
"horizontal" => Point::new(a.p.x, c.y),
|
||
"vertical" => Point::new(c.x, a.p.y),
|
||
_ => c,
|
||
};
|
||
a.translate(target - a.p);
|
||
}
|
||
}
|
||
}
|
||
Ok(())
|
||
})?;
|
||
ok()
|
||
}
|
||
|
||
fn convert_anchors(s: &mut Session, p: &Value) -> Result<Value> {
|
||
const C: &str = "path.convertAnchors";
|
||
let smooth = match str_param(p, "to") {
|
||
Some("smooth") => true,
|
||
Some("corner") => false,
|
||
_ => return Err(bad(C, "`to` must be \"corner\" or \"smooth\"")),
|
||
};
|
||
let t = anchor_targets(s)?;
|
||
if t.is_empty() {
|
||
return Err(bad(C, "select paths or anchor points"));
|
||
}
|
||
s.edit("Convert Anchor Points", |d, _| {
|
||
for (id, v) in &t {
|
||
let path = path_mut(d, *id)?;
|
||
for &(si, ai) in v {
|
||
let Some(sp) = path.subpaths.get_mut(si) else { continue };
|
||
if smooth {
|
||
sp.smooth_anchor(ai);
|
||
} else if let Some(a) = sp.anchors.get_mut(ai) {
|
||
a.retract();
|
||
}
|
||
}
|
||
}
|
||
Ok(())
|
||
})?;
|
||
ok()
|
||
}
|
||
|
||
pub(crate) fn delete_anchors(s: &mut Session, _: &Value) -> Result<Value> {
|
||
let st = s.doc()?;
|
||
let sel = st.selection.anchors.clone();
|
||
let segments = st.selection.segments.clone();
|
||
// Every anchor selected stores the path as an object, with no `anchors` entry. A marquee that
|
||
// also catches part of another path must still delete those whole objects.
|
||
let whole = st.selection.whole();
|
||
s.edit("Clear", |d, selection| {
|
||
let targets: BTreeSet<NodeId> = whole.into_iter().filter(|id| d.node(*id).is_some_and(|n| !n.is_layer())).collect();
|
||
let whole_ids: Vec<NodeId> = targets
|
||
.iter()
|
||
.copied()
|
||
.filter(|id| !d.ancestry(*id).unwrap_or_default().iter().rev().skip(1).any(|ancestor| targets.contains(ancestor)))
|
||
.collect();
|
||
if !whole_ids.is_empty() {
|
||
d.remove_many(&whole_ids)?;
|
||
}
|
||
let mut survivors = vec![];
|
||
let remaining: Vec<NodeId> = sel.keys().copied().filter(|id| d.node(*id).is_some()).collect();
|
||
let mut emptied = Beside::replacing(d, &remaining);
|
||
for (id, set) in &sel {
|
||
// The path went with a fully selected group around it.
|
||
if d.node(*id).is_none() {
|
||
continue;
|
||
}
|
||
let remove_node = {
|
||
let path = path_mut(d, *id)?;
|
||
if let Some(refs) = segments.get(id) {
|
||
// A segment pick cuts its connection, keeping every neighboring cubic.
|
||
path.subpaths = std::mem::take(&mut path.subpaths)
|
||
.into_iter()
|
||
.enumerate()
|
||
.flat_map(|(si, sp)| {
|
||
let cuts = refs.iter().filter_map(|&(s, seg)| (s == si).then_some(seg)).collect();
|
||
without_segments(sp, &cuts)
|
||
})
|
||
.collect();
|
||
} else {
|
||
// Remove every selected anchor against the original indexes, keeping surviving
|
||
// stretches separate rather than joining across deleted anchors.
|
||
path.subpaths = std::mem::take(&mut path.subpaths)
|
||
.into_iter()
|
||
.enumerate()
|
||
.flat_map(|(si, sp)| {
|
||
let gone = set.iter().filter_map(|&(s, ai)| (s == si).then_some(ai)).collect();
|
||
without_anchors(sp, &gone)
|
||
})
|
||
.collect();
|
||
}
|
||
path.subpaths.retain(|s| s.anchors.len() >= 2);
|
||
path.subpaths.is_empty()
|
||
};
|
||
if remove_node {
|
||
emptied.put(d, *id, vec![])?;
|
||
} else {
|
||
// The remainder is selected whole, so the next Delete removes it.
|
||
survivors.push(*id);
|
||
}
|
||
}
|
||
emptied.finish(d)?;
|
||
selection.set(survivors);
|
||
Ok(())
|
||
})?;
|
||
ok()
|
||
}
|
||
|
||
/// Remove anchors and their incident segments, keeping each surviving stretch as an open path.
|
||
/// Only a closed path can have a surviving stretch that wraps past the last anchor.
|
||
fn without_anchors(sp: SubPath, removed: &BTreeSet<usize>) -> Vec<SubPath> {
|
||
let n = sp.anchors.len();
|
||
let gone: BTreeSet<usize> = removed.iter().copied().filter(|&i| i < n).collect();
|
||
if gone.is_empty() {
|
||
return vec![sp];
|
||
}
|
||
let mut runs: Vec<Vec<Anchor>> = vec![];
|
||
let mut run = vec![];
|
||
for (i, anchor) in sp.anchors.into_iter().enumerate() {
|
||
if gone.contains(&i) {
|
||
if !run.is_empty() {
|
||
runs.push(std::mem::take(&mut run));
|
||
}
|
||
} else {
|
||
run.push(anchor);
|
||
}
|
||
}
|
||
if !sp.closed {
|
||
runs.push(run);
|
||
return runs.into_iter().filter_map(open_run).collect();
|
||
}
|
||
// The anchors before the first deletion and after the last are one closed-path stretch.
|
||
if gone.contains(&0) {
|
||
if !run.is_empty() {
|
||
runs.push(run);
|
||
}
|
||
} else if !runs.is_empty() {
|
||
let head = runs.remove(0);
|
||
run.extend(head);
|
||
runs.insert(0, run);
|
||
} else if !run.is_empty() {
|
||
runs.push(run);
|
||
}
|
||
runs.into_iter().filter_map(open_run).collect()
|
||
}
|
||
|
||
/// Remove connections, splitting open/closed contours into their surviving open runs.
|
||
fn without_segments(sp: SubPath, removed: &BTreeSet<usize>) -> Vec<SubPath> {
|
||
let cuts: BTreeSet<usize> = removed.iter().copied().filter(|&i| i < sp.segment_count()).collect();
|
||
let Some(&first) = cuts.first() else { return vec![sp] };
|
||
let n = sp.anchors.len();
|
||
let start = if sp.closed { (first + 1) % n } else { 0 };
|
||
let mut result = vec![];
|
||
let mut run = vec![];
|
||
let mut previous = None;
|
||
for (index, anchor) in sp.anchors.iter().enumerate().cycle().skip(start).take(n) {
|
||
if previous.is_some_and(|i| cuts.contains(&i)) {
|
||
result.extend(open_run(std::mem::take(&mut run)));
|
||
}
|
||
run.push(*anchor);
|
||
previous = Some(index);
|
||
}
|
||
result.extend(open_run(run));
|
||
result
|
||
}
|
||
|
||
fn open_run(mut anchors: Vec<vectorcraft_geom::Anchor>) -> Option<SubPath> {
|
||
if anchors.len() < 2 {
|
||
return None;
|
||
}
|
||
// The cut edge's incoming/outgoing controls are no longer part of an open endpoint.
|
||
if let Some(first) = anchors.first_mut() {
|
||
first.h_in = first.p;
|
||
}
|
||
if let Some(last) = anchors.last_mut() {
|
||
last.h_out = last.p;
|
||
}
|
||
Some(SubPath::new(anchors, false))
|
||
}
|
||
|
||
fn reshape(s: &mut Session, p: &Value) -> Result<Value> {
|
||
let id = id_param(p, "id").ok_or_else(|| bad("path.reshape", "missing id"))?;
|
||
let at = Point::new(f64_req(p, "x", "path.reshape")?, f64_req(p, "y", "path.reshape")?);
|
||
check_numbers(p, &["dx", "dy", "tol", "radius"], "path.reshape")?;
|
||
let delta = Vec2::new(f64_or(p, "dx", 0.0), f64_or(p, "dy", 0.0));
|
||
let tol = f64_or(p, "tol", 3.0).max(0.0);
|
||
let radius = p.get("radius").and_then(Value::as_f64);
|
||
s.edit("Reshape", |d, _| {
|
||
let path = path_mut(d, id)?;
|
||
let (si, seg, t, _, _) = path.nearest(at).ok_or_else(|| EngineError::Other("empty path".into()))?;
|
||
let sp = &mut path.subpaths[si];
|
||
let grabbed = match sp.anchors.iter().enumerate().map(|(i, a)| (i, a.p.distance(at))).min_by(|a, b| a.1.total_cmp(&b.1)) {
|
||
Some((i, dist)) if dist <= tol => i,
|
||
_ => sp.insert_anchor(seg, t),
|
||
};
|
||
// Each anchor's distance along the path from the grabbed one, the shorter way round a
|
||
// closed path: the lengths are measured once, as a path can have many anchors.
|
||
let pos = sp.anchor_arc_positions();
|
||
let total = pos.last().copied().unwrap_or(0.0);
|
||
// The default reach is the subpath's size, as before, now measured along it.
|
||
let r = radius.unwrap_or_else(|| {
|
||
let mut bp = vectorcraft_geom::BezPath::new();
|
||
sp.to_bezpath_into(&mut bp);
|
||
let b = vectorcraft_geom::Shape::bounding_box(&bp);
|
||
(b.width().hypot(b.height()) / 2.0).max(1.0)
|
||
});
|
||
let from = pos.get(grabbed).copied().unwrap_or(0.0);
|
||
let closed = sp.closed;
|
||
for (i, a) in sp.anchors.iter_mut().enumerate() {
|
||
let w = if i == grabbed {
|
||
1.0
|
||
} else {
|
||
let d = (pos.get(i).copied().unwrap_or(f64::INFINITY) - from).abs();
|
||
let d = if closed { d.min(total - d) } else { d };
|
||
// A distance or radius that isn't finite gives NaN here, which `min` reads as 1: no move.
|
||
let q = (d / r).min(1.0);
|
||
(1.0 - q * q).powi(2)
|
||
};
|
||
let v = delta * w;
|
||
a.p += v;
|
||
a.h_in += v;
|
||
a.h_out += v;
|
||
}
|
||
Ok(())
|
||
})?;
|
||
ok()
|
||
}
|
||
|
||
fn insert_anchor(s: &mut Session, p: &Value) -> Result<Value> {
|
||
let id = id_param(p, "id").ok_or_else(|| bad("path.insertAnchor", "missing id"))?;
|
||
let si = usize_opt(p, "subpath", "path.insertAnchor")?.unwrap_or(0);
|
||
let seg = p.get("segment").and_then(Value::as_u64).map(index).ok_or_else(|| bad("path.insertAnchor", "missing segment"))?;
|
||
let t = number_or(p, "t", 0.5, "path.insertAnchor")?.clamp(0.0, 1.0);
|
||
let idx = s.edit("Add Anchor Point", |d, _| {
|
||
let path = path_mut(d, id)?;
|
||
let sp = path.subpaths.get_mut(si).ok_or_else(|| EngineError::Other("no such subpath".into()))?;
|
||
if seg >= sp.segment_count() {
|
||
return Err(EngineError::Other("no such segment".into()));
|
||
}
|
||
Ok(sp.insert_anchor(seg, t))
|
||
})?;
|
||
Ok(json!({ "anchor": idx }))
|
||
}
|
||
|
||
fn cut_at_anchors(s: &mut Session, _: &Value) -> Result<Value> {
|
||
const C: &str = "path.cutAtAnchors";
|
||
let st = s.doc()?;
|
||
// Each selected path's subpaths cut at its selected anchors, those that cut anything.
|
||
let mut cuts: Vec<(NodeId, Vec<SubPath>, Vec<bool>)> = vec![];
|
||
for (id, set) in &st.selection.anchors {
|
||
let Some(pd) = st.doc.node(*id).and_then(|n| n.path_data()) else { continue };
|
||
let (mut subs, mut starts) = (vec![], vec![]);
|
||
for (si, sp) in pd.subpaths.iter().enumerate() {
|
||
let at: BTreeSet<usize> = set.iter().filter(|(s, _)| *s == si).map(|(_, a)| *a).collect();
|
||
let pieces = sp.cut_at(&at);
|
||
// The pieces that start at a cut: every piece of an opened closed subpath, all but the
|
||
// first of an open one.
|
||
starts.extend(pieces.iter().enumerate().map(|(k, piece)| if sp.closed { !piece.closed } else { k > 0 }));
|
||
subs.extend(pieces);
|
||
}
|
||
if starts.contains(&true) {
|
||
cuts.push((*id, subs, starts));
|
||
}
|
||
}
|
||
if cuts.is_empty() {
|
||
return Err(bad(C, "direct-select anchor points to cut at (not the end points of open paths)"));
|
||
}
|
||
let ids = s.edit("Cut Path", |d, sel| {
|
||
let (mut all, mut picked) = (vec![], vec![]);
|
||
let mut cut = Beside::replacing(d, &cuts.iter().map(|(id, ..)| *id).collect::<Vec<_>>());
|
||
for (id, subs, starts) in cuts {
|
||
// A path of one subpath becomes one path per piece (the first keeps the id); the
|
||
// pieces of a compound shape stay subpaths of it.
|
||
if d.node(id).and_then(|n| n.path_data()).is_some_and(|pd| pd.subpaths.len() == 1) {
|
||
let ids = super::draw2::replace_with_pieces(d, &mut cut, id, subs.into_iter().map(PathData::single).collect())?;
|
||
picked.extend(ids.iter().zip(&starts).filter(|(_, s)| **s).map(|(id, _)| (*id, (0, 0))));
|
||
all.extend(ids);
|
||
} else {
|
||
path_mut(d, id)?.subpaths = subs;
|
||
picked.extend(starts.iter().enumerate().filter(|(_, s)| **s).map(|(si, _)| (id, (si, 0))));
|
||
all.push(id);
|
||
}
|
||
}
|
||
cut.finish(d)?;
|
||
// Each cut leaves one of its two coincident anchors selected, so a drag pulls the ends apart.
|
||
sel.clear();
|
||
for (id, a) in picked {
|
||
sel.add(id);
|
||
sel.anchors.entry(id).or_default().insert(a);
|
||
}
|
||
Ok(all)
|
||
})?;
|
||
Ok(super::draw2::ids_json(&ids))
|
||
}
|