//! The 9-slice guides of a symbol edited in symbol editing mode: two horizontal and two vertical //! guides over its art //! ([helpx: maintain proportions while scaling symbols](https://helpx.adobe.com/illustrator/desktop/manage-objects/traces-mockups-symbols/maintain-proportions-while-scaling-symbols.html)). //! The canvas draws them, dotted, with any tool. With the Selection tool, the pointer near a guide //! takes the Move cursor, and dragging the guide moves it (`symbol.options`'s //! `nineSliceGuides`), in one undo step. //! //! A guide may be dragged past the art's edges, and the instance still scales by the slices its //! art falls in. //! //! VectorCraft's own rules: a guide stays within 16 times the art's width or height of its edge //! and stops short of the opposite guide; a guide outside the art is drawn and taken along the //! art's height or width beside it; the drag does not snap and its modifiers change nothing; a //! guide within reach takes the press before the art and the bounding box, and of two guides //! within reach the nearer one, else the first of left, top, right and bottom; Escape during the //! drag puts the guide back. use serde_json::json; use vectorcraft_doc::{EditedNineSlice, NineSliceGuide}; use vectorcraft_geom::Point; use crate::{Action, PointerEvent, ToolContext}; /// How near (screen px) the pointer must come to a guide to take it. const HIT_PX: f64 = 4.0; /// The distance from `p` to the segment from `a` to `b`. fn to_segment(p: Point, a: Point, b: Point) -> f64 { let d = b - a; let len2 = d.hypot2(); let t = if len2 > 0.0 { ((p - a).dot(d) / len2).clamp(0.0, 1.0) } else { 0.0 }; p.distance(a + d * t) } /// The edited symbol's guides and the one within reach of `p`, the nearest first. pub fn guide_at(cx: &ToolContext, p: Point) -> Option<(EditedNineSlice, NineSliceGuide)> { if !(p.x.is_finite() && p.y.is_finite()) { return None; } let e = cx.doc.edited_nine_slice()?; let reach = cx.tol(HIT_PX); let near = e .lines() .into_iter() .map(|(g, a, b)| (g, to_segment(p, a, b))) .filter(|(_, d)| *d <= reach) .min_by(|a, b| a.1.total_cmp(&b.1)) .map(|(g, _)| g)?; Some((e, near)) } /// Is `p` over a guide of the edited symbol? pub fn over_guide(cx: &ToolContext, p: Point) -> bool { guide_at(cx, p).is_some() } /// Dragging a 9-slice guide. #[derive(Clone, Debug)] pub struct GuideDrag { frame: EditedNineSlice, guide: NineSliceGuide, start: Point, began: bool, } impl GuideDrag { /// Start a drag when the press `ev` is on a guide of the edited symbol. pub fn hit(cx: &ToolContext, ev: &PointerEvent) -> Option { let (frame, guide) = guide_at(cx, ev.pos)?; Some(Self { frame, guide, start: ev.pos, began: false }) } /// The drag has left the click: the guide is moving. pub fn adjusting(&self) -> bool { self.began } pub fn drag(&mut self, cx: &ToolContext, p: Point) -> Vec { if !(p.x.is_finite() && p.y.is_finite()) || (!self.began && p.distance(self.start) < cx.tol(3.0)) { return vec![]; } let mut out = vec![]; if !self.began { self.began = true; out.push(Action::Begin("Symbol Options".into())); } let guides = self.frame.moved(self.guide, p); out.push(Action::Preview("symbol.options".into(), json!({ "name": self.frame.symbol, "nineSliceGuides": guides.to_value() }))); out } pub fn finish(self) -> Vec { if self.began { vec![Action::Commit] } else { vec![] } } pub fn cancel(self) -> Vec { if self.began { vec![Action::Cancel] } else { vec![] } } } #[cfg(test)] mod tests { use std::sync::Arc; use super::*; use crate::select::SelectionTool; use crate::testutil::*; use crate::{Cursor, Mods, PointerKind, Tool, ToolKey}; use vectorcraft_doc::{Appearance, Document, Node, Selection, Symbol, SymbolEdit, SymbolNineSlice}; use vectorcraft_geom::{Affine, Rect, shapes}; /// A 100 × 100 symbol "S" with 9-slice guides `guides`, edited in symbol editing mode with its /// art, a filled square, at (100, 100) on the editing layer: its guides lie at x and y = 125 /// and 175. fn editing(guides: Option) -> Document { let mut d = Document::new(500.0, 500.0); let square = |d: &mut Document, r: Rect| Node::path(d.alloc_id(), shapes::rectangle(r), Appearance::default_art()); let art = square(&mut d, Rect::new(0.0, 0.0, 100.0, 100.0)); d.symbols.push(Symbol { dynamic: false, name: "S".into(), art: Arc::new(art) }); d.set_symbol_nine_slice("S", guides); let layer = d.add_layer(Some("S")); let copy = square(&mut d, Rect::new(100.0, 100.0, 200.0, 200.0)); d.insert(Some(layer), 0, copy).unwrap(); d.symbol_edit = Some(SymbolEdit { symbol: "S".into(), layer, instance: None, xf: Affine::translate((100.0, 100.0)), group: false, changed: false, back_isolation: None, back_layer: None, }); d } fn ev(kind: PointerKind, x: f64, y: f64) -> PointerEvent { PointerEvent::new(kind, x, y) } fn preview(a: &Action) -> (String, serde_json::Value) { match a { Action::Preview(cmd, v) => (cmd.clone(), v.clone()), other => panic!("{other:?}"), } } /// The pointer within 4 screen px of a guide takes it at any zoom, the nearer of two where /// they cross, and nothing is taken outside symbol editing mode or without guides. #[test] fn a_guide_is_taken_within_a_few_screen_pixels_at_any_zoom() { let d = editing(Some(SymbolNineSlice::default())); let (s, p) = (Selection::default(), paint()); for zoom in [0.25, 1.0, 8.0] { let c = ToolContext { zoom, ..cx(&d, &s, &p) }; let at = |x: f64, y: f64| guide_at(&c, Point::new(x, y)).map(|(_, g)| g); assert_eq!(at(125.0 + 3.5 / zoom, 150.0), Some(NineSliceGuide::Left), "{zoom}"); assert_eq!(at(125.0 + 5.0 / zoom, 150.0), None, "{zoom}"); assert_eq!(at(150.0, 175.0 - 2.0 / zoom), Some(NineSliceGuide::Bottom), "{zoom}"); // Past the art's box the guides end. assert_eq!(at(125.0, 100.0 - 6.0 / zoom), None, "{zoom}"); } let c = cx(&d, &s, &p); assert_eq!(guide_at(&c, Point::new(176.0, 173.0)).map(|(_, g)| g), Some(NineSliceGuide::Right)); assert_eq!(guide_at(&c, Point::new(173.0, 176.0)).map(|(_, g)| g), Some(NineSliceGuide::Bottom)); assert_eq!(guide_at(&c, Point::new(125.0, 125.0)).map(|(_, g)| g), Some(NineSliceGuide::Left), "left before top"); assert!(guide_at(&c, Point::new(f64::NAN, 150.0)).is_none()); let off = editing(None); assert!(!over_guide(&cx(&off, &s, &p), Point::new(125.0, 150.0))); let mut out = editing(Some(SymbolNineSlice::default())); out.symbol_edit = None; assert!(!over_guide(&cx(&out, &s, &p), Point::new(125.0, 150.0))); } /// With the Selection tool, a press on a guide over the art takes the guide, not the art: the /// pointer shows the Move cursor, the drag previews that guide alone, and the release commits /// it as one step. A click without a drag sends nothing. #[test] fn dragging_a_guide_moves_that_guide_in_one_step() { let d = editing(Some(SymbolNineSlice::default())); let (s, p) = (Selection::default(), paint()); let c = cx(&d, &s, &p); let mut t = SelectionTool::default(); assert_eq!(t.cursor(&c, Point::new(126.0, 150.0), Mods::default()), Cursor::Move); assert_ne!(t.cursor(&c, Point::new(150.0, 150.0), Mods::default()), Cursor::Move, "the art between the guides"); assert!(t.pointer(&c, &ev(PointerKind::Down, 126.0, 150.0)).is_empty(), "the art is not selected"); assert!(t.busy()); assert_eq!(t.cursor(&c, Point::new(300.0, 300.0), Mods::default()), Cursor::Move, "kept during the drag"); let a = t.pointer(&c, &ev(PointerKind::Drag, 110.0, 400.0)); assert_eq!(a[0], Action::Begin("Symbol Options".into())); let (cmd, v) = preview(&a[1]); assert_eq!(cmd, "symbol.options"); assert_eq!(v, json!({ "name": "S", "nineSliceGuides": [0.1, 0.25, 0.25, 0.25] })); // Past the opposite guide it stops short of it; modifiers change nothing. let shifted = PointerEvent { mods: Mods { shift: true, alt: true, ..Mods::default() }, ..ev(PointerKind::Drag, 190.0, 150.0) }; let (_, v) = preview(&t.pointer(&c, &shifted)[0]); let left = v["nineSliceGuides"][0].as_f64().unwrap(); assert!((left - (0.75 - vectorcraft_doc::MIN_CENTER_BAND)).abs() < 1e-12, "{v}"); assert_eq!(t.pointer(&c, &ev(PointerKind::Up, 190.0, 150.0)), vec![Action::Commit]); assert!(!t.busy()); // A click on a guide without moving. assert!(t.pointer(&c, &ev(PointerKind::Down, 175.0, 150.0)).is_empty()); assert!(t.pointer(&c, &ev(PointerKind::Drag, 176.0, 150.0)).is_empty()); assert!(t.pointer(&c, &ev(PointerKind::Up, 176.0, 150.0)).is_empty()); // The top guide moves up and down only. t.pointer(&c, &ev(PointerKind::Down, 150.0, 125.0)); let a = t.pointer(&c, &ev(PointerKind::Drag, 10.0, 140.0)); assert_eq!(preview(&a[1]).1["nineSliceGuides"], json!([0.25, 0.4, 0.25, 0.25])); } /// A guide outside the art is taken beside the art, along its height, and a drag may take a /// guide past the art's edge and back; Escape puts it back where it was. #[test] fn a_guide_outside_the_art_is_taken_and_dragged_past_the_arts_edge() { let d = editing(SymbolNineSlice::new(-0.25, 0.25, 0.25, 0.25)); let (s, p) = (Selection::default(), paint()); let c = cx(&d, &s, &p); let at = |x: f64, y: f64| guide_at(&c, Point::new(x, y)).map(|(_, g)| g); assert_eq!(at(75.0, 150.0), Some(NineSliceGuide::Left), "25 % left of the art at x = 100"); assert_eq!(at(77.0, 110.0), Some(NineSliceGuide::Left)); assert_eq!(at(75.0, 95.0), None, "the guide ends with the art's height"); let mut t = SelectionTool::default(); assert_eq!(t.cursor(&c, Point::new(75.0, 150.0), Mods::default()), Cursor::Move); t.pointer(&c, &ev(PointerKind::Down, 75.0, 150.0)); let a = t.pointer(&c, &ev(PointerKind::Drag, 50.0, 150.0)); assert_eq!(a[0], Action::Begin("Symbol Options".into())); assert_eq!(preview(&a[1]).1["nineSliceGuides"], json!([-0.5, 0.25, 0.25, 0.25])); let (_, v) = preview(&t.pointer(&c, &ev(PointerKind::Drag, 110.0, 150.0))[0]); assert_eq!(v["nineSliceGuides"], json!([0.1, 0.25, 0.25, 0.25]), "back inside the art"); assert_eq!(t.key(&c, ToolKey::Escape, Mods::default()), vec![Action::Cancel]); // From inside the art, the default bottom guide passes the art's bottom edge at y = 200. let d = editing(Some(SymbolNineSlice::default())); let c = cx(&d, &s, &p); let mut t = SelectionTool::default(); t.pointer(&c, &ev(PointerKind::Down, 150.0, 175.0)); let a = t.pointer(&c, &ev(PointerKind::Drag, 150.0, 250.0)); assert_eq!(preview(&a[1]).1["nineSliceGuides"], json!([0.25, 0.25, 0.25, -0.5])); assert_eq!(t.pointer(&c, &ev(PointerKind::Up, 150.0, 250.0)), vec![Action::Commit]); } /// Escape during a guide drag cancels it and is the tool's; the release after it commits /// nothing. A double-click on a guide neither edits the art nor leaves the mode. #[test] fn escape_cancels_a_guide_drag_and_a_double_click_stays_on_the_guide() { let d = editing(Some(SymbolNineSlice::default())); let (s, p) = (Selection::default(), paint()); let c = ToolContext { isolation: d.symbol_edit.as_ref().map(|e| e.layer), ..cx(&d, &s, &p) }; let mut t = SelectionTool::default(); t.pointer(&c, &ev(PointerKind::Down, 175.0, 150.0)); assert_eq!(t.pointer(&c, &ev(PointerKind::Drag, 160.0, 150.0))[0], Action::Begin("Symbol Options".into())); assert!(t.claims_key(&c, ToolKey::Escape)); assert_eq!(t.key(&c, ToolKey::Escape, Mods::default()), vec![Action::Cancel]); assert!(!t.busy() && !t.claims_key(&c, ToolKey::Escape)); assert!(t.pointer(&c, &ev(PointerKind::Up, 160.0, 150.0)).is_empty()); // Escape after a click that did not move cancels nothing. t.pointer(&c, &ev(PointerKind::Down, 175.0, 150.0)); assert!(t.key(&c, ToolKey::Escape, Mods::default()).is_empty()); for k in [PointerKind::Down, PointerKind::Up, PointerKind::Down, PointerKind::Up, PointerKind::DoubleClick] { assert!(t.pointer(&c, &ev(k, 175.0, 150.0)).is_empty(), "{k:?}"); } // Away from the guides a double-click outside the art still leaves isolation. assert_eq!(t.pointer(&c, &ev(PointerKind::DoubleClick, 400.0, 400.0)), vec![Action::Exec("object.exitIsolation".into(), json!({}))]); } }