mirror of
https://github.com/storytold/designcraft.git
synced 2026-11-18 08:07:12 +00:00
Conflicts resolved per file (both sides kept unless noted):
crates/engine/src/atomic.rs | 1 | main's: `write_file` removed (main routes command writes through `crate::io::write_file`); its one caller in file.rs now uses `crate::io::write_file`
crates/engine/src/cmd/datamerge/fill.rs | 1 | next's `Graphic` literal (has `clip` and `wrap`, which next's `Graphic` carries)
crates/engine/src/cmd/datamerge/mod.rs | 1 | main's `read_path_capped` (crate::io metadata/read_capped, roots checked); next's capped read is the same behaviour
crates/engine/src/cmd/datamerge/parse.rs | 1 | main's (`crate::io::metadata`, `crate::io::Metadata`)
crates/engine/src/cmd/edit.rs | 1 | next's `spread_param(p, "edit.paste")` (the second argument is the command id on both sides)
crates/engine/src/cmd/export.rs | 3 | main's: EPUB params doc, `toc_title` once (main's position; next's duplicate dropped)
crates/engine/src/cmd/file.rs | 7 | place doc: next's (lists page/rect/autoflow params #803 checks); next's recent-file functions + main's `foreign_document`; next's open (load_bytes, warnings, non-DesignCraft refusal) with main's checked `crate::io::read_file` for the bytes; main's `check_write` be
crates/engine/src/cmd/find.rs | 7 | main's Find scope (FindContext, scope/selection/story, continuation, UTF-8 repair) on next's `designcraft_compose::grep::Grep` (dialect GREP): find uses `find_all` capped at MAX_MATCHES, change uses `replacements`/`find_all` (literal change text not expanded), fin
crates/engine/src/cmd/fonts.rs | 1 | next's (`has_style`, resolved/replacement face); `has_style` already compares styles ignoring spacing and case, which is main's `same_style` fix; main's test kept
crates/engine/src/cmd/interchange.rs | 1 | next's `import_idml_report_with_previews` (previews for unreadable links)
crates/engine/src/cmd/layout.rs | 8 | pages.insert: main's overflow-safe `after` + next's checked `parent_ref`; main's duplicateSpread doc; layout.section: next's `SectionEdit` (already keeps unnamed settings, #717) with main's `d.repaginate()` moved into `SectionEdit::apply` (remove and set paths),
crates/engine/src/cmd/links.rs | 5 | next's links.list (no doc clone); main's `text_status` via crate::io; `use std::io::Read` dropped (unused after main's read_capped); test literals main's. `link_missing` (next) uses `crate::io::exists` for the file-guard scan
crates/engine/src/cmd/object.rs | 4 | object.fill/stroke tint-alone: main's (23e1680e7; out-of-range tint is an error, which main's test asserts); object.fit doc: next's (lists `axis`)
crates/engine/src/cmd/paths.rs | 1 | next's (shatai transform on outlines)
crates/engine/src/cmd/place_text.rs | 1 | next's `add_flow_frame` (used by autoflow)
crates/engine/src/cmd/preflight.rs | 2 | next's overset/unplacedStory issue (its `overset_location` already applies the parent transform main's #738 fix adds); next's two test modules kept with main's
crates/engine/src/cmd/scripts.rs | 1 | combined: next's `in_undo_step = false` (#406) + main's full rollback of a failed script (#709)
crates/engine/src/cmd/style.rs | 14 | param docs next's (gradient swatch.create, swatch stops, model colours); create_para next's; rename_style main's structure (rename entry, then `redirect_style_refs`), redirect has next's full reference set (cells, defaults, notes, TOC) + main's never-based-on-it
crates/engine/src/cmd/text.rs | 10 | main's selectSentence/Paragraph/Story + select_around; next's selectionAttrs (mixed) + main's openTypeFeatures/type.feature; main's comments; tracked typing: next's `reserve_command_text` + main's `insert_format_at`; empty-paragraph mark formatting main's (with `
crates/engine/src/cmd/thread.rs | 1 | next's `spread_param(p, "text.thread")`
crates/engine/src/dtd.rs | 1 | next's linear, depth-bounded `expand_parameter_entities` with main's budget (input + 1 MiB, `MAX_EXPANDED_BYTES`) and message ("expand the DTD beyond"); 16 MiB constant removed; both sides' tests pass on message
crates/engine/src/guard.rs | 2 | main's whole-transaction snapshot (docs, active, journal; #742) + next's `in_undo_step` restore; tests both
crates/engine/src/lib.rs | 5 | LoadedGraphic doc next's; next's `new_document_preview`; execute: main's `discard_stale_find_scope()` before next's nested-undo run; modules both (tests_autosize, tests_file_guard, tests_params, tests_roots)
crates/engine/src/recovery.rs | 1 | next's test (superset of main's assertion)
crates/engine/src/tests.rs | 4 | moved tests deduplicated (identical on both sides); next's preflight and direct-selection/kerning tests + main's style-delete, locked-frame and baseline-fit tests
crates/engine/src/tests_idml.rs | 3 | main's order (drop cap and margins tests identical on both sides, once each)
crates/ui-egui/src/canvas.rs | 3 | next's screen_options/DisplayKey block and tests kept; two tests that auto-merge had added twice (parent_guides_on_a_page_are_not_picked_there, baseline_grid_lines_are_the_ones_on_the_page) kept once; main's `typing`/`screen_at`/`click` helpers and its tests clicks
crates/ui-egui/src/control.rs | 3 | main's `count` check and pending budget (control queue + synthetic queue); exact-budget test runs both sides' cases (click 255 on 9,492 pending; drag 9492×255)
crates/ui-egui/src/cursors.rs | 1 | main's (same Pen cursor set)
crates/ui-egui/src/dialogs.rs | 14 | dialog body (newDocument … alert match) is next's text, with main's Find/Change scope reset (`set_field`, `reset_find_scope`, `find_change_params`) and main's Create Guides / Margins and Columns arms ported in; `Dialog::new` ruby section (next) + main's `set_fi
crates/ui-egui/src/i18n.rs | 7 | ka and pl modules, languages, statics and lookups both; `category_first` covers uk, ru, pl, ka and `count_label` keeps next's Czech plurals; shared TABLE union; next's duplicate rows for Auto, Number:, Gutter:, Top:, Bottom:, Inside:, Outside:, Left:, Right: dropped
crates/ui-egui/src/i18n/ar.rs | 2 | union of rows, no duplicate keys
crates/ui-egui/src/i18n/it.rs | 1 | union of rows, no duplicate keys
crates/ui-egui/src/i18n/ja.rs | 1 | union of rows, no duplicate keys
crates/ui-egui/src/i18n/pt_br.rs | 1 | union of rows, no duplicate keys
crates/ui-egui/src/i18n/uk.rs | 1 | union of rows, no duplicate keys
crates/ui-egui/src/icons.rs | 2 | both tests (main's typography icon, next's distribute icons)
crates/ui-egui/src/lib.rs | 11 | UiState: next's tabs_panel + main's last_color/last_gradient; `cursors` field once; next's SVG paste and paste-on-spread-in-view; next's extensionless document open; opens_as_document next's comment; tests both (next's control bar / key-name tests, main's rich black
crates/ui-egui/src/menus.rs | 15 | app.language doc next's text with pl and ka; UI_COMMANDS both (next's Tabs, Toggle Presentation, Apply None text; main's panel commands, Apply Color, Apply Gradient); Edit › Interface Language stays out (next moved it to Preferences); Type menu main's order with
crates/ui-egui/src/panels/glyphs.rs | 1 | next's (already has main's scroll-bar fix); the scroll-bar test module auto-merge had added twice kept once
crates/ui-egui/src/panels/layers.rs | 3 | next's drag-and-drop `object_rows`, with main's features ported into it: selection reveal (layer opens, row scrolls into view once), selected rows highlighted (also a group whose member is selected), double-click rename in place (`object.rename` queued like
crates/ui-egui/src/panels/mod.rs | 6 | tabs + typography modules and color_panel_tests; SelInfo has wrap_side/wrap_contour and wrap_offsets (offsets from the graphic's own wrap when it is selected); next's swatch_picker returning the chip response; next's content_selection_tests
crates/ui-egui/src/panels/pages.rs | 1 | next's (parents dragged by id)
crates/ui-egui/src/panels/properties.rs | 4 | next's swatch popup (Apply To, Tint); main's four wrap offsets then next's Wrap To / Contour Type; test fixtures main's (`..Default::default()`, no unused builder)
crates/ui-egui/src/panels/swatches.rs | 3 | main's Delete Swatch button + next's New Swatch comment; next's draggable rows; click: main's PICKED + fill/stroke in front, with next's no-apply on double-click
crates/ui-egui/src/toolbar.rs | 2 | main's Apply Color / Gradient / None wells and functions; next's apply_none doc line
crates/compose/src/lib.rs | 5 | next's line loop kept (mark_leading + last_line_mark, wrap segments/carry, grid gyoudori); main's mark-chars base_leading block (auto-merged) stays beside it. `fits`: next's #106 rule (baseline fit for horizontal frames, full descent for paths, vertical text, footnote
crates/compose/src/tests.rs | 5 | next's tests (tombstone set, sliver/one-sided/contour/clipping wrap tests, borders, lists, kenten, grid, anchored wrap, balance, shaped frames) plus main's an_empty_last_paragraph_isnt_overset; main's wrap_object_beside_one_narrow_column_leaves_the_other_alone re-ad
crates/doc/src/assets.rs | 1 | main's doc comment (same meaning)
crates/doc/src/build.rs | 3 | parent_page_for: next's parent_page_for_side (RTL-aware); single_sided_page_shows_first_parent_page test kept once, at main's position
crates/doc/src/item.rs | 1 | next's rotated_group_bounds_follow_the_children_outlines test kept
crates/doc/src/lib.rs | 1 | next's kerning_increment field kept; main's "Bulleted & Numbered" wording
crates/doc/src/page.rs | 1 | next's outer_page_indices + parent_page_for_side (integration of parent-margins with rtl-master-sides); main's parent_page_index dropped, its only caller (build.rs) uses parent_page_for_side
crates/doc/src/slice.rs | 5 | extract: next's `marked()` (get-based, fix_notes/fix_endnotes/fix_marks; main's version indexed slices and could panic); insert_story: main's take() limit on endnote/editorial payload copies with next's id comment, redundant `let ne`/`let nn` dropped; main's excess_note
crates/geom/src/corners.rs | 1 | next's box_outline_rounds_only_closed_corners test kept
crates/render/src/damage.rs | 1 | next's wrapping-anchored-object damage test kept
crates/render/src/fx.rs | 2 | feather: next's choke/corners sigma+join inside main's structure (body and clip at device resolution, with_filters(.., None)); inner glow centre: next's blend `mix` with main's clip argument (bp, xf)
crates/render/src/lib.rs | 3 | next's layer comment; next's front baseline grid draw after items; gradient match on g.kind (main's tuple scrutinee did not match the single-pattern arms)
crates/render/src/text.rs | 5 | paint_glyphs: main's paint_stroke closure structure with next's stroke overprint (overprinting helper, stroke `(TextPaint, bool)`); callers pass next's overprint_fill/overprint_stroke
crates/render/tests/placed_pdf.rs | 1 | main's `near` helper version
crates/tools/src/lib.rs | 1 | main's (PenConvert already declared below, avoids a duplicate variant)
crates/tools/src/pen.rs | 1 | main's module doc
crates/tools/src/select.rs | 1 | next's Drag::Corner variant (live corners) kept
crates/tools/src/tests.rs | 4 | next's tests (content drag, live corners, table border drag, eyedropper matchFrom, fitting handles, pen cursors once); eyedropper_ignores_inactive keeps next's samples_image check (main's exact-JSON compare lacks matchFrom) with main's `..Default::default()` Asset lit
crates/tools/src/text.rs | 2 | next's table border drag (BorderDrag, border_at) kept, then main's comment on locked text frames
crates/tools/src/xform.rs | 2 | main's explicit `Vec<&Item>` for shown children; next's eyedropper matchFrom (integration 796e9d713)
Cargo.toml | 2 | main's craft-pdf workspace dep added (craft-print stays once, in next's craft-libs block); [patch.crates-io] keeps next's winit (rust-windowing #4694 backport) and adds main's krilla patch; main's skylartaylor winit left out (see UNSURE 1)
Cargo.lock | 1 | union: next's craft-atomic and craft-cms entries plus main's craft-pdf entry; needs `cargo` normalisation
README.md | 1 | Open bullet combines INDD import via indd-utils (next) and editable PowerPoint export (main); main's paragraph break kept
contributors/people.toml | 1 | both people kept (switch87 from next, Nmarello from main)
apps/designcraft-cli/src/main.rs | 4 | next's `Export` enum dispatch kept; main's .pptx export added as `Export::Pptx` (run prints slides and warnings, script runs file.exportPptx); main's `--pdf-options` null-as-{} parse; usage lines list .pptx
apps/designcraft/src/main.rs | 3 | `startup.leave()` right after `app.ui` (main #380) and next's macOS `sync_movable` kept after the IME discard; next's Apple Events install kept; main's macOS Dock Quit `with_close_requested_on_terminate` block left out (needs the skylartaylor winit; UNSURE 1)
crates/fonts/src/fontdb.rs | 9 | FONT6 aliases (next) combined with #911 WWS names (main): ScannedFace and both CatalogEntry constructors carry `wws` and `aliases`; `canonical_family` falls back to WWS family names; `exact_style_traits` canonicalises then tries typographic, then WWS names (`named_st
crates/format/src/lib.rs | 1 | tests: both sides kept (next's r7a nullable-default tests; main's oversized ZIP entry/asset/entry-count tests)
crates/idml/src/import.rs | 11 | main's bounded `Package` reader under next's `import_idml_report_with_previews` (metadata read through `pkg.part`); next's `tab_list_repaired` kept; ruler origin: next's `settings.ruler_origin`, and main's guide import reads it (main's private `RulerOrigin` enum and
crates/idml/src/tests.rs | 6 | item-level union: all next tests plus main's new ones (ruler guides, package limits, CJK leading model, liquid page rules module, mojikumi); no test dropped
crates/mcp/src/backend.rs | 1 | test comment merged from both
crates/pdf/src/tests.rs | 1 | tests: both sides kept
crates/pdf/src/text.rs | 4 | next's (skew `tan`, cluster `start`, ruby overprint warning); main had no change here beyond base
crates/textimport/src/docx.rs | 5 | next's (ListCounter integration for list levels, page-break test position); main's side was the older form of the same code
crates/epub/src/lib.rs | 30 | non-test code is next's (StoryWriter holds img_src/images/no_alt/heading_ids; covers main's #787/#791/#782 fixes, plus #314 group transforms, anchored images in images_without_alt, endnote story skipped in the TOC); tests: next's set plus main's extra css_weight_style a
docs/control-protocol.md | 2 | next's rows (ui.paste, count 1–255, documentGrid) and wording
docs/file-format-parity.md | 1 | rows combined (next's ICC notes, main's TIFF indexed colour)
docs/gaps.md | 2 | status change notes unioned; Flex Layout removed from missing (main implemented it), next's Parent Options sentence kept
docs/localization-parity.md | 4 | Polish and Georgian rows; 5 languages beyond the twelve; file list includes cs and ka; both history rows
docs/roadmap.md | 1 | M1 next's (#186 fixed on next), M2 main's IME wording
docs/target-app-parity.md | 6 | next's status line; File formats row next's, UI/UX row main's (IME no longer failing); UI line next's plus main's Swatches detail; one Page tool line (main's fuller one); Load styles and main's fuller Pathfinder line both kept, main's duplicate short Pathfinder line r
docs/ui-parity.md | 1 | IME row main's, Font menu row next's
i18n/fr.rs: five rows dropped that main's shared table now has (Row, Open Path, Flex Layout, Current Page Number, Rulers).
430 lines
22 KiB
Rust
430 lines
22 KiB
Rust
//! Type › Find/Replace Font: the fonts a document uses (missing ones flagged) and replacing one
|
||
//! font with another everywhere — local formatting and style definitions.
|
||
|
||
use std::collections::BTreeMap;
|
||
use std::sync::Arc;
|
||
|
||
use designcraft_doc::{CharAttrs, Document, Story};
|
||
use designcraft_fonts::FontSource;
|
||
use serde_json::{Value, json};
|
||
|
||
use super::{CommandSpec, bad, cmd, has_doc, str_param};
|
||
use crate::{Result, Session};
|
||
|
||
pub fn specs() -> Vec<CommandSpec> {
|
||
vec![
|
||
cmd!(query "font.list", "Fonts in Document", [], None, "{} → [{family, style, characters, missing, styleMissing, source: bundled|installed|document|added (null when missing), matchStatus: exact|styleSubstitute|missing, resolvedFamily, resolvedStyle, replacementFamily, replacementStyle}] (missing first)", has_doc, |s, _| {
|
||
Ok(Value::Array(list(&s.doc()?.doc)))
|
||
}),
|
||
cmd!(
|
||
"font.replace",
|
||
"Find/Replace Font…",
|
||
["Type"],
|
||
None,
|
||
"{family, style?, toFamily, toStyle?, redefineStyles?: true} — replaces the font in text and (by default) in paragraph and character styles",
|
||
has_doc,
|
||
replace
|
||
),
|
||
]
|
||
}
|
||
|
||
/// Every story's text, including table cells and footnotes.
|
||
pub(super) fn for_each_story(d: &Document, f: &mut dyn FnMut(&Story)) {
|
||
let mut pending: Vec<&Story> = d.stories.values().map(AsRef::as_ref).collect();
|
||
while let Some(st) = pending.pop() {
|
||
f(st);
|
||
pending.extend(st.tables.values().flat_map(|t| t.cells.iter().map(|c| &c.text)));
|
||
pending.extend(st.notes.iter().chain(&st.endnotes).map(|n| &n.text));
|
||
}
|
||
}
|
||
|
||
/// Effective document font use shared by the command layer and preflight.
|
||
#[derive(serde::Serialize)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub(super) struct UsedFont {
|
||
pub family: String,
|
||
pub style: String,
|
||
pub characters: usize,
|
||
pub missing: bool,
|
||
pub style_missing: bool,
|
||
pub source: Option<&'static str>,
|
||
pub match_status: &'static str,
|
||
pub resolved_family: String,
|
||
pub resolved_style: String,
|
||
pub replacement_family: String,
|
||
pub replacement_style: String,
|
||
}
|
||
|
||
fn list(d: &Document) -> Vec<Value> {
|
||
used_fonts(d).into_iter().map(|font| json!(font)).collect()
|
||
}
|
||
|
||
pub(super) fn used_fonts(d: &Document) -> Vec<UsedFont> {
|
||
let db = designcraft_fonts::FontDb::global().scoped(d.font_scope);
|
||
let mut used: BTreeMap<(String, String), (usize, std::collections::BTreeSet<char>)> = BTreeMap::new();
|
||
for_each_story(d, &mut |st| {
|
||
let ranges = st.para_ranges();
|
||
for (pi, r) in ranges.iter().enumerate() {
|
||
let (_, base) = d.styles.resolve_para(&st.paras[pi]);
|
||
for (rr, fmt) in st.runs() {
|
||
let n = st.text[rr.start.max(r.start)..rr.end.min(r.end).max(rr.start.max(r.start))].chars().count();
|
||
if n == 0 && !(r.is_empty() && rr.contains(&r.start)) {
|
||
continue;
|
||
}
|
||
let p = d.styles.resolve_char(&base, fmt);
|
||
if let Some(f) = d.styles.composite_font(&p.font_family) {
|
||
let text = st.text.get(rr.start.max(r.start)..rr.end.min(r.end).max(rr.start.max(r.start))).unwrap_or("");
|
||
for c in text.chars() {
|
||
if let Some(e) = f.entry(c) {
|
||
let entry = used.entry((e.family.clone(), e.style.clone())).or_default();
|
||
entry.0 += 1;
|
||
entry.1.insert(c);
|
||
}
|
||
}
|
||
} else {
|
||
let entry = used.entry((p.font_family, p.font_style)).or_default();
|
||
entry.0 += n;
|
||
entry.1.extend(st.text.get(rr.start.max(r.start)..rr.end.min(r.end).max(rr.start.max(r.start))).unwrap_or("").chars());
|
||
}
|
||
}
|
||
}
|
||
});
|
||
let mut out: Vec<UsedFont> = used
|
||
.into_iter()
|
||
.map(|((family, style), (n, characters))| {
|
||
let missing = !db.has_family(&family);
|
||
let style_missing = !missing && !db.has_style(&family, &style);
|
||
let resolved = db.face(&family, &style);
|
||
let characters: Vec<char> = characters.into_iter().filter(|c| !('\u{E000}'..='\u{E1FF}').contains(c)).collect();
|
||
let replacement = db.replacement_face(&family, &style, &characters);
|
||
let source = (!missing).then(|| match db.face(&family, &style).source {
|
||
FontSource::Bundled => "bundled",
|
||
FontSource::Installed(_) => "installed",
|
||
FontSource::Document(_) => "document",
|
||
FontSource::Memory => "added",
|
||
});
|
||
UsedFont {
|
||
family,
|
||
style,
|
||
characters: n,
|
||
missing,
|
||
style_missing,
|
||
source,
|
||
match_status: if missing {
|
||
"missing"
|
||
} else if style_missing {
|
||
"styleSubstitute"
|
||
} else {
|
||
"exact"
|
||
},
|
||
resolved_family: resolved.family.clone(),
|
||
resolved_style: resolved.style.clone(),
|
||
replacement_family: replacement.family.clone(),
|
||
replacement_style: replacement.style.clone(),
|
||
}
|
||
})
|
||
.collect();
|
||
out.sort_by_key(|font| !(font.missing || font.style_missing));
|
||
out
|
||
}
|
||
|
||
/// Replace the font in a sparse attribute set (only where the family is set); true when it changed.
|
||
fn swap(a: &mut CharAttrs, family: &str, style: Option<&str>, to_family: &str, to_style: Option<&str>) -> bool {
|
||
let fam_ok = a.font_family.as_deref().is_some_and(|f| f.eq_ignore_ascii_case(family));
|
||
let style_ok = style.is_none_or(|s| a.font_style.as_deref().is_some_and(|x| x.eq_ignore_ascii_case(s)));
|
||
if !fam_ok || !style_ok {
|
||
return false;
|
||
}
|
||
a.font_family = Some(to_family.to_string());
|
||
if let Some(ts) = to_style {
|
||
a.font_style = Some(ts.to_string());
|
||
}
|
||
true
|
||
}
|
||
|
||
fn replace(s: &mut Session, p: &Value) -> Result<Value> {
|
||
let family = str_param(p, "family").ok_or_else(|| bad("font.replace", "missing family"))?.to_string();
|
||
let style = str_param(p, "style").map(str::to_string);
|
||
let to_family = str_param(p, "toFamily").ok_or_else(|| bad("font.replace", "missing toFamily"))?.to_string();
|
||
let to_style = str_param(p, "toStyle").map(str::to_string);
|
||
let db = designcraft_fonts::FontDb::global().scoped(s.doc()?.doc.font_scope);
|
||
if family.trim().is_empty() || to_family.trim().is_empty() || !db.has_family(&to_family) {
|
||
return Err(bad("font.replace", "Choose an available replacement font family"));
|
||
}
|
||
if let Some(style) = &to_style
|
||
&& !db.has_style(&to_family, style)
|
||
{
|
||
return Err(bad("font.replace", "Choose an available replacement font style"));
|
||
}
|
||
let resolved = db.face(&to_family, to_style.as_deref().or(style.as_deref()).unwrap_or("Regular"));
|
||
if resolved.is_placeholder() {
|
||
return Err(bad("font.replace", "A placeholder font cannot replace document text"));
|
||
}
|
||
let to_family = resolved.family.clone();
|
||
let to_style = (to_style.is_some() || style.is_some()).then(|| resolved.style.clone());
|
||
let styles_too = p.get("redefineStyles").and_then(Value::as_bool).unwrap_or(true);
|
||
s.edit(|d, _| {
|
||
let mut changed = 0usize;
|
||
// Resolve text against the original styles before redefining them. Font family and
|
||
// style can be inherited independently through paragraph and character formatting.
|
||
let original_styles = d.styles.clone();
|
||
let ids: Vec<_> = d.stories.keys().copied().collect();
|
||
for sid in ids {
|
||
let Some(st) = d.story_mut(sid) else { continue };
|
||
let mut pending = vec![st];
|
||
while let Some(st) = pending.pop() {
|
||
let mut ranges = Vec::new();
|
||
for (pi, paragraph) in st.para_ranges().iter().enumerate() {
|
||
let Some(format) = st.paras.get(pi) else { continue };
|
||
let (_, base) = original_styles.resolve_para(format);
|
||
for (run, format) in st.runs() {
|
||
let start = run.start.max(paragraph.start);
|
||
// An empty paragraph still uses its paragraph-break character's font.
|
||
let end = if paragraph.is_empty() && run.contains(¶graph.start) {
|
||
st.text.get(start..).and_then(|tail| tail.chars().next()).map_or(start, |c| start.saturating_add(c.len_utf8()))
|
||
} else {
|
||
run.end.min(paragraph.end)
|
||
};
|
||
if start >= end {
|
||
continue;
|
||
}
|
||
let effective = original_styles.resolve_char(&base, format);
|
||
if effective.font_family.eq_ignore_ascii_case(&family)
|
||
&& style.as_ref().is_none_or(|s| effective.font_style.eq_ignore_ascii_case(s))
|
||
{
|
||
ranges.push((start..end, db.face(&to_family, to_style.as_deref().unwrap_or(&effective.font_style)).style.clone()));
|
||
}
|
||
}
|
||
}
|
||
for (range, replacement_style) in ranges {
|
||
st.format_chars(range, |format| {
|
||
format.over.font_family = Some(to_family.clone());
|
||
format.over.font_style = Some(replacement_style.clone());
|
||
});
|
||
changed += 1;
|
||
}
|
||
pending.extend(st.tables.values_mut().flat_map(|t| Arc::make_mut(t).cells.iter_mut().map(|c| &mut c.text)));
|
||
pending.extend(st.notes.iter_mut().chain(&mut st.endnotes).map(|n| &mut Arc::make_mut(n).text));
|
||
}
|
||
}
|
||
if styles_too {
|
||
let st = d.styles_mut();
|
||
for ps in &mut st.paragraph {
|
||
changed += swap(&mut ps.chars, &family, style.as_deref(), &to_family, to_style.as_deref()) as usize;
|
||
}
|
||
for cs in &mut st.character {
|
||
changed += swap(&mut cs.chars, &family, style.as_deref(), &to_family, to_style.as_deref()) as usize;
|
||
}
|
||
for f in &mut st.composite_fonts {
|
||
for e in &mut f.entries {
|
||
if e.family.eq_ignore_ascii_case(&family) && style.as_ref().is_none_or(|s| e.style.eq_ignore_ascii_case(s)) {
|
||
e.family.clone_from(&to_family);
|
||
e.style = db.face(&to_family, to_style.as_deref().unwrap_or(&e.style)).style.clone();
|
||
changed += 1;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
Ok(json!({"changed": changed}))
|
||
})
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
|
||
#[test]
|
||
fn replacement_resolves_inherited_family_and_style_and_rejects_missing_targets() {
|
||
let mut s = Session::new();
|
||
s.execute("file.new", &json!({})).unwrap();
|
||
s.execute("frame.create", &json!({"rect": [0,0,200,200], "content":"text", "text":"Inherited\n\nEnd"})).unwrap();
|
||
let d = Arc::make_mut(&mut s.doc_mut().unwrap().doc);
|
||
let sid = *d.stories.keys().next().unwrap();
|
||
let story = d.story_mut(sid).unwrap();
|
||
for para in &mut story.paras {
|
||
para.chars.font_family = Some("Unavailable Family".into());
|
||
}
|
||
let before = s.execute("font.list", &json!({})).unwrap();
|
||
let style = before[0]["style"].clone();
|
||
assert!(s.execute("font.replace", &json!({"family":"Unavailable Family", "toFamily":"Also Missing"})).is_err());
|
||
assert_eq!(before, s.execute("font.list", &json!({})).unwrap());
|
||
s.execute("font.replace", &json!({"family":"Unavailable Family", "style":style, "toFamily":"Source Sans 3", "toStyle":"Regular"})).unwrap();
|
||
assert!(s.execute("font.list", &json!({})).unwrap().as_array().unwrap().iter().all(|f| f["missing"] == false));
|
||
s.execute("edit.undo", &json!({})).unwrap();
|
||
assert_eq!(before, s.execute("font.list", &json!({})).unwrap());
|
||
}
|
||
|
||
#[test]
|
||
fn find_and_replace_font() {
|
||
let mut s = Session::new();
|
||
s.execute("file.new", &json!({})).unwrap();
|
||
let r = s.execute("frame.create", &json!({"rect": [72, 72, 400, 300], "content": "text", "text": "Some text here."})).unwrap();
|
||
let sid = s.doc().unwrap().doc.item(designcraft_doc::ItemId(r["id"].as_u64().unwrap())).unwrap().text_frame().unwrap().story;
|
||
s.execute("text.select", &json!({"story": sid.0, "anchor": 0, "focus": 4})).unwrap();
|
||
s.execute("type.char", &json!({"fontFamily": "Nonexistent Sans", "fontStyle": "Bold"})).unwrap();
|
||
let l = s.execute("font.list", &json!({})).unwrap();
|
||
assert_eq!(l[0]["family"], "Nonexistent Sans", "missing fonts first: {l}");
|
||
assert_eq!(l[0]["missing"], true);
|
||
assert_eq!(l[0]["characters"], 4);
|
||
// Replace it with an available family.
|
||
let avail = l.as_array().unwrap().iter().find(|f| f["missing"] == false).unwrap()["family"].as_str().unwrap().to_string();
|
||
let r = s.execute("font.replace", &json!({"family": "Nonexistent Sans", "toFamily": avail, "toStyle": "Regular"})).unwrap();
|
||
assert_eq!(r["changed"], 1);
|
||
let l = s.execute("font.list", &json!({})).unwrap();
|
||
assert!(l.as_array().unwrap().iter().all(|f| f["missing"] == false), "{l}");
|
||
// Style definitions are redefined too.
|
||
s.execute("style.paragraph.create", &json!({"name": "Odd", "chars": {"fontFamily": "Nonexistent Sans"}})).unwrap();
|
||
let r = s.execute("font.replace", &json!({"family": "Nonexistent Sans", "toFamily": avail})).unwrap();
|
||
assert_eq!(r["changed"], 1);
|
||
assert_eq!(s.doc().unwrap().doc.styles.para("Odd").unwrap().chars.font_family.as_deref(), Some(avail.as_str()));
|
||
}
|
||
|
||
/// InDesign names a family installed in several formats `Family (OTF)`; the plain family
|
||
/// stands for it, and a family that isn't available under either name is still missing.
|
||
#[test]
|
||
fn a_family_with_a_format_suffix_uses_the_plain_family() {
|
||
let mut s = Session::new();
|
||
s.execute("file.new", &json!({})).unwrap();
|
||
let r = s.execute("frame.create", &json!({"rect": [72, 72, 400, 300], "content": "text", "text": "Some text here."})).unwrap();
|
||
let sid = s.doc().unwrap().doc.item(designcraft_doc::ItemId(r["id"].as_u64().unwrap())).unwrap().text_frame().unwrap().story;
|
||
s.execute("text.select", &json!({"story": sid.0, "anchor": 0, "focus": 15})).unwrap();
|
||
s.execute("type.char", &json!({"fontFamily": "Source Serif 4 (OTF)", "fontStyle": "Bold"})).unwrap();
|
||
let l = s.execute("font.list", &json!({})).unwrap();
|
||
let entry = l.as_array().unwrap().iter().find(|f| f["family"] == "Source Serif 4 (OTF)").unwrap();
|
||
assert_eq!((&entry["missing"], &entry["styleMissing"], &entry["source"]), (&json!(false), &json!(false), &json!("bundled")), "{l}");
|
||
let st = s.doc().unwrap();
|
||
let cs = s.cache.get(&st.doc, sid, None);
|
||
let faces: Vec<_> =
|
||
cs.frames.iter().flat_map(|f| &f.lines).flat_map(|l| &l.glyphs).filter(|g| g.visible && g.len > 0).map(|g| g.face.get()).collect();
|
||
assert!(!faces.is_empty() && faces.iter().all(|f| f.family == "Source Serif 4" && f.style == "Bold"));
|
||
let kinds = |s: &mut Session| {
|
||
s.execute("preflight.run", &json!({})).unwrap()["issues"]
|
||
.as_array()
|
||
.unwrap()
|
||
.iter()
|
||
.map(|i| i["kind"].as_str().unwrap().to_string())
|
||
.collect::<Vec<_>>()
|
||
};
|
||
assert!(!kinds(&mut s).iter().any(|k| k == "missingFont"));
|
||
|
||
s.execute("text.select", &json!({"story": sid.0, "anchor": 0, "focus": 4})).unwrap();
|
||
s.execute("type.char", &json!({"fontFamily": "Nope (OTF)"})).unwrap();
|
||
let l = s.execute("font.list", &json!({})).unwrap();
|
||
assert_eq!((&l[0]["family"], &l[0]["missing"]), (&json!("Nope (OTF)"), &json!(true)), "{l}");
|
||
assert!(kinds(&mut s).iter().any(|k| k == "missingFont"));
|
||
}
|
||
|
||
/// A style name that differs only in spacing (Montilla Design's file sets `Regular ` with a
|
||
/// trailing space) is the face the text is drawn in, not a missing style.
|
||
#[test]
|
||
fn a_style_with_extra_spacing_is_not_missing() {
|
||
let mut s = Session::new();
|
||
s.execute("file.new", &json!({})).unwrap();
|
||
let r = s.execute("frame.create", &json!({"rect": [72, 72, 400, 300], "content": "text", "text": "Text"})).unwrap();
|
||
let sid = s.doc().unwrap().doc.item(designcraft_doc::ItemId(r["id"].as_u64().unwrap())).unwrap().text_frame().unwrap().story;
|
||
s.execute("text.select", &json!({"story": sid.0, "anchor": 0, "focus": 4})).unwrap();
|
||
s.execute("type.char", &json!({"fontFamily": "Source Serif 4", "fontStyle": "Regular "})).unwrap();
|
||
let l = s.execute("font.list", &json!({})).unwrap();
|
||
let entry = l.as_array().unwrap().iter().find(|f| f["style"] == "Regular ").unwrap();
|
||
assert_eq!((&entry["missing"], &entry["styleMissing"]), (&json!(false), &json!(false)), "{l}");
|
||
s.execute("type.char", &json!({"fontFamily": "Source Serif 4", "fontStyle": "Nope"})).unwrap();
|
||
let l = s.execute("font.list", &json!({})).unwrap();
|
||
assert_eq!(l[0]["styleMissing"], json!(true), "{l}");
|
||
}
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod composite_tests {
|
||
use super::*;
|
||
use designcraft_doc::{
|
||
ParaFormat,
|
||
cjk::{CompositeFont, CompositeFontEntry},
|
||
};
|
||
|
||
#[test]
|
||
fn inventory_resolves_composites_in_nested_cell_notes() {
|
||
use designcraft_doc::{StoryId, Table, build::NewDocument};
|
||
let mut d = Document::new(&NewDocument::default());
|
||
d.styles_mut().composite_fonts.push(CompositeFont {
|
||
name: "Mixed".into(),
|
||
entries: vec![
|
||
CompositeFontEntry { family: "Source Serif 4".into(), ..Default::default() },
|
||
CompositeFontEntry { characters: "1".into(), family: "Source Sans 3".into(), ..Default::default() },
|
||
],
|
||
});
|
||
let mut story = Story::new(StoryId(d.alloc()));
|
||
let mut table = Table::new(1, 1, 1, 0, 0, 100.0);
|
||
let cell = &mut table.cells[0].text;
|
||
cell.insert_note(0, "1", ParaFormat::default());
|
||
Arc::make_mut(&mut cell.notes[0]).text.format_chars(0..1, |f| f.over.font_family = Some("Mixed".into()));
|
||
story.insert_table(0, table);
|
||
d.stories.insert(story.id, Arc::new(story));
|
||
let fonts = list(&d);
|
||
assert!(fonts.iter().any(|f| f["family"] == "Source Sans 3" && f["characters"] == 1));
|
||
assert!(!fonts.iter().any(|f| f["family"] == "Mixed"));
|
||
}
|
||
|
||
#[test]
|
||
fn preflight_and_font_list_follow_used_composite_entries_in_notes() {
|
||
let mut s = Session::new();
|
||
s.execute("file.new", &json!({})).unwrap();
|
||
s.execute("frame.create", &json!({"rect": [20,20,400,600], "content":"text", "text":"Body"})).unwrap();
|
||
let d = Arc::make_mut(&mut s.doc_mut().unwrap().doc);
|
||
d.styles_mut().composite_fonts.push(CompositeFont {
|
||
name: "Mixed".into(),
|
||
entries: vec![
|
||
CompositeFontEntry { family: "Source Serif 4".into(), ..Default::default() },
|
||
CompositeFontEntry { characters: "1".into(), family: "Missing Note Digits".into(), ..Default::default() },
|
||
CompositeFontEntry { characters: "2".into(), family: "Unused Missing Digits".into(), ..Default::default() },
|
||
],
|
||
});
|
||
let sid = *d.stories.keys().next().unwrap();
|
||
let st = d.story_mut(sid).unwrap();
|
||
st.insert_note(4, "A1", ParaFormat::default());
|
||
Arc::make_mut(&mut st.notes[0]).text.format_chars(0..2, |f| f.over.font_family = Some("CompositeFont/Mixed".into()));
|
||
let list = s.execute("font.list", &json!({})).unwrap();
|
||
assert!(list.as_array().unwrap().iter().any(|f| f["family"] == "Missing Note Digits" && f["characters"] == 1));
|
||
assert!(!list.to_string().contains("Unused Missing Digits"));
|
||
let issues = s.execute("preflight.run", &json!({})).unwrap();
|
||
let fonts: Vec<_> = issues["issues"].as_array().unwrap().iter().filter(|i| i["kind"] == "missingFont").collect();
|
||
assert_eq!(fonts.len(), 1, "{issues}");
|
||
assert!(fonts[0]["message"].as_str().unwrap().contains("Missing Note Digits"));
|
||
s.execute("font.replace", &json!({"family":"Missing Note Digits", "toFamily":"Source Sans 3", "toStyle":"Regular"})).unwrap();
|
||
let issues = s.execute("preflight.run", &json!({})).unwrap();
|
||
assert!(issues["issues"].as_array().unwrap().iter().all(|i| i["kind"] != "missingFont"));
|
||
assert_eq!(s.doc().unwrap().doc.styles.composite_fonts[0].entries[1].characters, "1");
|
||
s.execute("edit.undo", &json!({})).unwrap();
|
||
assert_eq!(s.doc().unwrap().doc.styles.composite_fonts[0].entries[1].family, "Missing Note Digits");
|
||
}
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod resolution_tests {
|
||
use super::*;
|
||
|
||
#[test]
|
||
fn inventory_distinguishes_missing_styles_and_replacement_chooses_an_available_style() {
|
||
let mut s = Session::new();
|
||
s.execute("file.new", &json!({})).unwrap();
|
||
s.execute("frame.create", &json!({"rect":[20,20,300,400],"content":"text","text":"Body"})).unwrap();
|
||
let d = Arc::make_mut(&mut s.doc_mut().unwrap().doc);
|
||
let sid = *d.stories.keys().next().unwrap();
|
||
d.story_mut(sid).unwrap().format_chars(0..4, |f| {
|
||
f.over.font_family = Some("Source Sans 3".into());
|
||
f.over.font_style = Some("Unavailable Style".into());
|
||
});
|
||
let before = s.execute("font.list", &json!({})).unwrap();
|
||
assert_eq!(before[0]["matchStatus"], "styleSubstitute");
|
||
assert_eq!(before[0]["missing"], false);
|
||
assert_eq!(before[0]["styleMissing"], true);
|
||
assert_eq!(before[0]["resolvedStyle"], "Regular");
|
||
let preflight = s.execute("preflight.run", &json!({})).unwrap();
|
||
assert!(preflight["issues"].as_array().unwrap().iter().any(|i| i["kind"] == "missingFontStyle"));
|
||
s.execute("font.replace", &json!({"family":"Source Sans 3","toFamily":"Source Serif 4"})).unwrap();
|
||
let after = s.execute("font.list", &json!({})).unwrap();
|
||
assert_eq!(after[0]["matchStatus"], "exact");
|
||
s.execute("edit.undo", &json!({})).unwrap();
|
||
assert_eq!(before, s.execute("font.list", &json!({})).unwrap());
|
||
}
|
||
}
|