mirror of
https://github.com/storytold/wordcraft.git
synced 2026-11-17 11:22:56 -06:00
Compare commits
46
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
b78606c39b | ||
|
|
93bf14883c | ||
|
|
0cb315edaf | ||
|
|
2dd0f9a67b | ||
|
|
739cdcad0b | ||
|
|
b3f31666d3 | ||
|
|
68f758928e | ||
|
|
840efd03fb | ||
|
|
8e8ab631fd | ||
|
|
8a9d04eeb1 | ||
|
|
266407e840 | ||
|
|
8a56c71fa0 | ||
|
|
c817cc95c6 | ||
|
|
ff0823f40d | ||
|
|
211f62231d | ||
|
|
9144b9bfda | ||
|
|
a61cef5d45 | ||
|
|
739491f5c7 | ||
|
|
8377ea8e8f | ||
|
|
4357166531 | ||
|
|
5d871d0519 | ||
|
|
ae2d2b43d6 | ||
|
|
cd23034f65 | ||
|
|
b2306fe5ef | ||
|
|
646fbc7cd5 | ||
|
|
4a347e070a | ||
|
|
3bf4c05461 | ||
|
|
7b26a94193 | ||
|
|
ace000b4a4 | ||
|
|
7adbdc574c | ||
|
|
f77eef9cb6 | ||
|
|
a2f41d728e | ||
|
|
9fe9bd5042 | ||
|
|
83c3b5890b | ||
|
|
f472620ac0 | ||
|
|
5467f998a0 | ||
|
|
78dfa8f648 | ||
|
|
82f0c467be | ||
|
|
837a610133 | ||
|
|
de977bcde6 | ||
|
|
4ba0595760 | ||
|
|
e6e8c61dbf | ||
|
|
1d150004f7 | ||
|
|
7ccfd4caef | ||
|
|
7b3b6f8041 | ||
|
|
fecb717f99 |
@@ -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
|
||||
|
||||
+7
-1
File diff suppressed because one or more lines are too long
@@ -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
|
||||
|
||||
@@ -151,7 +151,7 @@ impl Launcher {
|
||||
name: Some(name.clone()),
|
||||
suggested: Some(name.clone()),
|
||||
folder: dir.clone().map(std::path::PathBuf::from),
|
||||
filters: save_filters(name),
|
||||
filters: wordcraft_ui_egui::save_filters(name),
|
||||
current: Some(0),
|
||||
cancel,
|
||||
timeout: None,
|
||||
@@ -224,7 +224,7 @@ fn picker(dialog: rfd::AsyncFileDialog, req: &FileDialogRequest) -> Picking {
|
||||
if let Some(dir) = dir.filter(|d| std::path::Path::new(d).is_dir()) {
|
||||
dialog = dialog.set_directory(dir);
|
||||
}
|
||||
for (label, exts) in save_filters(&name) {
|
||||
for (label, exts) in wordcraft_ui_egui::save_filters(&name) {
|
||||
dialog = dialog.add_filter(label, &exts);
|
||||
}
|
||||
Box::pin(async move { dialog.save_file().await.into_iter().collect() })
|
||||
@@ -324,62 +324,9 @@ fn on_path(program: &str) -> bool {
|
||||
std::env::var_os("PATH").is_some_and(|paths| std::env::split_paths(&paths).any(|dir| dir.join(program).is_file()))
|
||||
}
|
||||
|
||||
/// The file types Save As offers: every format the engine saves, with the suggested name's own
|
||||
/// format first. rfd makes a filter's first extension the dialog's default, which the Windows,
|
||||
/// macOS and Linux panels append to a file name the user typed without one; with no filter at
|
||||
/// all the name came back bare and the save failed, since the format is chosen by extension
|
||||
/// (#689).
|
||||
fn save_exts(name: &str) -> Vec<String> {
|
||||
let suggested = std::path::Path::new(name)
|
||||
.extension()
|
||||
.and_then(std::ffi::OsStr::to_str)
|
||||
.map(str::to_ascii_lowercase)
|
||||
// A .markdown file is under Markdown's one entry in the list.
|
||||
.map(|e| if e == "markdown" { "md".to_string() } else { e })
|
||||
.filter(|e| wordcraft_engine::io::SAVE_EXTS.contains(&e.as_str()))
|
||||
.unwrap_or_else(|| "docx".to_string());
|
||||
let mut exts: Vec<String> = Vec::with_capacity(wordcraft_engine::io::SAVE_EXTS.len());
|
||||
exts.push(suggested.clone());
|
||||
exts.extend(wordcraft_engine::io::SAVE_EXTS.iter().filter(|e| **e != suggested).map(|e| (*e).to_string()));
|
||||
exts
|
||||
}
|
||||
|
||||
/// The "Save as type" list (#1399): one named entry per format, the suggested one first (see
|
||||
/// [`save_exts`] for why the order matters).
|
||||
///
|
||||
/// On Linux and the BSDs, [`crate::portal_save`] asks the portal directly over D-Bus and gives a
|
||||
/// name the dialog left alone the chosen type's extension (#6180). When falling back to `rfd`, the
|
||||
/// extension in the name wins, as `rfd` doesn't report which entry the user picked.
|
||||
fn save_filters(name: &str) -> Vec<(String, Vec<String>)> {
|
||||
save_exts(name).into_iter().map(|e| (format!("{} (*.{e})", format_name(&e)), vec![e])).collect()
|
||||
}
|
||||
|
||||
/// A readable name for a save format's extension.
|
||||
fn format_name(ext: &str) -> String {
|
||||
match ext {
|
||||
"docx" => "Word Document".into(),
|
||||
"docm" => "Word Macro-Enabled Document".into(),
|
||||
"dotx" => "Word Template".into(),
|
||||
"dotm" => "Word Macro-Enabled Template".into(),
|
||||
"pdf" => "PDF".into(),
|
||||
"txt" => "Plain Text".into(),
|
||||
"md" => "Markdown".into(),
|
||||
"html" => "Web Page".into(),
|
||||
"rtf" => "Rich Text Format".into(),
|
||||
"odt" => "OpenDocument Text".into(),
|
||||
"ott" => "OpenDocument Text Template".into(),
|
||||
"fodt" => "Flat OpenDocument Text".into(),
|
||||
"tex" => "LaTeX".into(),
|
||||
"png" => "PNG Image".into(),
|
||||
"json" => "JSON".into(),
|
||||
"xml" => "XML".into(),
|
||||
other => other.to_ascii_uppercase(),
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::{pick, save_exts, save_filters};
|
||||
use super::pick;
|
||||
use std::time::Duration;
|
||||
|
||||
/// #2999: a dialog that "cancels" at once is a portal that failed: asked again without a
|
||||
@@ -430,44 +377,4 @@ mod tests {
|
||||
assert!(newer.token.is_cancelled(), "the newer request is still armed");
|
||||
assert!(!abandoned.token.is_cancelled(), "only the armed request is cancelled");
|
||||
}
|
||||
|
||||
/// #1399: the Save dialog's type list has one named entry per format, the suggested one first,
|
||||
/// every savable extension exactly once.
|
||||
#[test]
|
||||
fn save_dialog_lists_one_named_type_per_format() {
|
||||
let filters = save_filters("report.odt");
|
||||
assert_eq!(filters.len(), wordcraft_engine::io::SAVE_EXTS.len());
|
||||
assert_eq!(filters[0].1, vec!["odt".to_string()]);
|
||||
assert!(filters[0].0.contains("OpenDocument"), "{}", filters[0].0);
|
||||
let all: Vec<&String> = filters.iter().flat_map(|(_, e)| e).collect();
|
||||
for e in wordcraft_engine::io::SAVE_EXTS {
|
||||
assert_eq!(all.iter().filter(|x| x.as_str() == *e).count(), 1, "{e}");
|
||||
}
|
||||
assert!(filters.iter().all(|(l, e)| !l.trim().is_empty() && e.len() == 1));
|
||||
let mut labels: Vec<&String> = filters.iter().map(|(l, _)| l).collect();
|
||||
labels.sort();
|
||||
labels.dedup();
|
||||
assert_eq!(labels.len(), filters.len(), "labels are distinct");
|
||||
// Unknown names fall back to Word's format first.
|
||||
assert_eq!(save_filters("no extension")[0].1, vec!["docx".to_string()]);
|
||||
}
|
||||
|
||||
/// #689: the Save dialog's default extension is the suggested name's own format, so a file
|
||||
/// name the user types without one is saved in the document's format instead of coming back
|
||||
/// bare and failing.
|
||||
#[test]
|
||||
fn save_dialog_defaults_to_the_suggested_format() {
|
||||
assert_eq!(save_exts("novel.docx")[0], "docx");
|
||||
assert_eq!(save_exts("report.odt")[0], "odt");
|
||||
assert_eq!(save_exts("annual report.pdf")[0], "pdf");
|
||||
assert_eq!(save_exts("notes.md")[0], "md");
|
||||
assert_eq!(save_exts("notes.markdown")[0], "md");
|
||||
// A suggested name always has an extension; anything unreadable falls back to Word's.
|
||||
assert_eq!(save_exts("no extension")[0], "docx");
|
||||
assert_eq!(save_exts("mystery.rtf2")[0], "docx");
|
||||
// Every savable format is still offered, once.
|
||||
let exts = save_exts("novel.docx");
|
||||
assert!(wordcraft_engine::io::SAVE_EXTS.iter().all(|e| exts.iter().any(|x| x == e)));
|
||||
assert_eq!(exts.len(), wordcraft_engine::io::SAVE_EXTS.len());
|
||||
}
|
||||
}
|
||||
|
||||
+164
-16
@@ -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() {
|
||||
|
||||
@@ -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"]));
|
||||
}
|
||||
}
|
||||
@@ -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 {
|
||||
|
||||
@@ -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(),
|
||||
]
|
||||
}
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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()))
|
||||
};
|
||||
|
||||
@@ -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)?;
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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")));
|
||||
|
||||
@@ -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)),
|
||||
|
||||
@@ -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]
|
||||
|
||||
@@ -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| {
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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"#,
|
||||
),
|
||||
]
|
||||
}
|
||||
|
||||
@@ -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(),
|
||||
|
||||
+43
-1
@@ -47,6 +47,48 @@ fn ext_of(name: &str) -> String {
|
||||
file.rsplit_once('.').map(|(_, ext)| ext.to_ascii_lowercase()).unwrap_or_default()
|
||||
}
|
||||
|
||||
/// The format a file extension (any case) saves as, named by its [`SAVE_EXTS`] entry, other
|
||||
/// spellings included (`htm` is `html`, `text` is `txt`); `None` for one WordCraft doesn't save.
|
||||
pub fn save_format(ext: &str) -> Option<&'static str> {
|
||||
let ext = ext.to_ascii_lowercase();
|
||||
let ext = match ext.as_str() {
|
||||
"text" => "txt",
|
||||
"markdown" => "md",
|
||||
"htm" | "xhtml" => "html",
|
||||
"latex" | "ltx" => "tex",
|
||||
other => other,
|
||||
};
|
||||
SAVE_EXTS.iter().copied().find(|e| *e == ext)
|
||||
}
|
||||
|
||||
/// The path Save As writes for a `path` the user named, in format `ext` (`docx`, `pdf`…): a file
|
||||
/// name with no extension, or with one WordCraft doesn't save (`Report v1.2`, `notes.final`),
|
||||
/// gets `.ext` added, as Word adds `.docx` (#5368). The format is chosen by the extension, so
|
||||
/// such a name used to fail to save at all.
|
||||
pub fn with_save_ext(path: &str, ext: &str) -> String {
|
||||
if save_format(&ext_of(path)).is_some() {
|
||||
return path.to_string();
|
||||
}
|
||||
add_ext(path, ext)
|
||||
}
|
||||
|
||||
/// The path an export in format `ext` writes for a `path` the user named: one whose extension
|
||||
/// isn't that format's (`Report`, `Report.docx` for a PDF) gets `.ext` added, so an export
|
||||
/// writes the format it was asked for (#5368).
|
||||
pub fn with_export_ext(path: &str, ext: &str) -> String {
|
||||
let current = ext_of(path);
|
||||
if current == ext.to_ascii_lowercase() || save_format(¤t).is_some_and(|f| save_format(ext) == Some(f)) {
|
||||
return path.to_string();
|
||||
}
|
||||
add_ext(path, ext)
|
||||
}
|
||||
|
||||
/// `path` with `.ext` after it. Windows drops a file name's trailing dots, so `Report.` is
|
||||
/// `Report.docx`, not `Report..docx`.
|
||||
fn add_ext(path: &str, ext: &str) -> String {
|
||||
format!("{}.{ext}", path.trim_end_matches('.'))
|
||||
}
|
||||
|
||||
/// Is `ext` one of Word's package formats (.docx/.docm/.dotx/.dotm), which save without loss?
|
||||
pub fn is_word_package(ext: &str) -> bool {
|
||||
wordcraft_docx::Flavor::from_ext(ext).is_some()
|
||||
@@ -464,7 +506,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 {
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -248,7 +248,9 @@ impl Session {
|
||||
/// `file.printPdf`: write the print job's PDF to `path` (no dialogs).
|
||||
pub(crate) fn print_pdf_to_file(s: &mut Session, v: &Value) -> Result<Value, CmdError> {
|
||||
let path = p::req_str(v, "path")?;
|
||||
let path = if path.to_ascii_lowercase().ends_with(".pdf") { path.to_string() } else { format!("{path}.pdf") };
|
||||
// `.pdf` after a name without it, by the rule exports follow (the built-in browser asks
|
||||
// about replacing this same name).
|
||||
let path = crate::io::with_export_ext(path, "pdf");
|
||||
let (bytes, plan) = s.print_pdf(v)?;
|
||||
// Through `io`, so an agent confined to an automation write root (#769) can't print elsewhere.
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
|
||||
@@ -1108,6 +1108,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.
|
||||
@@ -13384,6 +13404,40 @@ fn page_down_extends_a_selection_that_ends_in_collapsed_outline_text() {
|
||||
assert!(s.layout().caret(&s.sel.focus).is_some(), "to a place the outline shows");
|
||||
}
|
||||
|
||||
/// #5368: Save As adds the format's extension to a name with none, or with one WordCraft
|
||||
/// doesn't save, as Word adds .docx; a name with a format's extension (any case) is kept.
|
||||
#[test]
|
||||
fn save_as_adds_the_extension_to_a_name_without_a_format() {
|
||||
use crate::io::with_save_ext;
|
||||
assert_eq!(with_save_ext(r"C:\Docs\Report", "docx"), r"C:\Docs\Report.docx");
|
||||
assert_eq!(with_save_ext(r"C:\My.Docs\Report", "docx"), r"C:\My.Docs\Report.docx", "a Windows folder's dot doesn't count either");
|
||||
assert_eq!(with_save_ext("/home/me/Report v1.2", "docx"), "/home/me/Report v1.2.docx");
|
||||
assert_eq!(with_save_ext("/home/me/notes.final", "dotx"), "/home/me/notes.final.dotx");
|
||||
assert_eq!(with_save_ext("/home/me/Report.", "docx"), "/home/me/Report.docx");
|
||||
assert_eq!(with_save_ext("/home/my.docs/Report", "pdf"), "/home/my.docs/Report.pdf", "a dot in a folder name doesn't count");
|
||||
for kept in ["/a/Report.docx", "/a/Report.PDF", "/a/page.htm", "/a/notes.text", "/a/Report.odt"] {
|
||||
assert_eq!(with_save_ext(kept, "docx"), kept);
|
||||
}
|
||||
// Every name it gives saves.
|
||||
let doc = wordcraft_doc::Document::from_text("x");
|
||||
for name in ["Report", "Report v1.2", "Report."] {
|
||||
let path = with_save_ext(name, "docx");
|
||||
assert!(crate::io::save_bytes(&path, &doc).is_ok(), "{path}");
|
||||
}
|
||||
assert!(crate::io::save_bytes("Report v1.2", &doc).is_err(), "it used to fail");
|
||||
// Other spellings name the same format.
|
||||
assert_eq!(crate::io::save_format("HTM"), Some("html"));
|
||||
assert_eq!(crate::io::save_format("text"), Some("txt"));
|
||||
assert_eq!(crate::io::save_format("2"), None);
|
||||
// An export writes its own format, whatever format's extension the name has.
|
||||
use crate::io::with_export_ext;
|
||||
assert_eq!(with_export_ext("/a/Handout", "pdf"), "/a/Handout.pdf");
|
||||
assert_eq!(with_export_ext("/a/Handout.docx", "pdf"), "/a/Handout.docx.pdf");
|
||||
assert_eq!(with_export_ext("/a/Handout.PDF", "pdf"), "/a/Handout.PDF");
|
||||
assert_eq!(with_export_ext("/a/page.htm", "html"), "/a/page.htm");
|
||||
assert_eq!(with_export_ext("/a/shot.pdf", "png"), "/a/shot.pdf.png");
|
||||
}
|
||||
|
||||
/// A picture an OpenDocument file gives no size is shown at its own, fitted to the text as other
|
||||
/// formats' are; one with a stated size keeps it, in line too.
|
||||
#[test]
|
||||
|
||||
@@ -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 ¶.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;
|
||||
|
||||
@@ -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}"),
|
||||
|
||||
@@ -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]
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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)
|
||||
{
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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]
|
||||
}
|
||||
@@ -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
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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]);
|
||||
}
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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
@@ -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();
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -856,7 +856,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
@@ -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);
|
||||
|
||||
@@ -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.
|
||||
@@ -1528,3 +1976,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);
|
||||
}
|
||||
|
||||
@@ -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"));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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, ¶ms);
|
||||
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());
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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]
|
||||
|
||||
@@ -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]
|
||||
|
||||
@@ -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(®, &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());
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -11,7 +11,7 @@ use std::path::{Path, PathBuf};
|
||||
|
||||
use egui::{Align2, Rect, Sense, Ui, pos2, vec2};
|
||||
|
||||
use crate::file_dialogs::{AfterPick, FileDialogRequest, open_filters};
|
||||
use crate::file_dialogs::{AfterPick, FileDialogRequest, format_name, open_filters, save_filters};
|
||||
use crate::print_page::{EXPORT_FORMATS, export_file_ext, export_name, is_document_ext};
|
||||
use crate::theme::{Tokens, regular};
|
||||
use crate::{WordApp, icons};
|
||||
@@ -154,9 +154,18 @@ impl FileBrowser {
|
||||
FileDialogRequest::Open { purpose } | FileDialogRequest::OpenMany { purpose } => {
|
||||
(String::new(), open_filters(purpose).iter().map(|(l, e)| ((*l).to_string(), e.iter().map(|x| (*x).to_string()).collect())).collect())
|
||||
}
|
||||
FileDialogRequest::Save { name, .. } => {
|
||||
// Print's Save as PDF writes a PDF whatever type is picked: only that one, then All
|
||||
// files. (An export's types are File › Export's formats, below.)
|
||||
FileDialogRequest::Save { name, .. } if matches!(after, AfterPick::PrintPdf { .. }) => {
|
||||
let ext = Path::new(name).extension().and_then(std::ffi::OsStr::to_str).filter(|e| !e.is_empty());
|
||||
let mut f: Vec<(String, Vec<String>)> = ext.map(|e| (format!("*.{e}"), vec![e.to_string()])).into_iter().collect();
|
||||
let mut f: Vec<(String, Vec<String>)> =
|
||||
ext.map(|e| (format!("{} (*.{e})", format_name(&e.to_ascii_lowercase())), vec![e.to_string()])).into_iter().collect();
|
||||
f.push(("All files".into(), vec!["*".into()]));
|
||||
(name.clone(), f)
|
||||
}
|
||||
// Every format WordCraft saves, the suggested one first, as the system dialog lists them (#5368).
|
||||
FileDialogRequest::Save { name, .. } => {
|
||||
let mut f = save_filters(name);
|
||||
f.push(("All files".into(), vec!["*".into()]));
|
||||
(name.clone(), f)
|
||||
}
|
||||
@@ -202,14 +211,27 @@ impl FileBrowser {
|
||||
self.note = Note::None;
|
||||
}
|
||||
|
||||
/// A type was chosen: when exporting it is the format, and the name's export extension follows it.
|
||||
/// A type was chosen: when exporting it is the format, and the name's export extension follows
|
||||
/// it. Saving, the name's extension changes to the type's when it is a format's
|
||||
/// (`Report.docx` → `Report.pdf`), so the type picked is the type saved (#5368).
|
||||
fn type_changed(&mut self) {
|
||||
let Some(format) = self.exports.get(self.filter).cloned() else { return };
|
||||
// Only a known document extension is replaced; `notes.v2` keeps its `.v2`.
|
||||
if Path::new(&self.name).extension().and_then(|e| e.to_str()).is_some_and(is_document_ext) {
|
||||
self.name = export_name(&self.name, &format);
|
||||
if let Some(format) = self.exports.get(self.filter).cloned() {
|
||||
// Only a known document extension is replaced; `notes.v2` keeps its `.v2`.
|
||||
if Path::new(&self.name).extension().and_then(|e| e.to_str()).is_some_and(is_document_ext) {
|
||||
self.name = export_name(&self.name, &format);
|
||||
}
|
||||
self.after = AfterPick::Export { ext: format };
|
||||
return;
|
||||
}
|
||||
if !matches!(self.req, FileDialogRequest::Save { .. }) {
|
||||
return;
|
||||
}
|
||||
let Some(ext) = self.exts().first().filter(|e| e.as_str() != "*").cloned() else { return };
|
||||
let path = Path::new(&self.name);
|
||||
let typed = path.extension().and_then(std::ffi::OsStr::to_str);
|
||||
if typed.and_then(wordcraft_engine::io::save_format).is_some() {
|
||||
self.name = path.with_extension(ext).to_string_lossy().into_owned();
|
||||
}
|
||||
self.after = AfterPick::Export { ext: format };
|
||||
}
|
||||
|
||||
fn up(&mut self) {
|
||||
@@ -245,11 +267,13 @@ impl FileBrowser {
|
||||
// The chosen type is the format: its extension replaces a known document
|
||||
// extension on the name, and is added to any other.
|
||||
path = PathBuf::from(export_name(&path.to_string_lossy(), ext));
|
||||
} else if path.extension().is_none()
|
||||
&& let Some(ext) = self.exts().first().filter(|e| e.as_str() != "*")
|
||||
{
|
||||
path.set_extension(ext);
|
||||
} else if let Some(ext) = self.exts().first().filter(|e| e.as_str() != "*") {
|
||||
// A name with no extension WordCraft saves (`Report v1.2`) gets the type's (#5368).
|
||||
path = PathBuf::from(wordcraft_engine::io::with_save_ext(&path.to_string_lossy(), ext));
|
||||
}
|
||||
// Then the save's own rule (All files: the suggested format; Print's Save as PDF:
|
||||
// `.pdf`), so a file about to be replaced is asked about under its written name.
|
||||
path = PathBuf::from(self.after.written_path(&path.to_string_lossy()));
|
||||
if path.exists() && self.note != Note::Replace(path.clone()) {
|
||||
self.note = Note::Replace(path);
|
||||
return Step::Stay;
|
||||
@@ -300,6 +324,24 @@ impl WordApp {
|
||||
self.file_browser.open = Some(Box::new(FileBrowser::new(req, after, start, unavailable)));
|
||||
}
|
||||
|
||||
/// Ask whether to replace `path` before a save or export writes it: the built-in browser on
|
||||
/// its folder and name, saying it exists (#5368 review). The system dialog only asked about
|
||||
/// the name it returned, and the save added an extension to that. OK replaces the file,
|
||||
/// another name saves there, Cancel cancels the save.
|
||||
pub(crate) fn confirm_replace(&mut self, req: FileDialogRequest, after: AfterPick, path: PathBuf) {
|
||||
let req = match req {
|
||||
FileDialogRequest::Save { .. } => FileDialogRequest::Save {
|
||||
name: path.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default(),
|
||||
dir: path.parent().filter(|d| d.is_dir()).map(|d| d.to_string_lossy().into_owned()),
|
||||
},
|
||||
other => other,
|
||||
};
|
||||
self.show_file_browser(req, after, false);
|
||||
if let Some(b) = self.file_browser.open.as_mut() {
|
||||
b.note = Note::Replace(path);
|
||||
}
|
||||
}
|
||||
|
||||
/// `ui.fileBrowser`: the built-in browser for `purpose` (document, picture, recipients, save,
|
||||
/// export), even when a system dialog was asked for and never showed up (it is given up as cancelled).
|
||||
pub(crate) fn browse_builtin(&mut self, purpose: &str) {
|
||||
@@ -311,10 +353,11 @@ impl WordApp {
|
||||
let (req, after) = match purpose {
|
||||
"picture" => (FileDialogRequest::Open { purpose: "picture".into() }, AfterPick::Picture),
|
||||
"recipients" => (FileDialogRequest::Open { purpose: "recipients".into() }, AfterPick::Recipients),
|
||||
"save" => (
|
||||
FileDialogRequest::Save { name: self.default_save_name(), dir: None },
|
||||
AfterPick::SaveAs { after: crate::file_dialogs::AfterSave::Nothing, document: self.session.document_id() },
|
||||
),
|
||||
"save" => {
|
||||
let name = self.default_save_name();
|
||||
let after = AfterPick::save_as(crate::file_dialogs::AfterSave::Nothing, self.session.document_id(), &name);
|
||||
(FileDialogRequest::Save { name, dir: None }, after)
|
||||
}
|
||||
"export" => {
|
||||
let ext = pending.unwrap_or_else(|| "pdf".into());
|
||||
let name = format!("{}.{}", self.title_stem(), export_file_ext(&ext));
|
||||
@@ -419,6 +462,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() {
|
||||
@@ -599,6 +645,66 @@ mod tests {
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
}
|
||||
|
||||
/// #5368: the built-in Save As lists every format WordCraft saves, the suggested one first;
|
||||
/// picking a type changes the name's extension to it, a name with no format's extension gets
|
||||
/// the type's, and the replace prompt is about the file that will be written.
|
||||
#[test]
|
||||
fn save_lists_every_format_and_the_type_picked_is_saved() {
|
||||
let dir = scratch("save-types");
|
||||
let req = FileDialogRequest::Save { name: "Document1.docx".into(), dir: None };
|
||||
let after = AfterPick::save_as(crate::file_dialogs::AfterSave::Nothing, 0, "Document1.docx");
|
||||
let mut b = FileBrowser::new(req, after, dir.clone(), false);
|
||||
assert_eq!(b.filters.len(), wordcraft_engine::io::SAVE_EXTS.len() + 1, "every format, then All files");
|
||||
assert_eq!(b.filters[0].1, ["docx"]);
|
||||
assert_eq!(b.filters.last().map(|f| f.1.clone()), Some(vec!["*".to_string()]));
|
||||
let pdf = b.filters.iter().position(|(_, e)| e[0] == "pdf").unwrap();
|
||||
b.filter = pdf;
|
||||
b.type_changed();
|
||||
assert_eq!(b.name, "Document1.pdf");
|
||||
assert_eq!(b.accept(), Step::Pick(dir.join("Document1.pdf")));
|
||||
b.name = "Report v1.2".into();
|
||||
b.type_changed();
|
||||
assert_eq!(b.name, "Report v1.2", "a name with no format's extension isn't changed");
|
||||
assert_eq!(b.accept(), Step::Pick(dir.join("Report v1.2.pdf")));
|
||||
// Another spelling of a format is a format's extension too.
|
||||
b.name = "Page.htm".into();
|
||||
b.type_changed();
|
||||
assert_eq!(b.name, "Page.pdf");
|
||||
// All files: the suggested format, and a file of that name is asked about before it's replaced.
|
||||
b.filter = b.filters.len() - 1;
|
||||
b.type_changed();
|
||||
b.name = "Bare".into();
|
||||
assert_eq!(b.accept(), Step::Pick(dir.join("Bare.docx")));
|
||||
std::fs::write(dir.join("Bare.docx"), b"x").unwrap();
|
||||
assert_eq!(b.accept(), Step::Stay, "asks before replacing Bare.docx");
|
||||
assert_eq!(b.accept(), Step::Pick(dir.join("Bare.docx")));
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
}
|
||||
|
||||
/// #5368 review: Print's Save as PDF writes a PDF whatever type is picked, so the built-in
|
||||
/// browser offers only that one and All files; the file asked about before it's replaced is
|
||||
/// the one written, `.pdf` added as `file.printPdf` adds it. (An export's types are File ›
|
||||
/// Export's formats, and the one picked is written: `export_types_choose_the_format_and_the_extension`.)
|
||||
#[test]
|
||||
fn print_to_pdf_lists_only_pdf() {
|
||||
let dir = scratch("export-types");
|
||||
let req = FileDialogRequest::Save { name: "Handout.pdf".into(), dir: None };
|
||||
let mut b = FileBrowser::new(req, AfterPick::PrintPdf { settings: serde_json::json!({}) }, dir.clone(), false);
|
||||
assert_eq!(b.filters.len(), 2, "{:?}", b.filters);
|
||||
assert_eq!(b.filters[0].1, ["pdf"]);
|
||||
assert!(b.filters[0].0.starts_with("PDF"), "{}", b.filters[0].0);
|
||||
assert_eq!(b.filters[1].1, ["*"]);
|
||||
b.filter = 1;
|
||||
b.type_changed();
|
||||
b.name = "Handout.docx".into();
|
||||
assert_eq!(b.accept(), Step::Pick(dir.join("Handout.docx.pdf")), "a PDF is written, named so");
|
||||
std::fs::write(dir.join("Notes.pdf"), b"x").unwrap();
|
||||
b.name = "Notes".into();
|
||||
assert_eq!(b.accept(), Step::Stay, "asks before replacing Notes.pdf");
|
||||
assert_eq!(b.accept(), Step::Pick(dir.join("Notes.pdf")));
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
}
|
||||
|
||||
/// The host can't show a system dialog (#576): Save As carries on in the built-in browser,
|
||||
/// and its answer saves the document.
|
||||
#[test]
|
||||
@@ -765,6 +871,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]
|
||||
|
||||
@@ -55,14 +55,69 @@ pub fn open_filters(purpose: &str) -> &'static [(&'static str, &'static [&'stati
|
||||
}
|
||||
}
|
||||
|
||||
/// The file types Save As offers: every format the engine saves, with the suggested name's own
|
||||
/// format first. rfd makes a filter's first extension the dialog's default, which the Windows,
|
||||
/// macOS and Linux panels append to a file name the user typed without one; with no filter at
|
||||
/// all the name came back bare and the save failed, since the format is chosen by extension
|
||||
/// (#689). The built-in browser lists them too (#5368).
|
||||
pub fn save_exts(name: &str) -> Vec<String> {
|
||||
let saves = wordcraft_engine::io::SAVE_EXTS;
|
||||
let suggested = std::path::Path::new(name)
|
||||
.extension()
|
||||
.and_then(std::ffi::OsStr::to_str)
|
||||
.map(str::to_ascii_lowercase)
|
||||
// A .markdown file is under Markdown's one entry in the list.
|
||||
.map(|e| if e == "markdown" { "md".to_string() } else { e })
|
||||
.filter(|e| saves.contains(&e.as_str()))
|
||||
.unwrap_or_else(|| "docx".to_string());
|
||||
let mut exts: Vec<String> = Vec::with_capacity(saves.len());
|
||||
exts.push(suggested.clone());
|
||||
exts.extend(saves.iter().filter(|e| **e != suggested).map(|e| (*e).to_string()));
|
||||
exts
|
||||
}
|
||||
|
||||
/// The "Save as type" list (#1399): one named entry per format, the suggested one first (see
|
||||
/// [`save_exts`] for why the order matters).
|
||||
///
|
||||
/// On Linux and the BSDs, the app asks the desktop portal directly over D-Bus and gives a name
|
||||
/// the dialog left alone the chosen type's extension (#6180). When falling back to `rfd`, the
|
||||
/// extension in the name wins, as `rfd` doesn't report which entry the user picked.
|
||||
pub fn save_filters(name: &str) -> Vec<(String, Vec<String>)> {
|
||||
save_exts(name).into_iter().map(|e| (format!("{} (*.{e})", format_name(&e)), vec![e])).collect()
|
||||
}
|
||||
|
||||
/// A readable name for a save format's extension.
|
||||
pub(crate) fn format_name(ext: &str) -> String {
|
||||
match ext {
|
||||
"docx" => "Word Document".into(),
|
||||
"docm" => "Word Macro-Enabled Document".into(),
|
||||
"dotx" => "Word Template".into(),
|
||||
"dotm" => "Word Macro-Enabled Template".into(),
|
||||
"pdf" => "PDF".into(),
|
||||
"txt" => "Plain Text".into(),
|
||||
"md" => "Markdown".into(),
|
||||
"html" => "Web Page".into(),
|
||||
"rtf" => "Rich Text Format".into(),
|
||||
"odt" => "OpenDocument Text".into(),
|
||||
"ott" => "OpenDocument Text Template".into(),
|
||||
"fodt" => "Flat OpenDocument Text".into(),
|
||||
"tex" => "LaTeX".into(),
|
||||
"png" => "PNG Image".into(),
|
||||
"json" => "JSON".into(),
|
||||
"xml" => "XML".into(),
|
||||
other => other.to_ascii_uppercase(),
|
||||
}
|
||||
}
|
||||
|
||||
/// What to do with the path picked in a dialog.
|
||||
pub(crate) enum AfterPick {
|
||||
/// Open the picked document from the window showing `document` ([`WordApp::open_file`]).
|
||||
OpenDocument { document: u64 },
|
||||
/// Insert the picked picture, or replace the pending Change Picture target.
|
||||
Picture,
|
||||
/// Save the document there, then carry on.
|
||||
SaveAs { after: AfterSave, document: u64 },
|
||||
/// Save the document there, then carry on. A name with no extension WordCraft saves gets
|
||||
/// `ext`, the suggested name's (#5368).
|
||||
SaveAs { after: AfterSave, document: u64, ext: String },
|
||||
/// Save a copy there in this format (`pdf`, `docx`, `png`…).
|
||||
Export { ext: String },
|
||||
/// Write the PDF of these print settings there (File › Print › Save these pages as PDF).
|
||||
@@ -82,6 +137,30 @@ pub(crate) enum AfterPick {
|
||||
ComparePath { revised: bool },
|
||||
}
|
||||
|
||||
impl AfterPick {
|
||||
/// Save As for `document`, suggested as `name`: its extension is the format a name typed
|
||||
/// without one is saved in (`.docx` when it has none).
|
||||
pub(crate) fn save_as(after: AfterSave, document: u64, name: &str) -> Self {
|
||||
let ext = std::path::Path::new(name).extension().and_then(std::ffi::OsStr::to_str).filter(|e| !e.is_empty()).unwrap_or("docx");
|
||||
AfterPick::SaveAs { after, document, ext: ext.to_ascii_lowercase() }
|
||||
}
|
||||
|
||||
/// The path a save or export writes for the `path` picked (#5368): Save As adds the format's
|
||||
/// extension to a name with none it saves; an export names the file as the built-in browser
|
||||
/// does (`print_page::export_name`: its format's extension replaces a known document one and
|
||||
/// is added to any other); Print's Save as PDF adds `.pdf` to a name without it, as
|
||||
/// `file.printPdf` does. Applied before asking to replace a file too, so the file asked about
|
||||
/// is the one written.
|
||||
pub(crate) fn written_path(&self, path: &str) -> String {
|
||||
match self {
|
||||
AfterPick::SaveAs { ext, .. } => wordcraft_engine::io::with_save_ext(path, ext),
|
||||
AfterPick::Export { ext } => crate::print_page::export_name(path, ext),
|
||||
AfterPick::PrintPdf { .. } => wordcraft_engine::io::with_export_ext(path, "pdf"),
|
||||
_ => path.to_string(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// What to do once Save As has written the document.
|
||||
pub(crate) enum AfterSave {
|
||||
Nothing,
|
||||
@@ -149,7 +228,7 @@ impl WordApp {
|
||||
}
|
||||
FileDialogRequest::Save { name, .. } => self.services.pick_save.as_ref().and_then(|f| f(name)),
|
||||
};
|
||||
Asked::Done(self.finish_pick(after, picked))
|
||||
self.finish_system_pick(req, after, picked.into_iter().collect()).map_or(Asked::Pending, Asked::Done)
|
||||
}
|
||||
|
||||
/// Pick up the answer of an open file dialog, if it has arrived (every frame, from `logic`),
|
||||
@@ -163,7 +242,7 @@ impl WordApp {
|
||||
};
|
||||
let d = self.file_dialog.take()?;
|
||||
match answer {
|
||||
Ok(picked) => Some(self.finish_picks(d.after, picked)),
|
||||
Ok(picked) => self.finish_system_pick(d.req, d.after, picked),
|
||||
Err(reason) => {
|
||||
log::warn!("no system file dialog ({reason}); showing the built-in file browser");
|
||||
self.dialog_unavailable(d.req, d.after)
|
||||
@@ -198,6 +277,24 @@ impl WordApp {
|
||||
Some(self.finish_pick(after, None))
|
||||
}
|
||||
|
||||
/// Finish what the system dialog was for with its answer. A save or export that writes another
|
||||
/// name than the one picked (its extension added, #5368) asks first when a file of that name
|
||||
/// exists: the system dialog only asked about the name it returned (#5368 review). `None`
|
||||
/// while that question is open in the built-in browser.
|
||||
fn finish_system_pick(&mut self, req: FileDialogRequest, after: AfterPick, picked: Vec<String>) -> Option<Result<Value, String>> {
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
if let Some(p) = picked.first() {
|
||||
let written = after.written_path(p);
|
||||
if written != *p && std::path::Path::new(&written).exists() {
|
||||
self.confirm_replace(req, after, std::path::PathBuf::from(written));
|
||||
return None;
|
||||
}
|
||||
}
|
||||
#[cfg(target_arch = "wasm32")]
|
||||
let _ = req;
|
||||
Some(self.finish_picks(after, picked))
|
||||
}
|
||||
|
||||
/// Do what the dialog was for with the picked paths (none: the user cancelled). Only Add Font
|
||||
/// takes more than one; the others use the first.
|
||||
fn finish_picks(&mut self, after: AfterPick, picked: Vec<String>) -> Result<Value, String> {
|
||||
@@ -247,6 +344,8 @@ impl WordApp {
|
||||
|
||||
/// Do what the dialog was for with the picked path (`None`: the user cancelled).
|
||||
pub(crate) fn finish_pick(&mut self, after: AfterPick, picked: Option<String>) -> Result<Value, String> {
|
||||
// An export names its file itself, below, and won't replace a file under a new name.
|
||||
let picked = if matches!(after, AfterPick::Export { .. }) { picked } else { picked.map(|p| after.written_path(&p)) };
|
||||
match after {
|
||||
AfterPick::OpenDocument { document } => {
|
||||
let Some(path) = picked else { return Ok(json!({"cancelled": true})) };
|
||||
@@ -302,21 +401,22 @@ impl WordApp {
|
||||
self.clear_export_error();
|
||||
return Ok(json!({"cancelled": true}));
|
||||
};
|
||||
// A system Save dialog lets the user type any name, and the engine picks the format
|
||||
// by the extension (an explicit format only for an .xml path): the file is named as
|
||||
// the built-in browser names it (`notes.docx` as PDF is `notes.pdf`, `notes.v2`
|
||||
// `notes.v2.pdf`, #5368). A file of that name the dialog never confirmed isn't
|
||||
// replaced (the system dialog's answer asks first, `finish_system_pick`).
|
||||
let named = crate::print_page::export_name(&path, &ext);
|
||||
if named != path {
|
||||
path = named;
|
||||
if std::path::Path::new(&path).exists() {
|
||||
// Callers drop the result, so say it where the person sees it.
|
||||
return Err(self.fail_export(format!("{path} already exists; choose another name")));
|
||||
}
|
||||
}
|
||||
let r = if ext == "png" {
|
||||
self.run("file.exportPng", json!({"path": path}))
|
||||
} else if ext == "xml" || ext == crate::print_page::EXPORT_WORD_2003 {
|
||||
// The engine takes an explicit format only for an .xml path, and a system Save
|
||||
// dialog lets the user type any name: give it the extension, as the built-in
|
||||
// browser does (`notes.docx` becomes `notes.xml`, `notes.v2` `notes.v2.xml`).
|
||||
let named = crate::print_page::export_name(&path, "xml");
|
||||
if named != path {
|
||||
path = named;
|
||||
// The dialog only confirmed the name it was given, not this one.
|
||||
if std::path::Path::new(&path).exists() {
|
||||
// Callers drop the result, so say it where the person sees it.
|
||||
return Err(self.fail_export(format!("{path} already exists; choose another name")));
|
||||
}
|
||||
}
|
||||
// Word XML even over a Word 2003 XML file, which a save by path would keep.
|
||||
let format = if ext == "xml" { wordcraft_engine::cmd::file::FORMAT_FLAT_OPC } else { crate::print_page::EXPORT_WORD_2003 };
|
||||
self.run("file.saveAs", json!({"path": path, "format": format}))
|
||||
@@ -344,7 +444,7 @@ impl WordApp {
|
||||
}
|
||||
r
|
||||
}
|
||||
AfterPick::SaveAs { after, document } => {
|
||||
AfterPick::SaveAs { after, document, .. } => {
|
||||
// The document it was for may wait behind another one: it is shown and saved.
|
||||
if document != self.session.document_id() {
|
||||
if !self.session.is_open(document) {
|
||||
@@ -431,7 +531,8 @@ impl WordApp {
|
||||
/// Ask where to save, save there, then do `after`.
|
||||
pub(crate) fn save_as(&mut self, after: AfterSave) -> Asked {
|
||||
let name = self.default_save_name();
|
||||
self.ask_file(FileDialogRequest::Save { name, dir: None }, AfterPick::SaveAs { after, document: self.session.document_id() })
|
||||
let after = AfterPick::save_as(after, self.session.document_id(), &name);
|
||||
self.ask_file(FileDialogRequest::Save { name, dir: None }, after)
|
||||
}
|
||||
|
||||
/// The user templates folder (#2852): the one File › Options names, else the app's own.
|
||||
@@ -467,7 +568,7 @@ impl WordApp {
|
||||
}
|
||||
let dir = dir.filter(|d| d.is_dir()).map(|d| d.to_string_lossy().into_owned());
|
||||
let name = format!("{}.dotx", self.title_stem());
|
||||
let after = AfterPick::SaveAs { after: AfterSave::Nothing, document: self.session.document_id() };
|
||||
let after = AfterPick::save_as(AfterSave::Nothing, self.session.document_id(), &name);
|
||||
let _ = self.ask_file(FileDialogRequest::Save { name, dir: dir.clone() }, after);
|
||||
dir
|
||||
}
|
||||
|
||||
@@ -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() {
|
||||
@@ -762,3 +826,118 @@ fn many_failed_fonts_end_with_a_count() {
|
||||
let msg = a.status_msg.as_ref().map(|(m, _)| m.clone()).unwrap_or_default();
|
||||
assert_eq!(msg, "Added 0 fonts; 5 couldn't be read: f0.ttf, f1.ttf, f2.ttf and 2 more");
|
||||
}
|
||||
|
||||
/// #5368: a name typed without an extension WordCraft saves is saved in the suggested format, as
|
||||
/// Word adds .docx, instead of failing (the format is chosen by extension); a template keeps
|
||||
/// .dotx and an export its own format.
|
||||
#[test]
|
||||
fn save_as_adds_the_format_to_a_name_without_one() {
|
||||
let dir = scratch("save-as-ext");
|
||||
let (mut a, shown) = async_app();
|
||||
typed(&mut a);
|
||||
for (name, saved) in [("Report", "Report.docx"), ("Report v1.2", "Report v1.2.docx"), ("Notes.", "Notes.docx"), ("Kept.DOCX", "Kept.DOCX")] {
|
||||
a.save_as_dialog();
|
||||
answer(&shown, Some(&dir.join(name).to_string_lossy()));
|
||||
assert_eq!(a.poll_file_dialog().unwrap().unwrap()["saved"], true, "{name}");
|
||||
let path = dir.join(saved);
|
||||
assert_eq!(a.session.path.as_deref(), Some(path.as_path()), "{name}");
|
||||
assert_eq!(saved_text(&path), UNSAVED, "{name}");
|
||||
}
|
||||
|
||||
a.services.templates_dir = Some(dir.join("Templates"));
|
||||
a.run("ui.saveAsTemplate", json!({})).unwrap();
|
||||
answer(&shown, Some(&dir.join("Templates").join("Memo").to_string_lossy()));
|
||||
assert_eq!(a.poll_file_dialog().unwrap().unwrap()["saved"], true);
|
||||
assert!(dir.join("Templates").join("Memo.dotx").is_file(), "a template stays a template");
|
||||
|
||||
a.export_dialog("pdf");
|
||||
answer(&shown, Some(&dir.join("Handout").to_string_lossy()));
|
||||
assert!(a.poll_file_dialog().unwrap().is_ok());
|
||||
assert!(std::fs::read(dir.join("Handout.pdf")).unwrap().starts_with(b"%PDF"), "an export keeps its format");
|
||||
// A name with another document format's extension is still a PDF, named as the built-in
|
||||
// browser names it (`print_page::export_name`).
|
||||
a.export_dialog("pdf");
|
||||
answer(&shown, Some(&dir.join("Flyer.docx").to_string_lossy()));
|
||||
assert!(a.poll_file_dialog().unwrap().is_ok());
|
||||
assert!(std::fs::read(dir.join("Flyer.pdf")).unwrap().starts_with(b"%PDF"));
|
||||
assert!(!dir.join("Flyer.docx").exists(), "no Word file written for a PDF export");
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
}
|
||||
|
||||
/// #5368 (review): the system dialog asks only about the name it returns. When the save adds an
|
||||
/// extension to it and a file of that name exists, the built-in browser asks before replacing
|
||||
/// it: Cancel leaves the file alone, OK replaces it. A new name is written straight away.
|
||||
#[test]
|
||||
fn a_name_the_save_extends_asks_before_replacing_its_file() {
|
||||
use crate::file_browser::Step;
|
||||
let dir = scratch("save-as-ext-replace");
|
||||
let (mut a, shown) = async_app();
|
||||
typed(&mut a);
|
||||
let target = dir.join("Handout.pdf");
|
||||
std::fs::write(&target, b"old").unwrap();
|
||||
let export = |a: &mut WordApp| {
|
||||
a.export_dialog("pdf");
|
||||
answer(&shown, Some(&dir.join("Handout.docx").to_string_lossy()));
|
||||
a.poll_file_dialog()
|
||||
};
|
||||
assert!(export(&mut a).is_none(), "nothing written yet: the question is open");
|
||||
assert_eq!(std::fs::read(&target).unwrap(), b"old");
|
||||
assert!(a.file_browser.open.is_some(), "the built-in browser asks");
|
||||
a.close_file_browser(None);
|
||||
assert_eq!(std::fs::read(&target).unwrap(), b"old", "Cancel keeps the file");
|
||||
assert!(export(&mut a).is_none());
|
||||
let step = a.file_browser.open.as_mut().map(|b| b.accept());
|
||||
assert_eq!(step, Some(Step::Pick(target.clone())), "OK on the name asked about replaces it");
|
||||
a.close_file_browser(Some(target.clone()));
|
||||
assert!(std::fs::read(&target).unwrap().starts_with(b"%PDF"), "replaced by the export");
|
||||
// A name whose extended form doesn't exist yet: no question.
|
||||
a.export_dialog("pdf");
|
||||
answer(&shown, Some(&dir.join("Fresh.docx").to_string_lossy()));
|
||||
assert!(a.poll_file_dialog().is_some_and(|r| r.is_ok()));
|
||||
assert!(std::fs::read(dir.join("Fresh.pdf")).unwrap().starts_with(b"%PDF"));
|
||||
assert!(a.file_browser.open.is_none());
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
}
|
||||
|
||||
/// #1399: the Save dialog's type list has one named entry per format, the suggested one first,
|
||||
/// every savable extension exactly once.
|
||||
#[test]
|
||||
fn save_dialog_lists_one_named_type_per_format() {
|
||||
let filters = save_filters("report.odt");
|
||||
assert_eq!(filters.len(), wordcraft_engine::io::SAVE_EXTS.len());
|
||||
assert_eq!(filters[0].1, vec!["odt".to_string()]);
|
||||
assert!(filters[0].0.contains("OpenDocument"), "{}", filters[0].0);
|
||||
let all: Vec<&String> = filters.iter().flat_map(|(_, e)| e).collect();
|
||||
for e in wordcraft_engine::io::SAVE_EXTS {
|
||||
assert_eq!(all.iter().filter(|x| x.as_str() == *e).count(), 1, "{e}");
|
||||
}
|
||||
assert!(filters.iter().all(|(l, e)| !l.trim().is_empty() && e.len() == 1));
|
||||
let mut labels: Vec<&String> = filters.iter().map(|(l, _)| l).collect();
|
||||
labels.sort();
|
||||
labels.dedup();
|
||||
assert_eq!(labels.len(), filters.len(), "labels are distinct");
|
||||
// Unknown names fall back to Word's format first.
|
||||
assert_eq!(save_filters("no extension")[0].1, vec!["docx".to_string()]);
|
||||
// The OpenDocument template and flat file have their own names.
|
||||
assert!(save_filters("plan.fodt")[0].0.starts_with("Flat OpenDocument Text"));
|
||||
assert!(save_filters("form.ott")[0].0.starts_with("OpenDocument Text Template"));
|
||||
}
|
||||
|
||||
/// #689: the Save dialog's default extension is the suggested name's own format, so a file
|
||||
/// name the user types without one is saved in the document's format instead of coming back
|
||||
/// bare and failing.
|
||||
#[test]
|
||||
fn save_dialog_defaults_to_the_suggested_format() {
|
||||
assert_eq!(save_exts("novel.docx")[0], "docx");
|
||||
assert_eq!(save_exts("report.odt")[0], "odt");
|
||||
assert_eq!(save_exts("annual report.pdf")[0], "pdf");
|
||||
assert_eq!(save_exts("notes.md")[0], "md");
|
||||
assert_eq!(save_exts("notes.markdown")[0], "md");
|
||||
// A suggested name always has an extension; anything unreadable falls back to Word's.
|
||||
assert_eq!(save_exts("no extension")[0], "docx");
|
||||
assert_eq!(save_exts("mystery.rtf2")[0], "docx");
|
||||
// Every savable format is still offered, once.
|
||||
let exts = save_exts("novel.docx");
|
||||
assert!(wordcraft_engine::io::SAVE_EXTS.iter().all(|e| exts.iter().any(|x| x == e)));
|
||||
assert_eq!(exts.len(), wordcraft_engine::io::SAVE_EXTS.len());
|
||||
}
|
||||
|
||||
@@ -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() {
|
||||
|
||||
@@ -105,7 +105,7 @@ pub use dialogs::dialogs_ribbon;
|
||||
pub use dialogs::dialogs_smart_art;
|
||||
pub use dialogs::dialogs_table_style;
|
||||
pub use dialogs::dialogs_templates;
|
||||
pub use file_dialogs::{FileDialogAnswer, FileDialogRequest, open_filters};
|
||||
pub use file_dialogs::{FileDialogAnswer, FileDialogRequest, open_filters, save_filters};
|
||||
|
||||
mod app;
|
||||
mod clock;
|
||||
|
||||
@@ -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 |
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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) |
|
||||
|
||||
|
||||
+4
-2
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
+2
-5
@@ -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
@@ -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
@@ -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.
|
||||
|
||||
|
||||
@@ -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
@@ -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
|
||||
|
||||
+5
-2
File diff suppressed because one or more lines are too long
+8
-5
@@ -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
@@ -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]
|
||||
|
||||
@@ -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
@@ -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
|
||||
|
||||
Reference in New Issue
Block a user