VectorCraft: An open-source, vector art tool written by scratch in pure Rust
Fonts: Find Font and Replace Missing Fonts reach the type in symbols
dotCooCoo82806d14417f
diff --git a/crates/engine/src/cmd/addons/cleanup/text.rs b/crates/engine/src/cmd/addons/cleanup/text.rsindex dd7cb6788..0d279c0f6 100644--- a/crates/engine/src/cmd/addons/cleanup/text.rs+++ b/crates/engine/src/cmd/addons/cleanup/text.rs@@ -12,6 +12,7 @@ use vectorcraft_doc::{CharStyle, Document, Justify, Node, NodeId, NodeKind, Parause vectorcraft_geom::{Affine, Point, Vec2};use vectorcraft_text::{FontDb, FontMatch, TextLayout, edit};+use crate::cmd::fonts::{edit_symbol_texts, symbol_texts};use crate::cmd::textedit::editing_range;use crate::cmd::typecmd::refresh_bounds;use crate::cmd::{CommandSpec, bad, checked_ids_or_selection, cmd, has_doc, has_selection, switch_or, text_param};@@ -107,7 +108,7 @@ pub fn specs() -> Vec<CommandSpec> {"Replace Missing Fonts…",["Object", "Plug-ins", "Artwork Cleanup"],None,- "{font?: family (default: the default type font, Source Sans 3; any of its names)} set every character of the document's type whose font family isn't available in `font`, in the style it has closest to the one each had, as one undo step → {runs (style runs changed), font}",+ "{font?: family (default: the default type font, Source Sans 3; any of its names)} set every character of the document's type (the type in the art of its symbols included) whose font family isn't available in `font`, in the style it has closest to the one each had, as one undo step → {runs (style runs changed), font}",has_doc,replace_fonts),@@ -918,24 +919,25 @@ fn replace_fonts(s: &mut Session, p: &Value) -> Result<Value> {_ => return Err(bad(C, "the replacement font is not available")),};let missing = |st: &CharStyle| db.resolve(&st.font_family, &st.font_style).is_none_or(|(_, m)| m == FontMatch::Missing);+ let lacks = |t: &TextObject| t.runs.iter().any(|r| missing(&r.style));let d = &s.doc()?.doc;let mut ids = vec![];for l in &d.layers {l.walk(&mut |n| {if let NodeKind::Text(t) = &n.kind- && t.runs.iter().any(|r| missing(&r.style))+ && lacks(t){ids.push(n.id);}});}- if ids.is_empty() {+ // The type in the symbols' art too, which exports name when its font is missing.+ if ids.is_empty() && !symbol_texts(d, None).into_iter().any(|(t, _)| lacks(t)) {return Err(EngineError::Other("No fonts are missing".into()));}let runs = s.edit("Replace Missing Fonts", |d, _| {let mut runs = 0;- for id in &ids {- let Some(NodeKind::Text(t)) = d.node_mut(*id).map(|n| &mut n.kind) else { continue };+ let mut replace = |t: &mut TextObject| {for r in t.runs.iter_mut().filter(|r| missing(&r.style)) {// The style the font has closest to the one the character had.r.style.font_style = db.face(&family, &r.style.font_style).map_or_else(|| r.style.font_style.clone(), |f| f.style.clone());@@ -946,7 +948,14 @@ fn replace_fonts(s: &mut Session, p: &Value) -> Result<Value> {}edit::normalize(&mut t.runs);refresh_bounds(t);+ };+ for id in &ids {+ if let Some(NodeKind::Text(t)) = d.node_mut(*id).map(|n| &mut n.kind) {+ replace(t);+ }}+ edit_symbol_texts(d, None, &|t, _| lacks(t), &mut replace);+ drop(replace);Ok(runs)})?;Ok(json!({ "runs": runs, "font": family }))diff --git a/crates/engine/src/cmd/addons/cleanup/text/tests.rs b/crates/engine/src/cmd/addons/cleanup/text/tests.rsindex 228628866..c75446b10 100644--- a/crates/engine/src/cmd/addons/cleanup/text/tests.rs+++ b/crates/engine/src/cmd/addons/cleanup/text/tests.rs@@ -339,3 +339,25 @@ fn replace_missing_fonts_with_the_default_or_a_chosen_font() {let r = s.execute("addon.cleanup.replaceFonts", &json!({"font": "No Such Font Family"}));assert!(matches!(r, Err(EngineError::BadParams { .. })), "{r:?}");}++#[test]+fn replace_missing_fonts_reaches_the_type_in_symbols() {+ let mut s = session();+ let gone = text(&mut s, json!({"x": 40, "y": 60, "text": "Lost", "size": 20, "font": "No Such Font Family"}));+ s.execute("symbol.new", &json!({"name": "Mark", "ids": [gone.0]})).unwrap();+ let family = |s: &Session| crate::cmd::fonts::symbol_texts(&s.doc().unwrap().doc, None)[0].0.runs[0].style.font_family.clone();+ assert_eq!(family(&s), "No Such Font Family");+ let r = s.execute("addon.cleanup.replaceFonts", &json!({})).unwrap();+ assert_eq!((r["runs"].as_u64(), r["font"].as_str()), (Some(1), Some("Source Sans 3")), "{r}");+ assert_eq!(family(&s), "Source Sans 3");+ assert_eq!(crate::cmd::fonts::substitution_warning(&s.doc().unwrap().doc), None);+ assert_eq!(other(s.execute("addon.cleanup.replaceFonts", &json!({}))), "No fonts are missing");+ // A symbol being edited: its type on the editing layer is replaced once.+ let gone = text(&mut s, json!({"x": 40, "y": 60, "text": "Lost", "size": 20, "font": "No Such Font Family"}));+ s.execute("symbol.new", &json!({"name": "Mark 2", "ids": [gone.0]})).unwrap();+ s.execute("symbol.edit", &json!({"name": "Mark 2"})).unwrap();+ let r = s.execute("addon.cleanup.replaceFonts", &json!({})).unwrap();+ assert_eq!(r["runs"].as_u64(), Some(1), "{r}");+ s.execute("symbol.exitEditing", &json!({})).unwrap();+ assert_eq!(crate::cmd::fonts::substitution_warning(&s.doc().unwrap().doc), None);+}diff --git a/crates/engine/src/cmd/fonts.rs b/crates/engine/src/cmd/fonts.rsindex cf3404c31..8e68987f9 100644--- a/crates/engine/src/cmd/fonts.rs+++ b/crates/engine/src/cmd/fonts.rs@@ -7,7 +7,7 @@ use std::sync::Arc;use serde_json::{Value, json};use vectorcraft_color::Paint;-use vectorcraft_doc::{AppearanceItem, Document, Node, NodeId, NodeKind, TextKind, TextRun};+use vectorcraft_doc::{AppearanceItem, Document, Node, NodeId, NodeKind, TextKind, TextObject, TextRun};use vectorcraft_geom::Rect;use super::typecmd::refresh_bounds;@@ -20,7 +20,7 @@ pub fn specs() -> Vec<CommandSpec> {"Fonts in Document",[],None,- "{selectionOnly?} → [{family, style, runs, objects, missing, status: exact|substitute|missing, resolved: {family, style}, missingGlyphs, version?: the installed version the type names (when it names one)}] sorted by name. A font is found by any of its names (ヒラギノ角ゴシック = Hiragino Sans) among the loaded and installed fonts; substitute: the family is there but not the style (resolved names the stand-in); missing: the family is unknown (the fallback family stands in); missingGlyphs: characters of its text the resolved font lacks (drawn by a fallback font)",+ "{selectionOnly?} (the type in the art of the symbols in scope included: all of the document's, or those the selected instances show) → [{family, style, runs, objects, missing, status: exact|substitute|missing, resolved: {family, style}, missingGlyphs, version?: the installed version the type names (when it names one)}] sorted by name. A font is found by any of its names (ヒラギノ角ゴシック = Hiragino Sans) among the loaded and installed fonts; substitute: the family is there but not the style (resolved names the stand-in); missing: the family is unknown (the fallback family stands in); missingGlyphs: characters of its text the resolved font lacks (drawn by a fallback font)",has_doc,fonts),@@ -29,7 +29,7 @@ pub fn specs() -> Vec<CommandSpec> {"Replace Font",[],None,- "{from: {family, style?}, to: {family (any of its names; stored as the font's own family name), style?}, selectionOnly?} (style omitted: every style of the family / keep the closest style); text that is hidden or locked, in a hidden or locked group or layer, or on a locked artboard keeps its font → {runs, skipped?: the text objects left in the font, warning?: text (some text was left in its font, or the style set isn't available: its type is drawn in the family's closest style)}",+ "{from: {family, style?}, to: {family (any of its names; stored as the font's own family name), style?}, selectionOnly?} (style omitted: every style of the family / keep the closest style); the type in the art of the symbols in scope changes too (all of the document's, or those the selected instances show, so every instance of them follows); text that is hidden or locked, in a hidden or locked group or layer (or group of a symbol's art), or on a locked artboard keeps its font → {runs, skipped?: the text objects left in the font, warning?: text (some text was left in its font, or the style set isn't available: its type is drawn in the family's closest style)}",has_doc,replace),@@ -38,7 +38,7 @@ pub fn specs() -> Vec<CommandSpec> {"Select Text by Font",[],None,- "{family, style?} select the text objects using the font that are not hidden or locked, in a hidden or locked group or layer, or on a locked artboard → {count}",+ "{family, style?} select the text objects using the font, and the instances of the symbols whose art uses it, that are not hidden or locked, in a hidden or locked group or layer, or on a locked artboard → {count}",has_doc,select_font),@@ -88,6 +88,113 @@ fn scope(s: &Session, selection_only: bool) -> Result<Vec<NodeId>> {Ok(v)}+/// Whether `name` is the symbol being edited, whose art is on the editing layer.+fn being_edited(d: &Document, name: &str) -> bool {+ d.symbol_edit.as_ref().is_some_and(|e| e.symbol == name)+}++/// The symbols that the selected objects of `s` show: those of the instances among them and their+/// descendants, and of the instances in those symbols' art that are not hidden or locked, nor in a+/// hidden or locked group of the art. Returned as (all of them, those shown by instances the+/// Selection tool can reach: not hidden or locked, as `Document::editable` says).+fn selected_symbols(s: &Session) -> Result<(BTreeSet<String>, BTreeSet<String>)> {+ fn open_instances(n: &Node, out: &mut BTreeSet<String>) {+ if !n.visible || n.locked {+ return;+ }+ if let NodeKind::SymbolInstance { symbol, .. } = &n.kind {+ out.insert(symbol.clone());+ }+ for c in n.children().map(Vec::as_slice).unwrap_or_default() {+ open_instances(c, out);+ }+ }+ let expand = |names: &mut BTreeSet<String>, d: &Document| loop {+ let mut more = BTreeSet::new();+ for sym in d.symbols.iter().filter(|sym| names.contains(&sym.name)) {+ open_instances(&sym.art, &mut more);+ }+ let before = names.len();+ names.extend(more);+ if names.len() == before {+ break;+ }+ };+ let st = s.doc()?;+ let (mut all, mut open) = (BTreeSet::new(), BTreeSet::new());+ let editable = st.doc.editable();+ for id in &st.selection.objects {+ if let Some(n) = st.doc.node(*id) {+ n.walk(&mut |c| {+ if let NodeKind::SymbolInstance { symbol, .. } = &c.kind {+ all.insert(symbol.clone());+ if editable(c.id) {+ open.insert(symbol.clone());+ }+ }+ });+ }+ }+ drop(editable);+ expand(&mut all, &st.doc);+ expand(&mut open, &st.doc);+ Ok((all, open))+}++/// The text objects in the art of `d`'s symbols (with `only`, of those it names), each with+/// whether it is open: neither it nor a group around it in the art is hidden or locked. The symbol+/// being edited is left out: its art is on the editing layer.+pub(super) fn symbol_texts<'a>(d: &'a Document, only: Option<&BTreeSet<String>>) -> Vec<(&'a TextObject, bool)> {+ fn visit<'a>(n: &'a Node, open: bool, out: &mut Vec<(&'a TextObject, bool)>) {+ let open = open && n.visible && !n.locked;+ if let NodeKind::Text(t) = &n.kind {+ out.push((&**t, open));+ }+ for c in n.children().map(Vec::as_slice).unwrap_or_default() {+ visit(c, open, out);+ }+ }+ let mut out = vec![];+ for s in d.symbols.iter().filter(|s| !being_edited(d, &s.name) && only.is_none_or(|o| o.contains(&s.name))) {+ visit(&s.art, true, &mut out);+ }+ out+}++/// Calls `f` on each text object in the art of `d`'s symbols (with `only`, of those it names) for+/// which `wants(text, open)` holds (open as in [`symbol_texts`]), the symbol being edited left out.+/// Art without such text is left as it is.+pub(super) fn edit_symbol_texts(+ d: &mut Document,+ only: Option<&BTreeSet<String>>,+ wants: &impl Fn(&TextObject, bool) -> bool,+ f: &mut impl FnMut(&mut TextObject),+) {+ fn wanted(n: &Node, open: bool, wants: &impl Fn(&TextObject, bool) -> bool) -> bool {+ let open = open && n.visible && !n.locked;+ matches!(&n.kind, NodeKind::Text(t) if wants(t, open)) || n.children().is_some_and(|ch| ch.iter().any(|c| wanted(c, open, wants)))+ }+ fn visit(n: &mut Node, open: bool, wants: &impl Fn(&TextObject, bool) -> bool, f: &mut impl FnMut(&mut TextObject)) {+ let open = open && n.visible && !n.locked;+ if let NodeKind::Text(t) = &mut n.kind+ && wants(t, open)+ {+ f(t);+ }+ for c in n.children_mut().into_iter().flatten() {+ if wanted(c, open, wants) {+ visit(Arc::make_mut(c), open, wants, f);+ }+ }+ }+ let edited = d.symbol_edit.as_ref().map(|e| e.symbol.clone());+ for s in &mut d.symbols {+ if edited.as_ref() != Some(&s.name) && only.is_none_or(|o| o.contains(&s.name)) && wanted(&s.art, true, wants) {+ visit(Arc::make_mut(&mut s.art), true, wants, f);+ }+ }+}+/// A font as type names it: family, style and, when it names one, the installed version.pub(super) type UsedFont = (String, String, Option<String>);@@ -375,17 +482,24 @@ fn text(d: &Document, id: NodeId) -> Option<&vectorcraft_doc::TextObject> {}fn fonts(s: &mut Session, p: &Value) -> Result<Value> {- let ids = scope(s, bool_or(p, "selectionOnly", false))?;+ let selection_only = bool_or(p, "selectionOnly", false);+ let ids = scope(s, selection_only)?;let d = &s.doc()?.doc;let db = vectorcraft_text::FontDb::global();- let mut found: BTreeMap<UsedFont, (usize, Vec<NodeId>, String)> = BTreeMap::new();- for id in ids {- for r in text(d, id).map(|t| t.runs.as_slice()).unwrap_or_default() {- let e = found.entry((r.style.font_family.clone(), r.style.font_style.clone(), r.style.font_version.clone())).or_default();+ // The type in the art of the symbols in scope too: all of them, or those the selection shows.+ let symbols = if selection_only { Some(selected_symbols(s)?.0) } else { None };+ let mut texts: Vec<&TextObject> = ids.iter().filter_map(|id| text(d, *id)).collect();+ texts.extend(symbol_texts(d, symbols.as_ref()).into_iter().map(|(t, _)| t));+ let mut found: BTreeMap<UsedFont, (usize, usize, String)> = BTreeMap::new();+ for t in texts {+ let mut seen = BTreeSet::new();+ for r in &t.runs {+ let font = (r.style.font_family.clone(), r.style.font_style.clone(), r.style.font_version.clone());+ let e = found.entry(font.clone()).or_default();e.0 += 1;e.2.push_str(&r.text);- if !e.1.contains(&id) {- e.1.push(id);+ if seen.insert(font) {+ e.1 += 1;}}}@@ -400,7 +514,7 @@ fn fonts(s: &mut Session, p: &Value) -> Result<Value> {lacking.dedup();lacking.retain(|c| !resolved.as_ref().is_some_and(|(f, _)| f.covers(*c)));let mut row = json!({- "family": family, "style": style, "runs": runs, "objects": objects.len(),+ "family": family, "style": style, "runs": runs, "objects": objects,"missing": status == vectorcraft_text::FontMatch::Missing,"status": status.as_str(),"resolved": resolved.as_ref().map(|(f, _)| json!({ "family": f.family, "style": f.style })),@@ -436,20 +550,36 @@ fn replace(s: &mut Session, p: &Value) -> Result<Value> {st.font_family.eq_ignore_ascii_case(&ff) && fs.as_ref().is_none_or(|x| st.font_style.eq_ignore_ascii_case(x))};// Only text the Selection tool can reach changes: not hidden or locked, in a hidden or locked- // group or layer, or on a locked artboard. The text left in the font is counted.+ // group or layer, or on a locked artboard. The text left in the font is counted. The type in+ // the art of the symbols in scope (all of them, or those the selection shows) changes too,+ // unless it or a group around it in the art is hidden or locked.+ let selection_only = bool_or(p, "selectionOnly", false);+ // With selectionOnly: the symbols the selection shows; those shown only by hidden or locked+ // instances keep their type, counted in `skipped`.+ let (symbols, closed) = if selection_only {+ let (all, open) = selected_symbols(s)?;+ let closed: BTreeSet<String> = all.difference(&open).cloned().collect();+ (Some(open), closed)+ } else {+ (None, BTreeSet::new())+ };+ let uses = |t: &TextObject| t.runs.iter().any(|r| matches(&r.style));let (ids, skipped) = {let d = &s.doc()?.doc;let editable = d.editable();- let (ids, other): (Vec<NodeId>, Vec<NodeId>) = scope(s, bool_or(p, "selectionOnly", false))?.into_iter().partition(|id| editable(*id));- let skipped = other.into_iter().filter(|id| text(d, *id).is_some_and(|t| t.runs.iter().any(|r| matches(&r.style)))).count();+ let (ids, other): (Vec<NodeId>, Vec<NodeId>) = scope(s, selection_only)?.into_iter().partition(|id| editable(*id));+ let mut skipped = other.into_iter().filter(|id| text(d, *id).is_some_and(uses)).count();+ skipped += symbol_texts(d, symbols.as_ref()).into_iter().filter(|(t, open)| !open && uses(t)).count();+ if !closed.is_empty() {+ skipped += symbol_texts(d, Some(&closed)).into_iter().filter(|(t, _)| uses(t)).count();+ }(ids, skipped)};// The fonts the replaced runs are set in, for the warning.let mut set = BTreeSet::new();let n = s.edit("Replace Font", |d, _| {let mut n = 0;- for id in &ids {- let Some(NodeKind::Text(t)) = d.node_mut(*id).map(|n| &mut n.kind) else { continue };+ let mut replace_in = |t: &mut TextObject| {let mut changed = false;for r in &mut t.runs {if matches(&r.style) {@@ -472,7 +602,14 @@ fn replace(s: &mut Session, p: &Value) -> Result<Value> {vectorcraft_text::edit::normalize(&mut t.runs);refresh_bounds(t);}+ };+ for id in &ids {+ if let Some(NodeKind::Text(t)) = d.node_mut(*id).map(|n| &mut n.kind) {+ replace_in(t);+ }}+ edit_symbol_texts(d, symbols.as_ref(), &|t, open| open && uses(t), &mut replace_in);+ drop(replace_in);Ok(n)})?;let mut out = json!({ "runs": n });@@ -499,17 +636,47 @@ fn select_font(s: &mut Session, p: &Value) -> Result<Value> {// Only text the Selection tool can reach: not hidden or locked, in a hidden or locked group// or layer, or on a locked artboard.let editable = d.editable();- let hits: Vec<NodeId> = ids- .into_iter()- .filter(|id| {- editable(*id)- && text(d, *id).is_some_and(|t| {- t.runs.iter().any(|r| {- r.style.font_family.eq_ignore_ascii_case(&family) && style.as_ref().is_none_or(|x| r.style.font_style.eq_ignore_ascii_case(x))- })- })- })- .collect();+ let uses = |t: &TextObject| {+ t.runs+ .iter()+ .any(|r| r.style.font_family.eq_ignore_ascii_case(&family) && style.as_ref().is_none_or(|x| r.style.font_style.eq_ignore_ascii_case(x)))+ };+ let mut hits: Vec<NodeId> = ids.into_iter().filter(|id| editable(*id) && text(d, *id).is_some_and(uses)).collect();+ // The symbols whose art uses the font in type that is not hidden or locked, nor in a hidden or+ // locked group of the art, also through the instances of other symbols it holds.+ fn reaches(n: &Node, uses: &impl Fn(&TextObject) -> bool, symbols: &BTreeSet<&str>) -> bool {+ n.visible+ && !n.locked+ && match &n.kind {+ NodeKind::Text(t) => uses(t),+ NodeKind::SymbolInstance { symbol, .. } => symbols.contains(symbol.as_str()),+ _ => n.children().is_some_and(|ch| ch.iter().any(|c| reaches(c, uses, symbols))),+ }+ }+ let mut symbols: BTreeSet<&str> = BTreeSet::new();+ loop {+ let found: Vec<&str> = d+ .symbols+ .iter()+ .filter(|sym| !symbols.contains(sym.name.as_str()) && reaches(&sym.art, &uses, &symbols))+ .map(|sym| sym.name.as_str())+ .collect();+ if found.is_empty() {+ break;+ }+ symbols.extend(found);+ }+ // Their instances the Selection tool can reach.+ if !symbols.is_empty() {+ d.walk(&mut |n: &Node| {+ if let NodeKind::SymbolInstance { symbol, .. } = &n.kind+ && symbols.contains(symbol.as_str())+ && editable(n.id)+ {+ hits.push(n.id);+ }+ });+ }drop(editable);let n = hits.len();s.select(|_, sel| sel.set(hits))?;@@ -722,6 +889,110 @@ mod tests {assert_eq!(r, json!({"runs": 2}));}+ /// The fonts of the symbols' art: Find Font lists them, and Change All replaces them, leaving+ /// hidden or locked type in the art as it is.+ #[test]+ fn find_font_reaches_the_type_in_symbols() {+ let mut s = Session::new();+ s.execute("file.new", &json!({"width": 200, "height": 200})).unwrap();+ let mut ids = vec![];+ for y in [20, 40, 60] {+ ids.push(s.execute("text.create", &json!({"x": 10, "y": y, "text": "Serif", "font": "Source Serif 4"})).unwrap()["id"].clone());+ }+ s.execute("symbol.new", &json!({"name": "Mark", "ids": ids})).unwrap();+ s.edit("Hide and lock", |d, _| {+ let art = Arc::make_mut(&mut d.symbols[0].art);+ let members = art.children_mut().unwrap();+ Arc::make_mut(&mut members[1]).visible = false;+ Arc::make_mut(&mut members[2]).locked = true;+ Ok(())+ })+ .unwrap();+ let mut on_layers = 0;+ s.doc().unwrap().doc.walk(|n| on_layers += usize::from(matches!(n.kind, NodeKind::Text(_))));+ assert_eq!(on_layers, 0, "the type is only in the symbol");+ let fonts = s.execute("text.fonts", &json!({})).unwrap();+ assert_eq!(+ (fonts[0]["family"].as_str(), fonts[0]["runs"].as_u64(), fonts[0]["objects"].as_u64()),+ (Some("Source Serif 4"), Some(3), Some(3)),+ "{fonts}"+ );+ // New Symbol selects the instance, which shows the symbol's type.+ assert_eq!(s.execute("text.fonts", &json!({"selectionOnly": true})).unwrap(), fonts);+ s.execute("select.set", &json!({"ids": []})).unwrap();+ assert_eq!(s.execute("text.fonts", &json!({"selectionOnly": true})).unwrap(), json!([]));+ // Find selects the symbol's instance, also when it is inside another symbol's instance.+ let mut instances = vec![];+ s.doc().unwrap().doc.walk(|n| {+ if matches!(n.kind, NodeKind::SymbolInstance { .. }) {+ instances.push(n.id);+ }+ });+ assert_eq!(instances.len(), 1);+ assert_eq!(s.execute("select.font", &json!({"family": "Source Serif 4"})).unwrap()["count"], 1);+ assert_eq!(s.doc().unwrap().selection.objects, instances);+ s.execute("symbol.new", &json!({"name": "Outer", "ids": [instances[0].0]})).unwrap();+ assert_eq!(s.execute("select.font", &json!({"family": "Source Serif 4"})).unwrap()["count"], 1);+ assert_ne!(s.doc().unwrap().selection.objects, instances);+ assert_eq!(s.execute("select.font", &json!({"family": "Inter"})).unwrap()["count"], 0);+ let r = s.execute("text.replaceFont", &json!({"from": {"family": "Source Serif 4"}, "to": {"family": "Source Sans 3"}})).unwrap();+ assert_eq!((r["runs"].as_u64(), r["skipped"].as_u64()), (Some(1), Some(2)), "{r}");+ let family = |s: &Session| symbol_texts(&s.doc().unwrap().doc, None)[0].0.runs[0].style.font_family.clone();+ let families: Vec<String> = symbol_texts(&s.doc().unwrap().doc, None).iter().map(|(t, _)| t.runs[0].style.font_family.clone()).collect();+ assert_eq!(families, ["Source Sans 3", "Source Serif 4", "Source Serif 4"]);+ // Find leaves out instances whose symbol uses the font only in hidden or locked type.+ assert_eq!(s.execute("select.font", &json!({"family": "Source Serif 4"})).unwrap()["count"], 0);+ // Only the selection: with nothing selected, the symbols' art stays as it is.+ let sans_to_inter = json!({"from": {"family": "Source Sans 3"}, "to": {"family": "Inter"}, "selectionOnly": true});+ assert_eq!(s.execute("text.replaceFont", &sans_to_inter).unwrap(), json!({"runs": 0}));+ assert_eq!(family(&s), "Source Sans 3");+ // With the instance that Find selects, the selection's fonts and Change reach its symbols' type.+ assert_eq!(s.execute("select.font", &json!({"family": "Source Sans 3"})).unwrap()["count"], 1);+ let fonts = s.execute("text.fonts", &json!({"selectionOnly": true})).unwrap();+ let rows: Vec<(&str, u64)> = fonts.as_array().unwrap().iter().map(|f| (f["family"].as_str().unwrap(), f["runs"].as_u64().unwrap())).collect();+ assert_eq!(rows, [("Source Sans 3", 1), ("Source Serif 4", 2)]);+ assert_eq!(s.execute("text.replaceFont", &sans_to_inter).unwrap()["runs"].as_u64(), Some(1));+ assert_eq!(family(&s), "Inter");+ // While the symbol is edited, its type on the editing layer is counted once.+ s.execute("symbol.edit", &json!({"name": "Mark"})).unwrap();+ let fonts = s.execute("text.fonts", &json!({})).unwrap();+ let serif = fonts.as_array().unwrap().iter().find(|f| f["family"] == "Source Serif 4").unwrap();+ assert_eq!((serif["runs"].as_u64(), serif["objects"].as_u64()), (Some(2), Some(2)), "{fonts}");+ let r = s.execute("text.replaceFont", &json!({"from": {"family": "Inter"}, "to": {"family": "Source Serif 4"}})).unwrap();+ assert_eq!(r["runs"].as_u64(), Some(1), "{r}");+ s.execute("symbol.exitEditing", &json!({})).unwrap();+ // A selected locked instance: its symbols' fonts are listed, and Change leaves them, counted.+ let mut outer = vec![];+ s.doc().unwrap().doc.walk(|n| {+ if matches!(&n.kind, NodeKind::SymbolInstance { symbol, .. } if symbol == "Outer") {+ outer.push(n.id.0);+ }+ });+ assert_eq!(outer.len(), 1);+ s.execute("select.set", &json!({"ids": outer})).unwrap();+ s.execute("object.lock", &json!({})).unwrap();+ s.execute("select.set", &json!({"ids": outer})).unwrap();+ assert_eq!(s.execute("text.fonts", &json!({"selectionOnly": true})).unwrap()[0]["runs"], 3);+ let serif_to_sans = json!({"from": {"family": "Source Serif 4"}, "to": {"family": "Source Sans 3"}, "selectionOnly": true});+ let r = s.execute("text.replaceFont", &serif_to_sans).unwrap();+ assert_eq!((r["runs"].as_u64(), r["skipped"].as_u64()), (Some(0), Some(3)), "{r}");+ // A hidden instance in a symbol's art does not bring its symbol into the selection's scope.+ s.execute("object.unlockAll", &json!({})).unwrap();+ s.edit("Hide the inner instance", |d, _| {+ let i = d.symbols.iter().position(|sym| sym.name == "Outer").unwrap();+ let art = Arc::make_mut(&mut d.symbols[i].art);+ match art.children_mut() {+ Some(members) => Arc::make_mut(&mut members[0]).visible = false,+ None => art.visible = false,+ }+ Ok(())+ })+ .unwrap();+ s.execute("select.set", &json!({"ids": outer})).unwrap();+ assert_eq!(s.execute("text.fonts", &json!({"selectionOnly": true})).unwrap(), json!([]));+ assert_eq!(s.execute("text.replaceFont", &serif_to_sans).unwrap(), json!({"runs": 0}));+ }+/// The font family of text object `id`'s first run.fn text_family(s: &Session, id: u64) -> String {text(&s.doc().unwrap().doc, NodeId(id)).unwrap().runs[0].style.font_family.clone()diff --git a/crates/engine/src/tests/fontfiles.rs b/crates/engine/src/tests/fontfiles.rsindex 32eaefc00..f31df35eb 100644--- a/crates/engine/src/tests/fontfiles.rs+++ b/crates/engine/src/tests/fontfiles.rs@@ -94,7 +94,7 @@ fn missing_fonts_are_listed_symbols_included() {assert_eq!((r["count"].as_u64(), r["fonts"][1]["resolved"]["family"].as_str()), (Some(3), Some("Source Sans 3")));assert!(r.get("fontsNextToDocument").is_none(), "an unsaved document has no folder");let listed = s.execute("text.fonts", &json!({})).unwrap();- assert!(!listed.as_array().unwrap().iter().any(|f| f["family"] == "Symbol Only Family"), "Find Font lists the layers' type only");+ assert!(listed.as_array().unwrap().iter().any(|f| f["family"] == "Symbol Only Family" && f["status"] == "missing"), "{listed}");assert!(listed.as_array().unwrap().iter().any(|f| f["family"] == "sans-serif" && f["status"] == "missing"), "{listed}");assert!(matches!(Session::new().execute("text.missingFonts", &json!({})), Err(EngineError::Disabled(..))));}diff --git a/docs/mcp.md b/docs/mcp.mdindex 204690755..703a8c416 100644--- a/docs/mcp.md+++ b/docs/mcp.md@@ -6087,7 +6087,8 @@ glyph of its first character lands where it was drawn.- `addon.cleanup.resetTextTransform {scale?, ids?}` takes the rotation, shear and reflection off point type, keeping itssize and the centre of its text. With `scale: true` the horizontal scale goes too, the object's and each character's.- `addon.cleanup.replaceFonts {font?}` sets every character of the document's type whose font family isn't available- in `font` (by default the default type font, Source Sans 3), in that family's style closest to the one it had.+ in `font` (by default the default type font, Source Sans 3), in that family's style closest to the one it had. The+ type in the art of the document's symbols is replaced too.In the panel, the Text row (which the panel can hide) runs them: Shift-click Lines to break into paragraphs, andAlt-click Reset Transform to reset the horizontal scale too. Recovering live text from outlines, combining vertical