mirror of
https://github.com/storytold/vectorcraft.git
synced 2026-11-17 09:36:45 +00:00
The Symbols panel and its panel menu asked for the current symbol on every frame by running symbol.list, which builds a row per symbol and walks the whole document once per symbol to count its instances. They now read it from the active document with cmd::current_symbol, the rule symbol.list itself uses for its `current`: the stored name while a symbol has it, else the first symbol. symbol.sortByName, symbol.place, symbol.options and text.insertInline use the same function, and symbol.list's reply is unchanged. An idle frame of the panel or its menu now runs no command, so on macOS the native menu is not brought up to date on every frame while the panel is open. In a document with 200 symbols and 50,000 objects the read takes 0.035 us instead of 48.5 ms in a release build (thread CPU time on Linux, median of 7 runs). The gain matters on large documents; on small ones it is too small to notice.
101 lines
5.1 KiB
Rust
101 lines
5.1 KiB
Rust
//! Inline graphics in text: document symbols placed in a run of text, flowing like a glyph
|
||
//! (beyond Illustrator; InDesign's inline anchored objects). See [`vectorcraft_doc::InlineArt`].
|
||
|
||
use serde_json::{Value, json};
|
||
use vectorcraft_doc::text::INLINE_MAX_SCALE;
|
||
use vectorcraft_doc::{Document, InlineArt, NodeId, NodeKind, TextRun};
|
||
use vectorcraft_text::edit;
|
||
|
||
use super::brushsym::current_symbol;
|
||
use super::typecmd::refresh_bounds;
|
||
use super::{CommandSpec, EngineError, Result, Session, bad, cmd, has_doc, id_param, str_param};
|
||
|
||
pub fn specs() -> Vec<CommandSpec> {
|
||
vec![cmd!(
|
||
"text.insertInline",
|
||
"Insert Inline Symbol",
|
||
["Type"],
|
||
None,
|
||
"{id?: text id (default: the text the Type tool edits), at?: byte offset (default: the Type tool's selection, which it replaces; clamped to the text), symbol?: symbol name (default: the Symbols panel's current symbol), scale?: art height ÷ font size = 1 (0 < scale ≤ 100), shift?: pt raise = 0} place a document symbol inline in the text as one character (U+FFFC) that flows like a glyph: its art is scaled to `scale` × the font size tall, its vertical centre on the middle of the cap height raised by `shift`. Typing, Backspace and Delete over it remove it whole → {id, caret}",
|
||
has_doc,
|
||
insert_inline
|
||
)]
|
||
}
|
||
|
||
/// Inline graphics follow their symbols: after an edit of a document that has (or had) symbols,
|
||
/// resolve the inline art of every text again, in the layers and in the art of symbols, graph
|
||
/// designs, pattern tiles and opacity masks, and lay out again the texts whose art changed (a
|
||
/// symbol's type before the type that shows that symbol inline).
|
||
pub(crate) fn refresh(before: &Document, d: &mut Document) {
|
||
if before.symbols.is_empty() && d.symbols.is_empty() {
|
||
return;
|
||
}
|
||
d.resolve_inline_art_with(&mut refresh_bounds);
|
||
}
|
||
|
||
fn insert_inline(s: &mut Session, p: &Value) -> Result<Value> {
|
||
const C: &str = "text.insertInline";
|
||
let tool = s.tool_options();
|
||
let editing = tool.get("editing").and_then(Value::as_u64).map(NodeId);
|
||
let id = match p.get("id") {
|
||
None | Some(Value::Null) => editing.ok_or_else(|| bad(C, "give `id` (no text is being edited)"))?,
|
||
Some(_) => id_param(p, "id").ok_or_else(|| bad(C, "`id` must be a node id"))?,
|
||
};
|
||
let doc = &s.doc()?.doc;
|
||
let NodeKind::Text(t) = &doc.node(id).ok_or(EngineError::NoNode(id))?.kind else {
|
||
return Err(bad(C, format!("node {} is not text", id.0)));
|
||
};
|
||
let len = edit::runs_len(&t.runs);
|
||
let from_tool = editing == Some(id);
|
||
let (a, b) = match p.get("at") {
|
||
None | Some(Value::Null) if from_tool => {
|
||
let g = |k: &str| tool.get(k).and_then(Value::as_u64).map_or(len, |v| (v as usize).min(len));
|
||
let (x, y) = (g("start"), g("end"));
|
||
(x.min(y), x.max(y))
|
||
}
|
||
None | Some(Value::Null) => (len, len),
|
||
Some(v) => {
|
||
let at = v.as_u64().ok_or_else(|| bad(C, "`at` must be a byte offset"))?.min(len as u64) as usize;
|
||
(at, at)
|
||
}
|
||
};
|
||
let symbol = match str_param(p, "symbol") {
|
||
Some(n) if doc.symbols.iter().any(|s| s.name == n) => n.to_string(),
|
||
Some(n) => return Err(bad(C, format!("no symbol named `{n}`"))),
|
||
None if p.get("symbol").is_some_and(|v| !v.is_null()) => return Err(bad(C, "`symbol` must be a symbol name")),
|
||
None => current_symbol(doc).ok_or_else(|| EngineError::Other("the document has no symbols".into()))?,
|
||
};
|
||
let scale = match p.get("scale") {
|
||
None | Some(Value::Null) => 1.0,
|
||
Some(v) => v
|
||
.as_f64()
|
||
.filter(|k| k.is_finite() && *k > 0.0 && *k <= INLINE_MAX_SCALE)
|
||
.ok_or_else(|| bad(C, "`scale` must be a number in (0, 100]"))?,
|
||
};
|
||
let shift = match p.get("shift") {
|
||
None | Some(Value::Null) => 0.0,
|
||
Some(v) => v.as_f64().filter(|k| k.is_finite() && k.abs() <= 1e5).ok_or_else(|| bad(C, "`shift` must be a number of points"))?,
|
||
};
|
||
// A typing session ends first: the insertion is a step of its own.
|
||
let typing = tool.get("typing").and_then(Value::as_bool) == Some(true);
|
||
if typing && from_tool {
|
||
s.set_tool_option("commitTyping", &Value::Bool(true));
|
||
s.commit_interaction()?;
|
||
}
|
||
let caret = s.edit("Insert Inline Symbol", |d, _| {
|
||
let mut art = InlineArt { scale, baseline_shift: shift, ..InlineArt::new(symbol.clone()) };
|
||
art.bounds = d.inline_art_bounds(&symbol);
|
||
let Some(NodeKind::Text(t)) = d.node_mut(id).map(|n| &mut n.kind) else { return Err(EngineError::NoNode(id)) };
|
||
let style = edit::insertion_style(&t.runs, a, b);
|
||
let caret = edit::replace_range_styled(&mut t.runs, a, b, &[TextRun::inline(art, style)]);
|
||
// The inline character is one plain-text byte range: ruby over it follows the text.
|
||
t.ruby_after_replace(a, b, vectorcraft_doc::text::INLINE_CHAR.len_utf8());
|
||
refresh_bounds(t);
|
||
Ok(caret)
|
||
})?;
|
||
if from_tool {
|
||
s.set_tool_option("select", &json!({"start": caret, "end": caret}));
|
||
}
|
||
Ok(json!({"id": id.0, "caret": caret}))
|
||
}
|