Files
vectorcraft/crates/tools/src/trace_split.rs
T
dotCooCoo 61cc30e9b8 Image Trace: a shown center point keeps its drag over the divider
With Show Center on, a press on a selected Image Trace object's center
point where the Split view's divider crosses it moved the divider
instead of the object. The divider now leaves a press on a shown center
point to the Selection tool, as it already did for the bounding-box
handles.
2026-11-18 16:40:27 -08:00

285 lines
13 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! The divider of an Image Trace object in the Split view: the source image shows on its left
//! (in the image's own pixels) and the tracing result on its right. Drawing and hit testing share
//! the document-space geometry here; a drag previews `imageTrace.setView` and commits it as one
//! undo step.
use serde_json::json;
use vectorcraft_doc::{Document, NodeId, NodeKind, Selection, TraceView};
use vectorcraft_geom::{Affine, Point};
use crate::{Action, Cursor, Mods, ToolContext};
/// How near (screen points) the pointer must come to the divider to take it.
pub const HIT_PX: f64 = 5.0;
/// The divider's half length past each end of its grip, in screen points.
pub const GRIP_HALF: f32 = 10.0;
/// The Split view's divider of one selected Image Trace object, in document space.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct TraceDivider {
/// The Image Trace object.
pub id: NodeId,
/// The fraction of the source image's width, from its left edge, that shows the image.
pub split: f64,
/// Where the divider meets the image's top and bottom edges.
pub ends: [Point; 2],
/// The source image's pixel-to-document transform.
xf: Affine,
width: f64,
}
impl TraceDivider {
/// The divider of the one Image Trace object selected whole, when it shows the Split view.
pub fn of(doc: &Document, selection: &Selection, zoom: f64) -> Option<Self> {
let [id] = selection.objects.as_slice() else { return None };
if !selection.anchors.is_empty() || !selection.segments.is_empty() || !doc.is_editable(*id) || !zoom.is_finite() || zoom <= 0.0 {
return None;
}
let n = doc.node(*id)?;
if n.extras().trace.is_none() || n.trace_view() != TraceView::Split {
return None;
}
let NodeKind::Group { children, clip: false } = &n.kind else { return None };
let NodeKind::Image(im) = &children.first()?.kind else { return None };
let (width, height) = (f64::from(im.width), f64::from(im.height));
let det = im.xf.determinant();
if width <= 0.0 || height <= 0.0 || !det.is_finite() || det.abs() < 1e-12 || !im.xf.as_coeffs().iter().all(|c| c.is_finite()) {
return None;
}
let split = n.trace_split();
let at = width * split;
let ends = [im.xf * Point::new(at, 0.0), im.xf * Point::new(at, height)];
ends.iter().all(|p| finite(*p)).then_some(Self { id: *id, split, ends, xf: im.xf, width })
}
/// The divider position for document point `p`: the fraction of the image's width left of
/// it, from 0 to 1, rounded to a ten-thousandth.
pub fn split_at(&self, p: Point) -> Option<f64> {
let local = self.xf.inverse() * p;
let f = (local.x / self.width).clamp(0.0, 1.0);
f.is_finite().then(|| (f * 10_000.0).round() / 10_000.0)
}
/// How far the image's left-to-right direction is turned (counter-clockwise degrees on the
/// page), for the resize cursor.
fn angle(&self) -> f64 {
let across = self.xf * Point::new(1.0, 0.0) - self.xf * Point::ZERO;
(-across.y).atan2(across.x).to_degrees()
}
/// The divider under document point `p`. Nothing with the bounding box hidden or in Outline
/// mode, where the canvas draws neither the divider nor the split.
fn hit(cx: &ToolContext, p: Point) -> Option<Self> {
if !cx.show_bbox || cx.outline || !finite(p) {
return None;
}
let d = Self::of(cx.doc, cx.selection, cx.zoom)?;
let [a, b] = d.ends;
let v = b - a;
let length = v.hypot();
if !length.is_finite() || length <= 0.0 {
return None;
}
let unit = v / length;
let along = (p - a).dot(unit).clamp(0.0, length);
// A bounding-box handle or a shown center point under the pointer keeps its own drag.
((a + unit * along).distance(p) <= cx.tol(HIT_PX)
&& !crate::select::bbox_handle_at(cx, p)
&& crate::select::hit_center(cx, p, cx.point_tol()).is_none())
.then_some(d)
}
}
fn finite(p: Point) -> bool {
p.x.is_finite() && p.y.is_finite()
}
fn resize_cursor(d: &TraceDivider, cx: &ToolContext) -> Cursor {
crate::select::handle_cursor(crate::bbox::Handle::Right, d.angle() - cx.view_angle())
}
/// The resize cursor over the divider at `p`, turned with the image and the view.
pub fn cursor(cx: &ToolContext, p: Point) -> Option<Cursor> {
TraceDivider::hit(cx, p).map(|d| resize_cursor(&d, cx))
}
/// A drag of the divider: it previews `imageTrace.setView` while the pointer moves and commits
/// it as one undo step.
#[derive(Clone, Debug)]
pub struct SplitDrag {
divider: TraceDivider,
start: Point,
began: bool,
}
impl SplitDrag {
pub fn hit(cx: &ToolContext, p: Point, mods: Mods) -> Option<Self> {
if mods.cmd || mods.ctrl || mods.alt {
return None;
}
let divider = TraceDivider::hit(cx, p)?;
Some(Self { divider, start: p, began: false })
}
pub fn adjusting(&self) -> bool {
self.began
}
pub fn cursor(&self, cx: &ToolContext) -> Cursor {
resize_cursor(&self.divider, cx)
}
pub fn drag(&mut self, cx: &ToolContext, p: Point) -> Vec<Action> {
if !finite(p) || (!self.began && p.distance(self.start) < cx.tol(3.0)) {
return vec![];
}
let Some(split) = self.divider.split_at(p) else { return vec![] };
let mut out = vec![];
if !self.began {
self.began = true;
out.push(Action::Begin("Image Trace View".into()));
}
out.push(Action::Preview("imageTrace.setView".into(), json!({"id": self.divider.id.0, "view": TraceView::Split.id(), "split": split})));
out
}
pub fn finish(self) -> Vec<Action> {
if self.began { vec![Action::Commit] } else { vec![] }
}
pub fn cancel(self) -> Vec<Action> {
if self.began { vec![Action::Cancel] } else { vec![] }
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::testutil::{cx, paint};
use std::sync::Arc;
use vectorcraft_doc::{ImageObject, Node};
/// A document with an Image Trace object over a 100 × 50 image placed by `xf`, in `view`.
fn traced(xf: Affine, view: &str, split: f64) -> (Document, NodeId) {
let mut doc = Document::new(400.0, 400.0);
let im = ImageObject { key: "k".into(), width: 100, height: 50, xf, link: None, placement: Default::default(), pixels: None };
let mut source = Node::new(doc.alloc_id(), NodeKind::Image(Box::new(im)));
source.visible = false;
let mut g = Node::group(doc.alloc_id(), vec![Arc::new(source)]);
g.extras_mut().trace = Some(Box::new(json!({"view": view, "split": split})));
let id = g.id;
let layer = doc.layers[0].id;
doc.insert(Some(layer), 0, g).unwrap();
(doc, id)
}
#[test]
fn the_divider_shows_only_for_one_selected_split_view_and_follows_the_image() {
let paint = paint();
let mut selection = Selection::default();
let (doc, id) = traced(Affine::translate((10.0, 20.0)), "split", 0.25);
assert!(TraceDivider::of(&doc, &selection, 1.0).is_none(), "nothing selected");
selection.set([id]);
let d = TraceDivider::of(&doc, &selection, 1.0).unwrap();
assert_eq!((d.split, d.ends), (0.25, [Point::new(35.0, 20.0), Point::new(35.0, 70.0)]));
for zoom in [0.0, -1.0, f64::NAN] {
assert!(TraceDivider::of(&doc, &selection, zoom).is_none());
}
let (other, id) = traced(Affine::IDENTITY, "sourceImage", 0.25);
selection.set([id]);
assert!(TraceDivider::of(&other, &selection, 1.0).is_none(), "another view");
// A turned and scaled image: the divider runs along the image's own height.
let xf = Affine::translate((200.0, 100.0)) * Affine::rotate(std::f64::consts::FRAC_PI_2) * Affine::scale(2.0);
let (doc, id) = traced(xf, "split", 0.5);
selection.set([id]);
let d = TraceDivider::of(&doc, &selection, 1.0).unwrap();
assert!(d.ends[0].distance(Point::new(200.0, 200.0)) < 1e-9 && d.ends[1].distance(Point::new(100.0, 200.0)) < 1e-9, "{:?}", d.ends);
assert_eq!(d.split_at(Point::new(150.0, 150.0)), Some(0.25));
assert_eq!(d.split_at(Point::new(150.0, 900.0)), Some(1.0), "clamped");
let c = cx(&doc, &selection, &paint);
assert_eq!(cursor(&c, Point::new(150.0, 200.0)), Some(Cursor::ResizeV));
assert_eq!(cursor(&c, Point::new(150.0, 210.0)), None, "past the hit distance");
let mut c = cx(&doc, &selection, &paint);
c.show_bbox = false;
assert_eq!(cursor(&c, Point::new(150.0, 200.0)), None, "bounding box hidden");
assert!(SplitDrag::hit(&c, Point::new(150.0, 200.0), Mods::default()).is_none(), "bounding box hidden");
let mut c = cx(&doc, &selection, &paint);
c.outline = true;
assert!(SplitDrag::hit(&c, Point::new(150.0, 200.0), Mods::default()).is_none(), "Outline mode");
}
#[test]
fn dragging_the_divider_previews_the_view_and_commits_once() {
let paint = paint();
let mut selection = Selection::default();
let (doc, id) = traced(Affine::translate((10.0, 20.0)), "split", 0.5);
selection.set([id]);
for zoom in [0.5, 1.0, 4.0] {
let mut c = cx(&doc, &selection, &paint);
c.zoom = zoom;
let on = Point::new(60.0 + 4.0 / zoom, 40.0);
assert_eq!(cursor(&c, on), Some(Cursor::ResizeH), "zoom {zoom}");
assert!(SplitDrag::hit(&c, Point::new(60.0 + 6.0 / zoom, 40.0), Mods::default()).is_none(), "zoom {zoom}");
assert!(SplitDrag::hit(&c, on, Mods { alt: true, ..Default::default() }).is_none());
let mut drag = SplitDrag::hit(&c, on, Mods::default()).unwrap();
assert!(drag.drag(&c, on + vectorcraft_geom::Vec2::new(1.0 / zoom, 0.0)).is_empty(), "under the drag threshold");
assert!(drag.drag(&c, Point::new(f64::NAN, 0.0)).is_empty());
let out = drag.drag(&c, Point::new(85.0, 300.0));
assert!(
matches!(&out[..], [Action::Begin(_), Action::Preview(id, p)]
if id == "imageTrace.setView" && p["split"] == json!(0.75) && p["view"] == "split"),
"{out:?}"
);
let out = drag.drag(&c, Point::new(-50.0, 30.0));
assert!(matches!(&out[..], [Action::Preview(_, p)] if p["split"] == json!(0.0)), "{out:?}");
assert!(drag.adjusting());
assert!(matches!(drag.clone().finish()[..], [Action::Commit]));
assert!(matches!(drag.cancel()[..], [Action::Cancel]));
}
}
/// With Show Center on, a press on the center point where the divider crosses it moves the
/// object; the rest of the divider still takes a press.
#[test]
fn the_center_point_keeps_its_drag_on_the_divider() {
use vectorcraft_doc::{Appearance, LiveShape};
let paint = paint();
let mut selection = Selection::default();
let (mut doc, id) = traced(Affine::translate((10.0, 20.0)), "split", 0.5);
let xf = Affine::translate((10.0, 20.0));
let shape = LiveShape::Rectangle { w: 100.0, h: 50.0, radii: [0.0; 4], kinds: Default::default(), radii_relative: false, xf };
let path = Node::path(doc.alloc_id(), shape.to_path(), Appearance::default_art());
doc.insert(Some(id), 1, path).unwrap();
doc.node_mut(id).unwrap().edit_attrs(|a| a.show_center = Some(true));
selection.set([id]);
let c = cx(&doc, &selection, &paint);
assert_eq!(crate::select::hit_center(&c, Point::new(60.0, 45.0), c.point_tol()).map(|(i, _)| i), Some(id));
assert_eq!(cursor(&c, Point::new(60.0, 45.0)), None, "the center point");
assert!(SplitDrag::hit(&c, Point::new(60.0, 45.0), Mods::default()).is_none(), "the center point");
assert_eq!(cursor(&c, Point::new(60.0, 33.0)), Some(Cursor::ResizeH));
}
/// Switching away from the Selection tool during a divider drag cancels it, as Escape does:
/// the view goes back. After a press that has not moved there is nothing to put back.
#[test]
fn a_tool_switch_cancels_a_divider_drag() {
use crate::{PointerEvent, PointerKind, Tool};
let paint = paint();
let mut selection = Selection::default();
let (doc, id) = traced(Affine::translate((10.0, 20.0)), "split", 0.5);
selection.set([id]);
let c = cx(&doc, &selection, &paint);
let mut t = crate::select::SelectionTool::default();
assert!(t.pointer(&c, &PointerEvent::new(PointerKind::Down, 60.0, 40.0)).is_empty());
let a = t.pointer(&c, &PointerEvent::new(PointerKind::Drag, 85.0, 40.0));
assert!(matches!(a.first(), Some(Action::Begin(_))), "{a:?}");
assert_eq!(t.deactivate(&c), vec![Action::Cancel]);
assert!(!t.busy() && !t.transforming());
assert!(t.pointer(&c, &PointerEvent::new(PointerKind::Up, 85.0, 40.0)).is_empty());
t.pointer(&c, &PointerEvent::new(PointerKind::Down, 60.0, 40.0));
assert!(t.busy());
assert!(t.deactivate(&c).is_empty());
assert!(!t.busy());
}
}