# Conflicts: # ROADMAP.md
This commit is contained in:
bflatastic
commit
7248c6aeec
File diff suppressed because one or more lines are too long
|
|
@ -0,0 +1,271 @@
|
|||
//! Live Corners on any path: the corners of its uncut outline (a live rectangle's or polygon's, a
|
||||
//! live path's, or a plain path's own), each one's radius and kind, and the anchors of the path as
|
||||
//! drawn that belong to each. [`set_corners`] edits them.
|
||||
|
||||
use std::borrow::Cow;
|
||||
use std::collections::BTreeSet;
|
||||
|
||||
use vectorcraft_geom::corners::{Corner, cut_corners, path_corners};
|
||||
use vectorcraft_geom::shapes::{self, CornerKind};
|
||||
use vectorcraft_geom::{Affine, PathData, Rect};
|
||||
|
||||
use crate::node::{LiveShape, Node, NodeKind};
|
||||
use crate::selection::AnchorRef;
|
||||
|
||||
/// The Live Corners of a path.
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct LiveCorners<'a> {
|
||||
/// The path with its corners uncut, in the corners' own space: a live rectangle's (its size
|
||||
/// and radii in document units, see [`LiveShape::folded`]), else the document's.
|
||||
pub base: Cow<'a, PathData>,
|
||||
/// Maps `base` into the document.
|
||||
pub xf: Affine,
|
||||
/// The corners that can be cut, in anchor order ([`path_corners`] of `base`).
|
||||
pub corners: Vec<Corner>,
|
||||
radii: Vec<f64>,
|
||||
kinds: Vec<CornerKind>,
|
||||
/// For each anchor of the path as drawn (per subpath), the anchor of `base` it comes from.
|
||||
sources: Vec<Vec<usize>>,
|
||||
}
|
||||
|
||||
impl<'a> LiveCorners<'a> {
|
||||
/// The Live Corners of `path` and its live shape; `None` for shapes without corners (ellipses,
|
||||
/// lines).
|
||||
pub fn new(path: &'a PathData, live: Option<&'a LiveShape>) -> Option<Self> {
|
||||
let (base, xf, radii, kinds) = match live {
|
||||
None => (Cow::Borrowed(path), Affine::IDENTITY, vec![], vec![]),
|
||||
Some(l @ LiveShape::Rectangle { .. }) => {
|
||||
let LiveShape::Rectangle { w, h, radii, kinds, xf } = l.folded() else { return None };
|
||||
(Cow::Owned(shapes::rectangle(Rect::new(0.0, 0.0, w, h))), xf, radii.to_vec(), kinds.to_vec())
|
||||
}
|
||||
Some(l @ LiveShape::Polygon { radii, kinds, .. }) => (Cow::Owned(l.polygon_outline()), Affine::IDENTITY, radii.clone(), kinds.clone()),
|
||||
Some(LiveShape::Path { base, radii, kinds }) => (Cow::Borrowed(base), Affine::IDENTITY, radii.clone(), kinds.clone()),
|
||||
Some(LiveShape::Ellipse { .. } | LiveShape::Line { .. }) => return None,
|
||||
};
|
||||
let sources = if radii.iter().any(|r| *r > 0.0) {
|
||||
cut_corners(&base, &radii, &kinds).1
|
||||
} else {
|
||||
let mut first = 0;
|
||||
base.subpaths
|
||||
.iter()
|
||||
.map(|sp| {
|
||||
first += sp.anchors.len();
|
||||
(first - sp.anchors.len()..first).collect()
|
||||
})
|
||||
.collect()
|
||||
};
|
||||
Some(Self { corners: path_corners(&base), base, xf, radii, kinds, sources })
|
||||
}
|
||||
|
||||
/// The Live Corners of a path object.
|
||||
pub fn of(node: &'a Node) -> Option<Self> {
|
||||
let NodeKind::Path { path, live, .. } = &node.kind else { return None };
|
||||
Self::new(path, live.as_ref())
|
||||
}
|
||||
|
||||
/// The corner at anchor `index` of `base`.
|
||||
pub fn corner(&self, index: usize) -> Option<&Corner> {
|
||||
self.corners.binary_search_by_key(&index, |c| c.index).ok().and_then(|i| self.corners.get(i))
|
||||
}
|
||||
|
||||
/// The radius corner `index` is set to, in document units (drawn no larger than fits).
|
||||
pub fn radius(&self, index: usize) -> f64 {
|
||||
self.radii.get(index).copied().unwrap_or(0.0)
|
||||
}
|
||||
|
||||
/// The kind corner `index` is cut with.
|
||||
pub fn kind(&self, index: usize) -> CornerKind {
|
||||
self.kinds.get(index).copied().unwrap_or_default()
|
||||
}
|
||||
|
||||
/// Every corner.
|
||||
pub fn all(&self) -> BTreeSet<usize> {
|
||||
self.corners.iter().map(|c| c.index).collect()
|
||||
}
|
||||
|
||||
/// The corners holding one of `anchors` (of the path as drawn).
|
||||
pub fn corners_of(&self, anchors: &BTreeSet<AnchorRef>) -> BTreeSet<usize> {
|
||||
anchors.iter().filter_map(|(si, ai)| self.sources.get(*si)?.get(*ai).copied()).filter(|k| self.corner(*k).is_some()).collect()
|
||||
}
|
||||
|
||||
/// The corners Live Corners edit for a selection: those holding a selected anchor when the
|
||||
/// path is partly selected (Direct Selection), else every corner.
|
||||
pub fn picked(&self, partial: Option<&BTreeSet<AnchorRef>>) -> BTreeSet<usize> {
|
||||
let picked = partial.map(|a| self.corners_of(a)).unwrap_or_default();
|
||||
if picked.is_empty() { self.all() } else { picked }
|
||||
}
|
||||
|
||||
/// The anchors of the path as drawn that belong to `corners` (to keep them selected as the
|
||||
/// path changes).
|
||||
pub fn anchors_of(&self, corners: &BTreeSet<usize>) -> BTreeSet<AnchorRef> {
|
||||
let mut out = BTreeSet::new();
|
||||
for (si, from) in self.sources.iter().enumerate() {
|
||||
out.extend(from.iter().enumerate().filter(|(_, k)| corners.contains(k)).map(|(ai, _)| (si, ai)));
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// For each anchor of the path as drawn (per subpath), the anchor of `base` it comes from.
|
||||
pub fn sources(&self) -> &[Vec<usize>] {
|
||||
&self.sources
|
||||
}
|
||||
|
||||
/// The radius (document units) and kind `corners` share (each `None` when they differ, or
|
||||
/// for no corners).
|
||||
pub fn style(&self, corners: &BTreeSet<usize>) -> (Option<f64>, Option<CornerKind>) {
|
||||
fn shared<T: Copy>(mut it: impl Iterator<Item = T>, same: impl Fn(T, T) -> bool) -> Option<T> {
|
||||
let first = it.next()?;
|
||||
it.all(|x| same(x, first)).then_some(first)
|
||||
}
|
||||
let radius = shared(corners.iter().map(|k| self.radius(*k)), |a, b| (a - b).abs() < 1e-9);
|
||||
(radius, shared(corners.iter().map(|k| self.kind(*k)), |a, b| a == b))
|
||||
}
|
||||
}
|
||||
|
||||
/// Set `radius` (document units; negative: 0) and/or `kind` on the `corners` (anchor indices of
|
||||
/// the uncut outline, see [`LiveCorners`]) of a path and its live shape, then cut the path again.
|
||||
/// A path that isn't a live shape keeps its uncut outline as a [`LiveShape::Path`], which is a
|
||||
/// plain path again once no corner is cut. Ellipses and lines have no corners: they stay as they
|
||||
/// are.
|
||||
pub fn set_corners(path: &mut PathData, live: &mut Option<LiveShape>, corners: &BTreeSet<usize>, radius: Option<f64>, kind: Option<CornerKind>) {
|
||||
fn edit(radii: &mut [f64], kinds: &mut [CornerKind], corners: &BTreeSet<usize>, radius: Option<f64>, kind: Option<CornerKind>) {
|
||||
for k in corners {
|
||||
if let (Some(r), Some(slot)) = (radius, radii.get_mut(*k)) {
|
||||
*slot = r.max(0.0);
|
||||
}
|
||||
if let (Some(kind), Some(slot)) = (kind, kinds.get_mut(*k)) {
|
||||
*slot = kind;
|
||||
}
|
||||
}
|
||||
}
|
||||
/// One radius and kind per corner of an outline of `n` anchors while editing; none saved
|
||||
/// when all are sharp or round.
|
||||
fn edit_vec(
|
||||
n: usize,
|
||||
radii: &mut Vec<f64>,
|
||||
kinds: &mut Vec<CornerKind>,
|
||||
corners: &BTreeSet<usize>,
|
||||
radius: Option<f64>,
|
||||
kind: Option<CornerKind>,
|
||||
) {
|
||||
radii.resize(n, 0.0);
|
||||
kinds.resize(n, CornerKind::Round);
|
||||
edit(radii, kinds, corners, radius, kind);
|
||||
if radii.iter().all(|r| *r <= 0.0) {
|
||||
radii.clear();
|
||||
}
|
||||
if kinds.iter().all(|k| *k == CornerKind::Round) {
|
||||
kinds.clear();
|
||||
}
|
||||
}
|
||||
let l = live.get_or_insert_with(|| LiveShape::Path { base: path.clone(), radii: vec![], kinds: vec![] });
|
||||
// Radii are document lengths and corners circular, also on a rectangle from a file that kept
|
||||
// an uneven scale in its transform (#442).
|
||||
l.fold_scale();
|
||||
match l {
|
||||
LiveShape::Rectangle { radii, kinds, .. } => edit(radii, kinds, corners, radius, kind),
|
||||
LiveShape::Polygon { sides, radii, kinds, .. } => edit_vec(*sides as usize, radii, kinds, corners, radius, kind),
|
||||
LiveShape::Path { base, radii, kinds } => edit_vec(base.anchor_count(), radii, kinds, corners, radius, kind),
|
||||
LiveShape::Ellipse { .. } | LiveShape::Line { .. } => return,
|
||||
}
|
||||
match live {
|
||||
Some(LiveShape::Path { base, radii, kinds }) if radii.is_empty() && kinds.is_empty() => {
|
||||
*path = std::mem::take(base);
|
||||
*live = None;
|
||||
}
|
||||
Some(l) => *path = l.to_path(),
|
||||
None => {}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use vectorcraft_geom::{Point, SubPath};
|
||||
|
||||
fn set(v: &[usize]) -> BTreeSet<usize> {
|
||||
v.iter().copied().collect()
|
||||
}
|
||||
|
||||
fn anchors(v: &[usize]) -> BTreeSet<AnchorRef> {
|
||||
v.iter().map(|ai| (0, *ai)).collect()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rectangle_corners_map_to_their_anchors() {
|
||||
let l = LiveShape::Rectangle { w: 100.0, h: 50.0, radii: [0.0, 10.0, 0.0, 0.0], kinds: Default::default(), xf: Affine::IDENTITY };
|
||||
let path = l.to_path();
|
||||
let c = LiveCorners::new(&path, Some(&l)).unwrap();
|
||||
// Anchors: top-left, the top-right corner's two, bottom-right, bottom-left.
|
||||
assert_eq!(c.sources(), [vec![0, 1, 1, 2, 3]]);
|
||||
assert_eq!(path.anchor_count(), 5);
|
||||
assert_eq!(c.corners_of(&anchors(&[2, 4])), set(&[1, 3]));
|
||||
assert!(c.corners_of(&anchors(&[9])).is_empty(), "out of range");
|
||||
assert_eq!(c.anchors_of(&set(&[1, 3])), anchors(&[1, 2, 4]));
|
||||
// Partly selected: the corners of the selected anchors; wholly (or no anchor): all four.
|
||||
assert_eq!(c.picked(Some(&anchors(&[0]))), set(&[0]));
|
||||
assert_eq!(c.picked(None), set(&[0, 1, 2, 3]));
|
||||
assert_eq!(c.picked(Some(&anchors(&[]))), set(&[0, 1, 2, 3]));
|
||||
assert_eq!(c.style(&set(&[1])), (Some(10.0), Some(CornerKind::Round)));
|
||||
assert_eq!(c.style(&set(&[0, 1])), (None, Some(CornerKind::Round)));
|
||||
assert_eq!(c.style(&set(&[0, 2, 3])), (Some(0.0), Some(CornerKind::Round)));
|
||||
let e = LiveShape::Ellipse { w: 1.0, h: 1.0, pie: (0.0, 360.0), xf: Affine::IDENTITY };
|
||||
assert!(LiveCorners::new(&e.to_path(), Some(&e)).is_none());
|
||||
}
|
||||
|
||||
/// #511: a plain path (a star) rounds its corners and keeps them editable; with none cut it
|
||||
/// is plain again.
|
||||
#[test]
|
||||
fn a_plain_path_keeps_its_cut_corners_live() {
|
||||
let star = shapes::star(Point::new(100.0, 100.0), 50.0, 25.0, 5, 0.0);
|
||||
let (mut path, mut live) = (star.clone(), None);
|
||||
set_corners(&mut path, &mut live, &set(&[0, 2]), Some(5.0), None);
|
||||
let Some(LiveShape::Path { base, radii, kinds }) = &live else { panic!("live corners: {live:?}") };
|
||||
assert_eq!((base, radii.len(), kinds.len()), (&star, 10, 0));
|
||||
assert_eq!(path.anchor_count(), 12, "two corners cut");
|
||||
let c = LiveCorners::new(&path, live.as_ref()).unwrap();
|
||||
assert_eq!(c.style(&set(&[0, 2])), (Some(5.0), Some(CornerKind::Round)));
|
||||
assert_eq!(c.corners_of(&anchors(&[0, 11])), set(&[0]), "the first corner's cut ends the path");
|
||||
// Kinds alone keep it live; squaring every corner makes it the plain star again.
|
||||
set_corners(&mut path, &mut live, &set(&[0, 2]), Some(0.0), Some(CornerKind::Chamfer));
|
||||
assert!(matches!(&live, Some(LiveShape::Path { radii, .. }) if radii.is_empty()));
|
||||
set_corners(&mut path, &mut live, &set(&[0, 2]), None, Some(CornerKind::Round));
|
||||
assert_eq!((path, live), (star, None));
|
||||
}
|
||||
|
||||
/// A polygon's corners are cut in the document and survive a change of sides when shared.
|
||||
#[test]
|
||||
fn polygon_corners_follow_their_sides() {
|
||||
let mut l = LiveShape::Polygon { radius: 50.0, sides: 6, xf: Affine::translate((100.0, 100.0)), radii: vec![], kinds: vec![] };
|
||||
let (mut path, mut live) = (l.to_path(), Some(l.clone()));
|
||||
set_corners(&mut path, &mut live, &set(&[0, 1, 2, 3, 4, 5]), Some(8.0), None);
|
||||
assert_eq!(path.anchor_count(), 12);
|
||||
l = live.clone().unwrap();
|
||||
l.set_sides(8);
|
||||
assert!(matches!(&l, LiveShape::Polygon { radii, .. } if *radii == vec![8.0; 8]));
|
||||
assert_eq!(l.to_path().anchor_count(), 16);
|
||||
// Mixed radii: the new corners are sharp.
|
||||
set_corners(&mut path, &mut live, &set(&[1]), Some(3.0), None);
|
||||
let mut l = live.unwrap();
|
||||
l.set_sides(7);
|
||||
assert!(matches!(&l, LiveShape::Polygon { radii, .. } if *radii == [8.0, 3.0, 8.0, 8.0, 8.0, 8.0, 0.0]));
|
||||
// An uneven scale keeps the cuts circular: the radius scales by the mean scale.
|
||||
let mut p = l.clone();
|
||||
assert!(p.transform(Affine::scale_non_uniform(4.0, 1.0)));
|
||||
assert!(matches!(&p, LiveShape::Polygon { radii, .. } if (radii[0] - 16.0).abs() < 1e-9));
|
||||
assert!(!p.transform(Affine::translate((5.0, 0.0))), "a move needs no new cuts");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn open_paths_and_curves_keep_their_ends_and_smooth_anchors() {
|
||||
let pen = PathData::single(SubPath::polyline(&[Point::new(0.0, 0.0), Point::new(100.0, 0.0), Point::new(100.0, 80.0)], false));
|
||||
let c = LiveCorners::new(&pen, None).unwrap();
|
||||
assert_eq!(c.all(), set(&[1]));
|
||||
assert_eq!(c.picked(Some(&anchors(&[0]))), set(&[1]), "an end is no corner: every corner");
|
||||
let (mut path, mut live) = (pen.clone(), None);
|
||||
set_corners(&mut path, &mut live, &c.all(), Some(10.0), None);
|
||||
assert_eq!(path.anchor_count(), 4);
|
||||
assert_eq!(path.subpaths[0].anchors[0].p, Point::new(0.0, 0.0));
|
||||
assert_eq!(path.subpaths[0].anchors[3].p, Point::new(100.0, 80.0));
|
||||
}
|
||||
}
|
||||
|
|
@ -10,6 +10,7 @@ pub mod assets;
|
|||
pub mod blend;
|
||||
pub mod clipnest;
|
||||
pub mod cmyk;
|
||||
pub mod corners;
|
||||
pub mod graph;
|
||||
pub mod hit;
|
||||
pub mod inks;
|
||||
|
|
@ -58,6 +59,7 @@ pub use appearance::{
|
|||
StrokeLayer, WidthProfile,
|
||||
};
|
||||
pub use assets::ExportAsset;
|
||||
pub use corners::LiveCorners;
|
||||
pub use graph::{GraphKind, GraphSpec};
|
||||
pub use hit::{Hit, HitKind};
|
||||
pub use links::{LinkInfo, PlacementOptions};
|
||||
|
|
|
|||
|
|
@ -1,17 +1,16 @@
|
|||
//! Document nodes.
|
||||
|
||||
use std::collections::BTreeSet;
|
||||
use std::sync::Arc;
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
use vectorcraft_color::BlendMode;
|
||||
use vectorcraft_geom::corners::cut_corners;
|
||||
use vectorcraft_geom::shapes::{self, CornerKind};
|
||||
use vectorcraft_geom::{Affine, BezPath, FillRule, PathData, Point, Rect};
|
||||
|
||||
use crate::appearance::Appearance;
|
||||
use crate::live::{BlendSpec, EnvelopeKind, GradientMesh, Outliner};
|
||||
use crate::pattern::RepeatSpec;
|
||||
use crate::selection::AnchorRef;
|
||||
use crate::text::TextObject;
|
||||
|
||||
/// Stable per-document object id. Never reused.
|
||||
|
|
@ -104,11 +103,30 @@ pub enum LiveShape {
|
|||
radius: f64,
|
||||
sides: u32,
|
||||
xf: Affine,
|
||||
/// Corner radii in document units, by vertex from the first one clockwise (none: sharp).
|
||||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||
radii: Vec<f64>,
|
||||
/// Corner kinds, in the same order (none: round).
|
||||
#[serde(default, skip_serializing_if = "all_round")]
|
||||
kinds: Vec<CornerKind>,
|
||||
},
|
||||
Line {
|
||||
a: Point,
|
||||
b: Point,
|
||||
},
|
||||
/// Any other path whose corners Live Corners cut (a star, a pen path): it keeps its uncut
|
||||
/// outline so the corners stay editable. Without a cut corner it is a plain path again.
|
||||
Path {
|
||||
/// The path with its corners uncut, in the document.
|
||||
base: PathData,
|
||||
/// Corner radii in document units, by anchor index of `base` (counting every subpath's
|
||||
/// anchors in order; missing: sharp).
|
||||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||
radii: Vec<f64>,
|
||||
/// Corner kinds, in the same order (missing: round).
|
||||
#[serde(default, skip_serializing_if = "all_round")]
|
||||
kinds: Vec<CornerKind>,
|
||||
},
|
||||
}
|
||||
|
||||
impl LiveShape {
|
||||
|
|
@ -119,6 +137,7 @@ impl LiveShape {
|
|||
LiveShape::Ellipse { .. } => "Ellipse",
|
||||
LiveShape::Polygon { .. } => "Polygon",
|
||||
LiveShape::Line { .. } => "Line",
|
||||
LiveShape::Path { .. } => "Path",
|
||||
}
|
||||
}
|
||||
/// Regenerate the path.
|
||||
|
|
@ -128,10 +147,33 @@ impl LiveShape {
|
|||
shapes::rectangle_with_corners(Rect::new(0.0, 0.0, *w, *h), *radii, *kinds).transformed(*xf)
|
||||
}
|
||||
LiveShape::Ellipse { w, h, xf, .. } => shapes::ellipse(Rect::new(0.0, 0.0, *w, *h)).transformed(*xf),
|
||||
LiveShape::Polygon { radius, sides, xf } => shapes::polygon(Point::ZERO, *radius, *sides, 0.0).transformed(*xf),
|
||||
LiveShape::Polygon { radii, kinds, .. } => cut_corners(&self.polygon_outline(), radii, kinds).0,
|
||||
LiveShape::Line { a, b } => shapes::line(*a, *b),
|
||||
LiveShape::Path { base, radii, kinds } => cut_corners(base, radii, kinds).0,
|
||||
}
|
||||
}
|
||||
/// A polygon's outline with its corners uncut, in the document (empty for other shapes).
|
||||
pub fn polygon_outline(&self) -> PathData {
|
||||
match self {
|
||||
LiveShape::Polygon { radius, sides, xf, .. } => shapes::polygon(Point::ZERO, *radius, *sides, 0.0).transformed(*xf),
|
||||
_ => PathData::default(),
|
||||
}
|
||||
}
|
||||
/// Give a polygon `n` sides (3–1000). Its corners keep the radius and kind they shared; else
|
||||
/// the corners past the old last one are sharp.
|
||||
pub fn set_sides(&mut self, n: u64) {
|
||||
let LiveShape::Polygon { sides, radii, kinds, .. } = self else { return };
|
||||
*sides = n.clamp(3, 1000) as u32;
|
||||
fn spread<T: Copy + PartialEq + Default>(v: &mut Vec<T>, n: usize) {
|
||||
match v.first().copied() {
|
||||
Some(x) if v.iter().all(|y| *y == x) => *v = vec![x; n],
|
||||
Some(_) => v.resize(n, T::default()),
|
||||
None => {}
|
||||
}
|
||||
}
|
||||
spread(radii, *sides as usize);
|
||||
spread(kinds, *sides as usize);
|
||||
}
|
||||
/// Apply `a` to the shape. True when the shape is no longer `a` applied to the old path, so
|
||||
/// the caller must regenerate the path with [`LiveShape::to_path`].
|
||||
///
|
||||
|
|
@ -140,19 +182,27 @@ impl LiveShape {
|
|||
/// only the rotation, reflection and position. The radii scale by the mean scale (the square
|
||||
/// root of the determinant), which [`LiveShape::keep_corners`] undoes for Scale Corners off.
|
||||
/// A shear can't keep circular corners: `xf` takes it, as do moves (so files saved with a
|
||||
/// scale in `xf` keep their exact geometry until they're next transformed).
|
||||
/// scale in `xf` keep their exact geometry until they're next transformed). A polygon's or a
|
||||
/// path's corner radii are document lengths: they scale by the mean scale and the corners are
|
||||
/// cut again, circular whatever `a` does.
|
||||
pub fn transform(&mut self, a: Affine) -> bool {
|
||||
match self {
|
||||
LiveShape::Rectangle { xf, .. } => {
|
||||
*xf = a * *xf;
|
||||
let [a0, a1, a2, a3, _, _] = a.as_coeffs();
|
||||
let moves_only = (a0 - 1.0).abs() < 1e-12 && a1.abs() < 1e-12 && a2.abs() < 1e-12 && (a3 - 1.0).abs() < 1e-12;
|
||||
!moves_only && self.fold_scale()
|
||||
!moves_only(a) && self.fold_scale()
|
||||
}
|
||||
LiveShape::Ellipse { xf, .. } | LiveShape::Polygon { xf, .. } => {
|
||||
LiveShape::Ellipse { xf, .. } => {
|
||||
*xf = a * *xf;
|
||||
false
|
||||
}
|
||||
LiveShape::Polygon { xf, radii, .. } => {
|
||||
*xf = a * *xf;
|
||||
scale_radii(radii, a)
|
||||
}
|
||||
LiveShape::Path { base, radii, .. } => {
|
||||
base.transform(a);
|
||||
scale_radii(radii, a)
|
||||
}
|
||||
LiveShape::Line { a: p, b } => {
|
||||
*p = a * *p;
|
||||
*b = a * *b;
|
||||
|
|
@ -192,52 +242,16 @@ impl LiveShape {
|
|||
/// Divide live corner radii by `k`, the mean scale of a transform just applied, so the corners
|
||||
/// keep their size (Scale Corners off). False when nothing changed.
|
||||
pub fn keep_corners(&mut self, k: f64) -> bool {
|
||||
match self {
|
||||
LiveShape::Rectangle { radii, .. } if radii.iter().any(|r| *r > 0.0) && k > 1e-12 => {
|
||||
radii.iter_mut().for_each(|r| *r /= k);
|
||||
true
|
||||
}
|
||||
_ => false,
|
||||
let radii: &mut [f64] = match self {
|
||||
LiveShape::Rectangle { radii, .. } => radii,
|
||||
LiveShape::Polygon { radii, .. } | LiveShape::Path { radii, .. } => radii,
|
||||
LiveShape::Ellipse { .. } | LiveShape::Line { .. } => return false,
|
||||
};
|
||||
if !radii.iter().any(|r| *r > 0.0) || k <= 1e-12 {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
/// The corner (radii order) of each anchor of a rectangle's path; empty for other shapes.
|
||||
pub fn anchor_corners(&self) -> Vec<usize> {
|
||||
match self {
|
||||
LiveShape::Rectangle { w, h, radii, .. } => shapes::rectangle_anchor_corners(Rect::new(0.0, 0.0, *w, *h), *radii),
|
||||
_ => vec![],
|
||||
}
|
||||
}
|
||||
/// The corners of a rectangle that hold one of `anchors` (of its only subpath).
|
||||
pub fn corners_of(&self, anchors: &BTreeSet<AnchorRef>) -> [bool; 4] {
|
||||
let map = self.anchor_corners();
|
||||
let mut out = [false; 4];
|
||||
for k in anchors.iter().filter(|(si, _)| *si == 0).filter_map(|(_, ai)| map.get(*ai)) {
|
||||
if let Some(c) = out.get_mut(*k) {
|
||||
*c = true;
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
/// The corners Live Corners edit for a selection: those holding a selected anchor when the
|
||||
/// shape is partly selected (Direct Selection), else all four.
|
||||
pub fn picked_corners(&self, partial: Option<&BTreeSet<AnchorRef>>) -> [bool; 4] {
|
||||
let picked = partial.map_or([true; 4], |a| self.corners_of(a));
|
||||
if picked.contains(&true) { picked } else { [true; 4] }
|
||||
}
|
||||
/// The anchors of a rectangle's `corners` (to keep them selected as its path changes).
|
||||
pub fn corner_anchors(&self, corners: [bool; 4]) -> BTreeSet<AnchorRef> {
|
||||
self.anchor_corners().into_iter().enumerate().filter(|(_, k)| corners.get(*k) == Some(&true)).map(|(ai, _)| (0, ai)).collect()
|
||||
}
|
||||
/// The radius (in document units, see [`LiveShape::folded`]) and kind the `corners` of a
|
||||
/// rectangle share (each `None` when they differ).
|
||||
pub fn corner_style(&self, corners: [bool; 4]) -> (Option<f64>, Option<CornerKind>) {
|
||||
let LiveShape::Rectangle { radii, kinds, .. } = self.folded() else { return (None, None) };
|
||||
fn shared<T: Copy>(v: [T; 4], corners: [bool; 4], same: impl Fn(T, T) -> bool) -> Option<T> {
|
||||
let mut it = v.into_iter().zip(corners).filter(|(_, on)| *on).map(|(x, _)| x);
|
||||
let first = it.next()?;
|
||||
it.all(|x| same(x, first)).then_some(first)
|
||||
}
|
||||
(shared(radii, corners, |a, b| (a - b).abs() < 1e-9), shared(kinds, corners, |a, b| a == b))
|
||||
radii.iter_mut().for_each(|r| *r /= k);
|
||||
true
|
||||
}
|
||||
/// Rotation angle of the live shape in degrees (shown in the Properties panel).
|
||||
pub fn angle_deg(&self) -> f64 {
|
||||
|
|
@ -247,14 +261,33 @@ impl LiveShape {
|
|||
c[1].atan2(c[0]).to_degrees()
|
||||
}
|
||||
LiveShape::Line { a, b } => (b.y - a.y).atan2(b.x - a.x).to_degrees(),
|
||||
LiveShape::Path { .. } => 0.0,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn all_round(kinds: &[CornerKind; 4]) -> bool {
|
||||
fn all_round(kinds: &[CornerKind]) -> bool {
|
||||
kinds.iter().all(|k| *k == CornerKind::Round)
|
||||
}
|
||||
|
||||
/// Whether `a` only moves (no rotation, scale, shear or reflection).
|
||||
fn moves_only(a: Affine) -> bool {
|
||||
let [a0, a1, a2, a3, _, _] = a.as_coeffs();
|
||||
(a0 - 1.0).abs() < 1e-12 && a1.abs() < 1e-12 && a2.abs() < 1e-12 && (a3 - 1.0).abs() < 1e-12
|
||||
}
|
||||
|
||||
/// Scale corner radii in document units by the mean scale of `a`, applied to their path. True
|
||||
/// when the path must be cut again: some corner is cut and `a` does more than move it (an
|
||||
/// uneven scale would otherwise make the cuts elliptical).
|
||||
fn scale_radii(radii: &mut [f64], a: Affine) -> bool {
|
||||
if moves_only(a) || !radii.iter().any(|r| *r > 0.0) {
|
||||
return false;
|
||||
}
|
||||
let k = a.determinant().abs().sqrt();
|
||||
radii.iter_mut().for_each(|r| *r *= k);
|
||||
true
|
||||
}
|
||||
|
||||
/// What a transform scales besides geometry, by its mean scale (the square root of its
|
||||
/// determinant). `Scaling::default()` (and `false`) scales nothing else; `true` scales stroke
|
||||
/// weights and dashes only. Transforms the user asks for take theirs from Scale Strokes & Effects
|
||||
|
|
@ -1214,7 +1247,7 @@ impl Node {
|
|||
|
||||
/// Shapes drawn with the shape tools (live rectangles, ellipses and polygons) show their centre.
|
||||
pub fn shows_center_by_default(&self) -> bool {
|
||||
matches!(&self.kind, NodeKind::Path { live: Some(l), .. } if !matches!(l, LiveShape::Line { .. }))
|
||||
matches!(&self.kind, NodeKind::Path { live: Some(l), .. } if !matches!(l, LiveShape::Line { .. } | LiveShape::Path { .. }))
|
||||
}
|
||||
|
||||
/// Change this object's attributes with `f`; all-default attributes are dropped.
|
||||
|
|
@ -1276,23 +1309,9 @@ mod tests {
|
|||
}
|
||||
|
||||
#[test]
|
||||
fn rectangle_corners_map_to_their_anchors() {
|
||||
fn corner_kinds_save_only_when_some_corner_isnt_round() {
|
||||
let mut l = LiveShape::Rectangle { w: 100.0, h: 50.0, radii: [0.0, 10.0, 0.0, 0.0], kinds: Default::default(), xf: Affine::IDENTITY };
|
||||
// Anchors: top-left, the top-right corner's two, bottom-right, bottom-left.
|
||||
assert_eq!(l.anchor_corners(), [0, 1, 1, 2, 3]);
|
||||
assert_eq!(l.to_path().anchor_count(), 5);
|
||||
let set = |v: &[usize]| v.iter().map(|ai| (0, *ai)).collect::<BTreeSet<AnchorRef>>();
|
||||
assert_eq!(l.corners_of(&set(&[2, 4])), [false, true, false, true]);
|
||||
assert_eq!(l.corners_of(&set(&[9])), [false; 4], "out of range");
|
||||
assert_eq!(l.corner_anchors([false, true, false, true]), set(&[1, 2, 4]));
|
||||
// Partly selected: the corners of the selected anchors; wholly (or no anchor): all four.
|
||||
assert_eq!(l.picked_corners(Some(&set(&[0]))), [true, false, false, false]);
|
||||
assert_eq!(l.picked_corners(None), [true; 4]);
|
||||
assert_eq!(l.picked_corners(Some(&set(&[]))), [true; 4]);
|
||||
assert_eq!(l.corner_style([false, true, false, false]), (Some(10.0), Some(CornerKind::Round)));
|
||||
assert_eq!(l.corner_style([true, true, false, false]), (None, Some(CornerKind::Round)));
|
||||
assert_eq!(l.corner_style([true, false, true, true]), (Some(0.0), Some(CornerKind::Round)));
|
||||
// Corner kinds save only when some corner isn't round, and older files read as round.
|
||||
// Older files read as round.
|
||||
let json = serde_json::to_value(&l).unwrap();
|
||||
assert!(json.get("kinds").is_none(), "{json}");
|
||||
assert_eq!(serde_json::from_value::<LiveShape>(json).unwrap(), l);
|
||||
|
|
@ -1302,7 +1321,16 @@ mod tests {
|
|||
let json = serde_json::to_value(&l).unwrap();
|
||||
assert_eq!(json["kinds"], serde_json::json!(["round", "chamfer", "round", "round"]));
|
||||
assert_eq!(serde_json::from_value::<LiveShape>(json).unwrap(), l);
|
||||
assert!(LiveShape::Ellipse { w: 1.0, h: 1.0, pie: (0.0, 360.0), xf: Affine::IDENTITY }.anchor_corners().is_empty());
|
||||
// Polygons saved before Live Corners cut theirs read as sharp; a live path round-trips.
|
||||
let p: LiveShape =
|
||||
serde_json::from_value(serde_json::json!({"shape": "polygon", "radius": 10.0, "sides": 5, "xf": [1, 0, 0, 1, 0, 0]})).unwrap();
|
||||
assert_eq!(p, LiveShape::Polygon { radius: 10.0, sides: 5, xf: Affine::IDENTITY, radii: vec![], kinds: vec![] });
|
||||
let star = shapes::star(Point::new(0.0, 0.0), 20.0, 10.0, 5, 0.0);
|
||||
let path = LiveShape::Path { base: star, radii: vec![2.0; 10], kinds: vec![] };
|
||||
let json = serde_json::to_value(&path).unwrap();
|
||||
assert_eq!((json["shape"].as_str(), json.get("kinds")), (Some("path"), None));
|
||||
assert_eq!(serde_json::from_value::<LiveShape>(json).unwrap(), path);
|
||||
assert_eq!(path.label(), "Path");
|
||||
}
|
||||
|
||||
/// A node holding a live rectangle (`w` × `h`, all radii `r`, placed by `xf`) and its path.
|
||||
|
|
@ -1427,7 +1455,8 @@ mod tests {
|
|||
assert!(near_xf(*xf, Affine::translate((5.0, 5.0))));
|
||||
let (a, b) = (folded.to_path().bounds().unwrap(), live.to_path().bounds().unwrap());
|
||||
assert!(near(a.x0, b.x0) && near(a.y0, b.y0) && near(a.x1, b.x1) && near(a.y1, b.y1), "same place and size: {a:?} {b:?}");
|
||||
assert_eq!(live.corner_style([true; 4]).0, Some(40.0), "the radius in document units");
|
||||
let corners = crate::LiveCorners::of(&n).unwrap();
|
||||
assert_eq!(corners.style(&corners.all()).0, Some(40.0), "the radius in document units");
|
||||
// Nothing to fold: a moved, rotated or reflected rectangle and a sheared one stay as they are.
|
||||
let place = Affine::translate((5.0, 5.0)) * Affine::rotate(0.5) * Affine::scale_non_uniform(-1.0, 1.0);
|
||||
let shear = Affine::new([1.0, 0.0, 0.5, 1.0, 0.0, 0.0]);
|
||||
|
|
|
|||
|
|
@ -188,7 +188,8 @@ fn polygon(s: &mut Session, p: &Value) -> Result<Value> {
|
|||
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()) };
|
||||
let xf = Affine::translate(c.to_vec2()) * Affine::rotate(rot.to_radians());
|
||||
let live = LiveShape::Polygon { radius: r, sides, xf, radii: vec![], kinds: vec![] };
|
||||
add_art(s, "Polygon", path_kind(live.to_path(), Some(live)), None)
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,11 +1,13 @@
|
|||
//! Object menu: transforms, arrange, group, lock/hide, compound paths, clipping masks, isolation,
|
||||
//! align & distribute, object properties.
|
||||
|
||||
use std::collections::BTreeSet;
|
||||
use std::sync::Arc;
|
||||
|
||||
use serde_json::{Value, json};
|
||||
use vectorcraft_color::{BlendMode, Paint};
|
||||
use vectorcraft_doc::{Appearance, Document, Knockout, Node, NodeId, NodeKind, OrientedBox, Scaling};
|
||||
use vectorcraft_doc::corners::set_corners;
|
||||
use vectorcraft_doc::{Appearance, Document, Knockout, LiveCorners, LiveShape, Node, NodeId, NodeKind, OrientedBox, Scaling};
|
||||
use vectorcraft_geom::shapes::CornerKind;
|
||||
use vectorcraft_geom::{Affine, FillRule, Point, Rect, Vec2};
|
||||
|
||||
|
|
@ -194,7 +196,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
|||
"Live Shape Properties",
|
||||
[],
|
||||
None,
|
||||
"{id?, ids?, radius?: pt, kind?: \"round\"|\"invertedRound\"|\"chamfer\", corners?: [0..3…], sides?: n} (Live Corners: radius and kind set a rectangle's corners: `corners` (0 top-left, 1 top-right, 2 bottom-right, 3 bottom-left), else the corners with a Direct-Selected anchor, else all four; sides: a polygon's)",
|
||||
"{id?, ids?, radius?: pt, kind?: \"round\"|\"invertedRound\"|\"chamfer\", corners?: [i…], sides?: n} (Live Corners on any path: radius and kind set its corners (anchors without handles between two straight sides): `corners` (anchor indices of the path with its corners uncut, counting every subpath's anchors in order: a rectangle's 0 top-left, 1 top-right, 2 bottom-right, 3 bottom-left; a polygon's from the first vertex clockwise), else the corners with a Direct-Selected anchor, else every corner; each radius is drawn no larger than half the corner's shorter side allows; a path that isn't a live shape keeps its uncut outline so its corners stay editable, and is plain again once none is cut; sides: a polygon's, which keep the radius they shared)",
|
||||
has_selection,
|
||||
set_live_shape
|
||||
),
|
||||
|
|
@ -1006,21 +1008,12 @@ fn expand_shape(s: &mut Session, _: &Value) -> Result<Value> {
|
|||
ok()
|
||||
}
|
||||
|
||||
/// The `corners` of `object.setLiveShape`: a mask of corner indices 0–3.
|
||||
fn corners_param(p: &Value) -> Result<Option<[bool; 4]>> {
|
||||
/// The `corners` of `object.setLiveShape`: anchor indices of a path's uncut outline.
|
||||
fn corners_param(p: &Value) -> Result<Option<BTreeSet<usize>>> {
|
||||
let Some(v) = p.get("corners").filter(|v| !v.is_null()) else { return Ok(None) };
|
||||
let err = || {
|
||||
bad(
|
||||
"object.setLiveShape",
|
||||
format!("`corners` must list corner indices 0–3 (0 top-left, 1 top-right, 2 bottom-right, 3 bottom-left), not {v}"),
|
||||
)
|
||||
};
|
||||
let mut mask = [false; 4];
|
||||
for k in v.as_array().ok_or_else(err)? {
|
||||
let slot = k.as_u64().and_then(|k| mask.get_mut(usize::try_from(k).ok()?)).ok_or_else(err)?;
|
||||
*slot = true;
|
||||
}
|
||||
Ok(Some(mask))
|
||||
let err = || bad("object.setLiveShape", format!("`corners` must list anchor indices (0, 1, 2…), not {v}"));
|
||||
let list = v.as_array().ok_or_else(err)?;
|
||||
list.iter().map(|k| k.as_u64().and_then(|k| usize::try_from(k).ok()).ok_or_else(err)).collect::<Result<_>>().map(Some)
|
||||
}
|
||||
|
||||
fn set_live_shape(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
|
|
@ -1035,39 +1028,37 @@ fn set_live_shape(s: &mut Session, p: &Value) -> Result<Value> {
|
|||
})
|
||||
.transpose()?;
|
||||
let radius = p.get("radius").and_then(Value::as_f64);
|
||||
let sides = p.get("sides").and_then(Value::as_u64);
|
||||
s.edit("Live Shape", |d, sel| {
|
||||
for id in &ids {
|
||||
let Some(NodeKind::Path { path, live: Some(live), .. }) = d.node_mut(*id).map(|n| &mut n.kind) else { continue };
|
||||
// Radii are document lengths and corners circular, also on a rectangle from a file
|
||||
// that kept an uneven scale in its transform (#442).
|
||||
live.fold_scale();
|
||||
let partial = sel.anchors.get_mut(id);
|
||||
let picked = corners.unwrap_or_else(|| live.picked_corners(partial.as_deref()));
|
||||
let (layout, selected) = (live.anchor_corners(), partial.as_deref().map(|a| live.corners_of(a)));
|
||||
match live {
|
||||
vectorcraft_doc::LiveShape::Rectangle { radii, kinds, .. } => {
|
||||
for ((_, r), k) in picked.iter().zip(radii.iter_mut()).zip(kinds.iter_mut()).filter(|((on, _), _)| **on) {
|
||||
if let Some(radius) = radius {
|
||||
*r = radius.max(0.0);
|
||||
}
|
||||
if let Some(kind) = kind {
|
||||
*k = kind;
|
||||
}
|
||||
}
|
||||
}
|
||||
vectorcraft_doc::LiveShape::Polygon { sides, .. } => {
|
||||
if let Some(n) = p.get("sides").and_then(Value::as_u64) {
|
||||
*sides = n.clamp(3, 1000) as u32;
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
let Some(NodeKind::Path { path, live, .. }) = d.node_mut(*id).map(|n| &mut n.kind) else { continue };
|
||||
if let (Some(l @ LiveShape::Polygon { .. }), Some(n)) = (live.as_mut(), sides) {
|
||||
l.set_sides(n);
|
||||
*path = l.to_path();
|
||||
}
|
||||
*path = live.to_path();
|
||||
if radius.is_none() && kind.is_none() {
|
||||
continue;
|
||||
}
|
||||
let partial = sel.anchors.get_mut(id);
|
||||
// The corners to edit, the Direct-Selected ones and the anchor layout before the edit.
|
||||
let Some(c) = LiveCorners::new(path, live.as_ref()) else { continue };
|
||||
let picked = match &corners {
|
||||
Some(k) if k.last().is_some_and(|k| *k >= c.base.anchor_count()) => {
|
||||
let n = c.base.anchor_count();
|
||||
let past: Vec<_> = k.range(n..).collect();
|
||||
return Err(bad("object.setLiveShape", format!("object {id} has anchors 0–{} for `corners`, not {past:?}", n.saturating_sub(1))));
|
||||
}
|
||||
Some(k) => k.clone(),
|
||||
None => c.picked(partial.as_deref()),
|
||||
};
|
||||
let (selected, layout) = (partial.as_deref().map(|a| c.corners_of(a)), c.sources().to_vec());
|
||||
set_corners(path, live, &picked, radius, kind);
|
||||
// Direct-Selected corners stay selected as they gain or lose anchors.
|
||||
if let (Some(anchors), Some(selected)) = (partial, selected)
|
||||
&& live.anchor_corners() != layout
|
||||
&& let Some(c) = LiveCorners::new(path, live.as_ref())
|
||||
&& c.sources() != layout
|
||||
{
|
||||
*anchors = live.corner_anchors(selected);
|
||||
*anchors = c.anchors_of(&selected);
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
|
|
|
|||
|
|
@ -1,10 +1,11 @@
|
|||
//! Live Corners on live rectangles: `object.setLiveShape` rounds the given corners, the
|
||||
//! Direct-Selected ones or all four, sets corner kinds, and keeps selected corners selected.
|
||||
//! Live Corners: `object.setLiveShape` rounds the given corners of a live rectangle, the
|
||||
//! Direct-Selected ones or all four, sets corner kinds, and keeps selected corners selected; and
|
||||
//! does the same on any path's corners: a star, a live polygon, a pen path (#511).
|
||||
|
||||
use std::collections::BTreeSet;
|
||||
|
||||
use serde_json::{Value, json};
|
||||
use vectorcraft_doc::{AnchorRef, LiveShape, NodeKind};
|
||||
use vectorcraft_doc::{AnchorRef, LiveCorners, LiveShape, NodeKind};
|
||||
use vectorcraft_geom::Affine;
|
||||
use vectorcraft_geom::shapes::CornerKind;
|
||||
|
||||
|
|
@ -150,3 +151,131 @@ fn corners_of_a_non_square_rectangle_are_alike_circles() {
|
|||
run(&mut s, json!({"radius": 8}));
|
||||
assert_spans(&s, id, [8.0; 4]);
|
||||
}
|
||||
|
||||
/// A selected five-pointed star at (200, 200) of radii 60 and 30: a plain path.
|
||||
fn star(s: &mut Session) -> NodeId {
|
||||
NodeId(s.execute("shape.star", &json!({"cx": 200, "cy": 200, "radius1": 60, "radius2": 30})).unwrap()["id"].as_u64().unwrap())
|
||||
}
|
||||
|
||||
fn node_path(s: &Session, id: NodeId) -> (vectorcraft_geom::PathData, Option<LiveShape>) {
|
||||
let NodeKind::Path { path, live, .. } = &s.doc().unwrap().doc.node(id).unwrap().kind else { panic!("not a path") };
|
||||
(path.clone(), live.clone())
|
||||
}
|
||||
|
||||
/// The radius and kind every corner of `id` shares, and how many corners it has.
|
||||
fn style(s: &Session, id: NodeId) -> (Option<f64>, Option<CornerKind>, usize) {
|
||||
let c = LiveCorners::of(s.doc().unwrap().doc.node(id).unwrap()).unwrap();
|
||||
let (r, k) = c.style(&c.all());
|
||||
(r, k, c.corners.len())
|
||||
}
|
||||
|
||||
/// The radius set on each of the first `N` corners of `id`.
|
||||
fn radii<const N: usize>(s: &Session, id: NodeId) -> [f64; N] {
|
||||
let c = LiveCorners::of(s.doc().unwrap().doc.node(id).unwrap()).unwrap();
|
||||
std::array::from_fn(|k| c.radius(k))
|
||||
}
|
||||
|
||||
/// #511: a star (a plain path) rounds all ten corners as one step, keeps them editable (a new
|
||||
/// radius cuts the outline again rather than the cut path), and is the plain star again at 0.
|
||||
#[test]
|
||||
fn a_star_rounds_its_corners_and_keeps_them_live() {
|
||||
let (mut s, _) = session();
|
||||
let id = star(&mut s);
|
||||
let (sharp, _) = node_path(&s, id);
|
||||
assert_eq!(style(&s, id), (Some(0.0), Some(CornerKind::Round), 10));
|
||||
let undo = s.doc().unwrap().history.undo.len();
|
||||
run(&mut s, json!({"radius": 4}));
|
||||
assert_eq!(s.doc().unwrap().history.undo.len(), undo + 1);
|
||||
let (path, live) = node_path(&s, id);
|
||||
assert_eq!(path.anchor_count(), 20);
|
||||
assert!(matches!(&live, Some(LiveShape::Path { base, .. }) if *base == sharp), "{live:?}");
|
||||
assert_eq!(style(&s, id), (Some(4.0), Some(CornerKind::Round), 10));
|
||||
assert_eq!(s.doc().unwrap().doc.node(id).unwrap().kind_label(), "Path");
|
||||
run(&mut s, json!({"radius": 6, "kind": "chamfer"}));
|
||||
assert_eq!((node_path(&s, id).0.anchor_count(), style(&s, id)), (20, (Some(6.0), Some(CornerKind::Chamfer), 10)));
|
||||
run(&mut s, json!({"radius": 0, "kind": "round"}));
|
||||
assert_eq!(node_path(&s, id), (sharp, None));
|
||||
s.execute("edit.undo", &json!({})).unwrap();
|
||||
assert_eq!(style(&s, id).0, Some(6.0));
|
||||
}
|
||||
|
||||
/// Each corner stops at its own limit: its cut reaches halfway along its shorter side, so a
|
||||
/// star's neighbouring corners meet without overlapping.
|
||||
#[test]
|
||||
fn star_corners_stop_at_their_own_limit() {
|
||||
let (mut s, _) = session();
|
||||
let id = star(&mut s);
|
||||
run(&mut s, json!({"radius": 1000}));
|
||||
let (path, live) = node_path(&s, id);
|
||||
let Some(LiveShape::Path { base, .. }) = live else { panic!("live corners") };
|
||||
// Every cut ends at the middle of a side: each side's two cuts meet there.
|
||||
let sp = &base.subpaths[0];
|
||||
for (i, a) in sp.anchors.iter().enumerate() {
|
||||
let mid = a.p.midpoint(sp.anchors[(i + 1) % 10].p);
|
||||
assert!(path.anchors().any(|(_, _, b)| b.p.distance(mid) < 1e-9), "a cut ends at {mid:?}");
|
||||
}
|
||||
assert_eq!(style(&s, id).0, Some(1000.0), "the radius set is kept; it draws as large as fits");
|
||||
}
|
||||
|
||||
/// #511: Direct Selection picks one of the star's anchors: that corner alone rounds, and both of
|
||||
/// its new anchors stay selected.
|
||||
#[test]
|
||||
fn a_direct_selected_star_anchor_rounds_its_corner_alone() {
|
||||
let (mut s, _) = session();
|
||||
let id = star(&mut s);
|
||||
s.execute("select.anchors", &json!({"id": id.0, "anchors": [[0, 0]], "mode": "set"})).unwrap();
|
||||
run(&mut s, json!({"radius": 5}));
|
||||
assert_eq!(node_path(&s, id).0.anchor_count(), 11);
|
||||
// The top tip's cut ends the path and starts it.
|
||||
assert_eq!(selected_anchors(&s, id), Some(anchors(&[0, 10])));
|
||||
assert_eq!(radii::<2>(&s, id), [5.0, 0.0]);
|
||||
// Explicit corners, as MCP and the widgets give them.
|
||||
run(&mut s, json!({"id": id.0, "corners": [1, 3], "radius": 2}));
|
||||
assert_eq!(radii::<4>(&s, id), [5.0, 2.0, 0.0, 2.0]);
|
||||
// Past the outline's last anchor is an error, and nothing changes.
|
||||
assert!(s.execute("object.setLiveShape", &json!({"id": id.0, "corners": [10], "radius": 1})).is_err());
|
||||
assert_eq!(node_path(&s, id).0.anchor_count(), 13);
|
||||
}
|
||||
|
||||
/// A live polygon stays live with cut corners, which keep their radius as its sides change and
|
||||
/// stay circular when it is scaled unevenly (the radius scales by the mean scale).
|
||||
#[test]
|
||||
fn a_polygon_keeps_its_corners_through_sides_and_scales() {
|
||||
let (mut s, _) = session();
|
||||
let id = NodeId(s.execute("shape.polygon", &json!({"cx": 200, "cy": 200, "radius": 80, "sides": 6})).unwrap()["id"].as_u64().unwrap());
|
||||
run(&mut s, json!({"radius": 10}));
|
||||
let (path, live) = node_path(&s, id);
|
||||
assert_eq!(path.anchor_count(), 12);
|
||||
assert!(matches!(live, Some(LiveShape::Polygon { sides: 6, .. })));
|
||||
run(&mut s, json!({"sides": 8}));
|
||||
assert_eq!((node_path(&s, id).0.anchor_count(), style(&s, id)), (16, (Some(10.0), Some(CornerKind::Round), 8)));
|
||||
s.execute("object.scale", &json!({"sx": 400, "sy": 100, "corners": true})).unwrap();
|
||||
assert!(matches!(node_path(&s, id).1, Some(LiveShape::Polygon { .. })));
|
||||
assert!((style(&s, id).0.unwrap() - 20.0).abs() < 1e-9);
|
||||
// Every cut is a circle of that radius: its ends are as far from its centre.
|
||||
let path = node_path(&s, id).0;
|
||||
let c = LiveCorners::of(s.doc().unwrap().doc.node(id).unwrap()).unwrap();
|
||||
for k in &c.corners {
|
||||
let centre = k.on_bisector(20.0 / k.sin());
|
||||
let ends = path.anchors().filter(|(_, _, a)| (a.p.distance(centre) - 20.0).abs() < 1e-6).count();
|
||||
assert_eq!(ends, 2, "corner {} is circular", k.index);
|
||||
}
|
||||
}
|
||||
|
||||
/// #511: a pen path's corners round; its ends don't. An ellipse has no corners to round.
|
||||
#[test]
|
||||
fn a_pen_path_rounds_its_corners_but_not_its_ends() {
|
||||
let (mut s, _) = session();
|
||||
let pen = json!({"anchors": [{"x": 10, "y": 200}, {"x": 110, "y": 100}, {"x": 210, "y": 200}, {"x": 310, "y": 100}]});
|
||||
let id = NodeId(s.execute("path.create", &pen).unwrap()["id"].as_u64().unwrap());
|
||||
s.execute("select.set", &json!({"ids": [id.0]})).unwrap();
|
||||
run(&mut s, json!({"radius": 8}));
|
||||
let path = node_path(&s, id).0;
|
||||
assert_eq!(path.anchor_count(), 6);
|
||||
let sp = &path.subpaths[0];
|
||||
assert_eq!((sp.anchors[0].p.x, sp.anchors[5].p.x), (10.0, 310.0), "the ends stay");
|
||||
let e = NodeId(s.execute("shape.ellipse", &json!({"x": 0, "y": 0, "width": 50, "height": 30})).unwrap()["id"].as_u64().unwrap());
|
||||
let before = node_path(&s, e);
|
||||
run(&mut s, json!({"id": e.0, "radius": 8}));
|
||||
assert_eq!(node_path(&s, e), before);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -0,0 +1,283 @@
|
|||
//! Live Corners on any path: the anchors where two straight sides meet at an angle, and the path
|
||||
//! with those corners cut round, inverted round or chamfered. Rectangles cut theirs the same way.
|
||||
|
||||
use kurbo::{Point, Vec2};
|
||||
|
||||
use crate::path::{Anchor, AnchorKind, PathData, SubPath};
|
||||
use crate::shapes::{CornerKind, KAPPA};
|
||||
|
||||
/// Lengths and radii at or below this are none at all.
|
||||
const EPS: f64 = 1e-9;
|
||||
/// Sides closer than this to straight on (or folded back), as the sine of their angle, make no corner.
|
||||
const MIN_SINE: f64 = 1e-6;
|
||||
|
||||
/// A corner Live Corners can cut: an anchor without handles between two straight sides that
|
||||
/// meet at an angle.
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub struct Corner {
|
||||
/// The anchor's index in its path, counting the anchors of every subpath in order.
|
||||
pub index: usize,
|
||||
/// Where the sides meet.
|
||||
pub at: Point,
|
||||
/// Unit directions along the sides: towards the previous anchor, then towards the next one.
|
||||
pub u: Vec2,
|
||||
pub v: Vec2,
|
||||
/// The sides' lengths, in the same order.
|
||||
pub lu: f64,
|
||||
pub lv: f64,
|
||||
}
|
||||
|
||||
impl Corner {
|
||||
/// The corner of anchor `i` of `sp`, whose index in the path is `index`; `None` when the
|
||||
/// anchor is an end of an open subpath, has handles or is smooth, when a side curves or has
|
||||
/// no length, or when the sides run straight on.
|
||||
fn of(sp: &SubPath, i: usize, index: usize) -> Option<Self> {
|
||||
let n = sp.anchors.len();
|
||||
let (prev, next) = if sp.closed { ((i + n).checked_sub(1)? % n, (i + 1) % n) } else { (i.checked_sub(1)?, i + 1) };
|
||||
let (a, prev, next) = (sp.anchors.get(i)?, sp.anchors.get(prev)?, sp.anchors.get(next)?);
|
||||
if a.kind == AnchorKind::Smooth || a.has_in() || a.has_out() || prev.has_out() || next.has_in() {
|
||||
return None;
|
||||
}
|
||||
let (du, dv) = (prev.p - a.p, next.p - a.p);
|
||||
let (lu, lv) = (du.hypot(), dv.hypot());
|
||||
if !(lu > EPS && lv > EPS && lu.is_finite() && lv.is_finite()) {
|
||||
return None;
|
||||
}
|
||||
let c = Self { index, at: a.p, u: du / lu, v: dv / lv, lu, lv };
|
||||
(c.sin() > MIN_SINE).then_some(c)
|
||||
}
|
||||
|
||||
/// The cosine of the angle between the sides.
|
||||
pub fn cos(&self) -> f64 {
|
||||
self.u.dot(self.v)
|
||||
}
|
||||
|
||||
/// The sine of the angle between the sides.
|
||||
pub fn sin(&self) -> f64 {
|
||||
self.u.cross(self.v).abs()
|
||||
}
|
||||
|
||||
/// The angle between the sides, in degrees (90 at a rectangle's corners).
|
||||
pub fn angle_deg(&self) -> f64 {
|
||||
self.sin().atan2(self.cos()).to_degrees()
|
||||
}
|
||||
|
||||
/// How far from the corner a round cut of radius `r` meets each side: r / tan(angle / 2).
|
||||
pub fn setback(&self, r: f64) -> f64 {
|
||||
r * (1.0 + self.cos()) / self.sin()
|
||||
}
|
||||
|
||||
/// The largest radius the corner draws: its cut then reaches halfway along the shorter side,
|
||||
/// so neighbouring corners at their largest meet without overlapping (half the shorter side
|
||||
/// at a rectangle's corners).
|
||||
pub fn max_radius(&self) -> f64 {
|
||||
self.lu.min(self.lv) / 2.0 * self.sin() / (1.0 + self.cos())
|
||||
}
|
||||
|
||||
/// The radius the corner is drawn with: `radius`, no larger than [`Corner::max_radius`], 0 when
|
||||
/// negative or not a number.
|
||||
pub fn fitted(&self, radius: f64) -> f64 {
|
||||
radius.max(0.0).min(self.max_radius())
|
||||
}
|
||||
|
||||
/// The point `k` along the bisector, measured in (u + v): the centre of a round cut of radius
|
||||
/// `r` is at `k = r / sin`.
|
||||
pub fn on_bisector(&self, k: f64) -> Point {
|
||||
self.at + (self.u + self.v) * k
|
||||
}
|
||||
|
||||
/// How much the radius grows when the centre of the round cut moves by `d`: `d`'s part along
|
||||
/// the bisector, in radius units.
|
||||
pub fn radius_change(&self, d: Vec2) -> f64 {
|
||||
d.dot(self.u + self.v) * self.sin() / (2.0 + 2.0 * self.cos())
|
||||
}
|
||||
|
||||
/// The two anchors replacing the corner when cut with `radius` (> 0, fitted): where the cut
|
||||
/// meets the arriving side, then the leaving one.
|
||||
fn cut(&self, radius: f64, kind: CornerKind) -> [Anchor; 2] {
|
||||
let t = self.setback(radius);
|
||||
let (start, end) = (self.at + self.u * t, self.at + self.v * t);
|
||||
let (h_out, h_in) = match kind {
|
||||
// An arc of `radius` tangent to both sides, turning by 180° less the angle.
|
||||
CornerKind::Round => {
|
||||
let h = radius * arc_handle(-self.cos());
|
||||
(start - self.u * h, end - self.v * h)
|
||||
}
|
||||
// An arc centred on the corner through both ends, spanning the angle.
|
||||
CornerKind::InvertedRound => {
|
||||
let h = t * arc_handle(self.cos());
|
||||
(start + square_to(self.u, self.v) * h, end + square_to(self.v, self.u) * h)
|
||||
}
|
||||
CornerKind::Chamfer => (start, end),
|
||||
};
|
||||
[Anchor { p: start, h_in: start, h_out, kind: AnchorKind::Corner }, Anchor { p: end, h_in, h_out: end, kind: AnchorKind::Corner }]
|
||||
}
|
||||
}
|
||||
|
||||
/// The unit direction square to unit `a`, on `b`'s side.
|
||||
fn square_to(a: Vec2, b: Vec2) -> Vec2 {
|
||||
let w = b - a * a.dot(b);
|
||||
w / w.hypot()
|
||||
}
|
||||
|
||||
/// The handle length, per unit of radius, of a cubic drawing a circular arc that spans an angle
|
||||
/// whose cosine is `cos`: 4/3 · tan(angle / 4) ([`KAPPA`] for a quarter circle).
|
||||
fn arc_handle(cos: f64) -> f64 {
|
||||
if cos.abs() < 1e-12 {
|
||||
return KAPPA;
|
||||
}
|
||||
let (sin_half, cos_half) = (((1.0 - cos) / 2.0).max(0.0).sqrt(), ((1.0 + cos) / 2.0).max(0.0).sqrt());
|
||||
4.0 / 3.0 * sin_half / (1.0 + cos_half)
|
||||
}
|
||||
|
||||
/// The corners of `path` Live Corners can cut, in anchor order.
|
||||
pub fn path_corners(path: &PathData) -> Vec<Corner> {
|
||||
let mut out = vec![];
|
||||
let mut first = 0;
|
||||
for sp in &path.subpaths {
|
||||
out.extend((0..sp.anchors.len()).filter_map(|i| Corner::of(sp, i, first + i)));
|
||||
first += sp.anchors.len();
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// `path` with each of its corners ([`path_corners`]) cut by the radius in `radii` and the kind in
|
||||
/// `kinds` at its anchor index (missing: 0 and round), each radius no larger than fits
|
||||
/// ([`Corner::fitted`]). A cut corner becomes two anchors; a closed subpath whose first corner
|
||||
/// is cut starts where that cut ends, so the cut closes it. Also returns, per subpath, the
|
||||
/// anchor index in `path` each anchor comes from.
|
||||
pub fn cut_corners(path: &PathData, radii: &[f64], kinds: &[CornerKind]) -> (PathData, Vec<Vec<usize>>) {
|
||||
let corners = path_corners(path);
|
||||
let mut corners = corners.iter().peekable();
|
||||
let (mut subpaths, mut sources) = (Vec::with_capacity(path.subpaths.len()), Vec::with_capacity(path.subpaths.len()));
|
||||
let mut first = 0;
|
||||
for sp in &path.subpaths {
|
||||
let (mut anchors, mut from) = (Vec::with_capacity(sp.anchors.len()), Vec::with_capacity(sp.anchors.len()));
|
||||
let mut closing = None;
|
||||
for (i, a) in sp.anchors.iter().enumerate() {
|
||||
let index = first + i;
|
||||
let corner = corners.next_if(|c| c.index == index);
|
||||
let radius = corner.map_or(0.0, |c| c.fitted(radii.get(index).copied().unwrap_or(0.0)));
|
||||
match corner {
|
||||
Some(c) if radius > EPS => {
|
||||
let [start, end] = c.cut(radius, kinds.get(index).copied().unwrap_or_default());
|
||||
if i == 0 && sp.closed {
|
||||
closing = Some(start);
|
||||
} else {
|
||||
anchors.push(start);
|
||||
from.push(index);
|
||||
}
|
||||
anchors.push(end);
|
||||
from.push(index);
|
||||
}
|
||||
_ => {
|
||||
anchors.push(*a);
|
||||
from.push(index);
|
||||
}
|
||||
}
|
||||
}
|
||||
if let Some(a) = closing {
|
||||
anchors.push(a);
|
||||
from.push(first);
|
||||
}
|
||||
first += sp.anchors.len();
|
||||
subpaths.push(SubPath::new(anchors, sp.closed));
|
||||
sources.push(from);
|
||||
}
|
||||
(PathData::new(subpaths), sources)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::shapes;
|
||||
use kurbo::Rect;
|
||||
|
||||
fn near(a: Point, b: Point) -> bool {
|
||||
a.distance(b) < 1e-9
|
||||
}
|
||||
|
||||
/// A five-pointed star's tips are acute corners, its inner corners obtuse: all ten cut, each
|
||||
/// a circle of the radius tangent to both sides.
|
||||
#[test]
|
||||
fn a_star_has_ten_corners_cut_as_circles() {
|
||||
let star = shapes::star(Point::new(100.0, 100.0), 50.0, 25.0, 5, 0.0);
|
||||
let corners = path_corners(&star);
|
||||
assert_eq!(corners.len(), 10);
|
||||
let angles: Vec<_> = corners.iter().map(|c| c.angle_deg()).collect();
|
||||
assert!(angles.iter().step_by(2).all(|a| *a < 90.0), "tips are acute: {angles:?}");
|
||||
assert!(angles.iter().skip(1).step_by(2).all(|a| *a > 90.0), "inner corners are obtuse: {angles:?}");
|
||||
let (cut, from) = cut_corners(&star, &[4.0; 10], &[]);
|
||||
assert_eq!(cut.anchor_count(), 20);
|
||||
assert_eq!(from, [vec![0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 0]]);
|
||||
for c in &corners {
|
||||
// Both ends of the cut lie `setback` along the sides, as far from the arc's centre as
|
||||
// the radius, and that centre is `radius` from either side.
|
||||
let t = c.setback(4.0);
|
||||
let o = c.on_bisector(4.0 / c.sin());
|
||||
for p in [c.at + c.u * t, c.at + c.v * t] {
|
||||
assert!((p.distance(o) - 4.0).abs() < 1e-9);
|
||||
assert!(cut.anchors().any(|(_, _, a)| near(a.p, p)), "{p:?} is an anchor");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn radii_stop_at_half_the_shorter_side_per_corner() {
|
||||
let tri = PathData::single(SubPath::polyline(&[Point::new(0.0, 0.0), Point::new(100.0, 0.0), Point::new(0.0, 40.0)], true));
|
||||
let corners = path_corners(&tri);
|
||||
assert_eq!(corners.len(), 3);
|
||||
for c in &corners {
|
||||
let max = c.max_radius();
|
||||
assert!((c.setback(max) - c.lu.min(c.lv) / 2.0).abs() < 1e-9);
|
||||
assert_eq!(c.fitted(1e6), max);
|
||||
assert_eq!(c.fitted(-3.0), 0.0);
|
||||
assert_eq!(c.fitted(f64::NAN), 0.0);
|
||||
}
|
||||
// The right angle at (0, 0) takes up to 20, half its shorter side.
|
||||
assert!((corners[0].max_radius() - 20.0).abs() < 1e-9);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ends_curves_smooth_and_straight_anchors_are_no_corners() {
|
||||
// An open zig-zag: its ends aren't corners, nor is the anchor its sides run straight on through.
|
||||
let open = PathData::single(SubPath::polyline(
|
||||
&[Point::new(0.0, 0.0), Point::new(50.0, 0.0), Point::new(100.0, 0.0), Point::new(100.0, 50.0), Point::new(150.0, 80.0)],
|
||||
false,
|
||||
));
|
||||
assert_eq!(path_corners(&open).iter().map(|c| c.index).collect::<Vec<_>>(), [2, 3]);
|
||||
// A curve on either side, or handles on the anchor, leave it alone.
|
||||
let mut sp = SubPath::polyline(&[Point::new(0.0, 0.0), Point::new(100.0, 0.0), Point::new(100.0, 100.0), Point::new(0.0, 100.0)], true);
|
||||
sp.anchors[1].h_out = Point::new(110.0, 10.0);
|
||||
let p = PathData::single(sp);
|
||||
assert_eq!(path_corners(&p).iter().map(|c| c.index).collect::<Vec<_>>(), [0, 3]);
|
||||
assert!(path_corners(&shapes::ellipse(Rect::new(0.0, 0.0, 10.0, 10.0))).is_empty());
|
||||
// A second subpath counts on from the first one's anchors.
|
||||
let two = PathData::new(vec![
|
||||
SubPath::polyline(&[Point::new(0.0, 0.0), Point::new(10.0, 0.0), Point::new(0.0, 10.0)], true),
|
||||
SubPath::polyline(&[Point::new(50.0, 0.0), Point::new(60.0, 0.0), Point::new(50.0, 10.0)], true),
|
||||
]);
|
||||
let (cut, from) = cut_corners(&two, &[0.0, 0.0, 0.0, 1.0], &[]);
|
||||
assert_eq!(from, [vec![0, 1, 2], vec![3, 4, 5, 3]]);
|
||||
assert_eq!(cut.anchor_count(), 7);
|
||||
}
|
||||
|
||||
/// Inverted round and chamfer cuts end where the round one does, at any angle.
|
||||
#[test]
|
||||
fn kinds_share_their_ends() {
|
||||
let star = shapes::star(Point::new(0.0, 0.0), 50.0, 25.0, 5, 0.0);
|
||||
let ends = |k: CornerKind| -> Vec<Point> { cut_corners(&star, &[3.0; 10], &[k; 10]).0.anchors().map(|(_, _, a)| a.p).collect() };
|
||||
let round = ends(CornerKind::Round);
|
||||
assert_eq!(ends(CornerKind::InvertedRound), round);
|
||||
assert_eq!(ends(CornerKind::Chamfer), round);
|
||||
// The inverted arc stays on the circle about the corner.
|
||||
let c = path_corners(&star)[0];
|
||||
let [s, e] = c.cut(3.0, CornerKind::InvertedRound);
|
||||
let bez = kurbo::CubicBez::new(s.p, s.h_out, e.h_in, e.p);
|
||||
let r = c.setback(3.0);
|
||||
for t in [0.25, 0.5, 0.75] {
|
||||
use kurbo::ParamCurve;
|
||||
assert!((bez.eval(t).distance(c.at) - r).abs() < r * 1e-3);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -9,6 +9,7 @@
|
|||
|
||||
pub mod arc;
|
||||
pub mod bez;
|
||||
pub mod corners;
|
||||
pub mod hit;
|
||||
pub mod path;
|
||||
pub mod projective;
|
||||
|
|
|
|||
|
|
@ -62,52 +62,10 @@ pub fn fitted_corner_radius(w: f64, h: f64, radius: f64) -> f64 {
|
|||
/// Rectangle whose corners (top-left, top-right, bottom-right, bottom-left, y down) each have
|
||||
/// their own radius and kind, every radius clamped to half the shorter side. A corner without a
|
||||
/// radius is one anchor, the others two (where the cut meets each side). Clockwise from the
|
||||
/// top-left corner, its anchor on the top side first.
|
||||
/// top-left corner, its anchor on the top side first. Cut as any path's corners are
|
||||
/// ([`crate::corners::cut_corners`]).
|
||||
pub fn rectangle_with_corners(r: Rect, radii: [f64; 4], kinds: [CornerKind; 4]) -> PathData {
|
||||
PathData::single(SubPath::new(corner_anchors(r, radii, kinds).into_iter().map(|(_, a)| a).collect(), true))
|
||||
}
|
||||
|
||||
/// The corner (index into `radii`) of each anchor of [`rectangle_with_corners`].
|
||||
pub fn rectangle_anchor_corners(r: Rect, radii: [f64; 4]) -> Vec<usize> {
|
||||
corner_anchors(r, radii, [CornerKind::Round; 4]).into_iter().map(|(k, _)| k).collect()
|
||||
}
|
||||
|
||||
/// The anchors of [`rectangle_with_corners`], each with its corner.
|
||||
fn corner_anchors(r: Rect, radii: [f64; 4], kinds: [CornerKind; 4]) -> Vec<(usize, Anchor)> {
|
||||
let r = r.abs();
|
||||
// Each corner, with the directions of the side arriving at it and of the side leaving it.
|
||||
let corners = [
|
||||
(Point::new(r.x0, r.y0), Vec2::new(0.0, -1.0), Vec2::new(1.0, 0.0)),
|
||||
(Point::new(r.x1, r.y0), Vec2::new(1.0, 0.0), Vec2::new(0.0, 1.0)),
|
||||
(Point::new(r.x1, r.y1), Vec2::new(0.0, 1.0), Vec2::new(-1.0, 0.0)),
|
||||
(Point::new(r.x0, r.y1), Vec2::new(-1.0, 0.0), Vec2::new(0.0, -1.0)),
|
||||
];
|
||||
let mut out = Vec::with_capacity(8);
|
||||
let mut top_left_start = None;
|
||||
for (k, ((c, din, dout), (rad, kind))) in corners.into_iter().zip(radii.into_iter().zip(kinds)).enumerate() {
|
||||
let rad = fitted_corner_radius(r.width(), r.height(), rad);
|
||||
if rad <= 1e-9 {
|
||||
out.push((k, Anchor::corner(c)));
|
||||
continue;
|
||||
}
|
||||
// The cut runs from `start` on the arriving side to `end` on the leaving one.
|
||||
let (start, end, h) = (c - din * rad, c + dout * rad, rad * KAPPA);
|
||||
let (h_out, h_in) = match kind {
|
||||
CornerKind::Round => (start + din * h, end - dout * h),
|
||||
CornerKind::InvertedRound => (start + dout * h, end - din * h),
|
||||
CornerKind::Chamfer => (start, end),
|
||||
};
|
||||
let start = Anchor { p: start, h_in: start, h_out, kind: AnchorKind::Corner };
|
||||
let end = Anchor { p: end, h_in, h_out: end, kind: AnchorKind::Corner };
|
||||
if k == 0 {
|
||||
top_left_start = Some(start);
|
||||
} else {
|
||||
out.push((k, start));
|
||||
}
|
||||
out.push((k, end));
|
||||
}
|
||||
out.extend(top_left_start.map(|a| (0, a)));
|
||||
out
|
||||
crate::corners::cut_corners(&rectangle(r), &radii, &kinds).0
|
||||
}
|
||||
|
||||
/// Ellipse inscribed in `r` with 4 smooth anchors (left, top, right, bottom).
|
||||
|
|
@ -244,6 +202,11 @@ pub fn polar_grid(r: Rect, concentric: u32, radial: u32) -> Vec<PathData> {
|
|||
mod tests {
|
||||
use super::*;
|
||||
|
||||
/// The corner (index into `radii`) of each anchor of [`rectangle_with_corners`].
|
||||
fn corner_sources(r: Rect, radii: [f64; 4]) -> Vec<usize> {
|
||||
crate::corners::cut_corners(&rectangle(r), &radii, &[]).1.concat()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rect_is_4_corners_clockwise() {
|
||||
let p = rectangle(Rect::new(0.0, 0.0, 100.0, 50.0));
|
||||
|
|
@ -293,7 +256,7 @@ mod tests {
|
|||
a((x0, y0 + rad), (x0, y0 + rad), (x0, y0 + rad - k)),
|
||||
];
|
||||
assert_eq!(rounded_rectangle(r, rad).subpaths[0].anchors, want);
|
||||
assert_eq!(rectangle_anchor_corners(r, [rad; 4]), [0, 1, 1, 2, 2, 3, 3, 0]);
|
||||
assert_eq!(corner_sources(r, [rad; 4]), [0, 1, 1, 2, 2, 3, 3, 0]);
|
||||
assert_eq!(rounded_rectangle(r, 0.0), rectangle(r));
|
||||
}
|
||||
|
||||
|
|
@ -305,11 +268,11 @@ mod tests {
|
|||
let p = rectangle_with_corners(r, radii, [CornerKind::Round; 4]);
|
||||
let pts: Vec<Point> = p.subpaths[0].anchors.iter().map(|a| a.p).collect();
|
||||
assert_eq!(pts, [Point::new(0.0, 0.0), Point::new(90.0, 0.0), Point::new(100.0, 10.0), Point::new(100.0, 60.0), Point::new(0.0, 60.0)]);
|
||||
assert_eq!(rectangle_anchor_corners(r, radii), [0, 1, 1, 2, 3]);
|
||||
assert_eq!(corner_sources(r, radii), [0, 1, 1, 2, 3]);
|
||||
let quarter = PI * 25.0;
|
||||
assert!((p.subpaths[0].area() - (6000.0 - 100.0 + quarter)).abs() < 0.1, "a quarter circle off one corner");
|
||||
// The top-left corner rounded: its top-side anchor first, its left-side one last.
|
||||
assert_eq!(rectangle_anchor_corners(r, [10.0, 0.0, 0.0, 200.0]), [0, 1, 2, 3, 3, 0]);
|
||||
assert_eq!(corner_sources(r, [10.0, 0.0, 0.0, 200.0]), [0, 1, 2, 3, 3, 0]);
|
||||
// Inverted round cuts a quarter circle out; a chamfer cuts a triangle.
|
||||
let inverted = rectangle_with_corners(r, radii, [CornerKind::InvertedRound; 4]);
|
||||
assert!((inverted.subpaths[0].area() - (6000.0 - quarter)).abs() < 0.1);
|
||||
|
|
|
|||
|
|
@ -621,7 +621,9 @@ fn corners(path: &PathData, live: Option<&LiveShape>) -> Option<Corners> {
|
|||
let sweep = (pie.1 - pie.0).abs();
|
||||
(sweep < 1e-6 || (sweep - 360.0).abs() < 1e-6).then_some(Corners::Ellipse)
|
||||
}
|
||||
Some(LiveShape::Rectangle { .. } | LiveShape::Ellipse { .. } | LiveShape::Polygon { .. } | LiveShape::Line { .. }) => None,
|
||||
Some(
|
||||
LiveShape::Rectangle { .. } | LiveShape::Ellipse { .. } | LiveShape::Polygon { .. } | LiveShape::Line { .. } | LiveShape::Path { .. },
|
||||
) => None,
|
||||
None => is_upright_rectangle(path).then_some(Corners::Square),
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,187 +1,231 @@
|
|||
//! Live Corners: the widgets inside the corners of a selected live rectangle. Dragging one rounds
|
||||
//! (or sharpens) the corners whose widgets show together: all four when the whole shape is
|
||||
//! selected, those with a selected anchor when Direct Selection picked some. Alt-clicking a widget
|
||||
//! cycles their corner kind (round, inverted round, chamfer); double-clicking one opens the
|
||||
//! Corners dialog. The Selection and Direct Selection tools share this, and the canvas draws the
|
||||
//! widgets from the same geometry.
|
||||
//! Live Corners: the widgets inside the corners of a selected path. The Selection tool shows them
|
||||
//! on a live rectangle or polygon, Direct Selection on any path (a star, a pen path) at each corner
|
||||
//! anchor: one without handles between two straight sides. Dragging one rounds (or sharpens) the
|
||||
//! corners whose widgets show together: every corner when the whole path is selected, those with a
|
||||
//! selected anchor when Direct Selection picked some. Alt-clicking a widget cycles their corner
|
||||
//! kind (round, inverted round, chamfer); double-clicking one opens the Corners dialog. The
|
||||
//! Selection and Direct Selection tools share this, and the canvas draws the widgets from the same
|
||||
//! geometry.
|
||||
|
||||
use serde_json::{Map, Value, json};
|
||||
use vectorcraft_doc::{Document, LiveShape, NodeId, NodeKind, Selection};
|
||||
use vectorcraft_geom::shapes::{self, CornerKind};
|
||||
use vectorcraft_geom::{Affine, BezPath, Point, Rect, Vec2};
|
||||
use vectorcraft_doc::{Document, LiveCorners, LiveShape, NodeId, NodeKind, Selection};
|
||||
use vectorcraft_geom::corners::{Corner, cut_corners};
|
||||
use vectorcraft_geom::shapes::CornerKind;
|
||||
use vectorcraft_geom::{Affine, BezPath, PathData, Point, Vec2};
|
||||
|
||||
use crate::{Action, Overlay, PointerEvent, ToolContext};
|
||||
|
||||
/// The dialog a double-click on a corner widget opens: `{id, corners}`.
|
||||
pub const DIALOG: &str = "corners";
|
||||
|
||||
/// Widgets sit at least this far inside their corner (screen px), further in once the radius is.
|
||||
/// Widgets sit at least this far inside their corner along each side of a right angle (screen px;
|
||||
/// √2 times it along the bisector, at any angle), further in once the radius is.
|
||||
const MIN_INSET_PX: f64 = 10.0;
|
||||
/// Shapes whose shorter side is smaller than this on screen (px) hide their widgets.
|
||||
/// Corners with a side shorter than this on screen (px) hide their widgets.
|
||||
const MIN_SIDE_PX: f64 = 3.0 * MIN_INSET_PX;
|
||||
/// Corners in radii order (top-left, top-right, bottom-right, bottom-left): position as factors
|
||||
/// of (w, h) and the inward diagonal.
|
||||
const CORNERS: [((f64, f64), (f64, f64)); 4] =
|
||||
[((0.0, 0.0), (1.0, 1.0)), ((1.0, 0.0), (-1.0, 1.0)), ((1.0, 1.0), (-1.0, -1.0)), ((0.0, 1.0), (1.0, -1.0))];
|
||||
|
||||
/// The corner widgets of a selection that is exactly one editable live rectangle.
|
||||
/// One corner's widget.
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
struct Widget {
|
||||
/// The corner, in the corners' own space.
|
||||
corner: Corner,
|
||||
/// The radius it is set to (document units) and its kind.
|
||||
radius: f64,
|
||||
kind: CornerKind,
|
||||
/// The angle between its sides in the document, in degrees.
|
||||
angle: f64,
|
||||
/// The widget's centre in the document.
|
||||
at: Point,
|
||||
}
|
||||
|
||||
/// The corner widgets of a selection that is exactly one editable path with corners.
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub struct CornerWidgets {
|
||||
pub id: NodeId,
|
||||
w: f64,
|
||||
h: f64,
|
||||
radii: [f64; 4],
|
||||
kinds: [CornerKind; 4],
|
||||
/// Maps the corners' space into the document (a live rectangle's own; else none).
|
||||
xf: Affine,
|
||||
/// Widget centres in document coordinates, in radii order.
|
||||
pub points: [Point; 4],
|
||||
/// The corners whose widgets show (and which a drag edits).
|
||||
pub shown: [bool; 4],
|
||||
/// The widgets that show (and which a drag edits), in anchor order.
|
||||
widgets: Vec<Widget>,
|
||||
/// Every corner of the path shows its widget.
|
||||
all: bool,
|
||||
}
|
||||
|
||||
impl CornerWidgets {
|
||||
/// The widgets at `zoom` (screen px per document point), if the selection has them.
|
||||
pub fn of(doc: &Document, selection: &Selection, zoom: f64) -> Option<Self> {
|
||||
/// The widgets at `zoom` (screen px per document point), if the selection has them: on any
|
||||
/// path with Direct Selection (`any_path`), on live rectangles and polygons with Selection.
|
||||
pub fn of(doc: &Document, selection: &Selection, zoom: f64, any_path: bool) -> Option<Self> {
|
||||
let [id] = selection.objects[..] else { return None };
|
||||
if !doc.is_editable(id) {
|
||||
return None;
|
||||
}
|
||||
let Some(NodeKind::Path { live: Some(live), .. }) = doc.node(id).map(|n| &n.kind) else { return None };
|
||||
// In document units, as `object.setLiveShape` edits them.
|
||||
let LiveShape::Rectangle { w, h, radii, kinds, xf } = live.folded() else { return None };
|
||||
// Screen pixels per shape unit along each side (the shape may be scaled or skewed).
|
||||
let c = xf.as_coeffs();
|
||||
let (px, py) = (Vec2::new(c[0], c[1]).hypot() * zoom, Vec2::new(c[2], c[3]).hypot() * zoom);
|
||||
if xf.determinant().abs() < 1e-12 || (w * px).min(h * py) < MIN_SIDE_PX {
|
||||
let NodeKind::Path { path, live, .. } = &doc.node(id)?.kind else { return None };
|
||||
if !any_path && !matches!(live, Some(LiveShape::Rectangle { .. } | LiveShape::Polygon { .. })) {
|
||||
return None;
|
||||
}
|
||||
// Each widget sits on its corner's diagonal, at the centre of the arc as drawn.
|
||||
let points = std::array::from_fn(|k| {
|
||||
let ((fx, fy), (sx, sy)) = CORNERS[k];
|
||||
let r = shapes::fitted_corner_radius(w, h, radii[k]);
|
||||
let ix = r.max(MIN_INSET_PX / px).min(w / 2.0);
|
||||
let iy = r.max(MIN_INSET_PX / py).min(h / 2.0);
|
||||
xf * Point::new(fx * w + sx * ix, fy * h + sy * iy)
|
||||
});
|
||||
Some(Self { id, w, h, radii, kinds, xf, points, shown: live.picked_corners(selection.partial(id)) })
|
||||
let lc = LiveCorners::new(path, live.as_ref())?;
|
||||
let det = lc.xf.determinant().abs();
|
||||
if det < 1e-12 {
|
||||
return None;
|
||||
}
|
||||
// Screen pixels per unit of the corners' space (a rectangle's may be skewed).
|
||||
let scale = zoom * det.sqrt();
|
||||
let picked = lc.picked(selection.partial(id));
|
||||
let widgets: Vec<_> = lc
|
||||
.corners
|
||||
.iter()
|
||||
.filter(|c| picked.contains(&c.index) && c.lu.min(c.lv) * scale >= MIN_SIDE_PX)
|
||||
.map(|c| {
|
||||
// On the bisector at the centre of the arc as drawn, at least the minimum inset
|
||||
// in and at most half the shorter side.
|
||||
let radius = lc.radius(c.index);
|
||||
let k = (c.fitted(radius) / c.sin()).max(MIN_INSET_PX / (scale * (1.0 + c.cos()).sqrt())).min(c.lu.min(c.lv) / 2.0);
|
||||
Widget { corner: *c, radius, kind: lc.kind(c.index), angle: angle_in(lc.xf, c), at: lc.xf * c.on_bisector(k) }
|
||||
})
|
||||
.collect();
|
||||
let all = widgets.len() == lc.corners.len();
|
||||
(!widgets.is_empty()).then_some(Self { id, xf: lc.xf, widgets, all })
|
||||
}
|
||||
|
||||
/// Selection & Anchor Display → Hide Corner Widget for angles greater than: the widgets of
|
||||
/// corners wider than `max` degrees (a skewed rectangle's obtuse ones) hide; none if all do.
|
||||
/// corners wider than `max` degrees (in the document) hide; none if all do.
|
||||
pub fn within_angle(mut self, max: f64) -> Option<Self> {
|
||||
// The angle between the shape's sides where they meet at the top-left corner; the
|
||||
// top-right and bottom-left corners are its supplement.
|
||||
let c = self.xf.as_coeffs();
|
||||
let (u, v) = (Vec2::new(c[0], c[1]), Vec2::new(c[2], c[3]));
|
||||
let a = u.cross(v).abs().atan2(u.dot(v)).to_degrees();
|
||||
for (k, shown) in self.shown.iter_mut().enumerate() {
|
||||
let angle = if k % 2 == 0 { a } else { 180.0 - a };
|
||||
*shown &= angle <= max + 1e-9;
|
||||
}
|
||||
self.shown.contains(&true).then_some(self)
|
||||
let n = self.widgets.len();
|
||||
self.widgets.retain(|w| w.angle <= max + 1e-9);
|
||||
self.all &= self.widgets.len() == n;
|
||||
(!self.widgets.is_empty()).then_some(self)
|
||||
}
|
||||
|
||||
/// The widgets the active tool can drag (View → Show Corner Widget on).
|
||||
pub fn for_tool(cx: &ToolContext) -> Option<Self> {
|
||||
if !cx.corner_widgets {
|
||||
/// The widgets on show: [`Self::of`] with View → Show Corner Widget `on`, less those wider
|
||||
/// than `max_angle` ([`Self::within_angle`]).
|
||||
pub fn showing(doc: &Document, selection: &Selection, zoom: f64, any_path: bool, on: bool, max_angle: f64) -> Option<Self> {
|
||||
if !on {
|
||||
return None;
|
||||
}
|
||||
Self::of(cx.doc, cx.selection, cx.zoom)?.within_angle(cx.corner_widget_max_angle)
|
||||
Self::of(doc, selection, zoom, any_path)?.within_angle(max_angle)
|
||||
}
|
||||
|
||||
/// The widgets the active tool can drag (Direct Selection: `any_path`).
|
||||
pub fn for_tool(cx: &ToolContext, any_path: bool) -> Option<Self> {
|
||||
Self::showing(cx.doc, cx.selection, cx.zoom, any_path, cx.corner_widgets, cx.corner_widget_max_angle)
|
||||
}
|
||||
|
||||
/// The centres of the widgets that show.
|
||||
pub fn visible(&self) -> impl Iterator<Item = Point> + '_ {
|
||||
self.points.iter().zip(self.shown).filter(|(_, on)| *on).map(|(p, _)| *p)
|
||||
self.widgets.iter().map(|w| w.at)
|
||||
}
|
||||
|
||||
/// The indices of the shown corners.
|
||||
fn shown_indices(&self) -> Value {
|
||||
(0..4).filter(|k| self.shown[*k]).collect()
|
||||
/// The corners whose widgets show: anchor indices of the path's uncut outline.
|
||||
pub fn corners(&self) -> Vec<usize> {
|
||||
self.widgets.iter().map(|w| w.corner.index).collect()
|
||||
}
|
||||
|
||||
/// Index of the shown widget nearest to `p` within `tol` (document units).
|
||||
pub fn hit(&self, p: Point, tol: f64) -> Option<usize> {
|
||||
let d = |k: &usize| self.points[*k].distance(p);
|
||||
(0..4).filter(|k| self.shown[*k] && d(k) <= tol).min_by(|a, b| d(a).total_cmp(&d(b)))
|
||||
/// The widget nearest to `p` within `tol` (document units).
|
||||
fn hit(&self, p: Point, tol: f64) -> Option<usize> {
|
||||
let d = |k: &usize| self.widgets.get(*k).map_or(f64::INFINITY, |w| w.at.distance(p));
|
||||
(0..self.widgets.len()).filter(|k| d(k) <= tol).min_by(|a, b| d(a).total_cmp(&d(b)))
|
||||
}
|
||||
|
||||
/// `object.setLiveShape` params setting `key` on the shown corners (all four unless some are
|
||||
/// hidden, which `corners` then leaves out).
|
||||
/// `object.setLiveShape` params setting `key` on the shown corners (every corner unless some
|
||||
/// are hidden, which `corners` then leaves out).
|
||||
fn command(&self, key: &str, value: Value) -> Value {
|
||||
let mut p = Map::new();
|
||||
p.insert("id".into(), json!(self.id.0));
|
||||
p.insert(key.into(), value);
|
||||
if self.shown != [true; 4] {
|
||||
p.insert("corners".into(), self.shown_indices());
|
||||
if !self.all {
|
||||
p.insert("corners".into(), json!(self.corners()));
|
||||
}
|
||||
Value::Object(p)
|
||||
}
|
||||
}
|
||||
|
||||
/// Is `p` over a corner widget the active tool would drag?
|
||||
pub fn over_widget(cx: &ToolContext, p: Point) -> bool {
|
||||
CornerWidgets::for_tool(cx).and_then(|w| w.hit(p, cx.tol(5.0))).is_some()
|
||||
/// The angle between corner `c`'s sides once `xf` maps them into the document, in degrees.
|
||||
fn angle_in(xf: Affine, c: &Corner) -> f64 {
|
||||
let [a, b, cc, d, _, _] = xf.as_coeffs();
|
||||
let map = |v: Vec2| Vec2::new(a * v.x + cc * v.y, b * v.x + d * v.y);
|
||||
let (u, v) = (map(c.u), map(c.v));
|
||||
u.cross(v).abs().atan2(u.dot(v)).to_degrees()
|
||||
}
|
||||
|
||||
/// Is `p` over a corner widget the active tool would drag (Direct Selection: `any_path`)?
|
||||
pub fn over_widget(cx: &ToolContext, p: Point, any_path: bool) -> bool {
|
||||
CornerWidgets::for_tool(cx, any_path).and_then(|w| w.hit(p, cx.tol(5.0))).is_some()
|
||||
}
|
||||
|
||||
/// A double-click on a corner widget opens the Corners dialog for the shown corners.
|
||||
pub fn double_click(cx: &ToolContext, p: Point) -> Option<Action> {
|
||||
let w = CornerWidgets::for_tool(cx)?;
|
||||
pub fn double_click(cx: &ToolContext, p: Point, any_path: bool) -> Option<Action> {
|
||||
let w = CornerWidgets::for_tool(cx, any_path)?;
|
||||
w.hit(p, cx.tol(5.0))?;
|
||||
Some(Action::Dialog(DIALOG.into(), json!({ "id": w.id.0, "corners": w.shown_indices() })))
|
||||
Some(Action::Dialog(DIALOG.into(), json!({ "id": w.id.0, "corners": w.corners() })))
|
||||
}
|
||||
|
||||
/// Dragging a corner widget: the radius follows the pointer along the corner's diagonal. An
|
||||
/// Dragging a corner widget: the radius follows the pointer along the corner's bisector. An
|
||||
/// Alt-click (no drag) cycles the corner kind instead.
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct CornerDrag {
|
||||
widgets: CornerWidgets,
|
||||
corner: usize,
|
||||
/// The dragged widget (index into the shown ones).
|
||||
widget: usize,
|
||||
/// The path's uncut outline with its corners' radii and kinds (to outline the corners at
|
||||
/// their largest).
|
||||
base: PathData,
|
||||
radii: Vec<f64>,
|
||||
kinds: Vec<CornerKind>,
|
||||
start: Point,
|
||||
began: bool,
|
||||
alt: bool,
|
||||
radius: f64,
|
||||
/// The pointer went past fully round: the corners are at their largest radius.
|
||||
/// The pointer went past fully round: the dragged corner is at its largest radius.
|
||||
at_limit: bool,
|
||||
at: Point,
|
||||
}
|
||||
|
||||
impl CornerDrag {
|
||||
/// Start a drag when the press `ev` is on a widget of the selection.
|
||||
pub fn hit(cx: &ToolContext, ev: &PointerEvent) -> Option<Self> {
|
||||
let (widgets, p) = (CornerWidgets::for_tool(cx)?, ev.pos);
|
||||
let corner = widgets.hit(p, cx.tol(5.0))?;
|
||||
Some(Self { widgets, corner, start: p, began: false, alt: ev.mods.alt, radius: widgets.radii[corner], at_limit: false, at: p })
|
||||
/// Start a drag when the press `ev` is on a widget of the selection (Direct Selection:
|
||||
/// `any_path`).
|
||||
pub fn hit(cx: &ToolContext, ev: &PointerEvent, any_path: bool) -> Option<Self> {
|
||||
let (widgets, p) = (CornerWidgets::for_tool(cx, any_path)?, ev.pos);
|
||||
let widget = widgets.hit(p, cx.tol(5.0))?;
|
||||
let radius = widgets.widgets.get(widget)?.radius;
|
||||
let lc = cx.doc.node(widgets.id).and_then(LiveCorners::of)?;
|
||||
let n = lc.base.anchor_count();
|
||||
let (radii, kinds) = ((0..n).map(|k| lc.radius(k)).collect(), (0..n).map(|k| lc.kind(k)).collect());
|
||||
let base = lc.base.into_owned();
|
||||
Some(Self { widgets, widget, base, radii, kinds, start: p, began: false, alt: ev.mods.alt, radius, at_limit: false, at: p })
|
||||
}
|
||||
|
||||
/// The start radius (as drawn: no larger than fits) plus the pointer's travel along the
|
||||
/// corner's inward diagonal (in the shape's own units), from square to fully round; and
|
||||
/// whether the travel reached fully round (the limit every corner shares).
|
||||
/// corner's bisector (in the corners' own units), from square to fully round; and whether the
|
||||
/// travel reached fully round.
|
||||
fn radius_at(&self, p: Point) -> (f64, bool) {
|
||||
let w = &self.widgets;
|
||||
let inv = w.xf.inverse();
|
||||
let d = inv * p - inv * self.start;
|
||||
let (_, (sx, sy)) = CORNERS[self.corner];
|
||||
let max = shapes::max_corner_radius(w.w, w.h);
|
||||
let r = shapes::fitted_corner_radius(w.w, w.h, w.radii[self.corner]) + (d.x * sx + d.y * sy) / 2.0;
|
||||
let Some(w) = self.widgets.widgets.get(self.widget) else { return (self.radius, self.at_limit) };
|
||||
let inv = self.widgets.xf.inverse();
|
||||
let max = w.corner.max_radius();
|
||||
let r = w.corner.fitted(w.radius) + w.corner.radius_change(inv * p - inv * self.start);
|
||||
(r.min(max).max(0.0), max > 0.0 && r >= max)
|
||||
}
|
||||
|
||||
/// The edited corners' cuts at the dragged radius, in document coordinates.
|
||||
fn edited_corners(&self) -> BezPath {
|
||||
let w = &self.widgets;
|
||||
let rect = Rect::new(0.0, 0.0, w.w, w.h);
|
||||
let radii = std::array::from_fn(|k| if w.shown[k] { self.radius } else { w.radii[k] });
|
||||
let corner_of = shapes::rectangle_anchor_corners(rect, radii);
|
||||
let path = shapes::rectangle_with_corners(rect, radii, w.kinds).transformed(w.xf);
|
||||
/// The cuts of the edited corners that are at their largest radius, in document coordinates.
|
||||
fn corners_at_limit(&self) -> BezPath {
|
||||
let shown = &self.widgets.widgets;
|
||||
let mut radii = self.radii.clone();
|
||||
for w in shown {
|
||||
if let Some(r) = radii.get_mut(w.corner.index) {
|
||||
*r = self.radius;
|
||||
}
|
||||
}
|
||||
let full = |k: &usize| shown.iter().any(|w| w.corner.index == *k && self.radius >= w.corner.max_radius() - 1e-9);
|
||||
let (path, sources) = cut_corners(&self.base, &radii, &self.kinds);
|
||||
let mut out = BezPath::new();
|
||||
let Some(sp) = path.subpaths.first() else { return out };
|
||||
// A corner's cut is the segment between its two anchors (the last one, for the top-left).
|
||||
for i in 0..sp.segment_count() {
|
||||
let (a, b) = (corner_of.get(i), corner_of.get(i + 1).or(corner_of.first()));
|
||||
if a == b && a.is_some_and(|k| w.shown.get(*k) == Some(&true)) {
|
||||
let c = sp.segment(i);
|
||||
out.move_to(c.p0);
|
||||
out.curve_to(c.p1, c.p2, c.p3);
|
||||
for (sp, from) in path.transformed(self.widgets.xf).subpaths.iter().zip(&sources) {
|
||||
// A corner's cut is the segment between its two anchors (the last one, for a closed
|
||||
// subpath's first corner).
|
||||
for i in 0..sp.segment_count() {
|
||||
let (a, b) = (from.get(i), from.get(i + 1).or(from.first()));
|
||||
if a == b && a.is_some_and(full) {
|
||||
let c = sp.segment(i);
|
||||
out.move_to(c.p0);
|
||||
out.curve_to(c.p1, c.p2, c.p3);
|
||||
}
|
||||
}
|
||||
}
|
||||
out
|
||||
|
|
@ -205,22 +249,21 @@ impl CornerDrag {
|
|||
pub fn finish(self) -> Vec<Action> {
|
||||
if self.began {
|
||||
vec![Action::Commit]
|
||||
} else if self.alt {
|
||||
let kind = self.widgets.kinds[self.corner].next();
|
||||
vec![Action::Exec("object.setLiveShape".into(), self.widgets.command("kind", json!(kind)))]
|
||||
} else if let Some(w) = self.widgets.widgets.get(self.widget).filter(|_| self.alt) {
|
||||
vec![Action::Exec("object.setLiveShape".into(), self.widgets.command("kind", json!(w.kind.next())))]
|
||||
} else {
|
||||
vec![]
|
||||
}
|
||||
}
|
||||
|
||||
/// The radius readout next to the pointer; at the largest radius, the edited corners in red.
|
||||
/// The radius readout next to the pointer; at the largest radius, the corners there in red.
|
||||
pub fn overlays(&self, cx: &ToolContext) -> Vec<Overlay> {
|
||||
if !self.began {
|
||||
return vec![];
|
||||
}
|
||||
let mut out = vec![Overlay::Measure { p: self.at, text: format!("Radius: {}", cx.len(self.radius)) }];
|
||||
if self.at_limit {
|
||||
out.push(Overlay::Path { path: self.edited_corners(), color: crate::builder::HIGHLIGHT_RED, width: 2.0, dashed: false });
|
||||
out.push(Overlay::Path { path: self.corners_at_limit(), color: crate::builder::HIGHLIGHT_RED, width: 2.0, dashed: false });
|
||||
}
|
||||
out
|
||||
}
|
||||
|
|
@ -240,24 +283,38 @@ mod tests {
|
|||
|
||||
/// A live `w` × `h` rectangle with corner radius `r`.
|
||||
fn live_shape(w: f64, h: f64, r: f64, xf: Affine) -> (Document, NodeId) {
|
||||
let live = LiveShape::Rectangle { w, h, radii: [r; 4], kinds: Default::default(), xf };
|
||||
doc_with(live.to_path(), Some(live))
|
||||
}
|
||||
|
||||
/// A document holding one path with its live shape.
|
||||
fn doc_with(path: PathData, live: Option<LiveShape>) -> (Document, NodeId) {
|
||||
let mut d = Document::new(500.0, 500.0);
|
||||
let l = d.layers[0].id;
|
||||
let id = d.alloc_id();
|
||||
let live = LiveShape::Rectangle { w, h, radii: [r; 4], kinds: Default::default(), xf };
|
||||
let mut n = Node::path(id, live.to_path(), Appearance::default_art());
|
||||
let mut n = Node::path(id, path, Appearance::default_art());
|
||||
if let NodeKind::Path { live: slot, .. } = &mut n.kind {
|
||||
*slot = Some(live);
|
||||
*slot = live;
|
||||
}
|
||||
d.insert(Some(l), 0, n).unwrap();
|
||||
(d, id)
|
||||
}
|
||||
|
||||
/// A five-pointed star at (200, 200) of radii 60 and 30 (#511): a plain path.
|
||||
fn star() -> (Document, NodeId) {
|
||||
doc_with(vectorcraft_geom::shapes::star(Point::new(200.0, 200.0), 60.0, 30.0, 5, 0.0), None)
|
||||
}
|
||||
|
||||
fn selected(id: NodeId) -> Selection {
|
||||
let mut s = Selection::default();
|
||||
s.add(id);
|
||||
s
|
||||
}
|
||||
|
||||
fn pts(w: &CornerWidgets) -> Vec<Point> {
|
||||
w.visible().collect()
|
||||
}
|
||||
|
||||
fn radius(a: &Action) -> f64 {
|
||||
let Action::Preview(c, v) = a else { panic!("not a preview: {a:?}") };
|
||||
assert_eq!(c, "object.setLiveShape");
|
||||
|
|
@ -267,17 +324,19 @@ mod tests {
|
|||
#[test]
|
||||
fn widgets_sit_inside_each_corner() {
|
||||
let (d, id) = live_rect(0.0, Affine::translate((100.0, 100.0)));
|
||||
let w = CornerWidgets::of(&d, &selected(id), 1.0).unwrap();
|
||||
assert_eq!(w.points, [Point::new(110.0, 110.0), Point::new(190.0, 110.0), Point::new(190.0, 190.0), Point::new(110.0, 190.0)]);
|
||||
let w = CornerWidgets::of(&d, &selected(id), 1.0, false).unwrap();
|
||||
assert_eq!(pts(&w), [Point::new(110.0, 110.0), Point::new(190.0, 110.0), Point::new(190.0, 190.0), Point::new(110.0, 190.0)]);
|
||||
// A larger radius moves them to the arc centres; zooming in keeps a 10 px minimum.
|
||||
let (d, id) = live_rect(20.0, Affine::translate((100.0, 100.0)));
|
||||
assert_eq!(CornerWidgets::of(&d, &selected(id), 1.0).unwrap().points[0], Point::new(120.0, 120.0));
|
||||
assert_eq!(CornerWidgets::of(&d, &selected(id), 4.0).unwrap().points[2], Point::new(180.0, 180.0));
|
||||
// Hidden when the shape is tiny on screen, for plain paths and without a single selection.
|
||||
assert!(CornerWidgets::of(&d, &selected(id), 0.2).is_none());
|
||||
assert_eq!(pts(&CornerWidgets::of(&d, &selected(id), 1.0, false).unwrap())[0], Point::new(120.0, 120.0));
|
||||
assert_eq!(pts(&CornerWidgets::of(&d, &selected(id), 4.0, false).unwrap())[2], Point::new(180.0, 180.0));
|
||||
// Hidden when the shape is tiny on screen and without a single selection; a plain path
|
||||
// shows them with Direct Selection only.
|
||||
assert!(CornerWidgets::of(&d, &selected(id), 0.2, true).is_none());
|
||||
let (d, id) = doc_with_rect();
|
||||
assert!(CornerWidgets::of(&d, &selected(id), 1.0).is_none());
|
||||
assert!(CornerWidgets::of(&d, &Selection::default(), 1.0).is_none());
|
||||
assert!(CornerWidgets::of(&d, &selected(id), 1.0, false).is_none());
|
||||
assert_eq!(pts(&CornerWidgets::of(&d, &selected(id), 1.0, true).unwrap())[0], Point::new(110.0, 110.0));
|
||||
assert!(CornerWidgets::of(&d, &Selection::default(), 1.0, true).is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -307,9 +366,9 @@ mod tests {
|
|||
fn widgets_of_a_non_square_rectangle_follow_the_drawn_corners() {
|
||||
let (d, id) = live_shape(200.0, 80.0, 60.0, Affine::translate((100.0, 100.0)));
|
||||
let s = selected(id);
|
||||
let w = CornerWidgets::of(&d, &s, 1.0).unwrap();
|
||||
let w = CornerWidgets::of(&d, &s, 1.0, false).unwrap();
|
||||
let centres = [Point::new(140.0, 140.0), Point::new(260.0, 140.0), Point::new(260.0, 140.0), Point::new(140.0, 140.0)];
|
||||
assert_eq!(w.points, centres);
|
||||
assert_eq!(pts(&w), centres);
|
||||
let p = paint();
|
||||
let cx = cx(&d, &s, &p);
|
||||
let red = |t: &dyn crate::Tool| {
|
||||
|
|
@ -339,8 +398,8 @@ mod tests {
|
|||
// 50 × 80 with 10 pt corners stretched 4 × 1: drawn 200 × 80, a mean radius of 20.
|
||||
let (d, id) = live_shape(50.0, 80.0, 10.0, Affine::translate((100.0, 100.0)) * Affine::scale_non_uniform(4.0, 1.0));
|
||||
let s = selected(id);
|
||||
let w = CornerWidgets::of(&d, &s, 1.0).unwrap();
|
||||
assert_eq!(w.points[0], Point::new(120.0, 120.0));
|
||||
let w = CornerWidgets::of(&d, &s, 1.0, false).unwrap();
|
||||
assert_eq!(pts(&w)[0], Point::new(120.0, 120.0));
|
||||
let p = paint();
|
||||
let cx = cx(&d, &s, &p);
|
||||
let mut t = crate::create("directSelection");
|
||||
|
|
@ -357,8 +416,8 @@ mod tests {
|
|||
let s = selected(id);
|
||||
let p = paint();
|
||||
let cx = cx(&d, &s, &p);
|
||||
let w = CornerWidgets::of(&d, &s, 1.0).unwrap();
|
||||
assert!(w.points[0].distance(Point::new(190.0, 110.0)) < 1e-9);
|
||||
let w = CornerWidgets::of(&d, &s, 1.0, false).unwrap();
|
||||
assert!(pts(&w)[0].distance(Point::new(190.0, 110.0)) < 1e-9);
|
||||
let mut t = crate::create("directSelection");
|
||||
t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 190.0, 110.0));
|
||||
let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 180.0, 120.0));
|
||||
|
|
@ -377,10 +436,10 @@ mod tests {
|
|||
s.anchors.insert(id, [(0, 2)].into());
|
||||
let p = paint();
|
||||
let cx = cx(&d, &s, &p);
|
||||
let w = CornerWidgets::of(&d, &s, 1.0).unwrap();
|
||||
assert_eq!(w.shown, [false, false, true, false]);
|
||||
assert_eq!(w.visible().collect::<Vec<_>>(), [Point::new(190.0, 190.0)]);
|
||||
assert!(!over_widget(&cx, Point::new(110.0, 110.0)), "the other corners hide theirs");
|
||||
let w = CornerWidgets::of(&d, &s, 1.0, true).unwrap();
|
||||
assert_eq!(w.corners(), [2]);
|
||||
assert_eq!(pts(&w), [Point::new(190.0, 190.0)]);
|
||||
assert!(!over_widget(&cx, Point::new(110.0, 110.0), true), "the other corners hide theirs");
|
||||
let mut t = crate::create("directSelection");
|
||||
assert!(t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 190.0, 191.0)).is_empty());
|
||||
let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 175.0, 176.0));
|
||||
|
|
@ -423,20 +482,20 @@ mod tests {
|
|||
#[test]
|
||||
fn corners_wider_than_the_preference_hide_their_widgets() {
|
||||
let (d, id) = live_rect(0.0, Affine::translate((100.0, 100.0)));
|
||||
let w = CornerWidgets::of(&d, &selected(id), 1.0).unwrap();
|
||||
assert_eq!(w.within_angle(177.0).map(|w| w.shown), Some([true; 4]));
|
||||
assert_eq!(w.within_angle(90.0).map(|w| w.shown), Some([true; 4]));
|
||||
let w = CornerWidgets::of(&d, &selected(id), 1.0, false).unwrap();
|
||||
assert_eq!(w.clone().within_angle(177.0).map(|w| w.corners()), Some(vec![0, 1, 2, 3]));
|
||||
assert_eq!(w.clone().within_angle(90.0).map(|w| w.corners()), Some(vec![0, 1, 2, 3]));
|
||||
assert!(w.within_angle(89.0).is_none());
|
||||
// Sheared by 30°: 60° at the top-left and bottom-right corners, 120° at the others.
|
||||
let shear = Affine::translate((100.0, 100.0)) * Affine::new([1.0, 0.0, 30f64.to_radians().tan(), 1.0, 0.0, 0.0]);
|
||||
let (d, id) = live_rect(0.0, shear);
|
||||
let w = CornerWidgets::of(&d, &selected(id), 1.0).unwrap();
|
||||
assert_eq!(w.within_angle(100.0).map(|w| w.shown), Some([true, false, true, false]));
|
||||
let w = CornerWidgets::of(&d, &selected(id), 1.0, false).unwrap();
|
||||
assert_eq!(w.clone().within_angle(100.0).map(|w| w.corners()), Some(vec![0, 2]));
|
||||
let s = selected(id);
|
||||
let p = paint();
|
||||
let c = ToolContext { corner_widget_max_angle: 100.0, ..cx(&d, &s, &p) };
|
||||
assert!(over_widget(&c, w.points[0]));
|
||||
assert!(!over_widget(&c, w.points[1]), "the 120° corner's widget is hidden");
|
||||
assert!(over_widget(&c, pts(&w)[0], false));
|
||||
assert!(!over_widget(&c, pts(&w)[1], false), "the 120° corner's widget is hidden");
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -445,14 +504,113 @@ mod tests {
|
|||
let s = selected(id);
|
||||
let p = paint();
|
||||
let mut c = cx(&d, &s, &p);
|
||||
assert!(over_widget(&c, Point::new(110.0, 110.0)));
|
||||
assert!(!over_widget(&c, Point::new(150.0, 150.0)));
|
||||
assert!(over_widget(&c, Point::new(110.0, 110.0), false));
|
||||
assert!(!over_widget(&c, Point::new(150.0, 150.0), false));
|
||||
c.corner_widgets = false;
|
||||
assert!(!over_widget(&c, Point::new(110.0, 110.0)));
|
||||
assert!(!over_widget(&c, Point::new(110.0, 110.0), true));
|
||||
// With the widgets hidden, a drag from the same spot moves the object.
|
||||
let mut t = crate::create("selection");
|
||||
t.pointer(&c, &PointerEvent::new(PointerKind::Down, 110.0, 110.0));
|
||||
let a = t.pointer(&c, &PointerEvent::new(PointerKind::Drag, 130.0, 110.0));
|
||||
assert_eq!(a[0], Action::Begin("Move".into()));
|
||||
}
|
||||
|
||||
/// #511: Direct Selection shows a widget in each of a star's ten corners (the Selection tool
|
||||
/// none: a star isn't a live shape); dragging a tip's inward rounds them all as one step.
|
||||
#[test]
|
||||
fn a_star_shows_widgets_in_every_corner_with_direct_selection() {
|
||||
let (d, id) = star();
|
||||
let s = selected(id);
|
||||
let p = paint();
|
||||
let cx = cx(&d, &s, &p);
|
||||
assert!(CornerWidgets::for_tool(&cx, false).is_none());
|
||||
let w = CornerWidgets::for_tool(&cx, true).expect("widgets on a plain path");
|
||||
assert_eq!(w.corners(), (0..10).collect::<Vec<_>>());
|
||||
// The top tip's widget sits 10 √2 px down its bisector.
|
||||
let tip = pts(&w)[0];
|
||||
assert!(tip.distance(Point::new(200.0, 140.0 + 10.0 * 2f64.sqrt())) < 1e-9, "{tip:?}");
|
||||
let mut t = crate::create("directSelection");
|
||||
assert!(t.pointer(&cx, &PointerEvent::new(PointerKind::Down, tip.x, tip.y)).is_empty());
|
||||
let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, tip.x, tip.y + 10.0));
|
||||
assert_eq!(a[0], Action::Begin("Corner Radius".into()));
|
||||
// The widget follows the arc's centre: r / sin(angle / 2) along the bisector.
|
||||
let c = vectorcraft_geom::corners::path_corners(&star_path(&d, id))[0];
|
||||
let want = 10.0 * (c.angle_deg() / 2.0).to_radians().sin();
|
||||
assert!((radius(&a[1]) - want).abs() < 1e-9, "{a:?} want {want}");
|
||||
assert!(matches!(&a[1], Action::Preview(_, v) if v["id"] == id.0 && v.get("corners").is_none()), "every corner: {a:?}");
|
||||
// The Selection tool drags the star instead.
|
||||
let mut t = crate::create("selection");
|
||||
t.pointer(&cx, &PointerEvent::new(PointerKind::Down, tip.x, tip.y));
|
||||
assert_eq!(t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, tip.x, tip.y + 10.0))[0], Action::Begin("Move".into()));
|
||||
}
|
||||
|
||||
fn star_path(d: &Document, id: NodeId) -> PathData {
|
||||
let Some(NodeKind::Path { path, .. }) = d.node(id).map(|n| &n.kind) else { panic!("not a path") };
|
||||
path.clone()
|
||||
}
|
||||
|
||||
/// #511: a Direct-Selected anchor of the star shows its corner's widget alone, and the
|
||||
/// preference hides the star's wide inner corners (about 125°) below their angle.
|
||||
#[test]
|
||||
fn star_corners_follow_the_anchors_and_the_angle_preference() {
|
||||
let (d, id) = star();
|
||||
let mut s = selected(id);
|
||||
s.anchors.insert(id, [(0, 3)].into());
|
||||
let p = paint();
|
||||
let c = cx(&d, &s, &p);
|
||||
let w = CornerWidgets::for_tool(&c, true).unwrap();
|
||||
assert_eq!(w.corners(), [3]);
|
||||
let mut t = crate::create("directSelection");
|
||||
let at = pts(&w)[0];
|
||||
t.pointer(&c, &PointerEvent::new(PointerKind::Down, at.x, at.y));
|
||||
let a = t.pointer(&c, &PointerEvent::new(PointerKind::Drag, at.x + 20.0, at.y + 20.0));
|
||||
assert!(matches!(&a[1], Action::Preview(_, v) if v["corners"] == json!([3])), "{a:?}");
|
||||
// Corners wider than 90° hide: the five tips keep theirs.
|
||||
let whole = selected(id);
|
||||
let c = ToolContext { corner_widget_max_angle: 90.0, ..cx(&d, &whole, &p) };
|
||||
let w = CornerWidgets::for_tool(&c, true).unwrap();
|
||||
assert_eq!(w.corners(), [0, 2, 4, 6, 8]);
|
||||
assert_eq!(w.command("radius", json!(4.0))["corners"], json!([0, 2, 4, 6, 8]));
|
||||
}
|
||||
|
||||
/// A live polygon shows its widgets to the Selection tool too; past every corner's limit the
|
||||
/// cuts outline in red.
|
||||
#[test]
|
||||
fn a_live_polygon_rounds_with_either_tool() {
|
||||
let live = LiveShape::Polygon { radius: 80.0, sides: 6, xf: Affine::translate((200.0, 200.0)), radii: vec![], kinds: vec![] };
|
||||
let (d, id) = doc_with(live.to_path(), Some(live));
|
||||
let s = selected(id);
|
||||
let p = paint();
|
||||
let cx = cx(&d, &s, &p);
|
||||
for any_path in [false, true] {
|
||||
assert_eq!(CornerWidgets::for_tool(&cx, any_path).unwrap().corners().len(), 6);
|
||||
}
|
||||
let tip = pts(&CornerWidgets::for_tool(&cx, false).unwrap())[0];
|
||||
let mut t = crate::create("selection");
|
||||
t.pointer(&cx, &PointerEvent::new(PointerKind::Down, tip.x, tip.y));
|
||||
let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 200.0, 300.0));
|
||||
// A hexagon's 120° corners stop where their cuts meet: 40 · tan 60°.
|
||||
assert!((radius(&a[1]) - 40.0 * 3f64.sqrt()).abs() < 1e-9, "{a:?}");
|
||||
let red = t
|
||||
.overlays(&cx)
|
||||
.into_iter()
|
||||
.any(|o| matches!(o, Overlay::Path { color, path, .. } if color == crate::builder::HIGHLIGHT_RED && path.elements().len() == 12));
|
||||
assert!(red, "six arcs at the limit");
|
||||
}
|
||||
|
||||
/// A pen path's middle corner shows a widget; its ends and curved corners don't.
|
||||
#[test]
|
||||
fn a_pen_path_shows_widgets_on_its_corners_only() {
|
||||
let mut sp = vectorcraft_geom::SubPath::polyline(
|
||||
&[Point::new(100.0, 100.0), Point::new(300.0, 100.0), Point::new(300.0, 300.0), Point::new(100.0, 300.0)],
|
||||
false,
|
||||
);
|
||||
sp.anchors[2].h_out = Point::new(250.0, 350.0);
|
||||
let (d, id) = doc_with(PathData::single(sp), None);
|
||||
let s = selected(id);
|
||||
let p = paint();
|
||||
let w = CornerWidgets::for_tool(&cx(&d, &s, &p), true).unwrap();
|
||||
assert_eq!(w.corners(), [1]);
|
||||
assert_eq!(pts(&w), [Point::new(290.0, 110.0)]);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
//! steps), drag a direction handle to
|
||||
//! reshape (Shift keeps it at 45° steps round its anchor, Alt moves it alone; smart guides snap
|
||||
//! it), marquee to select anchors (Shift-drag toggles them: the selected ones inside are
|
||||
//! deselected, the others selected), drag a live rectangle's corner widget to round its corners
|
||||
//! deselected, the others selected), drag a corner widget of any path (a star, a pen path) to round its corners
|
||||
//! (the selected ones when anchors are selected; Alt-click cycles their kind, double-click opens
|
||||
//! the Corners dialog).
|
||||
//! Group Selection: click selects the leaf; each further click on it adds the next enclosing group;
|
||||
|
|
@ -317,13 +317,13 @@ impl Tool for DirectSelectionTool {
|
|||
vec![Action::Exec("select.set".into(), json!({"ids": [target.0]}))]
|
||||
}
|
||||
}
|
||||
(PointerKind::DoubleClick, _) if !self.group => corners::double_click(cx, p).into_iter().collect(),
|
||||
(PointerKind::DoubleClick, _) if !self.group => corners::double_click(cx, p, true).into_iter().collect(),
|
||||
(PointerKind::Move, State::Idle) => {
|
||||
self.hover = if self.group || !cx.highlight_anchors { None } else { hovered_anchor(cx, p) };
|
||||
vec![]
|
||||
}
|
||||
(PointerKind::Down, _) => {
|
||||
if let Some(c) = CornerDrag::hit(cx, ev) {
|
||||
if let Some(c) = CornerDrag::hit(cx, ev, true) {
|
||||
self.state = State::Corner(c);
|
||||
return vec![];
|
||||
}
|
||||
|
|
@ -597,7 +597,7 @@ impl Tool for DirectSelectionTool {
|
|||
}
|
||||
}
|
||||
fn cursor(&self, cx: &ToolContext, p: Point, _m: Mods) -> Cursor {
|
||||
if !self.group && (matches!(self.state, State::Corner(_)) || over_widget(cx, p)) {
|
||||
if !self.group && (matches!(self.state, State::Corner(_)) || over_widget(cx, p, true)) {
|
||||
return Cursor::CornerRadius;
|
||||
}
|
||||
if !self.group && (matches!(self.state, State::Bracket(_)) || over_bracket(cx, p)) {
|
||||
|
|
|
|||
|
|
@ -234,7 +234,7 @@ pub struct ToolContext<'a> {
|
|||
/// points (a transform's reference point) land on anchors and ruler guides within
|
||||
/// [`Self::snap_tolerance`].
|
||||
pub snap_to_point: bool,
|
||||
/// View → Show Corner Widget: live rectangles show draggable Live Corners widgets.
|
||||
/// View → Show Corner Widget: paths show draggable Live Corners widgets in their corners.
|
||||
pub corner_widgets: bool,
|
||||
/// Which paint proxy is in front (true = Fill): the one the Gradient tool edits.
|
||||
pub fill_active: bool,
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
//! the selected ones are deselected, the others selected), move (Alt copies, Shift constrains; Smart
|
||||
//! Guides, or with them off View › Snap to Point, snap it),
|
||||
//! bounding-box scale (Shift proportional, Alt from centre) and rotate (outside corners, Shift 45°),
|
||||
//! drag a live rectangle's corner widget to round its corners (Alt-click cycles their kind,
|
||||
//! drag a live rectangle's or polygon's corner widget to round its corners (Alt-click cycles their kind,
|
||||
//! double-click opens the Corners dialog), double-click to enter isolation mode (Double Click To
|
||||
//! Isolate), Cmd/Ctrl-click to select the object behind (Command Click to Select Objects Behind),
|
||||
//! click or drag a ruler guide ([`crate::rulerguide`]), drag the brackets of type on a path
|
||||
|
|
@ -169,7 +169,7 @@ impl Tool for SelectionTool {
|
|||
match (ev.kind, self.state.clone()) {
|
||||
(PointerKind::DoubleClick, _) => {
|
||||
self.state = State::Idle;
|
||||
if let Some(a) = corners::double_click(cx, p).or_else(|| typewidget::double_click(cx, p)) {
|
||||
if let Some(a) = corners::double_click(cx, p, false).or_else(|| typewidget::double_click(cx, p)) {
|
||||
return vec![a];
|
||||
}
|
||||
if crate::rulerguide::guide_at(cx, p).is_some() {
|
||||
|
|
@ -191,7 +191,7 @@ impl Tool for SelectionTool {
|
|||
(PointerKind::Down, _) => {
|
||||
// 1. Live Corners widgets and type on a path's brackets, then the bounding-box
|
||||
// handles of the current selection.
|
||||
if let Some(c) = CornerDrag::hit(cx, ev) {
|
||||
if let Some(c) = CornerDrag::hit(cx, ev, false) {
|
||||
self.state = State::Corner(c);
|
||||
return vec![];
|
||||
}
|
||||
|
|
@ -381,7 +381,7 @@ impl Tool for SelectionTool {
|
|||
if self.guide.busy() {
|
||||
return self.guide.cursor(cx, p).unwrap_or_default();
|
||||
}
|
||||
if over_widget(cx, p) {
|
||||
if over_widget(cx, p, false) {
|
||||
return Cursor::CornerRadius;
|
||||
}
|
||||
if over_bracket(cx, p) {
|
||||
|
|
|
|||
|
|
@ -1429,11 +1429,16 @@ fn selection_overlay(app: &mut VectorcraftApp, p: &egui::Painter, xf: &Xf) {
|
|||
anchor_square(p, xf.to_screen(a.p), color, false, anchor(direct));
|
||||
}
|
||||
}
|
||||
// Live Corners widgets (Selection / Direct Selection on a single live rectangle).
|
||||
// Live Corners widgets (Selection on a live rectangle or polygon, Direct Selection on any path).
|
||||
if matches!(tool, "selection" | "directSelection")
|
||||
&& app.ui.view.corner_widgets
|
||||
&& let Some(w) = vectorcraft_tools::corners::CornerWidgets::of(&st.doc, &st.selection, xf.zoom)
|
||||
.and_then(|w| w.within_angle(app.session.prefs.hide_corner_widget_above))
|
||||
&& let Some(w) = vectorcraft_tools::corners::CornerWidgets::showing(
|
||||
&st.doc,
|
||||
&st.selection,
|
||||
xf.zoom,
|
||||
tool == "directSelection",
|
||||
app.ui.view.corner_widgets,
|
||||
app.session.prefs.hide_corner_widget_above,
|
||||
)
|
||||
{
|
||||
let color = c32(st.doc.layer_color(w.id));
|
||||
for sp in w.visible().map(|q| xf.to_screen(q)) {
|
||||
|
|
@ -2259,6 +2264,25 @@ mod tests {
|
|||
assert_eq!(widgets(&mut app), 0);
|
||||
}
|
||||
|
||||
/// #511: a star shows a widget in each of its ten corners with Direct Selection (none with
|
||||
/// the Selection tool: it isn't a live shape); View → Hide Corner Widget hides them.
|
||||
#[test]
|
||||
fn a_star_shows_corner_widgets_with_direct_selection() {
|
||||
let mut app = VectorcraftApp::new(Session::new(), Default::default());
|
||||
app.session.execute("file.new", &json!({"width": 400, "height": 300})).unwrap();
|
||||
app.session.execute("shape.star", &json!({"cx": 200, "cy": 150, "radius1": 80, "radius2": 40})).unwrap();
|
||||
let ctx = egui::Context::default();
|
||||
let widgets = |app: &mut VectorcraftApp| {
|
||||
shapes(app, &ctx).iter().filter(|s| matches!(s, Shape::Circle(c) if c.radius == 3.0 && c.fill == Color32::WHITE)).count()
|
||||
};
|
||||
app.select_tool("selection");
|
||||
assert_eq!(widgets(&mut app), 0);
|
||||
app.select_tool("directSelection");
|
||||
assert_eq!(widgets(&mut app), 10);
|
||||
app.run("view.cornerWidget", json!({})).unwrap();
|
||||
assert_eq!(widgets(&mut app), 0);
|
||||
}
|
||||
|
||||
/// The type widget beside selected type's bounding box: hollow (white) on point type, filled
|
||||
/// in the layer colour on area type.
|
||||
#[test]
|
||||
|
|
|
|||
|
|
@ -1,13 +1,16 @@
|
|||
//! Corners: double-clicking a Live Corners widget (or `ui.corners`) sets the corner kind and
|
||||
//! radius of a live rectangle's corners: those whose widgets show (the Direct-Selected ones, else
|
||||
//! all four). OK runs `object.setLiveShape` for them, one undo step.
|
||||
//! radius of a path's corners: those whose widgets show (the Direct-Selected ones, else every
|
||||
//! corner). OK runs `object.setLiveShape` for them, one undo step.
|
||||
//!
|
||||
//! Fields: `id`, `corners` (indices 0–3: top-left, top-right, bottom-right, bottom-left), `kind`
|
||||
//! ("round", "invertedRound" or "chamfer") and `radius` (pt). While the corners differ in kind
|
||||
//! or radius, that field is absent and OK leaves it as it is.
|
||||
//! Fields: `id`, `corners` (anchor indices of the path with its corners uncut: a rectangle's 0–3
|
||||
//! from the top-left clockwise), `kind` ("round", "invertedRound" or "chamfer") and `radius`
|
||||
//! (pt). While the corners differ in kind or radius, that field is absent and OK leaves it as it
|
||||
//! is.
|
||||
|
||||
use std::collections::BTreeSet;
|
||||
|
||||
use serde_json::{Value, json};
|
||||
use vectorcraft_engine::doc::{NodeId, NodeKind};
|
||||
use vectorcraft_engine::doc::{LiveCorners, NodeId};
|
||||
use vectorcraft_geom::shapes::CornerKind;
|
||||
|
||||
use super::swatch_options::{grid, label};
|
||||
|
|
@ -20,7 +23,7 @@ pub const KIND: &str = vectorcraft_tools::corners::DIALOG;
|
|||
|
||||
pub(super) const SPEC: DialogSpec = DialogSpec { heading: |_| tl!("Corners").into(), body, confirm, min_width: 280.0, ..DialogSpec::FORM };
|
||||
|
||||
/// Open Corners for `{id?, corners?}`: the live rectangle `id` (default: the selected one) and its
|
||||
/// Open Corners for `{id?, corners?}`: the path `id` (default: the selected one) and its
|
||||
/// `corners` (default: the selected corners), filled in with their kind and radius.
|
||||
pub fn open(app: &mut VectorcraftApp, p: &Value) -> Result<Value, String> {
|
||||
let st = app.session.active().ok_or("no document")?;
|
||||
|
|
@ -28,22 +31,21 @@ pub fn open(app: &mut VectorcraftApp, p: &Value) -> Result<Value, String> {
|
|||
Some(id) => NodeId(id),
|
||||
None => match st.selection.objects[..] {
|
||||
[id] => id,
|
||||
_ => return Err("select one live rectangle, or give its `id`".into()),
|
||||
_ => return Err("select one path, or give its `id`".into()),
|
||||
},
|
||||
};
|
||||
let Some(NodeKind::Path { live: Some(live @ vectorcraft_engine::doc::LiveShape::Rectangle { .. }), .. }) = st.doc.node(id).map(|n| &n.kind)
|
||||
else {
|
||||
return Err("Corners edits a live rectangle".into());
|
||||
let Some(live) = st.doc.node(id).and_then(LiveCorners::of) else {
|
||||
return Err("Corners edits the corners of a path".into());
|
||||
};
|
||||
let corners = match p.get("corners").and_then(Value::as_array) {
|
||||
Some(a) => std::array::from_fn(|k| a.iter().any(|v| v.as_u64() == Some(k as u64))),
|
||||
None => live.picked_corners(st.selection.partial(id)),
|
||||
let corners: BTreeSet<usize> = match p.get("corners").and_then(Value::as_array) {
|
||||
Some(a) => a.iter().filter_map(Value::as_u64).filter_map(|k| usize::try_from(k).ok()).filter(|k| live.corner(*k).is_some()).collect(),
|
||||
None => live.picked(st.selection.partial(id)),
|
||||
};
|
||||
if !corners.contains(&true) {
|
||||
return Err("give corners 0–3".into());
|
||||
if corners.is_empty() {
|
||||
return Err("give corners of the path: anchors between two straight sides".into());
|
||||
}
|
||||
let (radius, kind) = live.corner_style(corners);
|
||||
let mut fields = json!({"id": id.0, "corners": (0..4).filter(|k| corners[*k]).collect::<Vec<_>>()});
|
||||
let (radius, kind) = live.style(&corners);
|
||||
let mut fields = json!({"id": id.0, "corners": corners});
|
||||
if let Some(k) = kind {
|
||||
fields["kind"] = json!(k);
|
||||
}
|
||||
|
|
@ -94,7 +96,7 @@ fn confirm(app: &mut VectorcraftApp, d: &Dialog) -> Result<Value, String> {
|
|||
mod tests {
|
||||
use super::*;
|
||||
use vectorcraft_engine::Session;
|
||||
use vectorcraft_engine::doc::LiveShape;
|
||||
use vectorcraft_engine::doc::{LiveShape, NodeKind};
|
||||
use vectorcraft_tools::corners::CornerWidgets;
|
||||
use vectorcraft_tools::{PointerEvent, PointerKind};
|
||||
|
||||
|
|
@ -121,7 +123,7 @@ mod tests {
|
|||
/// The radius the Properties panel's Corner Radius field shows.
|
||||
fn panel_radius(app: &VectorcraftApp, id: u64) -> Option<f64> {
|
||||
let n = app.session.active().unwrap().doc.node(NodeId(id)).unwrap().clone();
|
||||
crate::panels::corner_radius(app, &n, &live(app, id))
|
||||
crate::panels::corner_radius(app, &n)
|
||||
}
|
||||
|
||||
fn shown(app: &mut VectorcraftApp) -> Vec<String> {
|
||||
|
|
@ -151,7 +153,7 @@ mod tests {
|
|||
app.select_tool("directSelection");
|
||||
let view = app.view_info();
|
||||
let st = app.session.active().unwrap();
|
||||
let at: Vec<_> = CornerWidgets::of(&st.doc, &st.selection, view.zoom).unwrap().visible().collect();
|
||||
let at: Vec<_> = CornerWidgets::of(&st.doc, &st.selection, view.zoom, true).unwrap().visible().collect();
|
||||
assert_eq!(at.len(), 1);
|
||||
crate::canvas::dispatch(&mut app, &PointerEvent::new(PointerKind::DoubleClick, at[0].x, at[0].y), view);
|
||||
let d = app.ui.dialog.clone().expect("Corners opened");
|
||||
|
|
@ -192,8 +194,25 @@ mod tests {
|
|||
app.ui.dialog.as_mut().unwrap().fields.insert("radius".into(), json!("3 pt"));
|
||||
super::super::confirm(&mut app).unwrap();
|
||||
assert_eq!(corners(&app, id), ([3.0; 4], before.1));
|
||||
// Only live rectangles, and only real corners.
|
||||
// Only paths, and only real corners.
|
||||
assert!(app.run("ui.corners", json!({"id": 9999})).is_err());
|
||||
assert!(app.run("ui.corners", json!({"corners": [7]})).is_err());
|
||||
let e = app.run("shape.ellipse", json!({"x": 0, "y": 0, "width": 50, "height": 30})).unwrap()["id"].as_u64().unwrap();
|
||||
assert!(app.run("ui.corners", json!({"id": e})).is_err());
|
||||
}
|
||||
|
||||
/// #511: a star's corners open in Corners too; OK rounds them.
|
||||
#[test]
|
||||
fn corners_edits_a_star() {
|
||||
let (mut app, _) = app();
|
||||
let id = app.run("shape.star", json!({"cx": 200, "cy": 200, "radius1": 60, "radius2": 30})).unwrap()["id"].as_u64().unwrap();
|
||||
app.run("ui.corners", json!({})).unwrap();
|
||||
let d = app.ui.dialog.as_mut().unwrap();
|
||||
assert_eq!((d.fields.get("corners"), d.f64("radius", -1.0)), (Some(&json!((0..10).collect::<Vec<_>>())), 0.0));
|
||||
d.fields.insert("radius".into(), json!(5));
|
||||
super::super::confirm(&mut app).unwrap();
|
||||
let n = app.session.active().unwrap().doc.node(NodeId(id)).unwrap().clone();
|
||||
assert!(matches!(&n.kind, NodeKind::Path { live: Some(LiveShape::Path { .. }), .. }));
|
||||
assert_eq!(crate::panels::corner_radius(&app, &n), Some(5.0));
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3072,7 +3072,7 @@ axis Both Ambos
|
|||
@msg Convert to Artboards: selection has no area Convertir en mesas de trabajo: la selección no tiene área
|
||||
@msg Convert to Shape: no rectangles or ellipses selected Convertir en forma: no hay rectángulos ni elipses seleccionados
|
||||
@msg Copied the CSS of {rules} object(s) Se copió el CSS de {rules} objeto(s)
|
||||
@msg Corners edits a live rectangle Esquinas edita un rectángulo interactivo
|
||||
@msg Corners edits the corners of a path Esquinas edita las esquinas de un trazado
|
||||
@msg Couldn't copy to the system clipboard: {e} No se pudo copiar al portapapeles del sistema: {e}
|
||||
@msg Couldn't open {name}: {e} No se pudo abrir {name}: {e}
|
||||
@msg Couldn't place {name}: the document it was dropped on was closed No se pudo colocar {name}: se cerró el documento en el que se soltó
|
||||
|
|
@ -3238,7 +3238,7 @@ axis Both Ambos
|
|||
@msg file version {0} is newer than this VectorCraft supports ({VERSION}) la versión de archivo {0} es más reciente de lo que admite este VectorCraft ({VERSION})
|
||||
@msg freeform point {i} needs `at` [x, y] and a valid `color` el punto de forma libre {i} necesita `at` [x, y] y un `color` válido
|
||||
@msg give both `start` and `end` [x, y] (or neither) indica `start` y `end` [x, y] (o ninguno de los dos)
|
||||
@msg give corners 0–3 indica esquinas de 0 a 3
|
||||
@msg give corners of the path: anchors between two straight sides indica esquinas del trazado: puntos de ancla entre dos lados rectos
|
||||
@msg give the path `id` and the width point `index` indica el `id` del trazado y el `index` del punto de anchura
|
||||
@msg guides are locked las guías están bloqueadas
|
||||
@msg image '{key}' has no pixels and was left out la imagen '{key}' no tiene píxeles y se omitió
|
||||
|
|
@ -3422,7 +3422,7 @@ axis Both Ambos
|
|||
@msg select artwork (or a colour group) to recolor selecciona la ilustración (o un grupo de colores) que quieres volver a colorear
|
||||
@msg select at least two objects selecciona al menos dos objetos
|
||||
@msg select objects, not layers selecciona objetos, no capas
|
||||
@msg select one live rectangle, or give its `id` selecciona un rectángulo interactivo o indica su `id`
|
||||
@msg select one path, or give its `id` selecciona un trazado o indica su `id`
|
||||
@msg select paths to join selecciona los trazados que quieres unir
|
||||
@msg select the art to repeat selecciona la ilustración que quieres repetir
|
||||
@msg select the artwork to warp selecciona la ilustración que quieres deformar
|
||||
|
|
|
|||
|
Can't render this file because it contains an unexpected character in line 2 and column 73.
|
|
|
@ -485,7 +485,7 @@ pub const UI_COMMANDS: &[(&str, &str, &str, &str)] = &[
|
|||
"ui.corners",
|
||||
"Corners…",
|
||||
"",
|
||||
"{id?, corners?: [0..3…]} open Corners for live rectangle `id` (default: the selected one) and its corners (0 top-left, 1 top-right, 2 bottom-right, 3 bottom-left; default: the Direct-Selected corners, else all four) (dialog `corners`: kind (round|invertedRound|chamfer), radius (pt); double-clicking a corner widget opens it too): OK runs object.setLiveShape",
|
||||
"{id?, corners?: [i…]} open Corners for path `id` (default: the selected one) and its corners (anchor indices of the path with its corners uncut, as object.setLiveShape takes them: a rectangle's 0 top-left, 1 top-right, 2 bottom-right, 3 bottom-left; default: the Direct-Selected corners, else every corner) (dialog `corners`: kind (round|invertedRound|chamfer), radius (pt); double-clicking a corner widget opens it too): OK runs object.setLiveShape",
|
||||
),
|
||||
(
|
||||
"ui.colorGuideLimit",
|
||||
|
|
|
|||
|
|
@ -45,7 +45,7 @@ pub mod transparency;
|
|||
use egui::{Rect, Sense, Ui, vec2};
|
||||
use serde_json::{Value, json};
|
||||
use vectorcraft_color::{BlendMode, Color, Paint};
|
||||
use vectorcraft_doc::{LiveShape, Node, StrokeLayer};
|
||||
use vectorcraft_doc::{LiveCorners, Node, StrokeLayer};
|
||||
use vectorcraft_engine::inspect::StrokeMixed;
|
||||
|
||||
use crate::theme::Tokens;
|
||||
|
|
@ -57,11 +57,24 @@ pub fn first_selected(app: &VectorcraftApp) -> Option<Node> {
|
|||
first_node(app).cloned()
|
||||
}
|
||||
|
||||
/// The radius the Live Corners of live rectangle `n` show in the panels: that of the corners the
|
||||
/// panels set (the Direct-Selected ones, else all four), blank when they differ.
|
||||
pub(crate) fn corner_radius(app: &VectorcraftApp, n: &Node, live: &LiveShape) -> Option<f64> {
|
||||
/// The radius the Live Corners of path `n` show in the panels: that of the corners the panels set
|
||||
/// (the Direct-Selected ones, else every corner), blank when they differ.
|
||||
pub(crate) fn corner_radius(app: &VectorcraftApp, n: &Node) -> Option<f64> {
|
||||
let partial = app.session.active().and_then(|d| d.selection.partial(n.id));
|
||||
live.corner_style(live.picked_corners(partial)).0
|
||||
let corners = LiveCorners::of(n)?;
|
||||
corners.style(&corners.picked(partial)).0
|
||||
}
|
||||
|
||||
/// The Corner Radius field of a live rectangle's or polygon's properties: [`corner_radius`],
|
||||
/// which a new value sets on those corners.
|
||||
pub(crate) fn corner_radius_row(app: &mut VectorcraftApp, ui: &mut Ui, n: &Node, id: &str) {
|
||||
let units = app.session.general_unit();
|
||||
ui.horizontal(|ui| {
|
||||
dim_label(ui, tl!("Corner Radius:"));
|
||||
if let Some(r) = crate::widgets::num_field(ui, id, corner_radius(app, n), units, 80.0) {
|
||||
app.run("object.setLiveShape", json!({"radius": r})).ok();
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/// Number of selected objects.
|
||||
|
|
|
|||
|
|
@ -2,9 +2,9 @@
|
|||
|
||||
use egui::Ui;
|
||||
use serde_json::json;
|
||||
use vectorcraft_doc::{NodeKind, Unit};
|
||||
use vectorcraft_doc::{LiveShape, NodeKind, Unit};
|
||||
|
||||
use super::{corner_radius, first_selected, pstate, set_pstate};
|
||||
use super::{corner_radius_row, first_selected, pstate, set_pstate};
|
||||
use crate::theme::Tokens;
|
||||
use crate::widgets::{self, dim_label, divider, section_header};
|
||||
use crate::{VectorcraftApp, icons};
|
||||
|
|
@ -93,7 +93,7 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
|
|||
divider(ui);
|
||||
section_header(ui, tl!("Quick Actions"));
|
||||
let is_group = matches!(first.as_ref().map(|n| &n.kind), Some(NodeKind::Group { .. }));
|
||||
let is_live = matches!(first.as_ref().map(|n| &n.kind), Some(NodeKind::Path { live: Some(_), .. }));
|
||||
let is_live = matches!(first.as_ref().map(|n| &n.kind), Some(NodeKind::Path { live: Some(l), .. }) if !matches!(l, LiveShape::Path { .. }));
|
||||
let mut actions: Vec<(&str, &str)> = vec![];
|
||||
if n_sel > 1 {
|
||||
actions.push((tl!("Group"), "object.group"));
|
||||
|
|
@ -335,14 +335,7 @@ pub fn transform_section(app: &mut VectorcraftApp, ui: &mut Ui) {
|
|||
&& let NodeKind::Path { live: Some(live), .. } = &n.kind
|
||||
{
|
||||
match live {
|
||||
vectorcraft_doc::LiveShape::Rectangle { .. } => {
|
||||
ui.horizontal(|ui| {
|
||||
dim_label(ui, tl!("Corner Radius:"));
|
||||
if let Some(r) = widgets::num_field(ui, "radius", corner_radius(app, &n, live), units, 80.0) {
|
||||
app.run("object.setLiveShape", json!({"radius": r})).ok();
|
||||
}
|
||||
});
|
||||
}
|
||||
vectorcraft_doc::LiveShape::Rectangle { .. } => corner_radius_row(app, ui, &n, "radius"),
|
||||
vectorcraft_doc::LiveShape::Polygon { sides, .. } => {
|
||||
ui.horizontal(|ui| {
|
||||
dim_label(ui, tl!("Sides:"));
|
||||
|
|
@ -350,6 +343,7 @@ pub fn transform_section(app: &mut VectorcraftApp, ui: &mut Ui) {
|
|||
app.run("object.setLiveShape", json!({"sides": s as u32})).ok();
|
||||
}
|
||||
});
|
||||
corner_radius_row(app, ui, &n, "radius");
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ use serde_json::json;
|
|||
use vectorcraft_doc::NodeKind;
|
||||
use vectorcraft_geom::Rect;
|
||||
|
||||
use super::{corner_radius, first_selected, pstate, set_pstate};
|
||||
use super::{corner_radius_row, first_selected, pstate, set_pstate};
|
||||
use crate::theme::Tokens;
|
||||
use crate::widgets::{self, menu_item};
|
||||
use crate::{VectorcraftApp, icons};
|
||||
|
|
@ -166,20 +166,16 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
|
|||
app.run("object.reflect", json!({"axis": "horizontal", "origin": origin})).ok();
|
||||
}
|
||||
});
|
||||
// Live shape properties.
|
||||
// Live shape properties (a path with live corners is no shape).
|
||||
if let Some(n) = first_selected(app)
|
||||
&& let NodeKind::Path { live: Some(live), .. } = &n.kind
|
||||
&& !matches!(live, vectorcraft_doc::LiveShape::Path { .. })
|
||||
{
|
||||
widgets::divider(ui);
|
||||
match live {
|
||||
vectorcraft_doc::LiveShape::Rectangle { .. } => {
|
||||
widgets::subheader(ui, tl!("Rectangle Properties:"));
|
||||
ui.horizontal(|ui| {
|
||||
widgets::dim_label(ui, tl!("Corner Radius:"));
|
||||
if let Some(r) = widgets::num_field(ui, "xfp-radius", corner_radius(app, &n, live), units, 80.0) {
|
||||
app.run("object.setLiveShape", json!({"radius": r})).ok();
|
||||
}
|
||||
});
|
||||
corner_radius_row(app, ui, &n, "xfp-radius");
|
||||
}
|
||||
vectorcraft_doc::LiveShape::Polygon { sides, .. } => {
|
||||
widgets::subheader(ui, tl!("Polygon Properties:"));
|
||||
|
|
@ -189,6 +185,7 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
|
|||
app.run("object.setLiveShape", json!({"sides": s.clamp(3.0, 20.0) as u32})).ok();
|
||||
}
|
||||
});
|
||||
corner_radius_row(app, ui, &n, "xfp-radius");
|
||||
}
|
||||
_ => {
|
||||
widgets::subheader(ui, tl!("Shape Properties:"));
|
||||
|
|
|
|||
|
|
@ -291,9 +291,9 @@ Width Point Edit: double-clicking a width point with the Width tool, or `ui.widt
|
|||
value: true}` then confirm (the Delete button) removes the point with `stroke.widthPoint.remove`.
|
||||
|
||||
Corners: double-clicking a Live Corners widget with the Selection or Direct Selection tool, or `ui.corners {id?,
|
||||
corners?}`, opens the `corners` dialog for a live rectangle's corners (the Direct-Selected ones, else all four; fields
|
||||
`id`, `corners`: indices 0–3 clockwise from the top-left, `kind`: round, invertedRound or chamfer, `radius` in points;
|
||||
`kind` or `radius` is absent while the corners differ). `ui.dialog.confirm` runs `object.setLiveShape` with them.
|
||||
corners?}`, opens the `corners` dialog for a path's corners (the Direct-Selected ones, else every corner; fields `id`,
|
||||
`corners`: anchor indices of the path with its corners uncut, a rectangle's 0–3 clockwise from the top-left, `kind`:
|
||||
round, invertedRound or chamfer, `radius` in points; `kind` or `radius` is absent while the corners differ). `ui.dialog.confirm` runs `object.setLiveShape` with them.
|
||||
|
||||
Perspective plane options: double-clicking a plane widget of the perspective grid, or `ui.perspectivePlane {plane}`,
|
||||
opens the `perspectivePlane` dialog (fields `plane`: left, right or ground; `location`: points along the plane's
|
||||
|
|
|
|||
33
docs/mcp.md
33
docs/mcp.md
|
|
@ -1135,21 +1135,32 @@ size. The journal entry of a scaling command records the `strokes` and `corners`
|
|||
|
||||
## Live Corners
|
||||
|
||||
`object.setLiveShape {id?, ids?, radius?, kind?, corners?}` sets the corners of live rectangles (one undo step):
|
||||
`radius` (pt) and `kind` (`round`, `invertedRound` or `chamfer`) go to the `corners` given (0 top-left, 1 top-right,
|
||||
2 bottom-right, 3 bottom-left), else to the corners holding a Direct-Selected anchor (`select.anchors`), else to all
|
||||
four. Each corner keeps its own radius and kind (the shape's `live` in queries has `radii` and, when a corner isn't
|
||||
round, `kinds`); a corner with no radius is one anchor, a cut one two, and Direct-Selected corners stay selected as
|
||||
that changes. Every corner is a circular arc, whatever the rectangle's proportions: a radius past half the shorter
|
||||
side draws at half of it (the same limit for every corner), and a rectangle from a file that kept an uneven scale in its
|
||||
transform (elliptical corners) gets circular ones in document units when its corners are next set. With the Selection or
|
||||
Direct Selection tool, dragging a corner widget rounds the corners whose widgets show (all four, or the Direct-Selected
|
||||
ones), outlining them in red once they reach that limit; Alt-clicking one cycles their kind and double-clicking one
|
||||
opens Corners (`ui.corners {id?, corners?}`, dialog `corners`: `kind`, `radius`; OK runs `object.setLiveShape`).
|
||||
`object.setLiveShape {id?, ids?, radius?, kind?, corners?}` sets the corners of any path (one undo step): a live
|
||||
rectangle's or polygon's, a star's, a pen path's. A corner is an anchor without handles between two straight sides
|
||||
(not an open path's ends, not a smooth anchor, not one the sides run straight on through). `radius` (pt) and `kind`
|
||||
(`round`, `invertedRound` or `chamfer`) go to the `corners` given, else to the corners holding a Direct-Selected
|
||||
anchor (`select.anchors`), else to every corner. `corners` are anchor indices of the path with its corners uncut,
|
||||
counting every subpath's anchors in order: a rectangle's 0 top-left, 1 top-right, 2 bottom-right, 3 bottom-left; a
|
||||
polygon's from its first vertex clockwise; a star's from its first tip; an index past the last anchor is an error.
|
||||
Each corner keeps its own radius and kind (the shape's `live` in queries has `radii` and, when a corner isn't round,
|
||||
`kinds`); a corner with no radius is one anchor, a cut one two, and Direct-Selected corners stay selected as that
|
||||
changes. A path that isn't a live shape keeps its uncut outline (`live` `{"shape": "path", "base", "radii"}`) so its
|
||||
corners stay editable, and is a plain path again once no corner is cut; a polygon stays a live polygon, its corners
|
||||
keeping the radius they shared when `sides` changes. Every corner is a circular arc tangent to both sides: a radius
|
||||
draws no larger than takes the cut halfway along the corner's shorter side (half the shorter side of a rectangle, the
|
||||
same limit for its four corners), the corners stay circular through uneven scales (the radius scales by the mean scale,
|
||||
or keeps its size with Scale Corners off), and a rectangle from a file that kept an uneven scale in its transform
|
||||
(elliptical corners) gets circular ones in document units when its corners are next set. Dragging a corner widget
|
||||
rounds the corners whose widgets show (every corner, or the Direct-Selected ones), outlining in red those that reach
|
||||
their limit; the Selection tool shows the widgets of live rectangles and polygons, the Direct Selection tool those of
|
||||
any path. Alt-clicking one cycles their kind and double-clicking one opens Corners (`ui.corners {id?, corners?}`,
|
||||
dialog `corners`: `kind`, `radius`; OK runs `object.setLiveShape`).
|
||||
|
||||
```json
|
||||
{"name":"run_command","arguments":{"command":"object.setLiveShape","params":{"id":12,"corners":[1],"radius":16}}}
|
||||
{"name":"run_command","arguments":{"command":"object.setLiveShape","params":{"id":12,"corners":[0,3],"radius":8,"kind":"chamfer"}}}
|
||||
{"name":"run_command","arguments":{"command":"shape.star","params":{"cx":200,"cy":200,"radius1":60,"radius2":30}}}
|
||||
{"name":"run_command","arguments":{"command":"object.setLiveShape","params":{"radius":5}}}
|
||||
```
|
||||
|
||||
## Use Preview Bounds
|
||||
|
|
|
|||
Loading…
Reference in New Issue