Skip to content

VectorCraft: An open-source, vector art tool written by scratch in pure Rust

Honor Preferences › Performance › Real-time Drawing and Editing during tool drags

bflatasticc1f96cc6f849
diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs
index b500f2dd5..4ba284d72 100644
--- a/crates/engine/src/lib.rs
+++ b/crates/engine/src/lib.rs
@@ -1415,6 +1415,9 @@ pub struct Session {
/// Where folder searches may go; `None`: this computer's rules ([`cmd::findfiles::Rules`]).
/// Tests set it.
pub search_rules: Option<cmd::findfiles::Rules>,
+ /// Canvas feedback cached for the pending deferred preview ([`Session::overlays`]); cleared
+ /// when the preview params change or the interaction ends.
+ pub(crate) deferred_overlay_cache: Option<(String, Value, Vec<vectorcraft_tools::Overlay>)>,
/// The walker threads a folder search starts; `None`: [`cmd::findfiles::threads`]. Tests set
/// it.
pub search_threads: Option<usize>,
@@ -1489,6 +1492,7 @@ impl Session {
font_search: None,
link_search: None,
search_rules: None,
+ deferred_overlay_cache: None,
search_threads: None,
link_stamps: Default::default(),
link_scan: None,
@@ -1941,12 +1945,23 @@ impl Session {
// ---------- interactions (live drags) ----------
+ pub(crate) fn clear_deferred_overlay_cache(&mut self) {
+ self.deferred_overlay_cache = None;
+ }
+
+ /// The interaction's latest preview command when the document is still its snapshot (deferred
+ /// Real-time Drawing), regardless of the preference at commit or overlay time.
+ pub(crate) fn unapplied_interaction_preview(&self) -> Option<(String, Value)> {
+ self.active().and_then(|d| d.interaction.as_ref().filter(|it| std::sync::Arc::ptr_eq(&it.doc, &d.doc)).and_then(|it| it.preview.clone()))
+ }
+
pub fn begin_interaction(&mut self, label: &str) -> Result<()> {
// Typing in progress is kept first: a drag or a dialog's preview would otherwise start
// from the snapshot taken before the typing, and drop it (#1881).
if label != "Typing" && cmd::typing_in_progress(self) {
cmd::settle_interaction(self)?;
}
+ self.clear_deferred_overlay_cache();
let st = self.doc_mut()?;
if st.interaction.is_some() {
return Ok(());
@@ -2000,6 +2015,7 @@ impl Session {
}
pub fn commit_interaction(&mut self) -> Result<()> {
+ self.clear_deferred_overlay_cache();
self.remember_pending_paint();
let st = self.doc_mut()?;
let Some(mut it) = st.interaction.take() else { return Ok(()) };
@@ -2052,6 +2068,7 @@ impl Session {
}
pub fn cancel_interaction(&mut self) -> Result<()> {
+ self.clear_deferred_overlay_cache();
self.pending_paint = None;
let guides_locked = self.menu.guides_locked;
let st = self.doc_mut()?;
diff --git a/crates/engine/src/tests_prefs.rs b/crates/engine/src/tests_prefs.rs
index 8c7cb3861..502c56aa7 100644
--- a/crates/engine/src/tests_prefs.rs
+++ b/crates/engine/src/tests_prefs.rs
@@ -1,6 +1,8 @@
//! Preferences: `prefs.get` / `prefs.set` / `prefs.reset` / `prefs.list`.
use serde_json::{Value, json};
+use vectorcraft_doc::NodeKind;
+use vectorcraft_tools::{PointerEvent, PointerKind};
use super::*;
use crate::cmd::prefscmds::{PREF_CATEGORIES, PREF_GROUPS, PREF_SPECS, validate};
@@ -1393,6 +1395,114 @@ fn highlight_alternate_glyphs_preference_is_off_by_default() {
assert!(!s.prefs.highlight_alternate_glyphs);
}
+/// Preferences › Performance › Real-time Drawing and Editing (#394): off, the document isn't
+/// previewed while dragging but the pending shape still shows as a canvas overlay until commit.
+#[test]
+fn real_time_drawing_off_skips_tool_previews_until_commit() {
+ let mut s = Session::new();
+ s.execute("file.new", &json!({"width": 400, "height": 400})).unwrap();
+ let v = ViewInfo::default();
+ s.select_tool("rectangle", v).unwrap();
+ set_pref(&mut s, "realTimeDrawing", json!(false));
+ let paths = |s: &Session| {
+ s.doc()
+ .unwrap()
+ .doc
+ .layers
+ .first()
+ .and_then(|l| l.children())
+ .map_or(0, |c| c.iter().filter(|n| matches!(n.kind, NodeKind::Path { .. })).count())
+ };
+ let rev = s.doc().unwrap().revision;
+ assert_eq!(paths(&s), 0);
+ s.pointer(&PointerEvent::new(PointerKind::Down, 50.0, 50.0), v).unwrap();
+ s.pointer(&PointerEvent::new(PointerKind::Drag, 150.0, 150.0), v).unwrap();
+ assert_eq!(s.doc().unwrap().revision, rev, "no preview steps");
+ assert_eq!(paths(&s), 0, "the rectangle isn't in the document yet");
+ assert!(s.overlays(v).iter().any(|o| matches!(o, vectorcraft_tools::Overlay::Path { .. })), "the deferred rectangle shows as an outline");
+ s.pointer(&PointerEvent::new(PointerKind::Up, 150.0, 150.0), v).unwrap();
+ assert!(s.doc().unwrap().revision > rev, "commit applies the shape");
+ assert_eq!(paths(&s), 1);
+ set_pref(&mut s, "realTimeDrawing", json!(true));
+ let rev = s.doc().unwrap().revision;
+ s.pointer(&PointerEvent::new(PointerKind::Down, 200.0, 50.0), v).unwrap();
+ s.pointer(&PointerEvent::new(PointerKind::Drag, 280.0, 120.0), v).unwrap();
+ assert!(s.doc().unwrap().revision > rev, "on again: previews run while dragging");
+}
+
+/// Real-time Drawing turned on mid-drag still applies the deferred preview on commit.
+#[test]
+fn real_time_drawing_turned_on_mid_drag_still_commits_deferred_preview() {
+ let mut s = Session::new();
+ s.execute("file.new", &json!({"width": 400, "height": 400})).unwrap();
+ let v = ViewInfo::default();
+ s.select_tool("rectangle", v).unwrap();
+ set_pref(&mut s, "realTimeDrawing", json!(false));
+ let paths = |s: &Session| {
+ s.doc()
+ .unwrap()
+ .doc
+ .layers
+ .first()
+ .and_then(|l| l.children())
+ .map_or(0, |c| c.iter().filter(|n| matches!(n.kind, NodeKind::Path { .. })).count())
+ };
+ s.pointer(&PointerEvent::new(PointerKind::Down, 50.0, 50.0), v).unwrap();
+ s.pointer(&PointerEvent::new(PointerKind::Drag, 150.0, 150.0), v).unwrap();
+ assert_eq!(paths(&s), 0);
+ set_pref(&mut s, "realTimeDrawing", json!(true));
+ s.pointer(&PointerEvent::new(PointerKind::Up, 150.0, 150.0), v).unwrap();
+ assert_eq!(paths(&s), 1, "the deferred rectangle is committed");
+}
+
+/// Repeated overlay redraws with Real-time Drawing off reuse the cached deferred feedback.
+#[test]
+fn deferred_preview_overlays_are_cached_across_redraws() {
+ let mut s = Session::new();
+ s.execute("file.new", &json!({"width": 400, "height": 400})).unwrap();
+ let v = ViewInfo::default();
+ s.select_tool("rectangle", v).unwrap();
+ set_pref(&mut s, "realTimeDrawing", json!(false));
+ s.pointer(&PointerEvent::new(PointerKind::Down, 50.0, 50.0), v).unwrap();
+ s.pointer(&PointerEvent::new(PointerKind::Drag, 150.0, 150.0), v).unwrap();
+ let rev = s.doc().unwrap().revision;
+ let count = |s: &mut Session| s.overlays(v).iter().filter(|o| matches!(o, vectorcraft_tools::Overlay::Path { .. })).count();
+ let first = count(&mut s);
+ assert!(first > 0);
+ assert_eq!(s.doc().unwrap().revision, rev);
+ let second = count(&mut s);
+ assert_eq!(first, second);
+ assert_eq!(s.doc().unwrap().revision, rev, "the preview command is not run again");
+}
+
+/// A deferred commit that fails its preview cancels the interaction instead of leaving it open.
+#[test]
+fn deferred_commit_preview_failure_cancels_interaction() {
+ let mut s = Session::new();
+ s.execute("file.new", &json!({"width": 400, "height": 400})).unwrap();
+ set_pref(&mut s, "realTimeDrawing", json!(false));
+ s.begin_interaction("Bad").unwrap();
+ s.doc_mut().unwrap().interaction.as_mut().unwrap().preview = Some(("no.such.command".into(), json!({})));
+ s.apply_actions(vec![vectorcraft_tools::Action::Commit]).unwrap();
+ assert!(s.doc().unwrap().interaction.is_none());
+}
+
+/// A deferred commit applies preview warnings to the UI, as live previews do.
+#[test]
+fn deferred_commit_forwards_preview_warnings() {
+ let mut s = Session::new();
+ s.execute("file.new", &json!({"width": 400, "height": 400})).unwrap();
+ let rect = s.execute("shape.rectangle", &json!({"x": 100, "y": 100, "width": 200, "height": 200})).unwrap();
+ let text = s.execute("text.create", &json!({"x": 300, "y": 200, "text": "Hi"})).unwrap();
+ s.execute("select.set", &json!({"ids": [rect["id"], text["id"]]})).unwrap();
+ set_pref(&mut s, "realTimeDrawing", json!(false));
+ s.begin_interaction("Bloat").unwrap();
+ let p = json!({"tool": "bloat", "points": [[290.0, 200.0]], "width": 200.0, "height": 200.0});
+ s.doc_mut().unwrap().interaction.as_mut().unwrap().preview = Some(("object.liquify".into(), p));
+ let ui = s.apply_actions(vec![vectorcraft_tools::Action::Commit]).unwrap();
+ assert!(ui.iter().any(|r| matches!(r, UiRequest::Status(m) if m.contains("type"))), "{ui:?}");
+}
+
/// File Handling › Use Low Resolution Proxy for Linked EPS (#394): off by default; toggling it does
/// not replace full-resolution pixels already in the document.
#[test]
diff --git a/crates/engine/src/tooling.rs b/crates/engine/src/tooling.rs
index 0068ccd82..067aaf806 100644
--- a/crates/engine/src/tooling.rs
+++ b/crates/engine/src/tooling.rs
@@ -1,8 +1,10 @@
//! Hosting the active tool: pointer/key events → actions → commands.
use serde_json::{Map, Value};
+use vectorcraft_doc::Selection;
use vectorcraft_geom::Point;
use vectorcraft_tools::distort::perspective::widget::WidgetPlace;
+use vectorcraft_tools::draw2::FEEDBACK;
use vectorcraft_tools::{Action, Cursor, Mods, Overlay, PointerEvent, PointerKind, Tool, ToolContext, ToolKey, settings};
use crate::{EngineError, Prefs, Result, Session};
@@ -450,11 +452,15 @@ impl Session {
v.extend(self.with_tool_cx(view, |_, cx| g.overlays(cx)));
self.ruler_guide = Some(g);
}
+ let deferred_preview = self.unapplied_interaction_preview();
if let Some(d) = self.active() {
let w = self.prefs.perspective_widget;
let place = w.show.then_some(WidgetPlace { screen: view.screen.as_ref(), corner: w.position });
v.splice(0..0, vectorcraft_tools::distort::perspective::grid_overlays_in(&d.doc, 1.0 / view.zoom.max(1e-9), place));
}
+ if let Some((cmd, p)) = deferred_preview {
+ v.extend(self.deferred_preview_overlays_from_command(&cmd, &p));
+ }
v
}
@@ -562,19 +568,49 @@ impl Session {
for a in acts {
match a {
Action::Begin(label) => self.begin_interaction(&label)?,
- Action::Preview(cmd, p) => match self.preview(&cmd, &p) {
- Ok(v) => {
- if let Some(w) = v.get("warning").and_then(Value::as_str)
- && !ui.iter().any(|r| matches!(r, UiRequest::Status(s) if s == w))
- {
- ui.push(UiRequest::Status(w.to_string()));
+ Action::Preview(cmd, p) => {
+ // Performance › Real-time Drawing and Editing (#394): off, remember the latest
+ // params and apply them once on Commit instead of every move.
+ if !self.prefs.real_time_drawing {
+ self.clear_deferred_overlay_cache();
+ let st = self.doc_mut()?;
+ if let Some(it) = &mut st.interaction {
+ it.preview = Some((cmd, p));
+ }
+ continue;
+ }
+ self.clear_deferred_overlay_cache();
+ match self.preview(&cmd, &p) {
+ Ok(v) => {
+ if let Some(w) = v.get("warning").and_then(Value::as_str)
+ && !ui.iter().any(|r| matches!(r, UiRequest::Status(s) if s == w))
+ {
+ ui.push(UiRequest::Status(w.to_string()));
+ }
}
+ Err(e) => log::warn!("preview {cmd}: {e}"),
}
- Err(e) => log::warn!("preview {cmd}: {e}"),
- },
+ }
// The drag is over: the dabs of a Liquify stroke have no further use.
Action::Commit => {
self.liquify_stroke = None;
+ let deferred = self.unapplied_interaction_preview();
+ if let Some((cmd, p)) = deferred {
+ match self.preview(&cmd, &p) {
+ Ok(v) => {
+ if let Some(w) = v.get("warning").and_then(Value::as_str)
+ && !ui.iter().any(|r| matches!(r, UiRequest::Status(s) if s == w))
+ {
+ ui.push(UiRequest::Status(w.to_string()));
+ }
+ }
+ Err(e) => {
+ log::warn!("preview {cmd}: {e}");
+ self.cancel_interaction()?;
+ continue;
+ }
+ }
+ }
self.commit_interaction()?
}
Action::Cancel => {
@@ -598,4 +634,50 @@ impl Session {
}
Ok(ui)
}
+
+ /// Canvas feedback while Real-time Drawing is off: run the pending preview command once, take
+ /// outlines from the objects it touched, then put the document back at the interaction snapshot.
+ fn deferred_preview_overlays_from_command(&mut self, cmd: &str, p: &Value) -> Vec<Overlay> {
+ if self.deferred_overlay_cache.as_ref().is_some_and(|(c, params, _)| c == cmd && params == p) {
+ return self.deferred_overlay_cache.as_ref().map(|(_, _, o)| o.clone()).unwrap_or_default();
+ }
+ let (snapshot, selection, revision, paint, interaction_fields) = {
+ let Some(st) = self.active() else { return vec![] };
+ let Some(it) = st.interaction.as_ref() else { return vec![] };
+ if !std::sync::Arc::ptr_eq(&it.doc, &st.doc) {
+ return vec![];
+ }
+ let interaction_fields = (it.preview.clone(), it.copies.clone(), it.perspective_again.clone());
+ (st.doc.clone(), st.selection.clone(), st.revision, self.pending_paint.clone(), interaction_fields)
+ };
+ let overlays = if self.preview(cmd, p).is_ok() {
+ self.active().map(|st| outlines_for_selection(&st.doc, &st.selection)).unwrap_or_default()
+ } else {
+ vec![]
+ };
+ if let Ok(st) = self.doc_mut() {
+ st.doc = snapshot;
+ st.selection = selection;
+ st.revision = revision;
+ if let Some(it) = &mut st.interaction {
+ it.preview = interaction_fields.0;
+ it.copies = interaction_fields.1;
+ it.perspective_again = interaction_fields.2;
+ }
+ }
+ self.pending_paint = paint;
+ self.deferred_overlay_cache = Some((cmd.to_string(), p.clone(), overlays.clone()));
+ overlays
+ }
+}
+
+fn outlines_for_selection(doc: &vectorcraft_doc::Document, selection: &Selection) -> Vec<Overlay> {
+ selection
+ .objects
+ .iter()
+ .filter_map(|&id| {
+ let n = doc.node(id)?;
+ vectorcraft_render::drawn_outline(doc, n).map(|(path, _)| Overlay::Path { path, color: FEEDBACK, width: 1.0, dashed: false })
+ })
+ .collect()
}