Files
vectorcraft/crates/ui-egui/src/canvas.rs
T
BFlat 08e419aa62 Merge pull request #8463 from dotCooCoo/feat/document-setup-grid-preview
Document Setup: the Transparency tab previews the grid
2026-11-19 00:42:49 +07:00

1386 lines
69 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! The document canvas: rendering, rulers, navigation, pointer routing to tools and on-canvas
//! selection visuals (bounding box, anchors, handles, smart-guide style labels).
use egui::emath::GuiRounding as _;
use egui::{Color32, CornerRadius, Pos2, Sense, Shape, Stroke, StrokeKind, Ui, Vec2, pos2, vec2};
use serde_json::json;
use vectorcraft_doc::text::TextKind;
use vectorcraft_doc::{Node, NodeKind, SymbolBoxes, Unit};
use vectorcraft_geom::{Affine, BezPath, PathEl, Point, Rect};
use vectorcraft_tools::{Cursor, Mods, Overlay, PenPose, PointerEvent, PointerKind};
use crate::opening;
use crate::state::View;
use crate::stylus::StylusFeed;
use crate::theme::{self, Tokens};
use crate::{CacheKey, VectorcraftApp, now_ms, widgets};
mod alternates_bar;
mod artboards;
mod context;
mod contour_bar;
mod cursor;
mod drag;
mod fill;
mod grid;
mod home;
mod input;
mod outline;
mod overlays;
mod panes;
mod raster;
mod selection_marks;
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::{art_out, end_art_move, end_document_drag, pose_on_page, 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};
pub use fill::Fill;
use fill::fill_uncovered;
#[cfg(test)]
use fill::{fill_view, polygon_area};
#[cfg(test)]
use grid::ruler_rects;
use grid::{LineLook, PIXEL_GRID, PIXEL_GRID_ZOOM, checker, clip_segment, grid, ruler_input, rulers, rulers_hidden, textured_quad, view_bounds};
pub(crate) use grid::{RulerScale, checker_texture, checker_tile, 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};
pub use overlays::SharedPaths;
#[cfg(test)]
use overlays::selected_anchor;
use overlays::{
HandleLook, blend_widgets_overlay, draw_inside_overlay, draw_overlays, hover_highlight, ime_geometry, overlay_hover_text, selection_overlay,
};
pub use panes::{Layout as TileLayout, Panes};
pub(crate) use panes::{consolidate, note_drop, noted_cursor, pane, release_on_noted, tile, tiled_area};
pub(crate) use raster::{KeptFrame, color_image, color_image_owned, render_job};
use raster::{changed_pixels, frame_ppp, pixel_region, upload};
pub use selection_marks::SelectionMarks;
use task_bar::task_bar;
#[cfg(test)]
pub(crate) use task_bar::{chip_paints, images_with_other_art};
pub(crate) use task_bar::{has_colors, task_bar_rect, task_bar_shows_fonts, task_bar_shows_type};
#[cfg(test)]
use tool_overlays::{DIAL_RADIUS, HiddenMarks};
pub use tool_overlays::{HiddenChars, SpellingMarks};
use tool_overlays::{
grid_repeat_overlay, hidden_chars_overlay, live_paint_gap_overlays, mirror_axis_overlay, nine_slice_overlay, original_path_overlay,
print_tiling_overlay, radial_repeat_overlay, rotate_view_dial, shaper_widget_overlay, slice_overlay, spelling_overlay, thread_overlays,
};
pub(crate) use view::animated_zoom;
pub(crate) use view::drag_rotation;
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;
/// Screen ↔ document mapping for one frame.
#[derive(Clone, Copy, Debug)]
pub struct Xf {
pub rect: egui::Rect,
pub zoom: f64,
pub center: Point,
/// View rotation in radians (Rotate View), clockwise on screen.
pub rot: f64,
}
impl Xf {
/// The mapping of view `v` onto the canvas `rect`, in the points of an interface zoomed by
/// `ui_zoom` (Preferences › User Interface › UI Scaling): a document point covers the same
/// device pixels at every UI Scaling ([`View::screen_zoom`]).
pub fn at(rect: egui::Rect, v: &View, ui_zoom: f32) -> Self {
Self { rect, zoom: v.screen_zoom(ui_zoom), center: v.center, rot: v.rotation.to_radians() }
}
/// [`Self::at`] with the interface unscaled.
#[cfg(test)]
pub fn new(rect: egui::Rect, v: &View) -> Self {
Self::at(rect, v, 1.0)
}
pub fn to_screen(&self, p: Point) -> Pos2 {
let c = self.rect.center();
let (dx, dy) = ((p.x - self.center.x) * self.zoom, (p.y - self.center.y) * self.zoom);
let (sn, cs) = self.rot.sin_cos();
pos2(c.x + (dx * cs - dy * sn) as f32, c.y + (dx * sn + dy * cs) as f32)
}
pub fn to_doc(&self, p: Pos2) -> Point {
let c = self.rect.center();
let (dx, dy) = ((p.x - c.x) as f64, (p.y - c.y) as f64);
let (sn, cs) = self.rot.sin_cos();
let (ux, uy) = (dx * cs + dy * sn, -dx * sn + dy * cs);
Point::new(self.center.x + ux / self.zoom, self.center.y + uy / self.zoom)
}
/// Screen-space corners of a document rect (a rotated quad when the view is rotated).
pub fn quad(&self, r: Rect) -> Vec<Pos2> {
[Point::new(r.x0, r.y0), Point::new(r.x1, r.y0), Point::new(r.x1, r.y1), Point::new(r.x0, r.y1)].iter().map(|p| self.to_screen(*p)).collect()
}
/// Convert a screen-space delta to a document delta.
pub fn delta_to_doc(&self, d: egui::Vec2) -> vectorcraft_geom::Vec2 {
let (sn, cs) = self.rot.sin_cos();
let (dx, dy) = (d.x as f64, d.y as f64);
vectorcraft_geom::Vec2::new((dx * cs + dy * sn) / self.zoom, (-dx * sn + dy * cs) / self.zoom)
}
pub fn rect_to_screen(&self, r: Rect) -> egui::Rect {
egui::Rect::from_two_pos(self.to_screen(Point::new(r.x0, r.y0)), self.to_screen(Point::new(r.x1, r.y1)))
}
/// Affine mapping document points to screen points.
pub fn affine(&self) -> Affine {
let c = self.rect.center();
Affine::translate((c.x as f64, c.y as f64)) * Affine::rotate(self.rot) * Affine::scale(self.zoom) * Affine::translate(-self.center.to_vec2())
}
}
#[derive(Clone, Copy, Debug, PartialEq)]
enum Drag {
Tool,
/// Hand tool / Space drag, or a middle-button drag with any tool (`middle`).
Pan {
start: Pos2,
center: Point,
middle: bool,
},
/// A Zoom tool drag without Animated Zoom: the area to zoom to.
ZoomBox {
start: Pos2,
},
/// A Zoom tool press with Animated Zoom ([`animated_zoom`]): dragged sideways it zooms about
/// `start`, held still (for `held` seconds so far) it zooms on, else it's a click.
ZoomScrub {
start: Pos2,
held: f32,
moved: bool,
},
/// A Rotate View tool drag, or a Space+Shift drag with any tool. With `snaps` (the Rotate
/// View tool), Shift rounds the angle to 15°.
RotateView {
start_angle: f64,
start_rot: f64,
snaps: bool,
},
/// A Selection tool move over a panel or toolbar: the art waits where it last moved on the
/// canvas, and the panels get it ([`widgets::PanelDrag::Art`]) if it is released there. Back
/// on the canvas the move goes on (#2826).
Art,
/// Fingers making a touch gesture ([`crate::touch`]): the first one's press does nothing.
Gesture,
/// A press in Presentation Mode: released as a click, it goes to the next artboard.
Present,
}
/// Whether the canvas is holding a pointer drag across frames.
pub(crate) fn dragging(ctx: &egui::Context) -> bool {
ctx.data(|d| d.get_temp::<Drag>(drag_id()).is_some())
}
/// Whether the canvas is holding a Zoom tool drag: a marquee, which Space moves, or an animated zoom.
pub(crate) fn dragging_zoom(ctx: &egui::Context) -> bool {
ctx.data(|d| matches!(d.get_temp::<Drag>(drag_id()), Some(Drag::ZoomBox { .. } | Drag::ZoomScrub { .. })))
}
/// The part of `outer` inside the scroll bars, and the part of that inside the rulers, which shows
/// the document. Normal Screen Mode and Full Screen Mode with Menu Bar keep the scroll bars along
/// the right and bottom edges; Full Screen and Presentation Mode have none.
fn view_rects(app: &VectorcraftApp, outer: egui::Rect, ppp: f32) -> (egui::Rect, egui::Rect) {
let full = if app.ui.screen_mode < 2 { egui::Rect::from_min_max(outer.min, outer.max - vec2(SCROLL_BAR, SCROLL_BAR)) } else { outer };
let rect = if app.ui.view.rulers && app.ui.screen_mode < 3 { egui::Rect::from_min_max(full.min + vec2(RULER, RULER), full.max) } else { full };
// Dock layout can differ by fractions of a device pixel between fresh windows.
// Use one pixel-aligned rectangle for drawing, inspection and pointer transforms.
(full, rect.round_to_pixels(ppp))
}
/// Whether the user pressed a button or a key, typed, scrolled or zoomed in this frame: the
/// opening fit stops following the canvas then ([`crate::caches::CanvasCache::opening_fit`]).
fn acted(i: &egui::InputState) -> bool {
i.pointer.any_pressed()
|| i.events.iter().any(|e| {
matches!(
e,
egui::Event::Key { pressed: true, .. }
| egui::Event::Text(_)
| egui::Event::MouseWheel { .. }
| egui::Event::Zoom(_)
| egui::Event::Touch { .. }
)
})
}
/// The view `v` shows in the canvas `rect`, as the opening fit records it.
fn view_key(v: &View, rect: egui::Rect) -> ViewKey {
ViewKey { rect, zoom: v.zoom, center: v.center, rotation: v.rotation }
}
/// Whether the opening fit still follows the canvas `rect` (the view is unfitted, or unmoved since
/// the fit and the user hasn't acted), and whether the canvas moved under it this frame, so the view
/// is fitted again.
fn opening_fit_follows(app: &VectorcraftApp, ui: &Ui, rect: egui::Rect, fitted: bool) -> (bool, bool) {
let following = !fitted || (!ui.input(acted) && app.canvas.opening_fit.zip(app.view()).is_some_and(|(was, v)| view_key(v, was.rect) == was));
let settling = fitted && following && app.canvas.opening_fit.is_some_and(|was| was.rect != rect);
(following, settling)
}
/// 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());
let full = ui.available_rect_before_wrap();
// `hidden_chars` holds the marks Show Hidden Characters kept and the text nodes they were laid
// out from. Only the assignment right before the overlay call below puts them back. A frame
// that does not draw the overlay drops them, for example with the option off, with the edges
// hidden, on the Home screen or with no document open.
let hidden_chars = std::mem::take(&mut app.canvas.hidden_chars);
// The selection's kept marks. Likewise, a frame that does not draw them drops them.
let selection_marks = std::mem::take(&mut app.canvas.selection_marks);
// The meshes of the tools' shared paths. Likewise, a frame that does not draw the tools'
// overlays drops them.
let mut shared_paths = std::mem::take(&mut app.canvas.shared_paths);
// A release ends the Image Trace panel's eye-button hold, also when the panel is no longer
// drawn, so a later press elsewhere does not show the source image.
if app.ui.trace_hold_source.is_some() && !ui.input(|i| i.pointer.any_down()) {
app.ui.trace_hold_source = None;
}
// The IME geometry this pass, if the Type tool gets one; `ime::end_of_pass` consumes it after
// the dialogs and panels draw.
app.ime_caret_rect = None;
// A document that opened, closed or became active since Home was chosen replaces it.
if app.ui.home.is_some_and(|k| k != crate::menus::home_key(app)) {
app.ui.home = None;
}
if crate::menus::home_showing(app) {
// No IME owner this pass (`ime_caret_rect` stays None): the end-of-pass observation marks
// the context absent and keeps any marked text as typed.
home(app, ui, full);
return;
}
if app.session.active().is_none() {
// No document and Show The Home Screen When No Documents Are Open off: an empty window.
ui.painter().rect_filled(full, 0.0, t.panel_darker);
return;
}
let outer = full;
let bars = app.ui.screen_mode < 2;
let (full, rect) = view_rects(app, outer, ui.ctx().pixels_per_point());
app.canvas_rect = Some(rect);
app.canvas_ui_zoom = ui.ctx().zoom_factor();
let fitted = app.view().is_some_and(|v| v.fitted);
// A document's opening view is fitted to the canvas of the first frame that shows it, and the
// window's layout can still move the canvas's edges over the next frames. Until the view is
// moved or the user acts, the opening fit follows the canvas, so that the document opens at the
// zoom of the settled window.
let (following, settling) = opening_fit_follows(app, ui, rect, fitted);
// Presentation Mode shows the active artboard on the whole screen and nothing but the art:
// no selection, guides, grids or artboard edges (#4365).
let presenting = app.ui.screen_mode == 3;
if !fitted || settling || (presenting && app.canvas.presented != Some(rect)) {
fit(app, "view.fitArtboard");
}
app.canvas.presented = presenting.then_some(rect);
app.canvas.opening_fit = following.then(|| app.view().map(|v| view_key(v, rect))).flatten();
// Before the canvas's own interaction, so the view the canvas draws is the one they moved to.
if bars {
scroll_bars(app, ui, rect, outer, &t);
}
let resp = ui.interact(rect, egui::Id::unique("canvas"), Sense::click_and_drag());
canvas_input(app, ui, &resp, rect);
let v = *app.view().unwrap_or(&View::default());
let xf = Xf::at(rect, &v, app.canvas_ui_zoom);
// While the view pans, zooms or turns under the pointer, the art under it isn't hit-tested.
let wait = hover_wait(&mut app.canvas.view_moved, ViewKey { rect, zoom: v.zoom, center: v.center, rotation: v.rotation }, ui.input(|i| i.time));
if let Some(secs) = wait {
ui.ctx().request_repaint_after_secs(secs as f32);
}
let hover_still = wait.is_none();
let origin_preview = if app.ui.view.rulers && app.ui.screen_mode < 3 { ruler_input(app, ui, full, rect, &xf) } else { rulers_hidden(app, ui) };
crate::document_drag::drop_on_canvas(app, &resp, &xf);
panel_drop(app, ui, &resp, &xf);
// In Presentation Mode a right click or a long touch opens no context menu.
if app.ui.screen_mode < 3 {
context_menu(app, &resp, &xf);
}
let painter = ui.painter_at(rect);
let Some(st) = app.session.active() else { return };
let doc = st.doc.clone();
let effects = st.plugin_effects.clone();
let mask_view = st.shown_mask();
paint_paper(app, st, ui, &painter, &xf, rect, (&t, app.outline_view()));
// The grid behind the art (Guides & Grid › Grids In Back), else over it below.
let grid_look = (app.ui.view.grid && !presenting).then(|| LineLook::grid(&app.session.prefs));
let grids_in_back = app.session.prefs.grids_in_back;
if let Some(look) = grid_look.filter(|_| grids_in_back) {
grid(&painter, &xf, doc.grid.spacing, doc.grid.subdivisions, look);
}
// Artwork raster.
let device_ppp = ui.ctx().pixels_per_point();
let max_side = ui.ctx().input(|i| i.max_texture_side);
let ppp = frame_ppp(rect.size(), device_ppp, max_side);
// Match Renderer::render_as before recording the cache extent or building its view.
let (w, h) = (
((rect.width() * ppp).round().max(1.0) as u32).min(u32::from(u16::MAX)),
((rect.height() * ppp).round().max(1.0) as u32).min(u32::from(u16::MAX)),
);
// View › Pixel Preview: the art as it rasterizes, one pixel per point, while a document pixel
// is bigger than a screen pixel (below that the screen render already shows it).
let pixel = (app.ui.view.pixel_preview && xf.zoom * device_ppp as f64 > 1.0).then(|| pixel_region(&xf, max_side)).flatten();
// File Handling › Display Bitmaps as Anti-aliased Images in Pixel Preview: off, images show
// their pixels as they rasterize, hard-edged.
let smooth_images = pixel.is_none() || app.session.prefs.anti_aliased_bitmaps;
let plugins = plugin_key(&mut app.canvas.plugin_keys, &app.session, st);
let placed = placed_key(&mut app.canvas.placed_keys, &app.session, st);
// The frame renders the view at its zoom in the interface's points, as `xf` maps it.
let drawn = v.on_screen(app.canvas_ui_zoom);
let key = cache_key(app, ui, st, &t, &drawn, (w, h, ppp), (pixel, smooth_images, plugins, placed));
// Placed documents' bitmaps are being made: draw again when they are ready.
if vectorcraft_render::placed_document::busy() {
ui.ctx().request_repaint_after(std::time::Duration::from_millis(30));
}
poll_worker(app, ui, key.doc);
// With `waits_for_still` set (the web build, which has no render worker), a heavy document is
// not rendered while only the view changes: the frame shown is drawn reprojected below, and the
// first frame after the view has been still for STILL_SECS renders.
let wait = if app.canvas.waits_for_still {
let slow = app.canvas.last_ms > 8.0 && app.canvas.texture.is_some();
still_wait(&mut app.canvas.still, app.canvas.key.as_ref(), &key, slow, ui.input(|i| i.time))
} else {
None
};
if let Some(secs) = wait {
ui.ctx().request_repaint_after(std::time::Duration::from_secs_f64(secs));
}
// A frame with copied pixels renders whole once it has been shown for STILL_SECS with the view unmoved.
let same_frame = app.canvas.key.as_ref() == Some(&key);
let settle = app.canvas.reused.filter(|_| same_frame).is_some_and(|at| {
let waited = ui.input(|i| i.time) - 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);
if waiting {
ui.ctx().request_repaint_after(std::time::Duration::from_secs_f64(STILL_SECS - waited));
}
!waiting
});
if wait.is_none() && (!same_frame || app.canvas.texture.is_none() || settle) {
let (w, h, view) = frame_view(pixel, (w, h), &drawn, ppp);
let opts = frame_options(app, &key, mask_view, smooth_images);
draw_frame(app, ui, Frame { key: &key, doc: &doc, effects: &effects, size: (w, h), view, opts, pixel });
}
report_deferred(app, &effects);
// The status bar reports each image that a renderer (this thread's or the worker's) could not
// decode, once per image in the process.
let undecoded = vectorcraft_render::newly_undecodable(doc.images.values());
if undecoded > 0 {
app.status(crate::i18n::msg_n(
undecoded as u64,
"{n} image couldn't be decoded and shows as a crossed box",
"{n} images couldn't be decoded and show as crossed boxes",
&[],
));
}
fill_uncovered(app, ui.ctx(), &painter, &key, &doc, rect, &xf);
reproject_frame(app, &painter, &xf, rect, (key.doc, v.rotation));
if fades_outside_artboards(app) {
fade_outside_artboards(&painter, &xf, &doc);
}
if let Some(look) = grid_look.filter(|_| !grids_in_back) {
grid(&painter, &xf, doc.grid.spacing, doc.grid.subdivisions, look);
}
// The pixel grid (Guides & Grid › Show Pixel Grid (Above 600% Zoom)): in Pixel Preview from
// 600% zoom, a line at every document pixel over the art, so the pixels it rasterizes to show.
let revolve_edit = app.ui.dialog.as_ref().is_some_and(crate::dialogs::revolve_gizmo::active);
let view_info = app.view_info();
if !presenting {
if app.ui.view.pixel_preview && v.zoom >= PIXEL_GRID_ZOOM && app.session.prefs.show_pixel_grid {
grid(&painter, &xf, 1.0, 1, LineLook { color: PIXEL_GRID, dots: false });
}
artboard_outlines(app, ui, &painter, &xf, &t);
if app.ui.view.guides {
guide_lines(app, &painter, &xf, rect, &t);
}
nine_slice_overlay(app, &painter, &xf);
if !app.session.slices_hidden() {
slice_overlay(app, &painter, &xf);
}
if app.session.active().is_some_and(|d| d.print_tiling) || app.session.tool_id() == "printTiling" {
print_tiling_overlay(app, &painter, &xf);
}
original_path_overlay(app, &painter, &xf);
let overlays = selection_visuals(app, &painter, &xf, (hidden_chars, selection_marks, hover_still), revolve_edit, view_info);
draw_overlays(&painter, &xf, &overlays, &t, HandleLook::of(&app.session.prefs), &mut shared_paths);
app.canvas.shared_paths = shared_paths;
crate::panels::tabs::paint_stop_guide(app, &painter, &xf);
overlay_hover_text(ui, &xf, &overlays, ui.data(|d| d.get_temp::<Drag>(drag_id())).is_some());
if !revolve_edit {
shaper_widget_overlay(app, &painter, &xf);
crate::panels::three_d::paint_graphic_handles(app, &painter, &xf);
}
}
ime_geometry(app, ui.ctx(), &xf);
crate::place::paint_drop_highlight(app, ui.ctx(), &painter, rect);
// A Rotate View drag (the tool, or Space+Shift with any tool) shows the view's angle on a dial
// at the canvas center, the point the view turns about.
if app.ui.screen_mode < 3 && matches!(ui.data(|d| d.get_temp::<Drag>(drag_id())), Some(Drag::RotateView { .. })) {
rotate_view_dial(&painter, rect.center(), v.rotation, &t);
}
if app.ui.view.rulers && app.ui.screen_mode < 3 {
ruler_bands(app, ui, &xf, (full, rect), origin_preview, &t);
}
// The task bar is not drawn while the Simplify or Smooth slider shows.
let strip = crate::dialogs::simplify_slider::showing(app) || crate::dialogs::smooth_slider::showing(app);
// It gives way to a drag, not to a click: hidden for the length of every press, it flashed as
// each click picked another object (#4681).
let dragging = app.session.tool_busy() && ui.input(|i| i.pointer.is_decidedly_dragging());
if app.ui.task_bar && !revolve_edit && !dragging && app.ui.screen_mode < 3 && !strip {
task_bar(app, ui, &xf);
}
if app.ui.screen_mode < 3 {
contour_bar::contour_bar(app, ui, &xf);
// After the task bar, which the row of character alternates keeps clear of.
alternates_bar::alternates_bar(app, ui, &xf);
}
if app.ui.screen_mode < 3 {
crate::free_transform::show(app, ui, xf.rect);
}
artboard_name_editor(app, ui, &xf);
if resp.hovered() {
canvas_cursor(app, ui, view_info, hover_still);
}
}
/// The pointer on the canvas: the tool's input, unless the context menu or the 3D gizmo has the press.
pub(crate) fn canvas_input(app: &mut VectorcraftApp, ui: &Ui, resp: &egui::Response, rect: egui::Rect) {
if app.ui.dialog.as_ref().is_some_and(crate::dialogs::revolve_gizmo::active) {
// The artboard's 3D gizmo owns these gestures while its options are open.
// Do not let a ring drag also move or deselect the editable source path.
} else if resp.context_menu_opened() && resp.hovered() && ui.input(|i| i.pointer.any_pressed()) {
// A press on the canvas while the context menu is open only closes it (a drag too, which
// egui alone would leave open); neither the tool nor a graphic's handle gets it.
egui::Popup::close_all(ui.ctx());
} else if crate::panels::three_d::graphic_handles_input(app, ui, resp, rect) {
// A mapped graphic's handle, shown while the 3D and Materials panel's Materials tab is
// open, has the press: the drag moves the graphic, not the object.
} else {
handle_input(app, ui, resp, rect);
// `hover_doc` is the document point under the pointer in the view `handle_input` left. The
// wheel, a pan, a Rotate View drag, the Zoom tool and a Presentation Mode click move the view
// there. A dialog, floating panel or menu over the canvas hides it (Object Highlighting
// showed through them: #4518), unless a drag that began on the canvas goes on there.
let moved = Xf::at(rect, app.view().unwrap_or(&View::default()), app.canvas_ui_zoom);
let dragging = ui.data(|d| d.get_temp::<Drag>(drag_id()).is_some());
app.hover_doc =
ui.input(|i| i.pointer.hover_pos()).filter(|p| rect.contains(*p) && (dragging || drag::on_canvas(ui, resp, *p))).map(|p| moved.to_doc(p));
}
}
/// The pointer over the canvas: the view tools' cursors, else the tool's own.
fn canvas_cursor(app: &mut VectorcraftApp, ui: &Ui, view_info: vectorcraft_engine::ViewInfo, hover_still: bool) {
if opening::long_operation_busy(app) {
ui.ctx().set_cursor_icon(cursor_icon(Cursor::Busy));
return;
}
let m = ui.input(|i| i.modifiers);
let space = drag::space_lends_view_tools(app, m, ui.input(|i| i.key_down(egui::Key::Space)));
let drag = ui.data(|d| d.get_temp::<Drag>(drag_id()));
let panning = matches!(drag, Some(Drag::Pan { .. }));
let tool_holds = drag.is_some_and(drag::tool_holds);
// A tool that holds the press (Pencil, a brush, a shape) keeps Space out of the way: the drag
// began before Space went down, so Space pans nothing, and the hand would promise a pan the
// drag does not do.
let space = space && !tool_holds;
// A zoom drag keeps its cursor when Space is pressed (with or without Shift) or Cmd is let go.
let zoom_drag = matches!(drag, Some(Drag::ZoomBox { .. } | Drag::ZoomScrub { .. }));
let zooming = zoom_drag || if space { m.command } else { app.session.tool_id() == "zoom" };
// A rotating drag keeps its cursor when Shift is let go.
let rotating = matches!(drag, Some(Drag::RotateView { .. }))
|| (!zoom_drag && if space { m.shift && !m.command } else { app.session.tool_id() == "rotateView" });
// The hand and the magnifier are drawn like the tool cursors below: Windows has no
// system cursor for them (winit shows the four-headed move cursor for Grab).
let view_cursor = if panning {
Some(Cursor::HandGrab)
} else if rotating {
Some(Cursor::Rotate)
} else if zooming {
Some(if m.alt { Cursor::ZoomOut } else { Cursor::ZoomIn })
} else if space || app.session.tool_id() == "hand" {
Some(Cursor::Hand)
} else {
None
};
// Cmd borrows a selection tool only at pointer-down. Pressed during another tool's drag, it
// cannot change the owner, so do not preview the borrowed tool's cursor. A drag that started
// with a borrowed selection tool keeps its Command modifier and cursor.
let mut cursor_mods = mods(m, space);
if tool_holds && !vectorcraft_tools::catalog::is_selection_tool(app.session.tool_id()) {
cursor_mods.cmd = false;
}
// In Presentation Mode the pointer is the default one, with no tool cursor.
let tool_cursor = (app.ui.screen_mode < 3).then(|| view_cursor.or_else(|| hover_cursor(app, cursor_mods, view_info, hover_still)));
let cur = if let Some(c) = tool_cursor.flatten() {
let painter = ui.ctx().layer_painter(egui::LayerId::new(egui::Order::Tooltip, egui::Id::unique("tool-cursor")));
// The loaded place cursor carries the file's thumbnail.
if app.session.tool_id() == "place"
&& let Some(hp) = ui.input(|i| i.pointer.hover_pos())
{
crate::place::paint_cursor(app, ui.ctx(), &painter, hp);
}
// The glyph cursors are drawn here; General › Use Precise Cursors (the session turns the drawing tools' pointers
// into crosshairs, `Cursor::precise`) needs no handling. VECTORCRAFT_SYSTEM_CURSORS opts out of the glyphs.
let custom = std::env::var_os("VECTORCRAFT_SYSTEM_CURSORS").is_none();
// User Interface › Scale Cursor Proportional to UI: the glyphs grow with UI Scaling;
// off, they keep their size.
let ui_scale = if app.session.prefs.scale_cursor_with_ui { 1.0 } else { ui.ctx().zoom_factor() };
match ui.input(|i| i.pointer.hover_pos()) {
// An OS cursor: the system moves it at once, where a painted one trails the pointer
// (#444). The system cursor stands in for cursors without a glyph. Over a window
// without the focus, macOS shows its own pointer whichever cursor the window sets,
// and the glyph is not painted there.
// Interim #2292: remove when pinned winit correctly handles macOS cursor image and hotspot sizing.
#[cfg(target_os = "macos")]
Some(_) if !app.services.wayland => {
crate::cursors::native_request::request(ui.ctx(), c, cursor_icon(c), custom, ui.ctx().zoom_factor() / ui_scale)
}
Some(_) if custom && crate::cursors::os_cursors(crate::cursors::OS_CURSORS, app.services.wayland) => {
let ppp = ui.ctx().pixels_per_point() / ui_scale;
ui.ctx().set_cursor_image(app.canvas.cursors.get(c, ppp));
cursor_icon(c)
}
Some(hp)
if custom
&& crate::cursors::paint_glyphs(crate::cursors::HIDES_ONLY_WHEN_KEY, ui.input(|i| i.focused), app.services.no_cursor_theme)
&& crate::cursors::paint(&painter, c, hp, 1.0 / ui_scale) =>
{
// The painted glyph stands in for the hidden system pointer. Without a cursor theme
// (Wayland) none is painted: the system pointer can't be hidden there (#2450).
egui::CursorIcon::None
}
_ => cursor_icon(c),
}
} else {
egui::CursorIcon::Default
};
ui.ctx().set_cursor_icon(cur);
}
/// The rulers, and the origin being dragged out of their corner.
fn ruler_bands(app: &VectorcraftApp, ui: &Ui, xf: &Xf, (full, rect): (egui::Rect, egui::Rect), origin_preview: Option<Point>, t: &Tokens) {
let painter = ui.painter_at(rect);
if let Some(origin) = origin_preview {
let at = xf.to_screen(origin);
let color = dim_on_canvas(t, app.outline_view());
painter.line_segment([pos2(at.x, rect.top()), pos2(at.x, rect.bottom())], Stroke::new(1.0, color));
painter.line_segment([pos2(rect.left(), at.y), pos2(rect.right(), at.y)], Stroke::new(1.0, color));
}
// View › Rulers › Show Video Rulers counts the active artboard in video pixels.
let video = app.ui.view.video_rulers.then(|| crate::dialogs::artboard_options::active_index(app));
let scale = match video.and_then(|i| app.session.active()?.doc.artboards.get(i)) {
Some(ab) => RulerScale::video(ab),
None => RulerScale::document(app.session.general_unit(), origin_preview.unwrap_or_else(|| app.ruler_origin())),
};
rulers(ui, full, xf, app.hover_doc, scale, t);
}
/// What the cached frame depends on.
fn cache_key(
app: &VectorcraftApp,
ui: &Ui,
st: &vectorcraft_engine::DocState,
t: &Tokens,
v: &View,
(w, h, ppp): (u32, u32, f32),
(pixel, smooth_images, plugins, placed): (Option<[i64; 4]>, bool, u64, u64),
) -> CacheKey {
// Paths made into guides are drawn as the ruler guides are (Preferences › Guides & Grid).
let guide_look = LineLook::guides(&app.session.prefs, t);
CacheKey {
guide: ([guide_look.color.r(), guide_look.color.g(), guide_look.color.b()], guide_look.dots),
doc: st.uid as usize,
revision: st.revision,
interacting: st.interaction.is_some(),
zoom: v.zoom,
cx: v.center.x,
cy: v.center.y,
w,
h,
outline: app.outline_view(),
trim: app.ui.view.trim_view,
templates: app.ui.view.templates,
guides: app.ui.view.guides,
ppp,
hidden: vec![],
rot: v.rotation,
anti_alias: app.session.prefs.anti_aliased_artwork,
highlight_alternate_glyphs: app.session.prefs.highlight_alternate_glyphs,
highlight_substituted_fonts: app.session.prefs.highlight_substituted_fonts,
placed,
plugins,
pixel,
smooth_images,
isolated: st.isolation.map(|id| id.0),
// Appearance of Black › On Screen: Display All Blacks as Rich Black.
rich_black: app.session.prefs.black_on_screen == "rich",
// A tool's drag on the canvas, during an interaction (not a dialog's preview).
dragging: app.session.in_interaction() && ui.data(|d| d.get_temp::<Drag>(drag_id())) == Some(Drag::Tool),
// The Image Trace panel's eye button, while it is held.
trace_source: app.ui.trace_hold_source.clone(),
// Preferences › Performance › Use Monitor Profile for Canvas.
display: app.display_profile.key(app.session.prefs.monitor_profile_display),
backdrop: backdrop(app, st, app.outline_view()),
}
}
/// [`CacheKey::plugins`] of document `st`, one of the documents open in `session`. `keys` holds each
/// document's value and the plug-in revision it was checked at, so a document is looked through only
/// once after each change of the plug-in revision.
fn plugin_key(
keys: &mut std::collections::HashMap<u64, (u64, u64)>,
session: &vectorcraft_engine::Session,
st: &vectorcraft_engine::DocState,
) -> u64 {
let revision = vectorcraft_render::effects::plugin_revision();
match keys.get(&st.uid) {
Some(&(checked, key)) if checked == revision => key,
seen => {
let key = if vectorcraft_render::draws_plugin_effects(&st.doc) { revision } else { seen.map_or(0, |&(_, key)| key) };
keys.retain(|uid, _| session.documents().iter().any(|d| d.uid == *uid));
keys.insert(st.uid, (revision, key));
key
}
}
}
/// [`CacheKey::placed`] of document `st`, one of the documents open in `session`. `keys` holds each
/// document's value and the placed-document bitmap generations it was checked at
/// ([`vectorcraft_render::placed_document::generation`]).
fn placed_key(
keys: &mut std::collections::HashMap<u64, crate::PlacedKey>,
session: &vectorcraft_engine::Session,
st: &vectorcraft_engine::DocState,
) -> u64 {
placed_key_at(keys, session, st, vectorcraft_render::placed_document::generation(), vectorcraft_render::placed_document::made_between)
}
/// [`placed_key`] at generation `now`, with `made` giving the files whose bitmaps were made between
/// two generations ([`vectorcraft_render::placed_document::made_between`]). The value becomes `now`
/// when `st` shows a placed document of a file whose bitmap was made since the last check, or when
/// `made` no longer knows which files they were and `st` shows a placed document of a file in its
/// images, as [`vectorcraft_render::placed_area`] decides (every file shows while a pattern is
/// edited). Otherwise it stays: a bitmap made for another document, or for a file `st` keeps only
/// for Undo, leaves this document's frame as it is. A document checked for the first time takes
/// `now`.
fn placed_key_at(
keys: &mut std::collections::HashMap<u64, crate::PlacedKey>,
session: &vectorcraft_engine::Session,
st: &vectorcraft_engine::DocState,
now: u64,
made: impl FnOnce(u64, u64) -> Option<std::collections::HashSet<String>>,
) -> u64 {
let entry = match keys.get(&st.uid).copied() {
Some(p) if p.checked == now => return p.key,
None => crate::PlacedKey { checked: now, key: now, before: (now, now) },
Some(p) => {
let images = &st.doc.images;
// The files made that `st` holds: a placed document of one of them may show.
let files: std::collections::HashSet<String> = if images.is_empty() {
Default::default()
} else {
match made(p.checked, now) {
Some(files) => files.into_iter().filter(|f| images.contains_key(f)).collect(),
None => images.keys().cloned().collect(),
}
};
let stays = matches!(vectorcraft_render::placed_area(&st.doc, &files), vectorcraft_render::Changed::Nothing);
if stays { crate::PlacedKey { checked: now, ..p } } else { crate::PlacedKey { checked: now, key: now, before: (p.key, p.checked) } }
}
};
keys.retain(|uid, _| session.documents().iter().any(|d| d.uid == *uid));
keys.insert(st.uid, entry);
entry.key
}
/// The generation after which the bitmaps made decide what a frame shown at [`CacheKey::placed`]
/// value `shown` draws again at value `key`, with `entry` the document's [`crate::PlacedKey`]. When
/// the value changed once since `shown`, it is the last generation `shown` was checked at: no
/// bitmap of the document's placed documents was made between `shown` and that generation.
/// Otherwise it is `shown`.
fn placed_since(entry: Option<&crate::PlacedKey>, shown: u64, key: u64) -> u64 {
entry.filter(|p| p.key == key && p.before.0 == shown).map_or(shown, |p| p.before.1)
}
/// What placed documents' bitmaps change in `doc` between a frame shown at [`CacheKey::placed`]
/// value `shown` and the frame at value `key`: where `doc` shows the files whose bitmaps were made
/// after [`placed_since`], with `entry` the document's [`crate::PlacedKey`] and `made` giving the
/// files whose bitmaps were made between two generations
/// ([`vectorcraft_render::placed_document::made_between`]). None when those files are no longer
/// known.
fn placed_changes(
entry: Option<&crate::PlacedKey>,
shown: u64,
key: u64,
doc: &vectorcraft_doc::Document,
made: impl FnOnce(u64, u64) -> Option<std::collections::HashSet<String>>,
) -> Option<vectorcraft_render::Changed> {
if shown == key {
return Some(vectorcraft_render::Changed::Nothing);
}
Some(vectorcraft_render::placed_area(doc, &made(placed_since(entry, shown, key), key)?))
}
/// Once the first view of a document has been drawn, the status bar says how many plug-in effect
/// stages it left deferred, if any.
fn report_deferred(app: &mut VectorcraftApp, effects: &vectorcraft_plugins::deferred::Deferrals) {
if let Some(n) = effects.take_report().filter(|n| *n > 0) {
app.status(crate::i18n::msg_n(
n as u64,
"Opened with {n} plug-in effect deferred. Effect › Refresh Deferred Effects runs it.",
"Opened with {n} plug-in effects deferred. Effect › Refresh Deferred Effects runs them.",
&[],
));
}
}
/// Start the render worker, and upload the frame it finished.
fn poll_worker(app: &mut VectorcraftApp, ui: &Ui, key_doc: usize) {
if !app.canvas.worker_started {
app.canvas.worker_started = true;
if std::env::var_os("VECTORCRAFT_SYNC_RENDER").is_none() {
app.canvas.worker = crate::render_worker::Worker::spawn(ui.ctx().clone());
app.canvas.fill_worker = crate::render_worker::Worker::spawn(ui.ctx().clone());
}
}
if let Some(done) = app.canvas.worker.as_mut().and_then(|w| w.poll()) {
show_worker_frame(app, ui.ctx(), done, key_doc);
}
}
/// Upload frame `done` from the render worker when it is of document `key_doc` and not older than
/// the frame shown. This prevents canvas freezes during continuous edits (drags, arrow nudges, MCP
/// command bursts) while ensuring obsolete out-of-order frames are dropped.
fn show_worker_frame(app: &mut VectorcraftApp, ctx: &egui::Context, done: crate::render_worker::Done, key_doc: usize) {
let not_older = app.canvas.key.as_ref().filter(|k| k.doc == done.key.doc).is_none_or(|k| done.key.revision >= k.revision);
if done.key.doc != key_doc || !not_older {
return;
}
upload(app, ctx, done.img, done.key.pixel.is_some());
if let Some(d) = app.session.documents().iter().find(|d| d.uid as usize == done.key.doc) {
d.plugin_effects.first_view_done();
}
app.canvas.key = Some(done.key);
app.canvas.shown = Some((done.doc, done.opts));
app.perf.render_ms = done.ms;
// A frame with copied pixels leaves `last_ms` at the whole frame's.
if !done.reused {
app.canvas.last_ms = done.ms;
}
app.canvas.reused = done.reused.then(|| ctx.input(|i| i.time));
app.canvas.moved = done.moved > 0;
app.canvas.from_worker = true;
}
/// The size and view matrix of the frame to render: the pixel region in Pixel Preview, else the whole canvas.
fn frame_view(pixel: Option<[i64; 4]>, (w, h): (u32, u32), v: &View, ppp: f32) -> (u32, u32, Affine) {
match pixel {
Some([x0, y0, x1, y1]) => ((x1 - x0) as u32, (y1 - y0) as u32, Affine::translate((-x0 as f64, -y0 as f64))),
None => (
w,
h,
Affine::translate((w as f64 / 2.0, h as f64 / 2.0))
* Affine::rotate(v.rotation.to_radians())
* Affine::scale(v.zoom * ppp as f64)
* Affine::translate(-v.center.to_vec2()),
),
}
}
/// The options the canvas renders the document with.
fn frame_options(
app: &VectorcraftApp,
key: &CacheKey,
mask_view: Option<vectorcraft_doc::NodeId>,
smooth_images: bool,
) -> vectorcraft_render::RenderOptions {
let opts = vectorcraft_render::RenderOptions { outline: key.outline, background: None, artboards: false, ..Default::default() };
vectorcraft_render::RenderOptions {
proof: vectorcraft_render::proof::active_proof(),
overprint_preview: vectorcraft_render::proof::overprint_preview_on(),
trim: app.ui.view.trim_view,
hide_templates: !app.ui.view.templates,
hide_guides: !app.ui.view.guides,
tile_edge: vectorcraft_color::Color::from_hex(&app.session.prefs.pattern_tile_edge_color).map_or(opts.tile_edge, |c| {
let [r, g, b, _] = c.to_rgba8(1.0);
[r, g, b]
}),
guide: key.guide,
mask_view,
highlight_substitutions: true,
// Type › Highlight Alternate Glyphs (#394): pink behind OpenType substitutions.
highlight_alternate_glyphs: app.session.prefs.highlight_alternate_glyphs,
// Type › Highlight Substituted Fonts: pink behind text in a substitute font.
highlight_substituted_fonts: app.session.prefs.highlight_substituted_fonts,
// General › Anti-aliased Artwork: off, edges are hard on screen (raster effects and
// pattern tiles stay smooth).
anti_alias: if app.session.prefs.anti_aliased_artwork { vectorcraft_render::AntiAlias::Art } else { vectorcraft_render::AntiAlias::None },
progressive_placed: true,
trace_views: true,
// Image Trace › the eye button held: the source image of the selected objects.
trace_source: key.trace_source.clone(),
smooth_images,
// Isolation mode: the art around the isolated group or layer is dimmed (#833).
isolated: key.isolated.map(vectorcraft_doc::NodeId),
// Images far smaller on screen than they are sample their mip levels (#1244).
image_mips: true,
// An image whose pixels can't be decoded shows as a crossed box, and the status message
// below reports it.
mark_undecoded_images: true,
// During a drag or a dialog's preview, objects that only moved draw their raster
// effects from the cached rasters of an earlier frame (#1257).
interacting: key.interacting,
// During a tool's drag, raster effects without a cached raster to draw render at a
// lower resolution (#2558); the frame after the drag renders them as a still frame does.
dragging: key.dragging,
rich_black: key.rich_black,
..opts
}
}
/// A frame to render: here, or on the worker.
struct Frame<'a> {
key: &'a CacheKey,
doc: &'a std::sync::Arc<vectorcraft_doc::Document>,
/// The document's deferred plug-in effect stages: the frame renders inside their view.
effects: &'a vectorcraft_plugins::deferred::Deferrals,
size: (u32, u32),
view: Affine,
opts: vectorcraft_render::RenderOptions,
pixel: Option<[i64; 4]>,
}
/// How long the UI thread waits for a document's first frame from the render worker before it
/// shows the document's paper without the art: about a frame at 60 Hz.
pub(crate) const FIRST_FRAME_GRACE: std::time::Duration = std::time::Duration::from_millis(16);
fn draw_frame(app: &mut VectorcraftApp, ui: &Ui, frame: Frame) {
let Frame { key, doc, effects, size: (w, h), view, opts, pixel } = frame;
// Frames that would be slow on this thread (the last one took over 8 ms) go
// to the worker. An interaction's frames stay on the worker once it drew the frame shown:
// its renderer keeps the rasters of the art's effects that make those frames fast, and this
// thread's renderer has none, so a frame fast on the worker would be slow here.
let same_doc = app.canvas.key.as_ref().is_some_and(|k| k.doc == key.doc);
let settling = app.canvas.moved && !key.interacting;
let staying = key.interacting && app.canvas.from_worker;
// A document's first frame (opened, or its tab chosen) renders on the worker too: how long it
// takes is not known yet, and a heavy one froze the window for seconds (#4155). Its paper and
// artboards show meanwhile.
let first = app.canvas.texture.is_none() || !same_doc;
let heavy = first || app.canvas.last_ms > 8.0 || settling || staying;
let changed = changed_pixels(app, key, doc, &opts, view, w, h);
// A new view can copy from the worker's last frame. The frame shown asked for again renders
// whole. The worker keeps either one for the next pan to copy from.
let may_copy = app.canvas.key.as_ref() != Some(key);
let display = app.display_profile.transform(app.session.prefs.monitor_profile_display);
let mut landed = None;
match (&mut app.canvas.worker, heavy, changed) {
// Only the document changed since the frame shown, in a part of it: that part is
// rendered again, here, into the texture. `last_ms` stays the whole frame's.
(_, _, Some(region)) => {
let t0 = now_ms();
if region.is_none() {
// Nothing in view to draw again: what was made to measure the edit isn't drawn.
app.canvas.renderer.let_go_of_measured();
}
if let (Some([x0, y0, x1, y1]), Some(tex)) = (region, &mut app.canvas.texture) {
let renderer = &mut app.canvas.renderer;
let part_view = Affine::translate((-f64::from(x0), -f64::from(y0))) * view;
let mut part = effects.view(|| renderer.render(doc, x1 - x0, y1 - y0, part_view, &opts));
let width = part.width;
crate::display_profile::convert_over(display.as_deref(), &mut part.pixels, width, part_view, key.over());
let color = color_image(&part);
let options = if pixel.is_some() { egui::TextureOptions::NEAREST } else { egui::TextureOptions::LINEAR };
tex.set_partial([x0 as usize, y0 as usize], color, options);
app.canvas.moved |= app.canvas.renderer.stats.moved > 0;
}
app.canvas.key = Some(key.clone());
app.canvas.shown = Some((doc.clone(), opts.clone()));
app.perf.render_ms = now_ms() - t0;
}
(Some(worker), true, None) => {
// The worker draws the frame: what this thread's renderer made to measure the edit
// isn't drawn here.
app.canvas.renderer.let_go_of_measured();
let queued = worker.submit(crate::render_worker::Job {
key: key.clone(),
doc: doc.clone(),
w,
h,
view,
opts,
scope: vectorcraft_engine::file_access::ScopeHandle::capture(),
effects: effects.clone(),
may_copy,
may_keep: true,
display,
});
// A light document's first frame is ready within the grace and shows in this frame,
// with no frame of bare paper. Waited for once, when the frame is queued.
if first && queued {
landed = worker.wait(FIRST_FRAME_GRACE);
}
}
_ => {
let t0 = now_ms();
let renderer = &mut app.canvas.renderer;
let mut img = effects.view(|| renderer.render(doc, w, h, view, &opts));
effects.first_view_done();
let width = img.width;
crate::display_profile::convert_over(display.as_deref(), &mut img.pixels, width, view, key.over());
upload(app, ui.ctx(), img, pixel.is_some());
app.canvas.key = Some(key.clone());
app.canvas.shown = Some((doc.clone(), opts.clone()));
app.perf.render_ms = now_ms() - t0;
app.canvas.last_ms = app.perf.render_ms;
app.canvas.moved = app.canvas.renderer.stats.moved > 0;
app.canvas.from_worker = false;
app.canvas.reused = None;
}
}
if let Some(done) = landed {
show_worker_frame(app, ui.ctx(), done, key.doc);
}
}
/// The canvas color in Outline, whatever the interface brightness and Canvas Color: the paths draw
/// as black hairlines, and the artboards as their edges only.
const OUTLINE_CANVAS: Color32 = Color32::WHITE;
/// The color of the artboards' names and the ruler origin's crosshair in Outline, on
/// [`OUTLINE_CANVAS`].
const OUTLINE_DIM: Color32 = Color32::from_gray(0x4b);
/// The pasteboard and the artboards' shadows and paper of document `st`, or in Outline (`outline`)
/// the whole canvas in [`OUTLINE_CANVAS`], with no paper drawn for the artboards: no Simulate
/// Colored Paper color, no artboard background color, and no paper with View › Hide Artboards.
fn paint_paper(
app: &VectorcraftApp,
st: &vectorcraft_engine::DocState,
ui: &Ui,
painter: &egui::Painter,
xf: &Xf,
rect: egui::Rect,
(t, outline): (&Tokens, bool),
) {
let doc = &st.doc;
if outline {
// The art draws in black on white over the pasteboard and the artboards alike, and the
// artboards show as their edges (`artboard_outlines`).
painter.rect_filled(rect, 0.0, OUTLINE_CANVAS);
return;
}
// Pasteboard, artboard shadows and paper (Document Setup: the transparency grid's look, the
// simulated paper colour; a white Background Contents hides the grid).
// An artboard with a background color draws its paper in that color. With Simulate Colored Paper
// on, the canvas multiplies it with the paper color: each sRGB channel is artboard × paper / 255,
// rounded. The transparency grid, while it shows, covers it as it covers the others.
painter.rect_filled(rect, 0.0, t.pasteboard);
// The paper and the transparency grid are document colors: they go through the display
// profile as the art does. The pasteboard and the shadows are the interface's.
let display = app.display_profile.transform(app.session.prefs.monitor_profile_display);
let on_display = |c: Color32| crate::display_profile::color32(display.as_deref(), c);
if !shows_artboards(app) {
// View › Hide Artboards: no edges and no pasteboard, the whole canvas paper (#4038).
painter.rect_filled(rect, 0.0, on_display(paper_color(&doc.setup)));
} else {
let setup = &doc.setup;
let grid = shows_transparency_grid(st).then(|| checker_texture(ui.ctx(), setup, display.as_deref()));
let paper = paper_color(setup);
for ab in &doc.artboards {
let q = xf.quad(ab.rect);
// Hard 2 pt drop shadow, right and bottom (measured: #4d4d4d then #565656 on #606060).
let shift = |d: f32| q.iter().map(|p| *p + vec2(d, d)).collect::<Vec<_>>();
painter.add(Shape::convex_polygon(shift(2.0), Color32::from_black_alpha(26), Stroke::NONE));
painter.add(Shape::convex_polygon(shift(1.0), Color32::from_black_alpha(52), Stroke::NONE));
match &grid {
Some((tex, cell)) => checker(painter, &q, ab.rect, xf.zoom, tex.id(), *cell),
None => {
painter.add(Shape::convex_polygon(q, on_display(artboard_paper(ab, paper)), Stroke::NONE));
}
}
}
}
}
/// The color of the paper: Simulate Colored Paper's, else white.
fn paper_color(setup: &vectorcraft_doc::DocSetup) -> Color32 {
if setup.simulate_paper { crate::panels::c32(&setup.paper()) } else { Color32::WHITE }
}
/// The color of artboard `ab`'s paper, the paper `paper`: an artboard with a background color
/// multiplies it with the paper, each sRGB channel artboard × paper / 255, rounded.
fn artboard_paper(ab: &vectorcraft_doc::Artboard, paper: Color32) -> Color32 {
ab.color.map_or(paper, |c| crate::panels::c32(&c) * paper)
}
/// The transparency grid covers the artboards of document `st`: it is shown, and the Background
/// Contents are transparent.
fn shows_transparency_grid(st: &vectorcraft_engine::DocState) -> bool {
st.transparency_grid && st.doc.setup.background == vectorcraft_doc::Background::Transparent
}
/// The paper [`paint_paper`] draws for document `st`, which translucent art is blended with before
/// the display profile's conversion. None without a display profile, and in Outline (`outline`),
/// whose white canvas is the interface's.
fn backdrop(app: &VectorcraftApp, st: &vectorcraft_engine::DocState, outline: bool) -> Option<std::sync::Arc<crate::display_profile::Backdrop>> {
if outline || app.display_profile.transform(app.session.prefs.monitor_profile_display).is_none() {
return None;
}
let rgb = |c: Color32| [c.r(), c.g(), c.b()];
let setup = &st.doc.setup;
let paper = paper_color(setup);
let b = if shows_artboards(app) {
crate::display_profile::Backdrop {
everywhere: None,
artboards: st.doc.artboards.iter().map(|ab| (ab.rect, rgb(artboard_paper(ab, paper)))).collect(),
grid: shows_transparency_grid(st).then(|| (setup.grid_colors.map(|c| rgb(crate::panels::c32(&c))), setup.grid_size.cell())),
}
} else {
crate::display_profile::Backdrop { everywhere: Some(rgb(paper)), artboards: vec![], grid: None }
};
Some(std::sync::Arc::new(b))
}
/// The last rendered frame, placed through the current view while a new one is on its way.
fn reproject_frame(app: &VectorcraftApp, painter: &egui::Painter, xf: &Xf, rect: egui::Rect, (key_doc, rotation): (usize, f64)) {
if let (Some(tex), Some(k)) = (&app.canvas.texture, &app.canvas.key)
&& k.doc == key_doc
{
// The frame being shown covers the canvas rect it was rendered for. While a panel is
// dragged that rect is a different size, so reprojecting the frame through the *current*
// rect stretches the art to the new size until the worker's frame arrives, then it snaps
// back. Rebuild the rect it was rendered for from the key's own pixel size instead.
let old_rect = {
let ppp = if k.ppp > 0.0 { k.ppp } else { 1.0 };
egui::Rect::from_center_size(rect.center(), vec2(k.w as f32 / ppp, k.h as f32 / ppp))
};
match k.pixel {
// Document pixels: placed over the document rect they cover, turning with the view.
Some([x0, y0, x1, y1]) => {
textured_quad(painter, tex.id(), &xf.quad(Rect::new(x0 as f64, y0 as f64, x1 as f64, y1 as f64)), (1.0, 1.0));
}
None if (k.rot - rotation).abs() < 1e-9 => {
// Reproject the last frame if it was rendered for a different view.
let old = Xf { rect: old_rect, zoom: k.zoom, center: Point::new(k.cx, k.cy), rot: xf.rot };
let a = xf.to_screen(old.to_doc(old_rect.min));
let b = xf.to_screen(old.to_doc(old_rect.max));
painter.image(tex.id(), egui::Rect::from_min_max(a, b), egui::Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0)), Color32::WHITE);
}
// The view turned after the last frame was rendered, and the worker renders the frame at
// the new angle. Until it arrives, the last frame is drawn turned into this view: each
// corner goes where this view puts the document point that the corner showed.
None => {
let old = Xf { rect: old_rect, zoom: k.zoom, center: Point::new(k.cx, k.cy), rot: k.rot.to_radians() };
let q =
[old_rect.left_top(), old_rect.right_top(), old_rect.right_bottom(), old_rect.left_bottom()].map(|c| xf.to_screen(old.to_doc(c)));
textured_quad(painter, tex.id(), &q, (1.0, 1.0));
}
}
}
}
/// Does the area outside the artboards draw darker? Artboard Options › Fade Region Outside Artboard
/// darkens it while the Artboard tool is active, and with Update While Dragging off it draws as
/// usual while the tool moves or resizes an artboard. Presentation Mode, exports and prints never
/// draw the fade.
fn fades_outside_artboards(app: &VectorcraftApp) -> bool {
let prefs = &app.session.prefs;
app.ui.screen_mode != 3
&& app.session.tool_id() == "artboard"
&& prefs.fade_region_outside_artboard
&& (prefs.artboard_update_while_dragging || !app.session.tool_transforming())
}
/// The fade's color: black at 40% opacity, which shows each channel under it at 60% of its value.
const FADE_OUTSIDE: Color32 = Color32::from_black_alpha(102);
/// Fade Region Outside Artboard: over the pasteboard and the art on it, one mesh in [`FADE_OUTSIDE`]
/// that covers the canvas outside the artboards of `doc`, drawn through the view. The mesh is not
/// anti-aliased, so its rectangles meet without seams.
fn fade_outside_artboards(painter: &egui::Painter, xf: &Xf, doc: &vectorcraft_doc::Document) {
let boards: Vec<Rect> = doc.artboards.iter().map(|a| a.rect).collect();
let mut mesh = egui::Mesh::default();
for (n, r) in (0u32..).zip(fade_rects(view_bounds(xf), &boards)) {
for p in xf.quad(r) {
mesh.colored_vertex(p, FADE_OUTSIDE);
}
let a = n * 4;
mesh.add_triangle(a, a + 1, a + 2);
mesh.add_triangle(a, a + 2, a + 3);
}
painter.add(Shape::mesh(mesh));
}
/// The most rectangles the fade draws exactly around the artboards.
const FADE_MAX_RECTS: usize = 4096;
/// The rectangles the fade covers: the parts of `bounds` outside the artboards ([`outside_rects`]),
/// or, when those would be more than [`FADE_MAX_RECTS`], the parts outside the box around all the
/// artboards, at most four.
fn fade_rects(bounds: Rect, boards: &[Rect]) -> Vec<Rect> {
outside_rects(bounds, boards, FADE_MAX_RECTS).unwrap_or_else(|| {
let all: Vec<Rect> = boards.iter().copied().reduce(|a, b| a.union(b)).into_iter().collect();
outside_rects(bounds, &all, FADE_MAX_RECTS).unwrap_or_default()
})
}
/// The parts of `bounds` that no rectangle of `boards` covers, as rectangles that do not overlap:
/// for each band between consecutive top and bottom edges, the gaps between the boards that cross
/// it. A gap with the same left and right edges as a gap of the band above extends that gap's
/// rectangle down, so each board edge adds at most a few rectangles. Boards that cross each other
/// can leave many more gaps; past `limit` rectangles it stops and returns `None`.
fn outside_rects(bounds: Rect, boards: &[Rect], limit: usize) -> Option<Vec<Rect>> {
let mut ys: Vec<f64> = boards.iter().flat_map(|b| [b.y0, b.y1]).filter(|y| *y > bounds.y0 && *y < bounds.y1).collect();
ys.extend([bounds.y0, bounds.y1]);
ys.sort_by(f64::total_cmp);
ys.dedup();
let mut by_top: Vec<Rect> = boards.iter().copied().filter(|b| b.y0 < bounds.y1 && b.y1 > bounds.y0).collect();
by_top.sort_by(|a, b| a.y0.total_cmp(&b.y0));
let mut next = 0;
// The boards that cross the current band, left to right.
let mut active: Vec<Rect> = vec![];
let mut out: Vec<Rect> = vec![];
// The indices in `out` of the band above's rectangles, left to right.
let mut above: Vec<usize> = vec![];
for band in ys.windows(2) {
let &[y0, y1] = band else { continue };
while let Some(b) = by_top.get(next).copied().filter(|b| b.y0 <= y0) {
let at = active.partition_point(|a| a.x0 <= b.x0);
active.insert(at, b);
next += 1;
}
active.retain(|b| b.y1 >= y1);
let mut gaps = vec![];
let mut x = bounds.x0;
for b in &active {
let (a, e) = (b.x0.max(bounds.x0), b.x1.min(bounds.x1));
if a >= e {
continue;
}
if a > x {
gaps.push((x, a));
}
x = x.max(e);
}
if x < bounds.x1 {
gaps.push((x, bounds.x1));
}
let mut prev = above.iter().copied().peekable();
let mut row = Vec::with_capacity(gaps.len());
for (a, e) in gaps {
while prev.next_if(|&i| out[i].x0 < a).is_some() {}
match prev.peek().copied() {
Some(i) if out[i].x0 == a && out[i].x1 == e => {
out[i].y1 = y1;
row.push(i);
prev.next();
}
_ => {
row.push(out.len());
out.push(Rect::new(a, y0, e, y1));
}
}
}
above = row;
if out.len() > limit {
return None;
}
}
Some(out)
}
/// Do the artboards show? View › Hide Artboards hides them, except for the Artboard tool, which
/// edits them.
fn shows_artboards(app: &VectorcraftApp) -> bool {
app.ui.view.artboards || app.session.tool_id() == "artboard"
}
/// The artboards' edges, bleeds, marks and names.
fn artboard_outlines(app: &VectorcraftApp, ui: &Ui, painter: &egui::Painter, xf: &Xf, t: &Tokens) {
if !shows_artboards(app) {
return;
}
let Some(st) = app.session.active() else { return };
let doc = &st.doc;
// Artboard edges and names. The Artboard tool labels its selected artboards itself (following
// a move or resize): those aren't named twice.
let active_ab = crate::panels::artboards::selected(app, doc.artboards.len());
let tool_selected = artboards::tool_labelled(app);
let editing_name = ui.data(|d| d.get_temp::<ArtboardNameEdit>(name_edit_id()).map(|e| e.index));
let unlabelled = |i: usize| editing_name == Some(i) || u64::try_from(i).ok().is_some_and(|idx| tool_selected.contains(&idx));
artboard_edges(app, doc, (painter, xf, t), (active_ab, dim_on_canvas(t, app.outline_view())), unlabelled);
}
/// The color of the artboards' names and the ruler origin's crosshair over the pasteboard, or over
/// [`OUTLINE_CANVAS`] in Outline (`outline`).
fn dim_on_canvas(t: &Tokens, outline: bool) -> Color32 {
if outline { OUTLINE_DIM } else { t.text_dim }
}
/// The edges, bleeds, marks and names of `doc`'s artboards, `active_ab` the active one, the names
/// in `label`; the artboards `unlabelled` gives are not named.
fn artboard_edges(
app: &VectorcraftApp,
doc: &vectorcraft_doc::Document,
(painter, xf, t): (&egui::Painter, &Xf, &Tokens),
(active_ab, label): (usize, Color32),
unlabelled: impl Fn(usize) -> bool,
) {
let artboard_tool = app.session.tool_id() == "artboard";
for (i, ab) in doc.artboards.iter().enumerate() {
let c = if i == active_ab { Color32::from_gray(0) } else { Color32::from_gray(120) };
painter.add(Shape::closed_line(xf.quad(ab.rect), Stroke::new(if i == active_ab { 1.0 } else { 0.6 }, c)));
// The bleed (Document Setup) as a red outline around the artboard.
if doc.setup.has_bleed() {
painter.add(Shape::closed_line(xf.quad(doc.setup.bleed_rect(ab.rect)), Stroke::new(1.0, t.bleed)));
}
// Show Center Mark, Show Cross Hairs and Show Video Safe Areas (Artboard Options). Only the
// canvas draws them, as it does the edges: exports and print leave them out.
artboard_marks(painter, xf, ab, t.artboard_mark);
if (artboard_tool || doc.artboards.len() > 1) && !unlabelled(i) {
// At the artboard's own top-left corner, which a rotated view turns away from its
// bounding box's (#1095).
let corner = xf.to_screen(Point::new(ab.rect.x0, ab.rect.y0));
artboard_label(painter, corner, (ab.rect.width() * xf.zoom) as f32, &format!("{:02} - {}", i + 1, ab.name), label);
}
}
}
/// The ruler guides.
fn guide_lines(app: &VectorcraftApp, painter: &egui::Painter, xf: &Xf, rect: egui::Rect, t: &Tokens) {
if let Some(st) = app.session.active() {
guides_of(app, st, (painter, xf, t), rect);
}
}
/// The ruler guides of document `st`, its selected guides in the selection colour. An artboard
/// guide of an artboard with a guide label ([`vectorcraft_doc::Artboard::guide_label`]) is drawn in
/// the label's color, in the guide preference's style; the others in the guide preference's color.
fn guides_of(app: &VectorcraftApp, st: &vectorcraft_engine::DocState, (painter, xf, t): (&egui::Painter, &Xf, &Tokens), rect: egui::Rect) {
let doc = &st.doc;
let look = LineLook::guides(&app.session.prefs, t);
let picked = LineLook { color: t.selection, ..look };
let labels = guide_labels(doc);
let selected: &[vectorcraft_doc::NodeId] = &st.selection.guides;
let key = st.selection.key_guide;
let view = view_bounds(xf);
// Guides on a hidden layer hide with it.
for g in doc.ruler_guides().iter().filter(|g| doc.guide_shown(g)) {
let Some(i) = g.id else { continue };
let at = |along: f64| xf.to_screen(if g.vertical { Point::new(g.pos, along) } else { Point::new(along, g.pos) });
// An artboard guide runs across its artboard, a canvas guide across the window (the part
// of its document line that the canvas shows, turned with the view).
let (a, b) = match doc.guide_span(g) {
Some((from, to)) => (at(from), at(to)),
None => {
let (from, to) = if g.vertical { (view.y0, view.y1) } else { (view.x0, view.x1) };
let Some(ends) = clip_segment(at(from), at(to), rect) else { continue };
ends
}
};
let own = g.artboard.and_then(|id| labels.get(&id)).map_or(look, |&color| LineLook { color, ..look });
if selected.contains(&i) { picked } else { own }.guide(painter, a, b);
// The key guide (Align to Key Object, #2143): thicker, as a key object's outline is.
if key == Some(i) {
painter.line_segment([a, b], Stroke::new(KEY_OUTLINE, picked.color));
}
}
}
/// The guide label colors of `doc`'s artboards that have one, by artboard id.
pub(super) fn guide_labels(doc: &vectorcraft_doc::Document) -> std::collections::HashMap<u32, Color32> {
doc.artboards
.iter()
.filter_map(|a| {
let [r, g, b] = a.guide_label?.rgb();
Some((a.id, Color32::from_rgb(r, g, b)))
})
.collect()
}
/// The selection's visuals and the tools' overlays, to be drawn.
fn selection_visuals(
app: &mut VectorcraftApp,
painter: &egui::Painter,
xf: &Xf,
(hidden_chars, mut marks, hover_still): (HiddenChars, SelectionMarks, bool),
revolve_edit: bool,
view_info: vectorcraft_engine::ViewInfo,
) -> Vec<Overlay> {
// View → Hide Gradient Annotator hides the Gradient tool's annotator.
let mut overlays = if !revolve_edit && (app.session.tool_id() != "gradient" || app.ui.view.gradient_annotator) {
app.session.overlays(view_info)
} else {
vec![]
};
// The tool shows the rest of its overlays on the next frame.
if app.session.tool_overlays_pending() {
painter.ctx().request_repaint();
}
// Gap Options' Preview shows the gaps it finds.
overlays.extend(crate::dialogs::live_paint_gaps::overlays(app));
if app.ui.view.edges && !revolve_edit {
if hover_still {
hover_highlight(app, painter, xf);
}
selection_overlay(app, painter, xf, overlays.iter().any(|o| matches!(o, Overlay::CurvePoint { .. })), &mut marks);
app.canvas.selection_marks = marks;
draw_inside_overlay(app, painter, xf);
mirror_axis_overlay(app, painter, xf);
grid_repeat_overlay(app, painter, xf);
radial_repeat_overlay(app, painter, xf);
if app.ui.view.text_threads {
// Under the tools' overlays: a selected frame's own ports are drawn over its thread's.
let mut threads = thread_overlays(app, xf.zoom);
threads.append(&mut overlays);
overlays = threads;
}
if app.ui.view.live_paint_gaps {
overlays.extend(live_paint_gap_overlays(app));
}
if app.ui.view.hidden_chars {
app.canvas.hidden_chars = hidden_chars;
hidden_chars_overlay(app, painter, xf);
}
}
if !revolve_edit {
blend_widgets_overlay(app, painter, xf);
}
// Edit › Spelling › Auto Spell Check: shown with the edges hidden too, as it marks the type
// rather than the selection.
if app.ui.view.auto_spell_check && !revolve_edit {
spelling_overlay(app, painter, xf);
} else {
app.canvas.spelling = SpellingMarks::default();
}
overlays
}
#[cfg(test)]
mod tests;
#[cfg(test)]
mod tests_ui_scaling;