Merge pull request #3984 from dotCooCoo/feat/pencil-straight-line-cursor

Pencil: the pointer shows a straight-line cursor while Shift or Alt is held before a press

crates/tools/src/cursors.toml

@@ -530,7 +530,7 @@ look = "Crosshair with a minus badge."
 [[cursor]]
 id = "Pencil"
 group = "Drawing and editing tools"
-shown_when = ["The Pencil tool: draws a freeform path; starting near the end of a selected open path continues it; Shift or Alt held at the press draws a straight line; Alt pressed after the drag starts closes the path."]
+shown_when = ["The Pencil tool: draws a freeform path; starting near the end of a selected open path continues it; Shift held at the press, or Alt held at the press when Alt key toggles to Smooth Tool is off, draws a straight line; Alt pressed after the drag starts, when that option is off, closes the path; when it is on, Alt held at the press gives the Smooth tool."]
 hotspot = "The lead tip."
 
 [[cursor]]
@@ -540,6 +540,13 @@ shown_when = ["The Pencil tool with Alt pressed after the drag starts, when Alt
 hotspot = "The lead tip."
 look = "The Pencil cursor with a ring badge (closing the loop), like PenClose."
 
+[[cursor]]
+id = "PencilStraight"
+group = "Drawing and editing tools"
+shown_when = ["The Pencil tool with Shift or Alt held before a press, except with Alt held when Alt key toggles to Smooth Tool is on: the press draws a straight line, at 45° steps from the Constrain Angle when Shift is held and at any angle with Alt alone."]
+hotspot = "The lead tip."
+look = "The Pencil cursor with a short straight-line badge, where PencilClose has its ring."
+
 [[cursor]]
 id = "Paintbrush"
 group = "Drawing and editing tools"

crates/tools/src/draw2/gesture.rs

@@ -137,6 +137,12 @@ impl GestureTool {
         }
     }
 
+    /// Would a press with `m` held draw a straight Pencil line? Shift or Alt held, unless Alt lends
+    /// the Smooth tool: the rule `PointerKind::Down` sets `straight` by.
+    fn straight_at_press(&self, m: Mods) -> bool {
+        self.id == "pencil" && !(self.alt_smooth && m.alt) && (m.shift || m.alt)
+    }
+
     /// Where the stroke takes a pointer at `p`. For the Blob Brush with Shift held, that is the
     /// horizontal or vertical line through the press point that is nearer in angle to `p` (90°
     /// steps from the Constrain Angle), at `p`'s distance from the press point. The points dragged
@@ -489,6 +495,10 @@ impl Tool for GestureTool {
         if self.smoothing || (self.id == "pencil" && self.alt_smooth && m.alt && !self.began) {
             return Cursor::Smooth;
         }
+        // Before a press that would draw a straight line.
+        if !self.active && self.straight_at_press(m) {
+            return Cursor::PencilStraight;
+        }
         // Alt held at the release closes the path (`finish`).
         // A straight line stays open, so its release has nothing to close, and before a press Alt
         // gives the Pencil a straight line.
@@ -654,7 +664,7 @@ mod tests {
     }
 
     /// Holding Alt shows the Paintbrush's closing cursor before the press, and the Pencil's and the
-    /// Paintbrush's while drawing (before a press, Alt gives the Pencil a straight line); a release
+    /// Paintbrush's while drawing (before a press, Alt gives the Pencil its straight-line cursor); a release
     /// with Alt still held closes the path, and Alt let go before the release leaves it open.
     #[test]
     fn alt_shows_the_closing_cursor_and_a_release_with_alt_closes() {
@@ -669,7 +679,7 @@ mod tests {
         {
             let mut t = GestureTool::new(id);
             assert_eq!(t.cursor(&cx, at, Mods::default()), own, "{id}");
-            assert_eq!(t.cursor(&cx, at, alt), if id == "pencil" { own } else { closing }, "{id}");
+            assert_eq!(t.cursor(&cx, at, alt), if id == "pencil" { Cursor::PencilStraight } else { closing }, "{id}");
             for alt_at_release in [true, false] {
                 t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 0.0, 0.0));
                 t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 10.0, 5.0).with_mods(alt));
@@ -837,6 +847,53 @@ mod tests {
         assert!(matches!(&acts[0], Action::Preview(_, v) if v["closed"] == false && v["points"].as_array().unwrap().len() == 2), "{acts:?}");
     }
 
+    /// Before a press, the Pencil shows its straight-line cursor exactly when the press would draw a
+    /// straight line; once the press is down, and with the Paintbrush, Shift leaves the tool's own
+    /// cursor.
+    #[test]
+    fn pencil_shows_the_straight_line_cursor_when_a_press_draws_a_line() {
+        let (d, _) = doc_with_rect();
+        let s = Selection::default();
+        let p = paint();
+        let mut cx = cx(&d, &s, &p);
+        cx.smart_guides = false;
+        let at = Point::new(0.0, 0.0);
+        let shift = Mods { shift: true, ..Default::default() };
+        let alt = Mods { alt: true, ..Default::default() };
+        let shift_alt = Mods { shift: true, alt: true, ..Default::default() };
+        // The last drag's preview: two points for a line, all three for a freehand stroke, none
+        // for a smoothing drag.
+        let straight = |acts: &[Vec<Action>]| {
+            acts[acts.len() - 2].iter().any(|a| matches!(a, Action::Preview(_, v) if v["points"].as_array().is_some_and(|q| q.len() == 2)))
+        };
+        for alt_smooth in [false, true] {
+            for m in [Mods::default(), shift, alt, shift_alt] {
+                let mut t = GestureTool::new("pencil");
+                t.set_option("altSmooth", &json!(alt_smooth));
+                let shown = t.cursor(&cx, at, m) == Cursor::PencilStraight;
+                let drawn = straight(&drag_held(&mut t, &cx, &[(0.0, 0.0), (30.0, -10.0), (50.0, -60.0)], m));
+                assert_eq!(shown, drawn, "altSmooth {alt_smooth}, {m:?}");
+            }
+        }
+        let mut t = GestureTool::new("pencil");
+        assert_eq!(t.cursor(&cx, at, Mods::default()), Cursor::Pencil);
+        assert_eq!(t.cursor(&cx, at, shift), Cursor::PencilStraight);
+        assert_eq!(t.cursor(&cx, at, alt), Cursor::PencilStraight, "Alt alone draws a line at any angle");
+        assert_eq!(t.cursor(&cx, at, shift_alt), Cursor::PencilStraight, "Alt at the release leaves a straight line open");
+        // While the line is drawn, the Pencil's own cursor; after the release, Shift shows it again.
+        t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 0.0, 0.0).with_mods(shift));
+        t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 40.0, -10.0).with_mods(shift));
+        assert_eq!(t.cursor(&cx, at, shift), Cursor::Pencil, "while the line is drawn");
+        t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 40.0, -10.0).with_mods(shift));
+        assert_eq!(t.cursor(&cx, at, shift), Cursor::PencilStraight, "after the release");
+        // Shift pressed during a freehand stroke doesn't make it a line.
+        t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 0.0, 0.0));
+        t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 40.0, -10.0).with_mods(shift));
+        assert_eq!(t.cursor(&cx, at, shift), Cursor::Pencil, "a freehand stroke");
+        assert_eq!(GestureTool::new("paintbrush").cursor(&cx, at, shift), Cursor::Paintbrush);
+        assert_eq!(Cursor::PencilStraight.precise(), Cursor::Crosshair, "Use Precise Cursors");
+    }
+
     /// #3799: a Shift line started on an end of a selected open path continues the path from that
     /// end, constrained from the end itself.
     #[test]
@@ -935,7 +992,7 @@ mod tests {
         };
         let wavy = [(0.0, 0.0), (30.0, -10.0), (50.0, -60.0), (100.0, -84.0)];
         let mut t = GestureTool::new("pencil");
-        assert_eq!(t.cursor(&cx, Point::new(0.0, 0.0), alt), Cursor::Pencil, "before the press");
+        assert_eq!(t.cursor(&cx, Point::new(0.0, 0.0), alt), Cursor::PencilStraight, "before the press");
         let acts = drag_held(&mut t, &cx, &wavy, alt);
         let all = pts(&acts);
         assert_eq!(all.len(), 4, "{all:?}");
@@ -1148,7 +1205,7 @@ mod tests {
         t.set_option("altSmooth", &json!(false));
         assert_eq!(t.options()["altSmooth"], json!(false));
         // Before a press, Alt gives a straight line rather than a closed path.
-        assert_eq!(t.cursor(&cx, Point::new(50.0, 50.0), alt_mod), Cursor::Pencil);
+        assert_eq!(t.cursor(&cx, Point::new(50.0, 50.0), alt_mod), Cursor::PencilStraight);
 
         // A drag released with Alt held draws a closed pencil path.
         let empty_sel = Selection::default();

crates/tools/src/lib.rs

@@ -578,6 +578,9 @@ pub enum Cursor {
     /// releasing the mouse button with Alt still held closes the path. A drag started with Shift or
     /// Alt held draws an open straight line instead. A crosshair with a ring.
     PencilClose,
+    /// The Pencil tool before a press that draws a straight line (Shift or Alt held). A crosshair with a
+    /// short straight line.
+    PencilStraight,
     /// The Paintbrush tool.
     Paintbrush,
     /// The Paintbrush tool with Alt held: releasing the mouse button with Alt still held closes
@@ -694,6 +697,7 @@ impl Cursor {
             | Cursor::MagicWand
             | Cursor::Pencil
             | Cursor::PencilClose
+            | Cursor::PencilStraight
             | Cursor::Paintbrush
             | Cursor::PaintbrushClose
             | Cursor::BlobBrush

crates/ui-egui/src/canvas.rs

@@ -894,7 +894,7 @@ fn cursor_icon(c: Cursor) -> egui::CursorIcon {
         Cursor::Width | Cursor::WidthAdd => C::Crosshair,
         Cursor::WidthPoint => C::Move,
         Cursor::Blend | Cursor::BlendObject | Cursor::BlendAnchor | Cursor::ShapeBuilder | Cursor::ShapeBuilderErase => C::Crosshair,
-        Cursor::PencilClose | Cursor::PaintbrushClose => C::Crosshair,
+        Cursor::PencilClose | Cursor::PencilStraight | Cursor::PaintbrushClose => C::Crosshair,
         Cursor::TypeVertical => C::VerticalText,
         // Not drawn yet: the cursor each borrows.
         Cursor::Lasso
@@ -3863,6 +3863,7 @@ mod tests {
             Cursor::BlendAnchor,
             Cursor::ShapeBuilder,
             Cursor::ShapeBuilderErase,
+            Cursor::PencilStraight,
         ] {
             assert_eq!(cursor_icon(c), egui::CursorIcon::Crosshair, "{c:?}");
             assert_eq!(cursor_icon(c), cursor_icon(c.precise()), "{c:?}");

crates/ui-egui/src/cursors.rs

@@ -409,7 +409,7 @@ fn magnifier(p: &mut Ink, o: Pos2, out: bool) {
 
 /// Every cursor with a glyph: its own, drawn here, or the one it borrows.
 #[cfg(test)]
-const GLYPHS: [Cursor; 78] = [
+const GLYPHS: [Cursor; 79] = [
     Cursor::Hand,
     Cursor::HandGrab,
     Cursor::ZoomIn,
@@ -464,6 +464,7 @@ const GLYPHS: [Cursor; 78] = [
     Cursor::MagicWand,
     Cursor::Pencil,
     Cursor::PencilClose,
+    Cursor::PencilStraight,
     Cursor::Paintbrush,
     Cursor::PaintbrushClose,
     Cursor::BlobBrush,
@@ -518,6 +519,11 @@ fn glyph(c: Cursor, p: Pos2) -> Option<Vec<Shape>> {
             ink.circle_stroke(p + vec2(8.0, 8.0), 3.0, Stroke::new(3.0, HALO));
             ink.circle_stroke(p + vec2(8.0, 8.0), 3.0, Stroke::new(1.2, INK));
         }
+        // The Pencil's crosshair with a short straight line where the closing ring goes.
+        Cursor::PencilStraight => {
+            crosshair(ink, p);
+            line(ink, p + vec2(5.0, 12.0), p + vec2(12.0, 5.0));
+        }
         Cursor::Eyedropper => eyedropper(ink, p),
         Cursor::ResizeH => double_arrow(ink, p, vec2(1.0, 0.0)),
         Cursor::ResizeV => double_arrow(ink, p, vec2(0.0, 1.0)),
@@ -889,6 +895,31 @@ mod tests {
         }
     }
 
+    /// The Pencil's straight-line cursor is the crosshair with a short straight line below right,
+    /// through the point where the closing cursor's ring is hollow.
+    #[test]
+    fn the_pencil_straight_line_cursor_is_the_crosshair_with_a_line() {
+        for ppp in [1.0, 2.0] {
+            let cross = rasterize(Cursor::Crosshair, ppp).unwrap();
+            let img = rasterize(Cursor::PencilStraight, ppp).unwrap();
+            let ring = rasterize(Cursor::PencilClose, ppp).unwrap();
+            assert_eq!(img.hotspot, cross.hotspot, "at {ppp}");
+            let at = |img: &CustomCursorImage, dx: f32, dy: f32| {
+                let [hx, hy] = img.hotspot.map(usize::from);
+                let (x, y) = ((hx as f32 + dx * ppp) as usize, (hy as f32 + dy * ppp) as usize);
+                if x < img.size[0] as usize && y < img.size[1] as usize { pixel(img, x, y) } else { [0; 4] }
+            };
+            let inked = |p: [u8; 4]| p[3] > 200 && p[0] < 64;
+            assert!(inked(at(&img, 8.5, 8.5)), "the line crosses the badge's middle at {ppp}");
+            assert_eq!(at(&ring, 8.5, 8.5)[3], 0, "the closing ring is hollow there at {ppp}");
+            assert_eq!(at(&cross, 8.5, 8.5)[3], 0, "the crosshair has no badge at {ppp}");
+            // Along the line, not across it: no ink off its ends.
+            assert!(!inked(at(&img, 5.0, 5.0)) && !inked(at(&img, 12.0, 12.0)), "a line, not a cross, at {ppp}");
+            assert_ne!(img, ring, "at {ppp}");
+            assert_eq!(at(&img, -6.0, 0.0), at(&cross, -6.0, 0.0), "the arms are the crosshair's at {ppp}");
+        }
+    }
+
     #[test]
     fn each_bitmap_is_made_once_so_the_os_cursor_is_kept() {
         let mut images = Images::default();

docs/target-app-parity.md

@@ -637,6 +637,9 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
   - **Drawing:** Pen, Curvature, anchor tools, Pencil, Paintbrush, Blob Brush, Smooth, Path Eraser, Join. Direction handles dragged with Direct Selection or the Anchor Point tool snap to smart guides, and Shift keeps them at 45° steps from their anchor. The Pen continues any open path from the end clicked, and while drawing, a click on an end of another open path joins the two into one (#776). The Curvature tool edits any selected path, whatever drew it, keeping its shape except where edited (#798): a click on a point makes it current and a drag moves it, re-curving only its two segments; Alt-click or double-click toggles it smooth or corner and Delete removes it; a click on a segment adds a point without changing the shape; with an end of an open path current, clicks go on from it and its other end closes it (`path.curvatureEdit`). Every point a drawing tool places snaps to Smart Guides through one snapper (#506): the Pen's and Curvature tool's anchors, the Pencil's ends, the shape tools' start and dragged corner or radius (Rectangle, Rounded Rectangle, Ellipse, Polygon, Star, Line Segment, Arc, Spiral, the grids), the Type tool's click and frame, a new artboard's corners. A filled Pencil path keeps a stroke of None (#1804, part of #1679). The [ and ] keys reach the Blob Brush, the Eraser and the Symbolism tools in the app (#1734, part of #1661).
     With the Blob Brush, Shift held during a drag keeps the stroke on the horizontal or vertical line through the press point, whichever is nearer to the pointer (90° steps from the Constrain Angle preference), and the points dragged since Shift went down move to the other line when the pointer crosses to it; the points dragged while Shift is up follow the pointer.
     Curvature point markers are circular, with no direction handles. While drawing, its own point feedback replaces generic selection markers; existing paths use the selection overlay, including partial selections and Hide Edges. Anchor Size applies, and Direct Selection and Pen retain their handles. The real egui-frame regressions in `crates/ui-egui/src/canvas.rs` verify marker positions, counts and unchanged documents (#1236, in part); the existing-path interpolation request remains open. The curve through the points (`curvature_spline` in `crates/tools/src/draw2.rs`) makes each stretch of three points follow the circle through them: a smooth point's handles lie along that circle's tangent, each `chord / (3 cos²(α/2))` long (α between handle and chord, capped at 90°), and the ends of an open path mirror their neighbour's tangent in their chord, so a J or a U curves evenly, a turn tighter than 30° comes to a point, and uneven spacing doesn't loop; the rubber band, a dragged or inserted point and `path.convertAnchor` to smooth use the same rule, while the Pencil's fitting keeps its own; `tests_draw2.rs` checks that the rubber band is the path the click makes (#1236, in part). The Smooth tool smooths only the stretch of path under the drag (#1547, fixes #1512).
+    While Alt is held, the Paintbrush, and the Pencil with Alt key toggles to Smooth Tool off, show a closing cursor (a crosshair with a ring); releasing the mouse button with Alt still held closes the path.
+    With Shift held at the press, the Pencil draws a straight line from the press point to the pointer at 45° steps from the Constrain Angle, as [Draw straight lines with the Pencil tool](https://helpx.adobe.com/illustrator/desktop/draw-shapes-and-paths/draw-shapes/draw-straight-lines-with-the-pencil-tool.html) describes; pressed on an end of a selected open path, the line continues the path from that end (part of #3799). While Shift is held before the press, the Pencil shows a straight-line cursor (a crosshair with a short line). Option/Alt's unconstrained straight line waits for #3959: Alt still closes the path or lends the Smooth tool.
+    With Shift held at the press, the Pencil draws a straight line from the press point to the pointer at 45° steps from the Constrain Angle, as [Draw straight lines with the Pencil tool](https://helpx.adobe.com/illustrator/desktop/draw-shapes-and-paths/draw-shapes/draw-straight-lines-with-the-pencil-tool.html) describes; pressed on an end of a selected open path, the line continues the path from that end (part of #3799). While Shift is held before the press, the Pencil shows a straight-line cursor (a crosshair with a short line). Option/Alt's unconstrained straight line remains: Alt still closes the path or lends the Smooth tool.
     While Alt is held, the Paintbrush (before a press and while drawing) shows a closing cursor (a crosshair with a ring), and so does the Pencil with Alt key toggles to Smooth Tool off when Alt is pressed after the drag starts; releasing the mouse button with Alt still held closes the path. A Pencil drag started with Shift or Alt held draws a straight line instead, which stays open.
     With Shift held at the press, the Pencil draws a straight line from the press point to the pointer at 45° steps from the Constrain Angle, as [Draw straight lines with the Pencil tool](https://helpx.adobe.com/illustrator/desktop/draw-shapes-and-paths/draw-shapes/draw-straight-lines-with-the-pencil-tool.html) describes; pressed on an end of a selected open path, the line continues the path from that end (part of #3799). With Option/Alt held at the press and Alt key toggles to Smooth Tool off, the Pencil draws a straight line at any angle, whose ends snap to Smart Guides, and it stays open when Alt is still held at the release; Shift and Alt together keep the 45° steps (#3799). The straight-line cursor remains.
   - **Shapes:** all shape tools (including Flare) and the line, arc, spiral and grid tools. Space held while dragging out a shape, line, arc, spiral or grid moves it at its current size. While a grid is dragged out, Up/Down change its rows (concentric dividers) and Left/Right its columns (radial dividers). A click with a grid tool asks for the size, the divider counts and the grid options (#1377, in part): a skew for each set of dividers, Use Outside Rectangle As Frame or Create Compound Path From Ellipses, and Fill Grid; they are parameters of `shape.rectangularGrid` and `shape.polarGrid`, stay as the tool's options and apply to drags too. The curve a skew percentage follows and the direction of the radial skew are our own (the public documentation gives neither), and the dialogs have no reference point locator. An ellipse's Pie Start and End Angle and Invert Pie (Transform and Properties panels' Ellipse Properties, `object.setLiveShape {pieStart, pieEnd, invertPie}`) cut it as a pie (#812). With the bounding box showing, the Selection tool shows a selected ellipse's two pie widgets just outside it; dragging one sets its angle in one undo step and double-clicking one makes the ellipse whole again. A live polygon's Polygon Properties there: side count, angle, corner type and radius, radius, side length and Make Sides Equal once an uneven scale has made its sides differ (`object.setLiveShape {sides, polygonAngle, polygonRadius, sideLength, makeSidesEqual}`, part of #812); a star is a plain path, as in Illustrator. The Flare Tool Options last as the tool's options: the next flare dragged out uses them, a click's dialog shows them and double-clicking the tool opens them (part of #812).

docs/ui-parity.md

@@ -91,6 +91,7 @@ tools, never checked side by side) isn't captured row by row.
 | Curvature tool: click/drag points, double-click or Alt-click for a corner, temporary Direct Selection, point conversion | partial | circular point markers without direction handles or duplicate markers, Anchor Size and Hide Edges regression-tested (#1236, in part); curve geometry: each stretch of three points follows the circle through them (handles along its tangent, chord/(3·cos²(α/2)) long, shorter in a turn tighter than 30°), open ends curving in, the same rule for the rubber band, dragged, inserted and converted points (#1236, in part); neighbours of a point dragged on an existing path keep their tangents, and modifiers requested in #975 remain |
 | 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 |
 | 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 | Alt key toggles to Smooth Tool (#2001); Shift held at the press draws a straight line at 45° steps from the Constrain Angle, with a straight-line cursor while Shift is held before the press (part of #3799; Alt's unconstrained straight line is not done); 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) off, the path a stroke draws or continues is not selected afterwards; a filled Pencil path keeps a stroke of None (#1804, part of #1679) |
 | Pencil: Fidelity, Keep selected, Alt to Smooth, edit selected paths, close by proximity | done | 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); 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) off, the path a stroke draws or continues is not selected afterwards; a filled Pencil path keeps a stroke of None (#1804, part of #1679) |
 | Pencil: Fidelity, Keep selected, Alt to Smooth, edit selected paths, close by proximity | partial | Alt to Smooth is missing; 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) off, the path a stroke draws or continues is not selected afterwards; a filled Pencil path keeps a stroke of None (#1804, part of #1679) |
 | Join tool scrubbing, Average, Join | done | Join merges the direct-selected anchors lying on one another along a path, as after Average, into one (#1533) |