mirror of
https://github.com/storytold/vectorcraft.git
synced 2026-11-19 03:08:00 +00:00
2273 lines
115 KiB
Rust
2273 lines
115 KiB
Rust
//! The Objects on Path tool (#2545): a click on a path attaches the selected objects to it
|
||
//! (`object.objectsOnPath.attach`). A path they can attach to is highlighted under the pointer,
|
||
//! and the pointer shows [`Cursor::ObjectsOnPath`] over it. The tool's options, `pivot` (0-8, row
|
||
//! by row from the top left; 4, the center) and `rotate` (degrees), go with each attach, so they
|
||
//! set how the objects attached next attach; groups attached before keep theirs.
|
||
//!
|
||
//! The Rotate All widget: with one Objects on Path group selected, the Selection tool and this
|
||
//! tool show a round handle beside the group's first object. Dragging it turns every object of the
|
||
//! group about its attachment point by the angle the pointer turns about the first object's
|
||
//! attachment point: the angle is added to the group's Rotate (`object.objectsOnPath.options`),
|
||
//! previewed while dragging and kept as one undo step on release. Shift turns in steps of 15°, and
|
||
//! Escape cancels the drag.
|
||
//!
|
||
//! The Space widget: with one Objects on Path group of two or more objects selected, the same
|
||
//! tools show a square handle beyond the group's last object, ahead along the path. Dragging it
|
||
//! along the path sets the distance between the objects' attachment points
|
||
//! (`object.objectsOnPath.options` with `spacing` and `start`): the first object stays where it is
|
||
//! and the others move toward or away from it. With Alt (Option on macOS) the objects spread from
|
||
//! both ends toward or away from the center of an open path, or of the first anchor of a closed
|
||
//! one. The distance shows next to the pointer in the document's units, the drag is previewed and
|
||
//! kept as one undo step on release, and Escape cancels it.
|
||
//!
|
||
//! The Move All widget: with one Objects on Path group selected whose objects have room to move
|
||
//! along its path, the same tools show a diamond beyond the group's first object, below it.
|
||
//! Dragging it along the path moves every object along it as far, keeping the distances between
|
||
//! them (`object.objectsOnPath.options` with `start`). On an open path, the widget shows only when
|
||
//! the distance from the first object to the last is shorter than the path, and the objects stop
|
||
//! at its ends; on a closed path they go on round across its first anchor. The first object's
|
||
//! distance along the path shows next to the pointer in the document's units, the drag is
|
||
//! previewed and kept as one undo step on release, and Escape cancels it.
|
||
//!
|
||
//! The Select/Move widgets: with one Objects on Path group selected, the same tools show a small
|
||
//! ring on each object's attachment point, highlighted under the pointer. A click on one chooses
|
||
//! that object (`object.objectsOnPath.selectMember`), and its ring is filled; the group stays
|
||
//! selected, and a click on the object's art still selects the group. Dragging a ring along the
|
||
//! path moves its object to the place of the object nearest the pointer, and the objects between
|
||
//! move one place toward where it was (`object.objectsOnPath.moveMember`): only their order along
|
||
//! the path changes, and hidden and locked objects keep their places. On an open path a pointer beyond an end takes the place at that end; on a
|
||
//! closed path the drag goes on round across the first anchor. The drag is previewed and kept as
|
||
//! one undo step on release, and Escape cancels it.
|
||
//!
|
||
//! Behavior: <https://helpx.adobe.com/illustrator/using/objects-on-path.html>,
|
||
//! <https://helpx.adobe.com/illustrator/desktop/manage-objects/arrange-objects/rearrange-and-edit-objects-on-a-path.html>.
|
||
|
||
use std::sync::Arc;
|
||
|
||
use serde_json::{Value, json};
|
||
use vectorcraft_doc::objects_on_path::{
|
||
CENTER, Measured, Member, ObjectsOnPath, attachable, attachable_path, is_objects_on_path, layout, nth_length,
|
||
};
|
||
use vectorcraft_doc::{Document, Node, NodeId, Selection};
|
||
use vectorcraft_geom::{BezPath, PathData, Point, Vec2};
|
||
|
||
use crate::{Action, Cursor, Mods, Overlay, PointerEvent, PointerKind, Tool, ToolContext, ToolKey};
|
||
|
||
/// The highlight of the path under the pointer.
|
||
const HIGHLIGHT: [u8; 3] = [0x4f, 0x9d, 0xff];
|
||
|
||
/// The Rotate All widget's center sits this far (screen px) beyond the first object, on the side
|
||
/// its top faces.
|
||
const ROTATE_ALL_OFFSET_PX: f64 = 16.0;
|
||
/// The Rotate All widget's radius (screen px), as the canvas draws it.
|
||
pub const ROTATE_ALL_RADIUS_PX: f32 = 4.0;
|
||
/// How near (screen px) the pointer must be to hit the Rotate All widget.
|
||
const ROTATE_ALL_HIT_PX: f64 = 6.0;
|
||
/// The step (degrees) a Shift-drag of the Rotate All widget turns by.
|
||
const ROTATE_ALL_STEP: f64 = 15.0;
|
||
|
||
/// The Space widget's center sits this far (screen px) beyond the last object, ahead along the path.
|
||
const SPACE_OFFSET_PX: f64 = 16.0;
|
||
/// Half the side of the Space widget's square (screen px), as the canvas draws it.
|
||
pub const SPACE_HALF_PX: f32 = 3.5;
|
||
/// How near (screen px) the pointer must be to hit the Space widget.
|
||
const SPACE_HIT_PX: f64 = 6.0;
|
||
|
||
/// The Move All widget's center sits this far (screen px) beyond the first object, on the side its
|
||
/// bottom faces.
|
||
const MOVE_ALL_OFFSET_PX: f64 = 16.0;
|
||
/// Half the diagonal of the Move All widget's diamond (screen px), as the canvas draws it.
|
||
pub const MOVE_ALL_HALF_PX: f32 = 4.5;
|
||
/// How near (screen px) the pointer must be to hit the Move All widget.
|
||
const MOVE_ALL_HIT_PX: f64 = 6.0;
|
||
|
||
/// The radius (screen px) of the Select/Move widget's ring, as the canvas draws it.
|
||
pub const MEMBER_RADIUS_PX: f32 = 4.5;
|
||
/// How near (screen px) the pointer must be to hit a Select/Move widget.
|
||
const MEMBER_HIT_PX: f64 = 6.0;
|
||
|
||
/// An Objects on Path group the widgets show for, with its record, its children, its path and the
|
||
/// path measured: one flattening serves every widget of the group.
|
||
struct Group<'a> {
|
||
id: NodeId,
|
||
rec: &'a ObjectsOnPath,
|
||
children: &'a [Arc<Node>],
|
||
path: &'a PathData,
|
||
measured: Arc<Measured>,
|
||
}
|
||
|
||
/// The Objects on Path group the widgets show for at `zoom` (screen px per document point): only
|
||
/// when the selection is that one editable group, on a path with length, and no anchors are
|
||
/// Direct-Selected.
|
||
fn one_group<'a>(doc: &'a Document, selection: &Selection, zoom: f64) -> Option<Group<'a>> {
|
||
if !selection.anchors.is_empty() || !zoom.is_finite() || zoom <= 0.0 {
|
||
return None;
|
||
}
|
||
let [group] = selection.objects.as_slice() else { return None };
|
||
if !doc.editable()(*group) {
|
||
return None;
|
||
}
|
||
let n = doc.node(*group)?;
|
||
let rec = n.extras().objects_on_path.as_deref()?;
|
||
let children = n.children()?;
|
||
let (path, measured) = attachable(children.iter().find(|c| c.id == rec.path)?)?;
|
||
Some(Group { id: *group, rec, children: children.as_slice(), path, measured: Arc::new(measured) })
|
||
}
|
||
|
||
/// The path of an Objects on Path group as measured when a widget drag began, kept for the drag:
|
||
/// the previews change the group's record and its objects, not its path.
|
||
#[derive(Clone, Debug)]
|
||
struct Kept {
|
||
group: NodeId,
|
||
path: PathData,
|
||
measured: Arc<Measured>,
|
||
}
|
||
|
||
impl Kept {
|
||
fn of(g: &Group) -> Self {
|
||
Self { group: g.id, path: g.path.clone(), measured: Arc::clone(&g.measured) }
|
||
}
|
||
|
||
/// The group's path in `doc` measured: the kept measurement while the path is as it was, else
|
||
/// the path measured again and kept. `None` when the group no longer has a path with length.
|
||
fn now(&mut self, doc: &Document) -> Option<Arc<Measured>> {
|
||
let n = doc.node(self.group)?;
|
||
let rec = n.extras().objects_on_path.as_deref()?;
|
||
let node = n.children()?.iter().find(|c| c.id == rec.path)?;
|
||
if let vectorcraft_doc::NodeKind::Path { path, guide: false, .. } = &node.kind
|
||
&& *path == self.path
|
||
{
|
||
return Some(Arc::clone(&self.measured));
|
||
}
|
||
let (path, measured) = attachable(node)?;
|
||
*self = Self { group: self.group, path: path.clone(), measured: Arc::new(measured) };
|
||
Some(Arc::clone(&self.measured))
|
||
}
|
||
}
|
||
|
||
/// The direction the top of the object `m` faces: the -y direction of the frame it is drawn in
|
||
/// (the document's y axis points down), so a reflected or sheared frame turns it with the art's
|
||
/// top. A unit vector in the document's axes.
|
||
fn top(m: &Member) -> Vec2 {
|
||
let [_, _, a2, a3, _, _] = m.frame.as_coeffs();
|
||
let len = a2.hypot(a3);
|
||
if len.is_finite() && len > 1e-12 {
|
||
Vec2::new(-a2 / len, -a3 / len)
|
||
} else {
|
||
let (sin, cos) = m.angle.sin_cos();
|
||
Vec2::new(sin, -cos)
|
||
}
|
||
}
|
||
|
||
/// The point `gap` (points) beyond the bounds of the object `m` (one of `children`), from its
|
||
/// attachment point `from` in the direction `dir`. `None` when it is not finite.
|
||
fn beside(doc: &Document, children: &[std::sync::Arc<Node>], m: &Member, from: Point, dir: Vec2, gap: f64) -> Option<Point> {
|
||
let b = children.iter().find(|c| c.id == m.id)?.geometric_bounds_with(&doc.symbol_boxes())?;
|
||
let corners = [Point::new(b.x0, b.y0), Point::new(b.x1, b.y0), Point::new(b.x0, b.y1), Point::new(b.x1, b.y1)];
|
||
let reach = corners.iter().map(|c| (*c - from).dot(dir)).fold(0.0, f64::max);
|
||
let at = from + dir * (reach + gap);
|
||
(at.x.is_finite() && at.y.is_finite() && from.x.is_finite() && from.y.is_finite()).then_some(at)
|
||
}
|
||
|
||
/// The Rotate All widget of a selected Objects on Path group.
|
||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||
pub struct RotateAllWidget {
|
||
pub group: NodeId,
|
||
/// The first object's attachment point, in the document: a drag turns about it.
|
||
pub pivot: Point,
|
||
/// The widget's center in the document.
|
||
pub at: Point,
|
||
/// The group's Rotate (degrees).
|
||
pub rotate: f64,
|
||
}
|
||
|
||
impl RotateAllWidget {
|
||
/// The widget of the selection at `zoom` (screen px per document point): only when the
|
||
/// selection is one editable Objects on Path group with at least one object on a path with
|
||
/// length, and no anchors are Direct-Selected.
|
||
pub fn of(doc: &Document, selection: &Selection, zoom: f64) -> Option<Self> {
|
||
Self::in_group(doc, &one_group(doc, selection, zoom)?, zoom)
|
||
}
|
||
|
||
/// The widget of the group `g`.
|
||
fn in_group(doc: &Document, g: &Group, zoom: f64) -> Option<Self> {
|
||
let rec = g.rec;
|
||
let first = rec.members.first()?;
|
||
let (pivot, _) = g.measured.stop(rec.members.len(), rec.spacing, rec.start, 0)?;
|
||
let at = beside(doc, g.children, first, pivot, top(first), ROTATE_ALL_OFFSET_PX / zoom)?;
|
||
Some(Self { group: g.id, pivot, at, rotate: rec.rotate })
|
||
}
|
||
|
||
/// The widget of the group `g` of `cx` when `p` is within reach of it.
|
||
fn at_point(cx: &ToolContext, g: &Group, p: Point) -> Option<Self> {
|
||
Self::in_group(cx.doc, g, cx.zoom).filter(|w| w.at.distance(p) <= cx.tol(ROTATE_ALL_HIT_PX))
|
||
}
|
||
}
|
||
|
||
/// Is `p` over the Rotate All widget?
|
||
pub fn over_rotate_all(cx: &ToolContext, p: Point) -> bool {
|
||
one_group(cx.doc, cx.selection, cx.zoom).and_then(|g| RotateAllWidget::at_point(cx, &g, p)).is_some()
|
||
}
|
||
|
||
/// Dragging the Rotate All widget: the group's Rotate follows the angle the pointer turns about
|
||
/// the first object's attachment point, counter-clockwise on the page, over as many turns as the
|
||
/// drag makes.
|
||
#[derive(Clone, Debug)]
|
||
pub struct RotateAllDrag {
|
||
widget: RotateAllWidget,
|
||
start: Point,
|
||
began: bool,
|
||
/// The pointer's direction from the pivot at the last drag (radians, the document's axes).
|
||
last: f64,
|
||
/// The degrees the pointer has turned counter-clockwise on the page since the press.
|
||
turned: f64,
|
||
/// The Rotate the drag sets.
|
||
rotate: f64,
|
||
at: Point,
|
||
}
|
||
|
||
impl RotateAllDrag {
|
||
/// The drag has left the click: the angle is changing.
|
||
pub fn adjusting(&self) -> bool {
|
||
self.began
|
||
}
|
||
|
||
/// Start a drag when the press `ev` is on the Rotate All widget.
|
||
pub fn hit(cx: &ToolContext, ev: &PointerEvent) -> Option<Self> {
|
||
Self::hit_in(cx, &one_group(cx.doc, cx.selection, cx.zoom)?, ev)
|
||
}
|
||
|
||
/// [`RotateAllDrag::hit`] on the group `g` of `cx`.
|
||
fn hit_in(cx: &ToolContext, g: &Group, ev: &PointerEvent) -> Option<Self> {
|
||
let widget = RotateAllWidget::at_point(cx, g, ev.pos)?;
|
||
let d = ev.pos - widget.pivot;
|
||
let last = d.y.atan2(d.x);
|
||
let last = if last.is_finite() { last } else { 0.0 };
|
||
Some(Self { widget, start: ev.pos, began: false, last, turned: 0.0, rotate: widget.rotate, at: ev.pos })
|
||
}
|
||
|
||
/// The pointer moved to `p`; `shift` turns in steps of 15°.
|
||
pub fn drag(&mut self, cx: &ToolContext, p: Point, shift: bool) -> Vec<Action> {
|
||
let mut out = vec![];
|
||
if !self.began {
|
||
if p.distance(self.start) < cx.tol(3.0) {
|
||
return out;
|
||
}
|
||
self.began = true;
|
||
out.push(Action::Begin("Objects on Path Options".into()));
|
||
}
|
||
let d = p - self.widget.pivot;
|
||
if d.hypot() > 1e-9 {
|
||
let now = d.y.atan2(d.x);
|
||
let step = (now - self.last + std::f64::consts::PI).rem_euclid(std::f64::consts::TAU) - std::f64::consts::PI;
|
||
if step.is_finite() {
|
||
self.turned -= step.to_degrees();
|
||
self.last = now;
|
||
}
|
||
}
|
||
let turned = if shift { (self.turned / ROTATE_ALL_STEP).round() * ROTATE_ALL_STEP } else { self.turned };
|
||
let r = self.widget.rotate + turned;
|
||
self.rotate = if r.abs() > 360.0 { r % 360.0 } else { r } + 0.0;
|
||
self.at = p;
|
||
out.push(Action::Preview("object.objectsOnPath.options".into(), json!({ "ids": [self.widget.group.0], "rotate": self.rotate })));
|
||
out
|
||
}
|
||
|
||
pub fn finish(self) -> Vec<Action> {
|
||
if self.began { vec![Action::Commit] } else { vec![] }
|
||
}
|
||
|
||
/// The Rotate readout next to the pointer.
|
||
pub fn overlays(&self, cx: &ToolContext) -> Vec<Overlay> {
|
||
if !self.began || !cx.measurement_labels {
|
||
return vec![];
|
||
}
|
||
vec![Overlay::Measure { p: self.at, text: format!("{:.1}°", self.rotate) }]
|
||
}
|
||
}
|
||
|
||
/// The Space widget of a selected Objects on Path group.
|
||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||
pub struct SpaceWidget {
|
||
pub group: NodeId,
|
||
/// The last object's attachment point, in the document.
|
||
pub last: Point,
|
||
/// The distance along the path to the last object's attachment point (points).
|
||
pub last_length: f64,
|
||
/// The widget's center in the document.
|
||
pub at: Point,
|
||
/// The path's direction at the last object's attachment point: a unit vector in the
|
||
/// document's axes, in which the widget sits beyond the object.
|
||
pub dir: Vec2,
|
||
/// The length of the path (points).
|
||
pub len: f64,
|
||
/// Is the path closed?
|
||
pub closed: bool,
|
||
/// The number of objects on the path: 2 or more.
|
||
pub count: usize,
|
||
/// Where the first object attaches along the path (points from its first anchor), as drawn.
|
||
pub start: f64,
|
||
/// The distance along the path between neighboring objects' attachment points (points), as drawn.
|
||
pub gap: f64,
|
||
/// The group's Space value (`None`: Auto) and start, as saved: more than is drawn when the path
|
||
/// is too short for them.
|
||
pub saved: (Option<f64>, f64),
|
||
}
|
||
|
||
impl SpaceWidget {
|
||
/// The widget of the selection at `zoom` (screen px per document point): only when the
|
||
/// selection is one editable Objects on Path group with two or more objects on a path with
|
||
/// length, and no anchors are Direct-Selected. It sits beyond the last object's bounds, ahead
|
||
/// along the path's direction there.
|
||
pub fn of(doc: &Document, selection: &Selection, zoom: f64) -> Option<Self> {
|
||
Self::in_group(doc, &one_group(doc, selection, zoom)?, zoom)
|
||
}
|
||
|
||
/// The widget of the group `g`.
|
||
fn in_group(doc: &Document, g: &Group, zoom: f64) -> Option<Self> {
|
||
let (group, rec) = (g.id, g.rec);
|
||
let count = rec.members.len();
|
||
if count < 2 {
|
||
return None;
|
||
}
|
||
let (len, closed) = (g.measured.length(), g.measured.closed());
|
||
let (start, gap) = layout(len, closed, count, rec.spacing, rec.start);
|
||
let (last, angle) = g.measured.stop(count, rec.spacing, rec.start, count - 1)?;
|
||
let dir = Vec2::new(angle.cos(), angle.sin());
|
||
let m = rec.members.last()?;
|
||
let b = g.children.iter().find(|c| c.id == m.id)?.geometric_bounds_with(&doc.symbol_boxes())?;
|
||
let corners = [Point::new(b.x0, b.y0), Point::new(b.x1, b.y0), Point::new(b.x0, b.y1), Point::new(b.x1, b.y1)];
|
||
let reach = corners.iter().map(|c| (*c - last).dot(dir)).fold(0.0, f64::max);
|
||
let at = last + dir * (reach + SPACE_OFFSET_PX / zoom);
|
||
let finite = at.x.is_finite() && at.y.is_finite() && last.x.is_finite() && last.y.is_finite();
|
||
let last_length = nth_length(len, closed, start, gap, count - 1);
|
||
finite.then_some(Self { group, last, last_length, at, dir, len, closed, count, start, gap, saved: (rec.spacing, rec.start) })
|
||
}
|
||
|
||
/// The widget of the group `g` of `cx` when `p` is within reach of it.
|
||
fn at_point(cx: &ToolContext, g: &Group, p: Point) -> Option<Self> {
|
||
Self::in_group(cx.doc, g, cx.zoom).filter(|w| w.at.distance(p) <= cx.tol(SPACE_HIT_PX))
|
||
}
|
||
}
|
||
|
||
/// Is `p` over the Space widget?
|
||
pub fn over_space(cx: &ToolContext, p: Point) -> bool {
|
||
one_group(cx.doc, cx.selection, cx.zoom).and_then(|g| SpaceWidget::at_point(cx, &g, p)).is_some()
|
||
}
|
||
|
||
/// The distance along the path of the Objects on Path group of `w`, `measured`, to the point nearest
|
||
/// `p` ([`vectorcraft_doc::blend::Spine::nearest`]: past the ends of an open path, along the lines
|
||
/// of its end segments), staying near `from` when the pointer is following the path from there. The
|
||
/// line from the last object's attachment point through the widget counts as the path too, as far
|
||
/// as the pointer is ahead of that object along it, so a widget beyond a corner measures from where
|
||
/// it is. The flag says whether the point is on that line, where the distance runs on past the end
|
||
/// of a closed path instead of round it.
|
||
fn length_near(measured: &Measured, w: &SpaceWidget, p: Point, from: Option<f64>) -> Option<(f64, bool)> {
|
||
let spine = measured.spine();
|
||
let bias = |s: f64| from.filter(|f| f.is_finite()).map_or(0.0, |f| spine.apart(s, f) / 2.0);
|
||
let ahead = (p - w.last).dot(w.dir);
|
||
let line = (ahead >= 0.0).then(|| {
|
||
let s = w.last_length + ahead;
|
||
((p - w.last).cross(w.dir).abs() + bias(s), s)
|
||
});
|
||
let (s, on_line) = match (spine.nearest(p, from), line) {
|
||
(Some(on), Some(line)) if line.0 < on.0 => (line.1, true),
|
||
(Some(on), _) => (on.1, false),
|
||
(None, line) => (line?.1, true),
|
||
};
|
||
s.is_finite().then_some((s, on_line))
|
||
}
|
||
|
||
/// Dragging the Space widget: the distance the pointer moves along the path moves the last object
|
||
/// along it as far, and the objects between follow evenly. With Alt the first object moves the
|
||
/// other way as far, so the objects spread from both ends.
|
||
#[derive(Clone, Debug)]
|
||
pub struct SpaceDrag {
|
||
widget: SpaceWidget,
|
||
/// The group's path, measured.
|
||
path: Kept,
|
||
start: Point,
|
||
began: bool,
|
||
/// The distance along the path to the point nearest the pointer at the last drag (points).
|
||
last: f64,
|
||
/// The distance the pointer has moved along the path since the press (points).
|
||
along: f64,
|
||
/// The distance between neighboring objects the drag sets (points).
|
||
gap: f64,
|
||
at: Point,
|
||
}
|
||
|
||
impl SpaceDrag {
|
||
/// The drag has left the click: the distance is changing.
|
||
pub fn adjusting(&self) -> bool {
|
||
self.began
|
||
}
|
||
|
||
/// Start a drag when the press `ev` is on the Space widget.
|
||
pub fn hit(cx: &ToolContext, ev: &PointerEvent) -> Option<Self> {
|
||
Self::hit_in(cx, &one_group(cx.doc, cx.selection, cx.zoom)?, ev)
|
||
}
|
||
|
||
/// [`SpaceDrag::hit`] on the group `g` of `cx`.
|
||
fn hit_in(cx: &ToolContext, g: &Group, ev: &PointerEvent) -> Option<Self> {
|
||
let widget = SpaceWidget::at_point(cx, g, ev.pos)?;
|
||
let (last, _) = length_near(&g.measured, &widget, ev.pos, None)?;
|
||
Some(Self { widget, path: Kept::of(g), start: ev.pos, began: false, last, along: 0.0, gap: widget.gap, at: ev.pos })
|
||
}
|
||
|
||
/// The pointer moved to `p` from `self.at`: add the distance it moved along the path. On the
|
||
/// line through the widget, from a point ahead of the last object, that is how far it moved
|
||
/// along the line; otherwise it takes the shorter way round a closed path.
|
||
fn follow(&mut self, doc: &Document, p: Point) {
|
||
let Some(measured) = self.path.now(doc) else { return };
|
||
let w = &self.widget;
|
||
let Some((t, on_line)) = length_near(&measured, w, p, Some(self.last)) else { return };
|
||
let before = (self.at - w.last).dot(w.dir);
|
||
let step = if on_line && before >= 0.0 {
|
||
(p - w.last).dot(w.dir) - before
|
||
} else if w.closed {
|
||
(t - self.last + w.len / 2.0).rem_euclid(w.len) - w.len / 2.0
|
||
} else {
|
||
t - self.last
|
||
};
|
||
if step.is_finite() {
|
||
self.along += step;
|
||
self.last = t;
|
||
}
|
||
}
|
||
|
||
/// The Space and start the drag sets: without `alt` the first object stays and the last one goes
|
||
/// no further than the end of an open path; with `alt` the objects are centered on an open path,
|
||
/// or on the first anchor of a closed one, and spread over the whole path at most. On a closed
|
||
/// path the objects go no more than once around.
|
||
fn spacing_at(&self, alt: bool) -> (f64, f64) {
|
||
let w = &self.widget;
|
||
let k = (w.count - 1) as f64;
|
||
let along = self.along;
|
||
let round = w.len / w.count as f64;
|
||
if alt {
|
||
let most = if w.closed { round } else { w.len / k };
|
||
let gap = (w.gap + 2.0 * along / k).clamp(0.0, most);
|
||
let span = gap * k;
|
||
(gap, if w.closed { (-span / 2.0).rem_euclid(w.len) } else { (w.len - span) / 2.0 })
|
||
} else {
|
||
let most = if w.closed { round } else { (w.len - w.start) / k };
|
||
((w.gap + along / k).clamp(0.0, most.max(0.0)), w.start)
|
||
}
|
||
}
|
||
|
||
/// The pointer moved to `p`; `alt` spreads the objects from both ends.
|
||
pub fn drag(&mut self, cx: &ToolContext, p: Point, alt: bool) -> Vec<Action> {
|
||
let mut out = vec![];
|
||
if !self.began {
|
||
if p.distance(self.start) < cx.tol(3.0) {
|
||
return out;
|
||
}
|
||
self.began = true;
|
||
out.push(Action::Begin("Objects on Path Options".into()));
|
||
}
|
||
self.follow(cx.doc, p);
|
||
let (gap, start) = self.spacing_at(alt);
|
||
self.gap = gap;
|
||
self.at = p;
|
||
// Where the objects stay as they are drawn, the group keeps its saved values: Auto, or a
|
||
// Space value the path is too short for.
|
||
let w = &self.widget;
|
||
let (spacing, start) = if (gap - w.gap).abs() < 1e-9 && (start - w.start).abs() < 1e-9 {
|
||
(w.saved.0.map_or_else(|| json!("auto"), |g| json!(g)), json!(w.saved.1))
|
||
} else {
|
||
(json!(gap), json!(start))
|
||
};
|
||
out.push(Action::Preview("object.objectsOnPath.options".into(), json!({ "ids": [w.group.0], "spacing": spacing, "start": start })));
|
||
out
|
||
}
|
||
|
||
pub fn finish(self) -> Vec<Action> {
|
||
if self.began { vec![Action::Commit] } else { vec![] }
|
||
}
|
||
|
||
/// The distance between the objects next to the pointer, in the document's units.
|
||
pub fn overlays(&self, cx: &ToolContext) -> Vec<Overlay> {
|
||
if !self.began || !cx.measurement_labels {
|
||
return vec![];
|
||
}
|
||
vec![Overlay::Measure { p: self.at, text: cx.len(self.gap) }]
|
||
}
|
||
}
|
||
|
||
/// The Move All widget of a selected Objects on Path group.
|
||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||
pub struct MoveAllWidget {
|
||
pub group: NodeId,
|
||
/// The first object's attachment point, in the document.
|
||
pub first: Point,
|
||
/// The widget's center in the document.
|
||
pub at: Point,
|
||
/// The length of the path (points).
|
||
pub len: f64,
|
||
/// Is the path closed?
|
||
pub closed: bool,
|
||
/// Where the first object attaches along the path (points from its first anchor), as drawn.
|
||
pub start: f64,
|
||
/// The farthest along an open path the first object can attach with the others still on it
|
||
/// (points); the path's length on a closed path.
|
||
pub most: f64,
|
||
/// The Space value a drag sets with the start: the distance between the objects as drawn, when
|
||
/// the saved value would draw them apart differently from another start (Auto, or a Space value
|
||
/// an open path is too short for). `None` keeps the saved value.
|
||
pub gap: Option<f64>,
|
||
/// The group's start, as saved.
|
||
pub saved: f64,
|
||
}
|
||
|
||
impl MoveAllWidget {
|
||
/// The widget of the selection at `zoom` (screen px per document point): only when the
|
||
/// selection is one editable Objects on Path group with at least one object on a path with
|
||
/// length, no anchors are Direct-Selected, and the objects have room to move: on an open path,
|
||
/// the distance from the first object to the last is shorter than the path. It sits beyond the
|
||
/// first object's bounds, on the side its bottom faces.
|
||
pub fn of(doc: &Document, selection: &Selection, zoom: f64) -> Option<Self> {
|
||
Self::in_group(doc, &one_group(doc, selection, zoom)?, zoom)
|
||
}
|
||
|
||
/// The widget of the group `g`.
|
||
fn in_group(doc: &Document, g: &Group, zoom: f64) -> Option<Self> {
|
||
let (group, rec, children) = (g.id, g.rec, g.children);
|
||
let count = rec.members.len();
|
||
let first = rec.members.first()?;
|
||
let (len, closed) = (g.measured.length(), g.measured.closed());
|
||
let (start, gap) = layout(len, closed, count, rec.spacing, rec.start);
|
||
let most = if closed { len } else { len - gap * count.saturating_sub(1) as f64 };
|
||
if !closed && (!most.is_finite() || most <= 1e-9) {
|
||
return None;
|
||
}
|
||
// On an open path, Auto and a Space value the path is too short for draw the objects apart
|
||
// by what is left of the path after the start, so another start would change the distance.
|
||
let keeps = closed || count < 2 || rec.spacing.is_some_and(|g| (g - gap).abs() < 1e-9);
|
||
let (at_first, _) = g.measured.stop(count, rec.spacing, rec.start, 0)?;
|
||
let at = beside(doc, children, first, at_first, -top(first), MOVE_ALL_OFFSET_PX / zoom)?;
|
||
let finite = [len, start, most, rec.start].iter().all(|v| v.is_finite());
|
||
finite.then_some(Self { group, first: at_first, at, len, closed, start, most, gap: (!keeps).then_some(gap), saved: rec.start })
|
||
}
|
||
|
||
/// The widget of the group `g` of `cx` when `p` is within reach of it.
|
||
fn at_point(cx: &ToolContext, g: &Group, p: Point) -> Option<Self> {
|
||
Self::in_group(cx.doc, g, cx.zoom).filter(|w| w.at.distance(p) <= cx.tol(MOVE_ALL_HIT_PX))
|
||
}
|
||
}
|
||
|
||
/// Is `p` over the Move All widget?
|
||
pub fn over_move_all(cx: &ToolContext, p: Point) -> bool {
|
||
one_group(cx.doc, cx.selection, cx.zoom).and_then(|g| MoveAllWidget::at_point(cx, &g, p)).is_some()
|
||
}
|
||
|
||
/// Dragging the Move All widget: the distance the pointer moves along the path moves every object
|
||
/// along it as far, keeping the distances between them. On an open path the objects stop at its
|
||
/// ends, and on a closed path they go on round across its first anchor.
|
||
#[derive(Clone, Debug)]
|
||
pub struct MoveAllDrag {
|
||
widget: MoveAllWidget,
|
||
/// The group's path, measured.
|
||
path: Kept,
|
||
start: Point,
|
||
began: bool,
|
||
/// The distance along the path to the point nearest the pointer at the last drag (points).
|
||
last: f64,
|
||
/// Where the drag puts the first object along the path (points from its first anchor).
|
||
to: f64,
|
||
at: Point,
|
||
}
|
||
|
||
impl MoveAllDrag {
|
||
/// The drag has left the click: the objects are moving.
|
||
pub fn adjusting(&self) -> bool {
|
||
self.began
|
||
}
|
||
|
||
/// Start a drag when the press `ev` is on the Move All widget.
|
||
pub fn hit(cx: &ToolContext, ev: &PointerEvent) -> Option<Self> {
|
||
Self::hit_in(cx, &one_group(cx.doc, cx.selection, cx.zoom)?, ev)
|
||
}
|
||
|
||
/// [`MoveAllDrag::hit`] on the group `g` of `cx`.
|
||
fn hit_in(cx: &ToolContext, g: &Group, ev: &PointerEvent) -> Option<Self> {
|
||
let widget = MoveAllWidget::at_point(cx, g, ev.pos)?;
|
||
let (_, last) = g.measured.spine().nearest(ev.pos, Some(widget.start))?;
|
||
last.is_finite().then_some(Self { widget, path: Kept::of(g), start: ev.pos, began: false, last, to: widget.start, at: ev.pos })
|
||
}
|
||
|
||
/// The pointer moved to `p`: move the first object as far along the path as the point nearest
|
||
/// the pointer moved, the shorter way round a closed path. On an open path it stays between
|
||
/// the first anchor and [`MoveAllWidget::most`], so moving back from beyond an end moves the
|
||
/// objects back at once.
|
||
fn follow(&mut self, doc: &Document, p: Point) {
|
||
let Some((_, t)) = self.path.now(doc).and_then(|m| m.spine().nearest(p, Some(self.last))) else { return };
|
||
let w = &self.widget;
|
||
let step = if w.closed { (t - self.last + w.len / 2.0).rem_euclid(w.len) - w.len / 2.0 } else { t - self.last };
|
||
if !t.is_finite() || !step.is_finite() {
|
||
return;
|
||
}
|
||
self.last = t;
|
||
self.to = if w.closed {
|
||
let s = (self.to + step).rem_euclid(w.len);
|
||
if s.is_finite() && s < w.len { s } else { 0.0 }
|
||
} else {
|
||
(self.to + step).clamp(0.0, w.most)
|
||
};
|
||
}
|
||
|
||
/// The pointer moved to `p`.
|
||
pub fn drag(&mut self, cx: &ToolContext, p: Point) -> Vec<Action> {
|
||
let mut out = vec![];
|
||
if !self.began {
|
||
if p.distance(self.start) < cx.tol(3.0) {
|
||
return out;
|
||
}
|
||
self.began = true;
|
||
out.push(Action::Begin("Objects on Path Options".into()));
|
||
}
|
||
self.follow(cx.doc, p);
|
||
self.at = p;
|
||
let w = &self.widget;
|
||
// Where the objects stay as they are drawn, the group keeps its saved values.
|
||
let params = if (self.to - w.start).abs() < 1e-9 {
|
||
json!({ "ids": [w.group.0], "start": w.saved })
|
||
} else if let Some(gap) = w.gap {
|
||
json!({ "ids": [w.group.0], "start": self.to, "spacing": gap })
|
||
} else {
|
||
json!({ "ids": [w.group.0], "start": self.to })
|
||
};
|
||
out.push(Action::Preview("object.objectsOnPath.options".into(), params));
|
||
out
|
||
}
|
||
|
||
pub fn finish(self) -> Vec<Action> {
|
||
if self.began { vec![Action::Commit] } else { vec![] }
|
||
}
|
||
|
||
/// The first object's distance along the path next to the pointer, in the document's units.
|
||
pub fn overlays(&self, cx: &ToolContext) -> Vec<Overlay> {
|
||
if !self.began || !cx.measurement_labels {
|
||
return vec![];
|
||
}
|
||
vec![Overlay::Measure { p: self.at, text: cx.len(self.to) }]
|
||
}
|
||
}
|
||
|
||
/// The Select/Move widget of one object of a selected Objects on Path group: a small ring on the
|
||
/// object's attachment point.
|
||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||
pub struct MemberWidget {
|
||
pub group: NodeId,
|
||
/// The object.
|
||
pub member: NodeId,
|
||
/// The object's place along the path (0: the first).
|
||
pub index: usize,
|
||
/// The object's attachment point, in the document: the widget's center.
|
||
pub at: Point,
|
||
/// Is the object the chosen one ([`Selection::on_path_member`])?
|
||
pub chosen: bool,
|
||
}
|
||
|
||
impl MemberWidget {
|
||
/// The widgets of the selection at `zoom` (screen px per document point), one per object in
|
||
/// its order along the path that is neither hidden nor locked: only when the selection is one
|
||
/// editable Objects on Path group on a path with length, and no anchors are Direct-Selected.
|
||
pub fn all(doc: &Document, selection: &Selection, zoom: f64) -> Vec<Self> {
|
||
one_group(doc, selection, zoom).map(|g| Self::in_group(doc, selection, &g)).unwrap_or_default()
|
||
}
|
||
|
||
/// The widgets of the group `g`, the selection.
|
||
fn in_group(doc: &Document, selection: &Selection, g: &Group) -> Vec<Self> {
|
||
let (group, rec) = (g.id, g.rec);
|
||
let at = g.measured.stops(rec.members.len(), rec.spacing, rec.start);
|
||
let editable = doc.editable();
|
||
rec.members
|
||
.iter()
|
||
.zip(at)
|
||
.enumerate()
|
||
.filter(|(_, (m, (p, _)))| p.x.is_finite() && p.y.is_finite() && editable(m.id))
|
||
.map(|(index, (m, (at, _)))| Self { group, member: m.id, index, at, chosen: selection.on_path_member == Some(m.id) })
|
||
.collect()
|
||
}
|
||
|
||
/// The widget of the group `g` of `cx` nearest `p`, when `p` is within reach of it; of widgets
|
||
/// as near, the chosen one, else the first along the path.
|
||
fn at_point(cx: &ToolContext, g: &Group, p: Point) -> Option<Self> {
|
||
let reach = cx.tol(MEMBER_HIT_PX);
|
||
// Every attachment point lies on the path: a pointer beyond reach of its bounds is over none.
|
||
if !g.path.control_bounds()?.inflate(reach, reach).contains(p) {
|
||
return None;
|
||
}
|
||
let mut best: Option<(f64, Self)> = None;
|
||
for w in Self::in_group(cx.doc, cx.selection, g) {
|
||
let d = w.at.distance(p);
|
||
let nearer = best.is_none_or(|(b, bw)| d < b - 1e-9 || (d <= b + 1e-9 && w.chosen && !bw.chosen));
|
||
if d <= reach && nearer {
|
||
best = Some((d, w));
|
||
}
|
||
}
|
||
best.map(|(_, w)| w)
|
||
}
|
||
}
|
||
|
||
/// Is `p` over a Select/Move widget?
|
||
pub fn over_member(cx: &ToolContext, p: Point) -> bool {
|
||
one_group(cx.doc, cx.selection, cx.zoom).and_then(|g| MemberWidget::at_point(cx, &g, p)).is_some()
|
||
}
|
||
|
||
/// The highlight of the Select/Move widget under `p`, if any: a ring around it.
|
||
pub fn member_hover(cx: &ToolContext, p: Point) -> Option<Overlay> {
|
||
let w = MemberWidget::at_point(cx, &one_group(cx.doc, cx.selection, cx.zoom)?, p)?;
|
||
let r = cx.tol(f64::from(MEMBER_RADIUS_PX) + 2.0);
|
||
let ring = vectorcraft_geom::shapes::ellipse(vectorcraft_geom::Rect::new(w.at.x - r, w.at.y - r, w.at.x + r, w.at.y + r));
|
||
Some(Overlay::Path { path: ring.to_bezpath(), color: HIGHLIGHT, width: 1.5, dashed: false })
|
||
}
|
||
|
||
/// The widgets of the selection at `zoom` (screen px per document point), each as its own `of` or
|
||
/// `all` gives it, from one measurement of the group's path: for drawing them together.
|
||
#[derive(Clone, Debug, Default, PartialEq)]
|
||
pub struct Widgets {
|
||
pub members: Vec<MemberWidget>,
|
||
pub rotate_all: Option<RotateAllWidget>,
|
||
pub space: Option<SpaceWidget>,
|
||
pub move_all: Option<MoveAllWidget>,
|
||
}
|
||
|
||
impl Widgets {
|
||
pub fn of(doc: &Document, selection: &Selection, zoom: f64) -> Self {
|
||
let Some(g) = one_group(doc, selection, zoom) else { return Self::default() };
|
||
Self {
|
||
members: MemberWidget::in_group(doc, selection, &g),
|
||
rotate_all: RotateAllWidget::in_group(doc, &g, zoom),
|
||
space: SpaceWidget::in_group(doc, &g, zoom),
|
||
move_all: MoveAllWidget::in_group(doc, &g, zoom),
|
||
}
|
||
}
|
||
}
|
||
|
||
/// A widget of a selected Objects on Path group.
|
||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||
pub enum WidgetKind {
|
||
RotateAll,
|
||
Space,
|
||
MoveAll,
|
||
Member,
|
||
}
|
||
|
||
/// The widget `p` is over, of the Rotate All, Space, Move All and Select/Move widgets in that
|
||
/// order, from one measurement of the group's path: as [`over_rotate_all`], [`over_space`],
|
||
/// [`over_move_all`] and [`over_member`] answer in turn.
|
||
pub fn widget_at(cx: &ToolContext, p: Point) -> Option<WidgetKind> {
|
||
let g = one_group(cx.doc, cx.selection, cx.zoom)?;
|
||
if RotateAllWidget::at_point(cx, &g, p).is_some() {
|
||
Some(WidgetKind::RotateAll)
|
||
} else if SpaceWidget::at_point(cx, &g, p).is_some() {
|
||
Some(WidgetKind::Space)
|
||
} else if MoveAllWidget::at_point(cx, &g, p).is_some() {
|
||
Some(WidgetKind::MoveAll)
|
||
} else {
|
||
MemberWidget::at_point(cx, &g, p).map(|_| WidgetKind::Member)
|
||
}
|
||
}
|
||
|
||
/// A drag of a widget of a selected Objects on Path group.
|
||
#[derive(Clone, Debug)]
|
||
pub enum WidgetDrag {
|
||
RotateAll(RotateAllDrag),
|
||
Space(SpaceDrag),
|
||
MoveAll(MoveAllDrag),
|
||
Member(MemberDrag),
|
||
}
|
||
|
||
impl WidgetDrag {
|
||
/// The drag the press `ev` starts, of the Rotate All, Space, Move All and Select/Move widgets
|
||
/// in that order, from one measurement of the group's path: as [`RotateAllDrag::hit`],
|
||
/// [`SpaceDrag::hit`], [`MoveAllDrag::hit`] and [`MemberDrag::hit`] answer in turn.
|
||
pub fn hit(cx: &ToolContext, ev: &PointerEvent) -> Option<Self> {
|
||
let g = one_group(cx.doc, cx.selection, cx.zoom)?;
|
||
RotateAllDrag::hit_in(cx, &g, ev)
|
||
.map(Self::RotateAll)
|
||
.or_else(|| SpaceDrag::hit_in(cx, &g, ev).map(Self::Space))
|
||
.or_else(|| MoveAllDrag::hit_in(cx, &g, ev).map(Self::MoveAll))
|
||
.or_else(|| MemberDrag::hit_in(cx, &g, ev).map(Self::Member))
|
||
}
|
||
}
|
||
|
||
/// Dragging a Select/Move widget: the object goes to the place along the path nearest the
|
||
/// pointer, and the objects between it and its place move one place toward where it was, except
|
||
/// hidden and locked ones (`object.objectsOnPath.moveMember`). On an open path a pointer beyond
|
||
/// an end takes the place at that end; on a closed path the pointer goes on round across the first
|
||
/// anchor. Where the path passes as near the pointer more than once, as where it runs back over
|
||
/// itself, the drag follows the part nearest along the path to where it was. Where two places are
|
||
/// as near, the one the drag is at stays. A click without a drag, and
|
||
/// the release of a drag, choose the object (`object.objectsOnPath.selectMember`).
|
||
#[derive(Clone, Debug)]
|
||
pub struct MemberDrag {
|
||
widget: MemberWidget,
|
||
/// The group's path, measured.
|
||
path: Kept,
|
||
/// The objects in their order along the path when the press began.
|
||
order: Vec<NodeId>,
|
||
/// The distance along the path to each place (points), in that order.
|
||
places: Vec<f64>,
|
||
/// Can the drag take each place? Not the place of a hidden or locked object.
|
||
open: Vec<bool>,
|
||
/// The length of the path (points).
|
||
len: f64,
|
||
/// Is the path closed?
|
||
closed: bool,
|
||
start: Point,
|
||
began: bool,
|
||
/// The distance along the path the drag was last at (points).
|
||
last: f64,
|
||
/// The place the drag puts the object at.
|
||
target: usize,
|
||
}
|
||
|
||
impl MemberDrag {
|
||
/// The drag has left the click: the object is moving.
|
||
pub fn adjusting(&self) -> bool {
|
||
self.began
|
||
}
|
||
|
||
/// Start a drag when the press `ev` is on a Select/Move widget.
|
||
pub fn hit(cx: &ToolContext, ev: &PointerEvent) -> Option<Self> {
|
||
Self::hit_in(cx, &one_group(cx.doc, cx.selection, cx.zoom)?, ev)
|
||
}
|
||
|
||
/// [`MemberDrag::hit`] on the group `g` of `cx`.
|
||
fn hit_in(cx: &ToolContext, g: &Group, ev: &PointerEvent) -> Option<Self> {
|
||
let widget = MemberWidget::at_point(cx, g, ev.pos)?;
|
||
let rec = g.rec;
|
||
let (len, closed) = (g.measured.length(), g.measured.closed());
|
||
let count = rec.members.len();
|
||
let (s0, gap) = layout(len, closed, count, rec.spacing, rec.start);
|
||
let places: Vec<f64> = (0..count).map(|i| nth_length(len, closed, s0, gap, i)).collect();
|
||
let last = *places.get(widget.index)?;
|
||
let editable = cx.doc.editable();
|
||
let open = rec.members.iter().map(|m| editable(m.id)).collect();
|
||
let order = rec.members.iter().map(|m| m.id).collect();
|
||
Some(Self { widget, path: Kept::of(g), order, places, open, len, closed, start: ev.pos, began: false, last, target: widget.index })
|
||
}
|
||
|
||
/// How far apart along the path the distances `a` and `b` are: the shorter way round a closed
|
||
/// path.
|
||
fn apart(&self, a: f64, b: f64) -> f64 {
|
||
let d = (a - b).abs();
|
||
if self.closed { d.rem_euclid(self.len).min(self.len - d.rem_euclid(self.len)) } else { d }
|
||
}
|
||
|
||
/// The place nearest the distance `t` along the path, of the places the drag can take; the
|
||
/// current one where another is as near.
|
||
fn nearest_place(&self, t: f64) -> usize {
|
||
let t = if self.closed { t } else { t.clamp(0.0, self.len) };
|
||
let now = self.places.get(self.target).map_or(f64::INFINITY, |s| self.apart(t, *s));
|
||
let mut best = (self.target, now);
|
||
for (i, s) in self.places.iter().enumerate().filter(|(i, _)| self.open.get(*i).copied().unwrap_or(false)) {
|
||
let d = self.apart(t, *s);
|
||
if d.is_finite() && d < best.1 - 1e-9 {
|
||
best = (i, d);
|
||
}
|
||
}
|
||
best.0
|
||
}
|
||
|
||
/// The pointer moved to `p`.
|
||
pub fn drag(&mut self, cx: &ToolContext, p: Point) -> Vec<Action> {
|
||
let mut out = vec![];
|
||
if !self.began {
|
||
if p.distance(self.start) < cx.tol(3.0) {
|
||
return out;
|
||
}
|
||
self.began = true;
|
||
out.push(Action::Begin("Move Object on Path".into()));
|
||
}
|
||
let Some(measured) = self.path.now(cx.doc) else { return out };
|
||
let (w, spine) = (&self.widget, measured.spine());
|
||
let Some((near, t)) = spine.nearest(p, None) else { return out };
|
||
// Where the path passes as near the pointer more than once, the point nearest along the path
|
||
// to where the drag was counts.
|
||
let t = match spine.nearest(p, Some(self.last)) {
|
||
Some((d, s)) if d - spine.apart(s, self.last) / 2.0 - near <= 1e-9 * (1.0 + near) => s,
|
||
_ => t,
|
||
};
|
||
if !t.is_finite() {
|
||
return out;
|
||
}
|
||
self.last = t;
|
||
let target = self.nearest_place(t);
|
||
if target != self.target {
|
||
self.target = target;
|
||
let to = self.order.get(target).copied().unwrap_or(w.member);
|
||
out.push(Action::Preview("object.objectsOnPath.moveMember".into(), json!({ "group": w.group.0, "member": w.member.0, "target": to.0 })));
|
||
}
|
||
out
|
||
}
|
||
|
||
/// The release: a drag that moved the object keeps it as one undo step, one that ends where it
|
||
/// began keeps nothing, and either way the object is chosen.
|
||
pub fn finish(self) -> Vec<Action> {
|
||
let choose = Action::Exec("object.objectsOnPath.selectMember".into(), json!({ "member": self.widget.member.0 }));
|
||
match (self.began, self.target == self.widget.index) {
|
||
(false, _) => vec![choose],
|
||
(true, true) => vec![Action::Cancel, choose],
|
||
(true, false) => vec![Action::Commit, choose],
|
||
}
|
||
}
|
||
}
|
||
|
||
/// The path a click at `p` attaches the selected objects to: the path object hit there, when it can
|
||
/// take objects, is in no Objects on Path group, is not a clipping path or part of a compound path,
|
||
/// blend, envelope, repeat or Intertwine group ([`vectorcraft_doc::objects_on_path::held`]), and
|
||
/// something else is selected.
|
||
pub fn target(cx: &ToolContext, p: Point) -> Option<(NodeId, BezPath)> {
|
||
let h = vectorcraft_doc::hit::hit_test(cx.doc, p, cx.hit_options())?;
|
||
let n = cx.doc.node(h.leaf)?;
|
||
if h.ancestry.iter().filter(|a| **a != h.leaf).any(|a| cx.doc.node(*a).is_some_and(is_objects_on_path)) {
|
||
return None;
|
||
}
|
||
if vectorcraft_doc::objects_on_path::held(cx.doc, h.leaf).is_some() || !cx.selection.objects.iter().any(|id| *id != h.leaf) {
|
||
return None;
|
||
}
|
||
attachable_path(n).map(|path| (h.leaf, path.to_bezpath()))
|
||
}
|
||
|
||
pub struct ObjectsOnPathTool {
|
||
/// The path under the pointer the selection can attach to, and its outline.
|
||
hover: Option<(NodeId, BezPath)>,
|
||
/// Where the press was, while the button is down.
|
||
press: Option<Point>,
|
||
/// The Rotate All widget drag, while the button is down after a press on the widget.
|
||
rotating: Option<RotateAllDrag>,
|
||
/// The Space widget drag, while the button is down after a press on the widget.
|
||
spacing: Option<SpaceDrag>,
|
||
/// The Move All widget drag, while the button is down after a press on the widget.
|
||
moving: Option<MoveAllDrag>,
|
||
/// The Select/Move widget drag, while the button is down after a press on a widget.
|
||
member: Option<MemberDrag>,
|
||
/// Where the pointer is while no button is down, for the Select/Move widget it is over.
|
||
pointer: Option<Point>,
|
||
/// The reference point of each object attached next (0-8, row by row from the top left).
|
||
pivot: u8,
|
||
/// The angle of each object attached next, in degrees counter-clockwise from upright on the path.
|
||
rotate: f64,
|
||
}
|
||
|
||
impl Default for ObjectsOnPathTool {
|
||
fn default() -> Self {
|
||
Self { hover: None, press: None, rotating: None, spacing: None, moving: None, member: None, pointer: None, pivot: CENTER, rotate: 0.0 }
|
||
}
|
||
}
|
||
|
||
impl Tool for ObjectsOnPathTool {
|
||
fn id(&self) -> &'static str {
|
||
"objectsOnPath"
|
||
}
|
||
|
||
fn pointer(&mut self, cx: &ToolContext, ev: &PointerEvent) -> Vec<Action> {
|
||
let p = ev.pos;
|
||
if let Some(d) = &mut self.rotating {
|
||
return match ev.kind {
|
||
PointerKind::Drag => d.drag(cx, p, ev.mods.shift),
|
||
PointerKind::Up => self.rotating.take().map(RotateAllDrag::finish).unwrap_or_default(),
|
||
_ => vec![],
|
||
};
|
||
}
|
||
if let Some(d) = &mut self.spacing {
|
||
return match ev.kind {
|
||
PointerKind::Drag => d.drag(cx, p, ev.mods.alt),
|
||
PointerKind::Up => self.spacing.take().map(SpaceDrag::finish).unwrap_or_default(),
|
||
_ => vec![],
|
||
};
|
||
}
|
||
if let Some(d) = &mut self.moving {
|
||
return match ev.kind {
|
||
PointerKind::Drag => d.drag(cx, p),
|
||
PointerKind::Up => self.moving.take().map(MoveAllDrag::finish).unwrap_or_default(),
|
||
_ => vec![],
|
||
};
|
||
}
|
||
if let Some(d) = &mut self.member {
|
||
return match ev.kind {
|
||
PointerKind::Drag => d.drag(cx, p),
|
||
PointerKind::Up => self.member.take().map(MemberDrag::finish).unwrap_or_default(),
|
||
_ => vec![],
|
||
};
|
||
}
|
||
self.pointer = (ev.kind == PointerKind::Move).then_some(p);
|
||
match ev.kind {
|
||
PointerKind::Move => {
|
||
self.hover = if widget_at(cx, p).is_some() { None } else { target(cx, p) };
|
||
vec![]
|
||
}
|
||
PointerKind::Down => {
|
||
if let Some(d) = WidgetDrag::hit(cx, ev) {
|
||
match d {
|
||
WidgetDrag::RotateAll(d) => self.rotating = Some(d),
|
||
WidgetDrag::Space(d) => self.spacing = Some(d),
|
||
WidgetDrag::MoveAll(d) => self.moving = Some(d),
|
||
WidgetDrag::Member(d) => self.member = Some(d),
|
||
}
|
||
self.hover = None;
|
||
return vec![];
|
||
}
|
||
self.press = Some(p);
|
||
vec![]
|
||
}
|
||
PointerKind::Up => {
|
||
// A press that moved away is not a click.
|
||
let Some(start) = self.press.take().filter(|q| q.distance(p) < cx.tol(3.0)) else { return vec![] };
|
||
let Some((path, _)) = target(cx, start) else { return vec![] };
|
||
self.hover = None;
|
||
vec![Action::Exec("object.objectsOnPath.attach".into(), json!({ "path": path.0, "pivot": self.pivot, "rotate": self.rotate }))]
|
||
}
|
||
_ => vec![],
|
||
}
|
||
}
|
||
|
||
fn overlays(&self, cx: &ToolContext) -> Vec<Overlay> {
|
||
let mut o: Vec<Overlay> =
|
||
self.hover.iter().map(|(_, path)| Overlay::Path { path: path.clone(), color: HIGHLIGHT, width: 2.0, dashed: false }).collect();
|
||
if let Some(d) = &self.rotating {
|
||
o.extend(d.overlays(cx));
|
||
}
|
||
if let Some(d) = &self.spacing {
|
||
o.extend(d.overlays(cx));
|
||
}
|
||
if let Some(d) = &self.moving {
|
||
o.extend(d.overlays(cx));
|
||
}
|
||
if let Some(p) = self.pointer.filter(|_| !self.busy()) {
|
||
o.extend(member_hover(cx, p));
|
||
}
|
||
o
|
||
}
|
||
|
||
fn cursor(&self, cx: &ToolContext, p: Point, _mods: Mods) -> Cursor {
|
||
if self.member.is_some() {
|
||
return Cursor::Move;
|
||
}
|
||
if self.rotating.is_some() {
|
||
return Cursor::Rotate;
|
||
}
|
||
if self.spacing.is_some() {
|
||
return Cursor::ArrowHollow;
|
||
}
|
||
if self.moving.is_some() {
|
||
return Cursor::Move;
|
||
}
|
||
match widget_at(cx, p) {
|
||
Some(WidgetKind::RotateAll) => Cursor::Rotate,
|
||
Some(WidgetKind::Space) => Cursor::ArrowHollow,
|
||
Some(WidgetKind::MoveAll | WidgetKind::Member) => Cursor::Move,
|
||
None if target(cx, p).is_some() => Cursor::ObjectsOnPath,
|
||
None => Cursor::Arrow,
|
||
}
|
||
}
|
||
|
||
/// Escape while the button is down cancels the click, so the release attaches nothing, or the
|
||
/// Rotate All, Space, Move All or Select/Move drag, so the objects go back to the Rotate, Space,
|
||
/// place or order they had.
|
||
fn key(&mut self, _cx: &ToolContext, key: ToolKey, _mods: Mods) -> Vec<Action> {
|
||
if key == ToolKey::Escape {
|
||
self.press = None;
|
||
self.hover = None;
|
||
let rotated = self.rotating.take().is_some_and(|d| d.adjusting());
|
||
let spaced = self.spacing.take().is_some_and(|d| d.adjusting());
|
||
let moved = self.moving.take().is_some_and(|d| d.adjusting());
|
||
let ordered = self.member.take().is_some_and(|d| d.adjusting());
|
||
if rotated || spaced || moved || ordered {
|
||
return vec![Action::Cancel];
|
||
}
|
||
}
|
||
vec![]
|
||
}
|
||
|
||
fn options(&self) -> Value {
|
||
json!({ "pivot": self.pivot, "rotate": self.rotate })
|
||
}
|
||
|
||
/// `pivot` takes a whole number from 0 to 8 and `rotate` a finite number, clamped to -360 to
|
||
/// 360; other values are ignored.
|
||
fn set_option(&mut self, key: &str, value: &Value) {
|
||
match key {
|
||
"pivot" => {
|
||
if let Some(n) = value.as_u64().filter(|n| *n <= 8) {
|
||
self.pivot = n as u8;
|
||
}
|
||
}
|
||
"rotate" => {
|
||
if let Some(r) = value.as_f64().filter(|r| r.is_finite()) {
|
||
self.rotate = r.clamp(-360.0, 360.0);
|
||
}
|
||
}
|
||
_ => {}
|
||
}
|
||
}
|
||
|
||
fn check_option(&self, key: &str, value: &Value) -> Result<(), String> {
|
||
use crate::option_check as c;
|
||
match key {
|
||
"pivot" => c::whole(key, value, 0, 8),
|
||
"rotate" => c::number(key, value, -360.0, 360.0),
|
||
_ => Err(c::unknown(key)),
|
||
}
|
||
}
|
||
|
||
fn busy(&self) -> bool {
|
||
self.press.is_some() || self.rotating.is_some() || self.spacing.is_some() || self.moving.is_some() || self.member.is_some()
|
||
}
|
||
|
||
fn transforming(&self) -> bool {
|
||
self.rotating.as_ref().is_some_and(RotateAllDrag::adjusting)
|
||
|| self.spacing.as_ref().is_some_and(SpaceDrag::adjusting)
|
||
|| self.moving.as_ref().is_some_and(MoveAllDrag::adjusting)
|
||
|| self.member.as_ref().is_some_and(MemberDrag::adjusting)
|
||
}
|
||
}
|
||
|
||
pub fn create(id: &str) -> Option<Box<dyn crate::Tool>> {
|
||
(id == "objectsOnPath").then(|| Box::new(ObjectsOnPathTool::default()) as Box<dyn crate::Tool>)
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use std::sync::Arc;
|
||
|
||
use vectorcraft_doc::{Appearance, Node, NodeKind};
|
||
use vectorcraft_geom::{Rect, shapes};
|
||
|
||
use super::*;
|
||
use crate::testutil::{cx, paint};
|
||
|
||
fn doc() -> (Document, NodeId, NodeId) {
|
||
let mut d = Document::new(500.0, 500.0);
|
||
let l = d.layers[0].id;
|
||
let line = d.alloc_id();
|
||
let square = d.alloc_id();
|
||
d.insert(Some(l), 0, Node::path(line, shapes::line(Point::new(0.0, 300.0), Point::new(400.0, 300.0)), Appearance::default_art())).unwrap();
|
||
d.insert(Some(l), 1, Node::path(square, shapes::rectangle(Rect::new(50.0, 50.0, 70.0, 70.0)), Appearance::default_art())).unwrap();
|
||
(d, line, square)
|
||
}
|
||
|
||
fn ev(kind: PointerKind, x: f64, y: f64) -> PointerEvent {
|
||
PointerEvent::new(kind, x, y)
|
||
}
|
||
|
||
#[test]
|
||
fn a_click_on_a_path_attaches_the_selection_to_it() {
|
||
let (d, line, square) = doc();
|
||
let mut sel = Selection::default();
|
||
sel.set([square]);
|
||
let paint = paint();
|
||
let cx = cx(&d, &sel, &paint);
|
||
let mut t = ObjectsOnPathTool::default();
|
||
let on = Point::new(200.0, 300.0);
|
||
assert_eq!(t.cursor(&cx, on, Mods::default()), Cursor::ObjectsOnPath);
|
||
assert_eq!(t.cursor(&cx, Point::new(200.0, 500.0), Mods::default()), Cursor::Arrow, "away from paths");
|
||
t.pointer(&cx, &ev(PointerKind::Move, on.x, on.y));
|
||
assert_eq!(t.overlays(&cx).len(), 1, "the path is highlighted");
|
||
t.pointer(&cx, &ev(PointerKind::Down, on.x, on.y));
|
||
let acts = t.pointer(&cx, &ev(PointerKind::Up, on.x, on.y));
|
||
assert!(matches!(acts.as_slice(), [Action::Exec(id, p)] if id == "object.objectsOnPath.attach" && p["path"] == line.0), "{acts:?}");
|
||
}
|
||
|
||
#[test]
|
||
fn the_click_sends_the_tool_options_pivot_and_rotate() {
|
||
let (d, _, square) = doc();
|
||
let mut sel = Selection::default();
|
||
sel.set([square]);
|
||
let paint = paint();
|
||
let cx = cx(&d, &sel, &paint);
|
||
let mut t = ObjectsOnPathTool::default();
|
||
assert_eq!(t.options(), json!({ "pivot": 4, "rotate": 0.0 }), "the center, upright");
|
||
t.set_option("pivot", &json!(0));
|
||
t.set_option("rotate", &json!(45.5));
|
||
// Values out of range are ignored.
|
||
t.set_option("pivot", &json!(9));
|
||
t.set_option("rotate", &json!("x"));
|
||
assert_eq!(t.options(), json!({ "pivot": 0, "rotate": 45.5 }));
|
||
// Rotate is kept within the dialog's -360 to 360.
|
||
t.set_option("rotate", &json!(450));
|
||
assert_eq!(t.options()["rotate"], 360.0);
|
||
t.set_option("rotate", &json!(-720.5));
|
||
assert_eq!(t.options()["rotate"], -360.0);
|
||
t.set_option("rotate", &json!(45.5));
|
||
t.pointer(&cx, &ev(PointerKind::Down, 200.0, 300.0));
|
||
let acts = t.pointer(&cx, &ev(PointerKind::Up, 200.0, 300.0));
|
||
assert!(matches!(acts.as_slice(), [Action::Exec(_, p)] if p["pivot"] == 0 && p["rotate"] == 45.5), "{acts:?}");
|
||
}
|
||
|
||
#[test]
|
||
fn escape_during_the_press_cancels_the_click() {
|
||
let (d, _, square) = doc();
|
||
let mut sel = Selection::default();
|
||
sel.set([square]);
|
||
let paint = paint();
|
||
let cx = cx(&d, &sel, &paint);
|
||
let mut t = ObjectsOnPathTool::default();
|
||
t.pointer(&cx, &ev(PointerKind::Move, 200.0, 300.0));
|
||
t.pointer(&cx, &ev(PointerKind::Down, 200.0, 300.0));
|
||
assert!(t.busy());
|
||
t.key(&cx, ToolKey::Escape, Mods::default());
|
||
assert!(!t.busy() && t.overlays(&cx).is_empty());
|
||
assert!(t.pointer(&cx, &ev(PointerKind::Up, 200.0, 300.0)).is_empty(), "the release attaches nothing");
|
||
}
|
||
|
||
#[test]
|
||
fn nothing_attaches_without_other_objects_selected() {
|
||
let (d, line, _) = doc();
|
||
let mut sel = Selection::default();
|
||
sel.set([line]);
|
||
let paint = paint();
|
||
let cx = cx(&d, &sel, &paint);
|
||
let mut t = ObjectsOnPathTool::default();
|
||
assert_eq!(t.cursor(&cx, Point::new(200.0, 300.0), Mods::default()), Cursor::Arrow);
|
||
t.pointer(&cx, &ev(PointerKind::Down, 200.0, 300.0));
|
||
assert!(t.pointer(&cx, &ev(PointerKind::Up, 200.0, 300.0)).is_empty());
|
||
assert!(matches!(d.node(line).map(|n| &n.kind), Some(NodeKind::Path { .. })));
|
||
}
|
||
|
||
/// A document holding an Objects on Path group (the line from (0, 300) to (400, 300), with two
|
||
/// 20 × 20 squares attached by their centers, the first on (0, 300)) whose Rotate is `rotate`,
|
||
/// and a selection of the group.
|
||
fn group_doc(rotate: f64) -> (Document, NodeId, Selection) {
|
||
group_doc_framed(rotate, None)
|
||
}
|
||
|
||
/// [`group_doc`] with every object drawn in `frame` (mapping its square onto itself) before it
|
||
/// is placed on the path.
|
||
fn group_doc_framed(rotate: f64, frame: Option<vectorcraft_geom::Affine>) -> (Document, NodeId, Selection) {
|
||
let mut d = Document::new(500.0, 500.0);
|
||
let l = d.layers[0].id;
|
||
let (line, a, b, g) = (d.alloc_id(), d.alloc_id(), d.alloc_id(), d.alloc_id());
|
||
let line = Node::path(line, shapes::line(Point::new(0.0, 300.0), Point::new(400.0, 300.0)), Appearance::default_art());
|
||
let a = Node::path(a, shapes::rectangle(Rect::new(50.0, 50.0, 70.0, 70.0)), Appearance::default_art());
|
||
let b = Node::path(b, shapes::rectangle(Rect::new(100.0, 50.0, 120.0, 70.0)), Appearance::default_art());
|
||
let mut rec = vectorcraft_doc::objects_on_path::ObjectsOnPath::new(line.id, &[&a, &b], CENTER, rotate);
|
||
if let Some(f) = frame {
|
||
for m in &mut rec.members {
|
||
m.frame = f;
|
||
}
|
||
}
|
||
let mut group = Node::new(g, NodeKind::Group { children: vec![Arc::new(line), Arc::new(a), Arc::new(b)], clip: false });
|
||
group.extras_mut().objects_on_path = Some(Box::new(rec));
|
||
vectorcraft_doc::objects_on_path::place(&mut group, &Document::new(1.0, 1.0).symbol_boxes());
|
||
d.insert(Some(l), 0, group).unwrap();
|
||
let mut sel = Selection::default();
|
||
sel.set([g]);
|
||
(d, g, sel)
|
||
}
|
||
|
||
/// The pointer `deg` degrees counter-clockwise on the page from straight above the first
|
||
/// object's attachment point (0, 300), 26 points from it.
|
||
fn around(deg: f64) -> Point {
|
||
let (sin, cos) = deg.to_radians().sin_cos();
|
||
Point::new(-26.0 * sin, 300.0 - 26.0 * cos)
|
||
}
|
||
|
||
fn near(a: Point, b: Point) -> bool {
|
||
a.distance(b) < 1e-9
|
||
}
|
||
|
||
/// The Rotate a drag's last action previews.
|
||
fn previewed(acts: &[Action]) -> Option<f64> {
|
||
match acts.last() {
|
||
Some(Action::Preview(cmd, p)) if cmd == "object.objectsOnPath.options" => p["rotate"].as_f64(),
|
||
_ => None,
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn the_rotate_all_widget_sits_above_the_first_object() {
|
||
let (d, g, sel) = group_doc(0.0);
|
||
let w = RotateAllWidget::of(&d, &sel, 1.0).unwrap();
|
||
// The first square spans 290 to 310 down the page: the widget is 16 px above its top.
|
||
assert_eq!(w.group, g);
|
||
assert!(near(w.pivot, Point::new(0.0, 300.0)) && near(w.at, Point::new(0.0, 274.0)), "{w:?}");
|
||
assert!(near(RotateAllWidget::of(&d, &sel, 2.0).unwrap().at, Point::new(0.0, 282.0)));
|
||
// Turned by Rotate, the widget goes round with the object's top.
|
||
let (d, _, sel) = group_doc(90.0);
|
||
let w = RotateAllWidget::of(&d, &sel, 1.0).unwrap();
|
||
assert!(near(w.at, Point::new(-26.0, 300.0)), "{w:?}");
|
||
// Drawn upside down (reflected across the line through their centers), the objects have
|
||
// their tops facing down the page, and the widget goes below the first one.
|
||
let flip = vectorcraft_geom::Affine::new([1.0, 0.0, 0.0, -1.0, 0.0, 120.0]);
|
||
let (df, _, sf) = group_doc_framed(0.0, Some(flip));
|
||
let wf = RotateAllWidget::of(&df, &sf, 1.0).unwrap();
|
||
assert!(near(wf.pivot, Point::new(0.0, 300.0)) && near(wf.at, Point::new(0.0, 326.0)), "{wf:?}");
|
||
// No widget for nothing selected, for an object in the group, or for two objects.
|
||
assert!(RotateAllWidget::of(&d, &Selection::default(), 1.0).is_none());
|
||
let children: Vec<NodeId> = d.node(sel.objects[0]).and_then(|n| n.children()).unwrap().iter().map(|c| c.id).collect();
|
||
let mut one = Selection::default();
|
||
one.set([children[1]]);
|
||
assert!(RotateAllWidget::of(&d, &one, 1.0).is_none());
|
||
let (d2, line, square) = doc();
|
||
let mut two = Selection::default();
|
||
two.set([line, square]);
|
||
assert!(RotateAllWidget::of(&d2, &two, 1.0).is_none());
|
||
// Nor for a group that is locked.
|
||
let (mut d3, g3, sel3) = group_doc(0.0);
|
||
if let Some(n) = d3.node_mut(g3) {
|
||
n.locked = true;
|
||
}
|
||
assert!(RotateAllWidget::of(&d3, &sel3, 1.0).is_none());
|
||
}
|
||
|
||
/// Dragging the widget a quarter turn counter-clockwise adds 90° to the group's Rotate, with
|
||
/// the Selection tool and with the Objects on Path tool, previewed while dragging and kept as
|
||
/// one undo step on release.
|
||
#[test]
|
||
fn dragging_the_rotate_all_widget_adds_the_angle_to_rotate() {
|
||
let (d, g, sel) = group_doc(30.0);
|
||
let paint = paint();
|
||
let c = cx(&d, &sel, &paint);
|
||
let at = RotateAllWidget::of(&d, &sel, 1.0).unwrap().at;
|
||
let tools: [Box<dyn Tool>; 2] = [Box::new(crate::select::SelectionTool::default()), Box::new(ObjectsOnPathTool::default())];
|
||
for mut t in tools {
|
||
assert_eq!(t.cursor(&c, at, Mods::default()), Cursor::Rotate, "{}", t.id());
|
||
assert!(t.pointer(&c, &ev(PointerKind::Down, at.x, at.y)).is_empty(), "{}", t.id());
|
||
// The press is 30° round from straight above the attachment point, as Rotate turns the
|
||
// first object; the pointer goes on to 120°.
|
||
let q = around(120.0);
|
||
let a = t.pointer(&c, &ev(PointerKind::Drag, q.x, q.y));
|
||
assert_eq!(a.first(), Some(&Action::Begin("Objects on Path Options".into())), "{}", t.id());
|
||
assert!(matches!(a.last(), Some(Action::Preview(_, p)) if p["ids"] == json!([g.0])), "{a:?}");
|
||
assert!((previewed(&a).unwrap() - 120.0).abs() < 1e-9, "{a:?}");
|
||
assert!(t.transforming() && t.cursor(&c, q, Mods::default()) == Cursor::Rotate);
|
||
assert!(t.overlays(&c).iter().any(|o| matches!(o, Overlay::Measure { text, .. } if text == "120.0°")), "{}", t.id());
|
||
assert_eq!(t.pointer(&c, &ev(PointerKind::Up, q.x, q.y)), vec![Action::Commit], "{}", t.id());
|
||
assert!(!t.busy());
|
||
// A click on the widget that does not move changes nothing.
|
||
assert!(t.pointer(&c, &ev(PointerKind::Down, at.x, at.y)).is_empty());
|
||
assert!(t.pointer(&c, &ev(PointerKind::Up, at.x, at.y)).is_empty(), "{}", t.id());
|
||
}
|
||
}
|
||
|
||
/// Shift turns in 15° steps, and a drag that goes on round the attachment point keeps adding
|
||
/// to the angle past half a turn.
|
||
#[test]
|
||
fn shift_turns_the_objects_in_steps_of_fifteen_degrees() {
|
||
let (d, _, sel) = group_doc(0.0);
|
||
let paint = paint();
|
||
let c = cx(&d, &sel, &paint);
|
||
let mut t = ObjectsOnPathTool::default();
|
||
let at = around(0.0);
|
||
t.pointer(&c, &ev(PointerKind::Down, at.x, at.y));
|
||
let q = around(20.0);
|
||
let shift = PointerEvent { mods: Mods { shift: true, ..Mods::default() }, ..ev(PointerKind::Drag, q.x, q.y) };
|
||
assert!((previewed(&t.pointer(&c, &shift)).unwrap() - 15.0).abs() < 1e-9);
|
||
let q = around(-38.0);
|
||
let shift = PointerEvent { mods: Mods { shift: true, ..Mods::default() }, ..ev(PointerKind::Drag, q.x, q.y) };
|
||
assert!((previewed(&t.pointer(&c, &shift)).unwrap() + 45.0).abs() < 1e-9);
|
||
let q = around(20.0);
|
||
assert!((previewed(&t.pointer(&c, &ev(PointerKind::Drag, q.x, q.y))).unwrap() - 20.0).abs() < 1e-9, "without Shift");
|
||
let mut last = 0.0;
|
||
for deg in [100.0, 180.0, 260.0] {
|
||
let q = around(deg);
|
||
last = previewed(&t.pointer(&c, &ev(PointerKind::Drag, q.x, q.y))).unwrap();
|
||
}
|
||
assert!((last - 260.0).abs() < 1e-9, "{last}");
|
||
}
|
||
|
||
/// Escape during a Rotate All drag cancels it: the readout is removed, and the release keeps
|
||
/// nothing.
|
||
#[test]
|
||
fn escape_cancels_a_rotate_all_drag() {
|
||
let (d, _, sel) = group_doc(0.0);
|
||
let paint = paint();
|
||
let c = cx(&d, &sel, &paint);
|
||
let tools: [Box<dyn Tool>; 2] = [Box::new(crate::select::SelectionTool::default()), Box::new(ObjectsOnPathTool::default())];
|
||
for mut t in tools {
|
||
let at = around(0.0);
|
||
t.pointer(&c, &ev(PointerKind::Down, at.x, at.y));
|
||
let q = around(60.0);
|
||
assert!(previewed(&t.pointer(&c, &ev(PointerKind::Drag, q.x, q.y))).is_some());
|
||
assert_eq!(t.key(&c, ToolKey::Escape, Mods::default()), vec![Action::Cancel], "{}", t.id());
|
||
assert!(!t.busy() && !t.transforming(), "{}", t.id());
|
||
assert!(!t.overlays(&c).iter().any(|o| matches!(o, Overlay::Measure { .. })), "{}", t.id());
|
||
assert!(t.pointer(&c, &ev(PointerKind::Drag, at.x, at.y)).is_empty(), "{}", t.id());
|
||
assert!(t.pointer(&c, &ev(PointerKind::Up, at.x, at.y)).is_empty(), "{}: the release keeps nothing", t.id());
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn a_clipping_path_or_a_blend_key_is_not_a_target() {
|
||
let (mut d, line, square) = doc();
|
||
let l = d.layers[0].id;
|
||
let key = d.alloc_id();
|
||
d.insert(Some(l), 2, Node::path(key, shapes::line(Point::new(0.0, 100.0), Point::new(400.0, 100.0)), Appearance::default_art())).unwrap();
|
||
let blend = d.alloc_id();
|
||
d.wrap(&[line, key], |children| Node::new(blend, NodeKind::Blend { children, spec: Default::default() })).unwrap();
|
||
let mask = d.alloc_id();
|
||
let art = d.alloc_id();
|
||
d.insert(Some(l), 2, Node::path(mask, shapes::rectangle(Rect::new(100.0, 380.0, 300.0, 430.0)), Appearance::default_art())).unwrap();
|
||
d.insert(Some(l), 3, Node::path(art, shapes::rectangle(Rect::new(250.0, 390.0, 290.0, 420.0)), Appearance::default_art())).unwrap();
|
||
let clip = d.alloc_id();
|
||
d.wrap(&[mask, art], |children| {
|
||
let mut g = Node::group(clip, children);
|
||
g.set_clips(true);
|
||
g
|
||
})
|
||
.unwrap();
|
||
assert_eq!(d.node(clip).and_then(|g| g.children()).and_then(|c| c.first()).map(|c| c.id), Some(mask));
|
||
let mut sel = Selection::default();
|
||
sel.set([square]);
|
||
let paint = paint();
|
||
let cx = cx(&d, &sel, &paint);
|
||
let mut t = ObjectsOnPathTool::default();
|
||
for (p, what) in [((150.0, 400.0), "a clipping path"), ((200.0, 300.0), "a blend's key path"), ((200.0, 100.0), "a blend's other key path")] {
|
||
assert_eq!(t.cursor(&cx, Point::new(p.0, p.1), Mods::default()), Cursor::Arrow, "{what}");
|
||
t.pointer(&cx, &ev(PointerKind::Move, p.0, p.1));
|
||
assert!(t.overlays(&cx).is_empty(), "{what} is not highlighted");
|
||
t.pointer(&cx, &ev(PointerKind::Down, p.0, p.1));
|
||
assert!(t.pointer(&cx, &ev(PointerKind::Up, p.0, p.1)).is_empty(), "a click on {what} attaches nothing");
|
||
}
|
||
}
|
||
|
||
/// [`group_doc`] with the group's Space `spacing` from `start`, its objects placed again.
|
||
fn spaced_doc(spacing: Option<f64>, start: f64) -> (Document, NodeId, Selection) {
|
||
let (mut d, g, sel) = group_doc(0.0);
|
||
let empty = Document::new(1.0, 1.0);
|
||
let symbols = empty.symbol_boxes();
|
||
let n = d.node_mut(g).unwrap();
|
||
let rec = n.extras().objects_on_path.as_deref().cloned().unwrap();
|
||
n.extras_mut().objects_on_path = Some(Box::new(vectorcraft_doc::objects_on_path::ObjectsOnPath { spacing, start, ..rec }));
|
||
vectorcraft_doc::objects_on_path::place(n, &symbols);
|
||
(d, g, sel)
|
||
}
|
||
|
||
/// The Space and start a drag's last action previews, to 1/1,000,000 pt.
|
||
fn spaced(acts: &[Action]) -> Option<(f64, f64)> {
|
||
let round = |v: f64| (v * 1e6).round() / 1e6 + 0.0;
|
||
match acts.last() {
|
||
Some(Action::Preview(cmd, p)) if cmd == "object.objectsOnPath.options" => {
|
||
Some((round(p["spacing"].as_f64()?), round(p["start"].as_f64()?)))
|
||
}
|
||
_ => None,
|
||
}
|
||
}
|
||
|
||
fn alt(kind: PointerKind, x: f64, y: f64) -> PointerEvent {
|
||
PointerEvent { mods: Mods { alt: true, ..Mods::default() }, ..ev(kind, x, y) }
|
||
}
|
||
|
||
#[test]
|
||
fn the_space_widget_sits_beyond_the_last_object_ahead_along_the_path() {
|
||
// Auto: the second square sits on the end (400, 300) and spans 390 to 410.
|
||
let (d, g, sel) = group_doc(0.0);
|
||
let w = SpaceWidget::of(&d, &sel, 1.0).unwrap();
|
||
assert_eq!((w.group, w.count, w.closed), (g, 2, false));
|
||
assert!(near(w.last, Point::new(400.0, 300.0)) && near(w.at, Point::new(426.0, 300.0)), "{w:?}");
|
||
assert!((w.len - 400.0).abs() < 1e-9 && w.start == 0.0 && (w.gap - 400.0).abs() < 1e-9, "{w:?}");
|
||
assert!(near(SpaceWidget::of(&d, &sel, 2.0).unwrap().at, Point::new(418.0, 300.0)));
|
||
// With a Space set it follows the last object, and Rotate All follows the first one.
|
||
let (d, _, sel) = spaced_doc(Some(100.0), 50.0);
|
||
let w = SpaceWidget::of(&d, &sel, 1.0).unwrap();
|
||
assert!(near(w.last, Point::new(150.0, 300.0)) && near(w.at, Point::new(176.0, 300.0)), "{w:?}");
|
||
assert!(near(RotateAllWidget::of(&d, &sel, 1.0).unwrap().pivot, Point::new(50.0, 300.0)));
|
||
// No widget for an object in the group, or for a locked group.
|
||
let children: Vec<NodeId> = d.node(sel.objects[0]).and_then(|n| n.children()).unwrap().iter().map(|c| c.id).collect();
|
||
let mut one = Selection::default();
|
||
one.set([children[1]]);
|
||
assert!(SpaceWidget::of(&d, &one, 1.0).is_none());
|
||
let (mut d, g, sel) = group_doc(0.0);
|
||
if let Some(n) = d.node_mut(g) {
|
||
n.locked = true;
|
||
}
|
||
assert!(SpaceWidget::of(&d, &sel, 1.0).is_none());
|
||
}
|
||
|
||
/// Dragging the widget 100 pt back along the path brings the last object 100 pt nearer the
|
||
/// first one, which stays; with Alt the first one comes as far the other way. Switching Alt
|
||
/// during the drag works from where the drag began.
|
||
#[test]
|
||
fn dragging_the_space_widget_spaces_the_objects_from_the_first_one() {
|
||
let (d, g, sel) = group_doc(0.0);
|
||
let paint = paint();
|
||
let c = cx(&d, &sel, &paint);
|
||
let at = SpaceWidget::of(&d, &sel, 1.0).unwrap().at;
|
||
let tools: [Box<dyn Tool>; 2] = [Box::new(crate::select::SelectionTool::default()), Box::new(ObjectsOnPathTool::default())];
|
||
for mut t in tools {
|
||
let id = t.id();
|
||
assert_eq!(t.cursor(&c, at, Mods::default()), Cursor::ArrowHollow, "{id}");
|
||
assert!(t.pointer(&c, &ev(PointerKind::Down, at.x, at.y)).is_empty(), "{id}");
|
||
let a = t.pointer(&c, &ev(PointerKind::Drag, at.x - 100.0, at.y + 30.0));
|
||
assert_eq!(a.first(), Some(&Action::Begin("Objects on Path Options".into())), "{id}");
|
||
assert!(matches!(a.last(), Some(Action::Preview(_, p)) if p["ids"] == json!([g.0])), "{a:?}");
|
||
assert_eq!(spaced(&a), Some((300.0, 0.0)), "{id}: the first object stays");
|
||
assert!(t.transforming() && t.cursor(&c, at, Mods::default()) == Cursor::ArrowHollow, "{id}");
|
||
let label = c.len(300.0);
|
||
assert!(t.overlays(&c).iter().any(|o| matches!(o, Overlay::Measure { text, .. } if *text == label)), "{id}");
|
||
assert_eq!(spaced(&t.pointer(&c, &alt(PointerKind::Drag, at.x - 100.0, at.y))), Some((200.0, 100.0)), "{id}: from both ends");
|
||
assert_eq!(spaced(&t.pointer(&c, &ev(PointerKind::Drag, at.x - 100.0, at.y))), Some((300.0, 0.0)), "{id}: Alt let go");
|
||
// No further than the end, where the objects are as drawn and the group stays Auto; and no
|
||
// less than 0.
|
||
let a = t.pointer(&c, &ev(PointerKind::Drag, at.x + 50.0, at.y));
|
||
assert!(matches!(a.last(), Some(Action::Preview(_, p)) if p["spacing"] == "auto" && p["start"] == 0.0), "{id}: {a:?}");
|
||
assert_eq!(spaced(&t.pointer(&c, &ev(PointerKind::Drag, at.x - 900.0, at.y))), Some((0.0, 0.0)), "{id}");
|
||
assert_eq!(spaced(&t.pointer(&c, &alt(PointerKind::Drag, at.x - 900.0, at.y))), Some((0.0, 200.0)), "{id}");
|
||
assert_eq!(t.pointer(&c, &ev(PointerKind::Up, at.x, at.y)), vec![Action::Commit], "{id}");
|
||
assert!(!t.busy(), "{id}");
|
||
// A click on the widget that does not move changes nothing.
|
||
assert!(t.pointer(&c, &ev(PointerKind::Down, at.x, at.y)).is_empty());
|
||
assert!(t.pointer(&c, &ev(PointerKind::Up, at.x, at.y)).is_empty(), "{id}");
|
||
}
|
||
}
|
||
|
||
/// A Space value the path is too short for stays when a drag leaves the objects where they are
|
||
/// drawn, and a drag that moves them sets the drawn value.
|
||
#[test]
|
||
fn a_drag_that_leaves_the_objects_as_drawn_keeps_the_saved_space() {
|
||
let (d, _, sel) = spaced_doc(Some(1000.0), 0.0);
|
||
let paint = paint();
|
||
let c = cx(&d, &sel, &paint);
|
||
let w = SpaceWidget::of(&d, &sel, 1.0).unwrap();
|
||
assert_eq!((w.gap, w.saved), (400.0, (Some(1000.0), 0.0)), "drawn to the end of the 400 pt path");
|
||
let mut t = ObjectsOnPathTool::default();
|
||
t.pointer(&c, &ev(PointerKind::Down, w.at.x, w.at.y));
|
||
assert_eq!(spaced(&t.pointer(&c, &ev(PointerKind::Drag, w.at.x + 50.0, w.at.y))), Some((1000.0, 0.0)));
|
||
assert_eq!(spaced(&t.pointer(&c, &ev(PointerKind::Drag, w.at.x - 50.0, w.at.y))), Some((350.0, 0.0)));
|
||
assert_eq!(spaced(&t.pointer(&c, &ev(PointerKind::Drag, w.at.x, w.at.y))), Some((1000.0, 0.0)), "back where it began");
|
||
}
|
||
|
||
/// On a closed path the objects go no more than once around, and Alt centers them on the
|
||
/// first anchor.
|
||
#[test]
|
||
fn dragging_the_space_widget_on_a_closed_path_wraps_at_the_first_anchor() {
|
||
let w = SpaceWidget {
|
||
group: NodeId(1),
|
||
last: Point::ZERO,
|
||
last_length: 300.0,
|
||
at: Point::ZERO,
|
||
dir: Vec2::new(1.0, 0.0),
|
||
len: 400.0,
|
||
closed: true,
|
||
count: 4,
|
||
start: 0.0,
|
||
gap: 100.0,
|
||
saved: (None, 0.0),
|
||
};
|
||
let line = shapes::line(Point::ZERO, Point::new(400.0, 0.0));
|
||
let path = Kept { group: NodeId(1), measured: Arc::new(Measured::new(&line).unwrap()), path: line };
|
||
let moved =
|
||
|along| SpaceDrag { widget: w, path: path.clone(), start: Point::ZERO, began: true, last: 0.0, along, gap: w.gap, at: Point::ZERO };
|
||
assert_eq!(moved(30.0).spacing_at(false), (100.0, 0.0), "a quarter of the way round at most");
|
||
assert_eq!(moved(-60.0).spacing_at(false), (80.0, 0.0));
|
||
assert_eq!(moved(-60.0).spacing_at(true), (60.0, 310.0), "the span of 180 centered on the first anchor");
|
||
}
|
||
|
||
/// An Objects on Path group of two 20 × 20 squares on an L: 400 pt to the right from (0, 300),
|
||
/// then 300 pt up, with Space `spacing`; and a selection of the group.
|
||
fn corner_doc(spacing: Option<f64>) -> (Document, Selection) {
|
||
let points = [Point::new(0.0, 300.0), Point::new(400.0, 300.0), Point::new(400.0, 0.0)];
|
||
path_doc(vectorcraft_geom::PathData::single(vectorcraft_geom::SubPath::polyline(&points, false)), spacing)
|
||
}
|
||
|
||
/// An Objects on Path group of two 20 × 20 squares on `path`, with Space `spacing`; and a
|
||
/// selection of the group.
|
||
fn path_doc(path: vectorcraft_geom::PathData, spacing: Option<f64>) -> (Document, Selection) {
|
||
let mut d = Document::new(500.0, 500.0);
|
||
let l = d.layers[0].id;
|
||
let (line, a, b, g) = (d.alloc_id(), d.alloc_id(), d.alloc_id(), d.alloc_id());
|
||
let line = Node::path(line, path, Appearance::default_art());
|
||
let a = Node::path(a, shapes::rectangle(Rect::new(50.0, 50.0, 70.0, 70.0)), Appearance::default_art());
|
||
let b = Node::path(b, shapes::rectangle(Rect::new(100.0, 50.0, 120.0, 70.0)), Appearance::default_art());
|
||
let rec = vectorcraft_doc::objects_on_path::ObjectsOnPath::new(line.id, &[&a, &b], CENTER, 0.0);
|
||
let rec = vectorcraft_doc::objects_on_path::ObjectsOnPath { spacing, ..rec };
|
||
let mut group = Node::new(g, NodeKind::Group { children: vec![Arc::new(line), Arc::new(a), Arc::new(b)], clip: false });
|
||
group.extras_mut().objects_on_path = Some(Box::new(rec));
|
||
vectorcraft_doc::objects_on_path::place(&mut group, &Document::new(1.0, 1.0).symbol_boxes());
|
||
d.insert(Some(l), 0, group).unwrap();
|
||
let mut sel = Selection::default();
|
||
sel.set([g]);
|
||
(d, sel)
|
||
}
|
||
|
||
/// On an L-shaped path the drag counts the distance along the path, round the corner.
|
||
#[test]
|
||
fn a_space_drag_follows_the_path_round_a_corner() {
|
||
let (d, sel) = corner_doc(None);
|
||
let paint = paint();
|
||
let c = cx(&d, &sel, &paint);
|
||
// The path is 700 pt long; the second object sits on its end (400, 0), and the widget above it.
|
||
let w = SpaceWidget::of(&d, &sel, 1.0).unwrap();
|
||
assert!(near(w.last, Point::new(400.0, 0.0)) && (w.gap - 700.0).abs() < 1e-9, "{w:?}");
|
||
let mut t = ObjectsOnPathTool::default();
|
||
t.pointer(&c, &ev(PointerKind::Down, w.at.x, w.at.y));
|
||
// The press, 26 pt beyond the end, is 726 pt along. Down the upright leg to 500 pt along,
|
||
// then round the corner onto the level one at 300 pt along.
|
||
assert_eq!(spaced(&t.pointer(&c, &ev(PointerKind::Drag, 400.0, 200.0))), Some((474.0, 0.0)));
|
||
assert_eq!(spaced(&t.pointer(&c, &ev(PointerKind::Drag, 300.0, 310.0))), Some((274.0, 0.0)));
|
||
}
|
||
|
||
/// With the last object just short of the corner, the widget sits past the corner; the drag
|
||
/// measures from the widget, so the objects follow the pointer from the start.
|
||
#[test]
|
||
fn a_space_widget_past_a_corner_measures_from_where_it_is() {
|
||
let (d, sel) = corner_doc(Some(390.0));
|
||
let paint = paint();
|
||
let c = cx(&d, &sel, &paint);
|
||
let w = SpaceWidget::of(&d, &sel, 1.0).unwrap();
|
||
assert!(near(w.last, Point::new(390.0, 300.0)) && near(w.at, Point::new(416.0, 300.0)) && w.last_length == 390.0, "{w:?}");
|
||
let mut t = ObjectsOnPathTool::default();
|
||
t.pointer(&c, &ev(PointerKind::Down, w.at.x, w.at.y));
|
||
assert_eq!(spaced(&t.pointer(&c, &ev(PointerKind::Drag, 396.0, 300.0))), Some((370.0, 0.0)), "20 pt back");
|
||
assert_eq!(spaced(&t.pointer(&c, &ev(PointerKind::Drag, 386.0, 300.0))), Some((360.0, 0.0)));
|
||
}
|
||
|
||
/// On a closed path, a drag far ahead along the line through the widget spreads the objects
|
||
/// apart, however far the pointer goes at once.
|
||
#[test]
|
||
fn a_long_drag_ahead_on_a_closed_path_spreads_the_objects() {
|
||
// The square's outline is 800 pt round, from (100, 100) to the right.
|
||
let (d, sel) = path_doc(shapes::rectangle(Rect::new(100.0, 100.0, 300.0, 300.0)), Some(100.0));
|
||
let paint = paint();
|
||
let c = cx(&d, &sel, &paint);
|
||
let w = SpaceWidget::of(&d, &sel, 1.0).unwrap();
|
||
assert!(near(w.last, Point::new(200.0, 100.0)) && near(w.at, Point::new(226.0, 100.0)), "{w:?}");
|
||
let mut t = ObjectsOnPathTool::default();
|
||
t.pointer(&c, &ev(PointerKind::Down, w.at.x, w.at.y));
|
||
assert_eq!(spaced(&t.pointer(&c, &ev(PointerKind::Drag, 236.0, 100.0))), Some((110.0, 0.0)));
|
||
assert_eq!(spaced(&t.pointer(&c, &ev(PointerKind::Drag, 1000.0, 100.0))), Some((400.0, 0.0)), "half way round at most");
|
||
}
|
||
|
||
/// The start a Move All drag's last action previews, to 1/1,000,000 pt, and whether it also
|
||
/// sets a Space value.
|
||
fn moved(acts: &[Action]) -> Option<(f64, Option<f64>)> {
|
||
let round = |v: f64| (v * 1e6).round() / 1e6 + 0.0;
|
||
match acts.last() {
|
||
Some(Action::Preview(cmd, p)) if cmd == "object.objectsOnPath.options" && p.get("rotate").is_none() => {
|
||
Some((round(p["start"].as_f64()?), p.get("spacing").and_then(Value::as_f64).map(round)))
|
||
}
|
||
_ => None,
|
||
}
|
||
}
|
||
|
||
/// A document holding an Objects on Path group of one 20 × 20 square on the line from (0, 300)
|
||
/// to (400, 300), and a selection of the group.
|
||
fn single_doc() -> (Document, Selection) {
|
||
let mut d = Document::new(500.0, 500.0);
|
||
let l = d.layers[0].id;
|
||
let (line, a, g) = (d.alloc_id(), d.alloc_id(), d.alloc_id());
|
||
let line = Node::path(line, shapes::line(Point::new(0.0, 300.0), Point::new(400.0, 300.0)), Appearance::default_art());
|
||
let a = Node::path(a, shapes::rectangle(Rect::new(50.0, 50.0, 70.0, 70.0)), Appearance::default_art());
|
||
let rec = vectorcraft_doc::objects_on_path::ObjectsOnPath::new(line.id, &[&a], CENTER, 0.0);
|
||
let mut group = Node::new(g, NodeKind::Group { children: vec![Arc::new(line), Arc::new(a)], clip: false });
|
||
group.extras_mut().objects_on_path = Some(Box::new(rec));
|
||
vectorcraft_doc::objects_on_path::place(&mut group, &Document::new(1.0, 1.0).symbol_boxes());
|
||
d.insert(Some(l), 0, group).unwrap();
|
||
let mut sel = Selection::default();
|
||
sel.set([g]);
|
||
(d, sel)
|
||
}
|
||
|
||
#[test]
|
||
fn the_move_all_widget_sits_below_the_first_object_when_the_objects_have_room() {
|
||
// Space 100 from 50: the first square spans 290 to 310 down the page, and the widget is
|
||
// 16 px below its bottom. The two objects take 100 pt of the 400 pt path, so the first
|
||
// one can go from 0 to 300 along it.
|
||
let (d, g, sel) = spaced_doc(Some(100.0), 50.0);
|
||
let w = MoveAllWidget::of(&d, &sel, 1.0).unwrap();
|
||
assert_eq!(w.group, g);
|
||
assert!(near(w.first, Point::new(50.0, 300.0)) && near(w.at, Point::new(50.0, 326.0)), "{w:?}");
|
||
assert!(w.start == 50.0 && (w.most - 300.0).abs() < 1e-9 && w.gap.is_none() && !w.closed, "{w:?}");
|
||
assert!(near(MoveAllWidget::of(&d, &sel, 2.0).unwrap().at, Point::new(50.0, 318.0)));
|
||
// Auto spreads the objects from one end of an open path to the other: no room to move.
|
||
let (d, _, sel) = group_doc(0.0);
|
||
assert!(MoveAllWidget::of(&d, &sel, 1.0).is_none(), "Auto");
|
||
// Nor with a Space value that reaches the end.
|
||
let (d, _, sel) = spaced_doc(Some(400.0), 0.0);
|
||
assert!(MoveAllWidget::of(&d, &sel, 1.0).is_none(), "the whole path");
|
||
// On a closed path the objects always have room, Auto included.
|
||
let (d, sel) = path_doc(shapes::rectangle(Rect::new(100.0, 100.0, 300.0, 300.0)), None);
|
||
let w = MoveAllWidget::of(&d, &sel, 1.0).unwrap();
|
||
assert!(w.closed && (w.most - 800.0).abs() < 1e-9 && w.gap.is_none(), "{w:?}");
|
||
// One object on an open path can move along all of it.
|
||
let (d, sel) = single_doc();
|
||
let w = MoveAllWidget::of(&d, &sel, 1.0).unwrap();
|
||
assert!(w.start == 0.0 && (w.most - 400.0).abs() < 1e-9 && w.gap.is_none(), "{w:?}");
|
||
// No widget for an object in the group, or for a locked group.
|
||
let (d, _, sel) = spaced_doc(Some(100.0), 50.0);
|
||
let children: Vec<NodeId> = d.node(sel.objects[0]).and_then(|n| n.children()).unwrap().iter().map(|c| c.id).collect();
|
||
let mut one = Selection::default();
|
||
one.set([children[1]]);
|
||
assert!(MoveAllWidget::of(&d, &one, 1.0).is_none());
|
||
let (mut d, g, sel) = spaced_doc(Some(100.0), 50.0);
|
||
if let Some(n) = d.node_mut(g) {
|
||
n.locked = true;
|
||
}
|
||
assert!(MoveAllWidget::of(&d, &sel, 1.0).is_none());
|
||
}
|
||
|
||
/// Dragging the widget 80 pt along the path moves both objects 80 pt, keeping the Space, with
|
||
/// the Selection tool and with the Objects on Path tool, previewed while dragging and kept as
|
||
/// one undo step on release. On an open path the objects stop at its ends, and coming back
|
||
/// moves them back at once.
|
||
#[test]
|
||
fn dragging_the_move_all_widget_moves_every_object_along_the_path() {
|
||
let (d, g, sel) = spaced_doc(Some(100.0), 50.0);
|
||
let paint = paint();
|
||
let c = cx(&d, &sel, &paint);
|
||
let at = MoveAllWidget::of(&d, &sel, 1.0).unwrap().at;
|
||
let tools: [Box<dyn Tool>; 2] = [Box::new(crate::select::SelectionTool::default()), Box::new(ObjectsOnPathTool::default())];
|
||
for mut t in tools {
|
||
let id = t.id();
|
||
assert_eq!(t.cursor(&c, at, Mods::default()), Cursor::Move, "{id}");
|
||
assert!(t.pointer(&c, &ev(PointerKind::Down, at.x, at.y)).is_empty(), "{id}");
|
||
let a = t.pointer(&c, &ev(PointerKind::Drag, at.x + 80.0, at.y + 10.0));
|
||
assert_eq!(a.first(), Some(&Action::Begin("Objects on Path Options".into())), "{id}");
|
||
assert!(matches!(a.last(), Some(Action::Preview(_, p)) if p["ids"] == json!([g.0])), "{a:?}");
|
||
assert_eq!(moved(&a), Some((130.0, None)), "{id}: only the start changes");
|
||
assert!(t.transforming() && t.cursor(&c, at, Mods::default()) == Cursor::Move, "{id}");
|
||
let label = c.len(130.0);
|
||
assert!(t.overlays(&c).iter().any(|o| matches!(o, Overlay::Measure { text, .. } if *text == label)), "{id}");
|
||
// Shift and Alt change nothing.
|
||
let mods = Mods { shift: true, alt: true, ..Mods::default() };
|
||
assert_eq!(moved(&t.pointer(&c, &PointerEvent { mods, ..ev(PointerKind::Drag, at.x + 90.0, at.y) })), Some((140.0, None)), "{id}");
|
||
// No further than where the last object reaches the end, and back at once.
|
||
assert_eq!(moved(&t.pointer(&c, &ev(PointerKind::Drag, at.x + 900.0, at.y))), Some((300.0, None)), "{id}");
|
||
assert_eq!(moved(&t.pointer(&c, &ev(PointerKind::Drag, at.x + 880.0, at.y))), Some((280.0, None)), "{id}");
|
||
assert_eq!(moved(&t.pointer(&c, &ev(PointerKind::Drag, at.x - 900.0, at.y))), Some((0.0, None)), "{id}");
|
||
assert_eq!(t.pointer(&c, &ev(PointerKind::Up, at.x, at.y)), vec![Action::Commit], "{id}");
|
||
assert!(!t.busy(), "{id}");
|
||
// A click on the widget that does not move changes nothing.
|
||
assert!(t.pointer(&c, &ev(PointerKind::Down, at.x, at.y)).is_empty());
|
||
assert!(t.pointer(&c, &ev(PointerKind::Up, at.x + 1.0, at.y)).is_empty(), "{id}");
|
||
}
|
||
}
|
||
|
||
/// Where the saved Space would draw the objects apart differently from another start (Auto,
|
||
/// or a value the path is too short for), the drag sets the distance as drawn with the start;
|
||
/// back where it began, the group keeps its saved values.
|
||
#[test]
|
||
fn a_move_all_drag_keeps_the_distance_the_objects_are_drawn_at() {
|
||
for (spacing, what) in [(Some(1000.0), "a Space value too large for the path"), (None, "Auto")] {
|
||
let (d, _, sel) = spaced_doc(spacing, 100.0);
|
||
let paint = paint();
|
||
let c = cx(&d, &sel, &paint);
|
||
let w = MoveAllWidget::of(&d, &sel, 1.0).unwrap();
|
||
assert!((w.most - 100.0).abs() < 1e-9 && w.gap == Some(300.0), "{what}: {w:?}");
|
||
let mut t = ObjectsOnPathTool::default();
|
||
t.pointer(&c, &ev(PointerKind::Down, w.at.x, w.at.y));
|
||
assert_eq!(moved(&t.pointer(&c, &ev(PointerKind::Drag, w.at.x - 40.0, w.at.y))), Some((60.0, Some(300.0))), "{what}");
|
||
let a = t.pointer(&c, &ev(PointerKind::Drag, w.at.x, w.at.y));
|
||
assert_eq!(moved(&a), Some((100.0, None)), "{what}: back where it began");
|
||
}
|
||
}
|
||
|
||
/// On an L-shaped path the drag counts the distance along the path, round the corner.
|
||
#[test]
|
||
fn a_move_all_drag_follows_the_path_round_a_corner() {
|
||
let (d, sel) = corner_doc(Some(100.0));
|
||
let paint = paint();
|
||
let c = cx(&d, &sel, &paint);
|
||
let w = MoveAllWidget::of(&d, &sel, 1.0).unwrap();
|
||
assert!(near(w.at, Point::new(0.0, 326.0)) && (w.most - 600.0).abs() < 1e-9, "{w:?}");
|
||
let mut t = ObjectsOnPathTool::default();
|
||
t.pointer(&c, &ev(PointerKind::Down, w.at.x, w.at.y));
|
||
assert_eq!(moved(&t.pointer(&c, &ev(PointerKind::Drag, 200.0, 326.0))), Some((200.0, None)));
|
||
// Up the upright leg, 200 pt from the corner.
|
||
assert_eq!(moved(&t.pointer(&c, &ev(PointerKind::Drag, 426.0, 100.0))), Some((600.0, None)), "no further than the end");
|
||
assert_eq!(moved(&t.pointer(&c, &ev(PointerKind::Drag, 426.0, 200.0))), Some((500.0, None)));
|
||
}
|
||
|
||
/// On a closed path the objects go on round across the first anchor, both ways.
|
||
#[test]
|
||
fn a_move_all_drag_on_a_closed_path_goes_round_across_the_first_anchor() {
|
||
// The square's outline is 800 pt round, from (100, 100) to the right.
|
||
let (d, sel) = path_doc(shapes::rectangle(Rect::new(100.0, 100.0, 300.0, 300.0)), Some(100.0));
|
||
let paint = paint();
|
||
let c = cx(&d, &sel, &paint);
|
||
let w = MoveAllWidget::of(&d, &sel, 1.0).unwrap();
|
||
assert!(near(w.first, Point::new(100.0, 100.0)) && near(w.at, Point::new(100.0, 126.0)), "{w:?}");
|
||
let mut t = ObjectsOnPathTool::default();
|
||
t.pointer(&c, &ev(PointerKind::Down, w.at.x, w.at.y));
|
||
// Down the left side, back before the first anchor.
|
||
assert_eq!(moved(&t.pointer(&c, &ev(PointerKind::Drag, 100.0, 150.0))), Some((776.0, None)));
|
||
// Round the corner onto the top, ahead of it again.
|
||
assert_eq!(moved(&t.pointer(&c, &ev(PointerKind::Drag, 130.0, 100.0))), Some((56.0, None)));
|
||
}
|
||
|
||
/// One object moves along all of an open path.
|
||
#[test]
|
||
fn a_move_all_drag_moves_a_single_object_to_the_end() {
|
||
let (d, sel) = single_doc();
|
||
let paint = paint();
|
||
let c = cx(&d, &sel, &paint);
|
||
let w = MoveAllWidget::of(&d, &sel, 1.0).unwrap();
|
||
let mut t = crate::select::SelectionTool::default();
|
||
t.pointer(&c, &ev(PointerKind::Down, w.at.x, w.at.y));
|
||
assert_eq!(moved(&t.pointer(&c, &ev(PointerKind::Drag, w.at.x + 150.0, w.at.y))), Some((150.0, None)));
|
||
assert_eq!(moved(&t.pointer(&c, &ev(PointerKind::Drag, w.at.x + 600.0, w.at.y))), Some((400.0, None)));
|
||
}
|
||
|
||
/// Escape during a Move All drag cancels it: the readout is removed, and the release keeps
|
||
/// nothing.
|
||
#[test]
|
||
fn escape_cancels_a_move_all_drag() {
|
||
let (d, _, sel) = spaced_doc(Some(100.0), 50.0);
|
||
let paint = paint();
|
||
let c = cx(&d, &sel, &paint);
|
||
let at = MoveAllWidget::of(&d, &sel, 1.0).unwrap().at;
|
||
let tools: [Box<dyn Tool>; 2] = [Box::new(crate::select::SelectionTool::default()), Box::new(ObjectsOnPathTool::default())];
|
||
for mut t in tools {
|
||
t.pointer(&c, &ev(PointerKind::Down, at.x, at.y));
|
||
assert!(moved(&t.pointer(&c, &ev(PointerKind::Drag, at.x + 40.0, at.y))).is_some());
|
||
assert_eq!(t.key(&c, ToolKey::Escape, Mods::default()), vec![Action::Cancel], "{}", t.id());
|
||
assert!(!t.busy() && !t.transforming(), "{}", t.id());
|
||
assert!(!t.overlays(&c).iter().any(|o| matches!(o, Overlay::Measure { .. })), "{}", t.id());
|
||
assert!(t.pointer(&c, &ev(PointerKind::Drag, at.x, at.y)).is_empty(), "{}", t.id());
|
||
assert!(t.pointer(&c, &ev(PointerKind::Up, at.x, at.y)).is_empty(), "{}: the release keeps nothing", t.id());
|
||
}
|
||
}
|
||
|
||
/// Escape during a Space drag cancels it: the readout is removed, and the release keeps
|
||
/// nothing.
|
||
#[test]
|
||
fn escape_cancels_a_space_drag() {
|
||
let (d, _, sel) = group_doc(0.0);
|
||
let paint = paint();
|
||
let c = cx(&d, &sel, &paint);
|
||
let at = SpaceWidget::of(&d, &sel, 1.0).unwrap().at;
|
||
let tools: [Box<dyn Tool>; 2] = [Box::new(crate::select::SelectionTool::default()), Box::new(ObjectsOnPathTool::default())];
|
||
for mut t in tools {
|
||
t.pointer(&c, &ev(PointerKind::Down, at.x, at.y));
|
||
assert!(spaced(&t.pointer(&c, &ev(PointerKind::Drag, at.x - 40.0, at.y))).is_some());
|
||
assert_eq!(t.key(&c, ToolKey::Escape, Mods::default()), vec![Action::Cancel], "{}", t.id());
|
||
assert!(!t.busy() && !t.transforming(), "{}", t.id());
|
||
assert!(!t.overlays(&c).iter().any(|o| matches!(o, Overlay::Measure { .. })), "{}", t.id());
|
||
assert!(t.pointer(&c, &ev(PointerKind::Drag, at.x, at.y)).is_empty(), "{}", t.id());
|
||
assert!(t.pointer(&c, &ev(PointerKind::Up, at.x, at.y)).is_empty(), "{}: the release keeps nothing", t.id());
|
||
}
|
||
}
|
||
|
||
/// A document holding an Objects on Path group of `n` 20 × 20 squares attached by their centers
|
||
/// to `path`, with the group's Space `spacing`, a selection of the group, and the squares' ids
|
||
/// in their order along the path.
|
||
fn members_doc(path: vectorcraft_geom::PathData, n: usize, spacing: Option<f64>) -> (Document, NodeId, Selection, Vec<NodeId>) {
|
||
let mut d = Document::new(500.0, 500.0);
|
||
let l = d.layers[0].id;
|
||
let (line, g) = (d.alloc_id(), d.alloc_id());
|
||
let line = Node::path(line, path, Appearance::default_art());
|
||
let squares: Vec<Node> = (0..n)
|
||
.map(|i| {
|
||
let x = 50.0 * i as f64;
|
||
Node::path(d.alloc_id(), shapes::rectangle(Rect::new(x, 50.0, x + 20.0, 70.0)), Appearance::default_art())
|
||
})
|
||
.collect();
|
||
let ids: Vec<NodeId> = squares.iter().map(|s| s.id).collect();
|
||
let rec = vectorcraft_doc::objects_on_path::ObjectsOnPath {
|
||
spacing,
|
||
..vectorcraft_doc::objects_on_path::ObjectsOnPath::new(line.id, &squares.iter().collect::<Vec<_>>(), CENTER, 0.0)
|
||
};
|
||
let mut children = vec![Arc::new(line)];
|
||
children.extend(squares.into_iter().map(Arc::new));
|
||
let mut group = Node::new(g, NodeKind::Group { children, clip: false });
|
||
group.extras_mut().objects_on_path = Some(Box::new(rec));
|
||
vectorcraft_doc::objects_on_path::place(&mut group, &Document::new(1.0, 1.0).symbol_boxes());
|
||
d.insert(Some(l), 0, group).unwrap();
|
||
let mut sel = Selection::default();
|
||
sel.set([g]);
|
||
(d, g, sel, ids)
|
||
}
|
||
|
||
/// Three squares on the line from (0, 300) to (400, 300): at 0, 200 and 400.
|
||
fn three_doc() -> (Document, NodeId, Selection, Vec<NodeId>) {
|
||
members_doc(shapes::line(Point::new(0.0, 300.0), Point::new(400.0, 300.0)), 3, None)
|
||
}
|
||
|
||
/// The `target` a drag's actions preview for `object.objectsOnPath.moveMember`, if any.
|
||
fn previewed_target(acts: &[Action]) -> Option<u64> {
|
||
acts.iter().rev().find_map(|a| match a {
|
||
Action::Preview(cmd, p) if cmd == "object.objectsOnPath.moveMember" => p["target"].as_u64(),
|
||
_ => None,
|
||
})
|
||
}
|
||
|
||
fn choose(id: NodeId) -> Action {
|
||
Action::Exec("object.objectsOnPath.selectMember".into(), json!({ "member": id.0 }))
|
||
}
|
||
|
||
#[test]
|
||
fn a_select_move_widget_sits_on_each_attachment_point() {
|
||
let (d, g, sel, ids) = three_doc();
|
||
let ws = MemberWidget::all(&d, &sel, 1.0);
|
||
let at: Vec<(NodeId, usize, Point, bool)> = ws.iter().map(|w| (w.member, w.index, w.at, w.chosen)).collect();
|
||
assert!(ws.iter().all(|w| w.group == g));
|
||
assert_eq!(at.len(), 3);
|
||
for (i, x) in [0.0, 200.0, 400.0].into_iter().enumerate() {
|
||
assert!(at[i].0 == ids[i] && at[i].1 == i && near(at[i].2, Point::new(x, 300.0)) && !at[i].3, "{at:?}");
|
||
}
|
||
let mut chosen = sel.clone();
|
||
chosen.on_path_member = Some(ids[1]);
|
||
assert_eq!(MemberWidget::all(&d, &chosen, 1.0).iter().map(|w| w.chosen).collect::<Vec<_>>(), [false, true, false]);
|
||
// None for an object in the group, with anchors Direct-Selected, or for a locked group.
|
||
let mut one = Selection::default();
|
||
one.set([ids[0]]);
|
||
assert!(MemberWidget::all(&d, &one, 1.0).is_empty());
|
||
let mut anchors = sel.clone();
|
||
anchors.anchors.insert(ids[0], [(0, 0)].into());
|
||
assert!(MemberWidget::all(&d, &anchors, 1.0).is_empty());
|
||
let (mut locked, lg, lsel, _) = three_doc();
|
||
locked.node_mut(lg).unwrap().locked = true;
|
||
assert!(MemberWidget::all(&locked, &lsel, 1.0).is_empty());
|
||
}
|
||
|
||
/// A click on a widget chooses its object without moving it, with the Selection tool and the
|
||
/// Objects on Path tool; a click on the object's art away from the widget does not.
|
||
#[test]
|
||
fn a_click_on_a_select_move_widget_chooses_its_object() {
|
||
let (d, _, sel, ids) = three_doc();
|
||
let paint = paint();
|
||
let c = cx(&d, &sel, &paint);
|
||
let tools: [Box<dyn Tool>; 2] = [Box::new(crate::select::SelectionTool::default()), Box::new(ObjectsOnPathTool::default())];
|
||
for mut t in tools {
|
||
t.pointer(&c, &ev(PointerKind::Move, 202.0, 301.0));
|
||
assert!(t.overlays(&c).iter().any(|o| matches!(o, Overlay::Path { color, .. } if *color == HIGHLIGHT)), "{}: highlighted", t.id());
|
||
assert_eq!(t.cursor(&c, Point::new(202.0, 301.0), Mods::default()), Cursor::Move, "{}", t.id());
|
||
assert!(t.pointer(&c, &ev(PointerKind::Down, 202.0, 301.0)).is_empty());
|
||
assert!(t.pointer(&c, &ev(PointerKind::Drag, 203.0, 301.0)).is_empty(), "{}: within the click", t.id());
|
||
assert_eq!(t.pointer(&c, &ev(PointerKind::Up, 203.0, 301.0)), vec![choose(ids[1])], "{}", t.id());
|
||
assert!(!t.busy());
|
||
// On the art, 8 px from the attachment point: not the widget.
|
||
t.pointer(&c, &ev(PointerKind::Down, 208.0, 300.0));
|
||
let acts = t.pointer(&c, &ev(PointerKind::Up, 208.0, 300.0));
|
||
assert!(!acts.contains(&choose(ids[1])), "{}: {acts:?}", t.id());
|
||
}
|
||
}
|
||
|
||
/// A widget at an end of the path is within reach from beyond the path's bounds too, up to
|
||
/// 6 px away.
|
||
#[test]
|
||
fn a_select_move_widget_at_an_end_is_hit_from_beyond_the_path() {
|
||
let (d, _, sel, _) = three_doc();
|
||
let paint = paint();
|
||
let c = cx(&d, &sel, &paint);
|
||
assert!(over_member(&c, Point::new(-5.0, 300.0)), "before the start");
|
||
assert!(over_member(&c, Point::new(405.0, 300.0)), "after the end");
|
||
assert!(over_member(&c, Point::new(0.0, 305.5)), "beside the line");
|
||
assert!(!over_member(&c, Point::new(0.0, 306.5)), "out of reach");
|
||
assert!(!over_member(&c, Point::new(-6.5, 300.0)), "out of reach before the start");
|
||
}
|
||
|
||
/// Dragging the middle object's widget past the last one moves it to the last place; dragging
|
||
/// the last one's beyond the start of the line moves it to the first place. Each drag is one
|
||
/// undo step, and the release chooses the object.
|
||
#[test]
|
||
fn dragging_a_select_move_widget_moves_its_object_to_the_nearest_place() {
|
||
let (d, g, sel, ids) = three_doc();
|
||
let paint = paint();
|
||
let c = cx(&d, &sel, &paint);
|
||
let tools: [Box<dyn Tool>; 2] = [Box::new(crate::select::SelectionTool::default()), Box::new(ObjectsOnPathTool::default())];
|
||
for mut t in tools {
|
||
t.pointer(&c, &ev(PointerKind::Down, 200.0, 300.0));
|
||
let a = t.pointer(&c, &ev(PointerKind::Drag, 280.0, 310.0));
|
||
assert_eq!(a, vec![Action::Begin("Move Object on Path".into())], "{}: still nearest its own place", t.id());
|
||
assert!(t.transforming() && t.cursor(&c, Point::new(280.0, 310.0), Mods::default()) == Cursor::Move);
|
||
let a = t.pointer(&c, &ev(PointerKind::Drag, 330.0, 300.0));
|
||
assert!(
|
||
matches!(a.as_slice(), [Action::Preview(cmd, p)] if cmd == "object.objectsOnPath.moveMember" && *p == json!({ "group": g.0, "member": ids[1].0, "target": ids[2].0 })),
|
||
"{}: {a:?}",
|
||
t.id()
|
||
);
|
||
assert!(t.pointer(&c, &ev(PointerKind::Drag, 600.0, 300.0)).is_empty(), "{}: beyond the end, the last place", t.id());
|
||
assert_eq!(t.pointer(&c, &ev(PointerKind::Up, 600.0, 300.0)), vec![Action::Commit, choose(ids[1])], "{}", t.id());
|
||
assert!(!t.busy() && !t.transforming());
|
||
// The last one, back before the start of the line.
|
||
t.pointer(&c, &ev(PointerKind::Down, 400.0, 300.0));
|
||
let a = t.pointer(&c, &ev(PointerKind::Drag, 250.0, 300.0));
|
||
assert_eq!(previewed_target(&a), Some(ids[1].0), "{}: {a:?}", t.id());
|
||
let a = t.pointer(&c, &ev(PointerKind::Drag, -80.0, 300.0));
|
||
assert_eq!(previewed_target(&a), Some(ids[0].0), "{}: {a:?}", t.id());
|
||
assert_eq!(t.pointer(&c, &ev(PointerKind::Up, -80.0, 300.0)), vec![Action::Commit, choose(ids[2])], "{}", t.id());
|
||
}
|
||
}
|
||
|
||
/// A drag that comes back to its own place previews the object back there and keeps nothing on
|
||
/// release; Escape cancels a drag.
|
||
#[test]
|
||
fn a_select_move_drag_back_to_its_place_or_escaped_keeps_nothing() {
|
||
let (d, _, sel, ids) = three_doc();
|
||
let paint = paint();
|
||
let c = cx(&d, &sel, &paint);
|
||
let tools: [Box<dyn Tool>; 2] = [Box::new(crate::select::SelectionTool::default()), Box::new(ObjectsOnPathTool::default())];
|
||
for mut t in tools {
|
||
t.pointer(&c, &ev(PointerKind::Down, 0.0, 300.0));
|
||
assert_eq!(previewed_target(&t.pointer(&c, &ev(PointerKind::Drag, 190.0, 300.0))), Some(ids[1].0));
|
||
assert_eq!(previewed_target(&t.pointer(&c, &ev(PointerKind::Drag, 20.0, 300.0))), Some(ids[0].0), "{}: back onto itself", t.id());
|
||
assert_eq!(t.pointer(&c, &ev(PointerKind::Up, 20.0, 300.0)), vec![Action::Cancel, choose(ids[0])], "{}", t.id());
|
||
t.pointer(&c, &ev(PointerKind::Down, 0.0, 300.0));
|
||
assert!(previewed_target(&t.pointer(&c, &ev(PointerKind::Drag, 390.0, 300.0))).is_some());
|
||
assert_eq!(t.key(&c, ToolKey::Escape, Mods::default()), vec![Action::Cancel], "{}", t.id());
|
||
assert!(!t.busy() && !t.transforming(), "{}", t.id());
|
||
assert!(t.pointer(&c, &ev(PointerKind::Drag, 0.0, 300.0)).is_empty(), "{}", t.id());
|
||
assert!(t.pointer(&c, &ev(PointerKind::Up, 0.0, 300.0)).is_empty(), "{}: the release keeps nothing", t.id());
|
||
}
|
||
}
|
||
|
||
/// Round a closed path the drag goes on across the first anchor: the first object, dragged back
|
||
/// past it, takes the last place.
|
||
#[test]
|
||
fn a_select_move_drag_goes_round_a_closed_path_across_its_first_anchor() {
|
||
// The square's outline is 400 pt round, from (100, 100) to the right and on clockwise: the
|
||
// four objects sit on its corners.
|
||
let (d, _, sel, ids) = members_doc(shapes::rectangle(Rect::new(100.0, 100.0, 200.0, 200.0)), 4, None);
|
||
let paint = paint();
|
||
let c = cx(&d, &sel, &paint);
|
||
let mut t = ObjectsOnPathTool::default();
|
||
t.pointer(&c, &ev(PointerKind::Down, 100.0, 100.0));
|
||
assert!(previewed_target(&t.pointer(&c, &ev(PointerKind::Drag, 100.0, 130.0))).is_none(), "nearer its own place");
|
||
let a = t.pointer(&c, &ev(PointerKind::Drag, 100.0, 180.0));
|
||
assert_eq!(previewed_target(&a), Some(ids[3].0), "{a:?}");
|
||
assert_eq!(t.pointer(&c, &ev(PointerKind::Up, 100.0, 180.0)), vec![Action::Commit, choose(ids[0])]);
|
||
// Forward from the last one across the first anchor: the first place.
|
||
t.pointer(&c, &ev(PointerKind::Down, 100.0, 200.0));
|
||
let a = t.pointer(&c, &ev(PointerKind::Drag, 100.0, 120.0));
|
||
assert_eq!(previewed_target(&a), Some(ids[0].0), "{a:?}");
|
||
}
|
||
|
||
/// On an open path that turns back on itself, a drag takes the place nearest the pointer even
|
||
/// when that place is far along the path from where the drag is.
|
||
#[test]
|
||
fn a_select_move_drag_takes_the_place_under_the_pointer_on_a_path_that_turns_back() {
|
||
// The path runs 210 pt from (0, 0) right, down and back left to (0, 10): the four objects
|
||
// sit at 0, 70, 140 and 210 pt along it, the last one 10 pt below the first.
|
||
let corners = [Point::new(0.0, 0.0), Point::new(100.0, 0.0), Point::new(100.0, 10.0), Point::new(0.0, 10.0)];
|
||
let path = vectorcraft_geom::PathData::new(vec![vectorcraft_geom::SubPath::polyline(&corners, false)]);
|
||
let (d, _, sel, ids) = members_doc(path, 4, None);
|
||
let paint = paint();
|
||
let c = cx(&d, &sel, &paint);
|
||
let mut t = ObjectsOnPathTool::default();
|
||
t.pointer(&c, &ev(PointerKind::Down, 0.0, 0.0));
|
||
let a = t.pointer(&c, &ev(PointerKind::Drag, 0.0, 9.0));
|
||
assert_eq!(previewed_target(&a), Some(ids[3].0), "{a:?}");
|
||
assert_eq!(t.pointer(&c, &ev(PointerKind::Up, 0.0, 9.0)), vec![Action::Commit, choose(ids[0])]);
|
||
}
|
||
|
||
/// Where an open path runs back over itself, a drag along the part that runs back stays on that
|
||
/// part.
|
||
#[test]
|
||
fn a_select_move_drag_follows_the_part_it_is_on_where_a_path_runs_back_over_itself() {
|
||
// The path runs 540 pt from (0, 0) right to (300, 0) and back left to (60, 0): the four
|
||
// objects sit at 0, 180, 360 and 540 pt along it, at x 0, 180, 240 and 60.
|
||
let corners = [Point::new(0.0, 0.0), Point::new(300.0, 0.0), Point::new(60.0, 0.0)];
|
||
let path = vectorcraft_geom::PathData::new(vec![vectorcraft_geom::SubPath::polyline(&corners, false)]);
|
||
let (d, _, sel, ids) = members_doc(path, 4, None);
|
||
let paint = paint();
|
||
let c = cx(&d, &sel, &paint);
|
||
let mut t = ObjectsOnPathTool::default();
|
||
t.pointer(&c, &ev(PointerKind::Down, 240.0, 0.0));
|
||
let a = t.pointer(&c, &ev(PointerKind::Drag, 220.0, 0.0));
|
||
assert!(previewed_target(&a).is_none(), "nearer its own place: {a:?}");
|
||
let a = t.pointer(&c, &ev(PointerKind::Drag, 80.0, 0.0));
|
||
assert_eq!(previewed_target(&a), Some(ids[3].0), "{a:?}");
|
||
assert_eq!(t.pointer(&c, &ev(PointerKind::Up, 80.0, 0.0)), vec![Action::Commit, choose(ids[2])]);
|
||
}
|
||
|
||
/// A hidden or locked object has no widget, and a drag does not take its place: the first
|
||
/// object, dragged onto the locked last one's place, stays at the nearest place it can take.
|
||
#[test]
|
||
fn a_locked_object_has_no_select_move_widget_and_keeps_its_place() {
|
||
let (mut d, _, sel, ids) = three_doc();
|
||
d.node_mut(ids[2]).unwrap().locked = true;
|
||
assert_eq!(MemberWidget::all(&d, &sel, 1.0).iter().map(|w| w.member).collect::<Vec<_>>(), ids[..2]);
|
||
let paint = paint();
|
||
let c = cx(&d, &sel, &paint);
|
||
let mut t = ObjectsOnPathTool::default();
|
||
t.pointer(&c, &ev(PointerKind::Down, 400.0, 300.0));
|
||
assert!(t.pointer(&c, &ev(PointerKind::Up, 400.0, 300.0)).iter().all(|a| *a != choose(ids[2])), "no widget to press");
|
||
t.pointer(&c, &ev(PointerKind::Down, 0.0, 300.0));
|
||
assert_eq!(previewed_target(&t.pointer(&c, &ev(PointerKind::Drag, 390.0, 300.0))), Some(ids[1].0));
|
||
assert_eq!(t.pointer(&c, &ev(PointerKind::Up, 390.0, 300.0)), vec![Action::Commit, choose(ids[0])]);
|
||
}
|
||
|
||
/// Of widgets on the same point (no Space between the objects), a press takes the chosen
|
||
/// object's, else the first one's; between places as near, a drag keeps the place it is at.
|
||
#[test]
|
||
fn stacked_select_move_widgets_take_the_chosen_one_and_ties_keep_the_place() {
|
||
let (d, _, mut sel, ids) = members_doc(shapes::line(Point::new(0.0, 300.0), Point::new(400.0, 300.0)), 3, Some(0.0));
|
||
let paint = paint();
|
||
{
|
||
let c = cx(&d, &sel, &paint);
|
||
let mut t = ObjectsOnPathTool::default();
|
||
t.pointer(&c, &ev(PointerKind::Down, 0.0, 300.0));
|
||
assert_eq!(t.pointer(&c, &ev(PointerKind::Up, 0.0, 300.0)), vec![choose(ids[0])]);
|
||
// Every place is as far as the others: the drag stays where it is.
|
||
t.pointer(&c, &ev(PointerKind::Down, 0.0, 300.0));
|
||
assert!(previewed_target(&t.pointer(&c, &ev(PointerKind::Drag, 200.0, 300.0))).is_none());
|
||
assert_eq!(t.pointer(&c, &ev(PointerKind::Up, 200.0, 300.0)), vec![Action::Cancel, choose(ids[0])]);
|
||
}
|
||
sel.on_path_member = Some(ids[2]);
|
||
let c = cx(&d, &sel, &paint);
|
||
let mut t = ObjectsOnPathTool::default();
|
||
t.pointer(&c, &ev(PointerKind::Down, 0.0, 300.0));
|
||
assert_eq!(t.pointer(&c, &ev(PointerKind::Up, 0.0, 300.0)), vec![choose(ids[2])], "the chosen one");
|
||
}
|
||
|
||
/// What `f` returns, and how many times it flattened a path.
|
||
fn flattenings<T>(f: impl FnOnce() -> T) -> (T, usize) {
|
||
let before = vectorcraft_doc::blend::spines_built();
|
||
let out = f();
|
||
(out, vectorcraft_doc::blend::spines_built() - before)
|
||
}
|
||
|
||
/// Space 100 from 50 on the line from (0, 300) to (400, 300): the objects attach at (50, 300)
|
||
/// and (150, 300). The Rotate All widget is at (50, 274), the Move All widget at (50, 326) and
|
||
/// the Space widget at (176, 300).
|
||
#[test]
|
||
fn each_widget_lookup_flattens_the_path_once() {
|
||
let (d, g, sel) = spaced_doc(Some(100.0), 50.0);
|
||
let paint = paint();
|
||
let c = cx(&d, &sel, &paint);
|
||
// Points to 1/1,000 pt, as the path is measured along its flattening.
|
||
let close = |a: Point, b: Point| a.distance(b) < 1e-3;
|
||
let (w, n) = flattenings(|| RotateAllWidget::of(&d, &sel, 1.0));
|
||
assert_eq!(n, 1, "Rotate All");
|
||
let w = w.unwrap();
|
||
assert!(w.group == g && w.rotate == 0.0, "{w:?}");
|
||
assert!(close(w.pivot, Point::new(50.0, 300.0)) && close(w.at, Point::new(50.0, 274.0)), "{w:?}");
|
||
let (w, n) = flattenings(|| SpaceWidget::of(&d, &sel, 1.0));
|
||
assert_eq!(n, 1, "Space");
|
||
let w = w.unwrap();
|
||
assert!(close(w.last, Point::new(150.0, 300.0)) && close(w.at, Point::new(176.0, 300.0)), "{w:?}");
|
||
assert!((w.last_length - 150.0).abs() < 1e-3 && (w.len - 400.0).abs() < 1e-3 && !w.closed && w.count == 2, "{w:?}");
|
||
assert!((w.start - 50.0).abs() < 1e-3 && (w.gap - 100.0).abs() < 1e-3 && w.saved == (Some(100.0), 50.0), "{w:?}");
|
||
let (w, n) = flattenings(|| MoveAllWidget::of(&d, &sel, 1.0));
|
||
assert_eq!(n, 1, "Move All");
|
||
let w = w.unwrap();
|
||
assert!(close(w.first, Point::new(50.0, 300.0)) && close(w.at, Point::new(50.0, 326.0)), "{w:?}");
|
||
assert!((w.len - 400.0).abs() < 1e-3 && (w.start - 50.0).abs() < 1e-3 && (w.most - 300.0).abs() < 1e-3, "{w:?}");
|
||
assert!(w.gap.is_none() && w.saved == 50.0 && !w.closed, "{w:?}");
|
||
let (ws, n) = flattenings(|| MemberWidget::all(&d, &sel, 1.0));
|
||
assert_eq!(n, 1, "Select/Move");
|
||
assert_eq!(ws.iter().map(|w| w.index).collect::<Vec<_>>(), [0, 1]);
|
||
assert!(close(ws[0].at, Point::new(50.0, 300.0)) && close(ws[1].at, Point::new(150.0, 300.0)), "{ws:?}");
|
||
// Each hit test, over its widget.
|
||
type Over = fn(&ToolContext, Point) -> bool;
|
||
let hits: [(&str, Over, Point); 4] = [
|
||
("Rotate All", over_rotate_all, Point::new(50.0, 274.0)),
|
||
("Space", over_space, Point::new(176.0, 300.0)),
|
||
("Move All", over_move_all, Point::new(50.0, 326.0)),
|
||
("Select/Move", over_member, Point::new(150.0, 300.0)),
|
||
];
|
||
for (what, over, p) in hits {
|
||
assert_eq!(flattenings(|| over(&c, p)), (true, 1), "{what}");
|
||
}
|
||
assert_eq!(flattenings(|| member_hover(&c, Point::new(150.0, 300.0)).is_some()), (true, 1));
|
||
// A group of one object has no Space widget, and its objects no room to move on an open
|
||
// path: one flattening finds that.
|
||
let (d1, sel1) = single_doc();
|
||
assert_eq!(flattenings(|| SpaceWidget::of(&d1, &sel1, 1.0)), (None, 1));
|
||
let (d2, _, sel2) = group_doc(0.0);
|
||
assert_eq!(flattenings(|| MoveAllWidget::of(&d2, &sel2, 1.0)), (None, 1));
|
||
// Nothing flattens for a selection the widgets do not show for.
|
||
assert_eq!(flattenings(|| Widgets::of(&d, &Selection::default(), 1.0)), (Widgets::default(), 0));
|
||
}
|
||
|
||
/// All four kinds of widget come from one flattening, as each one's own lookup gives it; and the
|
||
/// widget under the pointer, in the order a press takes them, from one flattening too.
|
||
#[test]
|
||
fn the_widgets_of_a_group_share_one_flattening() {
|
||
let (d, _, sel) = spaced_doc(Some(100.0), 50.0);
|
||
let paint = paint();
|
||
let c = cx(&d, &sel, &paint);
|
||
let (all, n) = flattenings(|| Widgets::of(&d, &sel, 1.0));
|
||
assert_eq!(n, 1);
|
||
assert_eq!(all.members, MemberWidget::all(&d, &sel, 1.0));
|
||
assert_eq!(all.rotate_all, RotateAllWidget::of(&d, &sel, 1.0));
|
||
assert_eq!(all.space, SpaceWidget::of(&d, &sel, 1.0));
|
||
assert_eq!(all.move_all, MoveAllWidget::of(&d, &sel, 1.0));
|
||
assert!(all.rotate_all.is_some() && all.space.is_some() && all.move_all.is_some() && all.members.len() == 2);
|
||
let cases = [
|
||
(Point::new(50.0, 274.0), Some(WidgetKind::RotateAll)),
|
||
(Point::new(176.0, 300.0), Some(WidgetKind::Space)),
|
||
(Point::new(50.0, 326.0), Some(WidgetKind::MoveAll)),
|
||
(Point::new(150.0, 300.0), Some(WidgetKind::Member)),
|
||
// On the path between the objects: over none of them, after every one is tested.
|
||
(Point::new(250.0, 300.0), None),
|
||
];
|
||
for (p, kind) in cases {
|
||
assert_eq!(flattenings(|| widget_at(&c, p)), (kind, 1), "{p:?}");
|
||
}
|
||
// A pointer move and the cursor of each tool look once.
|
||
for t in [Box::new(crate::select::SelectionTool::default()) as Box<dyn Tool>, Box::new(ObjectsOnPathTool::default())] {
|
||
for (p, cursor) in [(Point::new(50.0, 274.0), Cursor::Rotate), (Point::new(176.0, 300.0), Cursor::ArrowHollow)] {
|
||
assert_eq!(flattenings(|| t.cursor(&c, p, Mods::default())), (cursor, 1), "{}", t.id());
|
||
}
|
||
}
|
||
let mut t = ObjectsOnPathTool::default();
|
||
assert_eq!(flattenings(|| t.pointer(&c, &ev(PointerKind::Move, 250.0, 300.0))), (vec![], 1));
|
||
}
|
||
|
||
/// A press on each widget measures the path once, and the drag that follows measures it no more
|
||
/// while the path stays as it was.
|
||
#[test]
|
||
fn a_widget_drag_flattens_the_path_once() {
|
||
let (d, g, sel) = spaced_doc(Some(100.0), 50.0);
|
||
let paint = paint();
|
||
let c = cx(&d, &sel, &paint);
|
||
let presses = [
|
||
("Rotate All", Point::new(50.0, 274.0), Point::new(24.0, 300.0)),
|
||
("Space", Point::new(176.0, 300.0), Point::new(226.0, 300.0)),
|
||
("Move All", Point::new(50.0, 326.0), Point::new(100.0, 326.0)),
|
||
("Select/Move", Point::new(150.0, 300.0), Point::new(40.0, 300.0)),
|
||
];
|
||
let tools: [Box<dyn Fn() -> Box<dyn Tool>>; 2] =
|
||
[Box::new(|| Box::new(crate::select::SelectionTool::default())), Box::new(|| Box::new(ObjectsOnPathTool::default()))];
|
||
for new in &tools {
|
||
for (what, at, to) in presses {
|
||
let mut t = new();
|
||
assert_eq!(flattenings(|| t.pointer(&c, &ev(PointerKind::Down, at.x, at.y))), (vec![], 1), "{what} {}", t.id());
|
||
assert!(t.busy(), "{what} {}", t.id());
|
||
let (acts, n) = flattenings(|| t.pointer(&c, &ev(PointerKind::Drag, to.x, to.y)));
|
||
assert_eq!(n, 0, "{what} {}", t.id());
|
||
assert!(matches!(acts.last(), Some(Action::Preview(..))), "{what} {}: {acts:?}", t.id());
|
||
let (acts, n) = flattenings(|| t.pointer(&c, &ev(PointerKind::Drag, to.x + 1.0, to.y)));
|
||
assert_eq!(n, 0, "{what} {}: {acts:?}", t.id());
|
||
}
|
||
}
|
||
// The drags as each one's own press starts it.
|
||
type Hit = fn(&ToolContext, &PointerEvent) -> bool;
|
||
let checks: [(&str, Hit, Point); 4] = [
|
||
("Rotate All", |c, e| RotateAllDrag::hit(c, e).is_some(), Point::new(50.0, 274.0)),
|
||
("Space", |c, e| SpaceDrag::hit(c, e).is_some(), Point::new(176.0, 300.0)),
|
||
("Move All", |c, e| MoveAllDrag::hit(c, e).is_some(), Point::new(50.0, 326.0)),
|
||
("Select/Move", |c, e| MemberDrag::hit(c, e).is_some(), Point::new(150.0, 300.0)),
|
||
];
|
||
for (what, hit, p) in checks {
|
||
assert_eq!(flattenings(|| hit(&c, &ev(PointerKind::Down, p.x, p.y))), (true, 1), "{what}");
|
||
}
|
||
// The Move All drag moves the objects by what the pointer moves along the path: 50 pt.
|
||
let mut d = MoveAllDrag::hit(&c, &ev(PointerKind::Down, 50.0, 326.0)).unwrap();
|
||
let acts = d.drag(&c, Point::new(100.0, 326.0));
|
||
assert!(matches!(acts.last(), Some(Action::Preview(_, p)) if p["ids"] == json!([g.0])), "{acts:?}");
|
||
assert_eq!(moved(&acts), Some((100.0, None)), "{acts:?}");
|
||
}
|
||
|
||
/// A drag whose group's path changes while it goes on measures the new path, once.
|
||
#[test]
|
||
fn a_widget_drag_follows_a_path_that_changed() {
|
||
let (d, g, sel) = spaced_doc(Some(100.0), 50.0);
|
||
let paint = paint();
|
||
let c = cx(&d, &sel, &paint);
|
||
let mut drag = MoveAllDrag::hit(&c, &ev(PointerKind::Down, 50.0, 326.0)).unwrap();
|
||
// The path now runs from (100, 300) to (500, 300): the pointer at (200, 326) is 100 pt along
|
||
// it, 50 pt on from where the press was.
|
||
let mut longer = d.clone();
|
||
let line = longer.node(g).and_then(|n| n.children()).unwrap()[0].id;
|
||
if let Some(NodeKind::Path { path, .. }) = longer.node_mut(line).map(|n| &mut n.kind) {
|
||
*path = shapes::line(Point::new(100.0, 300.0), Point::new(500.0, 300.0));
|
||
}
|
||
let c = cx(&longer, &sel, &paint);
|
||
let (acts, n) = flattenings(|| drag.drag(&c, Point::new(200.0, 326.0)));
|
||
assert_eq!(n, 1);
|
||
assert!(matches!(acts.last(), Some(Action::Preview(_, p)) if p["ids"] == json!([g.0])), "{acts:?}");
|
||
assert_eq!(moved(&acts), Some((100.0, None)), "{acts:?}");
|
||
let (acts, n) = flattenings(|| drag.drag(&c, Point::new(300.0, 326.0)));
|
||
assert_eq!(n, 0);
|
||
assert_eq!(moved(&acts), Some((200.0, None)), "{acts:?}");
|
||
}
|
||
}
|