From b4e45fa93c38aad7403e7cccaefc981b1d2e4c8e Mon Sep 17 00:00:00 2001 From: dotCooCoo Date: Sun, 15 Nov 2026 22:51:59 -0800 Subject: [PATCH] Direct Selection: a marquee picks the points of a selected blend's spine A Direct Selection marquee now picks the spine points inside it on the topmost selected blend, and the picked points drag together as Shift-clicked ones do. With Shift the marquee adds points or takes picked ones away, and the blend stays selected. A plain marquee around none of them drops the picks, and Escape during the marquee keeps them. Unselected, locked and hidden blends are skipped. --- crates/tools/src/direct.rs | 43 +++++++++- crates/tools/src/direct/tests.rs | 131 +++++++++++++++++++++++++++++++ docs/target-app-parity.md | 1 + docs/ui-parity.md | 2 +- 4 files changed, 172 insertions(+), 5 deletions(-) diff --git a/crates/tools/src/direct.rs b/crates/tools/src/direct.rs index 5a5c951548..4c93660ace 100644 --- a/crates/tools/src/direct.rs +++ b/crates/tools/src/direct.rs @@ -25,8 +25,9 @@ //! Both pick the key objects of a blend, and click or drag ruler guides ([`crate::rulerguide`]). //! A Cmd/Ctrl+Shift double-click with either one releases the ruler guide or guide path under the //! pointer ([`release_guide_at`]). -//! Direct Selection also edits a blend's spine: drag its points (Shift-click picks several, which -//! drag together; a key object on a point moves with it) and, once a point is clicked, its +//! Direct Selection also edits a blend's spine: drag its points (Shift-click and, on a selected +//! blend, the marquee pick several, which drag together; a key object on a point moves with it) +//! and, once a point is clicked, its //! handles; and the points of selected gradient meshes //! and of mesh and warp envelopes and their handles ([`MeshEdit`]): Shift-clicks and the marquee pick several, //! a click on a gradient mesh's line picks its two ends and one inside a patch the four points @@ -192,7 +193,8 @@ pub struct DirectSelectionTool { moved: Option, /// The spine point last clicked (blend, anchor): its handles show and can be dragged. spine: Option<(NodeId, usize)>, - /// Other points of that spine picked with it (Shift-click adds or takes one away); dragging + /// Other points of that spine picked with it (Shift-click adds or takes one away, and a + /// marquee picks those inside it); dragging /// a picked point moves them all (#5285). spine_more: Vec, mesh: MeshEdit, @@ -915,6 +917,10 @@ impl Tool for DirectSelectionTool { if let Some(out) = self.press_hidden(cx, ev, p) { return out; } + // The spine points picked before stay picked while the marquee is drawn: its + // release replaces them (with Shift, toggles them), and Escape keeps them. + self.spine = held; + self.spine_more = if held.is_some() { more } else { vec![] }; self.state = State::Marquee { start: p, cur: p, toggle: ev.mods.shift, enclosed: false, whole: ev.mods.alt }; vec![] } @@ -1641,12 +1647,14 @@ impl DirectSelectionTool { return vec![]; } self.frame.clear(); + (self.spine, self.spine_more) = (None, vec![]); return vec![Action::Exec("select.none".into(), json!({}))]; } // With Group Selection's enclosed marquee, the tool selects the objects inside it // (members of groups too), each whole, as a click selects one; with an Alt-marquee, every // object it touches, each whole. if enclosed || whole { + (self.spine, self.spine_more) = (None, vec![]); let mut touched = vectorcraft_doc::hit::marquee_in_view(cx.doc, r, cx.isolation, true, cx.outline); let editable = cx.doc.editable(); touched.retain(|id| editable(*id)); @@ -1702,6 +1710,33 @@ impl DirectSelectionTool { } } } + // Direct Selection: the points of a selected blend's spine inside the rect are picked, on + // the topmost such blend; with Shift they are toggled. The blend stays selected. A plain + // marquee that holds none of them drops the points picked before. + let mut spined: Option = None; + if !self.group { + let found = spines(cx).into_iter().filter(|(id, _)| cx.selection.contains(*id)).find_map(|(id, path)| { + let inside: BTreeSet = path.anchors().filter(|(s, _, a)| *s == 0 && r.contains(a.p)).map(|(_, i, _)| i).collect(); + (!inside.is_empty()).then_some((id, inside)) + }); + match found { + Some((id, inside)) => { + let held = self.spine.filter(|(h, _)| toggle && *h == id); + let before: BTreeSet = held.map(|(_, a)| self.spine_more.iter().copied().chain([a]).collect()).unwrap_or_default(); + let picked: BTreeSet = if toggle { before.symmetric_difference(&inside).copied().collect() } else { inside }; + let focus = held.map(|(_, a)| a).filter(|a| picked.contains(a)).or_else(|| picked.last().copied()); + self.spine = focus.map(|a| (id, a)); + self.spine_more = picked.into_iter().filter(|a| Some(*a) != focus).collect(); + spined = Some(id); + if !toggle { + sel.push((id, vec![])); + } + } + None if !toggle => (self.spine, self.spine_more) = (None, vec![]), + // With Shift, the blend holding the picked points stays selected with them. + None => spined = self.spine.map(|(id, _)| id), + } + } let mut marked: BTreeMap> = if toggle { self.frame_anchors(cx).into_iter().map(|(id, v)| (id, v.into_iter().collect())).collect() } else { BTreeMap::new() }; for (id, inside) in &framed { @@ -1721,7 +1756,7 @@ impl DirectSelectionTool { // the marquee touches them, as with the Selection tool (#927). for id in vectorcraft_doc::hit::marquee_in_view(cx.doc, r, cx.isolation, true, cx.outline) { let whole = cx.doc.node(id).is_some_and(|n| !matches!(n.kind, NodeKind::Path { .. } | NodeKind::Compound { .. })); - if whole && !sel.iter().any(|(s, _)| *s == id) && !framed.iter().any(|(f, _)| *f == id) && !meshed.contains(&id) { + if whole && !sel.iter().any(|(s, _)| *s == id) && !framed.iter().any(|(f, _)| *f == id) && !meshed.contains(&id) && spined != Some(id) { sel.push((id, vec![])); } } diff --git a/crates/tools/src/direct/tests.rs b/crates/tools/src/direct/tests.rs index 1a7cb68a55..0c2aabb768 100644 --- a/crates/tools/src/direct/tests.rs +++ b/crates/tools/src/direct/tests.rs @@ -246,6 +246,137 @@ fn shift_click_picks_several_spine_points_which_drag_together() { assert!(matches!(a.last(), Some(Action::Preview(_, v)) if v["anchor"] == 0 && v.get("with").is_none()), "{a:?}"); } +/// [`blend_doc`] with a spine through (110, 310), (160, 310) and (210, 310). +fn blend_doc_with_three_spine_points() -> (vectorcraft_doc::Document, NodeId) { + let (mut d, g, _) = blend_doc(); + let sp = vectorcraft_geom::SubPath::polyline(&[Point::new(110.0, 310.0), Point::new(160.0, 310.0), Point::new(210.0, 310.0)], false); + let Some(NodeKind::Blend { spec, .. }) = d.node_mut(g).map(|n| &mut n.kind) else { panic!("blend") }; + (spec.spine, spec.key_anchors) = (Some(PathData::single(sp)), vec![0, 2]); + (d, g) +} + +/// A marquee drawn with Direct Selection from `from` to `to`, released. +fn spine_marquee(t: &mut DirectSelectionTool, cx: &ToolContext, from: (f64, f64), to: (f64, f64), mods: Mods) -> Vec { + assert_eq!(t.pointer(cx, &PointerEvent::new(PointerKind::Down, from.0, from.1).with_mods(mods)), vec![]); + t.pointer(cx, &PointerEvent::new(PointerKind::Drag, to.0, to.1).with_mods(mods)); + assert!(t.overlays(cx).iter().any(|o| matches!(o, Overlay::Marquee(_))), "a marquee"); + t.pointer(cx, &PointerEvent::new(PointerKind::Up, to.0, to.1).with_mods(mods)) +} + +/// A Direct Selection marquee picks the points of a selected blend's spine inside it, which then +/// drag together, and keeps the blend selected; a marquee around none of them drops the picks. +#[test] +fn marquee_picks_selected_blend_spine_points_which_drag_together() { + let (d, g) = blend_doc_with_three_spine_points(); + let mut s = Selection::default(); + s.set([g]); + let p = paint(); + let cx = cx(&d, &s, &p); + let filled = |t: &DirectSelectionTool| t.overlays(&cx).iter().filter(|o| matches!(o, Overlay::Anchor { filled: true, .. })).count(); + let mut t = DirectSelectionTool::new(false); + // Around (160, 310) and (210, 310), the second on the rect's edge. + let a = spine_marquee(&mut t, &cx, (230.0, 330.0), (160.0, 290.0), Mods::default()); + assert!( + matches!(a.first(), Some(Action::Exec(c, v)) if c == "select.anchorsMany" && v["mode"] == "set" && v["items"].as_array().is_some_and(|i| i.iter().any(|i| i["id"] == g.0))), + "the blend stays selected: {a:?}" + ); + assert_eq!(filled(&t), 2, "both picked points show"); + t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 210.0, 310.0)); + let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 210.0, 330.0)); + assert_eq!( + a.last(), + Some(&Action::Preview("object.blend.spine.moveAnchor".into(), json!({"id": g.0, "anchor": 2, "x": 210.0, "y": 330.0, "with": [1]}))) + ); + assert_eq!(t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 210.0, 330.0)), vec![Action::Commit]); + // A marquee around none of the points drops them. + spine_marquee(&mut t, &cx, (300.0, 330.0), (240.0, 290.0), Mods::default()); + assert_eq!((t.spine, filled(&t)), (None, 0)); +} + +/// With Shift, a Direct Selection marquee toggles the spine points inside it: a picked one leaves, +/// another joins, and those outside it keep their state; the blend is not toggled away. +#[test] +fn shift_marquee_toggles_selected_blend_spine_points() { + let (d, g) = blend_doc_with_three_spine_points(); + let mut s = Selection::default(); + s.set([g]); + let p = paint(); + let cx = cx(&d, &s, &p); + let shift = Mods { shift: true, ..Mods::default() }; + let mut t = DirectSelectionTool::new(false); + t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 160.0, 310.0)); + t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 160.0, 310.0)); + let a = spine_marquee(&mut t, &cx, (230.0, 330.0), (150.0, 290.0), shift); + assert!( + matches!(a.first(), Some(Action::Exec(c, v)) if c == "select.anchorsMany" && v["items"].as_array().is_some_and(|i| !i.iter().any(|i| i["id"] == g.0))), + "the blend is not toggled: {a:?}" + ); + assert_eq!((t.spine, t.spine_more.clone()), (Some((g, 2)), vec![])); + spine_marquee(&mut t, &cx, (130.0, 330.0), (90.0, 290.0), shift); + assert_eq!((t.spine, t.spine_more.clone()), (Some((g, 2)), vec![0])); + // A Shift-marquee around none of them keeps them, and keeps the blend selected when it + // touches the blend's art. + spine_marquee(&mut t, &cx, (300.0, 330.0), (240.0, 290.0), shift); + assert_eq!((t.spine, t.spine_more.clone()), (Some((g, 2)), vec![0])); + let a = spine_marquee(&mut t, &cx, (230.0, 330.0), (205.0, 315.0), shift); + assert!( + matches!(a.first(), Some(Action::Exec(c, v)) if c == "select.anchorsMany" && v["items"].as_array().is_some_and(|i| !i.iter().any(|i| i["id"] == g.0))), + "the blend is not toggled: {a:?}" + ); + assert_eq!((t.spine, t.spine_more.clone()), (Some((g, 2)), vec![0])); +} + +/// A Direct Selection marquee does not pick the spine points of a blend that is not selected, or +/// of a selected blend that is locked or hidden. +#[test] +fn marquee_skips_unselected_locked_and_hidden_blend_spines() { + let (d, g) = blend_doc_with_three_spine_points(); + let p = paint(); + let mut s = Selection::default(); + let none = cx(&d, &s, &p); + let mut t = DirectSelectionTool::new(false); + spine_marquee(&mut t, &none, (230.0, 330.0), (150.0, 290.0), Mods::default()); + assert_eq!(t.spine, None, "not selected"); + s.set([g]); + for lock in [true, false] { + let mut d = d.clone(); + let Some(n) = d.node_mut(g) else { panic!("blend") }; + if lock { + n.locked = true; + } else { + n.visible = false; + } + let c = cx(&d, &s, &p); + let mut t = DirectSelectionTool::new(false); + spine_marquee(&mut t, &c, (230.0, 330.0), (150.0, 290.0), Mods::default()); + assert_eq!(t.spine, None, "locked: {lock}"); + } + // The same marquee on the selected blend picks them. + let c = cx(&d, &s, &p); + let mut t = DirectSelectionTool::new(false); + spine_marquee(&mut t, &c, (230.0, 330.0), (150.0, 290.0), Mods::default()); + assert_eq!((t.spine, t.spine_more.clone()), (Some((g, 2)), vec![1])); +} + +/// Escape during a Direct Selection marquee cancels it and keeps the spine points picked before. +#[test] +fn escape_cancels_a_marquee_and_keeps_the_picked_spine_points() { + let (d, g) = blend_doc_with_three_spine_points(); + let mut s = Selection::default(); + s.set([g]); + let p = paint(); + let cx = cx(&d, &s, &p); + let mut t = DirectSelectionTool::new(false); + t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 160.0, 310.0)); + t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 160.0, 310.0)); + t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 300.0, 330.0)); + t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 90.0, 290.0)); + assert_eq!(t.key(&cx, ToolKey::Escape, Mods::default()), vec![Action::Cancel]); + assert_eq!(t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 90.0, 290.0)), vec![]); + assert_eq!((t.spine, t.spine_more.clone()), (Some((g, 1)), vec![])); + assert!(t.overlays(&cx).iter().any(|o| matches!(o, Overlay::Anchor { filled: true, .. })), "the picked point shows"); +} + /// #1111: the Anchor Point tool bends a selected blend's straight spine; Direct Selection /// reshapes a curved spine segment and leaves a straight one alone, as it does a path's. #[test] diff --git a/docs/target-app-parity.md b/docs/target-app-parity.md index 0782bacab9..a257d8c187 100644 --- a/docs/target-app-parity.md +++ b/docs/target-app-parity.md @@ -1239,6 +1239,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur - **Live Corners:** drag a live rectangle's corner widgets (Selection or Direct Selection) to round all corners, with a radius readout; with Direct Selection, select corner anchors to show and round just those corners (#381). Each corner keeps its own radius and kind (Round, Inverted Round, Chamfer): Alt-click a widget to cycle the kind, double-click it for the Corners dialog, and the Properties and Transform radius fields set the selected corners (`object.setLiveShape {corners, radius, kind}`). A link toggle behind Corner Radius (the `singleCornerRadius` preference) switches the panels to a field for each corner of a live rectangle: Top Left, Top Right, Bottom Right and Bottom Left. Corners stay circular when the rectangle is scaled unevenly or along its own sides when rotated (the radius keeps its size, or scales by the mean scale with Scale Corners on); only a shear distorts them. On a rectangle that isn't square every corner is the same circle: a radius past half the shorter side stops there for all of them, the widgets sit on the corners as drawn and turn the edited corners red at that limit, CSS export writes the drawn radii, and rectangles saved stretched by older versions get circular corners when their corners are next set (#442). Live Corners work on any path's corners too, as on a rectangle's (#511): a star's, a live polygon's (which also shows them to the Selection tool, has a Corner Radius field in the Properties and Transform panels and keeps its radius as its sides change) and a pen path's, wherever two sides meet at an angle at an anchor that isn't smooth: curved sides too, trimmed to what the cut leaves of them (#1144). Direct Selection shows the widgets of every corner, or of the corners holding selected anchors; each corner is a circle tangent to both sides, drawn no larger than takes its cut halfway along its shorter side; a path keeps its uncut outline so its corners stay editable, and the same command, dialog, angle preference and View › Hide Corner Widget apply. With Direct Selection a click on a widget (no drag) selects its corner, as a click on the corner's anchor does, so the next drag on it rounds that corner alone; Shift-click toggles it (#1239). While a corner widget is dragged with the Selection tool the bounding box hides, so the rounding shows against the path alone (#1229). A round corner next to a curved side curves smoothly instead of sticking out of the shape (#1547, fixes #1512). View › Hide Edges hides the Live Corners widgets, the bounding box and the type widget, and the selection tools then do not answer a press on them or change the cursor over them. - **Blend spine Anchor Point tool (#2544):** on a selected blend, dragging a spine corner makes symmetric Smooth handles; the tool displays and picks existing spine handles when switched to, drags one independently or retracts it on click, and clicking a point with handles retracts both. The spine is edited live without moving its key objects. Windows native canvas checks and screenshots reviewed: symmetric and independent handles, corner/retraction, Shift constraints and perpendicular reshaping, tool switching, key preservation, Undo/Redo, save/reopen, hidden handles and overlapping Path/Blend priority (PR #2643). Behaviour reference: [public path-editing documentation](https://helpx.adobe.com/illustrator/using/adjust-path-segments.html). + - **Blend spine points by marquee:** with Direct Selection, a marquee picks the spine points inside it on a selected blend, the topmost one when several are selected, and the picked points drag together as Shift-clicked ones do; Shift-marquee adds points or takes picked ones away, a plain marquee around none of them drops the picks, and Escape during the marquee keeps them. Unselected, locked and hidden blends are skipped. The spine's points are anchor points edited with Direct Selection ([the help page](https://helpx.adobe.com/illustrator/desktop/manage-colors/apply-transparency-and-blending/modify-spine-of-blended-objects.html)), and a boundary drag with the tool selects anchor points ([the help page](https://helpx.adobe.com/illustrator/desktop/draw-shapes-and-paths/modify-paths/select-anchor-points-in-paths.html)); the rules for selected, topmost and Shift are VectorCraft's own (`crates/tools/src/direct/tests.rs`, `marquee_picks_selected_blend_spine_points_which_drag_together`, `shift_marquee_toggles_selected_blend_spine_points`, `marquee_skips_unselected_locked_and_hidden_blend_spines`, `escape_cancels_a_marquee_and_keeps_the_picked_spine_points`). - **Blend steps of brushed strokes:** the steps interpolate the pen pressure, tilt, bearing and rotation recorded with the Paintbrush, so a Calligraphic, Scatter or Art brush that varies with the pen changes gradually from one key to the next. A key without a recording counts as half pressure, half tilt and 0°, as brushes read it, and angles turn the shorter way round. When the blend starts a key's path at another anchor (an open path run from its end, a closed one turned to another start), the key's recordings, width profile, arrowheads, dashes and a gradient along or across the stroke turn with the path. Different brushes still switch halfway (VectorCraft's own rule; strokes blend their options, as [Blended objects overview](https://helpx.adobe.com/illustrator/desktop/manage-colors/apply-transparency-and-blending/blended-objects-overview.html) describes; `crates/doc/src/blend.rs`, `pen_pressure_tilt_and_angles_interpolate_for_brushes`, `stroke_profiles_turn_with_a_key_path_started_elsewhere`, `stroke_gradients_and_dashes_turn_with_a_key_path_started_elsewhere`). - **Blend steps of spot gradients with process plates:** when the matching stops of two gradients, or of a gradient and a solid, are tints of one spot swatch, each step's stop stays linked to it at a tint between the two and keeps the process inks printed with it, each of C, M, Y and K between the two stops' amounts; a stop or solid without process inks counts as none of each. Gradients with different stop counts keep the inks at every resampled stop. PDF export writes such a step as one DeviceN shading of the spot and process inks. Tints of one spot color blend into tints of it, as [the help page](https://helpx.adobe.com/illustrator/desktop/manage-colors/apply-transparency-and-blending/blended-objects-overview.html) describes; the process-ink interpolation is VectorCraft's own rule (`crates/doc/src/blend.rs`, `blend_gradient_spot_process_plates_interpolate`, `resampled_gradient_spot_process_plates_interpolate`, `blend_gradient_missing_plates_mean_zero`, `blend_solid_to_spot_gradient_does_not_copy_plates`; `crates/pdf/src/tests/output.rs`, `blend_steps_between_spot_gradients_with_process_plates_print_both_inks`). - **Path editing (#494):** the handles shown are the handles that drag: Direct Selection drags those of a path selected as a whole (as the Pen leaves it), the Anchor Point tool and Pen+Alt no longer grab handles that Show handles when multiple anchors are selected hides, a handle shorter than the tolerance leaves its anchor to be picked, and the anchor tools pick within Selection & Anchor Display › Tolerance. A dragged segment keeps a smooth anchor at either end smooth. With Direct Selection, the Pen, the Curvature and the anchor tools, a path selected as a whole shows all its anchors selected, and the Control bar and the Properties panel offer Convert (corner, smooth) for them too; Remove and Cut wait for anchors direct-selected (#504). A handle drag gathers its snap targets once per drag (it took 21 ms per pointer move on a 20,000-path document, now 1 ms; `vectorcraft-cli perf` measures handle and segment drags on a 5,000-anchor path). Join merges the selected anchor points that lie on one another, as after Average, into one anchor (#1582, fixes #1533), and removes the merged anchors in one pass over the path, so a long run of them no longer moves the anchors after it once per merge (`cmd::path::tests::a_long_run_before_many_other_anchors_merges_in_one_pass`); Object › Path › Average & Join… (`path.averageJoin`, Cmd+Alt+Shift+J, the "Create corner or smooth join" shortcut of [Default keyboard shortcuts](https://helpx.adobe.com/illustrator/using/default-keyboard-shortcuts.html)) moves two open path ends to their midpoint and joins them there, a corner or smooth point as its dialog's Points choice asks, in one undo step. diff --git a/docs/ui-parity.md b/docs/ui-parity.md index 8e06948b33..b5cd387544 100644 --- a/docs/ui-parity.md +++ b/docs/ui-parity.md @@ -182,7 +182,7 @@ tools, never checked side by side) isn't captured row by row. | Layers panel lists a blend's spine (#4820) | done | an open blend shows a `` row below its key objects, where Release leaves the spine; a click selects the blend (Shift/Cmd toggles it) so Direct Selection edits the spine; a locked blend's row selects nothing; no row while searching or filtering (`a_blends_spine_is_a_row_below_its_keys_that_selects_the_blend`) | | Layers panel: a layer whose Layer Options › Print is off shows its name italic (#5739) | done | the panel row and its drag ghost; a printing layer stays upright, and Print on again restores it; `panels::layers` test `a_layer_that_does_not_print_has_its_name_italic` | | Blend spine Anchor Point conversion and handle editing (#2544) | implemented | symmetric handles, independent drag/retraction, visible-handle policy and selection/stacking covered by tool and engine regressions; Windows native canvas checks and screenshots reviewed in PR #2643 | -| Several blend spine points picked and dragged together (#5285) | done | with Direct Selection, Shift-click picks more points of a selected blend's spine or takes one away, as on a path; dragging any picked point moves them all, and the key objects on them, in one undo step (`object.blend.spine.moveAnchor {with}`); a marquee doesn't pick spine points yet | +| Several blend spine points picked and dragged together (#5285) | done | with Direct Selection, Shift-click picks more points of a selected blend's spine or takes one away, as on a path; dragging any picked point moves them all, and the key objects on them, in one undo step (`object.blend.spine.moveAnchor {with}`); a marquee picks the spine points inside it on the topmost selected blend, and with Shift adds or takes them away | | Add/Delete/Anchor Point tools; Anchor Point tool drags segments to reshape | done | #2267: a click on a handle end retracts that handle and leaves the anchor a corner with the other one; Shift held at the press on an anchor moves it, handles and all (Shift kept down: at 45° steps) instead of pulling out handles | | Pencil: Fidelity, Keep selected, Alt to Smooth, edit selected paths, close by proximity | done | Fidelity is in screen pixels, the same at any zoom, and goes down to 0.01 px in the dialog and the tool, which sends `path.freehand` the value in points at the current zoom (#5729; the Smooth tool keeps 0.05 pt); its slider runs across the Tool Options row on a logarithmic rail from 0.01 to 20 px, the field shows hundredths, and the slider's and the field's arrow keys step hundredths up to 0.1 px, tenths up to 1 px and whole pixels above (Shift ×10) (#3328); Alt key toggles to Smooth Tool (#2001); Shift held at the press draws a straight line at 45° steps from the Constrain Angle, and Alt held at the press (with Alt key toggles to Smooth Tool off) a straight line at any angle (#3799), with a straight-line cursor (a short level line) while Shift or Alt is held before the press, and a path-continuation cursor (a short rising line) over an end of a selected open path, where the stroke continues the path, freehand or straight, and while a continuing stroke ends near an open end of another selected path it connects to; Edit Selected Paths continues a selected path from an end and, from a stroke that starts and ends on a selected path, redraws the section between (the shorter way round a closed path, #2850); with Keep selected (Pencil and Paintbrush, on by default) on, a stroke selects the path it draws or continues and replaces the earlier selection, and off a new stroke leaves nothing selected, the earlier selection included, while a continued or redrawn path is deselected and the rest of the selection stays; a filled Pencil path keeps a stroke of None (#1804, part of #1679); while a freehand stroke is drawn back to within Close Paths When Ends Are Within of its start, or a stroke continuing a selected path (a straight line too) to within it of that path's other end, the Pencil and the Paintbrush show the closing cursor, and a release there closes the path; a Pencil stroke from an end of one selected open path to an end of another connects the two into one path | | Drop Shadow, Outer Glow and Inner Glow: Opacity, the offsets, Blur and Darkness have spinner arrows that step by one (a unit for distances), repeat when held and stop at the fields' ends (#5367, #5368) | done | dialogs::effect test drop_shadow_and_outer_glow_fields_have_spinner_arrows; other effect dialogs' number fields still have none |