VectorCraft: An open-source, vector art tool written by scratch in pure Rust
refactor(engine): move lib.rs items to {command_sets,doc_state,error,history,interaction,prefs,sanity,session,session/documents,session/edit,session/execute,session/undo}.rs
aionggef991b9c8a46
diff --git a/crates/engine/src/command_sets.rs b/crates/engine/src/command_sets.rsnew file mode 100644index 000000000..8f3f35528--- /dev/null+++ b/crates/engine/src/command_sets.rs@@ -0,0 +1,115 @@+use super::*;++/// The commands that act on the active artboard (#693), which the app passes as their `artboard`:+/// Paste in Place, in Front and in Back paste onto it, Align to Artboard aligns to it, Distribute+/// Objects and Distribute Spacing with Align to Artboard distribute objects across it, and All on+/// Active Artboard selects on it. A `command.batch` given `artboard` passes it on to each of their+/// steps that names none.+pub const ON_ACTIVE_ARTBOARD: [&str; 7] = [+ "edit.pasteInPlace",+ "edit.pasteInFront",+ "edit.pasteInBack",+ "object.align",+ "object.distribute",+ "object.distributeSpacing",+ "select.allOnArtboard",+];++/// The commands that resize the artboards the app passes (Object › Artboards): the app passes the+/// selected artboards to Fit to Artwork Bounds as its `indices`, and the active artboard to Fit to+/// Selected Art as its `index`. A `command.batch` given `artboard` passes it on, as `index`, to+/// each of their steps that names none.+pub const FIT_ACTIVE_ARTBOARD: [&str; 2] = ["artboard.fitToArt", "artboard.fitToSelection"];++/// `(command, param)` pairs the journal records only so a replay reproduces the original run+/// (dates from the clock: `cmd::clock_date`; the artboards the app passes to the+/// [`ON_ACTIVE_ARTBOARD`] and [`FIT_ACTIVE_ARTBOARD`] commands and to a batch); an action leaves+/// them out ([`Session::journal_for_action`]).+const REPLAY_ONLY: [(&str, &str); 14] = [+ ("file.new", "created"),+ ("document.save", "modified"),+ ("file.saveAs", "modified"),+ ("edit.pasteInPlace", "artboard"),+ ("edit.pasteInFront", "artboard"),+ ("edit.pasteInBack", "artboard"),+ ("object.align", "artboard"),+ ("object.distribute", "artboard"),+ ("object.distributeSpacing", "artboard"),+ ("artboard.fitToArt", "index"),+ ("artboard.fitToArt", "indices"),+ ("artboard.fitToSelection", "index"),+ ("select.allOnArtboard", "artboard"),+ ("command.batch", "artboard"),+];++/// `p`, the params of command `id`, without its [`REPLAY_ONLY`] values (a batch: its steps').+pub(crate) fn strip_replay_only(id: &str, p: &mut Value) {+ let strip = |id: &str, p: &mut Value| {+ if let Value::Object(m) = p {+ m.retain(|k, _| !REPLAY_ONLY.iter().any(|&(c, key)| c == id && key == k));+ }+ };+ strip(id, p);+ // Batches don't nest: one level of steps.+ if id == "command.batch"+ && let Some(Value::Array(steps)) = p.get_mut("commands")+ {+ for step in steps {+ let id = step.get("command").and_then(Value::as_str).unwrap_or_default().to_string();+ if let Some(p) = step.get_mut("params") {+ strip(&id, p);+ }+ }+ }+}++/// Commands that act on the selection and take `ids` by selecting them first (`select.set`, with+/// its checks), then running as on the selection: the result and the selection afterwards are the+/// menu command's (#2130).+pub(crate) const SELECTS_GIVEN_IDS: &[&str] = &[+ "edit.duplicate",+ "object.arrange.bringForward",+ "object.arrange.bringToFront",+ "object.arrange.sendBackward",+ "object.arrange.sendToBack",+ "object.arrange.sendToCurrentLayer",+ "object.clippingMask.make",+ "object.clippingMask.release",+ "object.compoundPath.make",+ "object.compoundPath.release",+ "object.group",+ "object.hide",+ "object.lock",+ "object.move",+ "object.pathfinder.crop",+ "object.pathfinder.divide",+ "object.pathfinder.exclude",+ "object.pathfinder.intersect",+ "object.pathfinder.merge",+ "object.pathfinder.minusBack",+ "object.pathfinder.minusFront",+ "object.pathfinder.outline",+ "object.pathfinder.trap",+ "object.pathfinder.trim",+ "object.pathfinder.unite",+ "object.reflect",+ "object.rotate",+ "object.scale",+ "object.shear",+ "object.ungroup",+];++/// The non-empty `ids` given to a command whose params description names `ids` as a key (the+/// key callers outside the app may pass it, [`cmd::params::takes_key`]), or its `id` as `ids` of+/// one when no `ids` are given and the description takes `id` so+/// ([`cmd::params::id_stands_for_ids`]), as [`cmd::targets`] reads them.+pub(crate) fn given_ids(description: &'static str, params: &Value) -> Option<Vec<NodeId>> {+ if !cmd::params::takes_key(description, "ids") {+ return None;+ }+ match params.get("ids").filter(|v| !v.is_null()) {+ Some(_) => cmd::ids_param(params, "ids"),+ None => cmd::id_param(params, "id").filter(|_| cmd::params::id_stands_for_ids(description)).map(|id| vec![id]),+ }+ .filter(|ids| !ids.is_empty())+}diff --git a/crates/engine/src/doc_state.rs b/crates/engine/src/doc_state.rsnew file mode 100644index 000000000..403d771d7--- /dev/null+++ b/crates/engine/src/doc_state.rs@@ -0,0 +1,465 @@+use super::error::{EngineError, Result};+use super::history::{History, HistoryEntry};+use super::interaction::{Interaction, LastTransform, UndoGroup};+use super::*;++/// Per-document editing state.+#[derive(Clone, Debug)]+pub struct DocState {+ pub doc: Arc<Document>,+ pub selection: Selection,+ pub history: History,+ pub path: Option<String>,+ /// Increments on every change (also selection and view-only changes); UIs re-render when it+ /// moves. Not a dirty flag: see [`DocState::is_dirty`].+ pub revision: u64,+ /// The document as last saved (or opened). Structural sharing makes "unchanged" a pointer+ /// comparison, and undoing back to the saved state counts as clean.+ pub(crate) saved_doc: Arc<Document>,+ /// The documents that changes that are not edits to save replaced ([`DocState::same_content`]).+ unsaved_changes: SameContent,+ /// The layer new art goes into (the "current layer" in the Layers panel).+ pub active_layer: Option<NodeId>,+ /// The rows highlighted in the Layers panel (layers, sublayers, groups or objects, in the order+ /// they were clicked): what the panel's Duplicate, Delete, Merge, Options… and similar act on.+ /// Panel state, not art selection: not saved, not undoable (`layer.setCurrent`,+ /// `layer.highlight`).+ pub layer_rows: Vec<NodeId>,+ /// The variable highlighted in the Variables panel: what its Delete, Options… and Select+ /// Bound Object act on. Panel state, not art selection: not saved, not undoable+ /// (`variable.highlight`). A name, so renaming a variable moves the highlight with it.+ pub variables_highlight: Option<String>,+ /// Isolation mode container.+ pub isolation: Option<NodeId>,+ /// Select › Start Global Edit: the objects edited together until Stop Global Edit or Escape+ /// ([`cmd::globaledit`]). Editing state: not saved, not undoable.+ pub global_edit: Option<cmd::globaledit::GlobalEdit>,+ pub interaction: Option<Interaction>,+ /// Edits made while this is open are one undo step (a scrubbed numeric field).+ pub undo_group: Option<UndoGroup>,+ /// For Object → Transform → Transform Again (⌘D): what the last transformation was. A+ /// transform command keeps the `copy`, `typeAreas` and `patterns` it used, and `strokes` and+ /// `corners` when it scales; a drag keeps the params of its last preview with the values that+ /// preview noted ([`Session::note_journal`]).+ pub last_transform: Option<LastTransform>,+ /// What Select → Reselect repeats: the last selection command, its params and the objects+ /// selected when it ran (a Same command's reference objects).+ pub last_selection_cmd: Option<(String, Value, Vec<NodeId>)>,+ /// The saved selection last recalled (`select.recall`), which Select → Update Selection+ /// changes. It is not saved with the file, and a recall is not an undo step.+ pub recalled_selection: RecalledSelection,+ /// Process-unique id of this open document (tab indices shift when tabs close).+ pub uid: u64,+ /// View Opacity Mask (Alt-click the mask thumbnail): the masked object whose mask the canvas+ /// shows alone, in greyscale, while that mask is edited (see [`DocState::shown_mask`]).+ pub mask_view: Option<NodeId>,+ /// View → Show Transparency Grid, per document (saved view state, not undoable).+ pub transparency_grid: bool,+ /// The format Save writes ([`cmd::fileio::SAVE_FORMATS`]): the one the document was opened+ /// from or last saved as.+ pub format: &'static str,+ /// That format's options as last saved (SVG options for SVG, the Save PDF settings for PDF;+ /// empty for native files): Save reuses them and `file.formatOptions` reads them back.+ pub save_options: serde_json::Map<String, Value>,+ /// The ids of the document's artboards, in order, when `save_options` were stored: the+ /// artboards their `artboard`, `artboards` and `range` named by number then+ /// ([`cmd::fileio::remembered_save_options`]).+ pub save_artboards: Vec<u32>,+ /// Opened from an older native file (former name or format version): the title says+ /// "[Converted]" and Save asks for a new name instead of overwriting it.+ pub converted: bool,+ /// The view saved into native files (`Document::last_view`); the UI keeps it current before a+ /// save and restores it when the document opens.+ pub view: Option<vectorcraft_doc::SavedView>,+ /// Restored by Data Recovery: the title says "[Recovered]" and Save asks where to save it+ /// (suggesting `path`, the file it was copied from) instead of overwriting that file.+ pub recovered: bool,+ /// The document's Data Recovery copy, once one was written ([`cmd::recovery`]).+ pub recovery: Option<cmd::recovery::RecoveryCopy>,+ /// View → Show Print Tiling, per document (view state: not saved, not undoable).+ pub print_tiling: bool,+ /// The rows open in the Layers panel (view state: not undoable; native files keep it).+ pub layers_open: OpenRows,+ /// The file this document was read from, and what reading it left out (hidden text, art or+ /// layers it could not read): writing the document over that file would lose those for good,+ /// so an export or save to it asks first ([`cmd::fileio::check_not_lossy_overwrite`]). Not saved.+ pub imported_from: Option<String>,+ pub import_losses: Vec<String>,+ /// Transform Again after a perspective move or scale (Perspective Selection tool): the+ /// `perspective.transform` params it repeats. `None` once an ordinary transform follows.+ pub last_perspective: Option<Value>,+ /// The folders a confined (automation) caller that opened or made the document may read: the+ /// paths the document links to are looked at within them later too, when the Links panel+ /// asks about a link outside any caller's scope.+ pub opened_by: Option<Arc<file_access::AutomationRoots>>,+}++static NEXT_DOC_UID: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(1);++/// The rows open in the Layers panel: the layers, sublayers and groups that show what they hold.+/// A document opens with the ones it was saved with ([`Document::layers_open`]), else with only+/// its top-level layers open (a `.ai` another app wrote opens with none open).+#[derive(Clone, Debug, Default)]+pub struct OpenRows {+ ids: std::collections::HashSet<NodeId>,+ /// Counts the changes, so views can keep what they work out from the open rows.+ generation: u64,+}++impl OpenRows {+ /// The rows `saved` in a file, else `doc`'s top-level layers.+ fn new(doc: &Document, saved: Option<Vec<NodeId>>) -> Self {+ let ids = match saved {+ Some(ids) => ids.into_iter().collect(),+ None => doc.layers.iter().map(|l| l.id).collect(),+ };+ Self { ids, generation: 0 }+ }+ pub fn contains(&self, id: NodeId) -> bool {+ self.ids.contains(&id)+ }+ /// Open or close row `id`.+ pub fn set(&mut self, id: NodeId, open: bool) {+ let changed = if open { self.ids.insert(id) } else { self.ids.remove(&id) };+ self.generation += u64::from(changed);+ }+ /// Changes so far: the same number means the same open rows.+ pub fn generation(&self) -> u64 {+ self.generation+ }+ /// What a native file keeps of the open rows: those of `doc` that hold others, in id order;+ /// `None` when they are the default (only the top-level layers).+ pub fn saved(&self, doc: &Document) -> Option<Vec<NodeId>> {+ let mut ids = vec![];+ doc.walk(|n| {+ if n.children().is_some() && self.ids.contains(&n.id) {+ ids.push(n.id);+ }+ });+ ids.sort_unstable();+ let mut layers: Vec<NodeId> = doc.layers.iter().map(|l| l.id).collect();+ layers.sort_unstable();+ (ids != layers).then_some(ids)+ }+}++/// The saved selection last recalled, which Select → Update Selection changes. The Select commands+/// give each saved selection an id for the session and keep the ids for every version of the+/// document's saved selections they make or read, so the recalled one is found again after Edit+/// Selection…, Undo and Redo. A version that nothing holds any more (neither the document nor its+/// undo history) is dropped the next time a version is added.+#[derive(Clone, Debug, Default)]+pub struct RecalledSelection {+ /// The recalled saved selection's id.+ id: Option<u64>,+ /// Each version of the saved selections (identified by its allocation), with the id of each saved+ /// selection in it.+ versions: Vec<(std::sync::Weak<Vec<vectorcraft_doc::SavedSelection>>, Vec<u64>)>,+ /// The last id given.+ last: u64,+}++impl RecalledSelection {+ /// The ids of `list`'s saved selections; a version not met before gets new ones.+ pub(crate) fn ids(&mut self, list: &vectorcraft_doc::Shared<Vec<vectorcraft_doc::SavedSelection>>) -> Vec<u64> {+ let version = vectorcraft_doc::Shared::downgrade(list);+ if let Some((_, ids)) = self.versions.iter().find(|(v, _)| v.ptr_eq(&version)) {+ return ids.clone();+ }+ let ids: Vec<u64> = (0..list.len()).map(|_| self.new_id()).collect();+ self.remember(list, ids.clone());+ ids+ }+ /// An id no saved selection has had.+ pub(crate) fn new_id(&mut self) -> u64 {+ self.last += 1;+ self.last+ }+ /// Keep `ids` as those of `list`'s saved selections, dropping versions nothing holds any more.+ pub(crate) fn remember(&mut self, list: &vectorcraft_doc::Shared<Vec<vectorcraft_doc::SavedSelection>>, ids: Vec<u64>) {+ let version = vectorcraft_doc::Shared::downgrade(list);+ self.versions.retain(|(v, _)| v.strong_count() > 0 && !v.ptr_eq(&version));+ self.versions.push((version, ids));+ }+ /// Recall the saved selection at `index` in `list`.+ pub(crate) fn recall(&mut self, list: &vectorcraft_doc::Shared<Vec<vectorcraft_doc::SavedSelection>>, index: usize) {+ self.id = self.ids(list).get(index).copied();+ }+ /// Where the recalled saved selection is in `list`, if `list` holds it.+ pub fn index_in(&self, list: &vectorcraft_doc::Shared<Vec<vectorcraft_doc::SavedSelection>>) -> Option<usize> {+ let id = self.id?;+ let version = vectorcraft_doc::Shared::downgrade(list);+ let (_, ids) = self.versions.iter().find(|(v, _)| v.ptr_eq(&version))?;+ ids.iter().position(|&x| x == id).filter(|&i| i < list.len())+ }+}++/// The documents that changes that are not edits to save (Puppet Warp pins dropped, Edit Text ended,+/// type laid out again after a font scan) replaced, each counted as having the content of the+/// document it was replaced by ([`DocState::change_unsaved`]). A document that nothing holds any+/// more is dropped the next time one is added.+#[derive(Clone, Debug, Default)]+struct SameContent {+ /// The document the last such change made.+ now: std::sync::Weak<Document>,+ /// The documents with its content that such changes replaced, oldest first.+ before: Vec<std::sync::Weak<Document>>,+}++impl SameContent {+ /// Note that `now` replaced `before` without a change to its content.+ fn replaced(&mut self, before: std::sync::Weak<Document>, now: &Arc<Document>) {+ if !self.now.ptr_eq(&before) {+ self.before.clear();+ }+ self.before.retain(|d| d.strong_count() > 0);+ if before.strong_count() > 0 {+ self.before.push(before);+ }+ self.now = Arc::downgrade(now);+ }+ /// Whether `doc` is one of the documents with the content of `now`.+ fn holds(&self, now: &Arc<Document>, doc: &Arc<Document>) -> bool {+ std::ptr::eq(self.now.as_ptr(), Arc::as_ptr(now)) && self.before.iter().any(|d| std::ptr::eq(d.as_ptr(), Arc::as_ptr(doc)))+ }+}++impl DocState {+ pub fn new(mut doc: Document, path: Option<String>) -> Self {+ let active_layer = doc.default_layer();+ // Saved view state lives here while the document is open (saves write it back).+ let view = doc.last_view.take();+ let transparency_grid = std::mem::take(&mut doc.transparency_grid);+ let saved_open = doc.layers_open.take();+ let layers_open = OpenRows::new(&doc, saved_open);+ let doc = Arc::new(doc);+ Self {+ saved_doc: doc.clone(),+ unsaved_changes: SameContent::default(),+ doc,+ selection: Selection::default(),+ history: History { limit: 500, ..Default::default() },+ path,+ revision: 1,+ active_layer,+ layer_rows: vec![],+ variables_highlight: None,+ isolation: None,+ global_edit: None,+ interaction: None,+ undo_group: None,+ last_transform: None,+ last_selection_cmd: None,+ recalled_selection: RecalledSelection::default(),+ uid: NEXT_DOC_UID.fetch_add(1, std::sync::atomic::Ordering::Relaxed),+ mask_view: None,+ transparency_grid,+ format: "vectorcraft",+ save_options: Default::default(),+ save_artboards: vec![],+ converted: false,+ view,+ recovered: false,+ recovery: None,+ print_tiling: false,+ layers_open,+ imported_from: None,+ import_losses: vec![],+ last_perspective: None,+ opened_by: file_access::current(),+ }+ }+ /// Unsaved changes: the document differs from the saved one (selection changes and changes that+ /// are not edits to save don't count, [`DocState::same_content`]).+ pub fn is_dirty(&self) -> bool {+ !self.same_content(&self.saved_doc)+ }+ /// Record the current document as saved.+ pub fn mark_saved(&mut self) {+ self.saved_doc = self.doc.clone();+ }+ /// Record `snapshot` (the document as a background save took it) as saved: edits made since+ /// keep the document modified.+ pub fn mark_saved_as(&mut self, snapshot: &Arc<Document>) {+ self.saved_doc = snapshot.clone();+ }+ /// Whether `doc` counts as having the content of the document now: it is the document, or one+ /// that changes that are not edits to save replaced since ([`DocState::change_unsaved`]).+ pub fn same_content(&self, doc: &Arc<Document>) -> bool {+ Arc::ptr_eq(&self.doc, doc) || self.unsaved_changes.holds(&self.doc, doc)+ }+ /// Make a change that is not an edit to save with `f`, without an undo step: editing state that+ /// is never saved, or type laid out again after a font scan (which can also refit the frame of+ /// Auto Size area type). A saved document stays saved, and a save or recovery copy taken of the+ /// document before counts as having its content ([`DocState::same_content`]).+ pub(crate) fn change_unsaved(&mut self, f: impl FnOnce(&mut Arc<Document>)) {+ let saved = !self.is_dirty();+ let before = Arc::downgrade(&self.doc);+ f(&mut self.doc);+ if !std::ptr::eq(before.as_ptr(), Arc::as_ptr(&self.doc)) {+ self.unsaved_changes.replaced(before, &self.doc);+ }+ if saved {+ self.mark_saved();+ }+ }+ /// Keep what interaction `it` (taken from this document) changed, as one undo step.+ pub(crate) fn keep_interaction(&mut self, it: Interaction) {+ if !Arc::ptr_eq(&it.doc, &self.doc) {+ let selection = match self.history.undo.last() {+ Some(l) if l.selection == it.selection => l.selection.clone(),+ _ => it.selection,+ };+ self.push_undo(it.label, it.doc, selection);+ self.revision += 1;+ }+ }+ /// Record an undo step: `doc` and `selection` as they were before an edit (the document now is+ /// the one after it). In an undo group only the group's first edit records one: the edits+ /// after it extend that step.+ pub(crate) fn push_undo(&mut self, mut label: String, doc: Arc<Document>, selection: Arc<Selection>) {+ if let Some(g) = &mut self.undo_group {+ let recorded = |first: &Arc<Document>| self.history.undo.last().is_some_and(|l| Arc::ptr_eq(&l.doc, first));+ if g.first.as_ref().is_some_and(recorded) {+ self.history.recost_last(&self.doc);+ self.history.trim();+ return;+ }+ g.first = Some(doc.clone());+ if let Some(l) = &g.label {+ label = l.clone();+ }+ }+ let e = HistoryEntry::kept(label, doc, selection, &self.doc);+ self.history.undo.push(e);+ self.history.redo.clear();+ self.history.trim();+ }+ /// End the interaction in progress, undoing what it changed.+ pub(crate) fn undo_interaction(&mut self) {+ if let Some(it) = self.interaction.take() {+ self.doc = it.doc;+ self.selection = Arc::unwrap_or_clone(it.selection);+ self.sync_new_art();+ cmd::globaledit::follow_history(self);+ self.active_layer = it.active_layer;+ self.layer_rows = it.layer_rows;+ self.variables_highlight = it.variables_highlight;+ self.isolation = it.isolation;+ self.revision += 1;+ }+ }+ /// Count the document as modified, as if never saved (a document restored by Data Recovery).+ pub fn mark_unsaved(&mut self) {+ self.saved_doc = Arc::new(Document::new(1.0, 1.0));+ }+ /// Deselect the art on a locked artboard, except new art ([`Document::new_art`]). New art+ /// becomes the objects of layers on a locked artboard that hold selected objects (a group for+ /// its selected members) and that an edit made (those not in `before`, the document before+ /// it), or that held objects selected in `was` that were new art (`old`, the new art of that+ /// selection), or were inside new art in `before` (the members of an ungrouped group). New art+ /// that a selection leaves out, or that leaves the locked artboards, is protected from then+ /// on. The selection and the document get the new art; the document's changes in place, so a+ /// selection change doesn't replace the document.+ pub(crate) fn protect_locked_artboards(&mut self, was: &[NodeId], old: &std::collections::HashSet<NodeId>, before: Option<&Document>) {+ let new_art: std::collections::HashSet<NodeId> = {+ let (doc, locks) = (&self.doc, self.doc.locked_artboards());+ if locks.is_empty() {+ Default::default()+ } else {+ // `was` and `old` name the objects of the document they were selected in.+ let then = before.unwrap_or(doc);+ let was: std::collections::HashSet<NodeId> =+ was.iter().filter_map(|o| then.layer_object(*o)).map(|n| n.id).filter(|o| old.contains(o)).collect();+ let selected: Vec<(NodeId, &vectorcraft_doc::Node)> =+ self.selection.objects.iter().filter_map(|o| doc.layer_object(*o).map(|n| (*o, n))).collect();+ // One walk of the document before the edit finds where the selected objects were;+ // the objects the edit made aren't in it.+ let paths = before.filter(|_| !selected.is_empty()).map(|b| b.index_paths(selected.iter().flat_map(|(o, n)| [*o, n.id])));+ let new = |o: NodeId, object: NodeId| {+ was.contains(&object)+ || before.zip(paths.as_ref()).is_some_and(|(b, p)| {+ !p.contains_key(&object) || p.get(&o).and_then(|p| b.layer_object_at(p)).is_some_and(|n| was.contains(&n.id))+ })+ };+ selected.into_iter().filter(|(o, n)| new(*o, n.id) && locks.overlaps(n)).map(|(_, n)| n.id).collect()+ }+ };+ if new_art != *self.selection.new_art {+ self.selection.new_art = Arc::new(new_art);+ }+ self.sync_new_art();+ self.selection.deselect_on_locked_artboards(&self.doc);+ }+ /// Give the document the selection's new art ([`Selection::new_art`]), less the objects the+ /// selection no longer holds: after Undo, Redo or a failed batch brings back a document and+ /// a selection, and after a command that changed the selection directly.+ pub(crate) fn sync_new_art(&mut self) {+ if !self.selection.new_art.is_empty() {+ let held: std::collections::HashSet<NodeId> =+ self.selection.objects.iter().filter_map(|o| self.doc.layer_object(*o)).map(|n| n.id).collect();+ if !self.selection.new_art.is_subset(&held) {+ self.selection.new_art = Arc::new(self.selection.new_art.intersection(&held).copied().collect());+ }+ }+ let doc = self.doc.new_art.get();+ if !Arc::ptr_eq(&doc, &self.selection.new_art) && *doc != *self.selection.new_art {+ self.doc.new_art.set(self.selection.new_art.clone());+ }+ }+ pub fn title(&self) -> String {+ let name = self+ .path+ .as_deref()+ .and_then(|p| std::path::Path::new(p).file_name())+ .map(|n| n.to_string_lossy().to_string())+ .unwrap_or_else(|| self.doc.title.clone());+ if self.converted {+ format!("{} [Converted]", cmd::fileio::file_stem(&name))+ } else if self.recovered {+ format!("{} [Recovered]", cmd::fileio::file_stem(&name))+ } else {+ name+ }+ }+ /// Where new art is inserted: the isolation container, else the active layer.+ /// The current layer, if the remembered id still names a layer (ids are reused after undo).+ pub fn current_layer(&self) -> Option<NodeId> {+ self.active_layer.filter(|l| self.doc.node(*l).is_some_and(|n| n.is_layer()))+ }+ pub fn insertion_parent(&self) -> Option<NodeId> {+ // Ids are reused after undo (the id counter is part of the document), so a remembered+ // layer or isolated group must still be one: a pasted group must never land in a path.+ if let Some(i) = self.isolation+ && self.doc.node(i).is_some_and(|n| matches!(n.kind, NodeKind::Group { .. } | NodeKind::Layer { .. }))+ {+ return Some(i);+ }+ // A single object isolated: new art goes beside it, in its group or layer.+ if let Some(p) = self.isolation.filter(|i| self.doc.node(*i).is_some_and(|n| !n.is_container())).and_then(|i| self.doc.parent_of(i))+ && self.doc.node(p).is_some_and(|n| matches!(n.kind, NodeKind::Group { .. } | NodeKind::Layer { .. }))+ {+ return Some(p);+ }+ // A sublayer takes new art only while it and the layers around it are shown and unlocked.+ self.active_layer.filter(|l| self.doc.node(*l).is_some_and(|n| n.is_layer()) && self.doc.is_editable(*l)).or_else(|| self.doc.default_layer())+ }+ /// [`Self::insertion_parent`] for new art, which a locked or hidden layer never takes: an error+ /// when no layer is shown and unlocked, so the art is refused rather than hidden or locked away.+ pub fn target_parent(&self) -> Result<Option<NodeId>> {+ match self.insertion_parent() {+ Some(p) if !self.doc.is_editable(p) => Err(EngineError::Other("the target layer is locked or hidden".into())),+ parent => Ok(parent),+ }+ }+ /// The highlighted Layers panel rows that still exist (ids are reused after undo, so a+ /// remembered row must still be in the document).+ pub fn highlighted_rows(&self) -> Vec<NodeId> {+ self.layer_rows.iter().copied().filter(|id| self.doc.node(*id).is_some()).collect()+ }+ /// The object whose opacity mask View Opacity Mask shows ([`DocState::mask_view`]): only while+ /// its mask is being edited, so leaving editing by any route (undo, deleting the object) ends it.+ pub fn shown_mask(&self) -> Option<NodeId> {+ self.mask_view.filter(|id| self.doc.mask_edit.is_some_and(|m| m.object == *id))+ }+}diff --git a/crates/engine/src/error.rs b/crates/engine/src/error.rsnew file mode 100644index 000000000..f894e516a--- /dev/null+++ b/crates/engine/src/error.rs@@ -0,0 +1,40 @@+use super::*;++#[derive(Debug, thiserror::Error)]+pub enum EngineError {+ #[error("unknown command `{0}`")]+ UnknownCommand(String),+ /// An unknown command id, with the command id it most likely misspells.+ #[error("unknown command `{0}`; did you mean `{1}`?")]+ UnknownCommandNear(String, String),+ #[error("command `{0}` is not available right now: {1}")]+ Disabled(String, String),+ #[error("invalid parameters for `{cmd}`: {msg}")]+ BadParams { cmd: String, msg: String },+ #[error("no active document")]+ NoDocument,+ #[error("no such object {0}")]+ NoNode(NodeId),+ #[error("{0}")]+ Other(String),+ /// The caller asked for the command to stop ([`cancel`]). It changed nothing.+ #[error("cancelled; nothing was changed")]+ Cancelled,+ /// A bug: the command panicked. The document was rolled back to its state before the command.+ #[error("internal error in `{cmd}`: {msg} (the document was left as it was before; please report this bug)")]+ Internal { cmd: String, msg: String },+}++impl From<cancel::Cancelled> for EngineError {+ fn from(_: cancel::Cancelled) -> Self {+ EngineError::Cancelled+ }+}++impl From<vectorcraft_doc::DocError> for EngineError {+ fn from(e: vectorcraft_doc::DocError) -> Self {+ EngineError::Other(e.to_string())+ }+}++pub type Result<T> = std::result::Result<T, EngineError>;diff --git a/crates/engine/src/history.rs b/crates/engine/src/history.rsnew file mode 100644index 000000000..f82ba3079--- /dev/null+++ b/crates/engine/src/history.rs@@ -0,0 +1,168 @@+use super::*;++/// One undo step.+#[derive(Clone, Debug)]+pub struct HistoryEntry {+ pub label: String,+ /// The document as it was. It keeps no lookup cache ([`Document::drop_lookup_cache`]): a+ /// table per step would add up, and undoing builds it again once.+ pub doc: Arc<Document>,+ /// The selection as it was, shared with the neighbouring steps that have the same one.+ pub selection: Arc<Selection>,+ /// Roughly the memory this step keeps of its own: what of `doc` the step after it (or the+ /// document now) doesn't share ([`Document::retained_bytes`]).+ pub bytes: usize,+ /// The same the other way round: what that next state keeps that `doc` doesn't share. Undoing+ /// (redoing) this step makes a step that keeps the next state: this is its `bytes`.+ next_bytes: usize,+ /// Which document the figures were taken against (its address): the next state.+ next: usize,+ /// The template and name `label` was made from ([`Session::edit_named`]).+ pub(crate) named: Option<NamedStep>,+}++/// A step name made by filling the `{name}` placeholder of a template with a name+/// ([`Session::edit_named`]).+#[derive(Clone, Debug, PartialEq, Eq)]+pub struct NamedStep {+ /// The English template, with one `{name}` placeholder (`Apply {name}`).+ pub template: &'static str,+ /// The name in the placeholder, as the document holds it (a style's name).+ pub name: String,+ /// The name is one VectorCraft gives (`[Normal Character Style]`), not one the user typed.+ pub built_in: bool,+}++impl NamedStep {+ /// The step name: the template with the name in its placeholder.+ pub fn label(&self) -> String {+ self.template.replace("{name}", &self.name)+ }+}++impl HistoryEntry {+ /// A step keeping `doc` and `selection`, as they were before the edit that made `next`.+ pub(crate) fn kept(label: String, doc: Arc<Document>, selection: Arc<Selection>, next: &Document) -> Self {+ doc.drop_lookup_cache();+ let (bytes, next_bytes) = doc.retained_bytes_each(next);+ HistoryEntry { label, doc, selection, bytes, next_bytes, next: std::ptr::from_ref(next) as usize, named: None }+ }++ /// The template and name the step's label was made from, while the label is still the one+ /// they make: `None` for a step named any other way, and for one whose label was changed+ /// since it was recorded.+ pub fn named(&self) -> Option<&NamedStep> {+ self.named.as_ref().filter(|n| n.label() == self.label)+ }++ /// The step that undoing (redoing) the step `costs` came from makes: it keeps `doc`, the+ /// document before the undo, whose next state is now `now` (that step's document). Its figures+ /// are that step's the other way round when `doc` is still the document they were taken+ /// against (nothing replaced it since), so undo and redo needn't walk the documents again. A+ /// change made to it in place without an undo step (a setting, a refresh) goes unnoticed: a+ /// small error, for an estimate.+ pub(crate) fn turned(label: String, doc: Arc<Document>, selection: Arc<Selection>, now: &Arc<Document>, costs: StepCosts) -> Self {+ if costs.next != Arc::as_ptr(&doc) as usize {+ return Self::kept(label, doc, selection, now);+ }+ doc.drop_lookup_cache();+ HistoryEntry { label, doc, selection, bytes: costs.next_bytes, next_bytes: costs.bytes, next: Arc::as_ptr(now) as usize, named: None }+ }++ /// The figures [`HistoryEntry::turned`] reuses.+ pub(crate) fn costs(&self) -> StepCosts {+ StepCosts { bytes: self.bytes, next_bytes: self.next_bytes, next: self.next }+ }+}++/// A step's memory figures ([`HistoryEntry::costs`]).+#[derive(Clone, Copy, Debug)]+pub(crate) struct StepCosts {+ bytes: usize,+ next_bytes: usize,+ next: usize,+}++/// The undo history of a document: bounded by a number of steps (Preferences › Performance ›+/// History States) and by the memory the steps keep ([`History::byte_budget`]).+#[derive(Clone, Debug)]+pub struct History {+ pub undo: Vec<HistoryEntry>,+ pub redo: Vec<HistoryEntry>,+ /// Maximum undo depth (Illustrator has no hard limit; snapshots are cheap here).+ pub limit: usize,+ /// About the most memory the steps may keep ([`HistoryEntry::bytes`]): past it the oldest+ /// steps go, but never the last [`History::MIN_STEPS`] undo (and redo) steps.+ pub byte_budget: usize,+}++impl Default for History {+ fn default() -> Self {+ History { undo: vec![], redo: vec![], limit: 0, byte_budget: default_history_budget() }+ }+}++impl History {+ /// Undo (and redo) steps kept whatever memory they take.+ pub const MIN_STEPS: usize = 8;++ /// Roughly the memory the steps keep of their own ([`HistoryEntry::bytes`]).+ pub fn bytes(&self) -> usize {+ self.undo.iter().chain(&self.redo).map(|e| e.bytes).sum()+ }++ /// Let the oldest steps go while over the step limit or the memory budget: undo steps first+ /// (the oldest), then redo steps (the furthest ahead).+ pub fn trim(&mut self) {+ let over = self.undo.len().saturating_sub(self.limit);+ if over > 0 {+ self.undo.drain(..over);+ }+ let mut total = self.bytes();+ if total <= self.byte_budget {+ return;+ }+ let mut n = 0;+ while total > self.byte_budget && self.undo.len() - n > Self::MIN_STEPS {+ total -= self.undo.get(n).map_or(0, |e| e.bytes);+ n += 1;+ }+ self.undo.drain(..n);+ let mut n = 0;+ while total > self.byte_budget && self.redo.len() - n > Self::MIN_STEPS {+ total -= self.redo.get(n).map_or(0, |e| e.bytes);+ n += 1;+ }+ self.redo.drain(..n);+ }++ /// Estimate the newest undo step again, its next state now being `now` (the steps after it were+ /// merged into it, or an undo group extended it).+ pub(crate) fn recost_last(&mut self, now: &Document) {+ if let Some(e) = self.undo.last_mut() {+ (e.bytes, e.next_bytes) = e.doc.retained_bytes_each(now);+ e.next = std::ptr::from_ref(now) as usize;+ }+ }+}++/// The default [`History::byte_budget`]: an eighth of the machine's memory where it is known+/// (Linux), at most 1 GiB (the figure elsewhere); 256 MiB on the web, whose memory is small.+pub fn default_history_budget() -> usize {+ const MAX: usize = 1 << 30;+ if cfg!(target_arch = "wasm32") {+ return 256 << 20;+ }+ static BUDGET: std::sync::OnceLock<usize> = std::sync::OnceLock::new();+ *BUDGET.get_or_init(|| physical_memory().map_or(MAX, |m| (m / 8).clamp(64 << 20, MAX)))+}++/// The machine's memory, where cheap to learn without platform calls.+fn physical_memory() -> Option<usize> {+ if !cfg!(target_os = "linux") {+ return None;+ }+ let info = std::fs::read_to_string("/proc/meminfo").ok()?;+ let kb: usize = info.lines().find_map(|l| l.strip_prefix("MemTotal:"))?.trim().trim_end_matches("kB").trim().parse().ok()?;+ kb.checked_mul(1024)+}diff --git a/crates/engine/src/interaction.rs b/crates/engine/src/interaction.rsnew file mode 100644index 000000000..986e9e566--- /dev/null+++ b/crates/engine/src/interaction.rs@@ -0,0 +1,86 @@+use super::*;++/// An in-progress drag: the snapshot the previews are applied to.+#[derive(Clone, Debug)]+pub struct Interaction {+ pub label: String,+ pub doc: Arc<Document>,+ /// The selection the previews start from (shared, so a preview frame copies nothing).+ pub selection: Arc<Selection>,+ pub preview: Option<(String, Value)>,+ /// Per-document state restored on cancel (current layer, highlighted Layers panel rows,+ /// isolation).+ pub active_layer: Option<NodeId>,+ pub layer_rows: Vec<NodeId>,+ pub variables_highlight: Option<String>,+ pub isolation: Option<NodeId>,+ /// The perspective transform the previews make (`perspective.transform` params): Transform+ /// Again repeats it once the drag is committed.+ pub perspective_again: Option<Value>,+ /// A transform or a perspective edit with `copy` keeps the copies it made of the snapshot here+ /// ([`PreviewCopies`]).+ pub(crate) copies: Option<Arc<PreviewCopies>>,+}++/// What Object → Transform → Transform Again (⌘D) repeats ([`SessionState::last_transform`]).+#[derive(Clone, Debug, PartialEq)]+pub enum LastTransform {+ /// The last transform command's matrix, and the options Transform Again passes with it.+ Matrix(Affine, Value),+ /// The last Transform Each's parameters: each object transforms about its own bounds, so the+ /// repeat runs the command on the selection of the moment rather than one matrix.+ Each(Value),+}++/// This holds the copies that a transform or a perspective edit with `copy` made of an+/// interaction's snapshot ([`cmd::object::apply_transform`]; `persp_edit` and `plane_move` in+/// `cmd::distortcmds`). A later transform or perspective edit with `copy` of the same objects,+/// while the document is still that snapshot, starts from `doc` and transforms only the copies.+#[derive(Debug)]+pub(crate) struct PreviewCopies {+ /// The copies were made from this snapshot.+ pub(crate) from: Arc<Document>,+ /// The transform or perspective edit copied these objects.+ pub(crate) roots: Vec<NodeId>,+ /// This is `from` with the copies added, untransformed.+ pub(crate) doc: Arc<Document>,+ /// This is the selection after copying, with the copies selected.+ pub(crate) selection: Selection,+ /// These are the copies' ids, in the order of `roots`.+ pub(crate) ids: Vec<NodeId>,+}++/// An open undo group ([`Session::begin_undo_group`]): the edits made in it are one undo step.+#[derive(Clone, Debug)]+pub struct UndoGroup {+ /// The document before the group's first edit, as the undo step that edit recorded keeps it.+ pub(crate) first: Option<Arc<Document>>,+ /// The numbers of the journal entries made in the group's document while it was open: a canceled+ /// group drops them. An entry that changed the active document has the index of the document it+ /// left active, and a canceled group turns it into that change.+ pub(crate) journal: Vec<(usize, Option<usize>)>,+ /// For each `command.batch` entry in `journal`, the steps of its `commands` that belong to the+ /// group (by number), each with the index of the document it left active when it changed the+ /// active document: a canceled group drops those steps and keeps the batch's other ones.+ pub(crate) steps: Vec<BatchSteps>,+ /// The undo step's name; else the first edit's.+ pub(crate) label: Option<String>,+}++/// A `command.batch` journal entry's number and the steps of it that belong to an undo group, each+/// with the index of the document it left active when it changed the active document+/// ([`UndoGroup::steps`]).+pub(crate) type BatchSteps = (usize, Vec<(usize, Option<usize>)>);++/// One undo step begun with [`Session::begin_undo_scope`], which [`Session::end_undo_scope`] ends.+#[derive(Clone, Debug)]+pub struct UndoScope {+ /// The document ([`DocState::uid`]).+ pub(crate) uid: u64,+ /// The journal's length when the scope began.+ pub(crate) journal: usize,+ /// When the document's undo group was open already: the document, its selection and the document+ /// that the group's undo step keeps, as they were when the scope began; `None` when the scope+ /// opened the group.+ pub(crate) joined: Option<(Arc<Document>, Selection, Option<Arc<Document>>)>,+}diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rsindex 8312ad56f..ebae936f8 100644--- a/crates/engine/src/lib.rs+++ b/crates/engine/src/lib.rs@@ -40,1335 +40,10 @@ pub use vectorcraft_doc::cancel;pub use vectorcraft_pathops::{SIMPLIFY_LEVEL, simplify_level_tolerance};pub use vectorcraft_tools as tools;-#[derive(Debug, thiserror::Error)]-pub enum EngineError {- #[error("unknown command `{0}`")]- UnknownCommand(String),- /// An unknown command id, with the command id it most likely misspells.- #[error("unknown command `{0}`; did you mean `{1}`?")]- UnknownCommandNear(String, String),- #[error("command `{0}` is not available right now: {1}")]- Disabled(String, String),- #[error("invalid parameters for `{cmd}`: {msg}")]- BadParams { cmd: String, msg: String },- #[error("no active document")]- NoDocument,- #[error("no such object {0}")]- NoNode(NodeId),- #[error("{0}")]- Other(String),- /// The caller asked for the command to stop ([`cancel`]). It changed nothing.- #[error("cancelled; nothing was changed")]- Cancelled,- /// A bug: the command panicked. The document was rolled back to its state before the command.- #[error("internal error in `{cmd}`: {msg} (the document was left as it was before; please report this bug)")]- Internal { cmd: String, msg: String },-}--impl From<cancel::Cancelled> for EngineError {- fn from(_: cancel::Cancelled) -> Self {- EngineError::Cancelled- }-}--impl From<vectorcraft_doc::DocError> for EngineError {- fn from(e: vectorcraft_doc::DocError) -> Self {- EngineError::Other(e.to_string())- }-}--pub type Result<T> = std::result::Result<T, EngineError>;--/// One undo step.-#[derive(Clone, Debug)]-pub struct HistoryEntry {- pub label: String,- /// The document as it was. It keeps no lookup cache ([`Document::drop_lookup_cache`]): a- /// table per step would add up, and undoing builds it again once.- pub doc: Arc<Document>,- /// The selection as it was, shared with the neighbouring steps that have the same one.- pub selection: Arc<Selection>,- /// Roughly the memory this step keeps of its own: what of `doc` the step after it (or the- /// document now) doesn't share ([`Document::retained_bytes`]).- pub bytes: usize,- /// The same the other way round: what that next state keeps that `doc` doesn't share. Undoing- /// (redoing) this step makes a step that keeps the next state: this is its `bytes`.- next_bytes: usize,- /// Which document the figures were taken against (its address): the next state.- next: usize,- /// The template and name `label` was made from ([`Session::edit_named`]).- named: Option<NamedStep>,-}--/// A step name made by filling the `{name}` placeholder of a template with a name-/// ([`Session::edit_named`]).-#[derive(Clone, Debug, PartialEq, Eq)]-pub struct NamedStep {- /// The English template, with one `{name}` placeholder (`Apply {name}`).- pub template: &'static str,- /// The name in the placeholder, as the document holds it (a style's name).- pub name: String,- /// The name is one VectorCraft gives (`[Normal Character Style]`), not one the user typed.- pub built_in: bool,-}--impl NamedStep {- /// The step name: the template with the name in its placeholder.- pub fn label(&self) -> String {- self.template.replace("{name}", &self.name)- }-}--impl HistoryEntry {- /// A step keeping `doc` and `selection`, as they were before the edit that made `next`.- pub(crate) fn kept(label: String, doc: Arc<Document>, selection: Arc<Selection>, next: &Document) -> Self {- doc.drop_lookup_cache();- let (bytes, next_bytes) = doc.retained_bytes_each(next);- HistoryEntry { label, doc, selection, bytes, next_bytes, next: std::ptr::from_ref(next) as usize, named: None }- }-- /// The template and name the step's label was made from, while the label is still the one- /// they make: `None` for a step named any other way, and for one whose label was changed- /// since it was recorded.- pub fn named(&self) -> Option<&NamedStep> {- self.named.as_ref().filter(|n| n.label() == self.label)- }-- /// The step that undoing (redoing) the step `costs` came from makes: it keeps `doc`, the- /// document before the undo, whose next state is now `now` (that step's document). Its figures- /// are that step's the other way round when `doc` is still the document they were taken- /// against (nothing replaced it since), so undo and redo needn't walk the documents again. A- /// change made to it in place without an undo step (a setting, a refresh) goes unnoticed: a- /// small error, for an estimate.- pub(crate) fn turned(label: String, doc: Arc<Document>, selection: Arc<Selection>, now: &Arc<Document>, costs: StepCosts) -> Self {- if costs.next != Arc::as_ptr(&doc) as usize {- return Self::kept(label, doc, selection, now);- }- doc.drop_lookup_cache();- HistoryEntry { label, doc, selection, bytes: costs.next_bytes, next_bytes: costs.bytes, next: Arc::as_ptr(now) as usize, named: None }- }-- /// The figures [`HistoryEntry::turned`] reuses.- pub(crate) fn costs(&self) -> StepCosts {- StepCosts { bytes: self.bytes, next_bytes: self.next_bytes, next: self.next }- }-}--/// A step's memory figures ([`HistoryEntry::costs`]).-#[derive(Clone, Copy, Debug)]-pub(crate) struct StepCosts {- bytes: usize,- next_bytes: usize,- next: usize,-}--/// The undo history of a document: bounded by a number of steps (Preferences › Performance ›-/// History States) and by the memory the steps keep ([`History::byte_budget`]).-#[derive(Clone, Debug)]-pub struct History {- pub undo: Vec<HistoryEntry>,- pub redo: Vec<HistoryEntry>,- /// Maximum undo depth (Illustrator has no hard limit; snapshots are cheap here).- pub limit: usize,- /// About the most memory the steps may keep ([`HistoryEntry::bytes`]): past it the oldest- /// steps go, but never the last [`History::MIN_STEPS`] undo (and redo) steps.- pub byte_budget: usize,-}--impl Default for History {- fn default() -> Self {- History { undo: vec![], redo: vec![], limit: 0, byte_budget: default_history_budget() }- }-}--impl History {- /// Undo (and redo) steps kept whatever memory they take.- pub const MIN_STEPS: usize = 8;-- /// Roughly the memory the steps keep of their own ([`HistoryEntry::bytes`]).- pub fn bytes(&self) -> usize {- self.undo.iter().chain(&self.redo).map(|e| e.bytes).sum()- }-- /// Let the oldest steps go while over the step limit or the memory budget: undo steps first- /// (the oldest), then redo steps (the furthest ahead).- pub fn trim(&mut self) {- let over = self.undo.len().saturating_sub(self.limit);- if over > 0 {- self.undo.drain(..over);- }- let mut total = self.bytes();- if total <= self.byte_budget {- return;- }- let mut n = 0;- while total > self.byte_budget && self.undo.len() - n > Self::MIN_STEPS {- total -= self.undo.get(n).map_or(0, |e| e.bytes);- n += 1;- }- self.undo.drain(..n);- let mut n = 0;- while total > self.byte_budget && self.redo.len() - n > Self::MIN_STEPS {- total -= self.redo.get(n).map_or(0, |e| e.bytes);- n += 1;- }- self.redo.drain(..n);- }-- /// Estimate the newest undo step again, its next state now being `now` (the steps after it were- /// merged into it, or an undo group extended it).- pub(crate) fn recost_last(&mut self, now: &Document) {- if let Some(e) = self.undo.last_mut() {- (e.bytes, e.next_bytes) = e.doc.retained_bytes_each(now);- e.next = std::ptr::from_ref(now) as usize;- }- }-}--/// The default [`History::byte_budget`]: an eighth of the machine's memory where it is known-/// (Linux), at most 1 GiB (the figure elsewhere); 256 MiB on the web, whose memory is small.-pub fn default_history_budget() -> usize {- const MAX: usize = 1 << 30;- if cfg!(target_arch = "wasm32") {- return 256 << 20;- }- static BUDGET: std::sync::OnceLock<usize> = std::sync::OnceLock::new();- *BUDGET.get_or_init(|| physical_memory().map_or(MAX, |m| (m / 8).clamp(64 << 20, MAX)))-}--/// The machine's memory, where cheap to learn without platform calls.-fn physical_memory() -> Option<usize> {- if !cfg!(target_os = "linux") {- return None;- }- let info = std::fs::read_to_string("/proc/meminfo").ok()?;- let kb: usize = info.lines().find_map(|l| l.strip_prefix("MemTotal:"))?.trim().trim_end_matches("kB").trim().parse().ok()?;- kb.checked_mul(1024)-}--/// An in-progress drag: the snapshot the previews are applied to.-#[derive(Clone, Debug)]-pub struct Interaction {- pub label: String,- pub doc: Arc<Document>,- /// The selection the previews start from (shared, so a preview frame copies nothing).- pub selection: Arc<Selection>,- pub preview: Option<(String, Value)>,- /// Per-document state restored on cancel (current layer, highlighted Layers panel rows,- /// isolation).- pub active_layer: Option<NodeId>,- pub layer_rows: Vec<NodeId>,- pub variables_highlight: Option<String>,- pub isolation: Option<NodeId>,- /// The perspective transform the previews make (`perspective.transform` params): Transform- /// Again repeats it once the drag is committed.- pub perspective_again: Option<Value>,- /// A transform or a perspective edit with `copy` keeps the copies it made of the snapshot here- /// ([`PreviewCopies`]).- pub(crate) copies: Option<Arc<PreviewCopies>>,-}--/// What Object → Transform → Transform Again (⌘D) repeats ([`SessionState::last_transform`]).-#[derive(Clone, Debug, PartialEq)]-pub enum LastTransform {- /// The last transform command's matrix, and the options Transform Again passes with it.- Matrix(Affine, Value),- /// The last Transform Each's parameters: each object transforms about its own bounds, so the- /// repeat runs the command on the selection of the moment rather than one matrix.- Each(Value),-}--/// This holds the copies that a transform or a perspective edit with `copy` made of an-/// interaction's snapshot ([`cmd::object::apply_transform`]; `persp_edit` and `plane_move` in-/// `cmd::distortcmds`). A later transform or perspective edit with `copy` of the same objects,-/// while the document is still that snapshot, starts from `doc` and transforms only the copies.-#[derive(Debug)]-pub(crate) struct PreviewCopies {- /// The copies were made from this snapshot.- pub(crate) from: Arc<Document>,- /// The transform or perspective edit copied these objects.- pub(crate) roots: Vec<NodeId>,- /// This is `from` with the copies added, untransformed.- pub(crate) doc: Arc<Document>,- /// This is the selection after copying, with the copies selected.- pub(crate) selection: Selection,- /// These are the copies' ids, in the order of `roots`.- pub(crate) ids: Vec<NodeId>,-}--/// An open undo group ([`Session::begin_undo_group`]): the edits made in it are one undo step.-#[derive(Clone, Debug)]-pub struct UndoGroup {- /// The document before the group's first edit, as the undo step that edit recorded keeps it.- first: Option<Arc<Document>>,- /// The numbers of the journal entries made in the group's document while it was open: a canceled- /// group drops them. An entry that changed the active document has the index of the document it- /// left active, and a canceled group turns it into that change.- journal: Vec<(usize, Option<usize>)>,- /// For each `command.batch` entry in `journal`, the steps of its `commands` that belong to the- /// group (by number), each with the index of the document it left active when it changed the- /// active document: a canceled group drops those steps and keeps the batch's other ones.- steps: Vec<BatchSteps>,- /// The undo step's name; else the first edit's.- label: Option<String>,-}--/// A `command.batch` journal entry's number and the steps of it that belong to an undo group, each-/// with the index of the document it left active when it changed the active document-/// ([`UndoGroup::steps`]).-type BatchSteps = (usize, Vec<(usize, Option<usize>)>);--/// One undo step begun with [`Session::begin_undo_scope`], which [`Session::end_undo_scope`] ends.-#[derive(Clone, Debug)]-pub struct UndoScope {- /// The document ([`DocState::uid`]).- uid: u64,- /// The journal's length when the scope began.- journal: usize,- /// When the document's undo group was open already: the document, its selection and the document- /// that the group's undo step keeps, as they were when the scope began; `None` when the scope- /// opened the group.- joined: Option<(Arc<Document>, Selection, Option<Arc<Document>>)>,-}--/// Per-document editing state.-#[derive(Clone, Debug)]-pub struct DocState {- pub doc: Arc<Document>,- pub selection: Selection,- pub history: History,- pub path: Option<String>,- /// Increments on every change (also selection and view-only changes); UIs re-render when it- /// moves. Not a dirty flag: see [`DocState::is_dirty`].- pub revision: u64,- /// The document as last saved (or opened). Structural sharing makes "unchanged" a pointer- /// comparison, and undoing back to the saved state counts as clean.- saved_doc: Arc<Document>,- /// The documents that changes that are not edits to save replaced ([`DocState::same_content`]).- unsaved_changes: SameContent,- /// The layer new art goes into (the "current layer" in the Layers panel).- pub active_layer: Option<NodeId>,- /// The rows highlighted in the Layers panel (layers, sublayers, groups or objects, in the order- /// they were clicked): what the panel's Duplicate, Delete, Merge, Options… and similar act on.- /// Panel state, not art selection: not saved, not undoable (`layer.setCurrent`,- /// `layer.highlight`).- pub layer_rows: Vec<NodeId>,- /// The variable highlighted in the Variables panel: what its Delete, Options… and Select- /// Bound Object act on. Panel state, not art selection: not saved, not undoable- /// (`variable.highlight`). A name, so renaming a variable moves the highlight with it.- pub variables_highlight: Option<String>,- /// Isolation mode container.- pub isolation: Option<NodeId>,- /// Select › Start Global Edit: the objects edited together until Stop Global Edit or Escape- /// ([`cmd::globaledit`]). Editing state: not saved, not undoable.- pub global_edit: Option<cmd::globaledit::GlobalEdit>,- pub interaction: Option<Interaction>,- /// Edits made while this is open are one undo step (a scrubbed numeric field).- pub undo_group: Option<UndoGroup>,- /// For Object → Transform → Transform Again (⌘D): what the last transformation was. A- /// transform command keeps the `copy`, `typeAreas` and `patterns` it used, and `strokes` and- /// `corners` when it scales; a drag keeps the params of its last preview with the values that- /// preview noted ([`Session::note_journal`]).- pub last_transform: Option<LastTransform>,- /// What Select → Reselect repeats: the last selection command, its params and the objects- /// selected when it ran (a Same command's reference objects).- pub last_selection_cmd: Option<(String, Value, Vec<NodeId>)>,- /// The saved selection last recalled (`select.recall`), which Select → Update Selection- /// changes. It is not saved with the file, and a recall is not an undo step.- pub recalled_selection: RecalledSelection,- /// Process-unique id of this open document (tab indices shift when tabs close).- pub uid: u64,- /// View Opacity Mask (Alt-click the mask thumbnail): the masked object whose mask the canvas- /// shows alone, in greyscale, while that mask is edited (see [`DocState::shown_mask`]).- pub mask_view: Option<NodeId>,- /// View → Show Transparency Grid, per document (saved view state, not undoable).- pub transparency_grid: bool,- /// The format Save writes ([`cmd::fileio::SAVE_FORMATS`]): the one the document was opened- /// from or last saved as.- pub format: &'static str,- /// That format's options as last saved (SVG options for SVG, the Save PDF settings for PDF;- /// empty for native files): Save reuses them and `file.formatOptions` reads them back.- pub save_options: serde_json::Map<String, Value>,- /// The ids of the document's artboards, in order, when `save_options` were stored: the- /// artboards their `artboard`, `artboards` and `range` named by number then- /// ([`cmd::fileio::remembered_save_options`]).- pub save_artboards: Vec<u32>,- /// Opened from an older native file (former name or format version): the title says- /// "[Converted]" and Save asks for a new name instead of overwriting it.- pub converted: bool,- /// The view saved into native files (`Document::last_view`); the UI keeps it current before a- /// save and restores it when the document opens.- pub view: Option<vectorcraft_doc::SavedView>,- /// Restored by Data Recovery: the title says "[Recovered]" and Save asks where to save it- /// (suggesting `path`, the file it was copied from) instead of overwriting that file.- pub recovered: bool,- /// The document's Data Recovery copy, once one was written ([`cmd::recovery`]).- pub recovery: Option<cmd::recovery::RecoveryCopy>,- /// View → Show Print Tiling, per document (view state: not saved, not undoable).- pub print_tiling: bool,- /// The rows open in the Layers panel (view state: not undoable; native files keep it).- pub layers_open: OpenRows,- /// The file this document was read from, and what reading it left out (hidden text, art or- /// layers it could not read): writing the document over that file would lose those for good,- /// so an export or save to it asks first ([`cmd::fileio::check_not_lossy_overwrite`]). Not saved.- pub imported_from: Option<String>,- pub import_losses: Vec<String>,- /// Transform Again after a perspective move or scale (Perspective Selection tool): the- /// `perspective.transform` params it repeats. `None` once an ordinary transform follows.- pub last_perspective: Option<Value>,- /// The folders a confined (automation) caller that opened or made the document may read: the- /// paths the document links to are looked at within them later too, when the Links panel- /// asks about a link outside any caller's scope.- pub opened_by: Option<Arc<file_access::AutomationRoots>>,-}--static NEXT_DOC_UID: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(1);--/// The rows open in the Layers panel: the layers, sublayers and groups that show what they hold.-/// A document opens with the ones it was saved with ([`Document::layers_open`]), else with only-/// its top-level layers open (a `.ai` another app wrote opens with none open).-#[derive(Clone, Debug, Default)]-pub struct OpenRows {- ids: std::collections::HashSet<NodeId>,- /// Counts the changes, so views can keep what they work out from the open rows.- generation: u64,-}--impl OpenRows {- /// The rows `saved` in a file, else `doc`'s top-level layers.- fn new(doc: &Document, saved: Option<Vec<NodeId>>) -> Self {- let ids = match saved {- Some(ids) => ids.into_iter().collect(),- None => doc.layers.iter().map(|l| l.id).collect(),- };- Self { ids, generation: 0 }- }- pub fn contains(&self, id: NodeId) -> bool {- self.ids.contains(&id)- }- /// Open or close row `id`.- pub fn set(&mut self, id: NodeId, open: bool) {- let changed = if open { self.ids.insert(id) } else { self.ids.remove(&id) };- self.generation += u64::from(changed);- }- /// Changes so far: the same number means the same open rows.- pub fn generation(&self) -> u64 {- self.generation- }- /// What a native file keeps of the open rows: those of `doc` that hold others, in id order;- /// `None` when they are the default (only the top-level layers).- pub fn saved(&self, doc: &Document) -> Option<Vec<NodeId>> {- let mut ids = vec![];- doc.walk(|n| {- if n.children().is_some() && self.ids.contains(&n.id) {- ids.push(n.id);- }- });- ids.sort_unstable();- let mut layers: Vec<NodeId> = doc.layers.iter().map(|l| l.id).collect();- layers.sort_unstable();- (ids != layers).then_some(ids)- }-}--/// The saved selection last recalled, which Select → Update Selection changes. The Select commands-/// give each saved selection an id for the session and keep the ids for every version of the-/// document's saved selections they make or read, so the recalled one is found again after Edit-/// Selection…, Undo and Redo. A version that nothing holds any more (neither the document nor its-/// undo history) is dropped the next time a version is added.-#[derive(Clone, Debug, Default)]-pub struct RecalledSelection {- /// The recalled saved selection's id.- id: Option<u64>,- /// Each version of the saved selections (identified by its allocation), with the id of each saved- /// selection in it.- versions: Vec<(std::sync::Weak<Vec<vectorcraft_doc::SavedSelection>>, Vec<u64>)>,- /// The last id given.- last: u64,-}--impl RecalledSelection {- /// The ids of `list`'s saved selections; a version not met before gets new ones.- pub(crate) fn ids(&mut self, list: &vectorcraft_doc::Shared<Vec<vectorcraft_doc::SavedSelection>>) -> Vec<u64> {- let version = vectorcraft_doc::Shared::downgrade(list);- if let Some((_, ids)) = self.versions.iter().find(|(v, _)| v.ptr_eq(&version)) {- return ids.clone();- }- let ids: Vec<u64> = (0..list.len()).map(|_| self.new_id()).collect();- self.remember(list, ids.clone());- ids- }- /// An id no saved selection has had.- pub(crate) fn new_id(&mut self) -> u64 {- self.last += 1;- self.last- }- /// Keep `ids` as those of `list`'s saved selections, dropping versions nothing holds any more.- pub(crate) fn remember(&mut self, list: &vectorcraft_doc::Shared<Vec<vectorcraft_doc::SavedSelection>>, ids: Vec<u64>) {- let version = vectorcraft_doc::Shared::downgrade(list);- self.versions.retain(|(v, _)| v.strong_count() > 0 && !v.ptr_eq(&version));- self.versions.push((version, ids));- }- /// Recall the saved selection at `index` in `list`.- pub(crate) fn recall(&mut self, list: &vectorcraft_doc::Shared<Vec<vectorcraft_doc::SavedSelection>>, index: usize) {- self.id = self.ids(list).get(index).copied();- }- /// Where the recalled saved selection is in `list`, if `list` holds it.- pub fn index_in(&self, list: &vectorcraft_doc::Shared<Vec<vectorcraft_doc::SavedSelection>>) -> Option<usize> {- let id = self.id?;- let version = vectorcraft_doc::Shared::downgrade(list);- let (_, ids) = self.versions.iter().find(|(v, _)| v.ptr_eq(&version))?;- ids.iter().position(|&x| x == id).filter(|&i| i < list.len())- }-}--/// The documents that changes that are not edits to save (Puppet Warp pins dropped, Edit Text ended,-/// type laid out again after a font scan) replaced, each counted as having the content of the-/// document it was replaced by ([`DocState::change_unsaved`]). A document that nothing holds any-/// more is dropped the next time one is added.-#[derive(Clone, Debug, Default)]-struct SameContent {- /// The document the last such change made.- now: std::sync::Weak<Document>,- /// The documents with its content that such changes replaced, oldest first.- before: Vec<std::sync::Weak<Document>>,-}--impl SameContent {- /// Note that `now` replaced `before` without a change to its content.- fn replaced(&mut self, before: std::sync::Weak<Document>, now: &Arc<Document>) {- if !self.now.ptr_eq(&before) {- self.before.clear();- }- self.before.retain(|d| d.strong_count() > 0);- if before.strong_count() > 0 {- self.before.push(before);- }- self.now = Arc::downgrade(now);- }- /// Whether `doc` is one of the documents with the content of `now`.- fn holds(&self, now: &Arc<Document>, doc: &Arc<Document>) -> bool {- std::ptr::eq(self.now.as_ptr(), Arc::as_ptr(now)) && self.before.iter().any(|d| std::ptr::eq(d.as_ptr(), Arc::as_ptr(doc)))- }-}--impl DocState {- pub fn new(mut doc: Document, path: Option<String>) -> Self {- let active_layer = doc.default_layer();- // Saved view state lives here while the document is open (saves write it back).- let view = doc.last_view.take();- let transparency_grid = std::mem::take(&mut doc.transparency_grid);- let saved_open = doc.layers_open.take();- let layers_open = OpenRows::new(&doc, saved_open);- let doc = Arc::new(doc);- Self {- saved_doc: doc.clone(),- unsaved_changes: SameContent::default(),- doc,- selection: Selection::default(),- history: History { limit: 500, ..Default::default() },- path,- revision: 1,- active_layer,- layer_rows: vec![],- variables_highlight: None,- isolation: None,- global_edit: None,- interaction: None,- undo_group: None,- last_transform: None,- last_selection_cmd: None,- recalled_selection: RecalledSelection::default(),- uid: NEXT_DOC_UID.fetch_add(1, std::sync::atomic::Ordering::Relaxed),- mask_view: None,- transparency_grid,- format: "vectorcraft",- save_options: Default::default(),- save_artboards: vec![],- converted: false,- view,- recovered: false,- recovery: None,- print_tiling: false,- layers_open,- imported_from: None,- import_losses: vec![],- last_perspective: None,- opened_by: file_access::current(),- }- }- /// Unsaved changes: the document differs from the saved one (selection changes and changes that- /// are not edits to save don't count, [`DocState::same_content`]).- pub fn is_dirty(&self) -> bool {- !self.same_content(&self.saved_doc)- }- /// Record the current document as saved.- pub fn mark_saved(&mut self) {- self.saved_doc = self.doc.clone();- }- /// Record `snapshot` (the document as a background save took it) as saved: edits made since- /// keep the document modified.- pub fn mark_saved_as(&mut self, snapshot: &Arc<Document>) {- self.saved_doc = snapshot.clone();- }- /// Whether `doc` counts as having the content of the document now: it is the document, or one- /// that changes that are not edits to save replaced since ([`DocState::change_unsaved`]).- pub fn same_content(&self, doc: &Arc<Document>) -> bool {- Arc::ptr_eq(&self.doc, doc) || self.unsaved_changes.holds(&self.doc, doc)- }- /// Make a change that is not an edit to save with `f`, without an undo step: editing state that- /// is never saved, or type laid out again after a font scan (which can also refit the frame of- /// Auto Size area type). A saved document stays saved, and a save or recovery copy taken of the- /// document before counts as having its content ([`DocState::same_content`]).- pub(crate) fn change_unsaved(&mut self, f: impl FnOnce(&mut Arc<Document>)) {- let saved = !self.is_dirty();- let before = Arc::downgrade(&self.doc);- f(&mut self.doc);- if !std::ptr::eq(before.as_ptr(), Arc::as_ptr(&self.doc)) {- self.unsaved_changes.replaced(before, &self.doc);- }- if saved {- self.mark_saved();- }- }- /// Keep what interaction `it` (taken from this document) changed, as one undo step.- pub(crate) fn keep_interaction(&mut self, it: Interaction) {- if !Arc::ptr_eq(&it.doc, &self.doc) {- let selection = match self.history.undo.last() {- Some(l) if l.selection == it.selection => l.selection.clone(),- _ => it.selection,- };- self.push_undo(it.label, it.doc, selection);- self.revision += 1;- }- }- /// Record an undo step: `doc` and `selection` as they were before an edit (the document now is- /// the one after it). In an undo group only the group's first edit records one: the edits- /// after it extend that step.- fn push_undo(&mut self, mut label: String, doc: Arc<Document>, selection: Arc<Selection>) {- if let Some(g) = &mut self.undo_group {- let recorded = |first: &Arc<Document>| self.history.undo.last().is_some_and(|l| Arc::ptr_eq(&l.doc, first));- if g.first.as_ref().is_some_and(recorded) {- self.history.recost_last(&self.doc);- self.history.trim();- return;- }- g.first = Some(doc.clone());- if let Some(l) = &g.label {- label = l.clone();- }- }- let e = HistoryEntry::kept(label, doc, selection, &self.doc);- self.history.undo.push(e);- self.history.redo.clear();- self.history.trim();- }- /// End the interaction in progress, undoing what it changed.- pub(crate) fn undo_interaction(&mut self) {- if let Some(it) = self.interaction.take() {- self.doc = it.doc;- self.selection = Arc::unwrap_or_clone(it.selection);- self.sync_new_art();- cmd::globaledit::follow_history(self);- self.active_layer = it.active_layer;- self.layer_rows = it.layer_rows;- self.variables_highlight = it.variables_highlight;- self.isolation = it.isolation;- self.revision += 1;- }- }- /// Count the document as modified, as if never saved (a document restored by Data Recovery).- pub fn mark_unsaved(&mut self) {- self.saved_doc = Arc::new(Document::new(1.0, 1.0));- }- /// Deselect the art on a locked artboard, except new art ([`Document::new_art`]). New art- /// becomes the objects of layers on a locked artboard that hold selected objects (a group for- /// its selected members) and that an edit made (those not in `before`, the document before- /// it), or that held objects selected in `was` that were new art (`old`, the new art of that- /// selection), or were inside new art in `before` (the members of an ungrouped group). New art- /// that a selection leaves out, or that leaves the locked artboards, is protected from then- /// on. The selection and the document get the new art; the document's changes in place, so a- /// selection change doesn't replace the document.- fn protect_locked_artboards(&mut self, was: &[NodeId], old: &std::collections::HashSet<NodeId>, before: Option<&Document>) {- let new_art: std::collections::HashSet<NodeId> = {- let (doc, locks) = (&self.doc, self.doc.locked_artboards());- if locks.is_empty() {- Default::default()- } else {- // `was` and `old` name the objects of the document they were selected in.- let then = before.unwrap_or(doc);- let was: std::collections::HashSet<NodeId> =- was.iter().filter_map(|o| then.layer_object(*o)).map(|n| n.id).filter(|o| old.contains(o)).collect();- let selected: Vec<(NodeId, &vectorcraft_doc::Node)> =- self.selection.objects.iter().filter_map(|o| doc.layer_object(*o).map(|n| (*o, n))).collect();- // One walk of the document before the edit finds where the selected objects were;- // the objects the edit made aren't in it.- let paths = before.filter(|_| !selected.is_empty()).map(|b| b.index_paths(selected.iter().flat_map(|(o, n)| [*o, n.id])));- let new = |o: NodeId, object: NodeId| {- was.contains(&object)- || before.zip(paths.as_ref()).is_some_and(|(b, p)| {- !p.contains_key(&object) || p.get(&o).and_then(|p| b.layer_object_at(p)).is_some_and(|n| was.contains(&n.id))- })- };- selected.into_iter().filter(|(o, n)| new(*o, n.id) && locks.overlaps(n)).map(|(_, n)| n.id).collect()- }- };- if new_art != *self.selection.new_art {- self.selection.new_art = Arc::new(new_art);- }- self.sync_new_art();- self.selection.deselect_on_locked_artboards(&self.doc);- }- /// Give the document the selection's new art ([`Selection::new_art`]), less the objects the- /// selection no longer holds: after Undo, Redo or a failed batch brings back a document and- /// a selection, and after a command that changed the selection directly.- pub(crate) fn sync_new_art(&mut self) {- if !self.selection.new_art.is_empty() {- let held: std::collections::HashSet<NodeId> =- self.selection.objects.iter().filter_map(|o| self.doc.layer_object(*o)).map(|n| n.id).collect();- if !self.selection.new_art.is_subset(&held) {- self.selection.new_art = Arc::new(self.selection.new_art.intersection(&held).copied().collect());- }- }- let doc = self.doc.new_art.get();- if !Arc::ptr_eq(&doc, &self.selection.new_art) && *doc != *self.selection.new_art {- self.doc.new_art.set(self.selection.new_art.clone());- }- }- pub fn title(&self) -> String {- let name = self- .path- .as_deref()- .and_then(|p| std::path::Path::new(p).file_name())- .map(|n| n.to_string_lossy().to_string())- .unwrap_or_else(|| self.doc.title.clone());- if self.converted {- format!("{} [Converted]", cmd::fileio::file_stem(&name))- } else if self.recovered {- format!("{} [Recovered]", cmd::fileio::file_stem(&name))- } else {- name- }- }- /// Where new art is inserted: the isolation container, else the active layer.- /// The current layer, if the remembered id still names a layer (ids are reused after undo).- pub fn current_layer(&self) -> Option<NodeId> {- self.active_layer.filter(|l| self.doc.node(*l).is_some_and(|n| n.is_layer()))- }- pub fn insertion_parent(&self) -> Option<NodeId> {- // Ids are reused after undo (the id counter is part of the document), so a remembered- // layer or isolated group must still be one: a pasted group must never land in a path.- if let Some(i) = self.isolation- && self.doc.node(i).is_some_and(|n| matches!(n.kind, NodeKind::Group { .. } | NodeKind::Layer { .. }))- {- return Some(i);- }- // A single object isolated: new art goes beside it, in its group or layer.- if let Some(p) = self.isolation.filter(|i| self.doc.node(*i).is_some_and(|n| !n.is_container())).and_then(|i| self.doc.parent_of(i))- && self.doc.node(p).is_some_and(|n| matches!(n.kind, NodeKind::Group { .. } | NodeKind::Layer { .. }))- {- return Some(p);- }- // A sublayer takes new art only while it and the layers around it are shown and unlocked.- self.active_layer.filter(|l| self.doc.node(*l).is_some_and(|n| n.is_layer()) && self.doc.is_editable(*l)).or_else(|| self.doc.default_layer())- }- /// [`Self::insertion_parent`] for new art, which a locked or hidden layer never takes: an error- /// when no layer is shown and unlocked, so the art is refused rather than hidden or locked away.- pub fn target_parent(&self) -> Result<Option<NodeId>> {- match self.insertion_parent() {- Some(p) if !self.doc.is_editable(p) => Err(EngineError::Other("the target layer is locked or hidden".into())),- parent => Ok(parent),- }- }- /// The highlighted Layers panel rows that still exist (ids are reused after undo, so a- /// remembered row must still be in the document).- pub fn highlighted_rows(&self) -> Vec<NodeId> {- self.layer_rows.iter().copied().filter(|id| self.doc.node(*id).is_some()).collect()- }- /// The object whose opacity mask View Opacity Mask shows ([`DocState::mask_view`]): only while- /// its mask is being edited, so leaving editing by any route (undo, deleting the object) ends it.- pub fn shown_mask(&self) -> Option<NodeId> {- self.mask_view.filter(|id| self.doc.mask_edit.is_some_and(|m| m.object == *id))- }-}-/// Coordinates beyond this (points) are rejected: ~1,400 m, far past Illustrator's large canvas.pub use vectorcraft_doc::MAX_COORD;--/// The commands that act on the active artboard (#693), which the app passes as their `artboard`:-/// Paste in Place, in Front and in Back paste onto it, Align to Artboard aligns to it, Distribute-/// Objects and Distribute Spacing with Align to Artboard distribute objects across it, and All on-/// Active Artboard selects on it. A `command.batch` given `artboard` passes it on to each of their-/// steps that names none.-pub const ON_ACTIVE_ARTBOARD: [&str; 7] = [- "edit.pasteInPlace",- "edit.pasteInFront",- "edit.pasteInBack",- "object.align",- "object.distribute",- "object.distributeSpacing",- "select.allOnArtboard",-];--/// The commands that resize the artboards the app passes (Object › Artboards): the app passes the-/// selected artboards to Fit to Artwork Bounds as its `indices`, and the active artboard to Fit to-/// Selected Art as its `index`. A `command.batch` given `artboard` passes it on, as `index`, to-/// each of their steps that names none.-pub const FIT_ACTIVE_ARTBOARD: [&str; 2] = ["artboard.fitToArt", "artboard.fitToSelection"];--/// `(command, param)` pairs the journal records only so a replay reproduces the original run-/// (dates from the clock: `cmd::clock_date`; the artboards the app passes to the-/// [`ON_ACTIVE_ARTBOARD`] and [`FIT_ACTIVE_ARTBOARD`] commands and to a batch); an action leaves-/// them out ([`Session::journal_for_action`]).-const REPLAY_ONLY: [(&str, &str); 14] = [- ("file.new", "created"),- ("document.save", "modified"),- ("file.saveAs", "modified"),- ("edit.pasteInPlace", "artboard"),- ("edit.pasteInFront", "artboard"),- ("edit.pasteInBack", "artboard"),- ("object.align", "artboard"),- ("object.distribute", "artboard"),- ("object.distributeSpacing", "artboard"),- ("artboard.fitToArt", "index"),- ("artboard.fitToArt", "indices"),- ("artboard.fitToSelection", "index"),- ("select.allOnArtboard", "artboard"),- ("command.batch", "artboard"),-];--/// `p`, the params of command `id`, without its [`REPLAY_ONLY`] values (a batch: its steps').-fn strip_replay_only(id: &str, p: &mut Value) {- let strip = |id: &str, p: &mut Value| {- if let Value::Object(m) = p {- m.retain(|k, _| !REPLAY_ONLY.iter().any(|&(c, key)| c == id && key == k));- }- };- strip(id, p);- // Batches don't nest: one level of steps.- if id == "command.batch"- && let Some(Value::Array(steps)) = p.get_mut("commands")- {- for step in steps {- let id = step.get("command").and_then(Value::as_str).unwrap_or_default().to_string();- if let Some(p) = step.get_mut("params") {- strip(&id, p);- }- }- }-}--/// Is `id` a path made into a guide (View → Guides → Make Guides)?-pub(crate) fn is_guide_path(d: &Document, id: NodeId) -> bool {- d.node(id).is_some_and(|n| matches!(n.kind, NodeKind::Path { guide: true, .. }))-}--/// Deselect the ruler guides and the paths made into guides: while View → Guides → Lock Guides is-/// on, they can't be selected (#1534), whatever selects them. → whether any was selected.-pub(crate) fn deselect_guides(d: &Document, sel: &mut Selection) -> bool {- let paths: Vec<NodeId> = sel.objects.iter().copied().filter(|id| is_guide_path(d, *id)).collect();- let any = !paths.is_empty() || !sel.guides.is_empty();- for id in paths {- sel.remove(id);- }- sel.guides.clear();- sel.key_guide = None;- // A key object kept only for the guides to line up on goes with them.- if sel.key.is_some_and(|k| sel.objects.iter().all(|o| *o == k)) {- sel.key = None;- }- any-}--/// Deselect what the View menu keeps from being selected: the guides while Lock Guides is on-/// ([`deselect_guides`]), and the slices that the Slice Selection tool or a slice command selected-/// ([`Selection::slices`]) while Lock Slices or Hide Slices is on. A selected object that is an-/// object slice stays selected. → whether any was selected.-pub(crate) fn deselect_hidden(menu: &cmd::menucmds::MenuState, d: &Document, sel: &mut Selection) -> bool {- let guides = menu.guides_locked && deselect_guides(d, sel);- let slices = (menu.slices_locked || menu.slices_hidden) && !sel.slices.is_empty();- if slices {- sel.slices.clear();- }- guides || slices-}--/// The error of an edit that would nest objects deeper than [`vectorcraft_doc::MAX_DEPTH`].-pub const TOO_DEEP: &str = "objects can't be nested more than 32 deep";const _: () = assert!(vectorcraft_doc::MAX_DEPTH == 32, "TOO_DEEP (and its catalog rows) names the cap");-/// Cheap sanity check after an edit: artboards and the objects just touched (the selection) must-/// have finite, in-range geometry, so saved files always reload and renderers never see NaN/∞.-fn doc_sane(d: &Document, sel: &Selection) -> bool {- d.ruler_origin.is_finite()- && d.ruler_origin.x.abs() <= MAX_COORD- && d.ruler_origin.y.abs() <= MAX_COORD- && d.artboards.iter().all(|a| rect_in_range(a.rect))- && d.guides.iter().all(|g| g.pos.is_finite() && g.pos.abs() <= MAX_COORD)- && objects_in_range(d, &sel.objects)-}--fn rect_in_range(r: vectorcraft_geom::Rect) -> bool {- [r.x0, r.y0, r.x1, r.y1].iter().all(|v| v.is_finite() && v.abs() <= MAX_COORD)-}--/// Do the objects `ids` have finite geometry within [`MAX_COORD`] (the ones not there pass)?-fn objects_in_range(d: &Document, ids: &[NodeId]) -> bool {- let paths = d.index_paths(ids.iter().copied());- ids.iter().all(|id| paths.get(id).and_then(|p| d.node_at(p)).and_then(|n| n.geometric_bounds()).is_none_or(rect_in_range))-}--/// Where new art goes (Illustrator's drawing modes, Shift+D cycles).-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, serde::Serialize, serde::Deserialize)]-#[serde(rename_all = "lowercase")]-pub enum DrawMode {- #[default]- Normal,- Behind,- Inside,-}--/// Application preferences (Edit → Preferences). Every field is reachable through `prefs.get` /-/// `prefs.set {key, value}` (camelCase keys, validated against [`cmd::prefscmds::PREF_SPECS`]).-#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]-#[serde(default, rename_all = "camelCase")]-pub struct Prefs {- // General- /// Arrow-key nudge distance (General → Keyboard Increment), points.- pub keyboard_increment: f64,- pub constrain_angle: f64,- pub corner_radius: f64,- pub disable_auto_add_delete: bool,- pub use_precise_cursors: bool,- pub show_tool_tips: bool,- pub anti_aliased_artwork: bool,- pub select_same_tint_percent: bool,- pub show_home_screen: bool,- pub use_preview_bounds: bool,- pub display_print_size: bool,- pub double_click_to_isolate: bool,- pub transform_pattern_tiles: bool,- pub scale_corners: bool,- /// Scale Strokes & Effects.- pub scale_strokes: bool,- pub zoom_with_mouse_wheel: bool,- /// A horizontal drag on a numeric field or its label steps its value (#400).- pub scrub_numeric_fields: bool,- /// A two-finger rotation on a Mac trackpad turns the view about the pointer once it reaches 5°.- pub trackpad_rotate_view: bool,- /// Offset for Paste / duplicate (Illustrator pastes to the view centre; we offset by this).- pub paste_offset: f64,- // Selection & Anchor Display- pub selection_tolerance: f64,- pub object_selection_by_path_only: bool,- pub snap_to_point_tolerance: f64,- pub ctrl_click_selects_behind: bool,- pub zoom_to_selection: bool,- pub move_locked_with_artboard: bool,- pub anchor_size: u32,- pub handle_style: String,- pub highlight_anchors_on_hover: bool,- pub show_handles_multiple_anchors: bool,- pub hide_corner_widget_above: f64,- pub pen_rubber_band: bool,- pub curvature_rubber_band: bool,- // Type- pub type_size_increment: f64,- pub tracking_increment: f64,- pub baseline_shift_increment: f64,- pub show_east_asian_options: bool,- pub show_indic_options: bool,- pub type_selection_by_path_only: bool,- pub font_names_in_english: bool,- pub auto_size_area_type: bool,- pub font_preview: bool,- pub font_preview_size: String,- pub recent_fonts_count: u32,- pub missing_glyph_protection: bool,- pub highlight_alternate_glyphs: bool,- /// Type › Highlight Substituted Fonts: on screen, text drawn in a substitute for a missing- /// font is highlighted, in every document (on by default).- pub highlight_substituted_fonts: bool,- pub placeholder_text: bool,- // Units- pub units_general: String,- pub units_stroke: String,- pub units_type: String,- pub units_asian_type: String,- /// Numbers Without Units Are Points: a number typed with no unit into a length field in picas- /// is read in points (on by default; the reference app dims it unless a unit is Picas).- pub numbers_without_units_are_points: bool,- pub identify_objects_by: String,- // Guides & Grid- pub guide_color: String,- pub guide_style: String,- pub grid_color: String,- pub grid_style: String,- pub gridline_every: f64,- pub grid_subdivisions: u32,- pub grids_in_back: bool,- pub show_pixel_grid: bool,- // Smart Guides- pub smart_guide_color: String,- pub alignment_guides: bool,- pub object_highlighting: bool,- pub transform_tools_guides: bool,- pub construction_guides: bool,- pub construction_angles: String,- pub anchor_path_labels: bool,- pub measurement_labels: bool,- pub spacing_guides: bool,- pub distance_guides: bool,- pub snapping_tolerance: f64,- pub snap_tangent: bool,- pub snap_perpendicular: bool,- // Slices- pub show_slice_numbers: bool,- pub slice_line_color: String,- // Hyphenation- pub hyphenation_language: String,- pub hyphenation_exceptions: String,- /// Type › Options › Additional Fonts Folder: a folder (read with its subfolders) whose fonts- /// are listed and used as if installed (#683); empty for none.- pub fonts_folder: String,- // Plug-ins & Scratch Disks- pub plugins_folder: String,- pub scratch_primary: String,- pub scratch_secondary: String,- // User Interface- pub ui_brightness: String,- /// User Interface › Accent Color: the colour of what is on, chosen or focused.- pub ui_accent: String,- /// User Interface › Color Scheme: "modern" (with the accent above) or "classic" (neutral- /// greys and a blue accent).- pub ui_color_scheme: String,- pub canvas_color: String,- pub auto_collapse_icon_panels: bool,- /// User Interface › Show Tool Group Labels: the toolbar's group names (Select, Shapes, Draw…);- /// off (as it ships, #1736), the tools run on from group to group with nothing between them.- pub tool_group_labels: bool,- pub open_documents_as_tabs: bool,- pub large_tabs: bool,- pub ui_scaling: f64,- pub scale_cursor_with_ui: bool,- /// UI language: `auto` (follow the system locale) or a language code such as `en`, `zh-hant`.- /// The list of languages belongs to the shell (`ui-egui` i18n); an unknown code reads as `auto`.- pub interface_language: String,- /// Windows and Linux: use the system's title bar and window buttons instead of the app bar- /// acting as the title bar (tiling window managers, desktops that draw their own decorations).- /// Read when the app starts. macOS always uses the system's.- pub system_title_bar: bool,- // Performance- pub gpu_performance: bool,- pub animated_zoom: bool,- /// Which graphics processor the desktop app asks for at startup (it takes effect after a- /// restart): `automatic`, `lowPower` (the integrated GPU on hybrid-graphics machines) or- /// `highPerformance` (the discrete one). The canvas is rasterized on the CPU and only- /// composited on the GPU, so the integrated GPU is plenty; presenting from the discrete GPU- /// through the integrated one made some hybrid laptops flicker (#306). Automatic is power- /// saving on Windows and macOS and the system's default GPU elsewhere, the one the desktop- /// runs on: a Wayland compositor may not show frames from another GPU (#502). Single-GPU- /// machines are unaffected.- pub gpu_preference: String,- pub history_states: u32,- pub real_time_drawing: bool,- /// Rasterizer worker threads; -1 = automatic.- pub render_threads: i32,- /// Linux: `automatic` opens the window on the session's display server; `x11` opens it through- /// XWayland on a Wayland session, where dropped files arrive (#1151); `x11WithPen` opens it- /// through XWayland only when a pen is attached (#2028). Read when the app starts.- pub linux_display_server: String,- // File Handling- pub background_save: bool,- pub background_export: bool,- pub autosave_recovery: bool,- pub autosave_interval: u32,- pub recovery_folder: String,- pub recovery_off_for_complex: bool,- pub recent_files_count: u32,- pub low_res_proxy_eps: bool,- pub anti_aliased_bitmaps: bool,- pub update_links: String,- // Clipboard Handling- pub copy_as_svg: bool,- pub copy_as_pdf: bool,- pub copy_aicb: bool,- pub aicb_mode: String,- pub paste_text_formatting: String,- // Appearance of Black- pub black_on_screen: String,- pub black_output: String,- // Devices- pub touch_workspace: bool,- pub touch_gestures: bool,- // Graphic Styles panel- /// Override Character Color: a graphic style applied to type replaces its characters' fill- /// and stroke with the style's fills and strokes.- pub override_char_color: bool,- // Pattern editing- /// Object → Pattern → Tile Edge Color (`#rrggbb`): the tile edge and swatch bounds in pattern- /// editing mode.- pub pattern_tile_edge_color: String,- /// Eyedropper Options (`eyedropper.setOptions`; a preference group, see- /// [`cmd::prefscmds::PREF_GROUPS`]).- pub eyedropper: EyedropperOptions,- /// Pathfinder panel › Pathfinder Options (`object.pathfinder.options`; a preference group, see- /// [`cmd::prefscmds::PREF_GROUPS`]).- pub pathfinder: PathfinderOptions,- /// Edit → Transparency Flattener Presets: the user's presets (the built-in ones aren't stored).- /// Not a `prefs.set` key or group (resetting the preferences keeps them): `flattener.presets.*`- /// edit it.- #[serde(skip_serializing_if = "Vec::is_empty")]- pub flattener_presets: Vec<cmd::FlattenerPreset>,- /// Width profiles saved to the Stroke panel's Profile list (`stroke.widthProfile.*`). Not a- /// Preferences dialog field, so it has no [`cmd::prefscmds::PREF_SPECS`] row.- #[serde(skip_serializing_if = "Vec::is_empty")]- pub width_profiles: Vec<vectorcraft_doc::SavedProfile>,- /// General → Use Japanese Crop Marks: the style of Create Trim Marks and Effect → Crop Marks.- pub japanese_crop_marks: bool,- /// Appearance panel → New Art Has Basic Appearance (on): new art takes one fill and stroke;- /// off, the whole appearance of the last selection (`appearance.setNewArtBasic`).- pub new_art_basic: bool,- /// The Color Themes panel's saved themes (`colorTheme.*`): a local library, not a Preferences- /// dialog field, so it has no [`cmd::prefscmds::PREF_SPECS`] row and resetting keeps it.- #[serde(skip_serializing_if = "Vec::is_empty")]- pub color_themes: Vec<cmd::colortheme::ColorTheme>,- /// New Document → Saved: the user's document presets (`file.newPresets.save`). A local- /// library, not a Preferences dialog field: resetting the preferences keeps it.- #[serde(skip_serializing_if = "Vec::is_empty")]- pub new_doc_presets: Vec<cmd::newdoc::DocSettings>,- /// New Document → Recent: the settings of the last documents made (newest first).- #[serde(skip_serializing_if = "Vec::is_empty")]- pub recent_new_docs: Vec<cmd::newdoc::DocSettings>,- /// Edit → PDF Presets: the user's presets (the built-in ones aren't stored). A local library,- /// not a Preferences dialog field: resetting the preferences keeps it; `pdf.preset.*` edit it.- #[serde(skip_serializing_if = "Vec::is_empty")]- pub pdf_presets: Vec<vectorcraft_pdf::PdfPreset>,- /// File → Export for Screens: the user's batch export presets (`document.exportPresets.*`;- /// the built-in ones aren't stored). A local library, not a Preferences dialog field.- #[serde(skip_serializing_if = "Vec::is_empty")]- pub screen_export_presets: Vec<cmd::fileio::ScreenExportPreset>,- // File Handling (continued)- /// Where Save as Template and New from Template start ("" = `Documents/VectorCraft Templates`).- pub templates_folder: String,- /// Open older native files as "<name> [Converted]" so Save asks for a new name.- pub append_converted: bool,- /// File Handling → Use Compression: native saves are gzip-compressed (`document.save- /// {compress}` overrides it).- pub use_compression: bool,- /// Save for Web: the user's presets (the built-in ones aren't stored). A local library, not a- /// Preferences dialog field: resetting the preferences keeps it; `webExport.presets.*` edit it.- #[serde(skip_serializing_if = "Vec::is_empty")]- pub web_export_presets: Vec<cmd::webexport::WebPreset>,- /// Save for Web: the settings the dialog opens on (`webExport.settings`); none until set.- #[serde(skip_serializing_if = "Option::is_none")]- pub web_export_settings: Option<cmd::webexport::WebSettings>,- /// Edit → Print Presets: the user's presets ([Default] isn't stored). A local library, not a- /// Preferences dialog field: resetting the preferences keeps it; `print.presets.*` edit it.- #[serde(skip_serializing_if = "Vec::is_empty")]- pub print_presets: Vec<cmd::printpresets::PrintPreset>,- /// Constrain Width and Height Proportions: the link between W and H in the Transform panel,- /// the Properties panel and the Control bar (their size fields pass `proportional` to- /// `object.setBounds`).- pub constrain_proportions: bool,- /// One Corner Radius field sets every corner of a live rectangle (off: a field per corner).- pub single_corner_radius: bool,- /// The Transform panel menu's Transform Object Only / Transform Pattern Only / Transform Both- /// (`object`, `pattern`, `both`): what the panel's fields, flips and menu flips transform- /// (they pass `objects` and `patterns` to the transform commands). `default` (and any other- /// value), until one is chosen: they pass neither, so patterns follow General › Transform- /// Pattern Tiles (`transformPatternTiles`), as before the menu acted.- pub transform_panel_patterns: String,- /// The Transform panel menu's Use Registration Point for Symbol: with one symbol instance- /// selected, the panel and the Properties panel's Transform section measure and transform it- /// from its symbol's registration point instead of the reference point.- pub use_registration_point_for_symbol: bool,- /// The tools' persistent options by store (a tool id, or a store a family shares: `liquify`- /// holds the Liquify tools' Global Brush Dimensions), see [`vectorcraft_tools::settings`]:- /// kept across tool switches and saved with the preferences. Not a Preferences dialog field:- /// resetting the preferences keeps them; `tool.setOption` edits them.- #[serde(skip_serializing_if = "std::collections::BTreeMap::is_empty")]- pub tool_settings: std::collections::BTreeMap<String, serde_json::Map<String, Value>>,- /// View → Perspective Grid presets: the user's (the built-in ones aren't stored). A local- /// library, not a Preferences dialog field: resetting the preferences keeps it;- /// `perspective.presets.*` edit it.- #[serde(skip_serializing_if = "Vec::is_empty")]- pub perspective_presets: Vec<vectorcraft_tools::distort::perspective::GridDefinition>,- /// Blend Options set with no blend selected: what new blends start with- /// (`object.blend.options`; none: Smooth Color, Align to Page). A tool setting, not a- /// Preferences dialog field: it has no [`cmd::prefscmds::PREF_SPECS`] row and resetting the- /// preferences keeps it.- #[serde(skip_serializing_if = "Option::is_none")]- pub blend_options: Option<vectorcraft_doc::live::BlendDefaults>,- /// Perspective Grid Options (double-click the Perspective Grid tool): whether the Plane- /// Switching Widget shows and where (`perspective.widget.options`).- pub perspective_widget: vectorcraft_tools::distort::perspective::widget::WidgetOptions,- /// What names and codes in other apps' shortcut sets stand for, as the user confirmed them on- /// import (`importMatches.*`). A local library, not a Preferences dialog field: resetting the- /// preferences keeps it.- #[serde(skip_serializing_if = "Vec::is_empty")]- pub import_matches: Vec<cmd::importmatches::ImportMatch>,-}--impl Default for Prefs {- fn default() -> Self {- let s = |v: &str| v.to_string();- Self {- keyboard_increment: 1.0,- constrain_angle: 0.0,- corner_radius: 12.0,- disable_auto_add_delete: false,- use_precise_cursors: false,- show_tool_tips: true,- anti_aliased_artwork: true,- select_same_tint_percent: false,- show_home_screen: true,- use_preview_bounds: false,- display_print_size: false,- double_click_to_isolate: true,- transform_pattern_tiles: false,- scale_corners: false,- scale_strokes: false,- zoom_with_mouse_wheel: false,- scrub_numeric_fields: true,- trackpad_rotate_view: true,- paste_offset: 10.0,- selection_tolerance: 3.0,- object_selection_by_path_only: false,- snap_to_point_tolerance: 2.0,- ctrl_click_selects_behind: true,- zoom_to_selection: true,- move_locked_with_artboard: false,- anchor_size: 3,- handle_style: s("solid"),- highlight_anchors_on_hover: true,- show_handles_multiple_anchors: true,- hide_corner_widget_above: 177.0,- pen_rubber_band: true,- curvature_rubber_band: true,- type_size_increment: 2.0,- tracking_increment: 20.0,- baseline_shift_increment: 2.0,- show_east_asian_options: false,- show_indic_options: false,- type_selection_by_path_only: false,- font_names_in_english: true,- auto_size_area_type: false,- font_preview: true,- font_preview_size: s("medium"),- recent_fonts_count: 10,- missing_glyph_protection: true,- highlight_alternate_glyphs: false,- highlight_substituted_fonts: true,- placeholder_text: true,- units_general: s("points"),- units_stroke: s("points"),- units_type: s("points"),- units_asian_type: s("points"),- numbers_without_units_are_points: true,- identify_objects_by: s("objectName"),- guide_color: s("#4affff"),- guide_style: s("lines"),- grid_color: s("#c8c8c8"),- grid_style: s("lines"),- gridline_every: 72.0,- grid_subdivisions: 8,- grids_in_back: true,- show_pixel_grid: true,- smart_guide_color: s("#ff3dfc"),- alignment_guides: true,- object_highlighting: true,- transform_tools_guides: true,- construction_guides: true,- construction_angles: s(vectorcraft_tools::guides::DEFAULT_CONSTRUCTION_ANGLES),- anchor_path_labels: true,- measurement_labels: true,- spacing_guides: true,- distance_guides: true,- snapping_tolerance: 4.0,- snap_tangent: true,- snap_perpendicular: true,- show_slice_numbers: true,- slice_line_color: s("#ff3f3f"),- hyphenation_language: s("English: USA"),- hyphenation_exceptions: String::new(),- fonts_folder: String::new(),- plugins_folder: String::new(),- scratch_primary: s("Startup"),- scratch_secondary: s("None"),- ui_brightness: s("mediumDark"),- ui_accent: s("coral"),- ui_color_scheme: s("modern"),- canvas_color: s("matchUi"),- auto_collapse_icon_panels: false,- tool_group_labels: false,- open_documents_as_tabs: true,- large_tabs: false,- ui_scaling: 1.0,- scale_cursor_with_ui: false,- interface_language: s("auto"),- system_title_bar: false,- gpu_performance: true,- animated_zoom: true,- gpu_preference: s("automatic"),- history_states: 500,- real_time_drawing: true,- render_threads: -1,- linux_display_server: s("automatic"),- background_save: true,- background_export: true,- autosave_recovery: true,- autosave_interval: 2,- recovery_folder: String::new(),- recovery_off_for_complex: false,- recent_files_count: 20,- low_res_proxy_eps: false,- anti_aliased_bitmaps: false,- update_links: s("askWhenModified"),- copy_as_svg: true,- copy_as_pdf: false,- copy_aicb: false,- aicb_mode: s("preserveAppearance"),- paste_text_formatting: s("keep"),- black_on_screen: s("accurate"),- black_output: s("accurate"),- touch_workspace: true,- touch_gestures: true,- override_char_color: true,- pattern_tile_edge_color: {- let [r, g, b] = vectorcraft_doc::LAYER_COLORS[0].1;- Color::rgb8(r, g, b).to_hex()- },- eyedropper: Default::default(),- pathfinder: Default::default(),- flattener_presets: vec![],- width_profiles: vec![],- japanese_crop_marks: false,- new_art_basic: true,- color_themes: vec![],- new_doc_presets: vec![],- recent_new_docs: vec![],- pdf_presets: vec![],- screen_export_presets: vec![],- templates_folder: String::new(),- append_converted: true,- use_compression: false,- web_export_presets: vec![],- web_export_settings: None,- print_presets: vec![],- constrain_proportions: false,- single_corner_radius: true,- transform_panel_patterns: "default".to_string(),- use_registration_point_for_symbol: false,- tool_settings: Default::default(),- perspective_presets: vec![],- blend_options: None,- perspective_widget: Default::default(),- import_matches: vec![],- }- }-}-pub struct Session {docs: Vec<DocState>,active: Option<usize>,@@ -1545,1048 +220,6 @@ impl Default for Session {}}-impl Session {- /// A session with no document open, the default preferences and the Selection tool. It also- /// installs the hooks the document crate calls back into: the loader and file reader of placed- /// documents, and where an image's effects draw its fills and strokes, for clicks.- pub fn new() -> Self {- // Placed documents are read by the native format's loader.- vectorcraft_doc::placed_document::set_loader(cmd::place::document::read_document);- vectorcraft_doc::placed_document::set_file_reader(cmd::place::document::read_file_again);- vectorcraft_doc::placed_document::set_read_check(|path| file_access::check_read(path).is_ok());- // The background workers of placed documents read files in the scope that asked.- vectorcraft_render::placed_document::set_scope_capture(|| {- let scope = file_access::ScopeHandle::capture();- Box::new(move |f: &mut dyn FnMut()| scope.run(f))- });- // Clicks find an image's own fills and strokes where their effects draw them.- vectorcraft_doc::hit::set_image_paint(vectorcraft_render::effects::image_paint);- // OpenType SVG glyphs are drawn as the SVG importer reads their documents.- vectorcraft_text::set_svg_glyph_reader(vectorcraft_svg::glyph_art);- Self {- docs: vec![],- active: None,- prefs: Prefs::default(),- paint: PaintDefaults::default(),- fill_active: true,- clipboard: Clipboard::default(),- journal: Journal::default(),- tool: vectorcraft_tools::create("selection"),- lender: None,- last_selection_tool: None,- last_view: ViewInfo::default(),- preview_memo: Default::default(),- depth: 0,- tool_panic: None,- tool_resets: 0,- tool_set_since_reset: false,- draw_mode: DrawMode::Normal,- draw_inside: None,- untitled_counter: 0,- menu: Default::default(),- gradient_stop: None,- active_appearance_item: None,- last_solid: Color::WHITE,- last_gradient: GradientPaint::new(Default::default()),- recent_colors: vec![],- pending_paint: None,- swatch_libraries: Default::default(),- freeform_point: None,- style_libraries: Default::default(),- symbol_libraries: Default::default(),- brush_libraries: Default::default(),- libraries: Default::default(),- pdf_preset_dir: None,- profile_dir: None,- plugin_dir: None,- plugin_output: None,- recent_urls: vec![],- ui_language: None,- journal_note: Default::default(),- note_depth: 1,- journal_query: false,- explicit_undo_group: None,- batch_stash: None,- batch_steps: None,- place_hand_off: None,- queue_hand_off: None,- place_cursor_requests: false,- package_hand_off: None,- screens_hand_off: None,- recovery: Default::default(),- in_tool_actions: false,- previewing: false,- envelope_defaults: None,- liquify_stroke: None,- plane_widget_press: false,- pointer_held: false,- ruler_guide: None,- port_marks: Default::default(),- font_search: None,- link_search: None,- search_rules: None,- deferred_overlay_cache: None,- search_threads: None,- link_stamps: Default::default(),- link_scan: None,- global_edit_options: Default::default(),- }- }-- pub fn documents(&self) -> &[DocState] {- &self.docs- }- /// The open document with [`DocState::uid`] `uid` (it may have closed since it was looked up).- pub fn document_mut(&mut self, uid: u64) -> Option<&mut DocState> {- self.docs.iter_mut().find(|d| d.uid == uid)- }- pub fn active_index(&self) -> Option<usize> {- self.active- }- pub fn active(&self) -> Option<&DocState> {- self.active.and_then(|i| self.docs.get(i))- }- pub fn active_mut(&mut self) -> Option<&mut DocState> {- self.active.and_then(|i| self.docs.get_mut(i))- }- pub fn doc(&self) -> Result<&DocState> {- self.active().ok_or(EngineError::NoDocument)- }- pub fn doc_mut(&mut self) -> Result<&mut DocState> {- self.active_mut().ok_or(EngineError::NoDocument)- }- /// Finish the tool's pending work in the current document and give it fresh state, so nothing- /// (e.g. uncommitted typing) leaks into the document we are switching to.- fn reset_tool_for_doc_switch(&mut self) {- if self.active.is_none() {- return;- }- let view = self.last_view;- // The switch goes on whatever the lent tool's last actions did, as for the deactivation.- let _ = self.give_back_tool(view);- let acts = self.with_tool_cx(view, |t, cx| t.deactivate(cx));- let _ = self.apply_actions(acts);- // A batch leaves its interaction open in the document it leaves, to keep or roll back with- // the rest of the batch; anything else in progress (a drag) is cancelled.- if self.batch_stash.is_none() {- let _ = self.cancel_interaction();- }- self.keep_tool_settings();- self.tool = self.make_tool(self.tool.id());- self.tool_resets = self.tool_resets.wrapping_add(1);- self.tool_set_since_reset = false;- }- pub fn set_active(&mut self, index: usize) -> bool {- if index < self.docs.len() {- if self.active != Some(index) {- self.reset_tool_for_doc_switch();- }- self.active = Some(index);- true- } else {- false- }- }- /// The name [`Session::next_untitled`] gives next (New Document's Name field).- pub fn peek_untitled(&self) -> String {- format!("Untitled-{}", self.untitled_counter + 1)- }- pub fn next_untitled(&mut self) -> String {- self.untitled_counter += 1;- format!("Untitled-{}", self.untitled_counter)- }- /// Text layout bounds are a cache (not saved): compute them for a document just read, or- /// selection boxes and hit testing would use the rough estimate until each text is edited, and- /// what is fitted to type's bounds (an envelope warping it) would come out differently. That- /// holds for the type in symbol definitions, pattern tiles, graph designs and opacity masks too,- /// not only in the layers (#1738).- pub(crate) fn refresh_text_bounds(doc: &mut Document) {- // Inline graphics in text take their size from their symbols' art (not saved either).- doc.resolve_inline_art();- let trees = doc.layers.iter_mut().chain(doc.symbols.iter_mut().map(|s| &mut s.art));- let trees = trees.chain(doc.graph_designs.iter_mut().map(|g| &mut g.art));- for tree in trees.chain(doc.patterns.iter_mut().flat_map(|p| p.art.iter_mut())) {- refresh_tree_text_bounds(tree);- }- }- /// Add a document and make it active. Between `edit.undoGroup.begin` and `edit.undoGroup.end`,- /// an undo group with the begun group's name opens in it: here outside a command, and after the- /// command that adds it otherwise ([`Session::execute`]).- pub fn add_document(&mut self, mut doc: Document, path: Option<String>) -> usize {- // Every edit is checked against the document before it, so the first one is within the cap- // (importers and the native reader have seen to theirs already, with a warning).- doc.limit_depth();- Self::refresh_text_bounds(&mut doc);- // Guides from files saved before guides had layers go on a layer.- doc.adopt_guides();- cmd::dimension::conform(&mut doc);- self.reset_tool_for_doc_switch();- let mut st = DocState::new(doc, path);- st.history.limit = self.prefs.history_states as usize;- self.docs.push(st);- let i = self.docs.len() - 1;- self.active = Some(i);- if self.depth == 0- && let Some(label) = self.explicit_undo_group.clone()- {- self.begin_named_undo_group(label);- }- i- }- /// Replace the document in tab `index` (File → Revert): new content, cleared history and- /// selection, saved state. The tab keeps its place, path, format and view.- pub fn replace_document(&mut self, index: usize, mut doc: Document) -> bool {- if index >= self.docs.len() {- return false;- }- doc.limit_depth();- Self::refresh_text_bounds(&mut doc);- doc.adopt_guides();- cmd::dimension::conform(&mut doc);- if self.active == Some(index) {- // Pending tool work (typing, a drag) belongs to the content being thrown away.- self.reset_tool_for_doc_switch();- }- let old = &self.docs[index];- let mut st = DocState::new(doc, old.path.clone());- st.history.limit = old.history.limit;- // Same open document (caches keyed by uid stay valid); a new revision redraws it.- st.uid = old.uid;- st.revision = old.revision + 1;- st.format = old.format;- st.save_options = old.save_options.clone();- // The remembered artboard pick follows the artboards it named when the file read back has- // the artboards the document had at the save, in the same order and with the same ids (a- // native file keeps them; a PDF's pages get new ids in page order); otherwise it is left- // out.- if old.save_artboards.is_empty() || st.doc.artboards.iter().map(|a| a.id).eq(old.save_artboards.iter().copied()) {- st.save_artboards = old.save_artboards.clone();- } else {- for k in cmd::fileio::ARTBOARD_PARAMS {- st.save_options.remove(k);- }- }- st.converted = old.converted;- st.imported_from = old.imported_from.clone();- st.import_losses = old.import_losses.clone();- st.view = old.view.clone();- st.layers_open = old.layers_open.clone();- let old = std::mem::replace(&mut self.docs[index], st);- if let Some(stash) = &mut self.batch_stash {- stash.push(old);- }- true- }- pub fn close_document(&mut self, index: usize) -> bool {- if index >= self.docs.len() {- return false;- }- self.reset_tool_for_doc_switch();- // Closed (saved or discarded): nothing left to recover.- let uid = self.docs[index].uid;- cmd::recovery::forget(self, uid);- let old = self.docs.remove(index);- if let Some(stash) = &mut self.batch_stash {- stash.push(old);- }- self.active = if self.docs.is_empty() { None } else { Some(index.min(self.docs.len() - 1)) };- true- }-- /// `spec`'s `enabled` with `ids` selected instead of the selection, which is then put back.- fn enabled_with_selection(&mut self, spec: &CommandSpec, ids: Vec<NodeId>) -> std::result::Result<(), String> {- let Some(d) = self.active_mut() else { return (spec.enabled)(self) };- let old = std::mem::replace(&mut d.selection, Selection { objects: ids, ..Selection::default() });- let r = (spec.enabled)(self);- if let Some(d) = self.active_mut() {- d.selection = old;- }- r- }-- /// Error, under the command's own id, at the first of `ids` that is malformed, names no node, or- /// names a layer or sublayer: a command in [`SELECTS_GIVEN_IDS`] acts on objects.- fn check_given_ids(&self, id: &str, params: &Value) -> Result<()> {- let (Some(st), Some(ids)) = (self.active(), params.get("ids")) else { return Ok(()) };- let Some(given) = ids.as_array() else { return cmd::checked_ids_param(self, params, "ids", id).map(drop) };- for value in given {- let node = cmd::checked_id(self, value, id)?;- if st.doc.node(node).is_some_and(|n| n.is_layer()) {- return Err(if id.starts_with("object.arrange.") {- cmd::bad(id, format!("id {value} is a layer, not an object; move layers with layer.move"))- } else {- cmd::bad(id, format!("id {value} is a layer, not an object"))- });- }- }- Ok(())- }-- /// Execute a command by id. This is THE entry point for every frontend.- pub fn execute(&mut self, id: &str, params: &Value) -> Result<Value> {- let spec = find_command(id).ok_or_else(|| cmd::params::unknown_command(id))?;- // The crate's own tests are the audit of the params descriptions (#1442): a key a test- // passes that its command's description doesn't name fails the test.- #[cfg(test)]- self.check_params(id, params)?;- // Objects given as `id` (where it stands for `ids` of one) or as `ids` beside it are checked- // before anything else: a malformed one, or one naming no object, is an error under this- // command's id, never the selection in its place. `effect.apply {id: "stylize.dropShadow"}`- // without `effect` names the effect (its older key), not an object.- let effect_named = id == "effect.apply"- && params.get("effect").is_none()- && params.get("ids").is_none_or(Value::is_null)- && params.get("id").and_then(Value::as_str).is_some_and(|e| !e.starts_with('$'));- if cmd::params::id_stands_for_ids(spec.params) && !effect_named && self.active().is_some() {- cmd::given_objects(self, params, id)?;- }- if SELECTS_GIVEN_IDS.contains(&id) {- self.check_given_ids(id, params)?;- }- // Clear's menu needs a selection; an agent supplying explicit targets only needs a- // document. The command validates those targets before making any edit.- let given = given_ids(spec.params, params);- let enabled = if id == "edit.clear" && params.get("ids").is_some() {- cmd::has_doc(self)- } else if let Some(ids) = given.clone() {- // Objects given as `ids` (or `id`) stand in for the selection: the command is enabled- // as it is with them selected (#1575).- self.enabled_with_selection(spec, ids)- } else {- (spec.enabled)(self)- };- if let Err(why) = enabled {- return Err(EngineError::Disabled(id.to_string(), why));- }- // Only top-level commands are journaled (commands that call other commands would otherwise- // be recorded twice and replay differently).- if self.depth == 0 {- self.journal_note.clear();- self.note_depth = 1;- self.journal_query = false;- self.batch_stash = None;- self.batch_steps = None;- }- // A selection-only command given `ids` (or `id`) selects them first, in the same undo step- // (#2130); when the command then fails, the selection (and the current layer selecting- // them made current) goes back to how it was, as when the ids are refused.- let select_first = SELECTS_GIVEN_IDS- .contains(&id)- .then(|| {- params.get("ids").filter(|v| !v.is_null()).cloned().or_else(|| given.map(|ids| ids.iter().map(|i| i.0).collect::<Vec<_>>().into()))- })- .flatten();- let selected_before = select_first.as_ref().and(self.active()).map(|d| (d.uid, d.selection.clone(), d.active_layer));- let run = |s: &mut Session| {- if let Some(ids) = &select_first {- s.execute("select.set", &serde_json::json!({ "ids": ids }))?;- }- let r = (spec.run)(s, params);- if r.is_err()- && let Some((uid, selection, layer)) = selected_before- && let Some(st) = s.docs.iter_mut().find(|d| d.uid == uid)- {- st.selection = selection;- st.active_layer = layer;- st.revision += 1;- }- r- };- // The entries the command journals belong to the undo groups of the documents it edits, and to- // the group of the document it starts in when it ends there too.- let (doc, journal, grouped) = (self.active().map(|d| d.uid), self.journal.len(), self.undo_group_docs());- let open = (self.depth == 0).then(|| self.docs.iter().map(|d| d.uid).collect::<Vec<_>>());- let r = if self.depth == 0 { self.run_guarded(id, run) } else { self.run_nested(run) };- let r = r?;- if self.depth == 0 {- self.inherit_new_art();- }- if let Some(open) = open {- self.open_undo_groups_in_new_documents(&open);- }- let journaled = spec.journal || (self.depth == 0 && std::mem::take(&mut self.journal_query));- if journaled && self.depth == 0 && self.active().is_none_or(|d| d.interaction.is_none()) {- let p = self.noted(params);- self.journal.push((id.to_string(), p));- }- if self.depth == 0 {- self.journal_in_undo_groups(doc, &grouped, journal);- self.after_command();- }- Ok(r)- }-- /// Is the interface in Japanese? Then new type starts with em box top-to-top leading and em- /// box centre character alignment (#432).- pub fn japanese_interface(&self) -> bool {- self.ui_language.as_deref().unwrap_or(&self.prefs.interface_language).eq_ignore_ascii_case("ja")- }-- /// Record `key: value` in the running top-level command's journal entry (or its interaction's- /// preview, or its step in a batch) unless its params give `key`: a value it resolved from the- /// preferences or the clock.- pub fn note_journal(&mut self, key: &str, value: Value) {- if self.depth == self.note_depth {- self.journal_note.insert(key.to_string(), value);- }- }-- /// Journal the running query command when it is the top-level command: it changed the- /// selection (`document.find {select: true}`), so an action recorded around it repeats that.- pub(crate) fn journal_query(&mut self) {- if self.depth == 1 {- self.journal_query = true;- }- }-- /// Run `id` as a step of the running command, which journals its steps (`command.batch`):- /// → the step's result and its params with what it noted ([`Session::note_journal`]), for the- /// step in the running command's journal entry.- pub(crate) fn execute_step(&mut self, id: &str, params: &Value) -> Result<(Value, Value)> {- let outer = (std::mem::take(&mut self.journal_note), self.note_depth);- self.note_depth = self.depth + 1;- let r = self.execute(id, params);- let noted = self.noted(params);- (self.journal_note, self.note_depth) = outer;- Ok((r?, noted))- }-- /// The journal from entry `start` on, as an action records it: without the params that only- /// pin a replay to the original run ([`REPLAY_ONLY`]), so playing the action later acts now.- pub fn journal_for_action(&self, start: usize) -> Vec<(String, Value)> {- self.journal- .since(start)- .iter()- .cloned()- .map(|(id, mut p)| {- strip_replay_only(&id, &mut p);- (id, p)- })- .collect()- }-- /// `params` with the noted values added (see [`Session::note_journal`]).- fn noted(&mut self, params: &Value) -> Value {- let mut note = std::mem::take(&mut self.journal_note);- match params {- // The params' own values win.- Value::Object(m) if !note.is_empty() => {- note.extend(m.clone());- Value::Object(note)- }- Value::Null if !note.is_empty() => Value::Object(note),- _ => params.clone(),- }- }-- fn run_nested(&mut self, f: impl FnOnce(&mut Self) -> Result<Value>) -> Result<Value> {- self.depth += 1;- let r = f(self);- self.depth -= 1;- r- }-- /// A top-level command: a panic (a bug) becomes [`EngineError::Internal`] and the active- /// document goes back to how it was before the command, instead of crashing the frontend.- fn run_guarded(&mut self, id: &str, f: impl FnOnce(&mut Self) -> Result<Value>) -> Result<Value> {- let snapshot = self.active().map(|d| (d.uid, d.doc.clone(), d.selection.clone(), d.interaction.clone()));- let active = self.active;- let r = match guard::catch_panic(|| self.run_nested(f)) {- Ok(r) => r,- Err(msg) => {- self.depth = 0;- self.journal_note.clear();- if let Some((uid, doc, selection, interaction)) = snapshot- && let Some(st) = self.docs.iter_mut().find(|d| d.uid == uid)- {- st.doc = doc;- st.selection = selection;- st.interaction = interaction;- cmd::globaledit::follow_history(st);- st.revision += 1;- }- if active.is_some_and(|i| i < self.docs.len()) {- self.active = active;- }- Err(EngineError::Internal { cmd: id.to_string(), msg })- }- };- // Undo, Redo and a failed batch bring back documents with their selections: each document- // gets its selection's new art on a locked artboard.- for st in &mut self.docs {- st.sync_new_art();- }- r- }-- /// Run `f` on a mutable copy of the active document. Outside an interaction this records one- /// undo step labelled `label`; inside one it just mutates (the interaction commits later).- pub fn edit<T>(&mut self, label: &str, f: impl FnOnce(&mut Document, &mut Selection) -> Result<T>) -> Result<T> {- // An edit made while typing (the Transform panel) is a step of its own: inside the typing- // session, the next keystroke's preview would start again from before it (#1881).- if !self.previewing && cmd::typing_in_progress(self) {- cmd::settle_interaction(self)?;- }- let menu = self.menu.clone();- let st = self.doc_mut()?;- let before = st.doc.clone();- let before_sel = st.selection.clone();- let doc = Arc::make_mut(&mut st.doc);- // The Global Edit members the edit reached besides the selection.- let mut spread = vec![];- // Objects attached to a path follow it, and dimensions follow the art they measure.- let result = match f(doc, &mut st.selection).and_then(|v| {- // Global Edit: the other members take what the edit changed about the one it edited.- if let Some(ge) = &st.global_edit {- spread = cmd::globaledit::propagate(&before, doc, ge, [&before_sel.objects, &st.selection.objects]);- }- cmd::objects_on_path::refresh(&before, doc);- cmd::dimension::refresh(&before, doc)?;- Ok(v)- }) {- Ok(v) => match cmd::shaper::refresh(&before, Arc::make_mut(&mut st.doc)) {- Err(e) => Err(e),- Ok(()) => {- // Attached Shaper groups whose art was rebuilt go back on their path.- cmd::objects_on_path::refresh(&before, Arc::make_mut(&mut st.doc));- // Inline graphics in text follow their symbols.- cmd::inline::refresh(&before, Arc::make_mut(&mut st.doc));- // Text Wrap: area type follows its wrap objects; then threads re-flow.- cmd::textwrap::refresh(Arc::make_mut(&mut st.doc));- // Type in no thread numbers its list paragraphs from 1 (before the mask copies- // its editing layer's art).- cmd::threads::restart_unthreaded_counts(&mut st.doc);- // Opacity-mask editing: the mask follows its art on the editing layer.- if st.doc.mask_edit.is_some() {- cmd::maskedit::sync(Arc::make_mut(&mut st.doc));- }- // Threaded text re-flows when any of its frames changed.- if !st.doc.text_threads.is_empty() {- cmd::threads::reflow(&before, Arc::make_mut(&mut st.doc));- }- // Asset Export: assets let go of deleted art.- if !st.doc.assets.is_empty() {- Arc::make_mut(&mut st.doc).prune_assets();- }- // Variables: bindings let go of deleted art.- if !st.doc.variables.bindings.is_empty() {- Arc::make_mut(&mut st.doc).prune_variable_bindings();- }- if st.doc.too_deep(Some(&before)) {- // Deeper trees overflow the stack of what walks them.- Err(EngineError::Other(TOO_DEEP.into()))- } else if doc_sane(&st.doc, &st.selection) && objects_in_range(&st.doc, &spread) {- Ok(v)- } else {- Err(EngineError::Other("result would exceed the canvas (coordinates out of range)".into()))- }- }- },- Err(e) => Err(e),- };- match result {- Ok(v) => {- st.selection.prune(&st.doc);- // An edit that selects what it unlocks, shows or pastes leaves locked guides out,- // and one that selects the slices it makes leaves them out while they are locked- // or hidden.- deselect_hidden(&menu, &st.doc, &mut st.selection);- // The art on a locked artboard can't stay selected, however it got there, except- // the new art this edit made and new art still selected.- st.protect_locked_artboards(&before_sel.objects, &before_sel.new_art, Some(&*before));- st.revision += 1;- if st.interaction.is_none() {- let selection = match st.history.undo.last() {- Some(l) if *l.selection == before_sel => l.selection.clone(),- _ => Arc::new(before_sel),- };- st.push_undo(label.to_string(), before, selection);- }- Ok(v)- }- Err(e) => {- st.doc = before;- st.selection = before_sel;- cmd::globaledit::follow_history(st);- Err(e)- }- }- }-- /// [`Session::edit`] with the step named `template`, its `{name}` placeholder filled with `name`- /// (a style's name). The undo step it records keeps the template and the name- /// ([`HistoryEntry::named`]), and a frontend shows the template's translation with the name in- /// it. An edit that records no step of its own (inside an interaction, or a later edit of an- /// undo group) keeps neither, and neither does a step an undo group names.- pub fn edit_named<T>(- &mut self,- template: &'static str,- name: &str,- built_in: bool,- f: impl FnOnce(&mut Document, &mut Selection) -> Result<T>,- ) -> Result<T> {- let named = NamedStep { template, name: name.to_string(), built_in };- let step = named.label();- // The step this edit records keeps the document as it is now.- let now = Arc::as_ptr(&self.doc()?.doc);- let v = self.edit(&step, f)?;- if let Ok(st) = self.doc_mut()- && let Some(e) = st.history.undo.last_mut()- && Arc::as_ptr(&e.doc) == now- && e.label == step- {- e.named = Some(named);- }- Ok(v)- }-- /// Change only the selection (not an undo step).- pub fn select(&mut self, f: impl FnOnce(&Document, &mut Selection)) -> Result<()> {- self.active_appearance_item = None;- let menu = self.menu.clone();- let st = self.doc_mut()?;- let before = st.selection.objects.clone();- let new_art = st.selection.new_art.clone();- f(&st.doc, &mut st.selection);- st.selection.prune(&st.doc);- // Lock Guides locks the paths made into guides too (#1534), and Lock Slices and Hide- // Slices keep the slices out, whatever selects them.- deselect_hidden(&menu, &st.doc, &mut st.selection);- // The art on a locked artboard can't be selected, whatever selects it, except new art- // that was selected and still is.- st.protect_locked_artboards(&before, &new_art, None);- // Selecting art makes its layer (or sublayer) the current one, as in the Layers panel of- // the reference app: new art then goes beside it.- if st.selection.objects != before- && let Some(layer) = st.selection.objects.last().and_then(|id| st.doc.layer_containing(*id)).filter(|l| st.doc.is_editable(*l))- && st.active_layer != Some(layer)- {- st.active_layer = Some(layer);- st.layer_rows.clear();- }- st.revision += 1;- // Puppet Warp pins belong to the art they were placed on: another selection starts afresh.- if st.doc.puppet.as_ref().is_some_and(|p| p.ids != st.selection.objects) {- cmd::distortcmds::drop_puppet_pins(st);- }- Ok(())- }-- // ---------- 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(());- }- st.interaction = Some(Interaction {- label: label.to_string(),- doc: st.doc.clone(),- selection: Arc::new(st.selection.clone()),- preview: None,- active_layer: st.active_layer,- layer_rows: st.layer_rows.clone(),- variables_highlight: st.variables_highlight.clone(),- isolation: st.isolation,- perspective_again: None,- copies: None,- });- Ok(())- }-- /// Re-apply `cmd` on top of the interaction snapshot (replacing the previous preview).- pub fn preview(&mut self, cmd: &str, params: &Value) -> Result<Value> {- {- let menu = self.menu.clone();- let st = self.doc_mut()?;- let Some(it) = &st.interaction else { return Err(EngineError::Other("no interaction in progress".into())) };- // Undoing the previous preview counts as a change, so views redraw even when the command- // below returns without an edit.- let selection_changed = st.selection != *it.selection;- if !Arc::ptr_eq(&st.doc, &it.doc) || selection_changed {- st.revision += 1;- }- st.doc = it.doc.clone();- if selection_changed {- st.selection.clone_from(&it.selection);- }- // Guides locked and slices locked or hidden during the interaction stay deselected,- // even when the preview fails.- deselect_hidden(&menu, &st.doc, &mut st.selection);- cmd::globaledit::follow_history(st);- }- // The previous preview's paint is undone with it.- self.pending_paint = None;- let rw = cmd::distortcmds::perspective_rewrite(self, cmd, params).or_else(|| cmd::bounds_rewrite(self, cmd, params));- let (cmd, params) = rw.as_ref().map_or((cmd, params), |(c, p)| (c.as_str(), p));- let outer = std::mem::replace(&mut self.previewing, true);- let r = self.execute(cmd, params);- self.previewing = outer;- let params = self.noted(params);- let st = self.doc_mut()?;- if let Some(it) = &mut st.interaction {- // A failed preview leaves the document at the snapshot, so nothing is left to commit- // (not even an earlier successful preview, which the reset above already undid).- it.preview = r.is_ok().then(|| (cmd.to_string(), params));- }- r- }-- 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(()) };- let Some(preview) = it.preview.take() else { return Ok(()) };- let perspective_again = it.perspective_again.take();- let copy = preview.0 == "object.transform" && preview.1.get("copy").and_then(Value::as_bool).unwrap_or(false);- // Alt pressed or released during a move drag turns it into a copy or back: name it for- // what it did in the end.- match (it.label.as_str(), copy) {- ("Move", true) => it.label = "Copy".into(),- ("Copy", false) if preview.0 == "object.transform" => it.label = "Move".into(),- _ => {}- }- // A preview that left the document as it was records no Transform Again either (as- // `keep_interaction` records no undo step): the last real transformation stands.- let changed = !Arc::ptr_eq(&it.doc, &st.doc);- st.keep_interaction(it);- if preview.0 == "object.transform" {- let m = cmd::matrix_param(&preview.1, "matrix");- if let Some(m) = m {- // The options are the last preview's params with the values it noted, without the- // matrix and the ids.- let mut options = preview.1.clone();- if let Some(o) = options.as_object_mut() {- o.remove("matrix");- o.remove("ids");- }- st.last_transform = Some(LastTransform::Matrix(m, options));- st.last_perspective = None;- }- } else if preview.0 == "object.transformEach" && changed {- // Transform Again repeats it as it stood when OK was pressed.- st.last_transform = Some(LastTransform::Each(preview.1.clone()));- st.last_perspective = None;- }- if perspective_again.is_some() {- st.last_perspective = perspective_again;- }- let (doc, journal, grouped) = (self.active().map(|d| d.uid), self.journal.len(), self.undo_group_docs());- self.journal.push(preview);- self.journal_in_undo_groups(doc, &grouped, journal);- Ok(())- }-- /// Remember the paint a live preview applied (as its interaction is kept).- pub(crate) fn remember_pending_paint(&mut self) {- if let Some(p) = self.pending_paint.take() {- self.remember_paint_now(&p);- }- }-- pub fn cancel_interaction(&mut self) -> Result<()> {- self.clear_deferred_overlay_cache();- self.pending_paint = None;- let menu = self.menu.clone();- let st = self.doc_mut()?;- st.undo_interaction();- // Guides locked and slices locked or hidden during the interaction stay deselected.- deselect_hidden(&menu, &st.doc, &mut st.selection);- Ok(())- }-- pub fn in_interaction(&self) -> bool {- self.active().is_some_and(|d| d.interaction.is_some())- }-- // ---------- undo groups (scrubbed numeric fields) ------------ /// Open an undo group in the active document: until [`Session::end_undo_group`], the edits- /// made there (commands, committed interactions) are one undo step. A scrubbed numeric field- /// applies each value it passes as its own command, as a typed value is applied; the drag is- /// one step.- pub fn begin_undo_group(&mut self) {- self.begin_named_undo_group(None);- }-- /// [`Session::begin_undo_group`] with the undo step named `label` (else after its first edit).- pub fn begin_named_undo_group(&mut self, label: Option<String>) {- if let Some(st) = self.active_mut()- && st.undo_group.is_none()- {- st.undo_group = Some(UndoGroup { first: None, journal: vec![], steps: vec![], label });- }- }-- /// Between `edit.undoGroup.begin` and `edit.undoGroup.end`, open an undo group with the begun- /// group's name in each document that the top-level command just run opened or created (its- /// [`DocState::uid`] is not in `open`). The group takes the edits after that command: the- /// command's own edits there stay its undo step, and a canceled group keeps them, as the journal- /// entry that made the document stays.- fn open_undo_groups_in_new_documents(&mut self, open: &[u64]) {- let Some(label) = &self.explicit_undo_group else { return };- for st in &mut self.docs {- if !open.contains(&st.uid) && st.undo_group.is_none() {- st.undo_group = Some(UndoGroup { first: None, journal: vec![], steps: vec![], label: label.clone() });- }- }- }-- /// The documents with an undo group open ([`DocState::uid`]), each with the document it holds.- fn undo_group_docs(&self) -> Vec<(u64, *const Document)> {- self.docs.iter().filter(|st| st.undo_group.is_some()).map(|st| (st.uid, Arc::as_ptr(&st.doc))).collect()- }-- /// Note the journal entries from number `from` on in the undo groups they belong to: the group of- /// each document in `grouped` ([`Session::undo_group_docs`] before the entries) that they changed,- /// each group they opened and edited, and the group of the document with [`DocState::uid`] `doc`- /// when they started in it and it is still the active one. A cancel drops them. The last entry of a command that changed the- /// active document keeps the index of the document it left active. A `command.batch` entry also- /// keeps, in each group, the steps that belong to it ([`Session::batch_steps`]).- fn journal_in_undo_groups(&mut self, doc: Option<u64>, grouped: &[(u64, *const Document)], from: usize) {- let to = self.journal.len();- let active = self.active().map(|d| d.uid);- let switched = if active == doc { None } else { self.active };- let batch = self.batch_steps.take().filter(|_| to > from && self.journal.get(to - 1).is_some_and(|(id, _)| id == "command.batch"));- for st in &mut self.docs {- let Some(g) = &mut st.undo_group else { continue };- let started = doc == Some(st.uid) && active == doc;- // A group the entries opened has an edit of theirs once it has a first edit.- let edited = match grouped.iter().find(|&&(uid, _)| uid == st.uid) {- Some(&(_, d)) => !std::ptr::eq(d, Arc::as_ptr(&st.doc)),- None => g.first.is_some(),- };- if started || edited {- // A committed interaction inside the command noted its entry already.- let noted = g.journal.partition_point(|&(n, _)| n < from);- g.journal.truncate(noted);- g.journal.extend((from..to).map(|n| (n, switched.filter(|_| n + 1 == to))));- g.steps.retain(|&(n, _)| n < from);- if let Some(steps) = &batch {- let own = steps.iter().enumerate().filter(|(_, (uids, _))| uids.contains(&st.uid));- g.steps.push((to - 1, own.map(|(i, &(_, switched))| (i, switched)).collect()));- }- }- }- }-- /// Close the open undo groups: their edits stay one undo step or, `cancel`led (Escape), are- /// undone and dropped from the journal. A group begun with `edit.undoGroup.begin` ends too, so- /// documents opened after this open no undo group.- pub fn end_undo_group(&mut self, cancel: bool) {- self.explicit_undo_group = None;- self.close_undo_groups(cancel, None);- }-- /// [`Session::end_undo_group`] without ending a group begun with `edit.undoGroup.begin`, for the- /// document with [`DocState::uid`] `only` alone when given. The groups that stay open follow the- /// journal entries and batch steps of theirs that a cancel renumbers.- fn close_undo_groups(&mut self, cancel: bool, only: Option<u64>) {- let mut journal: Vec<(usize, Option<usize>)> = vec![];- let mut steps: Vec<BatchSteps> = vec![];- for st in &mut self.docs {- if only.is_some_and(|uid| uid != st.uid) {- continue;- }- let Some(g) = st.undo_group.take() else { continue };- // Only while the group's step is still the newest one.- if cancel- && let Some(first) = g.first- && st.history.undo.last().is_some_and(|e| Arc::ptr_eq(&e.doc, &first))- && let Some(e) = st.history.undo.pop()- {- st.doc = e.doc;- st.selection = Arc::unwrap_or_clone(e.selection);- deselect_hidden(&self.menu, &st.doc, &mut st.selection);- st.sync_new_art();- cmd::globaledit::follow_history(st);- st.revision += 1;- // The journal drops only the canceled groups' own entries and keeps the ones made in other documents meanwhile.- journal.extend(g.journal);- steps.extend(g.steps);- }- }- // A batch that edited two of the documents is in both groups.- journal.sort_unstable();- journal.dedup_by_key(|&mut (n, _)| n);- // A batch with steps outside the canceled groups keeps those steps.- let mut rewritten: Vec<(usize, Vec<Option<usize>>)> = vec![];- journal.retain(|&(n, _)| match self.keep_batch_steps(n, &steps) {- Some(kept) => {- rewritten.push((n, kept));- false- }- None => true,- });- // An entry that changed the active document becomes that change, so the entries after it run- // in the same document when the journal is replayed.- for &(n, index) in &journal {- if let Some(index) = index {- self.journal.replace(n, ("document.activate".to_string(), serde_json::json!({ "index": index })));- }- }- let gone: Vec<usize> = journal.into_iter().filter(|(_, index)| index.is_none()).map(|(n, _)| n).collect();- self.journal.remove(&gone);- let below = |n: usize| gone.partition_point(|&m| m < n);- for g in self.docs.iter_mut().filter_map(|st| st.undo_group.as_mut()) {- g.journal.retain(|(n, _)| gone.binary_search(n).is_err());- for (n, _) in &mut g.journal {- *n -= below(*n);- }- g.steps.retain(|(n, _)| gone.binary_search(n).is_err());- for (n, own) in &mut g.steps {- if let Some((_, kept)) = rewritten.iter().find(|(r, _)| r == n) {- own.retain_mut(|(i, _)| kept.get(*i).copied().flatten().map(|k| *i = k).is_some());- }- *n -= below(*n);- }- }- }-- /// When journal entry `n` is a `command.batch` with `steps` noted in canceled undo groups and- /// other steps that are not `document.activate`: rewrite its `commands` without the noted steps- /// (a noted step that changed the active document becomes that change) → each step's number in- /// the rewritten `commands`, `None` for a noted step. `None` leaves the entry to be dropped as a- /// whole.- fn keep_batch_steps(&mut self, n: usize, steps: &[BatchSteps]) -> Option<Vec<Option<usize>>> {- let noted: Vec<(usize, Option<usize>)> = steps.iter().filter(|(e, _)| *e == n).flat_map(|(_, s)| s.iter().copied()).collect();- let (id, entry) = self.journal.get(n).filter(|(id, _)| id == "command.batch" && steps.iter().any(|(e, _)| *e == n))?;- let commands = entry.get("commands").and_then(Value::as_array)?;- let kept = |i: usize| !noted.iter().any(|&(s, _)| s == i);- let activate = |c: &Value| c.get("command").and_then(Value::as_str) == Some("document.activate");- if commands.iter().enumerate().all(|(i, c)| !kept(i) || activate(c)) {- return None;- }- let (mut rewritten, mut numbers) = (Vec::with_capacity(commands.len()), Vec::with_capacity(commands.len()));- for (i, c) in commands.iter().enumerate() {- if kept(i) {- numbers.push(Some(rewritten.len()));- rewritten.push(c.clone());- } else {- numbers.push(None);- if let Some(index) = noted.iter().find(|&&(s, _)| s == i).and_then(|&(_, index)| index) {- rewritten.push(serde_json::json!({ "command": "document.activate", "params": { "index": index } }));- }- }- }- let (id, mut entry) = (id.clone(), entry.clone());- if let Some(o) = entry.as_object_mut() {- o.insert("commands".into(), Value::Array(rewritten));- }- self.journal.replace(n, (id, entry));- Some(numbers)- }-- /// [`Session::end_undo_group`] for the open document with [`DocState::uid`] `uid` only (it may- /// have closed since): its open undo group closes, and undo groups open in other documents stay- /// open.- fn end_document_undo_group(&mut self, uid: u64, cancel: bool) {- self.close_undo_groups(cancel, Some(uid));- }-- /// Make the edits that follow in the active document one undo step, until- /// [`Session::end_undo_scope`]: open an undo group there or, when one is open already, join it,- /// so that the edits are part of its step. `None` without a document.- pub fn begin_undo_scope(&mut self) -> Option<UndoScope> {- let journal = self.journal.len();- let st = self.active()?;- let uid = st.uid;- let joined = st.undo_group.as_ref().map(|g| (st.doc.clone(), st.selection.clone(), g.first.clone()));- if joined.is_none() {- self.begin_undo_group();- }- Some(UndoScope { uid, journal, joined })- }-- /// End `scope` in its own document, whichever document is active now; undo groups open in other- /// documents stay open. The undo group the scope opened closes as [`Session::end_undo_group`]- /// closes it. A scope that joined an open group leaves the group open; with `cancel`, it puts the- /// document and its selection back as they were when the scope began and cuts the journal back to- /// where the scope began (only while the group's step is still the newest one), and an undo step- /// that the scope's first edit recorded goes too. The open undo groups drop the cut entries.- pub fn end_undo_scope(&mut self, scope: UndoScope, cancel: bool) {- let Some((doc, selection, first)) = scope.joined else {- self.end_document_undo_group(scope.uid, cancel);- return;- };- let menu = self.menu.clone();- let Some(st) = self.document_mut(scope.uid) else { return };- let Some(g) = &mut st.undo_group else { return };- let newest = g.first.as_ref().is_some_and(|f| st.history.undo.last().is_some_and(|e| Arc::ptr_eq(&e.doc, f)));- if !cancel || !newest {- return;- }- match &first {- // The scope's first edit recorded the group's step.- None => {- st.history.undo.pop();- g.first = None;- }- Some(f) if g.first.as_ref().is_some_and(|now| Arc::ptr_eq(now, f)) => {}- Some(_) => return,- }- st.doc = doc;- st.selection = selection;- cmd::globaledit::follow_history(st);- deselect_hidden(&menu, &st.doc, &mut st.selection);- st.history.recost_last(&st.doc);- st.revision += 1;- self.journal.truncate(scope.journal);- // The next commands take the cut entries' numbers, so no open undo group keeps them.- for g in self.docs.iter_mut().filter_map(|st| st.undo_group.as_mut()) {- g.journal.retain(|&(n, _)| n < scope.journal);- g.steps.retain(|&(n, _)| n < scope.journal);- }- }-- /// Commands with enablement (for menus, palette, MCP `list_commands`).- pub fn commands(&self) -> Vec<CommandInfo> {- command_specs().iter().map(|c| c.info(self)).collect()- }-}--/// Lay out the type in tree `n` (opacity mask art included) whose bounds aren't cached. Only the-/// nodes on the way to such type are copied.-fn refresh_tree_text_bounds(n: &mut Arc<vectorcraft_doc::Node>) {- fn stale(n: &vectorcraft_doc::Node) -> bool {- matches!(&n.kind, NodeKind::Text(t) if t.cached_bounds.is_none())- || n.extras().mask.as_deref().is_some_and(|m| stale(&m.art))- || n.children().is_some_and(|ch| ch.iter().any(|c| stale(c)))- }- if !stale(n) {- return;- }- let n = Arc::make_mut(n);- if let NodeKind::Text(t) = &mut n.kind- && t.cached_bounds.is_none()- {- cmd::typecmd::refresh_bounds(t);- }- if let Some(m) = n.extras_if_any().and_then(|e| e.mask.as_deref_mut()) {- refresh_tree_text_bounds(&mut m.art);- }- for c in n.children_mut().into_iter().flatten() {- refresh_tree_text_bounds(c);- }-}-/// Held by the tests that add fonts to the shared [`vectorcraft_text::FontDb::global`] for as long/// as they run: adding a font clears the database's caches, which would change how another such/// test's type resolves between its layout and its export.@@ -2602,56 +235,28 @@ use tests::{links as tests_links, linkspanel as tests_linkspanel, menucmds as tests_menucmds, outlinestroke as tests_outlinestroke,persp_select as tests_persp_select, textimport as tests_textimport,};-#[cfg(test)]-mod tests;-/// Commands that act on the selection and take `ids` by selecting them first (`select.set`, with-/// its checks), then running as on the selection: the result and the selection afterwards are the-/// menu command's (#2130).-pub(crate) const SELECTS_GIVEN_IDS: &[&str] = &[- "edit.duplicate",- "object.arrange.bringForward",- "object.arrange.bringToFront",- "object.arrange.sendBackward",- "object.arrange.sendToBack",- "object.arrange.sendToCurrentLayer",- "object.clippingMask.make",- "object.clippingMask.release",- "object.compoundPath.make",- "object.compoundPath.release",- "object.group",- "object.hide",- "object.lock",- "object.move",- "object.pathfinder.crop",- "object.pathfinder.divide",- "object.pathfinder.exclude",- "object.pathfinder.intersect",- "object.pathfinder.merge",- "object.pathfinder.minusBack",- "object.pathfinder.minusFront",- "object.pathfinder.outline",- "object.pathfinder.trap",- "object.pathfinder.trim",- "object.pathfinder.unite",- "object.reflect",- "object.rotate",- "object.scale",- "object.shear",- "object.ungroup",-];+mod command_sets;+mod doc_state;+mod error;+mod history;+mod interaction;+mod prefs;+mod sanity;+mod session;-/// The non-empty `ids` given to a command whose params description names `ids` as a key (the-/// key callers outside the app may pass it, [`cmd::params::takes_key`]), or its `id` as `ids` of-/// one when no `ids` are given and the description takes `id` so-/// ([`cmd::params::id_stands_for_ids`]), as [`cmd::targets`] reads them.-fn given_ids(description: &'static str, params: &Value) -> Option<Vec<NodeId>> {- if !cmd::params::takes_key(description, "ids") {- return None;- }- match params.get("ids").filter(|v| !v.is_null()) {- Some(_) => cmd::ids_param(params, "ids"),- None => cmd::id_param(params, "id").filter(|_| cmd::params::id_stands_for_ids(description)).map(|id| vec![id]),- }- .filter(|ids| !ids.is_empty())-}+#[cfg(test)]+pub(crate) use command_sets::SELECTS_GIVEN_IDS;+#[cfg(test)]+use command_sets::given_ids;+pub use command_sets::{FIT_ACTIVE_ARTBOARD, ON_ACTIVE_ARTBOARD};+pub use doc_state::{DocState, OpenRows, RecalledSelection};+pub use error::{EngineError, Result};+pub use history::{History, HistoryEntry, NamedStep, default_history_budget};+pub(crate) use interaction::PreviewCopies;+pub use interaction::{Interaction, LastTransform, UndoGroup, UndoScope};+pub use prefs::{DrawMode, Prefs};+pub use sanity::TOO_DEEP;+pub(crate) use sanity::{deselect_hidden, is_guide_path};+#[cfg(test)]+mod tests;diff --git a/crates/engine/src/prefs.rs b/crates/engine/src/prefs.rsnew file mode 100644index 000000000..fad473449--- /dev/null+++ b/crates/engine/src/prefs.rs@@ -0,0 +1,452 @@+use super::*;++/// Where new art goes (Illustrator's drawing modes, Shift+D cycles).+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, serde::Serialize, serde::Deserialize)]+#[serde(rename_all = "lowercase")]+pub enum DrawMode {+ #[default]+ Normal,+ Behind,+ Inside,+}++/// Application preferences (Edit → Preferences). Every field is reachable through `prefs.get` /+/// `prefs.set {key, value}` (camelCase keys, validated against [`cmd::prefscmds::PREF_SPECS`]).+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]+#[serde(default, rename_all = "camelCase")]+pub struct Prefs {+ // General+ /// Arrow-key nudge distance (General → Keyboard Increment), points.+ pub keyboard_increment: f64,+ pub constrain_angle: f64,+ pub corner_radius: f64,+ pub disable_auto_add_delete: bool,+ pub use_precise_cursors: bool,+ pub show_tool_tips: bool,+ pub anti_aliased_artwork: bool,+ pub select_same_tint_percent: bool,+ pub show_home_screen: bool,+ pub use_preview_bounds: bool,+ pub display_print_size: bool,+ pub double_click_to_isolate: bool,+ pub transform_pattern_tiles: bool,+ pub scale_corners: bool,+ /// Scale Strokes & Effects.+ pub scale_strokes: bool,+ pub zoom_with_mouse_wheel: bool,+ /// A horizontal drag on a numeric field or its label steps its value (#400).+ pub scrub_numeric_fields: bool,+ /// A two-finger rotation on a Mac trackpad turns the view about the pointer once it reaches 5°.+ pub trackpad_rotate_view: bool,+ /// Offset for Paste / duplicate (Illustrator pastes to the view centre; we offset by this).+ pub paste_offset: f64,+ // Selection & Anchor Display+ pub selection_tolerance: f64,+ pub object_selection_by_path_only: bool,+ pub snap_to_point_tolerance: f64,+ pub ctrl_click_selects_behind: bool,+ pub zoom_to_selection: bool,+ pub move_locked_with_artboard: bool,+ pub anchor_size: u32,+ pub handle_style: String,+ pub highlight_anchors_on_hover: bool,+ pub show_handles_multiple_anchors: bool,+ pub hide_corner_widget_above: f64,+ pub pen_rubber_band: bool,+ pub curvature_rubber_band: bool,+ // Type+ pub type_size_increment: f64,+ pub tracking_increment: f64,+ pub baseline_shift_increment: f64,+ pub show_east_asian_options: bool,+ pub show_indic_options: bool,+ pub type_selection_by_path_only: bool,+ pub font_names_in_english: bool,+ pub auto_size_area_type: bool,+ pub font_preview: bool,+ pub font_preview_size: String,+ pub recent_fonts_count: u32,+ pub missing_glyph_protection: bool,+ pub highlight_alternate_glyphs: bool,+ /// Type › Highlight Substituted Fonts: on screen, text drawn in a substitute for a missing+ /// font is highlighted, in every document (on by default).+ pub highlight_substituted_fonts: bool,+ pub placeholder_text: bool,+ // Units+ pub units_general: String,+ pub units_stroke: String,+ pub units_type: String,+ pub units_asian_type: String,+ /// Numbers Without Units Are Points: a number typed with no unit into a length field in picas+ /// is read in points (on by default; the reference app dims it unless a unit is Picas).+ pub numbers_without_units_are_points: bool,+ pub identify_objects_by: String,+ // Guides & Grid+ pub guide_color: String,+ pub guide_style: String,+ pub grid_color: String,+ pub grid_style: String,+ pub gridline_every: f64,+ pub grid_subdivisions: u32,+ pub grids_in_back: bool,+ pub show_pixel_grid: bool,+ // Smart Guides+ pub smart_guide_color: String,+ pub alignment_guides: bool,+ pub object_highlighting: bool,+ pub transform_tools_guides: bool,+ pub construction_guides: bool,+ pub construction_angles: String,+ pub anchor_path_labels: bool,+ pub measurement_labels: bool,+ pub spacing_guides: bool,+ pub distance_guides: bool,+ pub snapping_tolerance: f64,+ pub snap_tangent: bool,+ pub snap_perpendicular: bool,+ // Slices+ pub show_slice_numbers: bool,+ pub slice_line_color: String,+ // Hyphenation+ pub hyphenation_language: String,+ pub hyphenation_exceptions: String,+ /// Type › Options › Additional Fonts Folder: a folder (read with its subfolders) whose fonts+ /// are listed and used as if installed (#683); empty for none.+ pub fonts_folder: String,+ // Plug-ins & Scratch Disks+ pub plugins_folder: String,+ pub scratch_primary: String,+ pub scratch_secondary: String,+ // User Interface+ pub ui_brightness: String,+ /// User Interface › Accent Color: the colour of what is on, chosen or focused.+ pub ui_accent: String,+ /// User Interface › Color Scheme: "modern" (with the accent above) or "classic" (neutral+ /// greys and a blue accent).+ pub ui_color_scheme: String,+ pub canvas_color: String,+ pub auto_collapse_icon_panels: bool,+ /// User Interface › Show Tool Group Labels: the toolbar's group names (Select, Shapes, Draw…);+ /// off (as it ships, #1736), the tools run on from group to group with nothing between them.+ pub tool_group_labels: bool,+ pub open_documents_as_tabs: bool,+ pub large_tabs: bool,+ pub ui_scaling: f64,+ pub scale_cursor_with_ui: bool,+ /// UI language: `auto` (follow the system locale) or a language code such as `en`, `zh-hant`.+ /// The list of languages belongs to the shell (`ui-egui` i18n); an unknown code reads as `auto`.+ pub interface_language: String,+ /// Windows and Linux: use the system's title bar and window buttons instead of the app bar+ /// acting as the title bar (tiling window managers, desktops that draw their own decorations).+ /// Read when the app starts. macOS always uses the system's.+ pub system_title_bar: bool,+ // Performance+ pub gpu_performance: bool,+ pub animated_zoom: bool,+ /// Which graphics processor the desktop app asks for at startup (it takes effect after a+ /// restart): `automatic`, `lowPower` (the integrated GPU on hybrid-graphics machines) or+ /// `highPerformance` (the discrete one). The canvas is rasterized on the CPU and only+ /// composited on the GPU, so the integrated GPU is plenty; presenting from the discrete GPU+ /// through the integrated one made some hybrid laptops flicker (#306). Automatic is power+ /// saving on Windows and macOS and the system's default GPU elsewhere, the one the desktop+ /// runs on: a Wayland compositor may not show frames from another GPU (#502). Single-GPU+ /// machines are unaffected.+ pub gpu_preference: String,+ pub history_states: u32,+ pub real_time_drawing: bool,+ /// Rasterizer worker threads; -1 = automatic.+ pub render_threads: i32,+ /// Linux: `automatic` opens the window on the session's display server; `x11` opens it through+ /// XWayland on a Wayland session, where dropped files arrive (#1151); `x11WithPen` opens it+ /// through XWayland only when a pen is attached (#2028). Read when the app starts.+ pub linux_display_server: String,+ // File Handling+ pub background_save: bool,+ pub background_export: bool,+ pub autosave_recovery: bool,+ pub autosave_interval: u32,+ pub recovery_folder: String,+ pub recovery_off_for_complex: bool,+ pub recent_files_count: u32,+ pub low_res_proxy_eps: bool,+ pub anti_aliased_bitmaps: bool,+ pub update_links: String,+ // Clipboard Handling+ pub copy_as_svg: bool,+ pub copy_as_pdf: bool,+ pub copy_aicb: bool,+ pub aicb_mode: String,+ pub paste_text_formatting: String,+ // Appearance of Black+ pub black_on_screen: String,+ pub black_output: String,+ // Devices+ pub touch_workspace: bool,+ pub touch_gestures: bool,+ // Graphic Styles panel+ /// Override Character Color: a graphic style applied to type replaces its characters' fill+ /// and stroke with the style's fills and strokes.+ pub override_char_color: bool,+ // Pattern editing+ /// Object → Pattern → Tile Edge Color (`#rrggbb`): the tile edge and swatch bounds in pattern+ /// editing mode.+ pub pattern_tile_edge_color: String,+ /// Eyedropper Options (`eyedropper.setOptions`; a preference group, see+ /// [`cmd::prefscmds::PREF_GROUPS`]).+ pub eyedropper: EyedropperOptions,+ /// Pathfinder panel › Pathfinder Options (`object.pathfinder.options`; a preference group, see+ /// [`cmd::prefscmds::PREF_GROUPS`]).+ pub pathfinder: PathfinderOptions,+ /// Edit → Transparency Flattener Presets: the user's presets (the built-in ones aren't stored).+ /// Not a `prefs.set` key or group (resetting the preferences keeps them): `flattener.presets.*`+ /// edit it.+ #[serde(skip_serializing_if = "Vec::is_empty")]+ pub flattener_presets: Vec<cmd::FlattenerPreset>,+ /// Width profiles saved to the Stroke panel's Profile list (`stroke.widthProfile.*`). Not a+ /// Preferences dialog field, so it has no [`cmd::prefscmds::PREF_SPECS`] row.+ #[serde(skip_serializing_if = "Vec::is_empty")]+ pub width_profiles: Vec<vectorcraft_doc::SavedProfile>,+ /// General → Use Japanese Crop Marks: the style of Create Trim Marks and Effect → Crop Marks.+ pub japanese_crop_marks: bool,+ /// Appearance panel → New Art Has Basic Appearance (on): new art takes one fill and stroke;+ /// off, the whole appearance of the last selection (`appearance.setNewArtBasic`).+ pub new_art_basic: bool,+ /// The Color Themes panel's saved themes (`colorTheme.*`): a local library, not a Preferences+ /// dialog field, so it has no [`cmd::prefscmds::PREF_SPECS`] row and resetting keeps it.+ #[serde(skip_serializing_if = "Vec::is_empty")]+ pub color_themes: Vec<cmd::colortheme::ColorTheme>,+ /// New Document → Saved: the user's document presets (`file.newPresets.save`). A local+ /// library, not a Preferences dialog field: resetting the preferences keeps it.+ #[serde(skip_serializing_if = "Vec::is_empty")]+ pub new_doc_presets: Vec<cmd::newdoc::DocSettings>,+ /// New Document → Recent: the settings of the last documents made (newest first).+ #[serde(skip_serializing_if = "Vec::is_empty")]+ pub recent_new_docs: Vec<cmd::newdoc::DocSettings>,+ /// Edit → PDF Presets: the user's presets (the built-in ones aren't stored). A local library,+ /// not a Preferences dialog field: resetting the preferences keeps it; `pdf.preset.*` edit it.+ #[serde(skip_serializing_if = "Vec::is_empty")]+ pub pdf_presets: Vec<vectorcraft_pdf::PdfPreset>,+ /// File → Export for Screens: the user's batch export presets (`document.exportPresets.*`;+ /// the built-in ones aren't stored). A local library, not a Preferences dialog field.+ #[serde(skip_serializing_if = "Vec::is_empty")]+ pub screen_export_presets: Vec<cmd::fileio::ScreenExportPreset>,+ // File Handling (continued)+ /// Where Save as Template and New from Template start ("" = `Documents/VectorCraft Templates`).+ pub templates_folder: String,+ /// Open older native files as "<name> [Converted]" so Save asks for a new name.+ pub append_converted: bool,+ /// File Handling → Use Compression: native saves are gzip-compressed (`document.save+ /// {compress}` overrides it).+ pub use_compression: bool,+ /// Save for Web: the user's presets (the built-in ones aren't stored). A local library, not a+ /// Preferences dialog field: resetting the preferences keeps it; `webExport.presets.*` edit it.+ #[serde(skip_serializing_if = "Vec::is_empty")]+ pub web_export_presets: Vec<cmd::webexport::WebPreset>,+ /// Save for Web: the settings the dialog opens on (`webExport.settings`); none until set.+ #[serde(skip_serializing_if = "Option::is_none")]+ pub web_export_settings: Option<cmd::webexport::WebSettings>,+ /// Edit → Print Presets: the user's presets ([Default] isn't stored). A local library, not a+ /// Preferences dialog field: resetting the preferences keeps it; `print.presets.*` edit it.+ #[serde(skip_serializing_if = "Vec::is_empty")]+ pub print_presets: Vec<cmd::printpresets::PrintPreset>,+ /// Constrain Width and Height Proportions: the link between W and H in the Transform panel,+ /// the Properties panel and the Control bar (their size fields pass `proportional` to+ /// `object.setBounds`).+ pub constrain_proportions: bool,+ /// One Corner Radius field sets every corner of a live rectangle (off: a field per corner).+ pub single_corner_radius: bool,+ /// The Transform panel menu's Transform Object Only / Transform Pattern Only / Transform Both+ /// (`object`, `pattern`, `both`): what the panel's fields, flips and menu flips transform+ /// (they pass `objects` and `patterns` to the transform commands). `default` (and any other+ /// value), until one is chosen: they pass neither, so patterns follow General › Transform+ /// Pattern Tiles (`transformPatternTiles`), as before the menu acted.+ pub transform_panel_patterns: String,+ /// The Transform panel menu's Use Registration Point for Symbol: with one symbol instance+ /// selected, the panel and the Properties panel's Transform section measure and transform it+ /// from its symbol's registration point instead of the reference point.+ pub use_registration_point_for_symbol: bool,+ /// The tools' persistent options by store (a tool id, or a store a family shares: `liquify`+ /// holds the Liquify tools' Global Brush Dimensions), see [`vectorcraft_tools::settings`]:+ /// kept across tool switches and saved with the preferences. Not a Preferences dialog field:+ /// resetting the preferences keeps them; `tool.setOption` edits them.+ #[serde(skip_serializing_if = "std::collections::BTreeMap::is_empty")]+ pub tool_settings: std::collections::BTreeMap<String, serde_json::Map<String, Value>>,+ /// View → Perspective Grid presets: the user's (the built-in ones aren't stored). A local+ /// library, not a Preferences dialog field: resetting the preferences keeps it;+ /// `perspective.presets.*` edit it.+ #[serde(skip_serializing_if = "Vec::is_empty")]+ pub perspective_presets: Vec<vectorcraft_tools::distort::perspective::GridDefinition>,+ /// Blend Options set with no blend selected: what new blends start with+ /// (`object.blend.options`; none: Smooth Color, Align to Page). A tool setting, not a+ /// Preferences dialog field: it has no [`cmd::prefscmds::PREF_SPECS`] row and resetting the+ /// preferences keeps it.+ #[serde(skip_serializing_if = "Option::is_none")]+ pub blend_options: Option<vectorcraft_doc::live::BlendDefaults>,+ /// Perspective Grid Options (double-click the Perspective Grid tool): whether the Plane+ /// Switching Widget shows and where (`perspective.widget.options`).+ pub perspective_widget: vectorcraft_tools::distort::perspective::widget::WidgetOptions,+ /// What names and codes in other apps' shortcut sets stand for, as the user confirmed them on+ /// import (`importMatches.*`). A local library, not a Preferences dialog field: resetting the+ /// preferences keeps it.+ #[serde(skip_serializing_if = "Vec::is_empty")]+ pub import_matches: Vec<cmd::importmatches::ImportMatch>,+}++impl Default for Prefs {+ fn default() -> Self {+ let s = |v: &str| v.to_string();+ Self {+ keyboard_increment: 1.0,+ constrain_angle: 0.0,+ corner_radius: 12.0,+ disable_auto_add_delete: false,+ use_precise_cursors: false,+ show_tool_tips: true,+ anti_aliased_artwork: true,+ select_same_tint_percent: false,+ show_home_screen: true,+ use_preview_bounds: false,+ display_print_size: false,+ double_click_to_isolate: true,+ transform_pattern_tiles: false,+ scale_corners: false,+ scale_strokes: false,+ zoom_with_mouse_wheel: false,+ scrub_numeric_fields: true,+ trackpad_rotate_view: true,+ paste_offset: 10.0,+ selection_tolerance: 3.0,+ object_selection_by_path_only: false,+ snap_to_point_tolerance: 2.0,+ ctrl_click_selects_behind: true,+ zoom_to_selection: true,+ move_locked_with_artboard: false,+ anchor_size: 3,+ handle_style: s("solid"),+ highlight_anchors_on_hover: true,+ show_handles_multiple_anchors: true,+ hide_corner_widget_above: 177.0,+ pen_rubber_band: true,+ curvature_rubber_band: true,+ type_size_increment: 2.0,+ tracking_increment: 20.0,+ baseline_shift_increment: 2.0,+ show_east_asian_options: false,+ show_indic_options: false,+ type_selection_by_path_only: false,+ font_names_in_english: true,+ auto_size_area_type: false,+ font_preview: true,+ font_preview_size: s("medium"),+ recent_fonts_count: 10,+ missing_glyph_protection: true,+ highlight_alternate_glyphs: false,+ highlight_substituted_fonts: true,+ placeholder_text: true,+ units_general: s("points"),+ units_stroke: s("points"),+ units_type: s("points"),+ units_asian_type: s("points"),+ numbers_without_units_are_points: true,+ identify_objects_by: s("objectName"),+ guide_color: s("#4affff"),+ guide_style: s("lines"),+ grid_color: s("#c8c8c8"),+ grid_style: s("lines"),+ gridline_every: 72.0,+ grid_subdivisions: 8,+ grids_in_back: true,+ show_pixel_grid: true,+ smart_guide_color: s("#ff3dfc"),+ alignment_guides: true,+ object_highlighting: true,+ transform_tools_guides: true,+ construction_guides: true,+ construction_angles: s(vectorcraft_tools::guides::DEFAULT_CONSTRUCTION_ANGLES),+ anchor_path_labels: true,+ measurement_labels: true,+ spacing_guides: true,+ distance_guides: true,+ snapping_tolerance: 4.0,+ snap_tangent: true,+ snap_perpendicular: true,+ show_slice_numbers: true,+ slice_line_color: s("#ff3f3f"),+ hyphenation_language: s("English: USA"),+ hyphenation_exceptions: String::new(),+ fonts_folder: String::new(),+ plugins_folder: String::new(),+ scratch_primary: s("Startup"),+ scratch_secondary: s("None"),+ ui_brightness: s("mediumDark"),+ ui_accent: s("coral"),+ ui_color_scheme: s("modern"),+ canvas_color: s("matchUi"),+ auto_collapse_icon_panels: false,+ tool_group_labels: false,+ open_documents_as_tabs: true,+ large_tabs: false,+ ui_scaling: 1.0,+ scale_cursor_with_ui: false,+ interface_language: s("auto"),+ system_title_bar: false,+ gpu_performance: true,+ animated_zoom: true,+ gpu_preference: s("automatic"),+ history_states: 500,+ real_time_drawing: true,+ render_threads: -1,+ linux_display_server: s("automatic"),+ background_save: true,+ background_export: true,+ autosave_recovery: true,+ autosave_interval: 2,+ recovery_folder: String::new(),+ recovery_off_for_complex: false,+ recent_files_count: 20,+ low_res_proxy_eps: false,+ anti_aliased_bitmaps: false,+ update_links: s("askWhenModified"),+ copy_as_svg: true,+ copy_as_pdf: false,+ copy_aicb: false,+ aicb_mode: s("preserveAppearance"),+ paste_text_formatting: s("keep"),+ black_on_screen: s("accurate"),+ black_output: s("accurate"),+ touch_workspace: true,+ touch_gestures: true,+ override_char_color: true,+ pattern_tile_edge_color: {+ let [r, g, b] = vectorcraft_doc::LAYER_COLORS[0].1;+ Color::rgb8(r, g, b).to_hex()+ },+ eyedropper: Default::default(),+ pathfinder: Default::default(),+ flattener_presets: vec![],+ width_profiles: vec![],+ japanese_crop_marks: false,+ new_art_basic: true,+ color_themes: vec![],+ new_doc_presets: vec![],+ recent_new_docs: vec![],+ pdf_presets: vec![],+ screen_export_presets: vec![],+ templates_folder: String::new(),+ append_converted: true,+ use_compression: false,+ web_export_presets: vec![],+ web_export_settings: None,+ print_presets: vec![],+ constrain_proportions: false,+ single_corner_radius: true,+ transform_panel_patterns: "default".to_string(),+ use_registration_point_for_symbol: false,+ tool_settings: Default::default(),+ perspective_presets: vec![],+ blend_options: None,+ perspective_widget: Default::default(),+ import_matches: vec![],+ }+ }+}diff --git a/crates/engine/src/sanity.rs b/crates/engine/src/sanity.rsnew file mode 100644index 000000000..0d06450a8--- /dev/null+++ b/crates/engine/src/sanity.rs@@ -0,0 +1,60 @@+use super::*;++/// Is `id` a path made into a guide (View → Guides → Make Guides)?+pub(crate) fn is_guide_path(d: &Document, id: NodeId) -> bool {+ d.node(id).is_some_and(|n| matches!(n.kind, NodeKind::Path { guide: true, .. }))+}++/// Deselect the ruler guides and the paths made into guides: while View → Guides → Lock Guides is+/// on, they can't be selected (#1534), whatever selects them. → whether any was selected.+pub(crate) fn deselect_guides(d: &Document, sel: &mut Selection) -> bool {+ let paths: Vec<NodeId> = sel.objects.iter().copied().filter(|id| is_guide_path(d, *id)).collect();+ let any = !paths.is_empty() || !sel.guides.is_empty();+ for id in paths {+ sel.remove(id);+ }+ sel.guides.clear();+ sel.key_guide = None;+ // A key object kept only for the guides to line up on goes with them.+ if sel.key.is_some_and(|k| sel.objects.iter().all(|o| *o == k)) {+ sel.key = None;+ }+ any+}++/// Deselect what the View menu keeps from being selected: the guides while Lock Guides is on+/// ([`deselect_guides`]), and the slices that the Slice Selection tool or a slice command selected+/// ([`Selection::slices`]) while Lock Slices or Hide Slices is on. A selected object that is an+/// object slice stays selected. → whether any was selected.+pub(crate) fn deselect_hidden(menu: &cmd::menucmds::MenuState, d: &Document, sel: &mut Selection) -> bool {+ let guides = menu.guides_locked && deselect_guides(d, sel);+ let slices = (menu.slices_locked || menu.slices_hidden) && !sel.slices.is_empty();+ if slices {+ sel.slices.clear();+ }+ guides || slices+}++/// The error of an edit that would nest objects deeper than [`vectorcraft_doc::MAX_DEPTH`].+pub const TOO_DEEP: &str = "objects can't be nested more than 32 deep";++/// Cheap sanity check after an edit: artboards and the objects just touched (the selection) must+/// have finite, in-range geometry, so saved files always reload and renderers never see NaN/∞.+pub(crate) fn doc_sane(d: &Document, sel: &Selection) -> bool {+ d.ruler_origin.is_finite()+ && d.ruler_origin.x.abs() <= MAX_COORD+ && d.ruler_origin.y.abs() <= MAX_COORD+ && d.artboards.iter().all(|a| rect_in_range(a.rect))+ && d.guides.iter().all(|g| g.pos.is_finite() && g.pos.abs() <= MAX_COORD)+ && objects_in_range(d, &sel.objects)+}++fn rect_in_range(r: vectorcraft_geom::Rect) -> bool {+ [r.x0, r.y0, r.x1, r.y1].iter().all(|v| v.is_finite() && v.abs() <= MAX_COORD)+}++/// Do the objects `ids` have finite geometry within [`MAX_COORD`] (the ones not there pass)?+pub(crate) fn objects_in_range(d: &Document, ids: &[NodeId]) -> bool {+ let paths = d.index_paths(ids.iter().copied());+ ids.iter().all(|id| paths.get(id).and_then(|p| d.node_at(p)).and_then(|n| n.geometric_bounds()).is_none_or(rect_in_range))+}diff --git a/crates/engine/src/session.rs b/crates/engine/src/session.rsnew file mode 100644index 000000000..2dd1bc889--- /dev/null+++ b/crates/engine/src/session.rs@@ -0,0 +1,13 @@+use super::command_sets::{SELECTS_GIVEN_IDS, given_ids, strip_replay_only};+use super::doc_state::DocState;+use super::error::{EngineError, Result};+use super::history::NamedStep;+use super::interaction::{BatchSteps, Interaction, LastTransform, UndoGroup, UndoScope};+use super::prefs::{DrawMode, Prefs};+use super::sanity::{TOO_DEEP, deselect_hidden, doc_sane, objects_in_range};+use super::*;++mod documents;+mod edit;+mod execute;+mod undo;diff --git a/crates/engine/src/session/documents.rs b/crates/engine/src/session/documents.rsnew file mode 100644index 000000000..b0bf0f792--- /dev/null+++ b/crates/engine/src/session/documents.rs@@ -0,0 +1,294 @@+use super::*;++impl Session {+ /// A session with no document open, the default preferences and the Selection tool. It also+ /// installs the hooks the document crate calls back into: the loader and file reader of placed+ /// documents, and where an image's effects draw its fills and strokes, for clicks.+ pub fn new() -> Self {+ // Placed documents are read by the native format's loader.+ vectorcraft_doc::placed_document::set_loader(cmd::place::document::read_document);+ vectorcraft_doc::placed_document::set_file_reader(cmd::place::document::read_file_again);+ vectorcraft_doc::placed_document::set_read_check(|path| file_access::check_read(path).is_ok());+ // The background workers of placed documents read files in the scope that asked.+ vectorcraft_render::placed_document::set_scope_capture(|| {+ let scope = file_access::ScopeHandle::capture();+ Box::new(move |f: &mut dyn FnMut()| scope.run(f))+ });+ // Clicks find an image's own fills and strokes where their effects draw them.+ vectorcraft_doc::hit::set_image_paint(vectorcraft_render::effects::image_paint);+ // OpenType SVG glyphs are drawn as the SVG importer reads their documents.+ vectorcraft_text::set_svg_glyph_reader(vectorcraft_svg::glyph_art);+ Self {+ docs: vec![],+ active: None,+ prefs: Prefs::default(),+ paint: PaintDefaults::default(),+ fill_active: true,+ clipboard: Clipboard::default(),+ journal: Journal::default(),+ tool: vectorcraft_tools::create("selection"),+ lender: None,+ last_selection_tool: None,+ last_view: ViewInfo::default(),+ preview_memo: Default::default(),+ depth: 0,+ tool_panic: None,+ tool_resets: 0,+ tool_set_since_reset: false,+ draw_mode: DrawMode::Normal,+ draw_inside: None,+ untitled_counter: 0,+ menu: Default::default(),+ gradient_stop: None,+ active_appearance_item: None,+ last_solid: Color::WHITE,+ last_gradient: GradientPaint::new(Default::default()),+ recent_colors: vec![],+ pending_paint: None,+ swatch_libraries: Default::default(),+ freeform_point: None,+ style_libraries: Default::default(),+ symbol_libraries: Default::default(),+ brush_libraries: Default::default(),+ libraries: Default::default(),+ pdf_preset_dir: None,+ profile_dir: None,+ plugin_dir: None,+ plugin_output: None,+ recent_urls: vec![],+ ui_language: None,+ journal_note: Default::default(),+ note_depth: 1,+ journal_query: false,+ explicit_undo_group: None,+ batch_stash: None,+ batch_steps: None,+ place_hand_off: None,+ queue_hand_off: None,+ place_cursor_requests: false,+ package_hand_off: None,+ screens_hand_off: None,+ recovery: Default::default(),+ in_tool_actions: false,+ previewing: false,+ envelope_defaults: None,+ liquify_stroke: None,+ plane_widget_press: false,+ pointer_held: false,+ ruler_guide: None,+ port_marks: Default::default(),+ font_search: None,+ link_search: None,+ search_rules: None,+ deferred_overlay_cache: None,+ search_threads: None,+ link_stamps: Default::default(),+ link_scan: None,+ global_edit_options: Default::default(),+ }+ }++ pub fn documents(&self) -> &[DocState] {+ &self.docs+ }++ /// The open document with [`DocState::uid`] `uid` (it may have closed since it was looked up).+ pub fn document_mut(&mut self, uid: u64) -> Option<&mut DocState> {+ self.docs.iter_mut().find(|d| d.uid == uid)+ }++ pub fn active_index(&self) -> Option<usize> {+ self.active+ }++ pub fn active(&self) -> Option<&DocState> {+ self.active.and_then(|i| self.docs.get(i))+ }++ pub fn active_mut(&mut self) -> Option<&mut DocState> {+ self.active.and_then(|i| self.docs.get_mut(i))+ }++ pub fn doc(&self) -> Result<&DocState> {+ self.active().ok_or(EngineError::NoDocument)+ }++ pub fn doc_mut(&mut self) -> Result<&mut DocState> {+ self.active_mut().ok_or(EngineError::NoDocument)+ }++ /// Finish the tool's pending work in the current document and give it fresh state, so nothing+ /// (e.g. uncommitted typing) leaks into the document we are switching to.+ fn reset_tool_for_doc_switch(&mut self) {+ if self.active.is_none() {+ return;+ }+ let view = self.last_view;+ // The switch goes on whatever the lent tool's last actions did, as for the deactivation.+ let _ = self.give_back_tool(view);+ let acts = self.with_tool_cx(view, |t, cx| t.deactivate(cx));+ let _ = self.apply_actions(acts);+ // A batch leaves its interaction open in the document it leaves, to keep or roll back with+ // the rest of the batch; anything else in progress (a drag) is cancelled.+ if self.batch_stash.is_none() {+ let _ = self.cancel_interaction();+ }+ self.keep_tool_settings();+ self.tool = self.make_tool(self.tool.id());+ self.tool_resets = self.tool_resets.wrapping_add(1);+ self.tool_set_since_reset = false;+ }++ pub fn set_active(&mut self, index: usize) -> bool {+ if index < self.docs.len() {+ if self.active != Some(index) {+ self.reset_tool_for_doc_switch();+ }+ self.active = Some(index);+ true+ } else {+ false+ }+ }++ /// The name [`Session::next_untitled`] gives next (New Document's Name field).+ pub fn peek_untitled(&self) -> String {+ format!("Untitled-{}", self.untitled_counter + 1)+ }++ pub fn next_untitled(&mut self) -> String {+ self.untitled_counter += 1;+ format!("Untitled-{}", self.untitled_counter)+ }++ /// Text layout bounds are a cache (not saved): compute them for a document just read, or+ /// selection boxes and hit testing would use the rough estimate until each text is edited, and+ /// what is fitted to type's bounds (an envelope warping it) would come out differently. That+ /// holds for the type in symbol definitions, pattern tiles, graph designs and opacity masks too,+ /// not only in the layers (#1738).+ pub(crate) fn refresh_text_bounds(doc: &mut Document) {+ // Inline graphics in text take their size from their symbols' art (not saved either).+ doc.resolve_inline_art();+ let trees = doc.layers.iter_mut().chain(doc.symbols.iter_mut().map(|s| &mut s.art));+ let trees = trees.chain(doc.graph_designs.iter_mut().map(|g| &mut g.art));+ for tree in trees.chain(doc.patterns.iter_mut().flat_map(|p| p.art.iter_mut())) {+ refresh_tree_text_bounds(tree);+ }+ }++ /// Add a document and make it active. Between `edit.undoGroup.begin` and `edit.undoGroup.end`,+ /// an undo group with the begun group's name opens in it: here outside a command, and after the+ /// command that adds it otherwise ([`Session::execute`]).+ pub fn add_document(&mut self, mut doc: Document, path: Option<String>) -> usize {+ // Every edit is checked against the document before it, so the first one is within the cap+ // (importers and the native reader have seen to theirs already, with a warning).+ doc.limit_depth();+ Self::refresh_text_bounds(&mut doc);+ // Guides from files saved before guides had layers go on a layer.+ doc.adopt_guides();+ cmd::dimension::conform(&mut doc);+ self.reset_tool_for_doc_switch();+ let mut st = DocState::new(doc, path);+ st.history.limit = self.prefs.history_states as usize;+ self.docs.push(st);+ let i = self.docs.len() - 1;+ self.active = Some(i);+ if self.depth == 0+ && let Some(label) = self.explicit_undo_group.clone()+ {+ self.begin_named_undo_group(label);+ }+ i+ }++ /// Replace the document in tab `index` (File → Revert): new content, cleared history and+ /// selection, saved state. The tab keeps its place, path, format and view.+ pub fn replace_document(&mut self, index: usize, mut doc: Document) -> bool {+ if index >= self.docs.len() {+ return false;+ }+ doc.limit_depth();+ Self::refresh_text_bounds(&mut doc);+ doc.adopt_guides();+ cmd::dimension::conform(&mut doc);+ if self.active == Some(index) {+ // Pending tool work (typing, a drag) belongs to the content being thrown away.+ self.reset_tool_for_doc_switch();+ }+ let old = &self.docs[index];+ let mut st = DocState::new(doc, old.path.clone());+ st.history.limit = old.history.limit;+ // Same open document (caches keyed by uid stay valid); a new revision redraws it.+ st.uid = old.uid;+ st.revision = old.revision + 1;+ st.format = old.format;+ st.save_options = old.save_options.clone();+ // The remembered artboard pick follows the artboards it named when the file read back has+ // the artboards the document had at the save, in the same order and with the same ids (a+ // native file keeps them; a PDF's pages get new ids in page order); otherwise it is left+ // out.+ if old.save_artboards.is_empty() || st.doc.artboards.iter().map(|a| a.id).eq(old.save_artboards.iter().copied()) {+ st.save_artboards = old.save_artboards.clone();+ } else {+ for k in cmd::fileio::ARTBOARD_PARAMS {+ st.save_options.remove(k);+ }+ }+ st.converted = old.converted;+ st.imported_from = old.imported_from.clone();+ st.import_losses = old.import_losses.clone();+ st.view = old.view.clone();+ st.layers_open = old.layers_open.clone();+ let old = std::mem::replace(&mut self.docs[index], st);+ if let Some(stash) = &mut self.batch_stash {+ stash.push(old);+ }+ true+ }++ pub fn close_document(&mut self, index: usize) -> bool {+ if index >= self.docs.len() {+ return false;+ }+ self.reset_tool_for_doc_switch();+ // Closed (saved or discarded): nothing left to recover.+ let uid = self.docs[index].uid;+ cmd::recovery::forget(self, uid);+ let old = self.docs.remove(index);+ if let Some(stash) = &mut self.batch_stash {+ stash.push(old);+ }+ self.active = if self.docs.is_empty() { None } else { Some(index.min(self.docs.len() - 1)) };+ true+ }++ /// Commands with enablement (for menus, palette, MCP `list_commands`).+ pub fn commands(&self) -> Vec<CommandInfo> {+ command_specs().iter().map(|c| c.info(self)).collect()+ }+}++/// Lay out the type in tree `n` (opacity mask art included) whose bounds aren't cached. Only the+/// nodes on the way to such type are copied.+fn refresh_tree_text_bounds(n: &mut Arc<vectorcraft_doc::Node>) {+ fn stale(n: &vectorcraft_doc::Node) -> bool {+ matches!(&n.kind, NodeKind::Text(t) if t.cached_bounds.is_none())+ || n.extras().mask.as_deref().is_some_and(|m| stale(&m.art))+ || n.children().is_some_and(|ch| ch.iter().any(|c| stale(c)))+ }+ if !stale(n) {+ return;+ }+ let n = Arc::make_mut(n);+ if let NodeKind::Text(t) = &mut n.kind+ && t.cached_bounds.is_none()+ {+ cmd::typecmd::refresh_bounds(t);+ }+ if let Some(m) = n.extras_if_any().and_then(|e| e.mask.as_deref_mut()) {+ refresh_tree_text_bounds(&mut m.art);+ }+ for c in n.children_mut().into_iter().flatten() {+ refresh_tree_text_bounds(c);+ }+}diff --git a/crates/engine/src/session/edit.rs b/crates/engine/src/session/edit.rsnew file mode 100644index 000000000..6e9267720--- /dev/null+++ b/crates/engine/src/session/edit.rs@@ -0,0 +1,300 @@+use super::*;++impl Session {+ /// Run `f` on a mutable copy of the active document. Outside an interaction this records one+ /// undo step labelled `label`; inside one it just mutates (the interaction commits later).+ pub fn edit<T>(&mut self, label: &str, f: impl FnOnce(&mut Document, &mut Selection) -> Result<T>) -> Result<T> {+ // An edit made while typing (the Transform panel) is a step of its own: inside the typing+ // session, the next keystroke's preview would start again from before it (#1881).+ if !self.previewing && cmd::typing_in_progress(self) {+ cmd::settle_interaction(self)?;+ }+ let menu = self.menu.clone();+ let st = self.doc_mut()?;+ let before = st.doc.clone();+ let before_sel = st.selection.clone();+ let doc = Arc::make_mut(&mut st.doc);+ // The Global Edit members the edit reached besides the selection.+ let mut spread = vec![];+ // Objects attached to a path follow it, and dimensions follow the art they measure.+ let result = match f(doc, &mut st.selection).and_then(|v| {+ // Global Edit: the other members take what the edit changed about the one it edited.+ if let Some(ge) = &st.global_edit {+ spread = cmd::globaledit::propagate(&before, doc, ge, [&before_sel.objects, &st.selection.objects]);+ }+ cmd::objects_on_path::refresh(&before, doc);+ cmd::dimension::refresh(&before, doc)?;+ Ok(v)+ }) {+ Ok(v) => match cmd::shaper::refresh(&before, Arc::make_mut(&mut st.doc)) {+ Err(e) => Err(e),+ Ok(()) => {+ // Attached Shaper groups whose art was rebuilt go back on their path.+ cmd::objects_on_path::refresh(&before, Arc::make_mut(&mut st.doc));+ // Inline graphics in text follow their symbols.+ cmd::inline::refresh(&before, Arc::make_mut(&mut st.doc));+ // Text Wrap: area type follows its wrap objects; then threads re-flow.+ cmd::textwrap::refresh(Arc::make_mut(&mut st.doc));+ // Type in no thread numbers its list paragraphs from 1 (before the mask copies+ // its editing layer's art).+ cmd::threads::restart_unthreaded_counts(&mut st.doc);+ // Opacity-mask editing: the mask follows its art on the editing layer.+ if st.doc.mask_edit.is_some() {+ cmd::maskedit::sync(Arc::make_mut(&mut st.doc));+ }+ // Threaded text re-flows when any of its frames changed.+ if !st.doc.text_threads.is_empty() {+ cmd::threads::reflow(&before, Arc::make_mut(&mut st.doc));+ }+ // Asset Export: assets let go of deleted art.+ if !st.doc.assets.is_empty() {+ Arc::make_mut(&mut st.doc).prune_assets();+ }+ // Variables: bindings let go of deleted art.+ if !st.doc.variables.bindings.is_empty() {+ Arc::make_mut(&mut st.doc).prune_variable_bindings();+ }+ if st.doc.too_deep(Some(&before)) {+ // Deeper trees overflow the stack of what walks them.+ Err(EngineError::Other(TOO_DEEP.into()))+ } else if doc_sane(&st.doc, &st.selection) && objects_in_range(&st.doc, &spread) {+ Ok(v)+ } else {+ Err(EngineError::Other("result would exceed the canvas (coordinates out of range)".into()))+ }+ }+ },+ Err(e) => Err(e),+ };+ match result {+ Ok(v) => {+ st.selection.prune(&st.doc);+ // An edit that selects what it unlocks, shows or pastes leaves locked guides out,+ // and one that selects the slices it makes leaves them out while they are locked+ // or hidden.+ deselect_hidden(&menu, &st.doc, &mut st.selection);+ // The art on a locked artboard can't stay selected, however it got there, except+ // the new art this edit made and new art still selected.+ st.protect_locked_artboards(&before_sel.objects, &before_sel.new_art, Some(&*before));+ st.revision += 1;+ if st.interaction.is_none() {+ let selection = match st.history.undo.last() {+ Some(l) if *l.selection == before_sel => l.selection.clone(),+ _ => Arc::new(before_sel),+ };+ st.push_undo(label.to_string(), before, selection);+ }+ Ok(v)+ }+ Err(e) => {+ st.doc = before;+ st.selection = before_sel;+ cmd::globaledit::follow_history(st);+ Err(e)+ }+ }+ }++ /// [`Session::edit`] with the step named `template`, its `{name}` placeholder filled with `name`+ /// (a style's name). The undo step it records keeps the template and the name+ /// ([`HistoryEntry::named`]), and a frontend shows the template's translation with the name in+ /// it. An edit that records no step of its own (inside an interaction, or a later edit of an+ /// undo group) keeps neither, and neither does a step an undo group names.+ pub fn edit_named<T>(+ &mut self,+ template: &'static str,+ name: &str,+ built_in: bool,+ f: impl FnOnce(&mut Document, &mut Selection) -> Result<T>,+ ) -> Result<T> {+ let named = NamedStep { template, name: name.to_string(), built_in };+ let step = named.label();+ // The step this edit records keeps the document as it is now.+ let now = Arc::as_ptr(&self.doc()?.doc);+ let v = self.edit(&step, f)?;+ if let Ok(st) = self.doc_mut()+ && let Some(e) = st.history.undo.last_mut()+ && Arc::as_ptr(&e.doc) == now+ && e.label == step+ {+ e.named = Some(named);+ }+ Ok(v)+ }++ /// Change only the selection (not an undo step).+ pub fn select(&mut self, f: impl FnOnce(&Document, &mut Selection)) -> Result<()> {+ self.active_appearance_item = None;+ let menu = self.menu.clone();+ let st = self.doc_mut()?;+ let before = st.selection.objects.clone();+ let new_art = st.selection.new_art.clone();+ f(&st.doc, &mut st.selection);+ st.selection.prune(&st.doc);+ // Lock Guides locks the paths made into guides too (#1534), and Lock Slices and Hide+ // Slices keep the slices out, whatever selects them.+ deselect_hidden(&menu, &st.doc, &mut st.selection);+ // The art on a locked artboard can't be selected, whatever selects it, except new art+ // that was selected and still is.+ st.protect_locked_artboards(&before, &new_art, None);+ // Selecting art makes its layer (or sublayer) the current one, as in the Layers panel of+ // the reference app: new art then goes beside it.+ if st.selection.objects != before+ && let Some(layer) = st.selection.objects.last().and_then(|id| st.doc.layer_containing(*id)).filter(|l| st.doc.is_editable(*l))+ && st.active_layer != Some(layer)+ {+ st.active_layer = Some(layer);+ st.layer_rows.clear();+ }+ st.revision += 1;+ // Puppet Warp pins belong to the art they were placed on: another selection starts afresh.+ if st.doc.puppet.as_ref().is_some_and(|p| p.ids != st.selection.objects) {+ cmd::distortcmds::drop_puppet_pins(st);+ }+ Ok(())+ }++ // ---------- 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(());+ }+ st.interaction = Some(Interaction {+ label: label.to_string(),+ doc: st.doc.clone(),+ selection: Arc::new(st.selection.clone()),+ preview: None,+ active_layer: st.active_layer,+ layer_rows: st.layer_rows.clone(),+ variables_highlight: st.variables_highlight.clone(),+ isolation: st.isolation,+ perspective_again: None,+ copies: None,+ });+ Ok(())+ }++ /// Re-apply `cmd` on top of the interaction snapshot (replacing the previous preview).+ pub fn preview(&mut self, cmd: &str, params: &Value) -> Result<Value> {+ {+ let menu = self.menu.clone();+ let st = self.doc_mut()?;+ let Some(it) = &st.interaction else { return Err(EngineError::Other("no interaction in progress".into())) };+ // Undoing the previous preview counts as a change, so views redraw even when the command+ // below returns without an edit.+ let selection_changed = st.selection != *it.selection;+ if !Arc::ptr_eq(&st.doc, &it.doc) || selection_changed {+ st.revision += 1;+ }+ st.doc = it.doc.clone();+ if selection_changed {+ st.selection.clone_from(&it.selection);+ }+ // Guides locked and slices locked or hidden during the interaction stay deselected,+ // even when the preview fails.+ deselect_hidden(&menu, &st.doc, &mut st.selection);+ cmd::globaledit::follow_history(st);+ }+ // The previous preview's paint is undone with it.+ self.pending_paint = None;+ let rw = cmd::distortcmds::perspective_rewrite(self, cmd, params).or_else(|| cmd::bounds_rewrite(self, cmd, params));+ let (cmd, params) = rw.as_ref().map_or((cmd, params), |(c, p)| (c.as_str(), p));+ let outer = std::mem::replace(&mut self.previewing, true);+ let r = self.execute(cmd, params);+ self.previewing = outer;+ let params = self.noted(params);+ let st = self.doc_mut()?;+ if let Some(it) = &mut st.interaction {+ // A failed preview leaves the document at the snapshot, so nothing is left to commit+ // (not even an earlier successful preview, which the reset above already undid).+ it.preview = r.is_ok().then(|| (cmd.to_string(), params));+ }+ r+ }++ 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(()) };+ let Some(preview) = it.preview.take() else { return Ok(()) };+ let perspective_again = it.perspective_again.take();+ let copy = preview.0 == "object.transform" && preview.1.get("copy").and_then(Value::as_bool).unwrap_or(false);+ // Alt pressed or released during a move drag turns it into a copy or back: name it for+ // what it did in the end.+ match (it.label.as_str(), copy) {+ ("Move", true) => it.label = "Copy".into(),+ ("Copy", false) if preview.0 == "object.transform" => it.label = "Move".into(),+ _ => {}+ }+ // A preview that left the document as it was records no Transform Again either (as+ // `keep_interaction` records no undo step): the last real transformation stands.+ let changed = !Arc::ptr_eq(&it.doc, &st.doc);+ st.keep_interaction(it);+ if preview.0 == "object.transform" {+ let m = cmd::matrix_param(&preview.1, "matrix");+ if let Some(m) = m {+ // The options are the last preview's params with the values it noted, without the+ // matrix and the ids.+ let mut options = preview.1.clone();+ if let Some(o) = options.as_object_mut() {+ o.remove("matrix");+ o.remove("ids");+ }+ st.last_transform = Some(LastTransform::Matrix(m, options));+ st.last_perspective = None;+ }+ } else if preview.0 == "object.transformEach" && changed {+ // Transform Again repeats it as it stood when OK was pressed.+ st.last_transform = Some(LastTransform::Each(preview.1.clone()));+ st.last_perspective = None;+ }+ if perspective_again.is_some() {+ st.last_perspective = perspective_again;+ }+ let (doc, journal, grouped) = (self.active().map(|d| d.uid), self.journal.len(), self.undo_group_docs());+ self.journal.push(preview);+ self.journal_in_undo_groups(doc, &grouped, journal);+ Ok(())+ }++ /// Remember the paint a live preview applied (as its interaction is kept).+ pub(crate) fn remember_pending_paint(&mut self) {+ if let Some(p) = self.pending_paint.take() {+ self.remember_paint_now(&p);+ }+ }++ pub fn cancel_interaction(&mut self) -> Result<()> {+ self.clear_deferred_overlay_cache();+ self.pending_paint = None;+ let menu = self.menu.clone();+ let st = self.doc_mut()?;+ st.undo_interaction();+ // Guides locked and slices locked or hidden during the interaction stay deselected.+ deselect_hidden(&menu, &st.doc, &mut st.selection);+ Ok(())+ }++ pub fn in_interaction(&self) -> bool {+ self.active().is_some_and(|d| d.interaction.is_some())+ }+}diff --git a/crates/engine/src/session/execute.rs b/crates/engine/src/session/execute.rsnew file mode 100644index 000000000..45ede81e5--- /dev/null+++ b/crates/engine/src/session/execute.rs@@ -0,0 +1,229 @@+use super::*;++impl Session {+ /// `spec`'s `enabled` with `ids` selected instead of the selection, which is then put back.+ fn enabled_with_selection(&mut self, spec: &CommandSpec, ids: Vec<NodeId>) -> std::result::Result<(), String> {+ let Some(d) = self.active_mut() else { return (spec.enabled)(self) };+ let old = std::mem::replace(&mut d.selection, Selection { objects: ids, ..Selection::default() });+ let r = (spec.enabled)(self);+ if let Some(d) = self.active_mut() {+ d.selection = old;+ }+ r+ }++ /// Error, under the command's own id, at the first of `ids` that is malformed, names no node, or+ /// names a layer or sublayer: a command in [`SELECTS_GIVEN_IDS`] acts on objects.+ fn check_given_ids(&self, id: &str, params: &Value) -> Result<()> {+ let (Some(st), Some(ids)) = (self.active(), params.get("ids")) else { return Ok(()) };+ let Some(given) = ids.as_array() else { return cmd::checked_ids_param(self, params, "ids", id).map(drop) };+ for value in given {+ let node = cmd::checked_id(self, value, id)?;+ if st.doc.node(node).is_some_and(|n| n.is_layer()) {+ return Err(if id.starts_with("object.arrange.") {+ cmd::bad(id, format!("id {value} is a layer, not an object; move layers with layer.move"))+ } else {+ cmd::bad(id, format!("id {value} is a layer, not an object"))+ });+ }+ }+ Ok(())+ }++ /// Execute a command by id. This is THE entry point for every frontend.+ pub fn execute(&mut self, id: &str, params: &Value) -> Result<Value> {+ let spec = find_command(id).ok_or_else(|| cmd::params::unknown_command(id))?;+ // The crate's own tests are the audit of the params descriptions (#1442): a key a test+ // passes that its command's description doesn't name fails the test.+ #[cfg(test)]+ self.check_params(id, params)?;+ // Objects given as `id` (where it stands for `ids` of one) or as `ids` beside it are checked+ // before anything else: a malformed one, or one naming no object, is an error under this+ // command's id, never the selection in its place. `effect.apply {id: "stylize.dropShadow"}`+ // without `effect` names the effect (its older key), not an object.+ let effect_named = id == "effect.apply"+ && params.get("effect").is_none()+ && params.get("ids").is_none_or(Value::is_null)+ && params.get("id").and_then(Value::as_str).is_some_and(|e| !e.starts_with('$'));+ if cmd::params::id_stands_for_ids(spec.params) && !effect_named && self.active().is_some() {+ cmd::given_objects(self, params, id)?;+ }+ if SELECTS_GIVEN_IDS.contains(&id) {+ self.check_given_ids(id, params)?;+ }+ // Clear's menu needs a selection; an agent supplying explicit targets only needs a+ // document. The command validates those targets before making any edit.+ let given = given_ids(spec.params, params);+ let enabled = if id == "edit.clear" && params.get("ids").is_some() {+ cmd::has_doc(self)+ } else if let Some(ids) = given.clone() {+ // Objects given as `ids` (or `id`) stand in for the selection: the command is enabled+ // as it is with them selected (#1575).+ self.enabled_with_selection(spec, ids)+ } else {+ (spec.enabled)(self)+ };+ if let Err(why) = enabled {+ return Err(EngineError::Disabled(id.to_string(), why));+ }+ // Only top-level commands are journaled (commands that call other commands would otherwise+ // be recorded twice and replay differently).+ if self.depth == 0 {+ self.journal_note.clear();+ self.note_depth = 1;+ self.journal_query = false;+ self.batch_stash = None;+ self.batch_steps = None;+ }+ // A selection-only command given `ids` (or `id`) selects them first, in the same undo step+ // (#2130); when the command then fails, the selection (and the current layer selecting+ // them made current) goes back to how it was, as when the ids are refused.+ let select_first = SELECTS_GIVEN_IDS+ .contains(&id)+ .then(|| {+ params.get("ids").filter(|v| !v.is_null()).cloned().or_else(|| given.map(|ids| ids.iter().map(|i| i.0).collect::<Vec<_>>().into()))+ })+ .flatten();+ let selected_before = select_first.as_ref().and(self.active()).map(|d| (d.uid, d.selection.clone(), d.active_layer));+ let run = |s: &mut Session| {+ if let Some(ids) = &select_first {+ s.execute("select.set", &serde_json::json!({ "ids": ids }))?;+ }+ let r = (spec.run)(s, params);+ if r.is_err()+ && let Some((uid, selection, layer)) = selected_before+ && let Some(st) = s.docs.iter_mut().find(|d| d.uid == uid)+ {+ st.selection = selection;+ st.active_layer = layer;+ st.revision += 1;+ }+ r+ };+ // The entries the command journals belong to the undo groups of the documents it edits, and to+ // the group of the document it starts in when it ends there too.+ let (doc, journal, grouped) = (self.active().map(|d| d.uid), self.journal.len(), self.undo_group_docs());+ let open = (self.depth == 0).then(|| self.docs.iter().map(|d| d.uid).collect::<Vec<_>>());+ let r = if self.depth == 0 { self.run_guarded(id, run) } else { self.run_nested(run) };+ let r = r?;+ if self.depth == 0 {+ self.inherit_new_art();+ }+ if let Some(open) = open {+ self.open_undo_groups_in_new_documents(&open);+ }+ let journaled = spec.journal || (self.depth == 0 && std::mem::take(&mut self.journal_query));+ if journaled && self.depth == 0 && self.active().is_none_or(|d| d.interaction.is_none()) {+ let p = self.noted(params);+ self.journal.push((id.to_string(), p));+ }+ if self.depth == 0 {+ self.journal_in_undo_groups(doc, &grouped, journal);+ self.after_command();+ }+ Ok(r)+ }++ /// Is the interface in Japanese? Then new type starts with em box top-to-top leading and em+ /// box centre character alignment (#432).+ pub fn japanese_interface(&self) -> bool {+ self.ui_language.as_deref().unwrap_or(&self.prefs.interface_language).eq_ignore_ascii_case("ja")+ }++ /// Record `key: value` in the running top-level command's journal entry (or its interaction's+ /// preview, or its step in a batch) unless its params give `key`: a value it resolved from the+ /// preferences or the clock.+ pub fn note_journal(&mut self, key: &str, value: Value) {+ if self.depth == self.note_depth {+ self.journal_note.insert(key.to_string(), value);+ }+ }++ /// Journal the running query command when it is the top-level command: it changed the+ /// selection (`document.find {select: true}`), so an action recorded around it repeats that.+ pub(crate) fn journal_query(&mut self) {+ if self.depth == 1 {+ self.journal_query = true;+ }+ }++ /// Run `id` as a step of the running command, which journals its steps (`command.batch`):+ /// → the step's result and its params with what it noted ([`Session::note_journal`]), for the+ /// step in the running command's journal entry.+ pub(crate) fn execute_step(&mut self, id: &str, params: &Value) -> Result<(Value, Value)> {+ let outer = (std::mem::take(&mut self.journal_note), self.note_depth);+ self.note_depth = self.depth + 1;+ let r = self.execute(id, params);+ let noted = self.noted(params);+ (self.journal_note, self.note_depth) = outer;+ Ok((r?, noted))+ }++ /// The journal from entry `start` on, as an action records it: without the params that only+ /// pin a replay to the original run ([`REPLAY_ONLY`]), so playing the action later acts now.+ pub fn journal_for_action(&self, start: usize) -> Vec<(String, Value)> {+ self.journal+ .since(start)+ .iter()+ .cloned()+ .map(|(id, mut p)| {+ strip_replay_only(&id, &mut p);+ (id, p)+ })+ .collect()+ }++ /// `params` with the noted values added (see [`Session::note_journal`]).+ pub(super) fn noted(&mut self, params: &Value) -> Value {+ let mut note = std::mem::take(&mut self.journal_note);+ match params {+ // The params' own values win.+ Value::Object(m) if !note.is_empty() => {+ note.extend(m.clone());+ Value::Object(note)+ }+ Value::Null if !note.is_empty() => Value::Object(note),+ _ => params.clone(),+ }+ }++ pub(crate) fn run_nested(&mut self, f: impl FnOnce(&mut Self) -> Result<Value>) -> Result<Value> {+ self.depth += 1;+ let r = f(self);+ self.depth -= 1;+ r+ }++ /// A top-level command: a panic (a bug) becomes [`EngineError::Internal`] and the active+ /// document goes back to how it was before the command, instead of crashing the frontend.+ pub(crate) fn run_guarded(&mut self, id: &str, f: impl FnOnce(&mut Self) -> Result<Value>) -> Result<Value> {+ let snapshot = self.active().map(|d| (d.uid, d.doc.clone(), d.selection.clone(), d.interaction.clone()));+ let active = self.active;+ let r = match guard::catch_panic(|| self.run_nested(f)) {+ Ok(r) => r,+ Err(msg) => {+ self.depth = 0;+ self.journal_note.clear();+ if let Some((uid, doc, selection, interaction)) = snapshot+ && let Some(st) = self.docs.iter_mut().find(|d| d.uid == uid)+ {+ st.doc = doc;+ st.selection = selection;+ st.interaction = interaction;+ cmd::globaledit::follow_history(st);+ st.revision += 1;+ }+ if active.is_some_and(|i| i < self.docs.len()) {+ self.active = active;+ }+ Err(EngineError::Internal { cmd: id.to_string(), msg })+ }+ };+ // Undo, Redo and a failed batch bring back documents with their selections: each document+ // gets its selection's new art on a locked artboard.+ for st in &mut self.docs {+ st.sync_new_art();+ }+ r+ }+}diff --git a/crates/engine/src/session/undo.rs b/crates/engine/src/session/undo.rsnew file mode 100644index 000000000..f9f06135f--- /dev/null+++ b/crates/engine/src/session/undo.rs@@ -0,0 +1,243 @@+use super::*;++impl Session {+ // ---------- undo groups (scrubbed numeric fields) ----------++ /// Open an undo group in the active document: until [`Session::end_undo_group`], the edits+ /// made there (commands, committed interactions) are one undo step. A scrubbed numeric field+ /// applies each value it passes as its own command, as a typed value is applied; the drag is+ /// one step.+ pub fn begin_undo_group(&mut self) {+ self.begin_named_undo_group(None);+ }++ /// [`Session::begin_undo_group`] with the undo step named `label` (else after its first edit).+ pub fn begin_named_undo_group(&mut self, label: Option<String>) {+ if let Some(st) = self.active_mut()+ && st.undo_group.is_none()+ {+ st.undo_group = Some(UndoGroup { first: None, journal: vec![], steps: vec![], label });+ }+ }++ /// Between `edit.undoGroup.begin` and `edit.undoGroup.end`, open an undo group with the begun+ /// group's name in each document that the top-level command just run opened or created (its+ /// [`DocState::uid`] is not in `open`). The group takes the edits after that command: the+ /// command's own edits there stay its undo step, and a canceled group keeps them, as the journal+ /// entry that made the document stays.+ pub(super) fn open_undo_groups_in_new_documents(&mut self, open: &[u64]) {+ let Some(label) = &self.explicit_undo_group else { return };+ for st in &mut self.docs {+ if !open.contains(&st.uid) && st.undo_group.is_none() {+ st.undo_group = Some(UndoGroup { first: None, journal: vec![], steps: vec![], label: label.clone() });+ }+ }+ }++ /// The documents with an undo group open ([`DocState::uid`]), each with the document it holds.+ pub(super) fn undo_group_docs(&self) -> Vec<(u64, *const Document)> {+ self.docs.iter().filter(|st| st.undo_group.is_some()).map(|st| (st.uid, Arc::as_ptr(&st.doc))).collect()+ }++ /// Note the journal entries from number `from` on in the undo groups they belong to: the group of+ /// each document in `grouped` ([`Session::undo_group_docs`] before the entries) that they changed,+ /// each group they opened and edited, and the group of the document with [`DocState::uid`] `doc`+ /// when they started in it and it is still the active one. A cancel drops them. The last entry of a command that changed the+ /// active document keeps the index of the document it left active. A `command.batch` entry also+ /// keeps, in each group, the steps that belong to it ([`Session::batch_steps`]).+ pub(super) fn journal_in_undo_groups(&mut self, doc: Option<u64>, grouped: &[(u64, *const Document)], from: usize) {+ let to = self.journal.len();+ let active = self.active().map(|d| d.uid);+ let switched = if active == doc { None } else { self.active };+ let batch = self.batch_steps.take().filter(|_| to > from && self.journal.get(to - 1).is_some_and(|(id, _)| id == "command.batch"));+ for st in &mut self.docs {+ let Some(g) = &mut st.undo_group else { continue };+ let started = doc == Some(st.uid) && active == doc;+ // A group the entries opened has an edit of theirs once it has a first edit.+ let edited = match grouped.iter().find(|&&(uid, _)| uid == st.uid) {+ Some(&(_, d)) => !std::ptr::eq(d, Arc::as_ptr(&st.doc)),+ None => g.first.is_some(),+ };+ if started || edited {+ // A committed interaction inside the command noted its entry already.+ let noted = g.journal.partition_point(|&(n, _)| n < from);+ g.journal.truncate(noted);+ g.journal.extend((from..to).map(|n| (n, switched.filter(|_| n + 1 == to))));+ g.steps.retain(|&(n, _)| n < from);+ if let Some(steps) = &batch {+ let own = steps.iter().enumerate().filter(|(_, (uids, _))| uids.contains(&st.uid));+ g.steps.push((to - 1, own.map(|(i, &(_, switched))| (i, switched)).collect()));+ }+ }+ }+ }++ /// Close the open undo groups: their edits stay one undo step or, `cancel`led (Escape), are+ /// undone and dropped from the journal. A group begun with `edit.undoGroup.begin` ends too, so+ /// documents opened after this open no undo group.+ pub fn end_undo_group(&mut self, cancel: bool) {+ self.explicit_undo_group = None;+ self.close_undo_groups(cancel, None);+ }++ /// [`Session::end_undo_group`] without ending a group begun with `edit.undoGroup.begin`, for the+ /// document with [`DocState::uid`] `only` alone when given. The groups that stay open follow the+ /// journal entries and batch steps of theirs that a cancel renumbers.+ fn close_undo_groups(&mut self, cancel: bool, only: Option<u64>) {+ let mut journal: Vec<(usize, Option<usize>)> = vec![];+ let mut steps: Vec<BatchSteps> = vec![];+ for st in &mut self.docs {+ if only.is_some_and(|uid| uid != st.uid) {+ continue;+ }+ let Some(g) = st.undo_group.take() else { continue };+ // Only while the group's step is still the newest one.+ if cancel+ && let Some(first) = g.first+ && st.history.undo.last().is_some_and(|e| Arc::ptr_eq(&e.doc, &first))+ && let Some(e) = st.history.undo.pop()+ {+ st.doc = e.doc;+ st.selection = Arc::unwrap_or_clone(e.selection);+ deselect_hidden(&self.menu, &st.doc, &mut st.selection);+ st.sync_new_art();+ cmd::globaledit::follow_history(st);+ st.revision += 1;+ // The journal drops only the canceled groups' own entries and keeps the ones made in other documents meanwhile.+ journal.extend(g.journal);+ steps.extend(g.steps);+ }+ }+ // A batch that edited two of the documents is in both groups.+ journal.sort_unstable();+ journal.dedup_by_key(|&mut (n, _)| n);+ // A batch with steps outside the canceled groups keeps those steps.+ let mut rewritten: Vec<(usize, Vec<Option<usize>>)> = vec![];+ journal.retain(|&(n, _)| match self.keep_batch_steps(n, &steps) {+ Some(kept) => {+ rewritten.push((n, kept));+ false+ }+ None => true,+ });+ // An entry that changed the active document becomes that change, so the entries after it run+ // in the same document when the journal is replayed.+ for &(n, index) in &journal {+ if let Some(index) = index {+ self.journal.replace(n, ("document.activate".to_string(), serde_json::json!({ "index": index })));+ }+ }+ let gone: Vec<usize> = journal.into_iter().filter(|(_, index)| index.is_none()).map(|(n, _)| n).collect();+ self.journal.remove(&gone);+ let below = |n: usize| gone.partition_point(|&m| m < n);+ for g in self.docs.iter_mut().filter_map(|st| st.undo_group.as_mut()) {+ g.journal.retain(|(n, _)| gone.binary_search(n).is_err());+ for (n, _) in &mut g.journal {+ *n -= below(*n);+ }+ g.steps.retain(|(n, _)| gone.binary_search(n).is_err());+ for (n, own) in &mut g.steps {+ if let Some((_, kept)) = rewritten.iter().find(|(r, _)| r == n) {+ own.retain_mut(|(i, _)| kept.get(*i).copied().flatten().map(|k| *i = k).is_some());+ }+ *n -= below(*n);+ }+ }+ }++ /// When journal entry `n` is a `command.batch` with `steps` noted in canceled undo groups and+ /// other steps that are not `document.activate`: rewrite its `commands` without the noted steps+ /// (a noted step that changed the active document becomes that change) → each step's number in+ /// the rewritten `commands`, `None` for a noted step. `None` leaves the entry to be dropped as a+ /// whole.+ fn keep_batch_steps(&mut self, n: usize, steps: &[BatchSteps]) -> Option<Vec<Option<usize>>> {+ let noted: Vec<(usize, Option<usize>)> = steps.iter().filter(|(e, _)| *e == n).flat_map(|(_, s)| s.iter().copied()).collect();+ let (id, entry) = self.journal.get(n).filter(|(id, _)| id == "command.batch" && steps.iter().any(|(e, _)| *e == n))?;+ let commands = entry.get("commands").and_then(Value::as_array)?;+ let kept = |i: usize| !noted.iter().any(|&(s, _)| s == i);+ let activate = |c: &Value| c.get("command").and_then(Value::as_str) == Some("document.activate");+ if commands.iter().enumerate().all(|(i, c)| !kept(i) || activate(c)) {+ return None;+ }+ let (mut rewritten, mut numbers) = (Vec::with_capacity(commands.len()), Vec::with_capacity(commands.len()));+ for (i, c) in commands.iter().enumerate() {+ if kept(i) {+ numbers.push(Some(rewritten.len()));+ rewritten.push(c.clone());+ } else {+ numbers.push(None);+ if let Some(index) = noted.iter().find(|&&(s, _)| s == i).and_then(|&(_, index)| index) {+ rewritten.push(serde_json::json!({ "command": "document.activate", "params": { "index": index } }));+ }+ }+ }+ let (id, mut entry) = (id.clone(), entry.clone());+ if let Some(o) = entry.as_object_mut() {+ o.insert("commands".into(), Value::Array(rewritten));+ }+ self.journal.replace(n, (id, entry));+ Some(numbers)+ }++ /// [`Session::end_undo_group`] for the open document with [`DocState::uid`] `uid` only (it may+ /// have closed since): its open undo group closes, and undo groups open in other documents stay+ /// open.+ fn end_document_undo_group(&mut self, uid: u64, cancel: bool) {+ self.close_undo_groups(cancel, Some(uid));+ }++ /// Make the edits that follow in the active document one undo step, until+ /// [`Session::end_undo_scope`]: open an undo group there or, when one is open already, join it,+ /// so that the edits are part of its step. `None` without a document.+ pub fn begin_undo_scope(&mut self) -> Option<UndoScope> {+ let journal = self.journal.len();+ let st = self.active()?;+ let uid = st.uid;+ let joined = st.undo_group.as_ref().map(|g| (st.doc.clone(), st.selection.clone(), g.first.clone()));+ if joined.is_none() {+ self.begin_undo_group();+ }+ Some(UndoScope { uid, journal, joined })+ }++ /// End `scope` in its own document, whichever document is active now; undo groups open in other+ /// documents stay open. The undo group the scope opened closes as [`Session::end_undo_group`]+ /// closes it. A scope that joined an open group leaves the group open; with `cancel`, it puts the+ /// document and its selection back as they were when the scope began and cuts the journal back to+ /// where the scope began (only while the group's step is still the newest one), and an undo step+ /// that the scope's first edit recorded goes too. The open undo groups drop the cut entries.+ pub fn end_undo_scope(&mut self, scope: UndoScope, cancel: bool) {+ let Some((doc, selection, first)) = scope.joined else {+ self.end_document_undo_group(scope.uid, cancel);+ return;+ };+ let menu = self.menu.clone();+ let Some(st) = self.document_mut(scope.uid) else { return };+ let Some(g) = &mut st.undo_group else { return };+ let newest = g.first.as_ref().is_some_and(|f| st.history.undo.last().is_some_and(|e| Arc::ptr_eq(&e.doc, f)));+ if !cancel || !newest {+ return;+ }+ match &first {+ // The scope's first edit recorded the group's step.+ None => {+ st.history.undo.pop();+ g.first = None;+ }+ Some(f) if g.first.as_ref().is_some_and(|now| Arc::ptr_eq(now, f)) => {}+ Some(_) => return,+ }+ st.doc = doc;+ st.selection = selection;+ cmd::globaledit::follow_history(st);+ deselect_hidden(&menu, &st.doc, &mut st.selection);+ st.history.recost_last(&st.doc);+ st.revision += 1;+ self.journal.truncate(scope.journal);+ // The next commands take the cut entries' numbers, so no open undo group keeps them.+ for g in self.docs.iter_mut().filter_map(|st| st.undo_group.as_mut()) {+ g.journal.retain(|&(n, _)| n < scope.journal);+ g.steps.retain(|&(n, _)| n < scope.journal);+ }+ }+}