Skip to content

VectorCraft: An open-source, vector art tool written by scratch in pure Rust

6.7 KB
Raw Blame
//! 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?, 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 }))
}