VectorCraft: An open-source, vector art tool written by scratch in pure Rust
refactor(ui-egui): move canvas.rs items to canvas/{artboards,context,cursor,drag,grid,home,input,outline,overlays,raster,task_bar,tool_overlays,view}.rs
aionggdbce5020f2a4
diff --git a/crates/ui-egui/src/canvas.rs b/crates/ui-egui/src/canvas.rsindex ed1be0766..d590c01f6 100644--- a/crates/ui-egui/src/canvas.rs+++ b/crates/ui-egui/src/canvas.rs@@ -14,6 +14,62 @@ use crate::stylus::StylusFeed;use crate::theme::{self, Tokens};use crate::{CacheKey, VectorcraftApp, now_ms, widgets};+mod artboards;+mod context;+mod cursor;+mod drag;+mod grid;+mod home;+mod input;+mod outline;+mod overlays;+mod raster;+mod task_bar;+mod tool_overlays;+mod view;++use artboards::{ArtboardNameEdit, artboard_label, artboard_marks, artboard_name_editor, name_edit_id};+#[cfg(test)]+use artboards::{artboard_name_field_rect, begin_artboard_name_edit, commit_artboard_name, names_an_artboard, tool_name_rect};+use context::{context_menu, panel_drop};+pub use cursor::{HOVER_STILL_SECS, STILL_SECS, ViewKey};+use cursor::{cursor_icon, hover_cursor, hover_wait, still_wait};+use drag::drag_id;+pub use drag::{apply_requests, dispatch, mods};+pub(crate) use drag::{end_document_drag, release_art_in_window, release_over_panel};+#[cfg(test)]+use drag::{frame_moves, tool_drag_doc_id, tool_drag_moved, tool_frame_moves, tool_press_doc_id};+#[cfg(test)]+use grid::ruler_rects;+use grid::{LineLook, PIXEL_GRID, PIXEL_GRID_ZOOM, checker, clip_segment, grid, ruler_input, rulers, textured_quad, view_bounds};+pub(crate) use grid::{RulerScale, checker_texture, ruler_label, ruler_origin_dragging};+#[cfg(test)]+pub(crate) use grid::{TRANSPARENCY_GRID, vertical_label_height};+use home::home;+use input::handle_input;+use outline::KEY_OUTLINE;+#[cfg(test)]+use outline::{OVERLAY_MAX_ANCHORS, c32, node_outline, walk_drawn};+#[cfg(test)]+use overlays::selected_anchor;+use overlays::{HandleLook, draw_overlays, hover_highlight, ime_geometry, selection_overlay};+pub(crate) use raster::color_image;+use raster::{changed_pixels, pixel_region, upload};+use task_bar::task_bar;+pub(crate) use task_bar::{has_colors, task_bar_rect};+pub use tool_overlays::HiddenChars;+#[cfg(test)]+use tool_overlays::{DIAL_RADIUS, HiddenMarks};+use tool_overlays::{+ grid_repeat_overlay, hidden_chars_overlay, live_paint_gap_overlays, mirror_axis_overlay, original_path_overlay, print_tiling_overlay,+ rotate_view_dial, shaper_widget_overlay, slice_overlay, thread_overlays,+};+pub(crate) use view::animated_zoom;+pub use view::fit;+use view::scroll_bars;+#[cfg(test)]+use view::{ScrollRest, Span, scroll_by, scroll_spans, scroll_tracks};+const RULER: f32 = 16.0;/// The scroll bars' thickness along the window's right and bottom edges.const SCROLL_BAR: f32 = 12.0;@@ -102,184 +158,6 @@ enum Drag {Present,}-/// Whether drag `d` is a press the tool holds. Every other drag (panning, zooming, turning the-/// view, a touch gesture, Presentation Mode) never reaches the tool, so its hover ends with it.-fn tool_holds(d: Drag) -> bool {- matches!(d, Drag::Tool | Drag::Art)-}--/// What a hover depends on besides the pointer's screen position.-#[derive(Clone, Copy, Debug, PartialEq)]-struct HoverContext {- /// The active tool: a tool switched to under a still pointer is hovered at once.- tool: &'static str,- /// The canvas, and the view's centre, zoom and rotation.- canvas: egui::Rect,- center: Point,- zoom: f64,- rotation: f64,- /// The active document's id and revision (which moves with every edit, undo and selection- /// change).- doc: Option<(u64, u64)>,-}--/// Clear canvas interaction state before a tab transfer takes ownership of the artwork drag.-pub(crate) fn end_document_drag(ctx: &egui::Context) {- ctx.data_mut(|d| {- d.remove::<Drag>(drag_id());- d.remove::<Pos2>(drag_pos_id());- });-}--/// Temp-memory key for the active canvas drag state.-fn drag_id() -> egui::Id {- egui::Id::unique("canvas-drag")-}-/// Where the pointer was last seen during a press on the canvas.-fn drag_pos_id() -> egui::Id {- egui::Id::unique("canvas-drag-pos")-}-/// The layer the canvas was last drawn on: a release over another layer is over a panel (#2826).-fn drag_layer_id() -> egui::Id {- egui::Id::unique("canvas-drag-layer")-}-/// Whether `p` is over the canvas itself, not a panel or a floating window over it.-fn on_canvas(ui: &Ui, resp: &egui::Response, p: Pos2) -> bool {- resp.rect.contains(p) && ui.clip_rect().contains(p) && ui.ctx().layer_id_at(p).is_none_or(|l| l == resp.layer_id)-}-/// The document point last sent to the tool as a drag during [`Drag::Tool`]; none until the press-/// has dragged.-fn tool_drag_doc_id() -> egui::Id {- egui::Id::unique("canvas-tool-drag-doc")-}-/// The document point of the press that began [`Drag::Tool`], sent to the tool as its Down.-fn tool_press_doc_id() -> egui::Id {- egui::Id::unique("canvas-tool-press-doc")-}-/// Whether the tool should get another drag event, and if so records `p` as the last position-/// sent: the pointer moved this frame, or its document position changed without a delta (#834).-/// egui's frame delta is zero when some Wayland compositors coalesce motion until release, and in-/// the frame the pointer comes back into the window after leaving it (`PointerGone` forgot where-/// it was), though it is somewhere new; judged on the delta alone, the preview stayed behind.-fn tool_drag_moved(ui: &Ui, xf: &Xf, p: Pos2, pointer: &egui::PointerState) -> bool {- let at = xf.to_doc(p);- let id = tool_drag_doc_id();- // Before the press has dragged, the last position the tool got is the press itself: a press- // held still is not a drag.- let prev = ui.data(|d| d.get_temp::<Point>(id).or_else(|| d.get_temp::<Point>(tool_press_doc_id())));- if pointer.delta() == egui::Vec2::ZERO && prev == Some(at) {- return false;- }- ui.data_mut(|d| d.insert_temp(id, at));- true-}--/// The pen pressure (0..1) of the press in progress: the force of this frame's pen or touch-/// input, else the pressure in the host's feed while a pen is the pointer that moved last-/// ([`crate::Services::stylus`]: [`StylusFeed::press`] for a new press, [`StylusFeed::held`]-/// after it), else the last one seen since the press (`pressed`: a new press, whose mouse has none-/// until a pen reports it). A mouse presses fully (1).-fn pen_pressure(ui: &Ui, app: &VectorcraftApp, pressed: bool) -> f32 {- let stylus = app.services.stylus.as_ref();- let id = egui::Id::unique("canvas-pressure");- let force = ui.input(|i| {- i.events.iter().rev().find_map(|e| match e {- egui::Event::Touch { force: Some(f), .. } if f.is_finite() => Some(f.clamp(0.0, 1.0)),- _ => None,- })- });- let force = force.or_else(|| stylus.and_then(if pressed { StylusFeed::press } else { StylusFeed::held }));- let p = force.or_else(|| if pressed { None } else { ui.data(|d| d.get_temp::<f32>(id)) }).unwrap_or(1.0);- ui.data_mut(|d| d.insert_temp(id, p));- p-}--/// The positions this frame's pointer moves passed through before its last one, each with the-/// pen force a touch event gave just before it, or the pressure the host's feed kept for that move-/// ([`StylusFeed::take_moves`], macOS), if any. The last move is the pointer's position. A mouse's-/// moves count too, with no pressure: a fast mouse stroke otherwise keeps one position a frame, a-/// sample every few pixels, too few for a low Fidelity to follow the hand (#3328).-fn frame_moves(ui: &Ui, stylus: Option<&StylusFeed>) -> Vec<(Pos2, Option<f32>)> {- let pressures = stylus.map(StylusFeed::take_moves).unwrap_or_default();- ui.input(|i| {- let mut moves = vec![];- if i.events.iter().any(|e| matches!(e, egui::Event::Touch { .. })) {- let mut force = None;- for e in &i.events {- match e {- egui::Event::Touch { force: Some(f), .. } if f.is_finite() && *f > 0.0 => force = Some(f.clamp(0.0, 1.0)),- egui::Event::PointerMoved(p) => moves.push((*p, force)),- _ => {}- }- }- } else if !pressures.is_empty() {- // The feed's last pressure is the last move's: pair them from the end. A lift's 0 is- // no pressure (the press keeps its last touch).- let points: Vec<Pos2> = i.events.iter().filter_map(|e| if let egui::Event::PointerMoved(p) = e { Some(*p) } else { None }).collect();- let forces = pressures.iter().rev().map(|f| (*f > 0.0).then_some(*f)).chain(std::iter::repeat(None));- moves = points.into_iter().rev().zip(forces).collect();- moves.reverse();- } else {- moves = i.events.iter().filter_map(|e| if let egui::Event::PointerMoved(p) = e { Some((*p, None)) } else { None }).collect();- }- moves.pop();- // A burst of events (a stalled frame) is thinned to a bounded count.- const MAX: usize = 64;- if moves.len() > MAX {- let step = moves.len().div_ceil(MAX);- moves = moves.into_iter().step_by(step).collect();- }- moves- })-}--/// The moves of this frame ([`frame_moves`]) the active tool gets before the pointer's position:-/// all of them for a tool that builds a stroke from them ([`vectorcraft_engine::Session::tool_wants_samples`]), none-/// for the others, which get one drag a frame. The moves are read either way, so the host's feed-/// pairs the next frame's with its own.-fn tool_frame_moves(ui: &Ui, app: &VectorcraftApp) -> Vec<(Pos2, Option<f32>)> {- let moves = frame_moves(ui, app.services.stylus.as_ref());- if app.session.tool_wants_samples() { moves } else { vec![] }-}--pub fn mods(m: egui::Modifiers, space: bool) -> Mods {- Mods { shift: m.shift, alt: m.alt, cmd: m.command, ctrl: m.ctrl, space }-}--/// Fit the view (View → Fit Artboard / Fit All / Actual Size).-pub fn fit(app: &mut VectorcraftApp, how: &str) {- let Some(rect) = app.canvas_rect else {- if let Some(v) = app.view_mut() {- v.fitted = false;- }- return;- };- let current = app.view().map_or(0, |v| v.artboard);- let Some(st) = app.session.active() else { return };- let target = match how {- "view.fitAll" => {- st.doc.art_bounds().map(|a| st.doc.artboards.iter().fold(a, |r, ab| r.union(ab.rect))).or(st.doc.artboards.first().map(|a| a.rect))- }- // The navigator's artboard (the first if it has gone).- _ => st.doc.artboards.get(current).or(st.doc.artboards.first()).map(|a| a.rect),- };- let Some(target) = target else { return };- let zoom = if how == "view.actualSize" {- actual_size_zoom(app.session.prefs.display_print_size)- } else {- // The width and height of the box round the target turned with the view, at zoom 1.- let (sn, cs) = app.view().map_or(0.0, |v| v.rotation.to_radians()).sin_cos();- let (w, h) = (target.width(), target.height());- let zx = (rect.width() as f64 - 60.0) / (w * cs.abs() + h * sn.abs()).max(1.0);- let zy = (rect.height() as f64 - 60.0) / (w * sn.abs() + h * cs.abs()).max(1.0);- zx.min(zy).clamp(0.0313, 640.0)- };- let Some(v) = app.view_mut() else { return };- v.center = target.center();- v.fitted = true;- v.zoom = zoom;-}-/// Paint the document canvas, complete or cached artwork, navigation and tool overlays.pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {let t = Tokens::get(ui.ctx());@@ -817,3187 +695,5 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {}}-/// The active tool's cursor at the pointer, as `mods` make it. While the view moves (`still`-/// false), the cursor the tool last gave for the same tool and keys stays: asking the tool again-/// would hit-test the art under the pointer at every frame of the move (#2452).-fn hover_cursor(app: &mut VectorcraftApp, mods: Mods, view: vectorcraft_engine::ViewInfo, still: bool) -> Option<Cursor> {- let id = app.session.tool_id();- if !still- && let Some((was, with, c)) = app.canvas.hover_cursor- && (was, with) == (id, mods)- {- return Some(c);- }- let c = app.session.cursor(app.hover_doc?, mods, view);- app.canvas.hover_cursor = Some((id, mods, c));- Some(c)-}--/// How long (seconds) the view must stay still before a canvas with-/// [`crate::CanvasCache::waits_for_still`] set renders a heavy document again.-pub const STILL_SECS: f64 = 0.2;--/// How long (seconds) the view must stay still before the canvas hit-tests the art under the-/// pointer again, for Object Highlighting and the tool's cursor. While the view pans, zooms or-/// turns under a resting pointer, the document point under it changes every frame, and hit-testing-/// detailed art each time slowed every frame of the move (#2452).-pub const HOVER_STILL_SECS: f64 = 0.15;--/// The view [`hover_wait`] watches: the canvas's rectangle and the view's zoom, centre and rotation.-#[derive(Clone, Copy, Debug, PartialEq)]-pub struct ViewKey {- rect: egui::Rect,- zoom: f64,- center: Point,- rotation: f64,-}--/// Note the view `key` at time `now` (seconds, egui's input time) → how many more seconds the-/// canvas leaves the art under the pointer alone: the view changed less than [`HOVER_STILL_SECS`]-/// ago. The first view noted counts as still.-fn hover_wait(moved: &mut Option<(ViewKey, f64)>, key: ViewKey, now: f64) -> Option<f64> {- match moved {- Some((k, at)) if *k != key => (*k, *at) = (key, now),- Some(_) => {}- None => *moved = Some((key, f64::NEG_INFINITY)),- }- let waited = moved.map_or(f64::INFINITY, |(_, at)| now - at);- // The clock went back (a new egui context): don't wait for it to catch up.- (0.0..HOVER_STILL_SECS).contains(&waited).then_some(HOVER_STILL_SECS - waited)-}--/// Note that the canvas asks for `key` at time `now` (seconds, egui's input time) → how many more-/// seconds it draws the frame `shown` reprojected instead of rendering `key`: while the last-/// render was `slow`, only the view differs between the two, and the canvas has asked for `key`-/// for less than [`STILL_SECS`]. `still` holds the key last asked for and when the canvas first-/// asked for it. None: the canvas renders `key` now, unless it is the frame shown.-fn still_wait(still: &mut Option<(CacheKey, f64)>, shown: Option<&CacheKey>, key: &CacheKey, slow: bool, now: f64) -> Option<f64> {- if still.as_ref().is_none_or(|(k, _)| k != key) {- *still = Some((key.clone(), now));- }- let waited = still.as_ref().map_or(0.0, |(_, at)| now - at);- // The clock went back (a new egui context): don't wait for it to catch up.- let waiting = (0.0..STILL_SECS).contains(&waited);- (slow && waiting && shown.is_some_and(|s| s != key && only_view_differs(s, key))).then_some(STILL_SECS - waited)-}--/// Whether two cache keys differ only in the view (zoom, center, rotation, canvas size, pixel-/// density and Pixel Preview's document pixels), with Pixel Preview on in both or off in both.-fn only_view_differs(a: &CacheKey, b: &CacheKey) -> bool {- a.pixel.is_some() == b.pixel.is_some()- && *a == CacheKey { zoom: a.zoom, cx: a.cx, cy: a.cy, w: a.w, h: a.h, ppp: a.ppp, rot: a.rot, pixel: a.pixel, ..b.clone() }-}--fn cursor_icon(c: Cursor) -> egui::CursorIcon {- use egui::CursorIcon as C;- match c {- Cursor::Arrow- | Cursor::ArrowHollow- | Cursor::DirectAnchor- | Cursor::DirectAnchorSelected- | Cursor::ReshapeSegment- | Cursor::GroupSelection- | Cursor::CornerRadius- | Cursor::PathBracket- | Cursor::TypeWidget- | Cursor::LoadedText => C::Default,- Cursor::SelectionCopy => C::Copy,- Cursor::Move => C::Move,- Cursor::Crosshair => C::Crosshair,- Cursor::ResizeH | Cursor::ShearH => C::ResizeHorizontal,- Cursor::ResizeV | Cursor::ShearV => C::ResizeVertical,- Cursor::ResizeNwSe => C::ResizeNwSe,- Cursor::ResizeNeSw => C::ResizeNeSw,- Cursor::Rotate | Cursor::RotateToward(_) => C::Alias,- Cursor::Pen- | Cursor::PenDrawing- | Cursor::PenAdd- | Cursor::PenDelete- | Cursor::PenClose- | Cursor::PenContinue- | Cursor::PenJoin- | Cursor::PenConvert- | Cursor::AnchorPoint- | Cursor::Curvature => C::Crosshair,- Cursor::Text => C::Text,- Cursor::Hand => C::Grab,- Cursor::HandGrab => C::Grabbing,- Cursor::ZoomIn => C::ZoomIn,- Cursor::ZoomOut => C::ZoomOut,- Cursor::Eyedropper => C::Crosshair,- Cursor::NotAllowed => C::NotAllowed,- Cursor::Busy => C::Progress,- Cursor::AddStop => C::Copy,- Cursor::RemoveStop => C::NotAllowed,- Cursor::Slice => C::Crosshair,- Cursor::SliceSelect => C::Default,- Cursor::Width | Cursor::WidthAdd => C::Crosshair,- Cursor::WidthPoint => C::Move,- Cursor::PencilNew => C::Crosshair,- Cursor::Blend | Cursor::BlendObject | Cursor::BlendAnchor | Cursor::ShapeBuilder | Cursor::ShapeBuilderErase => C::Crosshair,- Cursor::PencilClose | Cursor::PencilStraight | Cursor::PencilContinue | Cursor::PaintbrushClose => C::Crosshair,- Cursor::TypeVertical => C::VerticalText,- // Not drawn yet: the cursor each borrows.- Cursor::Lasso- | Cursor::MagicWand- | Cursor::Pencil- | Cursor::Paintbrush- | Cursor::BlobBrush- | Cursor::Eraser- | Cursor::Smooth- | Cursor::PathEraser- | Cursor::Join- | Cursor::Knife- | Cursor::Shaper- | Cursor::LivePaintBucket- | Cursor::Measure- | Cursor::PrintTiling- | Cursor::SymbolSprayer- | Cursor::SymbolShifter- | Cursor::SymbolScruncher- | Cursor::SymbolSizer- | Cursor::SymbolSpinner- | Cursor::SymbolStainer- | Cursor::SymbolScreener- | Cursor::SymbolStyler- | Cursor::ObjectsOnPath- | Cursor::Scissors- | Cursor::ScissorsNotAllowed- | Cursor::MeshAdd- | Cursor::PuppetPin => cursor_icon(c.stand_in().unwrap_or(Cursor::Crosshair)),- }-}--/// Dispatch canvas pointer, keyboard and drop events through the active document view.-fn handle_input(app: &mut VectorcraftApp, ui: &Ui, resp: &egui::Response, rect: egui::Rect) {- let line = ui.ctx().options(|o| o.input_options.line_scroll_speed);- let wheel_zooms = app.session.prefs.zoom_with_mouse_wheel;- let turn_id = egui::Id::unique("canvas-wheel-turn");- let turn_before: WheelTurn = ui.data(|d| d.get_temp(turn_id)).unwrap_or_default();- let mut turn = turn_before;- let (pointer, m, space, (factor, scroll)) =- ui.input(|i| (i.pointer.clone(), i.modifiers, i.key_down(egui::Key::Space), wheel(i, wheel_zooms, line, rect.height(), &mut turn)));- if turn != turn_before {- ui.data_mut(|d| d.insert_temp(turn_id, turn));- }- if turn.glide != 0.0 {- ui.ctx().request_repaint();- }- let hover = pointer.hover_pos().filter(|p| rect.contains(*p));- // Zoom around the pointer, and scroll ([`wheel`]): fingers pinching on a touch screen may also- // slide. Then turn the view about the pointer for a trackpad rotation ([`trackpad_turn`]). The- // tool's events below take their document points from the view this moves to.- if resp.hovered() {- if (factor - 1.0).abs() > 1e-6- && let (Some(p), Some(vm)) = (hover, app.view_mut())- {- zoom_about(vm, rect, p, vm.zoom * factor);- }- if scroll != egui::Vec2::ZERO {- scroll_view(app, ui, scroll);- }- if let Some(p) = hover- && let Some(deg) = trackpad_turn(ui, app.session.prefs.trackpad_rotate_view)- && let Some(vm) = app.view_mut()- {- rotate_about(vm, rect, p, deg);- }- }- let v = *app.view().unwrap_or(&View::default());- let xf = Xf::new(rect, &v);- // A lifted pen or finger takes the pointer away in the frame it lifts (egui's `PointerGone`),- // so a tap whose press and lift come in one frame has no hover position: it presses (and- // double-taps) where it was seen last (#491).- let at = hover.or_else(|| pointer.interact_pos().filter(|p| rect.contains(*p)));- let view = app.view_info();- touch_gestures(app, ui, rect, view);- // Pressed and held still, a pen or a finger opens the context menu (egui's long touch): the- // tool's press is dropped, as a right-click presses nothing.- if resp.long_touched() {- drop_press(app, ui, view);- }- let drag: Option<Drag> = ui.data(|d| d.get_temp(drag_id()));- // A modifier pressed or released over the canvas re-hovers the tool, so what it changes shows- // without moving the mouse (Alt switches the Shape Builder to erase mode).- let mods_changed = ui.data_mut(|d| {- let id = egui::Id::unique("canvas-mods");- let prev = d.get_temp::<egui::Modifiers>(id);- d.insert_temp(id, m);- prev.is_some_and(|prev| prev != m)- });- // Where the tool hovers: the pointer over the canvas itself, not over a floating panel, a menu,- // a popup or a dialog drawn on top of it ([`on_canvas`]).- let hover_tool = hover.filter(|p| on_canvas(ui, resp, *p));- // Whether the tool hovered last frame: coming onto the canvas re-hovers it, even after a single- // jump egui doesn't count as moving, and leaving it ends the tool's hover (below).- let was_over = ui.data_mut(|d| {- let id = egui::Id::unique("canvas-hovered");- let prev = d.get_temp::<bool>(id).unwrap_or(false);- d.insert_temp(id, hover_tool.is_some());- prev- });- // What a hover means besides where the pointer is on screen: the tool, the canvas, the view- // (scrolled, zoomed or turned by the wheel, a gesture, keys or a command) and the document and- // selection as they are (another tab, an edit, an undo). Under a still pointer, a tool switched- // to is hovered at once, and when the rest changes, a tool that asks for it- // ([`Session::tool_wants_rehover`]) is hovered again where the pointer is.- let context = HoverContext {- tool: app.session.tool_id(),- canvas: rect,- center: v.center,- zoom: v.zoom,- rotation: v.rotation,- doc: app.session.active().map(|st| (st.uid, st.revision)),- };- let (tool_switched, context_changed) = ui.data_mut(|d| {- let id = egui::Id::unique("canvas-hover-context");- let prev = d.get_temp::<HoverContext>(id);- d.insert_temp(id, context);- prev.map_or((false, false), |prev| (prev.tool != context.tool, prev != context))- });-- // In Presentation Mode a click anywhere goes to the next artboard. The tool receives no press,- // drag or hover, and a drag does not pan the view. A drag that began before the mode was turned- // on ends as usual.- if app.ui.screen_mode == 3 && matches!(drag, None | Some(Drag::Present | Drag::Gesture)) {- let pressed = drag.is_none() && pointer.primary_pressed() && resp.hovered() && at.is_some();- // `press` is this frame's new press, or else the press held so far. A quick tap can be- // pressed and released in one frame.- let press = if pressed { Some(Drag::Present) } else { drag };- if press.is_some() && !pointer.primary_down() {- ui.data_mut(|dd| dd.remove::<Drag>(drag_id()));- // A tap of several fingers leaves `Drag::Gesture` (`touch_gestures`), and its release- // does not move the view to the next artboard.- if press == Some(Drag::Present) && resp.clicked() {- crate::shortcuts::presentation_step(app, true);- }- } else if pressed {- ui.data_mut(|dd| dd.insert_temp(drag_id(), Drag::Present));- }- return;- }-- // A pen turned to its eraser end selects the Eraser, and a pen turned back to its tip selects- // the tool before it. The switch runs only while the pointer is in this window. It runs before- // this frame's press, which then uses the new tool; while a press is held, it waits for the- // release. A turn made over another window takes effect when the pointer comes in.- if drag.is_none() && ui.input(|i| i.pointer.has_pointer()) {- crate::stylus::sync_eraser_tool(app);- }- let tool = app.session.tool_id();- // Held, Space is the Hand tool for the moment, Space+Shift is the Rotate View tool and- // Cmd+Space is the Zoom tool (with Alt, zooming out), whatever the tool.- let zoom_mode = if space { m.command } else { tool == "zoom" };- let rotate_mode = if space { m.shift && !m.command } else { tool == "rotateView" };- let pan_mode = if space { !m.command && !m.shift } else { tool == "hand" };- let middle_pan = matches!(drag, Some(Drag::Pan { middle: true, .. }));- // egui counts a press a few pixels outside the canvas as on it (its interaction radius): only a- // press on the canvas itself reaches the tools, else it would land at the canvas's centre.- if pointer.primary_pressed()- && resp.hovered()- && !middle_pan- && let Some(p) = at- {- ui.ctx().memory_mut(|mem| mem.stop_text_input());- app.ui.flyout = None;- // The artboard's name sits above its corner. A press there renames on a double-click- // and does not start a tool gesture (a fitted artboard, a new one, Artboard Options).- if let Some(i) = artboard_name_at(app, ui, &xf, p) {- ui.data_mut(|dd| dd.insert_temp(name_press_id(), i));- } else {- let d = if crate::touch::finger_navigates_only() {- // A finger (or a palm) once a pen has been seen: it navigates, it doesn't draw.- Drag::Gesture- } else if zoom_mode {- if animated_zoom(&app.session.prefs) { Drag::ZoomScrub { start: p, held: 0.0, moved: false } } else { Drag::ZoomBox { start: p } }- } else if pan_mode {- Drag::Pan { start: p, center: v.center, middle: false }- } else if rotate_mode {- let c = rect.center();- Drag::RotateView { start_angle: (p.y - c.y).atan2(p.x - c.x) as f64, start_rot: v.rotation, snaps: !space }- } else {- // Cmd with another tool drags with the selection tool used last (the session lends it).- let ev = PointerEvent { kind: PointerKind::Down, pos: xf.to_doc(p), mods: mods(m, space), pressure: pen_pressure(ui, app, true) };- dispatch(app, &ev, view);- crate::document_drag::begin(app, ui.ctx(), ev.pos);- Drag::Tool- };- // Panning, zooming or turning the view takes the pointer from the tool's hover.- if !tool_holds(d) {- app.session.tool_hover_ended(view);- }- ui.data_mut(|dd| {- dd.insert_temp(drag_id(), d);- dd.insert_temp(drag_pos_id(), p);- dd.insert_temp(drag_layer_id(), resp.layer_id);- // A new press has not dragged yet, whatever an interrupted one left behind.- dd.remove::<Point>(tool_drag_doc_id());- dd.insert_temp(tool_press_doc_id(), xf.to_doc(p));- });- }- } else if drag.is_none()- && resp.hovered()- && pointer.button_pressed(egui::PointerButton::Middle)- && let Some(start) = hover- {- // Middle-button drag pans the view whatever the tool.- ui.data_mut(|dd| dd.insert_temp(drag_id(), Drag::Pan { start, center: v.center, middle: true }));- app.session.tool_hover_ended(view);- } else if let Some(d) = drag {- // The pointer gone (a pen lifted with its press), the drag ends where it was last seen.- let p = pointer.interact_pos().or_else(|| ui.data(|dd| dd.get_temp(drag_pos_id()))).unwrap_or(rect.center());- let held = if middle_pan { pointer.button_down(egui::PointerButton::Middle) } else { pointer.primary_down() };- if held {- ui.data_mut(|dd| dd.insert_temp(drag_pos_id(), p));- match d {- Drag::Pan { start, center, .. } => {- let ppp = ui.ctx().pixels_per_point();- if let Some(vm) = app.view_mut() {- vm.center = center;- pan_pixels(vm, ppp, whole_pixels(p - start, ppp));- }- }- Drag::RotateView { start_angle, start_rot, snaps } => {- let c = rect.center();- let a = (p.y - c.y).atan2(p.x - c.x) as f64;- let mut deg = start_rot + (a - start_angle).to_degrees();- if snaps && m.shift {- deg = (deg / 15.0).round() * 15.0;- }- if let Some(vm) = app.view_mut() {- vm.rotation = vectorcraft_geom::normalize_deg(deg);- }- }- Drag::ZoomBox { start } => marquee(ui.painter(), egui::Rect::from_two_pos(start, p)),- Drag::ZoomScrub { start, held, moved } => {- let dt = ui.input(|i| i.unstable_dt).min(0.25);- let (held, moved) = (held + dt, moved || (p - start).length() > SCRUB_SLOP);- // Dragged sideways it zooms with the pointer, held still it zooms on (Alt: out).- let exponent = if moved {- f64::from(pointer.delta().x) * SCRUB_ZOOM- } else if held > HOLD_DELAY {- f64::from(dt) * HOLD_ZOOM * if m.alt { -1.0 } else { 1.0 }- } else {- 0.0- };- if exponent != 0.0- && let Some(vm) = app.view_mut()- {- zoom_about(vm, rect, start, vm.zoom * exponent.exp());- }- ui.data_mut(|dd| dd.insert_temp(drag_id(), Drag::ZoomScrub { start, held, moved }));- }- // Without a pointer it is over a floating panel's own OS window (`drag_art_out`).- Drag::Art if pointer.has_pointer() && on_canvas(ui, resp, p) => {- // Back on the canvas: the move goes on from where it left, with the pointer.- egui::DragAndDrop::clear_payload(ui.ctx());- let ev =- PointerEvent { kind: PointerKind::Drag, pos: xf.to_doc(p), mods: mods(m, space), pressure: pen_pressure(ui, app, false) };- dispatch(app, &ev, view);- ui.data_mut(|dd| {- dd.insert_temp(drag_id(), Drag::Tool);- dd.insert_temp(drag_pos_id(), p);- });- }- Drag::Art | Drag::Gesture | Drag::Present => {}- Drag::Tool if drag_art_out(app, ui, resp, p) => {- ui.data_mut(|dd| dd.insert_temp(drag_id(), Drag::Art));- }- Drag::Tool => {- // Every position the pen or mouse passed this frame, not just the last, for a- // tool that builds a stroke from them: a fast stroke keeps its curve (a pen or a- // mouse reports far more often than frames come). Touch events (a pen on Windows- // or the web, a finger) and a macOS pen's moves carry their own pressure; a- // mouse's, a pen's on X11 among them, take the host's latest. Other tools get- // the last position only, so a costly drag preview runs once a frame.- let moves = tool_frame_moves(ui, app);- // A frame whose pointer ends where the last one did still moved in between.- if tool_drag_moved(ui, &xf, p, &pointer) || !moves.is_empty() {- for (at, force) in moves {- let pressure = force.unwrap_or_else(|| pen_pressure(ui, app, false));- dispatch(app, &PointerEvent { kind: PointerKind::Drag, pos: xf.to_doc(at), mods: mods(m, space), pressure }, view);- }- let ev =- PointerEvent { kind: PointerKind::Drag, pos: xf.to_doc(p), mods: mods(m, space), pressure: pen_pressure(ui, app, false) };- dispatch(app, &ev, view);- }- // Time held (Twirl, Pucker and Bloat keep applying); a stalled frame counts- // a quarter second at most.- if app.session.tool_wants_ticks() {- let dt = f64::from(ui.input(|i| i.unstable_dt).min(0.25));- let r = app.session.tool_tick(dt, view);- apply_requests(app, r);- }- }- }- } else {- // The last position the tool's drag got: none if the press never dragged.- let last_drag: Option<Point> = ui.data(|dd| dd.get_temp(tool_drag_doc_id()));- ui.data_mut(|dd| {- dd.remove::<Drag>(drag_id());- dd.remove::<Pos2>(drag_pos_id());- dd.remove::<Point>(tool_drag_doc_id());- dd.remove::<Point>(tool_press_doc_id());- });- match d {- Drag::ZoomBox { start } => {- let r = egui::Rect::from_two_pos(start, p);- if let Some(vm) = app.view_mut() {- if r.width() > 8.0 && r.height() > 8.0 {- // The marquee's center and its size on screen set the view, at any rotation.- vm.center = xf.to_doc(r.center());- let fill = (rect.width() / r.width()).min(rect.height() / r.height());- vm.zoom = (xf.zoom * f64::from(fill)).clamp(0.0313, 640.0);- } else {- zoom_about(vm, rect, p, crate::state::next_zoom(vm.zoom, !m.alt));- }- }- }- // A click (not held, not dragged) steps the zoom as with the marquee.- Drag::ZoomScrub { held, moved: false, .. } if held <= HOLD_DELAY => {- if let Some(vm) = app.view_mut() {- zoom_about(vm, rect, p, crate::state::next_zoom(vm.zoom, !m.alt));- }- }- Drag::ZoomScrub { .. } => {}- Drag::Tool => {- // The second click of a double-click: don't fit another artboard on this release.- // A double-click on an object does not open Artboard Options. Empty artboard- // space still does.- if resp.double_clicked() && app.session.tool_id() == "artboard" {- app.session.set_tool_option("suppressFitClick", &json!(true));- }- // A move that came in the release's own frame shapes the preview first: the- // tools commit the last preview, which should be where the pointer let go- // (#834). Only once the press has dragged, so a click's jitter stays a click- // (the Pen's corner anchor, no nudge with Direct Selection).- if let Some(last) = last_drag- && last != xf.to_doc(p)- {- let ev =- PointerEvent { kind: PointerKind::Drag, pos: xf.to_doc(p), mods: mods(m, space), pressure: pen_pressure(ui, app, false) };- dispatch(app, &ev, view);- }- let ev = PointerEvent { kind: PointerKind::Up, pos: xf.to_doc(p), mods: mods(m, space), pressure: pen_pressure(ui, app, false) };- dispatch(app, &ev, view);- }- Drag::Art if on_canvas(ui, resp, p) => {- // Came back to the canvas and released in one frame: finish the move here.- egui::DragAndDrop::clear_payload(ui.ctx());- let pressure = pen_pressure(ui, app, false);- let pos = xf.to_doc(p);- dispatch(app, &PointerEvent { kind: PointerKind::Drag, pos, mods: mods(m, space), pressure }, view);- dispatch(app, &PointerEvent { kind: PointerKind::Up, pos, mods: mods(m, space), pressure }, view);- }- Drag::Art => {- // Released over a panel: the move goes back. (The app ends it before the panels- // see the release, so a panel can take the art; this is the headless path.)- // With no document open there is nothing to roll back; the tool still gets its up.- let _ = app.session.cancel_interaction();- dispatch(app, &PointerEvent { kind: PointerKind::Up, pos: Point::ZERO, mods: Mods::default(), pressure: 1.0 }, view);- }- Drag::Gesture | Drag::Present => {}- Drag::Pan { .. } | Drag::RotateView { .. } => {}- }- }- } else if let Some(p) = hover_tool- && (pointer.is_moving() || mods_changed || !was_over || tool_switched || (context_changed && app.session.tool_wants_rehover()))- {- let ev = PointerEvent { kind: PointerKind::Move, pos: xf.to_doc(p), mods: mods(m, space), pressure: 1.0 };- dispatch(app, &ev, view);- }- // The pointer left the canvas (for a panel, or out of the window) or went under a floating- // panel, menu, popup or dialog, with no press the tool holds: the tool's hover ends, which no- // hover event would clear (Alt's Distance Guides).- if was_over && hover_tool.is_none() && !drag.is_some_and(tool_holds) {- app.session.tool_hover_ended(view);- ui.ctx().request_repaint();- }- // The tool works on another thread (a large selection's planar map): it checks each frame- // whether the work is done, and then shows the highlight under the pointer.- if app.session.tool_waiting() {- if let Err(e) = app.session.tool_poll(view, false) {- app.status(e.to_string());- }- ui.ctx().request_repaint_after(std::time::Duration::from_millis(16));- }- if pointer.primary_released()- && let Some(i) = ui.data_mut(|d| d.remove_temp::<usize>(name_press_id()))- {- select_named_artboard(app, i);- }- if resp.double_clicked()- && let Some(p) = at- {- if let Some(i) = artboard_name_at(app, ui, &xf, p) {- begin_artboard_name_edit(ui, app, i);- } else {- let ev = PointerEvent { kind: PointerKind::DoubleClick, pos: xf.to_doc(p), mods: mods(m, space), pressure: 1.0 };- let before = app.session.tool_id().to_string();- dispatch(app, &ev, view);- // A double-click on type switched a selection tool to the Type tool: the caret goes where- // the type was clicked, so typing edits it at once.- if before != "type" && app.session.tool_id() == "type" {- app.session.set_tool_option("prevTool", &json!(before));- for kind in [PointerKind::Down, PointerKind::Up] {- dispatch(app, &PointerEvent { kind, ..ev }, view);- }- }- }- }- if drag.is_some() || pointer.is_moving() || mods_changed {- ui.ctx().request_repaint();- }-}--/// How much one point of wheel motion zooms (as `exp(points × WHEEL_ZOOM)`).-const WHEEL_ZOOM: f64 = 0.01;-/// How fast a wheel notch's zoom glides in with Zoom with Mouse Wheel: the time constant (s) of-/// the part still to come.-const WHEEL_GLIDE: f64 = 0.05;--/// What the wheel did across frames ([`wheel`]).-#[derive(Clone, Copy, Debug, Default, PartialEq)]-struct WheelTurn {- /// The last wheel turn was an Alt-wheel one.- alt: bool,- /// The zoom (natural log) wheel notches still have to glide in.- glide: f64,-}-/// Animated Zoom: how much one point of sideways drag zooms (100 points to the right double it).-const SCRUB_ZOOM: f64 = std::f64::consts::LN_2 / 100.0;-/// Animated Zoom: how far the pointer moves before a press is a drag, in points.-const SCRUB_SLOP: f32 = 3.0;-/// Animated Zoom: how long a press is held still before it zooms on, in seconds…-const HOLD_DELAY: f32 = 0.3;-/// …and how fast it zooms then (as `exp(seconds × HOLD_ZOOM)`: twice as close each second).-const HOLD_ZOOM: f64 = std::f64::consts::LN_2;--/// Performance › Animated Zoom, which needs GPU Performance as in Illustrator: the Zoom tool zooms-/// as it is dragged sideways or held, instead of zooming to the area dragged across.-pub(crate) fn animated_zoom(p: &vectorcraft_engine::Prefs) -> bool {- p.animated_zoom && p.gpu_performance-}--/// Zoom for View → Actual Size (`view.actualSize`). With Preferences › General › Display Print-/// Size at 100% Zoom off, one document point is one screen point. On, one document inch (72 pt)-/// fills an inch of the screen as the system counts it: 96 screen points, the reference density-/// that display scaling is set against (a CSS inch), whatever the scale factor.-pub(crate) fn actual_size_zoom(display_print_size: bool) -> f64 {- if display_print_size { 96.0 / 72.0 } else { 1.0 }-}--/// Zoom view `vm` of the canvas `rect` to `zoom` (clamped to the zoom range), keeping the document-/// point under screen point `p` where it is.-fn zoom_about(vm: &mut View, rect: egui::Rect, p: Pos2, zoom: f64) {- let before = Xf::new(rect, vm).to_doc(p);- vm.zoom = zoom.clamp(0.0313, 640.0);- vm.center += before - Xf::new(rect, vm).to_doc(p);-}--/// Turn view `vm` of the canvas `rect` by `degrees` clockwise, keeping the document point under-/// screen point `p` where it is.-fn rotate_about(vm: &mut View, rect: egui::Rect, p: Pos2, degrees: f64) {- let before = Xf::new(rect, vm).to_doc(p);- vm.rotation = vectorcraft_geom::normalize_deg(vm.rotation + degrees);- vm.center += before - Xf::new(rect, vm).to_doc(p);-}--/// Move view `vm`'s content by `(dx, dy)` device pixels along the screen's axes, at `ppp` device-/// pixels a point: the canvas's frame moves by exactly those pixels.-fn pan_pixels(vm: &mut View, ppp: f32, (dx, dy): (f64, f64)) {- let (sn, cs) = vm.rotation.to_radians().sin_cos();- let k = vm.zoom * f64::from(ppp);- vm.center -= vectorcraft_geom::Vec2::new((dx * cs + dy * sn) / k, (-dx * sn + dy * cs) / k);-}--/// Screen points `d` in the nearest whole device pixels, at `ppp` device pixels a point.-fn whole_pixels(d: egui::Vec2, ppp: f32) -> (f64, f64) {- ((f64::from(d.x) * f64::from(ppp)).round(), (f64::from(d.y) * f64::from(ppp)).round())-}--/// What the scrolls of the view have left to move ([`scroll_view`]).-#[derive(Clone, Copy, Debug, Default, PartialEq)]-struct ScrollRest {- /// Device pixels along the screen's axes, at most half a pixel each.- x: f64,- y: f64,- /// The document, the view's center, zoom and rotation, and the device pixels a point that the- /// last scroll left.- after: Option<(u64, Point, f64, f64, f32)>,-}--/// Scroll the active view so that its content moves `by` screen points (the wheel, a trackpad, a-/// touch screen, a scroll bar), in whole device pixels: the part of a pixel left over is added to-/// the next scroll. It is dropped when the view changed in between (a zoom, a turn, Fit, a pan-/// of another kind, another document) or the device pixels a point did.-fn scroll_view(app: &mut VectorcraftApp, ui: &Ui, by: egui::Vec2) {- let ppp = ui.ctx().pixels_per_point();- let Some(doc) = app.session.active().map(|st| st.uid) else { return };- let Some(vm) = app.view_mut() else { return };- let id = egui::Id::unique("canvas-scroll-rest");- let rest = scroll_by(vm, doc, ppp, by, ui.data(|d| d.get_temp(id)).unwrap_or_default());- ui.data_mut(|d| d.insert_temp(id, rest));-}--/// [`scroll_view`] for view `vm` of document `doc` at `ppp` device pixels a point, after the-/// scrolls that left `rest`: what this scroll leaves.-fn scroll_by(vm: &mut View, doc: u64, ppp: f32, by: egui::Vec2, rest: ScrollRest) -> ScrollRest {- let (x, y) = if rest.after == Some((doc, vm.center, vm.zoom, vm.rotation, ppp)) { (rest.x, rest.y) } else { (0.0, 0.0) };- let (x, y) = (x + f64::from(by.x) * f64::from(ppp), y + f64::from(by.y) * f64::from(ppp));- let (dx, dy) = (x.round(), y.round());- pan_pixels(vm, ppp, (dx, dy));- ScrollRest { x: x - dx, y: y - dy, after: Some((doc, vm.center, vm.zoom, vm.rotation, ppp)) }-}--/// How far a trackpad rotation turns before it turns the view, in degrees.-const ROTATE_DEAD_ZONE: f64 = 5.0;-/// How long after its last rotation event a trackpad rotation ends, in seconds.-const ROTATE_GESTURE_END: f64 = 0.25;--/// A trackpad rotation under way ([`trackpad_turn`]).-#[derive(Clone, Copy, Debug)]-struct TrackpadTurn {- /// Degrees it has turned so far, clockwise.- total: f64,- /// When its last rotation event came (egui's input time, in seconds).- last: f64,- /// It has reached [`ROTATE_DEAD_ZONE`] and turns the view.- turning: bool,-}--/// General › Trackpad Gesture to Rotate View (`on`): the degrees, clockwise, that a two-finger-/// rotation on a Mac trackpad turns the view this frame. egui sends the rotation as-/// [`egui::Event::Rotate`], from winit on macOS and from Safari's gesture events in the web build.-/// A rotation does not turn the view until it reaches [`ROTATE_DEAD_ZONE`]; it then turns the view-/// by all of it, and by each later event as it comes. It ends [`ROTATE_GESTURE_END`] after its last-/// event. Rotation events that come while fingers are on a touch screen do not turn the view.-fn trackpad_turn(ui: &Ui, on: bool) -> Option<f64> {- if !on {- return None;- }- let (deg, now) = ui.input(|i| {- let rad: f32 =- if i.multi_touch().is_some() { 0.0 } else { i.events.iter().map(|e| if let egui::Event::Rotate(r) = e { *r } else { 0.0 }).sum() };- (f64::from(rad).to_degrees(), i.time)- });- if deg == 0.0 || !deg.is_finite() {- return None;- }- let id = egui::Id::unique("canvas-trackpad-turn");- let kept: Option<TrackpadTurn> = ui.data(|d| d.get_temp(id));- let mut t = kept.filter(|t| now - t.last <= ROTATE_GESTURE_END).unwrap_or(TrackpadTurn { total: 0.0, last: now, turning: false });- t.total += deg;- t.last = now;- let turn = if t.turning {- Some(deg)- } else if t.total.abs() >= ROTATE_DEAD_ZONE {- t.turning = true;- Some(t.total)- } else {- None- };- ui.data_mut(|d| d.insert_temp(id, t));- turn-}--/// One scroll bar along its axis, in screen points: the span it scrolls over (`lo..hi`) and the-/// part of it the canvas shows (`v0..v1`).-#[derive(Clone, Copy, Debug, PartialEq)]-struct Span {- lo: f32,- hi: f32,- v0: f32,- v1: f32,-}--impl Span {- /// The thumb on a track `len` long: where it starts and how long it is.- fn thumb(self, len: f32) -> (f32, f32) {- let total = (self.hi - self.lo).max(1.0);- let size = (len * (self.v1 - self.v0) / total).clamp(MIN_THUMB.min(len), len);- let room = total - (self.v1 - self.v0);- let at = if room > 0.0 { (self.v0 - self.lo) / room * (len - size) } else { 0.0 };- (at.clamp(0.0, (len - size).max(0.0)), size)- }- /// Screen points the view moves for each point the thumb moves on a track `len` long.- fn ratio(self, len: f32) -> f32 {- let room = (self.hi - self.lo) - (self.v1 - self.v0);- let free = len - self.thumb(len).1;- if room > 0.0 && free > 0.0 { room / free } else { 0.0 }- }-}--const MIN_THUMB: f32 = 20.0;--/// The scroll bars' spans, horizontal then vertical: the art and the artboards (`content`) as the-/// view turns them on screen, half a window past each side, and the view itself, so the thumb is-/// always on its track. The canvas has no edge of its own (no drawing area), so the content sets it.-fn scroll_spans(xf: &Xf, content: Option<Rect>) -> [Span; 2] {- let r = xf.rect;- let around = content.map(|c| egui::Rect::from_points(&xf.quad(c)).expand2(r.size() / 2.0)).filter(|b| b.is_finite());- let b = around.map_or(r, |b| b.union(r));- [Span { lo: b.left(), hi: b.right(), v0: r.left(), v1: r.right() }, Span { lo: b.top(), hi: b.bottom(), v0: r.top(), v1: r.bottom() }]-}--/// The tracks of the horizontal and the vertical scroll bar, along the bottom and the right edge-/// of the window (`outer`), as long as the canvas (`rect`) beside them.-fn scroll_tracks(rect: egui::Rect, outer: egui::Rect) -> [egui::Rect; 2] {- let corner = outer.max - vec2(SCROLL_BAR, SCROLL_BAR);- [- egui::Rect::from_min_max(pos2(rect.left(), corner.y), pos2(corner.x, outer.bottom())),- egui::Rect::from_min_max(pos2(corner.x, rect.top()), pos2(outer.right(), corner.y)),- ]-}--/// The window's scroll bars ([`scroll_spans`]): a thumb dragged scrolls the view along the-/// screen's axis (a turned view too), a click on the track pages towards it, and the wheel over a-/// bar scrolls along it.-fn scroll_bars(app: &mut VectorcraftApp, ui: &Ui, rect: egui::Rect, outer: egui::Rect, t: &Tokens) {- let content = app.content_bounds();- let Some(v) = app.view().copied() else { return };- let xf = Xf::new(rect, &v);- let painter = ui.painter();- painter.rect_filled(egui::Rect::from_min_max(outer.max - vec2(SCROLL_BAR, SCROLL_BAR), outer.max), 0.0, t.ruler);- let hover = ui.input(|i| i.pointer.hover_pos());- // Screen points the view moves this frame, or the center a dragged thumb's drag began at and- // the screen points it has moved the view since.- let mut moved = egui::Vec2::ZERO;- let mut center = None;- for (k, (track, span)) in scroll_tracks(rect, outer).into_iter().zip(scroll_spans(&xf, content)).enumerate() {- let horizontal = k == 0;- let along = |p: Pos2| if horizontal { p.x - track.left() } else { p.y - track.top() };- let axis = if horizontal { vec2(1.0, 0.0) } else { vec2(0.0, 1.0) };- let len = if horizontal { track.width() } else { track.height() };- let (at, size) = span.thumb(len);- let on_thumb = |p: Pos2| (at..=at + size).contains(&along(p));- let id = egui::Id::unique(("canvas-scroll-bar", k));- let resp = ui.interact(track, id, Sense::click_and_drag());- if resp.drag_started()- && let Some(p) = ui.input(|i| i.pointer.press_origin())- && on_thumb(p)- {- // The span moves with the view: the drag keeps the one it started with.- let d = ThumbDrag { from: along(p), center: v.center, ratio: span.ratio(len), min: span.lo - span.v0, max: span.hi - span.v1 };- ui.data_mut(|dd| dd.insert_temp(id, d));- }- let drag: Option<ThumbDrag> = ui.data(|dd| dd.get_temp(id));- if let Some(d) = drag {- if resp.dragged()- && let Some(p) = resp.interact_pointer_pos()- {- let by = ((along(p) - d.from) * d.ratio).clamp(d.min, d.max);- center = Some((d.center, axis * by));- }- if !resp.dragged() || resp.drag_stopped() {- ui.data_mut(|dd| dd.remove::<ThumbDrag>(id));- }- } else if resp.clicked()- && let Some(p) = resp.interact_pointer_pos()- {- // A page is most of the window, and never past the end of the span.- let page = 0.9 * (span.v1 - span.v0);- if along(p) < at {- moved -= axis * page.min(span.v0 - span.lo);- } else if along(p) > at + size {- moved += axis * page.min(span.hi - span.v1);- }- }- if resp.hovered() {- let d = ui.input(|i| i.smooth_scroll_delta);- moved -= axis * if horizontal { d.x + d.y } else { d.y };- }- painter.rect_filled(track, 0.0, t.ruler);- let edge = if horizontal { [track.left_top(), track.right_top()] } else { [track.left_top(), track.left_bottom()] };- painter.line_segment(edge, Stroke::new(1.0, t.border));- let thumb = if horizontal {- egui::Rect::from_min_size(pos2(track.left() + at, track.top()), vec2(size, track.height())).shrink2(vec2(1.0, 3.0))- } else {- egui::Rect::from_min_size(pos2(track.left(), track.top() + at), vec2(track.width(), size)).shrink2(vec2(3.0, 1.0))- };- let hot = drag.is_some() || hover.is_some_and(|p| thumb.contains(p));- painter.rect_filled(thumb, CornerRadius::same(3), if hot { t.text_dim } else { t.text_disabled });- }- let ppp = ui.ctx().pixels_per_point();- if let Some((c, by)) = center- && let Some(vm) = app.view_mut()- {- vm.center = c;- pan_pixels(vm, ppp, whole_pixels(-by, ppp));- }- if moved != egui::Vec2::ZERO {- scroll_view(app, ui, -moved);- }-}--/// A scroll bar thumb being dragged: where along the track it was pressed, and the view's centre,-/// the span's travel ratio ([`Span::ratio`]) and how far the view could move either way then.-#[derive(Clone, Copy, Debug)]-struct ThumbDrag {- from: f32,- center: Point,- ratio: f32,- min: f32,- max: f32,-}--/// A marquee around screen rectangle `r`: dark dashes over a light line, so it shows on a white-/// artboard and on the grey pasteboard alike (#725).-fn marquee(p: &egui::Painter, r: egui::Rect) {- marquee_through(p, &[r.left_top(), r.right_top(), r.right_bottom(), r.left_bottom()]);-}--/// A [`marquee`] through the screen corners `q` in turn, back to the first: a document rectangle's-/// [`Xf::quad`] in a rotated view.-fn marquee_through(p: &egui::Painter, q: &[Pos2]) {- let pts: Vec<Pos2> = q.iter().chain(q.first()).copied().collect();- p.add(Shape::line(pts.clone(), Stroke::new(1.0, Color32::from_white_alpha(230))));- for w in pts.windows(2) {- p.extend(Shape::dashed_line(&[w[0], w[1]], Stroke::new(1.0, Color32::from_gray(40)), 3.0, 3.0));- }-}--/// What the wheel, a pinch and a two-finger drag on a touch screen did over the canvas this frame:-/// a zoom factor (about the pointer) and a scroll (screen points the content moves). The wheel scrolls, Cmd- and Alt-wheel (Option-/// on the Mac) zoom. With General › Zoom with Mouse Wheel (`wheel_zooms`) the wheel and Alt-wheel-/// zoom, Shift-wheel scrolls up and down and Cmd/Ctrl-wheel sideways. `line` and `page`: points-/// per wheel line and page. `turn`: kept by the caller across frames. A mouse wheel's notches zoom-/// in a glide over a few frames, as scrolling does (#888); a trackpad's fine steps at once.-fn wheel(i: &egui::InputState, wheel_zooms: bool, line: f32, page: f32, turn: &mut WheelTurn) -> (f64, egui::Vec2) {- // Fingers on a touch screen pan the content with them (a trackpad sends scrolls instead).- let pan = i.multi_touch().map_or(egui::Vec2::ZERO, |t| t.translation_delta);- if !wheel_zooms {- // egui makes Cmd-wheel (and a pinch) its zoom and the rest a scroll it spreads over a few- // frames: the rest of an Alt-wheel turn zooms too, however soon Alt is let go.- if let Some(m) = i.events.iter().rev().find_map(|e| if let egui::Event::MouseWheel { modifiers, .. } = e { Some(modifiers) } else { None }) {- turn.alt = m.alt && !m.command;- }- let (zoom, scroll) = (f64::from(i.zoom_delta()), i.smooth_scroll_delta);- return if turn.alt && scroll != egui::Vec2::ZERO {- (zoom * (f64::from(scroll.x + scroll.y) * WHEEL_ZOOM).exp(), pan)- } else {- (zoom, scroll + pan)- };- }- // The wheel events themselves: egui's own handling turns Cmd-wheel into a zoom.- let mut zoom = i.multi_touch().map_or(1.0, |t| f64::from(t.zoom_delta));- let mut scroll = pan;- for e in &i.events {- match e {- egui::Event::MouseWheel { unit, delta, modifiers, .. } => {- let d = match unit {- egui::MouseWheelUnit::Point => *delta,- egui::MouseWheelUnit::Line => *delta * line,- egui::MouseWheelUnit::Page => *delta * page,- };- if modifiers.command {- scroll.x += d.x + d.y;- } else if modifiers.shift {- scroll.y += d.x + d.y;- } else if *unit == egui::MouseWheelUnit::Point {- zoom *= (f64::from(d.y) * WHEEL_ZOOM).exp();- scroll.x += d.x;- } else {- turn.glide += f64::from(d.y) * WHEEL_ZOOM;- scroll.x += d.x;- }- }- egui::Event::Zoom(f) => zoom *= f64::from(*f),- _ => {}- }- }- // This frame's part of the glide: what is left shrinks by e every WHEEL_GLIDE seconds.- let part = if turn.glide.abs() < 1e-3 { 1.0 } else { 1.0 - (-f64::from(i.stable_dt.min(0.1)) / WHEEL_GLIDE).exp() };- let step = turn.glide * part;- turn.glide -= step;- (zoom * step.exp(), scroll)-}--/// Enable Touch Gestures: this frame's finger contacts on the canvas ([`crate::touch`]). A second-/// finger drops the press the first one began (its tool interaction rolled back; the rest of the-/// gesture presses nothing), and a tap of two fingers undoes, one of three redoes.-fn touch_gestures(app: &mut VectorcraftApp, ui: &Ui, rect: egui::Rect, view: vectorcraft_engine::ViewInfo) {- if !app.session.prefs.touch_gestures {- return;- }- let (touches, now): (Vec<_>, f64) = ui.input(|i| {- let t = i.events.iter().filter_map(|e| match e {- egui::Event::Touch { id, phase, pos, .. } => Some((*id, *phase, *pos)),- _ => None,- });- (t.collect(), i.time)- });- if touches.is_empty() {- return;- }- let key = egui::Id::unique("canvas-touch");- let mut taps: crate::touch::Taps = ui.data(|d| d.get_temp(key)).unwrap_or_default();- let mut tap = None;- for (id, phase, pos) in touches {- // A gesture begins on the canvas.- if phase == egui::TouchPhase::Start && !taps.is_down() && !rect.contains(pos) {- continue;- }- // A cancelled contact (a palm the shell drops when a pen lands) keeps nothing it began.- if phase == egui::TouchPhase::Cancel {- drop_press(app, ui, view);- }- match taps.feed(id, phase, pos, now) {- Some(crate::touch::Touch::Fingers) => {- drop_press(app, ui, view);- ui.data_mut(|d| d.insert_temp(drag_id(), Drag::Gesture));- }- Some(crate::touch::Touch::Tap(n)) => tap = crate::touch::tap_command(n),- None => {}- }- }- ui.data_mut(|d| d.insert_temp(key, taps));- // In Presentation Mode a tap of two or three fingers undoes or redoes nothing.- if let Some(cmd) = tap- && app.ui.screen_mode < 3- {- crate::menus::invoke(app, cmd, serde_json::json!({}));- }-}--/// Drop the tool press in progress, if any: nothing it began is kept, and the rest of the press-/// does nothing ([`Drag::Gesture`]).-fn drop_press(app: &mut VectorcraftApp, ui: &Ui, view: vectorcraft_engine::ViewInfo) {- match ui.data(|d| d.get_temp::<Drag>(drag_id())) {- Some(Drag::Tool | Drag::Art) => {- // The tool's mouse-up returns it to rest. A move waiting over a panel is still live- // and would otherwise outlive the drag that owns it (#2826).- // Nothing to roll back without a document; the tool still gets its mouse-up.- let _ = app.session.cancel_interaction();- dispatch(app, &PointerEvent { kind: PointerKind::Up, pos: Point::ZERO, mods: Mods::default(), pressure: 1.0 }, view);- egui::DragAndDrop::clear_payload(ui.ctx());- }- Some(_) => {}- None => return,- }- ui.data_mut(|d| d.insert_temp(drag_id(), Drag::Gesture));-}--/// A Selection tool move dragged off the canvas (to `p`, over a panel) becomes a panel drag of-/// the selected art ([`widgets::PanelDrag::Art`]): the art waits where it last moved on the-/// canvas, and a panel it is released on takes it (the Graphic Styles panel makes a style of it).-/// Back on the canvas, [`Drag::Art`] takes the move up again where the pointer is (#2826).-fn drag_art_out(app: &VectorcraftApp, ui: &Ui, resp: &egui::Response, p: Pos2) -> bool {- let Some(st) = app.session.active().filter(|_| app.session.tool_id() == "selection") else { return false };- // The Selection tool's interaction while it moves (or Alt-copies) the selection.- if !st.interaction.as_ref().is_some_and(|i| i.label == "Move" || i.label == "Copy") {- return false;- }- // A floating panel in an OS window of its own takes the art too: craft-ui hands that window- // the pointer while it is over it, and this window sees the pointer go.- craft_ui::docking::route_app_drag(ui.ctx(), crate::panel_docking::area_id());- if on_canvas(ui, resp, p) && ui.input(|i| i.pointer.has_pointer()) {- return false;- }- let ids = st.selection.objects.clone();- egui::DragAndDrop::set_payload(ui.ctx(), widgets::PanelDrag::Art(ids));- true-}--/// A Selection tool move released over a panel: end it before the panels see the release, so a-/// panel that takes the art ([`widgets::PanelDrag::Art`]) takes it where it was, and no move is-/// left open (#2826). The art stays where it last moved while the pointer is over the panel.-pub(crate) fn release_over_panel(app: &mut VectorcraftApp, ctx: &egui::Context) {- crate::document_drag::cleanup(app, ctx);- let art = matches!(ctx.data(|d| d.get_temp::<Drag>(drag_id())), Some(Drag::Art));- // Over a floating panel's own OS window the pointer is gone from this window, and the release- // comes here later, at a point of this window that may lie on the canvas: that panel takes it.- let gone_id = drag_id().with("art-gone");- if !ctx.input(|i| i.pointer.primary_released()) {- if art {- let gone = ctx.input(|i| !i.pointer.has_pointer());- ctx.data_mut(|d| d.insert_temp(gone_id, gone));- }- return;- }- let gone = ctx.data_mut(|d| d.remove_temp::<bool>(gone_id)).unwrap_or(false);- let p = ctx.input(|i| i.pointer.interact_pos().or(i.pointer.latest_pos()));- if !art {- return;- }- let layer = ctx.data(|d| d.get_temp::<egui::LayerId>(drag_layer_id()));- let on = !gone && p.is_some_and(|p| app.canvas_rect.is_some_and(|r| r.contains(p)) && ctx.layer_id_at(p).is_none_or(|l| Some(l) == layer));- if on {- // The canvas's release finishes the move.- return;- }- end_art_move(app, ctx);-}--/// A release in a floating panel's own OS window, during an art drag from the canvas: the move-/// ends before that panel takes the art. The main window would only see it on its next pass.-pub(crate) fn release_art_in_window(app: &mut VectorcraftApp, ctx: &egui::Context) {- let art = matches!(ctx.data(|d| d.get_temp::<Drag>(drag_id())), Some(Drag::Art));- if art && ctx.input(|i| i.pointer.primary_released()) {- end_art_move(app, ctx);- }-}--/// Roll back the art move dragged off the canvas; a panel takes the art instead.-fn end_art_move(app: &mut VectorcraftApp, ctx: &egui::Context) {- // With no document open there is nothing to roll back; the tool still gets its mouse-up.- let _ = app.session.cancel_interaction();- let view = app.view_info();- dispatch(app, &PointerEvent { kind: PointerKind::Up, pos: Point::ZERO, mods: Mods::default(), pressure: 1.0 }, view);- ctx.data_mut(|d| {- d.remove::<Drag>(drag_id());- d.remove::<bool>(drag_id().with("art-gone"));- });-}--/// Send a pointer event to the active tool and act on UI requests (dialogs, tool switches).-pub fn dispatch(app: &mut VectorcraftApp, ev: &PointerEvent, view: vectorcraft_engine::ViewInfo) {- let r = app.session.pointer(ev, view);- // The artboard the Artboard tool makes active is the active one (the navigator's, the- // Artboards panel's).- if app.session.tool_id() == "artboard"- && let Some(i) = app.session.tool_options()["active"].as_u64().and_then(|i| usize::try_from(i).ok())- && let Some(v) = app.view_mut()- {- v.artboard = i;- }- // A press with a selection tool inside an artboard makes it the active one (#693), as the- // Artboard tool's does: Paste in Place and in Front or Back then paste onto it, Align to- // Artboard aligns to it, and All on Active Artboard selects on it.- if ev.kind == PointerKind::Down- && vectorcraft_tools::catalog::is_selection_tool(app.session.tool_id())- && let Some(i) = app.session.active().and_then(|d| d.doc.artboard_at(ev.pos))- && let Some(v) = app.view_mut()- {- v.artboard = i;- }- apply_requests(app, r);-}--/// Act on what a tool event asked the UI for (dialogs, tool switches), or show its error.-pub fn apply_requests(app: &mut VectorcraftApp, r: vectorcraft_engine::Result<Vec<vectorcraft_engine::UiRequest>>) {- match r {- Ok(reqs) => {- for r in reqs {- match r {- vectorcraft_engine::UiRequest::Dialog(kind, p) => crate::dialogs::open_tool_dialog(app, &kind, p),- vectorcraft_engine::UiRequest::SwitchTool(t) => app.select_tool(&t),- vectorcraft_engine::UiRequest::Status(msg) => app.status(msg),- vectorcraft_engine::UiRequest::Place(p) => crate::place::place_from_cursor(app, &p),- }- }- }- Err(e) => app.status(e.to_string()),- }-}--/// The transparency grid's 2 × 2-cell tile in the document's colours (Document Setup), cached per-/// look, and its cell size in screen points.-pub(crate) fn checker_texture(ctx: &egui::Context, setup: &vectorcraft_doc::DocSetup) -> (egui::TextureHandle, f32) {- let colors = setup.grid_colors.map(|c| crate::panels::c32(&c));- let id = egui::Id::unique("transparency-grid-tile");- let cached = ctx.data(|d| d.get_temp::<([Color32; 2], egui::TextureHandle)>(id)).filter(|(c, _)| *c == colors);- let tex = cached.map(|(_, t)| t).unwrap_or_else(|| {- let [a, b] = colors;- let img = egui::ColorImage::new([2, 2], vec![a, b, b, a]);- let opts = egui::TextureOptions { wrap_mode: egui::TextureWrapMode::Repeat, ..egui::TextureOptions::NEAREST };- let t = ctx.load_texture(TRANSPARENCY_GRID, img, opts);- ctx.data_mut(|d| d.insert_temp(id, (colors, t.clone())));- t- });- (tex, setup.grid_size.cell())-}--/// Name of the transparency grid's texture.-pub(crate) const TRANSPARENCY_GRID: &str = "transparency grid";--/// The transparency grid over the artboard `ab` (screen corners `quad`): one textured quad whose-/// cells stay `cell` screen points at every zoom and turn with a rotated view.-fn checker(p: &egui::Painter, quad: &[Pos2], ab: Rect, zoom: f64, tex: egui::TextureId, cell: f32) {- // Two cells per texture repeat.- let per = (2.0 * cell as f64 / zoom).max(1e-9);- textured_quad(p, tex, quad, ((ab.width() / per) as f32, (ab.height() / per) as f32));-}--/// One quad drawn with `tex`: its corners `quad` (from the top left, clockwise) show the texture-/// from (0, 0) to (`u`, `v`).-fn textured_quad(p: &egui::Painter, tex: egui::TextureId, quad: &[Pos2], (u, v): (f32, f32)) {- let mut mesh = egui::Mesh::with_texture(tex);- for (pos, uv) in quad.iter().zip([pos2(0.0, 0.0), pos2(u, 0.0), pos2(u, v), pos2(0.0, v)]) {- mesh.vertices.push(egui::epaint::Vertex { pos: *pos, uv, color: Color32::WHITE });- }- mesh.indices.extend([0, 1, 2, 0, 2, 3]);- p.add(Shape::mesh(mesh));-}--/// The zoom the pixel grid shows from in Pixel Preview (600%), and its colour: a translucent grey,-/// so the art's pixels read through it.-const PIXEL_GRID_ZOOM: f64 = 6.0;-const PIXEL_GRID: Color32 = Color32::from_rgba_premultiplied(64, 64, 64, 96);--/// The look of the grid or of the guides (Preferences › Guides & Grid › Color and Style).-#[derive(Clone, Copy)]-struct LineLook {- color: Color32,- dots: bool,-}--impl LineLook {- fn grid(prefs: &vectorcraft_engine::Prefs) -> Self {- Self { color: pref_color(&prefs.grid_color, Color32::from_gray(200)), dots: prefs.grid_style == "dots" }- }-- fn guides(prefs: &vectorcraft_engine::Prefs, t: &Tokens) -> Self {- Self { color: pref_color(&prefs.guide_color, t.guide), dots: prefs.guide_style == "dots" }- }-- /// A guide from `a` to `b`: a line, or dots.- fn guide(self, p: &egui::Painter, a: Pos2, b: Pos2) {- if self.dots {- p.extend(Shape::dotted_line(&[a, b], self.color, 4.0, 0.75));- } else {- p.line_segment([a, b], Stroke::new(1.0, self.color));- }- }-}--/// A `#rrggbb` colour preference, `fallback` when it doesn't parse.-fn pref_color(hex: &str, fallback: Color32) -> Color32 {- vectorcraft_color::Color::from_hex(hex).map_or(fallback, |c| crate::panels::c32(&c))-}--/// The view in document space: the box round the canvas's corners (the view may be rotated).-fn view_bounds(xf: &Xf) -> Rect {- let r = xf.rect;- let corners = [r.left_top(), r.right_top(), r.right_bottom(), r.left_bottom()].map(|c| xf.to_doc(c));- corners.iter().fold(Rect::from_points(corners[0], corners[0]), |b, c| b.union_pt(*c))-}--/// The part of the segment from `a` to `b` inside `r`, none when the segment misses it.-fn clip_segment(a: Pos2, b: Pos2, r: egui::Rect) -> Option<(Pos2, Pos2)> {- let d = b - a;- let (mut t0, mut t1) = (0.0_f32, 1.0_f32);- // Each edge as (the run toward it, the room before it).- for (run, room) in [(-d.x, a.x - r.left()), (d.x, r.right() - a.x), (-d.y, a.y - r.top()), (d.y, r.bottom() - a.y)] {- if run == 0.0 {- if room < 0.0 {- return None;- }- } else if run < 0.0 {- t0 = t0.max(room / run);- } else {- t1 = t1.min(room / run);- }- }- (t0 <= t1).then(|| (a + d * t0, a + d * t1))-}--/// The grid (View → Show Grid): a gridline every `spacing` and `subdiv` lighter lines between-/// (left out when they would crowd). In the Dots style, a dot where gridlines cross the-/// subdivisions instead.-fn grid(p: &egui::Painter, xf: &Xf, spacing: f64, subdiv: u32, look: LineLook) {- // The painter clips to the canvas.- let view = view_bounds(xf);- let sub = spacing / subdiv.max(1) as f64;- let step = if sub * xf.zoom >= 6.0 { sub } else { spacing };- // Dots crowd sooner than lines.- if step * xf.zoom < 4.0 || (look.dots && spacing * xf.zoom < 8.0) {- return;- }- let major = |v: f64| (v / spacing - (v / spacing).round()).abs() < 1e-6;- // The lines across the view (where along their axis), at least 4 px apart (and capped).- let lines = |from: f64, to: f64| {- let first = (from / step).floor();- (0..10_000u32).map(move |i| (first + f64::from(i)) * step).take_while(move |v| *v <= to)- };- if look.dots {- let mut mesh = egui::Mesh::default();- for x in lines(view.x0, view.x1) {- for y in lines(view.y0, view.y1).filter(|y| major(x) || major(*y)) {- mesh.add_colored_rect(egui::Rect::from_center_size(xf.to_screen(Point::new(x, y)), vec2(1.5, 1.5)), look.color);- }- }- p.add(Shape::mesh(mesh));- return;- }- let minor = look.color.gamma_multiply(0.4);- let stroke = |major: bool| Stroke::new(1.0, if major { look.color } else { minor });- for x in lines(view.x0, view.x1) {- p.line_segment([xf.to_screen(Point::new(x, view.y0)), xf.to_screen(Point::new(x, view.y1))], stroke(major(x)));- }- for y in lines(view.y0, view.y1) {- p.line_segment([xf.to_screen(Point::new(view.x0, y)), xf.to_screen(Point::new(view.x1, y))], stroke(major(y)));- }-}--/// A ruler label for `v` (in the ruler's unit) on a ruler whose labels are `step` apart: whole-/// numbers, or the fewest decimals that write `step` exactly, so a binary step keeps its value-/// (an inch ruler's 1/16 reads `0.0625`, not the `0.06` that rounding the step's magnitude gave).-/// How far down the left ruler a label of `chars` characters reaches, counting from its top: it-/// is spelled one character per line, [`RULER_CHAR`] apart, and the last one is a line tall.-pub(crate) fn vertical_label_height(chars: usize) -> f32 {- chars.saturating_sub(1) as f32 * RULER_CHAR + RULER_LINE-}--/// A ruler label's line spacing and line height on the left ruler.-const RULER_CHAR: f32 = 8.5;-const RULER_LINE: f32 = 9.5;--pub(crate) fn ruler_label(v: f64, step: f64) -> String {- let exact = |d: u32| (step * 10f64.powi(d as i32)).fract().abs() < 1e-9;- let decimals = (0..=7).find(|d| exact(*d)).unwrap_or(7) as usize;- let s = format!("{v:.decimals$}");- // Trailing zeros go, as `Unit::number` drops them: a sixteenth-inch ruler labels the inch `1`,- // not `1.0000`, which the vertical ruler would spell down six lines.- let s = if s.contains('.') { s.trim_end_matches('0').trim_end_matches('.') } else { &s };- if s.trim_start_matches('-').chars().all(|c| c == '0' || c == '.') { "0".into() } else { s.into() }-}--/// The rulers, numbered in `unit` (the General unit).-/// The top ruler, the left ruler and the box where they meet.-fn ruler_rects(full: egui::Rect) -> [egui::Rect; 3] {- let top = egui::Rect::from_min_max(pos2(full.left() + RULER, full.top()), pos2(full.right(), full.top() + RULER));- let left = egui::Rect::from_min_max(pos2(full.left(), full.top() + RULER), pos2(full.left() + RULER, full.bottom()));- [top, left, egui::Rect::from_min_size(full.min, vec2(RULER, RULER))]-}--/// A drag from a ruler onto the canvas makes a guide where the button is released (the engine's-/// `Session::ruler_guide`): a horizontal one from the top ruler, a vertical one from the left-/// ruler, snapped as a moved guide is (with Shift to the ruler's ticks). Released anywhere else,-/// it makes none. The corner drags the rulers' origin or resets it on a double-click.-fn ruler_input(app: &mut VectorcraftApp, ui: &Ui, full: egui::Rect, canvas: egui::Rect, xf: &Xf) -> Option<Point> {- let [top, left, corner] = ruler_rects(full);- // Right-click on a ruler or the origin box: the document units, to swap between them as- // Preferences ▸ Units ▸ General does ([`crate::menus::ruler_menu_body`]).- let mut unit_clicked = None;- for (r, vertical, id) in [(top, false, "ruler-top"), (left, true, "ruler-left")] {- // Click-and-drag so the same widget drags out guides (left) and opens the unit menu (right).- let resp = ui.interact(r, egui::Id::unique(id), Sense::click_and_drag());- resp.context_menu(|ui| crate::menus::ruler_menu_body(app, ui, &mut unit_clicked));- let kind = if resp.drag_stopped() {- PointerKind::Up- } else if resp.dragged() {- PointerKind::Drag- } else {- continue;- };- let p = resp.interact_pointer_pos().or_else(|| ui.input(|i| i.pointer.latest_pos()));- let on_canvas = p.is_some_and(|p| canvas.contains(p));- if on_canvas {- // The new guide shows even if guides were hidden.- app.ui.view.guides = true;- }- let ev = PointerEvent { kind, pos: p.map_or(Point::ZERO, |p| xf.to_doc(p)), mods: mods(ui.input(|i| i.modifiers), false), pressure: 1.0 };- if let Err(e) = app.session.ruler_guide(vertical, &ev, on_canvas, app.view_info()) {- app.status(e.to_string());- }- }- let corner = ui.interact(corner, egui::Id::unique("ruler-corner"), Sense::click_and_drag());- corner.context_menu(|ui| crate::menus::ruler_menu_body(app, ui, &mut unit_clicked));- if let Some((id, p)) = unit_clicked {- crate::menus::invoke(app, &id, p);- }- if corner.double_clicked_by(egui::PointerButton::Primary) {- let artboard = app.view().map_or(0, |v| v.artboard);- if let Err(e) = app.run("document.resetRulerOrigin", json!({"artboard": artboard})) {- app.status(e.to_string());- }- }- // Keep previews in the UI: only a release on the canvas edits the document, once. Cancelling- // never adds an undo step or interferes with the drawing tool's interaction.- let drag_id = ruler_origin_drag_id();- let uid = app.session.active().map(|d| d.uid);- if corner.drag_started_by(egui::PointerButton::Primary) {- ui.data_mut(|d| d.insert_temp(drag_id, (uid, false)));- }- let mut preview = None;- if let Some((started_in, mut cancelled)) = ui.data(|d| d.get_temp::<(Option<u64>, bool)>(drag_id)) {- cancelled |= started_in != uid || ui.input(|i| !i.focused || i.key_pressed(egui::Key::Escape));- let at = corner.interact_pointer_pos().or_else(|| ui.input(|i| i.pointer.latest_pos())).filter(|p| canvas.contains(*p)).map(|p| xf.to_doc(p));- if corner.drag_stopped_by(egui::PointerButton::Primary) {- ui.data_mut(|d| d.remove::<(Option<u64>, bool)>(drag_id));- if !cancelled- && let Some(at) = at- && let Err(e) = app.run("document.setRulerOrigin", json!({"x": at.x, "y": at.y, "artboard": app.view().map_or(0, |v| v.artboard)}))- {- app.status(e.to_string());- }- } else if !ui.input(|i| i.pointer.primary_down()) {- ui.data_mut(|d| d.remove::<(Option<u64>, bool)>(drag_id));- } else {- ui.data_mut(|d| d.insert_temp(drag_id, (started_in, cancelled)));- if !cancelled {- preview = at;- }- }- }- preview-}--/// The key of the ruler origin drag's state in egui's temporary data.-fn ruler_origin_drag_id() -> egui::Id {- egui::Id::unique("ruler-origin-drag")-}--/// Is a drag from the rulers' corner in progress? It stays true after Escape cancels the move, until-/// the button is released.-pub(crate) fn ruler_origin_dragging(ctx: &egui::Context) -> bool {- ctx.data(|d| d.get_temp::<(Option<u64>, bool)>(ruler_origin_drag_id()).is_some())-}--/// What the rulers count, and from where: `unit`, from `origin` (document points), with each-/// unit stretched `stretch` times along the document's x and y, which a video ruler's pixel aspect-/// ratio makes differ.-#[derive(Clone, Copy, Debug, PartialEq)]-pub(crate) struct RulerScale {- pub(crate) unit: Unit,- pub(crate) origin: Point,- pub(crate) stretch: [f64; 2],-}--impl RulerScale {- /// The rulers in `unit` (the General unit), from `origin` (the ruler origin).- pub(crate) fn document(unit: Unit, origin: Point) -> Self {- Self { unit, origin, stretch: [1.0, 1.0] }- }-- /// View › Rulers › Show Video Rulers on artboard `ab`: pixels from its top-left corner, each- /// pixel as many points wide as its Video Ruler Pixel Aspect Ratio and one point tall, so the- /// rulers read the artboard's size in video pixels- /// (https://helpx.adobe.com/illustrator/desktop/create-manage-artboards/organize-manage-artboards/set-video-display-options-for-artboards.html).- pub(crate) fn video(ab: &vectorcraft_doc::Artboard) -> Self {- Self { unit: Unit::Pixels, origin: Point::new(ab.rect.x0, ab.rect.y0), stretch: [ab.video_ruler_pixel_aspect_ratio, 1.0] }- }-- /// How far document point `p` lies from the origin along `axis` (a unit direction in the- /// document), in points of this scale: each document coordinate divided by its stretch.- /// Divided by the unit's points, it is the value the ruler reads there.- pub(crate) fn along(&self, p: Point, axis: vectorcraft_geom::Vec2) -> f64 {- let d = p - self.origin;- d.x / self.stretch[0] * axis.x + d.y / self.stretch[1] * axis.y- }-- /// The screen points one point of this scale spans along `axis` at `zoom` (screen points per- /// document point): `zoom` itself when nothing is stretched.- pub(crate) fn zoom_along(&self, zoom: f64, axis: vectorcraft_geom::Vec2) -> f64 {- zoom / (axis.x * axis.x / self.stretch[0] + axis.y * axis.y / self.stretch[1])- }-}--fn rulers(ui: &Ui, full: egui::Rect, xf: &Xf, hover: Option<Point>, scale: RulerScale, t: &Tokens) {- let p = ui.painter();- let [top, left, corner] = ruler_rects(full);- for r in [top, left, corner] {- p.rect_filled(r, 0.0, t.ruler);- }- p.line_segment([top.left_bottom(), top.right_bottom()], Stroke::new(1.0, t.border));- p.line_segment([left.right_top(), left.right_bottom()], Stroke::new(1.0, t.border));- // Crosshair in the origin box.- p.line_segment([corner.center() - vec2(4.0, 0.0), corner.center() + vec2(4.0, 0.0)], Stroke::new(1.0, t.ruler_tick));- p.line_segment([corner.center() - vec2(0.0, 4.0), corner.center() + vec2(0.0, 4.0)], Stroke::new(1.0, t.ruler_tick));- let font = egui::FontId::proportional(9.5);- // Each ruler measures along its own edge, in the canvas's coordinates turned with the view- // (#826): at 0° the top one reads x and the left one y. `draw` gets each tick's distance- // (screen points) from `from` along the ruler, its length, and the label of a labelled one.- let ticks = |from: Pos2, to: Pos2, axis: vectorcraft_geom::Vec2, draw: &mut dyn FnMut(f32, f32, Option<String>)| {- // Pick a label step (in the unit) that gives ≥ 50 px between labels on this ruler, at its- // own scale; positions below are in the unit (`per` points of the scale each).- let zoom = scale.zoom_along(xf.zoom, axis);- let (per, step) = (scale.unit.points(), scale.unit.ruler_step(zoom));- let minor = scale.unit.ruler_minor(step);- let near = |v: f64, every: f64| ((v / every).round() * every - v).abs() < minor * 0.01;- let (a, b) = (scale.along(xf.to_doc(from), axis), scale.along(xf.to_doc(to), axis));- let mut v = (a / per / minor).floor() * minor;- while v * per <= b {- // A tick's length: the labelled ones longest, the halves between them shorter.- let (len, label) = if near(v, step) {- (RULER, Some(ruler_label(v, step)))- } else if near(v, step / 2.0) {- (7.0, None)- } else {- (4.0, None)- };- draw(((v * per - a) * zoom) as f32, len, label);- v += minor;- }- };- // The canvas's directions along the screen's x and y.- let (sn, cs) = xf.rot.sin_cos();- let clip_top = p.with_clip_rect(top);- ticks(top.left_top(), top.right_top(), vectorcraft_geom::Vec2::new(cs, -sn), &mut |d, len, label| {- let sx = top.left() + d;- clip_top.line_segment([pos2(sx, top.bottom() - len), pos2(sx, top.bottom())], Stroke::new(1.0, t.ruler_tick));- if let Some(text) = label {- clip_top.text(pos2(sx + 2.0, top.top() + 1.0), egui::Align2::LEFT_TOP, text, font.clone(), t.ruler_tick);- }- });- let clip_left = p.with_clip_rect(left);- // A label spelled down the ruler is tall, and a long one can reach the next label's place:- // "-0.0625" is seven characters, 60 pt of ruler, where a sixteenth-inch step leaves 54 pt at- // zoom 12. The ticks all stay; a label that would run into the one above it is left out.- let mut filled_to = f32::NEG_INFINITY;- ticks(left.left_top(), left.left_bottom(), vectorcraft_geom::Vec2::new(sn, cs), &mut |d, len, label| {- let sy = left.top() + d;- clip_left.line_segment([pos2(left.right() - len, sy), pos2(left.right(), sy)], Stroke::new(1.0, t.ruler_tick));- if let Some(text) = label {- // Vertical labels read top-to-bottom, one digit per line like Illustrator.- let top = sy + 2.0;- if top < filled_to {- return;- }- filled_to = top + vertical_label_height(text.chars().count());- for (k, ch) in text.chars().enumerate() {- clip_left.text(- pos2(left.left() + 4.0, top + k as f32 * RULER_CHAR),- egui::Align2::LEFT_TOP,- ch.to_string(),- font.clone(),- t.ruler_tick,- );- }- }- });- if let Some(h) = hover {- let s = xf.to_screen(h);- clip_top.line_segment([pos2(s.x, top.top()), pos2(s.x, top.bottom())], Stroke::new(1.0, t.text));- clip_left.line_segment([pos2(left.left(), s.y), pos2(left.right(), s.y)], Stroke::new(1.0, t.text));- }-}--fn to_screen_path(bp: &BezPath, xf: &Xf) -> Vec<Vec<Pos2>> {- // Flatten for drawing: a polyline per subpath (tolerance ~0.25 screen px).- let mut out: Vec<Vec<Pos2>> = vec![];- let a = xf.affine();- let mut t = bp.clone();- t.apply_affine(a);- let mut cur: Vec<Pos2> = vec![];- kurbo_flatten(&t, 0.25, &mut |el| match el {- PathEl::MoveTo(p) => {- if cur.len() > 1 {- out.push(std::mem::take(&mut cur));- }- cur.clear();- cur.push(pos2(p.x as f32, p.y as f32));- }- PathEl::LineTo(p) => cur.push(pos2(p.x as f32, p.y as f32)),- PathEl::ClosePath => {- if let Some(f) = cur.first().copied() {- cur.push(f);- }- }- _ => {}- });- if cur.len() > 1 {- out.push(cur);- }- out-}--fn stroke_path(p: &egui::Painter, bp: &BezPath, xf: &Xf, s: Stroke) {- for line in to_screen_path(bp, xf) {- p.add(Shape::line(line, s));- }-}--fn c32(rgb: [u8; 3]) -> Color32 {- Color32::from_rgb(rgb[0], rgb[1], rgb[2])-}--/// Outline of a node for highlighting (paths, compound children, area type frames, other-/// text/image bounds, symbol instances' bounds measured by their art from `symbols`; a clip-/// group's clipping path only, as [`walk_drawn`] visits it).-fn node_outline(n: &Node, symbols: &SymbolBoxes) -> BezPath {- let mut bp = BezPath::new();- walk_drawn(n, &mut |c| match &c.kind {- NodeKind::Path { path, .. } => bp.extend(path.to_bezpath()),- // Area type shows its frame: the type area Direct Selection reshapes; type on a path its- // path, which the selection tools' brackets sit on; point type shows its baseline(s).- NodeKind::Text(t) => {- if c.extras().perspective.is_none() {- if let Some(path) = t.area_frame().or_else(|| t.type_path()) {- bp.extend(path.to_bezpath());- } else if matches!(t.kind, vectorcraft_doc::TextKind::Point) {- for (a, b) in t.baselines() {- bp.move_to(t.xf * a);- bp.line_to(t.xf * b);- }- }- } else if let Some(b) = c.geometric_bounds_with(symbols) {- bp.extend(vectorcraft_geom::shapes::rectangle(b).to_bezpath());- }- }- NodeKind::Image(_) | NodeKind::SymbolInstance { .. } => {- if let Some(b) = c.geometric_bounds_with(symbols) {- bp.extend(vectorcraft_geom::shapes::rectangle(b).to_bezpath());- }- }- // A placed document shows its box, turned with it.- NodeKind::PlacedDocument(p) => {- let [a, b, c, d] = p.corners();- bp.move_to(a);- [b, c, d].into_iter().for_each(|q| bp.line_to(q));- bp.close_path();- }- // A gradient mesh shows its mesh lines (#1111).- NodeKind::Mesh(m) => bp.extend(m.lines().to_bezpath()),- // An envelope shows its mesh (or top object), not its content.- NodeKind::Envelope { .. } => {- if let Some((lines, _)) = vectorcraft_doc::live::envelope_overlay(c) {- bp.extend(lines.to_bezpath());- }- }- _ => {}- });- bp-}--/// The width of the key object's outline (Align to Key Object), thicker than the selection's.-const KEY_OUTLINE: f32 = 2.5;--/// The most points ([`overlay_points`]) the selection's outlines and anchors, and the hover-/// highlight, are drawn for: an Image Trace of a photo selects hundreds of thousands of paths at-/// once, and selecting all of an opened PDF can select as many type objects, images and gradient-/// mesh pieces. Their outlines would make a mesh larger than the GPU takes in one buffer (#525,-/// #2460).-const OVERLAY_MAX_ANCHORS: usize = 100_000;--/// Whether `nodes` have more than [`OVERLAY_MAX_ANCHORS`] points to outline ([`overlay_points`];-/// counting stops there).-fn too_many_anchors<'a>(nodes: impl IntoIterator<Item = &'a Node>) -> bool {- fn over(n: &Node, left: &mut usize) -> bool {- match left.checked_sub(overlay_points(n)) {- Some(l) => *left = l,- None => return true,- }- // A clip group counts only its clipping path, the one child `walk_drawn` visits.- if n.clips() {- return n.children().and_then(|children| children.first()).is_some_and(|clip| over(clip, left));- }- !matches!(n.kind, NodeKind::Envelope { .. }) && n.editing_children().iter().any(|c| over(c, left))- }- let mut left = OVERLAY_MAX_ANCHORS;- nodes.into_iter().any(|n| over(n, &mut left))-}--/// The points counted for `n` itself, without its children, toward [`OVERLAY_MAX_ANCHORS`]: a-/// path's anchors; the anchors of area type's frame or of type on a path's path; the four corners-/// of the box that area type or type on a path in perspective, images, symbol instances and-/// placed documents show; six for point type, its box's corners and the ends of the baseline-/// marker a selected one shows; and the points and the ends of the mesh lines of a gradient mesh-/// or an envelope.-fn overlay_points(n: &Node) -> usize {- match &n.kind {- NodeKind::Path { path, .. } => path.anchor_count(),- NodeKind::Text(t) => match &t.kind {- vectorcraft_doc::TextKind::Point => 6,- _ if n.extras().perspective.is_some() => 4,- vectorcraft_doc::TextKind::Area { frame } => frame.anchor_count(),- vectorcraft_doc::TextKind::OnPath { path, .. } => path.anchor_count(),- },- NodeKind::Image(_) | NodeKind::SymbolInstance { .. } | NodeKind::PlacedDocument(_) => 4,- NodeKind::Mesh(m) => m.lines().anchor_count() + m.points.len(),- NodeKind::Envelope { .. } => {- vectorcraft_doc::live::envelope_overlay(n).map_or(0, |(lines, grid)| lines.anchor_count() + grid.map_or(0, |g| g.points.len()))- }- _ => 0,- }-}--/// [`Node::walk`] over what a selection highlight shows: an envelope's content is left out (the-/// envelope shows its mesh instead), and a clip group or clipping layer shows only its clipping-/// path, its first child, not the art the path clips (#2422).-fn walk_drawn<'a>(n: &'a Node, f: &mut impl FnMut(&'a Node)) {- f(n);- if matches!(n.kind, NodeKind::Envelope { .. }) {- return;- }- if n.clips() {- if let Some(clip) = n.children().and_then(|children| children.first()) {- walk_drawn(clip, f);- }- return;- }- for c in n.editing_children().iter() {- walk_drawn(c, f);- }-}--/// The topmost editable object under document point `p` at `zoom`, as what is drawn there-/// ([`hit_with`]): a swatch or a symbol dropped on art.-fn hit_at(app: &VectorcraftApp, p: Point, zoom: f64) -> Option<vectorcraft_doc::hit::Hit> {- hit_with(app, p, zoom, vectorcraft_doc::hit::hit_test)-}--/// The topmost editable object under document point `p` at `zoom`, as the selection tools pick-/// it: [`hit_at`], and a clipping path on its outline before the art it clips-/// ([`vectorcraft_doc::hit::HitOptions::clip_outlines`]). Object Highlighting and a right-click's-/// selection show and take what a click of those tools would.-fn selection_hit_at(app: &VectorcraftApp, p: Point, zoom: f64) -> Option<vectorcraft_doc::hit::Hit> {- hit_with(app, p, zoom, |doc, p, opt| vectorcraft_doc::hit::hit_test(doc, p, vectorcraft_doc::hit::HitOptions { clip_outlines: true, ..opt }))-}--/// `test` on the active document at document point `p`, with the options the selection tools hit-/// objects with at `zoom` (Selection & Anchor Display › Tolerance and Object Selection by Path Only,-/// Type › Type Object Selection by Path Only, isolation mode).-fn hit_with<T>(- app: &VectorcraftApp,- p: Point,- zoom: f64,- test: impl FnOnce(&vectorcraft_doc::Document, Point, vectorcraft_doc::hit::HitOptions) -> Option<T>,-) -> Option<T> {- let prefs = &app.session.prefs;- let opt = vectorcraft_doc::hit::HitOptions {- tol: prefs.selection_tolerance / zoom,- outline: app.ui.view.outline,- path_only: prefs.object_selection_by_path_only,- type_path_only: prefs.type_selection_by_path_only,- scope: app.session.active().and_then(|st| st.isolation),- skip_guides: !app.ui.view.guides,- ..Default::default()- };- test(&app.session.active()?.doc, p, opt)-}--/// Right-click: the object under the pointer is selected first unless it already is, then the-/// context menu lists what applies to the selection ([`crate::menus::context_items`]). The locked-/// objects under the pointer ([`vectorcraft_doc::hit::locked_objects_at`]) are kept in-/// `ui.context_locked` while the menu is open, for its Unlock submenu.-fn context_menu(app: &mut VectorcraftApp, resp: &egui::Response, xf: &Xf) {- if resp.secondary_clicked()- && let Some(p) = resp.interact_pointer_pos()- {- let p = xf.to_doc(p);- let locked = hit_with(app, p, xf.zoom, |doc, p, opt| Some(vectorcraft_doc::hit::locked_objects_at(doc, p, opt)));- app.ui.context_locked = app.session.active().map(|st| st.uid).zip(locked);- if let Some(st) = app.session.active()- && let Some(top) = selection_hit_at(app, p, xf.zoom).map(|h| h.top_object(st.isolation))- && !st.selection.contains(top)- {- // A locked or hidden object can't be selected; the menu is then for the selection as is.- let _ = app.run("select.set", json!({ "ids": [top.0] }));- }- }- let mut clicked = None;- if resp.context_menu(|ui| crate::menus::context_menu_body(app, ui, &mut clicked)).is_none() {- app.ui.context_locked = None;- }- if let Some((id, p)) = clicked {- crate::menus::invoke(app, &id, p);- }-}--/// A panel drag ([`widgets::PanelDrag`]) dropped on art acts on the object under the pointer,-/// selected or not: a paint (swatches, a Fill/Stroke proxy, the Gradient panel's thumbnail) goes-/// to its active proxy (`paint.setFill`/`paint.setStroke` with its `ids`; a gradient fits it), the-/// Appearance panel's thumbnail gives the object (the topmost one hit) the appearance it carries-/// (`appearance.copyFrom`), a graphic style is applied to it (`graphicStyle.apply`; with Alt, on-/// top of its appearance). A chip follows the pointer meanwhile.-fn panel_drop(app: &mut VectorcraftApp, ui: &Ui, resp: &egui::Response, xf: &Xf) {- crate::panels::swatches::drag_preview(app, ui.ctx());- let Some(pos) = ui.input(|i| i.pointer.interact_pos()) else { return };- // Not through a floating panel over the canvas.- if ui.ctx().layer_id_at(pos).is_some_and(|l| l != resp.layer_id) {- return;- }- let Some(d) = resp.dnd_release_payload::<widgets::PanelDrag>() else { return };- // A Libraries panel graphic: a copy centred where it is dropped.- if let widgets::PanelDrag::LibraryGraphic { library, item } = &*d {- let at = xf.to_doc(pos);- if let Err(e) = app.run("library.use", json!({"library": library, "kind": "graphic", "item": item, "center": [at.x, at.y]})) {- app.status(e);- }- return;- }- // A symbol from the Symbols panel: an instance centred where it is dropped, on art or not.- if let widgets::PanelDrag::Symbol(name) = &*d {- let at = xf.to_doc(pos);- if let Err(e) = app.run("symbol.place", json!({"name": name, "x": at.x, "y": at.y})) {- app.status(e);- }- return;- }- // A symbol from a symbol library panel: added to the document's Symbols and placed there.- if let widgets::PanelDrag::LibrarySymbol { library, name } = &*d {- let at = xf.to_doc(pos);- if let Err(e) = app.run("symbol.addFromLibrary", json!({"library": library, "name": name, "place": true, "x": at.x, "y": at.y})) {- app.status(e);- }- return;- }- let Some(hit) = hit_at(app, xf.to_doc(pos), xf.zoom) else { return };- let Some(st) = app.session.active() else { return };- let (cmd, params) = match &*d {- widgets::PanelDrag::Paint { params, .. } => {- // Colour groups paint nothing.- if params.is_null() {- return;- }- let mut params = params.clone();- params["ids"] = json!([vectorcraft_tools::xform::paint_owner(&st.doc, hit.leaf).0]);- params["focus"] = json!(false);- (crate::panels::proxy_cmd(app, false), params)- }- widgets::PanelDrag::Appearance(source) => {- let target = hit.top_object(st.isolation);- if target == *source {- return;- }- ("appearance.copyFrom", json!({"source": source.0, "ids": [target.0]}))- }- widgets::PanelDrag::GraphicStyle(name) => {- let add = ui.input(|i| i.modifiers.alt);- ("graphicStyle.apply", json!({"name": name, "ids": [hit.top_object(st.isolation).0], "add": add}))- }- // A brush from the Brushes panel: the path it lands on takes it (a compound path as a whole).- widgets::PanelDrag::Brush { name, .. } => {- ("brush.apply", json!({"name": name, "ids": [vectorcraft_tools::xform::paint_owner(&st.doc, hit.leaf).0]}))- }- // A brush from a brush library panel: added to the document's Brushes and applied to the- // path it lands on, in one step.- widgets::PanelDrag::LibraryBrush { library, name } => (- "brush.addFromLibrary",- json!({"library": library, "name": name, "apply": true, "ids": [vectorcraft_tools::xform::paint_owner(&st.doc, hit.leaf).0]}),- ),- // Art dragged back onto the canvas: its move was already dropped. (A symbol was placed- // above.)- widgets::PanelDrag::Art(_)- | widgets::PanelDrag::Symbol(_)- | widgets::PanelDrag::LibrarySymbol { .. }- | widgets::PanelDrag::LibraryGraphic { .. } => return,- // A Libraries panel style or group only moves within that panel.- widgets::PanelDrag::LibraryItem { .. } | widgets::PanelDrag::LibraryGroup { .. } => return,- };- if let Err(e) = app.run(cmd, params) {- app.status(e);- }-}--fn hover_highlight(app: &VectorcraftApp, p: &egui::Painter, xf: &Xf) {- let Some(h) = app.hover_doc else { return };- // Smart Guides › Object Highlighting: a Smart Guides display option, so it needs them on and Snap to Grid and Pixel Preview off.- if !app.ui.view.smart_guides || !app.session.prefs.object_highlighting || app.ui.view.snap_to_grid || app.ui.view.pixel_preview {- return;- }- if app.session.tool_busy() || !matches!(app.session.tool_id(), "selection" | "directSelection" | "groupSelection") {- return;- }- let Some(st) = app.session.active() else { return };- let Some(hit) = selection_hit_at(app, h, xf.zoom) else { return };- let id = if app.session.tool_id() == "selection" { hit.top_object(st.isolation) } else { hit.leaf };- if st.selection.contains(id) {- return;- }- if let Some(n) = st.doc.node(id).filter(|n| !too_many_anchors([*n])) {- let color = c32(st.doc.layer_color(id));- stroke_path(p, &node_outline(n, &st.doc.symbol_boxes()), xf, Stroke::new(1.5, color));- }-}--/// Selected anchors are drawn slightly deeper than the layer colour (#4f80ff → #3d82ff for Layer 1).-fn selected_anchor(c: Color32) -> Color32 {- if c == Color32::from_rgb(0x4f, 0x80, 0xff) { Color32::from_rgb(0x3d, 0x82, 0xff) } else { c }-}--/// How anchors and handles look: Selection & Anchor Display › Size and Handles.-#[derive(Clone, Copy)]-struct HandleLook<'a> {- /// Points bigger (or smaller) than the default size 3, per step of Size (1–7).- grow: f32,- /// `solid` (the default), `hollow` or `large`.- style: &'a str,-}--impl<'a> HandleLook<'a> {- fn of(prefs: &'a vectorcraft_engine::Prefs) -> Self {- Self { grow: prefs.anchor_size.clamp(1, 7) as f32 - 3.0, style: &prefs.handle_style }- }-- /// A direction handle's end at `c`: a solid dot, a hollow one or a larger solid one.- fn draw(self, p: &egui::Painter, c: Pos2, color: Color32) {- let r = 2.75 + self.grow / 2.0;- let hollow = self.style == "hollow";- p.circle_filled(c, if self.style == "large" { r + 1.5 } else { r }, if hollow { Color32::WHITE } else { color });- if hollow {- p.circle_stroke(c, r, Stroke::new(1.0, color));- }- }-}--fn anchor_square(p: &egui::Painter, c: Pos2, color: Color32, filled: bool, size: f32) {- let r = egui::Rect::from_center_size(c, vec2(size, size));- if filled {- p.rect_filled(r, 0.0, color);- } else {- p.rect_filled(r, 0.0, Color32::WHITE);- p.rect_stroke(r, 0.0, Stroke::new(1.0, color), StrokeKind::Inside);- }-}--fn curve_point(p: &egui::Painter, c: Pos2, color: Color32, filled: bool, size: f32) {- p.circle(c, size / 2.0, if filled { color } else { Color32::WHITE }, Stroke::new(1.0, color));-}--/// Type → Show Hidden Characters: spaces as dots, ¶ at paragraph ends, # at the end of a story.-/// The marks of each text object are kept from one frame to the next ([`HiddenChars`]).-fn hidden_chars_overlay(app: &mut VectorcraftApp, p: &egui::Painter, xf: &Xf) {- let Some(st) = app.session.active() else { return };- let clip = p.clip_rect();- let color = Color32::from_rgb(0x4f, 0x9d, 0xff);- let font = egui::FontId::proportional(((10.0 * xf.zoom) as f32).clamp(7.0, 18.0));- let kept = &mut app.canvas.hidden_chars;- // `last` holds the marks of the last frame. The marks of the objects this frame doesn't draw- // are dropped at the end.- let mut last = std::mem::take(&mut kept.marks);- // The inputs are read before any layout: when fonts load during this frame, the next frame- // lays all type out again.- let inputs = (vectorcraft_text::FontDb::global().generation(), vectorcraft_text::hyphenation_exceptions());- if kept.inputs != inputs {- last.clear();- kept.inputs = inputs;- }- // `walk` visits each node's `Arc` in the order `Document::walk` visits the nodes (depth first,- // in paint order).- fn walk(nodes: &[std::sync::Arc<Node>], f: &mut impl FnMut(&std::sync::Arc<Node>)) {- for n in nodes {- f(n);- if let Some(children) = n.children() {- walk(children, f);- }- }- }- walk(&st.doc.layers, &mut |n| {- let NodeKind::Text(tx) = &n.kind else { return };- // The box round the object's corners on screen, turned with the view.- if !n.visible || n.geometric_bounds().is_none_or(|b| !egui::Rect::from_points(&xf.quad(b)).intersects(clip)) {- return;- }- let marks = match last.remove(&n.id) {- Some((was, marks)) if std::sync::Arc::ptr_eq(&was, n) => marks,- _ => std::sync::Arc::new(HiddenMarks::of(tx)),- };- for &at in &marks.spaces {- p.circle_filled(xf.to_screen(at), 1.2, color);- }- for &(at, glyph) in &marks.ends {- p.text(xf.to_screen(at), egui::Align2::LEFT_BOTTOM, glyph, font.clone(), color);- }- kept.marks.insert(n.id, (n.clone(), marks));- });-}--/// The Show Hidden Characters marks of the text objects drawn in the last frame-/// ([`crate::CanvasCache::hidden_chars`]). Each is kept with the object it was laid out from: an-/// edited object is a new `Arc` and is laid out again, and all type is laid out again when the-/// fonts or the hyphenation exceptions change.-#[derive(Default)]-pub struct HiddenChars {- /// The fonts' generation ([`vectorcraft_text::FontDb::generation`]) and the hyphenation- /// exceptions the marks were laid out with.- inputs: (u64, String),- /// Each text object drawn, by id: the node it was laid out from and its marks.- marks: std::collections::HashMap<vectorcraft_doc::NodeId, (std::sync::Arc<Node>, std::sync::Arc<HiddenMarks>)>,-}--/// One text object's marks in document space: a dot over each space, and ¶ or # after the lines-/// that end a paragraph or the story. Type on a path has none.-#[derive(Default)]-struct HiddenMarks {- spaces: Vec<Point>,- ends: Vec<(Point, &'static str)>,-}--impl HiddenMarks {- /// Lay out `tx` and place its marks.- fn of(tx: &vectorcraft_doc::TextObject) -> Self {- let mut marks = Self::default();- let lay = vectorcraft_text::layout(vectorcraft_text::FontDb::global(), tx);- if lay.on_path {- return marks;- }- let text = tx.plain_text();- let to = |q: Point| tx.xf * q;- // A list marker's glyphs (length 0) stand for no character.- for g in lay.glyphs.iter().filter(|g| g.len > 0) {- if text.get(g.byte..).is_some_and(|s| s.starts_with(' ')) {- marks.spaces.push(to(Point::new(g.origin.x + g.advance / 2.0, g.origin.y - 3.0)));- }- }- for (i, line) in lay.lines.iter().enumerate() {- let last = i + 1 == lay.lines.len();- let breaks = text.get(line.end..).is_some_and(|s| s.starts_with('\n'));- let (glyph, at) = if last && line.end >= text.len() {- ("#", true)- } else if breaks {- ("¶", true)- } else {- ("", false)- };- if at {- marks.ends.push((to(Point::new(line.x1 + 1.0, line.baseline)), glyph));- }- }- marks- }-}--/// View › Show Text Threads: for each thread with a selected frame, a line in its first frame's-/// layer colour from each frame's out port to the next frame's in port, both showing the arrow of a-/// threaded port, where the tools draw the ports of selected type ([`vectorcraft_tools::text`]).-/// Only frames with ports ([`vectorcraft_tools::text::ported`]) are joined: a link to or from a-/// frame in perspective, which has none, gets no line. With more than-/// [`vectorcraft_tools::text::PORTS_MAX`] such frames selected the tools draw no ports, and only-/// the lines are drawn here. `zoom`: screen pixels to the document unit.-fn thread_overlays(app: &VectorcraftApp, zoom: f64) -> Vec<Overlay> {- use vectorcraft_tools::text::{Port, PortState, port_centre, ported, ports_shown, push_port};- let Some(st) = app.session.active() else { return vec![] };- let px = 1.0 / zoom.max(1e-9);- let boxes = ports_shown(&st.doc, &st.selection.objects);- let mut o = vec![];- for thread in &st.doc.text_threads {- if !thread.iter().any(|id| st.selection.objects.contains(id)) {- continue;- }- let color = st.doc.layer_color(thread[0]);- for w in thread.windows(2) {- let [a, b] = [w[0], w[1]];- let (Some(from), Some(to)) = (ported(&st.doc, a), ported(&st.doc, b)) else { continue };- let (Some(out), Some(input)) = (port_centre(from, Port::Out, px), port_centre(to, Port::In, px)) else { continue };- o.push(Overlay::Line { a: out, b: input, color, dashed: false });- if boxes {- push_port(&mut o, out, PortState::Threaded, st.doc.layer_color(a), px);- push_port(&mut o, input, PortState::Threaded, st.doc.layer_color(b), px);- }- }- }- o-}--/// View → Show Live Paint Gaps: the gaps of the selected Live Paint groups in each group's Gap-/// Preview Color ([`crate::dialogs::live_paint_gaps::selected_gaps`]). Cached per revision.-fn live_paint_gap_overlays(app: &mut VectorcraftApp) -> Vec<Overlay> {- let Some(st) = app.session.active() else { return vec![] };- let key = (st.uid, st.revision);- let gaps = match &app.canvas.live_paint_gaps {- Some((k, gaps)) if *k == key => gaps.clone(),- _ => {- let gaps = std::sync::Arc::new(crate::dialogs::live_paint_gaps::selected_gaps(app));- app.canvas.live_paint_gaps = Some((key, gaps.clone()));- gaps- }- };- gaps.to_vec()-}--/// Simplify's Show Original Path: the paths its preview ran on, as they were before it, in a band-/// 3 screen points wide of their layer's color at 40%, under the selection's outlines. Nothing is drawn-/// when they have more than [`OVERLAY_MAX_ANCHORS`] anchor points.-fn original_path_overlay(app: &VectorcraftApp, p: &egui::Painter, xf: &Xf) {- let paths = crate::dialogs::path_ops::original_paths(app);- let Some(st) = app.session.active().filter(|_| paths.iter().map(|(_, path)| path.anchor_count()).sum::<usize>() <= OVERLAY_MAX_ANCHORS) else {- return;- };- for (id, path) in paths {- stroke_path(p, &path.to_bezpath(), xf, Stroke::new(3.0, c32(st.doc.layer_color(id)).gamma_multiply(0.4)));- }-}--/// The slices (unless View → Hide Slices): user and object slices outlined in the Slices-/// preferences' line colour, auto slices dashed and dimmer, each numbered at its top left (Show-/// Slice Numbers); selected slices have a bolder outline. The layout is cached per revision.-fn slice_overlay(app: &mut VectorcraftApp, p: &egui::Painter, xf: &Xf) {- let Some(st) = app.session.active() else { return };- let key = (st.uid, st.revision);- let slices = match &app.canvas.slices {- Some((k, s)) if *k == key => s.clone(),- _ => {- let s = std::sync::Arc::new(st.doc.slice_layout());- app.canvas.slices = Some((key, s.clone()));- s- }- };- if slices.is_empty() {- return;- }- let prefs = &app.session.prefs;- let line = pref_color(&prefs.slice_line_color, Color32::from_rgb(0xff, 0x3f, 0x3f));- let dim = line.gamma_multiply(0.55);- let selected = &st.selection.slices;- let objects = &st.selection.objects;- for a in slices.iter() {- let auto = a.source == vectorcraft_doc::SliceSource::Auto;- let on = a.id.is_some_and(|id| selected.contains(&id) || objects.contains(&id));- let q = xf.quad(a.rect);- let ring: Vec<Pos2> = q.iter().chain(q.first()).copied().collect();- if auto {- p.extend(Shape::dashed_line(&ring, Stroke::new(1.0, dim), 3.0, 3.0));- } else {- p.add(Shape::line(ring, Stroke::new(if on { 2.0 } else { 1.0 }, line)));- }- if prefs.show_slice_numbers- && let Some(tl) = q.first()- {- let font = egui::FontId::proportional(9.0);- let galley = p.layout_no_wrap(format!("{:02}", a.number), font, Color32::WHITE);- let badge = egui::Rect::from_min_size(*tl + vec2(1.0, 1.0), galley.size() + vec2(6.0, 2.0));- p.rect_filled(badge, CornerRadius::ZERO, if auto { dim } else { line });- p.galley(badge.min + vec2(3.0, 1.0), galley, Color32::WHITE);- }- }-}--/// The print tiling (View → Show Print Tiling, or the Print Tiling tool): each page of the-/// document's print settings as `print.preview` lays it out, its paper edge and its imageable-/// area dashed, numbered at its top left; tiles outside the tile range dimmer. Cached per revision.-fn print_tiling_overlay(app: &mut VectorcraftApp, p: &egui::Painter, xf: &Xf) {- let Some(st) = app.session.active() else { return };- let key = (st.uid, st.revision);- let pages = match &app.canvas.print_tiling {- Some((k, pages)) if *k == key => pages.clone(),- _ => {- // Settings that can't print have no pages to show.- let pages = std::sync::Arc::new(vectorcraft_engine::cmd::printtiling::pages(&st.doc).unwrap_or_default());- app.canvas.print_tiling = Some((key, pages.clone()));- pages- }- };- let font = egui::FontId::proportional(10.0);- let ring = |r: [f64; 4]| {- let q = xf.quad(Rect::new(r[0], r[1], r[2], r[3]));- q.iter().chain(q.first()).copied().collect::<Vec<Pos2>>()- };- for page in pages.iter() {- let color = if page.printed { PRINT_TILING } else { PRINT_TILING.gamma_multiply(0.45) };- p.add(Shape::line(ring(page.page), Stroke::new(0.75, color)));- let inner = ring(page.imageable);- p.extend(Shape::dashed_line(&inner, Stroke::new(1.0, color), 4.0, 3.0));- if let Some(corner) = inner.iter().copied().reduce(|a, b| pos2(a.x.min(b.x), a.y.min(b.y))) {- p.text(corner + vec2(3.0, 2.0), egui::Align2::LEFT_TOP, page.number.to_string(), font.clone(), color);- }- }-}--/// The print tiling's lines: a neutral grey that reads on the paper and on the pasteboard.-const PRINT_TILING: Color32 = Color32::from_gray(96);--/// A Shaper Group's mode widget (Shaper and Selection tools), drawn with selection edges shown or-/// hidden: an arrow pointing right in Face Selection mode and left in Construction mode.-fn shaper_widget_overlay(app: &VectorcraftApp, p: &egui::Painter, xf: &Xf) {- let Some(st) = app.session.active() else { return };- if matches!(app.session.tool_id(), "shaper" | "selection")- && let Some(w) = vectorcraft_tools::shaperwidget::ShaperWidget::of(&st.doc, &st.selection, st.isolation, xf.zoom)- {- let (c, r) = (xf.to_screen(w.at), vectorcraft_tools::shaperwidget::RADIUS_PX);- let color = c32(st.doc.layer_color(w.group));- p.circle_filled(c, r, Color32::WHITE);- p.circle_stroke(c, r, Stroke::new(1.0, color));- let d = if w.construction { -1.0 } else { 1.0 };- let arrow = vec![c + vec2(3.0 * d, 0.0), c + vec2(-2.0 * d, -3.0), c + vec2(-2.0 * d, 3.0)];- p.add(Shape::convex_polygon(arrow, color, Stroke::NONE));- }-}--/// High-contrast live controls, using the same geometry as the Selection tool's hit testing.-fn mirror_axis_overlay(app: &VectorcraftApp, p: &egui::Painter, xf: &Xf) {- if app.session.tool_id() != "selection" || !app.ui.view.bounding_box {- return;- }- let Some(st) = app.session.active() else { return };- let Some(axis) = vectorcraft_tools::mirror::MirrorAxis::of(&st.doc, &st.selection, xf.zoom) else { return };- let t = Tokens::get(p.ctx());- let ends = axis.ends.map(|q| xf.to_screen(q));- let center = xf.to_screen(axis.center);- if !center.is_finite() || !ends.iter().all(|p| p.is_finite()) {- return;- }- if let Some((a, b)) = clip_segment(ends[0], ends[1], xf.rect) {- p.line_segment([a, b], Stroke::new(5.0, t.measure_bg));- p.line_segment([a, b], Stroke::new(2.0, t.selection));- }- for end in ends {- p.circle_filled(end, vectorcraft_tools::mirror::HANDLE_RADIUS, t.measure_bg);- p.circle_stroke(end, vectorcraft_tools::mirror::HANDLE_RADIUS, Stroke::new(2.0, t.selection));- }- let handle = egui::Rect::from_center_size(center, vec2(12.0, 12.0));- p.rect_filled(handle, 2.0, t.selection);- p.rect_stroke(handle, 2.0, Stroke::new(2.0, t.measure_bg), StrokeKind::Outside);-}--/// A selected grid repeat's row, column and corner handles and its spacing sliders (#2691), at-/// the places the Selection tool's hit testing finds them.-fn grid_repeat_overlay(app: &mut VectorcraftApp, p: &egui::Painter, xf: &Xf) {- use vectorcraft_tools::repeat_grid::{GridHandles, GridPart, HANDLE_RADIUS, SLIDER_HALF};- if app.session.tool_id() != "selection" || !app.ui.view.bounding_box {- return;- }- let frame = app.selection_box();- let Some(st) = app.session.active() else { return };- let Some(grid) = GridHandles::of(&st.doc, &st.selection, frame, xf.zoom) else { return };- let t = Tokens::get(p.ctx());- let half = f64::from(SLIDER_HALF) / xf.zoom;- for (part, at) in grid.parts() {- let c = xf.to_screen(at);- if !c.is_finite() {- continue;- }- if part.is_slider() {- // A bar across the gap's middle, square to the spacing it sets.- let along = if part == GridPart::HSpacing { vectorcraft_geom::Vec2::new(0.0, half) } else { vectorcraft_geom::Vec2::new(half, 0.0) };- let ends = [xf.to_screen(at - along), xf.to_screen(at + along)];- p.line_segment(ends, Stroke::new(6.0, t.measure_bg));- p.line_segment(ends, Stroke::new(2.5, t.selection));- } else {- p.circle_filled(c, HANDLE_RADIUS, t.measure_bg);- p.circle_stroke(c, HANDLE_RADIUS, Stroke::new(2.0, t.selection));- }- }-}--/// The radius of the Rotate View dial, in screen points.-const DIAL_RADIUS: f32 = 40.0;--/// The dial a Rotate View drag shows, centered on `c`: a tick every 15° (longer every 90°), a-/// needle pointing where the document's top points in a view turned by `rotation` degrees, and the-/// angle under the center, rounded to whole degrees as in the status bar.-fn rotate_view_dial(p: &egui::Painter, c: Pos2, rotation: f64, t: &Tokens) {- // `dir(deg)` is the screen direction `deg` degrees clockwise from straight up.- let dir = |deg: f32| vec2(deg.to_radians().sin(), -deg.to_radians().cos());- p.circle(c, DIAL_RADIUS, t.panel.gamma_multiply(0.85), Stroke::new(1.0, t.border));- for i in 0..24u8 {- let len = if i % 6 == 0 { 8.0 } else { 4.0 };- let d = dir(f32::from(i) * 15.0);- p.line_segment([c + d * (DIAL_RADIUS - len), c + d * DIAL_RADIUS], Stroke::new(1.0, t.text_dim));- }- p.line_segment([c, c + dir(rotation as f32) * DIAL_RADIUS], Stroke::new(2.0, t.accent));- p.circle_filled(c, 2.5, t.accent);- p.text(c + vec2(0.0, 8.0), egui::Align2::CENTER_TOP, format!("{rotation:.0}°"), egui::FontId::proportional(11.0), t.text);-}--fn selection_overlay(app: &mut VectorcraftApp, p: &egui::Painter, xf: &Xf, curve_points_from_tool: bool) {- // The Selection tool's bounding box (rotated with the objects after a rotation). It hides while- // a drag moves or resizes the selection, so only the art is seen going with the pointer (#712).- let show_box = app.session.tool_id() == "selection"- && !app.session.tool_transforming()- && app.ui.view.bounding_box- && app.session.active().is_some_and(|st| !st.selection.is_empty() && st.selection.anchors.is_empty());- let bbox = if show_box { app.selection_box() } else { None };- let st = app.session.active();- let big = st.is_some_and(|st| too_many_anchors(st.selection.objects.iter().filter_map(|id| st.doc.node(*id))));- let big_bounds = if big { app.selection_bounds() } else { None };- let app = &*app;- let Some(st) = app.session.active() else { return };- let symbols = st.doc.symbol_boxes();- let tool = app.session.tool_id();- let direct = vectorcraft_tools::catalog::edits_anchors(tool);- let curvature = tool == "curvature";- // Selection & Anchor Display › Size (1–7, 3 the default): anchors, handles and the bounding- // box's handles a point bigger or smaller per step.- let look = HandleLook::of(&app.session.prefs);- let grow = look.grow;- let anchor = |direct: bool| grow + if direct { 5.0 } else { 4.0 };- // The selected anchors' handles (drawn once they are counted: Show handles when multiple- // anchors are selected off shows them for a single one only).- let (mut handles, mut with_handles) = (vec![], 0);- // Too many paths to outline: the selection's bounds stand for them.- if let Some((b, id)) = big_bounds.zip(st.selection.objects.first()) {- stroke_path(p, &vectorcraft_geom::shapes::rectangle(b).to_bezpath(), xf, Stroke::new(1.0, c32(st.doc.layer_color(*id))));- }- // The key object (Align to Key Object): its outline drawn thicker, or its bounds when it has- // too many paths to outline.- if let Some((k, n)) = st.selection.key.and_then(|k| Some((k, st.doc.node(k)?))) {- let outline = if too_many_anchors([n]) {- n.geometric_bounds_with(&symbols).map(|b| vectorcraft_geom::shapes::rectangle(b).to_bezpath())- } else {- Some(node_outline(n, &symbols))- };- if let Some(bp) = outline {- stroke_path(p, &bp, xf, Stroke::new(KEY_OUTLINE, c32(st.doc.layer_color(k))));- }- }- for id in st.selection.objects.iter().filter(|_| !big) {- let Some(n) = st.doc.node(*id) else { continue };- let color = c32(st.doc.layer_color(*id));- let partial = st.selection.partial(*id);- // Path outlines (and area type / placed document / image / mesh / symbol outlines;- // point type baselines and origin are drawn below).- if !matches!(n.kind, NodeKind::Text(ref tx) if matches!(tx.kind, vectorcraft_doc::TextKind::Point)) {- stroke_path(p, &node_outline(n, &symbols), xf, Stroke::new(1.0, color));- }- // Anchors (and handles for selected anchors in direct mode); a gradient mesh's or a mesh- // envelope's points.- walk_drawn(n, &mut |c| {- let envelope = vectorcraft_doc::live::envelope_overlay(c).and_then(|(_, grid)| grid);- let grid = match &c.kind {- NodeKind::Mesh(m) => Some(m),- _ => envelope.as_ref(),- };- if let Some(grid) = grid {- for q in &grid.points {- anchor_square(p, xf.to_screen(q.p), color, false, anchor(direct));- }- return;- }- let NodeKind::Path { path, .. } = &c.kind else { return };- // The Curvature tool owns its points while drawing; existing paths use this overlay.- if curvature && curve_points_from_tool {- return;- }- let selected_segments = st.selection.segments.get(&c.id);- if let Some(segments) = selected_segments {- for &(si, seg) in segments {- let Some(sp) = path.subpaths.get(si).filter(|sp| seg < sp.segment_count()) else { continue };- let curve = sp.segment(seg);- let mut outline = vectorcraft_geom::BezPath::new();- outline.move_to(curve.p0);- if sp.segment_is_line(seg) {- outline.line_to(curve.p3);- } else {- outline.curve_to(curve.p1, curve.p2, curve.p3);- }- stroke_path(p, &outline, xf, Stroke::new(2.0, color));- }- }- for (si, ai, a) in path.anchors() {- // An object selected whole has all its anchors selected, and so do the paths inside a- // group, compound path or clip group selected whole. Direction handles show only on a- // path that is selected itself: those are the handles that `handle_anchors` in- // `vectorcraft-tools` lets the tools drag.- let (sel, handles_shown) = match partial {- Some(set) => {- let sel = set.contains(&(si, ai));- (sel, sel)- }- None => (true, direct && c.id == *id),- };- let sp = xf.to_screen(a.p);- if !curvature && handles_shown {- with_handles += 1;- let sides = path.subpaths.get(si).map(|subpath| st.selection.handle_sides(c.id, si, ai, subpath)).unwrap_or((true, true));- handles.extend(- [(a.h_in, sides.0), (a.h_out, sides.1)]- .into_iter()- .filter(|(h, show)| *show && h.distance(a.p) > 1e-6)- .map(|(h, _)| (sp, xf.to_screen(h), color)),- );- }- let anchor_selected = sel && selected_segments.is_none();- let ink = if anchor_selected && partial.is_some() { selected_anchor(color) } else { color };- if curvature {- curve_point(p, sp, ink, anchor_selected && partial.is_some(), grow + 6.0);- } else {- anchor_square(p, sp, ink, anchor_selected, anchor(partial.is_some() || direct));- }- }- });- // Centre point (Attributes panel → Show Center).- if n.shows_center()- && let Some(b) = n.geometric_bounds_with(&symbols)- {- anchor_square(p, xf.to_screen(b.center()), color, true, anchor(false));- }- // Point type: each line's baseline, where a click selects it (`hit`), whatever its- // alignment and rotation, and the anchor (area type shows its frame instead, which may- // not be a rectangle, and type on a path its path).- if let NodeKind::Text(tx) = &n.kind- && matches!(tx.kind, vectorcraft_doc::TextKind::Point)- {- for (a, b) in tx.baselines() {- p.line_segment([xf.to_screen(tx.xf * a), xf.to_screen(tx.xf * b)], Stroke::new(1.0, color));- }- p.circle_filled(xf.to_screen(tx.xf * Point::ZERO), 2.5, color);- }- }- if app.session.prefs.show_handles_multiple_anchors || with_handles <= 1 {- for (sp, hp, color) in handles {- p.line_segment([sp, hp], Stroke::new(1.0, color));- look.draw(p, hp, color);- }- }- // The spine of each selected blend (or of the blend a selected key object belongs to).- let mut spines = vec![];- for id in &st.selection.objects {- let is_blend = |b: &vectorcraft_doc::NodeId| st.doc.node(*b).is_some_and(|n| matches!(n.kind, NodeKind::Blend { .. }));- let Some(b) = [Some(*id), st.doc.parent_of(*id)].into_iter().flatten().find(is_blend).filter(|b| !spines.contains(b)) else { continue };- spines.push(b);- let Some(NodeKind::Blend { children, spec }) = st.doc.node(b).map(|n| &n.kind) else { continue };- let Some((path, _)) = vectorcraft_doc::live::blend_spine(children, spec) else { continue };- let color = c32(st.doc.layer_color(b));- stroke_path(p, &path.to_bezpath(), xf, Stroke::new(1.0, color));- for (_, _, a) in path.anchors() {- anchor_square(p, xf.to_screen(a.p), color, false, anchor(direct));- }- }- // Live Corners widgets (Selection on a live rectangle or polygon, Direct Selection on any path).- if matches!(tool, "selection" | "directSelection")- && let Some(w) = vectorcraft_tools::corners::CornerWidgets::showing(- &st.doc,- &st.selection,- xf.zoom,- tool == "directSelection",- app.ui.view.corner_widgets,- app.session.prefs.hide_corner_widget_above,- )- {- for (id, q) in w.visible_on() {- let (sp, color) = (xf.to_screen(q), c32(st.doc.layer_color(id)));- p.circle_filled(sp, 3.0, Color32::WHITE);- p.circle_stroke(sp, 3.0, Stroke::new(1.0, color));- p.circle_filled(sp, 1.0, color);- }- }- // Bounding box with handles (Selection tool).- if let Some(b) = bbox {- let color = c32(st.doc.layer_color(st.selection.objects[0]));- p.add(Shape::closed_line(b.corners().iter().map(|q| xf.to_screen(*q)).collect(), Stroke::new(1.0, color)));- for h in vectorcraft_tools::bbox::Handle::ALL {- let c = xf.to_screen(b.to_doc() * h.pos(b.rect));- let hr = egui::Rect::from_center_size(c, vec2(6.0 + grow, 6.0 + grow));- p.rect_filled(hr, 0.0, Color32::WHITE);- p.rect_stroke(hr, 0.0, Stroke::new(1.0, color), StrokeKind::Inside);- }- // The type widget beside it: hollow on point type, filled on area type.- if let Some(w) = vectorcraft_tools::typewidget::TypeWidget::of(&st.doc, &st.selection, &b, xf.zoom) {- let (c, r) = (xf.to_screen(w.at), vectorcraft_tools::typewidget::RADIUS_PX);- p.circle_filled(c, r, if w.area { color } else { Color32::WHITE });- p.circle_stroke(c, r, Stroke::new(1.0, color));- }- }- // Pie widgets (Selection tool, with View › Show Bounding Box, on live ellipses): each joined- // by a line to the outline's point at its angle. They stay while one is dragged.- if tool == "selection" && app.ui.view.bounding_box {- for w in vectorcraft_tools::pie::PieWidget::of(&st.doc, &st.selection, xf.zoom) {- let (on, c, r, color) = (xf.to_screen(w.on), xf.to_screen(w.at), vectorcraft_tools::pie::RADIUS_PX, c32(st.doc.layer_color(w.id)));- p.line_segment([on, c], Stroke::new(1.0, color));- p.circle_filled(c, r, Color32::WHITE);- p.circle_stroke(c, r, Stroke::new(1.0, color));- }- }-}--/// Record where the Type tool's IME candidate window goes this pass, if it has an editor.-///-/// The descriptor itself is observed once at the end of the pass (`crate::ime::end_of_pass`),-/// after dialogs, floating panels, progress windows and the palette draw: any of them can open-/// over the canvas, take the keyboard or run a command that changes the edited text, so a-/// descriptor written here would carry a stale owner, surrounding text or cause.-fn ime_geometry(app: &mut VectorcraftApp, ctx: &egui::Context, xf: &Xf) {- app.ime_caret_rect = None;- // A hidden viewport cannot compose; the end-of-pass observation clears the owner.- if !app.session.tool_wants_text() || app.viewport_hidden(ctx) {- return;- }- let Some((a, b)) = app.session.tool_ime_caret(app.view_info()) else { return };- let r = egui::Rect::from_two_pos(xf.to_screen(a), xf.to_screen(b)).expand2(vec2(1.0, 0.0));- app.ime_caret_rect = Some((r, r));-}--/// The width an artboard needs on screen for its name to show (px): narrower, the name is left-/// out rather than spilling over its neighbours.-const MIN_LABELLED_ARTBOARD: f32 = 24.0;--/// Temp-memory key recording an artboard-name press before its edit field opens.-fn name_press_id() -> egui::Id {- egui::Id::unique("canvas-artboard-name-press")-}--/// Temp-memory key for the artboard name field currently being edited.-fn name_edit_id() -> egui::Id {- egui::Id::unique("canvas-artboard-name-edit")-}--/// A name being typed above an artboard. `fresh`: this frame opened it, so a focus loss from the-/// press that started it is not the user leaving the field.-#[derive(Clone)]-struct ArtboardNameEdit {- index: usize,- text: String,- fresh: bool,-}--/// The canvas label for `name`, laid out as [`artboard_label`] draws it.-fn canvas_name_galley(painter: &egui::Painter, corner: Pos2, width: f32, name: &str, color: Color32) -> Option<(std::sync::Arc<egui::Galley>, Pos2)> {- if !width.is_finite() || width < MIN_LABELLED_ARTBOARD {- return None;- }- let mut job = egui::text::LayoutJob::simple_singleline(name.to_owned(), egui::FontId::proportional(11.0), color);- job.wrap = egui::text::TextWrapping { max_width: width, max_rows: 1, break_anywhere: true, overflow_character: Some('…') };- let galley = painter.layout_job(job);- let at = corner - vec2(0.0, 4.0 + galley.size().y);- Some((galley, at))-}--/// The length on screen, in points, of each arm of an artboard's center mark (a cross), at any zoom.-const CENTER_MARK_ARM: f32 = 6.0;--/// Artboard `ab`'s display marks in `color`, each line 1 point wide on screen at any zoom and-/// turned with the view: with Show Cross Hairs, a line from the middle of each side through the-/// center to the middle of the opposite side; with Show Center Mark, a cross at the center whose-/// arms run along the artboard's sides, [`CENTER_MARK_ARM`] long on screen-/// (https://helpx.adobe.com/illustrator/desktop/create-manage-artboards/organize-manage-artboards/modify-display-settings-of-artboards.html);-/// with Show Video Safe Areas, the outlines of its action-safe and title-safe areas-/// ([`vectorcraft_doc::Artboard::video_safe_areas`],-/// https://helpx.adobe.com/illustrator/desktop/create-manage-artboards/organize-manage-artboards/set-video-display-options-for-artboards.html).-fn artboard_marks(painter: &egui::Painter, xf: &Xf, ab: &vectorcraft_doc::Artboard, color: Color32) {- let (r, stroke) = (ab.rect, Stroke::new(1.0, color));- let c = r.center();- let at = |x: f64, y: f64| xf.to_screen(Point::new(x, y));- if ab.show_cross_hairs {- painter.line_segment([at(r.x0, c.y), at(r.x1, c.y)], stroke);- painter.line_segment([at(c.x, r.y0), at(c.x, r.y1)], stroke);- }- if ab.show_center_mark {- let mid = at(c.x, c.y);- for side in [at(c.x + 1.0, c.y), at(c.x, c.y + 1.0)] {- let arm = (side - mid).normalized() * CENTER_MARK_ARM;- painter.line_segment([mid - arm, mid + arm], stroke);- }- }- if ab.show_video_safe_areas {- for area in ab.video_safe_areas() {- painter.add(Shape::closed_line(xf.quad(area), stroke));- }- }-}--/// Artboard `name` above its top-left `corner` on screen, no wider than the artboard (`width` on-/// screen): a longer name ends in "…", and an artboard too narrow shows none (#949).-fn artboard_label(painter: &egui::Painter, corner: Pos2, width: f32, name: &str, color: Color32) {- if let Some((galley, at)) = canvas_name_galley(painter, corner, width, name, color) {- painter.galley(at, galley, color);- }-}--fn canvas_name_rect(painter: &egui::Painter, corner: Pos2, width: f32, name: &str) -> Option<egui::Rect> {- canvas_name_galley(painter, corner, width, name, Color32::WHITE).map(|(galley, at)| egui::Rect::from_min_size(at, galley.size()).expand(2.0))-}--/// Where the Artboard tool draws "01 - name" for its active artboard (see its overlay label).-fn tool_name_rect(painter: &egui::Painter, xf: &Xf, rect: Rect, index: usize, name: &str) -> egui::Rect {- let z = xf.zoom.max(1e-9);- let anchor = Point::new(rect.x0 - 8.0 / z, rect.y0 - 4.0 / z);- let sp = xf.to_screen(anchor) + vec2(8.0, -14.0);- let galley = painter.layout(format!("{:02} - {name}", index + 1), egui::FontId::proportional(11.0), Color32::WHITE, f32::INFINITY);- egui::Rect::from_min_size(sp, galley.size()).expand(2.0)-}--/// The artboard whose on-canvas name contains `screen`, if that name is being drawn.-fn artboard_name_at(app: &VectorcraftApp, ui: &Ui, xf: &Xf, screen: Pos2) -> Option<usize> {- let st = app.session.active()?;- let artboard_tool = app.session.tool_id() == "artboard";- if !artboard_tool && st.doc.artboards.len() <= 1 {- return None;- }- let tool_labelled = artboard_tool.then(|| app.session.tool_options()["active"].as_u64()).flatten();- let painter = ui.painter();- let mut hit = None;- for (i, ab) in st.doc.artboards.iter().enumerate() {- if tool_labelled == u64::try_from(i).ok() {- continue;- }- let corner = xf.to_screen(Point::new(ab.rect.x0, ab.rect.y0));- let width = (ab.rect.width() * xf.zoom) as f32;- let text = format!("{:02} - {}", i + 1, ab.name);- if canvas_name_rect(painter, corner, width, &text).is_some_and(|r| r.contains(screen)) {- hit = Some(i);- }- }- if let Some(i) = tool_labelled.and_then(|i| usize::try_from(i).ok())- && let Some(ab) = st.doc.artboards.get(i)- && tool_name_rect(painter, xf, ab.rect, i, &ab.name).contains(screen)- {- return Some(i);- }- hit-}--fn select_named_artboard(app: &mut VectorcraftApp, index: usize) {- let n = app.session.active().map(|st| st.doc.artboards.len()).unwrap_or(0);- if index >= n {- return;- }- if let Some(v) = app.view_mut() {- v.artboard = index;- }- if app.session.tool_id() == "artboard" {- app.session.set_tool_option("active", &json!(index));- }-}--/// Start editing artboard `index`'s name on the canvas, unless the artboard is locked (the-/// Artboards panel still renames it).-fn begin_artboard_name_edit(ui: &Ui, app: &VectorcraftApp, index: usize) {- let Some(name) = app.session.active().and_then(|st| st.doc.artboards.get(index).filter(|a| !a.locked).map(|a| a.name.clone())) else { return };- ui.data_mut(|d| d.insert_temp(name_edit_id(), ArtboardNameEdit { index, text: name, fresh: true }));-}--fn commit_artboard_name(app: &mut VectorcraftApp, index: usize, text: &str) {- let trimmed = text.trim();- if trimmed.is_empty() {- return;- }- let current = app.session.active().and_then(|st| st.doc.artboards.get(index).map(|a| a.name.clone()));- if current.as_deref() == Some(trimmed) {- return;- }- // A refusal is reported by the command; the label just closes.- app.run("artboard.setProps", json!({ "index": index, "name": trimmed })).ok();-}--/// The text field over an artboard name a double-click opened.-fn artboard_name_editor(app: &mut VectorcraftApp, ui: &mut Ui, xf: &Xf) {- let Some(mut edit) = ui.data(|d| d.get_temp::<ArtboardNameEdit>(name_edit_id())) else { return };- let alive = app.session.active().is_some_and(|st| edit.index < st.doc.artboards.len());- if !alive {- ui.data_mut(|d| d.remove::<ArtboardNameEdit>(name_edit_id()));- return;- }- let Some(rect) = artboard_name_field_rect(app, ui, xf, edit.index) else {- ui.data_mut(|d| d.remove::<ArtboardNameEdit>(name_edit_id()));- return;- };- let fresh = edit.fresh;- edit.fresh = false;- let te = ui.put(- rect,- egui::TextEdit::singleline(&mut edit.text)- .id(name_edit_id().with("field"))- .font(egui::FontId::proportional(11.0))- // Keep the original inset so theme button padding cannot move the canvas label.- .margin(egui::Margin::symmetric(4, 2)),- );- if fresh || (!te.has_focus() && !te.lost_focus()) {- te.request_focus();- }- let done = !fresh && te.lost_focus();- let escape = ui.input(|i| i.key_pressed(egui::Key::Escape));- let (index, text) = (edit.index, edit.text.clone());- if done {- ui.data_mut(|d| d.remove::<ArtboardNameEdit>(name_edit_id()));- if !escape {- commit_artboard_name(app, index, &text);- }- } else {- ui.data_mut(|d| d.insert_temp(name_edit_id(), edit));- }-}--/// Where the rename field sits: the name label's rectangle, at least wide enough to type in.-fn artboard_name_field_rect(app: &VectorcraftApp, ui: &Ui, xf: &Xf, index: usize) -> Option<egui::Rect> {- let st = app.session.active()?;- let ab = st.doc.artboards.get(index)?;- let artboard_tool = app.session.tool_id() == "artboard";- let tool_labelled = artboard_tool.then(|| app.session.tool_options()["active"].as_u64()).flatten();- let painter = ui.painter();- let rect = if tool_labelled == u64::try_from(index).ok() {- tool_name_rect(painter, xf, ab.rect, index, &ab.name)- } else {- let corner = xf.to_screen(Point::new(ab.rect.x0, ab.rect.y0));- let width = (ab.rect.width() * xf.zoom) as f32;- canvas_name_rect(painter, corner, width, &format!("{:02} - {}", index + 1, ab.name))?- };- Some(egui::Rect::from_min_size(rect.min, vec2(rect.width().max(80.0), rect.height().max(16.0))))-}--/// Is overlay label `text` the Artboard tool's "01 - <artboard name>"? It holds a name, so it is-/// shown as it is; the tools' other labels ("anchor", "path", Puppet Warp's warning) are ours.-fn names_an_artboard(text: &str) -> bool {- text.split_once(" - ").is_some_and(|(n, _)| n.len() >= 2 && n.bytes().all(|b| b.is_ascii_digit()))-}--fn draw_overlays(p: &egui::Painter, xf: &Xf, overlays: &[Overlay], t: &Tokens, look: HandleLook) {- for o in overlays {- match o {- // Where the tools select: the document rectangle, turned with the view.- Overlay::Marquee(r) => marquee_through(p, &xf.quad(*r)),- Overlay::Path { path, color, width, dashed } => {- let s = Stroke::new(*width, c32(*color));- if *dashed {- for line in to_screen_path(path, xf) {- p.extend(Shape::dashed_line(&line, s, 4.0, 3.0));- }- } else {- stroke_path(p, path, xf, s);- }- }- Overlay::Line { a, b, color, dashed } => {- let s = Stroke::new(1.0, c32(*color));- let (a, b) = (xf.to_screen(*a), xf.to_screen(*b));- if *dashed {- p.extend(Shape::dashed_line(&[a, b], s, 4.0, 3.0));- } else {- p.line_segment([a, b], s);- }- }- Overlay::Anchor { p: pt, color, filled, size } => anchor_square(p, xf.to_screen(*pt), c32(*color), *filled, *size),- Overlay::CurvePoint { p: pt, color, filled, size } => curve_point(p, xf.to_screen(*pt), c32(*color), *filled, *size + look.grow),- Overlay::Handle { p: pt, color } => look.draw(p, xf.to_screen(*pt), c32(*color)),- Overlay::Label { p: pt, text, color } => {- let sp = xf.to_screen(*pt) + vec2(8.0, -14.0);- p.text(- sp,- egui::Align2::LEFT_TOP,- crate::panels::label_or_name(text, !names_an_artboard(text)),- egui::FontId::proportional(11.0),- c32(*color),- );- }- Overlay::Highlight { quad, color } => {- let c = Color32::from_rgba_unmultiplied(color[0], color[1], color[2], color[3]);- p.add(Shape::convex_polygon(quad.iter().map(|q| xf.to_screen(*q)).collect(), c, Stroke::NONE));- }- Overlay::Measure { p: pt, text } => {- let sp = xf.to_screen(*pt) + vec2(14.0, 14.0);- let galley = p.layout(text.clone(), egui::FontId::proportional(11.0), Color32::WHITE, 200.0);- let r = egui::Rect::from_min_size(sp, galley.size() + vec2(12.0, 8.0));- p.rect_filled(r, CornerRadius::same(3), t.measure_bg);- p.galley(sp + vec2(6.0, 4.0), galley, Color32::WHITE);- }- Overlay::Distance { a, b, text, color } => distance_guide(p, xf.to_screen(*a), xf.to_screen(*b), text, c32(*color)),- Overlay::GridLine { a, b, color } => {- let c = Color32::from_rgba_unmultiplied(color[0], color[1], color[2], color[3]);- p.line_segment([xf.to_screen(*a), xf.to_screen(*b)], Stroke::new(1.0, c));- }- Overlay::Swatch { p: pt, color, selected } => {- // A white disc under the colour shows its opacity; a dark rim keeps it readable on- // any art, and the accent ring marks the selected stop.- let c = xf.to_screen(*pt);- p.circle_filled(c, 6.0, Color32::WHITE);- p.circle_filled(c, 5.0, Color32::from_rgba_unmultiplied(color[0], color[1], color[2], color[3]));- p.circle_stroke(c, 6.0, Stroke::new(1.0, Color32::from_gray(32)));- if *selected {- p.circle_stroke(c, 8.0, Stroke::new(2.0, t.accent));- }- }- }- }-}--/// A Distance Guides measurement on screen ([`Overlay::Distance`]): the line from `a` to `b` in the-/// smart guide colour `color` with a 4 px tick across each end, and `text` in a pill of that colour-/// on its middle, in white or black, whichever reads on it.-fn distance_guide(p: &egui::Painter, a: Pos2, b: Pos2, text: &str, color: Color32) {- let s = Stroke::new(1.0, color);- p.line_segment([a, b], s);- let along = b - a;- let len = along.length();- if len > 0.0 && len.is_finite() {- let across = vec2(-along.y, along.x) / len * 4.0;- for end in [a, b] {- p.line_segment([end - across, end + across], s);- }- }- let luma = 0.299 * f32::from(color.r()) + 0.587 * f32::from(color.g()) + 0.114 * f32::from(color.b());- let ink = if luma > 150.0 { Color32::BLACK } else { Color32::WHITE };- let galley = p.layout_no_wrap(text.to_owned(), egui::FontId::proportional(11.0), ink);- let r = egui::Rect::from_center_size(a + along / 2.0, galley.size() + vec2(8.0, 4.0));- p.rect_filled(r, CornerRadius::same(3), color);- p.galley(r.min + vec2(4.0, 2.0), galley, ink);-}--/// The Home screen (`app.home`; with no document open, unless its preference is off).-fn home(app: &mut VectorcraftApp, ui: &mut Ui, rect: egui::Rect) {- let t = Tokens::get(ui.ctx());- ui.painter().rect_filled(rect, 0.0, t.panel_darker);- // Taller than the window (a small window, many recent files): it scrolls. Widgets scrolled out- // of view are clipped, so they take no pointer.- let mut child = ui.new_child(egui::UiBuilder::new().max_rect(rect).layout(egui::Layout::top_down(egui::Align::Min)));- egui::ScrollArea::vertical().id_salt("home-scroll").auto_shrink([false, false]).show(&mut child, |ui| {- let side = (ui.available_width() - 820.0).max(40.0) / 2.0;- let width = (ui.available_width() - 2.0 * side).max(0.0);- ui.add_space(60.0);- ui.horizontal_top(|ui| {- ui.add_space(side);- ui.allocate_ui_with_layout(vec2(width, 0.0), egui::Layout::top_down(egui::Align::Min), |ui| {- ui.set_width(width);- home_content(app, ui);- });- });- ui.add_space(60.0);- });-}--/// The Home screen's column: welcome, New / Open, Recent Files, presets and community links.-fn home_content(app: &mut VectorcraftApp, ui: &mut Ui) {- let t = Tokens::get(ui.ctx());- ui.label(egui::RichText::new(tl!("Welcome to VectorCraft")).font(theme::semibold(26.0)).color(t.text));- ui.add_space(4.0);- ui.label(egui::RichText::new(tl!("Vector illustration — fast, open, scriptable.")).size(14.0).color(t.text_dim));- ui.add_space(22.0);- ui.horizontal(|ui| {- if widgets::primary_button(ui, tl!("New file")).clicked() {- app.run("file.newDialog", json!({})).ok();- }- ui.add_space(8.0);- if widgets::secondary_button(ui, tl!("Open")).clicked() {- app.run("file.open", json!({})).ok();- }- });- recent(app, ui);- ui.add_space(28.0);- ui.label(egui::RichText::new(tl!("Quickly start a new file")).font(theme::semibold(14.0)).color(t.text));- ui.add_space(10.0);- // A few of New Document's presets (`file.newPresets`), as its cards.- let presets = ["Letter", "A4", "Web 1920×1080", "Phone 390×844", "Postcard", "Social Square Post 1080×1080"];- ui.horizontal_wrapped(|ui| {- ui.spacing_mut().item_spacing = vec2(14.0, 14.0);- let cards: Vec<_> = presets.iter().filter_map(|name| vectorcraft_engine::cmd::newdoc::find(&app.session, name)).collect();- for s in cards {- if crate::dialogs::preset_card(ui, &s, false).clicked() {- app.run("file.new", json!({ "preset": s.name })).ok();- }- }- });- ui.add_space(28.0);- ui.label(egui::RichText::new(tl!("Community")).font(theme::semibold(14.0)).color(t.text));- ui.add_space(10.0);- crate::community::links(app, ui);-}--/// The Home screen's Recent Files (#663): the first of File › Open Recent Files, each its name and-/// folder; a click opens it. Nothing when there are none.-fn recent(app: &mut VectorcraftApp, ui: &mut Ui) {- const SHOWN: usize = 6;- let files: Vec<String> = crate::io::recent_files(app).iter().take(SHOWN).cloned().collect();- if files.is_empty() {- return;- }- let t = Tokens::get(ui.ctx());- ui.add_space(28.0);- ui.label(egui::RichText::new(tl!("Recent Files")).font(theme::semibold(14.0)).color(t.text));- ui.add_space(8.0);- for path in files {- if recent_row(ui, &path).clicked() {- // A failure is reported to the user there.- let _ = crate::io::open_recent_reporting(app, &path);- }- }-}--/// One Recent Files row across the Home screen: history icon, name (accent) and folder (dim,-/// truncated). The whole row is one button that lights up under the pointer; its tooltip is the-/// full path.-fn recent_row(ui: &mut Ui, path: &str) -> egui::Response {- const PAD: f32 = 6.0;- const ICON: f32 = 16.0;- let t = Tokens::get(ui.ctx());- let p = std::path::Path::new(path);- let name = p.file_name().map_or_else(|| path.to_string(), |n| n.to_string_lossy().into_owned());- let folder = p.parent().map(|f| f.to_string_lossy().into_owned()).unwrap_or_default();- let (rect, resp) = ui.allocate_exact_size(vec2(ui.available_width(), 26.0), egui::Sense::click());- if ui.is_rect_visible(rect) {- if resp.hovered() {- ui.painter().rect_filled(rect, CornerRadius::same(4), t.hover);- }- let icon = egui::Rect::from_center_size(egui::pos2(rect.left() + PAD + ICON / 2.0, rect.center().y), vec2(ICON, ICON));- crate::icons::paint(ui, "history", icon, t.icon);- let x = icon.right() + 8.0;- let name_galley = egui::WidgetText::from(egui::RichText::new(&name).size(13.0).color(t.accent)).into_galley(- ui,- Some(egui::TextWrapMode::Truncate),- (rect.right() - PAD - x).max(0.0),- egui::TextStyle::Body,- );- let folder_x = x + name_galley.size().x + 10.0;- ui.painter().galley(egui::pos2(x, rect.center().y - name_galley.size().y / 2.0), name_galley, t.accent);- let room = rect.right() - PAD - folder_x;- if room > 0.0 && !folder.is_empty() {- let folder_galley = egui::WidgetText::from(egui::RichText::new(&folder).size(12.0).color(t.text_dim)).into_galley(- ui,- Some(egui::TextWrapMode::Truncate),- room,- egui::TextStyle::Body,- );- ui.painter().galley(egui::pos2(folder_x, rect.center().y - folder_galley.size().y / 2.0), folder_galley, t.text_dim);- }- }- resp.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, true, &name));- resp.on_hover_text(path).on_hover_cursor(egui::CursorIcon::PointingHand)-}--fn kurbo_flatten(p: &BezPath, tol: f64, f: &mut impl FnMut(PathEl)) {- // Bounded per curve: a document's far-out handles, zoomed onto the screen, made kurbo- // reserve gigabytes for the selection outline.- vectorcraft_geom::flatten(p.elements().iter().copied(), tol, f);-}--/// The rendered raster `img` as an egui image. Both are premultiplied RGBA8, so its bytes are copied-/// over whole instead of pixel by pixel, which costs milliseconds for a canvas on a large screen.-/// A raster whose bytes don't match its size gives an empty image of that size.-pub(crate) fn color_image(img: &vectorcraft_render::Rendered) -> egui::ColorImage {- let size = [img.width as usize, img.height as usize];- let mut pixels = vec![egui::Color32::TRANSPARENT; size[0] * size[1]];- let bytes: &mut [u8] = bytemuck::cast_slice_mut(&mut pixels);- if bytes.len() == img.pixels.len() {- bytes.copy_from_slice(&img.pixels);- }- egui::ColorImage::new(size, pixels)-}--/// The pixels of the `w`×`h` frame through `view` to render again for `doc`, when only the document-/// changed, or placed documents' bitmaps were made, since the frame shown (its key `key` but for-/// the revision and [`CacheKey::placed`], and its render options `opts`), which this thread-/// rendered, and no frame is on its way from the worker: those it changed in, and those the-/// objects showing those bitmaps' files cover (`Some(None)`: none), grown to whole eighths of the-/// frame, as long as they are at most half of it. None: render the whole frame. Frames the worker-/// renders stay whole: its renderer keeps the rasters of the art's effects, this thread's doesn't.-fn changed_pixels(- app: &VectorcraftApp,- key: &CacheKey,- doc: &vectorcraft_doc::Document,- opts: &vectorcraft_render::RenderOptions,- view: Affine,- w: u32,- h: u32,-) -> Option<Option<[u32; 4]>> {- let (shown, _) = app.canvas.shown.as_ref().filter(|(_, o)| o == opts)?;- // A viewed opacity mask shows its coverage wherever its art reaches, past its object's bounds.- if opts.mask_view.is_some() {- return None;- }- let shown_key = app.canvas.key.as_ref()?;- let same_view = *shown_key == CacheKey { revision: shown_key.revision, placed: shown_key.placed, ..key.clone() };- if !same_view || app.canvas.texture.is_none() || app.canvas.from_worker || app.canvas.worker.as_ref().is_some_and(|w| w.pending.is_some()) {- return None;- }- // The placed documents' files whose bitmaps were made since the frame shown.- let placed = if shown_key.placed == key.placed {- vectorcraft_render::Changed::Nothing- } else {- vectorcraft_render::placed_area(doc, &vectorcraft_render::placed_document::made_between(shown_key.placed, key.placed)?)- };- match vectorcraft_render::changed(shown, doc).and(placed) {- vectorcraft_render::Changed::Nothing => Some(None),- vectorcraft_render::Changed::Area(area) => match vectorcraft_render::view_pixels(area, view, w, h) {- None => Some(None),- Some([x0, y0, x1, y1]) => {- let ((x0, x1), (y0, y1)) = (in_steps(x0, x1, w), in_steps(y0, y1, h));- (u64::from(x1 - x0) * u64::from(y1 - y0) * 2 <= u64::from(w) * u64::from(h)).then_some(Some([x0, y0, x1, y1]))- }- },- vectorcraft_render::Changed::Everything => None,- }-}--/// `a..b` of `0..n`, grown to whole eighths of `n` and moved back into `0..n`: the parts of a-/// frame rendered again come in few sizes, which keep the contexts the renderer keeps.-fn in_steps(a: u32, b: u32, n: u32) -> (u32, u32) {- let step = n.div_ceil(8).max(1);- let len = (b - a).max(1).div_ceil(step).saturating_mul(step).min(n);- let a = a.min(n - len);- (a, a + len)-}--/// Upload the art's raster; Pixel Preview's document pixels keep hard edges when magnified.-fn upload(app: &mut VectorcraftApp, ctx: &egui::Context, img: &vectorcraft_render::Rendered, pixel: bool) {- let color = color_image(img);- let options = if pixel { egui::TextureOptions::NEAREST } else { egui::TextureOptions::LINEAR };- match &mut app.canvas.texture {- Some(tex) => tex.set(color, options),- None => app.canvas.texture = Some(ctx.load_texture("canvas", color, options)),- }-}--/// Pixel Preview: the whole document pixels (x0, y0, x1, y1) under the canvas, rotated view-/// included. None when the view is degenerate.-fn pixel_region(xf: &Xf) -> Option<[i64; 4]> {- let r = xf.rect;- let corners = [r.left_top(), r.right_top(), r.right_bottom(), r.left_bottom()].map(|p| xf.to_doc(p));- let (mut x0, mut y0, mut x1, mut y1) = (f64::INFINITY, f64::INFINITY, f64::NEG_INFINITY, f64::NEG_INFINITY);- for p in corners {- (x0, y0, x1, y1) = (x0.min(p.x), y0.min(p.y), x1.max(p.x), y1.max(p.y));- }- let (x0, y0, x1, y1) = (x0.floor(), y0.floor(), x1.ceil(), y1.ceil());- // A document pixel is bigger than a screen pixel here, so the region is about canvas-sized.- let ok = [x0, y0, x1, y1].iter().all(|c| c.is_finite() && c.abs() < 1e9) && x1 > x0 && y1 > y0 && x1 - x0 <= 16384.0 && y1 - y0 <= 16384.0;- ok.then_some([x0 as i64, y0 as i64, x1 as i64, y1 as i64])-}--/// The Contextual Task Bar's area.-fn task_bar_id() -> egui::Id {- egui::Id::unique("task-bar")-}--/// Where the Contextual Task Bar was last drawn (none while it isn't shown).-pub(crate) fn task_bar_rect(ctx: &egui::Context) -> Option<egui::Rect> {- let id = task_bar_id();- ctx.memory(|m| m.areas().is_visible(&egui::LayerId::new(egui::Order::Middle, id)).then(|| m.area_rect(id)).flatten())-}--/// Whether the objects `ids` (or anything inside them) are painted with a colour: a solid colour,-/// a gradient's stops or a mesh's points, which Recolor Artwork can change.-pub(crate) fn has_colors(doc: &vectorcraft_doc::Document, ids: &[vectorcraft_doc::NodeId]) -> bool {- ids.iter().filter_map(|id| doc.node(*id)).any(|n| {- let mut found = false;- vectorcraft_doc::swatches::node_colors(n, &mut |_, _| found = true);- found- })-}--/// The bounds of the artboards the Artboard tool has selected ([`crate::panels::artboards::picked`]).-fn picked_artboards_bounds(app: &VectorcraftApp) -> Option<Rect> {- let st = app.session.active()?;- let picked = crate::panels::artboards::picked(app, st.doc.artboards.len());- picked.iter().filter_map(|i| st.doc.artboards.get(*i)).map(|a| a.rect).reduce(|a, b| a.union(b))-}--/// The Contextual Task Bar: a floating pill under the selection with the most likely next actions.-/// With the Artboard tool it sits under the selected artboards and offers Resize (Artboard-/// Options), Duplicate, Rearrange All (with two or more artboards) and Export (Export for Screens).-/// Its handle drags it anywhere on the canvas; unpinned it keeps that offset as it follows the-/// selection, pinned it stays put ([`crate::state::TaskBarPlace`]).-fn task_bar(app: &mut VectorcraftApp, ui: &mut Ui, xf: &Xf) {- let t = Tokens::get(ui.ctx());- let on_artboards = app.session.tool_id() == "artboard";- if !on_artboards- && (app.session.active().is_none_or(|st| st.selection.is_empty())- || !matches!(app.session.tool_id(), "selection" | "directSelection" | "groupSelection"))- {- return;- }- let Some(b) = (if on_artboards { picked_artboards_bounds(app) } else { app.selection_bounds() }) else { return };- let Some(st) = app.session.active() else { return };- let n = st.selection.len();- let first = st.selection.objects.first().and_then(|id| st.doc.node(*id)).cloned();- let is_group = first.as_ref().is_some_and(|f| matches!(f.kind, NodeKind::Group { .. }));- let is_image = first.as_ref().is_some_and(|f| matches!(f.kind, NodeKind::Image(_)));- let is_clip_group = first.as_ref().is_some_and(|f| matches!(f.kind, NodeKind::Group { clip: true, .. }));- let is_compound = first.as_ref().is_some_and(|f| matches!(f.kind, NodeKind::Compound { .. }));- let open_path = first.as_ref().is_some_and(|f| matches!(&f.kind, NodeKind::Path { path, .. } if !path.is_closed()));- let text = first.as_ref().and_then(|f| match &f.kind {- NodeKind::Text(t) => Some(&t.kind),- _ => None,- });- // Images and vector art selected together: a clipping mask is the likely next step.- let mixed = n > 1 && {- let images = st.selection.objects.iter().filter_map(|id| st.doc.node(*id)).filter(|o| matches!(o.kind, NodeKind::Image(_))).count();- images > 0 && images < n- };- // An Image Trace object: the group the engine names "Image Trace", its source image first.- let is_trace = is_group- && first.as_ref().is_some_and(|f| {- f.name.as_deref() == Some("Image Trace") && f.children().is_some_and(|c| c.first().is_some_and(|i| matches!(i.kind, NodeKind::Image(_))))- });- let mut items: Vec<(&str, &str, &str, serde_json::Value)> = vec![]; // (label, icon, command, params)- let none = || json!({});- if on_artboards {- // As in the reference app, the Artboard tool offers to resize, duplicate and export the- // artboards (<https://community.adobe.com/questions-652/contextual-task-bar-in-illustrator-2025-quick-actions-when-you-need-them-1546580>),- // and to rearrange them (<https://creativepro.com/managing-artboards-in-illustrator/>).- items.push((tl!("Resize"), "move-diagonal-2", TASK_BAR_ARTBOARD_OPTIONS, none()));- items.push((tl!("Duplicate"), "copy", TASK_BAR_DUPLICATE_ARTBOARDS, none()));- if st.doc.artboards.len() > 1 {- items.push((tl!("Rearrange All"), "dc-rearrange", TASK_BAR_REARRANGE_ARTBOARDS, none()));- }- items.push((tl!("Export"), "share-2", "file.exportForScreens", none()));- } else {- // Edit Path: the Direct Selection tool, to edit the path's anchors.- let edit_path = || (tl!("Edit Path"), "dc-direct", "tool.select", json!({"tool": "directSelection"}));- // As in the reference app, an image offers Image Trace and Crop Image, and traced art offers- // Expand (<https://community.adobe.com/announcements-651/contextual-task-bar-in-illustrator-2025-quick-actions-when-you-need-them-1546580>).- if n == 1 && is_image {- items.push((tl!("Image Trace"), "image", TASK_BAR_IMAGE_TRACE, none()));- items.push((tl!("Crop Image"), "dc-pf-crop", "ui.cropImage", none()));- }- // Direct-selected anchors take the place of a path's Offset Path and Simplify. For them the bar- // offers Remove, Connect, Cut and Convert to corner or smooth, as the reference app does- // (<https://helpx.adobe.com/illustrator/desktop/get-started/learn-the-basics/contextual-task-bar-overview.html>).- // These run the same commands as the Control bar's anchor buttons.- let anchors = !st.selection.anchors.is_empty();- if anchors {- items.push((tl!("Remove Anchor Points"), "pen-tool-delete", "path.removeAnchors", none()));- items.push((tl!("Connect"), "dc-join", "path.join", none()));- items.push((tl!("Cut Path"), "scissors", "path.cutAtAnchors", none()));- items.push((tl!("Corner"), "dc-anchor", TASK_BAR_TO_CORNER, none()));- items.push((tl!("Smooth"), "dc-anchor-smooth", TASK_BAR_TO_SMOOTH, none()));- }- // As in the reference app, open paths offer Join and Edit Path, compound paths and clipping- // masks their Release, images selected with vector art Make Clipping Mask, and type converts- // between point and area type (<https://helpx.adobe.com/illustrator/desktop/get-started/learn-the-basics/contextual-task-bar-overview.html>).- if n > 1 {- items.push((tl!("Group"), "group", "object.group", none()));- if mixed {- items.push((tl!("Make Clipping Mask"), "dc-pf-crop", "object.clippingMask.make", none()));- } else {- items.push((tl!("Unite"), "squares-unite", "object.pathfinder.unite", none()));- }- } else if is_trace {- items.push((tl!("Expand"), "maximize-2", "imageTrace.expand", none()));- } else if is_clip_group {- items.push((tl!("Edit Clipping Path"), "dc-direct", "object.clippingMask.editMask", none()));- items.push((tl!("Release Clipping Mask"), "ungroup", "object.clippingMask.release", none()));- } else if is_group {- items.push((tl!("Ungroup"), "ungroup", "object.ungroup", none()));- items.push((tl!("Isolate"), "square-dashed", "object.isolate", none()));- } else if is_compound {- items.push(edit_path());- items.push((tl!("Release Compound Path"), "ungroup", "object.compoundPath.release", none()));- } else if let Some(kind) = text {- items.push((tl!("Create Outlines"), "type", "type.createOutlines", none()));- // Point type converts to area type and back; type on a path doesn't.- match kind {- TextKind::Area { .. } => items.push((tl!("Convert To Point Type"), "type", "type.convertToPointType", none())),- TextKind::Point => items.push((tl!("Convert To Area Type"), "dc-type-area", "type.convertToAreaType", none())),- TextKind::OnPath { .. } => {}- }- } else if is_image {- // Offset Path and Simplify don't apply to an image.- } else if !anchors {- if open_path {- items.push((tl!("Join"), "dc-join", "path.join", none()));- }- items.push(edit_path());- items.push((tl!("Offset Path"), "square-dashed", "object.path.offsetPath", none()));- items.push((tl!("Simplify"), "spline", "object.path.simplify", none()));- }- items.push((tl!("Duplicate"), "copy", "edit.duplicate", none()));- }- let fill = first.as_ref().map(|f| f.appearance.fill_paint()).unwrap_or_default();- let colored = has_colors(&st.doc, &st.selection.objects);- let doc = st.uid;- // Under the selection's lowest corner on screen, centered on the selection (the view may be- // rotated).- let lowest = xf.quad(b).iter().map(|c| c.y).fold(f32::NEG_INFINITY, f32::max);- let anchor = pos2(xf.to_screen(b.center()).x, lowest);- let est_w = 118.0 + items.iter().map(|(l, _, _, _)| l.len() as f32 * 7.2 + 44.0).sum::<f32>();- // Its place under the selection, then where the handle moved it, kept on the canvas (with the- // bar's size last frame, the estimate before it first shows).- let under = pos2(anchor.x - est_w / 2.0, anchor.y + 28.0);- let id = task_bar_id();- let size = egui::AreaState::load(ui.ctx(), id).and_then(|s| s.size).unwrap_or(vec2(est_w, 44.0));- let bounds = xf.rect.shrink(8.0);- let keep_in = |p: Pos2| p.clamp(bounds.min, (bounds.max - size).max(bounds.min));- let place = &mut app.ui.task_bar_place;- // Just unpinned: follow the selection from the pinned spot.- if !place.pinned- && let Some(at) = place.pin_at.take()- {- place.offset = Some((doc, xf.rect.min + at - under));- }- let pos = keep_in(match place.pin_at {- Some(at) => xf.rect.min + at,- None => under + place.offset.filter(|(d, _)| *d == doc).map_or(Vec2::ZERO, |(_, o)| o),- });- place.shown_at = Some(pos - xf.rect.min);- // Pinned before it ever showed: hold it here.- if place.pinned && place.pin_at.is_none() {- place.pin_at = place.shown_at;- }- let pinned = place.pinned;- let mut moved = Vec2::ZERO;- let mut run: Option<(&str, serde_json::Value)> = None;- egui::Area::new(id).order(egui::Order::Middle).fixed_pos(pos).show(ui.ctx(), |ui| {- egui::Frame::NONE- .fill(t.panel)- .stroke(Stroke::new(1.0, t.tool_active))- .corner_radius(CornerRadius::same(5))- .inner_margin(egui::Margin::symmetric(8, 6))- .shadow(egui::epaint::Shadow { offset: [0, 3], blur: 10, spread: 0, color: Color32::from_black_alpha(70) })- .show(ui, |ui| {- ui.horizontal(|ui| {- ui.spacing_mut().item_spacing.x = 6.0;- let (g, grip) = ui.allocate_exact_size(vec2(4.0, 28.0), Sense::drag());- let active = grip.hovered() || grip.dragged();- ui.painter().rect_filled(g.shrink2(vec2(0.5, 4.0)), CornerRadius::same(2), if active { t.text_dim } else { t.button_border });- if grip.dragged() {- ui.ctx().set_cursor_icon(egui::CursorIcon::Grabbing);- moved = grip.drag_delta();- } else if grip.hovered() {- ui.ctx().set_cursor_icon(egui::CursorIcon::Grab);- }- for (label, icon, cmd, params) in &items {- let galley = ui.painter().layout_no_wrap(label.to_string(), egui::FontId::proportional(13.0), t.text_strong);- let (r, resp) = ui.allocate_exact_size(vec2(galley.size().x + 38.0, 30.0), Sense::click());- if resp.hovered() {- ui.painter().rect_filled(r, CornerRadius::same(3), t.hover);- }- ui.painter().rect_stroke(r, CornerRadius::same(3), Stroke::new(1.0, t.button_border), StrokeKind::Inside);- crate::icons::paint(ui, icon, egui::Rect::from_min_size(r.min + vec2(8.0, 7.0), vec2(16.0, 16.0)), t.icon);- ui.painter().galley(pos2(r.left() + 30.0, r.center().y - galley.size().y / 2.0), galley, t.text_strong);- if resp.clicked() {- run = Some((*cmd, params.clone()));- }- }- // The selected objects' Fill, Recolor Artwork and Lock, left out with the Artboard tool.- if !on_artboards {- let (r, resp) = ui.allocate_exact_size(vec2(26.0, 30.0), Sense::click());- widgets::paint_chip(ui, egui::Rect::from_center_size(r.center(), vec2(16.0, 16.0)), &fill);- ui.painter().rect_stroke(- egui::Rect::from_center_size(r.center(), vec2(16.0, 16.0)),- 0.0,- Stroke::new(1.0, t.button_border),- StrokeKind::Outside,- );- if resp.on_hover_text(tl!("Fill")).clicked() {- app.session.fill_active = true;- app.ui.open_panel = Some("swatches".into());- }- // Recolor Artwork, when the selection has colours to recolour.- if colored && widgets::icon_button(ui, "palette", tl!("Recolor Artwork"), false, 30.0).clicked() {- run = Some(("ui.recolorDialog", json!({})));- }- if widgets::icon_button(ui, "lock", tl!("Lock (⌘2)"), false, 30.0).clicked() {- run = Some(("object.lock", json!({})));- }- }- let more = widgets::icon_button(ui, "ellipsis", tl!("More Options"), false, 30.0);- egui::Popup::menu(&more).show(|ui| {- ui.set_min_width(170.0);- let bar = [- (tl!("Hide Bar"), "window.taskBar", false),- (tl!("Pin Bar Position"), "window.taskBar.pin", pinned),- (tl!("Reset Bar Position"), "window.taskBar.reset", false),- ];- for (label, cmd, checked) in bar {- if widgets::menu_item(ui, label, true, checked) {- run = Some((cmd, json!({})));- }- }- ui.separator();- if widgets::menu_item(ui, tl!("Show Properties Panel"), true, false) {- run = Some(("window.panel", json!({"panel": "properties"})));- }- });- });- });- });- if moved != Vec2::ZERO {- let to = keep_in(pos + moved);- let place = &mut app.ui.task_bar_place;- if place.pinned {- place.pin_at = Some(to - xf.rect.min);- } else {- place.offset = Some((doc, to - under));- }- ui.ctx().request_repaint();- }- match run {- // Image Trace traces the image at once with the Default preset. As a quick trace from- // Properties or the Control bar, it leaves the Image Trace panel as it was.- Some((TASK_BAR_IMAGE_TRACE, _)) => crate::menus::invoke(app, "imageTrace.make", json!({"preset": "Default"})),- // The Artboard tool's buttons: Artboard Options for the active artboard, as Properties'- // icon opens it; Duplicate for every selected artboard; Rearrange All Artboards.- Some((TASK_BAR_ARTBOARD_OPTIONS, _)) => crate::menus::invoke(app, "tool.options", json!({"tool": "artboard"})),- Some((TASK_BAR_DUPLICATE_ARTBOARDS, _)) => crate::panels::artboards::duplicate_picked(app),- Some((TASK_BAR_REARRANGE_ARTBOARDS, _)) => crate::panels::artboards::open_rearrange(app),- // Corner and Smooth convert the direct-selected anchors, as the Control bar's buttons do.- Some((TASK_BAR_TO_CORNER, _)) => crate::menus::invoke(app, "path.convertAnchors", json!({"to": "corner"})),- Some((TASK_BAR_TO_SMOOTH, _)) => crate::menus::invoke(app, "path.convertAnchors", json!({"to": "smooth"})),- Some((c, p)) => crate::menus::invoke(app, c, p),- None => {}- }-}--/// The Contextual Task Bar's Image Trace button: a trace with the Default preset.-const TASK_BAR_IMAGE_TRACE: &str = "taskBar.imageTrace";-/// The Contextual Task Bar's Resize button with the Artboard tool: Artboard Options.-const TASK_BAR_ARTBOARD_OPTIONS: &str = "taskBar.artboardOptions";-/// The Contextual Task Bar's Duplicate button with the Artboard tool.-const TASK_BAR_DUPLICATE_ARTBOARDS: &str = "taskBar.duplicateArtboards";-/// The Contextual Task Bar's Rearrange All button with the Artboard tool.-const TASK_BAR_REARRANGE_ARTBOARDS: &str = "taskBar.rearrangeArtboards";-/// The Contextual Task Bar's Corner button for direct-selected anchors.-const TASK_BAR_TO_CORNER: &str = "taskBar.toCorner";-/// The Contextual Task Bar's Smooth button for direct-selected anchors.-const TASK_BAR_TO_SMOOTH: &str = "taskBar.toSmooth";-#[cfg(test)]mod tests;diff --git a/crates/ui-egui/src/canvas/artboards.rs b/crates/ui-egui/src/canvas/artboards.rsnew file mode 100644index 000000000..986be51aa--- /dev/null+++ b/crates/ui-egui/src/canvas/artboards.rs@@ -0,0 +1,214 @@+use super::*;++/// The width an artboard needs on screen for its name to show (px): narrower, the name is left+/// out rather than spilling over its neighbours.+const MIN_LABELLED_ARTBOARD: f32 = 24.0;++/// Temp-memory key recording an artboard-name press before its edit field opens.+pub(super) fn name_press_id() -> egui::Id {+ egui::Id::unique("canvas-artboard-name-press")+}++/// Temp-memory key for the artboard name field currently being edited.+pub(super) fn name_edit_id() -> egui::Id {+ egui::Id::unique("canvas-artboard-name-edit")+}++/// A name being typed above an artboard. `fresh`: this frame opened it, so a focus loss from the+/// press that started it is not the user leaving the field.+#[derive(Clone)]+pub(super) struct ArtboardNameEdit {+ pub(super) index: usize,+ text: String,+ fresh: bool,+}++/// The canvas label for `name`, laid out as [`artboard_label`] draws it.+fn canvas_name_galley(painter: &egui::Painter, corner: Pos2, width: f32, name: &str, color: Color32) -> Option<(std::sync::Arc<egui::Galley>, Pos2)> {+ if !width.is_finite() || width < MIN_LABELLED_ARTBOARD {+ return None;+ }+ let mut job = egui::text::LayoutJob::simple_singleline(name.to_owned(), egui::FontId::proportional(11.0), color);+ job.wrap = egui::text::TextWrapping { max_width: width, max_rows: 1, break_anywhere: true, overflow_character: Some('…') };+ let galley = painter.layout_job(job);+ let at = corner - vec2(0.0, 4.0 + galley.size().y);+ Some((galley, at))+}++/// The length on screen, in points, of each arm of an artboard's center mark (a cross), at any zoom.+const CENTER_MARK_ARM: f32 = 6.0;++/// Artboard `ab`'s display marks in `color`, each line 1 point wide on screen at any zoom and+/// turned with the view: with Show Cross Hairs, a line from the middle of each side through the+/// center to the middle of the opposite side; with Show Center Mark, a cross at the center whose+/// arms run along the artboard's sides, [`CENTER_MARK_ARM`] long on screen+/// (https://helpx.adobe.com/illustrator/desktop/create-manage-artboards/organize-manage-artboards/modify-display-settings-of-artboards.html);+/// with Show Video Safe Areas, the outlines of its action-safe and title-safe areas+/// ([`vectorcraft_doc::Artboard::video_safe_areas`],+/// https://helpx.adobe.com/illustrator/desktop/create-manage-artboards/organize-manage-artboards/set-video-display-options-for-artboards.html).+pub(super) fn artboard_marks(painter: &egui::Painter, xf: &Xf, ab: &vectorcraft_doc::Artboard, color: Color32) {+ let (r, stroke) = (ab.rect, Stroke::new(1.0, color));+ let c = r.center();+ let at = |x: f64, y: f64| xf.to_screen(Point::new(x, y));+ if ab.show_cross_hairs {+ painter.line_segment([at(r.x0, c.y), at(r.x1, c.y)], stroke);+ painter.line_segment([at(c.x, r.y0), at(c.x, r.y1)], stroke);+ }+ if ab.show_center_mark {+ let mid = at(c.x, c.y);+ for side in [at(c.x + 1.0, c.y), at(c.x, c.y + 1.0)] {+ let arm = (side - mid).normalized() * CENTER_MARK_ARM;+ painter.line_segment([mid - arm, mid + arm], stroke);+ }+ }+ if ab.show_video_safe_areas {+ for area in ab.video_safe_areas() {+ painter.add(Shape::closed_line(xf.quad(area), stroke));+ }+ }+}++/// Artboard `name` above its top-left `corner` on screen, no wider than the artboard (`width` on+/// screen): a longer name ends in "…", and an artboard too narrow shows none (#949).+pub(super) fn artboard_label(painter: &egui::Painter, corner: Pos2, width: f32, name: &str, color: Color32) {+ if let Some((galley, at)) = canvas_name_galley(painter, corner, width, name, color) {+ painter.galley(at, galley, color);+ }+}++fn canvas_name_rect(painter: &egui::Painter, corner: Pos2, width: f32, name: &str) -> Option<egui::Rect> {+ canvas_name_galley(painter, corner, width, name, Color32::WHITE).map(|(galley, at)| egui::Rect::from_min_size(at, galley.size()).expand(2.0))+}++/// Where the Artboard tool draws "01 - name" for its active artboard (see its overlay label).+pub(super) fn tool_name_rect(painter: &egui::Painter, xf: &Xf, rect: Rect, index: usize, name: &str) -> egui::Rect {+ let z = xf.zoom.max(1e-9);+ let anchor = Point::new(rect.x0 - 8.0 / z, rect.y0 - 4.0 / z);+ let sp = xf.to_screen(anchor) + vec2(8.0, -14.0);+ let galley = painter.layout(format!("{:02} - {name}", index + 1), egui::FontId::proportional(11.0), Color32::WHITE, f32::INFINITY);+ egui::Rect::from_min_size(sp, galley.size()).expand(2.0)+}++/// The artboard whose on-canvas name contains `screen`, if that name is being drawn.+pub(super) fn artboard_name_at(app: &VectorcraftApp, ui: &Ui, xf: &Xf, screen: Pos2) -> Option<usize> {+ let st = app.session.active()?;+ let artboard_tool = app.session.tool_id() == "artboard";+ if !artboard_tool && st.doc.artboards.len() <= 1 {+ return None;+ }+ let tool_labelled = artboard_tool.then(|| app.session.tool_options()["active"].as_u64()).flatten();+ let painter = ui.painter();+ let mut hit = None;+ for (i, ab) in st.doc.artboards.iter().enumerate() {+ if tool_labelled == u64::try_from(i).ok() {+ continue;+ }+ let corner = xf.to_screen(Point::new(ab.rect.x0, ab.rect.y0));+ let width = (ab.rect.width() * xf.zoom) as f32;+ let text = format!("{:02} - {}", i + 1, ab.name);+ if canvas_name_rect(painter, corner, width, &text).is_some_and(|r| r.contains(screen)) {+ hit = Some(i);+ }+ }+ if let Some(i) = tool_labelled.and_then(|i| usize::try_from(i).ok())+ && let Some(ab) = st.doc.artboards.get(i)+ && tool_name_rect(painter, xf, ab.rect, i, &ab.name).contains(screen)+ {+ return Some(i);+ }+ hit+}++pub(super) fn select_named_artboard(app: &mut VectorcraftApp, index: usize) {+ let n = app.session.active().map(|st| st.doc.artboards.len()).unwrap_or(0);+ if index >= n {+ return;+ }+ if let Some(v) = app.view_mut() {+ v.artboard = index;+ }+ if app.session.tool_id() == "artboard" {+ app.session.set_tool_option("active", &json!(index));+ }+}++/// Start editing artboard `index`'s name on the canvas, unless the artboard is locked (the+/// Artboards panel still renames it).+pub(super) fn begin_artboard_name_edit(ui: &Ui, app: &VectorcraftApp, index: usize) {+ let Some(name) = app.session.active().and_then(|st| st.doc.artboards.get(index).filter(|a| !a.locked).map(|a| a.name.clone())) else { return };+ ui.data_mut(|d| d.insert_temp(name_edit_id(), ArtboardNameEdit { index, text: name, fresh: true }));+}++pub(super) fn commit_artboard_name(app: &mut VectorcraftApp, index: usize, text: &str) {+ let trimmed = text.trim();+ if trimmed.is_empty() {+ return;+ }+ let current = app.session.active().and_then(|st| st.doc.artboards.get(index).map(|a| a.name.clone()));+ if current.as_deref() == Some(trimmed) {+ return;+ }+ // A refusal is reported by the command; the label just closes.+ app.run("artboard.setProps", json!({ "index": index, "name": trimmed })).ok();+}++/// The text field over an artboard name a double-click opened.+pub(super) fn artboard_name_editor(app: &mut VectorcraftApp, ui: &mut Ui, xf: &Xf) {+ let Some(mut edit) = ui.data(|d| d.get_temp::<ArtboardNameEdit>(name_edit_id())) else { return };+ let alive = app.session.active().is_some_and(|st| edit.index < st.doc.artboards.len());+ if !alive {+ ui.data_mut(|d| d.remove::<ArtboardNameEdit>(name_edit_id()));+ return;+ }+ let Some(rect) = artboard_name_field_rect(app, ui, xf, edit.index) else {+ ui.data_mut(|d| d.remove::<ArtboardNameEdit>(name_edit_id()));+ return;+ };+ let fresh = edit.fresh;+ edit.fresh = false;+ let te = ui.put(+ rect,+ egui::TextEdit::singleline(&mut edit.text)+ .id(name_edit_id().with("field"))+ .font(egui::FontId::proportional(11.0))+ // Keep the original inset so theme button padding cannot move the canvas label.+ .margin(egui::Margin::symmetric(4, 2)),+ );+ if fresh || (!te.has_focus() && !te.lost_focus()) {+ te.request_focus();+ }+ let done = !fresh && te.lost_focus();+ let escape = ui.input(|i| i.key_pressed(egui::Key::Escape));+ let (index, text) = (edit.index, edit.text.clone());+ if done {+ ui.data_mut(|d| d.remove::<ArtboardNameEdit>(name_edit_id()));+ if !escape {+ commit_artboard_name(app, index, &text);+ }+ } else {+ ui.data_mut(|d| d.insert_temp(name_edit_id(), edit));+ }+}++/// Where the rename field sits: the name label's rectangle, at least wide enough to type in.+pub(super) fn artboard_name_field_rect(app: &VectorcraftApp, ui: &Ui, xf: &Xf, index: usize) -> Option<egui::Rect> {+ let st = app.session.active()?;+ let ab = st.doc.artboards.get(index)?;+ let artboard_tool = app.session.tool_id() == "artboard";+ let tool_labelled = artboard_tool.then(|| app.session.tool_options()["active"].as_u64()).flatten();+ let painter = ui.painter();+ let rect = if tool_labelled == u64::try_from(index).ok() {+ tool_name_rect(painter, xf, ab.rect, index, &ab.name)+ } else {+ let corner = xf.to_screen(Point::new(ab.rect.x0, ab.rect.y0));+ let width = (ab.rect.width() * xf.zoom) as f32;+ canvas_name_rect(painter, corner, width, &format!("{:02} - {}", index + 1, ab.name))?+ };+ Some(egui::Rect::from_min_size(rect.min, vec2(rect.width().max(80.0), rect.height().max(16.0))))+}++/// Is overlay label `text` the Artboard tool's "01 - <artboard name>"? It holds a name, so it is+/// shown as it is; the tools' other labels ("anchor", "path", Puppet Warp's warning) are ours.+pub(super) fn names_an_artboard(text: &str) -> bool {+ text.split_once(" - ").is_some_and(|(n, _)| n.len() >= 2 && n.bytes().all(|b| b.is_ascii_digit()))+}diff --git a/crates/ui-egui/src/canvas/context.rs b/crates/ui-egui/src/canvas/context.rsnew file mode 100644index 000000000..534321242--- /dev/null+++ b/crates/ui-egui/src/canvas/context.rs@@ -0,0 +1,116 @@+use super::outline::{hit_at, hit_with, selection_hit_at};+use super::*;++/// Right-click: the object under the pointer is selected first unless it already is, then the+/// context menu lists what applies to the selection ([`crate::menus::context_items`]). The locked+/// objects under the pointer ([`vectorcraft_doc::hit::locked_objects_at`]) are kept in+/// `ui.context_locked` while the menu is open, for its Unlock submenu.+pub(super) fn context_menu(app: &mut VectorcraftApp, resp: &egui::Response, xf: &Xf) {+ if resp.secondary_clicked()+ && let Some(p) = resp.interact_pointer_pos()+ {+ let p = xf.to_doc(p);+ let locked = hit_with(app, p, xf.zoom, |doc, p, opt| Some(vectorcraft_doc::hit::locked_objects_at(doc, p, opt)));+ app.ui.context_locked = app.session.active().map(|st| st.uid).zip(locked);+ if let Some(st) = app.session.active()+ && let Some(top) = selection_hit_at(app, p, xf.zoom).map(|h| h.top_object(st.isolation))+ && !st.selection.contains(top)+ {+ // A locked or hidden object can't be selected; the menu is then for the selection as is.+ let _ = app.run("select.set", json!({ "ids": [top.0] }));+ }+ }+ let mut clicked = None;+ if resp.context_menu(|ui| crate::menus::context_menu_body(app, ui, &mut clicked)).is_none() {+ app.ui.context_locked = None;+ }+ if let Some((id, p)) = clicked {+ crate::menus::invoke(app, &id, p);+ }+}++/// A panel drag ([`widgets::PanelDrag`]) dropped on art acts on the object under the pointer,+/// selected or not: a paint (swatches, a Fill/Stroke proxy, the Gradient panel's thumbnail) goes+/// to its active proxy (`paint.setFill`/`paint.setStroke` with its `ids`; a gradient fits it), the+/// Appearance panel's thumbnail gives the object (the topmost one hit) the appearance it carries+/// (`appearance.copyFrom`), a graphic style is applied to it (`graphicStyle.apply`; with Alt, on+/// top of its appearance). A chip follows the pointer meanwhile.+pub(super) fn panel_drop(app: &mut VectorcraftApp, ui: &Ui, resp: &egui::Response, xf: &Xf) {+ crate::panels::swatches::drag_preview(app, ui.ctx());+ let Some(pos) = ui.input(|i| i.pointer.interact_pos()) else { return };+ // Not through a floating panel over the canvas.+ if ui.ctx().layer_id_at(pos).is_some_and(|l| l != resp.layer_id) {+ return;+ }+ let Some(d) = resp.dnd_release_payload::<widgets::PanelDrag>() else { return };+ // A Libraries panel graphic: a copy centred where it is dropped.+ if let widgets::PanelDrag::LibraryGraphic { library, item } = &*d {+ let at = xf.to_doc(pos);+ if let Err(e) = app.run("library.use", json!({"library": library, "kind": "graphic", "item": item, "center": [at.x, at.y]})) {+ app.status(e);+ }+ return;+ }+ // A symbol from the Symbols panel: an instance centred where it is dropped, on art or not.+ if let widgets::PanelDrag::Symbol(name) = &*d {+ let at = xf.to_doc(pos);+ if let Err(e) = app.run("symbol.place", json!({"name": name, "x": at.x, "y": at.y})) {+ app.status(e);+ }+ return;+ }+ // A symbol from a symbol library panel: added to the document's Symbols and placed there.+ if let widgets::PanelDrag::LibrarySymbol { library, name } = &*d {+ let at = xf.to_doc(pos);+ if let Err(e) = app.run("symbol.addFromLibrary", json!({"library": library, "name": name, "place": true, "x": at.x, "y": at.y})) {+ app.status(e);+ }+ return;+ }+ let Some(hit) = hit_at(app, xf.to_doc(pos), xf.zoom) else { return };+ let Some(st) = app.session.active() else { return };+ let (cmd, params) = match &*d {+ widgets::PanelDrag::Paint { params, .. } => {+ // Colour groups paint nothing.+ if params.is_null() {+ return;+ }+ let mut params = params.clone();+ params["ids"] = json!([vectorcraft_tools::xform::paint_owner(&st.doc, hit.leaf).0]);+ params["focus"] = json!(false);+ (crate::panels::proxy_cmd(app, false), params)+ }+ widgets::PanelDrag::Appearance(source) => {+ let target = hit.top_object(st.isolation);+ if target == *source {+ return;+ }+ ("appearance.copyFrom", json!({"source": source.0, "ids": [target.0]}))+ }+ widgets::PanelDrag::GraphicStyle(name) => {+ let add = ui.input(|i| i.modifiers.alt);+ ("graphicStyle.apply", json!({"name": name, "ids": [hit.top_object(st.isolation).0], "add": add}))+ }+ // A brush from the Brushes panel: the path it lands on takes it (a compound path as a whole).+ widgets::PanelDrag::Brush { name, .. } => {+ ("brush.apply", json!({"name": name, "ids": [vectorcraft_tools::xform::paint_owner(&st.doc, hit.leaf).0]}))+ }+ // A brush from a brush library panel: added to the document's Brushes and applied to the+ // path it lands on, in one step.+ widgets::PanelDrag::LibraryBrush { library, name } => (+ "brush.addFromLibrary",+ json!({"library": library, "name": name, "apply": true, "ids": [vectorcraft_tools::xform::paint_owner(&st.doc, hit.leaf).0]}),+ ),+ // Art dragged back onto the canvas: its move was already dropped. (A symbol was placed+ // above.)+ widgets::PanelDrag::Art(_)+ | widgets::PanelDrag::Symbol(_)+ | widgets::PanelDrag::LibrarySymbol { .. }+ | widgets::PanelDrag::LibraryGraphic { .. } => return,+ // A Libraries panel style or group only moves within that panel.+ widgets::PanelDrag::LibraryItem { .. } | widgets::PanelDrag::LibraryGroup { .. } => return,+ };+ if let Err(e) = app.run(cmd, params) {+ app.status(e);+ }+}diff --git a/crates/ui-egui/src/canvas/cursor.rs b/crates/ui-egui/src/canvas/cursor.rsnew file mode 100644index 000000000..b67276df4--- /dev/null+++ b/crates/ui-egui/src/canvas/cursor.rs@@ -0,0 +1,152 @@+use super::*;++/// The active tool's cursor at the pointer, as `mods` make it. While the view moves (`still`+/// false), the cursor the tool last gave for the same tool and keys stays: asking the tool again+/// would hit-test the art under the pointer at every frame of the move (#2452).+pub(super) fn hover_cursor(app: &mut VectorcraftApp, mods: Mods, view: vectorcraft_engine::ViewInfo, still: bool) -> Option<Cursor> {+ let id = app.session.tool_id();+ if !still+ && let Some((was, with, c)) = app.canvas.hover_cursor+ && (was, with) == (id, mods)+ {+ return Some(c);+ }+ let c = app.session.cursor(app.hover_doc?, mods, view);+ app.canvas.hover_cursor = Some((id, mods, c));+ Some(c)+}++/// How long (seconds) the view must stay still before a canvas with+/// [`crate::CanvasCache::waits_for_still`] set renders a heavy document again.+pub const STILL_SECS: f64 = 0.2;++/// How long (seconds) the view must stay still before the canvas hit-tests the art under the+/// pointer again, for Object Highlighting and the tool's cursor. While the view pans, zooms or+/// turns under a resting pointer, the document point under it changes every frame, and hit-testing+/// detailed art each time slowed every frame of the move (#2452).+pub const HOVER_STILL_SECS: f64 = 0.15;++/// The view [`hover_wait`] watches: the canvas's rectangle and the view's zoom, centre and rotation.+#[derive(Clone, Copy, Debug, PartialEq)]+pub struct ViewKey {+ pub(super) rect: egui::Rect,+ pub(super) zoom: f64,+ pub(super) center: Point,+ pub(super) rotation: f64,+}++/// Note the view `key` at time `now` (seconds, egui's input time) → how many more seconds the+/// canvas leaves the art under the pointer alone: the view changed less than [`HOVER_STILL_SECS`]+/// ago. The first view noted counts as still.+pub(super) fn hover_wait(moved: &mut Option<(ViewKey, f64)>, key: ViewKey, now: f64) -> Option<f64> {+ match moved {+ Some((k, at)) if *k != key => (*k, *at) = (key, now),+ Some(_) => {}+ None => *moved = Some((key, f64::NEG_INFINITY)),+ }+ let waited = moved.map_or(f64::INFINITY, |(_, at)| now - at);+ // The clock went back (a new egui context): don't wait for it to catch up.+ (0.0..HOVER_STILL_SECS).contains(&waited).then_some(HOVER_STILL_SECS - waited)+}++/// Note that the canvas asks for `key` at time `now` (seconds, egui's input time) → how many more+/// seconds it draws the frame `shown` reprojected instead of rendering `key`: while the last+/// render was `slow`, only the view differs between the two, and the canvas has asked for `key`+/// for less than [`STILL_SECS`]. `still` holds the key last asked for and when the canvas first+/// asked for it. None: the canvas renders `key` now, unless it is the frame shown.+pub(super) fn still_wait(still: &mut Option<(CacheKey, f64)>, shown: Option<&CacheKey>, key: &CacheKey, slow: bool, now: f64) -> Option<f64> {+ if still.as_ref().is_none_or(|(k, _)| k != key) {+ *still = Some((key.clone(), now));+ }+ let waited = still.as_ref().map_or(0.0, |(_, at)| now - at);+ // The clock went back (a new egui context): don't wait for it to catch up.+ let waiting = (0.0..STILL_SECS).contains(&waited);+ (slow && waiting && shown.is_some_and(|s| s != key && only_view_differs(s, key))).then_some(STILL_SECS - waited)+}++/// Whether two cache keys differ only in the view (zoom, center, rotation, canvas size, pixel+/// density and Pixel Preview's document pixels), with Pixel Preview on in both or off in both.+fn only_view_differs(a: &CacheKey, b: &CacheKey) -> bool {+ a.pixel.is_some() == b.pixel.is_some()+ && *a == CacheKey { zoom: a.zoom, cx: a.cx, cy: a.cy, w: a.w, h: a.h, ppp: a.ppp, rot: a.rot, pixel: a.pixel, ..b.clone() }+}++pub(super) fn cursor_icon(c: Cursor) -> egui::CursorIcon {+ use egui::CursorIcon as C;+ match c {+ Cursor::Arrow+ | Cursor::ArrowHollow+ | Cursor::DirectAnchor+ | Cursor::DirectAnchorSelected+ | Cursor::ReshapeSegment+ | Cursor::GroupSelection+ | Cursor::CornerRadius+ | Cursor::PathBracket+ | Cursor::TypeWidget+ | Cursor::LoadedText => C::Default,+ Cursor::SelectionCopy => C::Copy,+ Cursor::Move => C::Move,+ Cursor::Crosshair => C::Crosshair,+ Cursor::ResizeH | Cursor::ShearH => C::ResizeHorizontal,+ Cursor::ResizeV | Cursor::ShearV => C::ResizeVertical,+ Cursor::ResizeNwSe => C::ResizeNwSe,+ Cursor::ResizeNeSw => C::ResizeNeSw,+ Cursor::Rotate | Cursor::RotateToward(_) => C::Alias,+ Cursor::Pen+ | Cursor::PenDrawing+ | Cursor::PenAdd+ | Cursor::PenDelete+ | Cursor::PenClose+ | Cursor::PenContinue+ | Cursor::PenJoin+ | Cursor::PenConvert+ | Cursor::AnchorPoint+ | Cursor::Curvature => C::Crosshair,+ Cursor::Text => C::Text,+ Cursor::Hand => C::Grab,+ Cursor::HandGrab => C::Grabbing,+ Cursor::ZoomIn => C::ZoomIn,+ Cursor::ZoomOut => C::ZoomOut,+ Cursor::Eyedropper => C::Crosshair,+ Cursor::NotAllowed => C::NotAllowed,+ Cursor::Busy => C::Progress,+ Cursor::AddStop => C::Copy,+ Cursor::RemoveStop => C::NotAllowed,+ Cursor::Slice => C::Crosshair,+ Cursor::SliceSelect => C::Default,+ Cursor::Width | Cursor::WidthAdd => C::Crosshair,+ Cursor::WidthPoint => C::Move,+ Cursor::PencilNew => C::Crosshair,+ Cursor::Blend | Cursor::BlendObject | Cursor::BlendAnchor | Cursor::ShapeBuilder | Cursor::ShapeBuilderErase => C::Crosshair,+ Cursor::PencilClose | Cursor::PencilStraight | Cursor::PencilContinue | Cursor::PaintbrushClose => C::Crosshair,+ Cursor::TypeVertical => C::VerticalText,+ // Not drawn yet: the cursor each borrows.+ Cursor::Lasso+ | Cursor::MagicWand+ | Cursor::Pencil+ | Cursor::Paintbrush+ | Cursor::BlobBrush+ | Cursor::Eraser+ | Cursor::Smooth+ | Cursor::PathEraser+ | Cursor::Join+ | Cursor::Knife+ | Cursor::Shaper+ | Cursor::LivePaintBucket+ | Cursor::Measure+ | Cursor::PrintTiling+ | Cursor::SymbolSprayer+ | Cursor::SymbolShifter+ | Cursor::SymbolScruncher+ | Cursor::SymbolSizer+ | Cursor::SymbolSpinner+ | Cursor::SymbolStainer+ | Cursor::SymbolScreener+ | Cursor::SymbolStyler+ | Cursor::ObjectsOnPath+ | Cursor::Scissors+ | Cursor::ScissorsNotAllowed+ | Cursor::MeshAdd+ | Cursor::PuppetPin => cursor_icon(c.stand_in().unwrap_or(Cursor::Crosshair)),+ }+}diff --git a/crates/ui-egui/src/canvas/drag.rs b/crates/ui-egui/src/canvas/drag.rsnew file mode 100644index 000000000..e17690dd3--- /dev/null+++ b/crates/ui-egui/src/canvas/drag.rs@@ -0,0 +1,282 @@+use super::*;++/// Whether drag `d` is a press the tool holds. Every other drag (panning, zooming, turning the+/// view, a touch gesture, Presentation Mode) never reaches the tool, so its hover ends with it.+pub(super) fn tool_holds(d: Drag) -> bool {+ matches!(d, Drag::Tool | Drag::Art)+}++/// What a hover depends on besides the pointer's screen position.+#[derive(Clone, Copy, Debug, PartialEq)]+pub(super) struct HoverContext {+ /// The active tool: a tool switched to under a still pointer is hovered at once.+ pub(super) tool: &'static str,+ /// The canvas, and the view's centre, zoom and rotation.+ pub(super) canvas: egui::Rect,+ pub(super) center: Point,+ pub(super) zoom: f64,+ pub(super) rotation: f64,+ /// The active document's id and revision (which moves with every edit, undo and selection+ /// change).+ pub(super) doc: Option<(u64, u64)>,+}++/// Clear canvas interaction state before a tab transfer takes ownership of the artwork drag.+pub(crate) fn end_document_drag(ctx: &egui::Context) {+ ctx.data_mut(|d| {+ d.remove::<Drag>(drag_id());+ d.remove::<Pos2>(drag_pos_id());+ });+}++/// Temp-memory key for the active canvas drag state.+pub(super) fn drag_id() -> egui::Id {+ egui::Id::unique("canvas-drag")+}++/// Where the pointer was last seen during a press on the canvas.+pub(super) fn drag_pos_id() -> egui::Id {+ egui::Id::unique("canvas-drag-pos")+}++/// The layer the canvas was last drawn on: a release over another layer is over a panel (#2826).+pub(super) fn drag_layer_id() -> egui::Id {+ egui::Id::unique("canvas-drag-layer")+}++/// Whether `p` is over the canvas itself, not a panel or a floating window over it.+pub(super) fn on_canvas(ui: &Ui, resp: &egui::Response, p: Pos2) -> bool {+ resp.rect.contains(p) && ui.clip_rect().contains(p) && ui.ctx().layer_id_at(p).is_none_or(|l| l == resp.layer_id)+}++/// The document point last sent to the tool as a drag during [`Drag::Tool`]; none until the press+/// has dragged.+pub(super) fn tool_drag_doc_id() -> egui::Id {+ egui::Id::unique("canvas-tool-drag-doc")+}++/// The document point of the press that began [`Drag::Tool`], sent to the tool as its Down.+pub(super) fn tool_press_doc_id() -> egui::Id {+ egui::Id::unique("canvas-tool-press-doc")+}++/// Whether the tool should get another drag event, and if so records `p` as the last position+/// sent: the pointer moved this frame, or its document position changed without a delta (#834).+/// egui's frame delta is zero when some Wayland compositors coalesce motion until release, and in+/// the frame the pointer comes back into the window after leaving it (`PointerGone` forgot where+/// it was), though it is somewhere new; judged on the delta alone, the preview stayed behind.+pub(super) fn tool_drag_moved(ui: &Ui, xf: &Xf, p: Pos2, pointer: &egui::PointerState) -> bool {+ let at = xf.to_doc(p);+ let id = tool_drag_doc_id();+ // Before the press has dragged, the last position the tool got is the press itself: a press+ // held still is not a drag.+ let prev = ui.data(|d| d.get_temp::<Point>(id).or_else(|| d.get_temp::<Point>(tool_press_doc_id())));+ if pointer.delta() == egui::Vec2::ZERO && prev == Some(at) {+ return false;+ }+ ui.data_mut(|d| d.insert_temp(id, at));+ true+}++/// The pen pressure (0..1) of the press in progress: the force of this frame's pen or touch+/// input, else the pressure in the host's feed while a pen is the pointer that moved last+/// ([`crate::Services::stylus`]: [`StylusFeed::press`] for a new press, [`StylusFeed::held`]+/// after it), else the last one seen since the press (`pressed`: a new press, whose mouse has none+/// until a pen reports it). A mouse presses fully (1).+pub(super) fn pen_pressure(ui: &Ui, app: &VectorcraftApp, pressed: bool) -> f32 {+ let stylus = app.services.stylus.as_ref();+ let id = egui::Id::unique("canvas-pressure");+ let force = ui.input(|i| {+ i.events.iter().rev().find_map(|e| match e {+ egui::Event::Touch { force: Some(f), .. } if f.is_finite() => Some(f.clamp(0.0, 1.0)),+ _ => None,+ })+ });+ let force = force.or_else(|| stylus.and_then(if pressed { StylusFeed::press } else { StylusFeed::held }));+ let p = force.or_else(|| if pressed { None } else { ui.data(|d| d.get_temp::<f32>(id)) }).unwrap_or(1.0);+ ui.data_mut(|d| d.insert_temp(id, p));+ p+}++/// The positions this frame's pointer moves passed through before its last one, each with the+/// pen force a touch event gave just before it, or the pressure the host's feed kept for that move+/// ([`StylusFeed::take_moves`], macOS), if any. The last move is the pointer's position. A mouse's+/// moves count too, with no pressure: a fast mouse stroke otherwise keeps one position a frame, a+/// sample every few pixels, too few for a low Fidelity to follow the hand (#3328).+pub(super) fn frame_moves(ui: &Ui, stylus: Option<&StylusFeed>) -> Vec<(Pos2, Option<f32>)> {+ let pressures = stylus.map(StylusFeed::take_moves).unwrap_or_default();+ ui.input(|i| {+ let mut moves = vec![];+ if i.events.iter().any(|e| matches!(e, egui::Event::Touch { .. })) {+ let mut force = None;+ for e in &i.events {+ match e {+ egui::Event::Touch { force: Some(f), .. } if f.is_finite() && *f > 0.0 => force = Some(f.clamp(0.0, 1.0)),+ egui::Event::PointerMoved(p) => moves.push((*p, force)),+ _ => {}+ }+ }+ } else if !pressures.is_empty() {+ // The feed's last pressure is the last move's: pair them from the end. A lift's 0 is+ // no pressure (the press keeps its last touch).+ let points: Vec<Pos2> = i.events.iter().filter_map(|e| if let egui::Event::PointerMoved(p) = e { Some(*p) } else { None }).collect();+ let forces = pressures.iter().rev().map(|f| (*f > 0.0).then_some(*f)).chain(std::iter::repeat(None));+ moves = points.into_iter().rev().zip(forces).collect();+ moves.reverse();+ } else {+ moves = i.events.iter().filter_map(|e| if let egui::Event::PointerMoved(p) = e { Some((*p, None)) } else { None }).collect();+ }+ moves.pop();+ // A burst of events (a stalled frame) is thinned to a bounded count.+ const MAX: usize = 64;+ if moves.len() > MAX {+ let step = moves.len().div_ceil(MAX);+ moves = moves.into_iter().step_by(step).collect();+ }+ moves+ })+}++/// The moves of this frame ([`frame_moves`]) the active tool gets before the pointer's position:+/// all of them for a tool that builds a stroke from them ([`vectorcraft_engine::Session::tool_wants_samples`]), none+/// for the others, which get one drag a frame. The moves are read either way, so the host's feed+/// pairs the next frame's with its own.+pub(super) fn tool_frame_moves(ui: &Ui, app: &VectorcraftApp) -> Vec<(Pos2, Option<f32>)> {+ let moves = frame_moves(ui, app.services.stylus.as_ref());+ if app.session.tool_wants_samples() { moves } else { vec![] }+}++pub fn mods(m: egui::Modifiers, space: bool) -> Mods {+ Mods { shift: m.shift, alt: m.alt, cmd: m.command, ctrl: m.ctrl, space }+}++/// Drop the tool press in progress, if any: nothing it began is kept, and the rest of the press+/// does nothing ([`Drag::Gesture`]).+pub(super) fn drop_press(app: &mut VectorcraftApp, ui: &Ui, view: vectorcraft_engine::ViewInfo) {+ match ui.data(|d| d.get_temp::<Drag>(drag_id())) {+ Some(Drag::Tool | Drag::Art) => {+ // The tool's mouse-up returns it to rest. A move waiting over a panel is still live+ // and would otherwise outlive the drag that owns it (#2826).+ // Nothing to roll back without a document; the tool still gets its mouse-up.+ let _ = app.session.cancel_interaction();+ dispatch(app, &PointerEvent { kind: PointerKind::Up, pos: Point::ZERO, mods: Mods::default(), pressure: 1.0 }, view);+ egui::DragAndDrop::clear_payload(ui.ctx());+ }+ Some(_) => {}+ None => return,+ }+ ui.data_mut(|d| d.insert_temp(drag_id(), Drag::Gesture));+}++/// A Selection tool move dragged off the canvas (to `p`, over a panel) becomes a panel drag of+/// the selected art ([`widgets::PanelDrag::Art`]): the art waits where it last moved on the+/// canvas, and a panel it is released on takes it (the Graphic Styles panel makes a style of it).+/// Back on the canvas, [`Drag::Art`] takes the move up again where the pointer is (#2826).+pub(super) fn drag_art_out(app: &VectorcraftApp, ui: &Ui, resp: &egui::Response, p: Pos2) -> bool {+ let Some(st) = app.session.active().filter(|_| app.session.tool_id() == "selection") else { return false };+ // The Selection tool's interaction while it moves (or Alt-copies) the selection.+ if !st.interaction.as_ref().is_some_and(|i| i.label == "Move" || i.label == "Copy") {+ return false;+ }+ // A floating panel in an OS window of its own takes the art too: craft-ui hands that window+ // the pointer while it is over it, and this window sees the pointer go.+ craft_ui::docking::route_app_drag(ui.ctx(), crate::panel_docking::area_id());+ if on_canvas(ui, resp, p) && ui.input(|i| i.pointer.has_pointer()) {+ return false;+ }+ let ids = st.selection.objects.clone();+ egui::DragAndDrop::set_payload(ui.ctx(), widgets::PanelDrag::Art(ids));+ true+}++/// A Selection tool move released over a panel: end it before the panels see the release, so a+/// panel that takes the art ([`widgets::PanelDrag::Art`]) takes it where it was, and no move is+/// left open (#2826). The art stays where it last moved while the pointer is over the panel.+pub(crate) fn release_over_panel(app: &mut VectorcraftApp, ctx: &egui::Context) {+ crate::document_drag::cleanup(app, ctx);+ let art = matches!(ctx.data(|d| d.get_temp::<Drag>(drag_id())), Some(Drag::Art));+ // Over a floating panel's own OS window the pointer is gone from this window, and the release+ // comes here later, at a point of this window that may lie on the canvas: that panel takes it.+ let gone_id = drag_id().with("art-gone");+ if !ctx.input(|i| i.pointer.primary_released()) {+ if art {+ let gone = ctx.input(|i| !i.pointer.has_pointer());+ ctx.data_mut(|d| d.insert_temp(gone_id, gone));+ }+ return;+ }+ let gone = ctx.data_mut(|d| d.remove_temp::<bool>(gone_id)).unwrap_or(false);+ let p = ctx.input(|i| i.pointer.interact_pos().or(i.pointer.latest_pos()));+ if !art {+ return;+ }+ let layer = ctx.data(|d| d.get_temp::<egui::LayerId>(drag_layer_id()));+ let on = !gone && p.is_some_and(|p| app.canvas_rect.is_some_and(|r| r.contains(p)) && ctx.layer_id_at(p).is_none_or(|l| Some(l) == layer));+ if on {+ // The canvas's release finishes the move.+ return;+ }+ end_art_move(app, ctx);+}++/// A release in a floating panel's own OS window, during an art drag from the canvas: the move+/// ends before that panel takes the art. The main window would only see it on its next pass.+pub(crate) fn release_art_in_window(app: &mut VectorcraftApp, ctx: &egui::Context) {+ let art = matches!(ctx.data(|d| d.get_temp::<Drag>(drag_id())), Some(Drag::Art));+ if art && ctx.input(|i| i.pointer.primary_released()) {+ end_art_move(app, ctx);+ }+}++/// Roll back the art move dragged off the canvas; a panel takes the art instead.+fn end_art_move(app: &mut VectorcraftApp, ctx: &egui::Context) {+ // With no document open there is nothing to roll back; the tool still gets its mouse-up.+ let _ = app.session.cancel_interaction();+ let view = app.view_info();+ dispatch(app, &PointerEvent { kind: PointerKind::Up, pos: Point::ZERO, mods: Mods::default(), pressure: 1.0 }, view);+ ctx.data_mut(|d| {+ d.remove::<Drag>(drag_id());+ d.remove::<bool>(drag_id().with("art-gone"));+ });+}++/// Send a pointer event to the active tool and act on UI requests (dialogs, tool switches).+pub fn dispatch(app: &mut VectorcraftApp, ev: &PointerEvent, view: vectorcraft_engine::ViewInfo) {+ let r = app.session.pointer(ev, view);+ // The artboard the Artboard tool makes active is the active one (the navigator's, the+ // Artboards panel's).+ if app.session.tool_id() == "artboard"+ && let Some(i) = app.session.tool_options()["active"].as_u64().and_then(|i| usize::try_from(i).ok())+ && let Some(v) = app.view_mut()+ {+ v.artboard = i;+ }+ // A press with a selection tool inside an artboard makes it the active one (#693), as the+ // Artboard tool's does: Paste in Place and in Front or Back then paste onto it, Align to+ // Artboard aligns to it, and All on Active Artboard selects on it.+ if ev.kind == PointerKind::Down+ && vectorcraft_tools::catalog::is_selection_tool(app.session.tool_id())+ && let Some(i) = app.session.active().and_then(|d| d.doc.artboard_at(ev.pos))+ && let Some(v) = app.view_mut()+ {+ v.artboard = i;+ }+ apply_requests(app, r);+}++/// Act on what a tool event asked the UI for (dialogs, tool switches), or show its error.+pub fn apply_requests(app: &mut VectorcraftApp, r: vectorcraft_engine::Result<Vec<vectorcraft_engine::UiRequest>>) {+ match r {+ Ok(reqs) => {+ for r in reqs {+ match r {+ vectorcraft_engine::UiRequest::Dialog(kind, p) => crate::dialogs::open_tool_dialog(app, &kind, p),+ vectorcraft_engine::UiRequest::SwitchTool(t) => app.select_tool(&t),+ vectorcraft_engine::UiRequest::Status(msg) => app.status(msg),+ vectorcraft_engine::UiRequest::Place(p) => crate::place::place_from_cursor(app, &p),+ }+ }+ }+ Err(e) => app.status(e.to_string()),+ }+}diff --git a/crates/ui-egui/src/canvas/grid.rs b/crates/ui-egui/src/canvas/grid.rsnew file mode 100644index 000000000..a36380df0--- /dev/null+++ b/crates/ui-egui/src/canvas/grid.rs@@ -0,0 +1,377 @@+use super::drag::mods;+use super::*;++/// The transparency grid's 2 × 2-cell tile in the document's colours (Document Setup), cached per+/// look, and its cell size in screen points.+pub(crate) fn checker_texture(ctx: &egui::Context, setup: &vectorcraft_doc::DocSetup) -> (egui::TextureHandle, f32) {+ let colors = setup.grid_colors.map(|c| crate::panels::c32(&c));+ let id = egui::Id::unique("transparency-grid-tile");+ let cached = ctx.data(|d| d.get_temp::<([Color32; 2], egui::TextureHandle)>(id)).filter(|(c, _)| *c == colors);+ let tex = cached.map(|(_, t)| t).unwrap_or_else(|| {+ let [a, b] = colors;+ let img = egui::ColorImage::new([2, 2], vec![a, b, b, a]);+ let opts = egui::TextureOptions { wrap_mode: egui::TextureWrapMode::Repeat, ..egui::TextureOptions::NEAREST };+ let t = ctx.load_texture(TRANSPARENCY_GRID, img, opts);+ ctx.data_mut(|d| d.insert_temp(id, (colors, t.clone())));+ t+ });+ (tex, setup.grid_size.cell())+}++/// Name of the transparency grid's texture.+pub(crate) const TRANSPARENCY_GRID: &str = "transparency grid";++/// The transparency grid over the artboard `ab` (screen corners `quad`): one textured quad whose+/// cells stay `cell` screen points at every zoom and turn with a rotated view.+pub(super) fn checker(p: &egui::Painter, quad: &[Pos2], ab: Rect, zoom: f64, tex: egui::TextureId, cell: f32) {+ // Two cells per texture repeat.+ let per = (2.0 * cell as f64 / zoom).max(1e-9);+ textured_quad(p, tex, quad, ((ab.width() / per) as f32, (ab.height() / per) as f32));+}++/// One quad drawn with `tex`: its corners `quad` (from the top left, clockwise) show the texture+/// from (0, 0) to (`u`, `v`).+pub(super) fn textured_quad(p: &egui::Painter, tex: egui::TextureId, quad: &[Pos2], (u, v): (f32, f32)) {+ let mut mesh = egui::Mesh::with_texture(tex);+ for (pos, uv) in quad.iter().zip([pos2(0.0, 0.0), pos2(u, 0.0), pos2(u, v), pos2(0.0, v)]) {+ mesh.vertices.push(egui::epaint::Vertex { pos: *pos, uv, color: Color32::WHITE });+ }+ mesh.indices.extend([0, 1, 2, 0, 2, 3]);+ p.add(Shape::mesh(mesh));+}++/// The zoom the pixel grid shows from in Pixel Preview (600%), and its colour: a translucent grey,+/// so the art's pixels read through it.+pub(super) const PIXEL_GRID_ZOOM: f64 = 6.0;++pub(super) const PIXEL_GRID: Color32 = Color32::from_rgba_premultiplied(64, 64, 64, 96);++/// The look of the grid or of the guides (Preferences › Guides & Grid › Color and Style).+#[derive(Clone, Copy)]+pub(super) struct LineLook {+ pub(super) color: Color32,+ pub(super) dots: bool,+}++impl LineLook {+ pub(super) fn grid(prefs: &vectorcraft_engine::Prefs) -> Self {+ Self { color: pref_color(&prefs.grid_color, Color32::from_gray(200)), dots: prefs.grid_style == "dots" }+ }++ pub(super) fn guides(prefs: &vectorcraft_engine::Prefs, t: &Tokens) -> Self {+ Self { color: pref_color(&prefs.guide_color, t.guide), dots: prefs.guide_style == "dots" }+ }++ /// A guide from `a` to `b`: a line, or dots.+ pub(super) fn guide(self, p: &egui::Painter, a: Pos2, b: Pos2) {+ if self.dots {+ p.extend(Shape::dotted_line(&[a, b], self.color, 4.0, 0.75));+ } else {+ p.line_segment([a, b], Stroke::new(1.0, self.color));+ }+ }+}++/// A `#rrggbb` colour preference, `fallback` when it doesn't parse.+pub(super) fn pref_color(hex: &str, fallback: Color32) -> Color32 {+ vectorcraft_color::Color::from_hex(hex).map_or(fallback, |c| crate::panels::c32(&c))+}++/// The view in document space: the box round the canvas's corners (the view may be rotated).+pub(super) fn view_bounds(xf: &Xf) -> Rect {+ let r = xf.rect;+ let corners = [r.left_top(), r.right_top(), r.right_bottom(), r.left_bottom()].map(|c| xf.to_doc(c));+ corners.iter().fold(Rect::from_points(corners[0], corners[0]), |b, c| b.union_pt(*c))+}++/// The part of the segment from `a` to `b` inside `r`, none when the segment misses it.+pub(super) fn clip_segment(a: Pos2, b: Pos2, r: egui::Rect) -> Option<(Pos2, Pos2)> {+ let d = b - a;+ let (mut t0, mut t1) = (0.0_f32, 1.0_f32);+ // Each edge as (the run toward it, the room before it).+ for (run, room) in [(-d.x, a.x - r.left()), (d.x, r.right() - a.x), (-d.y, a.y - r.top()), (d.y, r.bottom() - a.y)] {+ if run == 0.0 {+ if room < 0.0 {+ return None;+ }+ } else if run < 0.0 {+ t0 = t0.max(room / run);+ } else {+ t1 = t1.min(room / run);+ }+ }+ (t0 <= t1).then(|| (a + d * t0, a + d * t1))+}++/// The grid (View → Show Grid): a gridline every `spacing` and `subdiv` lighter lines between+/// (left out when they would crowd). In the Dots style, a dot where gridlines cross the+/// subdivisions instead.+pub(super) fn grid(p: &egui::Painter, xf: &Xf, spacing: f64, subdiv: u32, look: LineLook) {+ // The painter clips to the canvas.+ let view = view_bounds(xf);+ let sub = spacing / subdiv.max(1) as f64;+ let step = if sub * xf.zoom >= 6.0 { sub } else { spacing };+ // Dots crowd sooner than lines.+ if step * xf.zoom < 4.0 || (look.dots && spacing * xf.zoom < 8.0) {+ return;+ }+ let major = |v: f64| (v / spacing - (v / spacing).round()).abs() < 1e-6;+ // The lines across the view (where along their axis), at least 4 px apart (and capped).+ let lines = |from: f64, to: f64| {+ let first = (from / step).floor();+ (0..10_000u32).map(move |i| (first + f64::from(i)) * step).take_while(move |v| *v <= to)+ };+ if look.dots {+ let mut mesh = egui::Mesh::default();+ for x in lines(view.x0, view.x1) {+ for y in lines(view.y0, view.y1).filter(|y| major(x) || major(*y)) {+ mesh.add_colored_rect(egui::Rect::from_center_size(xf.to_screen(Point::new(x, y)), vec2(1.5, 1.5)), look.color);+ }+ }+ p.add(Shape::mesh(mesh));+ return;+ }+ let minor = look.color.gamma_multiply(0.4);+ let stroke = |major: bool| Stroke::new(1.0, if major { look.color } else { minor });+ for x in lines(view.x0, view.x1) {+ p.line_segment([xf.to_screen(Point::new(x, view.y0)), xf.to_screen(Point::new(x, view.y1))], stroke(major(x)));+ }+ for y in lines(view.y0, view.y1) {+ p.line_segment([xf.to_screen(Point::new(view.x0, y)), xf.to_screen(Point::new(view.x1, y))], stroke(major(y)));+ }+}++/// A ruler label for `v` (in the ruler's unit) on a ruler whose labels are `step` apart: whole+/// numbers, or the fewest decimals that write `step` exactly, so a binary step keeps its value+/// (an inch ruler's 1/16 reads `0.0625`, not the `0.06` that rounding the step's magnitude gave).+/// How far down the left ruler a label of `chars` characters reaches, counting from its top: it+/// is spelled one character per line, [`RULER_CHAR`] apart, and the last one is a line tall.+pub(crate) fn vertical_label_height(chars: usize) -> f32 {+ chars.saturating_sub(1) as f32 * RULER_CHAR + RULER_LINE+}++/// A ruler label's line spacing and line height on the left ruler.+const RULER_CHAR: f32 = 8.5;++const RULER_LINE: f32 = 9.5;++pub(crate) fn ruler_label(v: f64, step: f64) -> String {+ let exact = |d: u32| (step * 10f64.powi(d as i32)).fract().abs() < 1e-9;+ let decimals = (0..=7).find(|d| exact(*d)).unwrap_or(7) as usize;+ let s = format!("{v:.decimals$}");+ // Trailing zeros go, as `Unit::number` drops them: a sixteenth-inch ruler labels the inch `1`,+ // not `1.0000`, which the vertical ruler would spell down six lines.+ let s = if s.contains('.') { s.trim_end_matches('0').trim_end_matches('.') } else { &s };+ if s.trim_start_matches('-').chars().all(|c| c == '0' || c == '.') { "0".into() } else { s.into() }+}++/// The rulers, numbered in `unit` (the General unit).+/// The top ruler, the left ruler and the box where they meet.+pub(super) fn ruler_rects(full: egui::Rect) -> [egui::Rect; 3] {+ let top = egui::Rect::from_min_max(pos2(full.left() + RULER, full.top()), pos2(full.right(), full.top() + RULER));+ let left = egui::Rect::from_min_max(pos2(full.left(), full.top() + RULER), pos2(full.left() + RULER, full.bottom()));+ [top, left, egui::Rect::from_min_size(full.min, vec2(RULER, RULER))]+}++/// A drag from a ruler onto the canvas makes a guide where the button is released (the engine's+/// `Session::ruler_guide`): a horizontal one from the top ruler, a vertical one from the left+/// ruler, snapped as a moved guide is (with Shift to the ruler's ticks). Released anywhere else,+/// it makes none. The corner drags the rulers' origin or resets it on a double-click.+pub(super) fn ruler_input(app: &mut VectorcraftApp, ui: &Ui, full: egui::Rect, canvas: egui::Rect, xf: &Xf) -> Option<Point> {+ let [top, left, corner] = ruler_rects(full);+ // Right-click on a ruler or the origin box: the document units, to swap between them as+ // Preferences ▸ Units ▸ General does ([`crate::menus::ruler_menu_body`]).+ let mut unit_clicked = None;+ for (r, vertical, id) in [(top, false, "ruler-top"), (left, true, "ruler-left")] {+ // Click-and-drag so the same widget drags out guides (left) and opens the unit menu (right).+ let resp = ui.interact(r, egui::Id::unique(id), Sense::click_and_drag());+ resp.context_menu(|ui| crate::menus::ruler_menu_body(app, ui, &mut unit_clicked));+ let kind = if resp.drag_stopped() {+ PointerKind::Up+ } else if resp.dragged() {+ PointerKind::Drag+ } else {+ continue;+ };+ let p = resp.interact_pointer_pos().or_else(|| ui.input(|i| i.pointer.latest_pos()));+ let on_canvas = p.is_some_and(|p| canvas.contains(p));+ if on_canvas {+ // The new guide shows even if guides were hidden.+ app.ui.view.guides = true;+ }+ let ev = PointerEvent { kind, pos: p.map_or(Point::ZERO, |p| xf.to_doc(p)), mods: mods(ui.input(|i| i.modifiers), false), pressure: 1.0 };+ if let Err(e) = app.session.ruler_guide(vertical, &ev, on_canvas, app.view_info()) {+ app.status(e.to_string());+ }+ }+ let corner = ui.interact(corner, egui::Id::unique("ruler-corner"), Sense::click_and_drag());+ corner.context_menu(|ui| crate::menus::ruler_menu_body(app, ui, &mut unit_clicked));+ if let Some((id, p)) = unit_clicked {+ crate::menus::invoke(app, &id, p);+ }+ if corner.double_clicked_by(egui::PointerButton::Primary) {+ let artboard = app.view().map_or(0, |v| v.artboard);+ if let Err(e) = app.run("document.resetRulerOrigin", json!({"artboard": artboard})) {+ app.status(e.to_string());+ }+ }+ // Keep previews in the UI: only a release on the canvas edits the document, once. Cancelling+ // never adds an undo step or interferes with the drawing tool's interaction.+ let drag_id = ruler_origin_drag_id();+ let uid = app.session.active().map(|d| d.uid);+ if corner.drag_started_by(egui::PointerButton::Primary) {+ ui.data_mut(|d| d.insert_temp(drag_id, (uid, false)));+ }+ let mut preview = None;+ if let Some((started_in, mut cancelled)) = ui.data(|d| d.get_temp::<(Option<u64>, bool)>(drag_id)) {+ cancelled |= started_in != uid || ui.input(|i| !i.focused || i.key_pressed(egui::Key::Escape));+ let at = corner.interact_pointer_pos().or_else(|| ui.input(|i| i.pointer.latest_pos())).filter(|p| canvas.contains(*p)).map(|p| xf.to_doc(p));+ if corner.drag_stopped_by(egui::PointerButton::Primary) {+ ui.data_mut(|d| d.remove::<(Option<u64>, bool)>(drag_id));+ if !cancelled+ && let Some(at) = at+ && let Err(e) = app.run("document.setRulerOrigin", json!({"x": at.x, "y": at.y, "artboard": app.view().map_or(0, |v| v.artboard)}))+ {+ app.status(e.to_string());+ }+ } else if !ui.input(|i| i.pointer.primary_down()) {+ ui.data_mut(|d| d.remove::<(Option<u64>, bool)>(drag_id));+ } else {+ ui.data_mut(|d| d.insert_temp(drag_id, (started_in, cancelled)));+ if !cancelled {+ preview = at;+ }+ }+ }+ preview+}++/// The key of the ruler origin drag's state in egui's temporary data.+fn ruler_origin_drag_id() -> egui::Id {+ egui::Id::unique("ruler-origin-drag")+}++/// Is a drag from the rulers' corner in progress? It stays true after Escape cancels the move, until+/// the button is released.+pub(crate) fn ruler_origin_dragging(ctx: &egui::Context) -> bool {+ ctx.data(|d| d.get_temp::<(Option<u64>, bool)>(ruler_origin_drag_id()).is_some())+}++/// What the rulers count, and from where: `unit`, from `origin` (document points), with each+/// unit stretched `stretch` times along the document's x and y, which a video ruler's pixel aspect+/// ratio makes differ.+#[derive(Clone, Copy, Debug, PartialEq)]+pub(crate) struct RulerScale {+ pub(crate) unit: Unit,+ pub(crate) origin: Point,+ pub(crate) stretch: [f64; 2],+}++impl RulerScale {+ /// The rulers in `unit` (the General unit), from `origin` (the ruler origin).+ pub(crate) fn document(unit: Unit, origin: Point) -> Self {+ Self { unit, origin, stretch: [1.0, 1.0] }+ }++ /// View › Rulers › Show Video Rulers on artboard `ab`: pixels from its top-left corner, each+ /// pixel as many points wide as its Video Ruler Pixel Aspect Ratio and one point tall, so the+ /// rulers read the artboard's size in video pixels+ /// (https://helpx.adobe.com/illustrator/desktop/create-manage-artboards/organize-manage-artboards/set-video-display-options-for-artboards.html).+ pub(crate) fn video(ab: &vectorcraft_doc::Artboard) -> Self {+ Self { unit: Unit::Pixels, origin: Point::new(ab.rect.x0, ab.rect.y0), stretch: [ab.video_ruler_pixel_aspect_ratio, 1.0] }+ }++ /// How far document point `p` lies from the origin along `axis` (a unit direction in the+ /// document), in points of this scale: each document coordinate divided by its stretch.+ /// Divided by the unit's points, it is the value the ruler reads there.+ pub(crate) fn along(&self, p: Point, axis: vectorcraft_geom::Vec2) -> f64 {+ let d = p - self.origin;+ d.x / self.stretch[0] * axis.x + d.y / self.stretch[1] * axis.y+ }++ /// The screen points one point of this scale spans along `axis` at `zoom` (screen points per+ /// document point): `zoom` itself when nothing is stretched.+ pub(crate) fn zoom_along(&self, zoom: f64, axis: vectorcraft_geom::Vec2) -> f64 {+ zoom / (axis.x * axis.x / self.stretch[0] + axis.y * axis.y / self.stretch[1])+ }+}++pub(super) fn rulers(ui: &Ui, full: egui::Rect, xf: &Xf, hover: Option<Point>, scale: RulerScale, t: &Tokens) {+ let p = ui.painter();+ let [top, left, corner] = ruler_rects(full);+ for r in [top, left, corner] {+ p.rect_filled(r, 0.0, t.ruler);+ }+ p.line_segment([top.left_bottom(), top.right_bottom()], Stroke::new(1.0, t.border));+ p.line_segment([left.right_top(), left.right_bottom()], Stroke::new(1.0, t.border));+ // Crosshair in the origin box.+ p.line_segment([corner.center() - vec2(4.0, 0.0), corner.center() + vec2(4.0, 0.0)], Stroke::new(1.0, t.ruler_tick));+ p.line_segment([corner.center() - vec2(0.0, 4.0), corner.center() + vec2(0.0, 4.0)], Stroke::new(1.0, t.ruler_tick));+ let font = egui::FontId::proportional(9.5);+ // Each ruler measures along its own edge, in the canvas's coordinates turned with the view+ // (#826): at 0° the top one reads x and the left one y. `draw` gets each tick's distance+ // (screen points) from `from` along the ruler, its length, and the label of a labelled one.+ let ticks = |from: Pos2, to: Pos2, axis: vectorcraft_geom::Vec2, draw: &mut dyn FnMut(f32, f32, Option<String>)| {+ // Pick a label step (in the unit) that gives ≥ 50 px between labels on this ruler, at its+ // own scale; positions below are in the unit (`per` points of the scale each).+ let zoom = scale.zoom_along(xf.zoom, axis);+ let (per, step) = (scale.unit.points(), scale.unit.ruler_step(zoom));+ let minor = scale.unit.ruler_minor(step);+ let near = |v: f64, every: f64| ((v / every).round() * every - v).abs() < minor * 0.01;+ let (a, b) = (scale.along(xf.to_doc(from), axis), scale.along(xf.to_doc(to), axis));+ let mut v = (a / per / minor).floor() * minor;+ while v * per <= b {+ // A tick's length: the labelled ones longest, the halves between them shorter.+ let (len, label) = if near(v, step) {+ (RULER, Some(ruler_label(v, step)))+ } else if near(v, step / 2.0) {+ (7.0, None)+ } else {+ (4.0, None)+ };+ draw(((v * per - a) * zoom) as f32, len, label);+ v += minor;+ }+ };+ // The canvas's directions along the screen's x and y.+ let (sn, cs) = xf.rot.sin_cos();+ let clip_top = p.with_clip_rect(top);+ ticks(top.left_top(), top.right_top(), vectorcraft_geom::Vec2::new(cs, -sn), &mut |d, len, label| {+ let sx = top.left() + d;+ clip_top.line_segment([pos2(sx, top.bottom() - len), pos2(sx, top.bottom())], Stroke::new(1.0, t.ruler_tick));+ if let Some(text) = label {+ clip_top.text(pos2(sx + 2.0, top.top() + 1.0), egui::Align2::LEFT_TOP, text, font.clone(), t.ruler_tick);+ }+ });+ let clip_left = p.with_clip_rect(left);+ // A label spelled down the ruler is tall, and a long one can reach the next label's place:+ // "-0.0625" is seven characters, 60 pt of ruler, where a sixteenth-inch step leaves 54 pt at+ // zoom 12. The ticks all stay; a label that would run into the one above it is left out.+ let mut filled_to = f32::NEG_INFINITY;+ ticks(left.left_top(), left.left_bottom(), vectorcraft_geom::Vec2::new(sn, cs), &mut |d, len, label| {+ let sy = left.top() + d;+ clip_left.line_segment([pos2(left.right() - len, sy), pos2(left.right(), sy)], Stroke::new(1.0, t.ruler_tick));+ if let Some(text) = label {+ // Vertical labels read top-to-bottom, one digit per line like Illustrator.+ let top = sy + 2.0;+ if top < filled_to {+ return;+ }+ filled_to = top + vertical_label_height(text.chars().count());+ for (k, ch) in text.chars().enumerate() {+ clip_left.text(+ pos2(left.left() + 4.0, top + k as f32 * RULER_CHAR),+ egui::Align2::LEFT_TOP,+ ch.to_string(),+ font.clone(),+ t.ruler_tick,+ );+ }+ }+ });+ if let Some(h) = hover {+ let s = xf.to_screen(h);+ clip_top.line_segment([pos2(s.x, top.top()), pos2(s.x, top.bottom())], Stroke::new(1.0, t.text));+ clip_left.line_segment([pos2(left.left(), s.y), pos2(left.right(), s.y)], Stroke::new(1.0, t.text));+ }+}diff --git a/crates/ui-egui/src/canvas/home.rs b/crates/ui-egui/src/canvas/home.rsnew file mode 100644index 000000000..1d23d9882--- /dev/null+++ b/crates/ui-egui/src/canvas/home.rs@@ -0,0 +1,121 @@+use super::*;++/// The Home screen (`app.home`; with no document open, unless its preference is off).+pub(super) fn home(app: &mut VectorcraftApp, ui: &mut Ui, rect: egui::Rect) {+ let t = Tokens::get(ui.ctx());+ ui.painter().rect_filled(rect, 0.0, t.panel_darker);+ // Taller than the window (a small window, many recent files): it scrolls. Widgets scrolled out+ // of view are clipped, so they take no pointer.+ let mut child = ui.new_child(egui::UiBuilder::new().max_rect(rect).layout(egui::Layout::top_down(egui::Align::Min)));+ egui::ScrollArea::vertical().id_salt("home-scroll").auto_shrink([false, false]).show(&mut child, |ui| {+ let side = (ui.available_width() - 820.0).max(40.0) / 2.0;+ let width = (ui.available_width() - 2.0 * side).max(0.0);+ ui.add_space(60.0);+ ui.horizontal_top(|ui| {+ ui.add_space(side);+ ui.allocate_ui_with_layout(vec2(width, 0.0), egui::Layout::top_down(egui::Align::Min), |ui| {+ ui.set_width(width);+ home_content(app, ui);+ });+ });+ ui.add_space(60.0);+ });+}++/// The Home screen's column: welcome, New / Open, Recent Files, presets and community links.+fn home_content(app: &mut VectorcraftApp, ui: &mut Ui) {+ let t = Tokens::get(ui.ctx());+ ui.label(egui::RichText::new(tl!("Welcome to VectorCraft")).font(theme::semibold(26.0)).color(t.text));+ ui.add_space(4.0);+ ui.label(egui::RichText::new(tl!("Vector illustration — fast, open, scriptable.")).size(14.0).color(t.text_dim));+ ui.add_space(22.0);+ ui.horizontal(|ui| {+ if widgets::primary_button(ui, tl!("New file")).clicked() {+ app.run("file.newDialog", json!({})).ok();+ }+ ui.add_space(8.0);+ if widgets::secondary_button(ui, tl!("Open")).clicked() {+ app.run("file.open", json!({})).ok();+ }+ });+ recent(app, ui);+ ui.add_space(28.0);+ ui.label(egui::RichText::new(tl!("Quickly start a new file")).font(theme::semibold(14.0)).color(t.text));+ ui.add_space(10.0);+ // A few of New Document's presets (`file.newPresets`), as its cards.+ let presets = ["Letter", "A4", "Web 1920×1080", "Phone 390×844", "Postcard", "Social Square Post 1080×1080"];+ ui.horizontal_wrapped(|ui| {+ ui.spacing_mut().item_spacing = vec2(14.0, 14.0);+ let cards: Vec<_> = presets.iter().filter_map(|name| vectorcraft_engine::cmd::newdoc::find(&app.session, name)).collect();+ for s in cards {+ if crate::dialogs::preset_card(ui, &s, false).clicked() {+ app.run("file.new", json!({ "preset": s.name })).ok();+ }+ }+ });+ ui.add_space(28.0);+ ui.label(egui::RichText::new(tl!("Community")).font(theme::semibold(14.0)).color(t.text));+ ui.add_space(10.0);+ crate::community::links(app, ui);+}++/// The Home screen's Recent Files (#663): the first of File › Open Recent Files, each its name and+/// folder; a click opens it. Nothing when there are none.+fn recent(app: &mut VectorcraftApp, ui: &mut Ui) {+ const SHOWN: usize = 6;+ let files: Vec<String> = crate::io::recent_files(app).iter().take(SHOWN).cloned().collect();+ if files.is_empty() {+ return;+ }+ let t = Tokens::get(ui.ctx());+ ui.add_space(28.0);+ ui.label(egui::RichText::new(tl!("Recent Files")).font(theme::semibold(14.0)).color(t.text));+ ui.add_space(8.0);+ for path in files {+ if recent_row(ui, &path).clicked() {+ // A failure is reported to the user there.+ let _ = crate::io::open_recent_reporting(app, &path);+ }+ }+}++/// One Recent Files row across the Home screen: history icon, name (accent) and folder (dim,+/// truncated). The whole row is one button that lights up under the pointer; its tooltip is the+/// full path.+fn recent_row(ui: &mut Ui, path: &str) -> egui::Response {+ const PAD: f32 = 6.0;+ const ICON: f32 = 16.0;+ let t = Tokens::get(ui.ctx());+ let p = std::path::Path::new(path);+ let name = p.file_name().map_or_else(|| path.to_string(), |n| n.to_string_lossy().into_owned());+ let folder = p.parent().map(|f| f.to_string_lossy().into_owned()).unwrap_or_default();+ let (rect, resp) = ui.allocate_exact_size(vec2(ui.available_width(), 26.0), egui::Sense::click());+ if ui.is_rect_visible(rect) {+ if resp.hovered() {+ ui.painter().rect_filled(rect, CornerRadius::same(4), t.hover);+ }+ let icon = egui::Rect::from_center_size(egui::pos2(rect.left() + PAD + ICON / 2.0, rect.center().y), vec2(ICON, ICON));+ crate::icons::paint(ui, "history", icon, t.icon);+ let x = icon.right() + 8.0;+ let name_galley = egui::WidgetText::from(egui::RichText::new(&name).size(13.0).color(t.accent)).into_galley(+ ui,+ Some(egui::TextWrapMode::Truncate),+ (rect.right() - PAD - x).max(0.0),+ egui::TextStyle::Body,+ );+ let folder_x = x + name_galley.size().x + 10.0;+ ui.painter().galley(egui::pos2(x, rect.center().y - name_galley.size().y / 2.0), name_galley, t.accent);+ let room = rect.right() - PAD - folder_x;+ if room > 0.0 && !folder.is_empty() {+ let folder_galley = egui::WidgetText::from(egui::RichText::new(&folder).size(12.0).color(t.text_dim)).into_galley(+ ui,+ Some(egui::TextWrapMode::Truncate),+ room,+ egui::TextStyle::Body,+ );+ ui.painter().galley(egui::pos2(folder_x, rect.center().y - folder_galley.size().y / 2.0), folder_galley, t.text_dim);+ }+ }+ resp.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, true, &name));+ resp.on_hover_text(path).on_hover_cursor(egui::CursorIcon::PointingHand)+}diff --git a/crates/ui-egui/src/canvas/input.rs b/crates/ui-egui/src/canvas/input.rsnew file mode 100644index 000000000..319e9c84b--- /dev/null+++ b/crates/ui-egui/src/canvas/input.rs@@ -0,0 +1,408 @@+use super::artboards::{artboard_name_at, begin_artboard_name_edit, name_press_id, select_named_artboard};+use super::drag::{+ HoverContext, apply_requests, dispatch, drag_art_out, drag_id, drag_layer_id, drag_pos_id, drop_press, mods, on_canvas, pen_pressure,+ tool_drag_doc_id, tool_drag_moved, tool_frame_moves, tool_holds, tool_press_doc_id,+};+use super::view::{+ HOLD_DELAY, HOLD_ZOOM, SCRUB_SLOP, SCRUB_ZOOM, WheelTurn, animated_zoom, pan_pixels, rotate_about, scroll_view, touch_gestures, trackpad_turn,+ wheel, whole_pixels, zoom_about,+};+use super::*;++/// Dispatch canvas pointer, keyboard and drop events through the active document view.+pub(super) fn handle_input(app: &mut VectorcraftApp, ui: &Ui, resp: &egui::Response, rect: egui::Rect) {+ let line = ui.ctx().options(|o| o.input_options.line_scroll_speed);+ let wheel_zooms = app.session.prefs.zoom_with_mouse_wheel;+ let turn_id = egui::Id::unique("canvas-wheel-turn");+ let turn_before: WheelTurn = ui.data(|d| d.get_temp(turn_id)).unwrap_or_default();+ let mut turn = turn_before;+ let (pointer, m, space, (factor, scroll)) =+ ui.input(|i| (i.pointer.clone(), i.modifiers, i.key_down(egui::Key::Space), wheel(i, wheel_zooms, line, rect.height(), &mut turn)));+ if turn != turn_before {+ ui.data_mut(|d| d.insert_temp(turn_id, turn));+ }+ if turn.glide != 0.0 {+ ui.ctx().request_repaint();+ }+ let hover = pointer.hover_pos().filter(|p| rect.contains(*p));+ // Zoom around the pointer, and scroll ([`wheel`]): fingers pinching on a touch screen may also+ // slide. Then turn the view about the pointer for a trackpad rotation ([`trackpad_turn`]). The+ // tool's events below take their document points from the view this moves to.+ if resp.hovered() {+ if (factor - 1.0).abs() > 1e-6+ && let (Some(p), Some(vm)) = (hover, app.view_mut())+ {+ zoom_about(vm, rect, p, vm.zoom * factor);+ }+ if scroll != egui::Vec2::ZERO {+ scroll_view(app, ui, scroll);+ }+ if let Some(p) = hover+ && let Some(deg) = trackpad_turn(ui, app.session.prefs.trackpad_rotate_view)+ && let Some(vm) = app.view_mut()+ {+ rotate_about(vm, rect, p, deg);+ }+ }+ let v = *app.view().unwrap_or(&View::default());+ let xf = Xf::new(rect, &v);+ // A lifted pen or finger takes the pointer away in the frame it lifts (egui's `PointerGone`),+ // so a tap whose press and lift come in one frame has no hover position: it presses (and+ // double-taps) where it was seen last (#491).+ let at = hover.or_else(|| pointer.interact_pos().filter(|p| rect.contains(*p)));+ let view = app.view_info();+ touch_gestures(app, ui, rect, view);+ // Pressed and held still, a pen or a finger opens the context menu (egui's long touch): the+ // tool's press is dropped, as a right-click presses nothing.+ if resp.long_touched() {+ drop_press(app, ui, view);+ }+ let drag: Option<Drag> = ui.data(|d| d.get_temp(drag_id()));+ // A modifier pressed or released over the canvas re-hovers the tool, so what it changes shows+ // without moving the mouse (Alt switches the Shape Builder to erase mode).+ let mods_changed = ui.data_mut(|d| {+ let id = egui::Id::unique("canvas-mods");+ let prev = d.get_temp::<egui::Modifiers>(id);+ d.insert_temp(id, m);+ prev.is_some_and(|prev| prev != m)+ });+ // Where the tool hovers: the pointer over the canvas itself, not over a floating panel, a menu,+ // a popup or a dialog drawn on top of it ([`on_canvas`]).+ let hover_tool = hover.filter(|p| on_canvas(ui, resp, *p));+ // Whether the tool hovered last frame: coming onto the canvas re-hovers it, even after a single+ // jump egui doesn't count as moving, and leaving it ends the tool's hover (below).+ let was_over = ui.data_mut(|d| {+ let id = egui::Id::unique("canvas-hovered");+ let prev = d.get_temp::<bool>(id).unwrap_or(false);+ d.insert_temp(id, hover_tool.is_some());+ prev+ });+ // What a hover means besides where the pointer is on screen: the tool, the canvas, the view+ // (scrolled, zoomed or turned by the wheel, a gesture, keys or a command) and the document and+ // selection as they are (another tab, an edit, an undo). Under a still pointer, a tool switched+ // to is hovered at once, and when the rest changes, a tool that asks for it+ // ([`Session::tool_wants_rehover`]) is hovered again where the pointer is.+ let context = HoverContext {+ tool: app.session.tool_id(),+ canvas: rect,+ center: v.center,+ zoom: v.zoom,+ rotation: v.rotation,+ doc: app.session.active().map(|st| (st.uid, st.revision)),+ };+ let (tool_switched, context_changed) = ui.data_mut(|d| {+ let id = egui::Id::unique("canvas-hover-context");+ let prev = d.get_temp::<HoverContext>(id);+ d.insert_temp(id, context);+ prev.map_or((false, false), |prev| (prev.tool != context.tool, prev != context))+ });++ // In Presentation Mode a click anywhere goes to the next artboard. The tool receives no press,+ // drag or hover, and a drag does not pan the view. A drag that began before the mode was turned+ // on ends as usual.+ if app.ui.screen_mode == 3 && matches!(drag, None | Some(Drag::Present | Drag::Gesture)) {+ let pressed = drag.is_none() && pointer.primary_pressed() && resp.hovered() && at.is_some();+ // `press` is this frame's new press, or else the press held so far. A quick tap can be+ // pressed and released in one frame.+ let press = if pressed { Some(Drag::Present) } else { drag };+ if press.is_some() && !pointer.primary_down() {+ ui.data_mut(|dd| dd.remove::<Drag>(drag_id()));+ // A tap of several fingers leaves `Drag::Gesture` (`touch_gestures`), and its release+ // does not move the view to the next artboard.+ if press == Some(Drag::Present) && resp.clicked() {+ crate::shortcuts::presentation_step(app, true);+ }+ } else if pressed {+ ui.data_mut(|dd| dd.insert_temp(drag_id(), Drag::Present));+ }+ return;+ }++ // A pen turned to its eraser end selects the Eraser, and a pen turned back to its tip selects+ // the tool before it. The switch runs only while the pointer is in this window. It runs before+ // this frame's press, which then uses the new tool; while a press is held, it waits for the+ // release. A turn made over another window takes effect when the pointer comes in.+ if drag.is_none() && ui.input(|i| i.pointer.has_pointer()) {+ crate::stylus::sync_eraser_tool(app);+ }+ let tool = app.session.tool_id();+ // Held, Space is the Hand tool for the moment, Space+Shift is the Rotate View tool and+ // Cmd+Space is the Zoom tool (with Alt, zooming out), whatever the tool.+ let zoom_mode = if space { m.command } else { tool == "zoom" };+ let rotate_mode = if space { m.shift && !m.command } else { tool == "rotateView" };+ let pan_mode = if space { !m.command && !m.shift } else { tool == "hand" };+ let middle_pan = matches!(drag, Some(Drag::Pan { middle: true, .. }));+ // egui counts a press a few pixels outside the canvas as on it (its interaction radius): only a+ // press on the canvas itself reaches the tools, else it would land at the canvas's centre.+ if pointer.primary_pressed()+ && resp.hovered()+ && !middle_pan+ && let Some(p) = at+ {+ ui.ctx().memory_mut(|mem| mem.stop_text_input());+ app.ui.flyout = None;+ // The artboard's name sits above its corner. A press there renames on a double-click+ // and does not start a tool gesture (a fitted artboard, a new one, Artboard Options).+ if let Some(i) = artboard_name_at(app, ui, &xf, p) {+ ui.data_mut(|dd| dd.insert_temp(name_press_id(), i));+ } else {+ let d = if crate::touch::finger_navigates_only() {+ // A finger (or a palm) once a pen has been seen: it navigates, it doesn't draw.+ Drag::Gesture+ } else if zoom_mode {+ if animated_zoom(&app.session.prefs) { Drag::ZoomScrub { start: p, held: 0.0, moved: false } } else { Drag::ZoomBox { start: p } }+ } else if pan_mode {+ Drag::Pan { start: p, center: v.center, middle: false }+ } else if rotate_mode {+ let c = rect.center();+ Drag::RotateView { start_angle: (p.y - c.y).atan2(p.x - c.x) as f64, start_rot: v.rotation, snaps: !space }+ } else {+ // Cmd with another tool drags with the selection tool used last (the session lends it).+ let ev = PointerEvent { kind: PointerKind::Down, pos: xf.to_doc(p), mods: mods(m, space), pressure: pen_pressure(ui, app, true) };+ dispatch(app, &ev, view);+ crate::document_drag::begin(app, ui.ctx(), ev.pos);+ Drag::Tool+ };+ // Panning, zooming or turning the view takes the pointer from the tool's hover.+ if !tool_holds(d) {+ app.session.tool_hover_ended(view);+ }+ ui.data_mut(|dd| {+ dd.insert_temp(drag_id(), d);+ dd.insert_temp(drag_pos_id(), p);+ dd.insert_temp(drag_layer_id(), resp.layer_id);+ // A new press has not dragged yet, whatever an interrupted one left behind.+ dd.remove::<Point>(tool_drag_doc_id());+ dd.insert_temp(tool_press_doc_id(), xf.to_doc(p));+ });+ }+ } else if drag.is_none()+ && resp.hovered()+ && pointer.button_pressed(egui::PointerButton::Middle)+ && let Some(start) = hover+ {+ // Middle-button drag pans the view whatever the tool.+ ui.data_mut(|dd| dd.insert_temp(drag_id(), Drag::Pan { start, center: v.center, middle: true }));+ app.session.tool_hover_ended(view);+ } else if let Some(d) = drag {+ // The pointer gone (a pen lifted with its press), the drag ends where it was last seen.+ let p = pointer.interact_pos().or_else(|| ui.data(|dd| dd.get_temp(drag_pos_id()))).unwrap_or(rect.center());+ let held = if middle_pan { pointer.button_down(egui::PointerButton::Middle) } else { pointer.primary_down() };+ if held {+ ui.data_mut(|dd| dd.insert_temp(drag_pos_id(), p));+ match d {+ Drag::Pan { start, center, .. } => {+ let ppp = ui.ctx().pixels_per_point();+ if let Some(vm) = app.view_mut() {+ vm.center = center;+ pan_pixels(vm, ppp, whole_pixels(p - start, ppp));+ }+ }+ Drag::RotateView { start_angle, start_rot, snaps } => {+ let c = rect.center();+ let a = (p.y - c.y).atan2(p.x - c.x) as f64;+ let mut deg = start_rot + (a - start_angle).to_degrees();+ if snaps && m.shift {+ deg = (deg / 15.0).round() * 15.0;+ }+ if let Some(vm) = app.view_mut() {+ vm.rotation = vectorcraft_geom::normalize_deg(deg);+ }+ }+ Drag::ZoomBox { start } => marquee(ui.painter(), egui::Rect::from_two_pos(start, p)),+ Drag::ZoomScrub { start, held, moved } => {+ let dt = ui.input(|i| i.unstable_dt).min(0.25);+ let (held, moved) = (held + dt, moved || (p - start).length() > SCRUB_SLOP);+ // Dragged sideways it zooms with the pointer, held still it zooms on (Alt: out).+ let exponent = if moved {+ f64::from(pointer.delta().x) * SCRUB_ZOOM+ } else if held > HOLD_DELAY {+ f64::from(dt) * HOLD_ZOOM * if m.alt { -1.0 } else { 1.0 }+ } else {+ 0.0+ };+ if exponent != 0.0+ && let Some(vm) = app.view_mut()+ {+ zoom_about(vm, rect, start, vm.zoom * exponent.exp());+ }+ ui.data_mut(|dd| dd.insert_temp(drag_id(), Drag::ZoomScrub { start, held, moved }));+ }+ // Without a pointer it is over a floating panel's own OS window (`drag_art_out`).+ Drag::Art if pointer.has_pointer() && on_canvas(ui, resp, p) => {+ // Back on the canvas: the move goes on from where it left, with the pointer.+ egui::DragAndDrop::clear_payload(ui.ctx());+ let ev =+ PointerEvent { kind: PointerKind::Drag, pos: xf.to_doc(p), mods: mods(m, space), pressure: pen_pressure(ui, app, false) };+ dispatch(app, &ev, view);+ ui.data_mut(|dd| {+ dd.insert_temp(drag_id(), Drag::Tool);+ dd.insert_temp(drag_pos_id(), p);+ });+ }+ Drag::Art | Drag::Gesture | Drag::Present => {}+ Drag::Tool if drag_art_out(app, ui, resp, p) => {+ ui.data_mut(|dd| dd.insert_temp(drag_id(), Drag::Art));+ }+ Drag::Tool => {+ // Every position the pen or mouse passed this frame, not just the last, for a+ // tool that builds a stroke from them: a fast stroke keeps its curve (a pen or a+ // mouse reports far more often than frames come). Touch events (a pen on Windows+ // or the web, a finger) and a macOS pen's moves carry their own pressure; a+ // mouse's, a pen's on X11 among them, take the host's latest. Other tools get+ // the last position only, so a costly drag preview runs once a frame.+ let moves = tool_frame_moves(ui, app);+ // A frame whose pointer ends where the last one did still moved in between.+ if tool_drag_moved(ui, &xf, p, &pointer) || !moves.is_empty() {+ for (at, force) in moves {+ let pressure = force.unwrap_or_else(|| pen_pressure(ui, app, false));+ dispatch(app, &PointerEvent { kind: PointerKind::Drag, pos: xf.to_doc(at), mods: mods(m, space), pressure }, view);+ }+ let ev =+ PointerEvent { kind: PointerKind::Drag, pos: xf.to_doc(p), mods: mods(m, space), pressure: pen_pressure(ui, app, false) };+ dispatch(app, &ev, view);+ }+ // Time held (Twirl, Pucker and Bloat keep applying); a stalled frame counts+ // a quarter second at most.+ if app.session.tool_wants_ticks() {+ let dt = f64::from(ui.input(|i| i.unstable_dt).min(0.25));+ let r = app.session.tool_tick(dt, view);+ apply_requests(app, r);+ }+ }+ }+ } else {+ // The last position the tool's drag got: none if the press never dragged.+ let last_drag: Option<Point> = ui.data(|dd| dd.get_temp(tool_drag_doc_id()));+ ui.data_mut(|dd| {+ dd.remove::<Drag>(drag_id());+ dd.remove::<Pos2>(drag_pos_id());+ dd.remove::<Point>(tool_drag_doc_id());+ dd.remove::<Point>(tool_press_doc_id());+ });+ match d {+ Drag::ZoomBox { start } => {+ let r = egui::Rect::from_two_pos(start, p);+ if let Some(vm) = app.view_mut() {+ if r.width() > 8.0 && r.height() > 8.0 {+ // The marquee's center and its size on screen set the view, at any rotation.+ vm.center = xf.to_doc(r.center());+ let fill = (rect.width() / r.width()).min(rect.height() / r.height());+ vm.zoom = (xf.zoom * f64::from(fill)).clamp(0.0313, 640.0);+ } else {+ zoom_about(vm, rect, p, crate::state::next_zoom(vm.zoom, !m.alt));+ }+ }+ }+ // A click (not held, not dragged) steps the zoom as with the marquee.+ Drag::ZoomScrub { held, moved: false, .. } if held <= HOLD_DELAY => {+ if let Some(vm) = app.view_mut() {+ zoom_about(vm, rect, p, crate::state::next_zoom(vm.zoom, !m.alt));+ }+ }+ Drag::ZoomScrub { .. } => {}+ Drag::Tool => {+ // The second click of a double-click: don't fit another artboard on this release.+ // A double-click on an object does not open Artboard Options. Empty artboard+ // space still does.+ if resp.double_clicked() && app.session.tool_id() == "artboard" {+ app.session.set_tool_option("suppressFitClick", &json!(true));+ }+ // A move that came in the release's own frame shapes the preview first: the+ // tools commit the last preview, which should be where the pointer let go+ // (#834). Only once the press has dragged, so a click's jitter stays a click+ // (the Pen's corner anchor, no nudge with Direct Selection).+ if let Some(last) = last_drag+ && last != xf.to_doc(p)+ {+ let ev =+ PointerEvent { kind: PointerKind::Drag, pos: xf.to_doc(p), mods: mods(m, space), pressure: pen_pressure(ui, app, false) };+ dispatch(app, &ev, view);+ }+ let ev = PointerEvent { kind: PointerKind::Up, pos: xf.to_doc(p), mods: mods(m, space), pressure: pen_pressure(ui, app, false) };+ dispatch(app, &ev, view);+ }+ Drag::Art if on_canvas(ui, resp, p) => {+ // Came back to the canvas and released in one frame: finish the move here.+ egui::DragAndDrop::clear_payload(ui.ctx());+ let pressure = pen_pressure(ui, app, false);+ let pos = xf.to_doc(p);+ dispatch(app, &PointerEvent { kind: PointerKind::Drag, pos, mods: mods(m, space), pressure }, view);+ dispatch(app, &PointerEvent { kind: PointerKind::Up, pos, mods: mods(m, space), pressure }, view);+ }+ Drag::Art => {+ // Released over a panel: the move goes back. (The app ends it before the panels+ // see the release, so a panel can take the art; this is the headless path.)+ // With no document open there is nothing to roll back; the tool still gets its up.+ let _ = app.session.cancel_interaction();+ dispatch(app, &PointerEvent { kind: PointerKind::Up, pos: Point::ZERO, mods: Mods::default(), pressure: 1.0 }, view);+ }+ Drag::Gesture | Drag::Present => {}+ Drag::Pan { .. } | Drag::RotateView { .. } => {}+ }+ }+ } else if let Some(p) = hover_tool+ && (pointer.is_moving() || mods_changed || !was_over || tool_switched || (context_changed && app.session.tool_wants_rehover()))+ {+ let ev = PointerEvent { kind: PointerKind::Move, pos: xf.to_doc(p), mods: mods(m, space), pressure: 1.0 };+ dispatch(app, &ev, view);+ }+ // The pointer left the canvas (for a panel, or out of the window) or went under a floating+ // panel, menu, popup or dialog, with no press the tool holds: the tool's hover ends, which no+ // hover event would clear (Alt's Distance Guides).+ if was_over && hover_tool.is_none() && !drag.is_some_and(tool_holds) {+ app.session.tool_hover_ended(view);+ ui.ctx().request_repaint();+ }+ // The tool works on another thread (a large selection's planar map): it checks each frame+ // whether the work is done, and then shows the highlight under the pointer.+ if app.session.tool_waiting() {+ if let Err(e) = app.session.tool_poll(view, false) {+ app.status(e.to_string());+ }+ ui.ctx().request_repaint_after(std::time::Duration::from_millis(16));+ }+ if pointer.primary_released()+ && let Some(i) = ui.data_mut(|d| d.remove_temp::<usize>(name_press_id()))+ {+ select_named_artboard(app, i);+ }+ if resp.double_clicked()+ && let Some(p) = at+ {+ if let Some(i) = artboard_name_at(app, ui, &xf, p) {+ begin_artboard_name_edit(ui, app, i);+ } else {+ let ev = PointerEvent { kind: PointerKind::DoubleClick, pos: xf.to_doc(p), mods: mods(m, space), pressure: 1.0 };+ let before = app.session.tool_id().to_string();+ dispatch(app, &ev, view);+ // A double-click on type switched a selection tool to the Type tool: the caret goes where+ // the type was clicked, so typing edits it at once.+ if before != "type" && app.session.tool_id() == "type" {+ app.session.set_tool_option("prevTool", &json!(before));+ for kind in [PointerKind::Down, PointerKind::Up] {+ dispatch(app, &PointerEvent { kind, ..ev }, view);+ }+ }+ }+ }+ if drag.is_some() || pointer.is_moving() || mods_changed {+ ui.ctx().request_repaint();+ }+}++/// A marquee around screen rectangle `r`: dark dashes over a light line, so it shows on a white+/// artboard and on the grey pasteboard alike (#725).+fn marquee(p: &egui::Painter, r: egui::Rect) {+ marquee_through(p, &[r.left_top(), r.right_top(), r.right_bottom(), r.left_bottom()]);+}++/// A [`marquee`] through the screen corners `q` in turn, back to the first: a document rectangle's+/// [`Xf::quad`] in a rotated view.+pub(super) fn marquee_through(p: &egui::Painter, q: &[Pos2]) {+ let pts: Vec<Pos2> = q.iter().chain(q.first()).copied().collect();+ p.add(Shape::line(pts.clone(), Stroke::new(1.0, Color32::from_white_alpha(230))));+ for w in pts.windows(2) {+ p.extend(Shape::dashed_line(&[w[0], w[1]], Stroke::new(1.0, Color32::from_gray(40)), 3.0, 3.0));+ }+}diff --git a/crates/ui-egui/src/canvas/outline.rs b/crates/ui-egui/src/canvas/outline.rsnew file mode 100644index 000000000..907f33612--- /dev/null+++ b/crates/ui-egui/src/canvas/outline.rs@@ -0,0 +1,201 @@+use super::*;++pub(super) fn to_screen_path(bp: &BezPath, xf: &Xf) -> Vec<Vec<Pos2>> {+ // Flatten for drawing: a polyline per subpath (tolerance ~0.25 screen px).+ let mut out: Vec<Vec<Pos2>> = vec![];+ let a = xf.affine();+ let mut t = bp.clone();+ t.apply_affine(a);+ let mut cur: Vec<Pos2> = vec![];+ kurbo_flatten(&t, 0.25, &mut |el| match el {+ PathEl::MoveTo(p) => {+ if cur.len() > 1 {+ out.push(std::mem::take(&mut cur));+ }+ cur.clear();+ cur.push(pos2(p.x as f32, p.y as f32));+ }+ PathEl::LineTo(p) => cur.push(pos2(p.x as f32, p.y as f32)),+ PathEl::ClosePath => {+ if let Some(f) = cur.first().copied() {+ cur.push(f);+ }+ }+ _ => {}+ });+ if cur.len() > 1 {+ out.push(cur);+ }+ out+}++pub(super) fn stroke_path(p: &egui::Painter, bp: &BezPath, xf: &Xf, s: Stroke) {+ for line in to_screen_path(bp, xf) {+ p.add(Shape::line(line, s));+ }+}++pub(super) fn c32(rgb: [u8; 3]) -> Color32 {+ Color32::from_rgb(rgb[0], rgb[1], rgb[2])+}++/// Outline of a node for highlighting (paths, compound children, area type frames, other+/// text/image bounds, symbol instances' bounds measured by their art from `symbols`; a clip+/// group's clipping path only, as [`walk_drawn`] visits it).+pub(super) fn node_outline(n: &Node, symbols: &SymbolBoxes) -> BezPath {+ let mut bp = BezPath::new();+ walk_drawn(n, &mut |c| match &c.kind {+ NodeKind::Path { path, .. } => bp.extend(path.to_bezpath()),+ // Area type shows its frame: the type area Direct Selection reshapes; type on a path its+ // path, which the selection tools' brackets sit on; point type shows its baseline(s).+ NodeKind::Text(t) => {+ if c.extras().perspective.is_none() {+ if let Some(path) = t.area_frame().or_else(|| t.type_path()) {+ bp.extend(path.to_bezpath());+ } else if matches!(t.kind, vectorcraft_doc::TextKind::Point) {+ for (a, b) in t.baselines() {+ bp.move_to(t.xf * a);+ bp.line_to(t.xf * b);+ }+ }+ } else if let Some(b) = c.geometric_bounds_with(symbols) {+ bp.extend(vectorcraft_geom::shapes::rectangle(b).to_bezpath());+ }+ }+ NodeKind::Image(_) | NodeKind::SymbolInstance { .. } => {+ if let Some(b) = c.geometric_bounds_with(symbols) {+ bp.extend(vectorcraft_geom::shapes::rectangle(b).to_bezpath());+ }+ }+ // A placed document shows its box, turned with it.+ NodeKind::PlacedDocument(p) => {+ let [a, b, c, d] = p.corners();+ bp.move_to(a);+ [b, c, d].into_iter().for_each(|q| bp.line_to(q));+ bp.close_path();+ }+ // A gradient mesh shows its mesh lines (#1111).+ NodeKind::Mesh(m) => bp.extend(m.lines().to_bezpath()),+ // An envelope shows its mesh (or top object), not its content.+ NodeKind::Envelope { .. } => {+ if let Some((lines, _)) = vectorcraft_doc::live::envelope_overlay(c) {+ bp.extend(lines.to_bezpath());+ }+ }+ _ => {}+ });+ bp+}++/// The width of the key object's outline (Align to Key Object), thicker than the selection's.+pub(super) const KEY_OUTLINE: f32 = 2.5;++/// The most points ([`overlay_points`]) the selection's outlines and anchors, and the hover+/// highlight, are drawn for: an Image Trace of a photo selects hundreds of thousands of paths at+/// once, and selecting all of an opened PDF can select as many type objects, images and gradient+/// mesh pieces. Their outlines would make a mesh larger than the GPU takes in one buffer (#525,+/// #2460).+pub(super) const OVERLAY_MAX_ANCHORS: usize = 100_000;++/// Whether `nodes` have more than [`OVERLAY_MAX_ANCHORS`] points to outline ([`overlay_points`];+/// counting stops there).+pub(super) fn too_many_anchors<'a>(nodes: impl IntoIterator<Item = &'a Node>) -> bool {+ fn over(n: &Node, left: &mut usize) -> bool {+ match left.checked_sub(overlay_points(n)) {+ Some(l) => *left = l,+ None => return true,+ }+ // A clip group counts only its clipping path, the one child `walk_drawn` visits.+ if n.clips() {+ return n.children().and_then(|children| children.first()).is_some_and(|clip| over(clip, left));+ }+ !matches!(n.kind, NodeKind::Envelope { .. }) && n.editing_children().iter().any(|c| over(c, left))+ }+ let mut left = OVERLAY_MAX_ANCHORS;+ nodes.into_iter().any(|n| over(n, &mut left))+}++/// The points counted for `n` itself, without its children, toward [`OVERLAY_MAX_ANCHORS`]: a+/// path's anchors; the anchors of area type's frame or of type on a path's path; the four corners+/// of the box that area type or type on a path in perspective, images, symbol instances and+/// placed documents show; six for point type, its box's corners and the ends of the baseline+/// marker a selected one shows; and the points and the ends of the mesh lines of a gradient mesh+/// or an envelope.+fn overlay_points(n: &Node) -> usize {+ match &n.kind {+ NodeKind::Path { path, .. } => path.anchor_count(),+ NodeKind::Text(t) => match &t.kind {+ vectorcraft_doc::TextKind::Point => 6,+ _ if n.extras().perspective.is_some() => 4,+ vectorcraft_doc::TextKind::Area { frame } => frame.anchor_count(),+ vectorcraft_doc::TextKind::OnPath { path, .. } => path.anchor_count(),+ },+ NodeKind::Image(_) | NodeKind::SymbolInstance { .. } | NodeKind::PlacedDocument(_) => 4,+ NodeKind::Mesh(m) => m.lines().anchor_count() + m.points.len(),+ NodeKind::Envelope { .. } => {+ vectorcraft_doc::live::envelope_overlay(n).map_or(0, |(lines, grid)| lines.anchor_count() + grid.map_or(0, |g| g.points.len()))+ }+ _ => 0,+ }+}++/// [`Node::walk`] over what a selection highlight shows: an envelope's content is left out (the+/// envelope shows its mesh instead), and a clip group or clipping layer shows only its clipping+/// path, its first child, not the art the path clips (#2422).+pub(super) fn walk_drawn<'a>(n: &'a Node, f: &mut impl FnMut(&'a Node)) {+ f(n);+ if matches!(n.kind, NodeKind::Envelope { .. }) {+ return;+ }+ if n.clips() {+ if let Some(clip) = n.children().and_then(|children| children.first()) {+ walk_drawn(clip, f);+ }+ return;+ }+ for c in n.editing_children().iter() {+ walk_drawn(c, f);+ }+}++/// The topmost editable object under document point `p` at `zoom`, as what is drawn there+/// ([`hit_with`]): a swatch or a symbol dropped on art.+pub(super) fn hit_at(app: &VectorcraftApp, p: Point, zoom: f64) -> Option<vectorcraft_doc::hit::Hit> {+ hit_with(app, p, zoom, vectorcraft_doc::hit::hit_test)+}++/// The topmost editable object under document point `p` at `zoom`, as the selection tools pick+/// it: [`hit_at`], and a clipping path on its outline before the art it clips+/// ([`vectorcraft_doc::hit::HitOptions::clip_outlines`]). Object Highlighting and a right-click's+/// selection show and take what a click of those tools would.+pub(super) fn selection_hit_at(app: &VectorcraftApp, p: Point, zoom: f64) -> Option<vectorcraft_doc::hit::Hit> {+ hit_with(app, p, zoom, |doc, p, opt| vectorcraft_doc::hit::hit_test(doc, p, vectorcraft_doc::hit::HitOptions { clip_outlines: true, ..opt }))+}++/// `test` on the active document at document point `p`, with the options the selection tools hit+/// objects with at `zoom` (Selection & Anchor Display › Tolerance and Object Selection by Path Only,+/// Type › Type Object Selection by Path Only, isolation mode).+pub(super) fn hit_with<T>(+ app: &VectorcraftApp,+ p: Point,+ zoom: f64,+ test: impl FnOnce(&vectorcraft_doc::Document, Point, vectorcraft_doc::hit::HitOptions) -> Option<T>,+) -> Option<T> {+ let prefs = &app.session.prefs;+ let opt = vectorcraft_doc::hit::HitOptions {+ tol: prefs.selection_tolerance / zoom,+ outline: app.ui.view.outline,+ path_only: prefs.object_selection_by_path_only,+ type_path_only: prefs.type_selection_by_path_only,+ scope: app.session.active().and_then(|st| st.isolation),+ skip_guides: !app.ui.view.guides,+ ..Default::default()+ };+ test(&app.session.active()?.doc, p, opt)+}++fn kurbo_flatten(p: &BezPath, tol: f64, f: &mut impl FnMut(PathEl)) {+ // Bounded per curve: a document's far-out handles, zoomed onto the screen, made kurbo+ // reserve gigabytes for the selection outline.+ vectorcraft_geom::flatten(p.elements().iter().copied(), tol, f);+}diff --git a/crates/ui-egui/src/canvas/overlays.rs b/crates/ui-egui/src/canvas/overlays.rsnew file mode 100644index 000000000..6722c4761--- /dev/null+++ b/crates/ui-egui/src/canvas/overlays.rs@@ -0,0 +1,377 @@+use super::artboards::names_an_artboard;+use super::input::marquee_through;+use super::outline::{KEY_OUTLINE, c32, node_outline, selection_hit_at, stroke_path, to_screen_path, too_many_anchors, walk_drawn};+use super::*;++pub(super) fn hover_highlight(app: &VectorcraftApp, p: &egui::Painter, xf: &Xf) {+ let Some(h) = app.hover_doc else { return };+ // Smart Guides › Object Highlighting: a Smart Guides display option, so it needs them on and Snap to Grid and Pixel Preview off.+ if !app.ui.view.smart_guides || !app.session.prefs.object_highlighting || app.ui.view.snap_to_grid || app.ui.view.pixel_preview {+ return;+ }+ if app.session.tool_busy() || !matches!(app.session.tool_id(), "selection" | "directSelection" | "groupSelection") {+ return;+ }+ let Some(st) = app.session.active() else { return };+ let Some(hit) = selection_hit_at(app, h, xf.zoom) else { return };+ let id = if app.session.tool_id() == "selection" { hit.top_object(st.isolation) } else { hit.leaf };+ if st.selection.contains(id) {+ return;+ }+ if let Some(n) = st.doc.node(id).filter(|n| !too_many_anchors([*n])) {+ let color = c32(st.doc.layer_color(id));+ stroke_path(p, &node_outline(n, &st.doc.symbol_boxes()), xf, Stroke::new(1.5, color));+ }+}++/// Selected anchors are drawn slightly deeper than the layer colour (#4f80ff → #3d82ff for Layer 1).+pub(super) fn selected_anchor(c: Color32) -> Color32 {+ if c == Color32::from_rgb(0x4f, 0x80, 0xff) { Color32::from_rgb(0x3d, 0x82, 0xff) } else { c }+}++/// How anchors and handles look: Selection & Anchor Display › Size and Handles.+#[derive(Clone, Copy)]+pub(super) struct HandleLook<'a> {+ /// Points bigger (or smaller) than the default size 3, per step of Size (1–7).+ grow: f32,+ /// `solid` (the default), `hollow` or `large`.+ style: &'a str,+}++impl<'a> HandleLook<'a> {+ pub(super) fn of(prefs: &'a vectorcraft_engine::Prefs) -> Self {+ Self { grow: prefs.anchor_size.clamp(1, 7) as f32 - 3.0, style: &prefs.handle_style }+ }++ /// A direction handle's end at `c`: a solid dot, a hollow one or a larger solid one.+ fn draw(self, p: &egui::Painter, c: Pos2, color: Color32) {+ let r = 2.75 + self.grow / 2.0;+ let hollow = self.style == "hollow";+ p.circle_filled(c, if self.style == "large" { r + 1.5 } else { r }, if hollow { Color32::WHITE } else { color });+ if hollow {+ p.circle_stroke(c, r, Stroke::new(1.0, color));+ }+ }+}++fn anchor_square(p: &egui::Painter, c: Pos2, color: Color32, filled: bool, size: f32) {+ let r = egui::Rect::from_center_size(c, vec2(size, size));+ if filled {+ p.rect_filled(r, 0.0, color);+ } else {+ p.rect_filled(r, 0.0, Color32::WHITE);+ p.rect_stroke(r, 0.0, Stroke::new(1.0, color), StrokeKind::Inside);+ }+}++fn curve_point(p: &egui::Painter, c: Pos2, color: Color32, filled: bool, size: f32) {+ p.circle(c, size / 2.0, if filled { color } else { Color32::WHITE }, Stroke::new(1.0, color));+}++pub(super) fn selection_overlay(app: &mut VectorcraftApp, p: &egui::Painter, xf: &Xf, curve_points_from_tool: bool) {+ // The Selection tool's bounding box (rotated with the objects after a rotation). It hides while+ // a drag moves or resizes the selection, so only the art is seen going with the pointer (#712).+ let show_box = app.session.tool_id() == "selection"+ && !app.session.tool_transforming()+ && app.ui.view.bounding_box+ && app.session.active().is_some_and(|st| !st.selection.is_empty() && st.selection.anchors.is_empty());+ let bbox = if show_box { app.selection_box() } else { None };+ let st = app.session.active();+ let big = st.is_some_and(|st| too_many_anchors(st.selection.objects.iter().filter_map(|id| st.doc.node(*id))));+ let big_bounds = if big { app.selection_bounds() } else { None };+ let app = &*app;+ let Some(st) = app.session.active() else { return };+ let symbols = st.doc.symbol_boxes();+ let tool = app.session.tool_id();+ let direct = vectorcraft_tools::catalog::edits_anchors(tool);+ let curvature = tool == "curvature";+ // Selection & Anchor Display › Size (1–7, 3 the default): anchors, handles and the bounding+ // box's handles a point bigger or smaller per step.+ let look = HandleLook::of(&app.session.prefs);+ let grow = look.grow;+ let anchor = |direct: bool| grow + if direct { 5.0 } else { 4.0 };+ // The selected anchors' handles (drawn once they are counted: Show handles when multiple+ // anchors are selected off shows them for a single one only).+ let (mut handles, mut with_handles) = (vec![], 0);+ // Too many paths to outline: the selection's bounds stand for them.+ if let Some((b, id)) = big_bounds.zip(st.selection.objects.first()) {+ stroke_path(p, &vectorcraft_geom::shapes::rectangle(b).to_bezpath(), xf, Stroke::new(1.0, c32(st.doc.layer_color(*id))));+ }+ // The key object (Align to Key Object): its outline drawn thicker, or its bounds when it has+ // too many paths to outline.+ if let Some((k, n)) = st.selection.key.and_then(|k| Some((k, st.doc.node(k)?))) {+ let outline = if too_many_anchors([n]) {+ n.geometric_bounds_with(&symbols).map(|b| vectorcraft_geom::shapes::rectangle(b).to_bezpath())+ } else {+ Some(node_outline(n, &symbols))+ };+ if let Some(bp) = outline {+ stroke_path(p, &bp, xf, Stroke::new(KEY_OUTLINE, c32(st.doc.layer_color(k))));+ }+ }+ for id in st.selection.objects.iter().filter(|_| !big) {+ let Some(n) = st.doc.node(*id) else { continue };+ let color = c32(st.doc.layer_color(*id));+ let partial = st.selection.partial(*id);+ // Path outlines (and area type / placed document / image / mesh / symbol outlines;+ // point type baselines and origin are drawn below).+ if !matches!(n.kind, NodeKind::Text(ref tx) if matches!(tx.kind, vectorcraft_doc::TextKind::Point)) {+ stroke_path(p, &node_outline(n, &symbols), xf, Stroke::new(1.0, color));+ }+ // Anchors (and handles for selected anchors in direct mode); a gradient mesh's or a mesh+ // envelope's points.+ walk_drawn(n, &mut |c| {+ let envelope = vectorcraft_doc::live::envelope_overlay(c).and_then(|(_, grid)| grid);+ let grid = match &c.kind {+ NodeKind::Mesh(m) => Some(m),+ _ => envelope.as_ref(),+ };+ if let Some(grid) = grid {+ for q in &grid.points {+ anchor_square(p, xf.to_screen(q.p), color, false, anchor(direct));+ }+ return;+ }+ let NodeKind::Path { path, .. } = &c.kind else { return };+ // The Curvature tool owns its points while drawing; existing paths use this overlay.+ if curvature && curve_points_from_tool {+ return;+ }+ let selected_segments = st.selection.segments.get(&c.id);+ if let Some(segments) = selected_segments {+ for &(si, seg) in segments {+ let Some(sp) = path.subpaths.get(si).filter(|sp| seg < sp.segment_count()) else { continue };+ let curve = sp.segment(seg);+ let mut outline = vectorcraft_geom::BezPath::new();+ outline.move_to(curve.p0);+ if sp.segment_is_line(seg) {+ outline.line_to(curve.p3);+ } else {+ outline.curve_to(curve.p1, curve.p2, curve.p3);+ }+ stroke_path(p, &outline, xf, Stroke::new(2.0, color));+ }+ }+ for (si, ai, a) in path.anchors() {+ // An object selected whole has all its anchors selected, and so do the paths inside a+ // group, compound path or clip group selected whole. Direction handles show only on a+ // path that is selected itself: those are the handles that `handle_anchors` in+ // `vectorcraft-tools` lets the tools drag.+ let (sel, handles_shown) = match partial {+ Some(set) => {+ let sel = set.contains(&(si, ai));+ (sel, sel)+ }+ None => (true, direct && c.id == *id),+ };+ let sp = xf.to_screen(a.p);+ if !curvature && handles_shown {+ with_handles += 1;+ let sides = path.subpaths.get(si).map(|subpath| st.selection.handle_sides(c.id, si, ai, subpath)).unwrap_or((true, true));+ handles.extend(+ [(a.h_in, sides.0), (a.h_out, sides.1)]+ .into_iter()+ .filter(|(h, show)| *show && h.distance(a.p) > 1e-6)+ .map(|(h, _)| (sp, xf.to_screen(h), color)),+ );+ }+ let anchor_selected = sel && selected_segments.is_none();+ let ink = if anchor_selected && partial.is_some() { selected_anchor(color) } else { color };+ if curvature {+ curve_point(p, sp, ink, anchor_selected && partial.is_some(), grow + 6.0);+ } else {+ anchor_square(p, sp, ink, anchor_selected, anchor(partial.is_some() || direct));+ }+ }+ });+ // Centre point (Attributes panel → Show Center).+ if n.shows_center()+ && let Some(b) = n.geometric_bounds_with(&symbols)+ {+ anchor_square(p, xf.to_screen(b.center()), color, true, anchor(false));+ }+ // Point type: each line's baseline, where a click selects it (`hit`), whatever its+ // alignment and rotation, and the anchor (area type shows its frame instead, which may+ // not be a rectangle, and type on a path its path).+ if let NodeKind::Text(tx) = &n.kind+ && matches!(tx.kind, vectorcraft_doc::TextKind::Point)+ {+ for (a, b) in tx.baselines() {+ p.line_segment([xf.to_screen(tx.xf * a), xf.to_screen(tx.xf * b)], Stroke::new(1.0, color));+ }+ p.circle_filled(xf.to_screen(tx.xf * Point::ZERO), 2.5, color);+ }+ }+ if app.session.prefs.show_handles_multiple_anchors || with_handles <= 1 {+ for (sp, hp, color) in handles {+ p.line_segment([sp, hp], Stroke::new(1.0, color));+ look.draw(p, hp, color);+ }+ }+ // The spine of each selected blend (or of the blend a selected key object belongs to).+ let mut spines = vec![];+ for id in &st.selection.objects {+ let is_blend = |b: &vectorcraft_doc::NodeId| st.doc.node(*b).is_some_and(|n| matches!(n.kind, NodeKind::Blend { .. }));+ let Some(b) = [Some(*id), st.doc.parent_of(*id)].into_iter().flatten().find(is_blend).filter(|b| !spines.contains(b)) else { continue };+ spines.push(b);+ let Some(NodeKind::Blend { children, spec }) = st.doc.node(b).map(|n| &n.kind) else { continue };+ let Some((path, _)) = vectorcraft_doc::live::blend_spine(children, spec) else { continue };+ let color = c32(st.doc.layer_color(b));+ stroke_path(p, &path.to_bezpath(), xf, Stroke::new(1.0, color));+ for (_, _, a) in path.anchors() {+ anchor_square(p, xf.to_screen(a.p), color, false, anchor(direct));+ }+ }+ // Live Corners widgets (Selection on a live rectangle or polygon, Direct Selection on any path).+ if matches!(tool, "selection" | "directSelection")+ && let Some(w) = vectorcraft_tools::corners::CornerWidgets::showing(+ &st.doc,+ &st.selection,+ xf.zoom,+ tool == "directSelection",+ app.ui.view.corner_widgets,+ app.session.prefs.hide_corner_widget_above,+ )+ {+ for (id, q) in w.visible_on() {+ let (sp, color) = (xf.to_screen(q), c32(st.doc.layer_color(id)));+ p.circle_filled(sp, 3.0, Color32::WHITE);+ p.circle_stroke(sp, 3.0, Stroke::new(1.0, color));+ p.circle_filled(sp, 1.0, color);+ }+ }+ // Bounding box with handles (Selection tool).+ if let Some(b) = bbox {+ let color = c32(st.doc.layer_color(st.selection.objects[0]));+ p.add(Shape::closed_line(b.corners().iter().map(|q| xf.to_screen(*q)).collect(), Stroke::new(1.0, color)));+ for h in vectorcraft_tools::bbox::Handle::ALL {+ let c = xf.to_screen(b.to_doc() * h.pos(b.rect));+ let hr = egui::Rect::from_center_size(c, vec2(6.0 + grow, 6.0 + grow));+ p.rect_filled(hr, 0.0, Color32::WHITE);+ p.rect_stroke(hr, 0.0, Stroke::new(1.0, color), StrokeKind::Inside);+ }+ // The type widget beside it: hollow on point type, filled on area type.+ if let Some(w) = vectorcraft_tools::typewidget::TypeWidget::of(&st.doc, &st.selection, &b, xf.zoom) {+ let (c, r) = (xf.to_screen(w.at), vectorcraft_tools::typewidget::RADIUS_PX);+ p.circle_filled(c, r, if w.area { color } else { Color32::WHITE });+ p.circle_stroke(c, r, Stroke::new(1.0, color));+ }+ }+ // Pie widgets (Selection tool, with View › Show Bounding Box, on live ellipses): each joined+ // by a line to the outline's point at its angle. They stay while one is dragged.+ if tool == "selection" && app.ui.view.bounding_box {+ for w in vectorcraft_tools::pie::PieWidget::of(&st.doc, &st.selection, xf.zoom) {+ let (on, c, r, color) = (xf.to_screen(w.on), xf.to_screen(w.at), vectorcraft_tools::pie::RADIUS_PX, c32(st.doc.layer_color(w.id)));+ p.line_segment([on, c], Stroke::new(1.0, color));+ p.circle_filled(c, r, Color32::WHITE);+ p.circle_stroke(c, r, Stroke::new(1.0, color));+ }+ }+}++/// Record where the Type tool's IME candidate window goes this pass, if it has an editor.+///+/// The descriptor itself is observed once at the end of the pass (`crate::ime::end_of_pass`),+/// after dialogs, floating panels, progress windows and the palette draw: any of them can open+/// over the canvas, take the keyboard or run a command that changes the edited text, so a+/// descriptor written here would carry a stale owner, surrounding text or cause.+pub(super) fn ime_geometry(app: &mut VectorcraftApp, ctx: &egui::Context, xf: &Xf) {+ app.ime_caret_rect = None;+ // A hidden viewport cannot compose; the end-of-pass observation clears the owner.+ if !app.session.tool_wants_text() || app.viewport_hidden(ctx) {+ return;+ }+ let Some((a, b)) = app.session.tool_ime_caret(app.view_info()) else { return };+ let r = egui::Rect::from_two_pos(xf.to_screen(a), xf.to_screen(b)).expand2(vec2(1.0, 0.0));+ app.ime_caret_rect = Some((r, r));+}++pub(super) fn draw_overlays(p: &egui::Painter, xf: &Xf, overlays: &[Overlay], t: &Tokens, look: HandleLook) {+ for o in overlays {+ match o {+ // Where the tools select: the document rectangle, turned with the view.+ Overlay::Marquee(r) => marquee_through(p, &xf.quad(*r)),+ Overlay::Path { path, color, width, dashed } => {+ let s = Stroke::new(*width, c32(*color));+ if *dashed {+ for line in to_screen_path(path, xf) {+ p.extend(Shape::dashed_line(&line, s, 4.0, 3.0));+ }+ } else {+ stroke_path(p, path, xf, s);+ }+ }+ Overlay::Line { a, b, color, dashed } => {+ let s = Stroke::new(1.0, c32(*color));+ let (a, b) = (xf.to_screen(*a), xf.to_screen(*b));+ if *dashed {+ p.extend(Shape::dashed_line(&[a, b], s, 4.0, 3.0));+ } else {+ p.line_segment([a, b], s);+ }+ }+ Overlay::Anchor { p: pt, color, filled, size } => anchor_square(p, xf.to_screen(*pt), c32(*color), *filled, *size),+ Overlay::CurvePoint { p: pt, color, filled, size } => curve_point(p, xf.to_screen(*pt), c32(*color), *filled, *size + look.grow),+ Overlay::Handle { p: pt, color } => look.draw(p, xf.to_screen(*pt), c32(*color)),+ Overlay::Label { p: pt, text, color } => {+ let sp = xf.to_screen(*pt) + vec2(8.0, -14.0);+ p.text(+ sp,+ egui::Align2::LEFT_TOP,+ crate::panels::label_or_name(text, !names_an_artboard(text)),+ egui::FontId::proportional(11.0),+ c32(*color),+ );+ }+ Overlay::Highlight { quad, color } => {+ let c = Color32::from_rgba_unmultiplied(color[0], color[1], color[2], color[3]);+ p.add(Shape::convex_polygon(quad.iter().map(|q| xf.to_screen(*q)).collect(), c, Stroke::NONE));+ }+ Overlay::Measure { p: pt, text } => {+ let sp = xf.to_screen(*pt) + vec2(14.0, 14.0);+ let galley = p.layout(text.clone(), egui::FontId::proportional(11.0), Color32::WHITE, 200.0);+ let r = egui::Rect::from_min_size(sp, galley.size() + vec2(12.0, 8.0));+ p.rect_filled(r, CornerRadius::same(3), t.measure_bg);+ p.galley(sp + vec2(6.0, 4.0), galley, Color32::WHITE);+ }+ Overlay::Distance { a, b, text, color } => distance_guide(p, xf.to_screen(*a), xf.to_screen(*b), text, c32(*color)),+ Overlay::GridLine { a, b, color } => {+ let c = Color32::from_rgba_unmultiplied(color[0], color[1], color[2], color[3]);+ p.line_segment([xf.to_screen(*a), xf.to_screen(*b)], Stroke::new(1.0, c));+ }+ Overlay::Swatch { p: pt, color, selected } => {+ // A white disc under the colour shows its opacity; a dark rim keeps it readable on+ // any art, and the accent ring marks the selected stop.+ let c = xf.to_screen(*pt);+ p.circle_filled(c, 6.0, Color32::WHITE);+ p.circle_filled(c, 5.0, Color32::from_rgba_unmultiplied(color[0], color[1], color[2], color[3]));+ p.circle_stroke(c, 6.0, Stroke::new(1.0, Color32::from_gray(32)));+ if *selected {+ p.circle_stroke(c, 8.0, Stroke::new(2.0, t.accent));+ }+ }+ }+ }+}++/// A Distance Guides measurement on screen ([`Overlay::Distance`]): the line from `a` to `b` in the+/// smart guide colour `color` with a 4 px tick across each end, and `text` in a pill of that colour+/// on its middle, in white or black, whichever reads on it.+fn distance_guide(p: &egui::Painter, a: Pos2, b: Pos2, text: &str, color: Color32) {+ let s = Stroke::new(1.0, color);+ p.line_segment([a, b], s);+ let along = b - a;+ let len = along.length();+ if len > 0.0 && len.is_finite() {+ let across = vec2(-along.y, along.x) / len * 4.0;+ for end in [a, b] {+ p.line_segment([end - across, end + across], s);+ }+ }+ let luma = 0.299 * f32::from(color.r()) + 0.587 * f32::from(color.g()) + 0.114 * f32::from(color.b());+ let ink = if luma > 150.0 { Color32::BLACK } else { Color32::WHITE };+ let galley = p.layout_no_wrap(text.to_owned(), egui::FontId::proportional(11.0), ink);+ let r = egui::Rect::from_center_size(a + along / 2.0, galley.size() + vec2(8.0, 4.0));+ p.rect_filled(r, CornerRadius::same(3), color);+ p.galley(r.min + vec2(4.0, 2.0), galley, ink);+}diff --git a/crates/ui-egui/src/canvas/raster.rs b/crates/ui-egui/src/canvas/raster.rsnew file mode 100644index 000000000..e2fc0f165--- /dev/null+++ b/crates/ui-egui/src/canvas/raster.rs@@ -0,0 +1,93 @@+use super::*;++/// The rendered raster `img` as an egui image. Both are premultiplied RGBA8, so its bytes are copied+/// over whole instead of pixel by pixel, which costs milliseconds for a canvas on a large screen.+/// A raster whose bytes don't match its size gives an empty image of that size.+pub(crate) fn color_image(img: &vectorcraft_render::Rendered) -> egui::ColorImage {+ let size = [img.width as usize, img.height as usize];+ let mut pixels = vec![egui::Color32::TRANSPARENT; size[0] * size[1]];+ let bytes: &mut [u8] = bytemuck::cast_slice_mut(&mut pixels);+ if bytes.len() == img.pixels.len() {+ bytes.copy_from_slice(&img.pixels);+ }+ egui::ColorImage::new(size, pixels)+}++/// The pixels of the `w`×`h` frame through `view` to render again for `doc`, when only the document+/// changed, or placed documents' bitmaps were made, since the frame shown (its key `key` but for+/// the revision and [`CacheKey::placed`], and its render options `opts`), which this thread+/// rendered, and no frame is on its way from the worker: those it changed in, and those the+/// objects showing those bitmaps' files cover (`Some(None)`: none), grown to whole eighths of the+/// frame, as long as they are at most half of it. None: render the whole frame. Frames the worker+/// renders stay whole: its renderer keeps the rasters of the art's effects, this thread's doesn't.+pub(super) fn changed_pixels(+ app: &VectorcraftApp,+ key: &CacheKey,+ doc: &vectorcraft_doc::Document,+ opts: &vectorcraft_render::RenderOptions,+ view: Affine,+ w: u32,+ h: u32,+) -> Option<Option<[u32; 4]>> {+ let (shown, _) = app.canvas.shown.as_ref().filter(|(_, o)| o == opts)?;+ // A viewed opacity mask shows its coverage wherever its art reaches, past its object's bounds.+ if opts.mask_view.is_some() {+ return None;+ }+ let shown_key = app.canvas.key.as_ref()?;+ let same_view = *shown_key == CacheKey { revision: shown_key.revision, placed: shown_key.placed, ..key.clone() };+ if !same_view || app.canvas.texture.is_none() || app.canvas.from_worker || app.canvas.worker.as_ref().is_some_and(|w| w.pending.is_some()) {+ return None;+ }+ // The placed documents' files whose bitmaps were made since the frame shown.+ let placed = if shown_key.placed == key.placed {+ vectorcraft_render::Changed::Nothing+ } else {+ vectorcraft_render::placed_area(doc, &vectorcraft_render::placed_document::made_between(shown_key.placed, key.placed)?)+ };+ match vectorcraft_render::changed(shown, doc).and(placed) {+ vectorcraft_render::Changed::Nothing => Some(None),+ vectorcraft_render::Changed::Area(area) => match vectorcraft_render::view_pixels(area, view, w, h) {+ None => Some(None),+ Some([x0, y0, x1, y1]) => {+ let ((x0, x1), (y0, y1)) = (in_steps(x0, x1, w), in_steps(y0, y1, h));+ (u64::from(x1 - x0) * u64::from(y1 - y0) * 2 <= u64::from(w) * u64::from(h)).then_some(Some([x0, y0, x1, y1]))+ }+ },+ vectorcraft_render::Changed::Everything => None,+ }+}++/// `a..b` of `0..n`, grown to whole eighths of `n` and moved back into `0..n`: the parts of a+/// frame rendered again come in few sizes, which keep the contexts the renderer keeps.+fn in_steps(a: u32, b: u32, n: u32) -> (u32, u32) {+ let step = n.div_ceil(8).max(1);+ let len = (b - a).max(1).div_ceil(step).saturating_mul(step).min(n);+ let a = a.min(n - len);+ (a, a + len)+}++/// Upload the art's raster; Pixel Preview's document pixels keep hard edges when magnified.+pub(super) fn upload(app: &mut VectorcraftApp, ctx: &egui::Context, img: &vectorcraft_render::Rendered, pixel: bool) {+ let color = color_image(img);+ let options = if pixel { egui::TextureOptions::NEAREST } else { egui::TextureOptions::LINEAR };+ match &mut app.canvas.texture {+ Some(tex) => tex.set(color, options),+ None => app.canvas.texture = Some(ctx.load_texture("canvas", color, options)),+ }+}++/// Pixel Preview: the whole document pixels (x0, y0, x1, y1) under the canvas, rotated view+/// included. None when the view is degenerate.+pub(super) fn pixel_region(xf: &Xf) -> Option<[i64; 4]> {+ let r = xf.rect;+ let corners = [r.left_top(), r.right_top(), r.right_bottom(), r.left_bottom()].map(|p| xf.to_doc(p));+ let (mut x0, mut y0, mut x1, mut y1) = (f64::INFINITY, f64::INFINITY, f64::NEG_INFINITY, f64::NEG_INFINITY);+ for p in corners {+ (x0, y0, x1, y1) = (x0.min(p.x), y0.min(p.y), x1.max(p.x), y1.max(p.y));+ }+ let (x0, y0, x1, y1) = (x0.floor(), y0.floor(), x1.ceil(), y1.ceil());+ // A document pixel is bigger than a screen pixel here, so the region is about canvas-sized.+ let ok = [x0, y0, x1, y1].iter().all(|c| c.is_finite() && c.abs() < 1e9) && x1 > x0 && y1 > y0 && x1 - x0 <= 16384.0 && y1 - y0 <= 16384.0;+ ok.then_some([x0 as i64, y0 as i64, x1 as i64, y1 as i64])+}diff --git a/crates/ui-egui/src/canvas/task_bar.rs b/crates/ui-egui/src/canvas/task_bar.rsnew file mode 100644index 000000000..273fce5e6--- /dev/null+++ b/crates/ui-egui/src/canvas/task_bar.rs@@ -0,0 +1,294 @@+use super::*;++/// The Contextual Task Bar's area.+fn task_bar_id() -> egui::Id {+ egui::Id::unique("task-bar")+}++/// Where the Contextual Task Bar was last drawn (none while it isn't shown).+pub(crate) fn task_bar_rect(ctx: &egui::Context) -> Option<egui::Rect> {+ let id = task_bar_id();+ ctx.memory(|m| m.areas().is_visible(&egui::LayerId::new(egui::Order::Middle, id)).then(|| m.area_rect(id)).flatten())+}++/// Whether the objects `ids` (or anything inside them) are painted with a colour: a solid colour,+/// a gradient's stops or a mesh's points, which Recolor Artwork can change.+pub(crate) fn has_colors(doc: &vectorcraft_doc::Document, ids: &[vectorcraft_doc::NodeId]) -> bool {+ ids.iter().filter_map(|id| doc.node(*id)).any(|n| {+ let mut found = false;+ vectorcraft_doc::swatches::node_colors(n, &mut |_, _| found = true);+ found+ })+}++/// The bounds of the artboards the Artboard tool has selected ([`crate::panels::artboards::picked`]).+fn picked_artboards_bounds(app: &VectorcraftApp) -> Option<Rect> {+ let st = app.session.active()?;+ let picked = crate::panels::artboards::picked(app, st.doc.artboards.len());+ picked.iter().filter_map(|i| st.doc.artboards.get(*i)).map(|a| a.rect).reduce(|a, b| a.union(b))+}++/// The Contextual Task Bar: a floating pill under the selection with the most likely next actions.+/// With the Artboard tool it sits under the selected artboards and offers Resize (Artboard+/// Options), Duplicate, Rearrange All (with two or more artboards) and Export (Export for Screens).+/// Its handle drags it anywhere on the canvas; unpinned it keeps that offset as it follows the+/// selection, pinned it stays put ([`crate::state::TaskBarPlace`]).+pub(super) fn task_bar(app: &mut VectorcraftApp, ui: &mut Ui, xf: &Xf) {+ let t = Tokens::get(ui.ctx());+ let on_artboards = app.session.tool_id() == "artboard";+ if !on_artboards+ && (app.session.active().is_none_or(|st| st.selection.is_empty())+ || !matches!(app.session.tool_id(), "selection" | "directSelection" | "groupSelection"))+ {+ return;+ }+ let Some(b) = (if on_artboards { picked_artboards_bounds(app) } else { app.selection_bounds() }) else { return };+ let Some(st) = app.session.active() else { return };+ let n = st.selection.len();+ let first = st.selection.objects.first().and_then(|id| st.doc.node(*id)).cloned();+ let is_group = first.as_ref().is_some_and(|f| matches!(f.kind, NodeKind::Group { .. }));+ let is_image = first.as_ref().is_some_and(|f| matches!(f.kind, NodeKind::Image(_)));+ let is_clip_group = first.as_ref().is_some_and(|f| matches!(f.kind, NodeKind::Group { clip: true, .. }));+ let is_compound = first.as_ref().is_some_and(|f| matches!(f.kind, NodeKind::Compound { .. }));+ let open_path = first.as_ref().is_some_and(|f| matches!(&f.kind, NodeKind::Path { path, .. } if !path.is_closed()));+ let text = first.as_ref().and_then(|f| match &f.kind {+ NodeKind::Text(t) => Some(&t.kind),+ _ => None,+ });+ // Images and vector art selected together: a clipping mask is the likely next step.+ let mixed = n > 1 && {+ let images = st.selection.objects.iter().filter_map(|id| st.doc.node(*id)).filter(|o| matches!(o.kind, NodeKind::Image(_))).count();+ images > 0 && images < n+ };+ // An Image Trace object: the group the engine names "Image Trace", its source image first.+ let is_trace = is_group+ && first.as_ref().is_some_and(|f| {+ f.name.as_deref() == Some("Image Trace") && f.children().is_some_and(|c| c.first().is_some_and(|i| matches!(i.kind, NodeKind::Image(_))))+ });+ let mut items: Vec<(&str, &str, &str, serde_json::Value)> = vec![]; // (label, icon, command, params)+ let none = || json!({});+ if on_artboards {+ // As in the reference app, the Artboard tool offers to resize, duplicate and export the+ // artboards (<https://community.adobe.com/questions-652/contextual-task-bar-in-illustrator-2025-quick-actions-when-you-need-them-1546580>),+ // and to rearrange them (<https://creativepro.com/managing-artboards-in-illustrator/>).+ items.push((tl!("Resize"), "move-diagonal-2", TASK_BAR_ARTBOARD_OPTIONS, none()));+ items.push((tl!("Duplicate"), "copy", TASK_BAR_DUPLICATE_ARTBOARDS, none()));+ if st.doc.artboards.len() > 1 {+ items.push((tl!("Rearrange All"), "dc-rearrange", TASK_BAR_REARRANGE_ARTBOARDS, none()));+ }+ items.push((tl!("Export"), "share-2", "file.exportForScreens", none()));+ } else {+ // Edit Path: the Direct Selection tool, to edit the path's anchors.+ let edit_path = || (tl!("Edit Path"), "dc-direct", "tool.select", json!({"tool": "directSelection"}));+ // As in the reference app, an image offers Image Trace and Crop Image, and traced art offers+ // Expand (<https://community.adobe.com/announcements-651/contextual-task-bar-in-illustrator-2025-quick-actions-when-you-need-them-1546580>).+ if n == 1 && is_image {+ items.push((tl!("Image Trace"), "image", TASK_BAR_IMAGE_TRACE, none()));+ items.push((tl!("Crop Image"), "dc-pf-crop", "ui.cropImage", none()));+ }+ // Direct-selected anchors take the place of a path's Offset Path and Simplify. For them the bar+ // offers Remove, Connect, Cut and Convert to corner or smooth, as the reference app does+ // (<https://helpx.adobe.com/illustrator/desktop/get-started/learn-the-basics/contextual-task-bar-overview.html>).+ // These run the same commands as the Control bar's anchor buttons.+ let anchors = !st.selection.anchors.is_empty();+ if anchors {+ items.push((tl!("Remove Anchor Points"), "pen-tool-delete", "path.removeAnchors", none()));+ items.push((tl!("Connect"), "dc-join", "path.join", none()));+ items.push((tl!("Cut Path"), "scissors", "path.cutAtAnchors", none()));+ items.push((tl!("Corner"), "dc-anchor", TASK_BAR_TO_CORNER, none()));+ items.push((tl!("Smooth"), "dc-anchor-smooth", TASK_BAR_TO_SMOOTH, none()));+ }+ // As in the reference app, open paths offer Join and Edit Path, compound paths and clipping+ // masks their Release, images selected with vector art Make Clipping Mask, and type converts+ // between point and area type (<https://helpx.adobe.com/illustrator/desktop/get-started/learn-the-basics/contextual-task-bar-overview.html>).+ if n > 1 {+ items.push((tl!("Group"), "group", "object.group", none()));+ if mixed {+ items.push((tl!("Make Clipping Mask"), "dc-pf-crop", "object.clippingMask.make", none()));+ } else {+ items.push((tl!("Unite"), "squares-unite", "object.pathfinder.unite", none()));+ }+ } else if is_trace {+ items.push((tl!("Expand"), "maximize-2", "imageTrace.expand", none()));+ } else if is_clip_group {+ items.push((tl!("Edit Clipping Path"), "dc-direct", "object.clippingMask.editMask", none()));+ items.push((tl!("Release Clipping Mask"), "ungroup", "object.clippingMask.release", none()));+ } else if is_group {+ items.push((tl!("Ungroup"), "ungroup", "object.ungroup", none()));+ items.push((tl!("Isolate"), "square-dashed", "object.isolate", none()));+ } else if is_compound {+ items.push(edit_path());+ items.push((tl!("Release Compound Path"), "ungroup", "object.compoundPath.release", none()));+ } else if let Some(kind) = text {+ items.push((tl!("Create Outlines"), "type", "type.createOutlines", none()));+ // Point type converts to area type and back; type on a path doesn't.+ match kind {+ TextKind::Area { .. } => items.push((tl!("Convert To Point Type"), "type", "type.convertToPointType", none())),+ TextKind::Point => items.push((tl!("Convert To Area Type"), "dc-type-area", "type.convertToAreaType", none())),+ TextKind::OnPath { .. } => {}+ }+ } else if is_image {+ // Offset Path and Simplify don't apply to an image.+ } else if !anchors {+ if open_path {+ items.push((tl!("Join"), "dc-join", "path.join", none()));+ }+ items.push(edit_path());+ items.push((tl!("Offset Path"), "square-dashed", "object.path.offsetPath", none()));+ items.push((tl!("Simplify"), "spline", "object.path.simplify", none()));+ }+ items.push((tl!("Duplicate"), "copy", "edit.duplicate", none()));+ }+ let fill = first.as_ref().map(|f| f.appearance.fill_paint()).unwrap_or_default();+ let colored = has_colors(&st.doc, &st.selection.objects);+ let doc = st.uid;+ // Under the selection's lowest corner on screen, centered on the selection (the view may be+ // rotated).+ let lowest = xf.quad(b).iter().map(|c| c.y).fold(f32::NEG_INFINITY, f32::max);+ let anchor = pos2(xf.to_screen(b.center()).x, lowest);+ let est_w = 118.0 + items.iter().map(|(l, _, _, _)| l.len() as f32 * 7.2 + 44.0).sum::<f32>();+ // Its place under the selection, then where the handle moved it, kept on the canvas (with the+ // bar's size last frame, the estimate before it first shows).+ let under = pos2(anchor.x - est_w / 2.0, anchor.y + 28.0);+ let id = task_bar_id();+ let size = egui::AreaState::load(ui.ctx(), id).and_then(|s| s.size).unwrap_or(vec2(est_w, 44.0));+ let bounds = xf.rect.shrink(8.0);+ let keep_in = |p: Pos2| p.clamp(bounds.min, (bounds.max - size).max(bounds.min));+ let place = &mut app.ui.task_bar_place;+ // Just unpinned: follow the selection from the pinned spot.+ if !place.pinned+ && let Some(at) = place.pin_at.take()+ {+ place.offset = Some((doc, xf.rect.min + at - under));+ }+ let pos = keep_in(match place.pin_at {+ Some(at) => xf.rect.min + at,+ None => under + place.offset.filter(|(d, _)| *d == doc).map_or(Vec2::ZERO, |(_, o)| o),+ });+ place.shown_at = Some(pos - xf.rect.min);+ // Pinned before it ever showed: hold it here.+ if place.pinned && place.pin_at.is_none() {+ place.pin_at = place.shown_at;+ }+ let pinned = place.pinned;+ let mut moved = Vec2::ZERO;+ let mut run: Option<(&str, serde_json::Value)> = None;+ egui::Area::new(id).order(egui::Order::Middle).fixed_pos(pos).show(ui.ctx(), |ui| {+ egui::Frame::NONE+ .fill(t.panel)+ .stroke(Stroke::new(1.0, t.tool_active))+ .corner_radius(CornerRadius::same(5))+ .inner_margin(egui::Margin::symmetric(8, 6))+ .shadow(egui::epaint::Shadow { offset: [0, 3], blur: 10, spread: 0, color: Color32::from_black_alpha(70) })+ .show(ui, |ui| {+ ui.horizontal(|ui| {+ ui.spacing_mut().item_spacing.x = 6.0;+ let (g, grip) = ui.allocate_exact_size(vec2(4.0, 28.0), Sense::drag());+ let active = grip.hovered() || grip.dragged();+ ui.painter().rect_filled(g.shrink2(vec2(0.5, 4.0)), CornerRadius::same(2), if active { t.text_dim } else { t.button_border });+ if grip.dragged() {+ ui.ctx().set_cursor_icon(egui::CursorIcon::Grabbing);+ moved = grip.drag_delta();+ } else if grip.hovered() {+ ui.ctx().set_cursor_icon(egui::CursorIcon::Grab);+ }+ for (label, icon, cmd, params) in &items {+ let galley = ui.painter().layout_no_wrap(label.to_string(), egui::FontId::proportional(13.0), t.text_strong);+ let (r, resp) = ui.allocate_exact_size(vec2(galley.size().x + 38.0, 30.0), Sense::click());+ if resp.hovered() {+ ui.painter().rect_filled(r, CornerRadius::same(3), t.hover);+ }+ ui.painter().rect_stroke(r, CornerRadius::same(3), Stroke::new(1.0, t.button_border), StrokeKind::Inside);+ crate::icons::paint(ui, icon, egui::Rect::from_min_size(r.min + vec2(8.0, 7.0), vec2(16.0, 16.0)), t.icon);+ ui.painter().galley(pos2(r.left() + 30.0, r.center().y - galley.size().y / 2.0), galley, t.text_strong);+ if resp.clicked() {+ run = Some((*cmd, params.clone()));+ }+ }+ // The selected objects' Fill, Recolor Artwork and Lock, left out with the Artboard tool.+ if !on_artboards {+ let (r, resp) = ui.allocate_exact_size(vec2(26.0, 30.0), Sense::click());+ widgets::paint_chip(ui, egui::Rect::from_center_size(r.center(), vec2(16.0, 16.0)), &fill);+ ui.painter().rect_stroke(+ egui::Rect::from_center_size(r.center(), vec2(16.0, 16.0)),+ 0.0,+ Stroke::new(1.0, t.button_border),+ StrokeKind::Outside,+ );+ if resp.on_hover_text(tl!("Fill")).clicked() {+ app.session.fill_active = true;+ app.ui.open_panel = Some("swatches".into());+ }+ // Recolor Artwork, when the selection has colours to recolour.+ if colored && widgets::icon_button(ui, "palette", tl!("Recolor Artwork"), false, 30.0).clicked() {+ run = Some(("ui.recolorDialog", json!({})));+ }+ if widgets::icon_button(ui, "lock", tl!("Lock (⌘2)"), false, 30.0).clicked() {+ run = Some(("object.lock", json!({})));+ }+ }+ let more = widgets::icon_button(ui, "ellipsis", tl!("More Options"), false, 30.0);+ egui::Popup::menu(&more).show(|ui| {+ ui.set_min_width(170.0);+ let bar = [+ (tl!("Hide Bar"), "window.taskBar", false),+ (tl!("Pin Bar Position"), "window.taskBar.pin", pinned),+ (tl!("Reset Bar Position"), "window.taskBar.reset", false),+ ];+ for (label, cmd, checked) in bar {+ if widgets::menu_item(ui, label, true, checked) {+ run = Some((cmd, json!({})));+ }+ }+ ui.separator();+ if widgets::menu_item(ui, tl!("Show Properties Panel"), true, false) {+ run = Some(("window.panel", json!({"panel": "properties"})));+ }+ });+ });+ });+ });+ if moved != Vec2::ZERO {+ let to = keep_in(pos + moved);+ let place = &mut app.ui.task_bar_place;+ if place.pinned {+ place.pin_at = Some(to - xf.rect.min);+ } else {+ place.offset = Some((doc, to - under));+ }+ ui.ctx().request_repaint();+ }+ match run {+ // Image Trace traces the image at once with the Default preset. As a quick trace from+ // Properties or the Control bar, it leaves the Image Trace panel as it was.+ Some((TASK_BAR_IMAGE_TRACE, _)) => crate::menus::invoke(app, "imageTrace.make", json!({"preset": "Default"})),+ // The Artboard tool's buttons: Artboard Options for the active artboard, as Properties'+ // icon opens it; Duplicate for every selected artboard; Rearrange All Artboards.+ Some((TASK_BAR_ARTBOARD_OPTIONS, _)) => crate::menus::invoke(app, "tool.options", json!({"tool": "artboard"})),+ Some((TASK_BAR_DUPLICATE_ARTBOARDS, _)) => crate::panels::artboards::duplicate_picked(app),+ Some((TASK_BAR_REARRANGE_ARTBOARDS, _)) => crate::panels::artboards::open_rearrange(app),+ // Corner and Smooth convert the direct-selected anchors, as the Control bar's buttons do.+ Some((TASK_BAR_TO_CORNER, _)) => crate::menus::invoke(app, "path.convertAnchors", json!({"to": "corner"})),+ Some((TASK_BAR_TO_SMOOTH, _)) => crate::menus::invoke(app, "path.convertAnchors", json!({"to": "smooth"})),+ Some((c, p)) => crate::menus::invoke(app, c, p),+ None => {}+ }+}++/// The Contextual Task Bar's Image Trace button: a trace with the Default preset.+const TASK_BAR_IMAGE_TRACE: &str = "taskBar.imageTrace";++/// The Contextual Task Bar's Resize button with the Artboard tool: Artboard Options.+const TASK_BAR_ARTBOARD_OPTIONS: &str = "taskBar.artboardOptions";++/// The Contextual Task Bar's Duplicate button with the Artboard tool.+const TASK_BAR_DUPLICATE_ARTBOARDS: &str = "taskBar.duplicateArtboards";++/// The Contextual Task Bar's Rearrange All button with the Artboard tool.+const TASK_BAR_REARRANGE_ARTBOARDS: &str = "taskBar.rearrangeArtboards";++/// The Contextual Task Bar's Corner button for direct-selected anchors.+const TASK_BAR_TO_CORNER: &str = "taskBar.toCorner";++/// The Contextual Task Bar's Smooth button for direct-selected anchors.+const TASK_BAR_TO_SMOOTH: &str = "taskBar.toSmooth";diff --git a/crates/ui-egui/src/canvas/tool_overlays.rs b/crates/ui-egui/src/canvas/tool_overlays.rsnew file mode 100644index 000000000..c3f1b8007--- /dev/null+++ b/crates/ui-egui/src/canvas/tool_overlays.rs@@ -0,0 +1,338 @@+use super::grid::{clip_segment, pref_color};+use super::outline::{OVERLAY_MAX_ANCHORS, c32, stroke_path};+use super::*;++/// Type → Show Hidden Characters: spaces as dots, ¶ at paragraph ends, # at the end of a story.+/// The marks of each text object are kept from one frame to the next ([`HiddenChars`]).+pub(super) fn hidden_chars_overlay(app: &mut VectorcraftApp, p: &egui::Painter, xf: &Xf) {+ let Some(st) = app.session.active() else { return };+ let clip = p.clip_rect();+ let color = Color32::from_rgb(0x4f, 0x9d, 0xff);+ let font = egui::FontId::proportional(((10.0 * xf.zoom) as f32).clamp(7.0, 18.0));+ let kept = &mut app.canvas.hidden_chars;+ // `last` holds the marks of the last frame. The marks of the objects this frame doesn't draw+ // are dropped at the end.+ let mut last = std::mem::take(&mut kept.marks);+ // The inputs are read before any layout: when fonts load during this frame, the next frame+ // lays all type out again.+ let inputs = (vectorcraft_text::FontDb::global().generation(), vectorcraft_text::hyphenation_exceptions());+ if kept.inputs != inputs {+ last.clear();+ kept.inputs = inputs;+ }+ // `walk` visits each node's `Arc` in the order `Document::walk` visits the nodes (depth first,+ // in paint order).+ fn walk(nodes: &[std::sync::Arc<Node>], f: &mut impl FnMut(&std::sync::Arc<Node>)) {+ for n in nodes {+ f(n);+ if let Some(children) = n.children() {+ walk(children, f);+ }+ }+ }+ walk(&st.doc.layers, &mut |n| {+ let NodeKind::Text(tx) = &n.kind else { return };+ // The box round the object's corners on screen, turned with the view.+ if !n.visible || n.geometric_bounds().is_none_or(|b| !egui::Rect::from_points(&xf.quad(b)).intersects(clip)) {+ return;+ }+ let marks = match last.remove(&n.id) {+ Some((was, marks)) if std::sync::Arc::ptr_eq(&was, n) => marks,+ _ => std::sync::Arc::new(HiddenMarks::of(tx)),+ };+ for &at in &marks.spaces {+ p.circle_filled(xf.to_screen(at), 1.2, color);+ }+ for &(at, glyph) in &marks.ends {+ p.text(xf.to_screen(at), egui::Align2::LEFT_BOTTOM, glyph, font.clone(), color);+ }+ kept.marks.insert(n.id, (n.clone(), marks));+ });+}++/// The Show Hidden Characters marks of the text objects drawn in the last frame+/// ([`crate::CanvasCache::hidden_chars`]). Each is kept with the object it was laid out from: an+/// edited object is a new `Arc` and is laid out again, and all type is laid out again when the+/// fonts or the hyphenation exceptions change.+#[derive(Default)]+pub struct HiddenChars {+ /// The fonts' generation ([`vectorcraft_text::FontDb::generation`]) and the hyphenation+ /// exceptions the marks were laid out with.+ pub(super) inputs: (u64, String),+ /// Each text object drawn, by id: the node it was laid out from and its marks.+ pub(super) marks: std::collections::HashMap<vectorcraft_doc::NodeId, (std::sync::Arc<Node>, std::sync::Arc<HiddenMarks>)>,+}++/// One text object's marks in document space: a dot over each space, and ¶ or # after the lines+/// that end a paragraph or the story. Type on a path has none.+#[derive(Default)]+pub(super) struct HiddenMarks {+ pub(super) spaces: Vec<Point>,+ ends: Vec<(Point, &'static str)>,+}++impl HiddenMarks {+ /// Lay out `tx` and place its marks.+ pub(super) fn of(tx: &vectorcraft_doc::TextObject) -> Self {+ let mut marks = Self::default();+ let lay = vectorcraft_text::layout(vectorcraft_text::FontDb::global(), tx);+ if lay.on_path {+ return marks;+ }+ let text = tx.plain_text();+ let to = |q: Point| tx.xf * q;+ // A list marker's glyphs (length 0) stand for no character.+ for g in lay.glyphs.iter().filter(|g| g.len > 0) {+ if text.get(g.byte..).is_some_and(|s| s.starts_with(' ')) {+ marks.spaces.push(to(Point::new(g.origin.x + g.advance / 2.0, g.origin.y - 3.0)));+ }+ }+ for (i, line) in lay.lines.iter().enumerate() {+ let last = i + 1 == lay.lines.len();+ let breaks = text.get(line.end..).is_some_and(|s| s.starts_with('\n'));+ let (glyph, at) = if last && line.end >= text.len() {+ ("#", true)+ } else if breaks {+ ("¶", true)+ } else {+ ("", false)+ };+ if at {+ marks.ends.push((to(Point::new(line.x1 + 1.0, line.baseline)), glyph));+ }+ }+ marks+ }+}++/// View › Show Text Threads: for each thread with a selected frame, a line in its first frame's+/// layer colour from each frame's out port to the next frame's in port, both showing the arrow of a+/// threaded port, where the tools draw the ports of selected type ([`vectorcraft_tools::text`]).+/// Only frames with ports ([`vectorcraft_tools::text::ported`]) are joined: a link to or from a+/// frame in perspective, which has none, gets no line. With more than+/// [`vectorcraft_tools::text::PORTS_MAX`] such frames selected the tools draw no ports, and only+/// the lines are drawn here. `zoom`: screen pixels to the document unit.+pub(super) fn thread_overlays(app: &VectorcraftApp, zoom: f64) -> Vec<Overlay> {+ use vectorcraft_tools::text::{Port, PortState, port_centre, ported, ports_shown, push_port};+ let Some(st) = app.session.active() else { return vec![] };+ let px = 1.0 / zoom.max(1e-9);+ let boxes = ports_shown(&st.doc, &st.selection.objects);+ let mut o = vec![];+ for thread in &st.doc.text_threads {+ if !thread.iter().any(|id| st.selection.objects.contains(id)) {+ continue;+ }+ let color = st.doc.layer_color(thread[0]);+ for w in thread.windows(2) {+ let [a, b] = [w[0], w[1]];+ let (Some(from), Some(to)) = (ported(&st.doc, a), ported(&st.doc, b)) else { continue };+ let (Some(out), Some(input)) = (port_centre(from, Port::Out, px), port_centre(to, Port::In, px)) else { continue };+ o.push(Overlay::Line { a: out, b: input, color, dashed: false });+ if boxes {+ push_port(&mut o, out, PortState::Threaded, st.doc.layer_color(a), px);+ push_port(&mut o, input, PortState::Threaded, st.doc.layer_color(b), px);+ }+ }+ }+ o+}++/// View → Show Live Paint Gaps: the gaps of the selected Live Paint groups in each group's Gap+/// Preview Color ([`crate::dialogs::live_paint_gaps::selected_gaps`]). Cached per revision.+pub(super) fn live_paint_gap_overlays(app: &mut VectorcraftApp) -> Vec<Overlay> {+ let Some(st) = app.session.active() else { return vec![] };+ let key = (st.uid, st.revision);+ let gaps = match &app.canvas.live_paint_gaps {+ Some((k, gaps)) if *k == key => gaps.clone(),+ _ => {+ let gaps = std::sync::Arc::new(crate::dialogs::live_paint_gaps::selected_gaps(app));+ app.canvas.live_paint_gaps = Some((key, gaps.clone()));+ gaps+ }+ };+ gaps.to_vec()+}++/// Simplify's Show Original Path: the paths its preview ran on, as they were before it, in a band+/// 3 screen points wide of their layer's color at 40%, under the selection's outlines. Nothing is drawn+/// when they have more than [`OVERLAY_MAX_ANCHORS`] anchor points.+pub(super) fn original_path_overlay(app: &VectorcraftApp, p: &egui::Painter, xf: &Xf) {+ let paths = crate::dialogs::path_ops::original_paths(app);+ let Some(st) = app.session.active().filter(|_| paths.iter().map(|(_, path)| path.anchor_count()).sum::<usize>() <= OVERLAY_MAX_ANCHORS) else {+ return;+ };+ for (id, path) in paths {+ stroke_path(p, &path.to_bezpath(), xf, Stroke::new(3.0, c32(st.doc.layer_color(id)).gamma_multiply(0.4)));+ }+}++/// The slices (unless View → Hide Slices): user and object slices outlined in the Slices+/// preferences' line colour, auto slices dashed and dimmer, each numbered at its top left (Show+/// Slice Numbers); selected slices have a bolder outline. The layout is cached per revision.+pub(super) fn slice_overlay(app: &mut VectorcraftApp, p: &egui::Painter, xf: &Xf) {+ let Some(st) = app.session.active() else { return };+ let key = (st.uid, st.revision);+ let slices = match &app.canvas.slices {+ Some((k, s)) if *k == key => s.clone(),+ _ => {+ let s = std::sync::Arc::new(st.doc.slice_layout());+ app.canvas.slices = Some((key, s.clone()));+ s+ }+ };+ if slices.is_empty() {+ return;+ }+ let prefs = &app.session.prefs;+ let line = pref_color(&prefs.slice_line_color, Color32::from_rgb(0xff, 0x3f, 0x3f));+ let dim = line.gamma_multiply(0.55);+ let selected = &st.selection.slices;+ let objects = &st.selection.objects;+ for a in slices.iter() {+ let auto = a.source == vectorcraft_doc::SliceSource::Auto;+ let on = a.id.is_some_and(|id| selected.contains(&id) || objects.contains(&id));+ let q = xf.quad(a.rect);+ let ring: Vec<Pos2> = q.iter().chain(q.first()).copied().collect();+ if auto {+ p.extend(Shape::dashed_line(&ring, Stroke::new(1.0, dim), 3.0, 3.0));+ } else {+ p.add(Shape::line(ring, Stroke::new(if on { 2.0 } else { 1.0 }, line)));+ }+ if prefs.show_slice_numbers+ && let Some(tl) = q.first()+ {+ let font = egui::FontId::proportional(9.0);+ let galley = p.layout_no_wrap(format!("{:02}", a.number), font, Color32::WHITE);+ let badge = egui::Rect::from_min_size(*tl + vec2(1.0, 1.0), galley.size() + vec2(6.0, 2.0));+ p.rect_filled(badge, CornerRadius::ZERO, if auto { dim } else { line });+ p.galley(badge.min + vec2(3.0, 1.0), galley, Color32::WHITE);+ }+ }+}++/// The print tiling (View → Show Print Tiling, or the Print Tiling tool): each page of the+/// document's print settings as `print.preview` lays it out, its paper edge and its imageable+/// area dashed, numbered at its top left; tiles outside the tile range dimmer. Cached per revision.+pub(super) fn print_tiling_overlay(app: &mut VectorcraftApp, p: &egui::Painter, xf: &Xf) {+ let Some(st) = app.session.active() else { return };+ let key = (st.uid, st.revision);+ let pages = match &app.canvas.print_tiling {+ Some((k, pages)) if *k == key => pages.clone(),+ _ => {+ // Settings that can't print have no pages to show.+ let pages = std::sync::Arc::new(vectorcraft_engine::cmd::printtiling::pages(&st.doc).unwrap_or_default());+ app.canvas.print_tiling = Some((key, pages.clone()));+ pages+ }+ };+ let font = egui::FontId::proportional(10.0);+ let ring = |r: [f64; 4]| {+ let q = xf.quad(Rect::new(r[0], r[1], r[2], r[3]));+ q.iter().chain(q.first()).copied().collect::<Vec<Pos2>>()+ };+ for page in pages.iter() {+ let color = if page.printed { PRINT_TILING } else { PRINT_TILING.gamma_multiply(0.45) };+ p.add(Shape::line(ring(page.page), Stroke::new(0.75, color)));+ let inner = ring(page.imageable);+ p.extend(Shape::dashed_line(&inner, Stroke::new(1.0, color), 4.0, 3.0));+ if let Some(corner) = inner.iter().copied().reduce(|a, b| pos2(a.x.min(b.x), a.y.min(b.y))) {+ p.text(corner + vec2(3.0, 2.0), egui::Align2::LEFT_TOP, page.number.to_string(), font.clone(), color);+ }+ }+}++/// The print tiling's lines: a neutral grey that reads on the paper and on the pasteboard.+const PRINT_TILING: Color32 = Color32::from_gray(96);++/// A Shaper Group's mode widget (Shaper and Selection tools), drawn with selection edges shown or+/// hidden: an arrow pointing right in Face Selection mode and left in Construction mode.+pub(super) fn shaper_widget_overlay(app: &VectorcraftApp, p: &egui::Painter, xf: &Xf) {+ let Some(st) = app.session.active() else { return };+ if matches!(app.session.tool_id(), "shaper" | "selection")+ && let Some(w) = vectorcraft_tools::shaperwidget::ShaperWidget::of(&st.doc, &st.selection, st.isolation, xf.zoom)+ {+ let (c, r) = (xf.to_screen(w.at), vectorcraft_tools::shaperwidget::RADIUS_PX);+ let color = c32(st.doc.layer_color(w.group));+ p.circle_filled(c, r, Color32::WHITE);+ p.circle_stroke(c, r, Stroke::new(1.0, color));+ let d = if w.construction { -1.0 } else { 1.0 };+ let arrow = vec![c + vec2(3.0 * d, 0.0), c + vec2(-2.0 * d, -3.0), c + vec2(-2.0 * d, 3.0)];+ p.add(Shape::convex_polygon(arrow, color, Stroke::NONE));+ }+}++/// High-contrast live controls, using the same geometry as the Selection tool's hit testing.+pub(super) fn mirror_axis_overlay(app: &VectorcraftApp, p: &egui::Painter, xf: &Xf) {+ if app.session.tool_id() != "selection" || !app.ui.view.bounding_box {+ return;+ }+ let Some(st) = app.session.active() else { return };+ let Some(axis) = vectorcraft_tools::mirror::MirrorAxis::of(&st.doc, &st.selection, xf.zoom) else { return };+ let t = Tokens::get(p.ctx());+ let ends = axis.ends.map(|q| xf.to_screen(q));+ let center = xf.to_screen(axis.center);+ if !center.is_finite() || !ends.iter().all(|p| p.is_finite()) {+ return;+ }+ if let Some((a, b)) = clip_segment(ends[0], ends[1], xf.rect) {+ p.line_segment([a, b], Stroke::new(5.0, t.measure_bg));+ p.line_segment([a, b], Stroke::new(2.0, t.selection));+ }+ for end in ends {+ p.circle_filled(end, vectorcraft_tools::mirror::HANDLE_RADIUS, t.measure_bg);+ p.circle_stroke(end, vectorcraft_tools::mirror::HANDLE_RADIUS, Stroke::new(2.0, t.selection));+ }+ let handle = egui::Rect::from_center_size(center, vec2(12.0, 12.0));+ p.rect_filled(handle, 2.0, t.selection);+ p.rect_stroke(handle, 2.0, Stroke::new(2.0, t.measure_bg), StrokeKind::Outside);+}++/// A selected grid repeat's row, column and corner handles and its spacing sliders (#2691), at+/// the places the Selection tool's hit testing finds them.+pub(super) fn grid_repeat_overlay(app: &mut VectorcraftApp, p: &egui::Painter, xf: &Xf) {+ use vectorcraft_tools::repeat_grid::{GridHandles, GridPart, HANDLE_RADIUS, SLIDER_HALF};+ if app.session.tool_id() != "selection" || !app.ui.view.bounding_box {+ return;+ }+ let frame = app.selection_box();+ let Some(st) = app.session.active() else { return };+ let Some(grid) = GridHandles::of(&st.doc, &st.selection, frame, xf.zoom) else { return };+ let t = Tokens::get(p.ctx());+ let half = f64::from(SLIDER_HALF) / xf.zoom;+ for (part, at) in grid.parts() {+ let c = xf.to_screen(at);+ if !c.is_finite() {+ continue;+ }+ if part.is_slider() {+ // A bar across the gap's middle, square to the spacing it sets.+ let along = if part == GridPart::HSpacing { vectorcraft_geom::Vec2::new(0.0, half) } else { vectorcraft_geom::Vec2::new(half, 0.0) };+ let ends = [xf.to_screen(at - along), xf.to_screen(at + along)];+ p.line_segment(ends, Stroke::new(6.0, t.measure_bg));+ p.line_segment(ends, Stroke::new(2.5, t.selection));+ } else {+ p.circle_filled(c, HANDLE_RADIUS, t.measure_bg);+ p.circle_stroke(c, HANDLE_RADIUS, Stroke::new(2.0, t.selection));+ }+ }+}++/// The radius of the Rotate View dial, in screen points.+pub(super) const DIAL_RADIUS: f32 = 40.0;++/// The dial a Rotate View drag shows, centered on `c`: a tick every 15° (longer every 90°), a+/// needle pointing where the document's top points in a view turned by `rotation` degrees, and the+/// angle under the center, rounded to whole degrees as in the status bar.+pub(super) fn rotate_view_dial(p: &egui::Painter, c: Pos2, rotation: f64, t: &Tokens) {+ // `dir(deg)` is the screen direction `deg` degrees clockwise from straight up.+ let dir = |deg: f32| vec2(deg.to_radians().sin(), -deg.to_radians().cos());+ p.circle(c, DIAL_RADIUS, t.panel.gamma_multiply(0.85), Stroke::new(1.0, t.border));+ for i in 0..24u8 {+ let len = if i % 6 == 0 { 8.0 } else { 4.0 };+ let d = dir(f32::from(i) * 15.0);+ p.line_segment([c + d * (DIAL_RADIUS - len), c + d * DIAL_RADIUS], Stroke::new(1.0, t.text_dim));+ }+ p.line_segment([c, c + dir(rotation as f32) * DIAL_RADIUS], Stroke::new(2.0, t.accent));+ p.circle_filled(c, 2.5, t.accent);+ p.text(c + vec2(0.0, 8.0), egui::Align2::CENTER_TOP, format!("{rotation:.0}°"), egui::FontId::proportional(11.0), t.text);+}diff --git a/crates/ui-egui/src/canvas/view.rs b/crates/ui-egui/src/canvas/view.rsnew file mode 100644index 000000000..f4ca00008--- /dev/null+++ b/crates/ui-egui/src/canvas/view.rs@@ -0,0 +1,436 @@+use super::drag::{drag_id, drop_press};+use super::*;++/// Fit the view (View → Fit Artboard / Fit All / Actual Size).+pub fn fit(app: &mut VectorcraftApp, how: &str) {+ let Some(rect) = app.canvas_rect else {+ if let Some(v) = app.view_mut() {+ v.fitted = false;+ }+ return;+ };+ let current = app.view().map_or(0, |v| v.artboard);+ let Some(st) = app.session.active() else { return };+ let target = match how {+ "view.fitAll" => {+ st.doc.art_bounds().map(|a| st.doc.artboards.iter().fold(a, |r, ab| r.union(ab.rect))).or(st.doc.artboards.first().map(|a| a.rect))+ }+ // The navigator's artboard (the first if it has gone).+ _ => st.doc.artboards.get(current).or(st.doc.artboards.first()).map(|a| a.rect),+ };+ let Some(target) = target else { return };+ let zoom = if how == "view.actualSize" {+ actual_size_zoom(app.session.prefs.display_print_size)+ } else {+ // The width and height of the box round the target turned with the view, at zoom 1.+ let (sn, cs) = app.view().map_or(0.0, |v| v.rotation.to_radians()).sin_cos();+ let (w, h) = (target.width(), target.height());+ let zx = (rect.width() as f64 - 60.0) / (w * cs.abs() + h * sn.abs()).max(1.0);+ let zy = (rect.height() as f64 - 60.0) / (w * sn.abs() + h * cs.abs()).max(1.0);+ zx.min(zy).clamp(0.0313, 640.0)+ };+ let Some(v) = app.view_mut() else { return };+ v.center = target.center();+ v.fitted = true;+ v.zoom = zoom;+}++/// How much one point of wheel motion zooms (as `exp(points × WHEEL_ZOOM)`).+const WHEEL_ZOOM: f64 = 0.01;++/// How fast a wheel notch's zoom glides in with Zoom with Mouse Wheel: the time constant (s) of+/// the part still to come.+const WHEEL_GLIDE: f64 = 0.05;++/// What the wheel did across frames ([`wheel`]).+#[derive(Clone, Copy, Debug, Default, PartialEq)]+pub(super) struct WheelTurn {+ /// The last wheel turn was an Alt-wheel one.+ alt: bool,+ /// The zoom (natural log) wheel notches still have to glide in.+ pub(super) glide: f64,+}++/// Animated Zoom: how much one point of sideways drag zooms (100 points to the right double it).+pub(super) const SCRUB_ZOOM: f64 = std::f64::consts::LN_2 / 100.0;++/// Animated Zoom: how far the pointer moves before a press is a drag, in points.+pub(super) const SCRUB_SLOP: f32 = 3.0;++/// Animated Zoom: how long a press is held still before it zooms on, in seconds…+pub(super) const HOLD_DELAY: f32 = 0.3;++/// …and how fast it zooms then (as `exp(seconds × HOLD_ZOOM)`: twice as close each second).+pub(super) const HOLD_ZOOM: f64 = std::f64::consts::LN_2;++/// Performance › Animated Zoom, which needs GPU Performance as in Illustrator: the Zoom tool zooms+/// as it is dragged sideways or held, instead of zooming to the area dragged across.+pub(crate) fn animated_zoom(p: &vectorcraft_engine::Prefs) -> bool {+ p.animated_zoom && p.gpu_performance+}++/// Zoom for View → Actual Size (`view.actualSize`). With Preferences › General › Display Print+/// Size at 100% Zoom off, one document point is one screen point. On, one document inch (72 pt)+/// fills an inch of the screen as the system counts it: 96 screen points, the reference density+/// that display scaling is set against (a CSS inch), whatever the scale factor.+pub(crate) fn actual_size_zoom(display_print_size: bool) -> f64 {+ if display_print_size { 96.0 / 72.0 } else { 1.0 }+}++/// Zoom view `vm` of the canvas `rect` to `zoom` (clamped to the zoom range), keeping the document+/// point under screen point `p` where it is.+pub(super) fn zoom_about(vm: &mut View, rect: egui::Rect, p: Pos2, zoom: f64) {+ let before = Xf::new(rect, vm).to_doc(p);+ vm.zoom = zoom.clamp(0.0313, 640.0);+ vm.center += before - Xf::new(rect, vm).to_doc(p);+}++/// Turn view `vm` of the canvas `rect` by `degrees` clockwise, keeping the document point under+/// screen point `p` where it is.+pub(super) fn rotate_about(vm: &mut View, rect: egui::Rect, p: Pos2, degrees: f64) {+ let before = Xf::new(rect, vm).to_doc(p);+ vm.rotation = vectorcraft_geom::normalize_deg(vm.rotation + degrees);+ vm.center += before - Xf::new(rect, vm).to_doc(p);+}++/// Move view `vm`'s content by `(dx, dy)` device pixels along the screen's axes, at `ppp` device+/// pixels a point: the canvas's frame moves by exactly those pixels.+pub(super) fn pan_pixels(vm: &mut View, ppp: f32, (dx, dy): (f64, f64)) {+ let (sn, cs) = vm.rotation.to_radians().sin_cos();+ let k = vm.zoom * f64::from(ppp);+ vm.center -= vectorcraft_geom::Vec2::new((dx * cs + dy * sn) / k, (-dx * sn + dy * cs) / k);+}++/// Screen points `d` in the nearest whole device pixels, at `ppp` device pixels a point.+pub(super) fn whole_pixels(d: egui::Vec2, ppp: f32) -> (f64, f64) {+ ((f64::from(d.x) * f64::from(ppp)).round(), (f64::from(d.y) * f64::from(ppp)).round())+}++/// What the scrolls of the view have left to move ([`scroll_view`]).+#[derive(Clone, Copy, Debug, Default, PartialEq)]+pub(super) struct ScrollRest {+ /// Device pixels along the screen's axes, at most half a pixel each.+ pub(super) x: f64,+ pub(super) y: f64,+ /// The document, the view's center, zoom and rotation, and the device pixels a point that the+ /// last scroll left.+ after: Option<(u64, Point, f64, f64, f32)>,+}++/// Scroll the active view so that its content moves `by` screen points (the wheel, a trackpad, a+/// touch screen, a scroll bar), in whole device pixels: the part of a pixel left over is added to+/// the next scroll. It is dropped when the view changed in between (a zoom, a turn, Fit, a pan+/// of another kind, another document) or the device pixels a point did.+pub(super) fn scroll_view(app: &mut VectorcraftApp, ui: &Ui, by: egui::Vec2) {+ let ppp = ui.ctx().pixels_per_point();+ let Some(doc) = app.session.active().map(|st| st.uid) else { return };+ let Some(vm) = app.view_mut() else { return };+ let id = egui::Id::unique("canvas-scroll-rest");+ let rest = scroll_by(vm, doc, ppp, by, ui.data(|d| d.get_temp(id)).unwrap_or_default());+ ui.data_mut(|d| d.insert_temp(id, rest));+}++/// [`scroll_view`] for view `vm` of document `doc` at `ppp` device pixels a point, after the+/// scrolls that left `rest`: what this scroll leaves.+pub(super) fn scroll_by(vm: &mut View, doc: u64, ppp: f32, by: egui::Vec2, rest: ScrollRest) -> ScrollRest {+ let (x, y) = if rest.after == Some((doc, vm.center, vm.zoom, vm.rotation, ppp)) { (rest.x, rest.y) } else { (0.0, 0.0) };+ let (x, y) = (x + f64::from(by.x) * f64::from(ppp), y + f64::from(by.y) * f64::from(ppp));+ let (dx, dy) = (x.round(), y.round());+ pan_pixels(vm, ppp, (dx, dy));+ ScrollRest { x: x - dx, y: y - dy, after: Some((doc, vm.center, vm.zoom, vm.rotation, ppp)) }+}++/// How far a trackpad rotation turns before it turns the view, in degrees.+const ROTATE_DEAD_ZONE: f64 = 5.0;++/// How long after its last rotation event a trackpad rotation ends, in seconds.+const ROTATE_GESTURE_END: f64 = 0.25;++/// A trackpad rotation under way ([`trackpad_turn`]).+#[derive(Clone, Copy, Debug)]+struct TrackpadTurn {+ /// Degrees it has turned so far, clockwise.+ total: f64,+ /// When its last rotation event came (egui's input time, in seconds).+ last: f64,+ /// It has reached [`ROTATE_DEAD_ZONE`] and turns the view.+ turning: bool,+}++/// General › Trackpad Gesture to Rotate View (`on`): the degrees, clockwise, that a two-finger+/// rotation on a Mac trackpad turns the view this frame. egui sends the rotation as+/// [`egui::Event::Rotate`], from winit on macOS and from Safari's gesture events in the web build.+/// A rotation does not turn the view until it reaches [`ROTATE_DEAD_ZONE`]; it then turns the view+/// by all of it, and by each later event as it comes. It ends [`ROTATE_GESTURE_END`] after its last+/// event. Rotation events that come while fingers are on a touch screen do not turn the view.+pub(super) fn trackpad_turn(ui: &Ui, on: bool) -> Option<f64> {+ if !on {+ return None;+ }+ let (deg, now) = ui.input(|i| {+ let rad: f32 =+ if i.multi_touch().is_some() { 0.0 } else { i.events.iter().map(|e| if let egui::Event::Rotate(r) = e { *r } else { 0.0 }).sum() };+ (f64::from(rad).to_degrees(), i.time)+ });+ if deg == 0.0 || !deg.is_finite() {+ return None;+ }+ let id = egui::Id::unique("canvas-trackpad-turn");+ let kept: Option<TrackpadTurn> = ui.data(|d| d.get_temp(id));+ let mut t = kept.filter(|t| now - t.last <= ROTATE_GESTURE_END).unwrap_or(TrackpadTurn { total: 0.0, last: now, turning: false });+ t.total += deg;+ t.last = now;+ let turn = if t.turning {+ Some(deg)+ } else if t.total.abs() >= ROTATE_DEAD_ZONE {+ t.turning = true;+ Some(t.total)+ } else {+ None+ };+ ui.data_mut(|d| d.insert_temp(id, t));+ turn+}++/// One scroll bar along its axis, in screen points: the span it scrolls over (`lo..hi`) and the+/// part of it the canvas shows (`v0..v1`).+#[derive(Clone, Copy, Debug, PartialEq)]+pub(super) struct Span {+ pub(super) lo: f32,+ pub(super) hi: f32,+ pub(super) v0: f32,+ pub(super) v1: f32,+}++impl Span {+ /// The thumb on a track `len` long: where it starts and how long it is.+ pub(super) fn thumb(self, len: f32) -> (f32, f32) {+ let total = (self.hi - self.lo).max(1.0);+ let size = (len * (self.v1 - self.v0) / total).clamp(MIN_THUMB.min(len), len);+ let room = total - (self.v1 - self.v0);+ let at = if room > 0.0 { (self.v0 - self.lo) / room * (len - size) } else { 0.0 };+ (at.clamp(0.0, (len - size).max(0.0)), size)+ }+ /// Screen points the view moves for each point the thumb moves on a track `len` long.+ pub(super) fn ratio(self, len: f32) -> f32 {+ let room = (self.hi - self.lo) - (self.v1 - self.v0);+ let free = len - self.thumb(len).1;+ if room > 0.0 && free > 0.0 { room / free } else { 0.0 }+ }+}++const MIN_THUMB: f32 = 20.0;++/// The scroll bars' spans, horizontal then vertical: the art and the artboards (`content`) as the+/// view turns them on screen, half a window past each side, and the view itself, so the thumb is+/// always on its track. The canvas has no edge of its own (no drawing area), so the content sets it.+pub(super) fn scroll_spans(xf: &Xf, content: Option<Rect>) -> [Span; 2] {+ let r = xf.rect;+ let around = content.map(|c| egui::Rect::from_points(&xf.quad(c)).expand2(r.size() / 2.0)).filter(|b| b.is_finite());+ let b = around.map_or(r, |b| b.union(r));+ [Span { lo: b.left(), hi: b.right(), v0: r.left(), v1: r.right() }, Span { lo: b.top(), hi: b.bottom(), v0: r.top(), v1: r.bottom() }]+}++/// The tracks of the horizontal and the vertical scroll bar, along the bottom and the right edge+/// of the window (`outer`), as long as the canvas (`rect`) beside them.+pub(super) fn scroll_tracks(rect: egui::Rect, outer: egui::Rect) -> [egui::Rect; 2] {+ let corner = outer.max - vec2(SCROLL_BAR, SCROLL_BAR);+ [+ egui::Rect::from_min_max(pos2(rect.left(), corner.y), pos2(corner.x, outer.bottom())),+ egui::Rect::from_min_max(pos2(corner.x, rect.top()), pos2(outer.right(), corner.y)),+ ]+}++/// The window's scroll bars ([`scroll_spans`]): a thumb dragged scrolls the view along the+/// screen's axis (a turned view too), a click on the track pages towards it, and the wheel over a+/// bar scrolls along it.+pub(super) fn scroll_bars(app: &mut VectorcraftApp, ui: &Ui, rect: egui::Rect, outer: egui::Rect, t: &Tokens) {+ let content = app.content_bounds();+ let Some(v) = app.view().copied() else { return };+ let xf = Xf::new(rect, &v);+ let painter = ui.painter();+ painter.rect_filled(egui::Rect::from_min_max(outer.max - vec2(SCROLL_BAR, SCROLL_BAR), outer.max), 0.0, t.ruler);+ let hover = ui.input(|i| i.pointer.hover_pos());+ // Screen points the view moves this frame, or the center a dragged thumb's drag began at and+ // the screen points it has moved the view since.+ let mut moved = egui::Vec2::ZERO;+ let mut center = None;+ for (k, (track, span)) in scroll_tracks(rect, outer).into_iter().zip(scroll_spans(&xf, content)).enumerate() {+ let horizontal = k == 0;+ let along = |p: Pos2| if horizontal { p.x - track.left() } else { p.y - track.top() };+ let axis = if horizontal { vec2(1.0, 0.0) } else { vec2(0.0, 1.0) };+ let len = if horizontal { track.width() } else { track.height() };+ let (at, size) = span.thumb(len);+ let on_thumb = |p: Pos2| (at..=at + size).contains(&along(p));+ let id = egui::Id::unique(("canvas-scroll-bar", k));+ let resp = ui.interact(track, id, Sense::click_and_drag());+ if resp.drag_started()+ && let Some(p) = ui.input(|i| i.pointer.press_origin())+ && on_thumb(p)+ {+ // The span moves with the view: the drag keeps the one it started with.+ let d = ThumbDrag { from: along(p), center: v.center, ratio: span.ratio(len), min: span.lo - span.v0, max: span.hi - span.v1 };+ ui.data_mut(|dd| dd.insert_temp(id, d));+ }+ let drag: Option<ThumbDrag> = ui.data(|dd| dd.get_temp(id));+ if let Some(d) = drag {+ if resp.dragged()+ && let Some(p) = resp.interact_pointer_pos()+ {+ let by = ((along(p) - d.from) * d.ratio).clamp(d.min, d.max);+ center = Some((d.center, axis * by));+ }+ if !resp.dragged() || resp.drag_stopped() {+ ui.data_mut(|dd| dd.remove::<ThumbDrag>(id));+ }+ } else if resp.clicked()+ && let Some(p) = resp.interact_pointer_pos()+ {+ // A page is most of the window, and never past the end of the span.+ let page = 0.9 * (span.v1 - span.v0);+ if along(p) < at {+ moved -= axis * page.min(span.v0 - span.lo);+ } else if along(p) > at + size {+ moved += axis * page.min(span.hi - span.v1);+ }+ }+ if resp.hovered() {+ let d = ui.input(|i| i.smooth_scroll_delta);+ moved -= axis * if horizontal { d.x + d.y } else { d.y };+ }+ painter.rect_filled(track, 0.0, t.ruler);+ let edge = if horizontal { [track.left_top(), track.right_top()] } else { [track.left_top(), track.left_bottom()] };+ painter.line_segment(edge, Stroke::new(1.0, t.border));+ let thumb = if horizontal {+ egui::Rect::from_min_size(pos2(track.left() + at, track.top()), vec2(size, track.height())).shrink2(vec2(1.0, 3.0))+ } else {+ egui::Rect::from_min_size(pos2(track.left(), track.top() + at), vec2(track.width(), size)).shrink2(vec2(3.0, 1.0))+ };+ let hot = drag.is_some() || hover.is_some_and(|p| thumb.contains(p));+ painter.rect_filled(thumb, CornerRadius::same(3), if hot { t.text_dim } else { t.text_disabled });+ }+ let ppp = ui.ctx().pixels_per_point();+ if let Some((c, by)) = center+ && let Some(vm) = app.view_mut()+ {+ vm.center = c;+ pan_pixels(vm, ppp, whole_pixels(-by, ppp));+ }+ if moved != egui::Vec2::ZERO {+ scroll_view(app, ui, -moved);+ }+}++/// A scroll bar thumb being dragged: where along the track it was pressed, and the view's centre,+/// the span's travel ratio ([`Span::ratio`]) and how far the view could move either way then.+#[derive(Clone, Copy, Debug)]+struct ThumbDrag {+ from: f32,+ center: Point,+ ratio: f32,+ min: f32,+ max: f32,+}++/// What the wheel, a pinch and a two-finger drag on a touch screen did over the canvas this frame:+/// a zoom factor (about the pointer) and a scroll (screen points the content moves). The wheel scrolls, Cmd- and Alt-wheel (Option+/// on the Mac) zoom. With General › Zoom with Mouse Wheel (`wheel_zooms`) the wheel and Alt-wheel+/// zoom, Shift-wheel scrolls up and down and Cmd/Ctrl-wheel sideways. `line` and `page`: points+/// per wheel line and page. `turn`: kept by the caller across frames. A mouse wheel's notches zoom+/// in a glide over a few frames, as scrolling does (#888); a trackpad's fine steps at once.+pub(super) fn wheel(i: &egui::InputState, wheel_zooms: bool, line: f32, page: f32, turn: &mut WheelTurn) -> (f64, egui::Vec2) {+ // Fingers on a touch screen pan the content with them (a trackpad sends scrolls instead).+ let pan = i.multi_touch().map_or(egui::Vec2::ZERO, |t| t.translation_delta);+ if !wheel_zooms {+ // egui makes Cmd-wheel (and a pinch) its zoom and the rest a scroll it spreads over a few+ // frames: the rest of an Alt-wheel turn zooms too, however soon Alt is let go.+ if let Some(m) = i.events.iter().rev().find_map(|e| if let egui::Event::MouseWheel { modifiers, .. } = e { Some(modifiers) } else { None }) {+ turn.alt = m.alt && !m.command;+ }+ let (zoom, scroll) = (f64::from(i.zoom_delta()), i.smooth_scroll_delta);+ return if turn.alt && scroll != egui::Vec2::ZERO {+ (zoom * (f64::from(scroll.x + scroll.y) * WHEEL_ZOOM).exp(), pan)+ } else {+ (zoom, scroll + pan)+ };+ }+ // The wheel events themselves: egui's own handling turns Cmd-wheel into a zoom.+ let mut zoom = i.multi_touch().map_or(1.0, |t| f64::from(t.zoom_delta));+ let mut scroll = pan;+ for e in &i.events {+ match e {+ egui::Event::MouseWheel { unit, delta, modifiers, .. } => {+ let d = match unit {+ egui::MouseWheelUnit::Point => *delta,+ egui::MouseWheelUnit::Line => *delta * line,+ egui::MouseWheelUnit::Page => *delta * page,+ };+ if modifiers.command {+ scroll.x += d.x + d.y;+ } else if modifiers.shift {+ scroll.y += d.x + d.y;+ } else if *unit == egui::MouseWheelUnit::Point {+ zoom *= (f64::from(d.y) * WHEEL_ZOOM).exp();+ scroll.x += d.x;+ } else {+ turn.glide += f64::from(d.y) * WHEEL_ZOOM;+ scroll.x += d.x;+ }+ }+ egui::Event::Zoom(f) => zoom *= f64::from(*f),+ _ => {}+ }+ }+ // This frame's part of the glide: what is left shrinks by e every WHEEL_GLIDE seconds.+ let part = if turn.glide.abs() < 1e-3 { 1.0 } else { 1.0 - (-f64::from(i.stable_dt.min(0.1)) / WHEEL_GLIDE).exp() };+ let step = turn.glide * part;+ turn.glide -= step;+ (zoom * step.exp(), scroll)+}++/// Enable Touch Gestures: this frame's finger contacts on the canvas ([`crate::touch`]). A second+/// finger drops the press the first one began (its tool interaction rolled back; the rest of the+/// gesture presses nothing), and a tap of two fingers undoes, one of three redoes.+pub(super) fn touch_gestures(app: &mut VectorcraftApp, ui: &Ui, rect: egui::Rect, view: vectorcraft_engine::ViewInfo) {+ if !app.session.prefs.touch_gestures {+ return;+ }+ let (touches, now): (Vec<_>, f64) = ui.input(|i| {+ let t = i.events.iter().filter_map(|e| match e {+ egui::Event::Touch { id, phase, pos, .. } => Some((*id, *phase, *pos)),+ _ => None,+ });+ (t.collect(), i.time)+ });+ if touches.is_empty() {+ return;+ }+ let key = egui::Id::unique("canvas-touch");+ let mut taps: crate::touch::Taps = ui.data(|d| d.get_temp(key)).unwrap_or_default();+ let mut tap = None;+ for (id, phase, pos) in touches {+ // A gesture begins on the canvas.+ if phase == egui::TouchPhase::Start && !taps.is_down() && !rect.contains(pos) {+ continue;+ }+ // A cancelled contact (a palm the shell drops when a pen lands) keeps nothing it began.+ if phase == egui::TouchPhase::Cancel {+ drop_press(app, ui, view);+ }+ match taps.feed(id, phase, pos, now) {+ Some(crate::touch::Touch::Fingers) => {+ drop_press(app, ui, view);+ ui.data_mut(|d| d.insert_temp(drag_id(), Drag::Gesture));+ }+ Some(crate::touch::Touch::Tap(n)) => tap = crate::touch::tap_command(n),+ None => {}+ }+ }+ ui.data_mut(|d| d.insert_temp(key, taps));+ // In Presentation Mode a tap of two or three fingers undoes or redoes nothing.+ if let Some(cmd) = tap+ && app.ui.screen_mode < 3+ {+ crate::menus::invoke(app, cmd, serde_json::json!({}));+ }+}