mirror of
https://github.com/storytold/vectorcraft.git
synced 2026-11-21 01:44:57 +01:00
A live rectangle stored four corner radii but drew them all with the largest, and the corner widgets always rounded all four corners, so one corner could not be rounded on its own. - geom: rectangle_with_corners draws each corner with its own radius and kind (Round, Inverted Round, Chamfer); a sharp corner is one anchor, a cut one two. Uniform corners keep the exact rounded-rectangle anchors. - doc: LiveShape::Rectangle gains `kinds` (saved only when a corner isn't round; older files read as round), plus helpers mapping anchors to corners. - engine: object.setLiveShape takes `corners` and `kind`; without `corners` it edits the Direct-Selected corners, else all four, and keeps the selected corners selected as their anchors change. - tools: with Direct Selection, only the selected corners show widgets and a drag rounds just those; Alt-click cycles the corner kind; double-click opens the new Corners dialog (also `ui.corners`). - ui: Properties/Transform radius fields show and set the selected corners; CSS export keeps per-corner radii and skips cut-in corners. - docs: mcp.md (Live Corners), control-protocol.md (Corners dialog), ROADMAP. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
449 lines
21 KiB
Rust
449 lines
21 KiB
Rust
//! Creating art: shapes, paths, text.
|
|
|
|
use serde_json::{Value, json};
|
|
use vectorcraft_doc::{Appearance, CharStyle, LiveShape, Node, NodeKind, TextObject};
|
|
use vectorcraft_geom::{Affine, Anchor, AnchorKind, FillRule, PathData, Point, Rect, SubPath, shapes};
|
|
|
|
use super::newart::NewArt;
|
|
use super::*;
|
|
|
|
pub fn specs() -> Vec<CommandSpec> {
|
|
vec![
|
|
cmd!("shape.rectangle", "Rectangle", [], None, "{x, y, width, height, radius?: pt} → {id}", has_doc, rectangle),
|
|
cmd!("shape.ellipse", "Ellipse", [], None, "{x, y, width, height} → {id}", has_doc, ellipse),
|
|
cmd!("shape.polygon", "Polygon", [], None, "{cx, cy, radius, sides=6, rotation?: deg} → {id}", has_doc, polygon),
|
|
cmd!("shape.star", "Star", [], None, "{cx, cy, radius1, radius2, points=5, rotation?: deg} → {id}", has_doc, star),
|
|
cmd!(
|
|
"shape.flare",
|
|
"Flare",
|
|
[],
|
|
None,
|
|
"{cx, cy, diameter=100, opacity=50 (%), brightness=30 (%), growth=20 (%), fuzziness=50 (%), rays=15, longest=300 (%), rayFuzziness=100 (%), x2?, y2? (ring end; else pathLength at direction), pathLength=300, rings=10, largest=50 (%), direction=45 (deg), seed?} → {id}",
|
|
has_doc,
|
|
flare
|
|
),
|
|
cmd!("shape.line", "Line Segment", [], None, "{x1, y1, x2, y2} → {id}", has_doc, line),
|
|
cmd!("shape.spiral", "Spiral", [], None, "{cx, cy, radius, decay=80 (%), segments=10, clockwise?} → {id}", has_doc, spiral),
|
|
cmd!("shape.arc", "Arc", [], None, "{x1, y1, x2, y2, closed?} → {id}", has_doc, arc),
|
|
cmd!("shape.rectangularGrid", "Rectangular Grid", [], None, "{x, y, width, height, rows=5, columns=5} → {id}", has_doc, rect_grid),
|
|
cmd!("shape.polarGrid", "Polar Grid", [], None, "{x, y, width, height, concentric=5, radial=5} → {id}", has_doc, polar_grid),
|
|
cmd!(
|
|
"path.create",
|
|
"Create Path",
|
|
[],
|
|
None,
|
|
"{anchors: [{x, y, in?: [x,y], out?: [x,y]}], closed?: bool, d?: SVG path data} → {id}",
|
|
has_doc,
|
|
path_create
|
|
),
|
|
cmd!(
|
|
"view.drawMode",
|
|
"Drawing Mode",
|
|
[],
|
|
Some("Shift+D"),
|
|
"{mode?: normal|behind|inside} (no param cycles; inside needs one selected path)",
|
|
has_doc,
|
|
draw_mode
|
|
),
|
|
cmd!(
|
|
"text.create",
|
|
"Create Text",
|
|
[],
|
|
None,
|
|
"{x, y, text, vertical?: bool = false, size?: pt, font?: family, style?, color?, area?: {width, height}} → {id}",
|
|
has_doc,
|
|
text_create
|
|
),
|
|
]
|
|
}
|
|
|
|
/// Insert a new object at the top of the insertion parent with the current paint and new-art
|
|
/// template; select it.
|
|
pub(crate) fn add_art(s: &mut Session, label: &str, kind: NodeKind, name: Option<String>) -> Result<Value> {
|
|
let look = s.new_art_look(s.paint.fill.clone(), s.paint.stroke.clone(), s.paint.stroke_width);
|
|
add_look(s, label, kind, look, name)
|
|
}
|
|
|
|
/// [`add_look`] with just `appearance`.
|
|
pub(crate) fn add_node(s: &mut Session, label: &str, kind: NodeKind, appearance: Appearance, name: Option<String>) -> Result<Value> {
|
|
add_look(s, label, kind, NewArt::plain(appearance), name)
|
|
}
|
|
|
|
/// Insert a new object looking like `look` (drawing modes apply); select it.
|
|
pub(crate) fn add_look(s: &mut Session, label: &str, kind: NodeKind, look: NewArt, name: Option<String>) -> Result<Value> {
|
|
let parent = s.doc()?.insertion_parent();
|
|
let mode = s.draw_mode;
|
|
let inside = s.draw_inside;
|
|
let behind_of = s.doc()?.selection.in_paint_order(&s.doc()?.doc).first().copied();
|
|
let id = s.edit(label, |d, sel| {
|
|
let id = d.alloc_id();
|
|
let mut n = Node::new(id, kind);
|
|
look.apply(d, &mut n);
|
|
n.name = name;
|
|
match (mode, inside) {
|
|
(crate::DrawMode::Inside, Some(target)) if d.node(target).is_some() => {
|
|
// Wrap the target once in a clip group [mask copy, target, …new art].
|
|
let group = match d.parent_of(target).and_then(|p| d.node(p).map(|pn| (p, pn.kind.clone()))) {
|
|
Some((p, NodeKind::Group { clip: true, children })) if children.get(1).is_some_and(|c| c.id == target) => p,
|
|
_ => {
|
|
let (par, idx, _) = d.position(target).ok_or(crate::EngineError::NoNode(target))?;
|
|
let mut mask = d.node(target).cloned().ok_or(crate::EngineError::NoNode(target))?;
|
|
mask.id = d.alloc_id();
|
|
mask.appearance = Appearance::basic(vectorcraft_color::Paint::None, vectorcraft_color::Paint::None, 0.0);
|
|
if let NodeKind::Path { clipping, .. } = &mut mask.kind {
|
|
*clipping = true;
|
|
}
|
|
let gid = d.alloc_id();
|
|
d.insert(par, idx + 1, Node::new(gid, NodeKind::Group { children: vec![std::sync::Arc::new(mask)], clip: true }))?;
|
|
d.move_node(target, Some(gid), usize::MAX)?;
|
|
gid
|
|
}
|
|
};
|
|
d.insert(Some(group), usize::MAX, n)?;
|
|
}
|
|
(crate::DrawMode::Behind, _) => match behind_of.and_then(|b| d.position(b)) {
|
|
Some((par, idx, _)) => {
|
|
d.insert(par, idx, n)?;
|
|
}
|
|
None => {
|
|
d.insert(parent, 0, n)?;
|
|
}
|
|
},
|
|
_ => {
|
|
d.insert(parent, usize::MAX, n)?;
|
|
}
|
|
}
|
|
sel.set([id]);
|
|
Ok(id)
|
|
})?;
|
|
Ok(json!({ "id": id.0 }))
|
|
}
|
|
|
|
fn draw_mode(s: &mut Session, p: &Value) -> Result<Value> {
|
|
let mode = match str_param(p, "mode") {
|
|
Some("behind") => crate::DrawMode::Behind,
|
|
Some("inside") => crate::DrawMode::Inside,
|
|
Some("normal") => crate::DrawMode::Normal,
|
|
None => match s.draw_mode {
|
|
crate::DrawMode::Normal => crate::DrawMode::Behind,
|
|
crate::DrawMode::Behind if s.doc()?.selection.len() == 1 => crate::DrawMode::Inside,
|
|
_ => crate::DrawMode::Normal,
|
|
},
|
|
Some(o) => return Err(bad("view.drawMode", format!("unknown mode `{o}`"))),
|
|
};
|
|
if mode == crate::DrawMode::Inside {
|
|
let st = s.doc()?;
|
|
let target =
|
|
st.selection.objects.first().copied().filter(|id| {
|
|
matches!(st.doc.node(*id).map(|n| &n.kind), Some(NodeKind::Path { .. } | NodeKind::Compound { .. } | NodeKind::Text(_)))
|
|
});
|
|
match target {
|
|
Some(t) if st.selection.len() == 1 => s.draw_inside = Some(t),
|
|
_ => return Err(bad("view.drawMode", "Draw Inside needs exactly one selected path, compound path or text")),
|
|
}
|
|
} else {
|
|
s.draw_inside = None;
|
|
}
|
|
s.draw_mode = mode;
|
|
Ok(json!({ "mode": mode }))
|
|
}
|
|
|
|
fn path_kind(path: PathData, live: Option<LiveShape>) -> NodeKind {
|
|
NodeKind::Path { path, rule: FillRule::NonZero, live, clipping: false, guide: false }
|
|
}
|
|
|
|
fn rect_of(p: &Value, cmd: &str) -> Result<Rect> {
|
|
let x = f64_req(p, "x", cmd)?;
|
|
let y = f64_req(p, "y", cmd)?;
|
|
let w = f64_req(p, "width", cmd)?;
|
|
let h = f64_req(p, "height", cmd)?;
|
|
if !(w.is_finite() && h.is_finite()) {
|
|
return Err(bad(cmd, "invalid size"));
|
|
}
|
|
Ok(Rect::new(x, y, x + w, y + h).abs())
|
|
}
|
|
|
|
fn rectangle(s: &mut Session, p: &Value) -> Result<Value> {
|
|
let r = rect_of(p, "shape.rectangle")?;
|
|
let radius = f64_or(p, "radius", 0.0).max(0.0);
|
|
let live = LiveShape::Rectangle {
|
|
w: r.width(),
|
|
h: r.height(),
|
|
radii: [radius; 4],
|
|
kinds: Default::default(),
|
|
xf: Affine::translate(r.origin().to_vec2()),
|
|
};
|
|
let label = if radius > 0.0 { "Rounded Rectangle" } else { "Rectangle" };
|
|
add_art(s, label, path_kind(live.to_path(), Some(live)), None)
|
|
}
|
|
|
|
fn ellipse(s: &mut Session, p: &Value) -> Result<Value> {
|
|
let r = rect_of(p, "shape.ellipse")?;
|
|
let live = LiveShape::Ellipse { w: r.width(), h: r.height(), pie: (0.0, 360.0), xf: Affine::translate(r.origin().to_vec2()) };
|
|
add_art(s, "Ellipse", path_kind(live.to_path(), Some(live)), None)
|
|
}
|
|
|
|
fn polygon(s: &mut Session, p: &Value) -> Result<Value> {
|
|
let c = Point::new(f64_req(p, "cx", "shape.polygon")?, f64_req(p, "cy", "shape.polygon")?);
|
|
let r = f64_req(p, "radius", "shape.polygon")?.abs();
|
|
let sides = p.get("sides").and_then(Value::as_u64).unwrap_or(6).clamp(3, 1000) as u32;
|
|
let rot = f64_or(p, "rotation", 0.0);
|
|
let live = LiveShape::Polygon { radius: r, sides, xf: Affine::translate(c.to_vec2()) * Affine::rotate(rot.to_radians()) };
|
|
add_art(s, "Polygon", path_kind(live.to_path(), Some(live)), None)
|
|
}
|
|
|
|
fn star(s: &mut Session, p: &Value) -> Result<Value> {
|
|
let c = Point::new(f64_req(p, "cx", "shape.star")?, f64_req(p, "cy", "shape.star")?);
|
|
let r1 = f64_req(p, "radius1", "shape.star")?.abs();
|
|
let r2 = f64_or(p, "radius2", r1 / 2.0).abs();
|
|
let n = p.get("points").and_then(Value::as_u64).unwrap_or(5).clamp(2, 1000) as u32;
|
|
let path = shapes::star(c, r1, r2, n, f64_or(p, "rotation", 0.0));
|
|
add_art(s, "Star", path_kind(path, None), None)
|
|
}
|
|
|
|
/// Flare tool: a lens flare built from radial-gradient paths in Screen mode — a bright centre, a halo
|
|
/// ring, rays of varying length and rings along the path to the end point.
|
|
fn flare(s: &mut Session, p: &Value) -> Result<Value> {
|
|
use vectorcraft_color::{BlendMode, Gradient, GradientGeom, GradientKind, GradientPaint, GradientStop, Paint};
|
|
let c = Point::new(f64_req(p, "cx", "shape.flare")?, f64_req(p, "cy", "shape.flare")?);
|
|
let pct = |k: &str, d: f64| (f64_or(p, k, d) / 100.0).clamp(0.0, 10.0);
|
|
let r = (f64_or(p, "diameter", 100.0) / 2.0).max(0.5);
|
|
let opacity = pct("opacity", 50.0).min(1.0) as f32;
|
|
let brightness = pct("brightness", 30.0).min(1.0) as f32;
|
|
let growth = pct("growth", 20.0);
|
|
let fuzz = pct("fuzziness", 50.0).min(1.0);
|
|
let rays = p.get("rays").and_then(Value::as_u64).unwrap_or(15).min(50) as usize;
|
|
let longest = pct("longest", 300.0);
|
|
let ray_fuzz = pct("rayFuzziness", 100.0).min(1.0);
|
|
let rings = p.get("rings").and_then(Value::as_u64).unwrap_or(10).min(50) as usize;
|
|
let largest = pct("largest", 50.0);
|
|
let end = match (p.get("x2").and_then(Value::as_f64), p.get("y2").and_then(Value::as_f64)) {
|
|
(Some(x), Some(y)) => Point::new(x, y),
|
|
_ => {
|
|
let a = f64_or(p, "direction", 45.0).to_radians();
|
|
c + vectorcraft_geom::Vec2::new(a.cos(), -a.sin()) * f64_or(p, "pathLength", 300.0)
|
|
}
|
|
};
|
|
// Deterministic pseudo-random sizes (same parameters → same flare).
|
|
let mut seed = p.get("seed").and_then(Value::as_u64).unwrap_or(0x2545_f491_4f6c_dd1d) | 1;
|
|
let mut rnd = move || {
|
|
seed ^= seed << 13;
|
|
seed ^= seed >> 7;
|
|
seed ^= seed << 17;
|
|
(seed >> 11) as f64 / (1u64 << 53) as f64
|
|
};
|
|
let stop = |offset: f32, opacity: f32| GradientStop { opacity, ..GradientStop::new(offset, vectorcraft_color::Color::WHITE) };
|
|
let radial = |centre: Point, radius: f64, stops: Vec<GradientStop>| {
|
|
let mut g = GradientPaint::new(Gradient { kind: GradientKind::Radial, stops });
|
|
g.geom = Some(GradientGeom { start: centre, end: centre + vectorcraft_geom::Vec2::new(radius, 0.0), aspect: 1.0, focal: None });
|
|
Paint::Gradient(Box::new(g))
|
|
};
|
|
let circle = |centre: Point, radius: f64| shapes::ellipse(Rect::from_center_size(centre, (radius * 2.0, radius * 2.0)));
|
|
let mut parts: Vec<(&str, PathData, Paint, f32)> = vec![];
|
|
// Halo: a soft ring just outside the centre.
|
|
let halo_r = r * (1.0 + growth) * 1.6;
|
|
let inner = (1.0 - fuzz as f32 * 0.6).clamp(0.05, 0.95);
|
|
parts.push(("Halo", circle(c, halo_r), radial(c, halo_r, vec![stop(0.0, 0.0), stop(inner * 0.75, 0.0), stop(inner, 0.5), stop(1.0, 0.0)]), 1.0));
|
|
// Rays: thin spikes of random length (Longest = % of the centre radius), fading outwards.
|
|
if rays > 0 {
|
|
let mut bp = vectorcraft_geom::BezPath::new();
|
|
let mut reach: f64 = 0.0;
|
|
for i in 0..rays {
|
|
let a = std::f64::consts::TAU * (i as f64 + rnd() * 0.6) / rays as f64;
|
|
let len = r * longest * (1.0 - ray_fuzz * 0.75 * rnd()).max(0.1);
|
|
reach = reach.max(len);
|
|
let w = r * 0.035;
|
|
let dir = vectorcraft_geom::Vec2::new(a.cos(), a.sin());
|
|
let n = vectorcraft_geom::Vec2::new(-dir.y, dir.x) * w;
|
|
bp.move_to(c + n);
|
|
bp.line_to(c + dir * len);
|
|
bp.line_to(c - n);
|
|
bp.line_to(c - dir * (w * 4.0));
|
|
bp.close_path();
|
|
}
|
|
parts.push(("Rays", PathData::from_bezpath(&bp), radial(c, reach, vec![stop(0.0, 0.9), stop(0.25, 0.35), stop(1.0, 0.0)]), 1.0));
|
|
}
|
|
// Centre: bright core fading to transparent.
|
|
parts.push(("Center", circle(c, r), radial(c, r, vec![stop(0.0, 1.0), stop(0.25 + brightness * 0.5, 0.6), stop(1.0, 0.0)]), opacity));
|
|
// Rings along the path to the end point (Largest = % of the average ring size).
|
|
for _ in 0..rings {
|
|
let t = rnd();
|
|
let at = c + (end - c) * t;
|
|
let rr = (r * largest * (0.25 + rnd() * 0.75)).max(0.5);
|
|
let solid = rnd() < 0.5;
|
|
let stops = if solid {
|
|
vec![stop(0.0, 0.25), stop(0.8, 0.2), stop(1.0, 0.0)]
|
|
} else {
|
|
vec![stop(0.0, 0.0), stop(0.7, 0.05), stop(0.92, 0.35), stop(1.0, 0.0)]
|
|
};
|
|
parts.push(("Ring", circle(at, rr), radial(at, rr, stops), 1.0));
|
|
}
|
|
let parent = s.doc()?.insertion_parent();
|
|
let id = s.edit("Flare", |d, sel| {
|
|
let children = parts
|
|
.into_iter()
|
|
.map(|(name, pd, paint, op)| {
|
|
let mut n = Node::path(d.alloc_id(), pd, Appearance::basic(paint, Paint::None, 0.0));
|
|
n.name = Some(name.into());
|
|
n.blend = BlendMode::Screen;
|
|
n.opacity = op;
|
|
std::sync::Arc::new(n)
|
|
})
|
|
.collect();
|
|
let gid = d.alloc_id();
|
|
let mut g = Node::group(gid, children);
|
|
g.name = Some("Flare".into());
|
|
d.insert(parent, usize::MAX, g)?;
|
|
sel.set([gid]);
|
|
Ok(gid)
|
|
})?;
|
|
Ok(json!({ "id": id.0 }))
|
|
}
|
|
|
|
fn line(s: &mut Session, p: &Value) -> Result<Value> {
|
|
let a = Point::new(f64_req(p, "x1", "shape.line")?, f64_req(p, "y1", "shape.line")?);
|
|
let b = Point::new(f64_req(p, "x2", "shape.line")?, f64_req(p, "y2", "shape.line")?);
|
|
let live = LiveShape::Line { a, b };
|
|
// Lines are stroked, never filled (Illustrator ignores the fill for new open lines).
|
|
let look = s.new_art_look(
|
|
vectorcraft_color::Paint::None,
|
|
if s.paint.stroke.is_none() { vectorcraft_color::Paint::solid(vectorcraft_color::Color::BLACK) } else { s.paint.stroke.clone() },
|
|
s.paint.stroke_width.max(0.1),
|
|
);
|
|
add_look(s, "Line", path_kind(live.to_path(), Some(live)), look, None)
|
|
}
|
|
|
|
fn spiral(s: &mut Session, p: &Value) -> Result<Value> {
|
|
let c = Point::new(f64_req(p, "cx", "shape.spiral")?, f64_req(p, "cy", "shape.spiral")?);
|
|
let path = shapes::spiral(
|
|
c,
|
|
f64_req(p, "radius", "shape.spiral")?,
|
|
f64_or(p, "decay", 80.0),
|
|
p.get("segments").and_then(Value::as_u64).unwrap_or(10).clamp(2, 1000) as u32,
|
|
bool_or(p, "clockwise", true),
|
|
);
|
|
add_art(s, "Spiral", path_kind(path, None), None)
|
|
}
|
|
|
|
fn arc(s: &mut Session, p: &Value) -> Result<Value> {
|
|
let a = Point::new(f64_req(p, "x1", "shape.arc")?, f64_req(p, "y1", "shape.arc")?);
|
|
let b = Point::new(f64_req(p, "x2", "shape.arc")?, f64_req(p, "y2", "shape.arc")?);
|
|
add_art(s, "Arc", path_kind(shapes::arc(a, b, 0.0, bool_or(p, "closed", false)), None), None)
|
|
}
|
|
|
|
fn grid_group(s: &mut Session, label: &str, paths: Vec<PathData>) -> Result<Value> {
|
|
let parent = s.doc()?.insertion_parent();
|
|
let look = s.new_art_look(vectorcraft_color::Paint::None, s.paint.stroke.clone(), s.paint.stroke_width);
|
|
let id = s.edit(label, |d, sel| {
|
|
let children = paths
|
|
.into_iter()
|
|
.map(|pd| {
|
|
let mut n = Node::path(d.alloc_id(), pd, Appearance::default());
|
|
look.apply(d, &mut n);
|
|
std::sync::Arc::new(n)
|
|
})
|
|
.collect();
|
|
let gid = d.alloc_id();
|
|
d.insert(parent, usize::MAX, Node::group(gid, children))?;
|
|
sel.set([gid]);
|
|
Ok(gid)
|
|
})?;
|
|
Ok(json!({ "id": id.0 }))
|
|
}
|
|
|
|
fn rect_grid(s: &mut Session, p: &Value) -> Result<Value> {
|
|
let r = rect_of(p, "shape.rectangularGrid")?;
|
|
let rows = p.get("rows").and_then(Value::as_u64).unwrap_or(5).min(999) as u32;
|
|
let cols = p.get("columns").and_then(Value::as_u64).unwrap_or(5).min(999) as u32;
|
|
grid_group(s, "Rectangular Grid", shapes::rectangular_grid(r, rows, cols, true))
|
|
}
|
|
|
|
fn polar_grid(s: &mut Session, p: &Value) -> Result<Value> {
|
|
let r = rect_of(p, "shape.polarGrid")?;
|
|
let c = p.get("concentric").and_then(Value::as_u64).unwrap_or(5).min(999) as u32;
|
|
let rad = p.get("radial").and_then(Value::as_u64).unwrap_or(5).min(999) as u32;
|
|
grid_group(s, "Polar Grid", shapes::polar_grid(r, c, rad))
|
|
}
|
|
|
|
pub(crate) fn anchor_from_json(v: &Value) -> Option<Anchor> {
|
|
let p = Point::new(v.get("x")?.as_f64()?, v.get("y")?.as_f64()?);
|
|
let h_in = point_param(v, "in").unwrap_or(p);
|
|
let h_out = point_param(v, "out").unwrap_or(p);
|
|
let mut a = Anchor::with_handles(p, h_in, h_out);
|
|
if v.get("smooth").and_then(Value::as_bool) == Some(true) {
|
|
a.kind = AnchorKind::Smooth;
|
|
}
|
|
Some(a)
|
|
}
|
|
|
|
fn path_create(s: &mut Session, p: &Value) -> Result<Value> {
|
|
let path = if let Some(d) = str_param(p, "d") {
|
|
let bp = vectorcraft_geom::BezPath::from_svg(d).map_err(|e| bad("path.create", format!("bad path data: {e}")))?;
|
|
PathData::from_bezpath(&bp)
|
|
} else {
|
|
let anchors: Vec<Anchor> = p
|
|
.get("anchors")
|
|
.and_then(Value::as_array)
|
|
.ok_or_else(|| bad("path.create", "missing anchors"))?
|
|
.iter()
|
|
.filter_map(anchor_from_json)
|
|
.collect();
|
|
if anchors.is_empty() {
|
|
return Err(bad("path.create", "need at least one anchor"));
|
|
}
|
|
PathData::single(SubPath::new(anchors, bool_or(p, "closed", false)))
|
|
};
|
|
let mut look = s.new_art_look(s.paint.fill.clone(), s.paint.stroke.clone(), s.paint.stroke_width);
|
|
// Open paths drawn with a stroke of None would be invisible: mimic Illustrator and keep what the user set.
|
|
let ap = &mut look.appearance;
|
|
if !path.is_closed() && ap.stroke_paint().is_none() && ap.fill_paint().is_none() {
|
|
ap.set_stroke(vectorcraft_color::Paint::solid(vectorcraft_color::Color::BLACK));
|
|
}
|
|
add_look(s, "Pen", path_kind(path, None), look, None)
|
|
}
|
|
|
|
fn text_create(s: &mut Session, p: &Value) -> Result<Value> {
|
|
let x = f64_req(p, "x", "text.create")?;
|
|
let y = f64_req(p, "y", "text.create")?;
|
|
let text = str_param(p, "text").unwrap_or("");
|
|
let mut t = TextObject::point(Point::new(x, y), text, new_type_style(s, p));
|
|
t.vertical = p.get("vertical").and_then(Value::as_bool).unwrap_or(false);
|
|
t.para = new_type_para();
|
|
if let Some(a) = p.get("area") {
|
|
let w = f64_or(a, "width", 200.0);
|
|
let h = f64_or(a, "height", 100.0);
|
|
t.kind = vectorcraft_doc::TextKind::Area { frame: shapes::rectangle(Rect::new(0.0, 0.0, w, h)) };
|
|
}
|
|
let lay = vectorcraft_text::layout(vectorcraft_text::FontDb::global(), &t);
|
|
t.cached_bounds = Some(lay.bounds);
|
|
add_node(s, "Type", NodeKind::Text(Box::new(t)), Appearance::default(), None)
|
|
}
|
|
|
|
/// The paragraph attributes new type gets (the Type tools, `text.create`): aligned to the start of
|
|
/// each paragraph's direction (left, right for Hebrew and Arabic), Japanese punctuation composed
|
|
/// with Line-end Punctuation Half Width. Imported text keeps its own.
|
|
pub(crate) fn new_type_para() -> vectorcraft_doc::ParaStyle {
|
|
vectorcraft_doc::ParaStyle { justify: vectorcraft_doc::Justify::Auto, mojikumi: vectorcraft_doc::Mojikumi::LineEndHalf, ..Default::default() }
|
|
}
|
|
|
|
/// The character style new type gets: `size`, `font`, `style` and `color` from `p`, else the
|
|
/// defaults, filled with the current fill unless that is None or white (black then).
|
|
pub(crate) fn new_type_style(s: &Session, p: &Value) -> CharStyle {
|
|
let mut style = CharStyle::default();
|
|
if let Some(sz) = p.get("size").and_then(Value::as_f64) {
|
|
style.size = sz.clamp(0.1, 1296.0);
|
|
}
|
|
if let Some(f) = str_param(p, "font") {
|
|
style.font_family = f.to_string();
|
|
}
|
|
if let Some(f) = str_param(p, "style") {
|
|
style.font_style = f.to_string();
|
|
}
|
|
style.fill = match p.get("color").and_then(color_value) {
|
|
Some(c) => vectorcraft_color::Paint::solid(c),
|
|
None if !s.paint.fill.is_none() && s.paint.fill != vectorcraft_color::Paint::solid(vectorcraft_color::Color::WHITE) => s.paint.fill.clone(),
|
|
None => vectorcraft_color::Paint::solid(vectorcraft_color::Color::BLACK),
|
|
};
|
|
style
|
|
}
|