Files
vectorcraft/crates/engine/src/cmd/addons/pathtools/shape.rs
T
HassanKhan b3860bf7d0 Commands: every angle and rotation param says which way it turns (#6340)
The params docs now state the direction (and the zero) of each angle or
rotation a command takes; behaviour is unchanged. Shape creation, text.create,
the grids, add-on shapes, saved views, Liquify, Puppet Warp pins, Mirror and
Radial Repeat and Vector Halftone turn clockwise; text character rotation,
gradients, the eraser tip and print screen angles turn counter-clockwise.

view.saved.new's rotation note changes its schema, so the API level goes to 3.

A test walks every command's params doc and fails when a param named like an
angle or rotation doesn't say clockwise or counter-clockwise.
2026-11-11 21:40:27 +05:00

138 lines
6.7 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.
//! The Parametric Shape Tool's commands (`addon.pathtools.shape.*`): draw a parametric shape, change
//! one's numbers, and turn plain rectangles, ellipses and regular polygons into them. A parametric
//! shape is an ordinary path whose numbers sit in one entry of its object data
//! (`vectorcraft_tools::addons::parametric_shape`), which SVG export leaves out.
use serde_json::{Value, json};
use vectorcraft_doc::{Node, NodeKind};
use vectorcraft_geom::{FillRule, PathData, Point};
use vectorcraft_pathops::addons::pathtools::shapes::{ParametricShape, ShapeKind, recognise};
use vectorcraft_tools::addons::parametric_shape::{CREATE, EDIT, KEY, apply, read, stored, to_json};
use super::super::super::{CommandSpec, bad, checked_id, checked_ids_or_selection, cmd, has_doc, has_selection};
use crate::{EngineError, Result, Session};
/// The undo step's name and the command's label.
const CONVERT: &str = "Convert to Parametric Shape";
pub fn specs() -> Vec<CommandSpec> {
vec![
cmd!(
"addon.pathtools.shape.create",
"Parametric Shape",
[],
None,
"{center: [x, y], kind?: \"rectangle\"|\"ellipse\"|\"polygon\" (default)|\"star\"|\"ring\"|\"arrow\"|\"cross\"|\"heart\"|\"gear\"|\"bubble\" (a speech bubble), width?, height?: 0.01..16384 pt (100), rotation?: degrees clockwise (0: upright), count?: 3..1000 (a polygon's sides, a star's points, a gear's teeth), a?, b?: the kind's own values (star: inner radius 0.01..1 of the outer, 0.5; ring: hole 0.01..0.99 of the size, 0.5; arrow: head length and shaft width 0.05..0.95, 0.4 and 0.4; cross: bar offset −0.9..0.9 (0, − up) and arm thickness 0.05..0.95 (1/3); heart: notch depth and point roundness 0..1 (0.4 and 0); gear: tooth height 0.01..0.9 (0.2); bubble: tail height 0.05..0.9 (0.25) and tail tip −1..1 across (−0.4)), radius?: corner radius 0..16384 pt (0; no corner rounds past the middle of a side)} draw a parametric shape with the current paint, selected, as one undo step; it stays editable with addon.pathtools.shape.set until its anchors are edited (moving, turning or scaling it keeps it) → {id, shape}",
has_doc,
create
),
cmd!(
"addon.pathtools.shape.set",
"Edit Parametric Shape",
[],
None,
"{id, kind?, center?, width?, height?, rotation?: degrees clockwise (0: upright), count?, a?, b?, radius?} change a parametric shape's numbers (as addon.pathtools.shape.create takes them; a new kind takes its own defaults for the values not given), as one undo step; with none, or the same ones, nothing changes → {id, shape (its numbers now)}",
has_doc,
set
),
cmd!(
"addon.pathtools.shape.convert",
"Convert to Parametric Shape",
["Object", "Plug-ins", "Path Precision Tools"],
None,
"{ids?: [id…] (default: the selection)} make each plain closed path that is a rectangle, an ellipse or a polygon with equal sides and corners (stretched along its own axes at most) a parametric shape of the same outline, as one undo step → {ids (converted)}",
has_selection,
convert
),
]
}
/// Give path node `n` the outline `path` of shape `s` and keep its numbers; a live shape goes.
fn shape_node(n: &mut Node, s: &ParametricShape, path: PathData) {
let entry = stored(s, &path);
if let NodeKind::Path { path: p, live, .. } = &mut n.kind {
*p = path;
*live = None;
}
n.edit_attrs(|a| match a.data.iter_mut().find(|(k, _)| k == KEY) {
Some(e) => e.1 = entry,
None => a.data.push((KEY.into(), entry)),
});
}
/// The outline of `s`, checked already.
fn outline(s: &ParametricShape, cmd: &str) -> Result<PathData> {
s.path().ok_or_else(|| bad(cmd, "the shape's numbers are out of range"))
}
fn create(s: &mut Session, p: &Value) -> Result<Value> {
const C: &str = "addon.pathtools.shape.create";
if p.get("center").is_none_or(Value::is_null) {
return Err(bad(C, "`center` must be [x, y]"));
}
let shape = apply(ParametricShape::new(ShapeKind::Polygon, Point::ZERO, 100.0, 100.0), p).map_err(|e| bad(C, e))?;
let path = outline(&shape, C)?;
let parent = s.doc()?.target_parent()?;
let look = s.new_art_look(s.paint.fill.clone(), s.paint.stroke.clone(), s.paint.stroke_width);
// shortcut: always on top of the insertion layer, as Draw Normal; honour Draw Behind/Inside if asked.
let id = s.edit(CREATE, |d, sel| {
let id = d.alloc_id();
let mut n = Node::new(id, NodeKind::Path { path: PathData::default(), rule: FillRule::NonZero, live: None, clipping: false, guide: false });
shape_node(&mut n, &shape, path);
look.apply(d, &mut n);
d.insert(parent, usize::MAX, n)?;
sel.set([id]);
Ok(id)
})?;
Ok(json!({ "id": id.0, "shape": to_json(&shape) }))
}
fn set(s: &mut Session, p: &Value) -> Result<Value> {
const C: &str = "addon.pathtools.shape.set";
let id = checked_id(s, p.get("id").unwrap_or(&Value::Null), C)?;
let d = &s.doc()?.doc;
if !d.is_editable(id) {
return Err(bad(C, "the path is locked or hidden"));
}
let old = d.node(id).and_then(read).ok_or_else(|| bad(C, "the object is not an editable parametric shape"))?;
let shape = apply(old, p).map_err(|e| bad(C, e))?;
if shape != old {
let path = outline(&shape, C)?;
s.edit(EDIT, |d, sel| {
shape_node(d.node_mut(id).ok_or(EngineError::NoNode(id))?, &shape, path);
sel.anchors.remove(&id);
sel.segments.remove(&id);
Ok(())
})?;
}
Ok(json!({ "id": id.0, "shape": to_json(&shape) }))
}
fn convert(s: &mut Session, p: &Value) -> Result<Value> {
const C: &str = "addon.pathtools.shape.convert";
let roots = checked_ids_or_selection(s, p, C)?;
let d = &s.doc()?.doc;
let mut found = vec![];
for id in roots {
let Some(n) = d.node(id).filter(|n| d.is_editable(id) && read(n).is_none()) else { continue };
if let NodeKind::Path { path, guide: false, clipping: false, .. } = &n.kind
&& let Some(shape) = recognise(path)
{
found.push((id, shape, outline(&shape, C)?));
}
}
if found.is_empty() {
return Err(bad(C, "select plain rectangles, ellipses or regular polygons to convert"));
}
let ids: Vec<u64> = found.iter().map(|(id, ..)| id.0).collect();
s.edit(CONVERT, |d, sel| {
for (id, shape, path) in found {
shape_node(d.node_mut(id).ok_or(EngineError::NoNode(id))?, &shape, path);
sel.anchors.remove(&id);
sel.segments.remove(&id);
}
Ok(())
})?;
Ok(json!({ "ids": ids }))
}