Compare commits

..
Author SHA1 Message Date
Martin BallandClaude Opus 5.5 be7624eb96 ROADMAP: remove two stray branch-name lines from the progress log
Leftovers from earlier merges: a line reading "fix/6146-touchpad-scroll-speed" and one reading "main" sat between progress-log entries.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FypgCXtSjB6e5jmy9Uq7u8
2026-11-17 08:05:16 +00:00
Bryan MarkandClaude Opus 5.5 aeb9704d82 UI: CJK text gets an installed CJK font in builds without craft-fonts and craft-i18n (#4637)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-17 08:53:51 +01:00
Michael MuandClaude Sonnet 5.5 221faf2901 KeyTips: two-letter command badges can be completed (#4498) (#4499)
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-17 08:40:33 +01:00
Dylan M. Taylor a5753be57e docs: prefer shared craft-libs implementations (#6862) 2026-11-17 08:27:16 +01:00
Valentin KleinandClaude Sonnet 5.5 caa4c4b114 Enter in a paragraph with a drop cap no longer copies the drop cap (#6793)
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-17 08:10:58 +01:00
Mex ca075db458 M14: report missing --cmd values before CLI options (#6686) 2026-11-17 07:54:43 +01:00
Valentin KleinandClaude Opus 5.5 4e2a5c2b8f Table borders no longer look blue and uneven (#6048)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-17 07:42:09 +01:00
Thân Minh NghĩaandClaude Opus 5.5 54e82f7131 Table Design: show Shading label beside the color menu arrow (#2016)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-17 07:26:11 +01:00
224bfdb2a0 Layout: Word 2003's indent rules start a line right after a float before the indent (#5939) (#5940) (#6905)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-Authored-By: SenuraMalaka <19330762+SenuraMalaka@users.noreply.github.com>
2026-11-17 07:04:39 +01:00
Bardan Ghimire abc04c1b41 geom: fix Rect collapse, sanitize deserialized Rect, accept non-ASCII… (#5880) 2026-11-17 06:50:55 +01:00
reubgr 29d862fabc Compare: preserve per-segment formatting in word_diff (#3749, stage 0) (#5569) 2026-11-17 06:37:34 +01:00
socrabs151 406befeaa2 #3720: budget hostile large parameters, and cap the TOC title (#5824) 2026-11-17 06:19:32 +01:00
ljkxandClaude Opus 5.5 93bf14883c #3773: a WordCraft process saves only the preferences it changed (#5258)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-17 06:06:04 +01:00
Marc 0cb315edaf fix(ui): Recent shortens long names and paths to the row (#5212) (#5321) 2026-11-17 05:53:08 +01:00
.CooCoo 2dd0f9a67b Field dialog: text fields have a Format list for capitalization (#5062) 2026-11-17 05:37:06 +01:00
Mex 739cdcad0b M15: correct English proofing credits in README (#6681) 2026-11-17 05:15:46 +01:00
Mex b3f31666d3 M14: align release guide with scheduled dry runs (#6682) 2026-11-17 05:00:18 +01:00
Mex 68f758928e M14: keep the type_text description in one MCP table row (#6683) 2026-11-17 04:45:21 +01:00
Mex 840efd03fb M14: link PDF revision guidance to the workspace manifest (#6685) 2026-11-17 04:30:24 +01:00
Mex 8e8ab631fd M14: document optional run commands and PNG save options (#6687) 2026-11-17 04:16:20 +01:00
Mex 8a9d04eeb1 M14: restore save stamps after immediate web-save errors (#6824) 2026-11-17 03:59:04 +01:00
Mex 266407e840 M14: expose file-browser row names and selection (#6790) 2026-11-17 03:46:09 +01:00
Valentin KleinandClaude Sonnet 5.5 c817cc95c6 Render: keep a metafile with huge bitmaps in the cache instead of parsing it on every repaint (#5494)
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-17 03:32:02 +01:00
Diego GueriniandClaude Opus 5.5 ff0823f40d Track Changes: a deleted list item's number is drawn as deleted text (#4828) (#4836)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-17 03:19:00 +01:00
Mex 211f62231d M14: correct control protocol parameter examples (#6684) 2026-11-17 03:03:15 +01:00
RickiNano 9144b9bfda Insert › Shapes: the Arrow tile is the block arrow it inserts (#6768) (#6882) 2026-11-17 02:45:40 +01:00
RickiNano a61cef5d45 edit.replace reports whether it replaced and what it selected (#6877) (#6879) 2026-11-17 02:29:41 +01:00
Mex 739491f5c7 M14: list xtask version and point layering help at public docs (#6688) 2026-11-17 02:13:51 +01:00
Mex 8377ea8e8f M7: document the explicit stop flag for protection (#6690) 2026-11-17 01:59:18 +01:00
Mex 4357166531 M14: report the supported ICO image bounds (#6694) 2026-11-17 01:28:39 +01:00
Mex 5d871d0519 M14: document the selection collapse end parameter (#6695) 2026-11-17 01:15:46 +01:00
Mex ae2d2b43d6 M3: describe the 32-bit comment identifier limit (#6696) 2026-11-17 01:03:22 +01:00
Mex cd23034f65 M14: clarify when layout tests need explicit font initialization (#6697) 2026-11-17 00:52:01 +01:00
Mex b2306fe5ef M3: explain invalid font name values (#6698) 2026-11-17 00:36:03 +01:00
Mex 646fbc7cd5 M10: clarify Zotero command response shapes (#6700) 2026-11-17 00:20:17 +01:00
Mex 4a347e070a M14: expose required command inputs in discovery (#6703) 2026-11-17 00:07:55 +01:00
Mex 3bf4c05461 M14: explain the bookmark name rules in validation errors (#6706) 2026-11-16 23:54:32 +01:00
Mex 7b26a94193 M14: clarify dictionary-folder auto reset (#6709) 2026-11-16 23:39:06 +01:00
Mex ace000b4a4 M14: expose table-style formatting names and selection (#6711) 2026-11-16 23:26:12 +01:00
Mex 7adbdc574c M14: describe canvas member listing without an index (#6714) 2026-11-16 23:12:16 +01:00
Mex f77eef9cb6 M14: expose the keyboard shortcut capture name and current key (#6716) 2026-11-16 22:57:20 +01:00
Mex a2f41d728e M14: distinguish font file and unpacked size limits in errors (#6719) 2026-11-16 22:41:53 +01:00
Mex 9fe9bd5042 M14: clarify initial and pane spelling-review wrapping (#6720) 2026-11-16 22:26:23 +01:00
Mex 83c3b5890b M14: describe all accepted mail-merge sort forms (#6724) 2026-11-16 22:15:32 +01:00
Mex f472620ac0 M14: explain invalid field code values (#6725) 2026-11-16 22:03:39 +01:00
FredApps 5467f998a0 Tests: set the fit-one-page fixtures in bundled Inter so FreeBSD pages them like other hosts (#6887)
* Tests: set the fit-one-page fixtures in bundled Inter

The fit-one-page fixtures count pages to the line, but they were set in the
default Aptos, which each host substitutes with whatever it has installed:
Arial on Windows, Liberation Sans on the Linux runners, DejaVu Sans on the
FreeBSD image (its only candidate). DejaVu Sans is taller, so at 11 pt it fits
27 of the fixture lines on a page where Arial fits 28, and the nightly FreeBSD
job failed fit_one_page_respects_step_pt and
fit_one_page_preserves_budget_across_document_serialization.

Set the fixtures in the bundled Inter, whose metrics keep a page boundary for
each 0.5 pt step, recount the fixed line counts for it, and start the boundary
searches below the boundary. The two tests that failed also assert that the
body is laid out in Inter, not a substitute.

* Tests: keep 7 to 12 body lines on the line-numbered fixture's final page

A boundary search left one body line on the final page, so counting the
line-number decorations too would still have stayed under the 12-line limit and
the test could not catch it. Use 33 lines, 8 on the final page in Inter, and
assert the body-only count is between 7 and 12.
2026-11-16 21:51:07 +01:00
Mex 78dfa8f648 M14: label Alt Text pane inputs for assistive technology (#6726) 2026-11-16 21:48:11 +01:00
Mex 82f0c467be M14: describe encrypted OpenDocument command support (#6776) 2026-11-16 21:32:11 +01:00
Mex 837a610133 M14: explain hyperlink URL input limits (#6789) 2026-11-16 21:20:15 +01:00
FredApps de977bcde6 Merge pull request #6658 from dotCooCoo/fix/issue-6636
Metafiles: draw EMF+ bitmaps, pattern fills, clips and pen styles from craft-metafile (#6636)
2026-11-16 17:28:06 +01:00
FredApps 4ba0595760 Merge pull request #6863 from storytold/refactor/shared-tiff-compression
geom: delegate TIFF compression inspection to craft-tiff
2026-11-16 16:48:47 +01:00
dotCooCoo e6e8c61dbf Merge main into fix/issue-6636 2026-11-14 12:11:53 -08:00
dotCooCoo 1d150004f7 Tests: EMF+ only bitmaps are drawn over their EmfPlusDrawImage rectangle
The two EMF+ bitmap tests checked only that the bitmap is embedded. They now
also read the page through hayro's interpreter and check that the page draws
each bitmap over the right half of the picture, where its EmfPlusDrawImage
rectangle places it.
2026-11-14 11:40:21 -08:00
dotCooCoo 7ccfd4caef Tests: EMF+ only bitmaps in ARGB, RGB, PNG and JPEG are drawn
The page renderer and the PDF exporter each get a test that draws an
EmfPlusDrawImage bitmap in PixelFormat32bppARGB, 24bppRGB and 32bppRGB,
and a compressed PNG and JPEG bitmap, from an EMF+ only file.
2026-11-14 07:40:12 -08:00
dotCooCoo 7b3b6f8041 Merge main into fix/issue-6636 2026-11-14 07:32:49 -08:00
dotCooCoo fecb717f99 Metafiles: read WMF, EMF and EMF+ with craft-metafile (#6636)
crates/metafile is deleted. formats, layout, render and pdf take their
WMF, EMF and EMF+ reader from craft-metafile (craft-libs 9dcbd90c, the
rev craft-docx is already pinned at), so EMF+ records are read: an EMF+
only file's DrawImage of a 32bppPARGB bitmap draws its pixels.

render and pdf draw what the shared model adds: pattern and hatch fills,
clip regions and clip paths, pen caps, joins, miter limits and dashes,
turned, skewed or mirrored bitmaps, and the opaque background behind
text. The text layout and the default font for a file that names none
(Arial, a 16-unit cell) move to layout, next to metafile_text_run.

layout/src/metafile.rs holds the rules both outputs follow: a negative
crop side draws as no crop, as before; a cosmetic pen's shortest dash
or gap is one output pixel; a dash pattern whose period is under a
pixel, or that would split a path into more than 100,000 pieces, draws
solid; and an invalid miter limit is 10. On screen, a pattern tile whose
sides are both under 1.5 device pixels fills with its average color,
computed once a tile, and the vector cache counts each item's clip
region, clip list and dash pattern.

Fixes #6636
2026-11-14 05:16:52 -08:00
93 changed files with 5140 additions and 360 deletions
+4
View File
@@ -138,3 +138,7 @@ Progress docs: `ROADMAP.md` (stage, headline numbers, progress log), `docs/targe
- Some workflow files here still run their own jobs. Don't add to them. Moving a job into craft-common-actions is its own task, never part of another PR, and the job stays here until a shared workflow runs it.
New workspace crates include `workspace = true` under `[lints]` in `Cargo.toml`. Production crate roots declare the crate-level lint attributes before modules; crate-level `//!` documentation may precede them.
## Shared-library reuse
Before implementing file formats, codecs, protocols or reusable UI components, check [storytold/craft-libs](https://github.com/storytold/craft-libs) and relevant open PRs; reuse or extend shared APIs instead of duplicating app-local implementations. Keep app-specific policy and adapters local, preserve behavior and format fidelity, security and resource limits, repository layering and regression tests, and document any shared-API gap rather than silently reducing functionality.
+4 -2
View File
@@ -451,8 +451,10 @@ Copyright (c) 2026 ArtCraft Team and the WordCraft contributors. Required notice
Bundled fonts, icons, images and other assets keep their own open licenses; each one is listed
with its author, source and license in [ATTRIBUTION.md](ATTRIBUTION.md).
The English spelling dictionary and hyphenation come from Grady Ward's public-domain Moby
Hyphenator II word list. Polish spelling reads the Hunspell `pl_PL` dictionary installed on the system (not bundled), as
English spelling first tries a matching Hunspell dictionary from the Dictionaries folder.
Otherwise it uses dialect-specific SCOWL 2026 dictionaries when built with language data;
without it, spelling falls back to system Hunspell dictionaries or Grady Ward's public-domain
Moby Hyphenator II word list. English hyphenation uses the Moby list and patterns trained from it. Polish spelling reads the Hunspell `pl_PL` dictionary installed on the system (not bundled), as
do Russian, Portuguese, Czech, Italian, Croatian and Turkish spelling (how to install them:
[docs/spelling-dictionaries.md](docs/spelling-dictionaries.md)), and
Polish hyphenation the TeX patterns by Hanna Kołodziejska, Bogusław Jackowski and Marek Ryćko (MIT
+5 -3
View File
File diff suppressed because one or more lines are too long
+9 -3
View File
@@ -35,10 +35,11 @@ USAGE:
--strict writes nothing and exits 3 if a character on the
page can't be drawn or a picture is missing or undecodable
(report on stderr, as for convert --strict)
wordcraft-cli run [--file F | --template T] [--script FILE|-] --cmd 'id={json}' [--cmd …]
[--save OUT] [--print] [--author NAME]
wordcraft-cli run [--file F | --template T] [--script FILE|-] [--cmd 'id={json}' …]
[--save OUT] [--page N] [--scale S] [--print] [--author NAME]
run commands headlessly, then save (--author names
who tracked changes and comments are by).
PNG saves use --page (1-based, default 1) and --scale (default 2).
--script runs a JSON file (- is stdin) first:
{\"file\"?, \"template\"?, \"commands\": [{\"command\": id,
\"params\"?: {…}} | id, …], \"save\"?: [OUT, …]}; save
@@ -602,6 +603,11 @@ fn run<S: AsRef<OsStr>>(args: &[S]) -> Result<(), Failure> {
write_stdout(|o| writeln!(o, "{r}"))
}
"run" => {
for (i, arg) in rest.iter().enumerate() {
if arg == "--cmd" && rest.get(i + 1).is_none_or(|value| value.starts_with("--")) {
return Err("--cmd needs a value".into());
}
}
validate_options("run", &rest, RUN_OPTIONS)?;
let page = parse_page_arg("run", &rest)?;
let scale = parse_scale_arg("run", &rest)?;
@@ -635,7 +641,7 @@ fn run<S: AsRef<OsStr>>(args: &[S]) -> Result<(), Failure> {
let mut i = 0;
while i < rest.len() {
if rest.get(i).map(String::as_str) == Some("--cmd") {
let spec = rest.get(i + 1).ok_or("--cmd needs a value")?;
let spec = rest.get(i + 1).filter(|value| !value.starts_with("--")).ok_or("--cmd needs a value")?;
let (id, params) = match spec.split_once('=') {
Some((id, p)) => {
(id.to_string(), serde_json::from_str::<Value>(p).map_err(|e| engine_error(format!("{id}: bad JSON params: {e}")))?)
+21
View File
@@ -497,6 +497,27 @@ fn command_line_template_wins_over_the_scripts_file() {
assert!(std::fs::read_to_string(&b).unwrap().contains("FROM FILE"));
}
#[test]
fn cmd_value_missing_is_reported() {
let missing = std::env::temp_dir().join(format!(
"wc-cli-missing-cmd-{}-{}.docx",
std::process::id(),
std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_nanos()
));
assert!(!missing.exists());
let missing = missing.to_string_lossy();
for argv in [
vec!["run", "--cmd"],
vec!["run", "--cmd", "--save", "out.docx"],
vec!["run", "--cmd", "caret.docEnd", "--cmd", "--print"],
vec!["run", "--cmd", "--bogus"],
vec!["run", "--cmd", "--file", &missing],
] {
assert_eq!(run(&args(&argv)), Err("--cmd needs a value".into()), "{argv:?}");
}
assert!(run(&args(&["run", "--cmd", "caret.docEnd", "--cmd", "caret.docStart"])).is_ok());
}
#[test]
fn script_value_missing_is_reported() {
let e = run(&args(&["run", "--script", "--cmd", "caret.docEnd"])).unwrap_err().to_string();
+164 -16
View File
@@ -23,6 +23,7 @@ mod graphics;
mod logging;
#[cfg(all(unix, not(target_os = "macos")))]
mod portal_save;
mod prefs_merge;
mod print;
mod region;
#[cfg(target_os = "macos")]
@@ -222,31 +223,44 @@ fn user_dict_path() -> Option<std::path::PathBuf> {
wordcraft_control_key::settings_dir().map(|b| b.join(wordcraft_engine::Session::USER_DICT_FILE))
}
fn load_user_dictionary(app: &mut WordApp) {
if !prefs_enabled() {
return;
}
if let Some(p) = user_dict_path() {
wordcraft_proof::load_user_dictionary(&p);
app.session.user_dict_path = Some(p);
}
}
/// Runs without preferences (`WORDCRAFT_NO_PREFS`, agents' test runs) neither read nor write them.
fn prefs_enabled() -> bool {
std::env::var_os("WORDCRAFT_NO_PREFS").is_none()
}
/// The preferences as this process last loaded or saved them, which `save_prefs` compares with
/// to write only what this process changed since (#3773, see `prefs_merge`).
static LOADED_PREFS: std::sync::Mutex<Option<serde_json::Value>> = std::sync::Mutex::new(None);
/// Apply the saved preferences (`ui.json`) and the user dictionary to `app`, and remember the
/// result for `save_prefs`. Runs without preferences neither read nor keep them.
fn load_prefs(app: &mut WordApp) {
if !prefs_enabled() {
return;
}
if let Some(p) = prefs_path()
&& let Ok(bytes) = std::fs::read(&p)
let loaded = load_prefs_from(app, prefs_path().as_deref(), user_dict_path());
if let Ok(mut slot) = LOADED_PREFS.lock() {
*slot = loaded;
}
}
/// Apply the preferences saved at `prefs` to `app`, then load the user dictionary at `dict`
/// (`custom-dictionary.txt`, #40), and give back the preferences as `prefs()` does after both:
/// the words only the dictionary file has are part of what was loaded, so a word another process
/// removes from `ui.json` isn't written back as one added here (#3773).
fn load_prefs_from(app: &mut WordApp, prefs: Option<&std::path::Path>, dict: Option<std::path::PathBuf>) -> Option<serde_json::Value> {
if let Some(p) = prefs
&& let Ok(bytes) = std::fs::read(p)
&& let Some(ui) = UiState::from_json(&bytes)
{
app.apply_prefs(ui);
}
if let Some(p) = dict {
wordcraft_proof::load_user_dictionary(&p);
app.session.user_dict_path = Some(p);
}
// As `prefs()` gives them back, so a setting nobody touched compares equal at exit.
serde_json::to_value(app.prefs()).ok()
}
/// Fonts the user added (#582) live in `fonts` in the settings folder: load them, and store fonts
@@ -332,6 +346,8 @@ fn x11_libraries() -> Result<(), String> {
if missing.is_empty() { Ok(()) } else { Err(missing.join("; ")) }
}
/// Write `app`'s preferences to `ui.json`, merged with what other processes saved since this one
/// loaded it (`merged_prefs`).
fn save_prefs(app: &WordApp) {
if let Err(e) = try_save_prefs(app) {
log::warn!("preferences: {e}");
@@ -348,11 +364,79 @@ fn try_save_prefs(app: &WordApp) -> Result<bool, String> {
if let Some(dir) = p.parent() {
std::fs::create_dir_all(dir).map_err(|e| format!("cannot create {}: {e}", dir.display()))?;
}
let bytes = serde_json::to_vec_pretty(&app.prefs()).map_err(|e| format!("cannot serialize: {e}"))?;
write_prefs(&p, &bytes).map_err(|e| format!("cannot save {}: {e}", p.display()))?;
let ours = serde_json::to_value(app.prefs()).map_err(|e| format!("cannot serialize: {e}"))?;
let mut base = LOADED_PREFS.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
save_merged(&p, &mut base, ours)?;
Ok(true)
}
/// Writes `ours` to `path`, merged with what other WordCraft processes saved there since this one
/// loaded or saved `base` (`merged_prefs`), and makes `ours` the new `base`: a setting changed here
/// before this save and by another process after it then takes the other's value at the next save.
/// Holds `lock_prefs` from the read to the rename.
fn save_merged(path: &std::path::Path, base: &mut Option<serde_json::Value>, ours: serde_json::Value) -> Result<(), String> {
let _lock = lock_prefs(path);
let merged = merged_prefs(path, base.as_ref(), ours.clone());
let bytes = serde_json::to_vec_pretty(&merged).map_err(|e| format!("cannot serialize: {e}"))?;
write_prefs(path, &bytes).map_err(|e| format!("cannot save {}: {e}", path.display()))?;
*base = Some(ours);
Ok(())
}
/// `ours` with what other WordCraft processes saved to `path` since this one loaded or saved
/// `base`, for the settings this one left alone (#3773, see `prefs_merge`). `ours` as it is when
/// there's no `base`, or the file is missing or isn't preferences now.
fn merged_prefs(path: &std::path::Path, base: Option<&serde_json::Value>, ours: serde_json::Value) -> serde_json::Value {
let Some(base) = base else { return ours };
let disk = match std::fs::read(path) {
Ok(bytes) => prefs_merge::as_read(&bytes),
Err(e) => {
if e.kind() != std::io::ErrorKind::NotFound {
log::debug!("preferences: cannot read {} to merge, saving this process's: {e}", path.display());
}
return ours;
}
};
match disk {
Some(disk) => prefs_merge::merge(base, ours, &disk),
None => {
log::debug!("preferences: {} isn't preferences, saving this process's", path.display());
ours
}
}
}
/// How long a save waits for another process's save to finish before going ahead anyway: a save
/// takes milliseconds, and a process stuck holding the lock mustn't stop this one from saving.
const PREFS_LOCK_WAIT: std::time::Duration = std::time::Duration::from_secs(2);
/// An advisory lock beside `path` (`.ui.json.lock`), held while it is returned, so that two
/// processes saving at once (logging out closes every window together) take turns at reading,
/// merging and replacing `ui.json` instead of one losing the other's changes. `None` (save
/// unlocked) when the lock file can't be opened or the lock isn't free within [`PREFS_LOCK_WAIT`].
fn lock_prefs(path: &std::path::Path) -> Option<std::fs::File> {
let name = path.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_else(|| "ui.json".into());
let lock = path.with_file_name(format!(".{name}.lock"));
let file = match std::fs::OpenOptions::new().create(true).truncate(false).write(true).open(&lock) {
Ok(f) => f,
Err(e) => {
log::debug!("preferences: cannot open {}, saving without it: {e}", lock.display());
return None;
}
};
let start = std::time::Instant::now();
loop {
match file.try_lock() {
Ok(()) => return Some(file),
Err(std::fs::TryLockError::WouldBlock) if start.elapsed() < PREFS_LOCK_WAIT => std::thread::sleep(std::time::Duration::from_millis(10)),
Err(e) => {
log::warn!("preferences: {} is held, saving without it: {e}", lock.display());
return None;
}
}
}
}
/// Writes `bytes` to a sibling temporary file and renames it over `path`, so a failed or
/// interrupted write leaves the previous preferences in place.
fn write_prefs(path: &std::path::Path, bytes: &[u8]) -> std::io::Result<()> {
@@ -626,7 +710,6 @@ fn main() -> eframe::Result {
if updates_unsafe {
app.disable_self_update();
}
load_user_dictionary(&mut app);
// Language packs from the suite's font store; an Install click is the person's own.
wordcraft_engine::packs::use_font_store(true);
// A region chosen in File › Options replaces the system's for the first blank
@@ -839,7 +922,72 @@ mod launch_arg_tests {
#[cfg(test)]
mod prefs_tests {
use super::write_prefs;
use serde_json::{Value, json};
use wordcraft_ui_egui::{UiState, theme::Appearance};
use super::{load_prefs_from, lock_prefs, prefs_merge, save_merged, write_prefs};
/// The preferences saved with `theme` (every other setting at its default).
fn with_theme(theme: &str) -> Value {
prefs_merge::as_read(&serde_json::to_vec(&json!({"theme": theme})).unwrap()).unwrap()
}
/// The theme the next process loads from `path`.
fn saved_theme(path: &std::path::Path) -> Appearance {
UiState::from_json(&std::fs::read(path).unwrap()).unwrap().theme
}
#[test]
fn a_setting_changed_by_another_process_after_a_save_here_keeps_its_value() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("ui.json");
std::fs::write(&path, serde_json::to_vec(&with_theme("light")).unwrap()).unwrap();
// A loads Light, switches to Dark and saves before exiting (taking a document off the
// recent list does).
let mut a = Some(with_theme("light"));
save_merged(&path, &mut a, with_theme("dark")).unwrap();
assert_eq!(saved_theme(&path), Appearance::Dark);
// B starts, loads Dark, switches to Light and exits.
save_merged(&path, &mut Some(with_theme("dark")), with_theme("light")).unwrap();
// A exits without touching the theme since its save: B's choice, made later, stays.
save_merged(&path, &mut a, with_theme("dark")).unwrap();
assert_eq!(saved_theme(&path), Appearance::Light);
}
#[test]
fn the_loaded_preferences_include_the_words_of_the_dictionary_file() {
// A word only `custom-dictionary.txt` has is loaded, not added here: if another process
// removes it from `ui.json`, this one mustn't write it back.
let dir = tempfile::tempdir().unwrap();
let (prefs, dict) = (dir.path().join("ui.json"), dir.path().join("custom-dictionary.txt"));
std::fs::write(&prefs, br#"{"dictionary": ["zqxinjson"]}"#).unwrap();
std::fs::write(&dict, "zqxinfile\n").unwrap();
let mut app = wordcraft_ui_egui::WordApp::new(wordcraft_engine::Session::new(wordcraft_doc::Document::new()), Default::default());
let loaded = load_prefs_from(&mut app, Some(&prefs), Some(dict)).unwrap();
let words = loaded["dictionary"].as_array().unwrap();
for word in ["zqxinjson", "zqxinfile"] {
assert!(words.contains(&json!(word)), "{word}: {words:?}");
}
wordcraft_engine::proof::remove_word("zqxinjson");
wordcraft_engine::proof::remove_word("zqxinfile");
}
#[test]
fn a_save_waits_for_another_process_saving_at_the_same_moment() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("ui.json");
// Another process is between reading and replacing `ui.json`.
let held = lock_prefs(&path).expect("the lock is free");
let saver = {
let path = path.clone();
std::thread::spawn(move || save_merged(&path, &mut None, with_theme("dark")))
};
std::thread::sleep(std::time::Duration::from_millis(200));
assert!(!path.exists(), "saved while another process held the lock");
drop(held);
saver.join().unwrap().unwrap();
assert_eq!(saved_theme(&path), Appearance::Dark);
}
#[test]
fn failed_preferences_write_keeps_the_old_file_and_reports_the_error() {
+550
View File
@@ -0,0 +1,550 @@
//! Several WordCraft processes share one `ui.json` (opening a file from the file manager starts
//! another). Each reads it at start-up and writes it at exit (and when a change must survive a
//! crash, like taking a document off the recent list), so without a merge the process that writes
//! last writes back what it loaded and loses the others' changes (#3773).
//!
//! The policy: when saving, read `ui.json` again as this version reads it ([`as_read`]: a setting
//! of the wrong type reads as its default, and keys it doesn't know or reads only to migrate are
//! left out), and write it with only what this process changed since it last loaded or saved its
//! preferences (`base`). Every other setting keeps what the file holds now, including the absence
//! of one another process removed (a shortcut, a task pane's place).
//!
//! - A setting both changed takes this process's value.
//! - Groups of settings (editing options, AutoCorrect's switches, keyboard shortcuts, the ribbon,
//! task pane places) merge entry by entry ([`rule`]). Any other object is one setting: the
//! window's size and place, or one task pane's place, are never mixed from two processes.
//! - Lists of user entries (AutoCorrect entries by the text they replace, its exceptions, removed
//! built-in shortcuts, ribbon tabs by name, Quick Access Toolbar commands, caption labels, pens,
//! custom dictionary words) merge entry by entry too ([`merge_entries`]): entries either process
//! added are kept, entries either process removed stay removed, and an entry both changed takes
//! this process's version. A ribbon or toolbar left as it comes counts as its default entries.
//! - Recent lists (documents, symbols, colours, fonts) take the entries this process added or used
//! again first, then the file's, without duplicates, without the entries this process removed,
//! and within each list's limit ([`merge_recent`]).
//! - Any other list (the task panes' order, a floating pane's rectangle) is one setting.
//!
//! What this process changed is found by comparing with `base`, not by recording each change: a
//! setting changed and then changed back counts as untouched, so the file's value stays, and a
//! recent entry used again without moving (it was already first) counts as not used.
use std::collections::{HashMap, HashSet};
use serde_json::{Map, Value};
use wordcraft_engine::ribbon::{DEFAULT_QAT, RibbonLayout};
use wordcraft_ui_egui::{MAX_RECENT, MAX_RECENT_FONTS, UiState, colors, dialogs_insert};
/// Whether two entries of a recent list are the same entry.
type Same = fn(&Value, &Value) -> bool;
/// What tells an entry of a list of user entries from the others. Entries with the same key are
/// told apart by their order ([`ids`]).
type Key = fn(&Value) -> String;
/// How a setting this process changed merges with the file's.
#[derive(Clone, Copy)]
enum Rule {
/// A group of settings: each entry on its own.
Group,
/// A recent list, most recent first: how many entries it keeps, and when two are the same.
Recent(usize, Same),
/// A list of user entries: each entry on its own.
Entries(Key),
/// One setting: this process's value.
Whole,
}
/// The rule for the setting at `path` (`ui.json`'s keys from the top).
fn rule(path: &[&str]) -> Rule {
match path {
[] | ["editing" | "keyboard" | "ribbon" | "panePlaces"] | ["editing", "markup" | "marks" | "autocorrect"] | ["keyboard", "assigned"] => {
Rule::Group
}
["recent"] => Rule::Recent(MAX_RECENT, same_entry),
["recentSymbols"] => Rule::Recent(dialogs_insert::RECENT_SYMBOLS, same_entry),
["recentColors"] => Rule::Recent(colors::RECENT_MAX, same_entry),
["recentFonts"] => Rule::Recent(MAX_RECENT_FONTS, same_font),
["editing", "autocorrect", "entries"] => Rule::Entries(replaced_text),
["ribbon", "tabs"] => Rule::Entries(tab_name),
["editing", "autocorrect", "removed" | "exceptions" | "exceptionsRemoved" | "initialCapsExceptions"]
| ["keyboard", "removed"]
| ["ribbon", "qat"]
| ["captionLabels" | "inkPens" | "dictionary"] => Rule::Entries(whole_entry),
_ => Rule::Whole,
}
}
/// What a setting saved only when it isn't its default stands for when it is missing: the
/// default ribbon tabs and Quick Access Toolbar, so that two processes customizing them from the
/// default merge entry by entry.
fn when_missing(path: &[&str]) -> Option<Value> {
match path {
["ribbon", "tabs"] => serde_json::to_value(RibbonLayout::default().tabs()).ok(),
["ribbon", "qat"] => serde_json::to_value(DEFAULT_QAT).ok(),
_ => None,
}
}
/// Entries saved alike (colours are saved normalised, `colors::push_recent`).
fn same_entry(a: &Value, b: &Value) -> bool {
a == b
}
/// Font names ignoring case, as `push_recent_font` compares them.
fn same_font(a: &Value, b: &Value) -> bool {
match (a.as_str(), b.as_str()) {
(Some(a), Some(b)) => a.to_lowercase() == b.to_lowercase(),
_ => a == b,
}
}
/// The entry as saved.
fn whole_entry(v: &Value) -> String {
v.to_string()
}
/// An AutoCorrect entry `[from, to]` by the text it replaces.
fn replaced_text(v: &Value) -> String {
v.get(0).unwrap_or(v).to_string()
}
/// A ribbon tab by its name, ignoring case as the ribbon does.
fn tab_name(v: &Value) -> String {
v.get("name").and_then(Value::as_str).map_or_else(|| v.to_string(), str::to_lowercase)
}
/// `ui.json`'s bytes as this version reads them, saved again: `None` when they aren't
/// preferences at all.
pub fn as_read(bytes: &[u8]) -> Option<Value> {
serde_json::to_value(UiState::from_json(bytes)?).ok()
}
/// The preferences to write: `ours` (this process's, now), with every value it left as it was in
/// `base` (what it last loaded or saved) taken from `disk` (what `ui.json` holds now, [`as_read`]).
pub fn merge(base: &Value, ours: Value, disk: &Value) -> Value {
let fallback = ours.clone();
merge_setting(&mut Vec::new(), Some(base), Some(ours), Some(disk)).unwrap_or(fallback)
}
/// One setting, at `path`. `None` for a setting left out (this process removed it, or it left it
/// alone and another process removed it).
fn merge_setting(path: &mut Vec<String>, base: Option<&Value>, ours: Option<Value>, disk: Option<&Value>) -> Option<Value> {
if base == ours.as_ref() {
// Unchanged here: whatever the file holds now.
return disk.cloned();
}
let ours = ours?;
let keys: Vec<&str> = path.iter().map(String::as_str).collect();
Some(match (rule(&keys), ours, base, disk) {
(Rule::Group, Value::Object(ours), Some(Value::Object(base)), Some(Value::Object(disk))) => {
Value::Object(merge_group(path, base, ours, disk))
}
(Rule::Recent(cap, same), Value::Array(ours), Some(Value::Array(base)), Some(Value::Array(disk))) => {
Value::Array(merge_recent(base, ours, disk, cap, same))
}
(Rule::Entries(key), Value::Array(ours), Some(Value::Array(base)), Some(Value::Array(disk))) => {
Value::Array(merge_entries(base, &ours, disk, key))
}
(_, ours, ..) => ours,
})
}
/// A group of settings, entry by entry: this process's entries in their order, then those only
/// the file or `base` has.
fn merge_group(path: &mut Vec<String>, base: &Map<String, Value>, mut ours: Map<String, Value>, disk: &Map<String, Value>) -> Map<String, Value> {
let mut names: Vec<String> = ours.keys().cloned().collect();
let mut seen: HashSet<String> = names.iter().cloned().collect();
for k in disk.keys().chain(base.keys()) {
if seen.insert(k.clone()) {
names.push(k.clone());
}
}
let mut merged = Map::new();
for k in names {
path.push(k.clone());
let keys: Vec<&str> = path.iter().map(String::as_str).collect();
let missing = when_missing(&keys);
let base_v = base.get(&k).cloned().or_else(|| missing.clone());
let disk_v = disk.get(&k).cloned().or_else(|| missing.clone());
let ours_v = ours.remove(&k).or_else(|| missing.clone());
let v = merge_setting(path, base_v.as_ref(), ours_v, disk_v.as_ref());
path.pop();
// A setting saved only when it isn't its default is left out when it is.
if let Some(v) = v.filter(|v| Some(v) != missing.as_ref()) {
merged.insert(k, v);
}
}
merged
}
/// A list entry: its key, and how many entries before it have the same key.
type Id = (String, usize);
/// The entries of `list` told apart by `key`, in order.
fn ids(list: &[Value], key: Key) -> Vec<Id> {
let mut seen: HashMap<String, usize> = HashMap::new();
list.iter()
.map(|v| {
let k = key(v);
let n = seen.entry(k.clone()).or_default();
*n += 1;
(k, *n - 1)
})
.collect()
}
/// A list of user entries, entry by entry. An entry either process added is kept, one either
/// removed stays removed, and one this process changed takes its version (else the file's). The
/// order is this process's if it reordered the entries it loaded, else the file's; an entry only
/// the other list has goes after the entry it follows there.
fn merge_entries(base: &[Value], ours: &[Value], disk: &[Value], key: Key) -> Vec<Value> {
let (base_ids, ours_ids, disk_ids) = (ids(base, key), ids(ours, key), ids(disk, key));
let index = |ids: &[Id], list: &[Value]| -> HashMap<Id, Value> { ids.iter().cloned().zip(list.iter().cloned()).collect() };
let (b, o, d) = (index(&base_ids, base), index(&ours_ids, ours), index(&disk_ids, disk));
let value = |id: &Id| -> Option<&Value> {
match (b.get(id), o.get(id), d.get(id)) {
// Left alone here: the file's, or gone if the other process removed it.
(Some(b), Some(o), d) if b == o => d,
// Added or changed here.
(_, Some(o), _) => Some(o),
// Removed here.
(Some(_), None, _) => None,
// Added there.
(None, None, d) => d,
}
};
let common = |ids: &[Id], other: &HashMap<Id, Value>| -> Vec<Id> { ids.iter().filter(|id| other.contains_key(*id)).cloned().collect() };
let reordered = common(&ours_ids, &b) != common(&base_ids, &o);
let (first, second) = if reordered { (&ours_ids, &disk_ids) } else { (&disk_ids, &ours_ids) };
let in_first: HashSet<&Id> = first.iter().collect();
let kept: HashSet<&Id> = first.iter().filter(|id| value(id).is_some()).collect();
// Entries only `second` has, by the kept entry they follow there (`None`: at the start).
let mut after: HashMap<Option<&Id>, Vec<&Id>> = HashMap::new();
let mut anchor = None;
for id in second {
if kept.contains(id) {
anchor = Some(id);
} else if !in_first.contains(id) && value(id).is_some() {
after.entry(anchor).or_default().push(id);
}
}
let mut merged = Vec::new();
let mut emit = |ids: &[&Id]| merged.extend(ids.iter().filter_map(|id| value(id).cloned()));
emit(after.get(&None).map_or(&[], Vec::as_slice));
for id in first.iter().filter(|id| kept.contains(id)) {
emit(&[id]);
emit(after.get(&Some(id)).map_or(&[], Vec::as_slice));
}
merged
}
/// The entries this process put at the front of `ours` ([`touched_len`]), then `disk`'s, leaving
/// out what this process removed (in `base` but no longer in `ours`), without duplicates and at
/// most `cap` entries. Entries are told apart by `same`.
fn merge_recent(base: &[Value], ours: Vec<Value>, disk: &[Value], cap: usize, same: Same) -> Vec<Value> {
let has = |list: &[Value], v: &Value| list.iter().any(|x| same(x, v));
let removed = |v: &Value| has(base, v) && !has(&ours, v);
let touched = &ours[..touched_len(base, &ours, same)];
let mut merged: Vec<Value> = Vec::new();
for v in touched.iter().cloned().chain(disk.iter().filter(|v| !removed(v)).cloned()) {
if merged.len() == cap {
break;
}
if !has(&merged, &v) {
merged.push(v);
}
}
merged
}
/// How many of `ours`'s first entries this process added or used again. Each use moves an entry
/// to the front of a recent list, so what it left alone is a tail of `ours` in `base`'s order: the
/// longest such tail is untouched, and everything before it (new entries, and entries that moved
/// ahead of one loaded before them) was touched. A use that leaves the order as it was loaded
/// (the first entry used again) can't be told from no use, and merges as none.
fn touched_len(base: &[Value], ours: &[Value], same: Same) -> usize {
let mut end = base.len();
for (i, v) in ours.iter().enumerate().rev() {
match base[..end].iter().rposition(|b| same(b, v)) {
Some(at) => end = at,
None => return i + 1,
}
}
0
}
#[cfg(test)]
mod tests {
use serde_json::{Value, json};
use wordcraft_ui_egui::UiState;
use super::{as_read, merge};
/// The preferences a process holds after loading a `ui.json` with `settings` (every other
/// setting at its default), as it saves them.
fn prefs(settings: Value) -> Value {
as_read(&serde_json::to_vec(&settings).unwrap()).unwrap()
}
/// What the next process loads from the merged preferences.
fn reloaded(merged: &Value) -> UiState {
UiState::from_json(&serde_json::to_vec(merged).unwrap()).unwrap()
}
/// `ui.json` after B and then A, which both loaded `loaded`, save `b` and `a`.
fn b_then_a(loaded: &Value, b: Value, a: Value) -> Value {
let after_b = merge(loaded, b, loaded);
merge(loaded, a, &after_b)
}
#[test]
fn two_processes_keep_each_others_changes() {
// #3773: A and B both start from the same file.
let loaded =
json!({"theme": "light", "author": "Ann", "recent": ["a.docx", "b.docx"], "editing": {"smartQuotes": true, "autoCapitalize": true}});
// B changes the theme and opens c.docx, then exits first.
let b = json!({"theme": "dark", "author": "Ann", "recent": ["c.docx", "a.docx", "b.docx"], "editing": {"smartQuotes": false, "autoCapitalize": true}});
// A changes the author name and opens d.docx, then exits.
let a = json!({"theme": "light", "author": "Bo", "recent": ["d.docx", "a.docx", "b.docx"], "editing": {"smartQuotes": true, "autoCapitalize": false}});
assert_eq!(
b_then_a(&loaded, b, a),
json!({"theme": "dark", "author": "Bo", "recent": ["d.docx", "c.docx", "a.docx", "b.docx"], "editing": {"smartQuotes": false, "autoCapitalize": false}})
);
}
#[test]
fn a_process_that_changed_nothing_writes_the_file_back_as_it_is() {
let loaded = json!({"theme": "light", "recent": ["a.docx"]});
let disk = json!({"theme": "dark", "recent": ["b.docx", "a.docx"]});
assert_eq!(merge(&loaded, loaded.clone(), &disk), disk);
}
#[test]
fn this_process_wins_a_setting_both_changed() {
let loaded = json!({"theme": "light"});
assert_eq!(merge(&loaded, json!({"theme": "system"}), &json!({"theme": "dark"})), json!({"theme": "system"}));
}
#[test]
fn a_setting_changed_and_changed_back_counts_as_untouched() {
// Changes are found by comparing with what was loaded: A switched to dark and back.
let loaded = json!({"theme": "light"});
assert_eq!(merge(&loaded, json!({"theme": "light"}), &json!({"theme": "dark"})), json!({"theme": "dark"}));
}
#[test]
fn a_recent_entry_removed_here_stays_removed() {
let loaded = json!({"recent": ["a.docx", "b.docx"]});
let ours = json!({"recent": ["b.docx"]});
let disk = json!({"recent": ["c.docx", "a.docx", "b.docx"]});
assert_eq!(merge(&loaded, ours, &disk), json!({"recent": ["c.docx", "b.docx"]}));
// Clear Recent clears what the other process had added too only if it was loaded here.
assert_eq!(merge(&loaded, json!({"recent": []}), &json!({"recent": ["c.docx", "a.docx", "b.docx"]})), json!({"recent": ["c.docx"]}));
}
#[test]
fn a_recent_entry_used_again_here_moves_to_the_front() {
// Applying a font already in Recently Used Fonts moves it to the front without adding one.
let loaded = json!({"recentFonts": ["A", "B"]});
assert_eq!(merge(&loaded, json!({"recentFonts": ["B", "A"]}), &loaded), json!({"recentFonts": ["B", "A"]}));
// Here C was used again, D opened and A removed; the other process used B again and added E.
let loaded = json!({"recent": ["a.docx", "b.docx", "c.docx"]});
let ours = json!({"recent": ["d.docx", "c.docx", "b.docx"]});
let disk = json!({"recent": ["e.docx", "b.docx", "a.docx", "c.docx"]});
assert_eq!(merge(&loaded, ours, &disk), json!({"recent": ["d.docx", "c.docx", "e.docx", "b.docx"]}));
// Entries this process only kept, in the order it loaded them, don't override the file's order.
let loaded = json!({"recentSymbols": ["x", "y", "z"]});
let ours = json!({"recentSymbols": ["w", "x", "z"]});
let disk = json!({"recentSymbols": ["z", "x", "y"]});
assert_eq!(merge(&loaded, ours, &disk), json!({"recentSymbols": ["w", "z", "x"]}));
}
#[test]
fn recent_fonts_are_one_entry_whatever_their_case() {
// Recently Used Fonts ignores case (`push_recent_font`): Arial applied here as `arial` and
// there as `ARIAL` is one entry, and doesn't push a distinct font out of the ten.
let loaded = json!({"recentFonts": ["A", "B", "C", "D", "E", "F", "G", "H", "I", "Arial"]});
let ours = json!({"recentFonts": ["arial", "A", "B", "C", "D", "E", "F", "G", "H", "I"]});
let disk = json!({"recentFonts": ["ARIAL", "A", "B", "C", "D", "E", "F", "G", "H", "I"]});
assert_eq!(merge(&loaded, ours, &disk), json!({"recentFonts": ["arial", "A", "B", "C", "D", "E", "F", "G", "H", "I"]}));
// Other lists compare their entries as saved.
let loaded = json!({"recent": ["a.docx"]});
assert_eq!(merge(&loaded, json!({"recent": ["A.docx", "a.docx"]}), &loaded), json!({"recent": ["A.docx", "a.docx"]}));
}
#[test]
fn merged_recent_lists_keep_their_limit() {
// Recently Used Fonts keeps ten.
let loaded = json!({"recentFonts": ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]});
let ours = json!({"recentFonts": ["X", "A", "B", "C", "D", "E", "F", "G", "H", "I"]});
let disk = json!({"recentFonts": ["Y", "A", "B", "C", "D", "E", "F", "G", "H", "I"]});
assert_eq!(merge(&loaded, ours, &disk), json!({"recentFonts": ["X", "Y", "A", "B", "C", "D", "E", "F", "G", "H"]}));
}
#[test]
fn a_bad_recent_entry_in_the_file_is_not_carried_forward() {
// A non-string entry makes the whole list read as empty (`options::lenient` falls back per
// setting). Merging it in would keep Recent empty in every later session; instead the
// list reads as this version reads it, and the next save heals it.
let loaded = prefs(json!({"recent": []}));
let ours = prefs(json!({"recent": ["x.docx"]}));
let disk = as_read(br#"{"recent": [{"path": "y.docx"}, "z.docx"]}"#).unwrap();
let merged = merge(&loaded, ours, &disk);
assert_eq!(merged["recent"], json!(["x.docx"]));
assert_eq!(loaded_recent(&merged), ["x.docx"]);
// Same for recent symbols.
let ours = prefs(json!({"recentSymbols": [{"ch": "§", "font": "Arial"}]}));
let disk = as_read(r#"{"recentSymbols": [{"ch": "¶", "font": "Arial"}, 7]}"#.as_bytes()).unwrap();
assert_eq!(reloaded(&merge(&prefs(json!({})), ours, &disk)).recent_symbols.len(), 1);
}
/// The recent documents the next process loads.
fn loaded_recent(merged: &Value) -> Vec<String> {
reloaded(merged).recent
}
#[test]
fn only_keys_this_version_writes_are_kept() {
// A legacy key read once to migrate, and junk, are not written back, even from the file.
let loaded = prefs(json!({"theme": "light"}));
let disk = as_read(br#"{"theme": "light", "dark": true, "interfaceSize": 120, "junk": 1}"#).unwrap();
let merged = merge(&loaded, loaded.clone(), &disk);
for gone in ["dark", "interfaceSize", "junk"] {
assert!(merged.get(gone).is_none(), "{gone}");
}
assert_eq!(merged["theme"], "light");
}
#[test]
fn a_file_another_process_damaged_gives_way_to_ours() {
let loaded = json!({"theme": "light", "recent": ["a.docx"]});
let ours = json!({"theme": "dark", "recent": ["a.docx"]});
// Not preferences at all: everything comes from this process.
assert_eq!(as_read(b"\"garbage\""), None);
assert_eq!(merge(&loaded, ours.clone(), &json!("garbage")), ours);
// A list replaced by something else keeps ours.
assert_eq!(merge(&loaded, json!({"recent": ["b.docx", "a.docx"]}), &json!({"recent": 3})), json!({"recent": ["b.docx", "a.docx"]}));
}
#[test]
fn autocorrect_entries_and_exceptions_from_both_processes_are_kept() {
let loaded = prefs(json!({"editing": {"autocorrect": {"entries": [["teh", "the"]], "exceptions": ["approx."]}}}));
// B adds an entry and an exception; A adds another entry, changes `teh`'s replacement and
// removes `approx.`. Each added entry follows the entry it was added after.
let b = prefs(json!({"editing": {"autocorrect": {"entries": [["teh", "the"], ["teh2", "the"]], "exceptions": ["approx.", "fig."]}}}));
let a = prefs(json!({"editing": {"autocorrect": {"entries": [["teh", "THE"], ["adn", "and"]], "exceptions": []}}}));
let ac = reloaded(&b_then_a(&loaded, b, a)).editing.autocorrect;
let entries: Vec<(&str, &str)> = ac.entries.iter().map(|(f, t)| (f.as_str(), t.as_str())).collect();
assert_eq!(entries, [("teh", "THE"), ("adn", "and"), ("teh2", "the")]);
assert_eq!(ac.exceptions, ["fig."]);
}
#[test]
fn keyboard_customisations_merge_key_by_key() {
let loaded = prefs(json!({"keyboard": {"assigned": {"Mod+Shift+K": "format.bold"}, "removed": []}}));
// B takes Ctrl+B off Bold and deletes its own Mod+Shift+K; A takes Ctrl+I off Italic and
// assigns Mod+Shift+J.
let b = prefs(json!({"keyboard": {"assigned": {}, "removed": ["Mod+B"]}}));
let a = prefs(json!({"keyboard": {"assigned": {"Mod+Shift+K": "format.bold", "Mod+Shift+J": "format.italic"}, "removed": ["Mod+I"]}}));
let keys = reloaded(&b_then_a(&loaded, b, a)).keyboard;
assert_eq!(keys.assigned.into_iter().collect::<Vec<_>>(), [("Mod+Shift+J".to_string(), "format.italic".to_string())]);
assert_eq!(keys.removed.into_iter().collect::<Vec<_>>(), ["Mod+B", "Mod+I"]);
}
#[test]
fn ribbon_changes_from_both_processes_are_kept() {
// Both start from the default ribbon. B hides Draw; A adds a custom tab after Home.
let loaded = prefs(json!({}));
let b = prefs(json!({"ribbon": {"tabs": hide(default_tabs(), "Draw")}}));
let mut a_tabs = default_tabs();
a_tabs.insert(1, json!({"name": "Mine", "custom": true}));
let a = prefs(json!({"ribbon": {"tabs": a_tabs}}));
let mut want = hide(default_tabs(), "Draw");
want.insert(1, json!({"name": "Mine", "custom": true}));
assert_eq!(serde_json::to_value(loaded_ribbon(&b_then_a(&loaded, b, a)).tabs).unwrap(), Value::Array(want));
}
#[test]
fn a_toolbar_reset_by_one_process_stays_reset() {
// B resets its custom Quick Access Toolbar to the default; A, which left it alone, adds a
// custom tab. The toolbar stays the default.
let loaded = prefs(json!({"ribbon": {"qat": ["file.save", "format.bold"]}}));
let b = prefs(json!({}));
let mut a_tabs = default_tabs();
a_tabs.push(json!({"name": "Mine", "custom": true}));
let a = prefs(json!({"ribbon": {"tabs": a_tabs, "qat": ["file.save", "format.bold"]}}));
let merged = b_then_a(&loaded, b, a);
assert!(merged["ribbon"].get("qat").is_none(), "{}", merged["ribbon"]);
let ribbon = loaded_ribbon(&merged);
assert_eq!(ribbon.qat, None);
assert!(ribbon.tabs.iter().any(|t| t.name == "Mine"));
// Two processes customizing the default toolbar: both commands, Save removed by A gone.
let loaded = prefs(json!({}));
let b = prefs(json!({"ribbon": {"qat": ["file.save", "edit.undo", "edit.redo", "format.bold"]}}));
let a = prefs(json!({"ribbon": {"qat": ["edit.undo", "edit.redo", "format.italic"]}}));
assert_eq!(loaded_ribbon(&b_then_a(&loaded, b, a)).qat.unwrap(), ["edit.undo", "edit.redo", "format.italic", "format.bold"]);
}
/// The default ribbon tabs, as saved once the ribbon is customized.
fn default_tabs() -> Vec<Value> {
serde_json::from_value(serde_json::to_value(wordcraft_engine::RibbonLayout::default().tabs()).unwrap()).unwrap()
}
/// `tabs` with the tab `name` hidden.
fn hide(mut tabs: Vec<Value>, name: &str) -> Vec<Value> {
for t in &mut tabs {
if t["name"] == name {
t["hidden"] = json!(true);
}
}
tabs
}
/// The ribbon the next process loads.
fn loaded_ribbon(merged: &Value) -> wordcraft_engine::RibbonLayout {
reloaded(merged).ribbon
}
#[test]
fn a_pane_order_changed_by_the_other_process_is_kept() {
// `paneOrder` is saved only when it isn't the default. B reorders; A leaves it alone and
// switches to dark.
let loaded = prefs(json!({}));
let order = json!(["styles", "navigation"]);
let b = prefs(json!({"paneOrder": order}));
let merged = b_then_a(&loaded, b, prefs(json!({"theme": "dark"})));
assert_eq!((&merged["paneOrder"], &merged["theme"]), (&order, &json!("dark")));
// B goes back to the default order; A, which loaded B's order and left it, doesn't bring
// it back.
let loaded = prefs(json!({"paneOrder": order}));
let merged = b_then_a(&loaded, prefs(json!({})), prefs(json!({"paneOrder": order, "theme": "dark"})));
assert!(merged.get("paneOrder").is_none(), "{merged}");
assert_eq!(merged["theme"], "dark");
}
#[test]
fn the_window_and_a_pane_place_are_one_setting_each() {
// A moved its window and B resized its own: the window is A's, not A's place with B's size.
let window = |x: f32, width: f32| json!({"window": {"position": [x, 10.0], "width": width, "height": 600.0, "maximized": false}});
let loaded = prefs(window(0.0, 800.0));
let merged = b_then_a(&loaded, prefs(window(0.0, 1000.0)), prefs(window(300.0, 800.0)));
assert_eq!(merged["window"], prefs(window(300.0, 800.0))["window"]);
}
#[test]
fn pens_labels_and_dictionary_words_from_both_processes_are_kept() {
let pen = |color: &str| json!({"kind": "pen", "color": color, "width": 1.0});
let loaded = prefs(json!({"inkPens": [pen("FF0000"), pen("FF0000")], "captionLabels": ["Plate"], "dictionary": ["foo", "bar"]}));
// B adds a third red pen, a label and a word; A adds a blue pen, removes `bar` and adds a
// label of its own. Identical pens stay apart, by their order.
let b = prefs(
json!({"inkPens": [pen("FF0000"), pen("FF0000"), pen("FF0000")], "captionLabels": ["Plate", "Chart"], "dictionary": ["foo", "bar", "baz"]}),
);
let a = prefs(json!({"inkPens": [pen("FF0000"), pen("FF0000"), pen("0000FF")], "captionLabels": ["Plate", "Map"], "dictionary": ["foo"]}));
let merged = b_then_a(&loaded, b, a);
let ui = reloaded(&merged);
let colors: Vec<String> = ui.ink_pens.iter().map(|p| serde_json::to_value(p).unwrap()["color"].as_str().unwrap().to_string()).collect();
assert_eq!(colors, ["FF0000", "FF0000", "0000FF", "FF0000"]);
assert_eq!(ui.caption_labels, ["Plate", "Map", "Chart"]);
assert_eq!(merged["dictionary"], json!(["foo", "baz"]));
}
}
+16 -1
View File
@@ -727,9 +727,16 @@ impl Document {
}
/// Split the paragraph at `pos`; returns the start of the new (second) paragraph.
///
/// A split after the first letters leaves the drop cap on the first paragraph only: the new
/// one is plain (Word: Enter makes a normal paragraph). A split at offset 0 is unchanged.
/// A drop cap that comes from a paragraph style, not the paragraph, is not cleared.
pub fn split_paragraph(&mut self, pos: &Pos) -> Result<Pos> {
let i = pos.path.last();
let tail = self.para_mut(pos.story, &pos.path)?.split_off(pos.off)?;
let mut tail = self.para_mut(pos.story, &pos.path)?.split_off(pos.off)?;
if pos.off > 0 {
clear_drop_cap(&mut tail.props);
}
let bl = self.container_mut(pos.story, &pos.path)?;
bl.insert((i + 1).min(bl.len()), para_block(tail));
Ok(Pos { story: pos.story, path: pos.path.with_last(i + 1), off: 0 })
@@ -1599,5 +1606,13 @@ impl Document {
}
}
/// Take the drop cap (and its options) off a paragraph's properties.
fn clear_drop_cap(props: &mut crate::props::ParaProps) {
props.drop_cap = None;
props.drop_cap_margin = None;
props.drop_cap_distance = None;
props.drop_cap_font = None;
}
#[cfg(test)]
mod tests;
+35
View File
@@ -988,3 +988,38 @@ fn insert_fragment_remaps_conflicting_media_keys() {
let remapped = para.objects.iter().find_map(|o| if let InlineObject::Image { media, .. } = o { Some(media.as_str()) } else { None }).unwrap();
assert_eq!(remapped, other_key);
}
/// #6788: splitting a paragraph after its first letters leaves the drop cap on the first
/// paragraph only; the new one (also when it is empty) is plain. A split at offset 0 is unchanged.
#[test]
fn split_paragraph_keeps_the_drop_cap_on_the_first_paragraph_only() {
let drop_cap = |d: &Document, i: usize| {
let p = d.body.get(i).and_then(|b| b.as_para()).map(|p| p.props.clone()).unwrap_or_default();
(p.drop_cap, p.drop_cap_margin, p.drop_cap_distance, p.drop_cap_font)
};
let capped = |text: &str| {
let mut d = doc(&[text]);
if let Ok(p) = d.para_mut(StoryRef::Body, &Path::top(0)) {
p.props.drop_cap = Some(3);
p.props.drop_cap_margin = Some(true);
p.props.drop_cap_distance = Some(4.0);
p.props.drop_cap_font = Some("Serif".into());
}
d
};
let cap = (Some(3), Some(true), Some(4.0), Some("Serif".to_string()));
let plain = (None, None, None, None);
let mut d = capped("Sugar and knowledge");
d.split_paragraph(&Pos::body(0, 10)).unwrap();
assert_eq!((drop_cap(&d, 0), drop_cap(&d, 1)), (cap.clone(), plain.clone()));
let mut d = capped("Sugar");
d.split_paragraph(&Pos::body(0, 5)).unwrap();
assert_eq!((drop_cap(&d, 0), drop_cap(&d, 1)), (cap.clone(), plain.clone()));
// At offset 0 nothing changes: both paragraphs keep the properties, as before.
let mut d = capped("Sugar");
d.split_paragraph(&Pos::body(0, 0)).unwrap();
assert_eq!((drop_cap(&d, 0), drop_cap(&d, 1)), (cap.clone(), cap));
}
+7
View File
@@ -137,6 +137,12 @@ pub struct Settings {
/// Keep contextual paragraph spacing inside legacy table cells (`allowSpaceOfSameStyleInTable`).
/// Word ignores the layout override in compatibility mode 15, but the flag still round-trips.
pub allow_space_of_same_style_in_table: bool,
/// `w:doNotSuppressIndentation` (a `.doc`'s `Copts.fWW11IndentRules`): Word 2003's indent
/// rules beside floating objects. An unnumbered paragraph's line starts right after a floating
/// object before it on the line, its own indent ignored (ECMA-376 Part 4 §14.8.3.12). Word 2013's
/// layout (compatibility mode 15) does not use it.
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
pub do_not_suppress_indentation: bool,
/// Drawing grid spacing in points, across and down (View › Gridlines); ECMA-376's default is 1/8 inch.
pub grid_h: f32,
pub grid_v: f32,
@@ -319,6 +325,7 @@ impl Default for Settings {
sum_paragraph_spacing: false,
do_not_expand_shift_return: false,
allow_space_of_same_style_in_table: false,
do_not_suppress_indentation: false,
grid_h: DEFAULT_GRID,
grid_v: DEFAULT_GRID,
math: None,
+2 -2
View File
@@ -79,7 +79,7 @@ pub fn specs() -> Vec<CommandSpec> {
.when(has_canvas)
.pure(),
CommandSpec::new("canvas.member", "Canvas Member", "Shape Format › Drawing Canvas", member)
.params(r#"{"index": n, "x"?: pt, "y"?: pt, "width"?: pt, "height"?: pt, "delete"?: bool} (moves, resizes or removes member `index` of the selected canvas; x/y from the canvas's top-left; with no change, returns the members)"#)
.params(r#"{"index"?: n, "x"?: pt, "y"?: pt, "width"?: pt, "height"?: pt, "delete"?: bool} (moves, resizes or removes member `index` of the selected canvas; x/y from the canvas's top-left; without index, returns the members)"#)
.when(has_canvas),
]
}
@@ -211,7 +211,7 @@ fn scale(s: &mut Session, v: &Value) -> CmdResult {
result(&o)
}
/// `canvas.member`: move, resize or remove one member; with no change, list the members.
/// `canvas.member`: move, resize or remove one member; without index, list the members.
fn member(s: &mut Session, v: &Value) -> CmdResult {
let pos = canvas_pos(s)?;
let Some(i) = p::u64(v, "index").and_then(|i| usize::try_from(i).ok()) else {
+1
View File
@@ -68,6 +68,7 @@ pub fn specs() -> Vec<CommandSpec> {
sel_result(s)
})
.key("Escape")
.params(r#"{"end"?: bool (default false: collapse to the start; true: to the end)}"#)
.pure(),
]
}
+2 -1
View File
@@ -63,7 +63,8 @@ pub fn specs() -> Vec<CommandSpec> {
let t = THEMES.iter().find(|t| t.0.eq_ignore_ascii_case(name)).ok_or_else(|| CmdError::Params(format!("unknown colours `{name}`")))?;
set_accent(s, t.3[0]);
sel_result(s)
}),
})
.params(r#"{"name": string (see design.themes)}"#),
CommandSpec::new("design.styleSet", "Style Set", "Design › Document Formatting", style_set)
.params(r#"{"name": "default|basic|lines|shaded|casual|centered|minimalist|title"}"#),
CommandSpec::new("design.paragraphSpacing", "Paragraph Spacing", "Design › Document Formatting", para_spacing)
+15 -4
View File
@@ -141,7 +141,9 @@ pub fn specs() -> Vec<CommandSpec> {
.key(super::mac_or("Mod+Shift+G / Mod+PageUp", "Mod+PageUp"))
.params(r#"{"text"?: string, "matchCase"?: bool, "wholeWord"?: bool, "regex"?: bool}"#)
.pure(),
CommandSpec::new("edit.replace", "Replace", "Home › Editing", replace).params(r#"{"text": string, "with": string, …options of edit.replaceAll}"#),
CommandSpec::new("edit.replace", "Replace", "Home › Editing", replace).params(
r#"{"text": string, "with": string, …options of edit.replaceAll} — Word's Replace button: replaces the match only when it is already selected, then selects the next one. The first call on a caret replaces nothing; call again to replace the selected match, or use edit.replaceAll for every match. Returns {"replaced": 0 | 1, "remaining": n, "selected": {start, end} | null}"#,
),
// Ctrl+H, Home › Replace: the Find and Replace dialog on its Replace tab (#712). Opening
// it changes nothing, so it is its own command and never marks the document edited.
CommandSpec::new("edit.findReplace", "Find and Replace", "Home › Editing", |s, v| {
@@ -746,12 +748,21 @@ fn replace(s: &mut Session, v: &Value) -> CmdResult {
let story = s.sel.focus.story;
let results = search_full(s, story, true)?;
let (a, b) = s.sel.ordered();
// Replace the current match if selected, then move to the next.
// Replace the current match if selected, then move to the next. The result says which
// happened (#6877): a first call that only selects a match reads as `replaced: 0`.
let mut replaced = 0;
if let Some(f) = results.into_iter().find(|f| f.a == a && f.b == b) {
super::paste_text(s, &f.rep.unwrap_or_default())?;
replaced = 1;
}
let _ = step(s, 1);
Ok(json!({"remaining": search(s, story)?.len()}))
let selected = match step(s, 1) {
Ok(_) => {
let (start, end) = s.sel.ordered();
json!({"start": pos_json(&start), "end": pos_json(&end)})
}
Err(_) => Value::Null,
};
Ok(json!({"replaced": replaced, "remaining": search(s, story)?.len(), "selected": selected}))
}
/// Every match replaced, last first so earlier positions stay valid (one undo step). A `\r` in
+5 -2
View File
@@ -154,7 +154,7 @@ pub fn show_results(s: &mut Session) -> Result<(), CmdError> {
fn set_code(s: &mut Session, v: &Value) -> CmdResult {
let code = p::req_str(v, "code")?.trim().to_string();
if code.is_empty() || code.len() > MAX_CODE || code.contains(OBJ) {
return Err(CmdError::Params("bad field code".into()));
return Err(CmdError::Params("`code` must be non-empty, at most 4096 UTF-8 bytes, and contain no U+FFFC object markers".into()));
}
let Some(f) = selected(s).into_iter().next() else { return Err(none_selected()) };
with_field(s, &f.at, |o| match o {
@@ -441,7 +441,10 @@ mod tests {
s.run("fields.setCode", &json!({"code": "TITLE"})).unwrap();
let objs = |s: &Session| s.doc.body.first().and_then(|b| b.as_para()).map(|p| p.objects.clone()).unwrap_or_default();
assert!(matches!(objs(&s).first(), Some(InlineObject::Field { instr, result, .. }) if instr == "TITLE" && result == "Report"));
assert!(s.run("fields.setCode", &json!({"code": ""})).is_err());
assert!(matches!(
s.run("fields.setCode", &json!({"code": ""})),
Err(crate::CmdError::Params(message)) if message == "`code` must be non-empty, at most 4096 UTF-8 bytes, and contain no U+FFFC object markers"
));
// A locked field keeps its result.
s.run("fields.lock", &json!({})).unwrap();
+4 -4
View File
@@ -90,7 +90,7 @@ pub fn specs() -> Vec<CommandSpec> {
CommandSpec::new("file.new", "New", "File", new).key("Mod+N").params(r#"{"template"?: "blank|sample|letter|resume|report"}"#).pure(),
CommandSpec::new("file.open", "Open", "File", open)
.key("Mod+O / Mod+F12 / Mod+Alt+F2")
.params(r#"{"path": string, "data"?: base64 (the file's bytes; `path` then only names it), "password"?: string (for a password-protected Word document)}"#)
.params(r#"{"path": string, "data"?: base64 (the file's bytes; `path` then only names it), "password"?: string (for a password-protected Word or OpenDocument text file)}"#)
.pure(),
CommandSpec::new("file.save", "Save", "File", save)
.key("Mod+S / Shift+F12 / Alt+Shift+F2")
@@ -100,7 +100,7 @@ pub fn specs() -> Vec<CommandSpec> {
// Pure: the password must not land in Repeat or a recorded macro, and it isn't an edit
// to undo; it marks the document as changed itself.
CommandSpec::new("file.encrypt", "Encrypt with Password", "File › Info › Protect Document", encrypt)
.params(r#"{"password": string (Word documents are saved encrypted with it) | null or "" (saved unencrypted)}"#)
.params(r#"{"password": string (Word packages and OpenDocument text files (.odt, .ott) are saved encrypted with it) | null or "" (saved unencrypted)}"#)
.pure(),
CommandSpec::new("file.exportPdf", "Export PDF", "File › Export", |s, v| {
// No path (the command search, say): the app asks where to save, as File › Export
@@ -368,8 +368,8 @@ fn close_document(s: &mut Session, v: &Value) -> CmdResult {
Ok(json!({"closed": id, "active": s.document_id(), "documents": s.documents()}))
}
/// File › Info › Protect Document › Encrypt with Password: the password Word documents are saved
/// with from now on, or none.
/// File › Info › Protect Document › Encrypt with Password: the password Word packages and
/// OpenDocument text files (.odt, .ott) are saved with from now on, or none.
fn encrypt(s: &mut Session, v: &Value) -> CmdResult {
let password = match v.get("password") {
Some(Value::Null) => None,
+1 -1
View File
@@ -336,7 +336,7 @@ fn font(s: &mut Session, v: &Value) -> CmdResult {
let Some(n) = v.get(k) else { return Ok(None) };
let n = n.as_str().map(str::trim).unwrap_or("");
if n.is_empty() || n.len() > 128 {
return Err(CmdError::Params(format!("bad font name `{k}`")));
return Err(CmdError::Params(format!("`{k}` must be a non-empty font name of at most 128 bytes")));
}
Ok(Some(n.to_string()))
};
+4 -2
View File
@@ -51,7 +51,7 @@ pub(super) fn link(s: &mut Session, v: &Value) -> CmdResult {
},
};
if url.is_empty() || url.len() > 4096 {
return Err(CmdError::Params("bad url".into()));
return Err(CmdError::Params("`url` must be non-empty and at most 4096 UTF-8 bytes".into()));
}
let style = Some("Hyperlink".to_string());
if s.sel.is_collapsed() {
@@ -188,7 +188,9 @@ pub(super) fn delete_bookmark(s: &mut Session, v: &Value) -> CmdResult {
pub(super) fn bookmark(s: &mut Session, v: &Value) -> CmdResult {
let name = p::req_str(v, "name")?.trim().to_string();
if !bookmark_name_ok(&name) {
return Err(CmdError::Params("bookmark names start with a letter, have no spaces and at most 40 characters".into()));
return Err(CmdError::Params(
"bookmark names start with a letter or underscore, contain only letters, numbers or underscores, and have at most 40 characters".into(),
));
}
// Replace an existing bookmark of the same name.
remove_bookmark(s, &name)?;
+3 -2
View File
@@ -110,7 +110,7 @@ pub fn specs() -> Vec<CommandSpec> {
apply_filter(s);
filter_result(s)
})
.params(r#"{"rules"?: [{"field": string, "op": "equal|notEqual|less|greater|lessOrEqual|greaterOrEqual|blank|notBlank|contains|notContains", "value"?: string, "join"?: "and|or" (with the rule before; And binds tighter)}], "sort"?: [{"field": string, "descending"?: bool}]} (replaces the filter; `sort` too when given; {} clears both). Preview, Finish & Merge and labels use only the matching records, in sort order"#)
.params(r#"{"rules"?: [{"field": string, "op": "equal|notEqual|less|greater|lessOrEqual|greaterOrEqual|blank|notBlank|contains|notContains", "value"?: string, "join"?: "and|or" (with the rule before; And binds tighter)}], "sort"?: [{"field": string, "descending"?: bool}]} (replaces the filter; `sort` too when given; `sort` also accepts a field name, one key object or null; array entries may also be field names; {} clears both). Preview, Finish & Merge and labels use only the matching records, in sort order"#)
.when(has_list)
.pure(),
CommandSpec::new("mailings.sortRecipients", "Sort Recipients", "Mailings › Start Mail Merge › Edit Recipient List", |s, v| {
@@ -118,7 +118,7 @@ pub fn specs() -> Vec<CommandSpec> {
apply_filter(s);
filter_result(s)
})
.params(r#"{"sort"?: [{"field": string, "descending"?: bool}]} | {"field": string, "descending"?: bool} (no params: the list's own order)"#)
.params(r#"{"sort"?: [{"field": string, "descending"?: bool}]} | {"field": string, "descending"?: bool} (`sort` also accepts a field name, one key object or null; array entries may also be field names; no params: the list's own order)"#)
.when(has_list)
.pure(),
CommandSpec::new("mailings.insertField", "Insert Merge Field", "Mailings › Write & Insert Fields", |s, v| {
@@ -192,6 +192,7 @@ pub fn specs() -> Vec<CommandSpec> {
refresh(s);
Ok(json!({"record": idx + 1}))
})
.params(r#"{"text": string}"#)
.when(has_recipients),
CommandSpec::new("mailings.checkErrors", "Check for Errors", "Mailings › Finish", |s, _| {
let mut missing = Vec::new();
+1 -1
View File
@@ -255,7 +255,7 @@ pub(super) fn parse_sort(headers: &[String], v: Option<&Value>) -> Result<Vec<So
None | Some(Value::Null) => return Ok(Vec::new()),
Some(Value::Array(a)) => a.clone(),
Some(o @ (Value::Object(_) | Value::String(_))) => vec![o.clone()],
Some(_) => return Err(CmdError::Params("`sort` must be an array of {field, descending}".into())),
Some(_) => return Err(CmdError::Params("`sort` must be a field name, a {field, descending} object, an array of those, or null".into())),
};
if arr.len() > MAX_SORT_KEYS {
return Err(CmdError::Params(format!("at most {MAX_SORT_KEYS} sort keys")));
+3 -2
View File
@@ -107,7 +107,8 @@ fn condition(s: &Session, t: &str, row: usize) -> (bool, Vec<String>) {
let op: String = rest.trim_start().chars().take_while(|c| matches!(c, '<'..='>')).collect();
let mut texts = field_words(rest).into_iter().filter(|(_, q)| *q).map(|(w, _)| w);
let cmp = texts.next().unwrap_or_default();
let v = value(s, row, &field);
let tested = t.split_once('{').and_then(|(_, r)| r.split('}').next()).unwrap_or("");
let v = wordcraft_layout::fields::apply_case_switch(tested, value(s, row, &field));
// Numbers compare as numbers (Word: "7" = "7.0"), everything else as text.
let ord = match (v.trim().parse::<f64>(), cmp.trim().parse::<f64>()) {
(Ok(a), Ok(b)) => a.partial_cmp(&b),
@@ -134,7 +135,7 @@ fn keyword(instr: &str) -> String {
fn act(s: &Session, instr: &str, row: usize) -> Option<Act> {
let t = instr.trim();
if let Some(n) = mergefield_name(t) {
return Some(Act::Text(value(s, row, &n)));
return Some(Act::Text(wordcraft_layout::fields::apply_case_switch(t, value(s, row, &n))));
}
Some(match keyword(t).as_str() {
"ADDRESSBLOCK" => Act::Text(address_block(s, row)),
+27
View File
@@ -147,6 +147,33 @@ fn merge_field_types_ignore_case() {
assert_eq!(s.doc.plain_text(StoryRef::Body), "Alpha\nBeta (b)");
}
/// A merge field's capitalization switch (`\* Upper`, `\* Lower`, `\* Caps`, `\* FirstCap`)
/// applies to the record's value in Preview Results and Finish & Merge.
#[test]
fn merge_fields_apply_their_capitalization_switch() {
let mut s = Session::new(Document::new());
s.run("mailings.recipients", &json!({"rows": [{"City": "new york", "Name": "ADA lovelace"}]})).unwrap();
s.run("insert.field", &json!({"instr": r"MERGEFIELD City \* Upper \* MERGEFORMAT", "result": ""})).unwrap();
s.run("text.insert", &json!({"text": " "})).unwrap();
s.run("insert.field", &json!({"instr": r#"MERGEFIELD "Name" \* Lower"#, "result": ""})).unwrap();
s.run("mailings.preview", &json!({"value": true})).unwrap();
assert_eq!(s.doc.plain_text(StoryRef::Body), "NEW YORK ada lovelace");
s.run("mailings.finish", &json!({})).unwrap();
assert_eq!(s.doc.plain_text(StoryRef::Body), "NEW YORK ada lovelace");
}
/// An IF, NEXTIF or SKIPIF compares the tested merge field after its capitalization switch.
#[test]
fn rule_conditions_apply_the_tested_fields_capitalization_switch() {
let mut s = Session::new(Document::new());
s.run("mailings.recipients", &json!({"rows": [{"City": "new york"}, {"City": "paris"}]})).unwrap();
s.run("insert.field", &json!({"instr": r#"IF { MERGEFIELD City \* Upper } = "NEW YORK" "match" "other""#, "result": ""})).unwrap();
s.run("mailings.preview", &json!({"value": true})).unwrap();
assert_eq!(s.doc.plain_text(StoryRef::Body), "match");
s.run("mailings.next", &json!({})).unwrap();
assert_eq!(s.doc.plain_text(StoryRef::Body), "other");
}
/// An IF is a merge rule only when the field it tests is a MERGEFIELD: the word in a quoted
/// value doesn't make `IF { PAGE } = "mergefield" …` one.
#[test]
+1 -1
View File
@@ -22,7 +22,7 @@ pub fn specs() -> Vec<CommandSpec> {
vec![
CommandSpec::new("file.options", "Options", "File", options)
.params(
r#"{"pane"?: "general|display|proofing|save|language|accessibility|advanced|agents", "author"?: string, "initials"?: string, "units"?: "inches|centimeters|millimeters|points|picas|auto" (auto: the region's), "region"?: string (a locale tag like pl-PL, saved: the paper File › New starts on, the default units and the decimal separator; auto: the system's), "typingReplacesSelection"?: bool, "insertKeyOvertype"?: bool, "overtype"?: bool, "marks"?: {"tabs"?: bool, "spaces"?: bool, "paragraphs"?: bool, "hidden"?: bool}, "checkSpelling"?: bool, "markGrammar"?: bool, "ignoreUppercase"?: bool, "ignoreNumbers"?: bool, "ignoreInternet"?: bool, "dictionariesFolder"?: string (a folder of Hunspell .aff/.dic files searched first, saved; auto: the system locations only), "userTemplatesFolder"?: string (the folder File › New lists personal templates from, saved; auto: the app's own Templates folder; not a network folder), "addWords"?: [string], "removeWords"?: [string]} — with any setting it changes them and opens nothing; without, it opens File › Options (at `pane`). Returns the settings."#,
r#"{"pane"?: "general|display|proofing|save|language|accessibility|advanced|agents", "author"?: string, "initials"?: string, "units"?: "inches|centimeters|millimeters|points|picas|auto" (auto: the region's), "region"?: string (a locale tag like pl-PL, saved: the paper File › New starts on, the default units and the decimal separator; auto: the system's), "typingReplacesSelection"?: bool, "insertKeyOvertype"?: bool, "overtype"?: bool, "marks"?: {"tabs"?: bool, "spaces"?: bool, "paragraphs"?: bool, "hidden"?: bool}, "checkSpelling"?: bool, "markGrammar"?: bool, "ignoreUppercase"?: bool, "ignoreNumbers"?: bool, "ignoreInternet"?: bool, "dictionariesFolder"?: string (a folder of Hunspell .aff/.dic files searched first, saved; auto: clear the configured folder), "userTemplatesFolder"?: string (the folder File › New lists personal templates from, saved; auto: the app's own Templates folder; not a network folder), "addWords"?: [string], "removeWords"?: [string]} — with any setting it changes them and opens nothing; without, it opens File › Options (at `pane`). Returns the settings."#,
)
.pure(),
CommandSpec::new("text.overtype", "Overtype", "File › Options › Advanced", |s, v| {
+2 -1
View File
@@ -274,7 +274,8 @@ pub fn specs() -> Vec<CommandSpec> {
st.quick = on;
}
sel_result(s)
}),
})
.params(r#"{"style": string (name or id), "value"?: bool (default true)}"#),
// Advanced paragraph tools (#5043, as in WPS Office): conversions and cleanup over the
// selection, or the whole document with `scope: "all"`. One undo step per command.
CommandSpec::new("para.convertBreaks", "Convert Line Breaks to Paragraphs", "Home › Paragraph › Paragraph Tools", convert_breaks)
+1 -1
View File
@@ -22,7 +22,7 @@ const MODES: [&str; 5] = ["none", "readOnly", "comments", "trackedChanges", "for
pub fn specs() -> Vec<CommandSpec> {
vec![
CommandSpec::new("review.restrict", "Restrict Editing", "Review › Protect", restrict).params(
r#"{"mode"?: "none|readOnly|comments|trackedChanges|forms" (start enforcing; "none" stops), "formatting"?: bool (limit formatting to unlocked styles), "lockedStyles"?: [style id or name] (the styles that can't be applied; every other style is unlocked), "password"?: string (set when enforcing; required to stop a password-protected document), "stop"?: bool, "exception"?: "add" (the selection stays editable for everyone) | "remove" (exceptions touching the selection) | "removeAll"} → state"#,
r#"{"mode"?: "none|readOnly|comments|trackedChanges|forms" (editing restriction; use "none" with "formatting": true for formatting-only protection), "formatting"?: bool (limit formatting to unlocked styles), "lockedStyles"?: [style id or name] (the styles that can't be applied; every other style is unlocked), "password"?: string (set when enforcing; required to stop a password-protected document), "stop"?: bool (true: stop protection), "exception"?: "add" (the selection stays editable for everyone) | "remove" (exceptions touching the selection) | "removeAll"} → state"#,
),
]
}
+1 -1
View File
@@ -32,7 +32,7 @@ use toc::{insert_toc, remove_toc, toc_range};
pub fn specs() -> Vec<CommandSpec> {
vec![
CommandSpec::new("references.toc", "Table of Contents", "References › Table of Contents", insert_toc).params(
r#"{"levels"?: 1-9, "title"?: string, "pageNumbers"?: bool, "rightAlign"?: bool, "tabLeader"?: "dot|hyphen|underscore|none", "hyperlinks"?: bool, "headingStyles"?: bool, "outlineLevels"?: bool, "tcFields"?: bool, "styleLevels"?: {style name: 1-9}} (replaces an existing table; {} updates it)"#,
r#"{"levels"?: 1-9, "title"?: string (at most 1024 characters), "pageNumbers"?: bool, "rightAlign"?: bool, "tabLeader"?: "dot|hyphen|underscore|none", "hyperlinks"?: bool, "headingStyles"?: bool, "outlineLevels"?: bool, "tcFields"?: bool, "styleLevels"?: {style name: 1-9}} (replaces an existing table; {} updates it)"#,
),
CommandSpec::new("references.updateToc", "Update Table", "References › Table of Contents", |s, _| {
update_toc(s)?;
+12
View File
@@ -1,6 +1,18 @@
use super::properties::{new_property_value, text_result};
use super::*;
#[test]
fn a_toc_title_is_capped() {
let mut s = Session::new(wordcraft_doc::Document::new());
let before = s.doc.body.len();
let long = "x".repeat(super::toc::MAX_TOC_TITLE + 1);
let r = s.run("references.toc", &json!({"title": long}));
assert!(matches!(r, Err(crate::CmdError::Params(_))), "{r:?}");
assert_eq!(s.doc.body.len(), before, "a rejected title changes nothing");
let at_cap = "x".repeat(super::toc::MAX_TOC_TITLE);
s.run("references.toc", &json!({"title": at_cap})).unwrap();
}
fn fields(s: &Session) -> Vec<(String, String)> {
let mut out = Vec::new();
for path in s.doc.para_paths(StoryRef::Body) {
+15 -2
View File
@@ -3,6 +3,18 @@ use super::{
StoryRef, TabAlign, TabLeader, TabStop, Value, delete_selection, p, sel_result,
};
/// A table-of-contents title is a heading, not document body: longer titles are rejected
/// instead of laying out megabytes of text (#3720).
pub(super) const MAX_TOC_TITLE: usize = 1024;
fn checked_title(v: &Value) -> Result<Option<&str>, CmdError> {
let Some(title) = p::str(v, "title") else { return Ok(None) };
if title.chars().count() > MAX_TOC_TITLE {
return Err(CmdError::Params(format!("`title` is longer than {MAX_TOC_TITLE} characters")));
}
Ok(Some(title))
}
/// A level range such as `1-3` (or one level, `2`), clamped to 1–9.
pub fn level_range(s: &str) -> Option<(u8, u8)> {
let mut it = s.split('-').map(|x| x.trim().parse::<u8>().ok());
@@ -382,6 +394,7 @@ pub(super) fn cached_toc_tabs(s: &Session) -> Vec<(String, Vec<TabStop>)> {
}
pub(super) fn insert_toc(s: &mut Session, v: &Value) -> CmdResult {
let title = checked_title(v)?.unwrap_or("Contents").to_string();
let tabs = cached_toc_tabs(s);
range_toc_to_field(s)?;
let replace = v.as_object().is_some_and(|m| !m.is_empty());
@@ -410,7 +423,6 @@ pub(super) fn insert_toc(s: &mut Session, v: &Value) -> CmdResult {
}
None => delete_selection(s)?,
};
let title = p::str(v, "title").unwrap_or("Contents").to_string();
if at.story != StoryRef::Body || at.path.depth() > 0 {
return Err(CmdError::Failed("a table of contents goes in the main text".into()));
}
@@ -440,6 +452,7 @@ pub(super) fn insert_toc(s: &mut Session, v: &Value) -> CmdResult {
/// (`title_above_break`): the field takes `v`'s settings, the title `v`'s `title` if one is given
/// (otherwise it is kept, as Word's Insert Table of Contents keeps it), and the entries are rebuilt.
fn replace_toc_above_break(s: &mut Session, v: &Value, start: usize, tabs: &[(String, Vec<TabStop>)]) -> Result<(), CmdError> {
let new_title = checked_title(v)?;
let instr = toc_instr(v);
let field = s.doc.para_mut(StoryRef::Body, &Path::top(start))?;
for o in &mut field.objects {
@@ -453,7 +466,7 @@ fn replace_toc_above_break(s: &mut Session, v: &Value, start: usize, tabs: &[(St
}
}
field.touch();
if let (Some(title), Some(i)) = (p::str(v, "title"), start.checked_sub(1)) {
if let (Some(title), Some(i)) = (new_title, start.checked_sub(1)) {
let old = s.doc.para_mut(StoryRef::Body, &Path::top(i))?;
let mut head = Paragraph::with_text(title, old.props_of_char(0).clone());
head.props = old.props.clone();
+4 -4
View File
@@ -28,12 +28,12 @@ pub fn specs() -> Vec<CommandSpec> {
vec![
CommandSpec::new("review.newComment", "New Comment", "Review › Comments", new_comment).key(super::mac_or("Mod+Alt+A / Mod+Alt+M", "Mod+Alt+M")).params(r#"{"text": string}"#),
CommandSpec::new("review.reply", "Reply", "Review › Comments", reply)
.params(r#"{"id": non-negative JSON integer, "text": string}"#)
.params(r#"{"id": non-negative 32-bit JSON integer, "text": string}"#)
.when(comments_change),
CommandSpec::new("review.editComment", "Edit Comment", "Review › Comments", edit_comment)
.params(r#"{"id": non-negative JSON integer, "text": string}"#)
.params(r#"{"id": non-negative 32-bit JSON integer, "text": string}"#)
.when(comments_change),
CommandSpec::new("review.deleteComment", "Delete", "Review › Comments", delete_comment).params(r#"{"id"?: non-negative JSON integer (omit to use the caret), "all"?: bool}"#),
CommandSpec::new("review.deleteComment", "Delete", "Review › Comments", delete_comment).params(r#"{"id"?: non-negative 32-bit JSON integer (omit to use the caret), "all"?: bool}"#),
CommandSpec::new("review.resolveComment", "Resolve", "Review › Comments", |s, v| {
validate_comment_id(v)?;
let id = p::u64(v, "id").map(|x| x as u32).or_else(|| comment_at_caret(s)).ok_or_else(|| CmdError::Params("`id` required".into()))?;
@@ -41,7 +41,7 @@ pub fn specs() -> Vec<CommandSpec> {
c.resolved = p::bool(v, "value").unwrap_or(!c.resolved);
sel_result(s)
})
.params(r#"{"id"?: non-negative JSON integer (omit to use the caret), "value"?: bool (omit to toggle)}"#),
.params(r#"{"id"?: non-negative 32-bit JSON integer (omit to use the caret), "value"?: bool (omit to toggle)}"#),
CommandSpec::new("review.nextComment", "Next", "Review › Comments", |s, _| nav_comment(s, 1)).pure(),
CommandSpec::new("review.previousComment", "Previous", "Review › Comments", |s, _| nav_comment(s, -1)).pure(),
CommandSpec::new("review.comments", "Show Comments", "Review › Comments", list_comments).pure(),
+135 -26
View File
@@ -34,6 +34,7 @@ struct DiffCtx<'a> {
opts: &'a CompareOptions,
budget: &'a mut u64,
char_fallbacks: &'a mut usize,
plain_revised: bool,
}
/// Changed paragraphs longer than this (in characters) are compared word by word even at
@@ -48,10 +49,12 @@ const MAX_CHAR_DIFF: usize = 2000;
/// [`MAX_CHAR_DIFF`] characters, it falls back to word-level diff for that paragraph, surfaces the
/// fallback count in `"characterFallback"`, and includes `"level"` in `"notHonoured"`.
pub(super) fn compare(s: &mut Session, v: &Value) -> CmdResult {
let revised = if let Some(t) = p::str(v, "text") {
Document::from_text(t)
// A revised side given as plain text carries no real runs or properties; one opened from a
// path does. The diff takes the revised formatting only in the latter case.
let (revised, plain_revised) = if let Some(t) = p::str(v, "text") {
(Document::from_text(t), true)
} else if let Some(path) = p::str(v, "path") {
crate::io::open_path(std::path::Path::new(path)).map_err(CmdError::Failed)?
(crate::io::open_path(std::path::Path::new(path)).map_err(CmdError::Failed)?, false)
} else {
return Err(CmdError::Params("`path` or `text` of the revised document is required".into()));
};
@@ -97,7 +100,7 @@ pub(super) fn compare(s: &mut Session, v: &Value) -> CmdResult {
let mut budget = MAX_COMPARE_CELLS;
let mut char_fallbacks = 0usize;
let ops = lcs_ops(&old.iter().map(key).collect::<Vec<_>>(), &new.iter().map(key).collect::<Vec<_>>(), &mut budget);
let mut ctx = DiffCtx { ins, del, opts: &opts, budget: &mut budget, char_fallbacks: &mut char_fallbacks };
let mut ctx = DiffCtx { ins, del, opts: &opts, budget: &mut budget, char_fallbacks: &mut char_fallbacks, plain_revised };
let mut out: Vec<Arc<Block>> = Vec::new();
let (mut i, mut j) = (0usize, 0usize);
let mut changes = 0usize;
@@ -393,9 +396,11 @@ fn flatten_region(out: &mut Vec<Op>, region: &[(Op, usize, Kind)]) {
/// A token of a changed paragraph: a word (or character), or an inline object without text
/// of its own (a text box anchor, a picture, a bookmark…), which is compared and kept whole.
/// Each token also carries the byte range it came from in its source paragraph, so the output
/// segment can take the formatting of the run it came from instead of the paragraph's first run.
enum Tok<'a> {
Text(String),
Obj(&'a InlineObject),
Text(String, std::ops::Range<usize>),
Obj(&'a InlineObject, std::ops::Range<usize>),
}
/// What a comparison sees of a token: the text as the options say, an object with the text of
@@ -421,52 +426,131 @@ fn same_objects(doc: &Document, a: &Paragraph, b: &Paragraph) -> bool {
}
/// Words with the spaces after them ("The ", "cat "), or single characters, and the objects
/// between them. Objects with text (fields, equations…) count as their text.
/// between them. Objects with text (fields, equations…) count as their text. Each token records
/// the byte range it came from in `p`, so its output segment can take that source run's
/// formatting. An object's flattened text (or a broken marker's placeholder) maps to the marker's
/// own range, which is the nearest formatting the object has.
fn tokens(p: &Paragraph, characters: bool) -> Vec<Tok<'_>> {
fn push(v: &mut Vec<Tok<'_>>, cur: &mut String, c: char, characters: bool) {
fn push(v: &mut Vec<Tok<'_>>, cur: &mut String, start: usize, end: usize, c: char, characters: bool) {
cur.push(c);
if characters || c == ' ' {
v.push(Tok::Text(std::mem::take(cur)));
v.push(Tok::Text(std::mem::take(cur), start..end));
}
}
let mut v = Vec::new();
let mut cur = String::new();
let mut cur_start = 0usize;
let mut objects = p.objects.iter();
for c in p.text.chars() {
for (i, c) in p.text.char_indices() {
let marker = i..i + OBJ.len_utf8();
if c != OBJ {
push(&mut v, &mut cur, c, characters);
if cur.is_empty() {
cur_start = i;
}
push(&mut v, &mut cur, cur_start, i + c.len_utf8(), c, characters);
continue;
}
match objects.next() {
Some(o) if o.plain_text().is_empty() => {
if !cur.is_empty() {
v.push(Tok::Text(std::mem::take(&mut cur)));
v.push(Tok::Text(std::mem::take(&mut cur), cur_start..i));
}
v.push(Tok::Obj(o, marker));
}
Some(o) => {
for c in o.plain_text().chars() {
if cur.is_empty() {
cur_start = i;
}
push(&mut v, &mut cur, cur_start, marker.end, c, characters);
}
v.push(Tok::Obj(o));
}
Some(o) => o.plain_text().chars().for_each(|c| push(&mut v, &mut cur, c, characters)),
None => {
// A marker without its object (a broken paragraph): kept as a visible
// placeholder, so the loss shows in the result instead of vanishing.
log::warn!("compare: an object marker without its object");
push(&mut v, &mut cur, char::REPLACEMENT_CHARACTER, characters);
if cur.is_empty() {
cur_start = i;
}
push(&mut v, &mut cur, cur_start, marker.end, char::REPLACEMENT_CHARACTER, characters);
}
}
}
if !cur.is_empty() {
v.push(Tok::Text(cur));
v.push(Tok::Text(cur, cur_start..p.text.len()));
}
v
}
/// One side's run formatting for `word_diff`: the paragraph's run ranges (from
/// [`Paragraph::run_ranges`]), walked with a forward cursor. `word_diff` consumes each side's
/// tokens in increasing offset order, so the cursor makes a token's lookup amortised O(1)
/// instead of rescanning the runs from the start for every token; an out-of-order offset falls
/// back to a binary search, so the lookup stays correct for any offset.
struct SideProps<'a> {
ranges: Vec<(std::ops::Range<usize>, &'a CharProps)>,
mark: &'a CharProps,
cursor: usize,
}
impl<'a> SideProps<'a> {
fn new(p: &'a Paragraph) -> Self {
SideProps { ranges: p.run_ranges().collect(), mark: &p.mark, cursor: 0 }
}
/// The props of the run holding byte `off`: that run's props, or the paragraph mark when
/// `off` is past the last run — the same answer `Paragraph::props_of_char` gives.
fn run_props(&mut self, off: usize) -> &'a CharProps {
while self.cursor < self.ranges.len() && self.ranges[self.cursor].0.end <= off {
self.cursor += 1;
}
if let Some((range, props)) = self.ranges.get(self.cursor)
&& range.contains(&off)
{
return props;
}
let idx = self.ranges.partition_point(|(r, _)| r.start <= off);
match idx.checked_sub(1).and_then(|i| self.ranges.get(i)) {
Some((range, props)) if range.contains(&off) => props,
_ => self.mark,
}
}
/// The formatting of the source run a token came from: the run holding the token's first
/// byte, with the revision metadata stripped. `ins`, `del` and `fmt_change` are indices into
/// the *source* document's own revision table, and the rebuilt paragraph lives in the result
/// document, whose table is a different one, so a source mark can never be carried across;
/// `word_diff` stamps the compare's own `ins`/`del` on the segments it marks. The consequence
/// is plain: a pre-existing pending revision inside a changed paragraph (say another author's
/// deletion) is superseded by the compare result rather than preserved. The hyperlink is
/// kept, because Reject restores it on a deleted run (at token granularity: the link is taken
/// from the token's first byte, so a token that starts unlinked can lose a mid-token link).
fn props_of(&mut self, t: &Tok<'_>) -> CharProps {
let off = match t {
Tok::Text(_, range) | Tok::Obj(_, range) => range.start,
};
let c = self.run_props(off);
CharProps { ins: None, del: None, fmt_change: None, ..c.clone() }
}
}
/// The props of an output token: those of the source run it came from, or — never expected, since
/// [`tokens`] and [`lcs_ops`] consume both sides in step — the given fallback. A miss is loud.
fn output_props(side: &mut SideProps<'_>, t: Option<&Tok<'_>>, fallback: &CharProps) -> CharProps {
if t.is_none() {
log::warn!("compare: a token range lookup missed; `tokens` and `lcs_ops` are out of step");
}
t.map(|t| side.props_of(t)).unwrap_or_else(|| fallback.clone())
}
/// Add a token at the end of `p` with `props`.
fn put(p: &mut Paragraph, t: Option<&Tok<'_>>, props: &CharProps) {
let at = p.len();
match t {
Some(Tok::Text(t)) => {
Some(Tok::Text(t, _)) => {
let _ = p.insert_text(at, t, props);
}
Some(Tok::Obj(o)) => {
Some(Tok::Obj(o, _)) => {
let _ = p.insert_object(at, (*o).clone(), props);
}
None => {}
@@ -500,10 +584,12 @@ fn word_diff(doc: &Document, a: &Paragraph, b: &Paragraph, ctx: &mut DiffCtx<'_>
} else {
false
};
let plain_revised = ctx.plain_revised;
let (ta, tb) = (tokens(a, chars), tokens(b, chars));
let (mut a_props, mut b_props) = (SideProps::new(a), SideProps::new(b));
let key = |t: &Tok<'_>| match t {
Tok::Text(t) => Key::Text(ctx.opts.key(t)),
Tok::Obj(o) => obj_key(doc, o),
Tok::Text(t, _) => Key::Text(ctx.opts.key(t)),
Tok::Obj(o, _) => obj_key(doc, o),
};
let ops = lcs_ops(&ta.iter().map(key).collect::<Vec<_>>(), &tb.iter().map(key).collect::<Vec<_>>(), ctx.budget);
// Only at character granularity: a matched whole word almost never happens by coincidence,
@@ -511,23 +597,46 @@ fn word_diff(doc: &Document, a: &Paragraph, b: &Paragraph, ctx: &mut DiffCtx<'_>
// a short interior match need folding back into its surrounding edit.
let ops = if chars { collapse_noise_matches(&ops) } else { ops };
let mut p = Paragraph::new();
p.props = b.props.clone();
let base = a.runs.first().map(|r| r.props.clone()).unwrap_or_default();
// The revised paragraph's properties are used with its revision bookkeeping stripped, like runs
// (`SideProps::props_of`) and the mark, because `fmt_change`/`num_change` are indices into the revised
// document's own revision table and are meaningless in the result document. A plain-text
// revised side, which carries no paragraph properties of its own, falls back to the original's,
// stripped the same way, so pre-existing revision state never leaks into the rebuilt paragraph.
p.props = if plain_revised && b.props.is_empty() { a.props.formatting() } else { b.props.formatting() };
// The paragraph mark (the formatting typing into the paragraph's end would get) is the revised
// paragraph's when it comes from a document, and the original's when the revised side is plain
// text and has no mark of its own. Its own revision bookkeeping (`ins`, `del`, `fmt_change`)
// is cleared because those indices belong to another document's revision table.
p.mark = if plain_revised {
CharProps { ins: None, del: None, fmt_change: None, ..a.mark.clone() }
} else {
CharProps { ins: None, del: None, fmt_change: None, ..b.mark.clone() }
};
let fallback = a.runs.first().map(|r| CharProps { ins: None, del: None, fmt_change: None, ..r.props.clone() }).unwrap_or_default();
let fallback_b = b.runs.first().map(|r| CharProps { ins: None, del: None, fmt_change: None, ..r.props.clone() }).unwrap_or_default();
let (mut i, mut j) = (0, 0);
for op in ops {
match op {
Op::Same => {
// Equal as compared (perhaps up to case or spacing): the revised text.
put(&mut p, tb.get(j), &base);
// Equal as compared (perhaps up to case or spacing): the revised text, but the
// formatting of the run it stands for. For a document revised side that is the
// revised run, as issue #3749 prescribes ("Copy unchanged tokens from the revised
// paragraph with their own properties"); a plain-text revised side has no runs to
// speak of, so the original run's formatting is kept instead.
let props =
if plain_revised { output_props(&mut a_props, ta.get(i), &fallback) } else { output_props(&mut b_props, tb.get(j), &fallback_b) };
put(&mut p, tb.get(j), &props);
i += 1;
j += 1;
}
Op::Del => {
put(&mut p, ta.get(i), &CharProps { del: Some(ctx.del), ..base.clone() });
let props = output_props(&mut a_props, ta.get(i), &fallback);
put(&mut p, ta.get(i), &CharProps { del: Some(ctx.del), ..props });
i += 1;
}
Op::Ins => {
put(&mut p, tb.get(j), &CharProps { ins: Some(ctx.ins), ..base.clone() });
let props = tb.get(j).map(|t| b_props.props_of(t)).unwrap_or_else(|| fallback.clone());
put(&mut p, tb.get(j), &CharProps { ins: Some(ctx.ins), ..props });
j += 1;
}
}
+2
View File
@@ -1,5 +1,7 @@
use super::*;
mod compare_stage0;
#[test]
fn compare_marks_changes() {
let mut s = Session::new(Document::from_text("The cat sat.\nKeep this.\nOld line."));
@@ -0,0 +1,349 @@
//! Regression tests for #3749 Stage 0: formatting-preserving compare.
//!
//! `word_diff` carries source byte ranges through tokenization, so every output segment takes its
//! `CharProps` from the run it came from instead of stamping the original paragraph's first run on
//! everything. The revised side decides which run each segment follows: when the revised side is a
//! real document, Same/Ins take the revised run and Del takes the original run; when it is plain
//! text (with no runs of its own), Same/Del take the original run and Ins takes the (default)
//! revised run. The paragraph mark and `ParaProps` follow the revised side for a document, and fall
//! back to the original's for plain text.
//!
//! The ins/del segmentation for text-only paragraphs is unchanged: the goldens below were captured
//! from the pre-fix binary (`review.compare` over a plain original and a plain revised text, word
//! and character level) and must keep matching.
use super::*;
/// A run signature: its text, and whether it is marked inserted / deleted.
fn run_sig(p: &Paragraph) -> Vec<(String, bool, bool)> {
p.run_ranges().map(|(r, c)| (p.text[r].to_string(), c.ins.is_some(), c.del.is_some())).collect()
}
/// The first run whose text contains `needle`.
fn run_with<'a>(p: &'a Paragraph, needle: &str) -> (&'a str, &'a CharProps) {
p.run_ranges()
.find(|(r, _)| p.text[r.clone()].contains(needle))
.map(|(r, c)| (&p.text[r], c))
.unwrap_or_else(|| panic!("no run contains {needle:?} in {:?}", p.text))
}
// --- mixed character formatting -----------------------------------------------------------------
#[test]
fn mixed_formatting_is_preserved_per_range() {
let mut s = Session::new(Document::from_text("alpha beta gamma"));
s.run("select.text", &json!({"text": "alpha"})).unwrap();
s.run("format.bold", &json!({})).unwrap();
s.run("select.text", &json!({"text": "gamma"})).unwrap();
s.run("format.italic", &json!({})).unwrap();
s.run("review.compare", &json!({"text": "alpha delta gamma"})).unwrap();
let p = s.doc.body[0].as_para().unwrap();
// The deleted text stays in the tracked paragraph; the visible result is what Accept shows.
assert_eq!(p.plain_text(), "alpha beta delta gamma");
assert_eq!(p.final_text(), "alpha delta gamma");
let (_, alpha) = run_with(p, "alpha");
assert_eq!(alpha.bold, Some(true), "unchanged `alpha` keeps the original's bold");
assert_ne!(alpha.italic, Some(true));
let (_, gamma) = run_with(p, "gamma");
assert_eq!(gamma.italic, Some(true), "unchanged `gamma` keeps the original's italic");
assert_ne!(gamma.bold, Some(true));
let (_, delta) = run_with(p, "delta");
assert!(delta.ins.is_some(), "inserted `delta` is marked inserted");
assert_ne!(delta.bold, Some(true), "inserted text does not inherit the original's bold");
assert_ne!(delta.italic, Some(true), "inserted text does not inherit the original's italic");
let (_, beta) = run_with(p, "beta");
assert!(beta.del.is_some(), "removed `beta` is marked deleted");
assert_ne!(beta.bold, Some(true));
}
// --- byte-range props lookup --------------------------------------------------------------------
#[test]
fn change_point_on_a_multibyte_char_takes_its_own_run() {
// The change point is the second character, `ä` (2 bytes). The byte-range lookup must land on
// `ä`'s own run; a character count used as a byte offset would land inside the preceding `é`
// and stamp its bold on the deleted `ä`.
let mut s = Session::new(Document::from_text("éä"));
s.run("select.text", &json!({"text": "é"})).unwrap();
s.run("format.bold", &json!({})).unwrap();
s.run("select.text", &json!({"text": "ä"})).unwrap();
s.run("format.italic", &json!({})).unwrap();
s.run("review.compare", &json!({"text": "éö", "level": "character"})).unwrap();
let p = s.doc.body[0].as_para().unwrap();
assert_eq!(p.plain_text(), "éäö", "deleted `ä` and inserted `ö`");
let (_, ae) = run_with(p, "ä");
assert!(ae.del.is_some(), "the changed multi-byte char is deleted");
assert_eq!(ae.italic, Some(true), "it takes its own run");
assert_ne!(ae.bold, Some(true), "and not the preceding multi-byte run's props");
}
#[test]
fn empty_run_at_a_token_start_does_not_shadow_its_props() {
let mut s = Session::new(Document::from_text("alpha beta gamma"));
s.run("select.text", &json!({"text": "beta"})).unwrap();
s.run("format.italic", &json!({})).unwrap();
{
let mut p = s.doc.body[0].as_para().unwrap().clone();
let at = p.text.find("beta").unwrap();
let mut idx = 0usize;
let mut start = 0usize;
for (i, r) in p.runs.iter().enumerate() {
if start == at {
idx = i;
break;
}
start += r.len;
}
// An empty run with different props exactly at "beta"'s start.
p.runs.insert(idx, wordcraft_doc::para::Run { len: 0, props: CharProps { bold: Some(true), ..CharProps::default() } });
s.doc.body[0] = std::sync::Arc::new(Block::Para(p));
}
s.run("review.compare", &json!({"text": "alpha delta gamma"})).unwrap();
let p = s.doc.body[0].as_para().unwrap();
let (_, beta) = run_with(p, "beta");
assert!(beta.del.is_some());
assert_eq!(beta.italic, Some(true), "the token takes the run after the empty one");
assert_ne!(beta.bold, Some(true), "an empty run at the token's start must not shadow the next run's props");
}
// --- hyperlinks ---------------------------------------------------------------------------------
#[test]
fn middle_run_hyperlink_survives_and_reject_restores_it() {
let mut s = Session::new(Document::from_text("click here now"));
s.run("select.text", &json!({"text": "here"})).unwrap();
s.run("insert.link", &json!({"url": "https://example.com"})).unwrap();
s.run("review.compare", &json!({"text": "click there now"})).unwrap();
let p = s.doc.body[0].as_para().unwrap();
let (_, here) = run_with(p, "here");
assert!(here.del.is_some(), "the removed word is deleted");
assert_eq!(here.link.as_deref(), Some("https://example.com"), "the deleted run keeps its hyperlink");
let (_, there) = run_with(p, "there");
assert!(there.ins.is_some());
assert_eq!(there.link, None, "inserted text takes the revised run's formatting (no link)");
s.run("review.rejectAll", &json!({})).unwrap();
assert_eq!(s.doc.plain_text(StoryRef::Body), "click here now");
let p = s.doc.body[0].as_para().unwrap();
let (_, here) = run_with(p, "here");
assert_eq!(here.link.as_deref(), Some("https://example.com"), "Reject restores the hyperlink at token level");
}
#[test]
fn first_run_hyperlink_does_not_leak_onto_inserted_text() {
let mut s = Session::new(Document::from_text("here click now"));
s.run("select.text", &json!({"text": "here"})).unwrap();
s.run("insert.link", &json!({"url": "https://example.com"})).unwrap();
s.run("review.compare", &json!({"text": "here there click now"})).unwrap();
let p = s.doc.body[0].as_para().unwrap();
let (_, here) = run_with(p, "here");
assert_eq!(here.link.as_deref(), Some("https://example.com"), "the unchanged first run keeps its link");
let (_, there) = run_with(p, "there");
assert!(there.ins.is_some());
assert_eq!(there.link, None, "the first run's link must not leak onto inserted text");
}
// --- reject restores formatting -----------------------------------------------------------------
#[test]
fn deleted_segment_keeps_formatting_so_reject_restores_it() {
let mut s = Session::new(Document::from_text("alpha beta gamma"));
s.run("select.text", &json!({"text": "alpha"})).unwrap();
s.run("format.bold", &json!({})).unwrap();
s.run("select.text", &json!({"text": "beta"})).unwrap();
s.run("format.italic", &json!({})).unwrap();
s.run("review.compare", &json!({"text": "alpha delta gamma"})).unwrap();
s.run("review.rejectAll", &json!({})).unwrap();
assert_eq!(s.doc.plain_text(StoryRef::Body), "alpha beta gamma");
let p = s.doc.body[0].as_para().unwrap();
let (_, alpha) = run_with(p, "alpha");
assert_eq!(alpha.bold, Some(true));
let (_, beta) = run_with(p, "beta");
assert_eq!(beta.italic, Some(true), "the deleted token kept its italic, so Reject restores it at token level");
}
// --- text-only segmentation identity (goldens from the pre-fix binary) --------------------------
#[test]
fn text_only_segmentation_matches_pre_fix_golden() {
// (original, revised, level, expected (text, ins, del) runs)
let cases: &[(&str, &str, &str, &[(&str, bool, bool)])] = &[
("The dog sat.", "The cat sat.", "word", &[("The ", false, false), ("dog ", false, true), ("cat ", true, false), ("sat.", false, false)]),
("a cat ran", "a dog ran", "word", &[("a ", false, false), ("cat ", false, true), ("dog ", true, false), ("ran", false, false)]),
("colour", "color", "word", &[("colour", false, true), ("color", true, false)]),
(
"zawarta w dniu 01.09.2026 pomiędzy:",
"zawarta w dniu 19.10.2026 pomiędzy:",
"word",
&[("zawarta w dniu ", false, false), ("01.09.2026 ", false, true), ("19.10.2026 ", true, false), ("pomiędzy:", false, false)],
),
("The dog sat.", "The cat sat.", "character", &[("The ", false, false), ("dog", false, true), ("cat", true, false), (" sat.", false, false)]),
("a cat ran", "a dog ran", "character", &[("a ", false, false), ("cat", false, true), ("dog", true, false), (" ran", false, false)]),
("colour", "color", "character", &[("colo", false, false), ("u", false, true), ("r", false, false)]),
(
"zawarta w dniu 01.09.2026 pomiędzy:",
"zawarta w dniu 19.10.2026 pomiędzy:",
"character",
&[("zawarta w dniu ", false, false), ("01.09", false, true), ("19.10", true, false), (".2026 pomiędzy:", false, false)],
),
];
for (orig, rev, level, want) in cases {
let mut s = Session::new(Document::from_text(orig));
s.run("review.compare", &json!({"text": rev, "level": level})).unwrap();
let p = s.doc.body[0].as_para().unwrap();
let want: Vec<(String, bool, bool)> = want.iter().map(|(t, i, d)| ((*t).to_string(), *i, *d)).collect();
assert_eq!(run_sig(p), want, "{orig:?} -> {rev:?} [{level}]");
}
}
// --- paragraph mark and paragraph properties ----------------------------------------------------
#[test]
fn paragraph_mark_is_preserved() {
let mut s = Session::new(Document::from_text("alpha beta gamma"));
{
let mut p = s.doc.body[0].as_para().unwrap().clone();
p.mark.bold = Some(true);
s.doc.body[0] = std::sync::Arc::new(Block::Para(p));
}
s.run("review.compare", &json!({"text": "alpha delta gamma"})).unwrap();
let p = s.doc.body[0].as_para().unwrap();
assert_eq!(p.mark.bold, Some(true), "the rebuilt paragraph keeps the original paragraph mark");
}
#[test]
fn paragraph_props_kept_when_revised_is_plain() {
let mut s = Session::new(Document::from_text("alpha beta gamma"));
s.run("para.style", &json!({"style": "Heading1"})).unwrap();
s.run("para.alignCenter", &json!({})).unwrap();
s.run("review.compare", &json!({"text": "alpha delta gamma"})).unwrap();
let p = s.doc.body[0].as_para().unwrap();
assert_eq!(p.props.style.as_deref(), Some("Heading1"), "the original style survives a plain revised side");
assert!(p.props.align.is_some(), "the original alignment survives a plain revised side");
}
// --- object pass-through (not flattened away by the rebuild) -------------------------------------
/// A session whose single paragraph is `alpha beta gamma` with a picture after "beta ", already
/// compared against `alpha delta gamma`: the picture's anchor sits in a deleted run.
fn compared_with_picture() -> Session {
let mut s = Session::new(Document::from_text("alpha beta gamma"));
s.run("caret.set", &json!({"pos": Pos::body(0, "alpha beta ".len())})).unwrap();
let png = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAC0lEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==";
s.run("insert.picture", &json!({"data": png})).unwrap();
assert_eq!(s.doc.body[0].as_para().unwrap().objects.len(), 1, "the picture was inserted");
s.run("review.compare", &json!({"text": "alpha delta gamma"})).unwrap();
s
}
#[test]
fn picture_anchor_survives_a_changed_paragraph() {
let s = compared_with_picture();
let p = s.doc.body[0].as_para().unwrap();
assert_eq!(p.objects.len(), 1, "the changed paragraph's picture anchor survives the rebuild");
let off = p.object_offsets().first().copied().expect("the picture anchor is in the text");
assert!(p.props_of_char(off).del.is_some(), "the picture anchor sits in a deleted run");
}
#[test]
fn accepting_removes_the_deleted_picture_and_rejecting_restores_it() {
let mut accepted = compared_with_picture();
accepted.run("review.acceptAll", &json!({})).unwrap();
assert_eq!(accepted.doc.body[0].as_para().unwrap().objects.len(), 0, "accepting the deletion removes the picture");
let mut rejected = compared_with_picture();
rejected.run("review.rejectAll", &json!({})).unwrap();
assert_eq!(rejected.doc.body[0].as_para().unwrap().objects.len(), 1, "rejecting the deletion restores the picture");
}
// --- document revised side: unchanged tokens follow the revised formatting (#3749) --------------
#[test]
fn unchanged_word_takes_the_revised_formatting_document_path() {
let rev = Session::new(Document::from_text("Read the manual now."));
let path = std::env::temp_dir().join(format!("wc-compare-s0-rev-bold-{}.docx", std::process::id()));
crate::io::save_path(&path, &rev.doc).unwrap();
let mut s = Session::new(Document::from_text("Read the manual today."));
s.run("select.text", &json!({"text": "manual"})).unwrap();
s.run("format.bold", &json!({})).unwrap();
s.run("review.compare", &json!({"path": path.to_string_lossy()})).unwrap();
let _ = std::fs::remove_file(&path);
let p = s.doc.body[0].as_para().unwrap();
let (_, manual) = run_with(p, "manual");
assert_ne!(manual.bold, Some(true), "the unchanged word takes the revised side's formatting, not the original's bold");
let (_, today) = run_with(p, "today.");
assert!(today.del.is_some(), "the removed word is deleted");
let (_, now) = run_with(p, "now.");
assert!(now.ins.is_some(), "the added word is inserted");
s.run("review.acceptAll", &json!({})).unwrap();
let p = s.doc.body[0].as_para().unwrap();
assert_eq!(p.plain_text(), "Read the manual now.");
let (_, manual) = run_with(p, "manual");
assert_ne!(manual.bold, Some(true), "accepting leaves the revised (unbolded) formatting");
}
#[test]
fn paragraph_style_change_is_not_masked_document_path() {
let rev = Session::new(Document::from_text("Introduction to X"));
let path = std::env::temp_dir().join(format!("wc-compare-s0-style-{}.docx", std::process::id()));
crate::io::save_path(&path, &rev.doc).unwrap();
let mut s = Session::new(Document::from_text("Introduction"));
s.run("para.style", &json!({"style": "Heading1"})).unwrap();
s.run("review.compare", &json!({"path": path.to_string_lossy(), "level": "character"})).unwrap();
let _ = std::fs::remove_file(&path);
let p = s.doc.body[0].as_para().unwrap();
assert_ne!(p.props.style.as_deref(), Some("Heading1"), "the revised paragraph's empty properties win, so the style change isn't masked");
assert!(p.run_ranges().any(|(_, c)| c.ins.is_some()), "the text was diffed, not wholesale replaced");
let (_, intro) = run_with(p, "Introduction");
assert!(intro.ins.is_none() && intro.del.is_none(), "the unchanged text survives unmarked");
let (_, added) = run_with(p, " to X");
assert!(added.ins.is_some(), "only the added text is insertion-marked");
}
#[test]
fn unchanged_word_gains_the_revised_formatting_document_path() {
let mut rev = Session::new(Document::from_text("Read the manual now."));
rev.run("select.text", &json!({"text": "manual"})).unwrap();
rev.run("format.bold", &json!({})).unwrap();
let path = std::env::temp_dir().join(format!("wc-compare-s0-rev-gains-bold-{}.docx", std::process::id()));
crate::io::save_path(&path, &rev.doc).unwrap();
let mut s = Session::new(Document::from_text("Read the manual today."));
s.run("review.compare", &json!({"path": path.to_string_lossy()})).unwrap();
let _ = std::fs::remove_file(&path);
let p = s.doc.body[0].as_para().unwrap();
let (_, manual) = run_with(p, "manual");
assert_eq!(manual.bold, Some(true), "the unchanged word takes the revised side's bold");
let (_, today) = run_with(p, "today.");
assert!(today.del.is_some(), "the removed word is deleted");
let (_, now) = run_with(p, "now.");
assert!(now.ins.is_some(), "the added word is inserted");
s.run("review.acceptAll", &json!({})).unwrap();
let p = s.doc.body[0].as_para().unwrap();
assert_eq!(p.plain_text(), "Read the manual now.");
let (_, manual) = run_with(p, "manual");
assert_eq!(manual.bold, Some(true), "accepting leaves the revised (bolded) formatting");
}
#[test]
fn removed_hyperlink_on_an_unchanged_word_follows_the_revised_side_document_path() {
let rev = Session::new(Document::from_text("Read the manual now."));
let path = std::env::temp_dir().join(format!("wc-compare-s0-link-{}.docx", std::process::id()));
crate::io::save_path(&path, &rev.doc).unwrap();
let mut s = Session::new(Document::from_text("Read the manual today."));
s.run("select.text", &json!({"text": "manual"})).unwrap();
s.run("insert.link", &json!({"url": "https://example.com"})).unwrap();
s.run("review.compare", &json!({"path": path.to_string_lossy()})).unwrap();
let _ = std::fs::remove_file(&path);
let p = s.doc.body[0].as_para().unwrap();
let (_, manual) = run_with(p, "manual");
assert_eq!(manual.link, None, "the unchanged word takes the revised side's run, which dropped the link");
}
+1 -1
View File
@@ -464,7 +464,7 @@ pub fn save_bytes_opts(name: &str, doc: &Document, opts: &ExportOptions) -> Resu
}
/// [`save_bytes`], encrypted with `password` when there is one and the format is a Word package
/// (other formats are copies and are written as they are).
/// or OpenDocument text file (.odt, .ott); other formats are copies and are written as they are.
pub fn save_bytes_with(name: &str, doc: &Document, password: Option<&str>, opts: &ExportOptions) -> Result<Vec<u8>, String> {
let bytes = save_bytes_opts(name, doc, opts)?;
match password {
+1 -1
View File
@@ -39,7 +39,7 @@ pub struct Prefs {
pub region: Option<String>,
/// A folder searched for Hunspell dictionaries before the system locations (File › Options ›
/// Language, #1063): an app started from Finder or the Dock doesn't see
/// `WORDCRAFT_DICTIONARIES`. `None` searches the system locations only.
/// `WORDCRAFT_DICTIONARIES`. `None` means no configured folder.
pub dictionaries_folder: Option<String>,
/// The user templates folder File › New lists personal templates from and Save as Word
/// Template starts in (File › Options › Advanced › File locations, #2852). `None`: the app's
+89
View File
@@ -5,6 +5,7 @@ mod czech_test_dict;
use serde_json::json;
use std::sync::Arc;
use std::time::{Duration, Instant};
use wordcraft_doc::props::BorderStyle;
use wordcraft_doc::{Pos, StoryRef};
@@ -1108,6 +1109,26 @@ fn replace_under_track_changes_skips_deleted_text() {
assert_eq!(text(&s), "one dog two dog");
}
#[test]
fn replace_reports_whether_it_replaced_and_what_it_selected() {
// Replace follows Word's button: the first call only selects a match. Agents read
// `remaining` alone as done (#6877), so the result says whether anything was replaced.
let mut s = s();
run(&mut s, "document.setText", json!({"text": "alpha XX beta XX gamma XX"}));
run(&mut s, "caret.docStart", json!({}));
let calls: Vec<_> = (0..5).map(|_| run(&mut s, "edit.replace", json!({"text": "XX", "with": "YY"}))).collect();
let replaced: Vec<_> = calls.iter().map(|r| r["replaced"].clone()).collect();
assert_eq!(replaced, [json!(0), json!(1), json!(1), json!(1), json!(0)]);
let remaining: Vec<_> = calls.iter().map(|r| r["remaining"].clone()).collect();
assert_eq!(remaining, [json!(3), json!(2), json!(1), json!(0), json!(0)]);
let selected: Vec<_> = calls.iter().map(|r| (r["selected"]["start"]["off"].clone(), r["selected"]["end"]["off"].clone())).collect();
assert_eq!(selected[0], (json!(6), json!(8)));
assert_eq!(selected[1], (json!(14), json!(16)));
assert_eq!(selected[2], (json!(23), json!(25)));
assert!(calls[3]["selected"].is_null() && calls[4]["selected"].is_null(), "no match is left to select");
assert_eq!(text(&s), "alpha YY beta YY gamma YY");
}
#[test]
fn find_reads_the_text_around_tracked_deletions() {
// `edits` are (start, end) byte ranges deleted with Track Changes on, last first.
@@ -5164,6 +5185,74 @@ fn hostile_file_params_never_panic() {
let _ = std::fs::remove_dir_all(&base);
}
/// Large parameters must return and lay out within a generous wall-clock budget, so a regression
/// that loops or allocates without a cap fails here with its command id (#3720).
#[test]
fn hostile_large_params_stay_bounded() {
const BUDGET: Duration = Duration::from_secs(5);
let reg = cmd::registry();
// 1 MiB makes an uncapped copy or a quadratic scan visible without making the test itself
// expensive; the counts are large enough that an uncapped loop takes seconds.
let big = "x".repeat(1 << 20);
let mut deep = json!([]);
for _ in 0..64 {
deep = json!([deep]);
}
let junk = [
json!({
"text": big, "name": big, "label": big, "find": big, "replace": big,
"title": big, "author": big, "path": big,
}),
json!({
"count": 1_000_000_000u64, "copies": 1_000_000_000u64, "times": 1_000_000_000u64,
"cols": 1_000_000_000u64, "rows": 1_000_000_000u64, "level": 1_000_000_000u64,
"page": 1_000_000_000u64, "from": 1_000_000_000u64, "to": 1_000_000_000u64,
"id": 1_000_000_000u64,
}),
json!({"width": 3e38, "height": 3e38, "top": -3e38, "left": 3e38}),
json!({"path": deep}),
];
for spec in reg.all() {
if spec.id.starts_with("file.") || spec.id == "insert.picture" || spec.id == "insert.textFromFile" {
continue;
}
for j in &junk {
let mut s = Session::new(crate::sample::sample_document());
assert_ne!(s.read_aloud.backend, crate::speech::Backend::System, "tests must never start real speech");
let start = Instant::now();
let r = s.run(spec.id, j);
let elapsed = start.elapsed();
assert!(!caught_panic(&reg, &r), "{} panicked on large params: {r:?}", spec.id);
assert_within_budget(spec.id, elapsed, BUDGET);
// Laying the result out is not part of the command's budget; the layout tests
// cover long text separately. It still runs so a bad parameter reaches the layout.
s.clamp_selection();
let _ = s.layout();
}
}
}
fn assert_within_budget(id: &str, elapsed: Duration, budget: Duration) {
assert!(elapsed <= budget, "{id} took {elapsed:?} (budget {budget:?})");
}
/// The budget above fires: a command that runs past it is named, not ignored (#3720).
#[test]
#[should_panic(expected = "test.slow took")]
fn hostile_large_param_budget_flags_a_slow_command() {
let budget = Duration::from_millis(1);
let mut s = Session::new(crate::sample::sample_document());
let slow = crate::CommandSpec::new("test.slow", "Slow", "", |_, _| {
std::thread::sleep(Duration::from_millis(20));
Ok(json!({}))
})
.pure();
s.registry = Arc::new(crate::Registry::new(vec![slow]));
let start = Instant::now();
let _ = s.run("test.slow", &json!({}));
assert_within_budget("test.slow", start.elapsed(), budget);
}
/// A panic that `Session::run`'s guard turned into an error, in a command or one it ran: still a
/// crash path (#3718). Only the guard's own `"{id} panicked: "` counts, not an error that echoes
/// those words.
+77 -51
View File
@@ -5,13 +5,40 @@ use wordcraft_doc::props::CharProps;
use crate::Session;
/// Creates a document with `lines` lines of text.
/// The bundled face the fixtures are set in. Their page counts are exact to a line, so they must
/// not depend on the face the host substitutes for the default Aptos: at 11 pt, Arial and
/// Liberation Sans fit 28 of these lines on a page and DejaVu Sans, the only candidate on a bare
/// FreeBSD system, fits 27. Inter is the bundled face whose metrics give each 0.5 pt step its own
/// page boundary at this page size.
const FIXTURE_FONT: &str = "Inter";
/// Creates a document with `lines` lines of text in [`FIXTURE_FONT`]. Inter fits 25 lines on a
/// page at 12 pt, 26 at 11.5 pt and 27 at 11 pt.
fn create_multiline_doc(lines: usize) -> Session {
let mut text = String::new();
for i in 1..=lines {
text.push_str(&format!("Line {i}: The quick brown fox jumps over the lazy dog.\n"));
}
Session::new(Document::from_text(&text))
let mut doc = Document::from_text(&text);
std::sync::Arc::make_mut(&mut doc.styles).default_chr.font = Some(FIXTURE_FONT.into());
Session::new(doc)
}
/// Asserts the body is laid out in the bundled [`FIXTURE_FONT`], not a substitute.
fn assert_fixture_font(s: &mut Session) {
let layout = s.layout();
let mut runs = 0;
for page in &layout.pages {
for item in &page.items {
if let wordcraft_layout::Placed::Lines { story: wordcraft_doc::StoryRef::Body, para, .. } = item {
for style in &para.styles {
runs += 1;
assert_eq!(style.face.family, FIXTURE_FONT, "the fixture must not fall back to another family");
}
}
}
}
assert!(runs > 0, "the font check must inspect laid-out body text");
}
#[test]
@@ -39,7 +66,7 @@ fn fit_one_page_fails_on_hard_page_break() {
#[test]
fn fit_one_page_refuses_page_break_before_before_search() {
let mut s = create_multiline_doc(27);
let mut s = create_multiline_doc(26);
assert_eq!(s.layout().pages.len(), 2);
if let wordcraft_doc::Block::Para(p) = std::sync::Arc::make_mut(&mut s.doc.body[1]) {
p.props.page_break_before = Some(true);
@@ -74,7 +101,7 @@ fn fit_one_page_fails_on_next_page_section_break() {
#[test]
fn fit_one_page_condenses_slight_overflow_and_undoes() {
// Find the boundary where the document just spills onto page 2
let mut lines = 30;
let mut lines = 20;
let mut s = create_multiline_doc(lines);
while s.layout().pages.len() < 2 && lines < 80 {
lines += 2;
@@ -102,7 +129,7 @@ fn fit_one_page_condenses_slight_overflow_and_undoes() {
#[test]
fn fit_one_page_respects_max_delta() {
let mut s = create_multiline_doc(27);
let mut s = create_multiline_doc(26);
assert_eq!(s.layout().pages.len(), 2, "must start as 2-page document");
let doc_backup = s.doc.clone();
@@ -117,11 +144,7 @@ fn fit_one_page_respects_max_delta() {
#[test]
fn fit_one_page_respects_step_pt() {
let mut text = String::new();
for i in 1..=28 {
text.push_str(&format!("Line {i}: The quick brown fox jumps over the lazy dog.\n"));
}
let mut s = Session::new(Document::from_text(&text));
let mut s = create_multiline_doc(27);
for b in &mut s.doc.body {
if let wordcraft_doc::Block::Para(p) = std::sync::Arc::make_mut(b) {
p.mark.size = Some(11.4);
@@ -131,6 +154,7 @@ fn fit_one_page_respects_step_pt() {
}
}
assert_eq!(s.layout().pages.len(), 2, "must start as 2-page document at 11.4 pt");
assert_fixture_font(&mut s);
// Both calls hold maxDeltaPt constant at 0.4 and disable spacing adjustments.
// Default 0.5 pt step generates no candidates <= 0.4 pt, so it must fail.
@@ -147,7 +171,7 @@ fn fit_one_page_respects_step_pt() {
#[test]
fn fit_one_page_allows_spacing_only_at_font_floor() {
let mut lines = 35;
let mut lines = 20;
let mut s = create_multiline_doc(lines);
let set_font = |s: &mut Session| {
for b in &mut s.doc.body {
@@ -178,7 +202,7 @@ fn fit_one_page_allows_spacing_only_at_font_floor() {
#[test]
fn fit_one_page_fails_when_body_font_already_at_minimum_readable_size() {
let mut lines = 35;
let mut lines = 20;
let mut s = create_multiline_doc(lines);
let set_font = |s: &mut Session| {
for b in &mut s.doc.body {
@@ -208,7 +232,7 @@ fn fit_one_page_fails_when_body_font_already_at_minimum_readable_size() {
#[test]
fn fit_one_page_bounds_fine_step_loop() {
let mut lines = 28;
let mut lines = 20;
let mut s = create_multiline_doc(lines);
while s.layout().pages.len() < 2 && lines < 80 {
lines += 1;
@@ -224,7 +248,7 @@ fn fit_one_page_bounds_fine_step_loop() {
#[test]
fn fit_one_page_supports_max_delta_above_2pt() {
let mut lines = 28;
let mut lines = 20;
let mut s = create_multiline_doc(lines);
while s.layout().pages.len() < 2 && lines < 80 {
lines += 1;
@@ -244,7 +268,7 @@ fn fit_one_page_supports_max_delta_above_2pt() {
#[test]
fn fit_one_page_anti_compound_guard_prevents_repeated_invocations() {
let mut lines = 28;
let mut lines = 20;
let mut s = create_multiline_doc(lines);
loop {
for b in &mut s.doc.body {
@@ -314,7 +338,7 @@ fn fit_one_page_already_fits_wins_over_exhausted_budget() {
#[test]
fn fit_one_page_checks_complex_script_font_floor() {
let mut lines = 28;
let mut lines = 20;
let mut s = create_multiline_doc(lines);
while s.layout().pages.len() < 2 && lines < 80 {
lines += 1;
@@ -340,7 +364,7 @@ fn fit_one_page_checks_complex_script_font_floor() {
#[test]
fn fit_one_page_checks_editable_text_box_font_floor() {
let mut lines = 28;
let mut lines = 20;
let mut s = create_multiline_doc(lines);
while s.layout().pages.len() < 2 && lines < 80 {
lines += 1;
@@ -386,7 +410,7 @@ fn fit_one_page_checks_editable_text_box_font_floor() {
#[test]
fn fit_one_page_fails_when_overflow_exceeds_limits() {
let mut lines = 28;
let mut lines = 20;
let mut s = create_multiline_doc(lines);
while s.layout().pages.len() < 2 {
lines += 1;
@@ -566,7 +590,7 @@ fn fit_one_page_fails_with_failed_cmd_error() {
#[test]
fn fit_one_page_never_populates_custom_props() {
let mut lines = 30;
let mut lines = 20;
let mut s = create_multiline_doc(lines);
while s.layout().pages.len() < 2 && lines < 80 {
lines += 2;
@@ -582,7 +606,7 @@ fn fit_one_page_never_populates_custom_props() {
fn fit_one_page_allows_subsequent_fit_after_typography_reset() {
use std::sync::Arc;
let mut lines = 28;
let mut lines = 20;
let mut s = create_multiline_doc(lines);
while s.layout().pages.len() < 2 && lines < 80 {
lines += 1;
@@ -625,7 +649,7 @@ fn fit_one_page_allows_subsequent_fit_after_typography_reset() {
#[test]
fn fit_one_page_small_paragraph_mark_with_runs_never_blocks_fit() {
let mut lines = 30;
let mut lines = 20;
let mut s = create_multiline_doc(lines);
while s.layout().pages.len() < 2 && lines < 80 {
lines += 2;
@@ -646,7 +670,7 @@ fn fit_one_page_small_paragraph_mark_with_runs_never_blocks_fit() {
#[test]
fn fit_one_page_small_comment_font_never_blocks_body_fit() {
let mut lines = 30;
let mut lines = 20;
let mut s = create_multiline_doc(lines);
while s.layout().pages.len() < 2 && lines < 80 {
lines += 2;
@@ -666,7 +690,7 @@ fn fit_one_page_small_comment_font_never_blocks_body_fit() {
#[test]
fn fit_one_page_anti_compound_caps_total_reduction_across_runs() {
let mut s = create_multiline_doc(27);
let mut s = create_multiline_doc(26);
assert_eq!(s.layout().pages.len(), 2);
// Initial fit with -0.5 pt font reduction (spacing disabled so font budget is exercised)
@@ -688,7 +712,7 @@ fn fit_one_page_anti_compound_caps_total_reduction_across_runs() {
#[test]
fn fit_one_page_tracks_reduced_text_provenance_without_global_minimum() {
let mut s = create_multiline_doc(27);
let mut s = create_multiline_doc(26);
// Add a 9.0 pt run to the first paragraph alongside 11.0 pt runs
if let wordcraft_doc::Block::Para(p) = std::sync::Arc::make_mut(&mut s.doc.body[0]) {
p.runs.push(wordcraft_doc::para::Run { len: 5, props: CharProps { size: Some(9.0), ..Default::default() } });
@@ -725,7 +749,7 @@ fn fit_one_page_tracks_reduced_text_provenance_without_global_minimum() {
#[test]
fn fit_one_page_allows_spill_with_bottom_placed_footnote() {
let mut lines = 28;
let mut lines = 20;
let mut s = create_multiline_doc(lines);
while s.layout().pages.len() < 2 && lines < 80 {
lines += 1;
@@ -751,7 +775,7 @@ fn fit_one_page_allows_spill_with_bottom_placed_footnote() {
#[test]
fn fit_one_page_with_final_page_footnote() {
let mut lines = 28;
let mut lines = 20;
let mut s = create_multiline_doc(lines);
while s.layout().pages.len() < 2 && lines < 80 {
lines += 1;
@@ -784,7 +808,7 @@ fn fit_one_page_with_final_page_footnote() {
#[test]
fn fit_one_page_skips_deleted_text_when_markup_hidden() {
let mut s = create_multiline_doc(27);
let mut s = create_multiline_doc(26);
assert_eq!(s.layout().pages.len(), 2);
// Insert a deleted text run with small font (e.g. 6.0 pt, below the 8.5 pt floor)
@@ -815,7 +839,7 @@ fn fit_one_page_skips_deleted_text_when_markup_hidden() {
#[test]
fn fit_one_page_tracks_reduced_complex_script_font_sizes() {
let mut s = create_multiline_doc(27);
let mut s = create_multiline_doc(26);
assert_eq!(s.layout().pages.len(), 2);
let styles_before = s.doc.styles.clone();
@@ -853,8 +877,9 @@ fn fit_one_page_tracks_reduced_complex_script_font_sizes() {
#[test]
fn fit_one_page_preserves_budget_across_document_serialization() {
let mut s = create_multiline_doc(27);
let mut s = create_multiline_doc(26);
assert_eq!(s.layout().pages.len(), 2);
assert_fixture_font(&mut s);
// Apply fit
let res = s.run("layout.fitOnePage", &json!({"maxDeltaPt": 0.5, "adjustSpacing": false}));
@@ -900,7 +925,7 @@ fn fit_one_page_enforces_durable_limit_when_fit_state_missing() {
s.touch();
s.relayout();
};
let mut lines = 27;
let mut lines = 20;
let mut s = create_multiline_doc(lines);
set_font(&mut s);
while s.layout().pages.len() < 2 && lines < 120 {
@@ -924,7 +949,7 @@ fn fit_one_page_enforces_durable_limit_when_fit_state_missing() {
#[test]
fn fit_one_page_skips_hidden_text_when_hidden_marks_off() {
let mut s = create_multiline_doc(27);
let mut s = create_multiline_doc(26);
assert_eq!(s.layout().pages.len(), 2);
// Insert a hidden text run with small font (6.0 pt, below the 8.5 pt floor) into an existing paragraph
@@ -958,7 +983,7 @@ fn fit_one_page_skips_hidden_text_when_hidden_marks_off() {
#[test]
fn fit_one_page_accounts_for_vertical_alignment_padding() {
let mut s = create_multiline_doc(26);
let mut s = create_multiline_doc(25);
let extra_p = wordcraft_doc::Paragraph::with_text("Spill line on page 2.", CharProps::default());
s.doc.body.push(wordcraft_doc::para_block(extra_p));
@@ -977,7 +1002,7 @@ fn fit_one_page_accounts_for_vertical_alignment_padding() {
#[test]
fn fit_one_page_accounts_for_note_separator_decor_story() {
let mut lines = 28;
let mut lines = 20;
let mut s = create_multiline_doc(lines);
while s.layout().pages.len() < 2 && lines < 80 {
lines += 1;
@@ -1012,7 +1037,7 @@ fn fit_one_page_accounts_for_note_separator_decor_story() {
#[test]
fn fit_one_page_tracks_fixed_spacing_independent_of_paragraph_mark_size() {
let mut lines = 28;
let mut lines = 20;
let mut s = create_multiline_doc(lines);
let set_spacing = |s: &mut Session| {
for b in &mut s.doc.body {
@@ -1053,7 +1078,7 @@ fn fit_one_page_tracks_fixed_spacing_independent_of_paragraph_mark_size() {
#[test]
fn fit_one_page_reports_search_exhaustion_when_candidates_cannot_remove_page() {
let mut s = create_multiline_doc(27);
let mut s = create_multiline_doc(26);
assert_eq!(s.layout().pages.len(), 2);
// Calling with zero maxDeltaPt and adjustSpacing: false produces no candidate steps
@@ -1068,23 +1093,24 @@ fn fit_one_page_reports_search_exhaustion_when_candidates_cannot_remove_page() {
#[test]
fn fit_one_page_excludes_line_number_decorations_from_final_page_limits() {
let mut lines = 33;
let enable_line_numbers = |s: &mut Session| {
s.doc.last_section.line_numbers = Some(wordcraft_doc::section::LineNumbering::default());
s.touch();
s.relayout();
};
let mut s = create_multiline_doc(lines);
enable_line_numbers(&mut s);
while s.layout().pages.len() < 2 && lines < 60 {
lines += 1;
s = create_multiline_doc(lines);
enable_line_numbers(&mut s);
}
let mut s = create_multiline_doc(33);
s.doc.last_section.line_numbers = Some(wordcraft_doc::section::LineNumbering::default());
s.touch();
s.relayout();
assert_eq!(s.layout().pages.len(), 2);
// Every body line on the final page also places a line-number decoration. Counting those as
// content would double the final-page line count and refuse before any candidate is tried.
// content would double the final-page line count and refuse before any candidate is tried:
// between 7 and 12 body lines are within the 12-line limit, and twice as many are not.
let body_lines: usize = s.layout().pages[1]
.items
.iter()
.map(|item| match item {
wordcraft_layout::Placed::Lines { story: wordcraft_doc::StoryRef::Body, l0, l1, .. } => l1 - l0,
_ => 0,
})
.sum();
assert!((7..=12).contains(&body_lines), "the final page must carry 7 to 12 body lines, has {body_lines}");
let decorated = s.layout().pages[1]
.items
.iter()
@@ -1099,7 +1125,7 @@ fn fit_one_page_excludes_line_number_decorations_from_final_page_limits() {
#[test]
fn fit_one_page_counts_side_by_side_footnote_cells_once() {
let mut s = create_multiline_doc(27);
let mut s = create_multiline_doc(26);
assert_eq!(s.layout().pages.len(), 2);
// A footnote table whose row's cells sit side by side: their text occupies one vertical
@@ -1134,7 +1160,7 @@ fn fit_one_page_counts_side_by_side_footnote_cells_once() {
#[test]
fn fit_one_page_refuses_when_formatting_changes_cannot_be_tracked() {
let mut s = create_multiline_doc(27);
let mut s = create_multiline_doc(26);
assert_eq!(s.layout().pages.len(), 2);
s.doc.settings.track_changes = true;
s.prefs.markup.track_formatting = true;
+22
View File
@@ -4031,3 +4031,25 @@ fn issues_1281_1045_english_dialects_proof_typed_text() {
let words: Vec<&str> = issues.as_array().unwrap().iter().filter(|i| i["kind"] == "spelling").filter_map(|i| i["text"].as_str()).collect();
assert_eq!(words, ["21th"]);
}
/// #6788: Enter in a paragraph with a drop cap makes a normal paragraph; only the first keeps
/// the cap (Word behaviour), for a dropped cap and one in the margin.
#[test]
fn enter_in_a_drop_cap_paragraph_makes_a_normal_paragraph() {
for position in ["dropped", "margin"] {
let mut s = typed("Sugar and knowledge");
run(&mut s, "insert.dropCap", json!({"position": position, "lines": 3, "distance": 4.0, "font": "Liberation Mono"}));
let first_has_cap = s.doc.body.first().and_then(|b| b.as_para()).is_some_and(|p| p.props.drop_cap == Some(3));
assert!(first_has_cap, "{position}: the cap is set");
run(&mut s, "select.range", json!({"anchor": {"block": 0, "off": 10}, "focus": {"block": 0, "off": 10}}));
run(&mut s, "text.newParagraph", json!({}));
let paras: Vec<_> = s.doc.body.iter().filter_map(|b| b.as_para()).collect();
assert_eq!(paras.len(), 2, "{position}");
let (first, second) = (&paras[0].props, &paras[1].props);
assert_eq!(first.drop_cap, Some(3), "{position}: the first paragraph keeps its cap");
assert_eq!(second.drop_cap, None, "{position}");
assert_eq!(second.drop_cap_margin, None, "{position}");
assert_eq!(second.drop_cap_distance, None, "{position}");
assert_eq!(second.drop_cap_font, None, "{position}");
}
}
+7 -1
View File
@@ -63,7 +63,13 @@ impl std::fmt::Display for UserFontError {
match self {
UserFontError::Empty => write!(f, "the font file is empty"),
UserFontError::TooLarge { bytes } => {
write!(f, "the font file is too large ({} MB; at most {} MB)", bytes.div_ceil(1 << 20), MAX_FONT_FILE_BYTES >> 20)
write!(
f,
"the font is too large ({} MB; file limit {} MB, unpacked limit {} MB)",
bytes.div_ceil(1 << 20),
MAX_FONT_FILE_BYTES >> 20,
MAX_DECODED_BYTES >> 20
)
}
UserFontError::NotAFont => write!(f, "not a font file (TrueType, OpenType, TTC, WOFF or WOFF2)"),
UserFontError::BadWebFont(e) => write!(f, "the web font couldn't be read: {e}"),
+6 -2
View File
@@ -210,7 +210,9 @@ fn woff1_claiming(orig: u32) -> Vec<u8> {
fn a_woff_claiming_a_huge_table_is_refused_before_inflating() {
// #3703: the decoder sizes a table's buffer from the directory before inflating it.
for orig in [200 << 20, u32::MAX] {
assert!(matches!(decode_font_file(&woff1_claiming(orig)), Err(UserFontError::TooLarge { .. })), "{orig}");
let error = decode_font_file(&woff1_claiming(orig)).unwrap_err();
assert!(matches!(&error, UserFontError::TooLarge { .. }), "{orig}");
assert!(error.to_string().contains("unpacked limit 128 MB"), "{error}");
}
// A small claim reaches the decoder, which finds the data doesn't inflate to it.
assert!(matches!(decode_font_file(&woff1_claiming(64)), Err(UserFontError::BadWebFont(_))));
@@ -311,7 +313,9 @@ fn junk_is_rejected_without_adding_anything() {
assert_eq!(db.families().len(), n + db.user_fonts().iter().map(|u| u.families().len()).sum::<usize>());
let mut big = regular.clone();
big.resize(MAX_FONT_FILE_BYTES + 1, 0);
assert!(matches!(db.install_font("big.ttf", &big), Err(UserFontError::TooLarge { .. })));
let error = db.install_font("big.ttf", &big).unwrap_err();
assert!(matches!(&error, UserFontError::TooLarge { .. }));
assert!(error.to_string().contains("file limit 50 MB"), "{error}");
}
#[test]
+212 -17
View File
@@ -63,15 +63,21 @@ pub fn finite(v: f32) -> f32 {
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
#[serde(rename_all = "lowercase")]
pub enum Unit {
/// Inches (the default).
#[default]
Inches,
/// Centimetres.
Centimeters,
/// Millimetres.
Millimeters,
/// Points (1/72 inch).
Points,
/// Picas (12 points).
Picas,
}
impl Unit {
/// The suffix shown after a number in this unit (`"` for inches, ` cm`, ` pt`, …).
pub fn suffix(self) -> &'static str {
match self {
Unit::Inches => "\"",
@@ -81,6 +87,7 @@ impl Unit {
Unit::Picas => " pi",
}
}
/// How many points one of this unit is.
pub fn pt_per_unit(self) -> f32 {
match self {
Unit::Inches => PT_PER_IN,
@@ -104,15 +111,34 @@ impl Unit {
let s = format!("{v:.2}");
let s = if s.contains('.') { s.trim_end_matches('0').trim_end_matches('.') } else { &s };
let s = if s == "-0" { "0" } else { s };
s.replace('.', &decimal.to_string())
let mut buf = [0u8; 4];
let sep: &str = decimal.encode_utf8(&mut buf);
s.replace('.', sep)
}
}
/// Maps the digits and decimal separators of other scripts to their ASCII forms: Arabic-Indic
/// (`٠`–`٩`, `٫`), Extended Arabic-Indic (`۰`–`۹`) and full-width (`0`–`9`, `.`, `,`).
fn fold_digit(c: char) -> char {
match c {
'\u{0660}'..='\u{0669}' => char::from(b'0' + (c as u32 - 0x0660) as u8),
'\u{06F0}'..='\u{06F9}' => char::from(b'0' + (c as u32 - 0x06F0) as u8),
'\u{FF10}'..='\u{FF19}' => char::from(b'0' + (c as u32 - 0xFF10) as u8),
'\u{066B}' | '\u{FF0E}' => '.',
'\u{FF0C}' => ',',
other => other,
}
}
/// Parse a measurement typed by a user: `1"`, `1 in`, `2.5cm`, `12pt`, `3 pi`, `10 mm`, `1.5 li`
/// (lines are 12 pt). A bare number is in `default`. Returns points. Either decimal separator
/// works (`2,5 cm` and `2.5 cm`), whatever the region.
/// (lines are 12 pt), `8 px` (pixels are 0.75 pt). A bare number is in `default`. Returns points,
/// or `None` for anything unreadable or whose result does not fit in an `f32`.
///
/// Either decimal separator works (`2,5 cm` and `2.5 cm`), whatever the region, so a thousands
/// separator is *not* understood: `1,000 pt` is 1 pt, not 1000. Arabic-Indic and full-width digits
/// are accepted like ASCII ones. Scientific notation is not: the number ends at the `e`.
pub fn parse_measure(s: &str, default: Unit) -> Option<f32> {
let t = s.trim().to_ascii_lowercase().replace('\u{2212}', "-");
let t = s.trim().chars().map(fold_digit).collect::<String>().to_ascii_lowercase().replace('\u{2212}', "-");
if t.is_empty() {
return None;
}
@@ -142,50 +168,98 @@ pub fn parse_measure(s: &str, default: Unit) -> Option<f32> {
/// A point in page space (points, y down).
#[derive(Clone, Copy, Debug, PartialEq, Default, Serialize, Deserialize)]
pub struct Point {
/// Distance from the left edge.
pub x: f32,
/// Distance from the top edge.
pub y: f32,
}
impl Point {
/// A point at (`x`, `y`).
pub const fn new(x: f32, y: f32) -> Self {
Point { x, y }
}
}
/// An axis-aligned rectangle (points, y down). `w`/`h` are never negative when built with [`Rect::new`].
/// An axis-aligned rectangle (points, y down). `w`/`h` are finite and never negative, whether the
/// rectangle was built with [`Rect::new`] or deserialized (both go through the same checks).
#[derive(Clone, Copy, Debug, PartialEq, Default, Serialize, Deserialize)]
#[serde(from = "RectRaw")]
pub struct Rect {
/// Left edge.
pub x: f32,
/// Top edge.
pub y: f32,
/// Width.
pub w: f32,
/// Height.
pub h: f32,
}
/// The unchecked shape of a [`Rect`] on the wire; converting it applies [`Rect::new`]'s rules.
#[derive(Deserialize)]
struct RectRaw {
x: f32,
y: f32,
w: f32,
h: f32,
}
impl From<RectRaw> for Rect {
fn from(r: RectRaw) -> Self {
Rect::new(r.x, r.y, r.w, r.h)
}
}
/// Where two crossed edges meet: both land on their midpoint.
fn collapse(lo: f32, hi: f32) -> (f32, f32) {
if hi < lo {
let m = lo * 0.5 + hi * 0.5;
(m, m)
} else {
(lo, hi)
}
}
impl Rect {
/// A rectangle with NaN and infinities replaced by 0 and a negative size clamped to 0.
pub fn new(x: f32, y: f32, w: f32, h: f32) -> Self {
Rect { x: finite(x), y: finite(y), w: finite(w).max(0.0), h: finite(h).max(0.0) }
}
/// The right edge.
pub fn right(&self) -> f32 {
self.x + self.w
}
/// The bottom edge.
pub fn bottom(&self) -> f32 {
self.y + self.h
}
/// Whether `p` is inside or on the edge. Edges are *included*, unlike [`Rect::intersects`],
/// so a point on an edge shared by two rectangles is in both.
pub fn contains(&self, p: Point) -> bool {
p.x >= self.x && p.x <= self.right() && p.y >= self.y && p.y <= self.bottom()
}
/// Whether the interiors overlap. Rectangles that only touch along an edge do *not* intersect.
pub fn intersects(&self, o: &Rect) -> bool {
self.x < o.right() && o.x < self.right() && self.y < o.bottom() && o.y < self.bottom()
}
/// The smallest rectangle covering both. An empty rectangle still counts: `Rect::default()`
/// sits at the origin, so accumulating bounds from it always stretches to (0, 0). Start from
/// the first real rectangle instead.
pub fn union(&self, o: &Rect) -> Rect {
let x = self.x.min(o.x);
let y = self.y.min(o.y);
Rect::new(x, y, self.right().max(o.right()) - x, self.bottom().max(o.bottom()) - y)
}
/// Shrunk by `l`, `t`, `r`, `b` on the left, top, right and bottom (grown for negative values).
/// If the edges cross, the result has zero size at the middle of where they crossed.
pub fn inset(&self, l: f32, t: f32, r: f32, b: f32) -> Rect {
Rect::new(self.x + l, self.y + t, self.w - l - r, self.h - t - b)
let (l, t, r, b) = (finite(l), finite(t), finite(r), finite(b));
let (x0, x1) = collapse(self.x + l, self.right() - r);
let (y0, y1) = collapse(self.y + t, self.bottom() - b);
Rect::new(x0, y0, x1 - x0, y1 - y0)
}
/// Grown by `d` on every side (shrunk for negative `d`, down to zero size).
/// Grown by `d` on every side (shrunk for negative `d`, down to zero size at the centre).
pub fn expand(&self, d: f32) -> Rect {
self.inset(-d, -d, -d, -d)
}
@@ -206,8 +280,11 @@ pub fn normalize_degrees(deg: f32) -> f32 {
/// `flipH`, `flipV` and `rot` say (ECMA-376 §20.1.7.6).
#[derive(Clone, Copy, Debug, PartialEq, Default)]
pub struct Spin {
/// Clockwise rotation in degrees.
pub deg: f32,
/// Mirrored left to right.
pub flip_h: bool,
/// Mirrored top to bottom.
pub flip_v: bool,
}
@@ -311,13 +388,15 @@ pub fn paper_by_name(name: &str) -> Option<(&'static str, f32, f32)> {
/// How a page is placed on other paper when printing with "Scale to paper size" (#2108).
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct PaperFit {
/// The sheet, turned to the page's orientation (points).
/// The sheet's width, turned to the page's orientation (points).
pub paper_w: f32,
/// The sheet's height, turned to the page's orientation (points).
pub paper_h: f32,
/// Page points to sheet points.
pub k: f32,
/// Where the page's top-left corner lands on the sheet (the page is centred).
/// Where the page's left edge lands on the sheet (the page is centred).
pub dx: f32,
/// Where the page's top edge lands on the sheet (the page is centred).
pub dy: f32,
}
@@ -327,7 +406,7 @@ pub struct PaperFit {
/// page as it is (scale 1 on paper of its own size).
pub fn fit_to_paper(page_w: f32, page_h: f32, paper_w: f32, paper_h: f32) -> PaperFit {
let ok = |v: f32| v.is_finite() && v >= 1.0;
let as_is = PaperFit { paper_w: page_w, paper_h: page_h, k: 1.0, dx: 0.0, dy: 0.0 };
let as_is = PaperFit { paper_w: finite(page_w), paper_h: finite(page_h), k: 1.0, dx: 0.0, dy: 0.0 };
if !(ok(page_w) && ok(page_h) && ok(paper_w) && ok(paper_h)) {
return as_is;
}
@@ -345,6 +424,10 @@ pub fn fit_to_paper(page_w: f32, page_h: f32, paper_w: f32, paper_h: f32) -> Pap
mod tests {
use super::*;
fn close(a: f32, b: f32) -> bool {
(a - b).abs() < 1e-3
}
#[test]
fn unit_round_trips() {
assert_eq!(twips(1440).to_bits(), 72.0f32.to_bits());
@@ -363,6 +446,7 @@ mod tests {
assert_eq!(parse_measure("12pt", Unit::Inches), Some(12.0));
assert_eq!(parse_measure("2", Unit::Inches), Some(144.0));
assert_eq!(parse_measure("1,5 li", Unit::Inches), Some(18.0));
assert_eq!(parse_measure("8 px", Unit::Inches), Some(6.0));
let cm = parse_measure("2.54 cm", Unit::Inches).unwrap();
assert!((cm - 72.0).abs() < 0.01);
assert_eq!(parse_measure("abc", Unit::Inches), None);
@@ -375,19 +459,29 @@ mod tests {
assert_eq!(parse_measure("1.5\"", Unit::Centimeters), Some(108.0));
assert_eq!(parse_measure("\u{2212}1 in", Unit::Points), Some(-72.0));
assert_eq!(parse_measure("1,2,3", Unit::Inches), None);
// Overflowing values during unit conversion return None (#1359).
// A comma is a decimal separator, never a thousands separator.
assert_eq!(parse_measure("1,000 pt", Unit::Inches), Some(1.0));
// Scientific notation is not accepted: the number stops at the `e`, leaving an unknown
// unit. (Overflow itself is covered by `parse_measure_rejects_overflow_to_infinity`.)
assert_eq!(parse_measure("1e3 pt", Unit::Points), None);
assert_eq!(parse_measure("3.4e38 in", Unit::Points), None);
assert_eq!(parse_measure("-3.4e38 in", Unit::Points), None);
assert_eq!(parse_measure("3.4e38 cm", Unit::Points), None);
assert_eq!(parse_measure("3.4e38 mm", Unit::Points), None);
assert_eq!(parse_measure("3.4e38 pi", Unit::Points), None);
assert_eq!(parse_measure("3.4e38 li", Unit::Points), None);
assert_eq!(parse_measure("3.4e38", Unit::Inches), None);
assert_eq!(parse_measure("1e39 pt", Unit::Points), None);
assert_eq!(parse_measure("inf", Unit::Points), None);
assert_eq!(parse_measure("nan", Unit::Points), None);
}
#[test]
fn parses_digits_of_other_scripts() {
let two_cm = parse_measure("2 cm", Unit::Inches).unwrap();
assert_eq!(parse_measure("\u{0662} cm", Unit::Inches), Some(two_cm)); // Arabic-Indic ٢
assert_eq!(parse_measure("\u{06F2} cm", Unit::Inches), Some(two_cm)); // Extended ۲
assert_eq!(parse_measure("\u{FF12} cm", Unit::Inches), Some(two_cm)); // Full-width 2
let two_and_half = parse_measure("2.5 cm", Unit::Inches).unwrap();
assert_eq!(parse_measure("\u{0662}\u{066B}\u{0665} cm", Unit::Inches), Some(two_and_half)); // ٢٫٥
assert_eq!(parse_measure("\u{FF12}\u{FF0E}\u{FF15}cm", Unit::Inches), Some(two_and_half)); // 2.5
assert_eq!(parse_measure("\u{0663}", Unit::Points), Some(3.0));
}
#[test]
fn parse_measure_rejects_overflow_to_infinity() {
// Finite inputs whose scaled result overflows `f32` must be rejected,
@@ -424,6 +518,10 @@ mod tests {
assert_eq!(Unit::Inches.format_with(108.0, ','), "1,5\"");
assert_eq!(Unit::Points.format_with(720.0, ','), "720 pt");
assert_eq!(Unit::Inches.format_with(f32::NAN, ','), "0\"");
// A tiny negative value must not print as "-0".
assert_eq!(Unit::Points.format(-0.001), "0 pt");
// Any character can be the separator.
assert_eq!(Unit::Inches.number(108.0, '\u{066B}'), "1\u{066B}5");
}
#[test]
@@ -437,6 +535,102 @@ mod tests {
assert_eq!(a.inset(1.0, 2.0, 3.0, 4.0), Rect::new(1.0, 2.0, 6.0, 4.0));
}
#[test]
fn rect_edges_are_in_contains_but_not_intersects() {
let a = Rect::new(0.0, 0.0, 10.0, 10.0);
let b = Rect::new(10.0, 0.0, 10.0, 10.0); // shares the edge x = 10
assert!(!a.intersects(&b));
assert!(a.contains(Point::new(10.0, 5.0)) && b.contains(Point::new(10.0, 5.0)));
}
#[test]
fn inset_past_zero_collapses_to_center() {
let r = Rect::new(0.0, 0.0, 10.0, 10.0);
assert_eq!(r.inset(8.0, 8.0, 8.0, 8.0), Rect::new(5.0, 5.0, 0.0, 0.0));
assert_eq!(r.expand(-8.0), Rect::new(5.0, 5.0, 0.0, 0.0));
assert_eq!(r.expand(-20.0), Rect::new(5.0, 5.0, 0.0, 0.0));
// Only one axis crosses: the other keeps its size.
assert_eq!(r.inset(0.0, 8.0, 0.0, 8.0), Rect::new(0.0, 5.0, 10.0, 0.0));
// Growing still works, and hostile insets are ignored rather than poisoning the result.
assert_eq!(r.expand(1.0), Rect::new(-1.0, -1.0, 12.0, 12.0));
assert_eq!(r.inset(f32::NAN, 0.0, 0.0, 0.0), r);
}
#[test]
fn rect_from_raw_is_sanitised() {
// Deserialization goes through this conversion (`#[serde(from = "RectRaw")]`).
let r = Rect::from(RectRaw { x: f32::NAN, y: 1.0, w: -4.0, h: f32::INFINITY });
assert_eq!(r, Rect::new(0.0, 1.0, 0.0, 0.0));
let ok = Rect::from(RectRaw { x: 1.0, y: 2.0, w: 3.0, h: 4.0 });
assert_eq!(ok, Rect::new(1.0, 2.0, 3.0, 4.0));
}
#[test]
fn rects_are_cleaned_when_deserialized() {
use serde::de::value::{Error, MapDeserializer};
let fields = [("x", f32::NAN), ("y", 1.0), ("w", -5.0), ("h", 2.0)];
let parsed: Result<Rect, Error> = Rect::deserialize(MapDeserializer::new(fields.into_iter()));
assert!(parsed.is_ok());
assert_eq!(parsed.unwrap_or_default(), Rect::new(0.0, 1.0, 0.0, 2.0));
}
#[test]
fn spin_apply_and_unapply_are_inverse() {
for spin in [
Spin::new(0.0, false, false),
Spin::new(37.0, false, false),
Spin::new(90.0, true, false),
Spin::new(215.0, false, true),
Spin::new(300.0, true, true),
] {
let (x, y) = spin.apply(50.0, 40.0, 70.0, 10.0);
let (bx, by) = spin.unapply(50.0, 40.0, x, y);
assert!(close(bx, 70.0) && close(by, 10.0), "{spin:?}");
}
}
#[test]
fn a_quarter_turn_is_clockwise_in_page_space() {
// y points down, so the point to the right of the centre goes below it.
let (x, y) = Spin::new(90.0, false, false).apply(0.0, 0.0, 10.0, 0.0);
assert!(x.abs() < 1e-4 && (y - 10.0).abs() < 1e-4);
}
#[test]
fn within_equals_applying_both_spins() {
let (outer, inner) = (Spin::new(30.0, true, false), Spin::new(75.0, false, true));
let (ix, iy) = inner.apply(0.0, 0.0, 12.0, -7.0);
let (ex, ey) = outer.apply(0.0, 0.0, ix, iy);
let (bx, by) = inner.within(outer).apply(0.0, 0.0, 12.0, -7.0);
assert!(close(ex, bx) && close(ey, by));
}
#[test]
fn spin_matrix_agrees_with_apply() {
let spin = Spin::new(37.0, true, false);
let [a, b, c, d, e, f] = spin.matrix(50.0, 40.0);
let (x, y) = spin.apply(50.0, 40.0, 70.0, 10.0);
assert!(close(a * 70.0 + c * 10.0 + e, x) && close(b * 70.0 + d * 10.0 + f, y));
// The centre stays where it is.
let (cx, cy) = spin.apply(50.0, 40.0, 50.0, 40.0);
assert!(close(cx, 50.0) && close(cy, 40.0));
}
#[test]
fn spin_bounds_and_identity() {
assert!(Spin::default().is_identity());
assert!(Spin::new(360.0, false, false).is_identity());
assert!(!Spin::new(0.0, true, false).is_identity());
let b = Spin::new(90.0, false, false).bounds(Rect::new(0.0, 0.0, 10.0, 20.0));
assert!(close(b.x, -5.0) && close(b.y, 5.0) && close(b.w, 20.0) && close(b.h, 10.0));
}
#[test]
fn normalises_degrees() {
assert_eq!(normalize_degrees(370.0), 10.0);
assert_eq!(normalize_degrees(-90.0), 270.0);
assert_eq!(normalize_degrees(f32::NAN), 0.0);
assert!((0.0..360.0).contains(&normalize_degrees(-1e-9)));
}
#[test]
fn paper_names() {
assert_eq!(paper_name(612.0, 792.0), Some("Letter"));
@@ -472,6 +666,7 @@ mod tests {
{
let f = fit_to_paper(a, b, c, d);
assert_eq!((f.k, f.dx, f.dy), (1.0, 0.0, 0.0));
assert!(f.paper_w.is_finite() && f.paper_h.is_finite());
}
assert!(fit_to_paper(1.0, 1.0, f32::MAX, f32::MAX).k.is_finite());
}
+1 -1
View File
@@ -307,7 +307,7 @@ fn decode_alpha(bytes: &[u8], decoded: &mut u64) -> Result<Option<Alpha>, OverBu
fn alpha_in_crop(img: &Alpha, crop: [f32; 4]) -> Option<Vec<(f32, f32)>> {
let (iw, ih) = (img.w, img.h);
// The part the renderers draw (#1899): a sliver keeps its partly covered pixels.
let [cl, ct, vw, vh] = craft_metafile::crop_window(crop);
let [cl, ct, vw, vh] = crate::crop_window(crop);
let (fw, fh) = (f64::from(iw), f64::from(ih));
let x0 = ((fw * cl) as u32).min(iw);
let y0 = ((fh * ct) as u32).min(ih);
+53 -4
View File
@@ -470,12 +470,41 @@ fn character_backgrounds(ctx: &LineContext<'_, '_, '_>, out: &mut Vec<Draw>) {
}
fn draw_label_and_hyphen(ctx: &LineContext<'_, '_, '_>, out: &mut Vec<Draw>) {
// A list number goes with its paragraph mark: when the mark is a tracked deletion the number
// is drawn as deleted text is, in the deletion's colour and with its mark (struck through by
// default, a caret, #s, bold…), and not at all where deletions aren't shown (#4828). Only
// when the item is deleted whole, its text too: a deleted mark alone joins the item to the
// next one, and its text and number stay as they are.
let m = &ctx.opts.revisions;
let whole = ctx.para.is_some_and(|p| p.runs.iter().all(|r| r.len == 0 || r.props.del.is_some()));
let mark_del = ctx.para.filter(|_| whole).and_then(|p| p.mark.del);
let moved = mark_del.is_some() && ctx.doc.move_name(mark_del).is_some();
let hidden = mark_del.is_some() && (!ctx.opts.markup || m.hides_deletion(moved));
let deleted = mark_del.filter(|_| ctx.opts.markup && m.insertions_deletions);
let del_mark = deleted.map(|_| if moved { m.move_from_mark } else { m.delete_mark });
// Moved-away text marked (none) is plain text, and so is its number.
let plain_move = moved && del_mark == Some(DeleteMark::None);
let del_color =
deleted.filter(|_| !plain_move).map(|r| if moved { m.move_from_color } else { m.delete_color }.unwrap_or_else(|| ctx.authors.color(r)));
if ctx.li == ctx.pl.label_line()
&& !hidden
&& let Some(label) = &ctx.pl.label
{
let gx = ctx.x + label.x;
let first = label.runs.first().and_then(|r| ctx.pl.styles.get(r.style as usize));
if let (Some(DeleteMark::Caret), Some(color), Some(style)) = (del_mark, del_color, first) {
// A caret where the number was, instead of the number.
let (h, w, y) = (style.size * 0.3, (style.size / 18.0).max(0.6), ctx.base + 1.0);
for (x0, y0, x1, y1) in [(gx - h * 0.6, y, gx, y - h), (gx, y - h, gx + h * 0.6, y)] {
out.push(Draw::Line { x0, y0, x1, y1, width: w, color, stroke: Stroke::Solid, alpha: ctx.alpha, text_bg: None });
}
return draw_hyphen(ctx, out);
}
for run in &label.runs {
let Some(style) = ctx.pl.styles.get(run.style as usize) else { continue };
let color = del_color.unwrap_or_else(|| ctx.ink(&style.rc.color, None));
// Each deleted character shows as #.
let hash = (del_mark == Some(DeleteMark::Hash)).then(|| style.face.glyph_for('#'));
out.push(Draw::Glyphs {
face: style.face,
size: style.size,
@@ -484,12 +513,12 @@ fn draw_label_and_hyphen(ctx: &LineContext<'_, '_, '_>, out: &mut Vec<Draw>) {
.get(run.glyphs.clone())
.into_iter()
.flatten()
.map(|g| (g.gid, gx + g.dx, ctx.base - style.shift - g.dy))
.map(|g| (hash.unwrap_or(g.gid), gx + g.dx, ctx.base - style.shift - g.dy))
.collect(),
color: ctx.ink(&style.rc.color, None),
color,
alpha: ctx.alpha,
synth_bold: style.synth_bold,
synth_italic: style.synth_italic,
synth_bold: style.synth_bold || del_mark == Some(DeleteMark::Bold),
synth_italic: style.synth_italic || del_mark == Some(DeleteMark::Italic),
text: run.text.clone(),
link: None,
ranges: Vec::new(),
@@ -497,7 +526,27 @@ fn draw_label_and_hyphen(ctx: &LineContext<'_, '_, '_>, out: &mut Vec<Draw>) {
x_scale: 1.0,
});
}
// Struck through or underlined once, across the whole number, in its first run's size.
if let (Some(color), Some(mark), Some(style)) = (del_color, del_mark, first) {
let strike_y = ctx.base - style.shift - style.size * 0.28;
let under_y = ctx.base - style.shift + style.size * 0.12;
let line = match mark {
DeleteMark::Strikethrough => Some((strike_y, Stroke::Solid)),
DeleteMark::DoubleStrikethrough => Some((strike_y, Stroke::Double)),
DeleteMark::Underline => Some((under_y, Stroke::Solid)),
DeleteMark::DoubleUnderline => Some((under_y, stroke_of(Underline::Double))),
_ => None,
};
if let Some((y, stroke)) = line {
let width = (style.size / 18.0).max(0.5);
out.push(Draw::Line { x0: gx, y0: y, x1: gx + label.width, y1: y, width, color, stroke, alpha: ctx.alpha, text_bg: None });
}
}
}
draw_hyphen(ctx, out);
}
fn draw_hyphen(ctx: &LineContext<'_, '_, '_>, out: &mut Vec<Draw>) {
if let Some((style_index, glyph, advance)) = ctx.line.hyphen
&& let Some(style) = ctx.pl.styles.get(style_index as usize)
{
+2
View File
@@ -59,6 +59,7 @@ mod ctx;
mod floats;
mod flow;
mod headers;
mod metafile;
mod missing;
mod notes;
mod page;
@@ -85,6 +86,7 @@ use headers::MAX_HEADER_ITEMS;
#[cfg(test)]
use headers::placed_cost;
use headers::placed_cost_by;
pub use metafile::{MAX_METAFILE_DASHES, crop_sides, crop_window, metafile_average_color, metafile_dashes, metafile_miter_limit};
pub use missing::{MAX_MISSING_GLYPHS, MissingGlyphs, metafile_text_run, missing_watermark_glyphs, watermark_run};
pub use notes::DECOR_STORY;
pub(crate) use notes::NOTE_SEP_W;
+75
View File
@@ -0,0 +1,75 @@
//! Drawing rules the page renderer and the PDF export share for metafile pictures and picture
//! crops, so the two outputs draw the same file the same way.
/// Most dashes and gaps one metafile stroke is split into. A path that a pen's pattern would split
/// into more draws solid.
pub const MAX_METAFILE_DASHES: f64 = 100_000.0;
/// The crop sides a picture is drawn with: each side of `crop` (left, top, right, bottom fractions
/// of the source) at least 0. A negative side draws as no crop, not as padding around the source.
pub fn crop_sides(crop: [f32; 4]) -> [f32; 4] {
crop.map(|v| if v.is_finite() { v.max(0.0) } else { 0.0 })
}
/// The part of a picture's source that `crop` keeps, as fractions of the source: [left, top,
/// width, height] (`craft_metafile::crop_window` of [`crop_sides`]).
pub fn crop_window(crop: [f32; 4]) -> [f64; 4] {
craft_metafile::crop_window(crop_sides(crop))
}
/// The miter limit a metafile pen is drawn with: its own when it is finite and at least 1,
/// otherwise 10.
pub fn metafile_miter_limit(limit: f32) -> f32 {
if limit.is_finite() && limit >= 1.0 { limit } else { 10.0 }
}
/// The dash lengths (page points) a metafile pen draws a path `length` points long with, or None
/// for a solid line. `dash` is the placed pen's pattern (`craft_metafile::LineStyle::dash`, page
/// points) and `pixel` is one output pixel in points.
///
/// A cosmetic pen (`cosmetic`: width 0) has its pattern scaled so that its shortest dash or gap is
/// one pixel, at any zoom. A pattern with a negative or non-finite length draws solid, and so does
/// one whose period is shorter than a pixel or that would split the path into more than
/// [`MAX_METAFILE_DASHES`] dashes and gaps.
pub fn metafile_dashes(dash: &[f32], cosmetic: bool, pixel: f64, length: f64) -> Option<Vec<f64>> {
if dash.is_empty() || !pixel.is_finite() || pixel <= 0.0 {
return None;
}
let mut out: Vec<f64> = dash.iter().map(|d| f64::from(*d)).collect();
if !out.iter().all(|d| d.is_finite() && *d >= 0.0) {
return None;
}
if cosmetic {
let shortest = out.iter().copied().filter(|d| *d > 0.0).fold(f64::INFINITY, f64::min);
if !shortest.is_finite() {
return None;
}
let k = pixel / shortest;
out.iter_mut().for_each(|d| *d *= k);
}
let period: f64 = out.iter().sum();
if !period.is_finite() || period < pixel {
return None;
}
// Each length of the pattern starts a new dash or gap.
let pieces = out.len() as f64 * if length.is_finite() { length.max(0.0) / period } else { f64::INFINITY };
(pieces <= MAX_METAFILE_DASHES).then_some(out)
}
/// The alpha-weighted average color of straight RGBA pixels (transparent when there are none): a
/// metafile pattern fill whose tile is too small to show is filled with it.
pub fn metafile_average_color(px: &[u8]) -> [u8; 4] {
let (mut r, mut g, mut b, mut a, mut n) = (0u64, 0u64, 0u64, 0u64, 0u64);
for p in px.as_chunks::<4>().0 {
let w = u64::from(p[3]);
r += u64::from(p[0]) * w;
g += u64::from(p[1]) * w;
b += u64::from(p[2]) * w;
a += w;
n += 1;
}
if a == 0 || n == 0 {
return [0; 4];
}
[(r / a) as u8, (g / a) as u8, (b / a) as u8, (a / n) as u8]
}
+36 -13
View File
@@ -151,13 +151,37 @@ pub fn watermark_run(wm: &wordcraft_doc::Watermark, max_chars: usize) -> Option<
/// in the face its font name resolves to (no fallback face), so a character that face lacks shapes
/// to glyph id 0. Strict export checks these same glyphs, so the check and the exporters can't
/// drift.
pub fn metafile_text_run(t: &craft_metafile::Text) -> (wordcraft_fonts::FaceRef, Vec<ShapedGlyph>) {
let family = t.font.family.trim();
let family = if family.is_empty() { METAFILE_DEFAULT_FONT } else { family };
let face = wordcraft_fonts::word::resolve(family, t.font.weight >= 600, t.font.italic).face;
let shaped = wordcraft_fonts::shape(&face, &t.text, &[], |c| c);
(face, shaped)
}
/// The face a metafile font with no face name is drawn in.
const METAFILE_DEFAULT_FONT: &str = "Arial";
/// The cell height (text units) of a metafile font whose height is 0, the file's default size.
const METAFILE_DEFAULT_HEIGHT: f64 = 16.0;
/// A metafile text run laid out with a font's metrics: the em size (text units), the baseline's y
/// and each glyph's (x, y), alignment included, in the run's text space (see
/// `craft_metafile::Text::transform`).
pub struct MetafileTextLayout {
pub em: f64,
pub baseline: f64,
pub glyphs: Vec<(f64, f64)>,
/// The rectangle of the character cells (x0, y0, x1, y1): from the leftmost to the rightmost
/// pen position of the run, the font's ascent above the baseline and its descent below. An
/// opaque background fills it.
pub cell: [f64; 4],
}
/// Lay out shaped glyphs for a metafile text run.
/// Lays out the shaped glyphs of `t`, given as (cluster byte offset, x advance, x offset, y offset)
/// in font units of a font with `upem` units per em, `ascent` above and `descent` below the
/// baseline. The font height is the em size when negative and the cell height (ascent plus
/// descent) when positive. The per-character advances `dx` place each cluster when there is one
/// per character. None when the size is not finite and positive.
pub fn layout_metafile_text(
t: &craft_metafile::Text,
upem: f64,
@@ -166,10 +190,9 @@ pub fn layout_metafile_text(
glyphs: &[(usize, f64, f64, f64)],
) -> Option<MetafileTextLayout> {
let upem = if upem.is_finite() && upem > 0.0 { upem } else { 1000.0 };
let cell_h = ascent + descent;
let size = if t.font.height == 0.0 { 12.0 } else { f64::from(t.font.height.abs()) };
let cell = t.font.height > 0.0;
let em = if cell && cell_h.is_finite() && cell_h > 0.0 { size * upem / cell_h } else { size };
let height = if t.font.height == 0.0 { METAFILE_DEFAULT_HEIGHT } else { f64::from(t.font.height) };
let cell = ascent + descent;
let em = if height > 0.0 && cell.is_finite() && cell > 0.0 { height * upem / cell } else { height.abs() };
if !em.is_finite() || em <= 0.0 {
return None;
}
@@ -187,6 +210,8 @@ pub fn layout_metafile_text(
});
let mut out = Vec::with_capacity(glyphs.len());
let (mut pen, mut cluster_pen, mut last) = (0.0, 0.0, None);
// The leftmost and rightmost pen positions: advances can move backward.
let (mut lo, mut hi) = (0.0f64, 0.0f64);
for &(cluster, adv, xo, yo) in glyphs {
let ci = starts.partition_point(|&b| b <= cluster).saturating_sub(1);
if last != Some(ci) {
@@ -199,6 +224,10 @@ pub fn layout_metafile_text(
};
out.push((x + xo * k, -yo * k));
pen += adv * k;
(lo, hi) = (lo.min(pen), hi.max(pen));
}
if let Some(cum) = &dx {
(lo, hi) = cum.iter().fold((0.0f64, 0.0f64), |(l, h), x| (l.min(*x), h.max(*x)));
}
let width = dx.as_ref().and_then(|c| c.last().copied()).unwrap_or(pen);
let hoff = match t.h_align {
@@ -212,14 +241,8 @@ pub fn layout_metafile_text(
craft_metafile::VAlign::Bottom => -descent * k,
};
let glyphs = out.into_iter().map(|(x, y)| (x + hoff, y + baseline)).collect();
Some(MetafileTextLayout { em, baseline, glyphs })
}
pub fn metafile_text_run(t: &craft_metafile::Text) -> (wordcraft_fonts::FaceRef, Vec<ShapedGlyph>) {
let bold = t.font.weight >= 600;
let face = wordcraft_fonts::word::resolve(&t.font.family, bold, t.font.italic).face;
let shaped = wordcraft_fonts::shape(&face, &t.text, &[], |c| c);
(face, shaped)
let cell = [hoff + lo, baseline - ascent * k, hoff + hi, baseline + descent * k];
Some(MetafileTextLayout { em, baseline, glyphs, cell })
}
/// The characters of the watermark that draw as an empty box (glyph id 0), counted as
+43 -4
View File
@@ -27,6 +27,9 @@ struct Breaker<'e> {
/// Word 2013+ (compatibility mode 15) fits more text on a justified line by shrinking its
/// spaces (`space_room`); never on lines with tabs.
shrink_spaces: bool,
/// Word 2003's indent rules (`w:doNotSuppressIndentation`) before Word 2013's layout, for an
/// unnumbered paragraph: a row starts right after a floating object before the indent.
tight_indent: bool,
/// Word stretches a justified line ending in a manual line break unless the document says not to.
expand_break: bool,
/// Hyphenation Options: the zone, and how many lines in a row may end with a hyphen.
@@ -190,6 +193,13 @@ impl<'e> Breaker<'e> {
hanging_at: if rp.indent_first < 0.0 { Some(rp.indent_left) } else { None },
tab_origin: if settings.odf.is_some_and(|o| o.tabs_from_indent) { rp.indent_left } else { 0.0 },
shrink_spaces: rp.align == Align::Justify && settings.compat_mode >= wordcraft_doc::COMPAT_MODE_CURRENT,
tight_indent: settings.do_not_suppress_indentation
&& settings.compat_mode < wordcraft_doc::COMPAT_MODE_CURRENT
&& level.is_none()
&& pl.label.is_none()
// A drop cap sits at the indent: starting its lines at a float's edge would put
// them over the letter.
&& pl.drop_cap.is_none(),
expand_break: !settings.do_not_expand_shift_return,
zone: Some(settings.hyphenation_zone).filter(|z| z.is_finite() && *z >= 0.0).unwrap_or(HYPHENATION_ZONE).min(1584.0),
hyph_limit: settings.consecutive_hyphen_limit as usize,
@@ -236,9 +246,12 @@ impl<'e> Breaker<'e> {
let mut guard = 0;
loop {
let lo = self.row_left(pl);
match row_spans(self.exclusions, self.top, self.est_h, self.table_h, lo, self.base_right).map(|mut spans| (spans.pop_front(), spans)) {
let row = (self.top, self.est_h, self.table_h);
match row_spans(self.exclusions, row, (lo, self.base_right), self.tight_indent).map(|mut spans| (spans.pop_front(), spans)) {
Ok((Some((a, b)), rest)) => {
let narrowed = !rest.is_empty() || a > lo || b < self.base_right;
// Under Word 2003's indent rules a row can start left of the indent too.
let moved = if self.tight_indent { (a - lo).abs() > 0.01 } else { a > lo };
let narrowed = !rest.is_empty() || moved || b < self.base_right;
self.row_rest = rest;
self.row_first = self.lines.len();
return (a, b.max(a + MIN_LINE_WIDTH), narrowed);
@@ -1064,6 +1077,23 @@ impl Scan {
/// paragraph beside a floating table in a 21.3pt gap but not in an 18.6pt one.
const MIN_SPAN: f32 = 20.0;
/// Where a row starts under Word 2003's indent rules: right after the floating objects that end
/// at or before the indent `lo` on this row and let text past their right side (their outline's
/// right edge for Tight and Through wrapping), never left of the paragraph's own left edge (0) or
/// right of `lo`; `lo` if there are none.
fn tight_row_start(exclusions: &[Exclusion], (top, h, table_h): (f32, f32, f32), lo: f32) -> f32 {
exclusions
.iter()
.filter(|e| !e.top_bottom && e.side != WrapText::Left && e.right <= lo && e.intersects_row(top, h, table_h, f32::NEG_INFINITY, lo))
.filter_map(|e| match &e.contour {
None => Some(e.right),
Some(c) => c.occupied(top - e.top, top + h - e.top).into_iter().map(|(_, b)| b + e.left).reduce(f32::max),
})
.reduce(f32::max)
// A float out in the left margin doesn't pull the text into the margin after it.
.map_or(lo, |edge| edge.max(0.0).min(lo))
}
/// How far below a line's top its baseline sits. Multiple spacing at or above single keeps the
/// text at the top of the line and puts the extra leading below the baseline; below single it
/// shrinks the whole box, ascent included (Word's output for docxide-pdf's fixtures: 1.15-spaced
@@ -1078,8 +1108,17 @@ fn baseline_offset(spacing: LineSpacing, asc: f32, height: f32, desc: f32) -> f3
/// The spans of a row at `top` (about `h` tall) between `lo` and `hi` that text can use around
/// the exclusions, left to right (Square wrapping uses both sides of an object). `Err(y)`: none
/// here, try again at `y` (below what's in the way).
fn row_spans(exclusions: &[Exclusion], top: f32, h: f32, table_h: f32, lo: f32, hi: f32) -> Result<VecDeque<(f32, f32)>, f32> {
/// here, try again at `y` (below what's in the way). With `tight_indent` (Word 2003's indent
/// rules, `w:doNotSuppressIndentation`) a row starts right after a floating object that ends
/// before `lo`, the indent ignored (ECMA-376 Part 4 §14.8.3.12: a paragraph indented 1" tightly
/// wraps an object at 0.25").
fn row_spans(
exclusions: &[Exclusion],
(top, h, table_h): (f32, f32, f32),
(lo, hi): (f32, f32),
tight_indent: bool,
) -> Result<VecDeque<(f32, f32)>, f32> {
let lo = if tight_indent { tight_row_start(exclusions, (top, h, table_h), lo) } else { lo };
let here: Vec<&Exclusion> = exclusions.iter().filter(|e| e.intersects_row(top, h, table_h, lo, hi)).collect();
if let Some(below) = here.iter().filter(|e| e.top_bottom).map(|e| e.bottom).reduce(f32::max) {
return Err(below);
+209
View File
@@ -1997,6 +1997,108 @@ fn break_only_list_has_no_label() {
}
}
/// #4828: a list item deleted whole (its text and its mark) under Track Changes shows its number
/// as deleted text, in the deletion's colour and struck through, with markup shown; without
/// markup the number is drawn no more than the text.
#[test]
fn a_deleted_list_items_number_is_drawn_as_deleted_text() {
let mut d = Document::from_text("Intro\nChapter two\nBody");
d.revisions.push(wordcraft_doc::Revision {
kind: wordcraft_doc::RevisionKind::Delete,
author: "Ana".into(),
date: String::new(),
move_name: None,
});
let id = std::sync::Arc::make_mut(&mut d.numbering).add_list(wordcraft_doc::ListKind::Numbered);
d.format_paragraphs(&Pos::body(1, 0), &Pos::body(1, 3), &|p| p.numbering = Some(wordcraft_doc::props::NumRef { num: id, level: 0 })).unwrap();
d.format_range(&Pos::body(1, 0), &Pos::body(1, 11), &|c| c.del = Some(0)).unwrap();
d.para_mut(StoryRef::Body, &Path::top(1)).unwrap().mark.del = Some(0);
let l = lay(&d);
let draws = |markup: bool| display::page_display(&d, &l.pages[0], &display::DisplayOptions { markup, ..Default::default() });
let glyph_color = |items: &[display::Draw], want: &str| {
items.iter().find_map(|i| match i {
display::Draw::Glyphs { text, color, glyphs, .. } if text.contains(want) => Some((*color, glyphs.first().map_or(0.0, |g| g.1))),
_ => None,
})
};
let marked = draws(true);
let (number, nx) = glyph_color(&marked, "1.").expect("the number is drawn with markup");
let (text, _) = glyph_color(&marked, "Chapter").expect("the deleted text is drawn with markup");
assert_eq!(number, text, "the number takes the deletion's colour");
let struck = marked
.iter()
.any(|i| matches!(i, display::Draw::Line { x0, x1, y0, y1, .. } if (y0 - y1).abs() < 0.01 && *x0 <= nx + 0.01 && *x1 > nx + 1.0));
assert!(struck, "the number is struck through");
// The number takes the other deletion marks as its text does.
let with_mark = |mark: display::DeleteMark| {
let mut o = display::DisplayOptions { markup: true, ..Default::default() };
o.revisions.delete_mark = mark;
display::page_display(&d, &l.pages[0], &o)
};
let caret = with_mark(display::DeleteMark::Caret);
assert!(glyph_color(&caret, "1.").is_none(), "a caret replaces the number");
assert!(caret.iter().any(|i| matches!(i, display::Draw::Line { x1, .. } if (*x1 - nx).abs() < 0.01)), "the caret is where the number was");
let bold = with_mark(display::DeleteMark::Bold);
assert!(bold.iter().any(|i| matches!(i, display::Draw::Glyphs { text, synth_bold: true, .. } if text.contains("1."))));
let hashed = with_mark(display::DeleteMark::Hash);
let ids = |items: &[display::Draw], want: &str| {
items.iter().find_map(|i| match i {
display::Draw::Glyphs { text, glyphs, .. } if text.contains(want) => Some(glyphs.iter().map(|g| g.0).collect::<Vec<_>>()),
_ => None,
})
};
let (numbers, hashes) = (ids(&marked, "1.").unwrap(), ids(&hashed, "1.").unwrap());
assert!(hashes.len() == numbers.len() && hashes.windows(2).all(|w| w[0] == w[1]) && hashes != numbers, "each character shows as #");
let plain_label = |items: &[display::Draw]| {
items.iter().any(|i| matches!(i, display::Draw::Line { x0, x1, y0, y1, .. } if (y0 - y1).abs() < 0.01 && *x0 <= nx + 0.01 && *x1 > nx + 1.0))
};
assert!(!plain_label(&with_mark(display::DeleteMark::ColorOnly)), "colour only: no line through or under the number");
// Moved-away text marked (none) is plain, its number too.
let mut moved = d.clone();
if let Some(r) = moved.revisions.get_mut(0) {
r.move_name = Some("move1".into());
}
let mut o = display::DisplayOptions { markup: true, ..Default::default() };
o.revisions.move_from_mark = display::DeleteMark::None;
let shown = display::page_display(&moved, &l.pages[0], &o);
let (moved_number, _) = glyph_color(&shown, "1.").expect("the moved number is drawn");
let (moved_text, _) = glyph_color(&shown, "Chapter").expect("the moved text is drawn");
assert_eq!(moved_number, moved_text, "plain, like its text");
assert!(!plain_label(&shown));
// With markup but deletions hidden in Track Changes Options, the number isn't drawn either.
assert!(glyph_color(&with_mark(display::DeleteMark::Hidden), "1.").is_none(), "deletions marked hidden");
let mut o = display::DisplayOptions { markup: true, ..Default::default() };
o.revisions.insertions_deletions = false;
assert!(glyph_color(&display::page_display(&d, &l.pages[0], &o), "1.").is_none(), "insertions and deletions not shown");
// Without markup neither the text nor its number is drawn.
let plain = draws(false);
assert!(glyph_color(&plain, "Chapter").is_none() && glyph_color(&plain, "1.").is_none());
// A number whose paragraph mark isn't deleted is drawn as before.
let mut kept = Document::from_text("Intro\nChapter two\nBody");
let id = std::sync::Arc::make_mut(&mut kept.numbering).add_list(wordcraft_doc::ListKind::Numbered);
kept.format_paragraphs(&Pos::body(1, 0), &Pos::body(1, 3), &|p| p.numbering = Some(wordcraft_doc::props::NumRef { num: id, level: 0 })).unwrap();
let kl = lay(&kept);
let plain = display::page_display(&kept, &kl.pages[0], &display::DisplayOptions { markup: false, ..Default::default() });
assert!(glyph_color(&plain, "1.").is_some());
// #4828 review: only the paragraph mark deleted (Delete at the end of the item): the text
// stays, and so does its number, plain, with markup and without (and in print, where markup
// is off).
let mut joined = kept.clone();
joined.revisions = d.revisions.clone();
joined.para_mut(StoryRef::Body, &Path::top(1)).unwrap().mark.del = Some(0);
let jl = lay(&joined);
for markup in [false, true] {
let shown = display::page_display(&joined, &jl.pages[0], &display::DisplayOptions { markup, ..Default::default() });
let (number, jx) = glyph_color(&shown, "1.").unwrap_or_else(|| panic!("markup {markup}: the number stays"));
let (text, _) = glyph_color(&shown, "Chapter").unwrap_or_else(|| panic!("markup {markup}: the text stays"));
assert_eq!(number, text, "markup {markup}: in the text's colour");
let struck = shown
.iter()
.any(|i| matches!(i, display::Draw::Line { x0, x1, y0, y1, .. } if (y0 - y1).abs() < 0.01 && *x0 <= jx + 0.01 && *x1 > jx + 1.0));
assert!(!struck, "markup {markup}: not struck through");
}
}
#[test]
fn empty_list_paragraph_with_a_hidden_mark_counts_but_shows_nothing() {
// Word (#3982): a list item whose paragraph mark is hidden, and whose text is empty or hidden
@@ -3707,6 +3809,113 @@ fn text_wraps_around_square_float() {
assert!(l.pages[0].items.iter().any(|i| matches!(i, Placed::Shape { .. })));
}
/// The left edges of a paragraph's lines beside a 144 × 100 pt square-wrapped rectangle at the
/// column's top left (9 pt from text), and of its first line below the rectangle, in
/// compatibility `mode` with Word 2003's indent rules on or off. The paragraph is indented
/// 216 pt; `float` adjusts the object, `para` the paragraph, and `numbered` makes it a list item.
fn word_2003_indent_lefts(
mode: u32,
rules: bool,
float: &dyn Fn(&mut wordcraft_doc::para::Float),
numbered: bool,
para: &dyn Fn(&mut ParaProps),
) -> (Vec<f32>, Option<f32>) {
let mut d = Document::from_text(&"Words beside the picture here. ".repeat(20));
d.settings.compat_mode = mode;
d.settings.do_not_suppress_indentation = rules;
let num = numbered.then(|| Arc::make_mut(&mut d.numbering).add_list(wordcraft_doc::ListKind::Numbered));
d.format_paragraphs(&Pos::body(0, 0), &Pos::body(0, 0), &|p| {
p.indent_left = Some(216.0);
p.indent_first = Some(0.0);
p.numbering = num.map(|num| wordcraft_doc::props::NumRef { num, level: 0 });
para(p);
})
.unwrap();
let mut f = wordcraft_doc::para::Float {
wrap: wordcraft_doc::para::Wrap::Square,
h_rel: wordcraft_doc::para::Anchor::Column,
v_rel: wordcraft_doc::para::Anchor::Paragraph,
x: 0.0,
y: 0.0,
dist: 9.0,
..Default::default()
};
float(&mut f);
let shape = InlineObject::Shape {
kind: wordcraft_doc::para::ShapeKind::Rectangle,
w: 144.0,
h: 100.0,
fill: None,
stroke: None,
stroke_width: 1.0,
float: f,
story: None,
freeform: None,
effects: Default::default(),
extra: Default::default(),
};
// After the first word, so a drop cap takes the paragraph's first letter.
d.insert_object(&Pos::body(0, 6), shape, &Default::default()).unwrap();
let l = lay(&d);
let Placed::Lines { para, .. } = l.pages[0].items.iter().find(|i| matches!(i, Placed::Lines { story: StoryRef::Body, .. })).unwrap() else {
panic!()
};
let beside = para.lines.iter().filter(|ln| ln.top < 100.0).map(|ln| ln.left).collect();
let below = para.lines.iter().find(|ln| ln.top > 120.0).map(|ln| ln.left);
(beside, below)
}
/// Word 2003's indent rules (`w:doNotSuppressIndentation`, a `.doc`'s `Copts.fWW11IndentRules`): an
/// unnumbered paragraph indented past a floating object on its left starts its lines right after
/// the object, its indent ignored (ECMA-376 Part 4 §14.8.3.12). In a Word 2003-mode `.doc` saved
/// by Word, empty paragraphs indented 216 pt sit right after a text box ending 165 pt into the
/// column, in the 71 pt gap before a second box where the indent would leave under 20 pt. Below
/// the object, and in Word 2013's layout, the indent applies.
#[test]
fn word_2003_indent_rules_start_lines_right_after_a_float_before_the_indent() {
let lefts = |mode: u32, rules: bool| word_2003_indent_lefts(mode, rules, &|_| {}, false, &|_| {});
for mode in [11, 12, 14] {
let (beside, below) = lefts(mode, true);
assert!(
!beside.is_empty() && beside.iter().all(|x| (x - 153.0).abs() < 0.01),
"mode {mode}: lines start after the object and its 9 pt distance: {beside:?}"
);
assert_eq!(below, Some(216.0), "mode {mode}: below the object the indent applies");
}
assert_eq!(lefts(11, false).0[0], 216.0, "without the option the indent applies beside the object");
assert_eq!(lefts(15, true).0[0], 216.0, "Word 2013's layout keeps the indent");
}
/// Under Word 2003's indent rules a line starts after a Tight or Through-wrapped object's outline
/// where the line meets it, not after the outline's widest point: here a right triangle, its
/// point at the top left, 144 pt wide (and 9 pt from text) only at its foot.
#[test]
fn word_2003_indent_rules_follow_a_tight_objects_outline() {
use wordcraft_doc::para::Wrap;
use wordcraft_doc::wrap::WrapPolygon;
let poly = WrapPolygon::new(true, [(0, 0), (0, 21_600), (21_600, 21_600)]).map(Arc::new);
for wrap in [Wrap::Tight, Wrap::Through] {
let (beside, _) = word_2003_indent_lefts(11, true, &|f| (f.wrap, f.wrap_polygon) = (wrap, poly.clone()), false, &|_| {});
assert!(beside.len() > 2 && beside[0] < 60.0, "{wrap:?}: the first line starts near the point: {beside:?}");
assert!(beside.windows(2).all(|w| w[0] < w[1]) && beside.iter().all(|&x| x <= 153.0 + 0.01), "{wrap:?}: each line further out: {beside:?}");
}
}
/// Word 2003's indent rules leave the indent alone for a numbered paragraph (its number sits at
/// the indent) and for one with a drop cap (the letter does), and never start a line left of the
/// paragraph's own edge after an object out in the margin.
#[test]
fn word_2003_indent_rules_keep_the_indent_where_they_do_not_apply() {
let (numbered, _) = word_2003_indent_lefts(11, true, &|_| {}, true, &|_| {});
assert!(numbered.iter().all(|&x| x >= 216.0 - 0.01), "a numbered paragraph keeps its indent: {numbered:?}");
let (dropped, _) = word_2003_indent_lefts(11, true, &|_| {}, false, &|p| p.drop_cap = Some(3));
assert!(dropped.iter().all(|&x| x >= 216.0 - 0.01), "lines beside a drop cap stay right of it: {dropped:?}");
// An object in the left margin, its right side and distance from text 44 pt short of the column.
let (margin, _) = word_2003_indent_lefts(11, true, &|f| f.x = -197.0, false, &|_| {});
assert!(margin.iter().all(|&x| x >= -0.01), "no line starts in the margin: {margin:?}");
assert!((margin[0] - 0.0).abs() < 0.01, "the line starts at the paragraph's edge: {margin:?}");
}
#[test]
fn a_lines_arrowheads_sit_at_its_ends() {
// A line runs from its frame's top left to its bottom right (DrawingML's `line`, as it is
+59
View File
@@ -242,3 +242,62 @@ fn an_equation_run_names_each_glyphs_characters() {
assert!(found.iter().any(|(t, g, _)| (t.contains('\u{1D44E}') || t == "ab") && *g == 2), "{found:?}");
assert!(found.iter().all(|(_, g, r)| g == r), "{found:?}");
}
/// A metafile text run with the given font height and advances, left-aligned at the baseline.
fn meta_text(height: f32, dx: Vec<f32>) -> craft_metafile::Text {
craft_metafile::Text {
transform: [1.0, 0.0, 0.0, 1.0, 0.0, 0.0],
text: "ab".into(),
dx,
font: craft_metafile::Font { family: "Arial".into(), height, ..Default::default() },
color: [0, 0, 0, 255],
background: Some([255, 255, 255, 255]),
h_align: craft_metafile::HAlign::Left,
v_align: craft_metafile::VAlign::Baseline,
clip: None,
region: None,
clips: Vec::new(),
}
}
/// A metafile font height of 0 is the file's default size: a 16-unit cell. A negative height is
/// the em size, and a positive one the cell (ascent plus descent, 1200 units of a 1000-unit em
/// here).
#[test]
fn metafile_text_heights() {
let glyphs = [(0, 500.0, 0.0, 0.0), (1, 500.0, 0.0, 0.0)];
let em = |h| crate::layout_metafile_text(&meta_text(h, Vec::new()), 1000.0, 900.0, 300.0, &glyphs).map(|l| l.em);
let near = |a: Option<f64>, b: f64| a.is_some_and(|a| (a - b).abs() < 1e-9);
assert!(near(em(0.0), 16.0 * 1000.0 / 1200.0), "{:?}", em(0.0));
assert!(near(em(-10.0), 10.0), "{:?}", em(-10.0));
assert!(near(em(24.0), 20.0), "a positive height is the cell: {:?}", em(24.0));
}
/// A cosmetic pen's dashes become whole output pixels (the shortest one pixel), a period under a
/// pixel draws solid, and so does a pattern that would split the path into too many pieces.
#[test]
fn metafile_dashes_follow_the_output_pixel() {
let cosmetic = crate::metafile_dashes(&[0.75, 0.25], true, 0.5, 100.0).unwrap_or_default();
assert!(cosmetic.len() == 2 && (cosmetic[0] - 1.5).abs() < 1e-6 && (cosmetic[1] - 0.5).abs() < 1e-6, "{cosmetic:?}");
assert_eq!(crate::metafile_dashes(&[3.0, 1.0], false, 0.5, 100.0), Some(vec![3.0, 1.0]));
assert_eq!(crate::metafile_dashes(&[0.2, 0.2], false, 0.5, 100.0), None, "a period under a pixel");
assert_eq!(crate::metafile_dashes(&[1.0, 1.0], false, 0.5, 1e6), None, "a million pieces");
assert_eq!(crate::metafile_dashes(&[1.0, -1.0], false, 0.5, 100.0), None, "a negative length");
assert_eq!(crate::metafile_dashes(&[0.0, 0.0], true, 0.5, 100.0), None, "no length at all");
}
/// A negative crop side is no crop; the others stay as they are.
#[test]
fn negative_crop_sides_are_no_crop() {
assert_eq!(crate::crop_sides([-0.5, 0.25, f32::NAN, 1.5]), [0.0, 0.25, 0.0, 1.5]);
assert_eq!(crate::crop_window([-0.5, 0.0, 0.0, 0.0]), [0.0, 0.0, 1.0, 1.0]);
}
/// The opaque background of a run whose advances move backward covers every pen position, not
/// only the run's total advance.
#[test]
fn metafile_text_cell_spans_backward_advances() {
let glyphs = [(0, 500.0, 0.0, 0.0), (1, 500.0, 0.0, 0.0)];
let lay = crate::layout_metafile_text(&meta_text(-10.0, vec![50.0, -40.0]), 1000.0, 800.0, 200.0, &glyphs).expect("a layout");
assert_eq!(lay.cell, [0.0, -8.0, 50.0, 2.0]);
}
+1 -1
View File
@@ -320,7 +320,7 @@ impl Exporter<'_> {
s.set_fill(None);
return;
};
let [cl, ct, vis_w, vis_h] = craft_metafile::crop_window(*crop).map(|v| v as f32);
let [cl, ct, vis_w, vis_h] = wordcraft_layout::crop_window(*crop).map(|v| v as f32);
let (fw, fh) = (rect.w / vis_w, rect.h / vis_h);
let Some(size) = Size::from_wh(fw.max(0.01), fh.max(0.01)) else { return };
let fade = alpha < 0.999;
+12 -3
View File
@@ -1,6 +1,6 @@
use super::{
Exporter, FaceRef, Fill, FillRule, KrillaGlyph, Point, Rgb, Stroke, Surface, Transform, baseline, cluster_ends, fill, glyph_id, glyph_outlines,
left_to_right, norm, ok, paint_of, rgb, split_clusters, visual_order,
Exporter, FaceRef, Fill, FillRule, KrillaGlyph, Point, Rect, Rgb, Stroke, Surface, Transform, baseline, cluster_ends, fill, glyph_id,
glyph_outlines, left_to_right, norm, ok, paint_of, rect_path, rgb, split_clusters, visual_order,
};
/// How a run of glyphs is painted: its colour, opacity and synthetic bold and italic.
@@ -181,7 +181,7 @@ impl Exporter<'_> {
}
/// Draws a metafile text run as PDF text (outlines when the font cannot be embedded). `tf` maps
/// the run's own space (see [`PlacedItem::Text`]) to the page.
/// its text space (`craft_metafile::Text::transform`) to the page.
pub(crate) fn vector_text(&mut self, s: &mut Surface, t: &craft_metafile::Text, tf: kurbo::Affine) {
let (face, shaped) = wordcraft_layout::metafile_text_run(t);
let glyphs: Vec<_> = shaped.iter().map(|g| (g.cluster, f64::from(g.x_advance), f64::from(g.x_offset), f64::from(g.y_offset))).collect();
@@ -198,6 +198,15 @@ impl Exporter<'_> {
let (paint, opacity) = paint_of(t.color);
s.push_transform(&Transform::from_row(c[0], c[1], c[2], c[3], c[4], c[5]));
s.set_stroke(None);
// An opaque background mode fills the character cells first.
if let Some(bg) = t.background {
let [x0, y0, x1, y1] = lay.cell.map(|v| v as f32);
if let Some(cell) = rect_path(&Rect { x: x0, y: y0, w: x1 - x0, h: y1 - y0 }) {
let (paint, opacity) = paint_of(bg);
s.set_fill(Some(Fill { paint: paint.into(), opacity, rule: FillRule::NonZero }));
s.draw_path(&cell);
}
}
s.set_fill(Some(Fill { paint: paint.into(), opacity, rule: FillRule::NonZero }));
match font {
Some(font) => {
+145 -26
View File
@@ -1,28 +1,51 @@
use super::exporter::Exporter;
use super::paint::{append_path, norm};
use super::{
Arc, Fill, FillRule, Image, LineCap, LineJoin, NormalizedF32, Path, PathBuilder, Picture, PlacedItem, Rect, Size, Stroke, Surface, Transform, rgb,
Arc, Fill, FillRule, Image, LineCap, LineJoin, NormalizedF32, Path, PathBuilder, Picture, PlacedItem, Rect, Size, Stroke, StrokeDash, Surface,
Transform, krilla, rgb,
};
use craft_metafile::Item;
use kurbo::Shape as _;
use wordcraft_doc::picfx::PicFx;
/// Largest picture side we embed (pixels).
const MAX_IMAGE_SIDE: u32 = 30_000;
/// A metafile picture, parsed once. The geometry comes placed by the metafile crate; the bitmaps are
/// embedded images, one per picture item (None for paths and undecodable bitmaps).
/// A metafile picture, parsed once. The geometry comes placed by the metafile crate; the bitmaps and
/// pattern tiles are embedded images, one per picture item (None for paths, text and undecodable
/// bitmaps). Fills that share a tile share its image. `averages` holds each pattern fill's tile
/// average color (transparent for other items), computed once a tile.
pub(crate) struct Vector {
pic: Picture,
images: Vec<Option<Image>>,
averages: Vec<[u8; 4]>,
}
/// Parses a metafile and embeds its bitmaps. None when the picture has no usable size.
/// Parses a metafile and embeds its bitmaps and pattern tiles. None when the picture has no usable
/// size.
pub(crate) fn build_vector(bytes: &[u8]) -> Option<Vector> {
let mut pic = craft_metafile::parse(bytes).ok()?;
if !pic.has_size() {
return None;
}
let images = pic.items.iter_mut().map(|it| it.take_pixels().map(|(w, h, px)| Image::from_rgba8(px, w, h))).collect();
Some(Vector { pic, images })
let mut tiles: std::collections::HashMap<usize, (Option<Image>, [u8; 4])> = std::collections::HashMap::new();
let (images, averages) = pic
.items
.iter_mut()
.map(|it| match it {
Item::Pattern { tile, .. } => tiles
.entry(Arc::as_ptr(tile) as usize)
.or_insert_with(|| {
let n = (tile.width as usize).saturating_mul(tile.height as usize).saturating_mul(4);
let img = (tile.width > 0 && tile.height > 0 && tile.rgba.len() == n)
.then(|| Image::from_rgba8(tile.rgba.clone(), tile.width, tile.height));
(img, wordcraft_layout::metafile_average_color(&tile.rgba))
})
.clone(),
_ => (it.take_pixels().map(|(w, h, px)| Image::from_rgba8(px, w, h)), [0; 4]),
})
.unzip();
Some(Vector { pic, images, averages })
}
/// A straight RGBA colour as a krilla colour and opacity.
@@ -36,9 +59,10 @@ pub(crate) fn paint_of(c: [u8; 4]) -> (rgb::Color, NormalizedF32) {
const HAIRLINE: f64 = 0.25;
/// Draws a metafile picture into the clip (the picture frame): paths are filled and stroked in page
/// space (strokes keep their width under non-uniform scaling), bitmaps stretched, all faded by `alpha`.
/// Every path sets its fill and stroke, so none carries over; strokes have round caps and joins. Text
/// runs are drawn as text.
/// space (strokes keep their width under non-uniform scaling), bitmaps stretched (or turned by their
/// transform), pattern fills tiled, each item inside its clip region and clip paths, all faded by
/// `alpha`. Every path sets its fill and stroke, so none carries over; strokes take the pen's caps,
/// joins and dashes. Text runs are drawn as text.
pub(crate) fn vector_picture(ex: &mut Exporter, s: &mut Surface, v: &Vector, r: &Rect, crop: &[f32; 4], clip: &Path, alpha: f32) {
let target = kurbo::Rect::new(f64::from(r.x), f64::from(r.y), f64::from(r.x + r.w), f64::from(r.y + r.h));
let fade = alpha < 0.999;
@@ -46,9 +70,9 @@ pub(crate) fn vector_picture(ex: &mut Exporter, s: &mut Surface, v: &Vector, r:
s.push_opacity(norm(alpha));
}
s.push_clip_path(clip, &FillRule::NonZero);
for it in v.pic.place(target, *crop) {
for it in v.pic.place(target, wordcraft_layout::crop_sides(*crop)) {
match it {
PlacedItem::Path { path, fill, stroke, even_odd, .. } => {
PlacedItem::Path { path, fill, stroke, line, even_odd, region, clips } => {
let Some(p) = path_from(&path) else { continue };
let fill = fill.map(|c| {
let (paint, opacity) = paint_of(c);
@@ -57,31 +81,63 @@ pub(crate) fn vector_picture(ex: &mut Exporter, s: &mut Surface, v: &Vector, r:
});
let stroke = stroke.map(|(c, w)| {
let (paint, opacity) = paint_of(c);
Stroke {
paint: paint.into(),
width: w.max(HAIRLINE) as f32,
opacity,
line_cap: LineCap::Round,
line_join: LineJoin::Round,
..Default::default()
}
pen(paint.into(), opacity, w, &line, &path)
});
let Some(n) = push_clips(s, region.as_deref(), &clips) else { continue };
s.set_fill(fill);
s.set_stroke(stroke);
s.draw_path(&p);
pop_clips(s, n);
}
PlacedItem::Bitmap { index, rect, .. } => {
PlacedItem::Bitmap { index, rect, transform, region, clips } => {
let Some(Some(img)) = v.images.get(index) else { continue };
let Some(size) = Size::from_wh(rect.width() as f32, rect.height() as f32) else { continue };
s.push_transform(&Transform::from_translate(rect.x0 as f32, rect.y0 as f32));
let c = transform.as_coeffs();
// Upright and not mirrored: the bitmap fills `rect`.
let upright = c[1] == 0.0 && c[2] == 0.0 && c[0] > 0.0 && c[3] > 0.0;
let (tf, size) = if upright {
(Transform::from_translate(rect.x0 as f32, rect.y0 as f32), Size::from_wh(rect.width() as f32, rect.height() as f32))
} else {
// A turned, skewed or mirrored bitmap: `transform` maps the unit square onto its place.
let c = c.map(|v| v as f32);
(Transform::from_row(c[0], c[1], c[2], c[3], c[4], c[5]), Size::from_wh(1.0, 1.0))
};
let Some(size) = size else { continue };
let Some(n) = push_clips(s, region.as_deref(), &clips) else { continue };
s.push_transform(&tf);
s.draw_image(img.clone(), size);
s.pop();
pop_clips(s, n);
}
PlacedItem::Pattern { .. } => {}
PlacedItem::Text { index, transform, .. } => {
if let Some(craft_metafile::Item::Text(t)) = v.pic.items.get(index) {
ex.vector_text(s, t, transform);
PlacedItem::Pattern { index, path, even_odd, tile, region, clips } => {
let Some(p) = path_from(&path) else { continue };
let Some(craft_metafile::Item::Pattern { tile: t, .. }) = v.pic.items.get(index) else { continue };
let rule = if even_odd { FillRule::EvenOdd } else { FillRule::NonZero };
let paint = match v.images.get(index) {
Some(Some(img)) => tile_pattern(s, img, t.width, t.height, tile).map(|p| (p.into(), norm(1.0))),
_ => None,
};
let (paint, opacity) = paint.unwrap_or_else(|| {
let (c, o) = paint_of(v.averages.get(index).copied().unwrap_or([0; 4]));
(c.into(), o)
});
let Some(n) = push_clips(s, region.as_deref(), &clips) else { continue };
s.set_fill(Some(Fill { paint, opacity, rule }));
s.set_stroke(None);
s.draw_path(&p);
pop_clips(s, n);
}
PlacedItem::Text { index, transform, clip, region, clips } => {
let Some(craft_metafile::Item::Text(t)) = v.pic.items.get(index) else { continue };
let Some(n) = push_clips(s, region.as_deref(), &clips) else { continue };
let text_clip = clip.and_then(|c| path_from(&c.to_path(0.1)));
if let Some(c) = &text_clip {
s.push_clip_path(c, &FillRule::NonZero);
}
ex.vector_text(s, t, transform);
if text_clip.is_some() {
s.pop();
}
pop_clips(s, n);
}
}
}
@@ -93,6 +149,69 @@ pub(crate) fn vector_picture(ex: &mut Exporter, s: &mut Surface, v: &Vector, r:
}
}
/// Pushes a metafile item's clip region and clip paths; pop them with [`pop_clips`] and the count
/// returned. None (nothing pushed) when a clip has no area to draw in.
fn push_clips(s: &mut Surface, region: Option<&kurbo::BezPath>, clips: &[Arc<craft_metafile::PlacedClip>]) -> Option<usize> {
let mut paths = Vec::with_capacity(clips.len() + 1);
if let Some(region) = region {
paths.push((path_from(region)?, FillRule::NonZero));
}
for c in clips {
paths.push((path_from(&c.path)?, if c.even_odd { FillRule::EvenOdd } else { FillRule::NonZero }));
}
for (p, rule) in &paths {
s.push_clip_path(p, rule);
}
Some(paths.len())
}
fn pop_clips(s: &mut Surface, n: usize) {
for _ in 0..n {
s.pop();
}
}
/// A metafile pen for `path`: `width` (points, at least [`HAIRLINE`]), the pen's caps, joins,
/// miter limit and dashes (`wordcraft_layout::metafile_dashes`, with the hairline as the pixel).
fn pen(paint: krilla::paint::Paint, opacity: NormalizedF32, width: f64, line: &craft_metafile::LineStyle, path: &kurbo::BezPath) -> Stroke {
let line_cap = match line.cap {
craft_metafile::Cap::Round => LineCap::Round,
craft_metafile::Cap::Square => LineCap::Square,
craft_metafile::Cap::Flat => LineCap::Butt,
};
let line_join = match line.join {
craft_metafile::Join::Round => LineJoin::Round,
craft_metafile::Join::Bevel => LineJoin::Bevel,
craft_metafile::Join::Miter => LineJoin::Miter,
};
let dash = if line.dash.is_empty() { None } else { wordcraft_layout::metafile_dashes(&line.dash, width == 0.0, HAIRLINE, path.perimeter(1.0)) };
Stroke {
paint,
width: width.max(HAIRLINE) as f32,
miter_limit: wordcraft_layout::metafile_miter_limit(line.miter_limit),
line_cap,
line_join,
opacity,
dash: dash.map(|d| StrokeDash { array: d.iter().map(|v| *v as f32).collect(), offset: 0.0 }),
}
}
/// A tiling pattern of `img` (`w` × `h` pixels); `tile` maps tile pixels to page space. None when
/// the mapping is not finite.
fn tile_pattern(s: &mut Surface, img: &Image, w: u32, h: u32, tile: kurbo::Affine) -> Option<krilla::paint::Pattern> {
let c = tile.as_coeffs().map(|v| v as f32);
if !c.iter().all(|v| v.is_finite()) {
return None;
}
let size = Size::from_wh(w as f32, h as f32)?;
let mut sb = s.stream_builder();
let mut ps = sb.surface();
ps.draw_image(img.clone(), size);
ps.finish();
let stream = sb.finish();
Some(krilla::paint::Pattern { stream, transform: Transform::from_row(c[0], c[1], c[2], c[3], c[4], c[5]), width: w as f32, height: h as f32 })
}
/// A kurbo path as a krilla path (None when empty).
fn path_from(b: &kurbo::BezPath) -> Option<Path> {
let mut pb = PathBuilder::new();
+250
View File
@@ -1305,6 +1305,211 @@ fn emf_rec(typ: u32, fields: &[i32]) -> Vec<u8> {
v
}
/// The PDF of a document holding one 70 pt metafile picture, uncompressed.
fn metafile_pdf(emf: Vec<u8>) -> String {
String::from_utf8_lossy(&metafile_pdf_bytes(emf)).into_owned()
}
fn metafile_pdf_bytes(emf: Vec<u8>) -> Vec<u8> {
export(&metafile_doc(emf), &PdfOptions { compress: false, tagged: false, ..Default::default() }).unwrap()
}
/// The uncompressed PDF of a document holding one 70 pt metafile picture, and the picture's box
/// on the first page in PDF space (points, y up).
fn metafile_pdf_and_box(emf: Vec<u8>) -> (Vec<u8>, kurbo::Rect) {
let d = metafile_doc(emf);
let bytes = export(&d, &PdfOptions { compress: false, tagged: false, ..Default::default() }).unwrap();
let lay = layout(&d, &mut LayoutCache::new(), &LayoutOptions::default());
let page = &lay.pages[0];
let h = f64::from(page.h);
let r = wordcraft_layout::display::page_display(&d, page, &DisplayOptions::default())
.into_iter()
.find_map(|item| if let Draw::Image { rect, .. } = item { Some(rect) } else { None })
.expect("the picture is laid out");
let (x, y, w, ph) = (f64::from(r.x), f64::from(r.y), f64::from(r.w), f64::from(r.h));
(bytes, kurbo::Rect::new(x, h - y - ph, x + w, h - y))
}
/// The right half of a box.
fn right_half(r: kurbo::Rect) -> kurbo::Rect {
kurbo::Rect::new((r.x0 + r.x1) / 2.0, r.y0, r.x1, r.y1)
}
/// Whether two boxes have the same edges, to within half a point.
fn same_box(a: kurbo::Rect, b: kurbo::Rect) -> bool {
[a.x0 - b.x0, a.y0 - b.y0, a.x1 - b.x1, a.y1 - b.y1].iter().all(|d| d.abs() < 0.5)
}
fn metafile_doc(emf: Vec<u8>) -> Document {
let mut d = Document::new();
let media = d.add_media(emf, "emf");
let mut p = Paragraph::with_text("Figure: ", CharProps::default());
let n = p.len();
p.insert_object(
n,
InlineObject::Image {
media,
w: 70.0,
h: 70.0,
alt: String::new(),
float: Default::default(),
crop: [0.0; 4],
fx: Default::default(),
ole: None,
},
&CharProps::default(),
)
.unwrap();
d.body = vec![para_block(p)];
d
}
/// #6636: an EMF+ only file whose EmfPlusDrawImage draws a 32bppPARGB bitmap: the bitmap is
/// embedded as an image, and the page draws it into the EmfPlusDrawImage rectangle.
#[test]
fn emf_plus_only_bitmap_is_embedded() {
let plus_rec = |typ: u16, flags: u16, data: &[u8]| {
let mut v = typ.to_le_bytes().to_vec();
v.extend(flags.to_le_bytes());
v.extend(((12 + data.len()) as u32).to_le_bytes());
v.extend((data.len() as u32).to_le_bytes());
v.extend(data);
v
};
let le32 = |vals: &[i32]| -> Vec<u8> { vals.iter().flat_map(|v| v.to_le_bytes()).collect() };
let header = plus_rec(0x4001, 0, &le32(&[0xDBC0_1002_u32 as i32, 1, 96, 96]));
let mut image = le32(&[0xDBC0_1002_u32 as i32, 1, 2, 2, 8, 0x000E_200B, 0]);
image.extend([0u8, 0, 255, 255].repeat(4));
let object = plus_rec(0x4008, 0x0500, &image);
let mut draw = le32(&[-1, 2]);
draw.extend([0.0f32, 0.0, 2.0, 2.0, 50.0, 0.0, 50.0, 100.0].iter().flat_map(|v| v.to_le_bytes()));
let draw = plus_rec(0x401A, 0, &draw);
let mut comment = 0x2B46_4D45u32.to_le_bytes().to_vec();
comment.extend([header, object, draw, plus_rec(0x4002, 0, &[])].concat());
let mut rec = 70u32.to_le_bytes().to_vec();
rec.extend(((12 + comment.len()) as u32).to_le_bytes());
rec.extend((comment.len() as u32).to_le_bytes());
rec.extend(comment);
let (bytes, pic) = metafile_pdf_and_box(emf_file(&[rec, emf_rec(14, &[0; 3])]));
let images = pdf_images(&bytes);
assert!(images.iter().any(|(w, h, ..)| (*w, *h) == (2, 2)), "the 2 × 2 bitmap is embedded");
let drawn = pdf_drawn_images(&bytes);
assert!(
drawn.iter().any(|&(w, h, r)| (w, h) == (2, 2) && same_box(r, right_half(pic))),
"the page draws the bitmap over the right half of the picture at {pic:?}: {drawn:?}"
);
assert!(!String::from_utf8_lossy(&bytes).contains("0.8156"), "the gray placeholder box is not drawn");
}
/// #6636: an EMF+ only file whose EmfPlusDrawImage draws a bitmap in PixelFormat32bppARGB,
/// 24bppRGB or 32bppRGB, or a compressed PNG or JPEG bitmap: the bitmap is embedded as an image,
/// and the page draws it into the EmfPlusDrawImage rectangle.
#[test]
fn emf_plus_only_bitmap_formats_are_embedded() {
let plus_rec = |typ: u16, flags: u16, data: &[u8]| {
let mut v = typ.to_le_bytes().to_vec();
v.extend(flags.to_le_bytes());
v.extend(((12 + data.len()) as u32).to_le_bytes());
v.extend((data.len() as u32).to_le_bytes());
v.extend(data);
v
};
let le32 = |vals: &[i32]| -> Vec<u8> { vals.iter().flat_map(|v| v.to_le_bytes()).collect() };
let encoded = |png: bool| {
let red = [255u8, 0, 0].repeat(15);
if png {
let img = image::RgbImage::from_raw(5, 3, red).unwrap();
wordcraft_geom::picture::encode_png(&image::DynamicImage::from(img)).unwrap()
} else {
wordcraft_geom::picture::encode_jpeg(&red, 5, 3, 100).unwrap()
}
};
// Name, width, height, stride, pixel format, bitmap type (0 pixels, 1 compressed) and data.
let cases: [(&str, i32, i32, i32, u32, i32, Vec<u8>); 5] = [
("32bppARGB", 2, 2, 8, 0x0026_200A, 0, [0u8, 0, 255, 255].repeat(4)),
("24bppRGB", 2, 2, 8, 0x0002_1808, 0, [0u8, 0, 255, 0, 0, 255, 0, 0].repeat(2)),
("32bppRGB", 2, 2, 8, 0x0002_2009, 0, [0u8, 0, 255, 0].repeat(4)),
("PNG", 5, 3, 0, 0, 1, encoded(true)),
("JPEG", 5, 3, 0, 0, 1, encoded(false)),
];
for (name, w, h, stride, format, kind, data) in cases {
let header = plus_rec(0x4001, 0, &le32(&[0xDBC0_1002_u32 as i32, 1, 96, 96]));
let mut image = le32(&[0xDBC0_1002_u32 as i32, 1, w, h, stride, format as i32, kind]);
image.extend(data);
// Records are a multiple of 4 bytes long.
image.resize(image.len().next_multiple_of(4), 0);
let object = plus_rec(0x4008, 0x0500, &image);
let mut draw = le32(&[-1, 2]);
draw.extend([0.0f32, 0.0, w as f32, h as f32, 50.0, 0.0, 50.0, 100.0].iter().flat_map(|v| v.to_le_bytes()));
let draw = plus_rec(0x401A, 0, &draw);
let mut comment = 0x2B46_4D45u32.to_le_bytes().to_vec();
comment.extend([header, object, draw, plus_rec(0x4002, 0, &[])].concat());
let mut rec = 70u32.to_le_bytes().to_vec();
rec.extend(((12 + comment.len()) as u32).to_le_bytes());
rec.extend((comment.len() as u32).to_le_bytes());
rec.extend(comment);
let (bytes, pic) = metafile_pdf_and_box(emf_file(&[rec, emf_rec(14, &[0; 3])]));
let images = pdf_images(&bytes);
assert!(images.iter().any(|(iw, ih, ..)| (*iw, *ih) == (w as u32, h as u32)), "{name}: the {w} × {h} bitmap is embedded");
let drawn = pdf_drawn_images(&bytes);
assert!(
drawn.iter().any(|&(iw, ih, r)| (iw, ih) == (w as u32, h as u32) && same_box(r, right_half(pic))),
"{name}: the page draws the bitmap over the right half of the picture at {pic:?}: {drawn:?}"
);
assert!(!String::from_utf8_lossy(&bytes).contains("0.8156"), "{name}: the gray placeholder box is not drawn");
}
}
/// A dotted cosmetic pen (CREATEPEN, PS_DOT, width 0) draws hairline dots: its dashes and gaps are
/// the hairline's width, not the file's device units scaled to the frame (0.7 pt here).
#[test]
fn metafile_cosmetic_dotted_pen_draws_hairline_dots() {
let recs = [emf_rec(38, &[1, 2, 0, 0, 0]), emf_rec(37, &[1]), emf_rec(27, &[0, 50]), emf_rec(54, &[100, 50]), emf_rec(14, &[0; 3])];
let raw = metafile_pdf(emf_file(&recs));
assert!(raw.contains("[0.25 0.25]0 d"), "the dots are hairline-sized");
}
/// A geometric PS_USERSTYLE pen whose dashes and gaps are far below the hairline draws its line
/// solid: no dash array is written.
#[test]
fn metafile_sub_pixel_dashes_draw_solid() {
let mut emf = emf_file(&[]);
// 10,000 device pixels over 250 mm: a device unit is 0.025 mm. The picture is 1000 units wide.
let le32 = |vals: &[i32]| -> Vec<u8> { vals.iter().flat_map(|v| v.to_le_bytes()).collect() };
emf[8..24].copy_from_slice(&le32(&[0, 0, 1000, 1000]));
emf[72..80].copy_from_slice(&le32(&[10_000, 10_000]));
let pen = emf_rec(95, &[1, 0, 0, 0, 0, 0x0001_0207, 80, 0, 0, 0, 2, 1, 1]);
let recs = [pen, emf_rec(37, &[1]), emf_rec(27, &[0, 500]), emf_rec(54, &[1000, 500]), emf_rec(14, &[0; 3])];
emf.extend(recs.concat());
let raw = metafile_pdf(emf);
assert!(raw.contains(" w ") && !raw.contains("]0 d"), "a stroke with no dash array");
}
/// A clip region (INTERSECTCLIPRECT) adds a clip around the rectangle it clips.
#[test]
fn metafile_clip_region_is_a_clip() {
let clips = |raw: &str| raw.matches("\nW\nn").count() + raw.matches("\nW*\nn").count();
let draw = |clip: bool| {
let mut recs = vec![emf_rec(39, &[1, 0, 0x0000_00FF, 0]), emf_rec(37, &[1])];
if clip {
recs.push(emf_rec(30, &[0, 0, 50, 100]));
}
recs.extend([emf_rec(43, &[0, 0, 100, 100]), emf_rec(14, &[0; 3])]);
metafile_pdf(emf_file(&recs))
};
let (with, without) = (clips(&draw(true)), clips(&draw(false)));
assert!(without > 0 && with == without + 1, "one clip more with the region: {with} and {without}");
}
/// A hatched brush (CREATEBRUSHINDIRECT, BS_HATCHED) fills through a tiling pattern, not with a
/// solid color.
#[test]
fn metafile_hatch_brush_is_a_tiling_pattern() {
let recs = [emf_rec(39, &[1, 2, 0x0000_00FF, 1]), emf_rec(37, &[1]), emf_rec(43, &[0, 0, 100, 100]), emf_rec(14, &[0; 3])];
let raw = metafile_pdf(emf_file(&recs));
assert!(raw.contains("/PatternType 1"), "the hatch is a tiling pattern");
}
#[test]
fn metafile_strokes_use_round_caps_and_joins() {
// A 4-unit black pen (handle 1) outlines a rectangle, so the stroke is drawn with round caps and joins.
@@ -1425,6 +1630,17 @@ fn emf_text_records(text: &str) -> Vec<Vec<u8>> {
vec![font, emf_rec(37, &[1]), emf_rec(24, &[0]), out]
}
/// With the opaque background mode (the default) and a red background color (SETBKCOLOR), a text
/// run's character cells are filled red behind the text.
#[test]
fn metafile_text_fills_its_opaque_background() {
let mut recs = vec![emf_rec(25, &[0x0000_00FF])];
recs.extend(emf_text_records("Hi"));
recs.push(emf_rec(14, &[0; 3]));
let raw = metafile_pdf(emf_file(&recs));
assert!(raw.contains("1 0 0 rg"), "the character cells are filled red");
}
/// #1764: the text of an EMF picture (EXTTEXTOUTW) is drawn, so it is in the PDF's text layer.
#[test]
fn metafile_text_records_are_drawn_as_text() {
@@ -2159,6 +2375,40 @@ fn pdf_images(bytes: &[u8]) -> Vec<(u32, u32, Vec<String>, Vec<Vec<u8>>)> {
out
}
/// The images the pages draw, through hayro's interpreter: pixel width and height, and the box each
/// one is drawn into, in PDF space (points, y up).
fn pdf_drawn_images(bytes: &[u8]) -> Vec<(u32, u32, kurbo::Rect)> {
use hayro_interpret::font::Glyph;
use hayro_interpret::{
BlendMode, ClipPath, Context, Device, GlyphDrawMode, Image, InterpreterCache, InterpreterSettings, Paint, PathDrawMode, SoftMask,
interpret_page,
};
struct Ex(Vec<(u32, u32, kurbo::Rect)>);
impl Device<'_> for Ex {
fn set_soft_mask(&mut self, _: Option<SoftMask<'_>>) {}
fn set_blend_mode(&mut self, _: BlendMode) {}
fn draw_path(&mut self, _: &kurbo::BezPath, _: kurbo::Affine, _: &Paint<'_>, _: &PathDrawMode) {}
fn push_clip_path(&mut self, _: &ClipPath) {}
fn push_transparency_group(&mut self, _: f32, _: Option<SoftMask<'_>>, _: BlendMode) {}
fn draw_glyph(&mut self, _: &Glyph<'_>, _: kurbo::Affine, _: kurbo::Affine, _: &Paint<'_>, _: &GlyphDrawMode) {}
fn draw_image(&mut self, image: Image<'_, '_>, t: kurbo::Affine) {
// The transform maps the image's pixel grid onto the page.
let (w, h) = (image.width(), image.height());
self.0.push((w, h, t.transform_rect_bbox(kurbo::Rect::new(0.0, 0.0, f64::from(w), f64::from(h)))));
}
fn pop_clip_path(&mut self) {}
fn pop_transparency_group(&mut self) {}
}
let pdf = hayro_syntax::Pdf::new(bytes.to_vec()).expect("parse");
let cache = InterpreterCache::new();
let mut ex = Ex(Vec::new());
for page in pdf.pages().iter() {
let mut ctx = Context::new(kurbo::Affine::IDENTITY, kurbo::Rect::new(0.0, 0.0, 1.0, 1.0), &cache, pdf.xref(), InterpreterSettings::default());
interpret_page(page, &mut ctx, &mut ex);
}
ex.0
}
/// The fill opacities (`ca`) of the PDF's graphics states.
fn pdf_fill_opacities(bytes: &[u8]) -> Vec<f32> {
use hayro_syntax::object::Object;
+33 -2
View File
@@ -703,12 +703,43 @@ fn draw_line(ctx: &mut RenderContext, fr: &Frame, it: &Draw) {
stroke_segment(ctx, (x0, y0, x1, y1), (-nx, -ny));
}
_ => {
let (st, off) = match snap_rule(fr.view, (x0, y0, x1, y1), w) {
Some((w_px, off)) => (kurbo::Stroke { width: w_px / fr.view.as_coeffs()[0], ..st }, off),
None => (st, (0.0, 0.0)),
};
ctx.set_stroke(st);
stroke_segment(ctx, (x0, y0, x1, y1), (0.0, 0.0));
stroke_segment(ctx, (x0, y0, x1, y1), off);
}
}
}
/// Snap a horizontal or vertical rule to the device pixel grid so every border of one nominal
/// width covers the same number of pixels at any zoom (#5967). Returns the stroke width in device
/// pixels and the offset, in points, that moves the line onto the snapped spot; `None` for slanted
/// lines or a view that rotates or skews.
fn snap_rule(view: Affine, (x0, y0, x1, y1): (f64, f64, f64, f64), width: f64) -> Option<(f64, (f64, f64))> {
if !is_upright(view) {
return None;
}
let [k, _, _, _, tx, ty] = view.as_coeffs();
if y0 == y1 && x0 != x1 {
let (w_px, c) = snap_hairline(y0 * k + ty, width * k);
Some((w_px, (0.0, (c - ty) / k - y0)))
} else if x0 == x1 && y0 != y1 {
let (w_px, c) = snap_hairline(x0 * k + tx, width * k);
Some((w_px, ((c - tx) / k - x0, 0.0)))
} else {
None
}
}
/// A line `width_px` wide centred at device coordinate `centre`, moved so both edges fall on whole
/// pixels. Returns the width, made a whole number of pixels (at least one), and the new centre.
fn snap_hairline(centre: f64, width_px: f64) -> (f64, f64) {
let w = width_px.round().max(1.0);
(w, (centre - w / 2.0).round() + w / 2.0)
}
/// Stroke the line from (`x0`, `y0`) to (`x1`, `y1`), moved by (`ox`, `oy`).
fn stroke_segment(ctx: &mut RenderContext, (x0, y0, x1, y1): (f64, f64, f64, f64), (ox, oy): (f64, f64)) {
let mut p = BezPath::new();
@@ -856,7 +887,7 @@ fn draw_image(ctx: &mut RenderContext, fr: &Frame, it: &Draw) {
return;
};
let (pw, ph) = (pm.width().max(1) as f64, pm.height().max(1) as f64);
let [cl, ct, vis_w, vis_h] = craft_metafile::crop_window(*crop);
let [cl, ct, vis_w, vis_h] = wordcraft_layout::crop_window(*crop);
let sx = r.width() / (pw * vis_w);
let sy = r.height() / (ph * vis_h);
ctx.set_transform(view);
+255 -37
View File
@@ -1,4 +1,6 @@
use super::{Affine, Arc, Document, FontDb, HashMap, Item, Mutex, Page, Picture, Pixmap, PlacedItem, RenderContext, Seg, Shape, Weak, kurbo, peniko};
use craft_metafile::{ClipPath, Tile};
use std::collections::HashSet;
/// Upper bound on the bytes the two decoded-media caches keep together (about 256 MB), half each;
/// past its half a cache starts over.
@@ -140,29 +142,70 @@ pub fn metafile_size(bytes: &[u8]) -> Option<(f32, f32, &'static str)> {
Some((w * k, h * k, ext))
}
/// A metafile (WMF/EMF) picture, parsed once. The geometry comes placed by the metafile crate; the
/// bitmaps are pixmaps, one per picture item (None for paths and undecodable bitmaps).
/// A metafile (WMF/EMF/EMF+) picture, parsed once. The geometry comes placed by the metafile crate;
/// the bitmaps and pattern tiles are pixmaps, one per picture item (None for paths, text and
/// undecodable bitmaps). Fills that share a tile share its pixmap. `averages` holds each pattern
/// fill's tile average color (transparent for other items), computed once a tile.
pub(crate) struct Vector {
pic: Picture,
pixmaps: Vec<Option<Arc<Pixmap>>>,
averages: Vec<[u8; 4]>,
}
impl Vector {
/// Approximate memory held: pixels and path segments.
fn bytes(&self) -> usize {
let px: usize = self.pixmaps.iter().flatten().map(|p| p.width() as usize * p.height() as usize * 4).sum();
let segs: usize = self
.pic
.items
/// Approximate memory held: pixels (a tile shared by several fills once), path segments and the
/// per-item bookkeeping.
pub(crate) fn bytes(&self) -> usize {
let mut seen: HashSet<*const Pixmap> = HashSet::new();
let px: usize = self.pixmaps.iter().flatten().filter(|p| seen.insert(Arc::as_ptr(p))).map(|p| bitmap_bytes(p)).sum();
px.saturating_add(self.averages.capacity() * 4).saturating_add(geometry_bytes(&self.pic))
}
}
/// Memory held by one decoded bitmap: its pixels plus the pixmap and its `Arc` header.
fn bitmap_bytes(p: &Pixmap) -> usize {
usize::from(p.width()) * usize::from(p.height()) * 4 + std::mem::size_of::<Pixmap>() + 2 * std::mem::size_of::<usize>()
}
/// Approximate memory held by a picture's items: path segments and text (charged by capacity, as a
/// parsed vector keeps its growth slack), the item itself (a bitmap
/// item stays in the list after its pixels move out), a path's dash array, a text's boxed record and
/// font name, the pixmap slot kept for it, a pattern's path
/// and tile, and every item's clip rectangles and clip paths. Tiles and clip paths are shared between
/// the items that use them, so each is charged once.
pub(crate) fn geometry_bytes(pic: &Picture) -> usize {
let slot = std::mem::size_of::<Option<Arc<Pixmap>>>();
let seg = std::mem::size_of::<Seg>();
let mut tiles: HashSet<*const Tile> = HashSet::new();
let mut clip_paths: HashSet<*const ClipPath> = HashSet::new();
let mut total = 0usize;
for it in &pic.items {
let (region, clips): (&Option<Vec<[f32; 4]>>, &[Arc<ClipPath>]) = match it {
Item::Path { region, clips, .. } | Item::Bitmap { region, clips, .. } | Item::Pattern { region, clips, .. } => (region, clips),
Item::Text(t) => (&t.region, &t.clips),
};
let own = match it {
Item::Path { segs, line, .. } => (segs.capacity() * seg).saturating_add(line.dash.capacity() * std::mem::size_of::<f32>()),
Item::Bitmap { .. } => 0,
Item::Pattern { segs, tile, .. } => {
let tile_bytes = if tiles.insert(Arc::as_ptr(tile)) { tile.rgba.len().saturating_add(std::mem::size_of::<Tile>()) } else { 0 };
(segs.capacity() * seg).saturating_add(tile_bytes)
}
Item::Text(t) => {
std::mem::size_of::<craft_metafile::Text>() + t.text.len() + t.dx.len() * std::mem::size_of::<f32>() + t.font.family.len()
}
};
let region_bytes = region.as_ref().map_or(0, |r| r.len() * std::mem::size_of::<[f32; 4]>());
let clip_bytes: usize = clips
.iter()
.map(|it| match it {
Item::Path { segs, .. } => segs.len() * std::mem::size_of::<Seg>(),
Item::Bitmap { .. } | Item::Pattern { .. } => 0,
Item::Text(t) => t.text.len() + t.dx.len() * 4,
.map(|c| {
let arc = std::mem::size_of::<usize>() * 2 + std::mem::size_of::<Arc<ClipPath>>();
if clip_paths.insert(Arc::as_ptr(c)) { arc + std::mem::size_of::<ClipPath>() + c.segs.capacity() * seg } else { arc }
})
.sum();
px + segs
total = total.saturating_add(slot + std::mem::size_of::<Item>()).saturating_add(own).saturating_add(region_bytes).saturating_add(clip_bytes);
}
total
}
/// The metafile picture for a media key. None when the bytes are not a metafile or do not parse, so
@@ -184,25 +227,94 @@ pub(crate) fn vector_for(doc: &Document, key: &str) -> Option<Arc<Vector>> {
v
}
/// Parses a metafile and decodes its bitmaps. None when the picture has no usable size.
fn build_vector(bytes: &[u8]) -> Option<Vector> {
/// Parses a metafile and decodes its bitmaps and pattern tiles. None when the picture has no
/// usable size.
pub(crate) fn build_vector(bytes: &[u8]) -> Option<Vector> {
let mut pic = craft_metafile::parse(bytes).ok()?;
if !pic.has_size() {
return None;
}
// The pixels move into the pixmaps; the picture keeps only the geometry.
let pixmaps = pic.items.iter_mut().map(|it| it.take_pixels().and_then(|(w, h, px)| premul_pixmap(w, h, &px)).map(Arc::new)).collect();
Some(Vector { pic, pixmaps })
// The pixels move into the pixmaps; the picture keeps only the geometry. A tile shared by
// several fills is converted and averaged once. Only the bitmaps are fitted to the cache: a
// tile is small and stays as it is, but counts against the budget.
let mut tiles: HashMap<usize, (Option<Arc<Pixmap>>, [u8; 4])> = HashMap::new();
let mut tile_bytes = 0usize;
let mut bitmaps: Vec<Option<Pixmap>> = Vec::with_capacity(pic.items.len());
let mut averages: Vec<[u8; 4]> = Vec::with_capacity(pic.items.len());
let mut patterns: Vec<Option<Arc<Pixmap>>> = Vec::with_capacity(pic.items.len());
for it in pic.items.iter_mut() {
if let Item::Pattern { tile, .. } = it {
let key = Arc::as_ptr(tile) as usize;
let fresh = !tiles.contains_key(&key);
let (pm, avg) = tiles
.entry(key)
.or_insert_with(|| {
(premul_pixmap(tile.width, tile.height, &tile.rgba).map(Arc::new), wordcraft_layout::metafile_average_color(&tile.rgba))
})
.clone();
if fresh {
tile_bytes = tile_bytes.saturating_add(pm.as_ref().map_or(0, |p| bitmap_bytes(p)));
}
bitmaps.push(None);
patterns.push(pm);
averages.push(avg);
} else {
bitmaps.push(it.take_pixels().and_then(|(w, h, px)| premul_pixmap(w, h, &px)));
patterns.push(None);
averages.push([0; 4]);
}
}
let bitmaps = fit_cache(bitmaps, geometry_bytes(&pic).saturating_add(tile_bytes));
let pixmaps = bitmaps.into_iter().zip(patterns).map(|(b, t)| b.map(Arc::new).or(t)).collect();
Some(Vector { pic, pixmaps, averages })
}
/// The bitmaps of a metafile at a size its whole picture is kept in the cache. When geometry and
/// bitmaps together are past the cache budget (a metafile with a 6000 x 6000 bitmap is 144 MB), the
/// cache would refuse the picture and every repaint would parse and decode the file again, so the
/// bitmaps are box-averaged down to an eighth of the budget between them, in proportion to their
/// size, as large raster pictures are (#3665, which uses half). An eighth because the cache starts
/// over when full: several huge pictures on screen together must fit side by side, and not clear
/// the small ones with them. Geometry that is itself an eighth or more still leaves the bitmaps a
/// sixteenth, as long as the whole budget has room for it. A picture that still cannot fit after shrinking stays uncached,
/// as before. Pictures within the budget keep their full resolution. Printing (`render_page`) draws
/// the shrunk bitmaps too, as it does large raster pictures; PDF export parses the metafile itself
/// and is unaffected.
pub(crate) fn fit_cache(mut pixmaps: Vec<Option<Pixmap>>, geometry: usize) -> Vec<Option<Pixmap>> {
let pixels = |p: &Pixmap| usize::from(p.width()) * usize::from(p.height()) * 4;
let total: usize = pixmaps.iter().flatten().map(pixels).sum();
let fixed: usize = pixmaps.iter().flatten().map(|p| bitmap_bytes(p) - pixels(p)).sum();
if total.saturating_add(fixed).saturating_add(geometry) <= CACHE_BYTES {
return pixmaps;
}
// The bitmaps get what is left of an eighth, but never less than a sixteenth (so the allowance does
// not drop to nothing as geometry reaches the eighth) and never more than the whole budget leaves.
let target = CACHE_BYTES / 8;
let allowance = target.saturating_sub(geometry).max(target / 2).min(CACHE_BYTES.saturating_sub(geometry));
let room = allowance.saturating_sub(fixed) / 4;
for pm in pixmaps.iter_mut().flatten() {
// This bitmap's share of the pixels that fit.
let share = (room as u128 * pixels(pm) as u128 / total.max(1) as u128) as u64;
if let Some(small) = shrink(pm, share) {
*pm = small;
}
}
pixmaps
}
fn rgba_color(c: [u8; 4]) -> peniko::Color {
peniko::Color::from_rgba8(c[0], c[1], c[2], c[3])
}
/// Pattern tiles smaller than this (device pixels on both sides) are drawn as the tile's average
/// color: a sub-pixel pattern would only alias.
const MIN_TILE_PX: f64 = 1.5;
/// Draws a metafile picture into `r` (page points): fills and strokes in page space (so strokes keep
/// their width under non-uniform scaling), bitmaps stretched, all clipped to `r` and faded by `alpha`.
/// Strokes have round caps and joins, as GDI draws them, and are at least one device pixel wide, so
/// cosmetic (width 0) pens show as hairlines at any zoom.
/// their width under non-uniform scaling), bitmaps stretched (or turned by their transform),
/// pattern fills tiled, each item inside its clip region and clip paths, all clipped to `r` and
/// faded by `alpha`. Strokes take the pen's caps, joins and dashes and are at least one device
/// pixel wide, so cosmetic (width 0) pens show as hairlines at any zoom.
pub(crate) fn draw_vector(ctx: &mut RenderContext, v: &Vector, r: &kurbo::Rect, crop: &[f32; 4], alpha: f32, view: Affine) {
ctx.set_transform(view);
let alpha = if alpha.is_finite() { alpha.clamp(0.0, 1.0) } else { 1.0 };
@@ -212,9 +324,9 @@ pub(crate) fn draw_vector(ctx: &mut RenderContext, v: &Vector, r: &kurbo::Rect,
}
ctx.push_clip_layer(&r.to_path(0.1));
let pixel = device_pixel(view);
for it in v.pic.place(*r, *crop) {
for it in v.pic.place(*r, wordcraft_layout::crop_sides(*crop)) {
match it {
PlacedItem::Path { path, fill, stroke, even_odd, .. } => {
PlacedItem::Path { path, fill, stroke, line, even_odd, region, clips } => clipped(ctx, region.as_deref(), &clips, |ctx| {
if let Some(f) = fill {
ctx.set_paint(rgba_color(f));
ctx.set_fill_rule(if even_odd { peniko::Fill::EvenOdd } else { peniko::Fill::NonZero });
@@ -222,26 +334,71 @@ pub(crate) fn draw_vector(ctx: &mut RenderContext, v: &Vector, r: &kurbo::Rect,
}
if let Some((s, w)) = stroke {
ctx.set_paint(rgba_color(s));
ctx.set_stroke(kurbo::Stroke::new(w.max(pixel)).with_caps(kurbo::Cap::Round).with_join(kurbo::Join::Round));
ctx.set_stroke(pen(w, pixel, &line, &path));
ctx.stroke_path(&path);
}
}
PlacedItem::Bitmap { index, rect, .. } => {
let Some(Some(pm)) = v.pixmaps.get(index) else { continue };
}),
PlacedItem::Bitmap { index, rect, transform, region, clips } => clipped(ctx, region.as_deref(), &clips, |ctx| {
let Some(Some(pm)) = v.pixmaps.get(index) else { return };
let (pw, ph) = (pm.width().max(1) as f64, pm.height().max(1) as f64);
ctx.set_paint(vello_cpu::Image {
image: vello_cpu::ImageSource::Pixmap(pm.clone()),
sampler: peniko::ImageSampler::default().with_quality(peniko::ImageQuality::Medium),
});
ctx.set_paint_transform(Affine::translate((rect.x0, rect.y0)) * Affine::scale_non_uniform(rect.width() / pw, rect.height() / ph));
ctx.fill_rect(&rect);
ctx.reset_paint_transform();
}
PlacedItem::Pattern { .. } => {}
PlacedItem::Text { index, transform, .. } => {
if let Some(Item::Text(t)) = v.pic.items.get(index) {
draw_vector_text(ctx, t, view * transform);
let c = transform.as_coeffs();
// Upright and not mirrored: the bitmap fills `rect`.
if c[1] == 0.0 && c[2] == 0.0 && c[0] > 0.0 && c[3] > 0.0 {
ctx.set_paint_transform(Affine::translate((rect.x0, rect.y0)) * Affine::scale_non_uniform(rect.width() / pw, rect.height() / ph));
ctx.fill_rect(&rect);
} else {
// A turned, skewed or mirrored bitmap: `transform` maps the unit square onto its place.
ctx.set_paint_transform(transform * Affine::scale_non_uniform(1.0 / pw, 1.0 / ph));
ctx.fill_path(&(transform * kurbo::Rect::new(0.0, 0.0, 1.0, 1.0).to_path(0.1)));
}
ctx.reset_paint_transform();
}),
PlacedItem::Pattern { index, path, even_odd, tile, region, clips } => clipped(ctx, region.as_deref(), &clips, |ctx| {
let Some(Item::Pattern { tile: t, .. }) = v.pic.items.get(index) else { return };
ctx.set_fill_rule(if even_odd { peniko::Fill::EvenOdd } else { peniko::Fill::NonZero });
// `tile` maps one tile pixel to page points: the tile's sides are its columns and
// its rows under that, in device pixels. The tile is drawn when either side is at
// least `MIN_TILE_PX`.
let c = (view * tile).as_coeffs();
let across = c[0].hypot(c[1]) * f64::from(t.width);
let down = c[2].hypot(c[3]) * f64::from(t.height);
match v.pixmaps.get(index) {
Some(Some(pm)) if across.max(down) >= MIN_TILE_PX => {
ctx.set_paint(vello_cpu::Image {
image: vello_cpu::ImageSource::Pixmap(pm.clone()),
sampler: peniko::ImageSampler {
x_extend: peniko::Extend::Repeat,
y_extend: peniko::Extend::Repeat,
quality: peniko::ImageQuality::Low,
alpha: 1.0,
},
});
ctx.set_paint_transform(tile);
ctx.fill_path(&path);
ctx.reset_paint_transform();
}
_ => {
ctx.set_paint(rgba_color(v.averages.get(index).copied().unwrap_or([0; 4])));
ctx.fill_path(&path);
}
}
}),
PlacedItem::Text { index, transform, clip, region, clips } => {
clipped(ctx, region.as_deref(), &clips, |ctx| {
let Some(Item::Text(t)) = v.pic.items.get(index) else { return };
if let Some(c) = clip {
ctx.push_clip_layer(&c.to_path(0.1));
}
draw_vector_text(ctx, t, view * transform);
ctx.set_transform(view);
if clip.is_some() {
ctx.pop_layer();
}
});
ctx.set_transform(view);
}
}
@@ -253,15 +410,76 @@ pub(crate) fn draw_vector(ctx: &mut RenderContext, v: &Vector, r: &kurbo::Rect,
}
}
/// Draws a metafile text run: `tf` maps the run's own space (see [`PlacedItem::Text`]) to the device.
/// Draws `draw` inside a metafile item's clip region and every one of its clip paths (page
/// points, under the current transform). No region is the default clip.
fn clipped(
ctx: &mut RenderContext,
region: Option<&kurbo::BezPath>,
clips: &[Arc<craft_metafile::PlacedClip>],
draw: impl FnOnce(&mut RenderContext),
) {
if let Some(region) = region {
ctx.set_fill_rule(peniko::Fill::NonZero);
ctx.push_clip_layer(region);
}
for c in clips {
ctx.set_fill_rule(if c.even_odd { peniko::Fill::EvenOdd } else { peniko::Fill::NonZero });
ctx.push_clip_layer(&c.path);
}
ctx.set_fill_rule(peniko::Fill::NonZero);
draw(ctx);
for _ in 0..clips.len() + usize::from(region.is_some()) {
ctx.pop_layer();
}
}
/// A metafile pen for `path` as a stroke `width` wide (page points, at least one device `pixel`):
/// its caps, joins, miter limit and dashes (`wordcraft_layout::metafile_dashes`).
fn pen(width: f64, pixel: f64, line: &craft_metafile::LineStyle, path: &kurbo::BezPath) -> kurbo::Stroke {
let cap = match line.cap {
craft_metafile::Cap::Round => kurbo::Cap::Round,
craft_metafile::Cap::Square => kurbo::Cap::Square,
craft_metafile::Cap::Flat => kurbo::Cap::Butt,
};
let join = match line.join {
craft_metafile::Join::Round => kurbo::Join::Round,
craft_metafile::Join::Bevel => kurbo::Join::Bevel,
craft_metafile::Join::Miter => kurbo::Join::Miter,
};
let stroke = kurbo::Stroke::new(width.max(pixel))
.with_caps(cap)
.with_join(join)
.with_miter_limit(f64::from(wordcraft_layout::metafile_miter_limit(line.miter_limit)));
if line.dash.is_empty() {
return stroke;
}
match wordcraft_layout::metafile_dashes(&line.dash, width == 0.0, pixel, path.perimeter(1.0)) {
Some(dash) => stroke.with_dashes(0.0, dash),
None => stroke,
}
}
/// Draws a metafile text run: `tf` maps its text space (`craft_metafile::Text::transform`) to the
/// device.
fn draw_vector_text(ctx: &mut RenderContext, t: &craft_metafile::Text, tf: Affine) {
let (face, shaped) = wordcraft_layout::metafile_text_run(t);
let glyphs: Vec<_> = shaped.iter().map(|g| (g.cluster, f64::from(g.x_advance), f64::from(g.x_offset), f64::from(g.y_offset))).collect();
let Some(lay) = wordcraft_layout::layout_metafile_text(t, face.upem, face.ascent, face.descent, &glyphs) else { return };
let k = lay.em / face.upem.max(1.0);
let canvas = kurbo::Rect::new(0.0, 0.0, f64::from(ctx.width()), f64::from(ctx.height()));
// An opaque background mode fills the character cells first.
if let Some(bg) = t.background {
let [x0, y0, x1, y1] = lay.cell;
let cell = tf * kurbo::Rect::new(x0, y0, x1, y1).to_path(0.1);
let b = cell.bounding_box();
if x1 > x0 && [b.x0, b.y0, b.x1, b.y1].iter().all(|v| v.is_finite() && v.abs() <= MAX_GLYPH_PIXELS * 16.0) && b.overlaps(canvas) {
ctx.set_transform(Affine::IDENTITY);
ctx.set_paint(rgba_color(bg));
ctx.fill_path(&cell);
}
}
ctx.set_paint(rgba_color(t.color));
let db = FontDb::global();
let canvas = kurbo::Rect::new(0.0, 0.0, f64::from(ctx.width()), f64::from(ctx.height()));
let mut oversized = 0usize;
for (g, (x, y)) in shaped.iter().zip(&lay.glyphs) {
let o = db.outline(&face, g.gid);
+572
View File
@@ -1,4 +1,5 @@
use super::*;
use crate::media::fit_cache;
use wordcraft_layout::display::page_display;
use wordcraft_layout::{LayoutCache, LayoutOptions, layout};
@@ -1041,6 +1042,393 @@ fn metafile_picture_is_drawn_as_vectors() {
assert!(left[..3].iter().all(|c| *c > 200), "left half should be paper, not the grey box: {left:?}");
}
/// An EMF whose only record is one `w` x `h` 1 bpp black and white bitmap over the whole picture.
fn emf_with_1bpp_bitmap(w: i32, h: i32) -> Vec<u8> {
let mut hdr = vec![0u8; 88];
hdr[0..4].copy_from_slice(&1u32.to_le_bytes());
hdr[4..8].copy_from_slice(&88u32.to_le_bytes());
hdr[8..24].copy_from_slice(&le32(&[0, 0, 100, 100]));
hdr[24..40].copy_from_slice(&le32(&[0, 0, 2500, 2500]));
hdr[40..44].copy_from_slice(&0x464D_4520u32.to_le_bytes());
hdr[72..88].copy_from_slice(&le32(&[1000, 1000, 250, 250]));
let stride = (w as usize).div_ceil(32) * 4;
let mut payload = vec![0u8; 16];
payload.extend(le32(&[0, 0, 0, 0, w, h, 80, 48, 128, (stride * h as usize) as i32, 0, 0x00CC_0020, 100, 100]));
payload.extend(le32(&[40, w, h, 1 | (1 << 16), 0, 0, 0, 0, 0, 0]));
payload.extend([0, 0, 0, 0, 255, 255, 255, 0]);
payload.extend((0..stride * h as usize).map(|i| (i * 31) as u8));
[hdr, emf_rec(81, &payload), emf_rec(14, &[0; 12])].concat()
}
/// #5482: a metafile whose bitmaps are past the whole cache budget was parsed and decoded again on
/// every repaint, because the cache refused it. It is now kept (its bitmaps at a smaller size).
#[test]
fn a_metafile_with_a_huge_bitmap_is_parsed_once() {
// 8000 x 5000 is 160 MB of RGBA, past the 128 MB cache, from a 5 MB file.
let mut d = Document::new();
// A key of its own: the vector cache is global and tests running in threads share `image1.emf`.
let key = "huge-parsed-once.emf";
d.media.insert(key.to_string(), Arc::new(emf_with_1bpp_bitmap(8000, 5000)));
let first = vector_for(&d, key).expect("the metafile reads");
let again = vector_for(&d, key).expect("the metafile reads");
assert!(Arc::ptr_eq(&first, &again), "the second repaint reuses the parsed picture");
assert!(first.bytes() <= CACHE_BYTES / 8, "{} bytes", first.bytes());
}
/// Several huge metafiles on screen together (zoomed-out pages, thumbnails) sit side by side in the
/// cache instead of clearing it, so a small metafile drawn with them stays a hit.
#[test]
fn huge_metafiles_do_not_push_a_small_one_out_of_the_cache() {
let mut d = Document::new();
let small = "evict-small.emf";
d.media.insert(small.to_string(), Arc::new(emf_with_1bpp_bitmap(64, 64)));
let huge: Vec<String> = (0..4).map(|n| format!("evict-huge-{n}.emf")).collect();
for (n, k) in huge.iter().enumerate() {
// Distinct bytes per file (the width differs; 8000 x 5000 is the most pixels a metafile decodes), so each is its own cache entry.
d.media.insert(k.clone(), Arc::new(emf_with_1bpp_bitmap(8000 - n as i32, 5000)));
}
let small_first = vector_for(&d, small).expect("the small metafile reads");
for round in 0..2 {
for k in &huge {
assert!(vector_for(&d, k).is_some(), "round {round}");
}
}
let kept: Vec<_> = huge.iter().map(|k| vector_for(&d, k).unwrap()).collect();
let again: Vec<_> = huge.iter().map(|k| vector_for(&d, k).unwrap()).collect();
for (a, b) in kept.iter().zip(&again) {
assert!(Arc::ptr_eq(a, b), "a huge metafile is parsed once while four are drawn together");
}
assert!(Arc::ptr_eq(&small_first, &vector_for(&d, small).unwrap()), "the small metafile is still cached");
}
/// Time of three repaints of a picture with a 160 MB bitmap:
/// `cargo test -p wordcraft-render --release -- --ignored --nocapture huge_metafile_repaint_time`.
#[test]
#[ignore = "timing only"]
fn huge_metafile_repaint_time() {
let mut d = Document::new();
let key = d.add_media(emf_with_1bpp_bitmap(8000, 5000), "emf");
for n in 1..=4 {
let t = std::time::Instant::now();
assert!(vector_for(&d, &key).is_some());
eprintln!("repaint {n}: vector_for {:.1} ms", t.elapsed().as_secs_f64() * 1e3);
}
}
#[test]
fn bitmaps_are_shrunk_in_proportion_only_when_the_picture_is_past_the_cache() {
let px = vello_cpu::color::PremulRgba8 { r: 1, g: 2, b: 3, a: 255 };
let pm = |w: u16, h: u16| Some(Pixmap::from_parts(vec![px; usize::from(w) * usize::from(h)], w, h));
let bytes = |v: &[Option<Pixmap>]| v.iter().flatten().map(|p| usize::from(p.width()) * usize::from(p.height()) * 4).sum::<usize>();
// Within the budget: untouched.
let kept = fit_cache(vec![pm(1000, 1000), None, pm(2000, 2000)], 1_000_000);
assert_eq!(kept.iter().flatten().map(|p| (p.width(), p.height())).collect::<Vec<_>>(), [(1000, 1000), (2000, 2000)]);
assert!(kept[1].is_none(), "a path item keeps its place in the list");
// A 144 MB and a 36 MB bitmap: both shrink by the same factor.
let fit = fit_cache(vec![pm(6000, 6000), pm(3000, 3000)], 4_000_000);
assert!(bytes(&fit) + 4_000_000 <= CACHE_BYTES / 8, "{} bytes", bytes(&fit));
let (a, b) = (fit[0].as_ref().unwrap(), fit[1].as_ref().unwrap());
assert_eq!((a.width(), b.width()), (1500, 750), "each bitmap keeps its share of the pixels that fit");
assert!(a.data().iter().all(|p| (p.r, p.g, p.b, p.a) == (1, 2, 3, 255)), "flat stays flat");
}
/// Geometry of an eighth of the budget or more leaves the bitmaps a positive allowance, so the
/// picture is still kept (and reused) when it fits the whole budget after shrinking; one whose
/// geometry alone fills the budget stays uncached.
#[test]
fn heavy_geometry_still_leaves_the_bitmaps_a_cacheable_size() {
let px = vello_cpu::color::PremulRgba8 { r: 1, g: 2, b: 3, a: 255 };
let pm = |w: u16, h: u16| Some(Pixmap::from_parts(vec![px; usize::from(w) * usize::from(h)], w, h));
let bytes = |v: &[Option<Pixmap>]| v.iter().flatten().map(|p| usize::from(p.width()) * usize::from(p.height()) * 4).sum::<usize>();
let geometry = CACHE_BYTES / 8 + 4_000_000;
let fit = fit_cache(vec![pm(6000, 6000)], geometry);
let size = bytes(&fit);
assert!(size > 0 && size < 6000 * 6000 * 4, "shrunk, not dropped: {size} bytes");
assert!(size + geometry <= CACHE_BYTES, "{size} bytes");
// The shrunk picture is accepted by the cache and hit again.
let src = Arc::new(vec![0u8; 1]);
let mut c: MediaCache<u8> = MediaCache { map: Default::default(), bytes: 0 };
c.insert("heavy", &src, 7, size + geometry);
assert_eq!(c.get("heavy", &src), Some(7));
// Just under and just over the eighth: both shrink the bitmap to a positive size, none to nothing.
for g in [CACHE_BYTES / 8 - 1, CACHE_BYTES / 8, CACHE_BYTES / 8 + 1] {
let size = bytes(&fit_cache(vec![pm(6000, 6000)], g));
assert!(size > 0 && size < 6000 * 6000 * 4 && size + g <= CACHE_BYTES / 4, "geometry {g}: {size} bytes");
}
// Geometry that takes the whole budget leaves nothing to shrink to: the bitmap stays as it is.
let full = fit_cache(vec![pm(6000, 6000)], CACHE_BYTES);
assert_eq!(bytes(&full), 6000 * 6000 * 4);
}
/// #6636: an EMF+ only file (no plain EMF drawing records) whose EmfPlusDrawImage draws a
/// 32bppPARGB bitmap over the right half: the bitmap's pixels are drawn.
#[test]
fn emf_plus_only_bitmap_is_drawn() {
// EmfPlusObject 0, an image (type 5): a 2 × 1 bitmap in PixelFormat32bppPARGB, opaque red
// and then red at half opacity (premultiplied BGRA 0, 0, 128, 128).
let mut image = le32(&[0xDBC0_1002_u32 as i32, 1, 2, 1, 8, 0x000E_200B, 0]);
image.extend([0u8, 0, 255, 255, 0, 0, 128, 128]);
let object = plus_rec(0x4008, 0x0500, &image);
// EmfPlusDrawImage of image 0: the whole bitmap (pixel units) into x 50..100, y 0..100.
let mut draw = le32(&[-1, 2]);
draw.extend([0.0f32, 0.0, 2.0, 1.0, 50.0, 0.0, 50.0, 100.0].iter().flat_map(|v| v.to_le_bytes()));
let emf = emf_plus_file(&[object, plus_rec(0x401A, 0, &draw)]);
let (img, rect) = emf_on_page(emf, [0.0; 4], 1.0);
let at = |fx: f32| img.pixel((rect.x + rect.w * fx) as u32, (rect.y + rect.h * 0.5) as u32);
let (opaque, half, left) = (at(0.6), at(0.9), at(0.25));
assert!(is_red(opaque), "the bitmap's opaque red is drawn on the right half: {opaque:?}");
// Premultiplied half-opacity red over white paper is (255, 127, 127); read as straight
// color it would be about (191, 127, 127).
assert!(half[0] > 235 && (110..145).contains(&half[1]) && (110..145).contains(&half[2]), "half-opacity red: {half:?}");
assert!(is_paper(left), "left half should be paper: {left:?}");
}
/// #6636: EmfPlusDrawImage draws a bitmap in PixelFormat32bppARGB, 24bppRGB and 32bppRGB, and a
/// compressed PNG or JPEG bitmap, in an EMF+ only file.
#[test]
fn emf_plus_only_bitmap_formats_are_drawn() {
let encoded = |png: bool| {
let red = [255u8, 0, 0].repeat(64);
if png {
let img = image::RgbImage::from_raw(8, 8, red).unwrap();
wordcraft_geom::picture::encode_png(&image::DynamicImage::from(img)).unwrap()
} else {
wordcraft_geom::picture::encode_jpeg(&red, 8, 8, 100).unwrap()
}
};
// Name, width, height, stride, pixel format, bitmap type (0 pixels, 1 compressed) and data.
let cases: [(&str, i32, i32, i32, u32, i32, Vec<u8>); 5] = [
("32bppARGB", 2, 1, 8, 0x0026_200A, 0, [0u8, 0, 255, 255].repeat(2)),
("24bppRGB", 2, 1, 8, 0x0002_1808, 0, vec![0, 0, 255, 0, 0, 255, 0, 0]),
("32bppRGB", 2, 1, 8, 0x0002_2009, 0, [0u8, 0, 255, 0].repeat(2)),
("PNG", 8, 8, 0, 0, 1, encoded(true)),
("JPEG", 8, 8, 0, 0, 1, encoded(false)),
];
for (name, w, h, stride, format, kind, data) in cases {
let mut image = le32(&[0xDBC0_1002_u32 as i32, 1, w, h, stride, format as i32, kind]);
image.extend(data);
// Records are a multiple of 4 bytes long.
image.resize(image.len().next_multiple_of(4), 0);
let mut draw = le32(&[-1, 2]);
draw.extend([0.0f32, 0.0, w as f32, h as f32, 50.0, 0.0, 50.0, 100.0].iter().flat_map(|v| v.to_le_bytes()));
let emf = emf_plus_file(&[plus_rec(0x4008, 0x0500, &image), plus_rec(0x401A, 0, &draw)]);
let (img, rect) = emf_on_page(emf, [0.0; 4], 1.0);
let at = |fx: f32| img.pixel((rect.x + rect.w * fx) as u32, (rect.y + rect.h * 0.5) as u32);
let (right, left) = (at(0.75), at(0.25));
assert!(is_red(right), "{name}: the red bitmap is drawn on the right half: {right:?}");
assert!(is_paper(left), "{name}: left half should be paper: {left:?}");
}
}
/// An EMF+ record for [`emf_plus_file`]: type, flags and data.
fn plus_rec(typ: u16, flags: u16, data: &[u8]) -> Vec<u8> {
let mut v = typ.to_le_bytes().to_vec();
v.extend(flags.to_le_bytes());
v.extend(((12 + data.len()) as u32).to_le_bytes());
v.extend((data.len() as u32).to_le_bytes());
v.extend(data);
v
}
/// An EMF+ only file with the frame of [`red_right_half_emf`]: an EmfPlusHeader (96 dpi), then
/// `records`, then EmfPlusEndOfFile, in one comment record.
fn emf_plus_file(records: &[Vec<u8>]) -> Vec<u8> {
let mut comment = 0x2B46_4D45u32.to_le_bytes().to_vec();
comment.extend(plus_rec(0x4001, 0, &le32(&[0xDBC0_1002_u32 as i32, 1, 96, 96])));
comment.extend(records.concat());
comment.extend(plus_rec(0x4002, 0, &[]));
let mut payload = (comment.len() as u32).to_le_bytes().to_vec();
payload.extend(comment);
let mut emf = red_right_half_emf()[..88].to_vec();
emf.extend([emf_rec(70, &payload), emf_rec(14, &[0; 12])].concat());
emf
}
/// Renders a document holding one 70 pt metafile picture with `crop` at `scale`: the page and the
/// picture's frame (points).
fn emf_on_page(emf: Vec<u8>, crop: [f32; 4], scale: f32) -> (Rendered, wordcraft_geom::Rect) {
emf_on_page_sized(emf, (70.0, 70.0), crop, scale)
}
/// [`emf_on_page`] with the picture `size` (points).
fn emf_on_page_sized(emf: Vec<u8>, size: (f32, f32), crop: [f32; 4], scale: f32) -> (Rendered, wordcraft_geom::Rect) {
let mut d = Document::new();
let media = d.add_media(emf, "emf");
let mut p = wordcraft_doc::Paragraph::new();
let obj = wordcraft_doc::para::InlineObject::Image {
media,
w: size.0,
h: size.1,
alt: String::new(),
float: Default::default(),
crop,
fx: Default::default(),
ole: None,
};
p.insert_object(0, obj, &Default::default()).unwrap();
d.body = vec![wordcraft_doc::para_block(p)];
let l = layout(&d, &mut LayoutCache::new(), &LayoutOptions::default());
let opts = RenderOptions::default();
let rect = page_display(&d, &l.pages[0], &opts.display)
.iter()
.find_map(|i| match i {
Draw::Image { rect, .. } => Some(*rect),
_ => None,
})
.expect("a picture on the page");
(render_page(&d, &l.pages[0], scale, &opts), rect)
}
/// Whether a pixel is close to pure red.
fn is_red(p: [u8; 4]) -> bool {
p[0] > 200 && p[1] < 60 && p[2] < 60
}
/// Whether a pixel is paper.
fn is_paper(p: [u8; 4]) -> bool {
p[..3].iter().all(|c| *c > 200)
}
/// A clip region (INTERSECTCLIPRECT to the left half) keeps a red rectangle over the whole
/// picture to that half; once RESTOREDC drops it, a second rectangle across the bottom shows on
/// both halves.
#[test]
fn metafile_clip_region_clips_and_ends() {
let mut emf = red_right_half_emf()[..88].to_vec();
let brush = emf_rec(39, &le32(&[1, 0, 0x0000_00FF, 0]));
let recs = [
brush,
emf_rec(37, &le32(&[1])),
emf_rec(33, &[]),
emf_rec(30, &le32(&[0, 0, 50, 100])),
emf_rec(43, &le32(&[0, 0, 100, 60])),
emf_rec(34, &le32(&[-1])),
emf_rec(43, &le32(&[0, 80, 100, 100])),
emf_rec(14, &[0; 12]),
];
emf.extend(recs.concat());
let (img, rect) = emf_on_page(emf, [0.0; 4], 1.0);
let at = |fx: f32, fy: f32| img.pixel((rect.x + rect.w * fx) as u32, (rect.y + rect.h * fy) as u32);
assert!(is_red(at(0.25, 0.3)), "inside the clip: {:?}", at(0.25, 0.3));
assert!(is_paper(at(0.75, 0.3)), "outside the clip: {:?}", at(0.75, 0.3));
assert!(is_red(at(0.75, 0.9)), "after the clip is restored away: {:?}", at(0.75, 0.9));
}
/// The vector cache counts each item's copy of the clip region: 100 rectangles drawn inside a
/// clip region hold 100 copies of its rectangle more than without it.
#[test]
fn metafile_cache_counts_clip_regions() {
let bytes = |clip: bool| {
let mut emf = red_right_half_emf()[..88].to_vec();
if clip {
emf.extend(emf_rec(30, &le32(&[0, 0, 50, 100])));
}
for i in 0..100 {
emf.extend(emf_rec(43, &le32(&[i % 50, 0, i % 50 + 10, 10])));
}
emf.extend(emf_rec(14, &[0; 12]));
media::build_vector(&emf).map(|v| v.bytes())
};
let (with, without) = (bytes(true).expect("a picture"), bytes(false).expect("a picture"));
assert!(with >= without + 100 * 16, "{with} and {without}");
}
/// A hatch tile squeezed to well under a pixel tall but several pixels wide (the picture is 70 pt
/// wide and 2 pt tall) keeps its vertical lines: the row crosses red lines and the background
/// between them, not one blended color.
#[test]
fn metafile_narrow_hatch_tile_keeps_its_lines() {
let mut emf = red_right_half_emf()[..88].to_vec();
let brush = emf_rec(39, &le32(&[1, 2, 0x0000_00FF, 1]));
// The stock NULL_PEN leaves the rectangle without an outline.
let no_pen = emf_rec(37, &le32(&[0x8000_0008_u32 as i32]));
emf.extend([brush, emf_rec(37, &le32(&[1])), no_pen, emf_rec(43, &le32(&[0, 0, 100, 100])), emf_rec(14, &[0; 12])].concat());
let (img, rect) = emf_on_page_sized(emf, (70.0, 2.0), [0.0; 4], 1.0);
let y = (rect.y + rect.h / 2.0) as u32;
let row: Vec<u8> = ((rect.x + 2.0) as u32..(rect.x + rect.w - 2.0) as u32).map(|x| img.pixel(x, y)[1]).collect();
assert!(row.iter().any(|g| *g < 160) && row.iter().any(|g| *g > 240), "red lines and background: {row:?}");
}
/// A clip path (a rectangle path over the left half, SELECTCLIPPATH with RGN_COPY) keeps a red
/// rectangle over the whole picture to that half.
#[test]
fn metafile_clip_path_clips() {
let mut emf = red_right_half_emf()[..88].to_vec();
let brush = emf_rec(39, &le32(&[1, 0, 0x0000_00FF, 0]));
let recs = [
brush,
emf_rec(37, &le32(&[1])),
emf_rec(59, &[]),
emf_rec(43, &le32(&[0, 0, 50, 100])),
emf_rec(60, &[]),
emf_rec(67, &le32(&[5])),
emf_rec(43, &le32(&[0, 0, 100, 100])),
emf_rec(14, &[0; 12]),
];
emf.extend(recs.concat());
let (img, rect) = emf_on_page(emf, [0.0; 4], 1.0);
let at = |fx: f32| img.pixel((rect.x + rect.w * fx) as u32, (rect.y + rect.h * 0.5) as u32);
assert!(is_red(at(0.25)), "inside the clip path: {:?}", at(0.25));
assert!(is_paper(at(0.75)), "outside the clip path: {:?}", at(0.75));
}
/// A bitmap under a world transform that turns it a quarter turn clockwise about the picture's
/// center (EmfPlusSetWorldTransform): its left pixel (red) is drawn at the top and its right pixel
/// (blue) at the bottom.
#[test]
fn emf_plus_turned_bitmap_is_drawn_turned() {
let mut image = le32(&[0xDBC0_1002_u32 as i32, 1, 2, 1, 8, 0x000E_200B, 0]);
// BGRA: red, then blue.
image.extend([0u8, 0, 255, 255, 255, 0, 0, 255]);
let turn = plus_rec(0x402A, 0, &[0.0f32, 1.0, -1.0, 0.0, 100.0, 0.0].iter().flat_map(|v| v.to_le_bytes()).collect::<Vec<_>>());
let mut draw = le32(&[-1, 2]);
draw.extend([0.0f32, 0.0, 2.0, 1.0, 25.0, 25.0, 50.0, 50.0].iter().flat_map(|v| v.to_le_bytes()));
let emf = emf_plus_file(&[plus_rec(0x4008, 0x0500, &image), turn, plus_rec(0x401A, 0, &draw)]);
let (img, rect) = emf_on_page(emf, [0.0; 4], 1.0);
let at = |fx: f32, fy: f32| img.pixel((rect.x + rect.w * fx) as u32, (rect.y + rect.h * fy) as u32);
let (top_right, bottom_left) = (at(0.65, 0.37), at(0.35, 0.62));
assert!(is_red(top_right), "red at the top: {top_right:?}");
assert!(bottom_left[2] > 200 && bottom_left[0] < 60, "blue at the bottom: {bottom_left:?}");
}
/// A geometric PS_USERSTYLE pen whose dashes and gaps are far below a pixel draws its line solid
/// instead of splitting it into dashes too small to see.
#[test]
fn metafile_sub_pixel_dashes_draw_solid() {
let mut emf = red_right_half_emf()[..88].to_vec();
// 10,000 device pixels over 250 mm: a device unit is 0.025 mm. The picture is 1000 units wide.
emf[8..24].copy_from_slice(&le32(&[0, 0, 1000, 1000]));
emf[72..80].copy_from_slice(&le32(&[10_000, 10_000]));
// EXTCREATEPEN 1: PS_GEOMETRIC | PS_ENDCAP_FLAT | PS_USERSTYLE, 80 units wide, black, two
// entries of 1 unit.
let pen = emf_rec(95, &le32(&[1, 0, 0, 0, 0, 0x0001_0207, 80, 0, 0, 0, 2, 1, 1]));
let recs = [pen, emf_rec(37, &le32(&[1])), emf_rec(27, &le32(&[0, 500])), emf_rec(54, &le32(&[1000, 500])), emf_rec(14, &[0; 12])];
emf.extend(recs.concat());
let (img, rect) = emf_on_page(emf, [0.0; 4], 1.0);
let y = (rect.y + rect.h * 0.5) as u32;
let (x0, x1) = ((rect.x + 5.0) as u32, (rect.x + rect.w - 5.0) as u32);
let dark = (x0..x1).filter(|&x| img.pixel(x, y)[..3].iter().all(|c| *c < 60)).count();
assert_eq!(dark, (x1 - x0) as usize, "the line is solid black");
}
/// A hatched brush (CREATEBRUSHINDIRECT, BS_HATCHED, HS_VERTICAL) fills with its red lines over
/// the background, not with a solid red.
#[test]
fn metafile_hatch_brush_draws_its_lines() {
let mut emf = red_right_half_emf()[..88].to_vec();
let brush = emf_rec(39, &le32(&[1, 2, 0x0000_00FF, 1]));
emf.extend([brush, emf_rec(37, &le32(&[1])), emf_rec(43, &le32(&[0, 0, 100, 100])), emf_rec(14, &[0; 12])].concat());
let scale = 4.0;
let (img, rect) = emf_on_page(emf, [0.0; 4], scale);
let y = ((rect.y + rect.h / 2.0) * scale) as u32;
let (x0, x1) = (((rect.x + 2.0) * scale) as u32, ((rect.x + rect.w - 2.0) * scale) as u32);
let red = (x0..x1).filter(|&x| img.pixel(x, y)[1] < 128).count();
let n = (x1 - x0) as usize;
assert!(red > 0 && red < n * 3 / 4, "the row crosses red lines and the background between them: {red} of {n} red");
}
/// #1899: a crop that keeps a sliver of the picture (3% here; a header's bar can be 2.7% of a
/// page-sized metafile) stretches that sliver over the frame, as the file says, for vector and
/// bitmap pictures alike. Both pictures are paper on the left half and red on the right.
@@ -1084,6 +1472,43 @@ fn a_crop_keeping_a_sliver_fills_the_frame_with_it() {
}
}
/// A negative crop side draws as no crop on that side, for vector and bitmap pictures alike: a
/// left side of -0.5 does not pad the source, so the frame at 55% shows the source at 55% (red).
#[test]
fn a_negative_crop_side_draws_uncropped() {
let img = image::RgbaImage::from_fn(100, 100, |x, _| image::Rgba(if x >= 50 { [255, 0, 0, 255] } else { [255; 4] }));
let png = wordcraft_geom::picture::encode_png(&image::DynamicImage::from(img)).unwrap();
for (bytes, ext) in [(red_right_half_emf(), "emf"), (png, "png")] {
let mut d = Document::new();
let media = d.add_media(bytes, ext);
let mut p = wordcraft_doc::Paragraph::new();
let obj = wordcraft_doc::para::InlineObject::Image {
media,
w: 70.0,
h: 70.0,
alt: String::new(),
float: Default::default(),
crop: [-0.5, 0.0, 0.0, 0.0],
fx: Default::default(),
ole: None,
};
p.insert_object(0, obj, &Default::default()).unwrap();
d.body = vec![wordcraft_doc::para_block(p)];
let l = layout(&d, &mut LayoutCache::new(), &LayoutOptions::default());
let opts = RenderOptions::default();
let rect = page_display(&d, &l.pages[0], &opts.display)
.iter()
.find_map(|i| match i {
Draw::Image { rect, .. } => Some(*rect),
_ => None,
})
.expect("a picture on the page");
let img = render_page(&d, &l.pages[0], 1.0, &opts);
let px = img.pixel((rect.x + rect.w * 0.55) as u32, (rect.y + rect.h * 0.5) as u32);
assert!(is_red(px), "{ext}: {px:?}");
}
}
#[test]
fn cosmetic_metafile_pen_is_one_device_pixel_wide() {
// MOVETO (0, 50), LINETO (100, 50) with the default cosmetic black pen: a hairline across the middle.
@@ -1168,6 +1593,29 @@ fn metafile_text_records_are_painted() {
assert!(dark > 50, "the text is painted inside the picture: {dark} dark pixels");
}
/// With the opaque background mode (the default) and a red background color (SETBKCOLOR), a text
/// run's character cells are filled red behind the black text.
#[test]
fn metafile_text_fills_its_opaque_background() {
let mut font = emf_rec(82, &le32(&[1, -20, 0, 0, 0, 400, 0, 0]));
let mut name: Vec<u8> = "Arial".encode_utf16().flat_map(|u| u.to_le_bytes()).collect();
name.resize(64, 0);
font.extend(name);
font[4..8].copy_from_slice(&104u32.to_le_bytes());
let mut text = emf_rec(84, &le32(&[0, 0, 100, 100, 1, 0, 0, 5, 40, 4, 76, 0, 0, 0, 0, 0, 0]));
text.extend("WWWW".encode_utf16().flat_map(|u| u.to_le_bytes()));
text[4..8].copy_from_slice(&84u32.to_le_bytes());
let mut emf = red_right_half_emf()[..88].to_vec();
let bk = emf_rec(25, &le32(&[0x0000_00FF]));
emf.extend([bk, font, emf_rec(37, &le32(&[1])), emf_rec(24, &le32(&[0])), text, emf_rec(14, &[0; 12])].concat());
let scale = 2.0;
let (img, rect) = emf_on_page(emf, [0.0; 4], scale);
let (x0, y0) = ((rect.x * scale) as u32, (rect.y * scale) as u32);
let (x1, y1) = (((rect.x + rect.w) * scale) as u32, ((rect.y + rect.h) * scale) as u32);
let red = (y0..y1).flat_map(|y| (x0..x1).map(move |x| (x, y))).filter(|&(x, y)| is_red(img.pixel(x, y))).count();
assert!(red > 50, "the character cells are filled red: {red} red pixels");
}
/// An EMF text run whose anchor sits inside the picture but whose font is billions of units
/// tall: each glyph's curves would span billions of device pixels, which the rasteriser
/// subdivides for ever. Glyphs that big (or off the raster) are left out; the page renders.
@@ -1490,6 +1938,31 @@ fn paths_far_past_every_canvas_are_not_flattened() {
assert!(!path_extent_ok(Affine::IDENTITY, &line(f64::NAN)));
}
#[test]
fn rules_of_one_width_cover_the_same_whole_pixels_at_every_zoom() {
for zoom in [0.5, 0.6, 0.75] {
for ppp in [1.0, 1.25] {
let k = zoom * ppp * 96.0 / 72.0;
let view = Affine::new([k, 0.0, 0.0, k, 37.3, 12.9]);
let mut widths = Vec::new();
for i in 0..20 {
let pos = 10.0 + f64::from(i) * 17.37;
let (w_h, (_, oy)) = snap_rule(view, (5.0, pos, 400.0, pos), 0.5).unwrap();
let (w_v, (ox, _)) = snap_rule(view, (pos, 5.0, pos, 400.0), 0.5).unwrap();
widths.push(w_h);
widths.push(w_v);
for (w, centre) in [(w_h, (pos + oy) * k + 12.9), (w_v, (pos + ox) * k + 37.3)] {
let edge = centre - w / 2.0;
assert!((edge - edge.round()).abs() < 1e-9, "zoom {zoom} ppp {ppp}: edge {edge} is off the pixel grid");
}
}
assert!(widths.iter().all(|w| *w == widths[0] && *w >= 1.0 && w.fract() == 0.0), "zoom {zoom} ppp {ppp}: {widths:?}");
}
}
assert!(snap_rule(Affine::rotate(0.3), (0.0, 0.0, 9.0, 0.0), 0.5).is_none());
assert!(snap_rule(Affine::scale(2.0), (0.0, 0.0, 9.0, 4.0), 0.5).is_none());
}
/// The same three pictures that don't draw as in the PDF test: each stays a grey box, and the page's
/// pixels are what they were before strict export existed (#6005).
#[test]
@@ -1528,3 +2001,102 @@ fn undecodable_pictures_keep_their_grey_box_pixels() {
let h = img.pixels.iter().fold(0xcbf29ce484222325u64, |h, b| (h ^ u64::from(*b)).wrapping_mul(0x100000001b3));
assert_eq!(h, 0x79f9f1d3602a9925, "{h:#x}");
}
/// The cache charge for a metafile's geometry covers what its items keep after their pixels move
/// out: a pattern's path and tile, and the clip rectangles and clip paths of every kind of item.
/// A tile or clip path shared by several items is charged once.
#[test]
fn geometry_bytes_counts_pattern_tiles_and_clips_once() {
use craft_metafile::{ClipPath, Tile};
let segs = |n: usize| vec![Seg::Line(0.0, 0.0); n];
let pic = |items: Vec<Item>| Picture { width: 10.0, height: 10.0, items, skipped_records: 0 };
let base = crate::media::geometry_bytes(&pic(vec![]));
let tile = Arc::new(Tile { width: 1000, height: 1000, rgba: vec![0; 4_000_000], cell: [1.0, 1.0], origin: [0.0, 0.0] });
let pattern = |tile: &Arc<Tile>| Item::Pattern { segs: segs(1000), even_odd: false, tile: tile.clone(), region: None, clips: vec![] };
let one = crate::media::geometry_bytes(&pic(vec![pattern(&tile)]));
assert!(one - base >= 4_000_000 + 1000 * std::mem::size_of::<Seg>(), "{} bytes", one - base);
// Two fills of the same brush keep one tile.
let two = crate::media::geometry_bytes(&pic(vec![pattern(&tile), pattern(&tile)]));
assert!(two - one < 1_000_000, "the shared tile is charged once: {} bytes more", two - one);
// A clip path shared by two bitmaps is charged once; a clip region is charged per item.
let clip = Arc::new(ClipPath { segs: segs(100_000), even_odd: false });
let bitmap = |clips: Vec<Arc<ClipPath>>, region: Option<Vec<[f32; 4]>>| Item::Bitmap {
rect: [0.0; 4],
transform: [1.0, 0.0, 0.0, 1.0, 0.0, 0.0],
width: 0,
height: 0,
rgba: vec![],
region,
clips,
};
let plain = crate::media::geometry_bytes(&pic(vec![bitmap(vec![], None)]));
let clipped = crate::media::geometry_bytes(&pic(vec![bitmap(vec![clip.clone()], None), bitmap(vec![clip.clone()], None)]));
let clip_bytes = 100_000 * std::mem::size_of::<Seg>();
assert!(clipped - 2 * plain >= clip_bytes && clipped - 2 * plain < 2 * clip_bytes, "{} bytes", clipped - 2 * plain);
let region = crate::media::geometry_bytes(&pic(vec![bitmap(vec![], Some(vec![[0.0; 4]; 1000]))]));
assert!(region - plain >= 1000 * 16, "{} bytes", region - plain);
}
/// The parser collects segments and dashes without shrinking them, so the charge follows the
/// capacity a vector keeps, not only its length.
#[test]
fn geometry_bytes_charges_the_capacity_of_segment_and_dash_vectors() {
use craft_metafile::LineStyle;
let pic = |items: Vec<Item>| Picture { width: 10.0, height: 10.0, items, skipped_records: 0 };
let path = |segs: Vec<Seg>, dash: Vec<f32>| Item::Path {
segs,
fill: None,
stroke: Some(([0, 0, 0, 255], 1.0)),
line: LineStyle { dash, ..LineStyle::default() },
even_odd: false,
region: None,
clips: vec![],
};
let tight = crate::media::geometry_bytes(&pic(vec![path(vec![Seg::Line(0.0, 0.0); 2], vec![1.0; 2])]));
let mut segs = Vec::with_capacity(10_000);
segs.extend([Seg::Line(0.0, 0.0); 2]);
let mut dash = Vec::with_capacity(1_000);
dash.extend([1.0f32; 2]);
let slack = crate::media::geometry_bytes(&pic(vec![path(segs, dash)]));
assert!(slack - tight >= 9_000 * std::mem::size_of::<Seg>(), "{} bytes more", slack - tight);
}
/// A stroked path keeps its dash array on the heap, and a text item keeps its boxed record and font
/// name; the cache charge counts both, so many dashed paths or text records are not under-counted.
#[test]
fn geometry_bytes_counts_dash_arrays_and_text_records() {
use craft_metafile::{Font, HAlign, LineStyle, Text, VAlign};
let pic = |items: Vec<Item>| Picture { width: 10.0, height: 10.0, items, skipped_records: 0 };
let path = |dash: usize| Item::Path {
segs: vec![Seg::Line(0.0, 0.0); 2],
fill: None,
stroke: Some(([0, 0, 0, 255], 1.0)),
line: LineStyle { dash: vec![1.0; dash], ..LineStyle::default() },
even_odd: false,
region: None,
clips: vec![],
};
let solid = crate::media::geometry_bytes(&pic(vec![path(0)]));
let dashed = crate::media::geometry_bytes(&pic(vec![path(16)]));
assert_eq!(dashed - solid, 16 * std::mem::size_of::<f32>());
let text = |family: &str| {
Item::Text(Box::new(Text {
transform: [1.0, 0.0, 0.0, 1.0, 0.0, 0.0],
text: "ab".into(),
dx: vec![1.0; 2],
font: Font { family: family.into(), ..Font::default() },
color: [0, 0, 0, 255],
background: None,
h_align: HAlign::default(),
v_align: VAlign::default(),
clip: None,
region: None,
clips: vec![],
}))
};
let bare = crate::media::geometry_bytes(&pic(vec![text("")]));
let named = crate::media::geometry_bytes(&pic(vec![text("Some Long Face Name")]));
assert_eq!(named - bare, "Some Long Face Name".len());
let empty = crate::media::geometry_bytes(&pic(vec![]));
assert!(bare - empty >= std::mem::size_of::<Text>(), "the boxed Text struct is charged: {} bytes", bare - empty);
}
+82 -7
View File
@@ -90,7 +90,8 @@ pub fn alt_text(app: &mut WordApp, ui: &mut Ui) {
let decorative = obj.is_decorative();
ui.label(egui::RichText::new(tl!("Describe what this object shows, for people who can't see it.")).weak());
ui.add_space(4.0);
if let Some(text) = draft_box(ui, ("alt_obj", &pos), obj.alt_text(), !decorative, true)
let label = ui.label(tl!("Description:"));
if let Some(text) = draft_box(ui, ("alt_obj", &pos), label.id, obj.alt_text(), !decorative, true)
&& still_selected(app, &pos)
{
let _ = app.run("object.altText", json!({"text": text}));
@@ -111,13 +112,13 @@ pub fn alt_text(app: &mut WordApp, ui: &mut Ui) {
if let Some((tp, caption, description)) = table {
ui.label(egui::RichText::new(tl!("Describe what this table shows, for people who can't see it.")).weak());
ui.add_space(4.0);
ui.label(tl!("Title:"));
if let Some(t) = draft_box(ui, ("alt_table_title", &tp), caption.as_deref().unwrap_or(""), true, false) {
let label = ui.label(tl!("Title:"));
if let Some(t) = draft_box(ui, ("alt_table_title", &tp), label.id, caption.as_deref().unwrap_or(""), true, false) {
let _ = app.run("table.altText", json!({"title": t}));
}
ui.add_space(4.0);
ui.label(tl!("Description:"));
if let Some(t) = draft_box(ui, ("alt_table_text", &tp), description.as_deref().unwrap_or(""), true, true) {
let label = ui.label(tl!("Description:"));
if let Some(t) = draft_box(ui, ("alt_table_text", &tp), label.id, description.as_deref().unwrap_or(""), true, true) {
let _ = app.run("table.altText", json!({"text": t}));
}
return;
@@ -131,11 +132,18 @@ fn still_selected(app: &WordApp, pos: &Pos) -> bool {
/// A text box editing `current`; the draft lives in egui memory while it has focus (frame-local
/// buffers lose keystrokes). Returns the new text when editing ends with a change.
fn draft_box(ui: &mut Ui, key: impl std::hash::Hash + std::fmt::Debug, current: &str, enabled: bool, multiline: bool) -> Option<String> {
fn draft_box(
ui: &mut Ui,
key: impl std::hash::Hash + std::fmt::Debug,
label: egui::Id,
current: &str,
enabled: bool,
multiline: bool,
) -> Option<String> {
let key = egui::Id::unique(key);
let mut text = ui.data(|d| d.get_temp::<String>(key)).unwrap_or_else(|| current.to_string());
let edit = if multiline { egui::TextEdit::multiline(&mut text).desired_rows(5) } else { egui::TextEdit::singleline(&mut text) };
let r = ui.add_enabled(enabled, edit.desired_width(f32::INFINITY));
let r = ui.add_enabled(enabled, edit.desired_width(f32::INFINITY)).labelled_by(label);
if r.changed() {
ui.data_mut(|d| d.insert_temp(key, text.clone()));
}
@@ -148,3 +156,70 @@ fn draft_box(ui: &mut Ui, key: impl std::hash::Hash + std::fmt::Debug, current:
}
None
}
#[cfg(test)]
mod tests {
use super::*;
use egui::accesskit::Role;
use egui_kittest::kittest::{NodeT, Queryable};
fn harness(app: WordApp) -> egui_kittest::Harness<'static, WordApp> {
let mut fonts = false;
let mut h = egui_kittest::Harness::builder().with_size(egui::vec2(400.0, 400.0)).build_ui_state(
move |ui, app: &mut WordApp| {
if fonts {
alt_text(app, ui);
} else {
crate::theme::install_fonts_for(ui.ctx(), false);
fonts = true;
}
},
app,
);
h.run_steps(4);
h
}
#[test]
fn object_description_is_named_commits_and_disables_when_decorative() {
let mut app = WordApp::new(wordcraft_engine::Session::new(wordcraft_doc::Document::new()), crate::Services::default());
app.run("insert.shape", json!({"kind": "ellipse"})).unwrap();
let mut h = harness(app);
h.get_by_role_and_label(Role::MultilineTextInput, "Description:").click();
h.run_steps(2);
h.get_by_role_and_label(Role::MultilineTextInput, "Description:").type_text("A green circle");
h.run_steps(2);
assert_eq!(h.get_by_role_and_label(Role::MultilineTextInput, "Description:").value().as_deref(), Some("A green circle"));
h.get_by_role_and_label(Role::CheckBox, "Mark as decorative").click();
h.run_steps(2);
let (_, object) = wordcraft_engine::cmd::objects::selected(&h.state().session).unwrap();
assert_eq!(object.alt_text(), "A green circle");
assert!(object.is_decorative());
assert!(h.get_by_role_and_label(Role::MultilineTextInput, "Description:").accesskit_node().is_disabled());
}
#[test]
fn table_title_and_description_are_named_and_commit_independently() {
let mut app = WordApp::new(wordcraft_engine::Session::new(wordcraft_doc::Document::new()), crate::Services::default());
app.run("insert.table", json!({"rows": 1, "cols": 1})).unwrap();
let mut h = harness(app);
h.get_by_role_and_label(Role::TextInput, "Title:").click();
h.run_steps(2);
h.get_by_role_and_label(Role::TextInput, "Title:").type_text("Prices");
h.run_steps(2);
assert_eq!(h.get_by_role_and_label(Role::TextInput, "Title:").value().as_deref(), Some("Prices"));
h.get_by_role_and_label(Role::MultilineTextInput, "Description:").click();
h.run_steps(2);
h.get_by_role_and_label(Role::MultilineTextInput, "Description:").type_text("Prices by year");
h.run_steps(2);
assert_eq!(h.get_by_role_and_label(Role::MultilineTextInput, "Description:").value().as_deref(), Some("Prices by year"));
h.get_by_role_and_label(Role::TextInput, "Title:").click();
h.run_steps(2);
let app = h.state();
let focus = &app.session.sel.focus;
let (path, _, _) = focus.path.cell().unwrap();
let table = app.session.doc.table(focus.story, &path).unwrap();
assert_eq!(table.props.caption.as_deref(), Some("Prices"));
assert_eq!(table.props.description.as_deref(), Some("Prices by year"));
}
}
+28 -1
View File
@@ -157,6 +157,14 @@ impl WordApp {
}
self.session.run("file.encrypt", &json!({"password": pw})).map_err(|e| e.to_string())?;
}
// Like a failed native save, a failed serialization or delivery keeps the save stamps.
let before_stamp = (
self.session.doc.settings.zoom,
self.session.doc.core.last_modified_by.clone(),
self.session.doc.core.created.clone(),
self.session.doc.core.modified.clone(),
self.session.doc.core.revision,
);
// A save is a save, download or not: advance the revision and modified stamp (#262).
if matches!(id, "file.save" | "file.saveAs") {
self.session.stamp_save();
@@ -165,7 +173,19 @@ impl WordApp {
let password =
if matches!(id, "file.save" | "file.saveAs") { self.session.password.as_ref().map(wordcraft_engine::Password::as_str) } else { None };
let opts = wordcraft_engine::cmd::file::export_options(&self.session, &params);
let bytes = wordcraft_engine::io::save_bytes_with(&name, &self.session.doc, password, &opts)?;
let bytes = match wordcraft_engine::io::save_bytes_with(&name, &self.session.doc, password, &opts) {
Ok(bytes) => bytes,
Err(error) => {
(
self.session.doc.settings.zoom,
self.session.doc.core.last_modified_by,
self.session.doc.core.created,
self.session.doc.core.modified,
self.session.doc.core.revision,
) = before_stamp;
return Err(error);
}
};
// A ticket left over from an earlier call isn't this save's.
let saves = self.services.async_saves.clone();
if let Some(saves) = &saves {
@@ -185,6 +205,13 @@ impl WordApp {
(None, None) => Ok(()),
};
if let Err(e) = delivered {
(
self.session.doc.settings.zoom,
self.session.doc.core.last_modified_by,
self.session.doc.core.created,
self.session.doc.core.modified,
self.session.doc.core.revision,
) = before_stamp;
let msg = i18n::fmt(tl!("Couldn't download {name}: {error}"), &[("name", &name), ("error", &e)]);
log::error!("download of {name} failed: {e}");
self.status(msg.clone());
+67 -5
View File
@@ -635,17 +635,27 @@ fn open_list(app: &mut WordApp, ui: &mut Ui) {
let shown = app.ui.recent.iter().take(app.ui.recent_shown()).cloned().collect::<Vec<_>>();
let file_name = |p: &str| std::path::Path::new(p).file_name().map(|n| n.to_string_lossy().to_string()).unwrap_or(p.to_string());
let names = shown.iter().map(|p| file_name(p)).collect::<Vec<_>>();
let (mut focused, mut hovered) = (None, None);
use egui::epaint::text::TextDirection;
for (p, name) in shown.iter().zip(&names) {
// #2716: each row carries its own Remove, as Word's context menu does. The × is a button
// of its own at the trailing end, so it never opens the document; clicking the rest of the
// row opens it as before.
let (r, resp) = ui.allocate_exact_size(vec2(ui.available_width().min(700.0) - REMOVE_W, 40.0), Sense::click());
// The row shows a name and a path that may not fit: the path in full is its tooltip.
let resp = resp.on_hover_text(crate::i18n::isolate_path(p));
// Two documents with the same file name are told apart by their path, as on screen.
let spoken = if names.iter().filter(|n| *n == name).count() > 1 { format!("{name}, {p}") } else { name.clone() };
let twin = names.iter().filter(|n| *n == name).count() > 1;
let spoken = if twin { format!("{name}, {p}") } else { name.clone() };
resp.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, ui.is_enabled(), &spoken));
// Only one row shows its path as a tooltip, so every row gives a screen reader the path
// itself, unless its label already says it.
if !twin {
ui.ctx().accesskit_node_builder(resp.id, |node| node.set_description(crate::i18n::isolate_path(p)));
}
if resp.has_focus() {
focused = Some((resp.clone(), p));
}
if resp.hovered() {
hovered = Some((resp.clone(), p));
ui.painter().rect_filled(r, 4.0, t.hover);
}
// Names and paths are set apart (a right-to-left line would scramble their marks and
@@ -659,8 +669,25 @@ fn open_list(app: &mut WordApp, ui: &mut Ui) {
t.accent,
);
let side = crate::rtl::lead_center(rtl);
ui.painter().text(pos2(crate::rtl::lead_x(rtl, r, 40.0), r.min.y + 13.0), side, crate::i18n::isolate(name), medium(13.0), t.text);
ui.painter().text(pos2(crate::rtl::lead_x(rtl, r, 40.0), r.min.y + 29.0), side, crate::i18n::isolate_path(p), regular(11.0), t.text_dim);
// A wide row on Home can push the row past the visible area at small window sizes, so the
// text stops at the visible edge and its ellipsis stays in view. Only its far end does: it
// starts at the row's start, in view or not.
let clip = ui.clip_rect();
let room = if rtl { r.max.x - r.min.x.max(clip.min.x) } else { r.max.x.min(clip.max.x) - r.min.x };
let text_w = (room - 48.0).max(0.0);
let fit = |text: String, direction: TextDirection, font: egui::FontId, color: egui::Color32, y: f32| {
let mut job = egui::text::LayoutJob::simple_singleline(text, font, color);
job.direction = direction;
job.wrap = egui::text::TextWrapping::truncate_at_width(text_w);
let g = ui.painter().layout_job(job);
let at = side.anchor_size(pos2(crate::rtl::lead_x(rtl, r, 40.0), y), g.size()).min;
ui.painter().galley(at, g, color);
};
// An isolate hides a right-to-left name's direction from its line, which would put the
// ellipsis beside the name's first letters.
let direction = if wordcraft_doc::bidi::first_strong_is_rtl(name) { TextDirection::RightToLeft } else { TextDirection::Auto };
fit(crate::i18n::isolate(name), direction, medium(13.0), t.text, r.min.y + 13.0);
fit(crate::i18n::isolate_path(p), TextDirection::Auto, regular(11.0), t.text_dim, r.min.y + 29.0);
let xr = Rect::from_min_max(pos2(r.max.x + 2.0, r.min.y + 4.0), pos2(r.max.x + REMOVE_W, r.max.y - 4.0));
// Right-to-left: the × sits on the left, past the row's trailing edge.
let xr = if rtl { xr.translate(vec2(-(r.width() + REMOVE_W + 2.0), 0.0)) } else { xr };
@@ -691,6 +718,41 @@ fn open_list(app: &mut WordApp, ui: &mut Ui) {
{
let _ = app.run("ui.recentClear", json!({}));
}
// A row shows a name and a path that may not fit: the path in full is its tooltip, for the
// hovered row or, after a key press, the focused one. egui shows one tooltip per layer, so
// only one of them is drawn, and the focus tooltip lets the pointer through to the rows below.
let keyboard = recent_keyboard_last(ui);
match (focused, hovered) {
(Some((resp, p)), hovered) if keyboard || hovered.is_none() => {
egui::Tooltip::for_widget(&resp).show(|ui| ui.label(crate::i18n::isolate_path(p)));
}
(_, Some((resp, p))) => {
resp.on_hover_text(crate::i18n::isolate_path(p));
}
_ => {}
}
}
/// Was a key pressed more recently than the pointer moved? Kept across passes, so a focused
/// Recent row keeps its tooltip while the pointer rests on another row.
fn recent_keyboard_last(ui: &Ui) -> bool {
let id = egui::Id::unique("backstage_recent_keyboard_last");
let now = ui.input(|i| {
if i.pointer.delta() != egui::Vec2::ZERO {
Some(false)
} else if i.events.iter().any(|e| matches!(e, egui::Event::Key { pressed: true, .. })) {
Some(true)
} else {
None
}
});
match now {
Some(keyboard) => {
ui.ctx().data_mut(|d| d.insert_temp(id, keyboard));
keyboard
}
None => ui.ctx().data(|d| d.get_temp(id)).unwrap_or(false),
}
}
/// Stable storage id for the Recent list's open error.
+283
View File
@@ -75,6 +75,289 @@ fn opening_a_missing_recent_file_keeps_file_open_with_the_error() {
assert!(app.ui.backstage, "File stays open");
}
/// Opens File > Home in a window of `size` with one long Recent entry; returns its name and path.
fn long_recent_harness(size: egui::Vec2) -> (egui_kittest::Harness<'static, WordApp>, String, String) {
let name = format!("{}.docx", "AVeryLongDocumentName".repeat(8));
let path = format!("C:/Users/Someone/{}/{name}", "LongFolderName".repeat(20));
(recent_harness(std::slice::from_ref(&path), size), name, path)
}
/// Opens File > Home in a window of `size` with `recent` as the Recent list.
fn recent_harness(recent: &[String], size: egui::Vec2) -> egui_kittest::Harness<'static, WordApp> {
let mut a = WordApp::new(wordcraft_engine::Session::new(wordcraft_doc::Document::new()), Services::default());
a.ui.recent = recent.to_vec();
a.run("ui.backstage", json!({"value": true, "page": "home"})).unwrap();
let mut h = egui_kittest::Harness::builder().with_size(size).build_ui_state(
|ui, app: &mut WordApp| {
let ctx = ui.ctx().clone();
app.logic(&ctx);
app.ui(ui);
},
a,
);
h.run_steps(4);
h
}
/// Collects every text shape, including those nested in shape lists.
fn collect_text<'a>(s: &'a egui::Shape, out: &mut Vec<&'a egui::epaint::TextShape>) {
match s {
egui::Shape::Text(ts) => out.push(ts),
egui::Shape::Vec(v) => {
for child in v {
collect_text(child, out);
}
}
_ => {}
}
}
/// Returns the painted bounds and clip rect of the Recent entry's name and path texts, and
/// whether each ends with an ellipsis.
fn recent_text_bounds(h: &egui_kittest::Harness<'_, WordApp>) -> Vec<(String, egui::Rect, egui::Rect, bool)> {
let mut found = Vec::new();
for cs in &h.output().shapes {
let mut texts = Vec::new();
collect_text(&cs.shape, &mut texts);
for ts in texts {
let text = ts.galley.text();
if text.contains("C:/Users/Someone") || text.contains("AVeryLongDocumentName") {
let ellipsis = ts.galley.rows.first().and_then(|row| row.glyphs.last()).is_some_and(|g| g.chr == '\u{2026}');
found.push((text.to_owned(), ts.visual_bounding_rect(), cs.clip_rect, ellipsis));
}
}
}
found
}
/// #5212: long names and paths in File > Home > Recent shorten to fit their row and show on hover.
#[test]
fn recent_shortens_a_long_name_and_path_to_its_row() {
let (mut h, name, path) = long_recent_harness(egui::vec2(1440.0, 900.0));
let row = h.get_by_label(&name).rect();
let texts = recent_text_bounds(&h);
assert_eq!(texts.len(), 2, "both file name and path shapes must be found");
for (text, bounds, _, ellipsis) in &texts {
assert!(*ellipsis, "text '{text}' must end with an ellipsis");
assert!(bounds.max.x <= row.max.x + 0.5, "text '{text}' bounds.max.x ({}) > row.max.x + 0.5 ({})", bounds.max.x, row.max.x + 0.5);
}
h.event(egui::Event::PointerMoved(row.center()));
h.run_steps(4);
h.get_by_label(&path);
}
/// #5212: at the smallest window width the shortened texts end inside the visible area, so the
/// ellipsis is not cut off.
#[test]
fn recent_texts_end_inside_the_visible_area_at_the_smallest_window() {
let (h, _, _) = long_recent_harness(egui::vec2(760.0, 480.0));
let texts = recent_text_bounds(&h);
assert_eq!(texts.len(), 2, "both file name and path shapes must be found");
for (text, bounds, clip, ellipsis) in &texts {
assert!(*ellipsis, "text '{text}' must end with an ellipsis");
assert!(bounds.max.x <= clip.max.x + 0.5, "text '{text}' ends at {} past the visible edge {}", bounds.max.x, clip.max.x);
}
}
/// #5212: a Recent row focused with the keyboard shows its full path, as hovering does.
#[test]
fn recent_shows_the_full_path_when_a_row_has_keyboard_focus() {
let (mut h, name, path) = long_recent_harness(egui::vec2(1440.0, 900.0));
assert!(h.query_by_label(&path).is_none(), "the full path must not show before focus");
h.get_by_label(&name).focus();
h.run_steps(4);
h.get_by_label(&path);
}
/// #5212: the focus tooltip lets the pointer through, so the Recent row under it still gets
/// hovered, shows its own path and opens on click.
#[test]
#[cfg(not(target_arch = "wasm32"))]
fn recent_focus_tooltip_does_not_block_the_row_below() {
let dir = std::env::temp_dir().join(format!("wordcraft-5212-{}", std::process::id()));
let paths = ["one.docx", "two.docx"].map(|n| dir.join(n).to_string_lossy().to_string());
let mut h = recent_harness(&paths, egui::vec2(1440.0, 900.0));
h.get_by_label("one.docx").focus();
h.run_steps(4);
let tip = h.get_by_label(&paths[0]).rect();
let below = tip.intersect(h.get_by_label("two.docx").rect());
assert!(below.is_positive(), "the focus tooltip must cover part of the next row: tip={tip:?}");
h.event(egui::Event::PointerMoved(below.center()));
h.run_steps(4);
h.get_by_label(&paths[1]);
for pressed in [true, false] {
h.event(egui::Event::PointerButton { pos: below.center(), button: egui::PointerButton::Primary, pressed, modifiers: egui::Modifiers::NONE });
h.run_steps(1);
}
h.run_steps(3);
let error = h.ctx.data(|d| d.get_temp::<String>(super::open_error_id())).unwrap_or_default();
assert!(error.contains("two.docx"), "the click must reach two.docx and try to open it, got error '{error}'");
}
/// #5212: every Recent row gives a screen reader its full path, not only the hovered or
/// focused row that shows the path as a tooltip.
#[test]
fn recent_rows_describe_their_full_path_without_hover_or_focus() {
use egui_kittest::kittest::NodeT;
let dir = std::env::temp_dir().join("wordcraft-5212-describe");
let paths = ["one.docx", "two.docx"].map(|n| dir.join(n).to_string_lossy().to_string());
let mut h = recent_harness(&paths, egui::vec2(1440.0, 900.0));
let one = h.get_by_label("one.docx").rect();
h.event(egui::Event::PointerMoved(one.center()));
h.run_steps(4);
for (name, path) in ["one.docx", "two.docx"].iter().zip(&paths) {
let described = h.get_by_label(name).accesskit_node().description();
assert_eq!(described.as_deref(), Some(crate::i18n::isolate_path(path).as_str()), "{name} must describe its full path");
}
}
/// A right-to-left language for the Recent tests. `rtl` goes by its code, so it needs no Arabic font.
fn recent_right_to_left() -> crate::i18n::Lang {
crate::i18n::fixture_lang("ar", "\tHome\tHome\n")
}
/// The Recent list alone with one `path`, in `lang`, in a window 1000 wide. `start` points on the
/// side its rows start from and `end` points on the other side are out of view, as on a page
/// scrolled sideways or wider than the window.
fn recent_list_cut(path: &str, lang: crate::i18n::Lang, start: f32, end: f32) -> egui_kittest::Harness<'static, WordApp> {
let mut a = WordApp::new(wordcraft_engine::Session::new(wordcraft_doc::Document::new()), Services::default());
a.ui.recent = vec![path.to_string()];
let mut h = egui_kittest::Harness::builder().with_size(egui::vec2(1000.0, 500.0)).build_ui_state(
move |ui, app: &mut WordApp| {
let ctx = ui.ctx().clone();
app.logic(&ctx);
crate::i18n::set_current(lang);
crate::rtl::sync(&ctx);
let mut clip = ui.clip_rect();
let (left, right) = if crate::rtl::on() { (end, start) } else { (start, end) };
clip.min.x += left;
clip.max.x -= right;
ui.set_clip_rect(clip);
super::open_list(app, ui);
},
a,
);
h.run_steps(4);
h
}
/// #5212: text runs from its row's start, so a row whose start is out of view has as much room
/// for its text as before. Only the far end stops at the visible edge.
#[test]
fn recent_text_keeps_its_room_when_its_row_starts_out_of_view() {
let name = format!("{}.docx", "AVeryLongDocumentName".repeat(8));
let path = format!("C:/Users/Someone/{name}");
for lang in [crate::i18n::Lang::EN, recent_right_to_left()] {
let widths = |cut| recent_text_bounds(&recent_list_cut(&path, lang, cut, 0.0)).iter().map(|t| t.1.width().round()).collect::<Vec<_>>();
let whole = widths(0.0);
assert_eq!(whole.len(), 2, "both lines must be painted: {whole:?}");
assert_eq!(widths(500.0), whole, "the cut must not take room from the text");
}
crate::i18n::set_current(crate::i18n::Lang::EN);
}
/// #5212: a row running past the visible area stops its text there, in either direction, with
/// its ellipsis in view.
#[test]
fn recent_text_stops_at_the_visible_edge_in_either_direction() {
let name = format!("{}.docx", "AVeryLongDocumentName".repeat(8));
let path = format!("C:/Users/Someone/{name}");
for lang in [crate::i18n::Lang::EN, recent_right_to_left()] {
let texts = recent_text_bounds(&recent_list_cut(&path, lang, 0.0, 400.0));
assert_eq!(texts.len(), 2, "both lines must be painted");
for (text, bounds, clip, ellipsis) in &texts {
assert!(
bounds.left() >= clip.left() - 0.5 && bounds.right() <= clip.right() + 0.5,
"{text} must end inside the visible area: {bounds:?} in {clip:?}"
);
assert!(ellipsis, "{text} must end in an ellipsis");
}
}
crate::i18n::set_current(crate::i18n::Lang::EN);
}
/// #5212: multibyte text is cut between its characters and stays in its row, starting at the
/// side the row starts from, in either direction.
#[test]
fn recent_shortens_multibyte_text_in_either_direction() {
let name = format!("AVeryLongDocumentName{}.docx", "\u{fc}\u{20ac}".repeat(120));
let path = format!("C:/Users/Someone/{name}");
for lang in [crate::i18n::Lang::EN, recent_right_to_left()] {
let h = recent_list_cut(&path, lang, 0.0, 0.0);
let row = h.get_by_label(&name).rect();
let texts = recent_text_bounds(&h);
assert_eq!(texts.len(), 2, "both lines must be painted");
for (text, bounds, _, ellipsis) in &texts {
let lead = if lang.rtl() { row.right() - bounds.right() } else { bounds.left() - row.left() };
assert!((lead - 40.0).abs() < 1.0, "{text} must start at its row's start: {bounds:?} in {row:?}");
assert!(bounds.left() >= row.left() - 0.5 && bounds.right() <= row.right() + 0.5, "{text} must stay in its row: {bounds:?} in {row:?}");
assert!(ellipsis, "{text} must end in an ellipsis");
}
}
crate::i18n::set_current(crate::i18n::Lang::EN);
}
/// #5212: a right-to-left name runs from the right, so it is cut on its left, and its ellipsis
/// belongs there, not beside the name's first letters.
#[test]
fn recent_puts_the_ellipsis_at_the_end_of_a_right_to_left_name() {
let name = format!("{}.docx", "\u{5d0}\u{5d1}\u{5d2} ".repeat(120));
let h = recent_list_cut(&format!("/docs/{name}"), recent_right_to_left(), 0.0, 0.0);
let output = h.output();
let mut texts = Vec::new();
for clipped in &output.shapes {
collect_text(&clipped.shape, &mut texts);
}
let shown = texts.iter().find(|t| t.galley.text().contains('\u{5d0}')).expect("the name");
let glyphs = &shown.galley.rows[0].glyphs;
let ellipsis = glyphs.iter().find(|g| g.chr == '\u{2026}').expect("an ellipsis");
let left = glyphs.iter().filter(|g| g.size().x > 0.0).map(|g| g.pos.x).fold(f32::MAX, f32::min);
assert!(ellipsis.pos.x <= left + 0.5, "the ellipsis must be the leftmost glyph: {} against {left}", ellipsis.pos.x);
crate::i18n::set_current(crate::i18n::Lang::EN);
}
/// #5212: two files with one name speak their path in the label, so it isn't read twice.
#[test]
fn recent_rows_with_one_name_speak_their_path_once() {
use egui_kittest::kittest::NodeT;
let dir = std::env::temp_dir().join("wordcraft-5212-twins");
let paths = ["one", "two"].map(|d| dir.join(d).join("same.docx").to_string_lossy().to_string());
let h = recent_harness(&paths, egui::vec2(1440.0, 900.0));
for path in &paths {
let label = format!("same.docx, {path}");
assert_eq!(h.get_by_label(&label).accesskit_node().description(), None, "{label} must not repeat its path");
}
}
/// #5212: with the pointer resting on one Recent row, Tab to the next row shows the focused
/// row's path, and moving the pointer again brings back the hovered row's path.
#[test]
fn recent_tab_shows_the_focused_path_while_the_pointer_rests_on_another_row() {
let dir = std::env::temp_dir().join("wordcraft-5212-tab");
let paths = ["one.docx", "two.docx"].map(|n| dir.join(n).to_string_lossy().to_string());
let mut h = recent_harness(&paths, egui::vec2(1440.0, 900.0));
let one = h.get_by_label("one.docx").rect();
h.event(egui::Event::PointerMoved(one.center()));
h.run_steps(4);
h.get_by_label(&paths[0]);
h.get_by_label("one.docx").focus();
h.run_steps(1);
// The first Tab goes to the row's own Remove ×, the second to the next row.
for _ in 0..2 {
h.key_press(egui::Key::Tab);
h.run_steps(4);
}
assert!(h.get_by_label("two.docx").is_focused(), "Tab must move focus to the next Recent row");
assert!(h.query_by_label(&paths[1]).is_some(), "the focused row's path must show while the pointer rests on another row");
h.event(egui::Event::PointerMoved(one.center() + egui::vec2(4.0, 0.0)));
h.run_steps(4);
assert!(h.query_by_label(&paths[0]).is_some(), "moving the pointer must bring back the hovered row's path");
}
/// #1873: the macOS back chevron sits beside the traffic lights windowed, at the plain
/// control inset in full screen.
#[test]
+6 -8
View File
@@ -64,7 +64,7 @@ use navigation::{scrollbar_page_tip, viewed_page};
use pages::{DRAWING_GRID_MAX_LINES, DRAWING_GRID_MIN_PX};
pub(crate) use pages::{PageKeys, dark_page, page_doc, page_screen_scale, preview_sel, screen_render_options};
use pages::{
drawing_grid, drawing_grid_step, gridline_cells, page_image, page_key, page_render_options, page_shows, shown_layout, texel_aligned_rect,
drawing_grid, drawing_grid_step, gridline_segments, page_image, page_key, page_render_options, page_shows, shown_layout, texel_aligned_rect,
view_key, visible_tiles,
};
pub(crate) use reading::turn_read_page;
@@ -1278,14 +1278,12 @@ fn paint_pages(pass: PagePaint<'_>) -> PagePaintOutput {
}
draw_page_gridlines(app, &painter, t, page, visual_sr, page_scale);
// The current header/footer's cells have editing guides; explicit View Gridlines
// still outlines every table. Neither kind of guide is part of the document.
// still outlines every table. Both are drawn only where no border is (#5967), and
// neither kind of guide is part of the document.
if app.session.view.table_gridlines || grid_story.is_some() {
for rect in gridline_cells(page, app.session.view.table_gridlines, grid_story) {
let r = Rect::from_min_size(
pos2(visual_sr.min.x + rect.x * page_scale, visual_sr.min.y + rect.y * page_scale),
vec2(rect.w * page_scale, rect.h * page_scale),
);
painter.rect_stroke(r, 0.0, Stroke::new(0.5, t.blue.linear_multiply(0.6)), egui::StrokeKind::Middle);
let at = |p: wordcraft_geom::Point| pos2(visual_sr.min.x + p.x * page_scale, visual_sr.min.y + p.y * page_scale);
for (a, b) in gridline_segments(page, app.session.view.table_gridlines, grid_story) {
painter.line_segment([at(a), at(b)], Stroke::new(0.5, t.blue.linear_multiply(0.6)));
}
}
}
+78
View File
@@ -171,6 +171,84 @@ pub(super) fn gridline_cells(page: &Page, all: bool, editing: Option<StoryRef>)
})
}
/// The table gridline segments to draw on a page, in document points: the edges of the
/// [`gridline_cells`] minus the parts a printed border already draws. Word shows gridlines only
/// where a cell has no border; drawn over a border, the thin blue guide tinted every bordered
/// table blue and made its lines look uneven when zoomed out (#5967).
pub(super) fn gridline_segments(page: &Page, all: bool, editing: Option<StoryRef>) -> Vec<(wordcraft_geom::Point, wordcraft_geom::Point)> {
use wordcraft_geom::Point;
// A rule this close to a cell edge (points) is drawn on it.
const ON_EDGE: f32 = 0.25;
// Rules by the line they run along (horizontal or not, coordinate in quarter points), so
// each cell edge looks only at the rules on its own line. Body rules cannot cover header or
// footer cells, so they are left out when only those are outlined, as in `gridline_cells`.
let key = |c: f32| (c * 4.0).round() as i64;
let body = if all { page.items.as_slice() } else { &[] };
let mut rules: std::collections::HashMap<(bool, i64), Vec<(f32, f32, f32)>> = std::collections::HashMap::new();
for it in body.iter().chain(&page.header).chain(&page.footer) {
let Placed::Rule { x0, y0, x1, y1, border } = it else { continue };
if !border.is_visible() {
continue;
}
let (horizontal, c0, c1, s0, s1) = if (y0 - y1).abs() <= ON_EDGE { (true, *y0, *y1, *x0, *x1) } else { (false, *x0, *x1, *y0, *y1) };
if (c0 - c1).abs() <= ON_EDGE && c0.is_finite() {
rules.entry((horizontal, key(c0))).or_default().push((c0, s0.min(s1), s0.max(s1)));
}
}
// The rules covering the line at `at`, sorted and merged into disjoint spans. Cells share their
// edges, so each distinct line is sorted once (not once per cell edge) and every edge then
// binary-searches its start.
let mut merged: std::collections::HashMap<(bool, u32), Vec<(f32, f32)>> = std::collections::HashMap::new();
// The parts of [a, b] along a line at `at` that no rule on the same line covers; `horizontal`
// picks rules running along x at y = `at`, otherwise along y at x = `at`.
let mut uncovered = |horizontal: bool, at: f32, a: f32, b: f32| -> Vec<(f32, f32)> {
let covers = merged.entry((horizontal, at.to_bits())).or_insert_with(|| {
let k = key(at);
let mut covers: Vec<(f32, f32)> = (k - 1..=k + 1)
.filter_map(|k| rules.get(&(horizontal, k)))
.flatten()
.filter(|(c, _, _)| (c - at).abs() <= ON_EDGE)
.map(|&(_, s0, s1)| (s0, s1))
.collect();
covers.sort_by(|p, q| p.0.total_cmp(&q.0));
let mut spans: Vec<(f32, f32)> = Vec::with_capacity(covers.len());
for (c0, c1) in covers {
match spans.last_mut() {
Some(last) if c0 <= last.1 + ON_EDGE => last.1 = last.1.max(c1),
_ => spans.push((c0, c1)),
}
}
spans
});
let mut out = Vec::new();
let mut from = a;
for &(c0, c1) in &covers[covers.partition_point(|s| s.1 < a)..] {
if c0 > from + ON_EDGE {
out.push((from, c0.min(b)));
}
from = from.max(c1);
if from >= b {
break;
}
}
if from + ON_EDGE < b {
out.push((from, b));
}
out
};
let mut segs = Vec::new();
for r in gridline_cells(page, all, editing) {
let (l, t, rt, bt) = (r.x, r.y, r.x + r.w, r.y + r.h);
for y in [t, bt] {
segs.extend(uncovered(true, y, l, rt).into_iter().map(|(a, b)| (Point::new(a, y), Point::new(b, y))));
}
for x in [l, rt] {
segs.extend(uncovered(false, x, t, bt).into_iter().map(|(a, b)| (Point::new(x, a), Point::new(x, b))));
}
}
segs
}
/// The drawing grid's spacing in points at a screen scale: the document's spacing (`w:drawingGrid*Spacing`;
/// ECMA-376's 1/8 inch when it doesn't say), doubled until the lines are at least
/// [`DRAWING_GRID_MIN_PX`] apart on screen.
+97
View File
@@ -1,3 +1,4 @@
use super::pages::gridline_cells;
use super::*;
use crate::table_resize::tests::{H, cell, screen, steps, table_window};
@@ -3563,6 +3564,102 @@ fn table_gridlines_include_header_and_footer_tables() {
assert!(ys(None).is_empty(), "closing header/footer editing removes the automatic guides");
}
/// #5967: gridlines show only where a cell has no printed border, as in Word; drawn over the
/// border they tinted every bordered table blue.
#[test]
fn table_gridlines_skip_edges_a_border_draws() {
use wordcraft_geom::Point;
let cell = Placed::Cell {
rect: wordcraft_geom::Rect::new(0.0, 0.0, 10.0, 20.0),
covered: false,
table: Default::default(),
row: 0,
cell: 0,
story: StoryRef::Body,
clip: false,
};
let rule = |x0, y0, x1, y1, border| Placed::Rule { x0, y0, x1, y1, border };
let line = wordcraft_doc::props::Border::single(0.5);
let none = wordcraft_doc::props::Border::single(0.0);
let page = Page {
items: vec![
// Top border over the whole edge (run on past the corners, as layout draws it).
rule(-0.25, 0.0, 10.25, 0.0, line),
// Left border over the top half only.
rule(0.0, 0.0, 0.0, 10.0, line),
// A zero-width border draws nothing, so the right edge keeps its gridline.
rule(10.0, 0.0, 10.0, 20.0, none),
cell,
],
..Default::default()
};
// Overlapping rules out of order on one line leave only the gap between them: the bottom
// edge keeps 4..6 alone.
let mut gapped = page.clone();
gapped.items.extend([
rule(5.0, 20.0, 10.0, 20.0, line),
rule(-0.25, 20.0, 3.0, 20.0, line),
rule(1.0, 20.0, 4.0, 20.0, line),
rule(6.0, 20.0, 5.5, 20.0, line),
]);
assert_eq!(gridline_segments(&gapped, true, None).first(), Some(&(Point::new(4.0, 20.0), Point::new(5.0, 20.0))));
assert_eq!(gridline_segments(&gapped, true, None).len(), 3);
let segs = gridline_segments(&page, true, None);
assert_eq!(
segs,
[
(Point::new(0.0, 20.0), Point::new(10.0, 20.0)), // bottom: no border
(Point::new(0.0, 10.0), Point::new(0.0, 20.0)), // left: below the border
(Point::new(10.0, 0.0), Point::new(10.0, 20.0)), // right: invisible border
]
);
}
/// #5967: the gridlines of a table with very many rows are found in one pass over the rules, not
/// by re-sorting every rule on a line for each cell edge on it (a long table repainted slowly).
#[test]
fn table_gridlines_of_a_many_row_table_are_fast() {
const ROWS: usize = 30_000;
let line = wordcraft_doc::props::Border::single(0.5);
let mut items = Vec::new();
for i in 0..ROWS {
let y = i as f32 * 10.0;
items.push(Placed::Cell {
rect: wordcraft_geom::Rect::new(0.0, y, 10.0, 10.0),
covered: false,
table: Default::default(),
row: i,
cell: 0,
story: StoryRef::Body,
clip: false,
});
// One border piece per row on each side, so both vertical lines carry a rule per row.
for x in [0.0, 10.0] {
items.push(Placed::Rule { x0: x, y0: y, x1: x, y1: y + 10.0, border: line });
}
}
let page = Page { items, ..Default::default() };
let start = std::time::Instant::now();
let segs = gridline_segments(&page, true, None);
// Both sides are covered; the top and bottom of every cell are not.
assert_eq!(segs.len(), 2 * ROWS);
assert!(segs.iter().all(|(a, b)| a.y == b.y));
assert!(start.elapsed() < std::time::Duration::from_secs(5), "took {:?}", start.elapsed());
}
/// #5967: a new table has borders on every edge, so it shows no gridline at all; with its
/// borders removed every edge shows one.
#[test]
fn a_bordered_table_shows_no_gridlines() {
let mut a = WordApp::new(wordcraft_engine::Session::new(wordcraft_doc::Document::new()), Default::default());
a.run("insert.table", json!({"rows": 2, "cols": 3})).unwrap();
assert!(a.session.view.table_gridlines, "View Gridlines is on by default");
let segs = |a: &mut WordApp| gridline_segments(&a.session.layout().pages[0], true, None).len();
assert_eq!(segs(&mut a), 0);
a.run("table.borders", json!({"kind": "none"})).unwrap();
assert_eq!(segs(&mut a), 6 * 4, "every edge of the six cells");
}
#[test]
fn drawing_grid_starts_at_the_margins_and_stays_inside_them() {
// Letter page with 1" margins: the text area is 468 x 648 pt from (72, 72).
@@ -93,6 +93,45 @@ pub const NUMBER_FORMATS: &[(&str, &str)] = &[
("OrdText", "First, Second, Third, …"),
];
/// Capitalization formats for the `\*` switch of a text field: (switch value, label).
pub const TEXT_FORMATS: &[(&str, &str)] =
&[("", "(none)"), ("Upper", "Uppercase"), ("Lower", "Lowercase"), ("FirstCap", "First capital"), ("Caps", "Title case")];
/// Whether the dialog offers the capitalization Format list for `name` (the fields whose result
/// is text).
pub fn takes_text_format(name: &str) -> bool {
matches!(name, "AUTHOR" | "COMMENTS" | "FILENAME" | "KEYWORDS" | "LASTSAVEDBY" | "SUBJECT" | "TITLE" | "REF" | "STYLEREF" | "MERGEFIELD")
}
/// The capitalization switches in a field code, as their [`TEXT_FORMATS`] values, in the order
/// they appear (layout applies them in that order). Quoted text in the code is not a switch.
pub fn text_formats(code: &str) -> Vec<&'static str> {
let mut chars = code.chars().peekable();
let mut quoted = false;
let mut all = Vec::new();
while let Some(c) = chars.next() {
match c {
'\\' if quoted => {
chars.next();
}
'"' => quoted = !quoted,
'\\' if chars.peek() == Some(&'*') => {
chars.next();
while chars.next_if(|c| c.is_whitespace()).is_some() {}
let mut word = String::new();
while let Some(c) = chars.next_if(|c| !c.is_whitespace() && *c != '\\' && *c != '"') {
word.push(c);
}
if let Some((v, _)) = TEXT_FORMATS.iter().find(|(v, _)| !v.is_empty() && v.eq_ignore_ascii_case(&word)) {
all.push(*v);
}
}
_ => {}
}
}
all
}
pub fn field_kind(name: &str) -> FieldKind {
match name {
"DATE" | "TIME" | "CREATEDATE" | "SAVEDATE" | "PRINTDATE" => FieldKind::Date,
@@ -117,6 +156,12 @@ pub struct FieldForm {
pub date_format: String,
/// `\*` value for number fields (empty = none).
pub number_format: String,
/// `\*` capitalization value for text fields (empty = none).
pub text_format: String,
/// Every capitalization switch of the code typed in Field Codes, in order. The code keeps them
/// all while the Format list shows the last of them.
#[serde(skip)]
typed_text_formats: Vec<&'static str>,
/// Bookmark (REF, PAGEREF), sequence name (SEQ), merge field (MERGEFIELD) or style name
/// (STYLEREF).
pub target: String,
@@ -148,6 +193,8 @@ impl FieldForm {
name: "DATE".into(),
date_format: DATE_FORMATS.first().copied().unwrap_or("M/d/yyyy").to_string(),
number_format: String::new(),
text_format: String::new(),
typed_text_formats: Vec::new(),
target: String::new(),
preserve: true,
codes: false,
@@ -178,6 +225,8 @@ impl FieldForm {
pub fn select(&mut self, name: &str) {
self.name = name.to_string();
self.number_format.clear();
self.text_format.clear();
self.typed_text_formats.clear();
self.target = match field_kind(name) {
FieldKind::Bookmark => self.bookmarks.first().cloned().unwrap_or_default(),
FieldKind::Sequence => "Figure".into(),
@@ -230,6 +279,15 @@ impl FieldForm {
if matches!(field_kind(&self.name), FieldKind::Number | FieldKind::Sequence) && !self.number_format.is_empty() {
s.push_str(&format!(" \\* {}", self.number_format));
}
if takes_text_format(&self.name) && !self.text_format.is_empty() {
if self.typed_text_formats.last().is_some_and(|v| *v == self.text_format) {
for v in &self.typed_text_formats {
s.push_str(&format!(" \\* {v}"));
}
} else {
s.push_str(&format!(" \\* {}", self.text_format));
}
}
if self.preserve && field_kind(&self.name) != FieldKind::Toc {
s.push_str(" \\* MERGEFORMAT");
}
@@ -241,6 +299,27 @@ impl FieldForm {
if self.codes { self.code.trim().to_string() } else { self.instruction() }
}
/// The Format list: a choice replaces the capitalization switches kept from a typed code.
pub fn choose_text_format(&mut self, value: &str) {
self.text_format = value.to_string();
self.typed_text_formats.clear();
}
/// Field Codes / Hide Codes: showing the code starts it from the options; hiding it sets the
/// Format list to the code's last capitalization switch when the code is for the chosen field,
/// and keeps all of the code's capitalization switches until another Format is chosen.
pub fn toggle_codes(&mut self) {
if !self.codes {
self.code = self.instruction();
} else if takes_text_format(&self.name)
&& (wordcraft_layout::fields::field_name(&self.code) == self.name || self.name == "MERGEFIELD" && is_merge_field(&self.code))
{
self.typed_text_formats = text_formats(&self.code);
self.text_format = self.typed_text_formats.last().copied().unwrap_or_default().to_string();
}
self.codes = !self.codes;
}
/// The `insert.field` parameters (a merge field shows «name» until merged).
pub fn params(&self) -> Option<Value> {
let code = self.final_code();
@@ -248,13 +327,29 @@ impl FieldForm {
return None;
}
let name = wordcraft_layout::fields::field_name(&code);
Some(if name == "MERGEFIELD" { json!({"instr": code, "result": format!("«{}»", merge_field_name(&code))}) } else { json!({"instr": code}) })
Some(if name == "MERGEFIELD" || is_merge_field(&code) {
json!({"instr": code, "result": format!("«{}»", merge_field_name(&code))})
} else {
json!({"instr": code})
})
}
}
/// The byte where a field code's type ends: at a space or a quote, as mail merge reads it.
fn field_type_end(code: &str) -> usize {
code.find(|c: char| c.is_whitespace() || c == '"').unwrap_or(code.len())
}
/// Whether a typed code is a `MERGEFIELD`, including one with no space before its quoted name.
fn is_merge_field(code: &str) -> bool {
let code = code.trim_start();
code[..field_type_end(code)].eq_ignore_ascii_case("MERGEFIELD")
}
/// The merge field a `MERGEFIELD` code names (quoted names may hold spaces).
fn merge_field_name(code: &str) -> String {
let rest = code.trim_start().split_once(char::is_whitespace).map(|x| x.1.trim_start()).unwrap_or("");
let code = code.trim_start();
let rest = code[field_type_end(code)..].trim_start();
match rest.strip_prefix('"') {
Some(q) => q.split('"').next().unwrap_or("").to_string(),
None => rest.split_whitespace().next().unwrap_or("").to_string(),
@@ -318,10 +413,7 @@ pub(super) fn field_ui(app: &mut WordApp, ui: &mut Ui, f: &mut FieldForm) -> boo
ui.horizontal(|ui| {
let label = if f.codes { "Hide Codes" } else { "Field Codes" };
if ui.button(tl!(label)).clicked() {
if !f.codes {
f.code = f.instruction();
}
f.codes = !f.codes;
f.toggle_codes();
}
});
let params = f.params();
@@ -409,7 +501,21 @@ fn field_options(ui: &mut Ui, f: &mut FieldForm, t: &Tokens) {
}
}
FieldKind::Toc | FieldKind::Plain => {
ui.label(egui::RichText::new(tl!("This field has no options.")).small().color(t.text_dim));
if !takes_text_format(&f.name) {
ui.label(egui::RichText::new(tl!("This field has no options.")).small().color(t.text_dim));
}
}
}
if takes_text_format(&f.name) {
ui.add_space(4.0);
ui.label(tl!("Format:"));
let shown = TEXT_FORMATS.iter().find(|(v, _)| *v == f.text_format).map(|(_, l)| *l).unwrap_or("(none)");
craft_ui::ComboBox::from_id_salt("field_text").selected_text(tl!(shown)).width(200.0).show_ui(ui, |ui| {
for (v, l) in TEXT_FORMATS {
if ui.selectable_label(f.text_format == *v, tl!(l)).clicked() {
f.choose_text_format(v);
}
}
});
}
}
@@ -149,6 +149,141 @@ fn field_dialog_builds_the_instruction() {
assert!(f.params().is_none());
}
/// Text fields take a capitalization Format: each choice writes its `\*` switch before
/// `\* MERGEFORMAT`, after the field's own arguments and switches, and (none) writes none.
#[test]
fn field_dialog_text_format_writes_its_switch() {
let a = app();
let mut f = FieldForm::new(&a);
f.select("AUTHOR");
assert_eq!(f.text_format, "");
assert_eq!(f.instruction(), r"AUTHOR \* MERGEFORMAT");
for v in ["Upper", "Lower", "FirstCap", "Caps"] {
f.text_format = v.into();
assert_eq!(f.instruction(), format!(r"AUTHOR \* {v} \* MERGEFORMAT"));
}
let labels: Vec<&str> = field::TEXT_FORMATS.iter().map(|(_, l)| *l).collect();
assert_eq!(labels, ["(none)", "Uppercase", "Lowercase", "First capital", "Title case"]);
f.select("REF");
f.target = "intro".into();
f.text_format = "Upper".into();
assert_eq!(f.instruction(), r"REF intro \h \* Upper \* MERGEFORMAT");
f.select("STYLEREF");
f.style_switches = "l".into();
f.text_format = "Caps".into();
f.preserve = false;
assert_eq!(f.instruction(), r#"STYLEREF "Heading 1" \l \* Caps"#);
f.select("MERGEFIELD");
f.target = "City".into();
f.text_format = "Lower".into();
assert_eq!(f.params().unwrap(), json!({"instr": r"MERGEFIELD City \* Lower", "result": "«City»"}));
// Choosing another field starts from (none).
f.select("TITLE");
assert_eq!((f.text_format.as_str(), f.instruction().as_str()), ("", "TITLE"));
}
/// The list is offered for the text fields only; date, number, PAGEREF, SEQ and TOC keep their
/// own options and never take a capitalization switch from it.
#[test]
fn field_dialog_text_format_is_for_text_fields_only() {
for name in ["AUTHOR", "COMMENTS", "FILENAME", "KEYWORDS", "LASTSAVEDBY", "SUBJECT", "TITLE", "REF", "STYLEREF", "MERGEFIELD"] {
assert!(field::takes_text_format(name), "{name}");
}
let a = app();
let mut f = FieldForm::new(&a);
for name in ["DATE", "PAGE", "NUMPAGES", "PAGEREF", "SEQ", "TOC"] {
assert!(!field::takes_text_format(name), "{name}");
f.select(name);
let before = f.instruction();
f.text_format = "Upper".into();
assert_eq!(f.instruction(), before, "{name}");
}
}
/// Hide Codes sets the Format list from the typed code's last capitalization switch outside
/// quotes, and to (none) when the code has none.
#[test]
fn field_dialog_text_format_follows_the_typed_code() {
assert_eq!(field::text_formats(r#"AUTHOR "a \* Lower" \* upper \* Caps \* MERGEFORMAT"#), ["Upper", "Caps"]);
assert!(field::text_formats(r#"MERGEFIELD "x \* FirstCap""#).is_empty());
assert!(field::text_formats(r"PAGE \* roman").is_empty());
let a = app();
let mut f = FieldForm::new(&a);
f.select("SUBJECT");
f.toggle_codes();
assert_eq!(f.code, r"SUBJECT \* MERGEFORMAT");
f.code = r"SUBJECT \* FIRSTCAP \* MERGEFORMAT".into();
f.toggle_codes();
assert!(!f.codes);
assert_eq!(f.instruction(), r"SUBJECT \* FirstCap \* MERGEFORMAT");
f.toggle_codes();
f.code = "SUBJECT".into();
f.toggle_codes();
assert_eq!(f.text_format, "");
// A code for another field leaves the list as it was.
f.text_format = "Lower".into();
f.toggle_codes();
f.code = r"TITLE \* Upper".into();
f.toggle_codes();
assert_eq!(f.text_format, "Lower");
}
/// Hide Codes keeps every capitalization switch of the typed code, in order, so the inserted field
/// shows what the typed code shows; choosing another Format writes that one switch only.
#[test]
fn field_dialog_text_format_keeps_every_typed_case_switch() {
use wordcraft_layout::fields::apply_case_switch;
let a = app();
let mut f = FieldForm::new(&a);
f.select("SUBJECT");
f.toggle_codes();
f.code = r"SUBJECT \* Lower \* Caps".into();
let typed = apply_case_switch(&f.code, "WEEKLY REPORT".into());
assert_eq!(typed, "Weekly Report");
f.toggle_codes();
assert_eq!(f.text_format, "Caps");
assert_eq!(f.final_code(), r"SUBJECT \* Lower \* Caps \* MERGEFORMAT");
assert_eq!(apply_case_switch(&f.final_code(), "WEEKLY REPORT".into()), typed);
// Field Codes shows the same switches again.
f.toggle_codes();
assert_eq!(f.code, r"SUBJECT \* Lower \* Caps \* MERGEFORMAT");
f.toggle_codes();
// A Format the user chooses replaces the typed switches, and choosing Title case again
// does not bring them back.
f.choose_text_format("Upper");
assert_eq!(f.final_code(), r"SUBJECT \* Upper \* MERGEFORMAT");
f.choose_text_format("Caps");
assert_eq!(f.final_code(), r"SUBJECT \* Caps \* MERGEFORMAT");
f.choose_text_format("");
assert_eq!(f.final_code(), r"SUBJECT \* MERGEFORMAT");
// Choosing another field forgets them.
f.toggle_codes();
f.code = r"SUBJECT \* Lower \* Caps".into();
f.toggle_codes();
f.select("SUBJECT");
f.text_format = "Caps".into();
assert_eq!(f.final_code(), r"SUBJECT \* Caps \* MERGEFORMAT");
}
/// A typed `MERGEFIELD` code's type ends at a quote as well as a space, as mail merge reads it.
#[test]
fn field_dialog_reads_a_typed_merge_field_with_no_space_before_its_quote() {
let a = app();
let mut f = FieldForm::new(&a);
f.select("MERGEFIELD");
f.toggle_codes();
f.code = r#"MERGEFIELD"City" \* Lower"#.into();
assert_eq!(f.params().unwrap()["result"], "«City»");
f.toggle_codes();
assert_eq!(f.text_format, "Lower");
// Another field whose name only starts the same way is not this one.
f.choose_text_format("");
f.toggle_codes();
f.code = r"MERGEFIELDX \* Lower".into();
f.toggle_codes();
assert_eq!(f.text_format, "");
}
/// The Field dialog lists Word's document information fields, and the counts take a number
/// format.
#[test]
+22 -3
View File
@@ -234,8 +234,9 @@ pub fn customize_keyboard(app: &mut WordApp, ui: &mut Ui, f: &mut KeyboardForm)
}
});
crate::rtl::vertical(ui, |ui| {
ui.label(tl!("New shortcut:"));
close = capture(ui, f);
let label = tl!("New shortcut:");
ui.label(label);
close = capture(ui, f, label);
ui.add_space(4.0);
if !f.pressed.is_empty() {
let owner = match app.session.keymap.resolve(&reg, &f.pressed) {
@@ -291,7 +292,7 @@ pub fn customize_keyboard(app: &mut WordApp, ui: &mut Ui, f: &mut KeyboardForm)
/// The "New shortcut" box: takes keyboard focus and records the combination pressed.
/// True when plain Escape asks to close the dialog.
fn capture(ui: &mut Ui, f: &mut KeyboardForm) -> bool {
fn capture(ui: &mut Ui, f: &mut KeyboardForm, label: &str) -> bool {
let t = Tokens::get(ui.ctx());
let (rect, resp) = ui.allocate_exact_size(vec2(300.0, 26.0), Sense::click());
// Keys belong to the box whenever nothing else in the dialog has focus, so a shortcut pressed
@@ -312,6 +313,8 @@ fn capture(ui: &mut Ui, f: &mut KeyboardForm) -> bool {
f.pressed = k;
}
}
resp.widget_info(|| egui::WidgetInfo::labeled(egui::Role::TextInput, ui.is_enabled(), label));
ui.ctx().accesskit_node_builder(resp.id, |node| node.set_value(key_text(&f.pressed)));
let stroke = egui::Stroke::new(if focused { 1.5 } else { 1.0 }, if focused { t.accent } else { t.input_border });
ui.painter().rect(rect, 2.0, t.input, stroke, egui::StrokeKind::Inside);
let (text, color) = if f.pressed.is_empty() { (tl!("Press a key combination").to_string(), t.text_dim) } else { (key_text(&f.pressed), t.text) };
@@ -416,6 +419,22 @@ mod tests {
h
}
/// The shortcut capture field has a name and reports the combination it records.
#[test]
fn shortcut_capture_exposes_its_name_and_current_value() {
use egui::accesskit::Role;
use egui_kittest::kittest::Queryable;
let mut h = harness("", Some("format.bold"));
let input = h.get_by_role_and_label(Role::TextInput, "New shortcut:");
assert_eq!(input.value().as_deref(), Some(""));
input.focus();
h.run_steps(2);
h.key_press(egui::Key::F6);
h.run_steps(2);
assert_eq!(h.state().1.pressed, "F6");
assert_eq!(h.get_by_role_and_label(Role::TextInput, "New shortcut:").value().as_deref(), Some("F6"));
}
type KbHarness<'a> = egui_kittest::Harness<'a, (WordApp, super::KeyboardForm)>;
/// The area of the Commands list that is on screen: 170 high, below the title, the item
@@ -288,6 +288,7 @@ fn edge_glyph(ui: &mut Ui, edges: &str) {
fn align_button(ui: &mut Ui, (v, h): (VAlign, Align), on: bool, tip: &str) -> egui::Response {
let t = Tokens::get(ui.ctx());
let (r, resp) = ui.allocate_exact_size(vec2(22.0, 22.0), Sense::click());
resp.widget_info(|| egui::WidgetInfo::selected(egui::Role::Button, ui.is_enabled(), on, tip));
let resp = resp.on_hover_text(tip);
let p = ui.painter_at(r);
let bg = if on {
@@ -523,9 +524,9 @@ pub fn body(app: &mut WordApp, ui: &mut Ui, f: Form) -> bool {
}
let size = ui.add(egui::TextEdit::singleline(&mut r.size).desired_width(36.0));
size.on_hover_text(tl!("Size:")).accessible_name(tl!("Size:"));
ui.toggle_value(&mut r.bold, egui::RichText::new("B").strong()).on_hover_text(tl!("Bold"));
ui.toggle_value(&mut r.italic, egui::RichText::new("I").italics()).on_hover_text(tl!("Italic"));
ui.toggle_value(&mut r.underline, egui::RichText::new("U").underline()).on_hover_text(tl!("Underline"));
ui.toggle_value(&mut r.bold, egui::RichText::new("B").strong()).on_hover_text(tl!("Bold")).accessible_name(tl!("Bold"));
ui.toggle_value(&mut r.italic, egui::RichText::new("I").italics()).on_hover_text(tl!("Italic")).accessible_name(tl!("Italic"));
ui.toggle_value(&mut r.underline, egui::RichText::new("U").underline()).on_hover_text(tl!("Underline")).accessible_name(tl!("Underline"));
ui.push_id("tstyle_color", |ui| {
ui.label(tl!("Font color:"));
color_menu(ui, &theme, &mut r.color);
@@ -661,6 +662,42 @@ mod tests {
use egui_kittest::kittest::Queryable;
use wordcraft_engine::Session;
/// Alignment choices expose their names and current selection, and can be toggled.
#[test]
fn alignment_buttons_expose_names_selection_and_clicks() {
use egui::accesskit::{Role, Toggled};
use egui_kittest::kittest::NodeT;
let mut h = egui_kittest::Harness::builder().with_size(vec2(200.0, 120.0)).build_ui_state(
|ui, selected: &mut Option<usize>| {
for (i, align, label) in
[(0, (VAlign::Top, Align::Left), "Align Top Left"), (1, (VAlign::Bottom, Align::Right), "Align Bottom Right")]
{
let on = *selected == Some(i);
if align_button(ui, align, on, label).clicked() {
*selected = if on { None } else { Some(i) };
}
}
ui.add_enabled_ui(false, |ui| {
align_button(ui, (VAlign::Center, Align::Center), false, "Align Center");
});
},
Some(0usize),
);
h.run_steps(2);
assert_eq!(h.get_by_role_and_label(Role::Button, "Align Top Left").accesskit_node().toggled(), Some(Toggled::True));
assert_eq!(h.get_by_role_and_label(Role::Button, "Align Bottom Right").accesskit_node().toggled(), Some(Toggled::False));
assert!(h.get_by_role_and_label(Role::Button, "Align Center").accesskit_node().is_disabled());
h.get_by_role_and_label(Role::Button, "Align Bottom Right").click();
h.run_steps(2);
assert_eq!(*h.state(), Some(1));
assert_eq!(h.get_by_role_and_label(Role::Button, "Align Top Left").accesskit_node().toggled(), Some(Toggled::False));
assert_eq!(h.get_by_role_and_label(Role::Button, "Align Bottom Right").accesskit_node().toggled(), Some(Toggled::True));
h.get_by_role_and_label(Role::Button, "Align Bottom Right").click();
h.run_steps(2);
assert_eq!(*h.state(), None);
assert_eq!(h.get_by_role_and_label(Role::Button, "Align Bottom Right").accesskit_node().toggled(), Some(Toggled::False));
}
fn steps(h: &mut egui_kittest::Harness<'_, WordApp>) {
for _ in 0..4 {
h.step();
@@ -671,11 +708,15 @@ mod tests {
/// even banded rows) and no other.
#[test]
fn the_part_picker_edits_the_part_it_shows() {
use egui::accesskit::Toggled;
use egui_kittest::kittest::NodeT;
let mut app = WordApp::new(Session::new(wordcraft_doc::Document::new()), crate::Services::default());
app.run("insert.table", json!({"rows": 4, "cols": 3})).unwrap();
app.run("table.newStyle", json!({"name": "Parts"})).unwrap();
app.dialog = Dialog::open("modifyTableStyle", &mut app);
assert!(matches!(app.dialog, Some(Dialog::TableStyle { .. })));
// Keep the background ribbon's character controls out of the dialog's label queries.
app.ui.tab = "Insert".into();
let mut h = egui_kittest::Harness::builder().with_size(vec2(1440.0, 900.0)).build_ui_state(
|ui, app: &mut WordApp| {
let ctx = ui.ctx().clone();
@@ -691,15 +732,25 @@ mod tests {
h.get_by_label("Even Banded Rows").click();
steps(&mut h);
assert!(matches!(&h.state().dialog, Some(Dialog::TableStyle { region, .. }) if *region == part_index(TablePart::Band2Horz)));
h.get_by_label("B").click();
steps(&mut h);
for label in ["Bold", "Italic", "Underline"] {
assert_eq!(h.get_by_label(label).accesskit_node().toggled(), Some(Toggled::False));
h.get_by_label(label).click();
steps(&mut h);
assert_eq!(h.get_by_label(label).accesskit_node().toggled(), Some(Toggled::True));
}
h.get_by_label("OK").click();
steps(&mut h);
assert!(h.state().dialog.is_none(), "OK closes the dialog");
let st = h.state().session.doc.styles.get("Parts").cloned().unwrap();
assert_eq!(st.table_part(TablePart::Band2Horz).chr.bold, Some(true));
let chr = st.table_part(TablePart::Band2Horz).chr;
assert_eq!(chr.bold, Some(true));
assert_eq!(chr.italic, Some(true));
assert!(chr.underline.is_some_and(|u| u != Underline::None));
for other in [TablePart::WholeTable, TablePart::Band1Horz, TablePart::FirstRow, TablePart::Band2Vert] {
assert_ne!(st.table_part(other).chr.bold, Some(true), "{}", other.ooxml());
let chr = st.table_part(other).chr;
assert_ne!(chr.bold, Some(true), "{}", other.ooxml());
assert_ne!(chr.italic, Some(true), "{}", other.ooxml());
assert!(!chr.underline.is_some_and(|u| u != Underline::None), "{}", other.ooxml());
}
}
+51
View File
@@ -419,6 +419,9 @@ fn body(ui: &mut Ui, b: &mut FileBrowser, t: &Tokens) -> Option<Option<PathBuf>>
}
for e in entries.get(range).unwrap_or(&[]) {
let (r, resp) = ui.allocate_exact_size(vec2(ui.available_width(), ROW), Sense::click());
resp.widget_info(|| {
egui::WidgetInfo::selected(egui::Role::Button, ui.is_enabled(), b.selected.as_ref() == Some(&e.path), &e.name)
});
if b.selected.as_ref() == Some(&e.path) {
ui.painter().rect_filled(r, 2.0, t.checked);
} else if resp.hovered() {
@@ -765,6 +768,54 @@ mod tests {
assert!(crate::keytips::suppressed(&a, &ctx));
}
/// Drawn entries have names and selection state, and choosing one still picks its path.
#[test]
fn entries_expose_names_selection_and_picking() {
use egui::accesskit::{Role, Toggled};
use egui_kittest::kittest::{NodeT, Queryable};
let dir = scratch("entry_accessibility");
let folder = dir.join("Drafts");
let file = dir.join("chapter.docx");
std::fs::create_dir(&folder).unwrap();
std::fs::write(&file, b"x").unwrap();
let browser =
FileBrowser::new(FileDialogRequest::Open { purpose: "document".into() }, AfterPick::OpenDocument { document: 0 }, dir.clone(), false);
// Font changes take effect next frame; the buttons need the named semibold family.
let mut fonts = false;
let mut h = egui_kittest::Harness::builder().with_size(vec2(760.0, 520.0)).build_ui_state(
move |ui, state: &mut (FileBrowser, Option<Option<PathBuf>>)| {
if !fonts {
crate::theme::install_fonts(ui.ctx());
fonts = true;
return;
}
let t = Tokens::get(ui.ctx());
if let Some(picked) = body(ui, &mut state.0, &t) {
state.1 = Some(picked);
}
},
(browser, None),
);
h.run_steps(4);
for name in ["Drafts", "chapter.docx"] {
assert_eq!(h.get_by_role_and_label(Role::Button, name).accesskit_node().toggled(), Some(Toggled::False));
}
h.get_by_role_and_label(Role::Button, "Drafts").click();
h.run_steps(2);
assert_eq!(h.state().0.selected.as_ref(), Some(&folder));
assert_eq!(h.get_by_role_and_label(Role::Button, "Drafts").accesskit_node().toggled(), Some(Toggled::True));
h.get_by_role_and_label(Role::Button, "chapter.docx").click();
h.run_steps(2);
assert_eq!(h.state().0.selected.as_ref(), Some(&file));
assert_eq!(h.state().0.name, "chapter.docx");
assert_eq!(h.get_by_role_and_label(Role::Button, "Drafts").accesskit_node().toggled(), Some(Toggled::False));
assert_eq!(h.get_by_role_and_label(Role::Button, "chapter.docx").accesskit_node().toggled(), Some(Toggled::True));
h.get_by_role_and_label(Role::Button, "Open").click();
h.run_steps(2);
assert_eq!(h.state().1, Some(Some(file)));
let _ = std::fs::remove_dir_all(&dir);
}
/// #3535: exporting offers File › Export's formats as the types; the chosen one is the format,
/// the name's extension follows it, and the export writes that format.
#[test]
+64
View File
@@ -465,6 +465,70 @@ fn export_pdf_without_a_path_asks_where_to_save() {
let _ = std::fs::remove_dir_all(&dir);
}
/// A synchronous web save failure must not stamp a save that never reached its destination.
#[test]
fn failed_web_saves_restore_the_save_stamps() {
for id in ["file.save", "file.saveAs"] {
for (name, hosted, dirty, expected_calls) in [
("draft.unsupported", false, true, vec![]),
("draft.docx", false, true, vec!["download"]),
("draft.docx", true, true, vec!["host"]),
("draft.docx", false, false, vec!["download"]),
] {
let calls = Rc::new(RefCell::new(Vec::new()));
let downloaded = calls.clone();
let host_calls = calls.clone();
let services = Services {
download: Some(Box::new(move |_, _| {
downloaded.borrow_mut().push("download");
Err("download refused".into())
})),
host_save: hosted.then(|| {
Box::new(move |_: &str, _: &[u8], _: bool| {
host_calls.borrow_mut().push("host");
Err("host refused".into())
}) as crate::HostSaveFn
}),
..Default::default()
};
let mut a = WordApp::new(Session::new(wordcraft_doc::Document::from_text(UNSAVED)), services);
a.session.dirty = dirty;
a.session.path = Some("original.docx".into());
a.session.view.zoom = 1.37;
a.session.doc.core.created.clear();
a.session.doc.core.modified = "2020-01-02T03:04:05Z".into();
a.session.doc.core.last_modified_by = "Previous author".into();
a.session.doc.core.revision = 7;
let path_before = a.session.path.clone();
let core_before = a.session.doc.core.clone();
let zoom_before = a.session.doc.settings.zoom;
let undo_before = a.session.undo_depth();
assert!(a.run(id, json!({"path": name})).is_err(), "{id}: {name}");
assert_eq!(*calls.borrow(), expected_calls, "{id}: {name}");
assert_eq!(a.session.doc.core, core_before, "{id}: {name}");
assert_eq!(a.session.doc.settings.zoom, zoom_before, "{id}: {name}");
assert_eq!(a.session.undo_depth(), undo_before, "{id}: {name}");
assert_eq!(a.session.dirty, dirty, "{id}: {name}");
assert_eq!(a.session.path, path_before, "{id}: {name}");
}
let services = Services {
download: Some(Box::new(|_, bytes| {
assert!(bytes.starts_with(b"PK"));
Ok(())
})),
..Default::default()
};
let mut a = WordApp::new(Session::new(wordcraft_doc::Document::from_text(UNSAVED)), services);
a.session.dirty = true;
let revision_before = a.session.doc.core.revision;
assert_eq!(a.run(id, json!({"path": "draft.docx"})).unwrap()["downloaded"], "draft.docx");
assert_eq!(a.session.doc.core.revision, revision_before.saturating_add(1));
assert_eq!(a.session.doc.core.last_modified_by, a.session.author);
assert!(!a.session.doc.core.created.is_empty() && !a.session.doc.core.modified.is_empty());
assert!(!a.session.dirty);
}
}
/// An explicit web PDF export keeps an existing PDF suffix regardless of ASCII case.
#[test]
fn web_pdf_export_keeps_an_existing_suffix_in_any_case() {
+38 -2
View File
@@ -1645,9 +1645,19 @@ fn shape(pen: &Pen, kind: &str) -> bool {
"triangle" => solid(&[(10.0, 3.5), (17.0, 16.5), (3.0, 16.5)]),
"diamond" => solid(&[(10.0, 3.0), (17.0, 10.0), (10.0, 17.0), (3.0, 10.0)]),
"line" => pen.line(&[(4.0, 16.0), (16.0, 4.0)]),
// The block arrow the tile inserts (#6768), from the outline the document draws it with.
"arrow" => {
pen.line(&[(4.0, 16.0), (14.5, 5.5)]);
head((16.5, 3.5), (4.0, 16.0));
let (x0, y0, w, h) = (3.0, 5.0, 14.0, 10.0);
let pts: Vec<(f32, f32)> = wordcraft_doc::wrap::arrow_outline(wordcraft_doc::para::ShapeKind::Arrow, w, h)
.iter()
.map(|&(u, v)| (x0 + u * w, y0 + v * h))
.collect();
// Concave: the shaft and the head are tinted apart, then the outline.
if let [tail_top, neck_top, barb_top, tip, barb_bottom, neck_bottom, tail_bottom] = pts[..] {
pen.fill(&[tail_top, neck_top, neck_bottom, tail_bottom], tint);
pen.fill(&[barb_top, tip, barb_bottom], tint);
}
pen.closed(&pts, c);
}
"star" => {
let pts: Vec<(f32, f32)> = (0..10)
@@ -1745,6 +1755,32 @@ mod tests {
assert!(!has_default_highlight_bar("shadingNoBar"));
}
/// #6768: the Insert › Shapes Arrow tile is the block arrow that tile inserts, outlined as the
/// document draws it, not a thin line with a head.
#[test]
fn the_arrow_tile_is_the_block_arrow_it_inserts() {
let ctx = egui::Context::default();
let output = ctx.run_ui(egui::RawInput::default(), |ui| {
paint(ui.painter(), Rect::from_min_size(Pos2::ZERO, egui::vec2(20.0, 20.0)), "shape.arrow", Color32::BLACK, Color32::BLUE);
});
let outline: Vec<Pos2> = output
.shapes
.iter()
.find_map(|s| match &s.shape {
// The outline, not the tinted fills (closed too, but without a stroke).
Shape::Path(path) if path.closed && path.stroke.width > 0.0 => Some(path.points.clone()),
_ => None,
})
.expect("the arrow is outlined");
output.drop_without_applying_deltas();
let want = wordcraft_doc::wrap::arrow_outline(wordcraft_doc::para::ShapeKind::Arrow, 14.0, 10.0);
assert_eq!(outline.len(), want.len(), "{outline:?}");
for (got, (u, v)) in outline.iter().zip(want) {
let expected = pos2(3.0 + u * 14.0, 5.0 + v * 10.0);
assert!(got.distance(expected) < 0.01, "{got:?} vs {expected:?}");
}
}
/// Verify that the fitOnePage vector icon renders without panics and emits shapes.
#[test]
fn fit_one_page_icon_paints_without_panic() {
+36 -13
View File
@@ -467,7 +467,10 @@ fn letters_for(app: &WordApp, tab: &str) -> Vec<String> {
out[i] = Some(c.to_string());
}
}
// Pass 2: name-derived letters for everything still unassigned.
// Pass 2: name-derived letters for everything still unassigned. A control that finds no free
// letter is left for the two-letter pass below.
let mut named: Vec<usize> = Vec::new();
let mut overflow: Vec<usize> = Vec::new();
for (i, ctl) in ctrls.iter().enumerate() {
if out[i].is_some() {
continue;
@@ -481,21 +484,30 @@ fn letters_for(app: &WordApp, tab: &str) -> Vec<String> {
Some(c) => {
used.push(c);
out[i] = Some(c.to_string());
named.push(i);
}
None => {
// Two-letter badge fallback: a tab has at most ~20 controls, so this succeeds;
// the "?n" form keeps assignment total rather than panicking.
let two = ('A'..='Z').flat_map(|a| ('A'..='Z').map(move |b| format!("{a}{b}"))).find(|s| {
let mut ch = s.chars();
let (a, b) = (ch.next().unwrap_or('?'), ch.next().unwrap_or('?'));
!out.iter().flatten().any(|o| o == s) && !reserved.contains(&a) && !reserved.contains(&b)
});
let two = two.unwrap_or_else(|| format!("?{}", out.iter().flatten().count()));
used.extend(two.chars());
out[i] = Some(two);
}
None => overflow.push(i),
}
}
// Pass 3: two-letter badges. No badge may be the start of another (Word's rule), or the short
// one runs the moment its letter is typed and the long one can never be completed (#4498).
// So the first letter of every two-letter badge is a letter no single-letter badge uses: the
// letters of the last name-derived badges are given up for that until the overflow fits.
let seconds: Vec<char> = ('A'..='Z').filter(|c| !reserved.contains(c)).collect();
let mut firsts: Vec<char> = Vec::new();
let mut two: Vec<usize> = overflow;
while !two.is_empty() && firsts.len() * seconds.len() < two.len() {
let Some(i) = named.pop() else { break };
let letter = out[i].take().and_then(|l| l.chars().next());
firsts.extend(letter);
two.push(i);
}
two.sort_unstable();
let mut labels = firsts.iter().flat_map(|a| seconds.iter().map(move |b| format!("{a}{b}")));
for i in two {
// "?n" keeps the assignment total, with nothing to run it, rather than panicking.
out[i] = Some(labels.next().unwrap_or_else(|| format!("?{i}")));
}
out.into_iter().map(Option::unwrap_or_default).collect()
}
@@ -639,6 +651,14 @@ pub fn handle_key(app: &mut WordApp, key: egui::Key) -> bool {
let tab = app.ui.tab.clone();
let ls = letters_for(app, &tab);
let ctrls = controls(&tab);
// Badges are never the start of one another, so a complete one is the one.
let name = format!("{}{name}", app.ui.keytip_prefix);
// The start of a two-letter badge: wait for its next letter, with
// KeyTips still on and only the badges it can complete showing (#4498).
if !ls.contains(&name) && ls.iter().any(|l| l.starts_with(&name)) {
app.ui.keytip_prefix = name;
return true;
}
let mut hit: Option<Target> = None;
for (ctl, l) in ctrls.into_iter().zip(ls) {
if l == name {
@@ -865,6 +885,9 @@ pub fn show(app: &mut WordApp, ctx: &egui::Context, ui: &mut Ui) {
return;
}
let cmds: Vec<(Rect, String)> = ui.data(|d| d.get_temp::<Vec<(Rect, String)>>(rects_id())).unwrap_or_default();
// After the start of a two-letter badge only the badges it can still complete show.
let prefix = app.ui.keytip_prefix.clone();
let cmds = cmds.into_iter().filter(|(_, l)| app.ui.keytips != Phase::Commands || l.starts_with(&prefix));
for (r, l) in tabs.into_iter().chain(cmds) {
badge(ui, r, &l);
}
+54
View File
@@ -161,6 +161,60 @@ fn letters_are_unique_inside_every_tab() {
}
}
/// #4498: no badge is the start of another, on any tab, or the short one runs as soon as its
/// letter is typed and the long one can never be reached.
#[test]
fn no_badge_starts_another_badge() {
let mut a = app();
a.run("insert.table", serde_json::json!({"rows": 2, "cols": 2})).unwrap();
let (_, cmds) = letters(&a);
let mut two_letter = 0;
for (tab, ls) in &cmds {
for l in ls {
assert!(!l.is_empty() && !l.starts_with('?'), "{tab}: a control without a badge ({l:?})");
two_letter += usize::from(l.chars().count() > 1);
let others = ls.iter().filter(|o| *o != l && o.starts_with(l.as_str())).count();
assert_eq!(others, 0, "{tab}: badge {l} starts another badge in {ls:?}");
}
}
assert!(two_letter > 0, "Home has more controls than letters, so some badges take two");
}
/// #4498: the first letter of a two-letter badge keeps KeyTips on and waits; the second runs
/// the command. A letter that completes nothing ends KeyTips and runs nothing.
#[test]
fn a_two_letter_badge_is_completed_by_its_second_letter() {
let key = |c: char| egui::Key::from_name(&c.to_string()).unwrap();
let mut a = app();
a.canvas.focused = false;
a.run("ui.tab", serde_json::json!({"tab": "Home"})).unwrap();
let ls = letters_for(&a, "Home");
let long: Vec<&String> = ls.iter().filter(|l| l.chars().count() == 2).collect();
let target = *long.first().expect("Home has two-letter badges");
let (first, second) = (target.chars().next().unwrap(), target.chars().nth(1).unwrap());
let sibling = long.iter().find(|l| l.starts_with(first) && *l != &target).map(|l| l.chars().nth(1).unwrap());
let before = a.session.doc.plain_text(wordcraft_doc::StoryRef::Body);
activate(&mut a);
assert!(handle_key(&mut a, egui::Key::H));
assert_eq!(a.ui.keytips, Phase::Commands);
assert!(handle_key(&mut a, key(first)));
assert_eq!((a.ui.keytips, a.ui.keytip_prefix.as_str()), (Phase::Commands, first.to_string().as_str()), "waits for the second letter");
assert!(handle_key(&mut a, key(second)));
assert_eq!(a.ui.keytips, Phase::Off, "the second letter completes it");
assert!(a.ui.keytip_prefix.is_empty());
assert_eq!(a.session.doc.plain_text(wordcraft_doc::StoryRef::Body), before, "no letter reached the document");
// The first letter then a second that completes nothing: off, and nothing runs.
let unused = ('A'..='Z').find(|c| !ls.contains(&format!("{first}{c}"))).unwrap();
a.run("ui.tab", serde_json::json!({"tab": "Home"})).unwrap();
activate(&mut a);
handle_key(&mut a, egui::Key::H);
handle_key(&mut a, key(first));
assert!(handle_key(&mut a, key(unused)));
assert_eq!((a.ui.keytips, a.ui.keytip_prefix.as_str()), (Phase::Off, ""));
assert_eq!(a.session.doc.plain_text(wordcraft_doc::StoryRef::Body), before);
assert!(sibling.is_none() || sibling != Some(second), "siblings of a prefix have distinct second letters");
}
#[test]
fn keytips_never_reuse_another_commands_shortcut_letter() {
let a = app();
+3 -2
View File
@@ -1,5 +1,5 @@
use super::common::{mi, stack};
use super::{MeasureExt, Remember, Target, Ui, WordApp, big, group, json, menu_button, small, split, vec2};
use super::{MeasureExt, Remember, Target, Ui, WordApp, big, group, json, menu_button, small, vec2};
pub(super) fn table_design(app: &mut WordApp, ui: &mut Ui) {
let look = app.session.sel.focus.path.cell().and_then(|(tp, _, _)| app.session.doc.table(app.session.sel.focus.story, &tp).map(|t| t.props.look));
@@ -81,7 +81,8 @@ pub(super) fn table_design(app: &mut WordApp, ui: &mut Ui) {
},
);
let sw = wordcraft_doc::Rgb::parse(&app.canvas.last_shading).map(crate::theme::c32);
split(
// Labelled, with its arrow on the same row (#1726).
crate::widgets::split_labeled(
ui,
app,
"shadingNoBar",
+149
View File
@@ -1092,3 +1092,152 @@ fn shape_and_chart_formats_leave_out_of_range_sizes_alone() {
assert_eq!(before.0, Some((20.0, 2500.0)));
assert_eq!(shown(a), before, "Chart Design shown, the chart untouched");
}
fn table_design_harness(language: &str, theme: egui::Theme) -> egui_kittest::Harness<'static, WordApp> {
let mut app = WordApp::new(Session::new(wordcraft_doc::Document::new()), crate::Services::default());
app.run("insert.table", json!({"rows": 2, "cols": 2})).unwrap();
app.run("ui.language", json!({"value": language})).unwrap();
app.run("ui.theme", json!({"value": if theme == egui::Theme::Dark { "dark" } else { "light" }})).unwrap();
egui_kittest::Harness::builder().with_size(vec2(1600.0, 700.0)).with_theme(theme).build_ui_state(
move |ui, app: &mut WordApp| {
let ctx = ui.ctx().clone();
app.logic(&ctx);
assert_eq!(ctx.global_style().visuals.dark_mode, theme == egui::Theme::Dark, "the requested palette is active while drawing");
ui.horizontal_top(|ui| table_design(app, ui));
},
app,
)
}
/// The Shading arrow's name: "Shading options", in the interface language (#3172).
fn shading_options() -> String {
crate::i18n::fmt(tl!("{name} options"), &[("name", tl!("Shading"))])
}
/// #1726: the text must actually be painted, and both hit targets must share one row in
/// Table Styles' vertical stack. Accessibility labels alone cannot prove visible text.
#[test]
fn table_shading_label_is_painted_beside_its_arrow() {
use egui::accesskit::Role;
use egui_kittest::kittest::Queryable;
// Vietnamese and German labels need the embedded catalogs (CI has them); English always runs.
let languages: &[&str] = if crate::i18n::catalogs_embedded() { &["en", "vi", "de"] } else { &["en"] };
for &language in languages {
for theme in [egui::Theme::Light, egui::Theme::Dark] {
let mut h = table_design_harness(language, theme);
h.run_steps(3);
let label = tl!("Shading");
let main = h.get_by_role_and_label(Role::Button, label).rect();
let arrow = h.get_by_role_and_label(Role::Button, &shading_options()).rect();
assert!((main.top() - arrow.top()).abs() < 0.01 && (main.bottom() - arrow.bottom()).abs() < 0.01);
assert!((main.right() - arrow.left()).abs() < 0.01, "{language}: {main:?}, {arrow:?}");
let text = h
.output()
.shapes
.iter()
.find_map(|s| match &s.shape {
egui::Shape::Text(t) if t.galley.text() == label => Some(t),
_ => None,
})
.expect("Shading is drawn as text, not just a hover tip");
let text_rect = Rect::from_min_size(text.pos, text.galley.size());
assert!(main.contains_rect(text_rect), "{language}: {text_rect:?} outside {main:?}");
assert!(text_rect.left() >= main.left() + 24.0, "the label starts after the icon");
}
}
crate::i18n::set_current(crate::i18n::Lang::EN);
}
fn first_cell_shading(app: &WordApp) -> Option<wordcraft_doc::Rgb> {
app.session.doc.body.iter().find_map(|b| b.as_table()).unwrap().rows[0].cells[0].props.shading
}
fn painted_text_rect(output: &egui::FullOutput, text: &str) -> Option<Rect> {
output.shapes.iter().find_map(|s| match &s.shape {
egui::Shape::Text(t) if t.galley.text() == text => Some(Rect::from_min_size(t.pos, t.galley.size())),
_ => None,
})
}
/// #1726: the arrow opens the real colour menu without applying the remembered colour;
/// picking a swatch remembers it, and the command half reapplies it after one-step undo.
#[test]
fn table_shading_split_keeps_palette_and_apply_separate() {
use egui::accesskit::Role;
use egui_kittest::kittest::Queryable;
let mut h = table_design_harness("en", egui::Theme::Light);
h.state_mut().canvas.last_shading = "0070C0".into();
h.run_steps(3);
let original = first_cell_shading(h.state());
h.get_by_role_and_label(Role::Button, &shading_options()).click();
h.run();
assert_eq!(first_cell_shading(h.state()), original, "opening the palette must not apply the last colour");
assert!(painted_text_rect(h.output(), "No Color").is_some(), "the arrow opens the shading palette");
// Swatches are drawn controls; locate the red standard swatch from its painted box.
let red = h
.output()
.shapes
.iter()
.find_map(|s| match &s.shape {
egui::Shape::Rect(r) if r.fill == egui::Color32::RED && r.rect.size() == vec2(15.0, 15.0) => Some(r.rect.center()),
_ => None,
})
.expect("red standard colour is visible in the palette");
h.hover_at(red);
h.drag_at(red);
h.drop_at(red);
h.run();
assert_eq!(first_cell_shading(h.state()), Some(wordcraft_doc::Rgb(255, 0, 0)));
assert_eq!(h.state().canvas.last_shading, "FF0000");
assert!(painted_text_rect(h.output(), "No Color").is_none(), "a colour pick closes the palette");
h.state_mut().run("edit.undo", json!({})).unwrap();
h.run_steps(2);
assert_eq!(first_cell_shading(h.state()), original);
h.get_by_role_and_label(Role::Button, "Shading").click();
h.run();
assert_eq!(first_cell_shading(h.state()), Some(wordcraft_doc::Rgb(255, 0, 0)));
assert!(painted_text_rect(h.output(), "No Color").is_none(), "the command half must not open the palette");
h.state_mut().run("edit.undo", json!({})).unwrap();
assert_eq!(first_cell_shading(h.state()), original);
h.get_by_role_and_label(Role::Button, "Shading").click();
h.run();
assert_eq!(first_cell_shading(h.state()), Some(wordcraft_doc::Rgb(255, 0, 0)));
h.get_by_role_and_label(Role::Button, &shading_options()).click();
h.run();
let clear = painted_text_rect(h.output(), "No Color").expect("No Color is visible in the palette").center();
h.hover_at(clear);
h.drag_at(clear);
h.drop_at(clear);
h.run();
assert_eq!(first_cell_shading(h.state()), None);
h.state_mut().run("edit.undo", json!({})).unwrap();
assert_eq!(first_cell_shading(h.state()), Some(wordcraft_doc::Rgb(255, 0, 0)), "No Color is undone in one step");
}
/// #1726 with #662: in a compact group the labelled split button drops its label and keeps only
/// its icon and arrow, as small buttons do; its name stays for the tooltip and screen readers.
#[test]
fn a_labelled_split_button_shows_only_its_icon_when_compact() {
use egui::accesskit::Role;
use egui_kittest::kittest::Queryable;
for compact in [false, true] {
let mut app = WordApp::new(Session::new(wordcraft_doc::Document::new()), crate::Services::default());
app.run("insert.table", json!({"rows": 2, "cols": 2})).unwrap();
let mut h = egui_kittest::Harness::builder().with_size(vec2(400.0, 100.0)).build_ui_state(
move |ui, app: &mut WordApp| {
crate::ribbon_fit::set_compact(ui.ctx(), compact);
let action = crate::widgets::ButtonAction::new("table.shading", json!({}), false);
crate::widgets::split_labeled(ui, app, "shadingNoBar", "Shading", action, None, |_, _| {});
},
app,
);
h.run_steps(2);
let button = h.get_by_role_and_label(Role::Button, "Shading").rect();
assert_eq!(painted_text_rect(h.output(), "Shading").is_some(), !compact, "compact: {compact}");
if compact {
assert_eq!(button.width(), 24.0, "only the icon");
} else {
assert!(button.width() > 30.0, "icon and label: {button:?}");
}
}
}
+34
View File
@@ -357,6 +357,40 @@ fn non_latin_file_name_is_drawn_in_the_caption() {
assert!(cjk.canvas.ime_faces.is_empty(), "CJK collections are not copied into the fallback list");
}
/// The CJK UI font a Japanese file name asks for is loaded and draws the name, also in a build
/// without craft-i18n's CJK catalogs and craft-fonts' CJK faces. There it was never loaded, and
/// the caption, like an input method's composition, showed boxes.
#[test]
fn a_japanese_file_name_is_drawn_in_the_caption() {
// A font to draw it with: an installed CJK font in a build without embedded CJK faces, or
// embedded faces that have the name's characters (embedded faces without them load no
// installed font for it).
let embedded = wordcraft_fonts::ui_cjk_fonts_for(false, false);
let drawable = if embedded.is_empty() {
wordcraft_fonts::system_cjk_ui_font_for(false, false, &[]).is_some()
} else {
wordcraft_fonts::ui_uncovered_cjk(&["日本語"], &embedded).is_empty()
};
// macOS and Windows always have one (Hiragino, Yu Gothic), and CI runs these tests on both (the
// Print job), so there a missing font fails instead of hiding a regression.
assert!(drawable || cfg!(not(any(target_os = "macos", windows))), "macOS and Windows have a CJK font, but none draws 日本語");
if !drawable {
eprintln!("skipped: no CJK font draws 日本語");
return;
}
let ctx = egui::Context::default();
let frame = |app: &mut WordApp| {
ctx.run_ui(egui::RawInput::default(), |ui| app.logic(ui.ctx())).drop_without_applying_deltas();
};
let mut a = app();
a.session.path = Some("日本語.docx".into());
// The fonts the name asks for load from the next frame.
frame(&mut a);
frame(&mut a);
assert!(a.want_system_cjk);
assert!(ctx.fonts_mut(|f| f.has_glyphs(&crate::theme::semibold(13.0), "日本語")), "the caption draws the name");
}
/// File › Recover draws the recovered documents' names with the interface faces: a Chinese
/// name there was a row of boxes because nothing asked for the CJK UI font. (The Recent list
/// has its own, `ensure_recent_fonts`.)
+55 -9
View File
@@ -695,7 +695,8 @@ fn system_arabic_font() -> Option<&'static wordcraft_fonts::SystemUiFont> {
/// The installed CJK interface font for a Chinese (`hans`) or other interface, chosen once:
/// `None` when the embedded faces already cover the interface text
/// ([`cjk_font_text`](crate::i18n::Lang::cjk_font_text)). The font is picked for the catalogs'
/// missing characters, or for the language names when only those are missing.
/// missing characters, or for the language names when only those are missing; see
/// [`system_cjk_needed`].
#[cfg(not(target_arch = "wasm32"))]
fn system_cjk_font(hans: bool, korean: bool) -> Option<&'static wordcraft_fonts::SystemUiFont> {
static ZH: std::sync::OnceLock<Option<wordcraft_fonts::SystemUiFont>> = std::sync::OnceLock::new();
@@ -711,19 +712,41 @@ fn system_cjk_font(hans: bool, korean: bool) -> Option<&'static wordcraft_fonts:
.get_or_init(|| {
let embedded = wordcraft_fonts::ui_cjk_fonts_for(hans, korean);
let (catalogs, names) = crate::i18n::Lang::cjk_font_text_for(hans, korean);
let mut needed = wordcraft_fonts::ui_uncovered_cjk(&catalogs, &embedded);
if needed.is_empty() {
needed = wordcraft_fonts::ui_uncovered_cjk(&[&names], &embedded);
if needed.is_empty() {
return None;
}
}
let needed = system_cjk_needed(&catalogs, &names, &embedded)?;
log::debug!("interface: {} CJK characters lack an embedded glyph", needed.len());
wordcraft_fonts::system_cjk_ui_font_for(hans, korean, &needed)
let found = wordcraft_fonts::system_cjk_ui_font_for(hans, korean, &needed);
if found.is_none() && needed.is_empty() && !hans && !korean {
// No Japanese or Chinese font installed: a Korean one (NanumGothic alone on Linux)
// still draws Korean document text.
return wordcraft_fonts::system_cjk_ui_font_for(false, true, &needed);
}
found
})
.as_ref()
}
/// The CJK characters an installed interface font is picked for: those of the catalogs, or of
/// the language names, that the embedded faces lack. `None` when the embedded faces draw them all.
///
/// The interface asks for this font only when CJK is on screen: the interface language, or CJK
/// document text drawn as interface text (an input method's composition, a file name in the
/// caption). A build with neither craft-i18n's CJK catalogs nor craft-fonts' CJK faces has no CJK
/// text of its own to measure, and that text drew as boxes. It gets the font picked for the
/// language's own characters (an empty list: [`wordcraft_fonts::system_cjk_ui_font_for`] probes
/// one, `の` for a Japanese or other interface), or failing that a Korean font.
#[cfg(not(target_arch = "wasm32"))]
pub(crate) fn system_cjk_needed(catalogs: &[&str], names: &str, embedded: &[&wordcraft_fonts::CraftFont]) -> Option<Vec<char>> {
let needed = wordcraft_fonts::ui_uncovered_cjk(catalogs, embedded);
if !needed.is_empty() {
return Some(needed);
}
let needed = wordcraft_fonts::ui_uncovered_cjk(&[names], embedded);
if !needed.is_empty() {
return Some(needed);
}
embedded.is_empty().then(Vec::new)
}
#[cfg(not(target_arch = "wasm32"))]
fn system_hant_font() -> Option<&'static wordcraft_fonts::SystemUiFont> {
static HANT: std::sync::OnceLock<Option<wordcraft_fonts::SystemUiFont>> = std::sync::OnceLock::new();
@@ -1160,6 +1183,29 @@ mod tests {
assert!(semi.iter().any(|n| n.starts_with("fallback ")), "the caption is painted with semibold");
}
/// A build without craft-i18n's CJK catalogs and craft-fonts' CJK faces has no CJK interface
/// text of its own, so the CJK UI font that CJK document text asks for (a composition, a file
/// name, a comment) was never loaded, and that text drew as boxes. It is now picked for the
/// language's own characters.
#[test]
fn cjk_text_gets_an_installed_cjk_font_in_a_build_without_one() {
assert_eq!(super::system_cjk_needed(&[], "English", &[]), Some(Vec::new()), "picked for the language's own characters");
assert_eq!(super::system_cjk_needed(&["ファイル"], "English", &[]), Some(vec!['ァ', 'イ', 'フ', 'ル']));
assert_eq!(super::system_cjk_needed(&[], "English 日本語", &[]), Some(vec!['日', '本', '語']));
let embedded = wordcraft_fonts::ui_cjk_fonts_for(false, false);
if !embedded.is_empty() {
assert_eq!(super::system_cjk_needed(&[], "English", &embedded), None, "the embedded faces draw CJK");
} else {
// macOS and Windows always have one, and CI runs these tests on both (the Print job).
let installed = wordcraft_fonts::system_cjk_ui_font_for(false, false, &[]).is_some();
assert!(installed || cfg!(not(any(target_os = "macos", windows))), "macOS and Windows have a CJK font");
if installed {
let defs = super::font_definitions_language(false, false, false, true);
assert!(defs.font_data.keys().any(|n| n.starts_with("system ")), "the installed CJK font follows the interface fonts");
}
}
}
/// #656: dialog primary buttons, the Discord pill, the table eraser and the Navigation search
/// highlight take their colours from the theme, not fixed light-theme values.
#[test]
+1 -1
View File
@@ -14,7 +14,7 @@ mod tooltip;
pub use buttons::{
BIG_ICON_Y, BIG_LABEL_Y, ButtonAction, CONTENT_H, DROPDOWN, LABEL_H, LABEL_LINE_H, LABEL_PITCH, MenuButtonOptions, big, big_toggle, enabled,
label_line, menu_button, menu_enabled, small, split,
label_line, menu_button, menu_enabled, small, split, split_labeled,
};
pub(crate) use buttons::{bg, run_from_ribbon};
pub use combo::{
+54 -5
View File
@@ -180,25 +180,74 @@ pub fn split(
action: ButtonAction<'_>,
swatch: Option<Color32>,
menu: impl FnOnce(&mut Ui, &mut WordApp),
) -> Response {
split_button(ui, app, icon, tip, action, SplitLook { swatch, labeled: false }, menu)
}
/// A [`split`] button with its label beside the icon and the arrow on the same row, also in a
/// vertical ribbon stack (Table Design › Shading, #1726). A compact group shows only the icon.
pub fn split_labeled(
ui: &mut Ui,
app: &mut WordApp,
icon: &str,
label: &str,
action: ButtonAction<'_>,
swatch: Option<Color32>,
menu: impl FnOnce(&mut Ui, &mut WordApp),
) -> Response {
ui.horizontal(|ui| {
ui.spacing_mut().item_spacing.x = 0.0;
split_button(ui, app, icon, label, action, SplitLook { swatch, labeled: true }, menu)
})
.inner
}
/// A split button's look beyond its icon: the colour bar under it, and its name beside it.
struct SplitLook {
swatch: Option<Color32>,
labeled: bool,
}
fn split_button(
ui: &mut Ui,
app: &mut WordApp,
icon: &str,
tip: &str,
action: ButtonAction<'_>,
look: SplitLook,
menu: impl FnOnce(&mut Ui, &mut WordApp),
) -> Response {
let ButtonAction { id, params, checked } = action;
let tip = tl!(tip);
let t = Tokens::get(ui.ctx());
let (r, resp) = ui.allocate_exact_size(vec2(24.0, 22.0), Sense::click());
let on = enabled(app, id);
// A compact group (#662) shows only the icon, as `small` does; the tooltip keeps the name.
let label = (look.labeled && !crate::ribbon_fit::compact(ui.ctx()))
.then(|| ui.painter().layout_no_wrap(tip.to_string(), regular(11.5), if on { t.text } else { t.text_disabled }));
let text_w = label.as_ref().map_or(0.0, |g| g.size().x + 6.0);
// What a compact group gives back, so the ribbon can plan it before drawing it compact.
crate::ribbon_fit::add_saving(ui.ctx(), text_w);
let (r, resp) = ui.allocate_exact_size(vec2(24.0 + text_w, 22.0), Sense::click());
keytip_badge(ui, r, id, tip);
let (ar, aresp) = ui.allocate_exact_size(vec2(11.0, 22.0), Sense::click());
let on = enabled(app, id);
bg_if(ui, r, &resp, checked, &t, on);
bg_if(ui, ar, &aresp, false, &t, on);
let ic = Rect::from_center_size(r.center(), vec2(17.0, 17.0));
// The icon (and its colour bar) leads; a label follows it, mirrored in a right-to-left interface.
let rtl = crate::rtl::flows(ui);
let ic = Rect::from_center_size(pos2(crate::rtl::lead_x(rtl, r, 12.0), r.center().y), vec2(17.0, 17.0));
let (c, a) = if on { (t.icon, t.accent) } else { (t.text_disabled, t.text_disabled) };
icons::paint(ui.painter(), ic, icon, c, a);
if let Some(sw) = swatch {
if let Some(sw) = look.swatch {
let sw = if on { sw } else { t.text_disabled };
let bar = Rect::from_min_max(pos2(r.min.x + 4.0, r.max.y - 5.0), pos2(r.max.x - 4.0, r.max.y - 2.0));
let left = crate::rtl::lead_left(rtl, r, 4.0, 16.0);
let bar = Rect::from_min_max(pos2(left, r.max.y - 5.0), pos2(left + 16.0, r.max.y - 2.0));
ui.painter().rect_filled(bar, 0.0, sw);
ui.painter().rect_stroke(bar, 0.0, Stroke::new(0.5, t.border), egui::StrokeKind::Inside);
}
if let Some(g) = label {
let y = r.center().y - g.size().y / 2.0;
ui.painter().galley(pos2(crate::rtl::lead_left(rtl, r, 24.0, g.size().x), y), g, t.text);
}
icons::paint(ui.painter(), Rect::from_center_size(ar.center(), vec2(DROPDOWN, DROPDOWN)), "dropdown", c, a);
let resp = tooltip(app, resp, tip, id);
command_menu(&resp, app, id);
+1 -1
View File
@@ -21,7 +21,7 @@ crate name links to its source tree.
| L0 | [`geom`](../crates/geom/src) | 1,271 | Units (points, twips, EMU, inches, cm), rectangles and measurement parsing |
| L1 | [`doc`](../crates/doc/src) | 23,719 | Document model: stories, paragraphs, runs, tables, sections, styles, numbering, fields, notes, comments, revisions and equations; edit primitives and bidi |
| L1 | [`fonts`](../crates/fonts/src) | 7,088 | Font database, metrics, outlines, HarfRust shaping, Word font substitution and OpenType MATH |
| L1 | [`metafile`](../crates/metafile/src) | 3,614 | Shared Windows Metafile parsing and drawing primitives used by format readers and renderers |
| L1 (external) | [`craft-metafile`](https://github.com/storytold/craft-libs/tree/main/crates/metafile) | — | WMF, EMF and EMF+ reader shared with the other Craft apps: paths, pattern fills, bitmaps and text with their clips, placed into a picture frame for the renderers |
| L1 (external) | [`craft-proof`](https://github.com/storytold/craft-libs/tree/main/crates/proof) (package alias `wordcraft-proof`) | — | Proofing moved to craft-libs (CP1, 2026-11): fifteen spelling dictionaries: English (US, GB, CA), Polish, Portuguese, Italian, Croatian, Turkish, Russian, Czech, Indonesian and Spanish (Spain, Mexico, Latin America, Uruguay); language modules provide spelling, suggestions and grammar, while Bulgarian and German have hyphenation only. Its word lists and patterns are craft-i18n's `language-data/`, embedded from `CRAFT_I18N_DIR` at the commit in `craft-i18n.rev` (CI and releases set `CRAFT_I18N_REQUIRED=1`); without them English spelling falls back to an installed Hunspell English or craft-proof's built-in Moby list, and pattern hyphenation is off (Bulgarian, Turkish and Russian hyphenate by rule) |
| L2 | [`docbin`](../crates/docbin/src) | 8,815 | Word 97–2003 `.doc` reader (FIB, piece table, FKPs, SPRMs, stylesheet, lists, tables, notes, pictures) over a CFB container |
| L2 | [`docx`](../crates/docx/src) | 37,376 | OOXML WordprocessingML reader/writer (Transitional and Strict), OMML, custom properties and preserved VBA parts |
+3 -3
View File
@@ -1,6 +1,6 @@
# Control protocol
> **Last updated:** 2026-11-09 · #6146: scroll speed preferences (`ui.scrollSpeed`, `ui.touchpadScrollSpeed`); #6159: refuse ui.screenshot on secondary document windows and support root window selection with view.switchWindows.
> **Last updated:** 2026-11-14 · Correct the force-close request envelope and document the optional command search parameter; command behavior unchanged. #6146: scroll speed preferences (`ui.scrollSpeed`, `ui.touchpadScrollSpeed`); #6159: refuse ui.screenshot on secondary document windows and support root window selection with view.switchWindows.
Start the app with a control port: `wordcraft --control 7981` (or `WORDCRAFT_CONTROL_PORT=7981`).
A missing or invalid port after `--control` (not 1–65535) prints an error and exits with status 2.
@@ -85,7 +85,7 @@ let apps move windows, so there Arrange All and Side by Side only resize.
| Method | Params | Result |
|---|---|---|
| `engine.execute` | `command`, `params`, `doc?` | the command's result (any id from `engine.commands`, including UI commands `ui.tab`, `ui.dialog` (`{"name": dialog, "part"?: table style part}`; `part` opens New / Modify Table Style (`newTableStyle` / `modifyTableStyle`) on that part: `wholeTable`, `headerRow`, `firstColumn`, `bandedRows`, `nwCell`… as `table.modifyStyle` names them), `ui.backstage`, `ui.zotero.*` (see `docs/zotero.md`), `ui.language` (`{"value": "auto"\|"en"\|"zh-hans"\|"zh-hant"\|"ja"\|"pt-br"\|"es"\|"uk"\|"sr"\|"sr-latn"\|"et"\|"tr"\|"ru"\|"pl"\|"de"\|"it"\|"cs"\|"hu"\|"fr"}`), `ui.theme` (`{"value": "system"\|"light"\|"dark"}`; `system` follows the OS appearance, light when it reports none), `ui.interfaceSize` (`{"value": "auto"}` or `{"percent": 50–300}`, clamped; no value reads it; `auto` keeps the system display scale, capped so a window of at least 900x460 points fits the screen (#4030), a percentage is absolute, so 100 is one screen pixel per point (#822); the result's `percent` is the size drawn at and `auto` whether it follows the system; document zoom stays `view.zoom`), `ui.animations` (`{"value": "system"\|"on"\|"off"}`; no value reads it; `system` follows the system's animation setting, which the desktop app reads on Windows, macOS, Linux and the BSDs and the web app from `prefers-reduced-motion`, and means on where the system doesn't say; the result's `enabled` is what the setting comes to and `system` what the system reports, `null` when it doesn't say), `ui.fileBrowser` (desktop: `{"purpose": "document"\|"picture"\|"recipients"\|"save"\|"export"}` opens WordCraft's own file browser, for when the system file dialog doesn't show up, #576; `export` offers File › Export's formats as its types, #3535), `ui.saveAsTemplate` (File › Save As › Save as Word Template: the Save dialog for a `.dotx`, starting in the user templates folder; the result's `dir` is that folder, `null` on the web, #2852), `ui.caretAnimation` (`{"value": true\|false}`; no value reads it; off, the caret jumps and blinks on and off instead of gliding and fading), `ui.startScreen` (`{"value": true\|false}`; no value reads it; on, the default, the desktop and web apps start on File › Home when launched with nothing to open, #766), `ui.alignmentGuides` (`{"value": true\|false}`; no value reads it; on, the default, moving a picture or shape snaps it to the page, the margins and other objects, with guide lines while dragging; Alt moves freely), `ui.quickAccessToolbar` (`{"value": true\|false}`; no value toggles it; false takes the Quick Access Toolbar out of the title bar, as its menu's Hide Quick Access Toolbar does, and true brings it back, #1945), `ui.displayServer` (`{"value": "auto"\|"wayland"\|"x11"}`; no value reads it; File › Options › Advanced › Linux display server, which the desktop app reads on Linux and the BSDs at its next launch; `WORDCRAFT_WAYLAND` overrides it, #2184), `ui.scrollSpeed` (`{"value": "slow"\|"normal"\|"fast"}`; no value reads it; mouse-wheel scroll speed, #6146), `ui.touchpadScrollSpeed` (`{"value": "slow"\|"normal"\|"fast"}`; no value reads it; scales touchpad scrolling on Wayland: slow 2×, normal 4×, fast 8×; on macOS: 0.5×, 1×, 2×; File › Options › Advanced › Scrolling › Touchpad scroll speed, #6146), `ui.statusCount` (`{"value": "words"\|"characters"\|"charactersNoSpaces"}`; no value reads it; what the status bar's count shows — words (the default), characters with spaces, or characters without spaces — kept between runs, #2797), `ui.recentRemove` (`{"path": entry}` takes that document off the recent list — `path` must be an entry on the list; on the desktop the new list is saved right away: the result's `saved` is true then, false with `saveError` when the write failed (the removal still holds for this run) and null where the host keeps no preferences (the web app, or preferences switched off), #2716), `ui.recentClear` (`{}` clears the whole list; the result reports `removed`, the new `recent` and `saved` as above), `ui.focusRibbon` (`{"value": true\|false}`; no value toggles it; in Focus, true drops the ribbon down over the page, as the bar's ⋯ does, and false puts it away, as a click on the page does; outside Focus it stays put away, #1678), `ui.contextMenu` (opens the page's context menu below the caret, as Shift+F10 does), `ui.paneDock` (`{"pane": "navigation"\|"clipboard"\|"styles"\|"styleInspector"\|"accessibility"\|"altText"\|"formatShape"\|"restrictEditing"\|"comments"\|"smartArtText", "dock"?: "left"\|"right"\|"float", "before"?: pane\|null}`; no `dock` reads it; docks or floats a task pane as its menu does, kept between runs; Styles is `view.stylesPaneDock`, #1756; `before` puts the pane directly before that pane in the order, outside it on their edge, as a drop over a docked pane's outer third does, and `null` after every pane; the order is kept between runs)…) |
| `engine.commands` | — | every command: id, label, location, shortcut, params, enabled |
| `engine.commands` | `search?` | every command: id, label, location, shortcut, params, enabled |
| `document.inspect` | `text?`, `doc?` | blocks (text, style, runs, lists, tables), parts, sections, selection, pages |
| `ui.inspect` | — | UI state, view, dialog, window size, page rects on screen, caret, comment balloons (`balloons`: id + screen rect; `balloon`: the selected one), perf; `windows`: the other windows as the drawn window sees them (`available`, `others`, `sideBySide`, `syncScroll`); `document`: the active document's id; `documents`: the open documents (`id`, `title`, `path`, `dirty`, `active`) |
| `ui.click` | `x`, `y`, `button?`, `count?`, `shift?`, `cmd?`, `alt?` | real pointer input at window coordinates |
@@ -187,7 +187,7 @@ discard unsaved work is **refused with an error** (the app keeps running and the
save first (`file.save`), or pass `{"force": true}` to discard the changes and go ahead.
`file.close` closes the shown document, so it is refused while that document has unsaved
changes; the bare form `{"method": "file.close", "force": true}` (a method name that is a
changes; the bare form `{"method": "file.close", "params": {"force": true}}` (a method name that is a
command id) is guarded the same way, and only a boolean `true` counts as `force`. A document
without unsaved changes closes at once (#1268). Closing closes the document and its window, and
the window focused before it becomes the active one. The last window stays open with no page,
+1 -1
View File
@@ -93,7 +93,7 @@ Weights are the share of a Word user's file traffic (estimate). Read/write: ✅
| Encrypted/password-protected `.doc` (XOR/RC4) | <1% | R | 🟡 | — | ~60% | 1–2 | `crates/docbin/src/tests/encrypted.rs` | XOR obfuscation, RC4 and RC4 CryptoAPI open with a password (`docbin` `crypt.rs`, #1079). An AES header (`fAES`) is refused with a clear message: [MS-OFFCRYPTO] defines AES only for encrypted packages, which open through the `.docx` reader (gap 9) |
| `.md` Markdown | — | (no) | ✅ | ✅ | — | — | `crates/formats/src/tests.rs` | Beyond Word |
| `.tex` LaTeX | — | — | ✅ | ✅ | — | — | `crates/formats/src/tests.rs` | Beyond Word (#11), incl. math |
| Pictures for Insert › Picture, drag-and-drop and paste | — | R | ✅ | — | — | — | `insert_picture_takes_a_windows_metafile` (engine), `paste_picture.rs` | PNG, JPEG, GIF, WebP, BMP, and Windows Metafile `.wmf` / Enhanced Metafile `.emf` at their own frame size (#802), drawn by `crates/metafile`. Not yet: SVG, TIFF, ICO, HEIC |
| Pictures for Insert › Picture, drag-and-drop and paste | — | R | ✅ | — | — | — | `insert_picture_takes_a_windows_metafile` (engine), `paste_picture.rs` | PNG, JPEG, GIF, WebP, BMP, and Windows Metafile `.wmf` / Enhanced Metafile `.emf`, EMF+ records included (#6636), at their own frame size (#802), drawn with craft-libs' `craft-metafile`. Not yet: SVG, TIFF, ICO, HEIC |
| `.png` page images | — | (Save as picture, Mac) | — | ✅ | — | — | `io_ext.rs` | |
| `.json` document model | — | — | ✅ | ✅ | — | — | engine tests | For agents. A table cell's span is any number in the file; Insert Column and Merge Cells count it as at most 63 columns, as the `.docx` reader does (#3637) |
+5 -3
View File
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
+2 -5
View File
@@ -1,6 +1,6 @@
# MCP server
> **Last updated:** 2026-10-31 · Delivery review fixes for #2596: unknown outcomes are not replayed, including image exports to a path; invalid UTF-8 returns a parse error without stopping later requests.
> **Last updated:** 2026-11-14 · Keep the complete `type_text` description in one tool-table row; behavior wording unchanged. Delivery review fixes for #2596: unknown outcomes are not replayed, including image exports to a path; invalid UTF-8 returns a parse error without stopping later requests.
WordCraft speaks the [Model Context Protocol](https://modelcontextprotocol.io) over stdio, so
Claude and other agents can write and edit documents.
@@ -173,10 +173,7 @@ test source in File › Options › Language and on the bar's Install.
| `new_document` | blank, sample, letter, resume, report; opens beside the open documents |
| `open_document` / `save_document` | docx, doc (open only), odt, rtf, html, md, tex, txt, json; save also pdf, png |
| `list_documents` | the open documents: `id`, `title`, `path`, `dirty`, `active` |
| `type_text` | type at the caret (`paragraphs: true` splits lines into paragraphs: one undo
step; each break is the Enter it stands for, so AutoFormat and AutoCorrect run and a
one-line control refuses; at most 10,000 lines — the cap is `text.insert`'s own, so a
control-channel or CLI call is held to it too) |
| `type_text` | type at the caret (`paragraphs: true` splits lines into paragraphs: one undo step; each break is the Enter it stands for, so AutoFormat and AutoCorrect run and a one-line control refuses; at most 10,000 lines — the cap is `text.insert`'s own, so a control-channel or CLI call is held to it too) |
| `select_text` | select the n-th occurrence of some text |
| `get_text` / `inspect_document` | read the document back (verify without screenshots) |
| `render_page` | a page as PNG |
+8 -6
View File
@@ -1,6 +1,7 @@
# Releasing WordCraft
1. Bump the version on `main`: `cargo xtask version set 0.2.0` (the one source of truth is
1. On a branch, bump the version with `cargo xtask version set 0.2.0`, then open and
merge a pull request into `main` (the one source of truth is
`[workspace.package] version`; the app shows it in `--version` and About, with the commit from
`WORDCRAFT_BUILD_SHA`).
2. Merge `main` into `release` and push. `.github/workflows/release.yml` builds:
@@ -17,12 +18,13 @@
3. The run drafts a GitHub Release `WordCraft v<version>` with `SHA256SUMS.txt`; review and publish it.
Signing secrets live in the repository's `release` environment (deployment branch: `release` only),
synced from the release manager's machine. Missing secrets
produce unsigned builds with a warning, so forks still build.
synced from the release manager's machine. On the release branch, the shared workflow fails the
macOS and Windows jobs if their signing credentials are missing. Local packaging can still
produce unsigned builds with a warning.
Local packaging: `packaging/macos/package.sh --arch universal`, `packaging/windows/package.ps1`,
`packaging/linux/package.sh` (then `packaging/linux/flatpak-bundle.sh` for the Flatpak), `packaging/web/package.sh`.
Dry run: `gh workflow run release.yml --ref <branch>` builds the unsigned jobs (version, Linux,
Linux riscv64, Flatpak, FreeBSD, web) on any branch; the signing jobs are refused there by the `release`
environment's branch rule, so no draft release is made.
A scheduled dry run runs on `main` nightly at 03:00 UTC. It builds every release target except
macOS, without signing, entering the `release` environment, pushing Flatpak images or making a
draft release. Manual dispatch uses the normal release path (`dry-run` is false).
+2 -2
View File
@@ -1,8 +1,8 @@
# Shared PDF writer
WordCraft uses `craft-pdf` with default features disabled and `write` enabled. Both that dependency
and the required root Krilla patch use the immutable `storytold/craft-libs` revision
`b926b5c03e256c86ca10934f58d03f628810b5b7`. Rust 1.95 or newer is required. The revision must be
and the required root Krilla patch use the same immutable `storytold/craft-libs` revision,
pinned in [`Cargo.toml`](../Cargo.toml). Rust 1.95 or newer is required. The revision must be
available from the remote before a fresh checkout can resolve it. The shared writer checks a
backend marker at compile time so an unpatched Krilla cannot replace the required backend.
+1 -1
View File
@@ -12,7 +12,7 @@ WordCraft uses this arrangement and its shared pane host, icons, typography and
## Scope and behavior
Review › Spelling & Grammar, Home › Editor and F7 open the task pane. The pass begins at the next issue from the current selection and continues to the end of the current story (body, header, note or other active text), not all document stories or only a selection. Each correction uses the existing review command and remains undoable. Ignore Once advances without changing the document or dictionaries. Ignore All lasts for the session; Add to Dictionary uses the personal dictionary. Those two actions are offered only for spelling issues. Completion remains visible; Check Again starts a wrapping search. The pane host supplies Close and docking.
Review › Spelling & Grammar, Home › Editor and F7 open the task pane. The initial search begins at the next issue from the current selection and wraps to the start of the current story if needed; pane navigation then stops at that story's end (body, header, note or other active text), not all document stories or only a selection. Each correction uses the existing review command and remains undoable. Ignore Once advances without changing the document or dictionaries. Ignore All lasts for the session; Add to Dictionary uses the personal dictionary. Those two actions are offered only for spelling issues. Completion remains visible; Check Again starts a wrapping search. The pane host supplies Close and docking.
If another command changes the document body or selection, a cached suggestion is refused; Check Again obtains a fresh target. Read-only/protected document commands retain their checks. The pane is local to each window, clears on a document switch and does not alter the compact right-click menu. Programmatic review commands return structured results without opening UI.
+8 -6
View File
@@ -5,12 +5,14 @@ Source Serif 4, Inter and JetBrains Mono, with their bundled styles. Family list
legacy style names such as Inter Medium. They do not load installed fonts, user font preferences,
or the optional `CRAFT_FONTS_DIR` input. No download or extra font checkout is required.
Every layout unit test starts with `crate::test_fonts();`, before constructing its fixture or
resolving a font. This initializes the process-wide database once, including when a single test is
run by name. The `wordcraft-fonts/test-support` development feature exposes the initializer;
enabling the feature alone has no effect. Initialization fails if an application database already
exists, rather than replacing a database whose faces may be in the shaping or math caches.
Other test binaries and application builds keep their normal font discovery behavior.
Layout entry points (`layout`, `layout_para`, `layout_equation` and
`display::mark_text_width`) initialize the process-wide font database once in unit-test builds,
including when a single test is run by name. Tests that resolve fonts before calling a layout
entry point must first call `crate::test_fonts();`. The `wordcraft-fonts/test-support`
development feature exposes the initializer; enabling the feature alone has no effect.
Initialization fails if an application database already exists, rather than replacing a database
whose faces may be in the shaping or math caches. Other test binaries and application builds
keep their normal font discovery behavior.
Uninstalled requested families use the normal substitution lists, restricted to this fixed set.
In particular, the default Aptos request resolves to Source Sans 3. These fonts are not Calibri
File diff suppressed because one or more lines are too long
+3 -1
View File
File diff suppressed because one or more lines are too long
+8 -5
View File
@@ -19,11 +19,14 @@ Citations (each runs one of the commands below).
| `ui.zotero.status` | `{busy, waitingForAnswer, last}` |
| `ui.zotero.answer` | `{"button": n}`: answer a question Zotero is asking (OK/Yes 1, No/Cancel 0; with Yes/No/Cancel: Yes 2, No 1, Cancel 0) |
They run in the app (and through the control channel and MCP bridged to the app). A command
returns at once with `{"started": …}`; Zotero then works in its own window and WordCraft answers
it in the background. All changes from one command are one undo step. If New or Open replaces
the document while a command is running, Zotero's remaining calls for it get an error and the
new document is left as it is.
They run in the app (and through the control channel and MCP bridged to the app). The six Zotero
actions return at once with `{"started": …}`; Zotero then works in its own window and WordCraft
answers it in the background. All changes from one action are one undo step. If New or Open
replaces the document while an action is running, Zotero's remaining calls for it get an error
and the new document is left as it is.
`ui.zotero.status` returns the current state. A successful `ui.zotero.answer` returns
`{"answered": n}` for the selected button.
From a terminal, against a file:
+7 -4
View File
@@ -19,7 +19,7 @@ pub fn png_size(png: &[u8]) -> Result<(u32, u32), String> {
/// An ICO file holding `pngs`, which must be square and at most 256 px.
pub fn pack(pngs: &[Vec<u8>]) -> Result<Vec<u8>, String> {
if pngs.is_empty() || pngs.len() > u16::MAX as usize {
return Err("need at least one PNG".into());
return Err("need between 1 and 65535 PNGs".into());
}
let mut out = Vec::new();
out.extend_from_slice(&0u16.to_le_bytes()); // reserved
@@ -29,7 +29,7 @@ pub fn pack(pngs: &[Vec<u8>]) -> Result<Vec<u8>, String> {
for png in pngs {
let (w, h) = png_size(png)?;
if w != h || w == 0 || w > 256 {
return Err(format!("icon images must be square and at most 256 px, got {w}x{h}"));
return Err(format!("icon images must be square and between 1 and 256 px, got {w}x{h}"));
}
let dim = if w == 256 { 0 } else { w as u8 };
out.extend_from_slice(&[dim, dim, 0, 0]); // width, height, palette size, reserved
@@ -87,10 +87,13 @@ mod tests {
#[test]
fn rejects_bad_input() {
assert!(pack(&[]).is_err());
assert!(pack(&[fake_png(512)]).is_err());
assert_eq!(pack(&[]).unwrap_err(), "need between 1 and 65535 PNGs");
assert_eq!(pack(&vec![Vec::new(); usize::from(u16::MAX) + 1]).unwrap_err(), "need between 1 and 65535 PNGs");
assert_eq!(pack(&[fake_png(0)]).unwrap_err(), "icon images must be square and between 1 and 256 px, got 0x0");
assert_eq!(pack(&[fake_png(512)]).unwrap_err(), "icon images must be square and between 1 and 256 px, got 512x512");
assert!(pack(&[b"GIF89a".to_vec()]).is_err());
assert_eq!(png_size(&fake_png(48)).unwrap(), (48, 48));
assert!(pack(&[fake_png(1)]).is_ok());
}
#[test]
-1
View File
@@ -37,7 +37,6 @@ pub const TABLE: &[(&str, Class)] = &[
("control-key", Class::Standalone),
("doc", Class::Layer(1)),
("fonts", Class::Layer(1)),
("metafile", Class::Layer(1)),
("layout", Class::Layer(2)),
("docx", Class::Layer(2)),
("docbin", Class::Layer(2)),
+4 -2
View File
@@ -19,7 +19,7 @@ usage: cargo xtask <command>
commands:
assets check that every icon/image/font/asset is attributed in ATTRIBUTION.md
layers enforce the crate dependency layering (plan/architecture.md §3)
layers enforce the crate dependency layering (docs/architecture.md, Layers)
wasm cargo check --target wasm32-unknown-unknown for the wasm-safe crates (one call)
test workspace tests (cargo nextest when installed, else cargo test), the interface
audit with its missing-translation report, then doctests
@@ -34,6 +34,8 @@ commands:
show where test corpora live; --download fetches PngSuite into corpus/pngsuite
stats [--exact] count tests and lines per crate (--exact: ask the test harness via `-- --list`)
parity recompute the Word feature-parity summary in docs/parity-checklist.md
version [set X.Y.Z[-pre]]
show the workspace version, or set it and update Cargo.lock
visual-diff <ref.pdf> <test.pdf> <outdir> [--private] [--dpi N]
compare two PDFs of a document page by page (SSIM, line breaks, offsets);
needs poppler (pdftoppm, pdftotext)
@@ -100,7 +102,7 @@ pub fn metadata() -> Result<serde_json::Value, String> {
fn cmd_layers() -> Result<(), String> {
let crates = layers::from_metadata(&metadata()?)?;
println!("Dependency layering (plan/architecture.md §3)\n");
println!("Dependency layering (docs/architecture.md, Layers)\n");
println!("{:<28} {:<14} workspace deps", "crate", "layer");
for c in &crates {
let ws: Vec<String> = c