Merge pull request #8124 from dotCooCoo/feat/radial-repeat-splitter

Repeat: dragging a Radial Repeat's splitter hides instances and the others keep their places
This commit is contained in:
BFlat
2026-11-16 23:07:16 +07:00
committed by GitHub
9 changed files with 944 additions and 5 deletions
+1
View File
@@ -34,6 +34,7 @@ pub mod pie;
pub mod place;
pub mod printtiling;
pub mod repeat_grid;
pub mod repeat_radial;
pub mod rulerguide;
pub mod select;
pub mod settings;
+684
View File
@@ -0,0 +1,684 @@
//! Radial Repeat's on-canvas handles: a handle below the repeat adds or removes instances, a
//! handle on the circle the instances sit on sets its radius, and a splitter on the circle hides
//! instances at the end of the ring while the others keep their places, as the public "Create
//! radial repeats" page describes. Drawing and hit testing share the document-space geometry of
//! [`RadialHandles::of`]; a drag previews the existing Repeat Options command and commits as one
//! undo step.
//!
//! A split ring is kept in the repeat's existing options: `instances` counts the instances shown,
//! and `endAngle` places them a full ring's step apart from `startAngle` (one step past it for a
//! single instance). The full ring's slot count is read back from that step, so dragging the
//! splitter forward shows the hidden instances again.
use serde_json::{Value, json};
use vectorcraft_doc::{Document, NodeId, NodeKind, OrientedBox, RepeatKind, Selection};
use vectorcraft_geom::{Affine, Point, Rect, Vec2};
use crate::bbox::Handle;
use crate::{Action, Cursor, Mods, ToolContext};
/// The radius of the instances, radius and splitter handles (screen points).
pub const HANDLE_RADIUS: f32 = 5.0;
/// How far (screen points) the instances handle sits below the bounding box, clear of its own
/// handles and rotate zones.
pub const HANDLE_GAP: f64 = 22.0;
/// How far (screen points) the instances handle is dragged for each instance it adds or removes.
pub const INSTANCE_STEP: f64 = 16.0;
/// How near (screen points) a press must come to a handle to take it.
const REACH: f64 = 8.0;
/// The most instances a radial repeat has (as `object.repeat.options` accepts them).
const MAX_INSTANCES: f64 = 1000.0;
/// A control of [`RadialHandles`].
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum RadialPart {
/// Below the repeat: drag down for more instances, up for fewer.
Instances,
/// On the circle, between the first two instances: drag outward for a larger radius, inward
/// for a smaller one.
Radius,
/// On the circle, half a step past the last instance shown: drag it back around the circle to
/// hide the instances it passes, forward to show them again.
Splitter,
}
/// The full ring a radial repeat's instances sit on.
#[derive(Clone, Copy, Debug, PartialEq)]
struct Ring {
/// The instances a full turn holds at the repeat's step.
slots: u32,
/// Degrees from one instance to the next (negative when the instances run the other way).
step: f64,
}
impl Ring {
/// The ring of `instances` laid out from `start` to `end` degrees, when their step fits a
/// whole number of times (2 to 1,000, and no fewer than the instances) in a full turn.
fn of(instances: u32, start: f64, end: f64) -> Option<Self> {
let step = instance_step(instances, end - start);
let slots = 360.0 / step.abs();
let whole = slots.round();
((slots - whole).abs() < 1e-6 && (2.0..=MAX_INSTANCES).contains(&whole) && whole >= f64::from(instances))
.then(|| Self { slots: whole as u32, step: (360.0 / whole).copysign(step) })
}
/// The Repeat Options that show the first `shown` instances of the ring (1 to all of them),
/// laid out from `start` degrees.
fn options(&self, shown: u32, start: f64) -> Value {
let shown = shown.clamp(1, self.slots.max(1));
let sweep = if shown == self.slots { 360.0_f64.copysign(self.step) } else { self.step * f64::from(shown.saturating_sub(1).max(1)) };
json!({ "instances": shown, "endAngle": start + sweep })
}
/// The instances shown with the splitter `turn` degrees around the ring from the first
/// instance: those it has passed, one at least and the full ring at most.
fn shown(&self, turn: f64) -> u32 {
let k = (turn / self.step.abs()).floor() + 1.0;
if k.is_nan() { 1 } else { k.clamp(1.0, f64::from(self.slots)) as u32 }
}
}
/// Degrees between neighboring instances, as `repeat_transforms` spaces `instances` over `sweep`.
fn instance_step(instances: u32, sweep: f64) -> f64 {
let full = (sweep.abs() - 360.0).abs() < 1e-9;
if full || instances <= 1 { sweep / f64::from(instances.max(1)) } else { sweep / f64::from(instances - 1) }
}
/// `v` turned by `deg` degrees as `repeat_transforms` turns the instances.
fn turned(v: Vec2, deg: f64) -> Vec2 {
(Affine::rotate(deg.to_radians()) * v.to_point()).to_vec2()
}
/// The direction of `v` in counter-clockwise screen degrees.
fn screen_angle(v: Vec2) -> f64 {
(-v.y).atan2(v.x).to_degrees()
}
/// The controls of a selected radial repeat, in document space.
#[derive(Clone, Copy, Debug)]
pub struct RadialHandles {
pub id: NodeId,
instances: u32,
/// The circle the instances' centers sit on.
pub center: Point,
pub radius: f64,
/// The unit direction from the center to the radius handle.
out: Vec2,
/// Document points of drag for each instance.
step: f64,
start_angle: f64,
ring: Option<Ring>,
pub instances_at: Point,
pub radius_at: Point,
/// Where the splitter is: none when the instances' step does not divide a full turn, for a
/// single instance to a turn, or with a radius of 0.
pub splitter_at: Option<Point>,
}
impl RadialHandles {
/// The controls of a single editable radial repeat selected whole, the instances handle placed
/// below `frame` (the bounding box the Selection tool shows; its geometric bounds without one)
/// at `zoom`.
pub fn of(doc: &Document, selection: &Selection, frame: Option<OrientedBox>, zoom: f64) -> Option<Self> {
let [id] = selection.objects.as_slice() else { return None };
if !selection.anchors.is_empty() || !selection.segments.is_empty() || !doc.is_editable(*id) || !zoom.is_finite() || zoom <= 0.0 {
return None;
}
let n = doc.node(*id)?;
let NodeKind::Repeat(spec) = &n.kind else { return None };
let RepeatKind::Radial { instances, radius, center, start_angle, end_angle, .. } = spec.kind else { return None };
if ![radius, center.x, center.y, start_angle, end_angle].iter().all(|v| v.is_finite()) {
return None;
}
let source = spec.source_bounds()?;
if !finite(source.center()) {
return None;
}
// As `repeat_transforms` lays the instances out: the first one at `start_angle` from the
// source's own direction, the rest a step apart.
let instances = instances.clamp(1, 1000);
let mut d = source.center() - center;
if d.hypot() < 1e-9 {
d = Vec2::new(0.0, -1.0);
}
let first = turned(d.normalize(), start_angle);
let step = instance_step(instances, end_angle - start_angle);
// Halfway between the first two instances; opposite a single one.
let out = turned(first, if instances == 1 { 180.0 } else { step / 2.0 });
let radius = radius.max(0.0);
let ring = Ring::of(instances, start_angle, end_angle);
// Half a step past the last instance shown.
let splitter_at = ring.filter(|_| radius > 0.0).map(|r| center + turned(first, r.step * (f64::from(instances) - 0.5)) * radius);
let frame = match frame {
Some(f) => aabb(f.corners())?,
None => n.geometric_bounds_with(&doc.symbol_boxes())?,
};
let h = Self {
id: *id,
instances,
center,
radius,
out,
step: INSTANCE_STEP / zoom,
start_angle,
ring,
instances_at: Point::new(frame.center().x, frame.y1 + HANDLE_GAP / zoom),
radius_at: center + out * radius,
splitter_at: splitter_at.filter(|p| finite(*p)),
};
(finite(h.instances_at) && finite(h.radius_at) && h.step.is_finite() && h.step > 0.0).then_some(h)
}
/// The controls with where they are.
pub fn parts(&self) -> Vec<(RadialPart, Point)> {
let mut parts = vec![(RadialPart::Instances, self.instances_at), (RadialPart::Radius, self.radius_at)];
parts.extend(self.splitter_at.map(|at| (RadialPart::Splitter, at)));
parts
}
/// The control under `p` (the nearer within reach) and the repeat's controls, unless a
/// bounding-box handle is there, which keeps its scaling.
fn hit(cx: &ToolContext, p: Point) -> Option<(Self, RadialPart)> {
if !cx.show_bbox || !finite(p) {
return None;
}
let h = Self::of(cx.doc, cx.selection, crate::select::selection_box(cx), cx.zoom)?;
let reach = cx.tol(REACH);
let (part, _) =
h.parts().into_iter().map(|(part, q)| (part, q.distance(p))).filter(|(_, d)| *d <= reach).min_by(|a, b| a.1.total_cmp(&b.1))?;
(!crate::select::bbox_handle_at(cx, p)).then_some((h, part))
}
/// The Repeat Options that dragging `part` by `d` (document points) from the press gives;
/// none when the drag is too far to measure. The splitter's options are those it shows at the
/// press.
fn options(&self, part: RadialPart, d: Vec2) -> Option<Value> {
match part {
RadialPart::Instances => {
let n = f64::from(self.instances) + (d.y / self.step).round();
// NaN only comes from an infinite drag; the clamp keeps a huge one at the limit.
(!n.is_nan()).then(|| json!({ "instances": n.clamp(1.0, MAX_INSTANCES) as u32 }))
}
RadialPart::Radius => {
// Only the part of the drag along the line from the center moves the circle.
let r = ((self.radius + d.dot(self.out)).max(0.0) * 100.0).round() / 100.0;
r.is_finite().then(|| json!({ "radius": r }))
}
RadialPart::Splitter => self.ring.map(|r| r.options(self.instances, self.start_angle)),
}
}
/// Degrees around the ring from the first instance to the splitter, in the direction the
/// instances run.
fn splitter_turn(&self) -> f64 {
self.ring.map_or(0.0, |r| (f64::from(self.instances) - 0.5) * r.step.abs())
}
/// The direction of `p` from the center in degrees, as the instances are turned; none at the
/// center.
fn bearing(&self, p: Point) -> Option<f64> {
let v = p - self.center;
(finite(p) && v.hypot() > 1e-9).then(|| v.y.atan2(v.x).to_degrees())
}
/// The direction (counter-clockwise degrees) in which the radius handle moves the circle out.
fn out_angle(&self) -> f64 {
screen_angle(self.out)
}
/// The direction (counter-clockwise degrees) along the circle at the splitter.
fn splitter_angle(&self) -> f64 {
self.splitter_at.map_or(0.0, |at| screen_angle(at - self.center) + 90.0)
}
}
/// The page-square bounds of `corners`.
fn aabb(corners: [Point; 4]) -> Option<Rect> {
let r = corners.iter().skip(1).fold(Rect::from_points(corners[0], corners[0]), |r, p| r.union_pt(*p));
[r.x0, r.y0, r.x1, r.y1].iter().all(|v| v.is_finite()).then_some(r)
}
fn finite(p: Point) -> bool {
p.x.is_finite() && p.y.is_finite()
}
/// The resize cursor of `part`, turned with the view: up and down for the instances handle, along
/// the line from the center for the radius handle, and along the circle for the splitter.
fn part_cursor(cx: &ToolContext, h: &RadialHandles, part: RadialPart) -> Cursor {
match part {
RadialPart::Instances => crate::select::handle_cursor(Handle::Bottom, -cx.view_angle()),
RadialPart::Radius => crate::select::handle_cursor(Handle::Right, h.out_angle() - cx.view_angle()),
RadialPart::Splitter => crate::select::handle_cursor(Handle::Right, h.splitter_angle() - cx.view_angle()),
}
}
/// The cursor over a radial repeat's control at `p`, if one is there.
pub fn cursor(cx: &ToolContext, p: Point) -> Option<Cursor> {
let (h, part) = RadialHandles::hit(cx, p)?;
Some(part_cursor(cx, &h, part))
}
/// A drag of one of a radial repeat's controls.
#[derive(Clone, Debug)]
pub struct RadialDrag {
handles: RadialHandles,
part: RadialPart,
start: Point,
/// The options the press found, and the last ones previewed.
from: Value,
last: Option<Value>,
/// For the splitter: its degrees around the ring from the first instance, and the pointer's
/// last direction from the center.
turn: f64,
bearing: Option<f64>,
}
impl RadialDrag {
pub fn hit(cx: &ToolContext, p: Point, mods: Mods) -> Option<Self> {
if mods.cmd || mods.ctrl || mods.alt {
return None;
}
let (handles, part) = RadialHandles::hit(cx, p)?;
let from = handles.options(part, Vec2::ZERO)?;
Some(Self { handles, part, start: p, from, last: None, turn: handles.splitter_turn(), bearing: handles.bearing(p) })
}
/// Whether the drag has changed the repeat (and so previews it).
pub fn adjusting(&self) -> bool {
self.last.is_some()
}
pub fn cursor(&self, cx: &ToolContext) -> Cursor {
part_cursor(cx, &self.handles, self.part)
}
/// The options of the splitter with the pointer at `p`: it follows the pointer around the
/// circle, each move counted by the shorter way round.
fn split(&mut self, p: Point) -> Option<Value> {
let ring = self.handles.ring?;
if let Some(b) = self.handles.bearing(p) {
if let Some(last) = self.bearing {
self.turn += ((b - last + 180.0).rem_euclid(360.0) - 180.0) * ring.step.signum();
}
self.bearing = Some(b);
}
Some(ring.options(ring.shown(self.turn), self.handles.start_angle))
}
/// Preview the options the pointer at `p` gives, when they change; the first change opens
/// the undo step.
pub fn drag(&mut self, p: Point) -> Vec<Action> {
if !finite(p) {
return vec![];
}
let v = match self.part {
RadialPart::Splitter => self.split(p),
part => self.handles.options(part, p - self.start),
};
let Some(v) = v else { return vec![] };
if self.last.as_ref().unwrap_or(&self.from) == &v {
return vec![];
}
let mut out = vec![];
if self.last.is_none() {
out.push(Action::Begin("Repeat Options".into()));
}
out.push(Action::Preview("object.repeat.options".into(), v.clone()));
self.last = Some(v);
out
}
/// Commit the drag; one that ends where it began leaves no undo step.
pub fn finish(self) -> Vec<Action> {
match self.last {
Some(v) if v == self.from => vec![Action::Cancel],
Some(_) => vec![Action::Commit],
None => vec![],
}
}
pub fn cancel(self) -> Vec<Action> {
if self.last.is_some() { vec![Action::Cancel] } else { vec![] }
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::testutil::{cx, doc_with_rect, paint};
use std::sync::Arc;
use vectorcraft_doc::pattern::RepeatSpec;
/// [`doc_with_rect`]'s 100 × 100 square at (100, 100) as a radial repeat of eight instances
/// with a radius of 100 pt about (150, 250), selected. The instances span (0, 100)–(300, 400).
fn radial() -> (Document, Selection) {
let (mut doc, id) = doc_with_rect();
let mut source = doc.node(id).unwrap().clone();
source.id = doc.alloc_id();
doc.node_mut(id).unwrap().kind = NodeKind::Repeat(RepeatSpec::radial(vec![Arc::new(source)], 8, Some(100.0)));
let mut selection = Selection::default();
selection.set([id]);
(doc, selection)
}
fn set(doc: &mut Document, selection: &Selection, f: impl FnOnce(&mut u32, &mut f64, &mut f64, &mut f64)) {
let NodeKind::Repeat(spec) = &mut doc.node_mut(selection.objects[0]).unwrap().kind else { panic!("a repeat") };
let RepeatKind::Radial { instances, radius, start_angle, end_angle, .. } = &mut spec.kind else { panic!("a radial repeat") };
f(instances, radius, start_angle, end_angle);
}
fn near(a: Point, b: Point) -> bool {
a.distance(b) < 1e-6
}
fn preview(out: &[Action]) -> Option<&Value> {
out.iter().find_map(|a| match a {
Action::Preview(cmd, v) if cmd == "object.repeat.options" => Some(v),
_ => None,
})
}
/// The point on the 100 pt circle about (150, 250) at `deg` degrees clockwise from straight up.
fn on_circle(deg: f64) -> Point {
let a = deg.to_radians();
Point::new(150.0 + 100.0 * a.sin(), 250.0 - 100.0 * a.cos())
}
/// Apply the `instances` and `endAngle` of a preview to the repeat.
fn apply(doc: &mut Document, selection: &Selection, v: &Value) {
let n = v["instances"].as_u64().unwrap() as u32;
let end = v["endAngle"].as_f64().unwrap();
set(doc, selection, |i, _, _, e| (*i, *e) = (n, end));
}
/// Where the repeat's instances are, in paint order.
fn transforms(doc: &Document, selection: &Selection) -> Vec<Affine> {
let NodeKind::Repeat(spec) = &doc.node(selection.objects[0]).unwrap().kind else { panic!("a repeat") };
spec.transforms(Some(doc))
}
/// Drag the splitter from `from` to `to` degrees clockwise from straight up, 5° a move, and
/// return the last preview.
fn sweep(d: &mut RadialDrag, from: f64, to: f64) -> Option<Value> {
let mut last = None;
let moves = ((to - from).abs() / 5.0).ceil() as i32;
for k in 1..=moves {
if let Some(v) = preview(&d.drag(on_circle(from + (to - from) * f64::from(k) / f64::from(moves)))) {
last = Some(v.clone());
}
}
last
}
#[test]
fn the_handles_sit_below_the_repeat_and_on_its_circle_at_every_zoom() {
let (doc, selection) = radial();
// Halfway between the first instance (straight up from the center) and the second, 45°
// clockwise from it.
let on_circle = on_circle(22.5);
for zoom in [0.02, 1.0, 4.0] {
let h = RadialHandles::of(&doc, &selection, None, zoom).unwrap();
assert!(near(h.instances_at, Point::new(150.0, 400.0 + HANDLE_GAP / zoom)), "{zoom}: {:?}", h.instances_at);
assert!(near(h.radius_at, on_circle), "{zoom}: {:?}", h.radius_at);
assert_eq!((h.center, h.radius), (Point::new(150.0, 250.0), 100.0));
}
// Placed below the bounding box the Selection tool shows.
let frame = OrientedBox::aligned(Rect::new(-10.0, 90.0, 310.0, 410.0));
let h = RadialHandles::of(&doc, &selection, Some(frame), 1.0).unwrap();
assert!(near(h.instances_at, Point::new(150.0, 410.0 + HANDLE_GAP)));
}
#[test]
fn the_radius_handle_follows_the_instances_angles() {
let (mut doc, selection) = radial();
// One instance: opposite it.
set(&mut doc, &selection, |n, _, _, _| *n = 1);
let h = RadialHandles::of(&doc, &selection, None, 1.0).unwrap();
assert!(near(h.radius_at, Point::new(150.0, 350.0)), "{:?}", h.radius_at);
// Three instances over a quarter turn from 90°: between those at 90° and 135°.
set(&mut doc, &selection, |n, _, a, b| (*n, *a, *b) = (3, 90.0, 180.0));
let h = RadialHandles::of(&doc, &selection, None, 1.0).unwrap();
let a = 112.5_f64.to_radians();
assert!(near(h.radius_at, Point::new(150.0 + 100.0 * a.sin(), 250.0 - 100.0 * a.cos())), "{:?}", h.radius_at);
// A radius of 0: at the center, still apart from the instances handle.
set(&mut doc, &selection, |_, r, _, _| *r = 0.0);
let h = RadialHandles::of(&doc, &selection, None, 1.0).unwrap();
assert!(near(h.radius_at, Point::new(150.0, 250.0)));
assert!(h.radius_at.distance(h.instances_at) > 2.0 * REACH);
}
#[test]
fn no_handles_without_a_single_valid_radial_repeat() {
let (mut doc, mut selection) = radial();
for zoom in [0.0, -1.0, f64::NAN, f64::INFINITY] {
assert!(RadialHandles::of(&doc, &selection, None, zoom).is_none(), "{zoom}");
}
let paint = paint();
let h = RadialHandles::of(&doc, &selection, None, 1.0).unwrap();
{
let mut c = cx(&doc, &selection, &paint);
assert!(cursor(&c, h.instances_at).is_some());
c.show_bbox = false;
assert!(cursor(&c, h.instances_at).is_none(), "the bounding box is hidden");
}
let id = selection.objects[0];
doc.node_mut(id).unwrap().locked = true;
assert!(RadialHandles::of(&doc, &selection, None, 1.0).is_none(), "a locked repeat");
doc.node_mut(id).unwrap().locked = false;
doc.node_mut(id).unwrap().visible = false;
assert!(RadialHandles::of(&doc, &selection, None, 1.0).is_none(), "a hidden repeat");
doc.node_mut(id).unwrap().visible = true;
for bad in [f64::NAN, f64::INFINITY] {
set(&mut doc, &selection, |_, r, _, _| *r = bad);
assert!(RadialHandles::of(&doc, &selection, None, 1.0).is_none(), "radius {bad}");
set(&mut doc, &selection, |_, r, a, _| (*r, *a) = (100.0, bad));
assert!(RadialHandles::of(&doc, &selection, None, 1.0).is_none(), "start angle {bad}");
set(&mut doc, &selection, |_, _, a, _| *a = 0.0);
}
let other = doc.alloc_id();
let mut second = doc.node(id).unwrap().clone();
second.id = other;
let layer = doc.layers[0].id;
doc.insert(Some(layer), 1, second).unwrap();
selection.set([id, other]);
assert!(RadialHandles::of(&doc, &selection, None, 1.0).is_none(), "two objects selected");
selection.set([id]);
let NodeKind::Repeat(spec) = &mut doc.node_mut(id).unwrap().kind else { panic!("a repeat") };
spec.kind = RepeatKind::Grid {
h_spacing: 10.0,
v_spacing: 10.0,
rows: 3,
cols: 3,
grid_type: Default::default(),
flip_rows: false,
flip_cols: false,
};
assert!(RadialHandles::of(&doc, &selection, None, 1.0).is_none(), "a grid repeat");
}
#[test]
fn dragging_the_instances_handle_steps_the_count() {
let (doc, selection) = radial();
let paint = paint();
let mut c = cx(&doc, &selection, &paint);
let h = RadialHandles::of(&doc, &selection, crate::select::selection_box(&c), 1.0).unwrap();
let mut d = RadialDrag::hit(&c, h.instances_at, Mods::default()).unwrap();
assert!(d.drag(h.instances_at + Vec2::new(0.0, 7.0)).is_empty(), "less than half a step changes nothing");
assert!(!d.adjusting());
// Two steps down, a little sideways: ten instances, one undo step.
let out = d.drag(h.instances_at + Vec2::new(5.0, 32.0));
assert!(matches!(out.first(), Some(Action::Begin(l)) if l == "Repeat Options"), "{out:?}");
assert_eq!(preview(&out), Some(&json!({"instances": 10})));
assert!(d.drag(h.instances_at + Vec2::new(0.0, 36.0)).is_empty(), "the same count isn't previewed again");
assert!(d.adjusting());
assert!(matches!(d.finish().as_slice(), [Action::Commit]));
// Far up: one instance at least; far down: 1,000 at most.
let mut d = RadialDrag::hit(&c, h.instances_at, Mods::default()).unwrap();
assert_eq!(preview(&d.drag(h.instances_at - Vec2::new(0.0, 900.0))), Some(&json!({"instances": 1})));
assert_eq!(preview(&d.drag(h.instances_at + Vec2::new(0.0, 1e300))), Some(&json!({"instances": 1000})));
assert!(d.drag(Point::new(f64::NAN, 0.0)).is_empty(), "a non-finite pointer");
// Back where it began: no undo step.
assert_eq!(preview(&d.drag(h.instances_at)), Some(&json!({"instances": 8})));
assert!(matches!(d.finish().as_slice(), [Action::Cancel]));
// The step is the same on screen at every zoom: 16 px is a quarter point at 64.
c.zoom = 64.0;
let h = RadialHandles::of(&doc, &selection, crate::select::selection_box(&c), c.zoom).unwrap();
let mut d = RadialDrag::hit(&c, h.instances_at, Mods::default()).unwrap();
assert_eq!(preview(&d.drag(h.instances_at - Vec2::new(0.0, 0.25))), Some(&json!({"instances": 7})));
assert!(matches!(d.cancel().as_slice(), [Action::Cancel]));
// Alt, Cmd and Ctrl keep the Selection tool's own gestures.
assert!(RadialDrag::hit(&c, h.instances_at, Mods { alt: true, ..Mods::default() }).is_none());
}
#[test]
fn dragging_the_radius_handle_moves_the_circle_in_and_out() {
let (doc, selection) = radial();
let paint = paint();
let c = cx(&doc, &selection, &paint);
let h = RadialHandles::of(&doc, &selection, crate::select::selection_box(&c), 1.0).unwrap();
let out = (h.radius_at - h.center) / 100.0;
let across = Vec2::new(-out.y, out.x);
let mut d = RadialDrag::hit(&c, h.radius_at, Mods::default()).unwrap();
// 25 pt out and 40 pt across: only the outward part counts.
let o = d.drag(h.radius_at + out * 25.0 + across * 40.0);
assert!(matches!(o.first(), Some(Action::Begin(l)) if l == "Repeat Options"), "{o:?}");
assert_eq!(preview(&o), Some(&json!({"radius": 125.0})));
assert!(d.drag(h.radius_at + across * 30.0).iter().any(|a| matches!(a, Action::Preview(_, v) if v == &json!({"radius": 100.0}))));
// Past the center: a radius of 0.
assert_eq!(preview(&d.drag(h.radius_at - out * 250.0)), Some(&json!({"radius": 0.0})));
// Too far to measure: nothing previewed.
assert!(d.drag(Point::new(f64::MAX, -f64::MAX)).is_empty());
assert!(matches!(d.finish().as_slice(), [Action::Commit]));
// Escape before any change leaves nothing to undo.
let d = RadialDrag::hit(&c, h.radius_at, Mods::default()).unwrap();
assert!(d.cancel().is_empty());
}
#[test]
fn a_bounding_box_handle_wins_where_they_overlap() {
let (doc, selection) = radial();
let paint = paint();
let mut c = cx(&doc, &selection, &paint);
// Zoomed far out (the 300 pt repeat 6 px across), the radius handle lies on a
// bounding-box handle, which keeps its scaling; the instances handle stays clear of the box.
c.zoom = 0.02;
let h = RadialHandles::of(&doc, &selection, crate::select::selection_box(&c), c.zoom).unwrap();
assert!(crate::select::bbox_handle_at(&c, h.radius_at));
assert!(RadialDrag::hit(&c, h.radius_at, Mods::default()).is_none());
assert!(cursor(&c, h.radius_at).is_none());
assert!(!crate::select::bbox_handle_at(&c, h.instances_at));
assert!(RadialDrag::hit(&c, h.instances_at, Mods::default()).is_some());
// At full size both are the repeat's, with resize cursors along their drags.
c.zoom = 1.0;
let h = RadialHandles::of(&doc, &selection, crate::select::selection_box(&c), c.zoom).unwrap();
assert!(RadialDrag::hit(&c, h.radius_at, Mods::default()).is_some());
assert_eq!(cursor(&c, h.instances_at), Some(Cursor::ResizeV));
// The radius handle points 22.5° clockwise from straight up: the up-and-down cursor.
assert_eq!(cursor(&c, h.radius_at), Some(Cursor::ResizeV));
}
#[test]
fn the_splitter_sits_half_a_step_past_the_last_instance_shown() {
let (mut doc, selection) = radial();
// A full ring of eight: between the last instance (315°) and the first.
for zoom in [0.02, 1.0, 4.0] {
let h = RadialHandles::of(&doc, &selection, None, zoom).unwrap();
assert!(near(h.splitter_at.unwrap(), on_circle(337.5)), "{zoom}: {:?}", h.splitter_at);
assert!(h.parts().contains(&(RadialPart::Splitter, h.splitter_at.unwrap())));
}
// Five of the eight shown: past the fifth (180°).
set(&mut doc, &selection, |n, _, _, e| (*n, *e) = (5, 180.0));
let h = RadialHandles::of(&doc, &selection, None, 1.0).unwrap();
assert!(near(h.splitter_at.unwrap(), on_circle(202.5)), "{:?}", h.splitter_at);
// The instances running the other way from 90°: three of six, the splitter at -60 - 30.
set(&mut doc, &selection, |n, _, a, e| (*n, *a, *e) = (3, 90.0, -30.0));
let h = RadialHandles::of(&doc, &selection, None, 1.0).unwrap();
assert!(near(h.splitter_at.unwrap(), on_circle(-60.0)), "{:?}", h.splitter_at);
// One of the eight shown: half a step past it, and the radius handle opposite it.
set(&mut doc, &selection, |n, _, a, e| (*n, *a, *e) = (1, 0.0, 45.0));
let h = RadialHandles::of(&doc, &selection, None, 1.0).unwrap();
assert!(near(h.splitter_at.unwrap(), on_circle(22.5)), "{:?}", h.splitter_at);
assert!(near(h.radius_at, on_circle(180.0)), "{:?}", h.radius_at);
}
#[test]
fn no_splitter_where_the_ring_cannot_be_split() {
let (mut doc, selection) = radial();
// A single instance to a full turn, no turn at all, a step that does not divide a full
// turn, and a radius of 0.
for (n, end, r) in [(1, 360.0, 100.0), (2, 0.0, 100.0), (3, 100.0, 100.0), (8, 360.0, 0.0), (8, f64::MAX, 100.0)] {
set(&mut doc, &selection, |i, rad, _, e| (*i, *rad, *e) = (n, r, end));
let h = RadialHandles::of(&doc, &selection, None, 1.0).unwrap();
assert_eq!(h.splitter_at, None, "{n} over {end}° at {r}");
assert!(!h.parts().iter().any(|(p, _)| *p == RadialPart::Splitter));
}
// Two instances to a turn can be split.
set(&mut doc, &selection, |i, rad, _, e| (*i, *rad, *e) = (2, 100.0, 360.0));
assert!(RadialHandles::of(&doc, &selection, None, 1.0).unwrap().splitter_at.is_some());
}
#[test]
fn dragging_the_splitter_hides_instances_and_the_others_keep_their_places() {
let (mut doc, selection) = radial();
let full = transforms(&doc, &selection);
assert_eq!(full.len(), 8);
let paint = paint();
let (v, mut d) = {
let c = cx(&doc, &selection, &paint);
let h = RadialHandles::of(&doc, &selection, crate::select::selection_box(&c), 1.0).unwrap();
let mut d = RadialDrag::hit(&c, h.splitter_at.unwrap(), Mods::default()).unwrap();
assert!(cursor(&c, h.splitter_at.unwrap()).is_some());
// Back to 320°, short of the last instance: nothing changes.
assert_eq!(sweep(&mut d, 337.5, 320.0), None);
assert!(!d.adjusting());
// Back past the last instance (315°): seven shown, the full ring's step apart.
let out = d.drag(on_circle(300.0));
assert!(matches!(out.first(), Some(Action::Begin(l)) if l == "Repeat Options"), "{out:?}");
let v = preview(&out).unwrap().clone();
assert_eq!(v, json!({"instances": 7, "endAngle": 270.0}));
(v, d)
};
apply(&mut doc, &selection, &v);
let seven = transforms(&doc, &selection);
assert_eq!(seven.len(), 7);
for (k, (a, b)) in seven.iter().zip(&full).enumerate() {
assert!(a.as_coeffs().iter().zip(b.as_coeffs()).all(|(x, y)| (x - y).abs() < 1e-9), "instance {k} kept its place");
}
// Further back, past 0°: one shown at least.
assert_eq!(sweep(&mut d, 300.0, -200.0), Some(json!({"instances": 1, "endAngle": 45.0})));
// Forward again, past the start of the ring: all eight, a full turn.
assert_eq!(sweep(&mut d, -200.0, 400.0), Some(json!({"instances": 8, "endAngle": 360.0})));
assert!(matches!(d.finish().as_slice(), [Action::Cancel]), "back where it began: no undo step");
// From the seven shown, forward past 315°: the eighth shows again where it was.
let c = cx(&doc, &selection, &paint);
let h = RadialHandles::of(&doc, &selection, crate::select::selection_box(&c), 1.0).unwrap();
assert!(near(h.splitter_at.unwrap(), on_circle(292.5)));
let mut d = RadialDrag::hit(&c, h.splitter_at.unwrap(), Mods::default()).unwrap();
let v = sweep(&mut d, 292.5, 330.0).unwrap();
assert_eq!(v, json!({"instances": 8, "endAngle": 360.0}));
assert!(matches!(d.finish().as_slice(), [Action::Commit]));
let mut d = RadialDrag::hit(&c, h.splitter_at.unwrap(), Mods::default()).unwrap();
assert!(d.drag(h.center).is_empty(), "the center gives no direction");
assert_eq!(sweep(&mut d, 292.5, 250.0), Some(json!({"instances": 6, "endAngle": 225.0})));
assert!(matches!(d.cancel().as_slice(), [Action::Cancel]));
apply(&mut doc, &selection, &v);
assert_eq!(transforms(&doc, &selection), full);
}
#[test]
fn the_instances_handle_spreads_a_split_ring_over_the_same_arc() {
let (mut doc, selection) = radial();
// Seven of eight shown: the handle sets the count alone, as for any partial repeat.
set(&mut doc, &selection, |n, _, _, e| (*n, *e) = (7, 270.0));
let paint = paint();
let c = cx(&doc, &selection, &paint);
let h = RadialHandles::of(&doc, &selection, crate::select::selection_box(&c), 1.0).unwrap();
let mut d = RadialDrag::hit(&c, h.instances_at, Mods::default()).unwrap();
assert_eq!(preview(&d.drag(h.instances_at + Vec2::new(0.0, 32.0))), Some(&json!({"instances": 9})));
assert!(matches!(d.finish().as_slice(), [Action::Commit]));
}
}
+38 -2
View File
@@ -147,6 +147,8 @@ enum State {
Mirror(crate::mirror::MirrorDrag),
/// Drag a grid repeat's row, column or corner handle or a spacing slider.
GridRepeat(crate::repeat_grid::GridDrag),
/// Drag a radial repeat's instances or radius handle.
RadialRepeat(crate::repeat_radial::RadialDrag),
/// Dragging a bracket of type on a path.
Bracket(BracketDrag),
/// Dragging a 9-slice guide of the symbol being edited.
@@ -826,6 +828,12 @@ impl Tool for SelectionTool {
{
return d.cancel();
}
if key == ToolKey::Escape
&& matches!(self.state, State::RadialRepeat(_))
&& let State::RadialRepeat(d) = std::mem::take(&mut self.state)
{
return d.cancel();
}
if key == ToolKey::Escape
&& matches!(self.state, State::NineSlice(_))
&& let State::NineSlice(d) = std::mem::take(&mut self.state)
@@ -875,7 +883,7 @@ impl Tool for SelectionTool {
State::Marquee { .. } => key == ToolKey::Letter('e'),
State::Corner(_) => matches!(key, ToolKey::Up | ToolKey::Down),
State::BlendWidget(_) => matches!(key, ToolKey::Up | ToolKey::Down | ToolKey::Left | ToolKey::Right),
State::Loaded { .. } | State::Mirror(_) | State::GridRepeat(_) | State::NineSlice(_) => key == ToolKey::Escape,
State::Loaded { .. } | State::Mirror(_) | State::GridRepeat(_) | State::RadialRepeat(_) | State::NineSlice(_) => key == ToolKey::Escape,
_ => false,
}
}
@@ -917,6 +925,7 @@ impl Tool for SelectionTool {
State::Bracket(b) => b.adjusting(),
State::Mirror(d) => d.adjusting(),
State::GridRepeat(d) => d.adjusting(),
State::RadialRepeat(d) => d.adjusting(),
_ => false,
}
}
@@ -1228,6 +1237,9 @@ impl Tool for SelectionTool {
if let State::GridRepeat(d) = &self.state {
return d.cursor(cx);
}
if let State::RadialRepeat(d) = &self.state {
return d.cursor(cx);
}
if matches!(self.state, State::NineSlice(_)) || (matches!(self.state, State::Idle) && crate::nineslice::over_guide(cx, p)) {
return Cursor::Move;
}
@@ -1235,7 +1247,8 @@ impl Tool for SelectionTool {
&& !m.cmd
&& !m.ctrl
&& !m.alt
&& let Some(cursor) = crate::mirror::cursor(cx, p).or_else(|| crate::repeat_grid::cursor(cx, p))
&& let Some(cursor) =
crate::mirror::cursor(cx, p).or_else(|| crate::repeat_grid::cursor(cx, p)).or_else(|| crate::repeat_radial::cursor(cx, p))
{
return cursor;
}
@@ -1553,6 +1566,21 @@ impl SelectionTool {
_ => return Some(vec![]),
}
}
if let State::RadialRepeat(mut d) = self.state.clone() {
match ev.kind {
PointerKind::Drag | PointerKind::Up => {
let mut out = d.drag(ev.pos);
if ev.kind == PointerKind::Up {
out.extend(d.finish());
self.state = State::Idle;
} else {
self.state = State::RadialRepeat(d);
}
return Some(out);
}
_ => return Some(vec![]),
}
}
if matches!(self.state, State::Idle)
&& ev.kind == PointerKind::Down
&& let Some(d) = crate::mirror::MirrorDrag::hit(cx, ev.pos, ev.mods)
@@ -1569,6 +1597,14 @@ impl SelectionTool {
self.hover = None;
return Some(vec![]);
}
if matches!(self.state, State::Idle)
&& ev.kind == PointerKind::Down
&& let Some(d) = crate::repeat_radial::RadialDrag::hit(cx, ev.pos, ev.mods)
{
self.state = State::RadialRepeat(d);
self.hover = None;
return Some(vec![]);
}
None
}
+2 -1
View File
@@ -78,7 +78,7 @@ use tool_overlays::{DIAL_RADIUS, HiddenMarks};
pub use tool_overlays::{HiddenChars, SpellingMarks};
use tool_overlays::{
grid_repeat_overlay, hidden_chars_overlay, live_paint_gap_overlays, mirror_axis_overlay, nine_slice_overlay, original_path_overlay,
print_tiling_overlay, rotate_view_dial, shaper_widget_overlay, slice_overlay, spelling_overlay, thread_overlays,
print_tiling_overlay, radial_repeat_overlay, rotate_view_dial, shaper_widget_overlay, slice_overlay, spelling_overlay, thread_overlays,
};
pub(crate) use view::animated_zoom;
pub(crate) use view::drag_rotation;
@@ -1347,6 +1347,7 @@ fn selection_visuals(
draw_inside_overlay(app, painter, xf);
mirror_axis_overlay(app, painter, xf);
grid_repeat_overlay(app, painter, xf);
radial_repeat_overlay(app, painter, xf);
if app.ui.view.text_threads {
// Under the tools' overlays: a selected frame's own ports are drawn over its thread's.
let mut threads = thread_overlays(app, xf.zoom);
+183
View File
@@ -4824,6 +4824,189 @@ fn grid_repeat_handles_set_rows_and_spacing_in_one_undo_step_each() {
assert_eq!((grid(&app).0, grid(&app).2), (5, 10.0), "the spacing's own undo step");
}
/// A selected radial repeat draws its instances handle and its radius handle (none with the
/// bounding box hidden). In a zoomed view turned 30°, dragging the instances handle two steps down
/// adds two instances without scaling the source, and dragging the radius handle 20 pt outward
/// makes the circle 20 pt larger, as one undo step each; Escape puts a drag back.
#[test]
fn radial_repeat_handles_set_instances_and_radius_in_one_undo_step_each() {
use vectorcraft_tools::repeat_radial::{HANDLE_RADIUS, INSTANCE_STEP, RadialHandles};
let mut app = VectorcraftApp::new(Session::new(), Default::default());
app.run("file.new", json!({"width": 400, "height": 300})).unwrap();
app.run("shape.rectangle", json!({"x": 180, "y": 40, "width": 40, "height": 40})).unwrap();
app.run("object.repeat.radial", json!({"instances": 6, "radius": 60})).unwrap();
app.ui.task_bar = false;
app.ui.view.rulers = false;
let ctx = egui::Context::default();
// The first frame fits the artboard in the window; then zoom to 1.5 px a point and turn 30°.
frame(&mut app, &ctx, vec![]);
app.view_mut().unwrap().zoom = 1.5;
app.view_mut().unwrap().rotation = 30.0;
frame(&mut app, &ctx, vec![]);
// Instances, radius and the source's bounds.
let radial = |app: &VectorcraftApp| {
let st = app.session.active().unwrap();
let n = st.doc.node(st.selection.objects[0]).unwrap();
let vectorcraft_doc::NodeKind::Repeat(spec) = &n.kind else { panic!("a repeat") };
let vectorcraft_doc::RepeatKind::Radial { instances, radius, .. } = spec.kind else { panic!("a radial repeat") };
(instances, radius, spec.source_bounds().unwrap())
};
let handles = |app: &mut VectorcraftApp| {
let frame = app.selection_box();
let st = app.session.active().unwrap();
RadialHandles::of(&st.doc, &st.selection, frame, app.view().unwrap().zoom).unwrap()
};
let before = radial(&app);
assert_eq!((before.0, before.1), (6, 60.0));
let h = handles(&mut app);
let xf = Xf::new(app.canvas_rect.unwrap(), app.view().unwrap());
let circle_at =
|drawn: &[Shape], at: Pos2| drawn.iter().any(|s| matches!(s, Shape::Circle(c) if c.center.distance(at) < 0.01 && c.radius == HANDLE_RADIUS));
let drawn = shapes(&mut app, &ctx);
assert!(circle_at(&drawn, xf.to_screen(h.instances_at)), "the instances handle is drawn");
assert!(circle_at(&drawn, xf.to_screen(h.radius_at)), "the radius handle is drawn");
app.ui.view.bounding_box = false;
let drawn = shapes(&mut app, &ctx);
assert!(!circle_at(&drawn, xf.to_screen(h.instances_at)) && !circle_at(&drawn, xf.to_screen(h.radius_at)), "hidden with the bounding box");
app.ui.view.bounding_box = true;
frame(&mut app, &ctx, vec![]);
let button = |pos, pressed| egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() };
let drag = |app: &mut VectorcraftApp, from: Pos2, to: Pos2| {
frame(app, &ctx, vec![egui::Event::PointerMoved(from), button(from, true)]);
for k in 1..=4 {
frame(app, &ctx, vec![egui::Event::PointerMoved(from + (to - from) * k as f32 / 4.0)]);
}
};
let release = |app: &mut VectorcraftApp, at: Pos2| frame(app, &ctx, vec![button(at, false)]);
// 2.2 steps down the page (the screen's down turned 30°): two more instances.
let to = xf.to_screen(h.instances_at + vectorcraft_geom::Vec2::new(0.0, 2.2 * INSTANCE_STEP / 1.5));
drag(&mut app, xf.to_screen(h.instances_at), to);
assert_eq!(radial(&app).0, 8, "the drag previews");
release(&mut app, to);
let after = radial(&app);
assert_eq!((after.0, after.1), (8, 60.0));
assert_eq!(after.2, before.2, "the source keeps its size");
app.run("edit.undo", json!({})).unwrap();
assert_eq!(radial(&app).0, 6, "one undo step");
app.run("edit.redo", json!({})).unwrap();
assert_eq!(radial(&app).0, 8);
// 20 pt outward from the center.
frame(&mut app, &ctx, vec![]);
let h = handles(&mut app);
let out = (h.radius_at - h.center) / h.radius;
let to = xf.to_screen(h.radius_at + out * 20.0);
drag(&mut app, xf.to_screen(h.radius_at), to);
release(&mut app, to);
assert_eq!((radial(&app).0, radial(&app).1), (8, 80.0));
assert_eq!(radial(&app).2, before.2, "the source keeps its size");
app.run("edit.undo", json!({})).unwrap();
assert_eq!((radial(&app).0, radial(&app).1), (8, 60.0), "the radius's own undo step");
// Escape during a drag puts the radius back and leaves no undo step.
frame(&mut app, &ctx, vec![]);
let h = handles(&mut app);
drag(&mut app, xf.to_screen(h.radius_at), xf.to_screen(h.radius_at + out * 30.0));
assert_eq!(radial(&app).1, 90.0, "the drag previews");
let escape = egui::Event::Key { key: egui::Key::Escape, physical_key: None, pressed: true, repeat: false, modifiers: Default::default() };
let screen = egui::Rect::from_min_size(Pos2::ZERO, vec2(800.0, 600.0));
let mut full = ctx.run_ui(egui::RawInput { screen_rect: Some(screen), events: vec![escape], ..Default::default() }, |ui| {
crate::shortcuts::handle(&mut app, ui.ctx());
show(&mut app, ui)
});
full.textures_delta.clear();
assert_eq!(radial(&app).1, 60.0);
release(&mut app, xf.to_screen(h.radius_at + out * 30.0));
assert_eq!(radial(&app).1, 60.0, "the release after Escape changes nothing");
app.run("edit.undo", json!({})).unwrap();
assert_eq!(radial(&app).0, 6, "the instances step is the one before");
}
/// A selected radial repeat draws its splitter on its circle. In a zoomed view turned 30°,
/// dragging the splitter back around the circle past two instances hides them while the other
/// four stay where they were, as one undo step; Escape puts a drag back.
#[test]
fn radial_repeat_splitter_hides_instances_in_one_undo_step() {
use vectorcraft_geom::Affine;
use vectorcraft_tools::repeat_radial::{HANDLE_RADIUS, RadialHandles};
let mut app = VectorcraftApp::new(Session::new(), Default::default());
app.run("file.new", json!({"width": 400, "height": 300})).unwrap();
app.run("shape.rectangle", json!({"x": 180, "y": 40, "width": 40, "height": 40})).unwrap();
app.run("object.repeat.radial", json!({"instances": 6, "radius": 60})).unwrap();
app.ui.task_bar = false;
app.ui.view.rulers = false;
let ctx = egui::Context::default();
frame(&mut app, &ctx, vec![]);
app.view_mut().unwrap().zoom = 1.5;
app.view_mut().unwrap().rotation = 30.0;
frame(&mut app, &ctx, vec![]);
// Instances shown, end angle and where the instances are.
let radial = |app: &VectorcraftApp| {
let st = app.session.active().unwrap();
let n = st.doc.node(st.selection.objects[0]).unwrap();
let vectorcraft_doc::NodeKind::Repeat(spec) = &n.kind else { panic!("a repeat") };
let vectorcraft_doc::RepeatKind::Radial { instances, end_angle, .. } = spec.kind else { panic!("a radial repeat") };
(instances, end_angle, spec.transforms(Some(&st.doc)))
};
let handles = |app: &mut VectorcraftApp| {
let frame = app.selection_box();
let st = app.session.active().unwrap();
RadialHandles::of(&st.doc, &st.selection, frame, app.view().unwrap().zoom).unwrap()
};
// `h`'s splitter turned `deg` degrees about the center (positive: the way the instances run).
let around =
|h: &RadialHandles, deg: f64| h.center + (Affine::rotate(deg.to_radians()) * (h.splitter_at.unwrap() - h.center).to_point()).to_vec2();
let before = radial(&app);
assert_eq!((before.0, before.1, before.2.len()), (6, 360.0, 6));
let h = handles(&mut app);
let xf = Xf::new(app.canvas_rect.unwrap(), app.view().unwrap());
let drawn = shapes(&mut app, &ctx);
let at = xf.to_screen(h.splitter_at.unwrap());
assert!(
drawn.iter().any(|s| matches!(s, Shape::Circle(c) if c.center.distance(at) < 0.01 && c.radius == HANDLE_RADIUS)),
"the splitter is drawn"
);
frame(&mut app, &ctx, vec![]);
let button = |pos, pressed| egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() };
let drag = |app: &mut VectorcraftApp, from: Pos2, to: Pos2| {
frame(app, &ctx, vec![egui::Event::PointerMoved(from), button(from, true)]);
for k in 1..=4 {
frame(app, &ctx, vec![egui::Event::PointerMoved(from + (to - from) * k as f32 / 4.0)]);
}
};
let release = |app: &mut VectorcraftApp, at: Pos2| frame(app, &ctx, vec![button(at, false)]);
// Back 120° (two instances 60° apart): four shown, the rest in place.
let to = xf.to_screen(around(&h, -120.0));
drag(&mut app, xf.to_screen(h.splitter_at.unwrap()), to);
assert_eq!(radial(&app).0, 4, "the drag previews");
release(&mut app, to);
let after = radial(&app);
assert_eq!((after.0, after.1, after.2.len()), (4, 180.0, 4));
for (k, (a, b)) in after.2.iter().zip(&before.2).enumerate() {
assert!(a.as_coeffs().iter().zip(b.as_coeffs()).all(|(x, y)| (x - y).abs() < 1e-9), "instance {k} stays where it was");
}
app.run("edit.undo", json!({})).unwrap();
assert_eq!((radial(&app).0, radial(&app).1), (6, 360.0), "one undo step");
app.run("edit.redo", json!({})).unwrap();
assert_eq!((radial(&app).0, radial(&app).1), (4, 180.0));
// Escape during a drag forward puts the split back and leaves no undo step.
frame(&mut app, &ctx, vec![]);
let h = handles(&mut app);
let to = xf.to_screen(around(&h, 120.0));
drag(&mut app, xf.to_screen(h.splitter_at.unwrap()), to);
assert_eq!((radial(&app).0, radial(&app).1), (6, 360.0), "the drag previews");
let escape = egui::Event::Key { key: egui::Key::Escape, physical_key: None, pressed: true, repeat: false, modifiers: Default::default() };
let screen = egui::Rect::from_min_size(Pos2::ZERO, vec2(800.0, 600.0));
let mut full = ctx.run_ui(egui::RawInput { screen_rect: Some(screen), events: vec![escape], ..Default::default() }, |ui| {
crate::shortcuts::handle(&mut app, ui.ctx());
show(&mut app, ui)
});
full.textures_delta.clear();
assert_eq!((radial(&app).0, radial(&app).1), (4, 180.0));
release(&mut app, to);
assert_eq!(radial(&app).0, 4, "the release after Escape changes nothing");
app.run("edit.undo", json!({})).unwrap();
assert_eq!((radial(&app).0, radial(&app).1), (6, 360.0), "the split was the step before");
}
/// While a symbol with 9-slice guides is edited, the canvas draws its four guides dotted across
/// its art, with ruler guides hidden too, and none once the mode ends. Dragging the left guide in
/// a zoomed view moves that guide alone, as one undo step.
@@ -535,6 +535,38 @@ pub(super) fn grid_repeat_overlay(app: &mut VectorcraftApp, p: &egui::Painter, x
}
}
/// A selected radial repeat's circle with its radius handle and its splitter on it, and its
/// instances handle below it, at the places the Selection tool's hit testing finds them. The
/// splitter also has a short line across the circle.
pub(super) fn radial_repeat_overlay(app: &mut VectorcraftApp, p: &egui::Painter, xf: &Xf) {
use vectorcraft_tools::repeat_radial::{HANDLE_RADIUS, RadialHandles, RadialPart};
if app.session.tool_id() != "selection" || !app.ui.view.bounding_box {
return;
}
let frame = app.selection_box();
let Some(st) = app.session.active() else { return };
let Some(h) = RadialHandles::of(&st.doc, &st.selection, frame, xf.zoom) else { return };
let t = Tokens::get(p.ctx());
// The circle the instances' centers sit on, while it is a sensible size on screen.
let (c, r) = (xf.to_screen(h.center), (h.radius * xf.zoom) as f32);
if c.is_finite() && r.is_finite() && r > 0.5 && r < 20_000.0 {
p.circle_stroke(c, r, Stroke::new(3.0, t.measure_bg));
p.circle_stroke(c, r, Stroke::new(1.0, t.selection));
}
for (part, at) in h.parts() {
let c = xf.to_screen(at);
let across = (c - xf.to_screen(h.center)).normalized() * (HANDLE_RADIUS + 4.0);
if part == RadialPart::Splitter && c.is_finite() && across.is_finite() {
p.line_segment([c - across, c + across], Stroke::new(3.0, t.measure_bg));
p.line_segment([c - across, c + across], Stroke::new(1.5, t.selection));
}
if c.is_finite() {
p.circle_filled(c, HANDLE_RADIUS, t.measure_bg);
p.circle_stroke(c, HANDLE_RADIUS, Stroke::new(2.0, t.selection));
}
}
}
/// The radius of the Rotate View dial, in screen points.
pub(super) const DIAL_RADIUS: f32 = 40.0;