Compare commits

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

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

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

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

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

A boundary search left one body line on the final page, so counting the
line-number decorations too would still have stayed under the 12-line limit and
the test could not catch it. Use 33 lines, 8 on the final page in Inter, and
assert the body-only count is between 7 and 12.
2026-11-16 21:51:07 +01:00
Mex 78dfa8f648 M14: label Alt Text pane inputs for assistive technology (#6726) 2026-11-16 21:48:11 +01:00
Mex 82f0c467be M14: describe encrypted OpenDocument command support (#6776) 2026-11-16 21:32:11 +01:00
Mex 837a610133 M14: explain hyperlink URL input limits (#6789) 2026-11-16 21:20:15 +01:00
FredApps de977bcde6 Merge pull request #6658 from dotCooCoo/fix/issue-6636
Metafiles: draw EMF+ bitmaps, pattern fills, clips and pen styles from craft-metafile (#6636)
2026-11-16 17:28:06 +01:00
FredApps 4ba0595760 Merge pull request #6863 from storytold/refactor/shared-tiff-compression
geom: delegate TIFF compression inspection to craft-tiff
2026-11-16 16:48:47 +01:00
FredApps 6854bd1fb3 Merge remote-tracking branch 'origin/main' into pr6863 2026-11-16 16:05:20 +01:00
FredApps 4356771236 geom: pin craft-tiff to craft-libs main at the merge of #1867 (6ef2c053) 2026-11-16 16:05:20 +01:00
Dylan M. Taylor cdf146cabd Merge pull request #6759 from RickiNano/fix/6757-unequal-formats-linear
Layout: a paragraph over many pages lays out in linear time (#6757)
2026-11-16 07:38:06 -05:00
Martin BallandClaude Opus 5.5 54e3e1cf34 CI: fix red SonarCloud on main (#6859)
The coverage shards failed six tests on every main push:
- three UI glyph tests: the Sonar job had no craft-fonts. Pass the same
  fonts-ref as ci.yml.
- three layout linear-time tests: llvm-cov instrumentation pushes the
  8x time ratio past 24 (24.2-31.2). Ignore them under cfg(coverage),
  which cargo llvm-cov sets; the gate CI still runs them.


Claude-Session: https://claude.ai/code/session_01FypgCXtSjB6e5jmy9Uq7u8

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 12:06:41 +00:00
Dylan M. Taylor 97c13a2990 geom: delegate TIFF compression inspection to craft-tiff 2026-11-16 06:44:41 -05:00
Martin BallandClaude Opus 5.5 fe8a8a838c Header pictures: while editing the header, a click selects its Behind Text picture wherever no header text covers it (#5601)
* Header pictures: while editing the header, a click selects its Behind Text picture wherever no header text covers it

Header and footer Behind Text pictures skip the deferred drag-over-text path
where the plain hit test picked them with no text under them, and a right-click
selects them (and sets the page they were hit on) so Reset Picture and Wrap
Text act on them. Tests cover a header and a footer, a drag, and a repeated
picture right-clicked on another page.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* #5601: header Behind Text picture: a left-click selects the copy clicked on a repeated page

The press branch of pointer() selected the picture but left page_hint on the page being edited, so on a header picture repeated on page 2 the frame and handles were resolved and drawn on page 1. Set page_hint to the picked object's page, as select_at does for a right-click. Adds a left-click counterpart to the right-click test.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* #5601: header text hit test checks each line's own extent

CodeRabbit: hf_text_at took the whole paragraph's right edge from its last line, so
a click on a long first line past a short last line's end counted as clear of text
and selected the Behind Text picture under it. Each line now has its own band and
extent.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* #5601: pin that centred and right-aligned header lines cover their whole band

Line::left/right are the edges available to a line, not where its ink sits,
so a centred or right-aligned header line already covers the Behind Text
picture across its band (indent and floats narrow it) plus 40pt. Test pins
that, and the parity row now says what counts as covering the picture.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

* #5601: pin Line.left/right as band edges in the header band test

Assert the band's left edge is the 150pt indent, the centred/right ink
starts well inside it, and a click between the indent and the ink is
text. Fails if Line.left were the ink extent.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 10:08:59 +00:00
2bd6f372c5 File › Print: reopened, the page doesn't repeat the last job's message (#5597)
* File › Print: opened again, the page doesn't repeat the last job's message

"Print job submitted…" (or a failure) stayed on the Print page the next
time it was opened. The job's outcome is said once in the status bar, so a
fresh open drops it; a failure arriving while the page is open stays, and
printer status (finding printers, none found) still shows.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FypgCYPZSei56X4AGFPSu5

* Print page: the last job's marker is kept per window, since egui counts passes per viewport

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FypgCYPZSei56X4AGFPSu5

* #5597: decide the Print page's hidden job message per window

The shared printing.message is no longer cleared on reopening Print (ui.printSettings
and other windows still report it). Each window remembers what it said (status bar or
Print page) and hides only that; a result that arrived under File's other pages is
not counted as said. Tests: failure-on-open-page now depends on reopen detection,
never-said and two-window state.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

* #5597: follow the job message by generation, not by text

A retry that fails again with the same words is a new result and shows. A generation
(WordApp::print_gen) is bumped when a job starts and when the message changes; each
window's Print memo stores generations, so cross-window comparison is by identity too.
Also: update the print_memo doc comment, drop an empty branch, align the docs row date.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FypgCXtSjB6e5jmy9Uq7u8

---------

Co-authored-by: Martin Ball <martin.ball@ucsmedical.co.uk>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 10:07:57 +00:00
8a1f101c46 Save As and Export: Browse in WordCraft when the system dialog doesn't appear (#3535) (#3801) (#5790)
* Save As and Export: Browse in WordCraft when the system dialog doesn't appear (#3535) (#3801)

Ported from #3801 by VoiceLessQ onto current main.

Re-resolved against main:
- file_browser.rs tests: rebuilt whole, keeping main's #3859 tests (browser
  above the dialog, Escape, dialog closing into the browser, modeless
  keyboard, no keytips) and the PR's #3535 export tests.
- print_page.rs: EXPORT_FORMATS now carries main's OpenDocument Text
  Template (*.ott) and Flat OpenDocument Text (*.fodt) in main's order;
  main's tests module kept.
- docs/control-protocol.md: ui.fileBrowser purpose "export" added to main's
  current row (keeps ui.displayServer).
- docs/ui-parity.md: File dialogs row merged with main's Linux display
  server row, #3955 history row kept, status line and revision history
  bumped.

Added a test that the ott and fodt export types get their extension and
write the file.

Co-Authored-By: VoiceLessQ <44067308+VoiceLessQ@users.noreply.github.com>
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FypgCVCCEo7u5wetHaJRU4

* #3535: Word XML export from the system dialog adds .xml to a typed name

CodeRabbit: the system Save dialog accepts any name, and the engine takes the
explicit Flat OPC format only for an .xml path, so `letter` failed to export. The
extension is added as the built-in browser does; an existing file at the new name
is refused, since the dialog never confirmed replacing it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* #3535: an existing file at the .xml name is refused on the status bar

CodeRabbit: export_dialog drops ask_file's result, so the refusal was silent with a
blocking Save dialog. finish_pick now puts it on the status bar as well.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* #3535: Export refusals show on the Export page; a typed document extension gives way to the chosen type's

A refused or failed export is said on the Export page (Backstage hides the status bar), as Save As does. A known document extension on the typed name is replaced by the chosen Export type's, and any other is kept with the extension added.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

* #3535: Print page shows export errors; cancel clears them; export_name edge cases

The export error is drawn inside export_formats, so the Print page shows it as well as the Export page. Cancelling an export drops an earlier error. export_name treats a name that is only a known extension (.txt) as that extension and drops a trailing dot before adding the type's.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FypgCXtSjB6e5jmy9Uq7u8

* #3535: Export error is per window; a dotfile export name gets a real extension

The export error moves from a shared Context-data id into per-window state (swapped with the window like missing_fonts), so one window's frame outside Backstage no longer erases another's message. export_name treats a dotfile name such as .docx as a stem, so the engine's explicit-format guard (Path::extension) accepts the result; Word 2003 XML exports are named the same way.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FypgCXtSjB6e5jmy9Uq7u8

---------

Co-authored-by: Martin Ball <martin.ball@ucsmedical.co.uk>
Co-authored-by: VoiceLessQ <44067308+VoiceLessQ@users.noreply.github.com>
Co-authored-by: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-16 10:06:53 +00:00
42f8559b97 Review › Language: set the whole document's proofing language (#3518) (#5810)
* #3518: Review › Language can set the whole document's proofing language

review.language takes scope "selection" (default, unchanged) or "document":
every run and paragraph mark of every story (body, headers, footers, notes,
comments, text boxes, table cells, glossary) takes lang/noProof in one undo
step, selection unchanged, pending typing format follows. The Language dialog
gets an "Apply to the whole document" check box.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FypgCVCCEo7u5wetHaJRU4

* #3518: whole-document OK sends only what was changed in the Language dialog

With "Apply to the whole document" ticked, OK sends noProof only if the user
changed it from the dialog's opening value, and lang if changed or if neither
changed (never the engine's en-US default). Heading reads "Mark the whole
document as:" while ticked. Glossary walker uses doc's PARA_WALK_DEPTH (now pub).

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FypgCVCCEo7u5wetHaJRU4

* #3518: whole-document OK with Do not check ticked marks the whole document

CodeRabbit: with the caret's text already not checked, the box was unchanged, so a
whole-document OK never sent noProof and the rest of the document stayed checked.
A ticked box is now always sent; an unticked, unchanged one is still omitted.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* #3518: refuse whole-document language changes under protection

Protection leaves only its exceptions editable, so document scope is refused before anything changes. The post-check now compares the glossary, which no story-level check reached.

* #3518: whole-document language keeps per-run proofing, returns selection, skips glossary while tracking

- Language dialog: whole-document OK sends noProof only when the box was changed, so a language-only change no longer marks everything no-proof.
- review.language scope "document" returns the caret/selection result (plus scope).
- Whole-document change skips glossary blocks while Track Changes and Track Formatting are on (tracked formatting does not cover them).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* #3518: whole-document Do not check is sent when the box is clicked; report skipped glossary

- Language dialog: a whole-document OK sends noProof iff the Do-not-check box was clicked (proof_touched), so ticking it with the caret in a no-proof run still marks the whole document, while a language-only change leaves other runs alone.
- review.language document scope reports "glossarySkipped": true when the glossary was skipped under Track Changes + Track Formatting; doc comment reworded to state only the limitation.
- Docs status line and revision row bumped to 2026-11-16.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Martin Ball <martin.ball@ucsmedical.co.uk>
Co-authored-by: Claude Sonnet 5.5 <noreply@anthropic.com>
Co-authored-by: Dylan M. Taylor <dylan@dylanmtaylor.com>
2026-11-16 10:05:15 +00:00
Martin BallandClaude Sonnet 5.5 bf8b37759c Ctrl/Cmd+Shift+V pastes text only when no formatting was copied, as in Word (#1537) (#5616)
* #1537: Ctrl/Cmd+Shift+V pastes text only when no formatting was copied, as in Word for Windows

With formatting picked up by Ctrl/Cmd+Shift+C it still pastes the formatting.
Closes #1537, #4943; takes over #1562.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* #1537: review — a browser's Mod+Shift+V paste event pastes text only, once (CodeRabbit)

On the web the key no longer pastes as well: the paste event that follows carries the text.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* #1537: review — copied formatting stays for every Mod+Shift+V; a browser's paste after it is ignored (wanikhawar)

Copy Formatting keeps its formatting apart from the one-shot Format Painter brush, so a second
Mod+Shift+V pastes formatting again instead of text, and Mod+Shift+C no longer arms the brush.
After Mod+Shift+V pastes formatting, the browser's paste event for the same keystroke is ignored;
paste events read the modifiers held in event order. Only Mod+Shift+V itself falls back to Keep
Text Only.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FypgCYPZSei56X4AGFPSu5

* #1537: review — one format buffer, formatting-only copy, browser paste suppression only where it exists

- ignore_next_paste armed only for Mod+Shift+V on platforms that send a paste event after it (web); never for a rebound key
- the ignored paste is dropped before equation and picture-file handling
- Event::Paste takes paste_mods so they don't leak into later pastes
- Copy Formatting and Format Painter replace each other; a used-up brush no longer hands over to older copied formatting
- copied formatting carries no hyperlink or revision marks

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* #1537: review — shared format buffer, no tracked paragraph changes, pointer press ends the paste wait

- picked_format strips ParaProps fmt_change/num_change
- Format Painter pick is stored in copied_format too; a used-up or cancelled brush leaves it
- a pointer press clears ignore_next_paste
- docs: repeat-until-replaced wording

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* #1537: review — a caret Paste Formatting keeps the target's own link and tracked marks

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* #1537: review — an unrelated key's modifiers can't steer a later paste event

A separate paste_event_mods is set by Mod changes and Mod+V's press, and cleared by any other key, a pointer press or focus change; the release path keeps paste_mods.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* #1537: review — the text-only paste test checks the destination's own formatting stays (CodeRabbit)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* #1537: review — the docs say a Format Painter pick counts as picked-up formatting too (CodeRabbit)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* #1537: review — a dropped paste uses up its modifiers; range Paste Formatting keeps the link (alehel)

- The browser paste event dropped after a formatting paste now clears paste_event_mods too, so a
  later menu-bar paste isn't read as Keep Text Only. Note the no-text clipboard case.
- Test that Paste Formatting over a selection keeps the target's hyperlink.
- session.rs: copied_format holds a Format Painter pick too.
- ROADMAP: entry moved up with the other 2026-11-04 entries; stray blank line dropped.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* #1537: review — the wait for Mod+Shift+V's browser paste ends after a second, so a later menu-bar paste isn't dropped (FredApps)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FypgCX8G9hbs6XYZFsgjbL

* #1537: review — an expired paste wait drops the chord's noted Mod+Shift too (CodeRabbit)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FypgCX8G9hbs6XYZFsgjbL

* #1537: review — dropping the paired paste uses up its modifiers; range Paste Formatting keeps the target's link

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* #1537: review — restore ui-parity status line; add Paste Formatting row to typing-parity

docs/ui-parity.md: the rebase had replaced main's status line with an older one;
restore it and prepend this PR's entry. docs/typing-parity.md: add the
Ctrl/Cmd+Shift+V row to the Paste section, bump status line and history.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* #1537: Ctrl/Cmd+Shift+V's V release never pastes a second time

On desktop the chord's key-down path pastes (text, or the copied formatting) but didn't mark the
paste as done, so releasing Shift before V left a plain Mod+V release that ran Paste again through
the clipboard-picture hook, inserting the text twice. The canvas's chord now marks the paste done;
the global-shortcut path (canvas unfocused, no release seen) doesn't, and a focus change clears
the mark so a lost release can't swallow a later Mod+V picture.
Docs: web text paste needs the browser to send its paired Paste event; with formatting copied that
event is dropped only within about a second of the key.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 09:59:47 +00:00
FredApps 1ed889c24c Merge pull request #6448 from batistalucasv/fix/control-server-reset-closed
Tests: a reset control connection counts as closed (Windows Print flake)
2026-11-16 10:23:29 +01:00
FredApps 6a7af0d679 Merge pull request #6731 from batistalucasv/fix/6722-font-combo-select-without-dropdown
UI: select font box text on click without opening dropdown (#6722)
2026-11-16 10:21:19 +01:00
ce6e4094d5 Dialogs: group settings in soft panels of dialogs to improve readability (#4038)
* Dialog sections: heading, space above, soft panel (#4035)

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

* Dialog sections: heading inside the panel, settings indented (#4035)

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

* Dialog sections: more dialogs, anonymous and nested panels, scroll on short screens (#4035)

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

* Format dialog accessibility updates

* Format reference dialog controls

* Replace deprecated egui IDs in dialogs

* Preserve stable IDs for dialog state

* Document dialog section parity update

* import layout test fixtures

* format merged code after fix

* Fix unused imports after dialog port

---------

Co-authored-by: Claude Sonnet 5.5 <noreply@anthropic.com>
Co-authored-by: Fluorine <joseph.anglada92@gmail.com>
2026-11-16 10:02:24 +01:00
FredApps 9088ed777d Merge pull request #6818 from storytold/extract/shared-engine-base64
Reuse shared Base64 encoding for engine payloads
2026-11-16 06:42:28 +01:00
Dylan M. Taylor cc90520b9d Merge pull request #5073 from AxylumRust/refactor/geom-clippy-pedantic
geom: satisfy Clippy pedantic lints (M14)
2026-11-15 16:49:58 -05:00
Dylan M. Taylor a95b065c2b M14: integrate current shared picture codecs and clarify refusals 2026-11-15 16:30:18 -05:00
FredApps 84026f98b2 Merge pull request #6817 from MMexicann/patch-45
M14: preserve existing PDF suffixes in web exports
2026-11-15 22:04:18 +01:00
Mex 5f228a0e24 M14: cover Unicode and misleading PDF filename suffixes
Added additional test cases for PDF file name handling in file dialogs.
2026-11-15 20:54:24 +01:00
Mex b354e0f870 M14: bound PDF suffix checks to four bytes 2026-11-15 20:53:49 +01:00
Dylan M. Taylor 86352d5cf3 Reuse shared Base64 encoding for engine payloads 2026-11-15 14:34:21 -05:00
Mex 3e776e4c7d M14: cover PDF suffix case in web downloads
Assert exact delivered filenames and PDF bytes for lowercase, uppercase, mixed-case Unicode and missing suffixes.
2026-11-15 20:27:16 +01:00
Mex a9a1aa36a2 M14: preserve existing PDF suffixes in web exports
Recognize an existing PDF extension without changing its case or the requested filename.
2026-11-15 20:26:14 +01:00
Valentin Klein bc0e51ee4d Interface size: Auto is capped to what fits the screen, Ctrl+Shift+0 returns to Auto (#4030) (#5203)
Fixes #4030

On a small screen (an 11-inch 1366x768 panel) the system can report a very large display scale. The Auto interface size followed it blindly, so the window and ribbon came out far bigger than the screen and File > Options, where the size is set, could not be reached.

What this changes:
- Auto interface size is now capped so a window of at least 900x460 points still fits the screen (about 152% on 1366x768). Scales that already fit (for example 1920x1080 at 100-150%, or 1366x768 at up to 150%) are unchanged. If the screen size is unknown there is no cap.
- A size chosen in File > Options is still taken as is. If a large size pushes the options out of reach, Ctrl+Shift+0 (Cmd+Shift+0 on Mac) returns to Auto from anywhere. Ctrl+Alt+0 is not used because it is AltGr+0 on some layouts and would type a character.
- `ui.interfaceSize` and the "Auto (n%)" label in Options report the capped value. The cap is never saved to `ui.json`.
- Tests: the cap for several screen sizes, the shortcut, AltGr+0 still typing, and the reported percent. Docs: ui-parity, control-protocol, ROADMAP progress log.

Not covered:
- The root cause of the oversized scale (X11 DPI detection) is handled by #721 and #3240. This change is separate and works with or without them.
- A manually chosen large size can still push controls off screen, but there is now a way back.
- Not tested on a real 1366x768 screen.

`cargo xtask ci` passed locally on the pushed code; GitHub CI has not run yet.

<!-- This is an auto-generated comment: release notes by coderabbit.ai -->

## Summary by CodeRabbit

* **New Features**
  * Auto interface sizing now scales down on smaller displays to keep a window of at least 900×460 points within the screen. Sizes selected in Options remain uncapped, and the minimum Auto scale is 100%.
  * Press Ctrl+Shift+0 (⌘⇧0 on Mac) to restore Auto sizing. When Auto sizing is capped, the displayed zoom percentage reflects the screen-fit limit; the cap does not change the saved size.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
2026-11-15 12:12:27 +01:00
batistalucasv ed66198574 .gitattributes: normalise text on add so CRLF cannot be committed again (#6543)
`cargo fmt --check` passes on CRLF (verified: exit 0, empty output), so the gate cannot see a commit that rewrites line endings. `#6537` did exactly that: 50 files, 35,102 lines, all CRLF, while declaring a one-line test change.

## Change

Adds the normalisation the repository lacks — `.gitattributes` only pins `craft-i18n.rev` today:

```
# Text lives in the repository with LF. A Windows checkout once committed 50 files with CRLF
# (#6537) and `cargo fmt --check` still passed, so the gate could not see it. Normalise on add.
* text=auto

craft-i18n.rev text eol=lf
```

`craft-i18n.rev` stays last so the specific rule still wins.

## Dependency

The repair landed first: #6541 merged as `eae8363e`, and `git grep -lI $'\r'` on that head finds **0** text files. This branch merges that `main` in `01617884`, so the rule now applies to a tree that is already LF.

`text=auto` is not an absolute enforcement gate. It normalises text on add, and it does not rewrite a blob already stored with CRLF: plain `git add` on such a file leaves `git ls-files --eol` at `i/mixed`, and only `git add --renormalize` rewrites it to `i/lf`. That is why the repair had to land first, and why this is a guard for future commits, not a fix for the past.

## Why it is safe

- Every text file in `main` is already LF (`git grep -lI $'\r'` = 0).
- No `.bat`/`.cmd` or CRLF fixture exists; the `.ps1` files under `packaging/windows/` are already LF in the repository.
- `cargo fmt --check` clean and `cargo test -p wordcraft-engine --lib` 1460 passed, unchanged.

## Why two PRs

#6541 was the repair; this is the guard, and it is a repository policy change rather than part of the fix, so it is separate and optional. If a repo-wide rule is more than you want, the narrower form is one pattern per line:

```
*.rs text eol=lf
*.toml text eol=lf
*.md text eol=lf
*.properties text eol=lf
```

Thanks for the syntax correction: the single-line fallback I wrote earlier was not valid attribute syntax.

@FredApps — the dependency is settled and this branch is on the new `main`. Ready for approval when you have a moment.
2026-11-15 12:11:56 +01:00
RickiNanoandClaude Opus 5.5 d53a740be1 #6757: lay out a paragraph over many pages in linear time
Each page's piece of a paragraph walked every line of the paragraph in
place_objects to find the pictures and shapes to draw with it, skipping
all but its own lines and the late-float anchor lines. A paragraph over
many pages was quadratic in its lines. A later piece now walks only its
own lines and the late-float anchor lines, in the same order.

unequal_formats_lay_out_in_linear_time reads 8.0x for 8x the runs in a
debug build, down from 15.0x, so it no longer fails in the slower
SonarCloud coverage build.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-15 10:25:09 +01:00
Nine e9750c5cb7 Add Bosnian interface language (#4804)
Register Latin Bosnian as an interface language, with catalog-backed locale, plural and font regressions. Preserve the existing system-locale detector; POSIX script-modifier handling is outside this change.

Original contribution by @nine-codes.
2026-11-15 00:31:44 -06:00
3d5a153e3d Keep TOC entries for tab-numbered headings on one line (#6738)
Fixes #6486

Co-authored-by: cute-johnny <269855522+cute-johnny@users.noreply.github.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-15 02:23:52 +01:00
batistalucasv 7bff3b53e9 Test: assert egui popup state on font arrow toggle (#6722) 2026-11-14 18:35:40 -03:00
batistalucasv 0909b15eae UI: select font box text on click without opening dropdown (#6722) 2026-11-14 18:08:39 -03:00
Mex 52d17a91df M14: identify WordCraft correctly in the iframe title example (#6717)
Use word processor as the accessible iframe description instead of image editor.
2026-11-14 21:40:06 +01:00
dotCooCoo e6e8c61dbf Merge main into fix/issue-6636 2026-11-14 12:11:53 -08:00
dotCooCoo 1d150004f7 Tests: EMF+ only bitmaps are drawn over their EmfPlusDrawImage rectangle
The two EMF+ bitmap tests checked only that the bitmap is embedded. They now
also read the page through hayro's interpreter and check that the page draws
each bitmap over the right half of the picture, where its EmfPlusDrawImage
rectangle places it.
2026-11-14 11:40:21 -08:00
Cédric Legrand 0aefd4d025 fix(geom): M14: adapt picture error mapping 2026-11-14 18:00:04 +01:00
Cédric Legrand 235a38c665 style(geom): M14: remove review churn 2026-11-14 17:55:18 +01:00
Cédric Legrand 3bf7a5dbbe docs(geom): M14: qualify truncated TIFF errors 2026-11-14 17:55:18 +01:00
Cédric Legrand e40199bf6f docs(geom): M14: clarify truncated TIFF errors 2026-11-14 17:55:18 +01:00
Cédric Legrand e2f94ecef9 refactor(geom): clean up Clippy pedantic diagnostics (M14) 2026-11-14 17:55:18 +01:00
dotCooCoo 7ccfd4caef Tests: EMF+ only bitmaps in ARGB, RGB, PNG and JPEG are drawn
The page renderer and the PDF exporter each get a test that draws an
EmfPlusDrawImage bitmap in PixelFormat32bppARGB, 24bppRGB and 32bppRGB,
and a compressed PNG and JPEG bitmap, from an EMF+ only file.
2026-11-14 07:40:12 -08:00
dotCooCoo 7b3b6f8041 Merge main into fix/issue-6636 2026-11-14 07:32:49 -08:00
dotCooCoo fecb717f99 Metafiles: read WMF, EMF and EMF+ with craft-metafile (#6636)
crates/metafile is deleted. formats, layout, render and pdf take their
WMF, EMF and EMF+ reader from craft-metafile (craft-libs 9dcbd90c, the
rev craft-docx is already pinned at), so EMF+ records are read: an EMF+
only file's DrawImage of a 32bppPARGB bitmap draws its pixels.

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

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

Fixes #6636
2026-11-14 05:16:52 -08:00
batistalucasvandQwen-Coder bd188c19d8 Tests: only closure errors mean the control peer closed (#6448)
CodeRabbit pointed out that read_line returns InvalidData for bytes that are not UTF-8 while the socket stays open, and the helper treated every non-timeout error as a close. closed_by_peer() now accepts only ConnectionReset, ConnectionAborted, NotConnected and BrokenPipe, and the regression test pins InvalidData, TimedOut and WouldBlock as still open; the new assertion fails without the stricter match.

Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
2026-11-12 16:42:47 -03:00
batistalucasv 56a28f33b7 Merge remote-tracking branch 'upstream/main' into fix/control-server-reset-closed 2026-11-12 16:35:04 -03:00
batistalucasvandQwen-Coder cd4ab71552 Tests: a reset control connection counts as closed (Windows Print flake)
The Windows Print job on #6232 failed in a_silent_connection_is_closed: quiet.closed() only accepted end of stream, but Windows can deliver a close with nothing to read as a reset. The test binary finished in 0.81 s, so it was not the 5 s read timeout. closed_by_peer() now counts a reset, abort, not-connected or broken pipe as closed, and only a read timeout as still open; the new regression test fails before the fix with ConnectionReset. A loaded Windows runner can also take seconds to schedule the connection thread, so the silent test waits up to 20 s and still requires the close within 10 s (the production budget is 30 s).

Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
2026-11-12 16:13:42 -03:00
150 changed files with 8723 additions and 1222 deletions
+5 -1
View File
@@ -1 +1,5 @@
craft-i18n.rev text eol=lf
# Text lives in the repository with LF. A Windows checkout once committed 50 files with CRLF
# (#6537) and `cargo fmt --check` still passed, so the gate could not see it. Normalise on add.
* text=auto
craft-i18n.rev text eol=lf
+3
View File
@@ -18,4 +18,7 @@ jobs:
sonarcloud:
# Tracked at @main so org-wide CI improvements propagate without PR churn.
uses: storytold/craft-common-actions/.github/workflows/sonarcloud.yml@main
with:
# Same craft-fonts commit as ci.yml: the UI glyph tests need its CJK and Arabic fonts.
fonts-ref: b076417b5880bd4154bd22f00695b1d28c6bea83
secrets: inherit
+4
View File
@@ -138,3 +138,7 @@ Progress docs: `ROADMAP.md` (stage, headline numbers, progress log), `docs/targe
- Some workflow files here still run their own jobs. Don't add to them. Moving a job into craft-common-actions is its own task, never part of another PR, and the job stays here until a shared workflow runs it.
New workspace crates include `workspace = true` under `[lints]` in `Cargo.toml`. Production crate roots declare the crate-level lint attributes before modules; crate-level `//!` documentation may precede them.
## Shared-library reuse
Before implementing file formats, codecs, protocols or reusable UI components, check [storytold/craft-libs](https://github.com/storytold/craft-libs) and relevant open PRs; reuse or extend shared APIs instead of duplicating app-local implementations. Keep app-specific policy and adapters local, preserve behavior and format fidelity, security and resource limits, repository layering and regression tests, and document any shared-API gap rather than silently reducing functionality.
Generated
+12 -1
View File
@@ -1248,7 +1248,7 @@ source = "git+https://github.com/storytold/craft-libs?rev=41fb227542efb8a7748caa
dependencies = [
"brotli-decompressor 6.3.1",
"chrono",
"craft-tiff",
"craft-tiff 0.1.0 (git+https://github.com/storytold/craft-libs?rev=41fb227542efb8a7748caa1c659f271d8605303c)",
"quick-xml 0.41.0",
"serde",
]
@@ -1401,6 +1401,15 @@ dependencies = [
"thiserror 2.0.21",
]
[[package]]
name = "craft-tiff"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=6ef2c053dfa758a9e292ff6ce4398bcd84aab1a1#6ef2c053dfa758a9e292ff6ce4398bcd84aab1a1"
dependencies = [
"serde",
"thiserror 2.0.21",
]
[[package]]
name = "craft-ui"
version = "0.1.0"
@@ -7331,6 +7340,7 @@ dependencies = [
"chrono",
"craft-font-catalog",
"craft-font-store",
"craft-mime",
"craft-proof",
"craft-zip",
"encoding_rs",
@@ -7406,6 +7416,7 @@ name = "wordcraft-geom"
version = "0.18.1"
dependencies = [
"craft-image-codecs",
"craft-tiff 0.1.0 (git+https://github.com/storytold/craft-libs?rev=6ef2c053dfa758a9e292ff6ce4398bcd84aab1a1)",
"image",
"serde",
]
+3
View File
@@ -68,6 +68,7 @@ brotli-decompressor = "5"
vello_cpu = "0.2"
image = { version = "0.25", default-features = false }
craft-image-codecs = { git = "https://github.com/storytold/craft-libs", rev = "41fb227542efb8a7748caa1c659f271d8605303c", version = "=0.1.0" }
craft-tiff = { git = "https://github.com/storytold/craft-libs", rev = "6ef2c053dfa758a9e292ff6ce4398bcd84aab1a1", version = "=0.1.0" }
craft-pdf = { git = "https://github.com/storytold/craft-libs", rev = "6e03f65bf45181db77ba6229716e6624db9eb25b", version = "=0.1.0", default-features = false, features = ["write"] }
# craft-update: app-specific pretend versions apply to startup and manual checks.
craft-update = { git = "https://github.com/storytold/craft-libs", version = "=0.1.0", rev = "6e03f65bf45181db77ba6229716e6624db9eb25b", features = ["egui"] }
@@ -122,6 +123,8 @@ arboard = { version = "3.7", default-features = false, features = ["wayland-data
[workspace.lints.rust]
unsafe_code = "forbid"
# cargo llvm-cov sets `--cfg coverage`; timing tests skip themselves under its instrumentation.
unexpected_cfgs = { level = "warn", check-cfg = ["cfg(coverage)"] }
[workspace.lints.clippy]
cognitive_complexity = "deny"
+5 -3
View File
@@ -124,7 +124,7 @@ Every screenshot below is WordCraft itself, rendered offscreen by its own UI tes
| **References** | Table of contents, footnotes and endnotes, citations and bibliography (APA, MLA, Chicago, IEEE), captions, table of figures, cross-references, index, table of authorities |
| **Review** | Spelling and grammar with suggestions (English and Polish, by each run's language), thesaurus, word count, comments in margin balloons or a pane, track changes, accept/reject, compare documents, restrict editing, accessibility checker, document inspector |
| **Mailings** | Mail merge from CSV, merge fields, address block, greeting line, rules, preview, finish to a document; envelopes and labels |
| **View** | Print layout, web layout, draft, read mode, focus, zoom, one/multiple pages, page width, Navigation pane, rulers, gridlines, dark mode; interface in English, 简体中文, 繁體中文, 日本語, Português (Brasil), Español, Українська, Српски / Srpski, Eesti, Türkçe, Русский, Italiano, Deutsch, Polski, Čeština, Magyar, Français, Български, Tiếng Việt, 한국어, Svenska, Hrvatski, Nederlands, Dansk, Română, العربية (mirrored) or Slovenščina (follows the system language by default) |
| **View** | Print layout, web layout, draft, read mode, focus, zoom, one/multiple pages, page width, Navigation pane, rulers, gridlines, dark mode; interface in English, 简体中文, 繁體中文, 日本語, Português (Brasil), Español, Українська, Српски / Srpski, Eesti, Türkçe, Русский, Italiano, Deutsch, Polski, Čeština, Magyar, Français, Български, Tiếng Việt, 한국어, Svenska, Hrvatski, Nederlands, Dansk, Română, العربية (mirrored) Slovenščina or Bosanski (follows the system language by default) |
| **Files** | .docx read/write, legacy 97-2003 .doc import, PDF export, .odt, .rtf, .html, .md, .tex, .txt import/export, page images |
The honest picture, area by area, is in [ROADMAP.md](ROADMAP.md), the
@@ -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
+11 -3
View File
File diff suppressed because one or more lines are too long
+9 -3
View File
@@ -35,10 +35,11 @@ USAGE:
--strict writes nothing and exits 3 if a character on the
page can't be drawn or a picture is missing or undecodable
(report on stderr, as for convert --strict)
wordcraft-cli run [--file F | --template T] [--script FILE|-] --cmd 'id={json}' [--cmd …]
[--save OUT] [--print] [--author NAME]
wordcraft-cli run [--file F | --template T] [--script FILE|-] [--cmd 'id={json}' …]
[--save OUT] [--page N] [--scale S] [--print] [--author NAME]
run commands headlessly, then save (--author names
who tracked changes and comments are by).
PNG saves use --page (1-based, default 1) and --scale (default 2).
--script runs a JSON file (- is stdin) first:
{\"file\"?, \"template\"?, \"commands\": [{\"command\": id,
\"params\"?: {…}} | id, …], \"save\"?: [OUT, …]}; save
@@ -602,6 +603,11 @@ fn run<S: AsRef<OsStr>>(args: &[S]) -> Result<(), Failure> {
write_stdout(|o| writeln!(o, "{r}"))
}
"run" => {
for (i, arg) in rest.iter().enumerate() {
if arg == "--cmd" && rest.get(i + 1).is_none_or(|value| value.starts_with("--")) {
return Err("--cmd needs a value".into());
}
}
validate_options("run", &rest, RUN_OPTIONS)?;
let page = parse_page_arg("run", &rest)?;
let scale = parse_scale_arg("run", &rest)?;
@@ -635,7 +641,7 @@ fn run<S: AsRef<OsStr>>(args: &[S]) -> Result<(), Failure> {
let mut i = 0;
while i < rest.len() {
if rest.get(i).map(String::as_str) == Some("--cmd") {
let spec = rest.get(i + 1).ok_or("--cmd needs a value")?;
let spec = rest.get(i + 1).filter(|value| !value.starts_with("--")).ok_or("--cmd needs a value")?;
let (id, params) = match spec.split_once('=') {
Some((id, p)) => {
(id.to_string(), serde_json::from_str::<Value>(p).map_err(|e| engine_error(format!("{id}: bad JSON params: {e}")))?)
+21
View File
@@ -497,6 +497,27 @@ fn command_line_template_wins_over_the_scripts_file() {
assert!(std::fs::read_to_string(&b).unwrap().contains("FROM FILE"));
}
#[test]
fn cmd_value_missing_is_reported() {
let missing = std::env::temp_dir().join(format!(
"wc-cli-missing-cmd-{}-{}.docx",
std::process::id(),
std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_nanos()
));
assert!(!missing.exists());
let missing = missing.to_string_lossy();
for argv in [
vec!["run", "--cmd"],
vec!["run", "--cmd", "--save", "out.docx"],
vec!["run", "--cmd", "caret.docEnd", "--cmd", "--print"],
vec!["run", "--cmd", "--bogus"],
vec!["run", "--cmd", "--file", &missing],
] {
assert_eq!(run(&args(&argv)), Err("--cmd needs a value".into()), "{argv:?}");
}
assert!(run(&args(&["run", "--cmd", "caret.docEnd", "--cmd", "caret.docStart"])).is_ok());
}
#[test]
fn script_value_missing_is_reported() {
let e = run(&args(&["run", "--script", "--cmd", "caret.docEnd"])).unwrap_err().to_string();
+40 -4
View File
@@ -369,8 +369,11 @@ mod tests {
impl Conn {
fn open(port: u16) -> Self {
Self::open_within(port, Duration::from_secs(5))
}
fn open_within(port: u16, read_timeout: Duration) -> Self {
let s = TcpStream::connect(("127.0.0.1", port)).unwrap();
s.set_read_timeout(Some(Duration::from_secs(5))).unwrap();
s.set_read_timeout(Some(read_timeout)).unwrap();
Self(BufReader::new(s.try_clone().unwrap()), s)
}
fn send(&mut self, line: &str) {
@@ -388,7 +391,24 @@ mod tests {
/// The server closed the connection.
fn closed(&mut self) -> bool {
let mut r = String::new();
matches!(self.0.read_line(&mut r), Ok(0))
closed_by_peer(self.0.read_line(&mut r))
}
}
/// Whether a read means the peer closed the connection. End of stream does; so does a reset,
/// which is how Windows can deliver a close when the writer had nothing to read back (the
/// Windows Print job failed here). Any other error, such as `InvalidData` for bytes that are
/// not UTF-8, leaves the connection open.
fn closed_by_peer(read: std::io::Result<usize>) -> bool {
match read {
Ok(n) => n == 0,
Err(e) => matches!(
e.kind(),
std::io::ErrorKind::ConnectionReset
| std::io::ErrorKind::ConnectionAborted
| std::io::ErrorKind::NotConnected
| std::io::ErrorKind::BrokenPipe
),
}
}
@@ -473,13 +493,29 @@ mod tests {
assert!(rx.try_recv().is_err());
}
#[test]
fn only_closure_errors_mean_the_peer_closed() {
use std::io::{Error, ErrorKind};
assert!(closed_by_peer(Ok(0)), "end of stream");
for kind in [ErrorKind::ConnectionReset, ErrorKind::ConnectionAborted, ErrorKind::NotConnected, ErrorKind::BrokenPipe] {
assert!(closed_by_peer(Err(Error::new(kind, "closed"))), "{kind:?}");
}
assert!(!closed_by_peer(Ok(1)), "a reply arrived");
// Not UTF-8, a timeout or a would-block leave the socket open.
for kind in [ErrorKind::InvalidData, ErrorKind::TimedOut, ErrorKind::WouldBlock] {
assert!(!closed_by_peer(Err(Error::new(kind, "still open"))), "{kind:?}");
}
}
#[test]
fn a_silent_connection_is_closed() {
let (port, rx) = boot_with(Duration::from_millis(300));
let mut quiet = Conn::open(port);
// A loaded Windows CI runner can take seconds to schedule the connection thread. The
// production deadline is 30 s, so 10 s still proves the server's own budget fired.
let mut quiet = Conn::open_within(port, Duration::from_secs(20));
let t0 = Instant::now();
assert!(quiet.closed());
assert!(t0.elapsed() < Duration::from_secs(3));
assert!(t0.elapsed() < Duration::from_secs(10), "{:?}", t0.elapsed());
// After an authorised request the connection may stay idle.
let mut busy = Conn::open(port);
assert_eq!(busy.call(&format!(r#"{{"id":1,"method":"auth","key":"{KEY}"}}"#))["ok"], true);
+164 -16
View File
@@ -23,6 +23,7 @@ mod graphics;
mod logging;
#[cfg(all(unix, not(target_os = "macos")))]
mod portal_save;
mod prefs_merge;
mod print;
mod region;
#[cfg(target_os = "macos")]
@@ -222,31 +223,44 @@ fn user_dict_path() -> Option<std::path::PathBuf> {
wordcraft_control_key::settings_dir().map(|b| b.join(wordcraft_engine::Session::USER_DICT_FILE))
}
fn load_user_dictionary(app: &mut WordApp) {
if !prefs_enabled() {
return;
}
if let Some(p) = user_dict_path() {
wordcraft_proof::load_user_dictionary(&p);
app.session.user_dict_path = Some(p);
}
}
/// Runs without preferences (`WORDCRAFT_NO_PREFS`, agents' test runs) neither read nor write them.
fn prefs_enabled() -> bool {
std::env::var_os("WORDCRAFT_NO_PREFS").is_none()
}
/// The preferences as this process last loaded or saved them, which `save_prefs` compares with
/// to write only what this process changed since (#3773, see `prefs_merge`).
static LOADED_PREFS: std::sync::Mutex<Option<serde_json::Value>> = std::sync::Mutex::new(None);
/// Apply the saved preferences (`ui.json`) and the user dictionary to `app`, and remember the
/// result for `save_prefs`. Runs without preferences neither read nor keep them.
fn load_prefs(app: &mut WordApp) {
if !prefs_enabled() {
return;
}
if let Some(p) = prefs_path()
&& let Ok(bytes) = std::fs::read(&p)
let loaded = load_prefs_from(app, prefs_path().as_deref(), user_dict_path());
if let Ok(mut slot) = LOADED_PREFS.lock() {
*slot = loaded;
}
}
/// Apply the preferences saved at `prefs` to `app`, then load the user dictionary at `dict`
/// (`custom-dictionary.txt`, #40), and give back the preferences as `prefs()` does after both:
/// the words only the dictionary file has are part of what was loaded, so a word another process
/// removes from `ui.json` isn't written back as one added here (#3773).
fn load_prefs_from(app: &mut WordApp, prefs: Option<&std::path::Path>, dict: Option<std::path::PathBuf>) -> Option<serde_json::Value> {
if let Some(p) = prefs
&& let Ok(bytes) = std::fs::read(p)
&& let Some(ui) = UiState::from_json(&bytes)
{
app.apply_prefs(ui);
}
if let Some(p) = dict {
wordcraft_proof::load_user_dictionary(&p);
app.session.user_dict_path = Some(p);
}
// As `prefs()` gives them back, so a setting nobody touched compares equal at exit.
serde_json::to_value(app.prefs()).ok()
}
/// Fonts the user added (#582) live in `fonts` in the settings folder: load them, and store fonts
@@ -332,6 +346,8 @@ fn x11_libraries() -> Result<(), String> {
if missing.is_empty() { Ok(()) } else { Err(missing.join("; ")) }
}
/// Write `app`'s preferences to `ui.json`, merged with what other processes saved since this one
/// loaded it (`merged_prefs`).
fn save_prefs(app: &WordApp) {
if let Err(e) = try_save_prefs(app) {
log::warn!("preferences: {e}");
@@ -348,11 +364,79 @@ fn try_save_prefs(app: &WordApp) -> Result<bool, String> {
if let Some(dir) = p.parent() {
std::fs::create_dir_all(dir).map_err(|e| format!("cannot create {}: {e}", dir.display()))?;
}
let bytes = serde_json::to_vec_pretty(&app.prefs()).map_err(|e| format!("cannot serialize: {e}"))?;
write_prefs(&p, &bytes).map_err(|e| format!("cannot save {}: {e}", p.display()))?;
let ours = serde_json::to_value(app.prefs()).map_err(|e| format!("cannot serialize: {e}"))?;
let mut base = LOADED_PREFS.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
save_merged(&p, &mut base, ours)?;
Ok(true)
}
/// Writes `ours` to `path`, merged with what other WordCraft processes saved there since this one
/// loaded or saved `base` (`merged_prefs`), and makes `ours` the new `base`: a setting changed here
/// before this save and by another process after it then takes the other's value at the next save.
/// Holds `lock_prefs` from the read to the rename.
fn save_merged(path: &std::path::Path, base: &mut Option<serde_json::Value>, ours: serde_json::Value) -> Result<(), String> {
let _lock = lock_prefs(path);
let merged = merged_prefs(path, base.as_ref(), ours.clone());
let bytes = serde_json::to_vec_pretty(&merged).map_err(|e| format!("cannot serialize: {e}"))?;
write_prefs(path, &bytes).map_err(|e| format!("cannot save {}: {e}", path.display()))?;
*base = Some(ours);
Ok(())
}
/// `ours` with what other WordCraft processes saved to `path` since this one loaded or saved
/// `base`, for the settings this one left alone (#3773, see `prefs_merge`). `ours` as it is when
/// there's no `base`, or the file is missing or isn't preferences now.
fn merged_prefs(path: &std::path::Path, base: Option<&serde_json::Value>, ours: serde_json::Value) -> serde_json::Value {
let Some(base) = base else { return ours };
let disk = match std::fs::read(path) {
Ok(bytes) => prefs_merge::as_read(&bytes),
Err(e) => {
if e.kind() != std::io::ErrorKind::NotFound {
log::debug!("preferences: cannot read {} to merge, saving this process's: {e}", path.display());
}
return ours;
}
};
match disk {
Some(disk) => prefs_merge::merge(base, ours, &disk),
None => {
log::debug!("preferences: {} isn't preferences, saving this process's", path.display());
ours
}
}
}
/// How long a save waits for another process's save to finish before going ahead anyway: a save
/// takes milliseconds, and a process stuck holding the lock mustn't stop this one from saving.
const PREFS_LOCK_WAIT: std::time::Duration = std::time::Duration::from_secs(2);
/// An advisory lock beside `path` (`.ui.json.lock`), held while it is returned, so that two
/// processes saving at once (logging out closes every window together) take turns at reading,
/// merging and replacing `ui.json` instead of one losing the other's changes. `None` (save
/// unlocked) when the lock file can't be opened or the lock isn't free within [`PREFS_LOCK_WAIT`].
fn lock_prefs(path: &std::path::Path) -> Option<std::fs::File> {
let name = path.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_else(|| "ui.json".into());
let lock = path.with_file_name(format!(".{name}.lock"));
let file = match std::fs::OpenOptions::new().create(true).truncate(false).write(true).open(&lock) {
Ok(f) => f,
Err(e) => {
log::debug!("preferences: cannot open {}, saving without it: {e}", lock.display());
return None;
}
};
let start = std::time::Instant::now();
loop {
match file.try_lock() {
Ok(()) => return Some(file),
Err(std::fs::TryLockError::WouldBlock) if start.elapsed() < PREFS_LOCK_WAIT => std::thread::sleep(std::time::Duration::from_millis(10)),
Err(e) => {
log::warn!("preferences: {} is held, saving without it: {e}", lock.display());
return None;
}
}
}
}
/// Writes `bytes` to a sibling temporary file and renames it over `path`, so a failed or
/// interrupted write leaves the previous preferences in place.
fn write_prefs(path: &std::path::Path, bytes: &[u8]) -> std::io::Result<()> {
@@ -626,7 +710,6 @@ fn main() -> eframe::Result {
if updates_unsafe {
app.disable_self_update();
}
load_user_dictionary(&mut app);
// Language packs from the suite's font store; an Install click is the person's own.
wordcraft_engine::packs::use_font_store(true);
// A region chosen in File › Options replaces the system's for the first blank
@@ -839,7 +922,72 @@ mod launch_arg_tests {
#[cfg(test)]
mod prefs_tests {
use super::write_prefs;
use serde_json::{Value, json};
use wordcraft_ui_egui::{UiState, theme::Appearance};
use super::{load_prefs_from, lock_prefs, prefs_merge, save_merged, write_prefs};
/// The preferences saved with `theme` (every other setting at its default).
fn with_theme(theme: &str) -> Value {
prefs_merge::as_read(&serde_json::to_vec(&json!({"theme": theme})).unwrap()).unwrap()
}
/// The theme the next process loads from `path`.
fn saved_theme(path: &std::path::Path) -> Appearance {
UiState::from_json(&std::fs::read(path).unwrap()).unwrap().theme
}
#[test]
fn a_setting_changed_by_another_process_after_a_save_here_keeps_its_value() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("ui.json");
std::fs::write(&path, serde_json::to_vec(&with_theme("light")).unwrap()).unwrap();
// A loads Light, switches to Dark and saves before exiting (taking a document off the
// recent list does).
let mut a = Some(with_theme("light"));
save_merged(&path, &mut a, with_theme("dark")).unwrap();
assert_eq!(saved_theme(&path), Appearance::Dark);
// B starts, loads Dark, switches to Light and exits.
save_merged(&path, &mut Some(with_theme("dark")), with_theme("light")).unwrap();
// A exits without touching the theme since its save: B's choice, made later, stays.
save_merged(&path, &mut a, with_theme("dark")).unwrap();
assert_eq!(saved_theme(&path), Appearance::Light);
}
#[test]
fn the_loaded_preferences_include_the_words_of_the_dictionary_file() {
// A word only `custom-dictionary.txt` has is loaded, not added here: if another process
// removes it from `ui.json`, this one mustn't write it back.
let dir = tempfile::tempdir().unwrap();
let (prefs, dict) = (dir.path().join("ui.json"), dir.path().join("custom-dictionary.txt"));
std::fs::write(&prefs, br#"{"dictionary": ["zqxinjson"]}"#).unwrap();
std::fs::write(&dict, "zqxinfile\n").unwrap();
let mut app = wordcraft_ui_egui::WordApp::new(wordcraft_engine::Session::new(wordcraft_doc::Document::new()), Default::default());
let loaded = load_prefs_from(&mut app, Some(&prefs), Some(dict)).unwrap();
let words = loaded["dictionary"].as_array().unwrap();
for word in ["zqxinjson", "zqxinfile"] {
assert!(words.contains(&json!(word)), "{word}: {words:?}");
}
wordcraft_engine::proof::remove_word("zqxinjson");
wordcraft_engine::proof::remove_word("zqxinfile");
}
#[test]
fn a_save_waits_for_another_process_saving_at_the_same_moment() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("ui.json");
// Another process is between reading and replacing `ui.json`.
let held = lock_prefs(&path).expect("the lock is free");
let saver = {
let path = path.clone();
std::thread::spawn(move || save_merged(&path, &mut None, with_theme("dark")))
};
std::thread::sleep(std::time::Duration::from_millis(200));
assert!(!path.exists(), "saved while another process held the lock");
drop(held);
saver.join().unwrap().unwrap();
assert_eq!(saved_theme(&path), Appearance::Dark);
}
#[test]
fn failed_preferences_write_keeps_the_old_file_and_reports_the_error() {
+550
View File
@@ -0,0 +1,550 @@
//! Several WordCraft processes share one `ui.json` (opening a file from the file manager starts
//! another). Each reads it at start-up and writes it at exit (and when a change must survive a
//! crash, like taking a document off the recent list), so without a merge the process that writes
//! last writes back what it loaded and loses the others' changes (#3773).
//!
//! The policy: when saving, read `ui.json` again as this version reads it ([`as_read`]: a setting
//! of the wrong type reads as its default, and keys it doesn't know or reads only to migrate are
//! left out), and write it with only what this process changed since it last loaded or saved its
//! preferences (`base`). Every other setting keeps what the file holds now, including the absence
//! of one another process removed (a shortcut, a task pane's place).
//!
//! - A setting both changed takes this process's value.
//! - Groups of settings (editing options, AutoCorrect's switches, keyboard shortcuts, the ribbon,
//! task pane places) merge entry by entry ([`rule`]). Any other object is one setting: the
//! window's size and place, or one task pane's place, are never mixed from two processes.
//! - Lists of user entries (AutoCorrect entries by the text they replace, its exceptions, removed
//! built-in shortcuts, ribbon tabs by name, Quick Access Toolbar commands, caption labels, pens,
//! custom dictionary words) merge entry by entry too ([`merge_entries`]): entries either process
//! added are kept, entries either process removed stay removed, and an entry both changed takes
//! this process's version. A ribbon or toolbar left as it comes counts as its default entries.
//! - Recent lists (documents, symbols, colours, fonts) take the entries this process added or used
//! again first, then the file's, without duplicates, without the entries this process removed,
//! and within each list's limit ([`merge_recent`]).
//! - Any other list (the task panes' order, a floating pane's rectangle) is one setting.
//!
//! What this process changed is found by comparing with `base`, not by recording each change: a
//! setting changed and then changed back counts as untouched, so the file's value stays, and a
//! recent entry used again without moving (it was already first) counts as not used.
use std::collections::{HashMap, HashSet};
use serde_json::{Map, Value};
use wordcraft_engine::ribbon::{DEFAULT_QAT, RibbonLayout};
use wordcraft_ui_egui::{MAX_RECENT, MAX_RECENT_FONTS, UiState, colors, dialogs_insert};
/// Whether two entries of a recent list are the same entry.
type Same = fn(&Value, &Value) -> bool;
/// What tells an entry of a list of user entries from the others. Entries with the same key are
/// told apart by their order ([`ids`]).
type Key = fn(&Value) -> String;
/// How a setting this process changed merges with the file's.
#[derive(Clone, Copy)]
enum Rule {
/// A group of settings: each entry on its own.
Group,
/// A recent list, most recent first: how many entries it keeps, and when two are the same.
Recent(usize, Same),
/// A list of user entries: each entry on its own.
Entries(Key),
/// One setting: this process's value.
Whole,
}
/// The rule for the setting at `path` (`ui.json`'s keys from the top).
fn rule(path: &[&str]) -> Rule {
match path {
[] | ["editing" | "keyboard" | "ribbon" | "panePlaces"] | ["editing", "markup" | "marks" | "autocorrect"] | ["keyboard", "assigned"] => {
Rule::Group
}
["recent"] => Rule::Recent(MAX_RECENT, same_entry),
["recentSymbols"] => Rule::Recent(dialogs_insert::RECENT_SYMBOLS, same_entry),
["recentColors"] => Rule::Recent(colors::RECENT_MAX, same_entry),
["recentFonts"] => Rule::Recent(MAX_RECENT_FONTS, same_font),
["editing", "autocorrect", "entries"] => Rule::Entries(replaced_text),
["ribbon", "tabs"] => Rule::Entries(tab_name),
["editing", "autocorrect", "removed" | "exceptions" | "exceptionsRemoved" | "initialCapsExceptions"]
| ["keyboard", "removed"]
| ["ribbon", "qat"]
| ["captionLabels" | "inkPens" | "dictionary"] => Rule::Entries(whole_entry),
_ => Rule::Whole,
}
}
/// What a setting saved only when it isn't its default stands for when it is missing: the
/// default ribbon tabs and Quick Access Toolbar, so that two processes customizing them from the
/// default merge entry by entry.
fn when_missing(path: &[&str]) -> Option<Value> {
match path {
["ribbon", "tabs"] => serde_json::to_value(RibbonLayout::default().tabs()).ok(),
["ribbon", "qat"] => serde_json::to_value(DEFAULT_QAT).ok(),
_ => None,
}
}
/// Entries saved alike (colours are saved normalised, `colors::push_recent`).
fn same_entry(a: &Value, b: &Value) -> bool {
a == b
}
/// Font names ignoring case, as `push_recent_font` compares them.
fn same_font(a: &Value, b: &Value) -> bool {
match (a.as_str(), b.as_str()) {
(Some(a), Some(b)) => a.to_lowercase() == b.to_lowercase(),
_ => a == b,
}
}
/// The entry as saved.
fn whole_entry(v: &Value) -> String {
v.to_string()
}
/// An AutoCorrect entry `[from, to]` by the text it replaces.
fn replaced_text(v: &Value) -> String {
v.get(0).unwrap_or(v).to_string()
}
/// A ribbon tab by its name, ignoring case as the ribbon does.
fn tab_name(v: &Value) -> String {
v.get("name").and_then(Value::as_str).map_or_else(|| v.to_string(), str::to_lowercase)
}
/// `ui.json`'s bytes as this version reads them, saved again: `None` when they aren't
/// preferences at all.
pub fn as_read(bytes: &[u8]) -> Option<Value> {
serde_json::to_value(UiState::from_json(bytes)?).ok()
}
/// The preferences to write: `ours` (this process's, now), with every value it left as it was in
/// `base` (what it last loaded or saved) taken from `disk` (what `ui.json` holds now, [`as_read`]).
pub fn merge(base: &Value, ours: Value, disk: &Value) -> Value {
let fallback = ours.clone();
merge_setting(&mut Vec::new(), Some(base), Some(ours), Some(disk)).unwrap_or(fallback)
}
/// One setting, at `path`. `None` for a setting left out (this process removed it, or it left it
/// alone and another process removed it).
fn merge_setting(path: &mut Vec<String>, base: Option<&Value>, ours: Option<Value>, disk: Option<&Value>) -> Option<Value> {
if base == ours.as_ref() {
// Unchanged here: whatever the file holds now.
return disk.cloned();
}
let ours = ours?;
let keys: Vec<&str> = path.iter().map(String::as_str).collect();
Some(match (rule(&keys), ours, base, disk) {
(Rule::Group, Value::Object(ours), Some(Value::Object(base)), Some(Value::Object(disk))) => {
Value::Object(merge_group(path, base, ours, disk))
}
(Rule::Recent(cap, same), Value::Array(ours), Some(Value::Array(base)), Some(Value::Array(disk))) => {
Value::Array(merge_recent(base, ours, disk, cap, same))
}
(Rule::Entries(key), Value::Array(ours), Some(Value::Array(base)), Some(Value::Array(disk))) => {
Value::Array(merge_entries(base, &ours, disk, key))
}
(_, ours, ..) => ours,
})
}
/// A group of settings, entry by entry: this process's entries in their order, then those only
/// the file or `base` has.
fn merge_group(path: &mut Vec<String>, base: &Map<String, Value>, mut ours: Map<String, Value>, disk: &Map<String, Value>) -> Map<String, Value> {
let mut names: Vec<String> = ours.keys().cloned().collect();
let mut seen: HashSet<String> = names.iter().cloned().collect();
for k in disk.keys().chain(base.keys()) {
if seen.insert(k.clone()) {
names.push(k.clone());
}
}
let mut merged = Map::new();
for k in names {
path.push(k.clone());
let keys: Vec<&str> = path.iter().map(String::as_str).collect();
let missing = when_missing(&keys);
let base_v = base.get(&k).cloned().or_else(|| missing.clone());
let disk_v = disk.get(&k).cloned().or_else(|| missing.clone());
let ours_v = ours.remove(&k).or_else(|| missing.clone());
let v = merge_setting(path, base_v.as_ref(), ours_v, disk_v.as_ref());
path.pop();
// A setting saved only when it isn't its default is left out when it is.
if let Some(v) = v.filter(|v| Some(v) != missing.as_ref()) {
merged.insert(k, v);
}
}
merged
}
/// A list entry: its key, and how many entries before it have the same key.
type Id = (String, usize);
/// The entries of `list` told apart by `key`, in order.
fn ids(list: &[Value], key: Key) -> Vec<Id> {
let mut seen: HashMap<String, usize> = HashMap::new();
list.iter()
.map(|v| {
let k = key(v);
let n = seen.entry(k.clone()).or_default();
*n += 1;
(k, *n - 1)
})
.collect()
}
/// A list of user entries, entry by entry. An entry either process added is kept, one either
/// removed stays removed, and one this process changed takes its version (else the file's). The
/// order is this process's if it reordered the entries it loaded, else the file's; an entry only
/// the other list has goes after the entry it follows there.
fn merge_entries(base: &[Value], ours: &[Value], disk: &[Value], key: Key) -> Vec<Value> {
let (base_ids, ours_ids, disk_ids) = (ids(base, key), ids(ours, key), ids(disk, key));
let index = |ids: &[Id], list: &[Value]| -> HashMap<Id, Value> { ids.iter().cloned().zip(list.iter().cloned()).collect() };
let (b, o, d) = (index(&base_ids, base), index(&ours_ids, ours), index(&disk_ids, disk));
let value = |id: &Id| -> Option<&Value> {
match (b.get(id), o.get(id), d.get(id)) {
// Left alone here: the file's, or gone if the other process removed it.
(Some(b), Some(o), d) if b == o => d,
// Added or changed here.
(_, Some(o), _) => Some(o),
// Removed here.
(Some(_), None, _) => None,
// Added there.
(None, None, d) => d,
}
};
let common = |ids: &[Id], other: &HashMap<Id, Value>| -> Vec<Id> { ids.iter().filter(|id| other.contains_key(*id)).cloned().collect() };
let reordered = common(&ours_ids, &b) != common(&base_ids, &o);
let (first, second) = if reordered { (&ours_ids, &disk_ids) } else { (&disk_ids, &ours_ids) };
let in_first: HashSet<&Id> = first.iter().collect();
let kept: HashSet<&Id> = first.iter().filter(|id| value(id).is_some()).collect();
// Entries only `second` has, by the kept entry they follow there (`None`: at the start).
let mut after: HashMap<Option<&Id>, Vec<&Id>> = HashMap::new();
let mut anchor = None;
for id in second {
if kept.contains(id) {
anchor = Some(id);
} else if !in_first.contains(id) && value(id).is_some() {
after.entry(anchor).or_default().push(id);
}
}
let mut merged = Vec::new();
let mut emit = |ids: &[&Id]| merged.extend(ids.iter().filter_map(|id| value(id).cloned()));
emit(after.get(&None).map_or(&[], Vec::as_slice));
for id in first.iter().filter(|id| kept.contains(id)) {
emit(&[id]);
emit(after.get(&Some(id)).map_or(&[], Vec::as_slice));
}
merged
}
/// The entries this process put at the front of `ours` ([`touched_len`]), then `disk`'s, leaving
/// out what this process removed (in `base` but no longer in `ours`), without duplicates and at
/// most `cap` entries. Entries are told apart by `same`.
fn merge_recent(base: &[Value], ours: Vec<Value>, disk: &[Value], cap: usize, same: Same) -> Vec<Value> {
let has = |list: &[Value], v: &Value| list.iter().any(|x| same(x, v));
let removed = |v: &Value| has(base, v) && !has(&ours, v);
let touched = &ours[..touched_len(base, &ours, same)];
let mut merged: Vec<Value> = Vec::new();
for v in touched.iter().cloned().chain(disk.iter().filter(|v| !removed(v)).cloned()) {
if merged.len() == cap {
break;
}
if !has(&merged, &v) {
merged.push(v);
}
}
merged
}
/// How many of `ours`'s first entries this process added or used again. Each use moves an entry
/// to the front of a recent list, so what it left alone is a tail of `ours` in `base`'s order: the
/// longest such tail is untouched, and everything before it (new entries, and entries that moved
/// ahead of one loaded before them) was touched. A use that leaves the order as it was loaded
/// (the first entry used again) can't be told from no use, and merges as none.
fn touched_len(base: &[Value], ours: &[Value], same: Same) -> usize {
let mut end = base.len();
for (i, v) in ours.iter().enumerate().rev() {
match base[..end].iter().rposition(|b| same(b, v)) {
Some(at) => end = at,
None => return i + 1,
}
}
0
}
#[cfg(test)]
mod tests {
use serde_json::{Value, json};
use wordcraft_ui_egui::UiState;
use super::{as_read, merge};
/// The preferences a process holds after loading a `ui.json` with `settings` (every other
/// setting at its default), as it saves them.
fn prefs(settings: Value) -> Value {
as_read(&serde_json::to_vec(&settings).unwrap()).unwrap()
}
/// What the next process loads from the merged preferences.
fn reloaded(merged: &Value) -> UiState {
UiState::from_json(&serde_json::to_vec(merged).unwrap()).unwrap()
}
/// `ui.json` after B and then A, which both loaded `loaded`, save `b` and `a`.
fn b_then_a(loaded: &Value, b: Value, a: Value) -> Value {
let after_b = merge(loaded, b, loaded);
merge(loaded, a, &after_b)
}
#[test]
fn two_processes_keep_each_others_changes() {
// #3773: A and B both start from the same file.
let loaded =
json!({"theme": "light", "author": "Ann", "recent": ["a.docx", "b.docx"], "editing": {"smartQuotes": true, "autoCapitalize": true}});
// B changes the theme and opens c.docx, then exits first.
let b = json!({"theme": "dark", "author": "Ann", "recent": ["c.docx", "a.docx", "b.docx"], "editing": {"smartQuotes": false, "autoCapitalize": true}});
// A changes the author name and opens d.docx, then exits.
let a = json!({"theme": "light", "author": "Bo", "recent": ["d.docx", "a.docx", "b.docx"], "editing": {"smartQuotes": true, "autoCapitalize": false}});
assert_eq!(
b_then_a(&loaded, b, a),
json!({"theme": "dark", "author": "Bo", "recent": ["d.docx", "c.docx", "a.docx", "b.docx"], "editing": {"smartQuotes": false, "autoCapitalize": false}})
);
}
#[test]
fn a_process_that_changed_nothing_writes_the_file_back_as_it_is() {
let loaded = json!({"theme": "light", "recent": ["a.docx"]});
let disk = json!({"theme": "dark", "recent": ["b.docx", "a.docx"]});
assert_eq!(merge(&loaded, loaded.clone(), &disk), disk);
}
#[test]
fn this_process_wins_a_setting_both_changed() {
let loaded = json!({"theme": "light"});
assert_eq!(merge(&loaded, json!({"theme": "system"}), &json!({"theme": "dark"})), json!({"theme": "system"}));
}
#[test]
fn a_setting_changed_and_changed_back_counts_as_untouched() {
// Changes are found by comparing with what was loaded: A switched to dark and back.
let loaded = json!({"theme": "light"});
assert_eq!(merge(&loaded, json!({"theme": "light"}), &json!({"theme": "dark"})), json!({"theme": "dark"}));
}
#[test]
fn a_recent_entry_removed_here_stays_removed() {
let loaded = json!({"recent": ["a.docx", "b.docx"]});
let ours = json!({"recent": ["b.docx"]});
let disk = json!({"recent": ["c.docx", "a.docx", "b.docx"]});
assert_eq!(merge(&loaded, ours, &disk), json!({"recent": ["c.docx", "b.docx"]}));
// Clear Recent clears what the other process had added too only if it was loaded here.
assert_eq!(merge(&loaded, json!({"recent": []}), &json!({"recent": ["c.docx", "a.docx", "b.docx"]})), json!({"recent": ["c.docx"]}));
}
#[test]
fn a_recent_entry_used_again_here_moves_to_the_front() {
// Applying a font already in Recently Used Fonts moves it to the front without adding one.
let loaded = json!({"recentFonts": ["A", "B"]});
assert_eq!(merge(&loaded, json!({"recentFonts": ["B", "A"]}), &loaded), json!({"recentFonts": ["B", "A"]}));
// Here C was used again, D opened and A removed; the other process used B again and added E.
let loaded = json!({"recent": ["a.docx", "b.docx", "c.docx"]});
let ours = json!({"recent": ["d.docx", "c.docx", "b.docx"]});
let disk = json!({"recent": ["e.docx", "b.docx", "a.docx", "c.docx"]});
assert_eq!(merge(&loaded, ours, &disk), json!({"recent": ["d.docx", "c.docx", "e.docx", "b.docx"]}));
// Entries this process only kept, in the order it loaded them, don't override the file's order.
let loaded = json!({"recentSymbols": ["x", "y", "z"]});
let ours = json!({"recentSymbols": ["w", "x", "z"]});
let disk = json!({"recentSymbols": ["z", "x", "y"]});
assert_eq!(merge(&loaded, ours, &disk), json!({"recentSymbols": ["w", "z", "x"]}));
}
#[test]
fn recent_fonts_are_one_entry_whatever_their_case() {
// Recently Used Fonts ignores case (`push_recent_font`): Arial applied here as `arial` and
// there as `ARIAL` is one entry, and doesn't push a distinct font out of the ten.
let loaded = json!({"recentFonts": ["A", "B", "C", "D", "E", "F", "G", "H", "I", "Arial"]});
let ours = json!({"recentFonts": ["arial", "A", "B", "C", "D", "E", "F", "G", "H", "I"]});
let disk = json!({"recentFonts": ["ARIAL", "A", "B", "C", "D", "E", "F", "G", "H", "I"]});
assert_eq!(merge(&loaded, ours, &disk), json!({"recentFonts": ["arial", "A", "B", "C", "D", "E", "F", "G", "H", "I"]}));
// Other lists compare their entries as saved.
let loaded = json!({"recent": ["a.docx"]});
assert_eq!(merge(&loaded, json!({"recent": ["A.docx", "a.docx"]}), &loaded), json!({"recent": ["A.docx", "a.docx"]}));
}
#[test]
fn merged_recent_lists_keep_their_limit() {
// Recently Used Fonts keeps ten.
let loaded = json!({"recentFonts": ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]});
let ours = json!({"recentFonts": ["X", "A", "B", "C", "D", "E", "F", "G", "H", "I"]});
let disk = json!({"recentFonts": ["Y", "A", "B", "C", "D", "E", "F", "G", "H", "I"]});
assert_eq!(merge(&loaded, ours, &disk), json!({"recentFonts": ["X", "Y", "A", "B", "C", "D", "E", "F", "G", "H"]}));
}
#[test]
fn a_bad_recent_entry_in_the_file_is_not_carried_forward() {
// A non-string entry makes the whole list read as empty (`options::lenient` falls back per
// setting). Merging it in would keep Recent empty in every later session; instead the
// list reads as this version reads it, and the next save heals it.
let loaded = prefs(json!({"recent": []}));
let ours = prefs(json!({"recent": ["x.docx"]}));
let disk = as_read(br#"{"recent": [{"path": "y.docx"}, "z.docx"]}"#).unwrap();
let merged = merge(&loaded, ours, &disk);
assert_eq!(merged["recent"], json!(["x.docx"]));
assert_eq!(loaded_recent(&merged), ["x.docx"]);
// Same for recent symbols.
let ours = prefs(json!({"recentSymbols": [{"ch": "§", "font": "Arial"}]}));
let disk = as_read(r#"{"recentSymbols": [{"ch": "¶", "font": "Arial"}, 7]}"#.as_bytes()).unwrap();
assert_eq!(reloaded(&merge(&prefs(json!({})), ours, &disk)).recent_symbols.len(), 1);
}
/// The recent documents the next process loads.
fn loaded_recent(merged: &Value) -> Vec<String> {
reloaded(merged).recent
}
#[test]
fn only_keys_this_version_writes_are_kept() {
// A legacy key read once to migrate, and junk, are not written back, even from the file.
let loaded = prefs(json!({"theme": "light"}));
let disk = as_read(br#"{"theme": "light", "dark": true, "interfaceSize": 120, "junk": 1}"#).unwrap();
let merged = merge(&loaded, loaded.clone(), &disk);
for gone in ["dark", "interfaceSize", "junk"] {
assert!(merged.get(gone).is_none(), "{gone}");
}
assert_eq!(merged["theme"], "light");
}
#[test]
fn a_file_another_process_damaged_gives_way_to_ours() {
let loaded = json!({"theme": "light", "recent": ["a.docx"]});
let ours = json!({"theme": "dark", "recent": ["a.docx"]});
// Not preferences at all: everything comes from this process.
assert_eq!(as_read(b"\"garbage\""), None);
assert_eq!(merge(&loaded, ours.clone(), &json!("garbage")), ours);
// A list replaced by something else keeps ours.
assert_eq!(merge(&loaded, json!({"recent": ["b.docx", "a.docx"]}), &json!({"recent": 3})), json!({"recent": ["b.docx", "a.docx"]}));
}
#[test]
fn autocorrect_entries_and_exceptions_from_both_processes_are_kept() {
let loaded = prefs(json!({"editing": {"autocorrect": {"entries": [["teh", "the"]], "exceptions": ["approx."]}}}));
// B adds an entry and an exception; A adds another entry, changes `teh`'s replacement and
// removes `approx.`. Each added entry follows the entry it was added after.
let b = prefs(json!({"editing": {"autocorrect": {"entries": [["teh", "the"], ["teh2", "the"]], "exceptions": ["approx.", "fig."]}}}));
let a = prefs(json!({"editing": {"autocorrect": {"entries": [["teh", "THE"], ["adn", "and"]], "exceptions": []}}}));
let ac = reloaded(&b_then_a(&loaded, b, a)).editing.autocorrect;
let entries: Vec<(&str, &str)> = ac.entries.iter().map(|(f, t)| (f.as_str(), t.as_str())).collect();
assert_eq!(entries, [("teh", "THE"), ("adn", "and"), ("teh2", "the")]);
assert_eq!(ac.exceptions, ["fig."]);
}
#[test]
fn keyboard_customisations_merge_key_by_key() {
let loaded = prefs(json!({"keyboard": {"assigned": {"Mod+Shift+K": "format.bold"}, "removed": []}}));
// B takes Ctrl+B off Bold and deletes its own Mod+Shift+K; A takes Ctrl+I off Italic and
// assigns Mod+Shift+J.
let b = prefs(json!({"keyboard": {"assigned": {}, "removed": ["Mod+B"]}}));
let a = prefs(json!({"keyboard": {"assigned": {"Mod+Shift+K": "format.bold", "Mod+Shift+J": "format.italic"}, "removed": ["Mod+I"]}}));
let keys = reloaded(&b_then_a(&loaded, b, a)).keyboard;
assert_eq!(keys.assigned.into_iter().collect::<Vec<_>>(), [("Mod+Shift+J".to_string(), "format.italic".to_string())]);
assert_eq!(keys.removed.into_iter().collect::<Vec<_>>(), ["Mod+B", "Mod+I"]);
}
#[test]
fn ribbon_changes_from_both_processes_are_kept() {
// Both start from the default ribbon. B hides Draw; A adds a custom tab after Home.
let loaded = prefs(json!({}));
let b = prefs(json!({"ribbon": {"tabs": hide(default_tabs(), "Draw")}}));
let mut a_tabs = default_tabs();
a_tabs.insert(1, json!({"name": "Mine", "custom": true}));
let a = prefs(json!({"ribbon": {"tabs": a_tabs}}));
let mut want = hide(default_tabs(), "Draw");
want.insert(1, json!({"name": "Mine", "custom": true}));
assert_eq!(serde_json::to_value(loaded_ribbon(&b_then_a(&loaded, b, a)).tabs).unwrap(), Value::Array(want));
}
#[test]
fn a_toolbar_reset_by_one_process_stays_reset() {
// B resets its custom Quick Access Toolbar to the default; A, which left it alone, adds a
// custom tab. The toolbar stays the default.
let loaded = prefs(json!({"ribbon": {"qat": ["file.save", "format.bold"]}}));
let b = prefs(json!({}));
let mut a_tabs = default_tabs();
a_tabs.push(json!({"name": "Mine", "custom": true}));
let a = prefs(json!({"ribbon": {"tabs": a_tabs, "qat": ["file.save", "format.bold"]}}));
let merged = b_then_a(&loaded, b, a);
assert!(merged["ribbon"].get("qat").is_none(), "{}", merged["ribbon"]);
let ribbon = loaded_ribbon(&merged);
assert_eq!(ribbon.qat, None);
assert!(ribbon.tabs.iter().any(|t| t.name == "Mine"));
// Two processes customizing the default toolbar: both commands, Save removed by A gone.
let loaded = prefs(json!({}));
let b = prefs(json!({"ribbon": {"qat": ["file.save", "edit.undo", "edit.redo", "format.bold"]}}));
let a = prefs(json!({"ribbon": {"qat": ["edit.undo", "edit.redo", "format.italic"]}}));
assert_eq!(loaded_ribbon(&b_then_a(&loaded, b, a)).qat.unwrap(), ["edit.undo", "edit.redo", "format.italic", "format.bold"]);
}
/// The default ribbon tabs, as saved once the ribbon is customized.
fn default_tabs() -> Vec<Value> {
serde_json::from_value(serde_json::to_value(wordcraft_engine::RibbonLayout::default().tabs()).unwrap()).unwrap()
}
/// `tabs` with the tab `name` hidden.
fn hide(mut tabs: Vec<Value>, name: &str) -> Vec<Value> {
for t in &mut tabs {
if t["name"] == name {
t["hidden"] = json!(true);
}
}
tabs
}
/// The ribbon the next process loads.
fn loaded_ribbon(merged: &Value) -> wordcraft_engine::RibbonLayout {
reloaded(merged).ribbon
}
#[test]
fn a_pane_order_changed_by_the_other_process_is_kept() {
// `paneOrder` is saved only when it isn't the default. B reorders; A leaves it alone and
// switches to dark.
let loaded = prefs(json!({}));
let order = json!(["styles", "navigation"]);
let b = prefs(json!({"paneOrder": order}));
let merged = b_then_a(&loaded, b, prefs(json!({"theme": "dark"})));
assert_eq!((&merged["paneOrder"], &merged["theme"]), (&order, &json!("dark")));
// B goes back to the default order; A, which loaded B's order and left it, doesn't bring
// it back.
let loaded = prefs(json!({"paneOrder": order}));
let merged = b_then_a(&loaded, prefs(json!({})), prefs(json!({"paneOrder": order, "theme": "dark"})));
assert!(merged.get("paneOrder").is_none(), "{merged}");
assert_eq!(merged["theme"], "dark");
}
#[test]
fn the_window_and_a_pane_place_are_one_setting_each() {
// A moved its window and B resized its own: the window is A's, not A's place with B's size.
let window = |x: f32, width: f32| json!({"window": {"position": [x, 10.0], "width": width, "height": 600.0, "maximized": false}});
let loaded = prefs(window(0.0, 800.0));
let merged = b_then_a(&loaded, prefs(window(0.0, 1000.0)), prefs(window(300.0, 800.0)));
assert_eq!(merged["window"], prefs(window(300.0, 800.0))["window"]);
}
#[test]
fn pens_labels_and_dictionary_words_from_both_processes_are_kept() {
let pen = |color: &str| json!({"kind": "pen", "color": color, "width": 1.0});
let loaded = prefs(json!({"inkPens": [pen("FF0000"), pen("FF0000")], "captionLabels": ["Plate"], "dictionary": ["foo", "bar"]}));
// B adds a third red pen, a label and a word; A adds a blue pen, removes `bar` and adds a
// label of its own. Identical pens stay apart, by their order.
let b = prefs(
json!({"inkPens": [pen("FF0000"), pen("FF0000"), pen("FF0000")], "captionLabels": ["Plate", "Chart"], "dictionary": ["foo", "bar", "baz"]}),
);
let a = prefs(json!({"inkPens": [pen("FF0000"), pen("FF0000"), pen("0000FF")], "captionLabels": ["Plate", "Map"], "dictionary": ["foo"]}));
let merged = b_then_a(&loaded, b, a);
let ui = reloaded(&merged);
let colors: Vec<String> = ui.ink_pens.iter().map(|p| serde_json::to_value(p).unwrap()["color"].as_str().unwrap().to_string()).collect();
assert_eq!(colors, ["FF0000", "FF0000", "0000FF", "FF0000"]);
assert_eq!(ui.caption_labels, ["Plate", "Map", "Chart"]);
assert_eq!(merged["dictionary"], json!(["foo", "baz"]));
}
}
+16 -1
View File
@@ -727,9 +727,16 @@ impl Document {
}
/// Split the paragraph at `pos`; returns the start of the new (second) paragraph.
///
/// A split after the first letters leaves the drop cap on the first paragraph only: the new
/// one is plain (Word: Enter makes a normal paragraph). A split at offset 0 is unchanged.
/// A drop cap that comes from a paragraph style, not the paragraph, is not cleared.
pub fn split_paragraph(&mut self, pos: &Pos) -> Result<Pos> {
let i = pos.path.last();
let tail = self.para_mut(pos.story, &pos.path)?.split_off(pos.off)?;
let mut tail = self.para_mut(pos.story, &pos.path)?.split_off(pos.off)?;
if pos.off > 0 {
clear_drop_cap(&mut tail.props);
}
let bl = self.container_mut(pos.story, &pos.path)?;
bl.insert((i + 1).min(bl.len()), para_block(tail));
Ok(Pos { story: pos.story, path: pos.path.with_last(i + 1), off: 0 })
@@ -1599,5 +1606,13 @@ impl Document {
}
}
/// Take the drop cap (and its options) off a paragraph's properties.
fn clear_drop_cap(props: &mut crate::props::ParaProps) {
props.drop_cap = None;
props.drop_cap_margin = None;
props.drop_cap_distance = None;
props.drop_cap_font = None;
}
#[cfg(test)]
mod tests;
+35
View File
@@ -988,3 +988,38 @@ fn insert_fragment_remaps_conflicting_media_keys() {
let remapped = para.objects.iter().find_map(|o| if let InlineObject::Image { media, .. } = o { Some(media.as_str()) } else { None }).unwrap();
assert_eq!(remapped, other_key);
}
/// #6788: splitting a paragraph after its first letters leaves the drop cap on the first
/// paragraph only; the new one (also when it is empty) is plain. A split at offset 0 is unchanged.
#[test]
fn split_paragraph_keeps_the_drop_cap_on_the_first_paragraph_only() {
let drop_cap = |d: &Document, i: usize| {
let p = d.body.get(i).and_then(|b| b.as_para()).map(|p| p.props.clone()).unwrap_or_default();
(p.drop_cap, p.drop_cap_margin, p.drop_cap_distance, p.drop_cap_font)
};
let capped = |text: &str| {
let mut d = doc(&[text]);
if let Ok(p) = d.para_mut(StoryRef::Body, &Path::top(0)) {
p.props.drop_cap = Some(3);
p.props.drop_cap_margin = Some(true);
p.props.drop_cap_distance = Some(4.0);
p.props.drop_cap_font = Some("Serif".into());
}
d
};
let cap = (Some(3), Some(true), Some(4.0), Some("Serif".to_string()));
let plain = (None, None, None, None);
let mut d = capped("Sugar and knowledge");
d.split_paragraph(&Pos::body(0, 10)).unwrap();
assert_eq!((drop_cap(&d, 0), drop_cap(&d, 1)), (cap.clone(), plain.clone()));
let mut d = capped("Sugar");
d.split_paragraph(&Pos::body(0, 5)).unwrap();
assert_eq!((drop_cap(&d, 0), drop_cap(&d, 1)), (cap.clone(), plain.clone()));
// At offset 0 nothing changes: both paragraphs keep the properties, as before.
let mut d = capped("Sugar");
d.split_paragraph(&Pos::body(0, 0)).unwrap();
assert_eq!((drop_cap(&d, 0), drop_cap(&d, 1)), (cap.clone(), cap));
}
+2 -2
View File
@@ -94,8 +94,8 @@ pub use settings::{
COMPAT_MODE_CURRENT, CoreProps, CustomProp, DEFAULT_GRID, DEFAULT_HYPHENATION_ZONE, LEGACY_COMPAT_MODE, OdfLayout, PagePicture, Settings, Source,
THEME_COLORS, Watermark, Zoom, ZoomFit,
};
pub(crate) use text_walk::{PARA_WALK_DEPTH, walk_between};
pub use text_walk::{count_chars, count_chars_no_spaces, count_words};
pub(crate) use text_walk::walk_between;
pub use text_walk::{PARA_WALK_DEPTH, count_chars, count_chars_no_spaces, count_words};
/// A document.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+7
View File
@@ -137,6 +137,12 @@ pub struct Settings {
/// Keep contextual paragraph spacing inside legacy table cells (`allowSpaceOfSameStyleInTable`).
/// Word ignores the layout override in compatibility mode 15, but the flag still round-trips.
pub allow_space_of_same_style_in_table: bool,
/// `w:doNotSuppressIndentation` (a `.doc`'s `Copts.fWW11IndentRules`): Word 2003's indent
/// rules beside floating objects. An unnumbered paragraph's line starts right after a floating
/// object before it on the line, its own indent ignored (ECMA-376 Part 4 §14.8.3.12). Word 2013's
/// layout (compatibility mode 15) does not use it.
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
pub do_not_suppress_indentation: bool,
/// Drawing grid spacing in points, across and down (View › Gridlines); ECMA-376's default is 1/8 inch.
pub grid_h: f32,
pub grid_v: f32,
@@ -319,6 +325,7 @@ impl Default for Settings {
sum_paragraph_spacing: false,
do_not_expand_shift_return: false,
allow_space_of_same_style_in_table: false,
do_not_suppress_indentation: false,
grid_h: DEFAULT_GRID,
grid_v: DEFAULT_GRID,
math: None,
+1 -1
View File
@@ -48,7 +48,7 @@ pub fn count_chars_no_spaces(s: &str) -> usize {
}
/// How deep in nested tables [`Document::para_paths`] goes: cells below this are skipped.
pub(crate) const PARA_WALK_DEPTH: usize = 16;
pub const PARA_WALK_DEPTH: usize = 16;
/// The note and text box stories an object shows, for `Document::reachable`.
pub(crate) fn notes_and_boxes(o: &InlineObject) -> Vec<(u32, &'static [PartKind])> {
+1
View File
@@ -15,6 +15,7 @@ workspace = true
test-support = []
[dependencies]
craft-mime.workspace = true
wordcraft-geom = { workspace = true, features = ["image"] }
wordcraft-doc = { workspace = true }
wordcraft-fonts = { workspace = true }
+2 -2
View File
@@ -79,7 +79,7 @@ pub fn specs() -> Vec<CommandSpec> {
.when(has_canvas)
.pure(),
CommandSpec::new("canvas.member", "Canvas Member", "Shape Format › Drawing Canvas", member)
.params(r#"{"index": n, "x"?: pt, "y"?: pt, "width"?: pt, "height"?: pt, "delete"?: bool} (moves, resizes or removes member `index` of the selected canvas; x/y from the canvas's top-left; with no change, returns the members)"#)
.params(r#"{"index"?: n, "x"?: pt, "y"?: pt, "width"?: pt, "height"?: pt, "delete"?: bool} (moves, resizes or removes member `index` of the selected canvas; x/y from the canvas's top-left; without index, returns the members)"#)
.when(has_canvas),
]
}
@@ -211,7 +211,7 @@ fn scale(s: &mut Session, v: &Value) -> CmdResult {
result(&o)
}
/// `canvas.member`: move, resize or remove one member; with no change, list the members.
/// `canvas.member`: move, resize or remove one member; without index, list the members.
fn member(s: &mut Session, v: &Value) -> CmdResult {
let pos = canvas_pos(s)?;
let Some(i) = p::u64(v, "index").and_then(|i| usize::try_from(i).ok()) else {
+1
View File
@@ -68,6 +68,7 @@ pub fn specs() -> Vec<CommandSpec> {
sel_result(s)
})
.key("Escape")
.params(r#"{"end"?: bool (default false: collapse to the start; true: to the end)}"#)
.pure(),
]
}
+2 -1
View File
@@ -63,7 +63,8 @@ pub fn specs() -> Vec<CommandSpec> {
let t = THEMES.iter().find(|t| t.0.eq_ignore_ascii_case(name)).ok_or_else(|| CmdError::Params(format!("unknown colours `{name}`")))?;
set_accent(s, t.3[0]);
sel_result(s)
}),
})
.params(r#"{"name": string (see design.themes)}"#),
CommandSpec::new("design.styleSet", "Style Set", "Design › Document Formatting", style_set)
.params(r#"{"name": "default|basic|lines|shaded|casual|centered|minimalist|title"}"#),
CommandSpec::new("design.paragraphSpacing", "Paragraph Spacing", "Design › Document Formatting", para_spacing)
+40 -16
View File
@@ -141,7 +141,9 @@ pub fn specs() -> Vec<CommandSpec> {
.key(super::mac_or("Mod+Shift+G / Mod+PageUp", "Mod+PageUp"))
.params(r#"{"text"?: string, "matchCase"?: bool, "wholeWord"?: bool, "regex"?: bool}"#)
.pure(),
CommandSpec::new("edit.replace", "Replace", "Home › Editing", replace).params(r#"{"text": string, "with": string, …options of edit.replaceAll}"#),
CommandSpec::new("edit.replace", "Replace", "Home › Editing", replace).params(
r#"{"text": string, "with": string, …options of edit.replaceAll} — Word's Replace button: replaces the match only when it is already selected, then selects the next one. The first call on a caret replaces nothing; call again to replace the selected match, or use edit.replaceAll for every match. Returns {"replaced": 0 | 1, "remaining": n, "selected": {start, end} | null}"#,
),
// Ctrl+H, Home › Replace: the Find and Replace dialog on its Replace tab (#712). Opening
// it changes nothing, so it is its own command and never marks the document edited.
CommandSpec::new("edit.findReplace", "Find and Replace", "Home › Editing", |s, v| {
@@ -172,7 +174,9 @@ pub fn specs() -> Vec<CommandSpec> {
.pure(),
CommandSpec::new("edit.formatPainter", "Format Painter", "Home › Clipboard", painter).params(r#"{"sticky"?: bool}"#).pure(),
CommandSpec::new("edit.copyFormat", "Copy Formatting", "Home › Clipboard", |s, _| {
painter_pick(s);
// One format buffer, as in Word: Copy Formatting replaces an armed Format Painter.
s.painter = None;
s.copied_format = Some(picked_format(s));
sel_result(s)
})
.key(copy_format_shortcut(cfg!(target_arch = "wasm32")))
@@ -744,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
@@ -832,11 +845,21 @@ fn goto(s: &mut Session, v: &Value) -> CmdResult {
sel_result(s)
}
fn painter_pick(s: &mut Session) {
/// The character and paragraph formatting at the start of the selection.
fn picked_format(s: &Session) -> (wordcraft_doc::props::CharProps, wordcraft_doc::props::ParaProps) {
let f = s.sel.ordered().0;
// A symbol's own font isn't formatting to paint onto text.
let chr = s.doc.para_at(&f).map(|p| p.props_of_char(f.off).clone().without_symbol()).unwrap_or_default();
let para = s.doc.para_at(&f).map(|p| p.props.clone()).unwrap_or_default();
// Formatting only: not the source's hyperlink or revision marks (#5616).
let chr = s.doc.para_at(&f).map(|p| p.props_of_char(f.off).clone().without_symbol().formatting()).unwrap_or_default();
let para = s.doc.para_at(&f).map(|p| p.props.clone().formatting()).unwrap_or_default();
(chr, para)
}
fn painter_pick(s: &mut Session) {
let (chr, para) = picked_format(s);
// One format buffer, as in Word: the pick is also what the next Paste Formatting applies,
// and stays after the brush is used up or cancelled.
s.copied_format = Some((chr.clone(), para.clone()));
s.painter = Some((chr, para, false));
}
@@ -852,9 +875,14 @@ fn painter(s: &mut Session, v: &Value) -> CmdResult {
Ok(json!({"active": true}))
}
/// Apply the format painter's formatting to the selection.
/// Apply the format painter's formatting to the selection, or else what Copy Formatting picked
/// up (which stays for the next Paste Formatting).
fn paste_format(s: &mut Session, _: &Value) -> CmdResult {
let Some((chr, para, sticky)) = s.painter.clone() else { return Err(CmdError::Failed("no formatting copied".into())) };
let (chr, para, sticky) = match (s.painter.clone(), s.copied_format.clone()) {
(Some(brush), _) => brush,
(None, Some((chr, para))) => (chr, para, true),
(None, None) => return Err(CmdError::Failed("no formatting copied".into())),
};
let (a, b) = s.sel.ordered();
if a == b {
// No selection: apply paragraph formatting (and word formatting like Word).
@@ -864,15 +892,11 @@ fn paste_format(s: &mut Session, _: &Value) -> CmdResult {
// Word selection includes trailing spaces; a painter click formats just the word,
// matching the ordinary collapsed-caret formatting target.
let word_end = pp.text.get(x..y).map(|word| x + word.trim_end().len()).unwrap_or(y);
s.doc.format_range(&Pos { off: x, ..f.clone() }, &Pos { off: word_end, ..f.clone() }, &|c| *c = chr.cleared().overlaid(&chr))?;
s.doc.format_range(&Pos { off: x, ..f.clone() }, &Pos { off: word_end, ..f.clone() }, &|c| *c = c.cleared().overlaid(&chr))?;
}
s.doc.format_paragraphs(&a, &b, &|p| *p = para.clone())?;
} else {
s.doc.format_range(&a, &b, &|c| {
let link = c.link.clone();
*c = c.cleared().overlaid(&chr);
c.link = link;
})?;
s.doc.format_range(&a, &b, &|c| *c = c.cleared().overlaid(&chr))?;
if a.path != b.path || a.off == 0 {
s.doc.format_paragraphs(&a, &b, &|p| *p = para.clone())?;
}
+5 -2
View File
@@ -154,7 +154,7 @@ pub fn show_results(s: &mut Session) -> Result<(), CmdError> {
fn set_code(s: &mut Session, v: &Value) -> CmdResult {
let code = p::req_str(v, "code")?.trim().to_string();
if code.is_empty() || code.len() > MAX_CODE || code.contains(OBJ) {
return Err(CmdError::Params("bad field code".into()));
return Err(CmdError::Params("`code` must be non-empty, at most 4096 UTF-8 bytes, and contain no U+FFFC object markers".into()));
}
let Some(f) = selected(s).into_iter().next() else { return Err(none_selected()) };
with_field(s, &f.at, |o| match o {
@@ -441,7 +441,10 @@ mod tests {
s.run("fields.setCode", &json!({"code": "TITLE"})).unwrap();
let objs = |s: &Session| s.doc.body.first().and_then(|b| b.as_para()).map(|p| p.objects.clone()).unwrap_or_default();
assert!(matches!(objs(&s).first(), Some(InlineObject::Field { instr, result, .. }) if instr == "TITLE" && result == "Report"));
assert!(s.run("fields.setCode", &json!({"code": ""})).is_err());
assert!(matches!(
s.run("fields.setCode", &json!({"code": ""})),
Err(crate::CmdError::Params(message)) if message == "`code` must be non-empty, at most 4096 UTF-8 bytes, and contain no U+FFFC object markers"
));
// A locked field keeps its result.
s.run("fields.lock", &json!({})).unwrap();
+4 -4
View File
@@ -90,7 +90,7 @@ pub fn specs() -> Vec<CommandSpec> {
CommandSpec::new("file.new", "New", "File", new).key("Mod+N").params(r#"{"template"?: "blank|sample|letter|resume|report"}"#).pure(),
CommandSpec::new("file.open", "Open", "File", open)
.key("Mod+O / Mod+F12 / Mod+Alt+F2")
.params(r#"{"path": string, "data"?: base64 (the file's bytes; `path` then only names it), "password"?: string (for a password-protected Word document)}"#)
.params(r#"{"path": string, "data"?: base64 (the file's bytes; `path` then only names it), "password"?: string (for a password-protected Word or OpenDocument text file)}"#)
.pure(),
CommandSpec::new("file.save", "Save", "File", save)
.key("Mod+S / Shift+F12 / Alt+Shift+F2")
@@ -100,7 +100,7 @@ pub fn specs() -> Vec<CommandSpec> {
// Pure: the password must not land in Repeat or a recorded macro, and it isn't an edit
// to undo; it marks the document as changed itself.
CommandSpec::new("file.encrypt", "Encrypt with Password", "File › Info › Protect Document", encrypt)
.params(r#"{"password": string (Word documents are saved encrypted with it) | null or "" (saved unencrypted)}"#)
.params(r#"{"password": string (Word packages and OpenDocument text files (.odt, .ott) are saved encrypted with it) | null or "" (saved unencrypted)}"#)
.pure(),
CommandSpec::new("file.exportPdf", "Export PDF", "File › Export", |s, v| {
// No path (the command search, say): the app asks where to save, as File › Export
@@ -368,8 +368,8 @@ fn close_document(s: &mut Session, v: &Value) -> CmdResult {
Ok(json!({"closed": id, "active": s.document_id(), "documents": s.documents()}))
}
/// File › Info › Protect Document › Encrypt with Password: the password Word documents are saved
/// with from now on, or none.
/// File › Info › Protect Document › Encrypt with Password: the password Word packages and
/// OpenDocument text files (.odt, .ott) are saved with from now on, or none.
fn encrypt(s: &mut Session, v: &Value) -> CmdResult {
let password = match v.get("password") {
Some(Value::Null) => None,
+1 -1
View File
@@ -336,7 +336,7 @@ fn font(s: &mut Session, v: &Value) -> CmdResult {
let Some(n) = v.get(k) else { return Ok(None) };
let n = n.as_str().map(str::trim).unwrap_or("");
if n.is_empty() || n.len() > 128 {
return Err(CmdError::Params(format!("bad font name `{k}`")));
return Err(CmdError::Params(format!("`{k}` must be a non-empty font name of at most 128 bytes")));
}
Ok(Some(n.to_string()))
};
+4 -2
View File
@@ -51,7 +51,7 @@ pub(super) fn link(s: &mut Session, v: &Value) -> CmdResult {
},
};
if url.is_empty() || url.len() > 4096 {
return Err(CmdError::Params("bad url".into()));
return Err(CmdError::Params("`url` must be non-empty and at most 4096 UTF-8 bytes".into()));
}
let style = Some("Hyperlink".to_string());
if s.sel.is_collapsed() {
@@ -188,7 +188,9 @@ pub(super) fn delete_bookmark(s: &mut Session, v: &Value) -> CmdResult {
pub(super) fn bookmark(s: &mut Session, v: &Value) -> CmdResult {
let name = p::req_str(v, "name")?.trim().to_string();
if !bookmark_name_ok(&name) {
return Err(CmdError::Params("bookmark names start with a letter, have no spaces and at most 40 characters".into()));
return Err(CmdError::Params(
"bookmark names start with a letter or underscore, contain only letters, numbers or underscores, and have at most 40 characters".into(),
));
}
// Replace an existing bookmark of the same name.
remove_bookmark(s, &name)?;
+1 -16
View File
@@ -71,22 +71,7 @@ pub fn base64_decode(s: &str) -> Option<Vec<u8>> {
Some(out)
}
pub fn base64_encode(b: &[u8]) -> String {
const T: &[u8; 64] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
let mut out = String::with_capacity(b.len().div_ceil(3) * 4);
for ch in b.chunks(3) {
let n =
(ch.first().copied().unwrap_or(0) as u32) << 16 | (ch.get(1).copied().unwrap_or(0) as u32) << 8 | ch.get(2).copied().unwrap_or(0) as u32;
for i in 0..4 {
if i <= ch.len() {
out.push(T[(n >> (18 - 6 * i) & 63) as usize] as char);
} else {
out.push('=');
}
}
}
out
}
pub use craft_mime::transfer::base64 as base64_encode;
pub(crate) fn picture(s: &mut Session, v: &Value) -> CmdResult {
let bytes = if let Some(d) = p::str(v, "data") {
+19
View File
@@ -415,3 +415,22 @@ fn local_civil_date_follows_the_utc_offset() {
assert!(crate::cmd::local_offset_secs(unix).abs() <= 26 * 3600);
}
}
#[test]
fn shared_base64_preserves_command_payload_bytes() {
for (plain, encoded) in [("", ""), ("f", "Zg=="), ("fo", "Zm8="), ("foo", "Zm9v"), ("foobar", "Zm9vYmFy")] {
assert_eq!(super::objects::base64_encode(plain.as_bytes()), encoded);
}
let bytes: Vec<u8> = (0..513).map(|i| (i % 256) as u8).collect();
for len in 0..=bytes.len() {
let encoded = super::objects::base64_encode(&bytes[..len]);
assert_eq!(encoded.len(), len.div_ceil(3) * 4);
assert!(!encoded.contains(['\r', '\n']));
assert_eq!(super::objects::base64_decode(&encoded), Some(bytes[..len].to_vec()));
}
assert_eq!(super::objects::base64_encode(&[251, 255, 255]), "+///");
// The existing decoder intentionally accepts URL-safe symbols, whitespace and optional padding.
assert_eq!(super::objects::base64_decode("-___"), Some(vec![251, 255, 255]));
assert_eq!(super::objects::base64_decode("Z g\n"), Some(b"f".to_vec()));
assert_eq!(super::objects::base64_decode("!!!!"), None);
}
+3 -2
View File
@@ -110,7 +110,7 @@ pub fn specs() -> Vec<CommandSpec> {
apply_filter(s);
filter_result(s)
})
.params(r#"{"rules"?: [{"field": string, "op": "equal|notEqual|less|greater|lessOrEqual|greaterOrEqual|blank|notBlank|contains|notContains", "value"?: string, "join"?: "and|or" (with the rule before; And binds tighter)}], "sort"?: [{"field": string, "descending"?: bool}]} (replaces the filter; `sort` too when given; {} clears both). Preview, Finish & Merge and labels use only the matching records, in sort order"#)
.params(r#"{"rules"?: [{"field": string, "op": "equal|notEqual|less|greater|lessOrEqual|greaterOrEqual|blank|notBlank|contains|notContains", "value"?: string, "join"?: "and|or" (with the rule before; And binds tighter)}], "sort"?: [{"field": string, "descending"?: bool}]} (replaces the filter; `sort` too when given; `sort` also accepts a field name, one key object or null; array entries may also be field names; {} clears both). Preview, Finish & Merge and labels use only the matching records, in sort order"#)
.when(has_list)
.pure(),
CommandSpec::new("mailings.sortRecipients", "Sort Recipients", "Mailings › Start Mail Merge › Edit Recipient List", |s, v| {
@@ -118,7 +118,7 @@ pub fn specs() -> Vec<CommandSpec> {
apply_filter(s);
filter_result(s)
})
.params(r#"{"sort"?: [{"field": string, "descending"?: bool}]} | {"field": string, "descending"?: bool} (no params: the list's own order)"#)
.params(r#"{"sort"?: [{"field": string, "descending"?: bool}]} | {"field": string, "descending"?: bool} (`sort` also accepts a field name, one key object or null; array entries may also be field names; no params: the list's own order)"#)
.when(has_list)
.pure(),
CommandSpec::new("mailings.insertField", "Insert Merge Field", "Mailings › Write & Insert Fields", |s, v| {
@@ -192,6 +192,7 @@ pub fn specs() -> Vec<CommandSpec> {
refresh(s);
Ok(json!({"record": idx + 1}))
})
.params(r#"{"text": string}"#)
.when(has_recipients),
CommandSpec::new("mailings.checkErrors", "Check for Errors", "Mailings › Finish", |s, _| {
let mut missing = Vec::new();
+1 -1
View File
@@ -255,7 +255,7 @@ pub(super) fn parse_sort(headers: &[String], v: Option<&Value>) -> Result<Vec<So
None | Some(Value::Null) => return Ok(Vec::new()),
Some(Value::Array(a)) => a.clone(),
Some(o @ (Value::Object(_) | Value::String(_))) => vec![o.clone()],
Some(_) => return Err(CmdError::Params("`sort` must be an array of {field, descending}".into())),
Some(_) => return Err(CmdError::Params("`sort` must be a field name, a {field, descending} object, an array of those, or null".into())),
};
if arr.len() > MAX_SORT_KEYS {
return Err(CmdError::Params(format!("at most {MAX_SORT_KEYS} sort keys")));
+3 -2
View File
@@ -107,7 +107,8 @@ fn condition(s: &Session, t: &str, row: usize) -> (bool, Vec<String>) {
let op: String = rest.trim_start().chars().take_while(|c| matches!(c, '<'..='>')).collect();
let mut texts = field_words(rest).into_iter().filter(|(_, q)| *q).map(|(w, _)| w);
let cmp = texts.next().unwrap_or_default();
let v = value(s, row, &field);
let tested = t.split_once('{').and_then(|(_, r)| r.split('}').next()).unwrap_or("");
let v = wordcraft_layout::fields::apply_case_switch(tested, value(s, row, &field));
// Numbers compare as numbers (Word: "7" = "7.0"), everything else as text.
let ord = match (v.trim().parse::<f64>(), cmp.trim().parse::<f64>()) {
(Ok(a), Ok(b)) => a.partial_cmp(&b),
@@ -134,7 +135,7 @@ fn keyword(instr: &str) -> String {
fn act(s: &Session, instr: &str, row: usize) -> Option<Act> {
let t = instr.trim();
if let Some(n) = mergefield_name(t) {
return Some(Act::Text(value(s, row, &n)));
return Some(Act::Text(wordcraft_layout::fields::apply_case_switch(t, value(s, row, &n))));
}
Some(match keyword(t).as_str() {
"ADDRESSBLOCK" => Act::Text(address_block(s, row)),
+27
View File
@@ -147,6 +147,33 @@ fn merge_field_types_ignore_case() {
assert_eq!(s.doc.plain_text(StoryRef::Body), "Alpha\nBeta (b)");
}
/// A merge field's capitalization switch (`\* Upper`, `\* Lower`, `\* Caps`, `\* FirstCap`)
/// applies to the record's value in Preview Results and Finish & Merge.
#[test]
fn merge_fields_apply_their_capitalization_switch() {
let mut s = Session::new(Document::new());
s.run("mailings.recipients", &json!({"rows": [{"City": "new york", "Name": "ADA lovelace"}]})).unwrap();
s.run("insert.field", &json!({"instr": r"MERGEFIELD City \* Upper \* MERGEFORMAT", "result": ""})).unwrap();
s.run("text.insert", &json!({"text": " "})).unwrap();
s.run("insert.field", &json!({"instr": r#"MERGEFIELD "Name" \* Lower"#, "result": ""})).unwrap();
s.run("mailings.preview", &json!({"value": true})).unwrap();
assert_eq!(s.doc.plain_text(StoryRef::Body), "NEW YORK ada lovelace");
s.run("mailings.finish", &json!({})).unwrap();
assert_eq!(s.doc.plain_text(StoryRef::Body), "NEW YORK ada lovelace");
}
/// An IF, NEXTIF or SKIPIF compares the tested merge field after its capitalization switch.
#[test]
fn rule_conditions_apply_the_tested_fields_capitalization_switch() {
let mut s = Session::new(Document::new());
s.run("mailings.recipients", &json!({"rows": [{"City": "new york"}, {"City": "paris"}]})).unwrap();
s.run("insert.field", &json!({"instr": r#"IF { MERGEFIELD City \* Upper } = "NEW YORK" "match" "other""#, "result": ""})).unwrap();
s.run("mailings.preview", &json!({"value": true})).unwrap();
assert_eq!(s.doc.plain_text(StoryRef::Body), "match");
s.run("mailings.next", &json!({})).unwrap();
assert_eq!(s.doc.plain_text(StoryRef::Body), "other");
}
/// An IF is a merge rule only when the field it tests is a MERGEFIELD: the word in a quoted
/// value doesn't make `IF { PAGE } = "mergefield" …` one.
#[test]
+1 -1
View File
@@ -22,7 +22,7 @@ pub fn specs() -> Vec<CommandSpec> {
vec![
CommandSpec::new("file.options", "Options", "File", options)
.params(
r#"{"pane"?: "general|display|proofing|save|language|accessibility|advanced|agents", "author"?: string, "initials"?: string, "units"?: "inches|centimeters|millimeters|points|picas|auto" (auto: the region's), "region"?: string (a locale tag like pl-PL, saved: the paper File › New starts on, the default units and the decimal separator; auto: the system's), "typingReplacesSelection"?: bool, "insertKeyOvertype"?: bool, "overtype"?: bool, "marks"?: {"tabs"?: bool, "spaces"?: bool, "paragraphs"?: bool, "hidden"?: bool}, "checkSpelling"?: bool, "markGrammar"?: bool, "ignoreUppercase"?: bool, "ignoreNumbers"?: bool, "ignoreInternet"?: bool, "dictionariesFolder"?: string (a folder of Hunspell .aff/.dic files searched first, saved; auto: the system locations only), "userTemplatesFolder"?: string (the folder File › New lists personal templates from, saved; auto: the app's own Templates folder; not a network folder), "addWords"?: [string], "removeWords"?: [string]} — with any setting it changes them and opens nothing; without, it opens File › Options (at `pane`). Returns the settings."#,
r#"{"pane"?: "general|display|proofing|save|language|accessibility|advanced|agents", "author"?: string, "initials"?: string, "units"?: "inches|centimeters|millimeters|points|picas|auto" (auto: the region's), "region"?: string (a locale tag like pl-PL, saved: the paper File › New starts on, the default units and the decimal separator; auto: the system's), "typingReplacesSelection"?: bool, "insertKeyOvertype"?: bool, "overtype"?: bool, "marks"?: {"tabs"?: bool, "spaces"?: bool, "paragraphs"?: bool, "hidden"?: bool}, "checkSpelling"?: bool, "markGrammar"?: bool, "ignoreUppercase"?: bool, "ignoreNumbers"?: bool, "ignoreInternet"?: bool, "dictionariesFolder"?: string (a folder of Hunspell .aff/.dic files searched first, saved; auto: clear the configured folder), "userTemplatesFolder"?: string (the folder File › New lists personal templates from, saved; auto: the app's own Templates folder; not a network folder), "addWords"?: [string], "removeWords"?: [string]} — with any setting it changes them and opens nothing; without, it opens File › Options (at `pane`). Returns the settings."#,
)
.pure(),
CommandSpec::new("text.overtype", "Overtype", "File › Options › Advanced", |s, v| {
+2 -1
View File
@@ -274,7 +274,8 @@ pub fn specs() -> Vec<CommandSpec> {
st.quick = on;
}
sel_result(s)
}),
})
.params(r#"{"style": string (name or id), "value"?: bool (default true)}"#),
// Advanced paragraph tools (#5043, as in WPS Office): conversions and cleanup over the
// selection, or the whole document with `scope: "all"`. One undo step per command.
CommandSpec::new("para.convertBreaks", "Convert Line Breaks to Paragraphs", "Home › Paragraph › Paragraph Tools", convert_breaks)
+4 -2
View File
@@ -22,7 +22,7 @@ const MODES: [&str; 5] = ["none", "readOnly", "comments", "trackedChanges", "for
pub fn specs() -> Vec<CommandSpec> {
vec![
CommandSpec::new("review.restrict", "Restrict Editing", "Review › Protect", restrict).params(
r#"{"mode"?: "none|readOnly|comments|trackedChanges|forms" (start enforcing; "none" stops), "formatting"?: bool (limit formatting to unlocked styles), "lockedStyles"?: [style id or name] (the styles that can't be applied; every other style is unlocked), "password"?: string (set when enforcing; required to stop a password-protected document), "stop"?: bool, "exception"?: "add" (the selection stays editable for everyone) | "remove" (exceptions touching the selection) | "removeAll"} → state"#,
r#"{"mode"?: "none|readOnly|comments|trackedChanges|forms" (editing restriction; use "none" with "formatting": true for formatting-only protection), "formatting"?: bool (limit formatting to unlocked styles), "lockedStyles"?: [style id or name] (the styles that can't be applied; every other style is unlocked), "password"?: string (set when enforcing; required to stop a password-protected document), "stop"?: bool (true: stop protection), "exception"?: "add" (the selection stays editable for everyone) | "remove" (exceptions touching the selection) | "removeAll"} → state"#,
),
]
}
@@ -431,7 +431,8 @@ enum HoleMode {
/// run formatting and paragraph formatting outside the ranges `author` may edit, in every story,
/// and the formatting of every table, row and cell that holds any of that protected content, and what
/// reaches the whole document: page setup, the document defaults and the existing styles
/// (applying a style may add one), the document's settings and its metadata.
/// (applying a style may add one), the glossary's building blocks, the document's settings and
/// its metadata.
pub(crate) fn outside_unchanged(before: &Document, after: &Document, author: &str) -> bool {
// Protection can't change mid-command (`protection_lifted` guards undo and redo).
let mode = if Some("forms") == before.settings.protection.as_deref() { HoleMode::Controls } else { HoleMode::Perms(author.into()) };
@@ -444,6 +445,7 @@ pub(crate) fn outside_unchanged(before: &Document, after: &Document, author: &st
&& before.settings == after.settings
&& before.core == after.core
&& before.custom_props == after.custom_props
&& before.glossary == after.glossary
&& comments_unchanged(before, after)
&& lists_unchanged(before, after)
&& sources_unchanged(before, after)
+17
View File
@@ -428,6 +428,23 @@ fn the_post_check_compares_the_settings_and_the_metadata() {
assert!(super::outside_unchanged(&before, &before.clone(), "someone"), "an unchanged document isn't unchanged");
}
/// The glossary's building blocks reach the whole document, so the post-check compares them.
#[test]
fn the_post_check_compares_the_glossary() {
use wordcraft_doc::{BuildingBlock, CharProps, Paragraph};
let mut before = Document::from_text("Some text.");
before.glossary.push(BuildingBlock {
name: "g".into(),
blocks: vec![wordcraft_doc::para_block(Paragraph::with_text("Block", Default::default()))],
..Default::default()
});
assert!(super::outside_unchanged(&before, &before.clone(), "someone"), "an unchanged glossary is unchanged");
let mut after = before.clone();
after.glossary[0].blocks[0] =
wordcraft_doc::para_block(Paragraph::with_text("Block", CharProps { lang: Some("fr-FR".into()), ..Default::default() }));
assert!(!super::outside_unchanged(&before, &after, "someone"), "a relanguaged building block is a change");
}
/// Read only, no exceptions: going to a header the document doesn't have doesn't create
/// one, and loading or filtering recipients doesn't rewrite the merge fields' shown results
/// (both used to change the document from a non-mutating command, #1327).
+1 -1
View File
@@ -32,7 +32,7 @@ use toc::{insert_toc, remove_toc, toc_range};
pub fn specs() -> Vec<CommandSpec> {
vec![
CommandSpec::new("references.toc", "Table of Contents", "References › Table of Contents", insert_toc).params(
r#"{"levels"?: 1-9, "title"?: string, "pageNumbers"?: bool, "rightAlign"?: bool, "tabLeader"?: "dot|hyphen|underscore|none", "hyperlinks"?: bool, "headingStyles"?: bool, "outlineLevels"?: bool, "tcFields"?: bool, "styleLevels"?: {style name: 1-9}} (replaces an existing table; {} updates it)"#,
r#"{"levels"?: 1-9, "title"?: string (at most 1024 characters), "pageNumbers"?: bool, "rightAlign"?: bool, "tabLeader"?: "dot|hyphen|underscore|none", "hyperlinks"?: bool, "headingStyles"?: bool, "outlineLevels"?: bool, "tcFields"?: bool, "styleLevels"?: {style name: 1-9}} (replaces an existing table; {} updates it)"#,
),
CommandSpec::new("references.updateToc", "Update Table", "References › Table of Contents", |s, _| {
update_toc(s)?;
+12
View File
@@ -1,6 +1,18 @@
use super::properties::{new_property_value, text_result};
use super::*;
#[test]
fn a_toc_title_is_capped() {
let mut s = Session::new(wordcraft_doc::Document::new());
let before = s.doc.body.len();
let long = "x".repeat(super::toc::MAX_TOC_TITLE + 1);
let r = s.run("references.toc", &json!({"title": long}));
assert!(matches!(r, Err(crate::CmdError::Params(_))), "{r:?}");
assert_eq!(s.doc.body.len(), before, "a rejected title changes nothing");
let at_cap = "x".repeat(super::toc::MAX_TOC_TITLE);
s.run("references.toc", &json!({"title": at_cap})).unwrap();
}
fn fields(s: &Session) -> Vec<(String, String)> {
let mut out = Vec::new();
for path in s.doc.para_paths(StoryRef::Body) {
+40 -10
View File
@@ -3,6 +3,18 @@ use super::{
StoryRef, TabAlign, TabLeader, TabStop, Value, delete_selection, p, sel_result,
};
/// A table-of-contents title is a heading, not document body: longer titles are rejected
/// instead of laying out megabytes of text (#3720).
pub(super) const MAX_TOC_TITLE: usize = 1024;
fn checked_title(v: &Value) -> Result<Option<&str>, CmdError> {
let Some(title) = p::str(v, "title") else { return Ok(None) };
if title.chars().count() > MAX_TOC_TITLE {
return Err(CmdError::Params(format!("`title` is longer than {MAX_TOC_TITLE} characters")));
}
Ok(Some(title))
}
/// A level range such as `1-3` (or one level, `2`), clamped to 1–9.
pub fn level_range(s: &str) -> Option<(u8, u8)> {
let mut it = s.split('-').map(|x| x.trim().parse::<u8>().ok());
@@ -67,13 +79,15 @@ pub fn toc_instr(v: &Value) -> String {
s
}
/// A TOC entry: the paragraph it points at, its level (0-based), its text, and the leading page
/// breaks of that paragraph (its page is where the text after them lands).
/// A TOC entry: the paragraph it points at, its level (0-based), its text, the leading page
/// breaks of that paragraph (its page is where the text after them lands), and, for a number
/// followed by a tab, how far the heading's text starts after where its number starts.
struct TocEntry {
path: Path,
level: u8,
text: String,
lead: usize,
number_gap: Option<f32>,
}
/// The headings of the body, in document order, as (body block, level 1–9, text, leading page
@@ -117,9 +131,13 @@ fn toc_entries(s: &Session, f: &FieldCode) -> Vec<TocEntry> {
.and_then(|n| counters.next_label(&s.doc.numbering, n.num, n.level))
.filter(|(label, def)| !label.is_empty() && !matches!(def.format, NumFormat::Bullet | NumFormat::None))
.map(|(label, def)| match def.suffix {
LevelSuffix::Tab => format!("{label}\t"),
LevelSuffix::Space => format!("{label} "),
LevelSuffix::Nothing => label,
LevelSuffix::Tab => {
let start = def.indent - def.hanging;
let gap = def.tab.filter(|t| *t > start).unwrap_or(def.indent) - start;
(format!("{label}\t"), Some(gap).filter(|g| g.is_finite() && *g > 0.0))
}
LevelSuffix::Space => (format!("{label} "), None),
LevelSuffix::Nothing => (label, None),
});
let style = p.props.style.as_deref().unwrap_or("Normal");
if style.starts_with("TOC") {
@@ -144,8 +162,9 @@ fn toc_entries(s: &Session, f: &FieldCode) -> Vec<TocEntry> {
if let Some(l) = by_style.or(by_outline).or(if hidden { None } else { by_heading }) {
let t = p.plain_text().replace(['\u{000C}', '\n', '\t'], " ").trim().to_string();
if !t.is_empty() {
let text = number.map_or_else(|| t.clone(), |n| format!("{n}{t}"));
v.push(TocEntry { path: path.clone(), level: l - 1, text, lead });
let text = number.as_ref().map_or_else(|| t.clone(), |(n, _)| format!("{n}{t}"));
let number_gap = number.as_ref().and_then(|(_, g)| *g);
v.push(TocEntry { path: path.clone(), level: l - 1, text, lead, number_gap });
}
}
if let Some(id) = &tc {
@@ -159,7 +178,7 @@ fn toc_entries(s: &Session, f: &FieldCode) -> Vec<TocEntry> {
let l = c.arg('l').and_then(|l| l.trim().parse::<u8>().ok()).unwrap_or(1).clamp(1, 9);
let text = c.args.first().map(|t| t.trim().to_string()).unwrap_or_default();
if (id.is_empty() || *id == kind) && (tc_levels.0..=tc_levels.1).contains(&l) && !text.is_empty() {
v.push(TocEntry { path: path.clone(), level: l - 1, text, lead: off });
v.push(TocEntry { path: path.clone(), level: l - 1, text, lead: off, number_gap: None });
}
}
}
@@ -375,6 +394,7 @@ pub(super) fn cached_toc_tabs(s: &Session) -> Vec<(String, Vec<TabStop>)> {
}
pub(super) fn insert_toc(s: &mut Session, v: &Value) -> CmdResult {
let title = checked_title(v)?.unwrap_or("Contents").to_string();
let tabs = cached_toc_tabs(s);
range_toc_to_field(s)?;
let replace = v.as_object().is_some_and(|m| !m.is_empty());
@@ -403,7 +423,6 @@ pub(super) fn insert_toc(s: &mut Session, v: &Value) -> CmdResult {
}
None => delete_selection(s)?,
};
let title = p::str(v, "title").unwrap_or("Contents").to_string();
if at.story != StoryRef::Body || at.path.depth() > 0 {
return Err(CmdError::Failed("a table of contents goes in the main text".into()));
}
@@ -433,6 +452,7 @@ pub(super) fn insert_toc(s: &mut Session, v: &Value) -> CmdResult {
/// (`title_above_break`): the field takes `v`'s settings, the title `v`'s `title` if one is given
/// (otherwise it is kept, as Word's Insert Table of Contents keeps it), and the entries are rebuilt.
fn replace_toc_above_break(s: &mut Session, v: &Value, start: usize, tabs: &[(String, Vec<TabStop>)]) -> Result<(), CmdError> {
let new_title = checked_title(v)?;
let instr = toc_instr(v);
let field = s.doc.para_mut(StoryRef::Body, &Path::top(start))?;
for o in &mut field.objects {
@@ -446,7 +466,7 @@ fn replace_toc_above_break(s: &mut Session, v: &Value, start: usize, tabs: &[(St
}
}
field.touch();
if let (Some(title), Some(i)) = (p::str(v, "title"), start.checked_sub(1)) {
if let (Some(title), Some(i)) = (new_title, start.checked_sub(1)) {
let old = s.doc.para_mut(StoryRef::Body, &Path::top(i))?;
let mut head = Paragraph::with_text(title, old.props_of_char(0).clone());
head.props = old.props.clone();
@@ -595,6 +615,16 @@ fn regenerate_toc(s: &mut Session, leader: Option<TabLeader>, tabs: &[(String, V
para.mark = CharProps::default();
if e.text.contains('\t') {
para.props.tabs = tabs.iter().find(|(style, _)| Some(style) == para.props.style.as_ref()).map(|(_, tabs)| tabs.clone());
// Without a stop for the number (LibreOffice's Contents styles have only the page
// number's right stop), its tab would run to the page number: the entry gets a
// left stop as far after its indent as the heading's text is after its number.
let style = s.doc.styles.resolve_para(&para.props);
let has_stop =
style.tabs.iter().any(|t| t.pos < width - 1.0 && matches!(t.align, TabAlign::Left | TabAlign::Center | TabAlign::Decimal));
if let (None, false, Some(gap)) = (&para.props.tabs, has_stop, e.number_gap) {
let pos = style.indent_left.max(0.0) + gap;
para.props.tabs = (pos < width - 1.0).then(|| vec![TabStop { pos, align: TabAlign::Left, leader: TabLeader::None }]);
}
}
if show_page && sep.contains('\t') {
let right = TabStop { pos: width - 0.5, align: TabAlign::Right, leader };
+4 -4
View File
@@ -28,12 +28,12 @@ pub fn specs() -> Vec<CommandSpec> {
vec![
CommandSpec::new("review.newComment", "New Comment", "Review › Comments", new_comment).key(super::mac_or("Mod+Alt+A / Mod+Alt+M", "Mod+Alt+M")).params(r#"{"text": string}"#),
CommandSpec::new("review.reply", "Reply", "Review › Comments", reply)
.params(r#"{"id": non-negative JSON integer, "text": string}"#)
.params(r#"{"id": non-negative 32-bit JSON integer, "text": string}"#)
.when(comments_change),
CommandSpec::new("review.editComment", "Edit Comment", "Review › Comments", edit_comment)
.params(r#"{"id": non-negative JSON integer, "text": string}"#)
.params(r#"{"id": non-negative 32-bit JSON integer, "text": string}"#)
.when(comments_change),
CommandSpec::new("review.deleteComment", "Delete", "Review › Comments", delete_comment).params(r#"{"id"?: non-negative JSON integer (omit to use the caret), "all"?: bool}"#),
CommandSpec::new("review.deleteComment", "Delete", "Review › Comments", delete_comment).params(r#"{"id"?: non-negative 32-bit JSON integer (omit to use the caret), "all"?: bool}"#),
CommandSpec::new("review.resolveComment", "Resolve", "Review › Comments", |s, v| {
validate_comment_id(v)?;
let id = p::u64(v, "id").map(|x| x as u32).or_else(|| comment_at_caret(s)).ok_or_else(|| CmdError::Params("`id` required".into()))?;
@@ -41,7 +41,7 @@ pub fn specs() -> Vec<CommandSpec> {
c.resolved = p::bool(v, "value").unwrap_or(!c.resolved);
sel_result(s)
})
.params(r#"{"id"?: non-negative JSON integer (omit to use the caret), "value"?: bool (omit to toggle)}"#),
.params(r#"{"id"?: non-negative 32-bit JSON integer (omit to use the caret), "value"?: bool (omit to toggle)}"#),
CommandSpec::new("review.nextComment", "Next", "Review › Comments", |s, _| nav_comment(s, 1)).pure(),
CommandSpec::new("review.previousComment", "Previous", "Review › Comments", |s, _| nav_comment(s, -1)).pure(),
CommandSpec::new("review.comments", "Show Comments", "Review › Comments", list_comments).pure(),
+86 -3
View File
@@ -1,4 +1,5 @@
use super::{Arc, CmdError, CmdResult, Document, Pos, Selection, Session, StoryRef, Value, delete_selection, json, p, sel_result};
use wordcraft_doc::CharProps;
/// Options › Language › Set as default: only the saved default proofing language (what future
/// blank documents are written in), as Word's Set as Preferred. A setting, like `file.options`: the
@@ -14,8 +15,19 @@ pub(super) fn preferred_language(s: &mut Session, v: &Value) -> CmdResult {
/// Set Proofing Language: the selection's language and "do not check spelling or grammar",
/// or (`default`) the document's default and the saved language for future blank documents;
/// `detect` is the per-user detection preference.
/// Nothing at all sets US English, as before.
/// Nothing at all sets US English, as before. `scope: "document"` sets it for every story.
pub(super) fn language(s: &mut Session, v: &Value) -> CmdResult {
// Checked first, so a bad scope changes nothing (not even the detect preference).
let whole_document = match v.get("scope") {
None | Some(Value::Null) => false,
Some(Value::String(t)) if t == "selection" => false,
Some(Value::String(t)) if t == "document" => true,
Some(other) => return Err(CmdError::Params(format!("`scope` must be \"selection\" or \"document\", not {other}"))),
};
// Protection leaves only its exceptions editable, so the whole document can't be one.
if whole_document && let Some(mode) = s.doc.settings.protection.as_deref() {
return Err(CmdError::Disabled(format!("review.language: stop protection ({mode}) before changing the whole document's proofing language")));
}
let lang = match p::str(v, "lang") {
Some(t) => Some(
wordcraft_proof::lang::normalize_tag(t)
@@ -45,20 +57,91 @@ pub(super) fn language(s: &mut Session, v: &Value) -> CmdResult {
if lang.is_none() && no_proof.is_none() {
return Ok(json!({"detect": s.prefs.detect_language}));
}
let result = crate::cmd::format::apply(s, &|c| {
let change = |c: &mut CharProps| {
if let Some(l) = &lang {
c.lang = Some(l.clone());
}
if let Some(np) = no_proof {
c.no_proof = Some(np);
}
})?;
};
let result = if whole_document {
let glossary_skipped = set_document_props(s, &change)?;
// The same caret/selection result as the selection path (the selection is untouched).
let mut r = sel_result(s)?;
if let Some(m) = r.as_object_mut() {
m.insert("scope".into(), json!("document"));
if glossary_skipped {
m.insert("glossarySkipped".into(), json!(true));
}
}
r
} else {
crate::cmd::format::apply(s, &change)?
};
if p::bool(v, "default") == Some(true) {
s.prefs.default_language = lang;
}
Ok(result)
}
/// Apply `f` to the character formatting of every story of the document (Language dialog, "Apply
/// to the whole document"): text and paragraph marks of the body, headers, footers, notes,
/// comments, text boxes (all `Document::parts`), table cells, and the glossary's building blocks.
/// The selection is untouched; formatting waiting for typing follows.
///
/// Glossary blocks are left alone while Track Changes and Track Formatting are both on: tracked
/// formatting (`fmt_revisions::record`) compares only the body and the parts, so a glossary change
/// would be an untracked edit. So those blocks keep their old language while tracking; the caller
/// reports it (`glossarySkipped`). Returns whether the glossary was skipped.
fn set_document_props(s: &mut Session, f: &dyn Fn(&mut CharProps)) -> Result<bool, CmdError> {
let stories: Vec<StoryRef> = std::iter::once(StoryRef::Body).chain(s.doc.parts.keys().map(|k| StoryRef::Part(*k))).collect();
for story in stories {
for path in s.doc.para_paths(story) {
let para = s.doc.para_mut(story, &path)?;
let len = para.len();
para.format(0, len, f)?;
f(&mut para.mark);
para.touch();
}
}
let skipped = s.doc.settings.track_changes && s.prefs.markup.track_formatting;
if !skipped {
for block in &mut s.doc.glossary {
format_blocks(&mut block.blocks, f, 0);
}
}
if let Some(pend) = s.pending.as_mut() {
f(pend);
}
Ok(skipped)
}
/// [`set_document_props`] for a block list outside any story (depth-limited like `para_paths`).
fn format_blocks(blocks: &mut wordcraft_doc::Blocks, f: &dyn Fn(&mut CharProps), depth: usize) {
if depth > wordcraft_doc::PARA_WALK_DEPTH {
return;
}
for blk in blocks.iter_mut() {
match Arc::make_mut(blk) {
wordcraft_doc::Block::Para(p) => {
let len = p.len();
// A range inside the paragraph can't fail; the mark is formatted regardless.
let _ = p.format(0, len, f);
f(&mut p.mark);
p.touch();
}
wordcraft_doc::Block::Table(t) => {
for row in &mut t.rows {
for cell in &mut row.cells {
format_blocks(&mut cell.blocks, f, depth + 1);
}
}
}
}
}
}
pub(super) fn macros(s: &mut Session, v: &Value) -> CmdResult {
if let Some(d) = v.get("define") {
let name = d.get("name").and_then(Value::as_str).unwrap_or("Macro").to_string();
+135 -26
View File
@@ -34,6 +34,7 @@ struct DiffCtx<'a> {
opts: &'a CompareOptions,
budget: &'a mut u64,
char_fallbacks: &'a mut usize,
plain_revised: bool,
}
/// Changed paragraphs longer than this (in characters) are compared word by word even at
@@ -48,10 +49,12 @@ const MAX_CHAR_DIFF: usize = 2000;
/// [`MAX_CHAR_DIFF`] characters, it falls back to word-level diff for that paragraph, surfaces the
/// fallback count in `"characterFallback"`, and includes `"level"` in `"notHonoured"`.
pub(super) fn compare(s: &mut Session, v: &Value) -> CmdResult {
let revised = if let Some(t) = p::str(v, "text") {
Document::from_text(t)
// A revised side given as plain text carries no real runs or properties; one opened from a
// path does. The diff takes the revised formatting only in the latter case.
let (revised, plain_revised) = if let Some(t) = p::str(v, "text") {
(Document::from_text(t), true)
} else if let Some(path) = p::str(v, "path") {
crate::io::open_path(std::path::Path::new(path)).map_err(CmdError::Failed)?
(crate::io::open_path(std::path::Path::new(path)).map_err(CmdError::Failed)?, false)
} else {
return Err(CmdError::Params("`path` or `text` of the revised document is required".into()));
};
@@ -97,7 +100,7 @@ pub(super) fn compare(s: &mut Session, v: &Value) -> CmdResult {
let mut budget = MAX_COMPARE_CELLS;
let mut char_fallbacks = 0usize;
let ops = lcs_ops(&old.iter().map(key).collect::<Vec<_>>(), &new.iter().map(key).collect::<Vec<_>>(), &mut budget);
let mut ctx = DiffCtx { ins, del, opts: &opts, budget: &mut budget, char_fallbacks: &mut char_fallbacks };
let mut ctx = DiffCtx { ins, del, opts: &opts, budget: &mut budget, char_fallbacks: &mut char_fallbacks, plain_revised };
let mut out: Vec<Arc<Block>> = Vec::new();
let (mut i, mut j) = (0usize, 0usize);
let mut changes = 0usize;
@@ -393,9 +396,11 @@ fn flatten_region(out: &mut Vec<Op>, region: &[(Op, usize, Kind)]) {
/// A token of a changed paragraph: a word (or character), or an inline object without text
/// of its own (a text box anchor, a picture, a bookmark…), which is compared and kept whole.
/// Each token also carries the byte range it came from in its source paragraph, so the output
/// segment can take the formatting of the run it came from instead of the paragraph's first run.
enum Tok<'a> {
Text(String),
Obj(&'a InlineObject),
Text(String, std::ops::Range<usize>),
Obj(&'a InlineObject, std::ops::Range<usize>),
}
/// What a comparison sees of a token: the text as the options say, an object with the text of
@@ -421,52 +426,131 @@ fn same_objects(doc: &Document, a: &Paragraph, b: &Paragraph) -> bool {
}
/// Words with the spaces after them ("The ", "cat "), or single characters, and the objects
/// between them. Objects with text (fields, equations…) count as their text.
/// between them. Objects with text (fields, equations…) count as their text. Each token records
/// the byte range it came from in `p`, so its output segment can take that source run's
/// formatting. An object's flattened text (or a broken marker's placeholder) maps to the marker's
/// own range, which is the nearest formatting the object has.
fn tokens(p: &Paragraph, characters: bool) -> Vec<Tok<'_>> {
fn push(v: &mut Vec<Tok<'_>>, cur: &mut String, c: char, characters: bool) {
fn push(v: &mut Vec<Tok<'_>>, cur: &mut String, start: usize, end: usize, c: char, characters: bool) {
cur.push(c);
if characters || c == ' ' {
v.push(Tok::Text(std::mem::take(cur)));
v.push(Tok::Text(std::mem::take(cur), start..end));
}
}
let mut v = Vec::new();
let mut cur = String::new();
let mut cur_start = 0usize;
let mut objects = p.objects.iter();
for c in p.text.chars() {
for (i, c) in p.text.char_indices() {
let marker = i..i + OBJ.len_utf8();
if c != OBJ {
push(&mut v, &mut cur, c, characters);
if cur.is_empty() {
cur_start = i;
}
push(&mut v, &mut cur, cur_start, i + c.len_utf8(), c, characters);
continue;
}
match objects.next() {
Some(o) if o.plain_text().is_empty() => {
if !cur.is_empty() {
v.push(Tok::Text(std::mem::take(&mut cur)));
v.push(Tok::Text(std::mem::take(&mut cur), cur_start..i));
}
v.push(Tok::Obj(o, marker));
}
Some(o) => {
for c in o.plain_text().chars() {
if cur.is_empty() {
cur_start = i;
}
push(&mut v, &mut cur, cur_start, marker.end, c, characters);
}
v.push(Tok::Obj(o));
}
Some(o) => o.plain_text().chars().for_each(|c| push(&mut v, &mut cur, c, characters)),
None => {
// A marker without its object (a broken paragraph): kept as a visible
// placeholder, so the loss shows in the result instead of vanishing.
log::warn!("compare: an object marker without its object");
push(&mut v, &mut cur, char::REPLACEMENT_CHARACTER, characters);
if cur.is_empty() {
cur_start = i;
}
push(&mut v, &mut cur, cur_start, marker.end, char::REPLACEMENT_CHARACTER, characters);
}
}
}
if !cur.is_empty() {
v.push(Tok::Text(cur));
v.push(Tok::Text(cur, cur_start..p.text.len()));
}
v
}
/// One side's run formatting for `word_diff`: the paragraph's run ranges (from
/// [`Paragraph::run_ranges`]), walked with a forward cursor. `word_diff` consumes each side's
/// tokens in increasing offset order, so the cursor makes a token's lookup amortised O(1)
/// instead of rescanning the runs from the start for every token; an out-of-order offset falls
/// back to a binary search, so the lookup stays correct for any offset.
struct SideProps<'a> {
ranges: Vec<(std::ops::Range<usize>, &'a CharProps)>,
mark: &'a CharProps,
cursor: usize,
}
impl<'a> SideProps<'a> {
fn new(p: &'a Paragraph) -> Self {
SideProps { ranges: p.run_ranges().collect(), mark: &p.mark, cursor: 0 }
}
/// The props of the run holding byte `off`: that run's props, or the paragraph mark when
/// `off` is past the last run — the same answer `Paragraph::props_of_char` gives.
fn run_props(&mut self, off: usize) -> &'a CharProps {
while self.cursor < self.ranges.len() && self.ranges[self.cursor].0.end <= off {
self.cursor += 1;
}
if let Some((range, props)) = self.ranges.get(self.cursor)
&& range.contains(&off)
{
return props;
}
let idx = self.ranges.partition_point(|(r, _)| r.start <= off);
match idx.checked_sub(1).and_then(|i| self.ranges.get(i)) {
Some((range, props)) if range.contains(&off) => props,
_ => self.mark,
}
}
/// The formatting of the source run a token came from: the run holding the token's first
/// byte, with the revision metadata stripped. `ins`, `del` and `fmt_change` are indices into
/// the *source* document's own revision table, and the rebuilt paragraph lives in the result
/// document, whose table is a different one, so a source mark can never be carried across;
/// `word_diff` stamps the compare's own `ins`/`del` on the segments it marks. The consequence
/// is plain: a pre-existing pending revision inside a changed paragraph (say another author's
/// deletion) is superseded by the compare result rather than preserved. The hyperlink is
/// kept, because Reject restores it on a deleted run (at token granularity: the link is taken
/// from the token's first byte, so a token that starts unlinked can lose a mid-token link).
fn props_of(&mut self, t: &Tok<'_>) -> CharProps {
let off = match t {
Tok::Text(_, range) | Tok::Obj(_, range) => range.start,
};
let c = self.run_props(off);
CharProps { ins: None, del: None, fmt_change: None, ..c.clone() }
}
}
/// The props of an output token: those of the source run it came from, or — never expected, since
/// [`tokens`] and [`lcs_ops`] consume both sides in step — the given fallback. A miss is loud.
fn output_props(side: &mut SideProps<'_>, t: Option<&Tok<'_>>, fallback: &CharProps) -> CharProps {
if t.is_none() {
log::warn!("compare: a token range lookup missed; `tokens` and `lcs_ops` are out of step");
}
t.map(|t| side.props_of(t)).unwrap_or_else(|| fallback.clone())
}
/// Add a token at the end of `p` with `props`.
fn put(p: &mut Paragraph, t: Option<&Tok<'_>>, props: &CharProps) {
let at = p.len();
match t {
Some(Tok::Text(t)) => {
Some(Tok::Text(t, _)) => {
let _ = p.insert_text(at, t, props);
}
Some(Tok::Obj(o)) => {
Some(Tok::Obj(o, _)) => {
let _ = p.insert_object(at, (*o).clone(), props);
}
None => {}
@@ -500,10 +584,12 @@ fn word_diff(doc: &Document, a: &Paragraph, b: &Paragraph, ctx: &mut DiffCtx<'_>
} else {
false
};
let plain_revised = ctx.plain_revised;
let (ta, tb) = (tokens(a, chars), tokens(b, chars));
let (mut a_props, mut b_props) = (SideProps::new(a), SideProps::new(b));
let key = |t: &Tok<'_>| match t {
Tok::Text(t) => Key::Text(ctx.opts.key(t)),
Tok::Obj(o) => obj_key(doc, o),
Tok::Text(t, _) => Key::Text(ctx.opts.key(t)),
Tok::Obj(o, _) => obj_key(doc, o),
};
let ops = lcs_ops(&ta.iter().map(key).collect::<Vec<_>>(), &tb.iter().map(key).collect::<Vec<_>>(), ctx.budget);
// Only at character granularity: a matched whole word almost never happens by coincidence,
@@ -511,23 +597,46 @@ fn word_diff(doc: &Document, a: &Paragraph, b: &Paragraph, ctx: &mut DiffCtx<'_>
// a short interior match need folding back into its surrounding edit.
let ops = if chars { collapse_noise_matches(&ops) } else { ops };
let mut p = Paragraph::new();
p.props = b.props.clone();
let base = a.runs.first().map(|r| r.props.clone()).unwrap_or_default();
// The revised paragraph's properties are used with its revision bookkeeping stripped, like runs
// (`SideProps::props_of`) and the mark, because `fmt_change`/`num_change` are indices into the revised
// document's own revision table and are meaningless in the result document. A plain-text
// revised side, which carries no paragraph properties of its own, falls back to the original's,
// stripped the same way, so pre-existing revision state never leaks into the rebuilt paragraph.
p.props = if plain_revised && b.props.is_empty() { a.props.formatting() } else { b.props.formatting() };
// The paragraph mark (the formatting typing into the paragraph's end would get) is the revised
// paragraph's when it comes from a document, and the original's when the revised side is plain
// text and has no mark of its own. Its own revision bookkeeping (`ins`, `del`, `fmt_change`)
// is cleared because those indices belong to another document's revision table.
p.mark = if plain_revised {
CharProps { ins: None, del: None, fmt_change: None, ..a.mark.clone() }
} else {
CharProps { ins: None, del: None, fmt_change: None, ..b.mark.clone() }
};
let fallback = a.runs.first().map(|r| CharProps { ins: None, del: None, fmt_change: None, ..r.props.clone() }).unwrap_or_default();
let fallback_b = b.runs.first().map(|r| CharProps { ins: None, del: None, fmt_change: None, ..r.props.clone() }).unwrap_or_default();
let (mut i, mut j) = (0, 0);
for op in ops {
match op {
Op::Same => {
// Equal as compared (perhaps up to case or spacing): the revised text.
put(&mut p, tb.get(j), &base);
// Equal as compared (perhaps up to case or spacing): the revised text, but the
// formatting of the run it stands for. For a document revised side that is the
// revised run, as issue #3749 prescribes ("Copy unchanged tokens from the revised
// paragraph with their own properties"); a plain-text revised side has no runs to
// speak of, so the original run's formatting is kept instead.
let props =
if plain_revised { output_props(&mut a_props, ta.get(i), &fallback) } else { output_props(&mut b_props, tb.get(j), &fallback_b) };
put(&mut p, tb.get(j), &props);
i += 1;
j += 1;
}
Op::Del => {
put(&mut p, ta.get(i), &CharProps { del: Some(ctx.del), ..base.clone() });
let props = output_props(&mut a_props, ta.get(i), &fallback);
put(&mut p, ta.get(i), &CharProps { del: Some(ctx.del), ..props });
i += 1;
}
Op::Ins => {
put(&mut p, tb.get(j), &CharProps { ins: Some(ctx.ins), ..base.clone() });
let props = tb.get(j).map(|t| b_props.props_of(t)).unwrap_or_else(|| fallback.clone());
put(&mut p, tb.get(j), &CharProps { ins: Some(ctx.ins), ..props });
j += 1;
}
}
+1 -1
View File
@@ -340,7 +340,7 @@ pub fn specs() -> Vec<CommandSpec> {
})
.params(r#"{"format": "decimal|upperRoman|lowerLetter…", "text"?: "%1.", "start"?: n}"#),
CommandSpec::new("review.language", "Language", "Review › Language", language).params(
r#"{"lang"?: "en-US|en-GB|pl-PL|fr-FR|…" (BCP 47; default en-US), "noProof"?: bool, "detect"?: bool (detect language automatically, a preference), "default"?: bool (also the document's default and the saved language for future blank documents)}"#,
r#"{"lang"?: "en-US|en-GB|pl-PL|fr-FR|…" (BCP 47; default en-US), "noProof"?: bool, "detect"?: bool (detect language automatically, a preference), "default"?: bool (also the document's default and the saved language for future blank documents), "scope"?: "selection" (default) | "document" (every run and paragraph mark of every story: body, headers, footers, notes, comments, text boxes, tables, glossary (skipped while Track Changes and Track Formatting are on); one undo step, selection unchanged; returns the caret, "scope":"document" and "glossarySkipped":true when the glossary was skipped)}"#,
),
CommandSpec::new("review.language.preferred", "Set as Default Language", "File › Options › Language", preferred_language)
.params(r#"{"lang": "en-US|en-GB|pl-PL|nl-NL|…" (BCP 47)} — only the saved default proofing language, what future blank documents are written in, as Options › Language › Set as default does; the open document, the selection and the undo history don't change. Returns {"preferred": tag}."#)
+149
View File
@@ -1,5 +1,7 @@
use super::*;
mod compare_stage0;
#[test]
fn compare_marks_changes() {
let mut s = Session::new(Document::from_text("The cat sat.\nKeep this.\nOld line."));
@@ -903,3 +905,150 @@ fn inspect_removals_work_when_the_document_does_not_track_changes() {
assert!(!text.contains("Hidden"), "the hidden text is still there: {text}");
assert!(text.contains("Visible text."), "{text}");
}
/// #3518: every run and paragraph mark of a story, as (story, path, lang, noProof) rows.
fn proofing_rows(s: &Session) -> Vec<(StoryRef, Option<String>, Option<bool>)> {
let stories = std::iter::once(StoryRef::Body).chain(s.doc.parts.keys().map(|k| StoryRef::Part(*k)));
let mut out = Vec::new();
for st in stories {
for path in s.doc.para_paths(st) {
let Some(p) = s.doc.para(st, &path) else { continue };
out.push((st, p.mark.lang.clone(), p.mark.no_proof));
out.extend(p.runs.iter().map(|r| (st, r.props.lang.clone(), r.props.no_proof)));
}
}
out
}
/// A document with its text in German in the body, a table cell, a header, a footnote, a comment
/// and a text box, as a Word DOCX keeps a `w:lang` on each run, plus a glossary entry.
fn multi_story_doc() -> Session {
use wordcraft_doc::{Block, BuildingBlock, CharProps, Paragraph, PartKind, Table};
let de = || CharProps { lang: Some("de-DE".into()), ..Default::default() };
let blk = |t: &str| Arc::new(Block::Para(Paragraph::with_text(t, de())));
let mut d = Document::from_text("Guten Tag");
d.body = vec![blk("Guten Tag")];
let mut t = Table::new(1, 2, 200.0);
if let Some(c) = t.rows.first_mut().and_then(|r| r.cells.first_mut()) {
c.blocks = vec![blk("Zelle")];
}
d.body.push(Arc::new(Block::Table(t)));
d.body.push(blk("Ende"));
for kind in [PartKind::Header, PartKind::Footnote, PartKind::Comment, PartKind::TextBox] {
d.add_part(kind, vec![blk("Teil")]);
}
d.glossary.push(BuildingBlock { name: "g".into(), blocks: vec![blk("Baustein")], ..Default::default() });
Session::new(d)
}
#[test]
fn language_scope_document_sets_every_story() {
let mut s = multi_story_doc();
s.run("select.text", &json!({"text": "Guten"})).unwrap();
let (sel, before) = (s.sel.clone(), s.doc.clone());
let rows = proofing_rows(&s);
assert!(rows.len() >= 10 && rows.iter().any(|r| r.1.as_deref() == Some("de-DE")));
s.run("review.language", &json!({"lang": "fr-FR", "scope": "document"})).unwrap();
// Runs that had their own language, the paragraph marks and the empty cell: all French.
let rows = proofing_rows(&s);
assert!(rows.iter().all(|r| r.1.as_deref() == Some("fr-FR")), "{rows:?}");
for kind_story in s.doc.parts.keys() {
assert!(rows.iter().any(|r| r.0 == StoryRef::Part(*kind_story)));
}
assert!(s.doc.plain_text(StoryRef::Body).contains("Zelle"));
let g = &s.doc.glossary[0].blocks;
assert_eq!(g[0].as_para().map(|p| p.runs[0].props.lang.clone()), Some(Some("fr-FR".into())));
assert_eq!(g[0].as_para().map(|p| p.mark.lang.clone()), Some(Some("fr-FR".into())));
// The selection stays; the document is modified.
assert_eq!(s.sel, sel);
assert!(s.doc != before);
// One undo restores everything.
s.run("edit.undo", &json!({})).unwrap();
assert!(s.doc == before);
assert_eq!(s.sel, sel);
}
#[test]
fn language_scope_document_no_proof_and_pending() {
let mut s = multi_story_doc();
s.run("review.language", &json!({"noProof": true, "scope": "document"})).unwrap();
assert!(proofing_rows(&s).iter().all(|r| r.2 == Some(true)));
// The language itself wasn't asked for and stays.
assert!(proofing_rows(&s).iter().any(|r| r.1.as_deref() == Some("de-DE")));
// Formatting waiting for typing follows.
s.run("format.bold", &json!({})).unwrap();
s.run("review.language", &json!({"lang": "pl-PL", "scope": "document"})).unwrap();
assert_eq!(s.pending.as_ref().and_then(|p| p.lang.as_deref()), Some("pl-PL"));
}
/// Document scope returns the caret/selection like the selection path, plus the scope.
#[test]
fn language_scope_document_returns_the_selection_result() {
let mut s = multi_story_doc();
s.run("select.text", &json!({"text": "Guten"})).unwrap();
let out = s.run("review.language", &json!({"lang": "fr-FR", "scope": "document"})).unwrap();
assert_eq!(out["scope"], "document");
assert_eq!(out["anchor"], crate::cmd::pos_json(&s.sel.anchor), "{out}");
assert_eq!(out["focus"], crate::cmd::pos_json(&s.sel.focus), "{out}");
}
/// Tracked formatting records only the body and parts, so while it is on the glossary (outside
/// any story) is left alone instead of changing untracked; with tracking off it changes.
#[test]
fn language_scope_document_skips_glossary_while_tracking_formatting() {
let gloss = |s: &Session| s.doc.glossary[0].blocks[0].as_para().map(|p| (p.runs[0].props.lang.clone(), p.mark.lang.clone()));
let mut s = multi_story_doc();
s.run("review.trackChanges", &json!({"value": true})).unwrap();
s.run("review.trackingOptions", &json!({"trackFormatting": true})).unwrap();
let out = s.run("review.language", &json!({"lang": "fr-FR", "scope": "document"})).unwrap();
assert_eq!(out["glossarySkipped"], true, "{out}");
assert_eq!(gloss(&s), Some((Some("de-DE".into()), Some("de-DE".into()))));
assert!(proofing_rows(&s).iter().all(|r| r.1.as_deref() == Some("fr-FR")));
assert!(s.doc.revisions.iter().any(|r| r.kind == wordcraft_doc::RevisionKind::Format), "the body change is tracked");
let mut s = multi_story_doc();
s.run("review.trackChanges", &json!({"value": true})).unwrap();
s.run("review.trackingOptions", &json!({"trackFormatting": false})).unwrap();
let out = s.run("review.language", &json!({"lang": "fr-FR", "scope": "document"})).unwrap();
assert!(out.get("glossarySkipped").is_none(), "{out}");
assert_eq!(gloss(&s), Some((Some("fr-FR".into()), Some("fr-FR".into()))));
}
#[test]
fn language_default_scope_is_selection_only() {
let mut s = multi_story_doc();
s.run("select.text", &json!({"text": "Guten"})).unwrap();
s.run("review.language", &json!({"lang": "fr-FR"})).unwrap();
let rows = proofing_rows(&s);
assert!(rows.iter().any(|r| r.1.as_deref() == Some("fr-FR")));
assert!(rows.iter().filter(|r| r.1.as_deref() == Some("fr-FR")).count() < rows.len() / 2);
let mut s = multi_story_doc();
s.run("select.text", &json!({"text": "Guten"})).unwrap();
s.run("review.language", &json!({"lang": "fr-FR", "scope": "selection"})).unwrap();
assert_eq!(proofing_rows(&s), rows);
}
#[test]
fn language_bad_scope_is_a_params_error() {
let mut s = multi_story_doc();
let before = s.doc.clone();
for bad in [json!("everything"), json!(1), json!(true), json!(["document"])] {
let e = s.run("review.language", &json!({"lang": "fr-FR", "detect": false, "scope": bad})).unwrap_err();
assert!(matches!(e, CmdError::Params(_)), "{e:?}");
}
assert!(s.doc == before);
assert!(s.prefs.detect_language);
}
/// Document scope is refused under editing protection, before anything changes.
#[test]
fn language_document_scope_is_refused_under_protection() {
for mode in ["readOnly", "comments", "forms"] {
let mut s = multi_story_doc();
s.doc.settings.protection = Some(mode.into());
let before = s.doc.clone();
let e = s.run("review.language", &json!({"lang": "fr-FR", "detect": false, "scope": "document"})).unwrap_err();
assert!(matches!(e, CmdError::Disabled(_)), "{mode}: {e:?}");
assert!(s.doc == before, "{mode}: nothing changed");
assert!(s.prefs.detect_language, "{mode}: the detect preference is untouched");
}
}
@@ -0,0 +1,349 @@
//! Regression tests for #3749 Stage 0: formatting-preserving compare.
//!
//! `word_diff` carries source byte ranges through tokenization, so every output segment takes its
//! `CharProps` from the run it came from instead of stamping the original paragraph's first run on
//! everything. The revised side decides which run each segment follows: when the revised side is a
//! real document, Same/Ins take the revised run and Del takes the original run; when it is plain
//! text (with no runs of its own), Same/Del take the original run and Ins takes the (default)
//! revised run. The paragraph mark and `ParaProps` follow the revised side for a document, and fall
//! back to the original's for plain text.
//!
//! The ins/del segmentation for text-only paragraphs is unchanged: the goldens below were captured
//! from the pre-fix binary (`review.compare` over a plain original and a plain revised text, word
//! and character level) and must keep matching.
use super::*;
/// A run signature: its text, and whether it is marked inserted / deleted.
fn run_sig(p: &Paragraph) -> Vec<(String, bool, bool)> {
p.run_ranges().map(|(r, c)| (p.text[r].to_string(), c.ins.is_some(), c.del.is_some())).collect()
}
/// The first run whose text contains `needle`.
fn run_with<'a>(p: &'a Paragraph, needle: &str) -> (&'a str, &'a CharProps) {
p.run_ranges()
.find(|(r, _)| p.text[r.clone()].contains(needle))
.map(|(r, c)| (&p.text[r], c))
.unwrap_or_else(|| panic!("no run contains {needle:?} in {:?}", p.text))
}
// --- mixed character formatting -----------------------------------------------------------------
#[test]
fn mixed_formatting_is_preserved_per_range() {
let mut s = Session::new(Document::from_text("alpha beta gamma"));
s.run("select.text", &json!({"text": "alpha"})).unwrap();
s.run("format.bold", &json!({})).unwrap();
s.run("select.text", &json!({"text": "gamma"})).unwrap();
s.run("format.italic", &json!({})).unwrap();
s.run("review.compare", &json!({"text": "alpha delta gamma"})).unwrap();
let p = s.doc.body[0].as_para().unwrap();
// The deleted text stays in the tracked paragraph; the visible result is what Accept shows.
assert_eq!(p.plain_text(), "alpha beta delta gamma");
assert_eq!(p.final_text(), "alpha delta gamma");
let (_, alpha) = run_with(p, "alpha");
assert_eq!(alpha.bold, Some(true), "unchanged `alpha` keeps the original's bold");
assert_ne!(alpha.italic, Some(true));
let (_, gamma) = run_with(p, "gamma");
assert_eq!(gamma.italic, Some(true), "unchanged `gamma` keeps the original's italic");
assert_ne!(gamma.bold, Some(true));
let (_, delta) = run_with(p, "delta");
assert!(delta.ins.is_some(), "inserted `delta` is marked inserted");
assert_ne!(delta.bold, Some(true), "inserted text does not inherit the original's bold");
assert_ne!(delta.italic, Some(true), "inserted text does not inherit the original's italic");
let (_, beta) = run_with(p, "beta");
assert!(beta.del.is_some(), "removed `beta` is marked deleted");
assert_ne!(beta.bold, Some(true));
}
// --- byte-range props lookup --------------------------------------------------------------------
#[test]
fn change_point_on_a_multibyte_char_takes_its_own_run() {
// The change point is the second character, `ä` (2 bytes). The byte-range lookup must land on
// `ä`'s own run; a character count used as a byte offset would land inside the preceding `é`
// and stamp its bold on the deleted `ä`.
let mut s = Session::new(Document::from_text("éä"));
s.run("select.text", &json!({"text": "é"})).unwrap();
s.run("format.bold", &json!({})).unwrap();
s.run("select.text", &json!({"text": "ä"})).unwrap();
s.run("format.italic", &json!({})).unwrap();
s.run("review.compare", &json!({"text": "éö", "level": "character"})).unwrap();
let p = s.doc.body[0].as_para().unwrap();
assert_eq!(p.plain_text(), "éäö", "deleted `ä` and inserted `ö`");
let (_, ae) = run_with(p, "ä");
assert!(ae.del.is_some(), "the changed multi-byte char is deleted");
assert_eq!(ae.italic, Some(true), "it takes its own run");
assert_ne!(ae.bold, Some(true), "and not the preceding multi-byte run's props");
}
#[test]
fn empty_run_at_a_token_start_does_not_shadow_its_props() {
let mut s = Session::new(Document::from_text("alpha beta gamma"));
s.run("select.text", &json!({"text": "beta"})).unwrap();
s.run("format.italic", &json!({})).unwrap();
{
let mut p = s.doc.body[0].as_para().unwrap().clone();
let at = p.text.find("beta").unwrap();
let mut idx = 0usize;
let mut start = 0usize;
for (i, r) in p.runs.iter().enumerate() {
if start == at {
idx = i;
break;
}
start += r.len;
}
// An empty run with different props exactly at "beta"'s start.
p.runs.insert(idx, wordcraft_doc::para::Run { len: 0, props: CharProps { bold: Some(true), ..CharProps::default() } });
s.doc.body[0] = std::sync::Arc::new(Block::Para(p));
}
s.run("review.compare", &json!({"text": "alpha delta gamma"})).unwrap();
let p = s.doc.body[0].as_para().unwrap();
let (_, beta) = run_with(p, "beta");
assert!(beta.del.is_some());
assert_eq!(beta.italic, Some(true), "the token takes the run after the empty one");
assert_ne!(beta.bold, Some(true), "an empty run at the token's start must not shadow the next run's props");
}
// --- hyperlinks ---------------------------------------------------------------------------------
#[test]
fn middle_run_hyperlink_survives_and_reject_restores_it() {
let mut s = Session::new(Document::from_text("click here now"));
s.run("select.text", &json!({"text": "here"})).unwrap();
s.run("insert.link", &json!({"url": "https://example.com"})).unwrap();
s.run("review.compare", &json!({"text": "click there now"})).unwrap();
let p = s.doc.body[0].as_para().unwrap();
let (_, here) = run_with(p, "here");
assert!(here.del.is_some(), "the removed word is deleted");
assert_eq!(here.link.as_deref(), Some("https://example.com"), "the deleted run keeps its hyperlink");
let (_, there) = run_with(p, "there");
assert!(there.ins.is_some());
assert_eq!(there.link, None, "inserted text takes the revised run's formatting (no link)");
s.run("review.rejectAll", &json!({})).unwrap();
assert_eq!(s.doc.plain_text(StoryRef::Body), "click here now");
let p = s.doc.body[0].as_para().unwrap();
let (_, here) = run_with(p, "here");
assert_eq!(here.link.as_deref(), Some("https://example.com"), "Reject restores the hyperlink at token level");
}
#[test]
fn first_run_hyperlink_does_not_leak_onto_inserted_text() {
let mut s = Session::new(Document::from_text("here click now"));
s.run("select.text", &json!({"text": "here"})).unwrap();
s.run("insert.link", &json!({"url": "https://example.com"})).unwrap();
s.run("review.compare", &json!({"text": "here there click now"})).unwrap();
let p = s.doc.body[0].as_para().unwrap();
let (_, here) = run_with(p, "here");
assert_eq!(here.link.as_deref(), Some("https://example.com"), "the unchanged first run keeps its link");
let (_, there) = run_with(p, "there");
assert!(there.ins.is_some());
assert_eq!(there.link, None, "the first run's link must not leak onto inserted text");
}
// --- reject restores formatting -----------------------------------------------------------------
#[test]
fn deleted_segment_keeps_formatting_so_reject_restores_it() {
let mut s = Session::new(Document::from_text("alpha beta gamma"));
s.run("select.text", &json!({"text": "alpha"})).unwrap();
s.run("format.bold", &json!({})).unwrap();
s.run("select.text", &json!({"text": "beta"})).unwrap();
s.run("format.italic", &json!({})).unwrap();
s.run("review.compare", &json!({"text": "alpha delta gamma"})).unwrap();
s.run("review.rejectAll", &json!({})).unwrap();
assert_eq!(s.doc.plain_text(StoryRef::Body), "alpha beta gamma");
let p = s.doc.body[0].as_para().unwrap();
let (_, alpha) = run_with(p, "alpha");
assert_eq!(alpha.bold, Some(true));
let (_, beta) = run_with(p, "beta");
assert_eq!(beta.italic, Some(true), "the deleted token kept its italic, so Reject restores it at token level");
}
// --- text-only segmentation identity (goldens from the pre-fix binary) --------------------------
#[test]
fn text_only_segmentation_matches_pre_fix_golden() {
// (original, revised, level, expected (text, ins, del) runs)
let cases: &[(&str, &str, &str, &[(&str, bool, bool)])] = &[
("The dog sat.", "The cat sat.", "word", &[("The ", false, false), ("dog ", false, true), ("cat ", true, false), ("sat.", false, false)]),
("a cat ran", "a dog ran", "word", &[("a ", false, false), ("cat ", false, true), ("dog ", true, false), ("ran", false, false)]),
("colour", "color", "word", &[("colour", false, true), ("color", true, false)]),
(
"zawarta w dniu 01.09.2026 pomiędzy:",
"zawarta w dniu 19.10.2026 pomiędzy:",
"word",
&[("zawarta w dniu ", false, false), ("01.09.2026 ", false, true), ("19.10.2026 ", true, false), ("pomiędzy:", false, false)],
),
("The dog sat.", "The cat sat.", "character", &[("The ", false, false), ("dog", false, true), ("cat", true, false), (" sat.", false, false)]),
("a cat ran", "a dog ran", "character", &[("a ", false, false), ("cat", false, true), ("dog", true, false), (" ran", false, false)]),
("colour", "color", "character", &[("colo", false, false), ("u", false, true), ("r", false, false)]),
(
"zawarta w dniu 01.09.2026 pomiędzy:",
"zawarta w dniu 19.10.2026 pomiędzy:",
"character",
&[("zawarta w dniu ", false, false), ("01.09", false, true), ("19.10", true, false), (".2026 pomiędzy:", false, false)],
),
];
for (orig, rev, level, want) in cases {
let mut s = Session::new(Document::from_text(orig));
s.run("review.compare", &json!({"text": rev, "level": level})).unwrap();
let p = s.doc.body[0].as_para().unwrap();
let want: Vec<(String, bool, bool)> = want.iter().map(|(t, i, d)| ((*t).to_string(), *i, *d)).collect();
assert_eq!(run_sig(p), want, "{orig:?} -> {rev:?} [{level}]");
}
}
// --- paragraph mark and paragraph properties ----------------------------------------------------
#[test]
fn paragraph_mark_is_preserved() {
let mut s = Session::new(Document::from_text("alpha beta gamma"));
{
let mut p = s.doc.body[0].as_para().unwrap().clone();
p.mark.bold = Some(true);
s.doc.body[0] = std::sync::Arc::new(Block::Para(p));
}
s.run("review.compare", &json!({"text": "alpha delta gamma"})).unwrap();
let p = s.doc.body[0].as_para().unwrap();
assert_eq!(p.mark.bold, Some(true), "the rebuilt paragraph keeps the original paragraph mark");
}
#[test]
fn paragraph_props_kept_when_revised_is_plain() {
let mut s = Session::new(Document::from_text("alpha beta gamma"));
s.run("para.style", &json!({"style": "Heading1"})).unwrap();
s.run("para.alignCenter", &json!({})).unwrap();
s.run("review.compare", &json!({"text": "alpha delta gamma"})).unwrap();
let p = s.doc.body[0].as_para().unwrap();
assert_eq!(p.props.style.as_deref(), Some("Heading1"), "the original style survives a plain revised side");
assert!(p.props.align.is_some(), "the original alignment survives a plain revised side");
}
// --- object pass-through (not flattened away by the rebuild) -------------------------------------
/// A session whose single paragraph is `alpha beta gamma` with a picture after "beta ", already
/// compared against `alpha delta gamma`: the picture's anchor sits in a deleted run.
fn compared_with_picture() -> Session {
let mut s = Session::new(Document::from_text("alpha beta gamma"));
s.run("caret.set", &json!({"pos": Pos::body(0, "alpha beta ".len())})).unwrap();
let png = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAC0lEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==";
s.run("insert.picture", &json!({"data": png})).unwrap();
assert_eq!(s.doc.body[0].as_para().unwrap().objects.len(), 1, "the picture was inserted");
s.run("review.compare", &json!({"text": "alpha delta gamma"})).unwrap();
s
}
#[test]
fn picture_anchor_survives_a_changed_paragraph() {
let s = compared_with_picture();
let p = s.doc.body[0].as_para().unwrap();
assert_eq!(p.objects.len(), 1, "the changed paragraph's picture anchor survives the rebuild");
let off = p.object_offsets().first().copied().expect("the picture anchor is in the text");
assert!(p.props_of_char(off).del.is_some(), "the picture anchor sits in a deleted run");
}
#[test]
fn accepting_removes_the_deleted_picture_and_rejecting_restores_it() {
let mut accepted = compared_with_picture();
accepted.run("review.acceptAll", &json!({})).unwrap();
assert_eq!(accepted.doc.body[0].as_para().unwrap().objects.len(), 0, "accepting the deletion removes the picture");
let mut rejected = compared_with_picture();
rejected.run("review.rejectAll", &json!({})).unwrap();
assert_eq!(rejected.doc.body[0].as_para().unwrap().objects.len(), 1, "rejecting the deletion restores the picture");
}
// --- document revised side: unchanged tokens follow the revised formatting (#3749) --------------
#[test]
fn unchanged_word_takes_the_revised_formatting_document_path() {
let rev = Session::new(Document::from_text("Read the manual now."));
let path = std::env::temp_dir().join(format!("wc-compare-s0-rev-bold-{}.docx", std::process::id()));
crate::io::save_path(&path, &rev.doc).unwrap();
let mut s = Session::new(Document::from_text("Read the manual today."));
s.run("select.text", &json!({"text": "manual"})).unwrap();
s.run("format.bold", &json!({})).unwrap();
s.run("review.compare", &json!({"path": path.to_string_lossy()})).unwrap();
let _ = std::fs::remove_file(&path);
let p = s.doc.body[0].as_para().unwrap();
let (_, manual) = run_with(p, "manual");
assert_ne!(manual.bold, Some(true), "the unchanged word takes the revised side's formatting, not the original's bold");
let (_, today) = run_with(p, "today.");
assert!(today.del.is_some(), "the removed word is deleted");
let (_, now) = run_with(p, "now.");
assert!(now.ins.is_some(), "the added word is inserted");
s.run("review.acceptAll", &json!({})).unwrap();
let p = s.doc.body[0].as_para().unwrap();
assert_eq!(p.plain_text(), "Read the manual now.");
let (_, manual) = run_with(p, "manual");
assert_ne!(manual.bold, Some(true), "accepting leaves the revised (unbolded) formatting");
}
#[test]
fn paragraph_style_change_is_not_masked_document_path() {
let rev = Session::new(Document::from_text("Introduction to X"));
let path = std::env::temp_dir().join(format!("wc-compare-s0-style-{}.docx", std::process::id()));
crate::io::save_path(&path, &rev.doc).unwrap();
let mut s = Session::new(Document::from_text("Introduction"));
s.run("para.style", &json!({"style": "Heading1"})).unwrap();
s.run("review.compare", &json!({"path": path.to_string_lossy(), "level": "character"})).unwrap();
let _ = std::fs::remove_file(&path);
let p = s.doc.body[0].as_para().unwrap();
assert_ne!(p.props.style.as_deref(), Some("Heading1"), "the revised paragraph's empty properties win, so the style change isn't masked");
assert!(p.run_ranges().any(|(_, c)| c.ins.is_some()), "the text was diffed, not wholesale replaced");
let (_, intro) = run_with(p, "Introduction");
assert!(intro.ins.is_none() && intro.del.is_none(), "the unchanged text survives unmarked");
let (_, added) = run_with(p, " to X");
assert!(added.ins.is_some(), "only the added text is insertion-marked");
}
#[test]
fn unchanged_word_gains_the_revised_formatting_document_path() {
let mut rev = Session::new(Document::from_text("Read the manual now."));
rev.run("select.text", &json!({"text": "manual"})).unwrap();
rev.run("format.bold", &json!({})).unwrap();
let path = std::env::temp_dir().join(format!("wc-compare-s0-rev-gains-bold-{}.docx", std::process::id()));
crate::io::save_path(&path, &rev.doc).unwrap();
let mut s = Session::new(Document::from_text("Read the manual today."));
s.run("review.compare", &json!({"path": path.to_string_lossy()})).unwrap();
let _ = std::fs::remove_file(&path);
let p = s.doc.body[0].as_para().unwrap();
let (_, manual) = run_with(p, "manual");
assert_eq!(manual.bold, Some(true), "the unchanged word takes the revised side's bold");
let (_, today) = run_with(p, "today.");
assert!(today.del.is_some(), "the removed word is deleted");
let (_, now) = run_with(p, "now.");
assert!(now.ins.is_some(), "the added word is inserted");
s.run("review.acceptAll", &json!({})).unwrap();
let p = s.doc.body[0].as_para().unwrap();
assert_eq!(p.plain_text(), "Read the manual now.");
let (_, manual) = run_with(p, "manual");
assert_eq!(manual.bold, Some(true), "accepting leaves the revised (bolded) formatting");
}
#[test]
fn removed_hyperlink_on_an_unchanged_word_follows_the_revised_side_document_path() {
let rev = Session::new(Document::from_text("Read the manual now."));
let path = std::env::temp_dir().join(format!("wc-compare-s0-link-{}.docx", std::process::id()));
crate::io::save_path(&path, &rev.doc).unwrap();
let mut s = Session::new(Document::from_text("Read the manual today."));
s.run("select.text", &json!({"text": "manual"})).unwrap();
s.run("insert.link", &json!({"url": "https://example.com"})).unwrap();
s.run("review.compare", &json!({"path": path.to_string_lossy()})).unwrap();
let _ = std::fs::remove_file(&path);
let p = s.doc.body[0].as_para().unwrap();
let (_, manual) = run_with(p, "manual");
assert_eq!(manual.link, None, "the unchanged word takes the revised side's run, which dropped the link");
}
+1 -1
View File
@@ -464,7 +464,7 @@ pub fn save_bytes_opts(name: &str, doc: &Document, opts: &ExportOptions) -> Resu
}
/// [`save_bytes`], encrypted with `password` when there is one and the format is a Word package
/// (other formats are copies and are written as they are).
/// or OpenDocument text file (.odt, .ott); other formats are copies and are written as they are.
pub fn save_bytes_with(name: &str, doc: &Document, password: Option<&str>, opts: &ExportOptions) -> Result<Vec<u8>, String> {
let bytes = save_bytes_opts(name, doc, opts)?;
match password {
+1 -1
View File
@@ -39,7 +39,7 @@ pub struct Prefs {
pub region: Option<String>,
/// A folder searched for Hunspell dictionaries before the system locations (File › Options ›
/// Language, #1063): an app started from Finder or the Dock doesn't see
/// `WORDCRAFT_DICTIONARIES`. `None` searches the system locations only.
/// `WORDCRAFT_DICTIONARIES`. `None` means no configured folder.
pub dictionaries_folder: Option<String>,
/// The user templates folder File › New lists personal templates from and Save as Word
/// Template starts in (File › Options › Advanced › File locations, #2852). `None`: the app's
+4
View File
@@ -88,6 +88,10 @@ pub struct Session {
pub initials: String,
/// Format painter: copied formatting waiting to be applied (and whether it stays on).
pub painter: Option<(CharProps, wordcraft_doc::props::ParaProps, bool)>,
/// Formatting picked up by Copy Formatting (Mod+Shift+C): Paste Formatting applies it as often
/// as asked, as in Word, until the next Copy Formatting. A Format Painter pick is stored here
/// as well.
pub copied_format: Option<(CharProps, wordcraft_doc::props::ParaProps)>,
/// Last message for the status bar / agents.
pub status: String,
/// Headers/footers `insert.createHeader`/`insert.createFooter` made for a page that had none
+1
View File
@@ -259,6 +259,7 @@ impl Session {
author: _,
initials: _,
painter: _,
copied_format: _,
// What the drawn window knows of the others: its front end sets it as it draws.
windows: _,
status: _,
+1
View File
@@ -109,6 +109,7 @@ impl Session {
author: "WordCraft User".into(),
initials: String::new(),
painter: None,
copied_format: None,
status: String::new(),
new_header_parts,
hf_return,
+1
View File
@@ -92,6 +92,7 @@ impl Session {
author: _,
initials: _,
painter: _,
copied_format: _,
status: _,
// Headers just created to edit: closing checks they still exist and are empty.
new_header_parts: _,
+259
View File
@@ -5,6 +5,7 @@ mod czech_test_dict;
use serde_json::json;
use std::sync::Arc;
use std::time::{Duration, Instant};
use wordcraft_doc::props::BorderStyle;
use wordcraft_doc::{Pos, StoryRef};
@@ -1108,6 +1109,26 @@ fn replace_under_track_changes_skips_deleted_text() {
assert_eq!(text(&s), "one dog two dog");
}
#[test]
fn replace_reports_whether_it_replaced_and_what_it_selected() {
// Replace follows Word's button: the first call only selects a match. Agents read
// `remaining` alone as done (#6877), so the result says whether anything was replaced.
let mut s = s();
run(&mut s, "document.setText", json!({"text": "alpha XX beta XX gamma XX"}));
run(&mut s, "caret.docStart", json!({}));
let calls: Vec<_> = (0..5).map(|_| run(&mut s, "edit.replace", json!({"text": "XX", "with": "YY"}))).collect();
let replaced: Vec<_> = calls.iter().map(|r| r["replaced"].clone()).collect();
assert_eq!(replaced, [json!(0), json!(1), json!(1), json!(1), json!(0)]);
let remaining: Vec<_> = calls.iter().map(|r| r["remaining"].clone()).collect();
assert_eq!(remaining, [json!(3), json!(2), json!(1), json!(0), json!(0)]);
let selected: Vec<_> = calls.iter().map(|r| (r["selected"]["start"]["off"].clone(), r["selected"]["end"]["off"].clone())).collect();
assert_eq!(selected[0], (json!(6), json!(8)));
assert_eq!(selected[1], (json!(14), json!(16)));
assert_eq!(selected[2], (json!(23), json!(25)));
assert!(calls[3]["selected"].is_null() && calls[4]["selected"].is_null(), "no match is left to select");
assert_eq!(text(&s), "alpha YY beta YY gamma YY");
}
#[test]
fn find_reads_the_text_around_tracked_deletions() {
// `edits` are (start, end) byte ranges deleted with Track Changes on, last first.
@@ -5164,6 +5185,74 @@ fn hostile_file_params_never_panic() {
let _ = std::fs::remove_dir_all(&base);
}
/// Large parameters must return and lay out within a generous wall-clock budget, so a regression
/// that loops or allocates without a cap fails here with its command id (#3720).
#[test]
fn hostile_large_params_stay_bounded() {
const BUDGET: Duration = Duration::from_secs(5);
let reg = cmd::registry();
// 1 MiB makes an uncapped copy or a quadratic scan visible without making the test itself
// expensive; the counts are large enough that an uncapped loop takes seconds.
let big = "x".repeat(1 << 20);
let mut deep = json!([]);
for _ in 0..64 {
deep = json!([deep]);
}
let junk = [
json!({
"text": big, "name": big, "label": big, "find": big, "replace": big,
"title": big, "author": big, "path": big,
}),
json!({
"count": 1_000_000_000u64, "copies": 1_000_000_000u64, "times": 1_000_000_000u64,
"cols": 1_000_000_000u64, "rows": 1_000_000_000u64, "level": 1_000_000_000u64,
"page": 1_000_000_000u64, "from": 1_000_000_000u64, "to": 1_000_000_000u64,
"id": 1_000_000_000u64,
}),
json!({"width": 3e38, "height": 3e38, "top": -3e38, "left": 3e38}),
json!({"path": deep}),
];
for spec in reg.all() {
if spec.id.starts_with("file.") || spec.id == "insert.picture" || spec.id == "insert.textFromFile" {
continue;
}
for j in &junk {
let mut s = Session::new(crate::sample::sample_document());
assert_ne!(s.read_aloud.backend, crate::speech::Backend::System, "tests must never start real speech");
let start = Instant::now();
let r = s.run(spec.id, j);
let elapsed = start.elapsed();
assert!(!caught_panic(&reg, &r), "{} panicked on large params: {r:?}", spec.id);
assert_within_budget(spec.id, elapsed, BUDGET);
// Laying the result out is not part of the command's budget; the layout tests
// cover long text separately. It still runs so a bad parameter reaches the layout.
s.clamp_selection();
let _ = s.layout();
}
}
}
fn assert_within_budget(id: &str, elapsed: Duration, budget: Duration) {
assert!(elapsed <= budget, "{id} took {elapsed:?} (budget {budget:?})");
}
/// The budget above fires: a command that runs past it is named, not ignored (#3720).
#[test]
#[should_panic(expected = "test.slow took")]
fn hostile_large_param_budget_flags_a_slow_command() {
let budget = Duration::from_millis(1);
let mut s = Session::new(crate::sample::sample_document());
let slow = crate::CommandSpec::new("test.slow", "Slow", "", |_, _| {
std::thread::sleep(Duration::from_millis(20));
Ok(json!({}))
})
.pure();
s.registry = Arc::new(crate::Registry::new(vec![slow]));
let start = Instant::now();
let _ = s.run("test.slow", &json!({}));
assert_within_budget("test.slow", start.elapsed(), budget);
}
/// A panic that `Session::run`'s guard turned into an error, in a command or one it ran: still a
/// crash path (#3718). Only the guard's own `"{id} panicked: "` counts, not an error that echoes
/// those words.
@@ -13472,3 +13561,173 @@ fn resolving_away_an_empty_paragraph_with_a_section_break_keeps_the_next_paragra
assert_eq!(s.doc.last_section.margin_left, 72.0, "{cmd}: the following section's setup stays");
}
}
/// #5616: Copy Formatting's formatting stays for every Paste Formatting, as in Word; it doesn't
/// arm the one-shot Format Painter brush.
#[test]
fn copied_formatting_pastes_again_and_again() {
let mut s = s();
run(&mut s, "document.setText", json!({"text": "Bold one two"}));
run(&mut s, "select.text", json!({"text": "Bold"}));
run(&mut s, "format.bold", json!({}));
run(&mut s, "edit.copyFormat", json!({}));
assert!(s.painter.is_none());
for word in ["one", "two"] {
run(&mut s, "select.text", json!({"text": word}));
run(&mut s, "edit.pasteFormat", json!({}));
assert_eq!(s.run("format.state", &json!({})).unwrap()["bold"], json!(true), "{word}");
}
assert_eq!(s.doc.plain_text(wordcraft_doc::StoryRef::Body), "Bold one two");
}
/// #5616: Copy Formatting and the Format Painter share one format buffer: each replaces the other,
/// so a used-up brush never hands over to older copied formatting.
#[test]
fn copy_formatting_and_the_format_painter_replace_each_other() {
let mut s = s();
run(&mut s, "document.setText", json!({"text": "Bold one two"}));
run(&mut s, "select.text", json!({"text": "Bold"}));
run(&mut s, "format.bold", json!({}));
run(&mut s, "edit.formatPainter", json!({}));
assert!(s.painter.is_some());
run(&mut s, "edit.copyFormat", json!({}));
assert!(s.painter.is_none(), "Copy Formatting clears an armed brush");
assert!(s.copied_format.is_some());
run(&mut s, "edit.formatPainter", json!({}));
assert!(s.painter.is_some());
run(&mut s, "select.text", json!({"text": "one"}));
run(&mut s, "edit.pasteFormat", json!({}));
assert!(s.painter.is_none(), "a used-up brush is gone");
assert!(s.copied_format.is_some(), "its pick stays for Paste Formatting");
}
/// #5616: arming and cancelling the Format Painter leaves Copy Formatting's pick; a brush's pick
/// is what Paste Formatting applies next.
#[test]
fn cancelling_the_format_painter_keeps_the_copied_formatting() {
let mut s = s();
run(&mut s, "document.setText", json!({"text": "Bold one two"}));
run(&mut s, "select.text", json!({"text": "Bold"}));
run(&mut s, "format.bold", json!({}));
run(&mut s, "edit.copyFormat", json!({}));
run(&mut s, "edit.formatPainter", json!({}));
run(&mut s, "edit.formatPainter", json!({}));
assert!(s.painter.is_none());
run(&mut s, "select.text", json!({"text": "one"}));
run(&mut s, "edit.pasteFormat", json!({}));
assert_eq!(s.run("format.state", &json!({})).unwrap()["bold"], json!(true));
// A brush picked from plain text replaces the bold pick.
run(&mut s, "select.text", json!({"text": "two"}));
run(&mut s, "edit.formatPainter", json!({}));
run(&mut s, "select.text", json!({"text": "Bold"}));
run(&mut s, "edit.pasteFormat", json!({}));
assert_ne!(s.run("format.state", &json!({})).unwrap()["bold"], json!(true));
}
/// #5616: copied formatting carries no tracked paragraph formatting or numbering change.
#[test]
fn copied_paragraph_formatting_carries_no_tracked_changes() {
let mut s = s();
run(&mut s, "document.setText", json!({"text": "one\ntwo"}));
run(&mut s, "review.trackChanges", json!({"value": true}));
run(&mut s, "select.text", json!({"text": "one"}));
run(&mut s, "para.alignCenter", json!({}));
run(&mut s, "review.trackChanges", json!({"value": false}));
run(&mut s, "select.text", json!({"text": "one"}));
let f = s.sel.focus.clone();
assert!(s.doc.para_at(&f).unwrap().props.fmt_change.is_some(), "the source paragraph has a tracked formatting change");
run(&mut s, "edit.copyFormat", json!({}));
let (_, para) = s.copied_format.clone().unwrap();
assert!(para.fmt_change.is_none() && para.num_change.is_none());
run(&mut s, "select.text", json!({"text": "two"}));
run(&mut s, "edit.pasteFormat", json!({}));
let f = s.sel.focus.clone();
let p = s.doc.para_at(&f).unwrap().props.clone();
assert!(p.fmt_change.is_none() && p.num_change.is_none());
}
/// #5616: copied formatting carries no hyperlink or revision marks, even into a collapsed caret.
#[test]
fn copied_formatting_carries_no_hyperlink() {
let mut s = s();
run(&mut s, "document.setText", json!({"text": "source target"}));
run(&mut s, "select.text", json!({"text": "source"}));
run(&mut s, "format.bold", json!({}));
run(&mut s, "insert.link", json!({"url": "https://example.com/"}));
run(&mut s, "select.text", json!({"text": "so"}));
run(&mut s, "edit.copyFormat", json!({}));
let (chr, _) = s.copied_format.clone().unwrap();
assert_eq!(chr.bold, Some(true));
assert!(chr.link.is_none() && chr.ins.is_none() && chr.del.is_none() && chr.fmt_change.is_none());
run(&mut s, "select.text", json!({"text": "target"}));
run(&mut s, "select.collapse", json!({}));
run(&mut s, "caret.left", json!({}));
run(&mut s, "edit.pasteFormat", json!({}));
let f = s.sel.focus.clone();
let link = s.doc.para_at(&f).map(|p| p.props_of_char(f.off).link.clone());
assert_eq!(link, Some(None), "the target didn't become a link");
}
/// #5616: Paste Formatting at a bare caret keeps the word's own hyperlink and tracked insertion.
#[test]
fn a_caret_paste_formatting_keeps_the_targets_link_and_tracked_marks() {
let mut s = s();
run(&mut s, "document.setText", json!({"text": "source target"}));
run(&mut s, "select.text", json!({"text": "source"}));
run(&mut s, "format.bold", json!({}));
run(&mut s, "edit.copyFormat", json!({}));
run(&mut s, "select.text", json!({"text": "target"}));
run(&mut s, "insert.link", json!({"url": "https://example.com/"}));
run(&mut s, "select.collapse", json!({}));
run(&mut s, "caret.right", json!({}));
run(&mut s, "edit.pasteFormat", json!({}));
let at_caret = |s: &Session| {
let f = s.sel.focus.clone();
s.doc.para_at(&f).map(|p| p.props_of_char(f.off).clone()).unwrap_or_default()
};
let c = at_caret(&s);
assert!(c.link.is_some(), "the target kept its hyperlink");
assert_eq!(c.bold, Some(true));
// A tracked insertion stays tracked.
run(&mut s, "caret.docEnd", json!({}));
run(&mut s, "review.trackChanges", json!({"value": true}));
run(&mut s, "text.insert", json!({"text": " added"}));
run(&mut s, "review.trackChanges", json!({"value": false}));
run(&mut s, "caret.left", json!({}));
assert!(at_caret(&s).ins.is_some(), "the insertion is tracked before");
run(&mut s, "edit.pasteFormat", json!({}));
assert!(at_caret(&s).ins.is_some(), "Paste Formatting kept the insertion mark");
}
/// #5616: Paste Formatting over a selection keeps the target's hyperlink and tracked marks too.
#[test]
fn a_range_paste_formatting_keeps_the_targets_link_and_tracked_marks() {
let mut s = s();
run(&mut s, "document.setText", json!({"text": "source target"}));
run(&mut s, "select.text", json!({"text": "source"}));
run(&mut s, "format.bold", json!({}));
run(&mut s, "edit.copyFormat", json!({}));
run(&mut s, "select.text", json!({"text": "target"}));
run(&mut s, "insert.link", json!({"url": "https://example.com/"}));
run(&mut s, "select.text", json!({"text": "target"}));
run(&mut s, "edit.pasteFormat", json!({}));
let (a, _) = s.sel.ordered();
let c = s.doc.para_at(&a).map(|p| p.props_of_char(a.off).clone()).unwrap_or_default();
assert!(c.link.is_some(), "the target kept its hyperlink");
assert_eq!(c.bold, Some(true));
// A tracked insertion selected as a range stays tracked.
run(&mut s, "caret.docEnd", json!({}));
run(&mut s, "review.trackChanges", json!({"value": true}));
run(&mut s, "text.insert", json!({"text": " added"}));
run(&mut s, "review.trackChanges", json!({"value": false}));
run(&mut s, "select.text", json!({"text": "added"}));
let at_start = |s: &Session| {
let (a, _) = s.sel.ordered();
s.doc.para_at(&a).map(|p| p.props_of_char(a.off).clone()).unwrap_or_default()
};
assert!(at_start(&s).ins.is_some(), "the insertion is tracked before");
run(&mut s, "edit.pasteFormat", json!({}));
let c = at_start(&s);
assert!(c.ins.is_some(), "Paste Formatting kept the insertion mark");
assert_eq!(c.bold, Some(true));
}
+77 -51
View File
@@ -5,13 +5,40 @@ use wordcraft_doc::props::CharProps;
use crate::Session;
/// Creates a document with `lines` lines of text.
/// The bundled face the fixtures are set in. Their page counts are exact to a line, so they must
/// not depend on the face the host substitutes for the default Aptos: at 11 pt, Arial and
/// Liberation Sans fit 28 of these lines on a page and DejaVu Sans, the only candidate on a bare
/// FreeBSD system, fits 27. Inter is the bundled face whose metrics give each 0.5 pt step its own
/// page boundary at this page size.
const FIXTURE_FONT: &str = "Inter";
/// Creates a document with `lines` lines of text in [`FIXTURE_FONT`]. Inter fits 25 lines on a
/// page at 12 pt, 26 at 11.5 pt and 27 at 11 pt.
fn create_multiline_doc(lines: usize) -> Session {
let mut text = String::new();
for i in 1..=lines {
text.push_str(&format!("Line {i}: The quick brown fox jumps over the lazy dog.\n"));
}
Session::new(Document::from_text(&text))
let mut doc = Document::from_text(&text);
std::sync::Arc::make_mut(&mut doc.styles).default_chr.font = Some(FIXTURE_FONT.into());
Session::new(doc)
}
/// Asserts the body is laid out in the bundled [`FIXTURE_FONT`], not a substitute.
fn assert_fixture_font(s: &mut Session) {
let layout = s.layout();
let mut runs = 0;
for page in &layout.pages {
for item in &page.items {
if let wordcraft_layout::Placed::Lines { story: wordcraft_doc::StoryRef::Body, para, .. } = item {
for style in &para.styles {
runs += 1;
assert_eq!(style.face.family, FIXTURE_FONT, "the fixture must not fall back to another family");
}
}
}
}
assert!(runs > 0, "the font check must inspect laid-out body text");
}
#[test]
@@ -39,7 +66,7 @@ fn fit_one_page_fails_on_hard_page_break() {
#[test]
fn fit_one_page_refuses_page_break_before_before_search() {
let mut s = create_multiline_doc(27);
let mut s = create_multiline_doc(26);
assert_eq!(s.layout().pages.len(), 2);
if let wordcraft_doc::Block::Para(p) = std::sync::Arc::make_mut(&mut s.doc.body[1]) {
p.props.page_break_before = Some(true);
@@ -74,7 +101,7 @@ fn fit_one_page_fails_on_next_page_section_break() {
#[test]
fn fit_one_page_condenses_slight_overflow_and_undoes() {
// Find the boundary where the document just spills onto page 2
let mut lines = 30;
let mut lines = 20;
let mut s = create_multiline_doc(lines);
while s.layout().pages.len() < 2 && lines < 80 {
lines += 2;
@@ -102,7 +129,7 @@ fn fit_one_page_condenses_slight_overflow_and_undoes() {
#[test]
fn fit_one_page_respects_max_delta() {
let mut s = create_multiline_doc(27);
let mut s = create_multiline_doc(26);
assert_eq!(s.layout().pages.len(), 2, "must start as 2-page document");
let doc_backup = s.doc.clone();
@@ -117,11 +144,7 @@ fn fit_one_page_respects_max_delta() {
#[test]
fn fit_one_page_respects_step_pt() {
let mut text = String::new();
for i in 1..=28 {
text.push_str(&format!("Line {i}: The quick brown fox jumps over the lazy dog.\n"));
}
let mut s = Session::new(Document::from_text(&text));
let mut s = create_multiline_doc(27);
for b in &mut s.doc.body {
if let wordcraft_doc::Block::Para(p) = std::sync::Arc::make_mut(b) {
p.mark.size = Some(11.4);
@@ -131,6 +154,7 @@ fn fit_one_page_respects_step_pt() {
}
}
assert_eq!(s.layout().pages.len(), 2, "must start as 2-page document at 11.4 pt");
assert_fixture_font(&mut s);
// Both calls hold maxDeltaPt constant at 0.4 and disable spacing adjustments.
// Default 0.5 pt step generates no candidates <= 0.4 pt, so it must fail.
@@ -147,7 +171,7 @@ fn fit_one_page_respects_step_pt() {
#[test]
fn fit_one_page_allows_spacing_only_at_font_floor() {
let mut lines = 35;
let mut lines = 20;
let mut s = create_multiline_doc(lines);
let set_font = |s: &mut Session| {
for b in &mut s.doc.body {
@@ -178,7 +202,7 @@ fn fit_one_page_allows_spacing_only_at_font_floor() {
#[test]
fn fit_one_page_fails_when_body_font_already_at_minimum_readable_size() {
let mut lines = 35;
let mut lines = 20;
let mut s = create_multiline_doc(lines);
let set_font = |s: &mut Session| {
for b in &mut s.doc.body {
@@ -208,7 +232,7 @@ fn fit_one_page_fails_when_body_font_already_at_minimum_readable_size() {
#[test]
fn fit_one_page_bounds_fine_step_loop() {
let mut lines = 28;
let mut lines = 20;
let mut s = create_multiline_doc(lines);
while s.layout().pages.len() < 2 && lines < 80 {
lines += 1;
@@ -224,7 +248,7 @@ fn fit_one_page_bounds_fine_step_loop() {
#[test]
fn fit_one_page_supports_max_delta_above_2pt() {
let mut lines = 28;
let mut lines = 20;
let mut s = create_multiline_doc(lines);
while s.layout().pages.len() < 2 && lines < 80 {
lines += 1;
@@ -244,7 +268,7 @@ fn fit_one_page_supports_max_delta_above_2pt() {
#[test]
fn fit_one_page_anti_compound_guard_prevents_repeated_invocations() {
let mut lines = 28;
let mut lines = 20;
let mut s = create_multiline_doc(lines);
loop {
for b in &mut s.doc.body {
@@ -314,7 +338,7 @@ fn fit_one_page_already_fits_wins_over_exhausted_budget() {
#[test]
fn fit_one_page_checks_complex_script_font_floor() {
let mut lines = 28;
let mut lines = 20;
let mut s = create_multiline_doc(lines);
while s.layout().pages.len() < 2 && lines < 80 {
lines += 1;
@@ -340,7 +364,7 @@ fn fit_one_page_checks_complex_script_font_floor() {
#[test]
fn fit_one_page_checks_editable_text_box_font_floor() {
let mut lines = 28;
let mut lines = 20;
let mut s = create_multiline_doc(lines);
while s.layout().pages.len() < 2 && lines < 80 {
lines += 1;
@@ -386,7 +410,7 @@ fn fit_one_page_checks_editable_text_box_font_floor() {
#[test]
fn fit_one_page_fails_when_overflow_exceeds_limits() {
let mut lines = 28;
let mut lines = 20;
let mut s = create_multiline_doc(lines);
while s.layout().pages.len() < 2 {
lines += 1;
@@ -566,7 +590,7 @@ fn fit_one_page_fails_with_failed_cmd_error() {
#[test]
fn fit_one_page_never_populates_custom_props() {
let mut lines = 30;
let mut lines = 20;
let mut s = create_multiline_doc(lines);
while s.layout().pages.len() < 2 && lines < 80 {
lines += 2;
@@ -582,7 +606,7 @@ fn fit_one_page_never_populates_custom_props() {
fn fit_one_page_allows_subsequent_fit_after_typography_reset() {
use std::sync::Arc;
let mut lines = 28;
let mut lines = 20;
let mut s = create_multiline_doc(lines);
while s.layout().pages.len() < 2 && lines < 80 {
lines += 1;
@@ -625,7 +649,7 @@ fn fit_one_page_allows_subsequent_fit_after_typography_reset() {
#[test]
fn fit_one_page_small_paragraph_mark_with_runs_never_blocks_fit() {
let mut lines = 30;
let mut lines = 20;
let mut s = create_multiline_doc(lines);
while s.layout().pages.len() < 2 && lines < 80 {
lines += 2;
@@ -646,7 +670,7 @@ fn fit_one_page_small_paragraph_mark_with_runs_never_blocks_fit() {
#[test]
fn fit_one_page_small_comment_font_never_blocks_body_fit() {
let mut lines = 30;
let mut lines = 20;
let mut s = create_multiline_doc(lines);
while s.layout().pages.len() < 2 && lines < 80 {
lines += 2;
@@ -666,7 +690,7 @@ fn fit_one_page_small_comment_font_never_blocks_body_fit() {
#[test]
fn fit_one_page_anti_compound_caps_total_reduction_across_runs() {
let mut s = create_multiline_doc(27);
let mut s = create_multiline_doc(26);
assert_eq!(s.layout().pages.len(), 2);
// Initial fit with -0.5 pt font reduction (spacing disabled so font budget is exercised)
@@ -688,7 +712,7 @@ fn fit_one_page_anti_compound_caps_total_reduction_across_runs() {
#[test]
fn fit_one_page_tracks_reduced_text_provenance_without_global_minimum() {
let mut s = create_multiline_doc(27);
let mut s = create_multiline_doc(26);
// Add a 9.0 pt run to the first paragraph alongside 11.0 pt runs
if let wordcraft_doc::Block::Para(p) = std::sync::Arc::make_mut(&mut s.doc.body[0]) {
p.runs.push(wordcraft_doc::para::Run { len: 5, props: CharProps { size: Some(9.0), ..Default::default() } });
@@ -725,7 +749,7 @@ fn fit_one_page_tracks_reduced_text_provenance_without_global_minimum() {
#[test]
fn fit_one_page_allows_spill_with_bottom_placed_footnote() {
let mut lines = 28;
let mut lines = 20;
let mut s = create_multiline_doc(lines);
while s.layout().pages.len() < 2 && lines < 80 {
lines += 1;
@@ -751,7 +775,7 @@ fn fit_one_page_allows_spill_with_bottom_placed_footnote() {
#[test]
fn fit_one_page_with_final_page_footnote() {
let mut lines = 28;
let mut lines = 20;
let mut s = create_multiline_doc(lines);
while s.layout().pages.len() < 2 && lines < 80 {
lines += 1;
@@ -784,7 +808,7 @@ fn fit_one_page_with_final_page_footnote() {
#[test]
fn fit_one_page_skips_deleted_text_when_markup_hidden() {
let mut s = create_multiline_doc(27);
let mut s = create_multiline_doc(26);
assert_eq!(s.layout().pages.len(), 2);
// Insert a deleted text run with small font (e.g. 6.0 pt, below the 8.5 pt floor)
@@ -815,7 +839,7 @@ fn fit_one_page_skips_deleted_text_when_markup_hidden() {
#[test]
fn fit_one_page_tracks_reduced_complex_script_font_sizes() {
let mut s = create_multiline_doc(27);
let mut s = create_multiline_doc(26);
assert_eq!(s.layout().pages.len(), 2);
let styles_before = s.doc.styles.clone();
@@ -853,8 +877,9 @@ fn fit_one_page_tracks_reduced_complex_script_font_sizes() {
#[test]
fn fit_one_page_preserves_budget_across_document_serialization() {
let mut s = create_multiline_doc(27);
let mut s = create_multiline_doc(26);
assert_eq!(s.layout().pages.len(), 2);
assert_fixture_font(&mut s);
// Apply fit
let res = s.run("layout.fitOnePage", &json!({"maxDeltaPt": 0.5, "adjustSpacing": false}));
@@ -900,7 +925,7 @@ fn fit_one_page_enforces_durable_limit_when_fit_state_missing() {
s.touch();
s.relayout();
};
let mut lines = 27;
let mut lines = 20;
let mut s = create_multiline_doc(lines);
set_font(&mut s);
while s.layout().pages.len() < 2 && lines < 120 {
@@ -924,7 +949,7 @@ fn fit_one_page_enforces_durable_limit_when_fit_state_missing() {
#[test]
fn fit_one_page_skips_hidden_text_when_hidden_marks_off() {
let mut s = create_multiline_doc(27);
let mut s = create_multiline_doc(26);
assert_eq!(s.layout().pages.len(), 2);
// Insert a hidden text run with small font (6.0 pt, below the 8.5 pt floor) into an existing paragraph
@@ -958,7 +983,7 @@ fn fit_one_page_skips_hidden_text_when_hidden_marks_off() {
#[test]
fn fit_one_page_accounts_for_vertical_alignment_padding() {
let mut s = create_multiline_doc(26);
let mut s = create_multiline_doc(25);
let extra_p = wordcraft_doc::Paragraph::with_text("Spill line on page 2.", CharProps::default());
s.doc.body.push(wordcraft_doc::para_block(extra_p));
@@ -977,7 +1002,7 @@ fn fit_one_page_accounts_for_vertical_alignment_padding() {
#[test]
fn fit_one_page_accounts_for_note_separator_decor_story() {
let mut lines = 28;
let mut lines = 20;
let mut s = create_multiline_doc(lines);
while s.layout().pages.len() < 2 && lines < 80 {
lines += 1;
@@ -1012,7 +1037,7 @@ fn fit_one_page_accounts_for_note_separator_decor_story() {
#[test]
fn fit_one_page_tracks_fixed_spacing_independent_of_paragraph_mark_size() {
let mut lines = 28;
let mut lines = 20;
let mut s = create_multiline_doc(lines);
let set_spacing = |s: &mut Session| {
for b in &mut s.doc.body {
@@ -1053,7 +1078,7 @@ fn fit_one_page_tracks_fixed_spacing_independent_of_paragraph_mark_size() {
#[test]
fn fit_one_page_reports_search_exhaustion_when_candidates_cannot_remove_page() {
let mut s = create_multiline_doc(27);
let mut s = create_multiline_doc(26);
assert_eq!(s.layout().pages.len(), 2);
// Calling with zero maxDeltaPt and adjustSpacing: false produces no candidate steps
@@ -1068,23 +1093,24 @@ fn fit_one_page_reports_search_exhaustion_when_candidates_cannot_remove_page() {
#[test]
fn fit_one_page_excludes_line_number_decorations_from_final_page_limits() {
let mut lines = 33;
let enable_line_numbers = |s: &mut Session| {
s.doc.last_section.line_numbers = Some(wordcraft_doc::section::LineNumbering::default());
s.touch();
s.relayout();
};
let mut s = create_multiline_doc(lines);
enable_line_numbers(&mut s);
while s.layout().pages.len() < 2 && lines < 60 {
lines += 1;
s = create_multiline_doc(lines);
enable_line_numbers(&mut s);
}
let mut s = create_multiline_doc(33);
s.doc.last_section.line_numbers = Some(wordcraft_doc::section::LineNumbering::default());
s.touch();
s.relayout();
assert_eq!(s.layout().pages.len(), 2);
// Every body line on the final page also places a line-number decoration. Counting those as
// content would double the final-page line count and refuse before any candidate is tried.
// content would double the final-page line count and refuse before any candidate is tried:
// between 7 and 12 body lines are within the 12-line limit, and twice as many are not.
let body_lines: usize = s.layout().pages[1]
.items
.iter()
.map(|item| match item {
wordcraft_layout::Placed::Lines { story: wordcraft_doc::StoryRef::Body, l0, l1, .. } => l1 - l0,
_ => 0,
})
.sum();
assert!((7..=12).contains(&body_lines), "the final page must carry 7 to 12 body lines, has {body_lines}");
let decorated = s.layout().pages[1]
.items
.iter()
@@ -1099,7 +1125,7 @@ fn fit_one_page_excludes_line_number_decorations_from_final_page_limits() {
#[test]
fn fit_one_page_counts_side_by_side_footnote_cells_once() {
let mut s = create_multiline_doc(27);
let mut s = create_multiline_doc(26);
assert_eq!(s.layout().pages.len(), 2);
// A footnote table whose row's cells sit side by side: their text occupies one vertical
@@ -1134,7 +1160,7 @@ fn fit_one_page_counts_side_by_side_footnote_cells_once() {
#[test]
fn fit_one_page_refuses_when_formatting_changes_cannot_be_tracked() {
let mut s = create_multiline_doc(27);
let mut s = create_multiline_doc(26);
assert_eq!(s.layout().pages.len(), 2);
s.doc.settings.track_changes = true;
s.prefs.markup.track_formatting = true;
+22
View File
@@ -4031,3 +4031,25 @@ fn issues_1281_1045_english_dialects_proof_typed_text() {
let words: Vec<&str> = issues.as_array().unwrap().iter().filter(|i| i["kind"] == "spelling").filter_map(|i| i["text"].as_str()).collect();
assert_eq!(words, ["21th"]);
}
/// #6788: Enter in a paragraph with a drop cap makes a normal paragraph; only the first keeps
/// the cap (Word behaviour), for a dropped cap and one in the margin.
#[test]
fn enter_in_a_drop_cap_paragraph_makes_a_normal_paragraph() {
for position in ["dropped", "margin"] {
let mut s = typed("Sugar and knowledge");
run(&mut s, "insert.dropCap", json!({"position": position, "lines": 3, "distance": 4.0, "font": "Liberation Mono"}));
let first_has_cap = s.doc.body.first().and_then(|b| b.as_para()).is_some_and(|p| p.props.drop_cap == Some(3));
assert!(first_has_cap, "{position}: the cap is set");
run(&mut s, "select.range", json!({"anchor": {"block": 0, "off": 10}, "focus": {"block": 0, "off": 10}}));
run(&mut s, "text.newParagraph", json!({}));
let paras: Vec<_> = s.doc.body.iter().filter_map(|b| b.as_para()).collect();
assert_eq!(paras.len(), 2, "{position}");
let (first, second) = (&paras[0].props, &paras[1].props);
assert_eq!(first.drop_cap, Some(3), "{position}: the first paragraph keeps its cap");
assert_eq!(second.drop_cap, None, "{position}");
assert_eq!(second.drop_cap_margin, None, "{position}");
assert_eq!(second.drop_cap_distance, None, "{position}");
assert_eq!(second.drop_cap_font, None, "{position}");
}
}
+55
View File
@@ -103,3 +103,58 @@ fn an_odt_bibliography_updates_from_its_citations_sources() {
assert!(text.iter().any(|t| t.contains("Kilns and Fire")), "{text:?}");
assert!(!text.iter().any(|t| t.contains("stale")), "{text:?}");
}
/// #6486: LibreOffice numbers headings through its outline style, the number followed by a tab,
/// and its Contents styles carry only the right-aligned dotted stop for the page number. After
/// Update Table, the tab after an entry's number stops near the number, not at the page-number
/// stop: the title stays at the left and each entry stays on one line.
#[test]
fn an_odt_toc_with_numbered_headings_keeps_its_entries_on_one_line() {
let outline = |level: u8, cm: f32| {
format!(
r#"<text:outline-level-style text:level="{level}" style:num-format="1" style:num-suffix="." text:display-levels="{level}"><style:list-level-properties text:list-level-position-and-space-mode="label-alignment"><style:list-level-label-alignment text:label-followed-by="listtab" text:list-tab-stop-position="{cm}cm" fo:text-indent="-{cm}cm" fo:margin-left="{cm}cm"/></style:list-level-properties></text:outline-level-style>"#
)
};
let contents = |n: u8, indent: f32| {
format!(
r#"<style:style style:name="Contents_20_{n}" style:display-name="Contents {n}" style:family="paragraph"><style:paragraph-properties fo:margin-left="{indent}cm"><style:tab-stops><style:tab-stop style:position="16.99cm" style:type="right" style:leader-style="dotted" style:leader-text="."/></style:tab-stops></style:paragraph-properties></style:style>"#
)
};
let styles = format!(
r#"<office:document-styles {NS}><office:styles>{}{}<text:outline-style style:name="Outline">{}{}</text:outline-style></office:styles><office:automatic-styles><style:page-layout style:name="pm1"><style:page-layout-properties fo:page-width="21.001cm" fo:page-height="29.7cm" fo:margin-left="2cm" fo:margin-right="2cm" fo:margin-top="2cm" fo:margin-bottom="2cm"/></style:page-layout></office:automatic-styles><office:master-styles><style:master-page style:name="Standard" style:page-layout-name="pm1"/></office:master-styles></office:document-styles>"#,
contents(1, 0.0),
contents(2, 0.499),
outline(1, 0.762),
outline(2, 1.016)
);
let content = format!(
r#"<office:document-content {NS}><office:body><office:text>
<text:table-of-content text:name="T"><text:table-of-content-source text:outline-level="2"/><text:index-body><text:p text:style-name="Contents_20_1">1. Planning<text:tab/>1</text:p><text:p text:style-name="Contents_20_2">1.1. Budget<text:tab/>1</text:p></text:index-body></text:table-of-content>
<text:h text:outline-level="1">Planning</text:h><text:p>Text.</text:p>
<text:h text:outline-level="2">Budget</text:h><text:p>More text.</text:p>
</office:text></office:body></office:document-content>"#
);
let mut z = craft_zip::Writer::new();
for (name, data) in [("mimetype", "application/vnd.oasis.opendocument.text"), ("styles.xml", styles.as_str()), ("content.xml", content.as_str())]
{
z.add(name, data.as_bytes(), craft_zip::Compression::Stored).unwrap();
}
let mut s = Session::new(io::open_bytes("toc.odt", &z.finish().unwrap()).unwrap());
s.run("references.updateToc", &json!({})).unwrap();
let layout = s.layout();
let mut checked = 0;
for (i, b) in s.doc.body.iter().enumerate() {
let Some(p) = b.as_para().filter(|p| p.props.style.as_deref().is_some_and(|st| st.starts_with("TOC") && st != "TOCHeading")) else {
continue;
};
let Some(tab) = p.text.find('\t') else { continue };
let pos = |off| wordcraft_doc::Pos { story: wordcraft_doc::StoryRef::Body, path: wordcraft_doc::Path::top(i), off };
let title = layout.caret(&pos(tab + 1)).unwrap();
let end = layout.caret(&pos(p.len())).unwrap();
assert!(p.plain_text().contains("Planning") || p.plain_text().contains("Budget"), "{:?}", p.text);
assert_eq!((title.page, title.top), (end.page, end.top), "{:?} wraps", p.text);
assert!(title.x < 200.0, "{:?}: the title starts at {}", p.text, title.x);
checked += 1;
}
assert_eq!(checked, 2);
}
+7 -1
View File
@@ -63,7 +63,13 @@ impl std::fmt::Display for UserFontError {
match self {
UserFontError::Empty => write!(f, "the font file is empty"),
UserFontError::TooLarge { bytes } => {
write!(f, "the font file is too large ({} MB; at most {} MB)", bytes.div_ceil(1 << 20), MAX_FONT_FILE_BYTES >> 20)
write!(
f,
"the font is too large ({} MB; file limit {} MB, unpacked limit {} MB)",
bytes.div_ceil(1 << 20),
MAX_FONT_FILE_BYTES >> 20,
MAX_DECODED_BYTES >> 20
)
}
UserFontError::NotAFont => write!(f, "not a font file (TrueType, OpenType, TTC, WOFF or WOFF2)"),
UserFontError::BadWebFont(e) => write!(f, "the web font couldn't be read: {e}"),
+6 -2
View File
@@ -210,7 +210,9 @@ fn woff1_claiming(orig: u32) -> Vec<u8> {
fn a_woff_claiming_a_huge_table_is_refused_before_inflating() {
// #3703: the decoder sizes a table's buffer from the directory before inflating it.
for orig in [200 << 20, u32::MAX] {
assert!(matches!(decode_font_file(&woff1_claiming(orig)), Err(UserFontError::TooLarge { .. })), "{orig}");
let error = decode_font_file(&woff1_claiming(orig)).unwrap_err();
assert!(matches!(&error, UserFontError::TooLarge { .. }), "{orig}");
assert!(error.to_string().contains("unpacked limit 128 MB"), "{error}");
}
// A small claim reaches the decoder, which finds the data doesn't inflate to it.
assert!(matches!(decode_font_file(&woff1_claiming(64)), Err(UserFontError::BadWebFont(_))));
@@ -311,7 +313,9 @@ fn junk_is_rejected_without_adding_anything() {
assert_eq!(db.families().len(), n + db.user_fonts().iter().map(|u| u.families().len()).sum::<usize>());
let mut big = regular.clone();
big.resize(MAX_FONT_FILE_BYTES + 1, 0);
assert!(matches!(db.install_font("big.ttf", &big), Err(UserFontError::TooLarge { .. })));
let error = db.install_font("big.ttf", &big).unwrap_err();
assert!(matches!(&error, UserFontError::TooLarge { .. }));
assert!(error.to_string().contains("file limit 50 MB"), "{error}");
}
#[test]
+2 -1
View File
@@ -10,9 +10,10 @@ workspace = true
[features]
# Picture decoding within a memory budget (`picture`), for the crates that decode pictures.
image = ["dep:image", "dep:craft-image-codecs"]
image = ["dep:image", "dep:craft-image-codecs", "dep:craft-tiff"]
[dependencies]
craft-image-codecs = { workspace = true, optional = true }
craft-tiff = { workspace = true, optional = true }
image = { workspace = true, optional = true }
serde = { workspace = true }
+236 -37
View File
@@ -1,5 +1,4 @@
//! WordCraft geometry and units.
//!
//! Layout works in **points** (1/72 inch, `f32`). File formats use other units: OOXML uses
//! twentieths of a point (twips) for most lengths, half-points for font sizes, eighths of a point
//! for borders and English Metric Units (EMU, 914 400 per inch) for drawings. The conversions live
@@ -25,26 +24,32 @@ pub const EMU_PER_PT: f32 = 12_700.0;
pub const PT_PER_CM: f32 = 72.0 / 2.54;
/// Twips → points.
#[expect(clippy::cast_precision_loss, reason = "The f32 return type intentionally rounds i64 inputs to f32 precision.")]
pub fn twips(v: i64) -> f32 {
v as f32 / TWIPS_PER_PT
}
/// Points → twips (rounded).
#[expect(clippy::cast_possible_truncation, reason = "The value is rounded first; Rust's float-to-integer cast saturates outside the i64 range.")]
pub fn to_twips(pt: f32) -> i64 {
finite(pt * TWIPS_PER_PT).round() as i64
}
/// EMU → points.
#[expect(clippy::cast_precision_loss, reason = "The f32 return type intentionally rounds i64 inputs to f32 precision.")]
pub fn emu(v: i64) -> f32 {
v as f32 / EMU_PER_PT
}
/// Points → EMU (rounded).
#[expect(clippy::cast_possible_truncation, reason = "The value is rounded first; Rust's float-to-integer cast saturates outside the i64 range.")]
pub fn to_emu(pt: f32) -> i64 {
(finite(pt) as f64 * EMU_PER_PT as f64).round() as i64
(f64::from(finite(pt)) * f64::from(EMU_PER_PT)).round() as i64
}
/// Half-points (OOXML font sizes) → points.
#[expect(clippy::cast_precision_loss, reason = "The f32 return type intentionally rounds i64 inputs to f32 precision.")]
pub fn half_points(v: i64) -> f32 {
v as f32 / 2.0
}
/// Points → half-points (rounded).
#[expect(clippy::cast_possible_truncation, reason = "The value is rounded first; Rust's float-to-integer cast saturates outside the i64 range.")]
pub fn to_half_points(pt: f32) -> i64 {
(finite(pt) * 2.0).round() as i64
}
@@ -58,15 +63,21 @@ pub fn finite(v: f32) -> f32 {
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
#[serde(rename_all = "lowercase")]
pub enum Unit {
/// Inches (the default).
#[default]
Inches,
/// Centimetres.
Centimeters,
/// Millimetres.
Millimeters,
/// Points (1/72 inch).
Points,
/// Picas (12 points).
Picas,
}
impl Unit {
/// The suffix shown after a number in this unit (`"` for inches, ` cm`, ` pt`, …).
pub fn suffix(self) -> &'static str {
match self {
Unit::Inches => "\"",
@@ -76,6 +87,7 @@ impl Unit {
Unit::Picas => " pi",
}
}
/// How many points one of this unit is.
pub fn pt_per_unit(self) -> f32 {
match self {
Unit::Inches => PT_PER_IN,
@@ -99,15 +111,34 @@ impl Unit {
let s = format!("{v:.2}");
let s = if s.contains('.') { s.trim_end_matches('0').trim_end_matches('.') } else { &s };
let s = if s == "-0" { "0" } else { s };
s.replace('.', &decimal.to_string())
let mut buf = [0u8; 4];
let sep: &str = decimal.encode_utf8(&mut buf);
s.replace('.', sep)
}
}
/// Maps the digits and decimal separators of other scripts to their ASCII forms: Arabic-Indic
/// (`٠`–`٩`, `٫`), Extended Arabic-Indic (`۰`–`۹`) and full-width (`0`–`9`, `.`, `,`).
fn fold_digit(c: char) -> char {
match c {
'\u{0660}'..='\u{0669}' => char::from(b'0' + (c as u32 - 0x0660) as u8),
'\u{06F0}'..='\u{06F9}' => char::from(b'0' + (c as u32 - 0x06F0) as u8),
'\u{FF10}'..='\u{FF19}' => char::from(b'0' + (c as u32 - 0xFF10) as u8),
'\u{066B}' | '\u{FF0E}' => '.',
'\u{FF0C}' => ',',
other => other,
}
}
/// Parse a measurement typed by a user: `1"`, `1 in`, `2.5cm`, `12pt`, `3 pi`, `10 mm`, `1.5 li`
/// (lines are 12 pt). A bare number is in `default`. Returns points. Either decimal separator
/// works (`2,5 cm` and `2.5 cm`), whatever the region.
/// (lines are 12 pt), `8 px` (pixels are 0.75 pt). A bare number is in `default`. Returns points,
/// or `None` for anything unreadable or whose result does not fit in an `f32`.
///
/// Either decimal separator works (`2,5 cm` and `2.5 cm`), whatever the region, so a thousands
/// separator is *not* understood: `1,000 pt` is 1 pt, not 1000. Arabic-Indic and full-width digits
/// are accepted like ASCII ones. Scientific notation is not: the number ends at the `e`.
pub fn parse_measure(s: &str, default: Unit) -> Option<f32> {
let t = s.trim().to_ascii_lowercase().replace('\u{2212}', "-");
let t = s.trim().chars().map(fold_digit).collect::<String>().to_ascii_lowercase().replace('\u{2212}', "-");
if t.is_empty() {
return None;
}
@@ -123,8 +154,7 @@ pub fn parse_measure(s: &str, default: Unit) -> Option<f32> {
"cm" => PT_PER_CM,
"mm" => PT_PER_CM / 10.0,
"pt" | "pts" | "point" | "points" => 1.0,
"pi" | "pc" | "pica" | "picas" => 12.0,
"li" | "line" | "lines" => 12.0,
"pi" | "pc" | "pica" | "picas" | "li" | "line" | "lines" => 12.0,
"px" => 0.75,
_ => return None,
};
@@ -138,50 +168,98 @@ pub fn parse_measure(s: &str, default: Unit) -> Option<f32> {
/// A point in page space (points, y down).
#[derive(Clone, Copy, Debug, PartialEq, Default, Serialize, Deserialize)]
pub struct Point {
/// Distance from the left edge.
pub x: f32,
/// Distance from the top edge.
pub y: f32,
}
impl Point {
/// A point at (`x`, `y`).
pub const fn new(x: f32, y: f32) -> Self {
Point { x, y }
}
}
/// An axis-aligned rectangle (points, y down). `w`/`h` are never negative when built with [`Rect::new`].
/// An axis-aligned rectangle (points, y down). `w`/`h` are finite and never negative, whether the
/// rectangle was built with [`Rect::new`] or deserialized (both go through the same checks).
#[derive(Clone, Copy, Debug, PartialEq, Default, Serialize, Deserialize)]
#[serde(from = "RectRaw")]
pub struct Rect {
/// Left edge.
pub x: f32,
/// Top edge.
pub y: f32,
/// Width.
pub w: f32,
/// Height.
pub h: f32,
}
/// The unchecked shape of a [`Rect`] on the wire; converting it applies [`Rect::new`]'s rules.
#[derive(Deserialize)]
struct RectRaw {
x: f32,
y: f32,
w: f32,
h: f32,
}
impl From<RectRaw> for Rect {
fn from(r: RectRaw) -> Self {
Rect::new(r.x, r.y, r.w, r.h)
}
}
/// Where two crossed edges meet: both land on their midpoint.
fn collapse(lo: f32, hi: f32) -> (f32, f32) {
if hi < lo {
let m = lo * 0.5 + hi * 0.5;
(m, m)
} else {
(lo, hi)
}
}
impl Rect {
/// A rectangle with NaN and infinities replaced by 0 and a negative size clamped to 0.
pub fn new(x: f32, y: f32, w: f32, h: f32) -> Self {
Rect { x: finite(x), y: finite(y), w: finite(w).max(0.0), h: finite(h).max(0.0) }
}
/// The right edge.
pub fn right(&self) -> f32 {
self.x + self.w
}
/// The bottom edge.
pub fn bottom(&self) -> f32 {
self.y + self.h
}
/// Whether `p` is inside or on the edge. Edges are *included*, unlike [`Rect::intersects`],
/// so a point on an edge shared by two rectangles is in both.
pub fn contains(&self, p: Point) -> bool {
p.x >= self.x && p.x <= self.right() && p.y >= self.y && p.y <= self.bottom()
}
/// Whether the interiors overlap. Rectangles that only touch along an edge do *not* intersect.
pub fn intersects(&self, o: &Rect) -> bool {
self.x < o.right() && o.x < self.right() && self.y < o.bottom() && o.y < self.bottom()
}
/// The smallest rectangle covering both. An empty rectangle still counts: `Rect::default()`
/// sits at the origin, so accumulating bounds from it always stretches to (0, 0). Start from
/// the first real rectangle instead.
pub fn union(&self, o: &Rect) -> Rect {
let x = self.x.min(o.x);
let y = self.y.min(o.y);
Rect::new(x, y, self.right().max(o.right()) - x, self.bottom().max(o.bottom()) - y)
}
/// Shrunk by `l`, `t`, `r`, `b` on the left, top, right and bottom (grown for negative values).
/// If the edges cross, the result has zero size at the middle of where they crossed.
pub fn inset(&self, l: f32, t: f32, r: f32, b: f32) -> Rect {
Rect::new(self.x + l, self.y + t, self.w - l - r, self.h - t - b)
let (l, t, r, b) = (finite(l), finite(t), finite(r), finite(b));
let (x0, x1) = collapse(self.x + l, self.right() - r);
let (y0, y1) = collapse(self.y + t, self.bottom() - b);
Rect::new(x0, y0, x1 - x0, y1 - y0)
}
/// Grown by `d` on every side (shrunk for negative `d`, down to zero size).
/// Grown by `d` on every side (shrunk for negative `d`, down to zero size at the centre).
pub fn expand(&self, d: f32) -> Rect {
self.inset(-d, -d, -d, -d)
}
@@ -198,12 +276,15 @@ pub fn normalize_degrees(deg: f32) -> f32 {
}
/// How a drawing is turned about its centre: mirrored first (`flip_h` left to right, `flip_v` top
/// to bottom), then rotated `deg` degrees clockwise (page space, y down), as DrawingML's `a:xfrm`
/// to bottom), then rotated `deg` degrees clockwise (page space, y down), as `DrawingML`'s `a:xfrm`
/// `flipH`, `flipV` and `rot` say (ECMA-376 §20.1.7.6).
#[derive(Clone, Copy, Debug, PartialEq, Default)]
pub struct Spin {
/// Clockwise rotation in degrees.
pub deg: f32,
/// Mirrored left to right.
pub flip_h: bool,
/// Mirrored top to bottom.
pub flip_v: bool,
}
@@ -219,7 +300,7 @@ impl Spin {
}
/// The linear part (a, b, c, d: x' = a·x + c·y, y' = b·x + d·y).
fn linear(&self) -> [f32; 4] {
fn linear(self) -> [f32; 4] {
let r = normalize_degrees(self.deg).to_radians();
let (s, c) = r.sin_cos();
let fx = if self.flip_h { -1.0 } else { 1.0 };
@@ -237,17 +318,17 @@ impl Spin {
/// Where point (`x`, `y`) goes when turned about (`cx`, `cy`).
pub fn apply(&self, cx: f32, cy: f32, x: f32, y: f32) -> (f32, f32) {
let [a, b, c, d] = self.linear();
let (u, v) = (x - cx, y - cy);
(cx + a * u + c * v, cy + b * u + d * v)
let [x_from_x, y_from_x, x_from_y, y_from_y] = self.linear();
let (relative_x, relative_y) = (x - cx, y - cy);
(cx + x_from_x * relative_x + x_from_y * relative_y, cy + y_from_x * relative_x + y_from_y * relative_y)
}
/// The point that [`Spin::apply`] takes to (`x`, `y`).
pub fn unapply(&self, cx: f32, cy: f32, x: f32, y: f32) -> (f32, f32) {
// The linear part is orthogonal: its inverse is its transpose.
let [a, b, c, d] = self.linear();
let (u, v) = (x - cx, y - cy);
(cx + a * u + b * v, cy + c * u + d * v)
let [x_from_x, y_from_x, x_from_y, y_from_y] = self.linear();
let (relative_x, relative_y) = (x - cx, y - cy);
(cx + x_from_x * relative_x + y_from_x * relative_y, cy + x_from_y * relative_x + y_from_y * relative_y)
}
/// The axis-aligned box `r` covers once turned about its centre.
@@ -258,10 +339,10 @@ impl Spin {
/// The width and height of the box a `w` × `h` rectangle covers once turned.
pub fn extent(&self, w: f32, h: f32) -> (f32, f32) {
let (w, h) = (finite(w).abs(), finite(h).abs());
let r = normalize_degrees(self.deg).to_radians();
let (s, c) = (r.sin().abs(), r.cos().abs());
(w * c + h * s, w * s + h * c)
let (width, height) = (finite(w).abs(), finite(h).abs());
let radians = normalize_degrees(self.deg).to_radians();
let (sine, cosine) = (radians.sin().abs(), radians.cos().abs());
(width * cosine + height * sine, width * sine + height * cosine)
}
/// This spin applied inside `outer` (a group member's own spin within its group's): the one
@@ -307,13 +388,15 @@ pub fn paper_by_name(name: &str) -> Option<(&'static str, f32, f32)> {
/// How a page is placed on other paper when printing with "Scale to paper size" (#2108).
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct PaperFit {
/// The sheet, turned to the page's orientation (points).
/// The sheet's width, turned to the page's orientation (points).
pub paper_w: f32,
/// The sheet's height, turned to the page's orientation (points).
pub paper_h: f32,
/// Page points to sheet points.
pub k: f32,
/// Where the page's top-left corner lands on the sheet (the page is centred).
/// Where the page's left edge lands on the sheet (the page is centred).
pub dx: f32,
/// Where the page's top edge lands on the sheet (the page is centred).
pub dy: f32,
}
@@ -323,7 +406,7 @@ pub struct PaperFit {
/// page as it is (scale 1 on paper of its own size).
pub fn fit_to_paper(page_w: f32, page_h: f32, paper_w: f32, paper_h: f32) -> PaperFit {
let ok = |v: f32| v.is_finite() && v >= 1.0;
let as_is = PaperFit { paper_w: page_w, paper_h: page_h, k: 1.0, dx: 0.0, dy: 0.0 };
let as_is = PaperFit { paper_w: finite(page_w), paper_h: finite(page_h), k: 1.0, dx: 0.0, dy: 0.0 };
if !(ok(page_w) && ok(page_h) && ok(paper_w) && ok(paper_h)) {
return as_is;
}
@@ -341,13 +424,17 @@ pub fn fit_to_paper(page_w: f32, page_h: f32, paper_w: f32, paper_h: f32) -> Pap
mod tests {
use super::*;
fn close(a: f32, b: f32) -> bool {
(a - b).abs() < 1e-3
}
#[test]
fn unit_round_trips() {
assert_eq!(twips(1440), 72.0);
assert_eq!(twips(1440).to_bits(), 72.0f32.to_bits());
assert_eq!(to_twips(72.0), 1440);
assert_eq!(emu(914_400), 72.0);
assert_eq!(emu(914_400).to_bits(), 72.0f32.to_bits());
assert_eq!(to_emu(72.0), 914_400);
assert_eq!(half_points(24), 12.0);
assert_eq!(half_points(24).to_bits(), 12.0f32.to_bits());
assert_eq!(to_half_points(10.5), 21);
assert_eq!(to_twips(f32::NAN), 0);
}
@@ -359,6 +446,7 @@ mod tests {
assert_eq!(parse_measure("12pt", Unit::Inches), Some(12.0));
assert_eq!(parse_measure("2", Unit::Inches), Some(144.0));
assert_eq!(parse_measure("1,5 li", Unit::Inches), Some(18.0));
assert_eq!(parse_measure("8 px", Unit::Inches), Some(6.0));
let cm = parse_measure("2.54 cm", Unit::Inches).unwrap();
assert!((cm - 72.0).abs() < 0.01);
assert_eq!(parse_measure("abc", Unit::Inches), None);
@@ -371,19 +459,29 @@ mod tests {
assert_eq!(parse_measure("1.5\"", Unit::Centimeters), Some(108.0));
assert_eq!(parse_measure("\u{2212}1 in", Unit::Points), Some(-72.0));
assert_eq!(parse_measure("1,2,3", Unit::Inches), None);
// Overflowing values during unit conversion return None (#1359).
// A comma is a decimal separator, never a thousands separator.
assert_eq!(parse_measure("1,000 pt", Unit::Inches), Some(1.0));
// Scientific notation is not accepted: the number stops at the `e`, leaving an unknown
// unit. (Overflow itself is covered by `parse_measure_rejects_overflow_to_infinity`.)
assert_eq!(parse_measure("1e3 pt", Unit::Points), None);
assert_eq!(parse_measure("3.4e38 in", Unit::Points), None);
assert_eq!(parse_measure("-3.4e38 in", Unit::Points), None);
assert_eq!(parse_measure("3.4e38 cm", Unit::Points), None);
assert_eq!(parse_measure("3.4e38 mm", Unit::Points), None);
assert_eq!(parse_measure("3.4e38 pi", Unit::Points), None);
assert_eq!(parse_measure("3.4e38 li", Unit::Points), None);
assert_eq!(parse_measure("3.4e38", Unit::Inches), None);
assert_eq!(parse_measure("1e39 pt", Unit::Points), None);
assert_eq!(parse_measure("inf", Unit::Points), None);
assert_eq!(parse_measure("nan", Unit::Points), None);
}
#[test]
fn parses_digits_of_other_scripts() {
let two_cm = parse_measure("2 cm", Unit::Inches).unwrap();
assert_eq!(parse_measure("\u{0662} cm", Unit::Inches), Some(two_cm)); // Arabic-Indic ٢
assert_eq!(parse_measure("\u{06F2} cm", Unit::Inches), Some(two_cm)); // Extended ۲
assert_eq!(parse_measure("\u{FF12} cm", Unit::Inches), Some(two_cm)); // Full-width 2
let two_and_half = parse_measure("2.5 cm", Unit::Inches).unwrap();
assert_eq!(parse_measure("\u{0662}\u{066B}\u{0665} cm", Unit::Inches), Some(two_and_half)); // ٢٫٥
assert_eq!(parse_measure("\u{FF12}\u{FF0E}\u{FF15}cm", Unit::Inches), Some(two_and_half)); // 2.5
assert_eq!(parse_measure("\u{0663}", Unit::Points), Some(3.0));
}
#[test]
fn parse_measure_rejects_overflow_to_infinity() {
// Finite inputs whose scaled result overflows `f32` must be rejected,
@@ -420,6 +518,10 @@ mod tests {
assert_eq!(Unit::Inches.format_with(108.0, ','), "1,5\"");
assert_eq!(Unit::Points.format_with(720.0, ','), "720 pt");
assert_eq!(Unit::Inches.format_with(f32::NAN, ','), "0\"");
// A tiny negative value must not print as "-0".
assert_eq!(Unit::Points.format(-0.001), "0 pt");
// Any character can be the separator.
assert_eq!(Unit::Inches.number(108.0, '\u{066B}'), "1\u{066B}5");
}
#[test]
@@ -429,10 +531,106 @@ mod tests {
assert!(a.intersects(&b));
assert_eq!(a.union(&b), Rect::new(0.0, 0.0, 15.0, 15.0));
assert!(a.contains(Point::new(5.0, 5.0)));
assert_eq!(Rect::new(0.0, 0.0, -5.0, f32::NAN).w, 0.0);
assert_eq!(Rect::new(0.0, 0.0, -5.0, f32::NAN).w.to_bits(), 0.0f32.to_bits());
assert_eq!(a.inset(1.0, 2.0, 3.0, 4.0), Rect::new(1.0, 2.0, 6.0, 4.0));
}
#[test]
fn rect_edges_are_in_contains_but_not_intersects() {
let a = Rect::new(0.0, 0.0, 10.0, 10.0);
let b = Rect::new(10.0, 0.0, 10.0, 10.0); // shares the edge x = 10
assert!(!a.intersects(&b));
assert!(a.contains(Point::new(10.0, 5.0)) && b.contains(Point::new(10.0, 5.0)));
}
#[test]
fn inset_past_zero_collapses_to_center() {
let r = Rect::new(0.0, 0.0, 10.0, 10.0);
assert_eq!(r.inset(8.0, 8.0, 8.0, 8.0), Rect::new(5.0, 5.0, 0.0, 0.0));
assert_eq!(r.expand(-8.0), Rect::new(5.0, 5.0, 0.0, 0.0));
assert_eq!(r.expand(-20.0), Rect::new(5.0, 5.0, 0.0, 0.0));
// Only one axis crosses: the other keeps its size.
assert_eq!(r.inset(0.0, 8.0, 0.0, 8.0), Rect::new(0.0, 5.0, 10.0, 0.0));
// Growing still works, and hostile insets are ignored rather than poisoning the result.
assert_eq!(r.expand(1.0), Rect::new(-1.0, -1.0, 12.0, 12.0));
assert_eq!(r.inset(f32::NAN, 0.0, 0.0, 0.0), r);
}
#[test]
fn rect_from_raw_is_sanitised() {
// Deserialization goes through this conversion (`#[serde(from = "RectRaw")]`).
let r = Rect::from(RectRaw { x: f32::NAN, y: 1.0, w: -4.0, h: f32::INFINITY });
assert_eq!(r, Rect::new(0.0, 1.0, 0.0, 0.0));
let ok = Rect::from(RectRaw { x: 1.0, y: 2.0, w: 3.0, h: 4.0 });
assert_eq!(ok, Rect::new(1.0, 2.0, 3.0, 4.0));
}
#[test]
fn rects_are_cleaned_when_deserialized() {
use serde::de::value::{Error, MapDeserializer};
let fields = [("x", f32::NAN), ("y", 1.0), ("w", -5.0), ("h", 2.0)];
let parsed: Result<Rect, Error> = Rect::deserialize(MapDeserializer::new(fields.into_iter()));
assert!(parsed.is_ok());
assert_eq!(parsed.unwrap_or_default(), Rect::new(0.0, 1.0, 0.0, 2.0));
}
#[test]
fn spin_apply_and_unapply_are_inverse() {
for spin in [
Spin::new(0.0, false, false),
Spin::new(37.0, false, false),
Spin::new(90.0, true, false),
Spin::new(215.0, false, true),
Spin::new(300.0, true, true),
] {
let (x, y) = spin.apply(50.0, 40.0, 70.0, 10.0);
let (bx, by) = spin.unapply(50.0, 40.0, x, y);
assert!(close(bx, 70.0) && close(by, 10.0), "{spin:?}");
}
}
#[test]
fn a_quarter_turn_is_clockwise_in_page_space() {
// y points down, so the point to the right of the centre goes below it.
let (x, y) = Spin::new(90.0, false, false).apply(0.0, 0.0, 10.0, 0.0);
assert!(x.abs() < 1e-4 && (y - 10.0).abs() < 1e-4);
}
#[test]
fn within_equals_applying_both_spins() {
let (outer, inner) = (Spin::new(30.0, true, false), Spin::new(75.0, false, true));
let (ix, iy) = inner.apply(0.0, 0.0, 12.0, -7.0);
let (ex, ey) = outer.apply(0.0, 0.0, ix, iy);
let (bx, by) = inner.within(outer).apply(0.0, 0.0, 12.0, -7.0);
assert!(close(ex, bx) && close(ey, by));
}
#[test]
fn spin_matrix_agrees_with_apply() {
let spin = Spin::new(37.0, true, false);
let [a, b, c, d, e, f] = spin.matrix(50.0, 40.0);
let (x, y) = spin.apply(50.0, 40.0, 70.0, 10.0);
assert!(close(a * 70.0 + c * 10.0 + e, x) && close(b * 70.0 + d * 10.0 + f, y));
// The centre stays where it is.
let (cx, cy) = spin.apply(50.0, 40.0, 50.0, 40.0);
assert!(close(cx, 50.0) && close(cy, 40.0));
}
#[test]
fn spin_bounds_and_identity() {
assert!(Spin::default().is_identity());
assert!(Spin::new(360.0, false, false).is_identity());
assert!(!Spin::new(0.0, true, false).is_identity());
let b = Spin::new(90.0, false, false).bounds(Rect::new(0.0, 0.0, 10.0, 20.0));
assert!(close(b.x, -5.0) && close(b.y, 5.0) && close(b.w, 20.0) && close(b.h, 10.0));
}
#[test]
fn normalises_degrees() {
assert_eq!(normalize_degrees(370.0), 10.0);
assert_eq!(normalize_degrees(-90.0), 270.0);
assert_eq!(normalize_degrees(f32::NAN), 0.0);
assert!((0.0..360.0).contains(&normalize_degrees(-1e-9)));
}
#[test]
fn paper_names() {
assert_eq!(paper_name(612.0, 792.0), Some("Letter"));
@@ -468,6 +666,7 @@ mod tests {
{
let f = fit_to_paper(a, b, c, d);
assert_eq!((f.k, f.dx, f.dy), (1.0, 0.0, 0.0));
assert!(f.paper_w.is_finite() && f.paper_h.is_finite());
}
assert!(fit_to_paper(1.0, 1.0, f32::MAX, f32::MAX).k.is_finite());
}
+29 -33
View File
@@ -20,9 +20,9 @@ pub enum Refusal {
NotAPicture,
/// A kind of picture that is never decoded, because its decoder can't be held to a budget.
Unsupported(&'static str),
/// Decoding it would take more memory than the budget.
/// Decoding would exceed the memory budget or size arithmetic overflowed.
TooLarge { width: u32, height: u32 },
/// The header or the data is damaged.
/// The header or data is damaged, or the decoder rejects the input.
Broken(String),
}
@@ -179,11 +179,19 @@ pub struct Probe<'a> {
}
/// TIFF compressions decoded within the caller's limits: none, CCITT Group 4, LZW, Deflate (both
/// codes) and PackBits. The `tiff` crate decodes a JPEG strip (7) with a decoder of its own and
/// codes) and `PackBits`. The `tiff` crate decodes a JPEG strip (7) with a decoder of its own and
/// default limits, whatever size the TIFF declares, so such a TIFF is not decoded (#3645).
const TIFF_COMPRESSIONS: [u16; 6] = [1, 4, 5, 8, 32946, 32773];
/// Read a picture's header: PNG, JPEG, GIF, WebP, BMP or TIFF.
///
/// # Errors
///
/// Returns `Refusal::NotAPicture` for an unsupported format, `Refusal::Unsupported` for a TIFF
/// whose compression cannot be read or budgeted (including truncation that prevents reading
/// its compression metadata), `Refusal::TooLarge`
/// on size arithmetic overflow, and `Refusal::Broken` for other header or inspection errors,
/// including TIFF errors after compression metadata is accepted.
pub fn probe(bytes: &[u8]) -> Result<Probe<'_>, Refusal> {
let codec_fmt = detect(bytes).ok_or(Refusal::NotAPicture)?;
let format = from_codec_format(codec_fmt).ok_or(Refusal::NotAPicture)?;
@@ -287,6 +295,11 @@ fn dib_to_bmp(dib: &[u8]) -> Vec<u8> {
/// Read a DIB's header: a BMP without its 14-byte file header, as the Windows clipboard holds
/// one (`CF_DIB`, `CF_DIBV5`). Its layout is first made the one the decoder reads (see
/// [`dib_layout`]).
///
/// # Errors
///
/// Returns `Refusal::Broken` for an invalid DIB header and `Refusal::TooLarge` on size arithmetic
/// overflow.
pub fn probe_dib(dib: Vec<u8>) -> Result<Probe<'static>, Refusal> {
let dib = dib_layout(dib);
let bmp = dib_to_bmp(&dib);
@@ -349,6 +362,12 @@ impl Probe<'_> {
/// Decode, refused before anything is allocated when the peak would pass `budget` bytes. The
/// decoder is held to the header's size and to `budget` as well.
///
/// # Errors
///
/// Returns `Refusal::TooLarge` when the picture does not fit `budget` or the decoder
/// exceeds its limits, `Refusal::NotAPicture` for an unsupported format, and
/// `Refusal::Broken` for other decoding or pixel-conversion errors.
pub fn decode(&self, budget: u64) -> Result<DynamicImage, Refusal> {
if !self.fits(budget) {
return Err(Refusal::TooLarge { width: self.width, height: self.height });
@@ -364,6 +383,10 @@ impl Probe<'_> {
}
/// [`probe`], then [`Probe::decode`] within `budget` bytes.
///
/// # Errors
///
/// Returns the probing or decoding `Refusal`; see [`probe`] and [`Probe::decode`].
pub fn decode(bytes: &[u8], budget: u64) -> Result<DynamicImage, Refusal> {
probe(bytes)?.decode(budget)
}
@@ -516,36 +539,7 @@ fn worst_coefficients(bytes: &[u8]) -> u64 {
/// tag is missing. None when the header can't be read, or when the tag appears more than once:
/// the decoder keeps the last copy, so a harmless first one must not hide a JPEG one after it.
fn tiff_compression(bytes: &[u8]) -> Option<u16> {
let le = match bytes.get(..4)? {
b"II*\0" => true,
b"MM\0*" => false,
_ => return None,
};
let u16_at = |at: usize| -> Option<u16> {
let b = [*bytes.get(at)?, *bytes.get(at.checked_add(1)?)?];
Some(if le { u16::from_le_bytes(b) } else { u16::from_be_bytes(b) })
};
let u32_at = |at: usize| -> Option<u32> {
let b: [u8; 4] = bytes.get(at..at.checked_add(4)?)?.try_into().ok()?;
Some(if le { u32::from_le_bytes(b) } else { u32::from_be_bytes(b) })
};
let ifd = usize::try_from(u32_at(4)?).ok()?;
let mut found = None;
for i in 0..usize::from(u16_at(ifd)?) {
let entry = ifd.checked_add(2)?.checked_add(i.checked_mul(12)?)?;
if u16_at(entry)? != 259 {
continue;
}
if found.is_some() || u32_at(entry.checked_add(4)?)? != 1 {
return None;
}
found = Some(match u16_at(entry.checked_add(2)?)? {
3 => u16_at(entry.checked_add(8)?)?,
4 => u16::try_from(u32_at(entry.checked_add(8)?)?).ok()?,
_ => return None,
});
}
Some(found.unwrap_or(1))
craft_tiff::probe::first_image_compression(bytes)
}
/// A DIB with a V4 or V5 header in the layout the decoder reads. A 32-bit one whose alpha mask
@@ -722,6 +716,7 @@ mod tests {
let mut s = vec![8];
s.extend(h.to_be_bytes());
s.extend(w.to_be_bytes());
#[expect(clippy::cast_possible_truncation, reason = "These fixtures contain at most four three-byte component records.")]
s.push((comps.len() / 3) as u8);
s.extend(comps);
s
@@ -736,6 +731,7 @@ mod tests {
// A marker walk over SOI, an APP0 segment, SOF2, then the scan.
let mut jpeg = vec![0xFF, 0xD8, 0xFF, 0xE0, 0, 4, 0, 0, 0xFF, 0xC2];
let f = sof(64, 64, &[1, 0x11, 0]);
#[expect(clippy::cast_possible_truncation, reason = "This fixture's nine-byte frame header and length field fit u16.")]
jpeg.extend(((f.len() + 2) as u16).to_be_bytes());
jpeg.extend(&f);
jpeg.extend([0xFF, 0xDA]);
+22 -10
View File
@@ -9,7 +9,7 @@ pub const MAX_RASTER_PIXELS: u64 = 100_000_000;
/// Bytes of a `w`×`h` RGBA8 raster, None on overflow.
pub fn rgba_bytes(w: u32, h: u32) -> Option<u64> {
(w as u64).checked_mul(h as u64)?.checked_mul(4)
u64::from(w).checked_mul(u64::from(h))?.checked_mul(4)
}
/// Whether a `w`×`h` RGBA8 raster fits `budget` bytes.
@@ -29,22 +29,34 @@ pub fn decode_fits(w: u32, h: u32, budget: u64) -> bool {
/// premultiplied copy, so the peak is the larger of `native + 4` and `8` bytes a pixel.
pub fn decode_peak_fits(w: u32, h: u32, native: u64, budget: u64) -> bool {
let per_pixel = native.saturating_add(4).max(8);
w > 0 && h > 0 && (w as u64).checked_mul(h as u64).and_then(|p| p.checked_mul(per_pixel)).is_some_and(|b| b <= budget)
w > 0 && h > 0 && u64::from(w).checked_mul(u64::from(h)).and_then(|p| p.checked_mul(per_pixel)).is_some_and(|b| b <= budget)
}
/// `w`×`h` shrunk (aspect kept, each side at least 1) until it holds at most `max_pixels`.
pub fn fit_pixels(w: u32, h: u32, max_pixels: u64) -> (u32, u32) {
let (w, h) = (w.max(1), h.max(1));
let max_pixels = max_pixels.max(1);
let area = w as u64 * h as u64;
let area = u64::from(w) * u64::from(h);
if area <= max_pixels {
return (w, h);
}
let f = (max_pixels as f64 / area as f64).sqrt();
let nh = ((h as f64 * f) as u64).clamp(1, h as u64);
let nw = ((w as f64 * f) as u64).clamp(1, w as u64).min(max_pixels / nh).max(1);
let nh = nh.min(max_pixels / nw).max(1);
(nw as u32, nh as u32)
#[expect(clippy::cast_precision_loss, reason = "Floating point only approximates the scale; the integer clamps below enforce every bound.")]
let scale = (max_pixels as f64 / area as f64).sqrt();
#[expect(
clippy::cast_possible_truncation,
clippy::cast_sign_loss,
reason = "The scale is finite and within 0..=1; truncation floors a positive dimension before clamping."
)]
let new_height = ((f64::from(h) * scale) as u64).clamp(1, u64::from(h));
#[expect(
clippy::cast_possible_truncation,
clippy::cast_sign_loss,
reason = "The scale is finite and within 0..=1; truncation floors a positive dimension before clamping."
)]
let new_width = ((f64::from(w) * scale) as u64).clamp(1, u64::from(w)).min(max_pixels / new_height).max(1);
let new_height = new_height.min(max_pixels / new_width).max(1);
#[expect(clippy::cast_possible_truncation, reason = "Both dimensions are clamped to their original u32 values above.")]
(new_width as u32, new_height as u32)
}
#[cfg(test)]
@@ -78,9 +90,9 @@ mod tests {
fn fit_pixels_keeps_normal_sizes_and_shrinks_huge_ones() {
assert_eq!(fit_pixels(612, 792, MAX_RASTER_PIXELS), (612, 792));
let (w, h) = fit_pixels(16_000, 16_000, 1_000_000);
assert!(w as u64 * h as u64 <= 1_000_000 && w >= 900, "{w}x{h}");
assert!(u64::from(w) * u64::from(h) <= 1_000_000 && w >= 900, "{w}x{h}");
let (w, h) = fit_pixels(16_000, 1, 100);
assert!(w as u64 * h as u64 <= 100 && h == 1, "{w}x{h}");
assert!(u64::from(w) * u64::from(h) <= 100 && h == 1, "{w}x{h}");
assert_eq!(fit_pixels(0, 5, 10).0, 1);
}
}
+1 -1
View File
@@ -307,7 +307,7 @@ fn decode_alpha(bytes: &[u8], decoded: &mut u64) -> Result<Option<Alpha>, OverBu
fn alpha_in_crop(img: &Alpha, crop: [f32; 4]) -> Option<Vec<(f32, f32)>> {
let (iw, ih) = (img.w, img.h);
// The part the renderers draw (#1899): a sliver keeps its partly covered pixels.
let [cl, ct, vw, vh] = craft_metafile::crop_window(crop);
let [cl, ct, vw, vh] = crate::crop_window(crop);
let (fw, fh) = (f64::from(iw), f64::from(ih));
let x0 = ((fw * cl) as u32).min(iw);
let y0 = ((fh * ct) as u32).min(ih);
+53 -4
View File
@@ -470,12 +470,41 @@ fn character_backgrounds(ctx: &LineContext<'_, '_, '_>, out: &mut Vec<Draw>) {
}
fn draw_label_and_hyphen(ctx: &LineContext<'_, '_, '_>, out: &mut Vec<Draw>) {
// A list number goes with its paragraph mark: when the mark is a tracked deletion the number
// is drawn as deleted text is, in the deletion's colour and with its mark (struck through by
// default, a caret, #s, bold…), and not at all where deletions aren't shown (#4828). Only
// when the item is deleted whole, its text too: a deleted mark alone joins the item to the
// next one, and its text and number stay as they are.
let m = &ctx.opts.revisions;
let whole = ctx.para.is_some_and(|p| p.runs.iter().all(|r| r.len == 0 || r.props.del.is_some()));
let mark_del = ctx.para.filter(|_| whole).and_then(|p| p.mark.del);
let moved = mark_del.is_some() && ctx.doc.move_name(mark_del).is_some();
let hidden = mark_del.is_some() && (!ctx.opts.markup || m.hides_deletion(moved));
let deleted = mark_del.filter(|_| ctx.opts.markup && m.insertions_deletions);
let del_mark = deleted.map(|_| if moved { m.move_from_mark } else { m.delete_mark });
// Moved-away text marked (none) is plain text, and so is its number.
let plain_move = moved && del_mark == Some(DeleteMark::None);
let del_color =
deleted.filter(|_| !plain_move).map(|r| if moved { m.move_from_color } else { m.delete_color }.unwrap_or_else(|| ctx.authors.color(r)));
if ctx.li == ctx.pl.label_line()
&& !hidden
&& let Some(label) = &ctx.pl.label
{
let gx = ctx.x + label.x;
let first = label.runs.first().and_then(|r| ctx.pl.styles.get(r.style as usize));
if let (Some(DeleteMark::Caret), Some(color), Some(style)) = (del_mark, del_color, first) {
// A caret where the number was, instead of the number.
let (h, w, y) = (style.size * 0.3, (style.size / 18.0).max(0.6), ctx.base + 1.0);
for (x0, y0, x1, y1) in [(gx - h * 0.6, y, gx, y - h), (gx, y - h, gx + h * 0.6, y)] {
out.push(Draw::Line { x0, y0, x1, y1, width: w, color, stroke: Stroke::Solid, alpha: ctx.alpha, text_bg: None });
}
return draw_hyphen(ctx, out);
}
for run in &label.runs {
let Some(style) = ctx.pl.styles.get(run.style as usize) else { continue };
let color = del_color.unwrap_or_else(|| ctx.ink(&style.rc.color, None));
// Each deleted character shows as #.
let hash = (del_mark == Some(DeleteMark::Hash)).then(|| style.face.glyph_for('#'));
out.push(Draw::Glyphs {
face: style.face,
size: style.size,
@@ -484,12 +513,12 @@ fn draw_label_and_hyphen(ctx: &LineContext<'_, '_, '_>, out: &mut Vec<Draw>) {
.get(run.glyphs.clone())
.into_iter()
.flatten()
.map(|g| (g.gid, gx + g.dx, ctx.base - style.shift - g.dy))
.map(|g| (hash.unwrap_or(g.gid), gx + g.dx, ctx.base - style.shift - g.dy))
.collect(),
color: ctx.ink(&style.rc.color, None),
color,
alpha: ctx.alpha,
synth_bold: style.synth_bold,
synth_italic: style.synth_italic,
synth_bold: style.synth_bold || del_mark == Some(DeleteMark::Bold),
synth_italic: style.synth_italic || del_mark == Some(DeleteMark::Italic),
text: run.text.clone(),
link: None,
ranges: Vec::new(),
@@ -497,7 +526,27 @@ fn draw_label_and_hyphen(ctx: &LineContext<'_, '_, '_>, out: &mut Vec<Draw>) {
x_scale: 1.0,
});
}
// Struck through or underlined once, across the whole number, in its first run's size.
if let (Some(color), Some(mark), Some(style)) = (del_color, del_mark, first) {
let strike_y = ctx.base - style.shift - style.size * 0.28;
let under_y = ctx.base - style.shift + style.size * 0.12;
let line = match mark {
DeleteMark::Strikethrough => Some((strike_y, Stroke::Solid)),
DeleteMark::DoubleStrikethrough => Some((strike_y, Stroke::Double)),
DeleteMark::Underline => Some((under_y, Stroke::Solid)),
DeleteMark::DoubleUnderline => Some((under_y, stroke_of(Underline::Double))),
_ => None,
};
if let Some((y, stroke)) = line {
let width = (style.size / 18.0).max(0.5);
out.push(Draw::Line { x0: gx, y0: y, x1: gx + label.width, y1: y, width, color, stroke, alpha: ctx.alpha, text_bg: None });
}
}
}
draw_hyphen(ctx, out);
}
fn draw_hyphen(ctx: &LineContext<'_, '_, '_>, out: &mut Vec<Draw>) {
if let Some((style_index, glyph, advance)) = ctx.line.hyphen
&& let Some(style) = ctx.pl.styles.get(style_index as usize)
{
+11 -5
View File
@@ -718,12 +718,18 @@ pub(crate) fn place_objects(ctx: &mut Ctx, req: &ObjectPlacement) -> (Vec<Placed
// (#4250). Inline objects go with their own line.
let first = l0 == 0;
let late = at.late.filter(|l| !l.placed.is_empty());
let late_lines = late.map(LateFloats::lines_here).unwrap_or_default();
for li in 0..pl.lines.len() {
// A later piece looks only at its own lines and those holding the anchors of the late floats
// it draws, in order: walking every line of the paragraph for each piece made a paragraph of
// many pages quadratic (#6757).
let (piece, mut late_lines) =
if first { (0..pl.lines.len(), Vec::new()) } else { (l0..l1.min(pl.lines.len()), late.map(LateFloats::lines_here).unwrap_or_default()) };
late_lines.retain(|li| !piece.contains(li));
late_lines.sort_unstable();
late_lines.dedup();
let (before, after) = late_lines.split_at(late_lines.partition_point(|li| *li < piece.start));
for li in before.iter().copied().chain(piece).chain(after.iter().copied()) {
crate::work::steps(1);
let in_piece = (l0..l1).contains(&li);
if !in_piece && !first && !late_lines.contains(&li) {
continue;
}
let Some(line) = pl.lines.get(li) else { continue };
for k in line.c0..line.c1 {
let Some(c) = pl.clusters.get(k) else { continue };
+7 -3
View File
@@ -292,9 +292,13 @@ fn hf_text_at(p: &Page, id: u32, x: f32, y: f32) -> bool {
_ => None,
})
.any(|(para, l0, l1, lx, ly)| {
let (Some(first), Some(last)) = (para.lines.get(*l0), para.lines.get(l1.checked_sub(1).unwrap_or(0))) else { return false };
let bottom = ly + last.top + last.height - first.top;
y >= *ly - 2.0 && y <= bottom + 2.0 && x >= *lx - 40.0 && x <= lx + last.right + 40.0
let Some(first) = para.lines.get(*l0) else { return false };
// Each line has its own band and extent: lines beside a float are shorter than the
// ones above them, and a click on a long line past a short one's end is still text.
(*l0..*l1).filter_map(|li| para.lines.get(li)).any(|l| {
let top = ly + l.top - first.top;
y >= top - 2.0 && y <= top + l.height + 2.0 && x >= lx + l.left - 40.0 && x <= lx + l.right + 40.0
})
})
}
+2
View File
@@ -59,6 +59,7 @@ mod ctx;
mod floats;
mod flow;
mod headers;
mod metafile;
mod missing;
mod notes;
mod page;
@@ -85,6 +86,7 @@ use headers::MAX_HEADER_ITEMS;
#[cfg(test)]
use headers::placed_cost;
use headers::placed_cost_by;
pub use metafile::{MAX_METAFILE_DASHES, crop_sides, crop_window, metafile_average_color, metafile_dashes, metafile_miter_limit};
pub use missing::{MAX_MISSING_GLYPHS, MissingGlyphs, metafile_text_run, missing_watermark_glyphs, watermark_run};
pub use notes::DECOR_STORY;
pub(crate) use notes::NOTE_SEP_W;
+75
View File
@@ -0,0 +1,75 @@
//! Drawing rules the page renderer and the PDF export share for metafile pictures and picture
//! crops, so the two outputs draw the same file the same way.
/// Most dashes and gaps one metafile stroke is split into. A path that a pen's pattern would split
/// into more draws solid.
pub const MAX_METAFILE_DASHES: f64 = 100_000.0;
/// The crop sides a picture is drawn with: each side of `crop` (left, top, right, bottom fractions
/// of the source) at least 0. A negative side draws as no crop, not as padding around the source.
pub fn crop_sides(crop: [f32; 4]) -> [f32; 4] {
crop.map(|v| if v.is_finite() { v.max(0.0) } else { 0.0 })
}
/// The part of a picture's source that `crop` keeps, as fractions of the source: [left, top,
/// width, height] (`craft_metafile::crop_window` of [`crop_sides`]).
pub fn crop_window(crop: [f32; 4]) -> [f64; 4] {
craft_metafile::crop_window(crop_sides(crop))
}
/// The miter limit a metafile pen is drawn with: its own when it is finite and at least 1,
/// otherwise 10.
pub fn metafile_miter_limit(limit: f32) -> f32 {
if limit.is_finite() && limit >= 1.0 { limit } else { 10.0 }
}
/// The dash lengths (page points) a metafile pen draws a path `length` points long with, or None
/// for a solid line. `dash` is the placed pen's pattern (`craft_metafile::LineStyle::dash`, page
/// points) and `pixel` is one output pixel in points.
///
/// A cosmetic pen (`cosmetic`: width 0) has its pattern scaled so that its shortest dash or gap is
/// one pixel, at any zoom. A pattern with a negative or non-finite length draws solid, and so does
/// one whose period is shorter than a pixel or that would split the path into more than
/// [`MAX_METAFILE_DASHES`] dashes and gaps.
pub fn metafile_dashes(dash: &[f32], cosmetic: bool, pixel: f64, length: f64) -> Option<Vec<f64>> {
if dash.is_empty() || !pixel.is_finite() || pixel <= 0.0 {
return None;
}
let mut out: Vec<f64> = dash.iter().map(|d| f64::from(*d)).collect();
if !out.iter().all(|d| d.is_finite() && *d >= 0.0) {
return None;
}
if cosmetic {
let shortest = out.iter().copied().filter(|d| *d > 0.0).fold(f64::INFINITY, f64::min);
if !shortest.is_finite() {
return None;
}
let k = pixel / shortest;
out.iter_mut().for_each(|d| *d *= k);
}
let period: f64 = out.iter().sum();
if !period.is_finite() || period < pixel {
return None;
}
// Each length of the pattern starts a new dash or gap.
let pieces = out.len() as f64 * if length.is_finite() { length.max(0.0) / period } else { f64::INFINITY };
(pieces <= MAX_METAFILE_DASHES).then_some(out)
}
/// The alpha-weighted average color of straight RGBA pixels (transparent when there are none): a
/// metafile pattern fill whose tile is too small to show is filled with it.
pub fn metafile_average_color(px: &[u8]) -> [u8; 4] {
let (mut r, mut g, mut b, mut a, mut n) = (0u64, 0u64, 0u64, 0u64, 0u64);
for p in px.as_chunks::<4>().0 {
let w = u64::from(p[3]);
r += u64::from(p[0]) * w;
g += u64::from(p[1]) * w;
b += u64::from(p[2]) * w;
a += w;
n += 1;
}
if a == 0 || n == 0 {
return [0; 4];
}
[(r / a) as u8, (g / a) as u8, (b / a) as u8, (a / n) as u8]
}
+36 -13
View File
@@ -151,13 +151,37 @@ pub fn watermark_run(wm: &wordcraft_doc::Watermark, max_chars: usize) -> Option<
/// in the face its font name resolves to (no fallback face), so a character that face lacks shapes
/// to glyph id 0. Strict export checks these same glyphs, so the check and the exporters can't
/// drift.
pub fn metafile_text_run(t: &craft_metafile::Text) -> (wordcraft_fonts::FaceRef, Vec<ShapedGlyph>) {
let family = t.font.family.trim();
let family = if family.is_empty() { METAFILE_DEFAULT_FONT } else { family };
let face = wordcraft_fonts::word::resolve(family, t.font.weight >= 600, t.font.italic).face;
let shaped = wordcraft_fonts::shape(&face, &t.text, &[], |c| c);
(face, shaped)
}
/// The face a metafile font with no face name is drawn in.
const METAFILE_DEFAULT_FONT: &str = "Arial";
/// The cell height (text units) of a metafile font whose height is 0, the file's default size.
const METAFILE_DEFAULT_HEIGHT: f64 = 16.0;
/// A metafile text run laid out with a font's metrics: the em size (text units), the baseline's y
/// and each glyph's (x, y), alignment included, in the run's text space (see
/// `craft_metafile::Text::transform`).
pub struct MetafileTextLayout {
pub em: f64,
pub baseline: f64,
pub glyphs: Vec<(f64, f64)>,
/// The rectangle of the character cells (x0, y0, x1, y1): from the leftmost to the rightmost
/// pen position of the run, the font's ascent above the baseline and its descent below. An
/// opaque background fills it.
pub cell: [f64; 4],
}
/// Lay out shaped glyphs for a metafile text run.
/// Lays out the shaped glyphs of `t`, given as (cluster byte offset, x advance, x offset, y offset)
/// in font units of a font with `upem` units per em, `ascent` above and `descent` below the
/// baseline. The font height is the em size when negative and the cell height (ascent plus
/// descent) when positive. The per-character advances `dx` place each cluster when there is one
/// per character. None when the size is not finite and positive.
pub fn layout_metafile_text(
t: &craft_metafile::Text,
upem: f64,
@@ -166,10 +190,9 @@ pub fn layout_metafile_text(
glyphs: &[(usize, f64, f64, f64)],
) -> Option<MetafileTextLayout> {
let upem = if upem.is_finite() && upem > 0.0 { upem } else { 1000.0 };
let cell_h = ascent + descent;
let size = if t.font.height == 0.0 { 12.0 } else { f64::from(t.font.height.abs()) };
let cell = t.font.height > 0.0;
let em = if cell && cell_h.is_finite() && cell_h > 0.0 { size * upem / cell_h } else { size };
let height = if t.font.height == 0.0 { METAFILE_DEFAULT_HEIGHT } else { f64::from(t.font.height) };
let cell = ascent + descent;
let em = if height > 0.0 && cell.is_finite() && cell > 0.0 { height * upem / cell } else { height.abs() };
if !em.is_finite() || em <= 0.0 {
return None;
}
@@ -187,6 +210,8 @@ pub fn layout_metafile_text(
});
let mut out = Vec::with_capacity(glyphs.len());
let (mut pen, mut cluster_pen, mut last) = (0.0, 0.0, None);
// The leftmost and rightmost pen positions: advances can move backward.
let (mut lo, mut hi) = (0.0f64, 0.0f64);
for &(cluster, adv, xo, yo) in glyphs {
let ci = starts.partition_point(|&b| b <= cluster).saturating_sub(1);
if last != Some(ci) {
@@ -199,6 +224,10 @@ pub fn layout_metafile_text(
};
out.push((x + xo * k, -yo * k));
pen += adv * k;
(lo, hi) = (lo.min(pen), hi.max(pen));
}
if let Some(cum) = &dx {
(lo, hi) = cum.iter().fold((0.0f64, 0.0f64), |(l, h), x| (l.min(*x), h.max(*x)));
}
let width = dx.as_ref().and_then(|c| c.last().copied()).unwrap_or(pen);
let hoff = match t.h_align {
@@ -212,14 +241,8 @@ pub fn layout_metafile_text(
craft_metafile::VAlign::Bottom => -descent * k,
};
let glyphs = out.into_iter().map(|(x, y)| (x + hoff, y + baseline)).collect();
Some(MetafileTextLayout { em, baseline, glyphs })
}
pub fn metafile_text_run(t: &craft_metafile::Text) -> (wordcraft_fonts::FaceRef, Vec<ShapedGlyph>) {
let bold = t.font.weight >= 600;
let face = wordcraft_fonts::word::resolve(&t.font.family, bold, t.font.italic).face;
let shaped = wordcraft_fonts::shape(&face, &t.text, &[], |c| c);
(face, shaped)
let cell = [hoff + lo, baseline - ascent * k, hoff + hi, baseline + descent * k];
Some(MetafileTextLayout { em, baseline, glyphs, cell })
}
/// The characters of the watermark that draw as an empty box (glyph id 0), counted as
+43 -4
View File
@@ -27,6 +27,9 @@ struct Breaker<'e> {
/// Word 2013+ (compatibility mode 15) fits more text on a justified line by shrinking its
/// spaces (`space_room`); never on lines with tabs.
shrink_spaces: bool,
/// Word 2003's indent rules (`w:doNotSuppressIndentation`) before Word 2013's layout, for an
/// unnumbered paragraph: a row starts right after a floating object before the indent.
tight_indent: bool,
/// Word stretches a justified line ending in a manual line break unless the document says not to.
expand_break: bool,
/// Hyphenation Options: the zone, and how many lines in a row may end with a hyphen.
@@ -190,6 +193,13 @@ impl<'e> Breaker<'e> {
hanging_at: if rp.indent_first < 0.0 { Some(rp.indent_left) } else { None },
tab_origin: if settings.odf.is_some_and(|o| o.tabs_from_indent) { rp.indent_left } else { 0.0 },
shrink_spaces: rp.align == Align::Justify && settings.compat_mode >= wordcraft_doc::COMPAT_MODE_CURRENT,
tight_indent: settings.do_not_suppress_indentation
&& settings.compat_mode < wordcraft_doc::COMPAT_MODE_CURRENT
&& level.is_none()
&& pl.label.is_none()
// A drop cap sits at the indent: starting its lines at a float's edge would put
// them over the letter.
&& pl.drop_cap.is_none(),
expand_break: !settings.do_not_expand_shift_return,
zone: Some(settings.hyphenation_zone).filter(|z| z.is_finite() && *z >= 0.0).unwrap_or(HYPHENATION_ZONE).min(1584.0),
hyph_limit: settings.consecutive_hyphen_limit as usize,
@@ -236,9 +246,12 @@ impl<'e> Breaker<'e> {
let mut guard = 0;
loop {
let lo = self.row_left(pl);
match row_spans(self.exclusions, self.top, self.est_h, self.table_h, lo, self.base_right).map(|mut spans| (spans.pop_front(), spans)) {
let row = (self.top, self.est_h, self.table_h);
match row_spans(self.exclusions, row, (lo, self.base_right), self.tight_indent).map(|mut spans| (spans.pop_front(), spans)) {
Ok((Some((a, b)), rest)) => {
let narrowed = !rest.is_empty() || a > lo || b < self.base_right;
// Under Word 2003's indent rules a row can start left of the indent too.
let moved = if self.tight_indent { (a - lo).abs() > 0.01 } else { a > lo };
let narrowed = !rest.is_empty() || moved || b < self.base_right;
self.row_rest = rest;
self.row_first = self.lines.len();
return (a, b.max(a + MIN_LINE_WIDTH), narrowed);
@@ -1064,6 +1077,23 @@ impl Scan {
/// paragraph beside a floating table in a 21.3pt gap but not in an 18.6pt one.
const MIN_SPAN: f32 = 20.0;
/// Where a row starts under Word 2003's indent rules: right after the floating objects that end
/// at or before the indent `lo` on this row and let text past their right side (their outline's
/// right edge for Tight and Through wrapping), never left of the paragraph's own left edge (0) or
/// right of `lo`; `lo` if there are none.
fn tight_row_start(exclusions: &[Exclusion], (top, h, table_h): (f32, f32, f32), lo: f32) -> f32 {
exclusions
.iter()
.filter(|e| !e.top_bottom && e.side != WrapText::Left && e.right <= lo && e.intersects_row(top, h, table_h, f32::NEG_INFINITY, lo))
.filter_map(|e| match &e.contour {
None => Some(e.right),
Some(c) => c.occupied(top - e.top, top + h - e.top).into_iter().map(|(_, b)| b + e.left).reduce(f32::max),
})
.reduce(f32::max)
// A float out in the left margin doesn't pull the text into the margin after it.
.map_or(lo, |edge| edge.max(0.0).min(lo))
}
/// How far below a line's top its baseline sits. Multiple spacing at or above single keeps the
/// text at the top of the line and puts the extra leading below the baseline; below single it
/// shrinks the whole box, ascent included (Word's output for docxide-pdf's fixtures: 1.15-spaced
@@ -1078,8 +1108,17 @@ fn baseline_offset(spacing: LineSpacing, asc: f32, height: f32, desc: f32) -> f3
/// The spans of a row at `top` (about `h` tall) between `lo` and `hi` that text can use around
/// the exclusions, left to right (Square wrapping uses both sides of an object). `Err(y)`: none
/// here, try again at `y` (below what's in the way).
fn row_spans(exclusions: &[Exclusion], top: f32, h: f32, table_h: f32, lo: f32, hi: f32) -> Result<VecDeque<(f32, f32)>, f32> {
/// here, try again at `y` (below what's in the way). With `tight_indent` (Word 2003's indent
/// rules, `w:doNotSuppressIndentation`) a row starts right after a floating object that ends
/// before `lo`, the indent ignored (ECMA-376 Part 4 §14.8.3.12: a paragraph indented 1" tightly
/// wraps an object at 0.25").
fn row_spans(
exclusions: &[Exclusion],
(top, h, table_h): (f32, f32, f32),
(lo, hi): (f32, f32),
tight_indent: bool,
) -> Result<VecDeque<(f32, f32)>, f32> {
let lo = if tight_indent { tight_row_start(exclusions, (top, h, table_h), lo) } else { lo };
let here: Vec<&Exclusion> = exclusions.iter().filter(|e| e.intersects_row(top, h, table_h, lo, hi)).collect();
if let Some(below) = here.iter().filter(|e| e.top_bottom).map(|e| e.bottom).reduce(f32::max) {
return Err(below);
+297
View File
@@ -914,6 +914,7 @@ fn long_word_beside_a_float(n: usize) -> Document {
/// A word with no break opportunity in it: measuring the word for every line it takes scanned
/// the whole paragraph each time, so the layout was quadratic in the word's length.
#[test]
#[cfg_attr(coverage, ignore = "coverage instrumentation skews the time ratio")]
fn a_long_unbreakable_word_lays_out_in_linear_time() {
let (t1, tk, ratio) = layout_time_ratio(long_word_beside_a_float, 50_000, &LayoutOptions::default());
eprintln!("t(n) {t1:.4} s, t(8n) {tk:.4} s, ratio {ratio:.1}");
@@ -1134,6 +1135,7 @@ fn long_word_with_alternating_advances_beside_a_float(n: usize) -> Document {
/// A word whose advances alternate in sign lays out in linear time: the measurement that asks
/// whether it would fit the full line must not walk the word again for every line it takes.
#[test]
#[cfg_attr(coverage, ignore = "coverage instrumentation skews the time ratio")]
fn a_word_with_alternating_advances_lays_out_in_linear_time() {
let (t1, tk, ratio) = layout_time_ratio(long_word_with_alternating_advances_beside_a_float, 50_000, &LayoutOptions::default());
eprintln!("t(n) {t1:.4} s, t(8n) {tk:.4} s, ratio {ratio:.1}");
@@ -1995,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
@@ -3705,6 +3809,113 @@ fn text_wraps_around_square_float() {
assert!(l.pages[0].items.iter().any(|i| matches!(i, Placed::Shape { .. })));
}
/// The left edges of a paragraph's lines beside a 144 × 100 pt square-wrapped rectangle at the
/// column's top left (9 pt from text), and of its first line below the rectangle, in
/// compatibility `mode` with Word 2003's indent rules on or off. The paragraph is indented
/// 216 pt; `float` adjusts the object, `para` the paragraph, and `numbered` makes it a list item.
fn word_2003_indent_lefts(
mode: u32,
rules: bool,
float: &dyn Fn(&mut wordcraft_doc::para::Float),
numbered: bool,
para: &dyn Fn(&mut ParaProps),
) -> (Vec<f32>, Option<f32>) {
let mut d = Document::from_text(&"Words beside the picture here. ".repeat(20));
d.settings.compat_mode = mode;
d.settings.do_not_suppress_indentation = rules;
let num = numbered.then(|| Arc::make_mut(&mut d.numbering).add_list(wordcraft_doc::ListKind::Numbered));
d.format_paragraphs(&Pos::body(0, 0), &Pos::body(0, 0), &|p| {
p.indent_left = Some(216.0);
p.indent_first = Some(0.0);
p.numbering = num.map(|num| wordcraft_doc::props::NumRef { num, level: 0 });
para(p);
})
.unwrap();
let mut f = wordcraft_doc::para::Float {
wrap: wordcraft_doc::para::Wrap::Square,
h_rel: wordcraft_doc::para::Anchor::Column,
v_rel: wordcraft_doc::para::Anchor::Paragraph,
x: 0.0,
y: 0.0,
dist: 9.0,
..Default::default()
};
float(&mut f);
let shape = InlineObject::Shape {
kind: wordcraft_doc::para::ShapeKind::Rectangle,
w: 144.0,
h: 100.0,
fill: None,
stroke: None,
stroke_width: 1.0,
float: f,
story: None,
freeform: None,
effects: Default::default(),
extra: Default::default(),
};
// After the first word, so a drop cap takes the paragraph's first letter.
d.insert_object(&Pos::body(0, 6), shape, &Default::default()).unwrap();
let l = lay(&d);
let Placed::Lines { para, .. } = l.pages[0].items.iter().find(|i| matches!(i, Placed::Lines { story: StoryRef::Body, .. })).unwrap() else {
panic!()
};
let beside = para.lines.iter().filter(|ln| ln.top < 100.0).map(|ln| ln.left).collect();
let below = para.lines.iter().find(|ln| ln.top > 120.0).map(|ln| ln.left);
(beside, below)
}
/// Word 2003's indent rules (`w:doNotSuppressIndentation`, a `.doc`'s `Copts.fWW11IndentRules`): an
/// unnumbered paragraph indented past a floating object on its left starts its lines right after
/// the object, its indent ignored (ECMA-376 Part 4 §14.8.3.12). In a Word 2003-mode `.doc` saved
/// by Word, empty paragraphs indented 216 pt sit right after a text box ending 165 pt into the
/// column, in the 71 pt gap before a second box where the indent would leave under 20 pt. Below
/// the object, and in Word 2013's layout, the indent applies.
#[test]
fn word_2003_indent_rules_start_lines_right_after_a_float_before_the_indent() {
let lefts = |mode: u32, rules: bool| word_2003_indent_lefts(mode, rules, &|_| {}, false, &|_| {});
for mode in [11, 12, 14] {
let (beside, below) = lefts(mode, true);
assert!(
!beside.is_empty() && beside.iter().all(|x| (x - 153.0).abs() < 0.01),
"mode {mode}: lines start after the object and its 9 pt distance: {beside:?}"
);
assert_eq!(below, Some(216.0), "mode {mode}: below the object the indent applies");
}
assert_eq!(lefts(11, false).0[0], 216.0, "without the option the indent applies beside the object");
assert_eq!(lefts(15, true).0[0], 216.0, "Word 2013's layout keeps the indent");
}
/// Under Word 2003's indent rules a line starts after a Tight or Through-wrapped object's outline
/// where the line meets it, not after the outline's widest point: here a right triangle, its
/// point at the top left, 144 pt wide (and 9 pt from text) only at its foot.
#[test]
fn word_2003_indent_rules_follow_a_tight_objects_outline() {
use wordcraft_doc::para::Wrap;
use wordcraft_doc::wrap::WrapPolygon;
let poly = WrapPolygon::new(true, [(0, 0), (0, 21_600), (21_600, 21_600)]).map(Arc::new);
for wrap in [Wrap::Tight, Wrap::Through] {
let (beside, _) = word_2003_indent_lefts(11, true, &|f| (f.wrap, f.wrap_polygon) = (wrap, poly.clone()), false, &|_| {});
assert!(beside.len() > 2 && beside[0] < 60.0, "{wrap:?}: the first line starts near the point: {beside:?}");
assert!(beside.windows(2).all(|w| w[0] < w[1]) && beside.iter().all(|&x| x <= 153.0 + 0.01), "{wrap:?}: each line further out: {beside:?}");
}
}
/// Word 2003's indent rules leave the indent alone for a numbered paragraph (its number sits at
/// the indent) and for one with a drop cap (the letter does), and never start a line left of the
/// paragraph's own edge after an object out in the margin.
#[test]
fn word_2003_indent_rules_keep_the_indent_where_they_do_not_apply() {
let (numbered, _) = word_2003_indent_lefts(11, true, &|_| {}, true, &|_| {});
assert!(numbered.iter().all(|&x| x >= 216.0 - 0.01), "a numbered paragraph keeps its indent: {numbered:?}");
let (dropped, _) = word_2003_indent_lefts(11, true, &|_| {}, false, &|p| p.drop_cap = Some(3));
assert!(dropped.iter().all(|&x| x >= 216.0 - 0.01), "lines beside a drop cap stay right of it: {dropped:?}");
// An object in the left margin, its right side and distance from text 44 pt short of the column.
let (margin, _) = word_2003_indent_lefts(11, true, &|f| f.x = -197.0, false, &|_| {});
assert!(margin.iter().all(|&x| x >= -0.01), "no line starts in the margin: {margin:?}");
assert!((margin[0] - 0.0).abs() < 0.01, "the line starts at the paragraph's edge: {margin:?}");
}
#[test]
fn a_lines_arrowheads_sit_at_its_ends() {
// A line runs from its frame's top left to its bottom right (DrawingML's `line`, as it is
@@ -7839,6 +8050,7 @@ fn a_no_break_space_before_a_slash_still_holds() {
}
#[test]
#[cfg_attr(coverage, ignore = "coverage instrumentation skews the time ratio")]
fn unequal_formats_lay_out_in_linear_time() {
crate::test_fonts();
// Runs whose formats never compare equal (NaN spacing from a hostile file) each get a style;
@@ -15444,3 +15656,88 @@ fn turned_cell_float_keeps_its_along_text_offset() {
assert!((confined.y - reference.y).abs() < 0.01, "{direction:?}: {confined:?} vs {reference:?}");
}
}
/// A header paragraph beside a Square float on its last lines only: those lines are shorter than
/// the first. A click on the first line past the short last line's end is still on the header's
/// text, so a Behind Text picture under it is not grabbed there (#5601 review).
#[test]
fn header_text_covers_the_whole_width_of_a_wrapped_first_line() {
use wordcraft_doc::para::{Anchor, Float, Wrap};
let text = "Header words that wrap across the whole line and carry on over several lines of the header \
paragraph so there are three lines here and the last one is cut short by the float beside it";
let mut d = Document::new();
let id =
d.add_part(wordcraft_doc::PartKind::Header, vec![wordcraft_doc::para_block(wordcraft_doc::Paragraph::with_text(text, Default::default()))]);
d.last_section.headers.default = Some(id);
let at = |off| Pos::new(wordcraft_doc::StoryRef::Part(id), wordcraft_doc::Path(vec![0]), off);
// The Square float narrows the lines below the first two, on the right.
let square = Float { wrap: Wrap::Square, h_rel: Anchor::Column, v_rel: Anchor::Paragraph, x: 300.0, y: 30.0, ..Default::default() };
d.insert_object(&at(0), rect_shape(160.0, 80.0, square), &Default::default()).unwrap();
// The Behind Text picture lies under the first line, past where the last line ends.
let behind = Float { wrap: Wrap::BehindText, h_rel: Anchor::Column, v_rel: Anchor::Paragraph, x: 340.0, y: 0.0, ..Default::default() };
d.insert_object(&at(0), rect_shape(120.0, 20.0, behind), &Default::default()).unwrap();
let l = lay(&d);
let page = &l.pages[0];
let lines: Vec<_> = page
.header
.iter()
.filter_map(|it| match it {
Placed::Lines { para, l0, l1, x, y, .. } => {
Some((*x, *y, (*l0..*l1).filter_map(|i| para.lines.get(i)).map(|l| (l.top, l.height, l.right)).collect::<Vec<_>>()))
}
_ => None,
})
.collect();
let (x, y, ls) = lines.first().expect("header lines").clone();
let (first, last) = (ls.first().expect("first"), ls.last().expect("last"));
assert!(last.2 + 40.0 < first.2 - 20.0, "the last line is shorter than the first: {ls:?}");
let (px, py) = (x + first.2 - 15.0, y + first.0 + first.1 / 2.0);
assert!(l.object_at_in(0, px, py, 0.0, wordcraft_doc::StoryRef::Part(id)).is_none(), "on the first line's text, not the picture: {lines:?}");
}
/// `Line::left`/`right` are the edges available to a line, not where its ink sits: a centred or
/// right-aligned header line covers the Behind Text picture across its whole band, so a click in
/// the empty space beside its text is still on the header text. Beyond the band (an indent, or
/// beside a float) and 40pt of slack the picture is hit (#5601 review).
#[test]
fn header_text_covers_the_whole_band_of_centred_and_right_lines() {
use wordcraft_doc::Align;
use wordcraft_doc::para::{Anchor, Float, Wrap};
for align in [Align::Center, Align::Right] {
let mut d = Document::new();
let mut p = wordcraft_doc::Paragraph::with_text("Header", Default::default());
p.props.align = Some(align);
p.props.indent_left = Some(150.0);
let id = d.add_part(wordcraft_doc::PartKind::Header, vec![wordcraft_doc::para_block(p)]);
d.last_section.headers.default = Some(id);
let story = wordcraft_doc::StoryRef::Part(id);
let at = Pos::new(story, wordcraft_doc::Path(vec![0]), 0);
// A Behind Text picture across the whole text width, level with the header line.
let behind = Float { wrap: Wrap::BehindText, h_rel: Anchor::Column, v_rel: Anchor::Paragraph, x: 0.0, y: 0.0, ..Default::default() };
d.insert_object(&at, rect_shape(460.0, 20.0, behind), &Default::default()).unwrap();
let l = lay(&d);
let (x, y, left, right, height, ink0) = l.pages[0]
.header
.iter()
.find_map(|it| match it {
Placed::Lines { para, l0, x, y, .. } => {
para.lines.get(*l0).and_then(|ln| Some((*x, *y, ln.left, ln.right, ln.height, *ln.xs.first()?)))
}
_ => None,
})
.expect("header line");
// `left`/`right` are the band edges available to the line, not the ink extent.
assert!((left - 150.0).abs() < 0.5, "{align:?}: the band's left edge is the indent: {left}");
assert!(ink0 > left + 100.0, "{align:?}: the ink starts well inside the band: ink {ink0}, band left {left}");
let ym = y + height / 2.0;
let hit = |px: f32| l.object_at_in(0, px, ym, 0.0, story).is_some();
// Inside the band, wherever the centred or right-aligned ink sits: header text.
assert!(!hit(x + left + 5.0), "{align:?}: the band's left end is text");
assert!(!hit(x + (left + right) / 2.0), "{align:?}: the band's middle is text");
// Between the indent and the ink is still the text band, not the picture.
assert!(!hit(x + left + 160.0), "{align:?}: between the indent and the ink is text");
// Within 40pt of the band's left end is still text; further left the picture is hit.
assert!(!hit(x + left - 30.0), "{align:?}: within 40pt left of the band is text");
assert!(hit(x + left - 60.0), "{align:?}: beyond 40pt left of the band the picture is hit");
}
}
+16
View File
@@ -223,6 +223,22 @@ fn selecting_a_long_endnote_takes_linear_time() {
assert_linear_steps("endnote selection", 20, laid, |(d, l, (a, b))| drop(std::hint::black_box(l.selection_rects(d, a, b, 0))));
}
/// One paragraph of `n` lines (a line break after each word), so it runs over many pages.
fn many_lines(n: usize) -> Document {
let mut d = Document::from_text("");
d.body = vec![wordcraft_doc::para_block(Paragraph::with_text(&"x\n".repeat(n), CharProps::default()))];
d
}
/// The piece of a long paragraph on each page looked through every line of the paragraph for the
/// pictures and shapes to draw with it (#6757).
#[test]
fn a_paragraph_over_many_pages_lays_out_in_linear_time() {
let pages = lay(&many_lines(SCALE * 400), &LayoutOptions::default()).pages.len();
assert!(pages > 40, "the paragraph runs over many pages: {pages}");
assert_layout_linear("a paragraph over many pages", 400, many_lines, &LayoutOptions::default());
}
/// A table of `n` rows of 60 cells, each row exactly half a point high, so every cell clips its
/// (empty) paragraph and the whole table fits on the first page.
fn clipped_table(n: usize) -> Document {
+59
View File
@@ -242,3 +242,62 @@ fn an_equation_run_names_each_glyphs_characters() {
assert!(found.iter().any(|(t, g, _)| (t.contains('\u{1D44E}') || t == "ab") && *g == 2), "{found:?}");
assert!(found.iter().all(|(_, g, r)| g == r), "{found:?}");
}
/// A metafile text run with the given font height and advances, left-aligned at the baseline.
fn meta_text(height: f32, dx: Vec<f32>) -> craft_metafile::Text {
craft_metafile::Text {
transform: [1.0, 0.0, 0.0, 1.0, 0.0, 0.0],
text: "ab".into(),
dx,
font: craft_metafile::Font { family: "Arial".into(), height, ..Default::default() },
color: [0, 0, 0, 255],
background: Some([255, 255, 255, 255]),
h_align: craft_metafile::HAlign::Left,
v_align: craft_metafile::VAlign::Baseline,
clip: None,
region: None,
clips: Vec::new(),
}
}
/// A metafile font height of 0 is the file's default size: a 16-unit cell. A negative height is
/// the em size, and a positive one the cell (ascent plus descent, 1200 units of a 1000-unit em
/// here).
#[test]
fn metafile_text_heights() {
let glyphs = [(0, 500.0, 0.0, 0.0), (1, 500.0, 0.0, 0.0)];
let em = |h| crate::layout_metafile_text(&meta_text(h, Vec::new()), 1000.0, 900.0, 300.0, &glyphs).map(|l| l.em);
let near = |a: Option<f64>, b: f64| a.is_some_and(|a| (a - b).abs() < 1e-9);
assert!(near(em(0.0), 16.0 * 1000.0 / 1200.0), "{:?}", em(0.0));
assert!(near(em(-10.0), 10.0), "{:?}", em(-10.0));
assert!(near(em(24.0), 20.0), "a positive height is the cell: {:?}", em(24.0));
}
/// A cosmetic pen's dashes become whole output pixels (the shortest one pixel), a period under a
/// pixel draws solid, and so does a pattern that would split the path into too many pieces.
#[test]
fn metafile_dashes_follow_the_output_pixel() {
let cosmetic = crate::metafile_dashes(&[0.75, 0.25], true, 0.5, 100.0).unwrap_or_default();
assert!(cosmetic.len() == 2 && (cosmetic[0] - 1.5).abs() < 1e-6 && (cosmetic[1] - 0.5).abs() < 1e-6, "{cosmetic:?}");
assert_eq!(crate::metafile_dashes(&[3.0, 1.0], false, 0.5, 100.0), Some(vec![3.0, 1.0]));
assert_eq!(crate::metafile_dashes(&[0.2, 0.2], false, 0.5, 100.0), None, "a period under a pixel");
assert_eq!(crate::metafile_dashes(&[1.0, 1.0], false, 0.5, 1e6), None, "a million pieces");
assert_eq!(crate::metafile_dashes(&[1.0, -1.0], false, 0.5, 100.0), None, "a negative length");
assert_eq!(crate::metafile_dashes(&[0.0, 0.0], true, 0.5, 100.0), None, "no length at all");
}
/// A negative crop side is no crop; the others stay as they are.
#[test]
fn negative_crop_sides_are_no_crop() {
assert_eq!(crate::crop_sides([-0.5, 0.25, f32::NAN, 1.5]), [0.0, 0.25, 0.0, 1.5]);
assert_eq!(crate::crop_window([-0.5, 0.0, 0.0, 0.0]), [0.0, 0.0, 1.0, 1.0]);
}
/// The opaque background of a run whose advances move backward covers every pen position, not
/// only the run's total advance.
#[test]
fn metafile_text_cell_spans_backward_advances() {
let glyphs = [(0, 500.0, 0.0, 0.0), (1, 500.0, 0.0, 0.0)];
let lay = crate::layout_metafile_text(&meta_text(-10.0, vec![50.0, -40.0]), 1000.0, 800.0, 200.0, &glyphs).expect("a layout");
assert_eq!(lay.cell, [0.0, -8.0, 50.0, 2.0]);
}
+1 -1
View File
@@ -320,7 +320,7 @@ impl Exporter<'_> {
s.set_fill(None);
return;
};
let [cl, ct, vis_w, vis_h] = craft_metafile::crop_window(*crop).map(|v| v as f32);
let [cl, ct, vis_w, vis_h] = wordcraft_layout::crop_window(*crop).map(|v| v as f32);
let (fw, fh) = (rect.w / vis_w, rect.h / vis_h);
let Some(size) = Size::from_wh(fw.max(0.01), fh.max(0.01)) else { return };
let fade = alpha < 0.999;
+12 -3
View File
@@ -1,6 +1,6 @@
use super::{
Exporter, FaceRef, Fill, FillRule, KrillaGlyph, Point, Rgb, Stroke, Surface, Transform, baseline, cluster_ends, fill, glyph_id, glyph_outlines,
left_to_right, norm, ok, paint_of, rgb, split_clusters, visual_order,
Exporter, FaceRef, Fill, FillRule, KrillaGlyph, Point, Rect, Rgb, Stroke, Surface, Transform, baseline, cluster_ends, fill, glyph_id,
glyph_outlines, left_to_right, norm, ok, paint_of, rect_path, rgb, split_clusters, visual_order,
};
/// How a run of glyphs is painted: its colour, opacity and synthetic bold and italic.
@@ -181,7 +181,7 @@ impl Exporter<'_> {
}
/// Draws a metafile text run as PDF text (outlines when the font cannot be embedded). `tf` maps
/// the run's own space (see [`PlacedItem::Text`]) to the page.
/// its text space (`craft_metafile::Text::transform`) to the page.
pub(crate) fn vector_text(&mut self, s: &mut Surface, t: &craft_metafile::Text, tf: kurbo::Affine) {
let (face, shaped) = wordcraft_layout::metafile_text_run(t);
let glyphs: Vec<_> = shaped.iter().map(|g| (g.cluster, f64::from(g.x_advance), f64::from(g.x_offset), f64::from(g.y_offset))).collect();
@@ -198,6 +198,15 @@ impl Exporter<'_> {
let (paint, opacity) = paint_of(t.color);
s.push_transform(&Transform::from_row(c[0], c[1], c[2], c[3], c[4], c[5]));
s.set_stroke(None);
// An opaque background mode fills the character cells first.
if let Some(bg) = t.background {
let [x0, y0, x1, y1] = lay.cell.map(|v| v as f32);
if let Some(cell) = rect_path(&Rect { x: x0, y: y0, w: x1 - x0, h: y1 - y0 }) {
let (paint, opacity) = paint_of(bg);
s.set_fill(Some(Fill { paint: paint.into(), opacity, rule: FillRule::NonZero }));
s.draw_path(&cell);
}
}
s.set_fill(Some(Fill { paint: paint.into(), opacity, rule: FillRule::NonZero }));
match font {
Some(font) => {
+145 -26
View File
@@ -1,28 +1,51 @@
use super::exporter::Exporter;
use super::paint::{append_path, norm};
use super::{
Arc, Fill, FillRule, Image, LineCap, LineJoin, NormalizedF32, Path, PathBuilder, Picture, PlacedItem, Rect, Size, Stroke, Surface, Transform, rgb,
Arc, Fill, FillRule, Image, LineCap, LineJoin, NormalizedF32, Path, PathBuilder, Picture, PlacedItem, Rect, Size, Stroke, StrokeDash, Surface,
Transform, krilla, rgb,
};
use craft_metafile::Item;
use kurbo::Shape as _;
use wordcraft_doc::picfx::PicFx;
/// Largest picture side we embed (pixels).
const MAX_IMAGE_SIDE: u32 = 30_000;
/// A metafile picture, parsed once. The geometry comes placed by the metafile crate; the bitmaps are
/// embedded images, one per picture item (None for paths and undecodable bitmaps).
/// A metafile picture, parsed once. The geometry comes placed by the metafile crate; the bitmaps and
/// pattern tiles are embedded images, one per picture item (None for paths, text and undecodable
/// bitmaps). Fills that share a tile share its image. `averages` holds each pattern fill's tile
/// average color (transparent for other items), computed once a tile.
pub(crate) struct Vector {
pic: Picture,
images: Vec<Option<Image>>,
averages: Vec<[u8; 4]>,
}
/// Parses a metafile and embeds its bitmaps. None when the picture has no usable size.
/// Parses a metafile and embeds its bitmaps and pattern tiles. None when the picture has no usable
/// size.
pub(crate) fn build_vector(bytes: &[u8]) -> Option<Vector> {
let mut pic = craft_metafile::parse(bytes).ok()?;
if !pic.has_size() {
return None;
}
let images = pic.items.iter_mut().map(|it| it.take_pixels().map(|(w, h, px)| Image::from_rgba8(px, w, h))).collect();
Some(Vector { pic, images })
let mut tiles: std::collections::HashMap<usize, (Option<Image>, [u8; 4])> = std::collections::HashMap::new();
let (images, averages) = pic
.items
.iter_mut()
.map(|it| match it {
Item::Pattern { tile, .. } => tiles
.entry(Arc::as_ptr(tile) as usize)
.or_insert_with(|| {
let n = (tile.width as usize).saturating_mul(tile.height as usize).saturating_mul(4);
let img = (tile.width > 0 && tile.height > 0 && tile.rgba.len() == n)
.then(|| Image::from_rgba8(tile.rgba.clone(), tile.width, tile.height));
(img, wordcraft_layout::metafile_average_color(&tile.rgba))
})
.clone(),
_ => (it.take_pixels().map(|(w, h, px)| Image::from_rgba8(px, w, h)), [0; 4]),
})
.unzip();
Some(Vector { pic, images, averages })
}
/// A straight RGBA colour as a krilla colour and opacity.
@@ -36,9 +59,10 @@ pub(crate) fn paint_of(c: [u8; 4]) -> (rgb::Color, NormalizedF32) {
const HAIRLINE: f64 = 0.25;
/// Draws a metafile picture into the clip (the picture frame): paths are filled and stroked in page
/// space (strokes keep their width under non-uniform scaling), bitmaps stretched, all faded by `alpha`.
/// Every path sets its fill and stroke, so none carries over; strokes have round caps and joins. Text
/// runs are drawn as text.
/// space (strokes keep their width under non-uniform scaling), bitmaps stretched (or turned by their
/// transform), pattern fills tiled, each item inside its clip region and clip paths, all faded by
/// `alpha`. Every path sets its fill and stroke, so none carries over; strokes take the pen's caps,
/// joins and dashes. Text runs are drawn as text.
pub(crate) fn vector_picture(ex: &mut Exporter, s: &mut Surface, v: &Vector, r: &Rect, crop: &[f32; 4], clip: &Path, alpha: f32) {
let target = kurbo::Rect::new(f64::from(r.x), f64::from(r.y), f64::from(r.x + r.w), f64::from(r.y + r.h));
let fade = alpha < 0.999;
@@ -46,9 +70,9 @@ pub(crate) fn vector_picture(ex: &mut Exporter, s: &mut Surface, v: &Vector, r:
s.push_opacity(norm(alpha));
}
s.push_clip_path(clip, &FillRule::NonZero);
for it in v.pic.place(target, *crop) {
for it in v.pic.place(target, wordcraft_layout::crop_sides(*crop)) {
match it {
PlacedItem::Path { path, fill, stroke, even_odd, .. } => {
PlacedItem::Path { path, fill, stroke, line, even_odd, region, clips } => {
let Some(p) = path_from(&path) else { continue };
let fill = fill.map(|c| {
let (paint, opacity) = paint_of(c);
@@ -57,31 +81,63 @@ pub(crate) fn vector_picture(ex: &mut Exporter, s: &mut Surface, v: &Vector, r:
});
let stroke = stroke.map(|(c, w)| {
let (paint, opacity) = paint_of(c);
Stroke {
paint: paint.into(),
width: w.max(HAIRLINE) as f32,
opacity,
line_cap: LineCap::Round,
line_join: LineJoin::Round,
..Default::default()
}
pen(paint.into(), opacity, w, &line, &path)
});
let Some(n) = push_clips(s, region.as_deref(), &clips) else { continue };
s.set_fill(fill);
s.set_stroke(stroke);
s.draw_path(&p);
pop_clips(s, n);
}
PlacedItem::Bitmap { index, rect, .. } => {
PlacedItem::Bitmap { index, rect, transform, region, clips } => {
let Some(Some(img)) = v.images.get(index) else { continue };
let Some(size) = Size::from_wh(rect.width() as f32, rect.height() as f32) else { continue };
s.push_transform(&Transform::from_translate(rect.x0 as f32, rect.y0 as f32));
let c = transform.as_coeffs();
// Upright and not mirrored: the bitmap fills `rect`.
let upright = c[1] == 0.0 && c[2] == 0.0 && c[0] > 0.0 && c[3] > 0.0;
let (tf, size) = if upright {
(Transform::from_translate(rect.x0 as f32, rect.y0 as f32), Size::from_wh(rect.width() as f32, rect.height() as f32))
} else {
// A turned, skewed or mirrored bitmap: `transform` maps the unit square onto its place.
let c = c.map(|v| v as f32);
(Transform::from_row(c[0], c[1], c[2], c[3], c[4], c[5]), Size::from_wh(1.0, 1.0))
};
let Some(size) = size else { continue };
let Some(n) = push_clips(s, region.as_deref(), &clips) else { continue };
s.push_transform(&tf);
s.draw_image(img.clone(), size);
s.pop();
pop_clips(s, n);
}
PlacedItem::Pattern { .. } => {}
PlacedItem::Text { index, transform, .. } => {
if let Some(craft_metafile::Item::Text(t)) = v.pic.items.get(index) {
ex.vector_text(s, t, transform);
PlacedItem::Pattern { index, path, even_odd, tile, region, clips } => {
let Some(p) = path_from(&path) else { continue };
let Some(craft_metafile::Item::Pattern { tile: t, .. }) = v.pic.items.get(index) else { continue };
let rule = if even_odd { FillRule::EvenOdd } else { FillRule::NonZero };
let paint = match v.images.get(index) {
Some(Some(img)) => tile_pattern(s, img, t.width, t.height, tile).map(|p| (p.into(), norm(1.0))),
_ => None,
};
let (paint, opacity) = paint.unwrap_or_else(|| {
let (c, o) = paint_of(v.averages.get(index).copied().unwrap_or([0; 4]));
(c.into(), o)
});
let Some(n) = push_clips(s, region.as_deref(), &clips) else { continue };
s.set_fill(Some(Fill { paint, opacity, rule }));
s.set_stroke(None);
s.draw_path(&p);
pop_clips(s, n);
}
PlacedItem::Text { index, transform, clip, region, clips } => {
let Some(craft_metafile::Item::Text(t)) = v.pic.items.get(index) else { continue };
let Some(n) = push_clips(s, region.as_deref(), &clips) else { continue };
let text_clip = clip.and_then(|c| path_from(&c.to_path(0.1)));
if let Some(c) = &text_clip {
s.push_clip_path(c, &FillRule::NonZero);
}
ex.vector_text(s, t, transform);
if text_clip.is_some() {
s.pop();
}
pop_clips(s, n);
}
}
}
@@ -93,6 +149,69 @@ pub(crate) fn vector_picture(ex: &mut Exporter, s: &mut Surface, v: &Vector, r:
}
}
/// Pushes a metafile item's clip region and clip paths; pop them with [`pop_clips`] and the count
/// returned. None (nothing pushed) when a clip has no area to draw in.
fn push_clips(s: &mut Surface, region: Option<&kurbo::BezPath>, clips: &[Arc<craft_metafile::PlacedClip>]) -> Option<usize> {
let mut paths = Vec::with_capacity(clips.len() + 1);
if let Some(region) = region {
paths.push((path_from(region)?, FillRule::NonZero));
}
for c in clips {
paths.push((path_from(&c.path)?, if c.even_odd { FillRule::EvenOdd } else { FillRule::NonZero }));
}
for (p, rule) in &paths {
s.push_clip_path(p, rule);
}
Some(paths.len())
}
fn pop_clips(s: &mut Surface, n: usize) {
for _ in 0..n {
s.pop();
}
}
/// A metafile pen for `path`: `width` (points, at least [`HAIRLINE`]), the pen's caps, joins,
/// miter limit and dashes (`wordcraft_layout::metafile_dashes`, with the hairline as the pixel).
fn pen(paint: krilla::paint::Paint, opacity: NormalizedF32, width: f64, line: &craft_metafile::LineStyle, path: &kurbo::BezPath) -> Stroke {
let line_cap = match line.cap {
craft_metafile::Cap::Round => LineCap::Round,
craft_metafile::Cap::Square => LineCap::Square,
craft_metafile::Cap::Flat => LineCap::Butt,
};
let line_join = match line.join {
craft_metafile::Join::Round => LineJoin::Round,
craft_metafile::Join::Bevel => LineJoin::Bevel,
craft_metafile::Join::Miter => LineJoin::Miter,
};
let dash = if line.dash.is_empty() { None } else { wordcraft_layout::metafile_dashes(&line.dash, width == 0.0, HAIRLINE, path.perimeter(1.0)) };
Stroke {
paint,
width: width.max(HAIRLINE) as f32,
miter_limit: wordcraft_layout::metafile_miter_limit(line.miter_limit),
line_cap,
line_join,
opacity,
dash: dash.map(|d| StrokeDash { array: d.iter().map(|v| *v as f32).collect(), offset: 0.0 }),
}
}
/// A tiling pattern of `img` (`w` × `h` pixels); `tile` maps tile pixels to page space. None when
/// the mapping is not finite.
fn tile_pattern(s: &mut Surface, img: &Image, w: u32, h: u32, tile: kurbo::Affine) -> Option<krilla::paint::Pattern> {
let c = tile.as_coeffs().map(|v| v as f32);
if !c.iter().all(|v| v.is_finite()) {
return None;
}
let size = Size::from_wh(w as f32, h as f32)?;
let mut sb = s.stream_builder();
let mut ps = sb.surface();
ps.draw_image(img.clone(), size);
ps.finish();
let stream = sb.finish();
Some(krilla::paint::Pattern { stream, transform: Transform::from_row(c[0], c[1], c[2], c[3], c[4], c[5]), width: w as f32, height: h as f32 })
}
/// A kurbo path as a krilla path (None when empty).
fn path_from(b: &kurbo::BezPath) -> Option<Path> {
let mut pb = PathBuilder::new();
+250
View File
@@ -1305,6 +1305,211 @@ fn emf_rec(typ: u32, fields: &[i32]) -> Vec<u8> {
v
}
/// The PDF of a document holding one 70 pt metafile picture, uncompressed.
fn metafile_pdf(emf: Vec<u8>) -> String {
String::from_utf8_lossy(&metafile_pdf_bytes(emf)).into_owned()
}
fn metafile_pdf_bytes(emf: Vec<u8>) -> Vec<u8> {
export(&metafile_doc(emf), &PdfOptions { compress: false, tagged: false, ..Default::default() }).unwrap()
}
/// The uncompressed PDF of a document holding one 70 pt metafile picture, and the picture's box
/// on the first page in PDF space (points, y up).
fn metafile_pdf_and_box(emf: Vec<u8>) -> (Vec<u8>, kurbo::Rect) {
let d = metafile_doc(emf);
let bytes = export(&d, &PdfOptions { compress: false, tagged: false, ..Default::default() }).unwrap();
let lay = layout(&d, &mut LayoutCache::new(), &LayoutOptions::default());
let page = &lay.pages[0];
let h = f64::from(page.h);
let r = wordcraft_layout::display::page_display(&d, page, &DisplayOptions::default())
.into_iter()
.find_map(|item| if let Draw::Image { rect, .. } = item { Some(rect) } else { None })
.expect("the picture is laid out");
let (x, y, w, ph) = (f64::from(r.x), f64::from(r.y), f64::from(r.w), f64::from(r.h));
(bytes, kurbo::Rect::new(x, h - y - ph, x + w, h - y))
}
/// The right half of a box.
fn right_half(r: kurbo::Rect) -> kurbo::Rect {
kurbo::Rect::new((r.x0 + r.x1) / 2.0, r.y0, r.x1, r.y1)
}
/// Whether two boxes have the same edges, to within half a point.
fn same_box(a: kurbo::Rect, b: kurbo::Rect) -> bool {
[a.x0 - b.x0, a.y0 - b.y0, a.x1 - b.x1, a.y1 - b.y1].iter().all(|d| d.abs() < 0.5)
}
fn metafile_doc(emf: Vec<u8>) -> Document {
let mut d = Document::new();
let media = d.add_media(emf, "emf");
let mut p = Paragraph::with_text("Figure: ", CharProps::default());
let n = p.len();
p.insert_object(
n,
InlineObject::Image {
media,
w: 70.0,
h: 70.0,
alt: String::new(),
float: Default::default(),
crop: [0.0; 4],
fx: Default::default(),
ole: None,
},
&CharProps::default(),
)
.unwrap();
d.body = vec![para_block(p)];
d
}
/// #6636: an EMF+ only file whose EmfPlusDrawImage draws a 32bppPARGB bitmap: the bitmap is
/// embedded as an image, and the page draws it into the EmfPlusDrawImage rectangle.
#[test]
fn emf_plus_only_bitmap_is_embedded() {
let plus_rec = |typ: u16, flags: u16, data: &[u8]| {
let mut v = typ.to_le_bytes().to_vec();
v.extend(flags.to_le_bytes());
v.extend(((12 + data.len()) as u32).to_le_bytes());
v.extend((data.len() as u32).to_le_bytes());
v.extend(data);
v
};
let le32 = |vals: &[i32]| -> Vec<u8> { vals.iter().flat_map(|v| v.to_le_bytes()).collect() };
let header = plus_rec(0x4001, 0, &le32(&[0xDBC0_1002_u32 as i32, 1, 96, 96]));
let mut image = le32(&[0xDBC0_1002_u32 as i32, 1, 2, 2, 8, 0x000E_200B, 0]);
image.extend([0u8, 0, 255, 255].repeat(4));
let object = plus_rec(0x4008, 0x0500, &image);
let mut draw = le32(&[-1, 2]);
draw.extend([0.0f32, 0.0, 2.0, 2.0, 50.0, 0.0, 50.0, 100.0].iter().flat_map(|v| v.to_le_bytes()));
let draw = plus_rec(0x401A, 0, &draw);
let mut comment = 0x2B46_4D45u32.to_le_bytes().to_vec();
comment.extend([header, object, draw, plus_rec(0x4002, 0, &[])].concat());
let mut rec = 70u32.to_le_bytes().to_vec();
rec.extend(((12 + comment.len()) as u32).to_le_bytes());
rec.extend((comment.len() as u32).to_le_bytes());
rec.extend(comment);
let (bytes, pic) = metafile_pdf_and_box(emf_file(&[rec, emf_rec(14, &[0; 3])]));
let images = pdf_images(&bytes);
assert!(images.iter().any(|(w, h, ..)| (*w, *h) == (2, 2)), "the 2 × 2 bitmap is embedded");
let drawn = pdf_drawn_images(&bytes);
assert!(
drawn.iter().any(|&(w, h, r)| (w, h) == (2, 2) && same_box(r, right_half(pic))),
"the page draws the bitmap over the right half of the picture at {pic:?}: {drawn:?}"
);
assert!(!String::from_utf8_lossy(&bytes).contains("0.8156"), "the gray placeholder box is not drawn");
}
/// #6636: an EMF+ only file whose EmfPlusDrawImage draws a bitmap in PixelFormat32bppARGB,
/// 24bppRGB or 32bppRGB, or a compressed PNG or JPEG bitmap: the bitmap is embedded as an image,
/// and the page draws it into the EmfPlusDrawImage rectangle.
#[test]
fn emf_plus_only_bitmap_formats_are_embedded() {
let plus_rec = |typ: u16, flags: u16, data: &[u8]| {
let mut v = typ.to_le_bytes().to_vec();
v.extend(flags.to_le_bytes());
v.extend(((12 + data.len()) as u32).to_le_bytes());
v.extend((data.len() as u32).to_le_bytes());
v.extend(data);
v
};
let le32 = |vals: &[i32]| -> Vec<u8> { vals.iter().flat_map(|v| v.to_le_bytes()).collect() };
let encoded = |png: bool| {
let red = [255u8, 0, 0].repeat(15);
if png {
let img = image::RgbImage::from_raw(5, 3, red).unwrap();
wordcraft_geom::picture::encode_png(&image::DynamicImage::from(img)).unwrap()
} else {
wordcraft_geom::picture::encode_jpeg(&red, 5, 3, 100).unwrap()
}
};
// Name, width, height, stride, pixel format, bitmap type (0 pixels, 1 compressed) and data.
let cases: [(&str, i32, i32, i32, u32, i32, Vec<u8>); 5] = [
("32bppARGB", 2, 2, 8, 0x0026_200A, 0, [0u8, 0, 255, 255].repeat(4)),
("24bppRGB", 2, 2, 8, 0x0002_1808, 0, [0u8, 0, 255, 0, 0, 255, 0, 0].repeat(2)),
("32bppRGB", 2, 2, 8, 0x0002_2009, 0, [0u8, 0, 255, 0].repeat(4)),
("PNG", 5, 3, 0, 0, 1, encoded(true)),
("JPEG", 5, 3, 0, 0, 1, encoded(false)),
];
for (name, w, h, stride, format, kind, data) in cases {
let header = plus_rec(0x4001, 0, &le32(&[0xDBC0_1002_u32 as i32, 1, 96, 96]));
let mut image = le32(&[0xDBC0_1002_u32 as i32, 1, w, h, stride, format as i32, kind]);
image.extend(data);
// Records are a multiple of 4 bytes long.
image.resize(image.len().next_multiple_of(4), 0);
let object = plus_rec(0x4008, 0x0500, &image);
let mut draw = le32(&[-1, 2]);
draw.extend([0.0f32, 0.0, w as f32, h as f32, 50.0, 0.0, 50.0, 100.0].iter().flat_map(|v| v.to_le_bytes()));
let draw = plus_rec(0x401A, 0, &draw);
let mut comment = 0x2B46_4D45u32.to_le_bytes().to_vec();
comment.extend([header, object, draw, plus_rec(0x4002, 0, &[])].concat());
let mut rec = 70u32.to_le_bytes().to_vec();
rec.extend(((12 + comment.len()) as u32).to_le_bytes());
rec.extend((comment.len() as u32).to_le_bytes());
rec.extend(comment);
let (bytes, pic) = metafile_pdf_and_box(emf_file(&[rec, emf_rec(14, &[0; 3])]));
let images = pdf_images(&bytes);
assert!(images.iter().any(|(iw, ih, ..)| (*iw, *ih) == (w as u32, h as u32)), "{name}: the {w} × {h} bitmap is embedded");
let drawn = pdf_drawn_images(&bytes);
assert!(
drawn.iter().any(|&(iw, ih, r)| (iw, ih) == (w as u32, h as u32) && same_box(r, right_half(pic))),
"{name}: the page draws the bitmap over the right half of the picture at {pic:?}: {drawn:?}"
);
assert!(!String::from_utf8_lossy(&bytes).contains("0.8156"), "{name}: the gray placeholder box is not drawn");
}
}
/// A dotted cosmetic pen (CREATEPEN, PS_DOT, width 0) draws hairline dots: its dashes and gaps are
/// the hairline's width, not the file's device units scaled to the frame (0.7 pt here).
#[test]
fn metafile_cosmetic_dotted_pen_draws_hairline_dots() {
let recs = [emf_rec(38, &[1, 2, 0, 0, 0]), emf_rec(37, &[1]), emf_rec(27, &[0, 50]), emf_rec(54, &[100, 50]), emf_rec(14, &[0; 3])];
let raw = metafile_pdf(emf_file(&recs));
assert!(raw.contains("[0.25 0.25]0 d"), "the dots are hairline-sized");
}
/// A geometric PS_USERSTYLE pen whose dashes and gaps are far below the hairline draws its line
/// solid: no dash array is written.
#[test]
fn metafile_sub_pixel_dashes_draw_solid() {
let mut emf = emf_file(&[]);
// 10,000 device pixels over 250 mm: a device unit is 0.025 mm. The picture is 1000 units wide.
let le32 = |vals: &[i32]| -> Vec<u8> { vals.iter().flat_map(|v| v.to_le_bytes()).collect() };
emf[8..24].copy_from_slice(&le32(&[0, 0, 1000, 1000]));
emf[72..80].copy_from_slice(&le32(&[10_000, 10_000]));
let pen = emf_rec(95, &[1, 0, 0, 0, 0, 0x0001_0207, 80, 0, 0, 0, 2, 1, 1]);
let recs = [pen, emf_rec(37, &[1]), emf_rec(27, &[0, 500]), emf_rec(54, &[1000, 500]), emf_rec(14, &[0; 3])];
emf.extend(recs.concat());
let raw = metafile_pdf(emf);
assert!(raw.contains(" w ") && !raw.contains("]0 d"), "a stroke with no dash array");
}
/// A clip region (INTERSECTCLIPRECT) adds a clip around the rectangle it clips.
#[test]
fn metafile_clip_region_is_a_clip() {
let clips = |raw: &str| raw.matches("\nW\nn").count() + raw.matches("\nW*\nn").count();
let draw = |clip: bool| {
let mut recs = vec![emf_rec(39, &[1, 0, 0x0000_00FF, 0]), emf_rec(37, &[1])];
if clip {
recs.push(emf_rec(30, &[0, 0, 50, 100]));
}
recs.extend([emf_rec(43, &[0, 0, 100, 100]), emf_rec(14, &[0; 3])]);
metafile_pdf(emf_file(&recs))
};
let (with, without) = (clips(&draw(true)), clips(&draw(false)));
assert!(without > 0 && with == without + 1, "one clip more with the region: {with} and {without}");
}
/// A hatched brush (CREATEBRUSHINDIRECT, BS_HATCHED) fills through a tiling pattern, not with a
/// solid color.
#[test]
fn metafile_hatch_brush_is_a_tiling_pattern() {
let recs = [emf_rec(39, &[1, 2, 0x0000_00FF, 1]), emf_rec(37, &[1]), emf_rec(43, &[0, 0, 100, 100]), emf_rec(14, &[0; 3])];
let raw = metafile_pdf(emf_file(&recs));
assert!(raw.contains("/PatternType 1"), "the hatch is a tiling pattern");
}
#[test]
fn metafile_strokes_use_round_caps_and_joins() {
// A 4-unit black pen (handle 1) outlines a rectangle, so the stroke is drawn with round caps and joins.
@@ -1425,6 +1630,17 @@ fn emf_text_records(text: &str) -> Vec<Vec<u8>> {
vec![font, emf_rec(37, &[1]), emf_rec(24, &[0]), out]
}
/// With the opaque background mode (the default) and a red background color (SETBKCOLOR), a text
/// run's character cells are filled red behind the text.
#[test]
fn metafile_text_fills_its_opaque_background() {
let mut recs = vec![emf_rec(25, &[0x0000_00FF])];
recs.extend(emf_text_records("Hi"));
recs.push(emf_rec(14, &[0; 3]));
let raw = metafile_pdf(emf_file(&recs));
assert!(raw.contains("1 0 0 rg"), "the character cells are filled red");
}
/// #1764: the text of an EMF picture (EXTTEXTOUTW) is drawn, so it is in the PDF's text layer.
#[test]
fn metafile_text_records_are_drawn_as_text() {
@@ -2159,6 +2375,40 @@ fn pdf_images(bytes: &[u8]) -> Vec<(u32, u32, Vec<String>, Vec<Vec<u8>>)> {
out
}
/// The images the pages draw, through hayro's interpreter: pixel width and height, and the box each
/// one is drawn into, in PDF space (points, y up).
fn pdf_drawn_images(bytes: &[u8]) -> Vec<(u32, u32, kurbo::Rect)> {
use hayro_interpret::font::Glyph;
use hayro_interpret::{
BlendMode, ClipPath, Context, Device, GlyphDrawMode, Image, InterpreterCache, InterpreterSettings, Paint, PathDrawMode, SoftMask,
interpret_page,
};
struct Ex(Vec<(u32, u32, kurbo::Rect)>);
impl Device<'_> for Ex {
fn set_soft_mask(&mut self, _: Option<SoftMask<'_>>) {}
fn set_blend_mode(&mut self, _: BlendMode) {}
fn draw_path(&mut self, _: &kurbo::BezPath, _: kurbo::Affine, _: &Paint<'_>, _: &PathDrawMode) {}
fn push_clip_path(&mut self, _: &ClipPath) {}
fn push_transparency_group(&mut self, _: f32, _: Option<SoftMask<'_>>, _: BlendMode) {}
fn draw_glyph(&mut self, _: &Glyph<'_>, _: kurbo::Affine, _: kurbo::Affine, _: &Paint<'_>, _: &GlyphDrawMode) {}
fn draw_image(&mut self, image: Image<'_, '_>, t: kurbo::Affine) {
// The transform maps the image's pixel grid onto the page.
let (w, h) = (image.width(), image.height());
self.0.push((w, h, t.transform_rect_bbox(kurbo::Rect::new(0.0, 0.0, f64::from(w), f64::from(h)))));
}
fn pop_clip_path(&mut self) {}
fn pop_transparency_group(&mut self) {}
}
let pdf = hayro_syntax::Pdf::new(bytes.to_vec()).expect("parse");
let cache = InterpreterCache::new();
let mut ex = Ex(Vec::new());
for page in pdf.pages().iter() {
let mut ctx = Context::new(kurbo::Affine::IDENTITY, kurbo::Rect::new(0.0, 0.0, 1.0, 1.0), &cache, pdf.xref(), InterpreterSettings::default());
interpret_page(page, &mut ctx, &mut ex);
}
ex.0
}
/// The fill opacities (`ca`) of the PDF's graphics states.
fn pdf_fill_opacities(bytes: &[u8]) -> Vec<f32> {
use hayro_syntax::object::Object;
+33 -2
View File
@@ -703,12 +703,43 @@ fn draw_line(ctx: &mut RenderContext, fr: &Frame, it: &Draw) {
stroke_segment(ctx, (x0, y0, x1, y1), (-nx, -ny));
}
_ => {
let (st, off) = match snap_rule(fr.view, (x0, y0, x1, y1), w) {
Some((w_px, off)) => (kurbo::Stroke { width: w_px / fr.view.as_coeffs()[0], ..st }, off),
None => (st, (0.0, 0.0)),
};
ctx.set_stroke(st);
stroke_segment(ctx, (x0, y0, x1, y1), (0.0, 0.0));
stroke_segment(ctx, (x0, y0, x1, y1), off);
}
}
}
/// Snap a horizontal or vertical rule to the device pixel grid so every border of one nominal
/// width covers the same number of pixels at any zoom (#5967). Returns the stroke width in device
/// pixels and the offset, in points, that moves the line onto the snapped spot; `None` for slanted
/// lines or a view that rotates or skews.
fn snap_rule(view: Affine, (x0, y0, x1, y1): (f64, f64, f64, f64), width: f64) -> Option<(f64, (f64, f64))> {
if !is_upright(view) {
return None;
}
let [k, _, _, _, tx, ty] = view.as_coeffs();
if y0 == y1 && x0 != x1 {
let (w_px, c) = snap_hairline(y0 * k + ty, width * k);
Some((w_px, (0.0, (c - ty) / k - y0)))
} else if x0 == x1 && y0 != y1 {
let (w_px, c) = snap_hairline(x0 * k + tx, width * k);
Some((w_px, ((c - tx) / k - x0, 0.0)))
} else {
None
}
}
/// A line `width_px` wide centred at device coordinate `centre`, moved so both edges fall on whole
/// pixels. Returns the width, made a whole number of pixels (at least one), and the new centre.
fn snap_hairline(centre: f64, width_px: f64) -> (f64, f64) {
let w = width_px.round().max(1.0);
(w, (centre - w / 2.0).round() + w / 2.0)
}
/// Stroke the line from (`x0`, `y0`) to (`x1`, `y1`), moved by (`ox`, `oy`).
fn stroke_segment(ctx: &mut RenderContext, (x0, y0, x1, y1): (f64, f64, f64, f64), (ox, oy): (f64, f64)) {
let mut p = BezPath::new();
@@ -856,7 +887,7 @@ fn draw_image(ctx: &mut RenderContext, fr: &Frame, it: &Draw) {
return;
};
let (pw, ph) = (pm.width().max(1) as f64, pm.height().max(1) as f64);
let [cl, ct, vis_w, vis_h] = craft_metafile::crop_window(*crop);
let [cl, ct, vis_w, vis_h] = wordcraft_layout::crop_window(*crop);
let sx = r.width() / (pw * vis_w);
let sy = r.height() / (ph * vis_h);
ctx.set_transform(view);
+255 -37
View File
@@ -1,4 +1,6 @@
use super::{Affine, Arc, Document, FontDb, HashMap, Item, Mutex, Page, Picture, Pixmap, PlacedItem, RenderContext, Seg, Shape, Weak, kurbo, peniko};
use craft_metafile::{ClipPath, Tile};
use std::collections::HashSet;
/// Upper bound on the bytes the two decoded-media caches keep together (about 256 MB), half each;
/// past its half a cache starts over.
@@ -140,29 +142,70 @@ pub fn metafile_size(bytes: &[u8]) -> Option<(f32, f32, &'static str)> {
Some((w * k, h * k, ext))
}
/// A metafile (WMF/EMF) picture, parsed once. The geometry comes placed by the metafile crate; the
/// bitmaps are pixmaps, one per picture item (None for paths and undecodable bitmaps).
/// A metafile (WMF/EMF/EMF+) picture, parsed once. The geometry comes placed by the metafile crate;
/// the bitmaps and pattern tiles are pixmaps, one per picture item (None for paths, text and
/// undecodable bitmaps). Fills that share a tile share its pixmap. `averages` holds each pattern
/// fill's tile average color (transparent for other items), computed once a tile.
pub(crate) struct Vector {
pic: Picture,
pixmaps: Vec<Option<Arc<Pixmap>>>,
averages: Vec<[u8; 4]>,
}
impl Vector {
/// Approximate memory held: pixels and path segments.
fn bytes(&self) -> usize {
let px: usize = self.pixmaps.iter().flatten().map(|p| p.width() as usize * p.height() as usize * 4).sum();
let segs: usize = self
.pic
.items
/// Approximate memory held: pixels (a tile shared by several fills once), path segments and the
/// per-item bookkeeping.
pub(crate) fn bytes(&self) -> usize {
let mut seen: HashSet<*const Pixmap> = HashSet::new();
let px: usize = self.pixmaps.iter().flatten().filter(|p| seen.insert(Arc::as_ptr(p))).map(|p| bitmap_bytes(p)).sum();
px.saturating_add(self.averages.capacity() * 4).saturating_add(geometry_bytes(&self.pic))
}
}
/// Memory held by one decoded bitmap: its pixels plus the pixmap and its `Arc` header.
fn bitmap_bytes(p: &Pixmap) -> usize {
usize::from(p.width()) * usize::from(p.height()) * 4 + std::mem::size_of::<Pixmap>() + 2 * std::mem::size_of::<usize>()
}
/// Approximate memory held by a picture's items: path segments and text (charged by capacity, as a
/// parsed vector keeps its growth slack), the item itself (a bitmap
/// item stays in the list after its pixels move out), a path's dash array, a text's boxed record and
/// font name, the pixmap slot kept for it, a pattern's path
/// and tile, and every item's clip rectangles and clip paths. Tiles and clip paths are shared between
/// the items that use them, so each is charged once.
pub(crate) fn geometry_bytes(pic: &Picture) -> usize {
let slot = std::mem::size_of::<Option<Arc<Pixmap>>>();
let seg = std::mem::size_of::<Seg>();
let mut tiles: HashSet<*const Tile> = HashSet::new();
let mut clip_paths: HashSet<*const ClipPath> = HashSet::new();
let mut total = 0usize;
for it in &pic.items {
let (region, clips): (&Option<Vec<[f32; 4]>>, &[Arc<ClipPath>]) = match it {
Item::Path { region, clips, .. } | Item::Bitmap { region, clips, .. } | Item::Pattern { region, clips, .. } => (region, clips),
Item::Text(t) => (&t.region, &t.clips),
};
let own = match it {
Item::Path { segs, line, .. } => (segs.capacity() * seg).saturating_add(line.dash.capacity() * std::mem::size_of::<f32>()),
Item::Bitmap { .. } => 0,
Item::Pattern { segs, tile, .. } => {
let tile_bytes = if tiles.insert(Arc::as_ptr(tile)) { tile.rgba.len().saturating_add(std::mem::size_of::<Tile>()) } else { 0 };
(segs.capacity() * seg).saturating_add(tile_bytes)
}
Item::Text(t) => {
std::mem::size_of::<craft_metafile::Text>() + t.text.len() + t.dx.len() * std::mem::size_of::<f32>() + t.font.family.len()
}
};
let region_bytes = region.as_ref().map_or(0, |r| r.len() * std::mem::size_of::<[f32; 4]>());
let clip_bytes: usize = clips
.iter()
.map(|it| match it {
Item::Path { segs, .. } => segs.len() * std::mem::size_of::<Seg>(),
Item::Bitmap { .. } | Item::Pattern { .. } => 0,
Item::Text(t) => t.text.len() + t.dx.len() * 4,
.map(|c| {
let arc = std::mem::size_of::<usize>() * 2 + std::mem::size_of::<Arc<ClipPath>>();
if clip_paths.insert(Arc::as_ptr(c)) { arc + std::mem::size_of::<ClipPath>() + c.segs.capacity() * seg } else { arc }
})
.sum();
px + segs
total = total.saturating_add(slot + std::mem::size_of::<Item>()).saturating_add(own).saturating_add(region_bytes).saturating_add(clip_bytes);
}
total
}
/// The metafile picture for a media key. None when the bytes are not a metafile or do not parse, so
@@ -184,25 +227,94 @@ pub(crate) fn vector_for(doc: &Document, key: &str) -> Option<Arc<Vector>> {
v
}
/// Parses a metafile and decodes its bitmaps. None when the picture has no usable size.
fn build_vector(bytes: &[u8]) -> Option<Vector> {
/// Parses a metafile and decodes its bitmaps and pattern tiles. None when the picture has no
/// usable size.
pub(crate) fn build_vector(bytes: &[u8]) -> Option<Vector> {
let mut pic = craft_metafile::parse(bytes).ok()?;
if !pic.has_size() {
return None;
}
// The pixels move into the pixmaps; the picture keeps only the geometry.
let pixmaps = pic.items.iter_mut().map(|it| it.take_pixels().and_then(|(w, h, px)| premul_pixmap(w, h, &px)).map(Arc::new)).collect();
Some(Vector { pic, pixmaps })
// The pixels move into the pixmaps; the picture keeps only the geometry. A tile shared by
// several fills is converted and averaged once. Only the bitmaps are fitted to the cache: a
// tile is small and stays as it is, but counts against the budget.
let mut tiles: HashMap<usize, (Option<Arc<Pixmap>>, [u8; 4])> = HashMap::new();
let mut tile_bytes = 0usize;
let mut bitmaps: Vec<Option<Pixmap>> = Vec::with_capacity(pic.items.len());
let mut averages: Vec<[u8; 4]> = Vec::with_capacity(pic.items.len());
let mut patterns: Vec<Option<Arc<Pixmap>>> = Vec::with_capacity(pic.items.len());
for it in pic.items.iter_mut() {
if let Item::Pattern { tile, .. } = it {
let key = Arc::as_ptr(tile) as usize;
let fresh = !tiles.contains_key(&key);
let (pm, avg) = tiles
.entry(key)
.or_insert_with(|| {
(premul_pixmap(tile.width, tile.height, &tile.rgba).map(Arc::new), wordcraft_layout::metafile_average_color(&tile.rgba))
})
.clone();
if fresh {
tile_bytes = tile_bytes.saturating_add(pm.as_ref().map_or(0, |p| bitmap_bytes(p)));
}
bitmaps.push(None);
patterns.push(pm);
averages.push(avg);
} else {
bitmaps.push(it.take_pixels().and_then(|(w, h, px)| premul_pixmap(w, h, &px)));
patterns.push(None);
averages.push([0; 4]);
}
}
let bitmaps = fit_cache(bitmaps, geometry_bytes(&pic).saturating_add(tile_bytes));
let pixmaps = bitmaps.into_iter().zip(patterns).map(|(b, t)| b.map(Arc::new).or(t)).collect();
Some(Vector { pic, pixmaps, averages })
}
/// The bitmaps of a metafile at a size its whole picture is kept in the cache. When geometry and
/// bitmaps together are past the cache budget (a metafile with a 6000 x 6000 bitmap is 144 MB), the
/// cache would refuse the picture and every repaint would parse and decode the file again, so the
/// bitmaps are box-averaged down to an eighth of the budget between them, in proportion to their
/// size, as large raster pictures are (#3665, which uses half). An eighth because the cache starts
/// over when full: several huge pictures on screen together must fit side by side, and not clear
/// the small ones with them. Geometry that is itself an eighth or more still leaves the bitmaps a
/// sixteenth, as long as the whole budget has room for it. A picture that still cannot fit after shrinking stays uncached,
/// as before. Pictures within the budget keep their full resolution. Printing (`render_page`) draws
/// the shrunk bitmaps too, as it does large raster pictures; PDF export parses the metafile itself
/// and is unaffected.
pub(crate) fn fit_cache(mut pixmaps: Vec<Option<Pixmap>>, geometry: usize) -> Vec<Option<Pixmap>> {
let pixels = |p: &Pixmap| usize::from(p.width()) * usize::from(p.height()) * 4;
let total: usize = pixmaps.iter().flatten().map(pixels).sum();
let fixed: usize = pixmaps.iter().flatten().map(|p| bitmap_bytes(p) - pixels(p)).sum();
if total.saturating_add(fixed).saturating_add(geometry) <= CACHE_BYTES {
return pixmaps;
}
// The bitmaps get what is left of an eighth, but never less than a sixteenth (so the allowance does
// not drop to nothing as geometry reaches the eighth) and never more than the whole budget leaves.
let target = CACHE_BYTES / 8;
let allowance = target.saturating_sub(geometry).max(target / 2).min(CACHE_BYTES.saturating_sub(geometry));
let room = allowance.saturating_sub(fixed) / 4;
for pm in pixmaps.iter_mut().flatten() {
// This bitmap's share of the pixels that fit.
let share = (room as u128 * pixels(pm) as u128 / total.max(1) as u128) as u64;
if let Some(small) = shrink(pm, share) {
*pm = small;
}
}
pixmaps
}
fn rgba_color(c: [u8; 4]) -> peniko::Color {
peniko::Color::from_rgba8(c[0], c[1], c[2], c[3])
}
/// Pattern tiles smaller than this (device pixels on both sides) are drawn as the tile's average
/// color: a sub-pixel pattern would only alias.
const MIN_TILE_PX: f64 = 1.5;
/// Draws a metafile picture into `r` (page points): fills and strokes in page space (so strokes keep
/// their width under non-uniform scaling), bitmaps stretched, all clipped to `r` and faded by `alpha`.
/// Strokes have round caps and joins, as GDI draws them, and are at least one device pixel wide, so
/// cosmetic (width 0) pens show as hairlines at any zoom.
/// their width under non-uniform scaling), bitmaps stretched (or turned by their transform),
/// pattern fills tiled, each item inside its clip region and clip paths, all clipped to `r` and
/// faded by `alpha`. Strokes take the pen's caps, joins and dashes and are at least one device
/// pixel wide, so cosmetic (width 0) pens show as hairlines at any zoom.
pub(crate) fn draw_vector(ctx: &mut RenderContext, v: &Vector, r: &kurbo::Rect, crop: &[f32; 4], alpha: f32, view: Affine) {
ctx.set_transform(view);
let alpha = if alpha.is_finite() { alpha.clamp(0.0, 1.0) } else { 1.0 };
@@ -212,9 +324,9 @@ pub(crate) fn draw_vector(ctx: &mut RenderContext, v: &Vector, r: &kurbo::Rect,
}
ctx.push_clip_layer(&r.to_path(0.1));
let pixel = device_pixel(view);
for it in v.pic.place(*r, *crop) {
for it in v.pic.place(*r, wordcraft_layout::crop_sides(*crop)) {
match it {
PlacedItem::Path { path, fill, stroke, even_odd, .. } => {
PlacedItem::Path { path, fill, stroke, line, even_odd, region, clips } => clipped(ctx, region.as_deref(), &clips, |ctx| {
if let Some(f) = fill {
ctx.set_paint(rgba_color(f));
ctx.set_fill_rule(if even_odd { peniko::Fill::EvenOdd } else { peniko::Fill::NonZero });
@@ -222,26 +334,71 @@ pub(crate) fn draw_vector(ctx: &mut RenderContext, v: &Vector, r: &kurbo::Rect,
}
if let Some((s, w)) = stroke {
ctx.set_paint(rgba_color(s));
ctx.set_stroke(kurbo::Stroke::new(w.max(pixel)).with_caps(kurbo::Cap::Round).with_join(kurbo::Join::Round));
ctx.set_stroke(pen(w, pixel, &line, &path));
ctx.stroke_path(&path);
}
}
PlacedItem::Bitmap { index, rect, .. } => {
let Some(Some(pm)) = v.pixmaps.get(index) else { continue };
}),
PlacedItem::Bitmap { index, rect, transform, region, clips } => clipped(ctx, region.as_deref(), &clips, |ctx| {
let Some(Some(pm)) = v.pixmaps.get(index) else { return };
let (pw, ph) = (pm.width().max(1) as f64, pm.height().max(1) as f64);
ctx.set_paint(vello_cpu::Image {
image: vello_cpu::ImageSource::Pixmap(pm.clone()),
sampler: peniko::ImageSampler::default().with_quality(peniko::ImageQuality::Medium),
});
ctx.set_paint_transform(Affine::translate((rect.x0, rect.y0)) * Affine::scale_non_uniform(rect.width() / pw, rect.height() / ph));
ctx.fill_rect(&rect);
ctx.reset_paint_transform();
}
PlacedItem::Pattern { .. } => {}
PlacedItem::Text { index, transform, .. } => {
if let Some(Item::Text(t)) = v.pic.items.get(index) {
draw_vector_text(ctx, t, view * transform);
let c = transform.as_coeffs();
// Upright and not mirrored: the bitmap fills `rect`.
if c[1] == 0.0 && c[2] == 0.0 && c[0] > 0.0 && c[3] > 0.0 {
ctx.set_paint_transform(Affine::translate((rect.x0, rect.y0)) * Affine::scale_non_uniform(rect.width() / pw, rect.height() / ph));
ctx.fill_rect(&rect);
} else {
// A turned, skewed or mirrored bitmap: `transform` maps the unit square onto its place.
ctx.set_paint_transform(transform * Affine::scale_non_uniform(1.0 / pw, 1.0 / ph));
ctx.fill_path(&(transform * kurbo::Rect::new(0.0, 0.0, 1.0, 1.0).to_path(0.1)));
}
ctx.reset_paint_transform();
}),
PlacedItem::Pattern { index, path, even_odd, tile, region, clips } => clipped(ctx, region.as_deref(), &clips, |ctx| {
let Some(Item::Pattern { tile: t, .. }) = v.pic.items.get(index) else { return };
ctx.set_fill_rule(if even_odd { peniko::Fill::EvenOdd } else { peniko::Fill::NonZero });
// `tile` maps one tile pixel to page points: the tile's sides are its columns and
// its rows under that, in device pixels. The tile is drawn when either side is at
// least `MIN_TILE_PX`.
let c = (view * tile).as_coeffs();
let across = c[0].hypot(c[1]) * f64::from(t.width);
let down = c[2].hypot(c[3]) * f64::from(t.height);
match v.pixmaps.get(index) {
Some(Some(pm)) if across.max(down) >= MIN_TILE_PX => {
ctx.set_paint(vello_cpu::Image {
image: vello_cpu::ImageSource::Pixmap(pm.clone()),
sampler: peniko::ImageSampler {
x_extend: peniko::Extend::Repeat,
y_extend: peniko::Extend::Repeat,
quality: peniko::ImageQuality::Low,
alpha: 1.0,
},
});
ctx.set_paint_transform(tile);
ctx.fill_path(&path);
ctx.reset_paint_transform();
}
_ => {
ctx.set_paint(rgba_color(v.averages.get(index).copied().unwrap_or([0; 4])));
ctx.fill_path(&path);
}
}
}),
PlacedItem::Text { index, transform, clip, region, clips } => {
clipped(ctx, region.as_deref(), &clips, |ctx| {
let Some(Item::Text(t)) = v.pic.items.get(index) else { return };
if let Some(c) = clip {
ctx.push_clip_layer(&c.to_path(0.1));
}
draw_vector_text(ctx, t, view * transform);
ctx.set_transform(view);
if clip.is_some() {
ctx.pop_layer();
}
});
ctx.set_transform(view);
}
}
@@ -253,15 +410,76 @@ pub(crate) fn draw_vector(ctx: &mut RenderContext, v: &Vector, r: &kurbo::Rect,
}
}
/// Draws a metafile text run: `tf` maps the run's own space (see [`PlacedItem::Text`]) to the device.
/// Draws `draw` inside a metafile item's clip region and every one of its clip paths (page
/// points, under the current transform). No region is the default clip.
fn clipped(
ctx: &mut RenderContext,
region: Option<&kurbo::BezPath>,
clips: &[Arc<craft_metafile::PlacedClip>],
draw: impl FnOnce(&mut RenderContext),
) {
if let Some(region) = region {
ctx.set_fill_rule(peniko::Fill::NonZero);
ctx.push_clip_layer(region);
}
for c in clips {
ctx.set_fill_rule(if c.even_odd { peniko::Fill::EvenOdd } else { peniko::Fill::NonZero });
ctx.push_clip_layer(&c.path);
}
ctx.set_fill_rule(peniko::Fill::NonZero);
draw(ctx);
for _ in 0..clips.len() + usize::from(region.is_some()) {
ctx.pop_layer();
}
}
/// A metafile pen for `path` as a stroke `width` wide (page points, at least one device `pixel`):
/// its caps, joins, miter limit and dashes (`wordcraft_layout::metafile_dashes`).
fn pen(width: f64, pixel: f64, line: &craft_metafile::LineStyle, path: &kurbo::BezPath) -> kurbo::Stroke {
let cap = match line.cap {
craft_metafile::Cap::Round => kurbo::Cap::Round,
craft_metafile::Cap::Square => kurbo::Cap::Square,
craft_metafile::Cap::Flat => kurbo::Cap::Butt,
};
let join = match line.join {
craft_metafile::Join::Round => kurbo::Join::Round,
craft_metafile::Join::Bevel => kurbo::Join::Bevel,
craft_metafile::Join::Miter => kurbo::Join::Miter,
};
let stroke = kurbo::Stroke::new(width.max(pixel))
.with_caps(cap)
.with_join(join)
.with_miter_limit(f64::from(wordcraft_layout::metafile_miter_limit(line.miter_limit)));
if line.dash.is_empty() {
return stroke;
}
match wordcraft_layout::metafile_dashes(&line.dash, width == 0.0, pixel, path.perimeter(1.0)) {
Some(dash) => stroke.with_dashes(0.0, dash),
None => stroke,
}
}
/// Draws a metafile text run: `tf` maps its text space (`craft_metafile::Text::transform`) to the
/// device.
fn draw_vector_text(ctx: &mut RenderContext, t: &craft_metafile::Text, tf: Affine) {
let (face, shaped) = wordcraft_layout::metafile_text_run(t);
let glyphs: Vec<_> = shaped.iter().map(|g| (g.cluster, f64::from(g.x_advance), f64::from(g.x_offset), f64::from(g.y_offset))).collect();
let Some(lay) = wordcraft_layout::layout_metafile_text(t, face.upem, face.ascent, face.descent, &glyphs) else { return };
let k = lay.em / face.upem.max(1.0);
let canvas = kurbo::Rect::new(0.0, 0.0, f64::from(ctx.width()), f64::from(ctx.height()));
// An opaque background mode fills the character cells first.
if let Some(bg) = t.background {
let [x0, y0, x1, y1] = lay.cell;
let cell = tf * kurbo::Rect::new(x0, y0, x1, y1).to_path(0.1);
let b = cell.bounding_box();
if x1 > x0 && [b.x0, b.y0, b.x1, b.y1].iter().all(|v| v.is_finite() && v.abs() <= MAX_GLYPH_PIXELS * 16.0) && b.overlaps(canvas) {
ctx.set_transform(Affine::IDENTITY);
ctx.set_paint(rgba_color(bg));
ctx.fill_path(&cell);
}
}
ctx.set_paint(rgba_color(t.color));
let db = FontDb::global();
let canvas = kurbo::Rect::new(0.0, 0.0, f64::from(ctx.width()), f64::from(ctx.height()));
let mut oversized = 0usize;
for (g, (x, y)) in shaped.iter().zip(&lay.glyphs) {
let o = db.outline(&face, g.gid);
+572
View File
@@ -1,4 +1,5 @@
use super::*;
use crate::media::fit_cache;
use wordcraft_layout::display::page_display;
use wordcraft_layout::{LayoutCache, LayoutOptions, layout};
@@ -1041,6 +1042,393 @@ fn metafile_picture_is_drawn_as_vectors() {
assert!(left[..3].iter().all(|c| *c > 200), "left half should be paper, not the grey box: {left:?}");
}
/// An EMF whose only record is one `w` x `h` 1 bpp black and white bitmap over the whole picture.
fn emf_with_1bpp_bitmap(w: i32, h: i32) -> Vec<u8> {
let mut hdr = vec![0u8; 88];
hdr[0..4].copy_from_slice(&1u32.to_le_bytes());
hdr[4..8].copy_from_slice(&88u32.to_le_bytes());
hdr[8..24].copy_from_slice(&le32(&[0, 0, 100, 100]));
hdr[24..40].copy_from_slice(&le32(&[0, 0, 2500, 2500]));
hdr[40..44].copy_from_slice(&0x464D_4520u32.to_le_bytes());
hdr[72..88].copy_from_slice(&le32(&[1000, 1000, 250, 250]));
let stride = (w as usize).div_ceil(32) * 4;
let mut payload = vec![0u8; 16];
payload.extend(le32(&[0, 0, 0, 0, w, h, 80, 48, 128, (stride * h as usize) as i32, 0, 0x00CC_0020, 100, 100]));
payload.extend(le32(&[40, w, h, 1 | (1 << 16), 0, 0, 0, 0, 0, 0]));
payload.extend([0, 0, 0, 0, 255, 255, 255, 0]);
payload.extend((0..stride * h as usize).map(|i| (i * 31) as u8));
[hdr, emf_rec(81, &payload), emf_rec(14, &[0; 12])].concat()
}
/// #5482: a metafile whose bitmaps are past the whole cache budget was parsed and decoded again on
/// every repaint, because the cache refused it. It is now kept (its bitmaps at a smaller size).
#[test]
fn a_metafile_with_a_huge_bitmap_is_parsed_once() {
// 8000 x 5000 is 160 MB of RGBA, past the 128 MB cache, from a 5 MB file.
let mut d = Document::new();
// A key of its own: the vector cache is global and tests running in threads share `image1.emf`.
let key = "huge-parsed-once.emf";
d.media.insert(key.to_string(), Arc::new(emf_with_1bpp_bitmap(8000, 5000)));
let first = vector_for(&d, key).expect("the metafile reads");
let again = vector_for(&d, key).expect("the metafile reads");
assert!(Arc::ptr_eq(&first, &again), "the second repaint reuses the parsed picture");
assert!(first.bytes() <= CACHE_BYTES / 8, "{} bytes", first.bytes());
}
/// Several huge metafiles on screen together (zoomed-out pages, thumbnails) sit side by side in the
/// cache instead of clearing it, so a small metafile drawn with them stays a hit.
#[test]
fn huge_metafiles_do_not_push_a_small_one_out_of_the_cache() {
let mut d = Document::new();
let small = "evict-small.emf";
d.media.insert(small.to_string(), Arc::new(emf_with_1bpp_bitmap(64, 64)));
let huge: Vec<String> = (0..4).map(|n| format!("evict-huge-{n}.emf")).collect();
for (n, k) in huge.iter().enumerate() {
// Distinct bytes per file (the width differs; 8000 x 5000 is the most pixels a metafile decodes), so each is its own cache entry.
d.media.insert(k.clone(), Arc::new(emf_with_1bpp_bitmap(8000 - n as i32, 5000)));
}
let small_first = vector_for(&d, small).expect("the small metafile reads");
for round in 0..2 {
for k in &huge {
assert!(vector_for(&d, k).is_some(), "round {round}");
}
}
let kept: Vec<_> = huge.iter().map(|k| vector_for(&d, k).unwrap()).collect();
let again: Vec<_> = huge.iter().map(|k| vector_for(&d, k).unwrap()).collect();
for (a, b) in kept.iter().zip(&again) {
assert!(Arc::ptr_eq(a, b), "a huge metafile is parsed once while four are drawn together");
}
assert!(Arc::ptr_eq(&small_first, &vector_for(&d, small).unwrap()), "the small metafile is still cached");
}
/// Time of three repaints of a picture with a 160 MB bitmap:
/// `cargo test -p wordcraft-render --release -- --ignored --nocapture huge_metafile_repaint_time`.
#[test]
#[ignore = "timing only"]
fn huge_metafile_repaint_time() {
let mut d = Document::new();
let key = d.add_media(emf_with_1bpp_bitmap(8000, 5000), "emf");
for n in 1..=4 {
let t = std::time::Instant::now();
assert!(vector_for(&d, &key).is_some());
eprintln!("repaint {n}: vector_for {:.1} ms", t.elapsed().as_secs_f64() * 1e3);
}
}
#[test]
fn bitmaps_are_shrunk_in_proportion_only_when_the_picture_is_past_the_cache() {
let px = vello_cpu::color::PremulRgba8 { r: 1, g: 2, b: 3, a: 255 };
let pm = |w: u16, h: u16| Some(Pixmap::from_parts(vec![px; usize::from(w) * usize::from(h)], w, h));
let bytes = |v: &[Option<Pixmap>]| v.iter().flatten().map(|p| usize::from(p.width()) * usize::from(p.height()) * 4).sum::<usize>();
// Within the budget: untouched.
let kept = fit_cache(vec![pm(1000, 1000), None, pm(2000, 2000)], 1_000_000);
assert_eq!(kept.iter().flatten().map(|p| (p.width(), p.height())).collect::<Vec<_>>(), [(1000, 1000), (2000, 2000)]);
assert!(kept[1].is_none(), "a path item keeps its place in the list");
// A 144 MB and a 36 MB bitmap: both shrink by the same factor.
let fit = fit_cache(vec![pm(6000, 6000), pm(3000, 3000)], 4_000_000);
assert!(bytes(&fit) + 4_000_000 <= CACHE_BYTES / 8, "{} bytes", bytes(&fit));
let (a, b) = (fit[0].as_ref().unwrap(), fit[1].as_ref().unwrap());
assert_eq!((a.width(), b.width()), (1500, 750), "each bitmap keeps its share of the pixels that fit");
assert!(a.data().iter().all(|p| (p.r, p.g, p.b, p.a) == (1, 2, 3, 255)), "flat stays flat");
}
/// Geometry of an eighth of the budget or more leaves the bitmaps a positive allowance, so the
/// picture is still kept (and reused) when it fits the whole budget after shrinking; one whose
/// geometry alone fills the budget stays uncached.
#[test]
fn heavy_geometry_still_leaves_the_bitmaps_a_cacheable_size() {
let px = vello_cpu::color::PremulRgba8 { r: 1, g: 2, b: 3, a: 255 };
let pm = |w: u16, h: u16| Some(Pixmap::from_parts(vec![px; usize::from(w) * usize::from(h)], w, h));
let bytes = |v: &[Option<Pixmap>]| v.iter().flatten().map(|p| usize::from(p.width()) * usize::from(p.height()) * 4).sum::<usize>();
let geometry = CACHE_BYTES / 8 + 4_000_000;
let fit = fit_cache(vec![pm(6000, 6000)], geometry);
let size = bytes(&fit);
assert!(size > 0 && size < 6000 * 6000 * 4, "shrunk, not dropped: {size} bytes");
assert!(size + geometry <= CACHE_BYTES, "{size} bytes");
// The shrunk picture is accepted by the cache and hit again.
let src = Arc::new(vec![0u8; 1]);
let mut c: MediaCache<u8> = MediaCache { map: Default::default(), bytes: 0 };
c.insert("heavy", &src, 7, size + geometry);
assert_eq!(c.get("heavy", &src), Some(7));
// Just under and just over the eighth: both shrink the bitmap to a positive size, none to nothing.
for g in [CACHE_BYTES / 8 - 1, CACHE_BYTES / 8, CACHE_BYTES / 8 + 1] {
let size = bytes(&fit_cache(vec![pm(6000, 6000)], g));
assert!(size > 0 && size < 6000 * 6000 * 4 && size + g <= CACHE_BYTES / 4, "geometry {g}: {size} bytes");
}
// Geometry that takes the whole budget leaves nothing to shrink to: the bitmap stays as it is.
let full = fit_cache(vec![pm(6000, 6000)], CACHE_BYTES);
assert_eq!(bytes(&full), 6000 * 6000 * 4);
}
/// #6636: an EMF+ only file (no plain EMF drawing records) whose EmfPlusDrawImage draws a
/// 32bppPARGB bitmap over the right half: the bitmap's pixels are drawn.
#[test]
fn emf_plus_only_bitmap_is_drawn() {
// EmfPlusObject 0, an image (type 5): a 2 × 1 bitmap in PixelFormat32bppPARGB, opaque red
// and then red at half opacity (premultiplied BGRA 0, 0, 128, 128).
let mut image = le32(&[0xDBC0_1002_u32 as i32, 1, 2, 1, 8, 0x000E_200B, 0]);
image.extend([0u8, 0, 255, 255, 0, 0, 128, 128]);
let object = plus_rec(0x4008, 0x0500, &image);
// EmfPlusDrawImage of image 0: the whole bitmap (pixel units) into x 50..100, y 0..100.
let mut draw = le32(&[-1, 2]);
draw.extend([0.0f32, 0.0, 2.0, 1.0, 50.0, 0.0, 50.0, 100.0].iter().flat_map(|v| v.to_le_bytes()));
let emf = emf_plus_file(&[object, plus_rec(0x401A, 0, &draw)]);
let (img, rect) = emf_on_page(emf, [0.0; 4], 1.0);
let at = |fx: f32| img.pixel((rect.x + rect.w * fx) as u32, (rect.y + rect.h * 0.5) as u32);
let (opaque, half, left) = (at(0.6), at(0.9), at(0.25));
assert!(is_red(opaque), "the bitmap's opaque red is drawn on the right half: {opaque:?}");
// Premultiplied half-opacity red over white paper is (255, 127, 127); read as straight
// color it would be about (191, 127, 127).
assert!(half[0] > 235 && (110..145).contains(&half[1]) && (110..145).contains(&half[2]), "half-opacity red: {half:?}");
assert!(is_paper(left), "left half should be paper: {left:?}");
}
/// #6636: EmfPlusDrawImage draws a bitmap in PixelFormat32bppARGB, 24bppRGB and 32bppRGB, and a
/// compressed PNG or JPEG bitmap, in an EMF+ only file.
#[test]
fn emf_plus_only_bitmap_formats_are_drawn() {
let encoded = |png: bool| {
let red = [255u8, 0, 0].repeat(64);
if png {
let img = image::RgbImage::from_raw(8, 8, red).unwrap();
wordcraft_geom::picture::encode_png(&image::DynamicImage::from(img)).unwrap()
} else {
wordcraft_geom::picture::encode_jpeg(&red, 8, 8, 100).unwrap()
}
};
// Name, width, height, stride, pixel format, bitmap type (0 pixels, 1 compressed) and data.
let cases: [(&str, i32, i32, i32, u32, i32, Vec<u8>); 5] = [
("32bppARGB", 2, 1, 8, 0x0026_200A, 0, [0u8, 0, 255, 255].repeat(2)),
("24bppRGB", 2, 1, 8, 0x0002_1808, 0, vec![0, 0, 255, 0, 0, 255, 0, 0]),
("32bppRGB", 2, 1, 8, 0x0002_2009, 0, [0u8, 0, 255, 0].repeat(2)),
("PNG", 8, 8, 0, 0, 1, encoded(true)),
("JPEG", 8, 8, 0, 0, 1, encoded(false)),
];
for (name, w, h, stride, format, kind, data) in cases {
let mut image = le32(&[0xDBC0_1002_u32 as i32, 1, w, h, stride, format as i32, kind]);
image.extend(data);
// Records are a multiple of 4 bytes long.
image.resize(image.len().next_multiple_of(4), 0);
let mut draw = le32(&[-1, 2]);
draw.extend([0.0f32, 0.0, w as f32, h as f32, 50.0, 0.0, 50.0, 100.0].iter().flat_map(|v| v.to_le_bytes()));
let emf = emf_plus_file(&[plus_rec(0x4008, 0x0500, &image), plus_rec(0x401A, 0, &draw)]);
let (img, rect) = emf_on_page(emf, [0.0; 4], 1.0);
let at = |fx: f32| img.pixel((rect.x + rect.w * fx) as u32, (rect.y + rect.h * 0.5) as u32);
let (right, left) = (at(0.75), at(0.25));
assert!(is_red(right), "{name}: the red bitmap is drawn on the right half: {right:?}");
assert!(is_paper(left), "{name}: left half should be paper: {left:?}");
}
}
/// An EMF+ record for [`emf_plus_file`]: type, flags and data.
fn plus_rec(typ: u16, flags: u16, data: &[u8]) -> Vec<u8> {
let mut v = typ.to_le_bytes().to_vec();
v.extend(flags.to_le_bytes());
v.extend(((12 + data.len()) as u32).to_le_bytes());
v.extend((data.len() as u32).to_le_bytes());
v.extend(data);
v
}
/// An EMF+ only file with the frame of [`red_right_half_emf`]: an EmfPlusHeader (96 dpi), then
/// `records`, then EmfPlusEndOfFile, in one comment record.
fn emf_plus_file(records: &[Vec<u8>]) -> Vec<u8> {
let mut comment = 0x2B46_4D45u32.to_le_bytes().to_vec();
comment.extend(plus_rec(0x4001, 0, &le32(&[0xDBC0_1002_u32 as i32, 1, 96, 96])));
comment.extend(records.concat());
comment.extend(plus_rec(0x4002, 0, &[]));
let mut payload = (comment.len() as u32).to_le_bytes().to_vec();
payload.extend(comment);
let mut emf = red_right_half_emf()[..88].to_vec();
emf.extend([emf_rec(70, &payload), emf_rec(14, &[0; 12])].concat());
emf
}
/// Renders a document holding one 70 pt metafile picture with `crop` at `scale`: the page and the
/// picture's frame (points).
fn emf_on_page(emf: Vec<u8>, crop: [f32; 4], scale: f32) -> (Rendered, wordcraft_geom::Rect) {
emf_on_page_sized(emf, (70.0, 70.0), crop, scale)
}
/// [`emf_on_page`] with the picture `size` (points).
fn emf_on_page_sized(emf: Vec<u8>, size: (f32, f32), crop: [f32; 4], scale: f32) -> (Rendered, wordcraft_geom::Rect) {
let mut d = Document::new();
let media = d.add_media(emf, "emf");
let mut p = wordcraft_doc::Paragraph::new();
let obj = wordcraft_doc::para::InlineObject::Image {
media,
w: size.0,
h: size.1,
alt: String::new(),
float: Default::default(),
crop,
fx: Default::default(),
ole: None,
};
p.insert_object(0, obj, &Default::default()).unwrap();
d.body = vec![wordcraft_doc::para_block(p)];
let l = layout(&d, &mut LayoutCache::new(), &LayoutOptions::default());
let opts = RenderOptions::default();
let rect = page_display(&d, &l.pages[0], &opts.display)
.iter()
.find_map(|i| match i {
Draw::Image { rect, .. } => Some(*rect),
_ => None,
})
.expect("a picture on the page");
(render_page(&d, &l.pages[0], scale, &opts), rect)
}
/// Whether a pixel is close to pure red.
fn is_red(p: [u8; 4]) -> bool {
p[0] > 200 && p[1] < 60 && p[2] < 60
}
/// Whether a pixel is paper.
fn is_paper(p: [u8; 4]) -> bool {
p[..3].iter().all(|c| *c > 200)
}
/// A clip region (INTERSECTCLIPRECT to the left half) keeps a red rectangle over the whole
/// picture to that half; once RESTOREDC drops it, a second rectangle across the bottom shows on
/// both halves.
#[test]
fn metafile_clip_region_clips_and_ends() {
let mut emf = red_right_half_emf()[..88].to_vec();
let brush = emf_rec(39, &le32(&[1, 0, 0x0000_00FF, 0]));
let recs = [
brush,
emf_rec(37, &le32(&[1])),
emf_rec(33, &[]),
emf_rec(30, &le32(&[0, 0, 50, 100])),
emf_rec(43, &le32(&[0, 0, 100, 60])),
emf_rec(34, &le32(&[-1])),
emf_rec(43, &le32(&[0, 80, 100, 100])),
emf_rec(14, &[0; 12]),
];
emf.extend(recs.concat());
let (img, rect) = emf_on_page(emf, [0.0; 4], 1.0);
let at = |fx: f32, fy: f32| img.pixel((rect.x + rect.w * fx) as u32, (rect.y + rect.h * fy) as u32);
assert!(is_red(at(0.25, 0.3)), "inside the clip: {:?}", at(0.25, 0.3));
assert!(is_paper(at(0.75, 0.3)), "outside the clip: {:?}", at(0.75, 0.3));
assert!(is_red(at(0.75, 0.9)), "after the clip is restored away: {:?}", at(0.75, 0.9));
}
/// The vector cache counts each item's copy of the clip region: 100 rectangles drawn inside a
/// clip region hold 100 copies of its rectangle more than without it.
#[test]
fn metafile_cache_counts_clip_regions() {
let bytes = |clip: bool| {
let mut emf = red_right_half_emf()[..88].to_vec();
if clip {
emf.extend(emf_rec(30, &le32(&[0, 0, 50, 100])));
}
for i in 0..100 {
emf.extend(emf_rec(43, &le32(&[i % 50, 0, i % 50 + 10, 10])));
}
emf.extend(emf_rec(14, &[0; 12]));
media::build_vector(&emf).map(|v| v.bytes())
};
let (with, without) = (bytes(true).expect("a picture"), bytes(false).expect("a picture"));
assert!(with >= without + 100 * 16, "{with} and {without}");
}
/// A hatch tile squeezed to well under a pixel tall but several pixels wide (the picture is 70 pt
/// wide and 2 pt tall) keeps its vertical lines: the row crosses red lines and the background
/// between them, not one blended color.
#[test]
fn metafile_narrow_hatch_tile_keeps_its_lines() {
let mut emf = red_right_half_emf()[..88].to_vec();
let brush = emf_rec(39, &le32(&[1, 2, 0x0000_00FF, 1]));
// The stock NULL_PEN leaves the rectangle without an outline.
let no_pen = emf_rec(37, &le32(&[0x8000_0008_u32 as i32]));
emf.extend([brush, emf_rec(37, &le32(&[1])), no_pen, emf_rec(43, &le32(&[0, 0, 100, 100])), emf_rec(14, &[0; 12])].concat());
let (img, rect) = emf_on_page_sized(emf, (70.0, 2.0), [0.0; 4], 1.0);
let y = (rect.y + rect.h / 2.0) as u32;
let row: Vec<u8> = ((rect.x + 2.0) as u32..(rect.x + rect.w - 2.0) as u32).map(|x| img.pixel(x, y)[1]).collect();
assert!(row.iter().any(|g| *g < 160) && row.iter().any(|g| *g > 240), "red lines and background: {row:?}");
}
/// A clip path (a rectangle path over the left half, SELECTCLIPPATH with RGN_COPY) keeps a red
/// rectangle over the whole picture to that half.
#[test]
fn metafile_clip_path_clips() {
let mut emf = red_right_half_emf()[..88].to_vec();
let brush = emf_rec(39, &le32(&[1, 0, 0x0000_00FF, 0]));
let recs = [
brush,
emf_rec(37, &le32(&[1])),
emf_rec(59, &[]),
emf_rec(43, &le32(&[0, 0, 50, 100])),
emf_rec(60, &[]),
emf_rec(67, &le32(&[5])),
emf_rec(43, &le32(&[0, 0, 100, 100])),
emf_rec(14, &[0; 12]),
];
emf.extend(recs.concat());
let (img, rect) = emf_on_page(emf, [0.0; 4], 1.0);
let at = |fx: f32| img.pixel((rect.x + rect.w * fx) as u32, (rect.y + rect.h * 0.5) as u32);
assert!(is_red(at(0.25)), "inside the clip path: {:?}", at(0.25));
assert!(is_paper(at(0.75)), "outside the clip path: {:?}", at(0.75));
}
/// A bitmap under a world transform that turns it a quarter turn clockwise about the picture's
/// center (EmfPlusSetWorldTransform): its left pixel (red) is drawn at the top and its right pixel
/// (blue) at the bottom.
#[test]
fn emf_plus_turned_bitmap_is_drawn_turned() {
let mut image = le32(&[0xDBC0_1002_u32 as i32, 1, 2, 1, 8, 0x000E_200B, 0]);
// BGRA: red, then blue.
image.extend([0u8, 0, 255, 255, 255, 0, 0, 255]);
let turn = plus_rec(0x402A, 0, &[0.0f32, 1.0, -1.0, 0.0, 100.0, 0.0].iter().flat_map(|v| v.to_le_bytes()).collect::<Vec<_>>());
let mut draw = le32(&[-1, 2]);
draw.extend([0.0f32, 0.0, 2.0, 1.0, 25.0, 25.0, 50.0, 50.0].iter().flat_map(|v| v.to_le_bytes()));
let emf = emf_plus_file(&[plus_rec(0x4008, 0x0500, &image), turn, plus_rec(0x401A, 0, &draw)]);
let (img, rect) = emf_on_page(emf, [0.0; 4], 1.0);
let at = |fx: f32, fy: f32| img.pixel((rect.x + rect.w * fx) as u32, (rect.y + rect.h * fy) as u32);
let (top_right, bottom_left) = (at(0.65, 0.37), at(0.35, 0.62));
assert!(is_red(top_right), "red at the top: {top_right:?}");
assert!(bottom_left[2] > 200 && bottom_left[0] < 60, "blue at the bottom: {bottom_left:?}");
}
/// A geometric PS_USERSTYLE pen whose dashes and gaps are far below a pixel draws its line solid
/// instead of splitting it into dashes too small to see.
#[test]
fn metafile_sub_pixel_dashes_draw_solid() {
let mut emf = red_right_half_emf()[..88].to_vec();
// 10,000 device pixels over 250 mm: a device unit is 0.025 mm. The picture is 1000 units wide.
emf[8..24].copy_from_slice(&le32(&[0, 0, 1000, 1000]));
emf[72..80].copy_from_slice(&le32(&[10_000, 10_000]));
// EXTCREATEPEN 1: PS_GEOMETRIC | PS_ENDCAP_FLAT | PS_USERSTYLE, 80 units wide, black, two
// entries of 1 unit.
let pen = emf_rec(95, &le32(&[1, 0, 0, 0, 0, 0x0001_0207, 80, 0, 0, 0, 2, 1, 1]));
let recs = [pen, emf_rec(37, &le32(&[1])), emf_rec(27, &le32(&[0, 500])), emf_rec(54, &le32(&[1000, 500])), emf_rec(14, &[0; 12])];
emf.extend(recs.concat());
let (img, rect) = emf_on_page(emf, [0.0; 4], 1.0);
let y = (rect.y + rect.h * 0.5) as u32;
let (x0, x1) = ((rect.x + 5.0) as u32, (rect.x + rect.w - 5.0) as u32);
let dark = (x0..x1).filter(|&x| img.pixel(x, y)[..3].iter().all(|c| *c < 60)).count();
assert_eq!(dark, (x1 - x0) as usize, "the line is solid black");
}
/// A hatched brush (CREATEBRUSHINDIRECT, BS_HATCHED, HS_VERTICAL) fills with its red lines over
/// the background, not with a solid red.
#[test]
fn metafile_hatch_brush_draws_its_lines() {
let mut emf = red_right_half_emf()[..88].to_vec();
let brush = emf_rec(39, &le32(&[1, 2, 0x0000_00FF, 1]));
emf.extend([brush, emf_rec(37, &le32(&[1])), emf_rec(43, &le32(&[0, 0, 100, 100])), emf_rec(14, &[0; 12])].concat());
let scale = 4.0;
let (img, rect) = emf_on_page(emf, [0.0; 4], scale);
let y = ((rect.y + rect.h / 2.0) * scale) as u32;
let (x0, x1) = (((rect.x + 2.0) * scale) as u32, ((rect.x + rect.w - 2.0) * scale) as u32);
let red = (x0..x1).filter(|&x| img.pixel(x, y)[1] < 128).count();
let n = (x1 - x0) as usize;
assert!(red > 0 && red < n * 3 / 4, "the row crosses red lines and the background between them: {red} of {n} red");
}
/// #1899: a crop that keeps a sliver of the picture (3% here; a header's bar can be 2.7% of a
/// page-sized metafile) stretches that sliver over the frame, as the file says, for vector and
/// bitmap pictures alike. Both pictures are paper on the left half and red on the right.
@@ -1084,6 +1472,43 @@ fn a_crop_keeping_a_sliver_fills_the_frame_with_it() {
}
}
/// A negative crop side draws as no crop on that side, for vector and bitmap pictures alike: a
/// left side of -0.5 does not pad the source, so the frame at 55% shows the source at 55% (red).
#[test]
fn a_negative_crop_side_draws_uncropped() {
let img = image::RgbaImage::from_fn(100, 100, |x, _| image::Rgba(if x >= 50 { [255, 0, 0, 255] } else { [255; 4] }));
let png = wordcraft_geom::picture::encode_png(&image::DynamicImage::from(img)).unwrap();
for (bytes, ext) in [(red_right_half_emf(), "emf"), (png, "png")] {
let mut d = Document::new();
let media = d.add_media(bytes, ext);
let mut p = wordcraft_doc::Paragraph::new();
let obj = wordcraft_doc::para::InlineObject::Image {
media,
w: 70.0,
h: 70.0,
alt: String::new(),
float: Default::default(),
crop: [-0.5, 0.0, 0.0, 0.0],
fx: Default::default(),
ole: None,
};
p.insert_object(0, obj, &Default::default()).unwrap();
d.body = vec![wordcraft_doc::para_block(p)];
let l = layout(&d, &mut LayoutCache::new(), &LayoutOptions::default());
let opts = RenderOptions::default();
let rect = page_display(&d, &l.pages[0], &opts.display)
.iter()
.find_map(|i| match i {
Draw::Image { rect, .. } => Some(*rect),
_ => None,
})
.expect("a picture on the page");
let img = render_page(&d, &l.pages[0], 1.0, &opts);
let px = img.pixel((rect.x + rect.w * 0.55) as u32, (rect.y + rect.h * 0.5) as u32);
assert!(is_red(px), "{ext}: {px:?}");
}
}
#[test]
fn cosmetic_metafile_pen_is_one_device_pixel_wide() {
// MOVETO (0, 50), LINETO (100, 50) with the default cosmetic black pen: a hairline across the middle.
@@ -1168,6 +1593,29 @@ fn metafile_text_records_are_painted() {
assert!(dark > 50, "the text is painted inside the picture: {dark} dark pixels");
}
/// With the opaque background mode (the default) and a red background color (SETBKCOLOR), a text
/// run's character cells are filled red behind the black text.
#[test]
fn metafile_text_fills_its_opaque_background() {
let mut font = emf_rec(82, &le32(&[1, -20, 0, 0, 0, 400, 0, 0]));
let mut name: Vec<u8> = "Arial".encode_utf16().flat_map(|u| u.to_le_bytes()).collect();
name.resize(64, 0);
font.extend(name);
font[4..8].copy_from_slice(&104u32.to_le_bytes());
let mut text = emf_rec(84, &le32(&[0, 0, 100, 100, 1, 0, 0, 5, 40, 4, 76, 0, 0, 0, 0, 0, 0]));
text.extend("WWWW".encode_utf16().flat_map(|u| u.to_le_bytes()));
text[4..8].copy_from_slice(&84u32.to_le_bytes());
let mut emf = red_right_half_emf()[..88].to_vec();
let bk = emf_rec(25, &le32(&[0x0000_00FF]));
emf.extend([bk, font, emf_rec(37, &le32(&[1])), emf_rec(24, &le32(&[0])), text, emf_rec(14, &[0; 12])].concat());
let scale = 2.0;
let (img, rect) = emf_on_page(emf, [0.0; 4], scale);
let (x0, y0) = ((rect.x * scale) as u32, (rect.y * scale) as u32);
let (x1, y1) = (((rect.x + rect.w) * scale) as u32, ((rect.y + rect.h) * scale) as u32);
let red = (y0..y1).flat_map(|y| (x0..x1).map(move |x| (x, y))).filter(|&(x, y)| is_red(img.pixel(x, y))).count();
assert!(red > 50, "the character cells are filled red: {red} red pixels");
}
/// An EMF text run whose anchor sits inside the picture but whose font is billions of units
/// tall: each glyph's curves would span billions of device pixels, which the rasteriser
/// subdivides for ever. Glyphs that big (or off the raster) are left out; the page renders.
@@ -1490,6 +1938,31 @@ fn paths_far_past_every_canvas_are_not_flattened() {
assert!(!path_extent_ok(Affine::IDENTITY, &line(f64::NAN)));
}
#[test]
fn rules_of_one_width_cover_the_same_whole_pixels_at_every_zoom() {
for zoom in [0.5, 0.6, 0.75] {
for ppp in [1.0, 1.25] {
let k = zoom * ppp * 96.0 / 72.0;
let view = Affine::new([k, 0.0, 0.0, k, 37.3, 12.9]);
let mut widths = Vec::new();
for i in 0..20 {
let pos = 10.0 + f64::from(i) * 17.37;
let (w_h, (_, oy)) = snap_rule(view, (5.0, pos, 400.0, pos), 0.5).unwrap();
let (w_v, (ox, _)) = snap_rule(view, (pos, 5.0, pos, 400.0), 0.5).unwrap();
widths.push(w_h);
widths.push(w_v);
for (w, centre) in [(w_h, (pos + oy) * k + 12.9), (w_v, (pos + ox) * k + 37.3)] {
let edge = centre - w / 2.0;
assert!((edge - edge.round()).abs() < 1e-9, "zoom {zoom} ppp {ppp}: edge {edge} is off the pixel grid");
}
}
assert!(widths.iter().all(|w| *w == widths[0] && *w >= 1.0 && w.fract() == 0.0), "zoom {zoom} ppp {ppp}: {widths:?}");
}
}
assert!(snap_rule(Affine::rotate(0.3), (0.0, 0.0, 9.0, 0.0), 0.5).is_none());
assert!(snap_rule(Affine::scale(2.0), (0.0, 0.0, 9.0, 4.0), 0.5).is_none());
}
/// The same three pictures that don't draw as in the PDF test: each stays a grey box, and the page's
/// pixels are what they were before strict export existed (#6005).
#[test]
@@ -1528,3 +2001,102 @@ fn undecodable_pictures_keep_their_grey_box_pixels() {
let h = img.pixels.iter().fold(0xcbf29ce484222325u64, |h, b| (h ^ u64::from(*b)).wrapping_mul(0x100000001b3));
assert_eq!(h, 0x79f9f1d3602a9925, "{h:#x}");
}
/// The cache charge for a metafile's geometry covers what its items keep after their pixels move
/// out: a pattern's path and tile, and the clip rectangles and clip paths of every kind of item.
/// A tile or clip path shared by several items is charged once.
#[test]
fn geometry_bytes_counts_pattern_tiles_and_clips_once() {
use craft_metafile::{ClipPath, Tile};
let segs = |n: usize| vec![Seg::Line(0.0, 0.0); n];
let pic = |items: Vec<Item>| Picture { width: 10.0, height: 10.0, items, skipped_records: 0 };
let base = crate::media::geometry_bytes(&pic(vec![]));
let tile = Arc::new(Tile { width: 1000, height: 1000, rgba: vec![0; 4_000_000], cell: [1.0, 1.0], origin: [0.0, 0.0] });
let pattern = |tile: &Arc<Tile>| Item::Pattern { segs: segs(1000), even_odd: false, tile: tile.clone(), region: None, clips: vec![] };
let one = crate::media::geometry_bytes(&pic(vec![pattern(&tile)]));
assert!(one - base >= 4_000_000 + 1000 * std::mem::size_of::<Seg>(), "{} bytes", one - base);
// Two fills of the same brush keep one tile.
let two = crate::media::geometry_bytes(&pic(vec![pattern(&tile), pattern(&tile)]));
assert!(two - one < 1_000_000, "the shared tile is charged once: {} bytes more", two - one);
// A clip path shared by two bitmaps is charged once; a clip region is charged per item.
let clip = Arc::new(ClipPath { segs: segs(100_000), even_odd: false });
let bitmap = |clips: Vec<Arc<ClipPath>>, region: Option<Vec<[f32; 4]>>| Item::Bitmap {
rect: [0.0; 4],
transform: [1.0, 0.0, 0.0, 1.0, 0.0, 0.0],
width: 0,
height: 0,
rgba: vec![],
region,
clips,
};
let plain = crate::media::geometry_bytes(&pic(vec![bitmap(vec![], None)]));
let clipped = crate::media::geometry_bytes(&pic(vec![bitmap(vec![clip.clone()], None), bitmap(vec![clip.clone()], None)]));
let clip_bytes = 100_000 * std::mem::size_of::<Seg>();
assert!(clipped - 2 * plain >= clip_bytes && clipped - 2 * plain < 2 * clip_bytes, "{} bytes", clipped - 2 * plain);
let region = crate::media::geometry_bytes(&pic(vec![bitmap(vec![], Some(vec![[0.0; 4]; 1000]))]));
assert!(region - plain >= 1000 * 16, "{} bytes", region - plain);
}
/// The parser collects segments and dashes without shrinking them, so the charge follows the
/// capacity a vector keeps, not only its length.
#[test]
fn geometry_bytes_charges_the_capacity_of_segment_and_dash_vectors() {
use craft_metafile::LineStyle;
let pic = |items: Vec<Item>| Picture { width: 10.0, height: 10.0, items, skipped_records: 0 };
let path = |segs: Vec<Seg>, dash: Vec<f32>| Item::Path {
segs,
fill: None,
stroke: Some(([0, 0, 0, 255], 1.0)),
line: LineStyle { dash, ..LineStyle::default() },
even_odd: false,
region: None,
clips: vec![],
};
let tight = crate::media::geometry_bytes(&pic(vec![path(vec![Seg::Line(0.0, 0.0); 2], vec![1.0; 2])]));
let mut segs = Vec::with_capacity(10_000);
segs.extend([Seg::Line(0.0, 0.0); 2]);
let mut dash = Vec::with_capacity(1_000);
dash.extend([1.0f32; 2]);
let slack = crate::media::geometry_bytes(&pic(vec![path(segs, dash)]));
assert!(slack - tight >= 9_000 * std::mem::size_of::<Seg>(), "{} bytes more", slack - tight);
}
/// A stroked path keeps its dash array on the heap, and a text item keeps its boxed record and font
/// name; the cache charge counts both, so many dashed paths or text records are not under-counted.
#[test]
fn geometry_bytes_counts_dash_arrays_and_text_records() {
use craft_metafile::{Font, HAlign, LineStyle, Text, VAlign};
let pic = |items: Vec<Item>| Picture { width: 10.0, height: 10.0, items, skipped_records: 0 };
let path = |dash: usize| Item::Path {
segs: vec![Seg::Line(0.0, 0.0); 2],
fill: None,
stroke: Some(([0, 0, 0, 255], 1.0)),
line: LineStyle { dash: vec![1.0; dash], ..LineStyle::default() },
even_odd: false,
region: None,
clips: vec![],
};
let solid = crate::media::geometry_bytes(&pic(vec![path(0)]));
let dashed = crate::media::geometry_bytes(&pic(vec![path(16)]));
assert_eq!(dashed - solid, 16 * std::mem::size_of::<f32>());
let text = |family: &str| {
Item::Text(Box::new(Text {
transform: [1.0, 0.0, 0.0, 1.0, 0.0, 0.0],
text: "ab".into(),
dx: vec![1.0; 2],
font: Font { family: family.into(), ..Font::default() },
color: [0, 0, 0, 255],
background: None,
h_align: HAlign::default(),
v_align: VAlign::default(),
clip: None,
region: None,
clips: vec![],
}))
};
let bare = crate::media::geometry_bytes(&pic(vec![text("")]));
let named = crate::media::geometry_bytes(&pic(vec![text("Some Long Face Name")]));
assert_eq!(named - bare, "Some Long Face Name".len());
let empty = crate::media::geometry_bytes(&pic(vec![]));
assert!(bare - empty >= std::mem::size_of::<Text>(), "the boxed Text struct is charged: {} bytes", bare - empty);
}
+82 -7
View File
@@ -90,7 +90,8 @@ pub fn alt_text(app: &mut WordApp, ui: &mut Ui) {
let decorative = obj.is_decorative();
ui.label(egui::RichText::new(tl!("Describe what this object shows, for people who can't see it.")).weak());
ui.add_space(4.0);
if let Some(text) = draft_box(ui, ("alt_obj", &pos), obj.alt_text(), !decorative, true)
let label = ui.label(tl!("Description:"));
if let Some(text) = draft_box(ui, ("alt_obj", &pos), label.id, obj.alt_text(), !decorative, true)
&& still_selected(app, &pos)
{
let _ = app.run("object.altText", json!({"text": text}));
@@ -111,13 +112,13 @@ pub fn alt_text(app: &mut WordApp, ui: &mut Ui) {
if let Some((tp, caption, description)) = table {
ui.label(egui::RichText::new(tl!("Describe what this table shows, for people who can't see it.")).weak());
ui.add_space(4.0);
ui.label(tl!("Title:"));
if let Some(t) = draft_box(ui, ("alt_table_title", &tp), caption.as_deref().unwrap_or(""), true, false) {
let label = ui.label(tl!("Title:"));
if let Some(t) = draft_box(ui, ("alt_table_title", &tp), label.id, caption.as_deref().unwrap_or(""), true, false) {
let _ = app.run("table.altText", json!({"title": t}));
}
ui.add_space(4.0);
ui.label(tl!("Description:"));
if let Some(t) = draft_box(ui, ("alt_table_text", &tp), description.as_deref().unwrap_or(""), true, true) {
let label = ui.label(tl!("Description:"));
if let Some(t) = draft_box(ui, ("alt_table_text", &tp), label.id, description.as_deref().unwrap_or(""), true, true) {
let _ = app.run("table.altText", json!({"text": t}));
}
return;
@@ -131,11 +132,18 @@ fn still_selected(app: &WordApp, pos: &Pos) -> bool {
/// A text box editing `current`; the draft lives in egui memory while it has focus (frame-local
/// buffers lose keystrokes). Returns the new text when editing ends with a change.
fn draft_box(ui: &mut Ui, key: impl std::hash::Hash + std::fmt::Debug, current: &str, enabled: bool, multiline: bool) -> Option<String> {
fn draft_box(
ui: &mut Ui,
key: impl std::hash::Hash + std::fmt::Debug,
label: egui::Id,
current: &str,
enabled: bool,
multiline: bool,
) -> Option<String> {
let key = egui::Id::unique(key);
let mut text = ui.data(|d| d.get_temp::<String>(key)).unwrap_or_else(|| current.to_string());
let edit = if multiline { egui::TextEdit::multiline(&mut text).desired_rows(5) } else { egui::TextEdit::singleline(&mut text) };
let r = ui.add_enabled(enabled, edit.desired_width(f32::INFINITY));
let r = ui.add_enabled(enabled, edit.desired_width(f32::INFINITY)).labelled_by(label);
if r.changed() {
ui.data_mut(|d| d.insert_temp(key, text.clone()));
}
@@ -148,3 +156,70 @@ fn draft_box(ui: &mut Ui, key: impl std::hash::Hash + std::fmt::Debug, current:
}
None
}
#[cfg(test)]
mod tests {
use super::*;
use egui::accesskit::Role;
use egui_kittest::kittest::{NodeT, Queryable};
fn harness(app: WordApp) -> egui_kittest::Harness<'static, WordApp> {
let mut fonts = false;
let mut h = egui_kittest::Harness::builder().with_size(egui::vec2(400.0, 400.0)).build_ui_state(
move |ui, app: &mut WordApp| {
if fonts {
alt_text(app, ui);
} else {
crate::theme::install_fonts_for(ui.ctx(), false);
fonts = true;
}
},
app,
);
h.run_steps(4);
h
}
#[test]
fn object_description_is_named_commits_and_disables_when_decorative() {
let mut app = WordApp::new(wordcraft_engine::Session::new(wordcraft_doc::Document::new()), crate::Services::default());
app.run("insert.shape", json!({"kind": "ellipse"})).unwrap();
let mut h = harness(app);
h.get_by_role_and_label(Role::MultilineTextInput, "Description:").click();
h.run_steps(2);
h.get_by_role_and_label(Role::MultilineTextInput, "Description:").type_text("A green circle");
h.run_steps(2);
assert_eq!(h.get_by_role_and_label(Role::MultilineTextInput, "Description:").value().as_deref(), Some("A green circle"));
h.get_by_role_and_label(Role::CheckBox, "Mark as decorative").click();
h.run_steps(2);
let (_, object) = wordcraft_engine::cmd::objects::selected(&h.state().session).unwrap();
assert_eq!(object.alt_text(), "A green circle");
assert!(object.is_decorative());
assert!(h.get_by_role_and_label(Role::MultilineTextInput, "Description:").accesskit_node().is_disabled());
}
#[test]
fn table_title_and_description_are_named_and_commit_independently() {
let mut app = WordApp::new(wordcraft_engine::Session::new(wordcraft_doc::Document::new()), crate::Services::default());
app.run("insert.table", json!({"rows": 1, "cols": 1})).unwrap();
let mut h = harness(app);
h.get_by_role_and_label(Role::TextInput, "Title:").click();
h.run_steps(2);
h.get_by_role_and_label(Role::TextInput, "Title:").type_text("Prices");
h.run_steps(2);
assert_eq!(h.get_by_role_and_label(Role::TextInput, "Title:").value().as_deref(), Some("Prices"));
h.get_by_role_and_label(Role::MultilineTextInput, "Description:").click();
h.run_steps(2);
h.get_by_role_and_label(Role::MultilineTextInput, "Description:").type_text("Prices by year");
h.run_steps(2);
assert_eq!(h.get_by_role_and_label(Role::MultilineTextInput, "Description:").value().as_deref(), Some("Prices by year"));
h.get_by_role_and_label(Role::TextInput, "Title:").click();
h.run_steps(2);
let app = h.state();
let focus = &app.session.sel.focus;
let (path, _, _) = focus.path.cell().unwrap();
let table = app.session.doc.table(focus.story, &path).unwrap();
assert_eq!(table.props.caption.as_deref(), Some("Prices"));
assert_eq!(table.props.description.as_deref(), Some("Prices by year"));
}
}
+36 -1
View File
@@ -58,7 +58,9 @@ impl WordApp {
seen_full_screen,
escape_free,
status_counts,
print_memo,
missing_fonts,
export_error,
last_autosave,
equation_prev_tab,
smart_art_item,
@@ -104,6 +106,7 @@ impl WordApp {
clipboard_published: false,
printing: Default::default(),
print_feedback_seen: None,
print_gen: 0,
integrated_titlebar: false,
mac_titlebar: chrome::MacTitleBar::default(),
updates_rt: updates_ui::Runtime::default(),
@@ -131,6 +134,8 @@ impl WordApp {
fonts_frames: 0,
applied_theme: None,
native_scale: 1.0,
auto_scale_limit: f32::INFINITY,
monitor_zoom: 1.0,
legacy_interface_size: None,
// Inert until the app binary calls `watch_desktop_theme`.
desktop_theme: desktop_theme::DesktopTheme::default(),
@@ -176,7 +181,9 @@ impl WordApp {
seen_full_screen,
escape_free,
status_counts,
print_memo,
missing_fonts,
export_error,
last_autosave,
equation_prev_tab,
smart_art_item,
@@ -301,7 +308,25 @@ impl WordApp {
{
self.ui.interface_size = theme::migrate_legacy_interface_size(old, native);
}
let zoom = self.ui.interface_size.zoom_factor(self.native_scale);
// Auto never draws larger than the screen holds (#4030): a system that guesses 3× on a
// 1366x768 panel would put the window's controls off screen. The zoom is shared by every
// window, so the smallest screen of all the open windows sets the cap. A viewport's
// `monitor_size` is in points of the zoom in force before a pending change applied, so
// its pixels are that size times `monitor_zoom` and the window's own native scale; each window's allowed zoom is its own, the smallest is shared.
let monitors: Vec<_> = self
.windows
.viewport_ids()
.into_iter()
.filter_map(|v| {
ctx.input_for(v, |i| {
let info = i.viewport();
Some(((info.monitor_size?.x, info.monitor_size?.y), info.native_pixels_per_point?))
})
})
.collect();
self.auto_scale_limit = theme::auto_scale_limit_over(monitors, self.monitor_zoom, self.native_scale);
self.monitor_zoom = ctx.zoom_factor();
let zoom = self.ui.interface_size.zoom_factor_within(self.native_scale, self.auto_scale_limit);
if ctx.zoom_factor() != zoom {
ctx.set_zoom_factor(zoom);
}
@@ -410,6 +435,15 @@ impl WordApp {
/// Pane's Tab keys and dropped files are read in the first UI pass
/// ([`WordApp::handle_ui_input_events`]).
pub(crate) fn window_input(&mut self, ctx: &egui::Context) {
// The way back when a large interface size has pushed File › Options off screen (#4030).
// A modal dialog keeps the keys (Customize Keyboard records them), and a command the user
// bound to the chord runs instead.
if !self.modal_open()
&& self.session.keymap.resolve(&self.session.registry, "Mod+Shift+0").is_none()
&& ctx.input_mut(super::consume_reset_interface_size)
{
let _ = self.run("ui.interfaceSize", serde_json::json!({"value": "auto"}));
}
if self.windows.native() && ctx.input_mut(|i| i.consume_shortcut(&QUIT)) {
self.quit();
}
@@ -468,6 +502,7 @@ impl WordApp {
if !self.ui.backstage {
backstage::forget_open_error(&ctx);
backstage::forget_save_as_error(&ctx);
self.export_error.clear();
}
self.paint_window(ui, &ctx, t);
if !moved(self) {
+33 -4
View File
@@ -145,7 +145,9 @@ impl WordApp {
// Web: saving and exporting become downloads.
if self.services.download.is_some() && matches!(id, "file.save" | "file.saveAs" | "file.exportPdf" | "file.exportPng") {
let name = params.get("path").and_then(Value::as_str).map(str::to_string).unwrap_or_else(|| self.web_save_name(id));
let name = if id == "file.exportPdf" && !name.ends_with(".pdf") { format!("{name}.pdf") } else { name };
// Inspect only the suffix bytes: no full-name allocation or UTF-8 slicing.
let has_pdf_suffix = name.as_bytes().last_chunk::<4>().is_some_and(|suffix| suffix.eq_ignore_ascii_case(b".pdf"));
let name = if id == "file.exportPdf" && !has_pdf_suffix { format!("{name}.pdf") } else { name };
// A save with a password encrypts this and later saves (`file.save`'s `password`).
if matches!(id, "file.save" | "file.saveAs")
&& let Some(pw) = params.get("password").filter(|v| !v.is_null())
@@ -155,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();
@@ -163,7 +173,19 @@ impl WordApp {
let password =
if matches!(id, "file.save" | "file.saveAs") { self.session.password.as_ref().map(wordcraft_engine::Password::as_str) } else { None };
let opts = wordcraft_engine::cmd::file::export_options(&self.session, &params);
let bytes = wordcraft_engine::io::save_bytes_with(&name, &self.session.doc, password, &opts)?;
let bytes = match wordcraft_engine::io::save_bytes_with(&name, &self.session.doc, password, &opts) {
Ok(bytes) => bytes,
Err(error) => {
(
self.session.doc.settings.zoom,
self.session.doc.core.last_modified_by,
self.session.doc.core.created,
self.session.doc.core.modified,
self.session.doc.core.revision,
) = before_stamp;
return Err(error);
}
};
// A ticket left over from an earlier call isn't this save's.
let saves = self.services.async_saves.clone();
if let Some(saves) = &saves {
@@ -183,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());
@@ -667,7 +696,7 @@ impl WordApp {
}
}
let size = self.ui.interface_size;
json!({"auto": size.is_auto(), "percent": size.drawn_percent(self.native_scale)})
json!({"auto": size.is_auto(), "percent": size.drawn_percent_within(self.native_scale, self.auto_scale_limit)})
}
"ui.animations" => {
// `system` (follow the system's animation setting), `on` or `off`; no value reads
@@ -775,7 +804,7 @@ impl WordApp {
json!({"dir": dir})
}
// The built-in file browser (#576), for when the system's file dialog doesn't show up
// (desktop only): `purpose` is document (default), picture, recipients or save. A system
// (desktop only): `purpose` is document (default), picture, recipients, save or export. A system
// dialog still waiting for an answer is given up as cancelled.
#[cfg(not(target_arch = "wasm32"))]
"ui.fileBrowser" => {
+7
View File
@@ -320,6 +320,8 @@ impl WordApp {
return;
}
self.print_feedback_seen = self.printing.message.clone();
// A new message: what any window said before no longer stands for it.
self.print_gen = self.print_gen.wrapping_add(1);
let Some(message @ (printing::Feedback::Submitted(_) | printing::Feedback::Failed(_) | printing::Feedback::WorkerStopped)) =
self.printing.message.clone()
else {
@@ -334,6 +336,11 @@ impl WordApp {
self.ui.backstage = false;
self.canvas.want_focus = true;
}
// Said only where the status bar is drawn: not under File's other pages, and a failure on
// the Print page is the page's to show.
if !self.ui.backstage {
self.print_memo.said = Some(self.print_gen);
}
}
/// Files dropped on the native window. Raw input is taken only in the first UI pass: a
+72 -5
View File
@@ -635,17 +635,27 @@ fn open_list(app: &mut WordApp, ui: &mut Ui) {
let shown = app.ui.recent.iter().take(app.ui.recent_shown()).cloned().collect::<Vec<_>>();
let file_name = |p: &str| std::path::Path::new(p).file_name().map(|n| n.to_string_lossy().to_string()).unwrap_or(p.to_string());
let names = shown.iter().map(|p| file_name(p)).collect::<Vec<_>>();
let (mut focused, mut hovered) = (None, None);
use egui::epaint::text::TextDirection;
for (p, name) in shown.iter().zip(&names) {
// #2716: each row carries its own Remove, as Word's context menu does. The × is a button
// of its own at the trailing end, so it never opens the document; clicking the rest of the
// row opens it as before.
let (r, resp) = ui.allocate_exact_size(vec2(ui.available_width().min(700.0) - REMOVE_W, 40.0), Sense::click());
// The row shows a name and a path that may not fit: the path in full is its tooltip.
let resp = resp.on_hover_text(crate::i18n::isolate_path(p));
// Two documents with the same file name are told apart by their path, as on screen.
let spoken = if names.iter().filter(|n| *n == name).count() > 1 { format!("{name}, {p}") } else { name.clone() };
let twin = names.iter().filter(|n| *n == name).count() > 1;
let spoken = if twin { format!("{name}, {p}") } else { name.clone() };
resp.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, ui.is_enabled(), &spoken));
// Only one row shows its path as a tooltip, so every row gives a screen reader the path
// itself, unless its label already says it.
if !twin {
ui.ctx().accesskit_node_builder(resp.id, |node| node.set_description(crate::i18n::isolate_path(p)));
}
if resp.has_focus() {
focused = Some((resp.clone(), p));
}
if resp.hovered() {
hovered = Some((resp.clone(), p));
ui.painter().rect_filled(r, 4.0, t.hover);
}
// Names and paths are set apart (a right-to-left line would scramble their marks and
@@ -659,8 +669,25 @@ fn open_list(app: &mut WordApp, ui: &mut Ui) {
t.accent,
);
let side = crate::rtl::lead_center(rtl);
ui.painter().text(pos2(crate::rtl::lead_x(rtl, r, 40.0), r.min.y + 13.0), side, crate::i18n::isolate(name), medium(13.0), t.text);
ui.painter().text(pos2(crate::rtl::lead_x(rtl, r, 40.0), r.min.y + 29.0), side, crate::i18n::isolate_path(p), regular(11.0), t.text_dim);
// A wide row on Home can push the row past the visible area at small window sizes, so the
// text stops at the visible edge and its ellipsis stays in view. Only its far end does: it
// starts at the row's start, in view or not.
let clip = ui.clip_rect();
let room = if rtl { r.max.x - r.min.x.max(clip.min.x) } else { r.max.x.min(clip.max.x) - r.min.x };
let text_w = (room - 48.0).max(0.0);
let fit = |text: String, direction: TextDirection, font: egui::FontId, color: egui::Color32, y: f32| {
let mut job = egui::text::LayoutJob::simple_singleline(text, font, color);
job.direction = direction;
job.wrap = egui::text::TextWrapping::truncate_at_width(text_w);
let g = ui.painter().layout_job(job);
let at = side.anchor_size(pos2(crate::rtl::lead_x(rtl, r, 40.0), y), g.size()).min;
ui.painter().galley(at, g, color);
};
// An isolate hides a right-to-left name's direction from its line, which would put the
// ellipsis beside the name's first letters.
let direction = if wordcraft_doc::bidi::first_strong_is_rtl(name) { TextDirection::RightToLeft } else { TextDirection::Auto };
fit(crate::i18n::isolate(name), direction, medium(13.0), t.text, r.min.y + 13.0);
fit(crate::i18n::isolate_path(p), TextDirection::Auto, regular(11.0), t.text_dim, r.min.y + 29.0);
let xr = Rect::from_min_max(pos2(r.max.x + 2.0, r.min.y + 4.0), pos2(r.max.x + REMOVE_W, r.max.y - 4.0));
// Right-to-left: the × sits on the left, past the row's trailing edge.
let xr = if rtl { xr.translate(vec2(-(r.width() + REMOVE_W + 2.0), 0.0)) } else { xr };
@@ -691,6 +718,41 @@ fn open_list(app: &mut WordApp, ui: &mut Ui) {
{
let _ = app.run("ui.recentClear", json!({}));
}
// A row shows a name and a path that may not fit: the path in full is its tooltip, for the
// hovered row or, after a key press, the focused one. egui shows one tooltip per layer, so
// only one of them is drawn, and the focus tooltip lets the pointer through to the rows below.
let keyboard = recent_keyboard_last(ui);
match (focused, hovered) {
(Some((resp, p)), hovered) if keyboard || hovered.is_none() => {
egui::Tooltip::for_widget(&resp).show(|ui| ui.label(crate::i18n::isolate_path(p)));
}
(_, Some((resp, p))) => {
resp.on_hover_text(crate::i18n::isolate_path(p));
}
_ => {}
}
}
/// Was a key pressed more recently than the pointer moved? Kept across passes, so a focused
/// Recent row keeps its tooltip while the pointer rests on another row.
fn recent_keyboard_last(ui: &Ui) -> bool {
let id = egui::Id::unique("backstage_recent_keyboard_last");
let now = ui.input(|i| {
if i.pointer.delta() != egui::Vec2::ZERO {
Some(false)
} else if i.events.iter().any(|e| matches!(e, egui::Event::Key { pressed: true, .. })) {
Some(true)
} else {
None
}
});
match now {
Some(keyboard) => {
ui.ctx().data_mut(|d| d.insert_temp(id, keyboard));
keyboard
}
None => ui.ctx().data(|d| d.get_temp(id)).unwrap_or(false),
}
}
/// Stable storage id for the Recent list's open error.
@@ -759,6 +821,11 @@ fn save_as_page(app: &mut WordApp, ui: &mut Ui) {
if ui.button(egui::RichText::new(tl!("Browse…")).font(medium(14.0))).clicked() {
app.save_as_dialog();
}
// Linux and the BSDs (#3535): WordCraft's own browser when the system dialog doesn't appear.
#[cfg(all(unix, not(target_os = "macos"), not(target_arch = "wasm32")))]
if ui.button(egui::RichText::new(tl!("Browse in WordCraft…")).font(medium(14.0))).clicked() {
let _ = app.run("ui.fileBrowser", json!({"purpose": "save"}));
}
// A Word template in the user templates folder, which File › New lists under Personal (#2852).
ui.add_space(8.0);
if ui
+457
View File
@@ -75,6 +75,289 @@ fn opening_a_missing_recent_file_keeps_file_open_with_the_error() {
assert!(app.ui.backstage, "File stays open");
}
/// Opens File > Home in a window of `size` with one long Recent entry; returns its name and path.
fn long_recent_harness(size: egui::Vec2) -> (egui_kittest::Harness<'static, WordApp>, String, String) {
let name = format!("{}.docx", "AVeryLongDocumentName".repeat(8));
let path = format!("C:/Users/Someone/{}/{name}", "LongFolderName".repeat(20));
(recent_harness(std::slice::from_ref(&path), size), name, path)
}
/// Opens File > Home in a window of `size` with `recent` as the Recent list.
fn recent_harness(recent: &[String], size: egui::Vec2) -> egui_kittest::Harness<'static, WordApp> {
let mut a = WordApp::new(wordcraft_engine::Session::new(wordcraft_doc::Document::new()), Services::default());
a.ui.recent = recent.to_vec();
a.run("ui.backstage", json!({"value": true, "page": "home"})).unwrap();
let mut h = egui_kittest::Harness::builder().with_size(size).build_ui_state(
|ui, app: &mut WordApp| {
let ctx = ui.ctx().clone();
app.logic(&ctx);
app.ui(ui);
},
a,
);
h.run_steps(4);
h
}
/// Collects every text shape, including those nested in shape lists.
fn collect_text<'a>(s: &'a egui::Shape, out: &mut Vec<&'a egui::epaint::TextShape>) {
match s {
egui::Shape::Text(ts) => out.push(ts),
egui::Shape::Vec(v) => {
for child in v {
collect_text(child, out);
}
}
_ => {}
}
}
/// Returns the painted bounds and clip rect of the Recent entry's name and path texts, and
/// whether each ends with an ellipsis.
fn recent_text_bounds(h: &egui_kittest::Harness<'_, WordApp>) -> Vec<(String, egui::Rect, egui::Rect, bool)> {
let mut found = Vec::new();
for cs in &h.output().shapes {
let mut texts = Vec::new();
collect_text(&cs.shape, &mut texts);
for ts in texts {
let text = ts.galley.text();
if text.contains("C:/Users/Someone") || text.contains("AVeryLongDocumentName") {
let ellipsis = ts.galley.rows.first().and_then(|row| row.glyphs.last()).is_some_and(|g| g.chr == '\u{2026}');
found.push((text.to_owned(), ts.visual_bounding_rect(), cs.clip_rect, ellipsis));
}
}
}
found
}
/// #5212: long names and paths in File > Home > Recent shorten to fit their row and show on hover.
#[test]
fn recent_shortens_a_long_name_and_path_to_its_row() {
let (mut h, name, path) = long_recent_harness(egui::vec2(1440.0, 900.0));
let row = h.get_by_label(&name).rect();
let texts = recent_text_bounds(&h);
assert_eq!(texts.len(), 2, "both file name and path shapes must be found");
for (text, bounds, _, ellipsis) in &texts {
assert!(*ellipsis, "text '{text}' must end with an ellipsis");
assert!(bounds.max.x <= row.max.x + 0.5, "text '{text}' bounds.max.x ({}) > row.max.x + 0.5 ({})", bounds.max.x, row.max.x + 0.5);
}
h.event(egui::Event::PointerMoved(row.center()));
h.run_steps(4);
h.get_by_label(&path);
}
/// #5212: at the smallest window width the shortened texts end inside the visible area, so the
/// ellipsis is not cut off.
#[test]
fn recent_texts_end_inside_the_visible_area_at_the_smallest_window() {
let (h, _, _) = long_recent_harness(egui::vec2(760.0, 480.0));
let texts = recent_text_bounds(&h);
assert_eq!(texts.len(), 2, "both file name and path shapes must be found");
for (text, bounds, clip, ellipsis) in &texts {
assert!(*ellipsis, "text '{text}' must end with an ellipsis");
assert!(bounds.max.x <= clip.max.x + 0.5, "text '{text}' ends at {} past the visible edge {}", bounds.max.x, clip.max.x);
}
}
/// #5212: a Recent row focused with the keyboard shows its full path, as hovering does.
#[test]
fn recent_shows_the_full_path_when_a_row_has_keyboard_focus() {
let (mut h, name, path) = long_recent_harness(egui::vec2(1440.0, 900.0));
assert!(h.query_by_label(&path).is_none(), "the full path must not show before focus");
h.get_by_label(&name).focus();
h.run_steps(4);
h.get_by_label(&path);
}
/// #5212: the focus tooltip lets the pointer through, so the Recent row under it still gets
/// hovered, shows its own path and opens on click.
#[test]
#[cfg(not(target_arch = "wasm32"))]
fn recent_focus_tooltip_does_not_block_the_row_below() {
let dir = std::env::temp_dir().join(format!("wordcraft-5212-{}", std::process::id()));
let paths = ["one.docx", "two.docx"].map(|n| dir.join(n).to_string_lossy().to_string());
let mut h = recent_harness(&paths, egui::vec2(1440.0, 900.0));
h.get_by_label("one.docx").focus();
h.run_steps(4);
let tip = h.get_by_label(&paths[0]).rect();
let below = tip.intersect(h.get_by_label("two.docx").rect());
assert!(below.is_positive(), "the focus tooltip must cover part of the next row: tip={tip:?}");
h.event(egui::Event::PointerMoved(below.center()));
h.run_steps(4);
h.get_by_label(&paths[1]);
for pressed in [true, false] {
h.event(egui::Event::PointerButton { pos: below.center(), button: egui::PointerButton::Primary, pressed, modifiers: egui::Modifiers::NONE });
h.run_steps(1);
}
h.run_steps(3);
let error = h.ctx.data(|d| d.get_temp::<String>(super::open_error_id())).unwrap_or_default();
assert!(error.contains("two.docx"), "the click must reach two.docx and try to open it, got error '{error}'");
}
/// #5212: every Recent row gives a screen reader its full path, not only the hovered or
/// focused row that shows the path as a tooltip.
#[test]
fn recent_rows_describe_their_full_path_without_hover_or_focus() {
use egui_kittest::kittest::NodeT;
let dir = std::env::temp_dir().join("wordcraft-5212-describe");
let paths = ["one.docx", "two.docx"].map(|n| dir.join(n).to_string_lossy().to_string());
let mut h = recent_harness(&paths, egui::vec2(1440.0, 900.0));
let one = h.get_by_label("one.docx").rect();
h.event(egui::Event::PointerMoved(one.center()));
h.run_steps(4);
for (name, path) in ["one.docx", "two.docx"].iter().zip(&paths) {
let described = h.get_by_label(name).accesskit_node().description();
assert_eq!(described.as_deref(), Some(crate::i18n::isolate_path(path).as_str()), "{name} must describe its full path");
}
}
/// A right-to-left language for the Recent tests. `rtl` goes by its code, so it needs no Arabic font.
fn recent_right_to_left() -> crate::i18n::Lang {
crate::i18n::fixture_lang("ar", "\tHome\tHome\n")
}
/// The Recent list alone with one `path`, in `lang`, in a window 1000 wide. `start` points on the
/// side its rows start from and `end` points on the other side are out of view, as on a page
/// scrolled sideways or wider than the window.
fn recent_list_cut(path: &str, lang: crate::i18n::Lang, start: f32, end: f32) -> egui_kittest::Harness<'static, WordApp> {
let mut a = WordApp::new(wordcraft_engine::Session::new(wordcraft_doc::Document::new()), Services::default());
a.ui.recent = vec![path.to_string()];
let mut h = egui_kittest::Harness::builder().with_size(egui::vec2(1000.0, 500.0)).build_ui_state(
move |ui, app: &mut WordApp| {
let ctx = ui.ctx().clone();
app.logic(&ctx);
crate::i18n::set_current(lang);
crate::rtl::sync(&ctx);
let mut clip = ui.clip_rect();
let (left, right) = if crate::rtl::on() { (end, start) } else { (start, end) };
clip.min.x += left;
clip.max.x -= right;
ui.set_clip_rect(clip);
super::open_list(app, ui);
},
a,
);
h.run_steps(4);
h
}
/// #5212: text runs from its row's start, so a row whose start is out of view has as much room
/// for its text as before. Only the far end stops at the visible edge.
#[test]
fn recent_text_keeps_its_room_when_its_row_starts_out_of_view() {
let name = format!("{}.docx", "AVeryLongDocumentName".repeat(8));
let path = format!("C:/Users/Someone/{name}");
for lang in [crate::i18n::Lang::EN, recent_right_to_left()] {
let widths = |cut| recent_text_bounds(&recent_list_cut(&path, lang, cut, 0.0)).iter().map(|t| t.1.width().round()).collect::<Vec<_>>();
let whole = widths(0.0);
assert_eq!(whole.len(), 2, "both lines must be painted: {whole:?}");
assert_eq!(widths(500.0), whole, "the cut must not take room from the text");
}
crate::i18n::set_current(crate::i18n::Lang::EN);
}
/// #5212: a row running past the visible area stops its text there, in either direction, with
/// its ellipsis in view.
#[test]
fn recent_text_stops_at_the_visible_edge_in_either_direction() {
let name = format!("{}.docx", "AVeryLongDocumentName".repeat(8));
let path = format!("C:/Users/Someone/{name}");
for lang in [crate::i18n::Lang::EN, recent_right_to_left()] {
let texts = recent_text_bounds(&recent_list_cut(&path, lang, 0.0, 400.0));
assert_eq!(texts.len(), 2, "both lines must be painted");
for (text, bounds, clip, ellipsis) in &texts {
assert!(
bounds.left() >= clip.left() - 0.5 && bounds.right() <= clip.right() + 0.5,
"{text} must end inside the visible area: {bounds:?} in {clip:?}"
);
assert!(ellipsis, "{text} must end in an ellipsis");
}
}
crate::i18n::set_current(crate::i18n::Lang::EN);
}
/// #5212: multibyte text is cut between its characters and stays in its row, starting at the
/// side the row starts from, in either direction.
#[test]
fn recent_shortens_multibyte_text_in_either_direction() {
let name = format!("AVeryLongDocumentName{}.docx", "\u{fc}\u{20ac}".repeat(120));
let path = format!("C:/Users/Someone/{name}");
for lang in [crate::i18n::Lang::EN, recent_right_to_left()] {
let h = recent_list_cut(&path, lang, 0.0, 0.0);
let row = h.get_by_label(&name).rect();
let texts = recent_text_bounds(&h);
assert_eq!(texts.len(), 2, "both lines must be painted");
for (text, bounds, _, ellipsis) in &texts {
let lead = if lang.rtl() { row.right() - bounds.right() } else { bounds.left() - row.left() };
assert!((lead - 40.0).abs() < 1.0, "{text} must start at its row's start: {bounds:?} in {row:?}");
assert!(bounds.left() >= row.left() - 0.5 && bounds.right() <= row.right() + 0.5, "{text} must stay in its row: {bounds:?} in {row:?}");
assert!(ellipsis, "{text} must end in an ellipsis");
}
}
crate::i18n::set_current(crate::i18n::Lang::EN);
}
/// #5212: a right-to-left name runs from the right, so it is cut on its left, and its ellipsis
/// belongs there, not beside the name's first letters.
#[test]
fn recent_puts_the_ellipsis_at_the_end_of_a_right_to_left_name() {
let name = format!("{}.docx", "\u{5d0}\u{5d1}\u{5d2} ".repeat(120));
let h = recent_list_cut(&format!("/docs/{name}"), recent_right_to_left(), 0.0, 0.0);
let output = h.output();
let mut texts = Vec::new();
for clipped in &output.shapes {
collect_text(&clipped.shape, &mut texts);
}
let shown = texts.iter().find(|t| t.galley.text().contains('\u{5d0}')).expect("the name");
let glyphs = &shown.galley.rows[0].glyphs;
let ellipsis = glyphs.iter().find(|g| g.chr == '\u{2026}').expect("an ellipsis");
let left = glyphs.iter().filter(|g| g.size().x > 0.0).map(|g| g.pos.x).fold(f32::MAX, f32::min);
assert!(ellipsis.pos.x <= left + 0.5, "the ellipsis must be the leftmost glyph: {} against {left}", ellipsis.pos.x);
crate::i18n::set_current(crate::i18n::Lang::EN);
}
/// #5212: two files with one name speak their path in the label, so it isn't read twice.
#[test]
fn recent_rows_with_one_name_speak_their_path_once() {
use egui_kittest::kittest::NodeT;
let dir = std::env::temp_dir().join("wordcraft-5212-twins");
let paths = ["one", "two"].map(|d| dir.join(d).join("same.docx").to_string_lossy().to_string());
let h = recent_harness(&paths, egui::vec2(1440.0, 900.0));
for path in &paths {
let label = format!("same.docx, {path}");
assert_eq!(h.get_by_label(&label).accesskit_node().description(), None, "{label} must not repeat its path");
}
}
/// #5212: with the pointer resting on one Recent row, Tab to the next row shows the focused
/// row's path, and moving the pointer again brings back the hovered row's path.
#[test]
fn recent_tab_shows_the_focused_path_while_the_pointer_rests_on_another_row() {
let dir = std::env::temp_dir().join("wordcraft-5212-tab");
let paths = ["one.docx", "two.docx"].map(|n| dir.join(n).to_string_lossy().to_string());
let mut h = recent_harness(&paths, egui::vec2(1440.0, 900.0));
let one = h.get_by_label("one.docx").rect();
h.event(egui::Event::PointerMoved(one.center()));
h.run_steps(4);
h.get_by_label(&paths[0]);
h.get_by_label("one.docx").focus();
h.run_steps(1);
// The first Tab goes to the row's own Remove ×, the second to the next row.
for _ in 0..2 {
h.key_press(egui::Key::Tab);
h.run_steps(4);
}
assert!(h.get_by_label("two.docx").is_focused(), "Tab must move focus to the next Recent row");
assert!(h.query_by_label(&paths[1]).is_some(), "the focused row's path must show while the pointer rests on another row");
h.event(egui::Event::PointerMoved(one.center() + egui::vec2(4.0, 0.0)));
h.run_steps(4);
assert!(h.query_by_label(&paths[0]).is_some(), "moving the pointer must bring back the hovered row's path");
}
/// #1873: the macOS back chevron sits beside the traffic lights windowed, at the plain
/// control inset in full screen.
#[test]
@@ -859,6 +1142,77 @@ fn save_as_page_shows_browse_and_no_open_list() {
assert!(h.query_by_label("Recent").is_none(), "Save As has no list that opens documents");
}
/// #3467, #3535: a system dialog that never shows up doesn't leave Save As stuck: Browse in
/// WordCraft… gives it up and saves through WordCraft's own browser.
#[test]
#[cfg(all(unix, not(target_os = "macos")))]
fn save_as_saves_in_wordcraft_when_the_system_dialog_never_shows() {
// A host that takes every request and never answers, like a portal that shows nothing.
let senders: std::rc::Rc<std::cell::RefCell<Vec<std::sync::mpsc::Sender<crate::FileDialogAnswer>>>> = Default::default();
let keep = senders.clone();
let services = Services {
file_dialog: Some(Box::new(move |_| {
let (tx, rx) = std::sync::mpsc::channel();
keep.borrow_mut().push(tx);
rx
})),
..Default::default()
};
let dir = std::env::temp_dir().join(format!("wordcraft-backstage-builtin-save-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
let mut a = WordApp::new(wordcraft_engine::Session::new(wordcraft_doc::Document::new()), services);
a.run("text.insert", json!({"text": "Saved past a silent portal"})).unwrap();
a.run("ui.backstage", json!({"value": true, "page": "saveAs"})).unwrap();
let mut h = egui_kittest::Harness::builder().with_size(egui::vec2(1440.0, 900.0)).build_ui_state(
|ui, app: &mut WordApp| {
let ctx = ui.ctx().clone();
app.logic(&ctx);
app.ui(ui);
},
a,
);
h.run_steps(4);
h.get_by_label("Browse…").click();
h.run_steps(4);
assert!(h.state().file_dialog.is_some(), "the system dialog was asked for and never answered");
h.get_by_label("Browse in WordCraft…").click();
h.run_steps(4);
let a = h.state_mut();
assert!(a.file_dialog.is_none(), "the silent system dialog is given up");
let b = a.file_browser.open.as_mut().expect("WordCraft's own browser is open");
b.navigate(dir.clone());
b.name = "kept".into();
let crate::file_browser::Step::Pick(path) = b.accept() else { panic!("picked") };
a.close_file_browser(Some(path));
let saved = dir.join("kept.docx");
assert_eq!(a.session.path.as_deref(), Some(saved.as_path()));
let back = wordcraft_engine::io::open_path(&saved).unwrap();
assert!(back.plain_text(wordcraft_doc::StoryRef::Body).contains("Saved past a silent portal"));
let _ = std::fs::remove_dir_all(&dir);
}
/// #3535: File › Export offers WordCraft's own browser as well, for its formats.
#[test]
#[cfg(all(unix, not(target_os = "macos")))]
fn export_page_offers_wordcrafts_own_browser() {
let mut a = WordApp::new(wordcraft_engine::Session::new(wordcraft_doc::Document::new()), Services::default());
a.run("ui.backstage", json!({"value": true, "page": "export"})).unwrap();
let mut h = egui_kittest::Harness::builder().with_size(egui::vec2(1440.0, 900.0)).build_ui_state(
|ui, app: &mut WordApp| {
let ctx = ui.ctx().clone();
app.logic(&ctx);
app.ui(ui);
},
a,
);
h.run_steps(4);
h.get_by_label("Browse in WordCraft…").click();
h.run_steps(4);
let b = h.state().file_browser.open.as_ref().expect("WordCraft's own browser is open");
assert!(matches!(&b.after, crate::file_dialogs::AfterPick::Export { ext } if ext == "pdf"));
}
#[test]
fn backstage_save_navigates_to_save_as_when_unnamed() {
let mut a = WordApp::new(wordcraft_engine::Session::new(wordcraft_doc::Document::new()), Services::default());
@@ -1292,3 +1646,106 @@ fn rtl_template_titles_are_right_aligned() {
wide_text_right,
);
}
/// A refused Word XML export (the typed name's `.xml` twin already exists) is said on the Export
/// page itself: Backstage hides the status bar, so the person would otherwise see nothing.
#[test]
fn export_refusal_shows_on_the_export_page() {
let dir = std::env::temp_dir().join(format!("wordcraft-backstage-export-error-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
std::fs::write(dir.join("letter.xml"), "taken").unwrap();
let bare = dir.join("letter").to_string_lossy().into_owned();
let mut a = WordApp::new(wordcraft_engine::Session::new(wordcraft_doc::Document::new()), Services::default());
a.run("text.insert", json!({"text": "Dear reader"})).unwrap();
a.run("ui.backstage", json!({"value": true, "page": "export"})).unwrap();
let mut h = egui_kittest::Harness::builder().with_size(egui::vec2(1440.0, 900.0)).build_ui_state(
|ui, app: &mut WordApp| {
let ctx = ui.ctx().clone();
app.logic(&ctx);
app.ui(ui);
},
a,
);
h.run_steps(4);
let err = h.state_mut().finish_pick(crate::file_dialogs::AfterPick::Export { ext: "xml".into() }, Some(bare)).unwrap_err();
h.run_steps(4);
assert!(h.state().ui.backstage, "still on the Export page");
assert!(err.contains("letter.xml already exists"), "{err}");
h.get_by_label(err.as_str());
assert_eq!(std::fs::read_to_string(dir.join("letter.xml")).unwrap(), "taken", "nothing replaced");
let _ = std::fs::remove_dir_all(&dir);
}
/// A refused Word XML export (the typed name's `.xml` twin already exists) is said on the Export
/// page itself: Backstage hides the status bar, so the person would otherwise see nothing.
#[test]
fn export_refusal_shows_on_the_print_page() {
let dir = std::env::temp_dir().join(format!("wordcraft-backstage-print-export-error-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
std::fs::write(dir.join("letter.xml"), "taken").unwrap();
let bare = dir.join("letter").to_string_lossy().into_owned();
let mut a = WordApp::new(wordcraft_engine::Session::new(wordcraft_doc::Document::new()), Services::default());
a.run("text.insert", json!({"text": "Dear reader"})).unwrap();
a.run("ui.backstage", json!({"value": true, "page": "print"})).unwrap();
let mut h = egui_kittest::Harness::builder().with_size(egui::vec2(1440.0, 900.0)).build_ui_state(
|ui, app: &mut WordApp| {
let ctx = ui.ctx().clone();
app.logic(&ctx);
app.ui(ui);
},
a,
);
h.run_steps(4);
let err = h.state_mut().finish_pick(crate::file_dialogs::AfterPick::Export { ext: "xml".into() }, Some(bare)).unwrap_err();
h.run_steps(4);
assert!(h.state().ui.backstage, "still on the Print page");
assert!(err.contains("letter.xml already exists"), "{err}");
h.get_by_label(err.as_str());
assert_eq!(std::fs::read_to_string(dir.join("letter.xml")).unwrap(), "taken", "nothing replaced");
let _ = std::fs::remove_dir_all(&dir);
}
/// A cancelled export dialog drops an earlier refusal: it is not news any more.
#[test]
fn cancelling_an_export_clears_its_page_error() {
let mut a = WordApp::new(wordcraft_engine::Session::new(wordcraft_doc::Document::new()), Services::default());
a.export_error = "old refusal".into();
a.finish_pick(crate::file_dialogs::AfterPick::Export { ext: "xml".into() }, None).unwrap();
assert!(a.export_error.is_empty());
}
/// The export error belongs to the window that refused the export: another window running a
/// frame outside Backstage must not erase it while this one still shows the Export page.
#[test]
fn export_error_belongs_to_its_window() {
let dir = std::env::temp_dir().join(format!("wordcraft-backstage-export-two-windows-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
std::fs::write(dir.join("letter.xml"), "taken").unwrap();
let bare = dir.join("letter").to_string_lossy().into_owned();
let mut a = WordApp::new(wordcraft_engine::Session::new(wordcraft_doc::Document::new()), Services::default());
a.run("text.insert", json!({"text": "Dear reader"})).unwrap();
a.run("ui.backstage", json!({"value": true, "page": "export"})).unwrap();
// Window A (this one) is refused; window B is another window's state, outside Backstage.
let mut b = crate::window_ui::WindowUi::new(a.session.document_id());
let err = a.finish_pick(crate::file_dialogs::AfterPick::Export { ext: "xml".into() }, Some(bare)).unwrap_err();
assert_eq!(a.export_error, err);
// B's frame: swap its state in, run frames outside Backstage, swap back.
a.swap_window(&mut b);
assert!(!a.ui.backstage && a.export_error.is_empty(), "B has its own, empty, error");
let mut h = egui_kittest::Harness::builder().with_size(egui::vec2(1440.0, 900.0)).build_ui_state(
|ui, app: &mut WordApp| {
let ctx = ui.ctx().clone();
app.logic(&ctx);
app.ui(ui);
},
a,
);
h.run_steps(4);
h.state_mut().swap_window(&mut b);
assert!(h.state().ui.backstage, "A is still on the Export page");
assert_eq!(h.state().export_error, err, "B's frames left A's message alone");
let _ = std::fs::remove_dir_all(&dir);
}
+22 -8
View File
@@ -64,7 +64,7 @@ use navigation::{scrollbar_page_tip, viewed_page};
use pages::{DRAWING_GRID_MAX_LINES, DRAWING_GRID_MIN_PX};
pub(crate) use pages::{PageKeys, dark_page, page_doc, page_screen_scale, preview_sel, screen_render_options};
use pages::{
drawing_grid, drawing_grid_step, gridline_cells, page_image, page_key, page_render_options, page_shows, shown_layout, texel_aligned_rect,
drawing_grid, drawing_grid_step, gridline_segments, page_image, page_key, page_render_options, page_shows, shown_layout, texel_aligned_rect,
view_key, visible_tiles,
};
pub(crate) use reading::turn_read_page;
@@ -253,6 +253,18 @@ pub struct CanvasState {
pub(crate) v_pressed: bool,
/// The modifiers last held with Mod, for a Mod+V whose Mod is released before V.
pub(crate) paste_mods: Option<egui::Modifiers>,
/// The modifiers a paste event is read with: those of Mod+V's press or a Mod change, until an
/// unrelated key, a pointer press or a focus change. (`paste_mods` also serves the release path.)
pub(crate) paste_event_mods: Option<egui::Modifiers>,
/// On the web, Mod+Shift+V pasted formatting from its key press: the browser's paste event
/// that follows is the same keystroke and pastes nothing (#5616). Any other key press clears it.
pub(crate) ignore_next_paste: bool,
/// When `ignore_next_paste` was set (input time, seconds): the browser's paired paste comes
/// with the key, so the wait ends after `PASTE_WAIT` and a later paste isn't dropped.
pub(crate) paste_wait_since: Option<f64>,
/// The platform sends a paste event after Mod+Shift+V's key (a browser does; a desktop shell
/// doesn't). Only then does the key leave a paste event to ignore or to let paste text.
pub(crate) paste_event_follows_chord: bool,
/// Draw Table or Eraser is on (`table_pen`): presses draw instead of moving the caret.
pub table_tool: Option<crate::table_pen::TableTool>,
/// The Draw Table stroke (or eraser press) in progress.
@@ -436,6 +448,10 @@ impl Default for CanvasState {
pasted: false,
v_pressed: false,
paste_mods: None,
paste_event_mods: None,
ignore_next_paste: false,
paste_wait_since: None,
paste_event_follows_chord: cfg!(target_arch = "wasm32"),
swallow_text: false,
ime_join_text: None,
ime_reset: false,
@@ -1262,14 +1278,12 @@ fn paint_pages(pass: PagePaint<'_>) -> PagePaintOutput {
}
draw_page_gridlines(app, &painter, t, page, visual_sr, page_scale);
// The current header/footer's cells have editing guides; explicit View Gridlines
// still outlines every table. Neither kind of guide is part of the document.
// still outlines every table. Both are drawn only where no border is (#5967), and
// neither kind of guide is part of the document.
if app.session.view.table_gridlines || grid_story.is_some() {
for rect in gridline_cells(page, app.session.view.table_gridlines, grid_story) {
let r = Rect::from_min_size(
pos2(visual_sr.min.x + rect.x * page_scale, visual_sr.min.y + rect.y * page_scale),
vec2(rect.w * page_scale, rect.h * page_scale),
);
painter.rect_stroke(r, 0.0, Stroke::new(0.5, t.blue.linear_multiply(0.6)), egui::StrokeKind::Middle);
let at = |p: wordcraft_geom::Point| pos2(visual_sr.min.x + p.x * page_scale, visual_sr.min.y + p.y * page_scale);
for (a, b) in gridline_segments(page, app.session.view.table_gridlines, grid_story) {
painter.line_segment([at(a), at(b)], Stroke::new(0.5, t.blue.linear_multiply(0.6)));
}
}
}
+78
View File
@@ -171,6 +171,84 @@ pub(super) fn gridline_cells(page: &Page, all: bool, editing: Option<StoryRef>)
})
}
/// The table gridline segments to draw on a page, in document points: the edges of the
/// [`gridline_cells`] minus the parts a printed border already draws. Word shows gridlines only
/// where a cell has no border; drawn over a border, the thin blue guide tinted every bordered
/// table blue and made its lines look uneven when zoomed out (#5967).
pub(super) fn gridline_segments(page: &Page, all: bool, editing: Option<StoryRef>) -> Vec<(wordcraft_geom::Point, wordcraft_geom::Point)> {
use wordcraft_geom::Point;
// A rule this close to a cell edge (points) is drawn on it.
const ON_EDGE: f32 = 0.25;
// Rules by the line they run along (horizontal or not, coordinate in quarter points), so
// each cell edge looks only at the rules on its own line. Body rules cannot cover header or
// footer cells, so they are left out when only those are outlined, as in `gridline_cells`.
let key = |c: f32| (c * 4.0).round() as i64;
let body = if all { page.items.as_slice() } else { &[] };
let mut rules: std::collections::HashMap<(bool, i64), Vec<(f32, f32, f32)>> = std::collections::HashMap::new();
for it in body.iter().chain(&page.header).chain(&page.footer) {
let Placed::Rule { x0, y0, x1, y1, border } = it else { continue };
if !border.is_visible() {
continue;
}
let (horizontal, c0, c1, s0, s1) = if (y0 - y1).abs() <= ON_EDGE { (true, *y0, *y1, *x0, *x1) } else { (false, *x0, *x1, *y0, *y1) };
if (c0 - c1).abs() <= ON_EDGE && c0.is_finite() {
rules.entry((horizontal, key(c0))).or_default().push((c0, s0.min(s1), s0.max(s1)));
}
}
// The rules covering the line at `at`, sorted and merged into disjoint spans. Cells share their
// edges, so each distinct line is sorted once (not once per cell edge) and every edge then
// binary-searches its start.
let mut merged: std::collections::HashMap<(bool, u32), Vec<(f32, f32)>> = std::collections::HashMap::new();
// The parts of [a, b] along a line at `at` that no rule on the same line covers; `horizontal`
// picks rules running along x at y = `at`, otherwise along y at x = `at`.
let mut uncovered = |horizontal: bool, at: f32, a: f32, b: f32| -> Vec<(f32, f32)> {
let covers = merged.entry((horizontal, at.to_bits())).or_insert_with(|| {
let k = key(at);
let mut covers: Vec<(f32, f32)> = (k - 1..=k + 1)
.filter_map(|k| rules.get(&(horizontal, k)))
.flatten()
.filter(|(c, _, _)| (c - at).abs() <= ON_EDGE)
.map(|&(_, s0, s1)| (s0, s1))
.collect();
covers.sort_by(|p, q| p.0.total_cmp(&q.0));
let mut spans: Vec<(f32, f32)> = Vec::with_capacity(covers.len());
for (c0, c1) in covers {
match spans.last_mut() {
Some(last) if c0 <= last.1 + ON_EDGE => last.1 = last.1.max(c1),
_ => spans.push((c0, c1)),
}
}
spans
});
let mut out = Vec::new();
let mut from = a;
for &(c0, c1) in &covers[covers.partition_point(|s| s.1 < a)..] {
if c0 > from + ON_EDGE {
out.push((from, c0.min(b)));
}
from = from.max(c1);
if from >= b {
break;
}
}
if from + ON_EDGE < b {
out.push((from, b));
}
out
};
let mut segs = Vec::new();
for r in gridline_cells(page, all, editing) {
let (l, t, rt, bt) = (r.x, r.y, r.x + r.w, r.y + r.h);
for y in [t, bt] {
segs.extend(uncovered(true, y, l, rt).into_iter().map(|(a, b)| (Point::new(a, y), Point::new(b, y))));
}
for x in [l, rt] {
segs.extend(uncovered(false, x, t, bt).into_iter().map(|(a, b)| (Point::new(x, a), Point::new(x, b))));
}
}
segs
}
/// The drawing grid's spacing in points at a screen scale: the document's spacing (`w:drawingGrid*Spacing`;
/// ECMA-376's 1/8 inch when it doesn't say), doubled until the lines are at least
/// [`DRAWING_GRID_MIN_PX`] apart on screen.
+312 -48
View File
@@ -1,3 +1,4 @@
use super::pages::gridline_cells;
use super::*;
use crate::table_resize::tests::{H, cell, screen, steps, table_window};
@@ -635,12 +636,12 @@ fn multi_click_drag_extends_by_units() {
for _ in 0..6 {
h.step();
}
let screen = |h: &mut egui_kittest::Harness<'_, WordApp>, pos: Pos| {
let screen = |h: &mut H, pos: Pos| {
let c = h.state_mut().session.layout().caret(&pos).expect("caret");
page_to_screen(h.state_mut(), c.page, c.x + 1.0, c.top + c.height / 2.0).expect("on screen")
};
let button = |at: Pos2, pressed: bool| Event::PointerButton { pos: at, button: PointerButton::Primary, pressed, modifiers: Default::default() };
let multi_drag = |h: &mut egui_kittest::Harness<'_, WordApp>, from: Pos2, to: Pos2, clicks: usize| {
let multi_drag = |h: &mut H, from: Pos2, to: Pos2, clicks: usize| {
h.event(Event::PointerMoved(from));
for i in 0..clicks {
h.event(button(from, true));
@@ -871,7 +872,7 @@ fn clicking_vertical_scrollbar_track_advances_one_screen() {
let button = |at: Pos2, pressed: bool| Event::PointerButton { pos: at, button: PointerButton::Primary, pressed, modifiers: Default::default() };
let click = |h: &mut egui_kittest::Harness<'_, WordApp>, at: Pos2| {
let click = |h: &mut H, at: Pos2| {
h.event(Event::PointerMoved(at));
h.step();
h.event(button(at, true));
@@ -939,7 +940,7 @@ fn clicking_vertical_scrollbar_track_advances_one_screen_in_rtl() {
let button = |at: Pos2, pressed: bool| Event::PointerButton { pos: at, button: PointerButton::Primary, pressed, modifiers: Default::default() };
let click = |h: &mut egui_kittest::Harness<'_, WordApp>, at: Pos2| {
let click = |h: &mut H, at: Pos2| {
h.event(Event::PointerMoved(at));
h.step();
h.event(button(at, true));
@@ -1002,7 +1003,7 @@ fn clicking_thin_vertical_scrollbar_track_advances_one_screen() {
let button = |at: Pos2, pressed: bool| Event::PointerButton { pos: at, button: PointerButton::Primary, pressed, modifiers: Default::default() };
let click = |h: &mut egui_kittest::Harness<'_, WordApp>, at: Pos2| {
let click = |h: &mut H, at: Pos2| {
h.event(Event::PointerMoved(at));
h.step();
h.event(button(at, true));
@@ -1195,11 +1196,11 @@ fn ctrl_drag_copies_an_object() {
for _ in 0..6 {
h.step();
}
let objects = |h: &mut egui_kittest::Harness<'_, WordApp>| {
let objects = |h: &mut H| {
let doc = &h.state().session.doc;
doc.para(wordcraft_doc::StoryRef::Body, &wordcraft_doc::Path::top(0)).map_or(0, |p| p.objects.len())
};
let xs = |h: &mut egui_kittest::Harness<'_, WordApp>| {
let xs = |h: &mut H| {
let mut v: Vec<i32> = Vec::new();
for x in (0..600).step_by(50) {
if h.state_mut().session.layout().find_object(0, |o| (o.rect.x - x as f32).abs() < 0.5).is_some() {
@@ -1208,7 +1209,7 @@ fn ctrl_drag_copies_an_object() {
}
v
};
let drag = |h: &mut egui_kittest::Harness<'_, WordApp>, mods: Modifiers| {
let drag = |h: &mut H, mods: Modifiers| {
let from = page_to_screen(h.state_mut(), 0, 250.0, 330.0).expect("on screen");
let to = page_to_screen(h.state_mut(), 0, 400.0, 330.0).expect("on screen");
h.event(Event::ModifiersChanged(mods));
@@ -1257,19 +1258,19 @@ fn selection_bar_clicks_select_lines() {
h.step();
}
// A point in the left margin beside the line `li` lines below the one holding `pos`.
let margin = |h: &mut egui_kittest::Harness<'_, WordApp>, pos: Pos, li: f32| {
let margin = |h: &mut H, pos: Pos, li: f32| {
let c = h.state_mut().session.layout().caret(&pos).expect("caret");
page_to_screen(h.state_mut(), c.page, 30.0, c.top + c.height * (li + 0.5)).expect("on screen")
};
let line_start = |h: &mut egui_kittest::Harness<'_, WordApp>, at: Pos2| {
let line_start = |h: &mut H, at: Pos2| {
let (rects, scale) = (h.state().canvas.page_rects.clone(), h.state().canvas.scale);
let layout = h.state_mut().session.layout();
let (pg, x, y) = page_at(&rects, &layout, scale, at).expect("page");
layout.selection_bar_at(pg, x, y).expect("in the selection bar")
};
let span = |h: &mut egui_kittest::Harness<'_, WordApp>, pos: &Pos| h.state_mut().session.layout().line_span(pos, 0).expect("line");
let span = |h: &mut H, pos: &Pos| h.state_mut().session.layout().line_span(pos, 0).expect("line");
let button = |at: Pos2, pressed: bool| Event::PointerButton { pos: at, button: PointerButton::Primary, pressed, modifiers: Default::default() };
let clicks_drag = |h: &mut egui_kittest::Harness<'_, WordApp>, from: Pos2, to: Pos2, clicks: usize| {
let clicks_drag = |h: &mut H, from: Pos2, to: Pos2, clicks: usize| {
h.event(Event::PointerMoved(from));
for i in 0..clicks {
h.event(button(from, true));
@@ -1288,7 +1289,7 @@ fn selection_bar_clicks_select_lines() {
h.step();
}
};
let pause = |h: &mut egui_kittest::Harness<'_, WordApp>| {
let pause = |h: &mut H| {
for _ in 0..40 {
h.step();
}
@@ -1361,7 +1362,7 @@ fn selection_bar_of_a_right_to_left_paragraph_is_on_the_right() {
let y = c.top + c.height / 2.0;
let right = page_to_screen(h.state_mut(), c.page, (body_x + page_w) / 2.0, y).expect("on screen");
let left = page_to_screen(h.state_mut(), c.page, 30.0, y).expect("on screen");
let click = |h: &mut egui_kittest::Harness<'_, WordApp>, at: Pos2| {
let click = |h: &mut H, at: Pos2| {
h.event(Event::PointerMoved(at));
h.step();
h.event(Event::PointerButton { pos: at, button: PointerButton::Primary, pressed: true, modifiers: Default::default() });
@@ -1408,7 +1409,7 @@ fn an_armed_format_painter_changes_the_pointer() {
let c = h.state_mut().session.layout().caret(&Pos::body(0, 6)).expect("caret");
let over_text = page_to_screen(h.state_mut(), c.page, c.x, c.top + c.height / 2.0).expect("on screen");
let over_bar = page_to_screen(h.state_mut(), c.page, 30.0, c.top + c.height / 2.0).expect("on screen");
let pointer_after = |h: &mut egui_kittest::Harness<'_, WordApp>, cmd: Option<&str>| {
let pointer_after = |h: &mut H, cmd: Option<&str>| {
if let Some(cmd) = cmd {
h.state_mut().run(cmd, json!({})).unwrap();
}
@@ -1493,7 +1494,7 @@ fn an_empty_comment_balloon_deletes() {
for _ in 0..6 {
h.step();
}
let click = |h: &mut egui_kittest::Harness<'_, WordApp>, at: egui::Pos2| {
let click = |h: &mut H, at: egui::Pos2| {
h.event(egui::Event::PointerMoved(at));
h.event(egui::Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed: true, modifiers: Default::default() });
h.step();
@@ -2137,7 +2138,7 @@ fn double_click_margin_creates_header_and_footer() {
for _ in 0..6 {
h.step();
}
let double_click = |h: &mut egui_kittest::Harness<'_, WordApp>, at: Pos2| {
let double_click = |h: &mut H, at: Pos2| {
h.event(Event::PointerMoved(at));
for _ in 0..2 {
h.event(Event::PointerButton { pos: at, button: PointerButton::Primary, pressed: true, modifiers: Default::default() });
@@ -2150,7 +2151,7 @@ fn double_click_margin_creates_header_and_footer() {
h.step();
}
};
let kind = |h: &egui_kittest::Harness<'_, WordApp>| part_kind(h.state(), h.state().session.sel.focus.story);
let kind = |h: &H| part_kind(h.state(), h.state().session.sel.focus.story);
let page = h.state_mut().session.layout().pages[0].clone();
assert!(page.header_story.is_none() && page.footer_story.is_none());
let (x, top, bottom) = (page.body.x + 20.0, page.body.y / 2.0, (page.body.bottom() + page.h) / 2.0);
@@ -2250,7 +2251,7 @@ fn double_click_switches_between_header_and_footer() {
for _ in 0..6 {
h.step();
}
let double_click = |h: &mut egui_kittest::Harness<'_, WordApp>, at: Pos2| {
let double_click = |h: &mut H, at: Pos2| {
h.event(Event::PointerMoved(at));
for _ in 0..2 {
h.event(Event::PointerButton { pos: at, button: PointerButton::Primary, pressed: true, modifiers: Default::default() });
@@ -2262,7 +2263,7 @@ fn double_click_switches_between_header_and_footer() {
h.step();
}
};
let kind = |h: &egui_kittest::Harness<'_, WordApp>| part_kind(h.state(), h.state().session.sel.focus.story);
let kind = |h: &H| part_kind(h.state(), h.state().session.sel.focus.story);
let page = h.state_mut().session.layout().pages[0].clone();
let (x, top, bottom) = (page.body.x + 20.0, page.body.y / 2.0, (page.body.bottom() + page.h) / 2.0);
let head_at = page_to_screen(h.state_mut(), 0, x, top).expect("top margin on screen");
@@ -2885,7 +2886,7 @@ fn control_click_on_macos_opens_the_context_menu() {
h.step();
let ctrl = egui::Modifiers { ctrl: true, ..Default::default() };
// The events winit delivers for a Control-click, through the app's input hook as eframe runs it.
let send = |h: &mut egui_kittest::Harness<'_, WordApp>, events: Vec<egui::Event>| {
let send = |h: &mut H, events: Vec<egui::Event>| {
let mut raw = egui::RawInput { events, ..Default::default() };
let ctx = h.ctx.clone();
h.state_mut().raw_input_hook(&ctx, &mut raw);
@@ -2973,7 +2974,10 @@ fn drag_floating_picture(wrap: &str, header: bool, preselect: bool) {
for _ in 0..3 {
h.step();
}
assert!(wordcraft_engine::cmd::objects::object_selection(&h.state().session).is_none(), "a click still selects text");
// In the header the picture lies over the body area, clear of the header's own text, so a
// click on it selects it (Word); in the body a click still reaches the text behind it.
let picked = wordcraft_engine::cmd::objects::object_selection(&h.state().session).is_some();
assert_eq!(picked, header, "a click selects the header's picture, but only edits the body's text");
if preselect {
let end = Pos { off: pos.off + wordcraft_doc::para::OBJ.len_utf8(), ..pos.clone() };
h.state_mut().run("select.range", json!({"anchor": pos, "focus": end})).unwrap();
@@ -3138,7 +3142,7 @@ fn right_clicking_a_link_hides_the_hover_tooltip() {
let at = screen(&mut h, c.x, c.top + c.height / 2.0);
h.event(egui::Event::PointerMoved(at));
steps(&mut h, 2);
let tips = |h: &egui_kittest::Harness<'_, WordApp>| h.query_all_by_label_contains("Click to follow link").count();
let tips = |h: &H| h.query_all_by_label_contains("Click to follow link").count();
assert!(tips(&h) > 0, "hovering the link shows its target");
for pressed in [true, false] {
h.event(egui::Event::PointerButton { pos: at, button: egui::PointerButton::Secondary, pressed, modifiers: Default::default() });
@@ -3171,7 +3175,7 @@ fn a_handled_press_skips_the_link_tooltip() {
let at = screen(&mut h, c.x, c.top + c.height / 2.0);
h.event(Event::PointerMoved(at));
steps(&mut h, 2);
let tips = |h: &egui_kittest::Harness<'_, WordApp>| h.query_all_by_label_contains("Click to follow link").count();
let tips = |h: &H| h.query_all_by_label_contains("Click to follow link").count();
assert!(tips(&h) > 0, "hovering the link shows its target");
h.event(Event::ModifiersChanged(Modifiers::COMMAND));
h.event(Event::PointerButton { pos: at, button: PointerButton::Primary, pressed: true, modifiers: Modifiers::COMMAND });
@@ -3560,6 +3564,102 @@ fn table_gridlines_include_header_and_footer_tables() {
assert!(ys(None).is_empty(), "closing header/footer editing removes the automatic guides");
}
/// #5967: gridlines show only where a cell has no printed border, as in Word; drawn over the
/// border they tinted every bordered table blue.
#[test]
fn table_gridlines_skip_edges_a_border_draws() {
use wordcraft_geom::Point;
let cell = Placed::Cell {
rect: wordcraft_geom::Rect::new(0.0, 0.0, 10.0, 20.0),
covered: false,
table: Default::default(),
row: 0,
cell: 0,
story: StoryRef::Body,
clip: false,
};
let rule = |x0, y0, x1, y1, border| Placed::Rule { x0, y0, x1, y1, border };
let line = wordcraft_doc::props::Border::single(0.5);
let none = wordcraft_doc::props::Border::single(0.0);
let page = Page {
items: vec![
// Top border over the whole edge (run on past the corners, as layout draws it).
rule(-0.25, 0.0, 10.25, 0.0, line),
// Left border over the top half only.
rule(0.0, 0.0, 0.0, 10.0, line),
// A zero-width border draws nothing, so the right edge keeps its gridline.
rule(10.0, 0.0, 10.0, 20.0, none),
cell,
],
..Default::default()
};
// Overlapping rules out of order on one line leave only the gap between them: the bottom
// edge keeps 4..6 alone.
let mut gapped = page.clone();
gapped.items.extend([
rule(5.0, 20.0, 10.0, 20.0, line),
rule(-0.25, 20.0, 3.0, 20.0, line),
rule(1.0, 20.0, 4.0, 20.0, line),
rule(6.0, 20.0, 5.5, 20.0, line),
]);
assert_eq!(gridline_segments(&gapped, true, None).first(), Some(&(Point::new(4.0, 20.0), Point::new(5.0, 20.0))));
assert_eq!(gridline_segments(&gapped, true, None).len(), 3);
let segs = gridline_segments(&page, true, None);
assert_eq!(
segs,
[
(Point::new(0.0, 20.0), Point::new(10.0, 20.0)), // bottom: no border
(Point::new(0.0, 10.0), Point::new(0.0, 20.0)), // left: below the border
(Point::new(10.0, 0.0), Point::new(10.0, 20.0)), // right: invisible border
]
);
}
/// #5967: the gridlines of a table with very many rows are found in one pass over the rules, not
/// by re-sorting every rule on a line for each cell edge on it (a long table repainted slowly).
#[test]
fn table_gridlines_of_a_many_row_table_are_fast() {
const ROWS: usize = 30_000;
let line = wordcraft_doc::props::Border::single(0.5);
let mut items = Vec::new();
for i in 0..ROWS {
let y = i as f32 * 10.0;
items.push(Placed::Cell {
rect: wordcraft_geom::Rect::new(0.0, y, 10.0, 10.0),
covered: false,
table: Default::default(),
row: i,
cell: 0,
story: StoryRef::Body,
clip: false,
});
// One border piece per row on each side, so both vertical lines carry a rule per row.
for x in [0.0, 10.0] {
items.push(Placed::Rule { x0: x, y0: y, x1: x, y1: y + 10.0, border: line });
}
}
let page = Page { items, ..Default::default() };
let start = std::time::Instant::now();
let segs = gridline_segments(&page, true, None);
// Both sides are covered; the top and bottom of every cell are not.
assert_eq!(segs.len(), 2 * ROWS);
assert!(segs.iter().all(|(a, b)| a.y == b.y));
assert!(start.elapsed() < std::time::Duration::from_secs(5), "took {:?}", start.elapsed());
}
/// #5967: a new table has borders on every edge, so it shows no gridline at all; with its
/// borders removed every edge shows one.
#[test]
fn a_bordered_table_shows_no_gridlines() {
let mut a = WordApp::new(wordcraft_engine::Session::new(wordcraft_doc::Document::new()), Default::default());
a.run("insert.table", json!({"rows": 2, "cols": 3})).unwrap();
assert!(a.session.view.table_gridlines, "View Gridlines is on by default");
let segs = |a: &mut WordApp| gridline_segments(&a.session.layout().pages[0], true, None).len();
assert_eq!(segs(&mut a), 0);
a.run("table.borders", json!({"kind": "none"})).unwrap();
assert_eq!(segs(&mut a), 6 * 4, "every edge of the six cells");
}
#[test]
fn drawing_grid_starts_at_the_margins_and_stays_inside_them() {
// Letter page with 1" margins: the text area is 468 x 648 pt from (72, 72).
@@ -4029,13 +4129,13 @@ fn ruler_tab_gestures_are_primary_only_and_cancellable() {
h.step();
}
let area = h.state().canvas.canvas_rect.expect("the canvas is laid out");
let ruler_x = |h: &mut egui_kittest::Harness<'_, WordApp>, d: f32| {
let ruler_x = |h: &mut H, d: f32| {
let body_x = h.state_mut().session.layout().pages[0].body.x;
page_to_screen(h.state_mut(), 0, body_x + d, 0.0).expect("on screen").x
};
let on_ruler = |h: &mut egui_kittest::Harness<'_, WordApp>, d: f32| pos2(ruler_x(h, d), area.min.y - 7.0);
let on_ruler = |h: &mut H, d: f32| pos2(ruler_x(h, d), area.min.y - 7.0);
let button = |at: Pos2, b: PointerButton, pressed: bool| Event::PointerButton { pos: at, button: b, pressed, modifiers: Default::default() };
let drag_events = |h: &mut egui_kittest::Harness<'_, WordApp>, from: Pos2, to: Pos2, b: PointerButton| {
let drag_events = |h: &mut H, from: Pos2, to: Pos2, b: PointerButton| {
h.event(Event::PointerMoved(from));
h.event(button(from, b, true));
h.step();
@@ -4048,7 +4148,7 @@ fn ruler_tab_gestures_are_primary_only_and_cancellable() {
h.step();
}
};
let stops_of = |h: &egui_kittest::Harness<'_, WordApp>, block: usize| {
let stops_of = |h: &H, block: usize| {
let s = &h.state().session;
let para = s.doc.para_at(&Pos::body(block, 0)).expect("a paragraph");
s.doc.styles.resolve_para(&para.props).tabs.iter().map(|t| (t.pos, t.align)).collect::<Vec<_>>()
@@ -4134,13 +4234,13 @@ fn ruler_tab_stops_are_set_moved_and_cleared_with_the_pointer() {
}
let area = h.state().canvas.canvas_rect.expect("the canvas is laid out");
// The middle of the ruler's strip, over a point `d` points from the paragraph's start.
let on_ruler = |h: &mut egui_kittest::Harness<'_, WordApp>, d: f32| {
let on_ruler = |h: &mut H, d: f32| {
let body_x = h.state_mut().session.layout().pages[0].body.x;
let x = page_to_screen(h.state_mut(), 0, body_x + d, 0.0).expect("on screen").x;
pos2(x, area.min.y - 7.0)
};
let button = |at: Pos2, pressed: bool| Event::PointerButton { pos: at, button: PointerButton::Primary, pressed, modifiers: Default::default() };
let click = |h: &mut egui_kittest::Harness<'_, WordApp>, at: Pos2| {
let click = |h: &mut H, at: Pos2| {
h.event(Event::PointerMoved(at));
h.event(button(at, true));
h.step();
@@ -4153,7 +4253,7 @@ fn ruler_tab_stops_are_set_moved_and_cleared_with_the_pointer() {
h.step();
}
};
let drag = |h: &mut egui_kittest::Harness<'_, WordApp>, from: Pos2, to: Pos2| {
let drag = |h: &mut H, from: Pos2, to: Pos2| {
h.event(Event::PointerMoved(from));
h.event(button(from, true));
h.step();
@@ -4166,7 +4266,7 @@ fn ruler_tab_stops_are_set_moved_and_cleared_with_the_pointer() {
h.step();
}
};
let stops = |h: &egui_kittest::Harness<'_, WordApp>| {
let stops = |h: &H| {
let s = &h.state().session;
let para = s.doc.para_at(&s.sel.focus).expect("a paragraph");
s.doc.styles.resolve_para(&para.props).tabs.iter().map(|t| (t.pos, t.align)).collect::<Vec<_>>()
@@ -4253,8 +4353,7 @@ fn space_and_enter_on_the_canvas_do_not_interrupt_ime() {
}
assert!(h.state().canvas.focused, "the canvas takes focus when the window opens");
let key = |key| egui::Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers: egui::Modifiers::NONE };
let ime_interrupted =
|h: &egui_kittest::Harness<'_, WordApp>| h.output().platform_output.ime.as_ref().map(|ime| ime.should_interrupt_composition);
let ime_interrupted = |h: &H| h.output().platform_output.ime.as_ref().map(|ime| ime.should_interrupt_composition);
h.event(key(egui::Key::Space));
h.event(egui::Event::Text(" ".into()));
h.step();
@@ -4340,7 +4439,7 @@ fn the_caret_follows_the_input_method_cursor_in_the_composition() {
for _ in 0..8 {
h.step();
}
let ime_x = |h: &egui_kittest::Harness<'_, WordApp>| h.output().platform_output.ime.as_ref().map(|ime| ime.cursor_rect.min.x);
let ime_x = |h: &H| h.output().platform_output.ime.as_ref().map(|ime| ime.cursor_rect.min.x);
let start = ime_x(&h).expect("the canvas places the candidate window");
let mut compose = |range: Option<std::ops::Range<usize>>| {
h.event(egui::Event::Ime(egui::ImeEvent::Preedit { text: "にほん".into(), active_range_chars: range }));
@@ -4386,10 +4485,8 @@ fn ime_descriptor_reports_visible_logical_text_and_exact_cause() {
}
h.state_mut().session.sel = wordcraft_engine::Selection::caret(wordcraft_doc::Pos::body(0, 2));
h.step();
let text = |h: &egui_kittest::Harness<'_, WordApp>| {
h.output().platform_output.ime.as_ref().and_then(|i| i.surrounding_text.available()).map(|p| p.text.clone())
};
let cause = |h: &egui_kittest::Harness<'_, WordApp>| h.output().platform_output.ime.as_ref().map(|i| i.change_cause);
let text = |h: &H| h.output().platform_output.ime.as_ref().and_then(|i| i.surrounding_text.available()).map(|p| p.text.clone());
let cause = |h: &H| h.output().platform_output.ime.as_ref().map(|i| i.change_cause);
assert_eq!(text(&h), Some("ab".into()), "the committed text is available");
h.event(egui::Event::Ime(egui::ImeEvent::Preedit { text: "に".into(), active_range_chars: None }));
h.step();
@@ -4433,8 +4530,7 @@ fn ime_descriptor_hides_tracked_deletions_and_preserves_reversed_selection() {
}
h.state_mut().session.sel = wordcraft_engine::Selection { anchor: wordcraft_doc::Pos::body(0, 2), focus: wordcraft_doc::Pos::body(0, 7) };
h.step();
let payload =
|h: &egui_kittest::Harness<'_, WordApp>| h.output().platform_output.ime.as_ref().and_then(|i| i.surrounding_text.available()).cloned();
let payload = |h: &H| h.output().platform_output.ime.as_ref().and_then(|i| i.surrounding_text.available()).cloned();
let p = payload(&h).expect("the visible text is available");
assert_eq!(p.text, "abcd");
assert_eq!(p.cursor, 4);
@@ -4460,10 +4556,10 @@ fn ime_byte_deletion_preserves_the_selection_and_earns_input_method() {
}
h.state_mut().session.sel = wordcraft_engine::Selection { anchor: wordcraft_doc::Pos::body(0, 3), focus: wordcraft_doc::Pos::body(0, 1) };
h.step();
let cause = |h: &egui_kittest::Harness<'_, WordApp>| h.output().platform_output.ime.as_ref().map(|i| i.change_cause);
let cause = |h: &H| h.output().platform_output.ime.as_ref().map(|i| i.change_cause);
h.event(egui::Event::Ime(egui::ImeEvent::DeleteSurroundingBytes { before_bytes: 1, after_bytes: 1 }));
h.step();
let body = |h: &egui_kittest::Harness<'_, WordApp>| h.state().session.doc.plain_text(wordcraft_doc::StoryRef::Body).trim_end().to_string();
let body = |h: &H| h.state().session.doc.plain_text(wordcraft_doc::StoryRef::Body).trim_end().to_string();
assert_eq!(body(&h), "bc", "the selected text is preserved");
assert_eq!(h.state().session.sel.anchor.off, 2, "the selection anchor moved with the erased prefix");
assert_eq!(h.state().session.sel.focus.off, 0);
@@ -4510,7 +4606,7 @@ fn ime_generation_changes_on_document_replacement_but_not_on_caret_motion() {
for _ in 0..8 {
h.step();
}
let generation = |h: &egui_kittest::Harness<'_, WordApp>| h.output().platform_output.ime.as_ref().map(|i| i.context_generation);
let generation = |h: &H| h.output().platform_output.ime.as_ref().map(|i| i.context_generation);
let first = generation(&h).expect("an IME context");
h.state_mut().run("caret.right", json!({})).unwrap();
h.step();
@@ -4715,7 +4811,7 @@ fn ime_generation_changes_on_undo_and_version_restore() {
for _ in 0..8 {
h.step();
}
let generation = |h: &egui_kittest::Harness<'_, WordApp>| h.output().platform_output.ime.as_ref().map(|i| i.context_generation);
let generation = |h: &H| h.output().platform_output.ime.as_ref().map(|i| i.context_generation);
let first = generation(&h).expect("an IME context");
h.state_mut().run("edit.undo", json!({})).unwrap();
h.step();
@@ -5014,9 +5110,7 @@ fn ime_equation_byte_delete_drops_only_its_immediate_replacement() {
for _ in 0..8 {
h.step();
}
let linear = |h: &mut egui_kittest::Harness<'_, WordApp>| {
h.state_mut().run("equation.get", json!({})).unwrap()["linear"].as_str().unwrap_or_default().to_string()
};
let linear = |h: &mut H| h.state_mut().run("equation.get", json!({})).unwrap()["linear"].as_str().unwrap_or_default().to_string();
// Harness::event steps each queued event in a separate frame. Insert the complete
// protocol replacement into RawInput to exercise a single native input batch.
h.input_mut().events.extend([
@@ -5388,6 +5482,176 @@ fn a_long_comment_balloon_paints_only_its_first_ten_rows() {
}
}
/// A Behind Text header picture: while editing the header a click on it selects it wherever no
/// header text covers it (far down over the body, or in the band clear of the text), as in Word;
/// over the header text the click edits the text. From the body a click there is body text.
#[test]
fn header_picture_clear_of_header_text_is_selected_while_editing_the_header() {
// Far down the page, over the body.
header_picture_click(false, 200.0, 400.0, Some((300.0, f32::MAX)), true);
// In the header band, below the header's text line.
header_picture_click(false, 300.0, 56.0, Some((50.0, 72.0)), true);
// Over the header's text, at its start: the click goes to the text.
header_picture_click(false, 72.0, 36.0, None, false);
}
/// The same for a footer, which is a `StoryRef::Part` like the header.
#[test]
fn footer_picture_clear_of_footer_text_is_selected_while_editing_the_footer() {
header_picture_click(true, 200.0, 400.0, Some((300.0, f32::MAX)), true);
}
/// Dragging a header picture that no header text covers moves it, rather than starting the
/// deferred drag-over-text path.
#[test]
fn dragging_a_header_picture_clear_of_header_text_moves_it() {
let (mut h, pos, rect) = header_picture_app(false, 200.0, 400.0, 1);
edit_story(&mut h, false, 0);
let at = picture_point(&h, 0, rect);
h.event(egui::Event::PointerMoved(at));
h.event(pointer_button(at, egui::PointerButton::Primary, true));
h.step();
let to = at + egui::vec2(60.0, 30.0);
for p in [at + egui::vec2(20.0, 10.0), to] {
h.event(egui::Event::PointerMoved(p));
h.step();
}
h.event(pointer_button(to, egui::PointerButton::Primary, false));
steps(&mut h, 3);
let moved = h.state_mut().session.layout().object(&pos, 0).unwrap().rect;
assert!(moved.x > rect.x + 10.0 && moved.y > rect.y + 5.0, "the picture moved with the drag: {rect:?} -> {moved:?}");
assert_eq!(wordcraft_engine::cmd::objects::object_selection(&h.state().session).map(|(p, _)| p), Some(pos), "and stays selected");
}
/// A right-click on the header picture repeated on page 2 while editing the header on page 1
/// selects that copy: the frame and handles belong on page 2, not the page last edited.
#[test]
fn right_clicking_a_repeated_header_picture_selects_it_on_its_own_page() {
let (mut h, pos, _) = header_picture_app(false, 200.0, 400.0, 2);
edit_story(&mut h, false, 0);
assert_eq!(h.state().session.page_hint, 0, "editing the header on page 1");
let rect = h.state_mut().session.layout().object(&pos, 1).unwrap().rect;
assert_eq!(h.state_mut().session.layout().object(&pos, 1).unwrap().page, 1, "the picture is repeated on page 2");
let at = picture_point(&h, 1, rect);
press(&mut h, at, egui::PointerButton::Secondary);
assert_eq!(wordcraft_engine::cmd::objects::object_selection(&h.state().session).map(|(p, _)| p), Some(pos), "the right-click selected it");
assert_eq!(h.state().session.page_hint, 1, "its frame is drawn on the page clicked");
}
/// The same for a left-click: it selects the page-2 copy and moves the frame there, not the copy
/// on page 1 that was being edited.
#[test]
fn left_clicking_a_repeated_header_picture_selects_it_on_its_own_page() {
let (mut h, pos, _) = header_picture_app(false, 200.0, 400.0, 2);
edit_story(&mut h, false, 0);
assert_eq!(h.state().session.page_hint, 0, "editing the header on page 1");
let rect = h.state_mut().session.layout().object(&pos, 1).unwrap().rect;
assert_eq!(h.state_mut().session.layout().object(&pos, 1).unwrap().page, 1, "the picture is repeated on page 2");
let at = picture_point(&h, 1, rect);
press(&mut h, at, egui::PointerButton::Primary);
assert_eq!(wordcraft_engine::cmd::objects::object_selection(&h.state().session).map(|(p, _)| p), Some(pos), "the left-click selected it");
assert_eq!(h.state().session.page_hint, 1, "its frame is drawn on the page clicked");
}
fn pointer_button(pos: egui::Pos2, button: egui::PointerButton, pressed: bool) -> egui::Event {
egui::Event::PointerButton { pos, button, pressed, modifiers: Default::default() }
}
/// Moves to `at`, presses and releases `button` there and lets the frames settle.
fn press(h: &mut H, at: egui::Pos2, button: egui::PointerButton) {
h.event(egui::Event::PointerMoved(at));
h.event(pointer_button(at, button, true));
h.step();
h.event(pointer_button(at, button, false));
steps(h, 3);
}
/// Near the top-left corner of the picture's `rect` on `page`: on the header text line when the
/// picture is placed over it.
fn picture_point(h: &H, page: usize, rect: wordcraft_geom::Rect) -> egui::Pos2 {
let scale = h.state().canvas.scale;
crate::frame::to_screen(h.state().canvas.page_rects[page], scale, rect).min + egui::vec2(10.0, 6.0) * scale
}
/// Starts editing the header (or footer) of `page` and lets the frames settle.
fn edit_story(h: &mut H, footer: bool, page: usize) {
let command = if footer { "insert.editFooter" } else { "insert.editHeader" };
h.state_mut().run(command, json!({"page": page})).unwrap();
// Entering the footer scrolls the page to it: wait until the page stops moving.
let (mut last, mut still) = (h.state().canvas.page_rects[0], 0);
for _ in 0..600 {
h.step();
let now = h.state().canvas.page_rects[0];
still = if now == last { still + 1 } else { 0 };
last = now;
if still >= 10 {
break;
}
}
}
/// A body-mode window on a document of `pages` pages whose header (or footer) holds text and a
/// 160pt Behind Text picture at (`x`, `y`) on the page. Returns it, the picture's position and
/// its first-page rectangle.
fn header_picture_app(footer: bool, x: f32, y: f32, pages: usize) -> (H, Pos, wordcraft_geom::Rect) {
let mut a = WordApp::new(wordcraft_engine::Session::new(wordcraft_doc::Document::new()), Default::default());
for _ in 1..pages {
a.run("insert.pageBreak", json!({})).unwrap();
}
a.run(if footer { "insert.editFooter" } else { "insert.editHeader" }, json!({})).unwrap();
a.run("text.insert", json!({"text": if footer { "Footer" } else { "Header" }})).unwrap();
let mut png = Vec::new();
let img = image::RgbaImage::from_pixel(40, 20, image::Rgba([200, 30, 30, 255]));
image::DynamicImage::ImageRgba8(img).write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png).unwrap();
a.run("insert.picture", json!({"data": wordcraft_engine::cmd::insert::base64_encode(&png), "width": 160})).unwrap();
let pos = wordcraft_engine::cmd::objects::selected(&a.session).unwrap().0;
a.run("arrange.bounds", json!({"x": x, "y": y})).unwrap();
a.run("arrange.wrap", json!({"wrap": "behindText"})).unwrap();
let rect = a.session.layout().object(&pos, 0).unwrap().rect;
a.run("insert.closeHeader", json!({})).unwrap();
let mut h = egui_kittest::Harness::builder().with_size(egui::vec2(1440.0, 900.0)).with_step_dt(1.0 / 60.0).build_ui_state(
|ui, app: &mut WordApp| {
let ctx = ui.ctx().clone();
app.logic(&ctx);
app.ui(ui);
},
a,
);
// Zoomed out so the whole page is on screen and entering the footer scrolls nothing.
h.state_mut().run("view.zoom", json!({"value": 40})).unwrap();
steps(&mut h, 20);
(h, pos, rect)
}
/// Puts a Behind Text header (or footer) picture at (`x`, `y`), checks its top lies within `band`
/// (when given), clicks near its top-left corner from the body and then while editing, and checks
/// the second click selects it (`selects`) or leaves the caret in the text; a right-click picks it
/// only where the click does, so the context menu (Reset Picture, Wrap Text) acts on it.
fn header_picture_click(footer: bool, x: f32, y: f32, band: Option<(f32, f32)>, selects: bool) {
let (mut h, pos, rect) = header_picture_app(footer, x, y, 1);
if let Some((lo, hi)) = band {
assert!(rect.y >= lo && rect.y < hi, "the picture sits where the case wants it: {rect:?}");
}
let at = picture_point(&h, 0, rect);
let picked = |h: &H| wordcraft_engine::cmd::objects::object_selection(&h.state().session).map(|(p, _)| p);
press(&mut h, at, egui::PointerButton::Primary);
assert!(picked(&h).is_none(), "from the body the picture isn't selectable");
assert_eq!(h.state().session.sel.focus.story, StoryRef::Body);
edit_story(&mut h, footer, 0);
press(&mut h, at, egui::PointerButton::Primary);
if selects {
assert_eq!(picked(&h), Some(pos.clone()), "while editing a click on its picture selects it ({x}, {y})");
} else {
assert_eq!(picked(&h), None, "over the text the click edits the text ({x}, {y})");
assert!(matches!(h.state().session.sel.focus.story, StoryRef::Part(_)), "still in the header or footer");
}
h.state_mut().session.sel = wordcraft_engine::Selection::caret(Pos { off: 0, ..pos.clone() });
press(&mut h, at, egui::PointerButton::Secondary);
assert_eq!(picked(&h), selects.then(|| pos.clone()), "a right-click picks the picture only where a click does ({x}, {y})");
h.event(egui::Event::Key { key: egui::Key::Escape, physical_key: None, pressed: true, repeat: false, modifiers: Default::default() });
h.step();
}
/// #1961 review: what a picture draws must be in its page's fingerprint itself. Reset Picture on
/// one never edited keeps its media and clears only its corrections and crop, and undo puts them
/// back; the anchor paragraph's layout pointer also moves then, but only as long as the old
+15 -1
View File
@@ -225,7 +225,21 @@ pub fn show(app: &mut WordApp, ctx: &egui::Context) {
let held = (app.file_browser_open() || app.colors.is_some()).then(|| ctx.input_mut(|i| std::mem::take(&mut i.events)));
let shown = place_dialog(ctx, id, window).show(ctx, |ui| {
ui.set_min_width(340.0);
close = crate::rtl::root(ui, |ui| body(app, ui, &mut d));
// Scrolls only when the last frame's body was taller than the screen.
let room = (ui.ctx().content_rect().height() - 110.0).max(160.0);
let key = id.with("body_height");
let tall = ui.ctx().data(|data| data.get_temp::<f32>(key)).is_some_and(|h| h > room);
let mut content = |ui: &mut egui::Ui| {
let top = ui.cursor().min.y;
close = crate::rtl::root(ui, |ui| body(app, ui, &mut d));
let height = ui.min_rect().max.y - top;
ui.ctx().data_mut(|data| data.insert_temp(key, height));
};
if tall {
egui::ScrollArea::vertical().max_height(room).auto_shrink([true, true]).show(ui, content);
} else {
content(ui);
}
});
if let Some(events) = held {
ctx.input_mut(|i| i.events = events);
@@ -93,6 +93,45 @@ pub const NUMBER_FORMATS: &[(&str, &str)] = &[
("OrdText", "First, Second, Third, …"),
];
/// Capitalization formats for the `\*` switch of a text field: (switch value, label).
pub const TEXT_FORMATS: &[(&str, &str)] =
&[("", "(none)"), ("Upper", "Uppercase"), ("Lower", "Lowercase"), ("FirstCap", "First capital"), ("Caps", "Title case")];
/// Whether the dialog offers the capitalization Format list for `name` (the fields whose result
/// is text).
pub fn takes_text_format(name: &str) -> bool {
matches!(name, "AUTHOR" | "COMMENTS" | "FILENAME" | "KEYWORDS" | "LASTSAVEDBY" | "SUBJECT" | "TITLE" | "REF" | "STYLEREF" | "MERGEFIELD")
}
/// The capitalization switches in a field code, as their [`TEXT_FORMATS`] values, in the order
/// they appear (layout applies them in that order). Quoted text in the code is not a switch.
pub fn text_formats(code: &str) -> Vec<&'static str> {
let mut chars = code.chars().peekable();
let mut quoted = false;
let mut all = Vec::new();
while let Some(c) = chars.next() {
match c {
'\\' if quoted => {
chars.next();
}
'"' => quoted = !quoted,
'\\' if chars.peek() == Some(&'*') => {
chars.next();
while chars.next_if(|c| c.is_whitespace()).is_some() {}
let mut word = String::new();
while let Some(c) = chars.next_if(|c| !c.is_whitespace() && *c != '\\' && *c != '"') {
word.push(c);
}
if let Some((v, _)) = TEXT_FORMATS.iter().find(|(v, _)| !v.is_empty() && v.eq_ignore_ascii_case(&word)) {
all.push(*v);
}
}
_ => {}
}
}
all
}
pub fn field_kind(name: &str) -> FieldKind {
match name {
"DATE" | "TIME" | "CREATEDATE" | "SAVEDATE" | "PRINTDATE" => FieldKind::Date,
@@ -117,6 +156,12 @@ pub struct FieldForm {
pub date_format: String,
/// `\*` value for number fields (empty = none).
pub number_format: String,
/// `\*` capitalization value for text fields (empty = none).
pub text_format: String,
/// Every capitalization switch of the code typed in Field Codes, in order. The code keeps them
/// all while the Format list shows the last of them.
#[serde(skip)]
typed_text_formats: Vec<&'static str>,
/// Bookmark (REF, PAGEREF), sequence name (SEQ), merge field (MERGEFIELD) or style name
/// (STYLEREF).
pub target: String,
@@ -148,6 +193,8 @@ impl FieldForm {
name: "DATE".into(),
date_format: DATE_FORMATS.first().copied().unwrap_or("M/d/yyyy").to_string(),
number_format: String::new(),
text_format: String::new(),
typed_text_formats: Vec::new(),
target: String::new(),
preserve: true,
codes: false,
@@ -178,6 +225,8 @@ impl FieldForm {
pub fn select(&mut self, name: &str) {
self.name = name.to_string();
self.number_format.clear();
self.text_format.clear();
self.typed_text_formats.clear();
self.target = match field_kind(name) {
FieldKind::Bookmark => self.bookmarks.first().cloned().unwrap_or_default(),
FieldKind::Sequence => "Figure".into(),
@@ -230,6 +279,15 @@ impl FieldForm {
if matches!(field_kind(&self.name), FieldKind::Number | FieldKind::Sequence) && !self.number_format.is_empty() {
s.push_str(&format!(" \\* {}", self.number_format));
}
if takes_text_format(&self.name) && !self.text_format.is_empty() {
if self.typed_text_formats.last().is_some_and(|v| *v == self.text_format) {
for v in &self.typed_text_formats {
s.push_str(&format!(" \\* {v}"));
}
} else {
s.push_str(&format!(" \\* {}", self.text_format));
}
}
if self.preserve && field_kind(&self.name) != FieldKind::Toc {
s.push_str(" \\* MERGEFORMAT");
}
@@ -241,6 +299,27 @@ impl FieldForm {
if self.codes { self.code.trim().to_string() } else { self.instruction() }
}
/// The Format list: a choice replaces the capitalization switches kept from a typed code.
pub fn choose_text_format(&mut self, value: &str) {
self.text_format = value.to_string();
self.typed_text_formats.clear();
}
/// Field Codes / Hide Codes: showing the code starts it from the options; hiding it sets the
/// Format list to the code's last capitalization switch when the code is for the chosen field,
/// and keeps all of the code's capitalization switches until another Format is chosen.
pub fn toggle_codes(&mut self) {
if !self.codes {
self.code = self.instruction();
} else if takes_text_format(&self.name)
&& (wordcraft_layout::fields::field_name(&self.code) == self.name || self.name == "MERGEFIELD" && is_merge_field(&self.code))
{
self.typed_text_formats = text_formats(&self.code);
self.text_format = self.typed_text_formats.last().copied().unwrap_or_default().to_string();
}
self.codes = !self.codes;
}
/// The `insert.field` parameters (a merge field shows «name» until merged).
pub fn params(&self) -> Option<Value> {
let code = self.final_code();
@@ -248,13 +327,29 @@ impl FieldForm {
return None;
}
let name = wordcraft_layout::fields::field_name(&code);
Some(if name == "MERGEFIELD" { json!({"instr": code, "result": format!("«{}»", merge_field_name(&code))}) } else { json!({"instr": code}) })
Some(if name == "MERGEFIELD" || is_merge_field(&code) {
json!({"instr": code, "result": format!("«{}»", merge_field_name(&code))})
} else {
json!({"instr": code})
})
}
}
/// The byte where a field code's type ends: at a space or a quote, as mail merge reads it.
fn field_type_end(code: &str) -> usize {
code.find(|c: char| c.is_whitespace() || c == '"').unwrap_or(code.len())
}
/// Whether a typed code is a `MERGEFIELD`, including one with no space before its quoted name.
fn is_merge_field(code: &str) -> bool {
let code = code.trim_start();
code[..field_type_end(code)].eq_ignore_ascii_case("MERGEFIELD")
}
/// The merge field a `MERGEFIELD` code names (quoted names may hold spaces).
fn merge_field_name(code: &str) -> String {
let rest = code.trim_start().split_once(char::is_whitespace).map(|x| x.1.trim_start()).unwrap_or("");
let code = code.trim_start();
let rest = code[field_type_end(code)..].trim_start();
match rest.strip_prefix('"') {
Some(q) => q.split('"').next().unwrap_or("").to_string(),
None => rest.split_whitespace().next().unwrap_or("").to_string(),
@@ -318,10 +413,7 @@ pub(super) fn field_ui(app: &mut WordApp, ui: &mut Ui, f: &mut FieldForm) -> boo
ui.horizontal(|ui| {
let label = if f.codes { "Hide Codes" } else { "Field Codes" };
if ui.button(tl!(label)).clicked() {
if !f.codes {
f.code = f.instruction();
}
f.codes = !f.codes;
f.toggle_codes();
}
});
let params = f.params();
@@ -409,7 +501,21 @@ fn field_options(ui: &mut Ui, f: &mut FieldForm, t: &Tokens) {
}
}
FieldKind::Toc | FieldKind::Plain => {
ui.label(egui::RichText::new(tl!("This field has no options.")).small().color(t.text_dim));
if !takes_text_format(&f.name) {
ui.label(egui::RichText::new(tl!("This field has no options.")).small().color(t.text_dim));
}
}
}
if takes_text_format(&f.name) {
ui.add_space(4.0);
ui.label(tl!("Format:"));
let shown = TEXT_FORMATS.iter().find(|(v, _)| *v == f.text_format).map(|(_, l)| *l).unwrap_or("(none)");
craft_ui::ComboBox::from_id_salt("field_text").selected_text(tl!(shown)).width(200.0).show_ui(ui, |ui| {
for (v, l) in TEXT_FORMATS {
if ui.selectable_label(f.text_format == *v, tl!(l)).clicked() {
f.choose_text_format(v);
}
}
});
}
}
@@ -149,6 +149,141 @@ fn field_dialog_builds_the_instruction() {
assert!(f.params().is_none());
}
/// Text fields take a capitalization Format: each choice writes its `\*` switch before
/// `\* MERGEFORMAT`, after the field's own arguments and switches, and (none) writes none.
#[test]
fn field_dialog_text_format_writes_its_switch() {
let a = app();
let mut f = FieldForm::new(&a);
f.select("AUTHOR");
assert_eq!(f.text_format, "");
assert_eq!(f.instruction(), r"AUTHOR \* MERGEFORMAT");
for v in ["Upper", "Lower", "FirstCap", "Caps"] {
f.text_format = v.into();
assert_eq!(f.instruction(), format!(r"AUTHOR \* {v} \* MERGEFORMAT"));
}
let labels: Vec<&str> = field::TEXT_FORMATS.iter().map(|(_, l)| *l).collect();
assert_eq!(labels, ["(none)", "Uppercase", "Lowercase", "First capital", "Title case"]);
f.select("REF");
f.target = "intro".into();
f.text_format = "Upper".into();
assert_eq!(f.instruction(), r"REF intro \h \* Upper \* MERGEFORMAT");
f.select("STYLEREF");
f.style_switches = "l".into();
f.text_format = "Caps".into();
f.preserve = false;
assert_eq!(f.instruction(), r#"STYLEREF "Heading 1" \l \* Caps"#);
f.select("MERGEFIELD");
f.target = "City".into();
f.text_format = "Lower".into();
assert_eq!(f.params().unwrap(), json!({"instr": r"MERGEFIELD City \* Lower", "result": "«City»"}));
// Choosing another field starts from (none).
f.select("TITLE");
assert_eq!((f.text_format.as_str(), f.instruction().as_str()), ("", "TITLE"));
}
/// The list is offered for the text fields only; date, number, PAGEREF, SEQ and TOC keep their
/// own options and never take a capitalization switch from it.
#[test]
fn field_dialog_text_format_is_for_text_fields_only() {
for name in ["AUTHOR", "COMMENTS", "FILENAME", "KEYWORDS", "LASTSAVEDBY", "SUBJECT", "TITLE", "REF", "STYLEREF", "MERGEFIELD"] {
assert!(field::takes_text_format(name), "{name}");
}
let a = app();
let mut f = FieldForm::new(&a);
for name in ["DATE", "PAGE", "NUMPAGES", "PAGEREF", "SEQ", "TOC"] {
assert!(!field::takes_text_format(name), "{name}");
f.select(name);
let before = f.instruction();
f.text_format = "Upper".into();
assert_eq!(f.instruction(), before, "{name}");
}
}
/// Hide Codes sets the Format list from the typed code's last capitalization switch outside
/// quotes, and to (none) when the code has none.
#[test]
fn field_dialog_text_format_follows_the_typed_code() {
assert_eq!(field::text_formats(r#"AUTHOR "a \* Lower" \* upper \* Caps \* MERGEFORMAT"#), ["Upper", "Caps"]);
assert!(field::text_formats(r#"MERGEFIELD "x \* FirstCap""#).is_empty());
assert!(field::text_formats(r"PAGE \* roman").is_empty());
let a = app();
let mut f = FieldForm::new(&a);
f.select("SUBJECT");
f.toggle_codes();
assert_eq!(f.code, r"SUBJECT \* MERGEFORMAT");
f.code = r"SUBJECT \* FIRSTCAP \* MERGEFORMAT".into();
f.toggle_codes();
assert!(!f.codes);
assert_eq!(f.instruction(), r"SUBJECT \* FirstCap \* MERGEFORMAT");
f.toggle_codes();
f.code = "SUBJECT".into();
f.toggle_codes();
assert_eq!(f.text_format, "");
// A code for another field leaves the list as it was.
f.text_format = "Lower".into();
f.toggle_codes();
f.code = r"TITLE \* Upper".into();
f.toggle_codes();
assert_eq!(f.text_format, "Lower");
}
/// Hide Codes keeps every capitalization switch of the typed code, in order, so the inserted field
/// shows what the typed code shows; choosing another Format writes that one switch only.
#[test]
fn field_dialog_text_format_keeps_every_typed_case_switch() {
use wordcraft_layout::fields::apply_case_switch;
let a = app();
let mut f = FieldForm::new(&a);
f.select("SUBJECT");
f.toggle_codes();
f.code = r"SUBJECT \* Lower \* Caps".into();
let typed = apply_case_switch(&f.code, "WEEKLY REPORT".into());
assert_eq!(typed, "Weekly Report");
f.toggle_codes();
assert_eq!(f.text_format, "Caps");
assert_eq!(f.final_code(), r"SUBJECT \* Lower \* Caps \* MERGEFORMAT");
assert_eq!(apply_case_switch(&f.final_code(), "WEEKLY REPORT".into()), typed);
// Field Codes shows the same switches again.
f.toggle_codes();
assert_eq!(f.code, r"SUBJECT \* Lower \* Caps \* MERGEFORMAT");
f.toggle_codes();
// A Format the user chooses replaces the typed switches, and choosing Title case again
// does not bring them back.
f.choose_text_format("Upper");
assert_eq!(f.final_code(), r"SUBJECT \* Upper \* MERGEFORMAT");
f.choose_text_format("Caps");
assert_eq!(f.final_code(), r"SUBJECT \* Caps \* MERGEFORMAT");
f.choose_text_format("");
assert_eq!(f.final_code(), r"SUBJECT \* MERGEFORMAT");
// Choosing another field forgets them.
f.toggle_codes();
f.code = r"SUBJECT \* Lower \* Caps".into();
f.toggle_codes();
f.select("SUBJECT");
f.text_format = "Caps".into();
assert_eq!(f.final_code(), r"SUBJECT \* Caps \* MERGEFORMAT");
}
/// A typed `MERGEFIELD` code's type ends at a quote as well as a space, as mail merge reads it.
#[test]
fn field_dialog_reads_a_typed_merge_field_with_no_space_before_its_quote() {
let a = app();
let mut f = FieldForm::new(&a);
f.select("MERGEFIELD");
f.toggle_codes();
f.code = r#"MERGEFIELD"City" \* Lower"#.into();
assert_eq!(f.params().unwrap()["result"], "«City»");
f.toggle_codes();
assert_eq!(f.text_format, "Lower");
// Another field whose name only starts the same way is not this one.
f.choose_text_format("");
f.toggle_codes();
f.code = r"MERGEFIELDX \* Lower".into();
f.toggle_codes();
assert_eq!(f.text_format, "");
}
/// The Field dialog lists Word's document information fields, and the counts take a number
/// format.
#[test]
+22 -3
View File
@@ -234,8 +234,9 @@ pub fn customize_keyboard(app: &mut WordApp, ui: &mut Ui, f: &mut KeyboardForm)
}
});
crate::rtl::vertical(ui, |ui| {
ui.label(tl!("New shortcut:"));
close = capture(ui, f);
let label = tl!("New shortcut:");
ui.label(label);
close = capture(ui, f, label);
ui.add_space(4.0);
if !f.pressed.is_empty() {
let owner = match app.session.keymap.resolve(&reg, &f.pressed) {
@@ -291,7 +292,7 @@ pub fn customize_keyboard(app: &mut WordApp, ui: &mut Ui, f: &mut KeyboardForm)
/// The "New shortcut" box: takes keyboard focus and records the combination pressed.
/// True when plain Escape asks to close the dialog.
fn capture(ui: &mut Ui, f: &mut KeyboardForm) -> bool {
fn capture(ui: &mut Ui, f: &mut KeyboardForm, label: &str) -> bool {
let t = Tokens::get(ui.ctx());
let (rect, resp) = ui.allocate_exact_size(vec2(300.0, 26.0), Sense::click());
// Keys belong to the box whenever nothing else in the dialog has focus, so a shortcut pressed
@@ -312,6 +313,8 @@ fn capture(ui: &mut Ui, f: &mut KeyboardForm) -> bool {
f.pressed = k;
}
}
resp.widget_info(|| egui::WidgetInfo::labeled(egui::Role::TextInput, ui.is_enabled(), label));
ui.ctx().accesskit_node_builder(resp.id, |node| node.set_value(key_text(&f.pressed)));
let stroke = egui::Stroke::new(if focused { 1.5 } else { 1.0 }, if focused { t.accent } else { t.input_border });
ui.painter().rect(rect, 2.0, t.input, stroke, egui::StrokeKind::Inside);
let (text, color) = if f.pressed.is_empty() { (tl!("Press a key combination").to_string(), t.text_dim) } else { (key_text(&f.pressed), t.text) };
@@ -416,6 +419,22 @@ mod tests {
h
}
/// The shortcut capture field has a name and reports the combination it records.
#[test]
fn shortcut_capture_exposes_its_name_and_current_value() {
use egui::accesskit::Role;
use egui_kittest::kittest::Queryable;
let mut h = harness("", Some("format.bold"));
let input = h.get_by_role_and_label(Role::TextInput, "New shortcut:");
assert_eq!(input.value().as_deref(), Some(""));
input.focus();
h.run_steps(2);
h.key_press(egui::Key::F6);
h.run_steps(2);
assert_eq!(h.state().1.pressed, "F6");
assert_eq!(h.get_by_role_and_label(Role::TextInput, "New shortcut:").value().as_deref(), Some("F6"));
}
type KbHarness<'a> = egui_kittest::Harness<'a, (WordApp, super::KeyboardForm)>;
/// The area of the Commands list that is on screen: 170 high, below the title, the item
@@ -1,4 +1,4 @@
use super::{MeasureExt, Serialize, Ui, Value, WordApp, buttons, fit_size, heading, json, run, unit, vec2};
use super::{MeasureExt, Serialize, Ui, Value, WordApp, buttons, fit_size, json, run, unit, vec2};
// ---------------------------------------------------------------------------------------------
// Size
@@ -163,46 +163,49 @@ pub(super) fn size_ui(app: &mut WordApp, ui: &mut Ui, f: &mut SizeForm) -> bool
let changed = r.cell(|ui| ui.add(field.update_while_editing(false)).labelled_by(name.id).changed());
(changed && v != was).then_some(v)
};
heading(ui, "Size");
crate::rtl::Table::new("size_lengths").columns(4).spacing(vec2(10.0, 6.0)).show(ui, |t| {
t.row(|r| {
if let Some(h) = length(r, "Height:", f.height) {
f.set_height(h);
}
if let Some(w) = length(r, "Width:", f.width) {
f.set_width(w);
}
crate::widgets::section(ui, tl!("Size"), |ui| {
crate::rtl::Table::new("size_lengths").columns(4).spacing(vec2(10.0, 6.0)).show(ui, |t| {
t.row(|r| {
if let Some(h) = length(r, "Height:", f.height) {
f.set_height(h);
}
if let Some(w) = length(r, "Width:", f.width) {
f.set_width(w);
}
});
});
});
heading(ui, "Scale");
let (sw, sh) = f.scale();
crate::rtl::Table::new("size_scale").columns(4).spacing(vec2(10.0, 6.0)).show(ui, |t| {
t.row(|r| {
if let Some(p) = percent(r, "Height:", sh) {
f.set_scale_height(p);
}
if let Some(w) = percent(r, "Width:", sw) {
f.set_scale_width(w);
}
crate::widgets::section(ui, tl!("Scale"), |ui| {
let (sw, sh) = f.scale();
crate::rtl::Table::new("size_scale").columns(4).spacing(vec2(10.0, 6.0)).show(ui, |t| {
t.row(|r| {
if let Some(p) = percent(r, "Height:", sh) {
f.set_scale_height(p);
}
if let Some(w) = percent(r, "Width:", sw) {
f.set_scale_width(w);
}
});
});
ui.checkbox(&mut f.lock, tl!("Lock aspect ratio"));
ui.add_enabled_ui(f.original.is_some(), |ui| ui.checkbox(&mut f.relative, tl!("Relative to original picture size")));
});
ui.checkbox(&mut f.lock, tl!("Lock aspect ratio"));
ui.add_enabled_ui(f.original.is_some(), |ui| ui.checkbox(&mut f.relative, tl!("Relative to original picture size")));
if let Some((w, h)) = f.uncropped {
heading(ui, "Original size");
ui.horizontal(|ui| {
ui.label(format!("{} {}", tl!("Height:"), crate::options::length(h)));
ui.add_space(12.0);
ui.label(format!("{} {}", tl!("Width:"), crate::options::length(w)));
if let Some((pw, ph)) = f.pixels {
crate::widgets::section(ui, tl!("Original size"), |ui| {
ui.horizontal(|ui| {
ui.label(format!("{} {}", tl!("Height:"), crate::options::length(h)));
ui.add_space(12.0);
let (pw, ph) = (pw.to_string(), ph.to_string());
ui.weak(crate::i18n::fmt(tl!("{width} × {height} pixels"), &[("width", &pw), ("height", &ph)]));
}
ui.add_space(12.0);
if ui.button(tl!("Reset")).clicked() {
f.reset();
}
ui.label(format!("{} {}", tl!("Width:"), crate::options::length(w)));
if let Some((pw, ph)) = f.pixels {
ui.add_space(12.0);
let (pw, ph) = (pw.to_string(), ph.to_string());
ui.weak(crate::i18n::fmt(tl!("{width} × {height} pixels"), &[("width", &pw), ("height", &ph)]));
}
ui.add_space(12.0);
if ui.button(tl!("Reset")).clicked() {
f.reset();
}
});
});
}
let (ok, cancel) = buttons(ui, "OK", true);
@@ -268,11 +271,12 @@ pub(super) fn page_numbers_ui(app: &mut WordApp, ui: &mut Ui, f: &mut PageNumber
ui.selectable_value(&mut f.format, v.to_string(), l);
}
});
heading(ui, "Page numbering");
ui.radio_value(&mut f.cont, true, tl!("Continue from previous section"));
ui.horizontal(|ui| {
ui.radio_value(&mut f.cont, false, tl!("Start at:"));
ui.add_enabled(!f.cont, egui::DragValue::new(&mut f.start).range(1..=100_000));
crate::widgets::section(ui, tl!("Page numbering"), |ui| {
ui.radio_value(&mut f.cont, true, tl!("Continue from previous section"));
ui.horizontal(|ui| {
ui.radio_value(&mut f.cont, false, tl!("Start at:"));
ui.add_enabled(!f.cont, egui::DragValue::new(&mut f.start).range(1..=100_000));
});
});
let (ok, cancel) = buttons(ui, "OK", true);
if ok {
@@ -1,4 +1,4 @@
use super::{ENVELOPE_SIZES, LABEL_PRODUCTS, Serialize, Ui, Value, WordApp, buttons, heading, json, run};
use super::{ENVELOPE_SIZES, LABEL_PRODUCTS, Serialize, Ui, Value, WordApp, buttons, json, run};
// ---------------------------------------------------------------------------------------------
// Envelopes
@@ -163,15 +163,16 @@ pub(super) fn labels_ui(app: &mut WordApp, ui: &mut Ui, f: &mut LabelsForm) -> b
});
});
let (rows, cols) = LABEL_PRODUCTS.get(f.product).map_or((1, 1), |p| (p.rows, p.cols));
heading(ui, "Print");
ui.radio_value(&mut f.single, false, tl!("Full page of the same label"));
ui.horizontal(|ui| {
ui.radio_value(&mut f.single, true, tl!("Single label"));
ui.add_enabled_ui(f.single, |ui| {
ui.label(tl!("Row:"));
ui.add(egui::DragValue::new(&mut f.row).range(1..=rows));
ui.label(tl!("Column:"));
ui.add(egui::DragValue::new(&mut f.col).range(1..=cols));
crate::widgets::section(ui, tl!("Print"), |ui| {
ui.radio_value(&mut f.single, false, tl!("Full page of the same label"));
ui.horizontal(|ui| {
ui.radio_value(&mut f.single, true, tl!("Single label"));
ui.add_enabled_ui(f.single, |ui| {
ui.label(tl!("Row:"));
ui.add(egui::DragValue::new(&mut f.row).range(1..=rows));
ui.label(tl!("Column:"));
ui.add(egui::DragValue::new(&mut f.col).range(1..=cols));
});
});
});
f.row = f.row.clamp(1, rows.max(1));
@@ -118,23 +118,25 @@ impl SortForm {
}
pub(super) fn sort_ui(app: &mut WordApp, ui: &mut Ui, f: &mut SortForm) -> bool {
heading(ui, "Sort by");
ui.horizontal(|ui| {
craft_ui::ComboBox::from_id_salt("sort_column").selected_text(f.column_label(f.column)).width(180.0).show_ui(ui, |ui| {
for i in 0..f.headers.len() {
let label = f.column_label(i);
ui.selectable_value(&mut f.column, i, label);
}
});
crate::rtl::vertical(ui, |ui| {
ui.radio_value(&mut f.descending, false, tl!("Ascending"));
ui.radio_value(&mut f.descending, true, tl!("Descending"));
crate::widgets::section(ui, tl!("Sort by"), |ui| {
ui.horizontal(|ui| {
craft_ui::ComboBox::from_id_salt("sort_column").selected_text(f.column_label(f.column)).width(180.0).show_ui(ui, |ui| {
for i in 0..f.headers.len() {
let label = f.column_label(i);
ui.selectable_value(&mut f.column, i, label);
}
});
crate::rtl::vertical(ui, |ui| {
ui.radio_value(&mut f.descending, false, tl!("Ascending"));
ui.radio_value(&mut f.descending, true, tl!("Descending"));
});
});
});
heading(ui, "My list has");
ui.horizontal(|ui| {
ui.radio_value(&mut f.header, true, tl!("Header row"));
ui.radio_value(&mut f.header, false, tl!("No header row"));
crate::widgets::section(ui, tl!("My list has"), |ui| {
ui.horizontal(|ui| {
ui.radio_value(&mut f.header, true, tl!("Header row"));
ui.radio_value(&mut f.header, false, tl!("No header row"));
});
});
let (ok, cancel) = buttons(ui, "OK", true);
if ok {
@@ -380,39 +382,42 @@ impl TextToTableForm {
pub(super) fn text_to_table_ui(app: &mut WordApp, ui: &mut Ui, f: &mut TextToTableForm) -> bool {
let before = (f.separator.clone(), f.other_char.clone(), f.columns);
heading(ui, "Table size");
crate::rtl::Table::new("text_to_table").columns(2).show(ui, |t| {
t.row(|r| {
r.cell(|ui| ui.label(tl!("Number of columns:")));
r.cell(|ui| ui.add(egui::DragValue::new(&mut f.columns).range(1..=63)));
});
t.row(|r| {
r.cell(|ui| ui.label(tl!("Number of rows:")));
r.cell(|ui| ui.label(f.rows.to_string()));
crate::widgets::section(ui, tl!("Table size"), |ui| {
crate::rtl::Table::new("text_to_table").columns(2).show(ui, |t| {
t.row(|r| {
r.cell(|ui| ui.label(tl!("Number of columns:")));
r.cell(|ui| ui.add(egui::DragValue::new(&mut f.columns).range(1..=63)));
});
t.row(|r| {
r.cell(|ui| ui.label(tl!("Number of rows:")));
r.cell(|ui| ui.label(f.rows.to_string()));
});
});
});
heading(ui, "AutoFit behavior");
ui.horizontal(|ui| {
ui.radio_value(&mut f.autofit, "initial".to_string(), tl!("Initial column width:"));
ui.add_enabled(f.autofit == "initial", egui::TextEdit::singleline(&mut f.width).desired_width(72.0));
});
ui.radio_value(&mut f.autofit, "contents".to_string(), tl!("AutoFit to contents"));
ui.radio_value(&mut f.autofit, "window".to_string(), tl!("AutoFit to window"));
heading(ui, "Separate text at");
crate::rtl::Table::new("text_to_table_sep").columns(2).show(ui, |t| {
t.row(|r| {
r.cell(|ui| ui.radio_value(&mut f.separator, "paragraph".to_string(), tl!("Paragraphs")));
r.cell(|ui| ui.radio_value(&mut f.separator, "comma".to_string(), tl!("Commas")));
crate::widgets::section(ui, tl!("AutoFit behavior"), |ui| {
ui.horizontal(|ui| {
ui.radio_value(&mut f.autofit, "initial".to_string(), tl!("Initial column width:"));
ui.add_enabled(f.autofit == "initial", egui::TextEdit::singleline(&mut f.width).desired_width(72.0));
});
t.row(|r| {
r.cell(|ui| ui.radio_value(&mut f.separator, "tab".to_string(), tl!("Tabs")));
r.cell(|ui| {
ui.horizontal(|ui| {
ui.radio_value(&mut f.separator, "other".to_string(), tl!("Other:"));
let edit = ui.add(egui::TextEdit::singleline(&mut f.other_char).char_limit(1).desired_width(24.0));
if edit.changed() {
f.separator = "other".into();
}
ui.radio_value(&mut f.autofit, "contents".to_string(), tl!("AutoFit to contents"));
ui.radio_value(&mut f.autofit, "window".to_string(), tl!("AutoFit to window"));
});
crate::widgets::section(ui, tl!("Separate text at"), |ui| {
crate::rtl::Table::new("text_to_table_sep").columns(2).show(ui, |t| {
t.row(|r| {
r.cell(|ui| ui.radio_value(&mut f.separator, "paragraph".to_string(), tl!("Paragraphs")));
r.cell(|ui| ui.radio_value(&mut f.separator, "comma".to_string(), tl!("Commas")));
});
t.row(|r| {
r.cell(|ui| ui.radio_value(&mut f.separator, "tab".to_string(), tl!("Tabs")));
r.cell(|ui| {
ui.horizontal(|ui| {
ui.radio_value(&mut f.separator, "other".to_string(), tl!("Other:"));
let edit = ui.add(egui::TextEdit::singleline(&mut f.other_char).char_limit(1).desired_width(24.0));
if edit.changed() {
f.separator = "other".into();
}
});
});
});
});
@@ -208,7 +208,14 @@ fn language_dialog_default_survives_a_restart() {
use egui_kittest::kittest::Queryable;
let mut a = app();
a.ui.language = "en".into();
a.dialog = Some(Dialog::Layout(Box::new(LayoutDialog::Language(LanguageForm { lang: "fr-FR".into(), no_proof: false, detect: false }))));
a.dialog = Some(Dialog::Layout(Box::new(LayoutDialog::Language(LanguageForm {
lang: "fr-FR".into(),
no_proof: false,
detect: false,
whole_document: false,
initial: ("fr-FR".into(), false),
proof_touched: false,
}))));
let mut h = egui_kittest::Harness::builder().with_size(egui::vec2(1440.0, 900.0)).build_ui_state(
|ui, app: &mut WordApp| {
app.logic(&ui.ctx().clone());
@@ -232,6 +239,143 @@ fn language_dialog_default_survives_a_restart() {
assert_eq!(LanguageForm::read(&b).lang, "fr-FR");
}
/// #3518: ticking "Apply to the whole document" makes OK send `scope: "document"`; unticked sends none.
#[test]
fn language_dialog_whole_document_checkbox_sends_scope() {
use egui_kittest::kittest::Queryable;
let f = LanguageForm {
lang: "fr-FR".into(),
no_proof: false,
detect: false,
whole_document: false,
initial: ("fr-FR".into(), false),
proof_touched: false,
};
assert!(f.params().get("scope").is_none());
assert_eq!(LanguageForm { whole_document: true, ..f.clone() }.params()["scope"], "document");
let mut a = app();
a.ui.language = "en".into();
let para = wordcraft_doc::Paragraph::with_text("Header", Default::default());
let header = a.session.doc.add_part(wordcraft_doc::PartKind::Header, vec![Arc::new(wordcraft_doc::Block::Para(para))]);
a.dialog = Some(Dialog::Layout(Box::new(LayoutDialog::Language(f))));
let mut h = egui_kittest::Harness::builder().with_size(egui::vec2(1440.0, 900.0)).build_ui_state(
|ui, app: &mut WordApp| {
app.logic(&ui.ctx().clone());
app.ui(ui);
},
a,
);
h.run_steps(3);
h.get_by_label("Apply to the whole document").click();
h.run_steps(3);
h.get_by_label("OK").click();
h.run_steps(3);
// The header, which the caret isn't in, took the language.
let doc = &h.state().session.doc;
let hp = doc.para(wordcraft_doc::StoryRef::Part(header), &wordcraft_doc::Path::top(0)).unwrap();
assert_eq!(hp.runs.first().and_then(|r| r.props.lang.as_deref()), Some("fr-FR"));
}
/// "Plain text, then a Do-not-check run", the caret in the plain text.
fn proofing_mix_app() -> WordApp {
let mut a = app();
a.run("text.insert", json!({"text": "Plain code"})).unwrap();
a.run("select.text", json!({"text": "code"})).unwrap();
a.run("review.language", json!({"lang": "de-DE", "noProof": true})).unwrap();
a.run("select.text", json!({"text": "Plain"})).unwrap();
a.run("review.language", json!({"lang": "en-US", "noProof": false})).unwrap();
a.run("select.text", json!({"text": "Plain"})).unwrap();
a
}
fn run_proofing(a: &mut WordApp, text: &str) -> (Option<String>, Option<bool>) {
a.run("select.text", json!({"text": text})).unwrap();
let st = a.run("format.state", json!({})).unwrap();
(st["lang"].as_str().map(String::from), st["noProof"].as_bool())
}
/// #3518: whole-document OK sends only what the user changed.
#[test]
fn language_dialog_whole_document_sends_only_changes() {
// Changing only the language leaves the Do-not-check run alone.
let mut a = proofing_mix_app();
let mut f = LanguageForm::read(&a);
f.whole_document = true;
f.lang = "en-GB".into();
let p = f.params();
assert!(p.get("noProof").is_none());
a.run("review.language", p).unwrap();
assert_eq!(run_proofing(&mut a, "code"), (Some("en-GB".into()), Some(true)));
assert_eq!(run_proofing(&mut a, "Plain"), (Some("en-GB".into()), Some(false)));
// Changing only Do-not-check leaves each run's language alone.
let mut a = proofing_mix_app();
let mut f = LanguageForm::read(&a);
f.whole_document = true;
f.no_proof = true;
f.proof_touched = true;
let p = f.params();
assert!(p.get("lang").is_none());
a.run("review.language", p).unwrap();
assert_eq!(run_proofing(&mut a, "code"), (Some("de-DE".into()), Some(true)));
assert_eq!(run_proofing(&mut a, "Plain"), (Some("en-US".into()), Some(true)));
// No edits: the caret's language, no noProof (never the engine's en-US default).
let mut a = proofing_mix_app();
let mut f = LanguageForm::read(&a);
f.lang = "fr-FR".into();
f.initial.0 = "fr-FR".into();
f.whole_document = true;
let p = f.params();
assert_eq!(p["lang"], "fr-FR");
assert!(p.get("noProof").is_none());
a.run("review.language", p).unwrap();
assert_eq!(run_proofing(&mut a, "code"), (Some("fr-FR".into()), Some(true)));
// Selection mode is unchanged: both are sent.
f.whole_document = false;
assert_eq!(f.params()["noProof"], false);
}
/// #3518: a ticked Do-not-check box the user did not change (the caret sits in a no-proof run)
/// is not sent, so a language-only whole-document apply leaves other runs' proofing state alone.
#[test]
fn language_dialog_whole_document_unchanged_no_proof_is_not_sent() {
let mut a = proofing_mix_app();
a.run("select.text", json!({"text": "code"})).unwrap();
let mut f = LanguageForm::read(&a);
assert!(f.no_proof && f.initial.1);
f.whole_document = true;
f.lang = "en-GB".into();
let p = f.params();
assert!(p.get("noProof").is_none(), "{p}");
a.run("review.language", p).unwrap();
assert_eq!(run_proofing(&mut a, "code"), (Some("en-GB".into()), Some(true)));
assert_eq!(run_proofing(&mut a, "Plain"), (Some("en-GB".into()), Some(false)));
}
/// #3518: with the caret in a no-proof run, ticking the whole-document box and clicking Do not
/// check off and on again (ending ticked) still marks the whole document no-proof.
#[test]
fn language_dialog_whole_document_retoggled_no_proof_is_sent() {
let mut a = proofing_mix_app();
a.run("select.text", json!({"text": "code"})).unwrap();
let mut f = LanguageForm::read(&a);
assert!(f.no_proof && f.initial.1 && !f.proof_touched);
f.whole_document = true;
for _ in 0..2 {
f.no_proof = !f.no_proof;
f.proof_touched = true;
}
assert!(f.no_proof);
let p = f.params();
assert_eq!(p["noProof"], true, "{p}");
assert!(p.get("lang").is_none(), "{p}");
a.run("review.language", p).unwrap();
assert_eq!(run_proofing(&mut a, "Plain"), (Some("en-US".into()), Some(true)));
assert_eq!(run_proofing(&mut a, "code"), (Some("de-DE".into()), Some(true)));
}
/// #407: Envelopes starts from the selected address; Add to Document puts an envelope
/// section before the letter without asking to save (nothing is replaced).
#[test]
@@ -320,6 +320,16 @@ pub struct LanguageForm {
pub lang: String,
pub no_proof: bool,
pub detect: bool,
/// "Apply to the whole document": OK sends `scope: "document"` (every story), not the selection.
pub whole_document: bool,
/// The language and Do-not-check state the dialog opened with, to tell what the user changed.
#[serde(skip)]
pub initial: (String, bool),
/// The Do-not-check box was clicked (even back to where it started). A whole-document OK sends
/// `noProof` only then: the caret's value alone says nothing about runs that differ elsewhere,
/// but a click is a request to mark the whole document that way (#3518).
#[serde(skip)]
pub proof_touched: bool,
}
impl LanguageForm {
@@ -328,12 +338,36 @@ impl LanguageForm {
let style = s.doc.para_at(&s.sel.focus).and_then(|p| p.props.style.as_deref());
let here = s.doc.styles.resolve_char(style, &s.typing_props());
let lang = here.lang.unwrap_or_else(|| "en-US".into());
LanguageForm { lang, no_proof: here.no_proof, detect: s.prefs.detect_language }
LanguageForm {
initial: (lang.clone(), here.no_proof),
lang,
no_proof: here.no_proof,
detect: s.prefs.detect_language,
whole_document: false,
proof_touched: false,
}
}
/// `review.language` parameters for OK.
pub fn params(&self) -> Value {
json!({"lang": self.lang, "noProof": self.no_proof, "detect": self.detect})
if !self.whole_document {
return json!({"lang": self.lang, "noProof": self.no_proof, "detect": self.detect});
}
// Whole document: the caret's values must not flatten what differs elsewhere, so send only
// what was changed. With no edits at all the language goes (never the engine's en-US default).
let (lang_changed, proof_touched) = (self.lang != self.initial.0, self.proof_touched);
let mut v = json!({"scope": "document", "detect": self.detect});
if let Some(m) = v.as_object_mut() {
if lang_changed || !proof_touched {
m.insert("lang".into(), json!(self.lang));
}
// Only a clicked box is sent: the caret's value untouched says nothing about runs that
// differ elsewhere, and resending it would flatten them.
if proof_touched {
m.insert("noProof".into(), json!(self.no_proof));
}
}
v
}
}
@@ -343,7 +377,7 @@ pub(super) fn language_name(tag: &str) -> String {
}
pub(super) fn language_ui(app: &mut WordApp, ui: &mut Ui, f: &mut LanguageForm) -> bool {
ui.label(tl!("Mark selected text as:"));
ui.label(if f.whole_document { tl!("Mark the whole document as:") } else { tl!("Mark selected text as:") });
let list = crate::ribbon::language_list(&f.lang);
egui::Frame::NONE.stroke(egui::Stroke::new(1.0, crate::theme::Tokens::get(ui.ctx()).border_strong)).inner_margin(4.0).show(ui, |ui| {
egui::ScrollArea::vertical().max_height(220.0).min_scrolled_height(220.0).show(ui, |ui| {
@@ -358,8 +392,11 @@ pub(super) fn language_ui(app: &mut WordApp, ui: &mut Ui, f: &mut LanguageForm)
});
});
ui.add_space(4.0);
ui.checkbox(&mut f.no_proof, tl!("Do not check spelling or grammar"));
if ui.checkbox(&mut f.no_proof, tl!("Do not check spelling or grammar")).clicked() {
f.proof_touched = true;
}
ui.checkbox(&mut f.detect, tl!("Detect language automatically"));
ui.checkbox(&mut f.whole_document, tl!("Apply to the whole document"));
ui.add_space(4.0);
let set_default = ui.button(tl!("Set As Default")).clicked();
if set_default && run(app, "review.language", json!({"lang": f.lang, "default": true, "detect": f.detect})) {
+60 -59
View File
@@ -534,69 +534,70 @@ const MOVE_TO_MARKS: &[(&str, &str)] = &[
/// Track Changes Options. Returns true to close.
pub fn track_options(app: &mut WordApp, ui: &mut Ui, f: &mut TrackForm) -> bool {
let theme = app.session.doc.settings.theme_colors.clone();
let heading = |ui: &mut Ui, s: &str| {
ui.add_space(4.0);
ui.label(egui::RichText::new(tl!(s)).font(semibold(12.5)));
};
heading(ui, "Show");
crate::rtl::Table::new("tco_show").columns(2).spacing(vec2(16.0, 4.0)).show(ui, |t| {
t.row(|r| {
r.cell(|ui| ui.checkbox(&mut f.comments, tl!("Comments")));
r.cell(|ui| ui.checkbox(&mut f.ink, tl!("Ink")));
});
t.row(|r| {
r.cell(|ui| ui.checkbox(&mut f.insertions_deletions, tl!("Insertions and Deletions")));
r.cell(|ui| ui.checkbox(&mut f.formatting, tl!("Formatting")));
});
});
heading(ui, "Balloons");
for (v, l) in [
("revisions", "Show revisions in balloons"),
("inline", "Show all revisions inline"),
("commentsAndFormatting", "Show only comments and formatting in balloons"),
] {
ui.radio_value(&mut f.balloons, v.to_string(), tl!(l));
}
heading(ui, "Comments");
for (v, l) in [("margin", "In the margin"), ("selected", "Only for the selected text")] {
ui.radio_value(&mut f.comment_display, v.to_string(), tl!(l));
}
heading(ui, "Advanced");
crate::rtl::Table::new("tco_advanced").columns(3).spacing(vec2(10.0, 6.0)).show(ui, |t| {
t.row(|r| {
r.cell(|ui| ui.label(tl!("Insertions:")));
r.cell(|ui| choice(ui, "tco_ins", &mut f.insert_mark, INSERT_MARKS));
r.cell(|ui| color(ui, &theme, &mut f.insert_color, "By author", None));
});
t.row(|r| {
r.cell(|ui| ui.label(tl!("Deletions:")));
r.cell(|ui| choice(ui, "tco_del", &mut f.delete_mark, DELETE_MARKS));
r.cell(|ui| color(ui, &theme, &mut f.delete_color, "By author", None));
});
t.row(|r| {
r.cell(|ui| ui.label(tl!("Changed lines:")));
r.cell(|ui| {
choice(
ui,
"tco_bar",
&mut f.changed_lines,
&[("outside", "Outside border"), ("left", "Left border"), ("right", "Right border"), ("none", "None")],
)
crate::widgets::section(ui, tl!("Show"), |ui| {
crate::rtl::Table::new("tco_show").columns(2).spacing(vec2(16.0, 4.0)).show(ui, |t| {
t.row(|r| {
r.cell(|ui| ui.checkbox(&mut f.comments, tl!("Comments")));
r.cell(|ui| ui.checkbox(&mut f.ink, tl!("Ink")));
});
t.row(|r| {
r.cell(|ui| ui.checkbox(&mut f.insertions_deletions, tl!("Insertions and Deletions")));
r.cell(|ui| ui.checkbox(&mut f.formatting, tl!("Formatting")));
});
r.cell(|ui| color(ui, &theme, &mut f.changed_lines_color, "Automatic", Some(wordcraft_layout::display::CHANGE_BAR)));
});
});
heading(ui, "Moves");
crate::rtl::Table::new("tco_moves").columns(3).spacing(vec2(10.0, 6.0)).show(ui, |t| {
t.row(|r| {
r.cell(|ui| ui.label(tl!("Moved from:")));
r.cell(|ui| choice(ui, "tco_move_from", &mut f.move_from_mark, DELETE_MARKS));
r.cell(|ui| ui.push_id("tco_move_from_color", |ui| color(ui, &theme, &mut f.move_from_color, "By author", None)));
crate::widgets::section(ui, tl!("Balloons"), |ui| {
for (v, l) in [
("revisions", "Show revisions in balloons"),
("inline", "Show all revisions inline"),
("commentsAndFormatting", "Show only comments and formatting in balloons"),
] {
ui.radio_value(&mut f.balloons, v.to_string(), tl!(l));
}
});
crate::widgets::section(ui, tl!("Comments"), |ui| {
for (v, l) in [("margin", "In the margin"), ("selected", "Only for the selected text")] {
ui.radio_value(&mut f.comment_display, v.to_string(), tl!(l));
}
});
crate::widgets::section(ui, tl!("Advanced"), |ui| {
crate::rtl::Table::new("tco_advanced").columns(3).spacing(vec2(10.0, 6.0)).show(ui, |t| {
t.row(|r| {
r.cell(|ui| ui.label(tl!("Insertions:")));
r.cell(|ui| choice(ui, "tco_ins", &mut f.insert_mark, INSERT_MARKS));
r.cell(|ui| color(ui, &theme, &mut f.insert_color, "By author", None));
});
t.row(|r| {
r.cell(|ui| ui.label(tl!("Deletions:")));
r.cell(|ui| choice(ui, "tco_del", &mut f.delete_mark, DELETE_MARKS));
r.cell(|ui| color(ui, &theme, &mut f.delete_color, "By author", None));
});
t.row(|r| {
r.cell(|ui| ui.label(tl!("Changed lines:")));
r.cell(|ui| {
choice(
ui,
"tco_bar",
&mut f.changed_lines,
&[("outside", "Outside border"), ("left", "Left border"), ("right", "Right border"), ("none", "None")],
)
});
r.cell(|ui| color(ui, &theme, &mut f.changed_lines_color, "Automatic", Some(wordcraft_layout::display::CHANGE_BAR)));
});
});
t.row(|r| {
r.cell(|ui| ui.label(tl!("Moved to:")));
r.cell(|ui| choice(ui, "tco_move_to", &mut f.move_to_mark, MOVE_TO_MARKS));
r.cell(|ui| ui.push_id("tco_move_to_color", |ui| color(ui, &theme, &mut f.move_to_color, "By author", None)));
});
crate::widgets::section(ui, tl!("Moves"), |ui| {
crate::rtl::Table::new("tco_moves").columns(3).spacing(vec2(10.0, 6.0)).show(ui, |t| {
t.row(|r| {
r.cell(|ui| ui.label(tl!("Moved from:")));
r.cell(|ui| choice(ui, "tco_move_from", &mut f.move_from_mark, DELETE_MARKS));
r.cell(|ui| ui.push_id("tco_move_from_color", |ui| color(ui, &theme, &mut f.move_from_color, "By author", None)));
});
t.row(|r| {
r.cell(|ui| ui.label(tl!("Moved to:")));
r.cell(|ui| choice(ui, "tco_move_to", &mut f.move_to_mark, MOVE_TO_MARKS));
r.cell(|ui| ui.push_id("tco_move_to_color", |ui| color(ui, &theme, &mut f.move_to_color, "By author", None)));
});
});
});
ui.add_space(4.0);
+71 -73
View File
@@ -8,7 +8,6 @@ use serde::Serialize;
use serde_json::{Value, json};
use crate::WordApp;
use crate::theme::semibold;
/// Number formats notes offer: OOXML name and a sample (not translated). The Format Page Numbers
/// dialog offers the same list (#1113).
@@ -80,84 +79,83 @@ fn choice(ui: &mut Ui, id: &str, value: &mut String, options: &[(&str, &str)], t
/// Footnote and Endnote. Returns true to close.
pub fn note_options(app: &mut WordApp, ui: &mut Ui, f: &mut NoteForm) -> bool {
let heading = |ui: &mut Ui, s: &str| {
ui.add_space(4.0);
ui.label(egui::RichText::new(tl!(s)).font(semibold(12.5)));
};
heading(ui, "Location");
let mut convert = None;
crate::rtl::grid(ui, egui::Grid::new("notes_location").num_columns(2).spacing(vec2(10.0, 6.0)), |ui| {
ui.radio_value(&mut f.endnote, false, tl!("Footnotes"));
ui.add_enabled_ui(!f.endnote, |ui| {
choice(ui, "notes_fpos", &mut f.pos[0], &[("pageBottom", "Bottom of Page"), ("beneathText", "Below text")], true);
});
ui.end_row();
ui.radio_value(&mut f.endnote, true, tl!("Endnotes"));
ui.add_enabled_ui(f.endnote, |ui| {
choice(ui, "notes_epos", &mut f.pos[1], &[("sectEnd", "End of section"), ("docEnd", "End of document")], true);
});
ui.end_row();
ui.label("");
ui.menu_button(format!("{}…", tl!("Convert")), |ui| {
crate::rtl::root(ui, |ui| {
for (to, l) in [("endnote", "Footnotes to endnotes"), ("footnote", "Endnotes to footnotes"), ("swap", "Swap footnotes and endnotes")]
{
if ui.button(tl!(l)).clicked() {
convert = Some(to);
ui.close();
crate::widgets::section(ui, tl!("Location"), |ui| {
let mut convert = None;
crate::rtl::grid(ui, egui::Grid::new("notes_location").num_columns(2).spacing(vec2(10.0, 6.0)), |ui| {
ui.radio_value(&mut f.endnote, false, tl!("Footnotes"));
ui.add_enabled_ui(!f.endnote, |ui| {
choice(ui, "notes_fpos", &mut f.pos[0], &[("pageBottom", "Bottom of Page"), ("beneathText", "Below text")], true);
});
ui.end_row();
ui.radio_value(&mut f.endnote, true, tl!("Endnotes"));
ui.add_enabled_ui(f.endnote, |ui| {
choice(ui, "notes_epos", &mut f.pos[1], &[("sectEnd", "End of section"), ("docEnd", "End of document")], true);
});
ui.end_row();
ui.label("");
ui.menu_button(format!("{}…", tl!("Convert")), |ui| {
crate::rtl::root(ui, |ui| {
for (to, l) in
[("endnote", "Footnotes to endnotes"), ("footnote", "Endnotes to footnotes"), ("swap", "Swap footnotes and endnotes")]
{
if ui.button(tl!(l)).clicked() {
convert = Some(to);
ui.close();
}
}
}
})
})
});
ui.end_row();
});
ui.end_row();
if let Some(to) = convert
&& let Err(e) = app.run("references.convertNotes", json!({ "to": to }))
{
app.status(e);
}
});
if let Some(to) = convert
&& let Err(e) = app.run("references.convertNotes", json!({ "to": to }))
{
app.status(e);
}
heading(ui, "Format");
let k = usize::from(f.endnote);
crate::rtl::Table::new("notes_format").columns(2).spacing(vec2(10.0, 6.0)).show(ui, |t| {
t.row(|r| {
r.cell(|ui| ui.label(tl!("Number format")));
r.cell(|ui| {
if let Some(v) = f.fmt.get_mut(k) {
choice(ui, "notes_fmt", v, &FORMATS, false);
}
crate::widgets::section(ui, tl!("Format"), |ui| {
let k = usize::from(f.endnote);
crate::rtl::Table::new("notes_format").columns(2).spacing(vec2(10.0, 6.0)).show(ui, |t| {
t.row(|r| {
r.cell(|ui| ui.label(tl!("Number format")));
r.cell(|ui| {
if let Some(v) = f.fmt.get_mut(k) {
choice(ui, "notes_fmt", v, &FORMATS, false);
}
});
});
});
t.row(|r| {
r.cell(|ui| ui.label(tl!("Custom mark:")));
r.cell(|ui| ui.add(egui::TextEdit::singleline(&mut f.mark).desired_width(60.0).char_limit(10)));
});
t.row(|r| {
r.cell(|ui| ui.label(tl!("Start at:")));
r.cell(|ui| {
if let Some(v) = f.start.get_mut(k) {
ui.add(egui::DragValue::new(v).range(1..=32_767).speed(0.2));
}
t.row(|r| {
r.cell(|ui| ui.label(tl!("Custom mark:")));
r.cell(|ui| ui.add(egui::TextEdit::singleline(&mut f.mark).desired_width(60.0).char_limit(10)));
});
});
t.row(|r| {
r.cell(|ui| ui.label(tl!("Numbering")));
r.cell(|ui| {
if let Some(v) = f.restart.get_mut(k) {
let each_page: &[(&str, &str)] = if f.endnote { &[] } else { &[("eachPage", "Restart Each Page")] };
let options: Vec<(&str, &str)> = [("continuous", "Continuous numbering"), ("eachSect", "Restart Each Section")]
.into_iter()
.chain(each_page.iter().copied())
.collect();
choice(ui, "notes_restart", v, &options, true);
}
t.row(|r| {
r.cell(|ui| ui.label(tl!("Start at:")));
r.cell(|ui| {
if let Some(v) = f.start.get_mut(k) {
ui.add(egui::DragValue::new(v).range(1..=32_767).speed(0.2));
}
});
});
});
t.row(|r| {
r.cell(|ui| ui.label(tl!("Apply to:")));
r.cell(|ui| {
let mut scope = if f.whole { "document" } else { "section" }.to_string();
choice(ui, "notes_scope", &mut scope, &[("document", "Whole document"), ("section", "This section")], true);
f.whole = scope == "document";
t.row(|r| {
r.cell(|ui| ui.label(tl!("Numbering")));
r.cell(|ui| {
if let Some(v) = f.restart.get_mut(k) {
let each_page: &[(&str, &str)] = if f.endnote { &[] } else { &[("eachPage", "Restart Each Page")] };
let options: Vec<(&str, &str)> = [("continuous", "Continuous numbering"), ("eachSect", "Restart Each Section")]
.into_iter()
.chain(each_page.iter().copied())
.collect();
choice(ui, "notes_restart", v, &options, true);
}
});
});
t.row(|r| {
r.cell(|ui| ui.label(tl!("Apply to:")));
r.cell(|ui| {
let mut scope = if f.whole { "document" } else { "section" }.to_string();
choice(ui, "notes_scope", &mut scope, &[("document", "Whole document"), ("section", "This section")], true);
f.whole = scope == "document";
});
});
});
});
@@ -1,4 +1,4 @@
use super::common::{LEADERS, choice, heading, leader_char, sample};
use super::common::{LEADERS, choice, leader_char, sample};
use super::shell::{Next, go};
use super::{FieldCode, RefsDialog, Serialize, Ui, Value, WordApp, buttons, json, vec2};
@@ -161,40 +161,43 @@ impl MarkForm {
/// Draws the index-entry fields and page, cross-reference or bookmark-range options, with Mark
/// and Mark All running `references.markEntry`.
pub(super) fn mark_ui(app: &mut WordApp, ui: &mut Ui, f: &mut MarkForm) -> Next {
heading(ui, "Index");
crate::rtl::Table::new("xe").columns(2).spacing(vec2(10.0, 6.0)).show(ui, |t| {
t.row(|r| {
let entry_label = r.cell(|ui| ui.label(tl!("Main entry:")));
r.cell(|ui| ui.add(egui::TextEdit::singleline(&mut f.entry).desired_width(220.0)).labelled_by(entry_label.id));
});
t.row(|r| {
let subentry_label = r.cell(|ui| ui.label(tl!("Subentry:")));
r.cell(|ui| ui.add(egui::TextEdit::singleline(&mut f.subentry).desired_width(220.0)).labelled_by(subentry_label.id));
});
});
heading(ui, "Options");
ui.horizontal(|ui| {
let see_label = ui.radio_value(&mut f.option, "see".to_string(), tl!("Cross-reference:"));
ui.add_enabled(f.option == "see", egui::TextEdit::singleline(&mut f.see).desired_width(160.0)).labelled_by(see_label.id);
});
ui.radio_value(&mut f.option, "page".to_string(), tl!("This page"));
ui.horizontal(|ui| {
let bookmark_label =
ui.add_enabled_ui(!f.bookmarks.is_empty(), |ui| ui.radio_value(&mut f.option, "range".to_string(), tl!("Pages of bookmark:"))).inner;
ui.add_enabled_ui(f.option == "range", |ui| {
let opts: Vec<(String, &str)> = f.bookmarks.iter().map(|b| (b.clone(), b.as_str())).collect();
let combo = craft_ui::ComboBox::from_id_salt("xe_bm").selected_text(f.bookmark.clone()).width(140.0).show_ui(ui, |ui| {
for (v, l) in &opts {
ui.selectable_value(&mut f.bookmark, v.clone(), *l);
}
crate::widgets::section(ui, tl!("Index"), |ui| {
crate::rtl::Table::new("xe").columns(2).spacing(vec2(10.0, 6.0)).show(ui, |t| {
t.row(|r| {
let entry_label = r.cell(|ui| ui.label(tl!("Main entry:")));
r.cell(|ui| ui.add(egui::TextEdit::singleline(&mut f.entry).desired_width(220.0)).labelled_by(entry_label.id));
});
t.row(|r| {
let subentry_label = r.cell(|ui| ui.label(tl!("Subentry:")));
r.cell(|ui| ui.add(egui::TextEdit::singleline(&mut f.subentry).desired_width(220.0)).labelled_by(subentry_label.id));
});
combo.response.labelled_by(bookmark_label.id);
});
});
heading(ui, "Page number style");
ui.horizontal(|ui| {
ui.checkbox(&mut f.bold, tl!("Bold"));
ui.checkbox(&mut f.italic, tl!("Italic"));
crate::widgets::section(ui, tl!("Options"), |ui| {
ui.horizontal(|ui| {
let see_label = ui.radio_value(&mut f.option, "see".to_string(), tl!("Cross-reference:"));
ui.add_enabled(f.option == "see", egui::TextEdit::singleline(&mut f.see).desired_width(160.0)).labelled_by(see_label.id);
});
ui.radio_value(&mut f.option, "page".to_string(), tl!("This page"));
ui.horizontal(|ui| {
let bookmark_label =
ui.add_enabled_ui(!f.bookmarks.is_empty(), |ui| ui.radio_value(&mut f.option, "range".to_string(), tl!("Pages of bookmark:"))).inner;
ui.add_enabled_ui(f.option == "range", |ui| {
let opts: Vec<(String, &str)> = f.bookmarks.iter().map(|b| (b.clone(), b.as_str())).collect();
let combo = craft_ui::ComboBox::from_id_salt("xe_bm").selected_text(f.bookmark.clone()).width(140.0).show_ui(ui, |ui| {
for (v, l) in &opts {
ui.selectable_value(&mut f.bookmark, v.clone(), *l);
}
});
combo.response.labelled_by(bookmark_label.id);
});
});
});
crate::widgets::section(ui, tl!("Page number style"), |ui| {
ui.horizontal(|ui| {
ui.checkbox(&mut f.bold, tl!("Bold"));
ui.checkbox(&mut f.italic, tl!("Italic"));
});
});
if !f.message.is_empty() {
ui.label(egui::RichText::new(&f.message).small());

Some files were not shown because too many files have changed in this diff Show More