diff --git a/crates/behavior/src/cursor.rs b/crates/behavior/src/cursor.rs index 1e4f13cde..f6dd7230c 100644 --- a/crates/behavior/src/cursor.rs +++ b/crates/behavior/src/cursor.rs @@ -205,9 +205,12 @@ pub enum PaintedCursor { /// The end of the path can be grabbed. end: bool, }, - /// A crosshair with the tool's icon below and right of it. + /// A pointer with the tool's icon below and right of it: a crosshair (Perspective Crop), or an arrow with its tip + /// on the hotspot (Paint Bucket, Ruler). #[non_exhaustive] - CrosshairTool { + PointerTool { + /// The pointer the icon rides beside. + pointer: PointerGlyph, /// The icon. icon: IconId, }, @@ -280,9 +283,9 @@ impl PaintedCursor { PaintedCursor::PathText { start, end } } - /// A crosshair with the tool's icon at (+10, +10). - pub const fn crosshair_tool(icon: IconId) -> Self { - PaintedCursor::CrosshairTool { icon } + /// `pointer` with the tool's icon below and right of it. + pub const fn pointer_tool(pointer: PointerGlyph, icon: IconId) -> Self { + PaintedCursor::PointerTool { pointer, icon } } /// A system cursor with a mark. @@ -291,6 +294,16 @@ impl PaintedCursor { } } +/// The pointer of a [`PaintedCursor::PointerTool`]. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] +#[non_exhaustive] +pub enum PointerGlyph { + /// A crosshair centred on the hotspot. + Crosshair, + /// The solid arrow with its tip on the hotspot. + Arrow, +} + /// What a cursor request names. #[derive(Clone, Debug, PartialEq)] #[non_exhaustive] diff --git a/crates/behavior/src/lib.rs b/crates/behavior/src/lib.rs index caa7a2c17..f0b3ab0c4 100644 --- a/crates/behavior/src/lib.rs +++ b/crates/behavior/src/lib.rs @@ -71,7 +71,7 @@ pub use kurbo; pub use codec::{Caret, Codec, NotAValue, NumberCodec, ParseNote, PlainText, decimals_for_step}; pub use columns::{ColumnKey, ColumnWidth, GridSection, GridView, sub_row_cells}; pub use command::{CommandFlags, pick_instance, resolve_flags}; -pub use cursor::{CountMark, Cursor, CursorBadge, CursorIcon, CursorPriority, IconId, PaintedCursor}; +pub use cursor::{CountMark, Cursor, CursorBadge, CursorIcon, CursorPriority, IconId, PaintedCursor, PointerGlyph}; pub use digit_keys::{DigitEntry, DigitKeys}; pub use doc_key::DocKey; pub use dock::DockSide; diff --git a/crates/draw/src/ui/crop/perspective_tool.rs b/crates/draw/src/ui/crop/perspective_tool.rs index febf7e559..132c146fd 100644 --- a/crates/draw/src/ui/crop/perspective_tool.rs +++ b/crates/draw/src/ui/crop/perspective_tool.rs @@ -7,7 +7,7 @@ use std::sync::Arc; use craft_behavior::geometry::Constraint; use craft_behavior::kurbo::Point; -use craft_behavior::{CancelReason, Cursor, CursorIcon, EditEvent, GestureId, IconId, Mixed, PaintedCursor}; +use craft_behavior::{CancelReason, Cursor, CursorIcon, EditEvent, GestureId, IconId, Mixed, PaintedCursor, PointerGlyph}; use craft_theme::variant::Tone; use craft_ui::canvas::{CanvasTool, CropShield, ToolAction, ToolContext, ToolKey, ToolPath, ToolPointer}; use craft_ui::contract::{Bind, Show as _}; @@ -292,7 +292,7 @@ impl CanvasTool for PerspectiveCropPass<'_> { fn cursor(&self, _: &ToolContext<'_>) -> Cursor { if self.tool.quad.is_none() { - PaintedCursor::crosshair_tool(IconId::new("perspective_crop")).into() + PaintedCursor::pointer_tool(PointerGlyph::Crosshair, IconId::new("perspective_crop")).into() } else { Cursor::System(CursorIcon::Default) } diff --git a/crates/ui-contract/icons/ATTRIBUTION.md b/crates/ui-contract/icons/ATTRIBUTION.md index 085f8720a..ca6c4bf39 100644 --- a/crates/ui-contract/icons/ATTRIBUTION.md +++ b/crates/ui-contract/icons/ATTRIBUTION.md @@ -19,6 +19,7 @@ Every set folder's files come from the npm package of the version in the table ( - `distribute-*`, `symmetry-*`, `painting-symmetry` (the symmetry glyphs follow PhotoCraft's axis icons) - `lasso`, `lasso-magnetic`, `lasso-select`, `adjustment-layer`, `layer-mask`, `lollipop`, `marquee-column`, `marquee-row`, `pen-add-anchor`, `pen-curvature`, `pen-delete-anchor`, `pen-freeform`, `quick-selection` (the pen nib and the quick-selection brush follow Lucide's `pen-tool` and `paintbrush`, ISC) - `gradient-linear`, `gradient-radial`, `gradient-angle`, `gradient-reflected`, `gradient-diamond`, `fx` (the layer-style button) +- `protractor` (the Ruler tool's pointer over an end point with Alt, which starts the protractor arm) - `stroke-align-*`, `stroke-cap-*`, `stroke-join-*`, `route-straight`, `route-elbow`, `route-curved` (the stroke editor's and connector bar's segments; the other packs have no matching glyph and draw these) - `sync-lock`, `mark-in`, `mark-out`, `insert-clip`, `overwrite-clip`, `lift-clip`, `extract-clip` (the timeline's lock and edit glyphs, after Premiere Pro's), `keyframe-linear`, `keyframe-bezier`, `keyframe-auto-bezier`, `keyframe-hold`, `keyframe-ease-in`, `keyframe-ease-out` (keyframe nodes after After Effects' shapes: diamond, square for Bezier, circle for Auto Bezier) - `key-linear`, `key-linear-filled`, `key-hold`, `key-bezier`, `key-auto-bezier`, `key-continuous-bezier`, `key-ease-in`, `key-ease-out`, `keyframe-easy-ease` (the timeline's single keyframe marks and the graph editor's Easy Ease button, after FilmCraft's diamond, square and circle and After Effects' keys; solid shapes except the outline diamond and the rings) diff --git a/crates/ui-contract/icons/icons.toml b/crates/ui-contract/icons/icons.toml index 94ac327cc..741c2641e 100644 --- a/crates/ui-contract/icons/icons.toml +++ b/crates/ui-contract/icons/icons.toml @@ -41,7 +41,7 @@ stroke_drawings = [ "keyframe-bezier", "keyframe-ease-in", "keyframe-ease-out", "keyframe-easy-ease", "keyframe-hold", "keyframe-linear", "lasso", "lasso-magnetic", "lasso-select", "layer-mask", "lift-clip", "lollipop", "mark-in", "mark-out", "marquee-column", "marquee-row", "overwrite-clip", "painting-symmetry", "pen-add-anchor", - "pen-curvature", "pen-delete-anchor", "pen-freeform", "quick-selection", "route-curved", "route-elbow", + "pen-curvature", "pen-delete-anchor", "pen-freeform", "protractor", "quick-selection", "route-curved", "route-elbow", "route-straight", "stroke-align-center", "stroke-align-inside", "stroke-align-outside", "stroke-cap-butt", "stroke-cap-round", "stroke-cap-square", "stroke-join-bevel", "stroke-join-miter", "stroke-join-round", "symmetry-diagonal", "symmetry-dual", "symmetry-horizontal", "symmetry-vertical", "sync-lock", @@ -1419,6 +1419,11 @@ name = "gradient_angle" directional = false phosphor = "gradient-angle" # drawn in Phosphor's style: no match in any set +[[icon]] +name = "protractor" +directional = false +phosphor = "protractor" # drawn in Phosphor's style: no match in any set + [[icon]] name = "gradient_reflected" directional = false diff --git a/crates/ui-contract/icons/phosphor/protractor.svg b/crates/ui-contract/icons/phosphor/protractor.svg new file mode 100644 index 000000000..a17dcc3e7 --- /dev/null +++ b/crates/ui-contract/icons/phosphor/protractor.svg @@ -0,0 +1 @@ + diff --git a/crates/ui-contract/src/contract/ghost.rs b/crates/ui-contract/src/contract/ghost.rs index 21174da4b..08c027b89 100644 --- a/crates/ui-contract/src/contract/ghost.rs +++ b/crates/ui-contract/src/contract/ghost.rs @@ -60,7 +60,7 @@ fn paint_pointer(ctx: &Context, env: &Env, painter: &egui::Painter) { /// The art of `cursor`: the hand as a fist while `closed`; with `marks_only`, a brush tip's centre cross and badge /// without its ring. fn pointer_art(env: &Env, cursor: &craft_behavior::PaintedCursor, closed: bool, marks_only: bool) -> Art { - use craft_behavior::PaintedCursor; + use craft_behavior::{PaintedCursor, PointerGlyph}; let overlay = &env.tokens.color.overlay; let pen = pointers::Pen { art: RefCell::new(Art::default()), @@ -100,10 +100,11 @@ fn pointer_art(env: &Env, cursor: &craft_behavior::PaintedCursor, closed: bool, PaintedCursor::Locator => pointers::locator(&pen), PaintedCursor::Arrow { hollow, .. } => pointers::arrow(&pen, *hollow), PaintedCursor::PathText { start, end, .. } => pointers::path_text(&pen, *start, *end), - PaintedCursor::CrosshairTool { icon, .. } => { - let side = env.tokens.size.icon.sm; + PaintedCursor::PointerTool { pointer, icon, .. } => { + // The arrow's icon sits under its body, so it takes the larger size to show past the arrow. + let side = if *pointer == PointerGlyph::Arrow { env.tokens.size.icon.md } else { env.tokens.size.icon.sm }; let icon = SvgIcon::of(&env.tokens, env.direction, side, icon, IconSet::default(), Mirror::Auto); - pointers::crosshair_tool(&pen, icon, side, edge, ink); + pointers::pointer_tool(&pen, *pointer, icon, side, edge, ink); } // `Hidden` has no marks. _ => {} diff --git a/crates/ui-contract/src/primitives/pointer_art.rs b/crates/ui-contract/src/primitives/pointer_art.rs index 5d9f1e972..d605c94de 100644 --- a/crates/ui-contract/src/primitives/pointer_art.rs +++ b/crates/ui-contract/src/primitives/pointer_art.rs @@ -9,7 +9,7 @@ use super::SvgIcon; use crate::style::UiTokens; pub(crate) use art::Art; use art::Mark; -use craft_behavior::{CountMark, CursorBadge, PaintedCursor}; +use craft_behavior::{CountMark, CursorBadge, PaintedCursor, PointerGlyph}; use craft_i18n::Direction; use egui::{Color32, Pos2, Rect, Stroke, Vec2}; use std::cell::RefCell; @@ -61,6 +61,8 @@ const ARROW_TRIANGLES: [[usize; 3]; 5] = [[0, 1, 2], [0, 2, 5], [0, 5, 6], [2, 3 const GRAB_TRIANGLE: [[f32; 2]; 3] = [[3.0, -4.0], [8.0, 0.0], [3.0, 4.0]]; /// The top-left corner of the tool icon beside a crosshair. const CROSSHAIR_ICON: [f32; 2] = [10.0, 10.0]; +/// The top-left corner of the tool icon beside an arrow: under the arrow's body, which is drawn over it. +const ARROW_ICON: [f32; 2] = [6.0, 6.0]; /// The rotate pointer: radius of its arc, half its sweep in radians, and its segment count. const TURN_RADIUS: f32 = 12.0; const HALF_SWEEP: f32 = 0.75; @@ -356,13 +358,20 @@ pub(crate) fn path_text(pen: &Pen, start: bool, end: bool) { } } -/// A crosshair with arms of `side` points in a line of `width` in `color`, as the plain crosshair pointer, with the tool's -/// `icon` of `side` points below and right of it. An icon the catalog lacks leaves only the crosshair. -// A missing icon still shows the crosshair. -pub(crate) fn crosshair_tool(pen: &Pen, icon: Option, side: f32, width: f32, color: Color32) { - crosshair(pen, side, width, color); +/// `pointer` with the tool's `icon` of `side` points below and right of it: a crosshair with arms of `side` points in a +/// line of `width` in `color`, as the plain crosshair pointer, beside the icon; or the solid arrow, as the plain arrow +/// pointer, over the icon's top-left corner. An icon the catalog lacks leaves only the pointer. +pub(crate) fn pointer_tool(pen: &Pen, pointer: PointerGlyph, icon: Option, side: f32, width: f32, color: Color32) { + let corner = match pointer { + PointerGlyph::Arrow => ARROW_ICON, + _ => CROSSHAIR_ICON, + }; if let Some(icon) = icon { - icon_on_halo(pen, Rect::from_min_size(v(CROSSHAIR_ICON).to_pos2(), Vec2::splat(side)), icon); + icon_on_halo(pen, Rect::from_min_size(v(corner).to_pos2(), Vec2::splat(side)), icon); + } + match pointer { + PointerGlyph::Arrow => arrow(pen, false), + _ => crosshair(pen, side, width, color), } } diff --git a/crates/ui-contract/tests/it/runtime/cursor.rs b/crates/ui-contract/tests/it/runtime/cursor.rs index 4b1711a01..ab2ae8670 100644 --- a/crates/ui-contract/tests/it/runtime/cursor.rs +++ b/crates/ui-contract/tests/it/runtime/cursor.rs @@ -1,7 +1,7 @@ //! The cursor service's images (8.5): a painted pointer reaches the window as its cursor image where the window takes //! one at its size, and is painted at the pointer otherwise. -use craft_behavior::{CountMark, Cursor, CursorBadge, CursorIcon, CursorPriority, IconId, PaintedCursor}; +use craft_behavior::{CountMark, Cursor, CursorBadge, CursorIcon, CursorPriority, IconId, PaintedCursor, PointerGlyph}; use craft_host::target::{Backend, Os, Runtime, ShellInfo}; use craft_ui::runtime::cursor; use craft_ui::testing::pointer::moved; @@ -133,7 +133,8 @@ fn a_painted_pointer_is_the_window_cursor_image_where_the_window_takes_one() { PaintedCursor::arrow(false), PaintedCursor::arrow(true), PaintedCursor::path_text(true, false), - PaintedCursor::crosshair_tool(IconId::new("crop")), + PaintedCursor::pointer_tool(PointerGlyph::Crosshair, IconId::new("crop")), + PaintedCursor::pointer_tool(PointerGlyph::Arrow, IconId::new("paint_bucket")), ] { let seen = painted(&mut frames, cursor.clone()); assert!(seen.image.is_some() && seen.shapes == 0, "{cursor:?}"); @@ -158,6 +159,36 @@ fn a_painted_pointer_is_the_window_cursor_image_where_the_window_takes_one() { assert!(hidden.image.is_none() && hidden.shapes == 0 && hidden.icon == egui::CursorIcon::None); } +/// A tool icon rides below and right of its pointer: beside the plain pointer, the image's marks reach as far left and up +/// from the hotspot (the arrow's tip, the crosshair's centre) and farther right and down; an icon the catalog lacks +/// leaves the plain pointer. +#[trial] +fn a_tool_icon_rides_below_right_of_its_pointer() { + // How far the opaque pixels reach from the hotspot: left, up, right, down. + fn reach(image: &CustomCursorImage) -> [i32; 4] { + let (side, [hx, hy]) = (i32::from(image.size[0]), image.hotspot.map(i32::from)); + let mut reach = [0; 4]; + for (i, px) in image.rgba.chunks(4).enumerate() { + if px[3] > 0 { + let (dx, dy) = (i as i32 % side - hx, i as i32 / side - hy); + reach = [reach[0].max(-dx), reach[1].max(-dy), reach[2].max(dx), reach[3].max(dy)]; + } + } + reach + } + let mut frames = frames(linux(), 1.0); + for (plain, pointer) in [(PaintedCursor::arrow(false), PointerGlyph::Arrow), (PaintedCursor::Crosshair, PointerGlyph::Crosshair)] { + let plain = reach(&painted(&mut frames, plain).image.unwrap()); + for icon in ["paint_bucket", "ruler", "protractor"] { + let with = reach(&painted(&mut frames, PaintedCursor::pointer_tool(pointer, IconId::new(icon))).image.unwrap()); + assert_eq!(with[..2], plain[..2], "{pointer:?} {icon}: nothing reaches farther left or up"); + assert!(with[2] > plain[2] && with[3] > plain[3], "{pointer:?} {icon}: the icon lies below right"); + } + let missing = reach(&painted(&mut frames, PaintedCursor::pointer_tool(pointer, IconId::new("no_such_icon"))).image.unwrap()); + assert_eq!(missing, plain, "{pointer:?}: only the pointer"); + } +} + /// An unchanged pointer hands the window the same image, so the integration uploads it to the OS once; a new size or /// scale makes a new one; a frame whose winner is a system cursor, or that asks for nothing, clears it (egui keeps an /// image until it is replaced).