Compare commits

...
Author SHA1 Message Date
Dylan M. Taylor 24e40de94f Pin PDF RunLength dependency to merged shared fix 2026-11-15 17:02:36 -05:00
Dylan M. Taylor d217e8272d Fix shared codec dependency for external GridCraft builds 2026-11-15 14:33:42 -05:00
Dylan M. Taylor 75c4b01db3 Use shared RunLength encoding for PDF image streams 2026-11-15 13:53:04 -05:00
Mouhand Kaddo 1d0b311b4a Preserve Arabic cell direction and RTL sheet layout in PDF exports (#955)
**Stacked on #940.** It contains all of #940 (Arabic shaping in PDF) and adds cell direction and right-to-left sheet geometry (`M12.AR5`). Review the [diff against #940's branch](https://github.com/Mouhand-Kaddo/gridcraft/compare/fix/arabic-pdf-text...fix/arabic-pdf-reading-direction); once #940 merges, this PR is up to date with it.

## Summary

PDF export now honors cell Context, Left-to-Right and Right-to-Left settings. Wrapped lines keep their paragraph direction. Right-to-left sheets place columns, repeated headings, merged cells and objects in the same order as the grid, and explicit Left and Right alignment stay on the side the grid shows them.

```diff
 PDF export
- infer each line separately; place every sheet left to right
+ preserve cell direction across lines; mirror RTL sheet positions
+ reject oversized text before appending an incomplete PDF block
```

Depends on #940 (Arabic PDF glyphs). The cell reading direction it reads landed with #947.

## Evidence

- **Before:** PDF ignored explicit reading order and RTL sheet layout. A public size-limit probe returned a PDF with an unmatched marked-content block.
  **After:** Direction, wrapped paragraphs, numeric brackets, RTL columns, headings, objects, clipping and sparklines have focused regressions. The same size-limit probe returns an error; its regression failed before the fix and passes afterward.
- At the current head, with Noto Sans Arabic installed and no `CRAFT_FONTS_DIR`: the `gridcraft-pdf` and `gridcraft-engine` tests, workspace clippy and fmt pass. The full `cargo xtask ci` with the craft-fonts bundle relies on the hosted gate.
- Poppler rendering inspected for LTR and RTL sheets. Bounding boxes confirm reversed column positions; logical Arabic strings remain searchable. No physical printer test.

## Merge Danger

**Door:** Two-way. Revert the commit to restore prior export behavior.

**Blast Radius:** PDF. Explicit cell direction is shared with XLSX persistence. Latin text retains the standard-font path, including forced RTL numeric text without an Arabic font.
2026-11-15 17:55:04 +01:00
Mouhand Kaddo 92ff21b9f2 Shape and preserve Arabic text in PDF exports (#940)
## Summary

Arabic text reached the PDF writer intact, then WinAnsi encoding replaced its characters with question marks. This fixes #923 through the shared PDF text path, including cells, headers and chart labels.

```diff
 PDF text
- encode Arabic through WinAnsi
+ shape with harfrust and Unicode bidi
+ embed licensed glyph outlines with matching weight coordinates
+ preserve logical source using ToUnicode and ActualText
+ fall back to the standard and CID fonts for characters the Arabic face lacks
```

Font binaries stay in the optional craft-fonts build input. Native unbundled builds can use installed Noto Sans Arabic. Explicit cell reading-direction integration follows separately.

**Web build:** shaped Arabic on web needs the bundled craft fonts. The current release workflow doesn't enable `web-craft-fonts`, so until a maintainer enables it, web sets Arabic in the CID font, as main does today, which has no Arabic glyphs, and shows a message that no Noto Sans Arabic face was found. The same applies to a desktop without Noto Sans Arabic, and to bold Arabic where only the regular face is installed.

## Evidence

- **Before:** Arabic exported as `?` (#923, v0.6.1); main now sets it in the CID font, which has no Arabic glyphs, so readers show blanks or boxes.
  **After:** native and bundled exports show joined letters, marks, Western/Arabic digits, bold/italic, wrapping, rotation and chart labels. Fresh `pdfinfo`, `pdffonts` and `pdftotext -bbox` checks accept the files; eight original Arabic strings match extracted logical text exactly.
- At the current head, with Noto Sans Arabic installed and no `CRAFT_FONTS_DIR`: the `gridcraft-pdf`, `gridcraft-engine` and `gridcraft-xlsx` tests, clippy, fmt, layers, assets, parity and the wasm check pass. The full `cargo xtask ci` with the craft-fonts bundle relies on the hosted gate.
- Characters the Arabic face lacks (emoji, Cyrillic) are set like non-Arabic text, and without an Arabic face for the text's weight Arabic takes the CID path main uses, with one message per export. Only a broken font or a size limit fails the export. Size limits cover text, glyph subsets, outlines and page content.

## Merge Danger

**Door:** two-way

**Blast Radius:** printing

`PdfDoc::finish` now returns a Result and every caller handles it. Latin-only rendering stays on its existing path. This is a glyph-outline PDF solution; platform printer and physical screen-reader behavior are not claimed.
2026-11-15 17:29:22 +01:00
Valentin Klein ee24d50ac8 Calc: overlapping spills resolve by anchor order, incremental matches full recalc (#2483)
## What

When two array formulas want the same cells, the one that already has its spill keeps them, whichever anchor comes first (this is what Excel does, measured on this PR by Harrison-Booth). The other formula shows `#SPILL!` until the winner is cleared, then it spills. When neither has a spill yet (a first calculation with no remembered layout), the anchor first in reading order (row, then column) wins, so the result never depends on evaluation order.

Before, an incremental recalculation let the existing spill keep its cells, while a full recalculation laid everything out from scratch and gave them to the earlier anchor. The two disagreed. A full recalculation now starts from the layout the sheet held, so both agree.

Also fixed: clearing a spilling formula did not unblock an array blocked by its old area when that array sat below or to the right of it.

## Why

Issue #2480: on the sales sample, `cell.set C14 =TRANSPOSE(B18:B24)` followed by `range.fill =D14:E18` over E13:F13 left F13 as `#SPILL!` in memory but `0` after a full recalc (the fuzzer, `command_sequence_fuzz` seed 0, hits this on #795). Now C14 keeps its cells, F13 is `#SPILL!`, and a full recalc gives the same.

Known limits: the xlsx reader does not restore spill layouts, so a workbook opened from a file is laid out by reading order only (Excel keeps the layout the file records); and when both anchors already held a spill and one grows into the other, reading order decides (Excel keeps the cells the other owns). The rule is documented on `Standing` in `crates/calc/src/recalc.rs`.

## Test

In `crates/engine/src/tests.rs`: the two-command sequence from the issue; both entry orders of an overlap, plus clearing the winner; and a no-history layout, where the earlier anchor wins in both entry orders. All compare cells with a full recalc.

## How verified

- `cargo fmt --check`, `cargo clippy -p gridcraft-calc -p gridcraft-engine --all-targets -- -D warnings`, `cargo test -p gridcraft-calc -p gridcraft-engine` (includes the fuzz test): all pass.

Fixes #2480
2026-11-15 17:27:51 +01:00
skylar taylor-barrick 8bde636f27 Sandbox: test the socket owner ioctls with a real pointer (#4245)
The merged test asserts FIOSETOWN and FIOASYNC with the ioctl argument passed
by value, where the kernel reads the number as an address and fails with
EFAULT whether or not the filter refuses it, so the refusal alone is not the
reason the call came back. Passing a pointer, as a C caller does, the call
succeeds unconfined and is EPERM confined.

This covers FIOSETOWN and SIOCSPGRP that way on a socket the parent made and
the program inherited as a standard stream, after reading its socket name so a
pipe cannot pass for one. SIOCSPGRP is in the rules and in the filter's count
assertion but in no test until now.

Deleting either rule line fails this test at that ioctl's assertion; restored,
it passes. The test above is untouched.
2026-11-14 22:04:39 -06:00
skylar taylor-barrick 2f52ae5c7e Sandbox: refuse fcntl's asynchronous notification on Linux (#3846)
* Sandbox: refuse fcntl's asynchronous notification on Linux

* Sandbox: tests for fcntl's notification rules and the new probe

* Sandbox: the socket ioctls that notify another process, too
2026-11-14 21:12:49 -06:00
Dylan M. Taylor a62a532753 Merge pull request #4242 from storytold/ci/sonar-pinned-fonts
ci: provision pinned fonts for coverage tests
2026-11-14 20:53:30 -05:00
Dylan M. Taylor 69219c0d5c ci: provision pinned fonts for coverage tests 2026-11-14 20:38:23 -05:00
FredApps f2044337c7 Merge pull request #4190 from storytold/fix/oversized-pivot-cache-warning-text
Tests: the oversized pivot cache warning names the part limit (main is red)
2026-11-14 18:29:41 +01:00
FredApps 34ab393c72 Tests: the oversized pivot cache warning names the part limit
The package reader reports a part over the limit as "expands to more
than <limit> bytes"; the test added in #2491 expected the declared size
and failed on main.
2026-11-14 18:20:30 +01:00
c2aba7a3f4 perf: win back formula-entry and XLSX-save time lost since 23829d8c (#2654)
Measured with crates/engine/examples/bench.rs (perf/xtask-bench), 100k rows, M2 Pro:
enter.formulas 465 -> 420 ms (23829d8c: 375), xlsx.save 540 -> 488 ms (466).

- number_to_text: the round-up-to-1E+15 check (f29ac7d9e) formatted every number with
  exact {:.14e} and parsed it back; formula printing calls it once per literal. Run it
  only for magnitudes that can round up (>= 9.9999999999999e14). Same output; boundary
  tests added.
- Expr clone/map, xlsx prefix_params: a binary node whose left operand is not a chain
  no longer allocates a spine Vec (2aeb21d4d); map rewrites the operands in their boxes.
  Expr::walk reserves room for a typical formula up front.
- grow_autofilter checks the sheet has an AutoFilter before looking up the cell.
- retained_bytes_against looks up the newer band's row once per row, not per cell.
- The journal measures an entry's JSON size with a counting writer instead of building
  the text (a big paste's params are MBs).

The rest of the enter.formulas gap and all of edit.fanout's (~+12%) is Undo's byte
budget (72db972de, #1227): sizing each snapshot and freeing evicted ones, an intended
cost of bounded memory.

Co-authored-by: nihilist-narwhal <240798405+nihilist-narwhal@users.noreply.github.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-14 16:57:27 +01:00
Harrison BoothandClaude Opus 5.5 a8a51e3cf7 XLSX: warn when a pivot cache can't be read or is too large (#1039) (#2491)
read_cache turned every pivot cache error into absence with
optional_xml(part).ok().flatten(), so a cache over the part size limit
dropped its PivotTable with no warning, and a malformed or missing cache
only left a generic "skipped part" line. Each case now adds a warning that
the PivotTable was kept as plain cells, and the workbook keeps opening
(the oversized part is refused before it inflates).

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-14 16:56:12 +01:00
NetterSilverandClaude Haiku 5.5 45ee4eceed Keep mid-field quotes when splitting with Text to Columns (#2438)
Found while testing crates/engine/src/cmd/data.rs:992 (split_delimited, used by text_to_columns)

Co-authored-by: Claude Haiku 5.5 <noreply@anthropic.com>
2026-11-14 16:54:24 +01:00
Michael HigginsandClaude Opus 5.5 fdba683246 calc: linear dependency extraction for range-operator chains (#2183) (#2198)
* calc: linear dependency extraction for range-operator chains (#2183)

precedents() handled a range operator with non-reference operands by recursing into both operands and then letting Expr::walk descend into them again, so a left-associative chain of k operands cost 2^k (a 60-operand INDEX(...):INDEX(...) chain would hang on open). It is now a hand-written collector that visits every node once, growing the per-sheet bounding boxes of the enclosing range operator as it goes. Past a depth (4096) or node (1,000,000) bound it marks the formula dynamic (always recalculated) instead of recursing further.

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

* calc: drop wall-clock timing from precedents tests (clippy)

std::time::Instant::now is a disallowed method (clippy.toml: traps on wasm).
The regression test only needs to finish; the old 2^k walk would never return.

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

* calc: bound precedents to 100 ms and box plain-reference range chains (#2183)

- range_operator_chain_precedents_are_linear times the direct precedents
  call against the 100 ms bound in the issue.
- A Range node with two plain Ref operands (A1:B2:C3, which the parser
  can't fold) now collects its bounding box like any other range node, so
  an edit to C1 recalculates.

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

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-14 16:53:03 +01:00
Mex 10849d5003 fix(functions): reject negative fractions in GCD and LCM (#2072)
* M0: reject negative fractional GCD and LCM arguments

Validate the original input before truncation. Add scalar and range regressions, including signed zero, positive fractions and zero-first LCM validation.

* M0: document negative-fraction GCD and LCM regression

Record tested edge-case behavior and update the parity revision history. Function counts and readiness estimates remain unchanged.

* M0: preserve GCD and LCM regression after math test extraction

Move the original negative-fraction regression into the existing extracted math tests. Scalar and range cases, zero-first validation, signed zero and positive truncation coverage are unchanged.
2026-11-14 16:51:29 +01:00
gyurix 494b830240 Linux: the title bar carries the window controls, as in Excel (#192) 2026-11-14 16:48:20 +01:00
Zinadin Zidan 40783ab184 functions: ACCRINTM accrues zero when issue equals settlement (#4096) (#4102)
ACCRINTM returned #NUM! whenever issue >= settlement. Excel rejects only
an issue date after settlement: when the two dates are equal after
truncation to whole days (including distinct times on the same day) it
returns 0 in every basis and both date systems. Relax the guard to
issue > settle; zero rate, zero par and an invalid basis stay #NUM!.
2026-11-14 15:22:59 +01:00
FredApps c0ee120ac2 Merge pull request #1140 from vangel76/perf/chart-frame-cache
Charts: resolved data and rendering are cached between frames (#1139)
2026-11-12 19:55:40 +01:00
Codex bf76e6e63b test: keep ref-edit three-sheet check clippy-clean 2026-11-12 19:41:19 +01:00
Codex 467d36a9c8 Merge main after PDF cleanup; retain both roadmap entries 2026-11-12 19:30:40 +01:00
FredApps efc11acede Merge pull request #818 from vangel76/perf/pdf-writer-cleanup
PDF: writer cleanup, q nesting limit, image dedupe, style only on change (#816)
2026-11-12 18:59:02 +01:00
Codex 0c5436de76 Merge main into chart frame cache; preserve both roadmap entries 2026-11-12 18:13:44 +01:00
Codex ce0beb6900 Merge main into PDF writer cleanup; preserve both roadmap entries 2026-11-12 18:13:44 +01:00
FredApps a60db4f1c7 Merge pull request #3323 from vangel76/fix/linest-qr
LINEST, LOGEST, TREND, GROWTH: solve by Householder QR (#3322)
2026-11-12 17:59:31 +01:00
FredApps a3366cff65 Merge pull request #1135 from vangel76/fix/group-resize-on-release-1082
Grid: resizing several selected columns applies the width on release (#1082)
2026-11-12 17:58:46 +01:00
FredApps 591b8354f2 Merge pull request #3624 from vangel76/fix/3619-merged-shift-enter
Shift+arrows, Enter and Tab no longer get stuck on a merged cell
2026-11-12 17:57:39 +01:00
FredApps 0b31cebe5d Merge pull request #789 from vangel76/feat/wordart-784
Insert: WordArt (insert.wordArt) (#784)
2026-11-12 17:56:55 +01:00
vangel76andClaude Sonnet 5.5 2ff6001d3d Merge upstream/main
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-11 21:54:23 +01:00
vangel76andClaude Sonnet 5.5 20917cfd01 Merge upstream/main
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-11 21:54:20 +01:00
vangel76andClaude Sonnet 5.5 4dd1c6cf6c Merge upstream/main into perf/chart-frame-cache
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-11 21:54:05 +01:00
vangel76andClaude Sonnet 5.5 60063b85cd Keep the Decorative Text ribbon button two lines wide
The one-line label widened the Insert tab enough to scroll the Equation button
out of view at 1400 px, which broke the equation editor tests in CI.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-10 23:20:06 +01:00
vangel76andClaude Sonnet 5.5 40c1afbe84 Use the Decorative Text label for the WordArt ribbon button
Upstream retires WordArt as a display name (display_names guard); the
button and its tooltip use the already translated Decorative Text key,
and the parity checklist is regenerated.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-10 22:17:09 +01:00
vangel76andClaude Sonnet 5.5 75c07a1a83 Merge upstream/main into feat/wordart-784
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-10 22:01:55 +01:00
vangel76 353908fca5 Merge remote-tracking branch 'upstream/main' into fix3624-wt 2026-11-09 23:30:34 +01:00
vangel76andClaude Opus 5.5 10545dc4e1 fix(selection): keep the old walk when the hidden axis has no direction
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-09 23:30:29 +01:00
vangel76andClaude Opus 5.5 f8070bbbd0 fix(selection): keep the Tab run's column when Enter skips hidden rows after a merged cell
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-09 23:21:03 +01:00
vangel76andClaude Opus 5.5 5e5b5d082d fix(selection): Enter from a merged cell keeps the Tab run's column
Leaving a merged cell downwards kept the start column and dropped the
column offset Enter passes to return to the Tab run's start column, so
Tab A2 -> B2:C3, Enter landed on B4 instead of A4. Keep the computed
column (and the computed row when leaving to the right).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-08 23:22:22 +01:00
vangel76andClaude Opus 5.5 2bc50341a0 fix(selection): Shift+arrows and Enter/Tab treat a merged cell as one cell (#3619)
Shift+Left/Up from a selected merged cell now widen the selection past
its edges, Shift+arrows shrink an area back over a merged cell, and
Enter/Tab leave a selected merged cell instead of walking the cells it
covers. Inside a larger selection Enter visits a merged cell once.

Fixes #3619

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-08 22:23:32 +01:00
vangel76andClaude Opus 5.5 7cd0a6cc72 Resize drag: spend Esc on the cancelled drag
Esc during a header-boundary resize was only peeked at, so the grid's
own Esc handling saw it as well and dropped a marked copy and Format
Painter. The cancel now removes the Esc presses from the frame's input,
with any modifiers, as before, cancelling the drag. The regression test
covers a pending copy and sticky Format Painter for rows and columns,
with the release in a later frame or the same frame, and Shift+Esc.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-08 13:01:31 +01:00
vangel76andClaude Opus 5.5 14aae7cee1 WordArt: keep ordinary shapes with textNoShape; print the text outline
textNoShape is the standard no-warp value, so it alone no longer makes a
shape WordArt: only a rectangle that is a text box (as the writer saves
WordArt) or has no fill and no outline reads as WordArt. A filled ellipse
with an explicit textNoShape now reads and saves as the same ellipse.

The PDF/print path drew WordArt text without its outline, so Mint
Outline (white text, green outline) printed as a blank page. The outline
is now drawn like on screen: the text in the outline colour, offset in
eight directions, under the filled text.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-08 12:54:30 +01:00
vangel76andClaude Opus 5.5 8605fb02f0 Charts: follow defined names when deciding a chart is volatile
A series like =FreshClock, where the workbook name FreshClock is NOW(),
was cached because only the literal series text was searched for
volatile calls. The check now also follows defined names the formulas
use (workbook or sheet scope, bare or sheet-qualified, LAMBDA names),
the way the evaluator looks them up. Nesting deeper than 8, cycles and
more than 64 lookups per chart count as volatile, so a chart whose
stability isn't established is not cached.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-08 12:52:00 +01:00
vangel76 032b280b04 Merge upstream/main into feat/wordart-784 2026-11-08 12:39:59 +01:00
vangel76andClaude Opus 5.5 40c3ada226 Merge upstream/main into perf/chart-frame-cache
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-08 12:28:15 +01:00
vangel76andClaude Opus 5.5 01fe67010d PDF: look up page images by hash instead of scanning every earlier image
Page::image_rgba compared each new picture with all earlier pictures on
the page, so N distinct pictures cost N(N-1)/2 comparisons. Keep a
page-local hash-to-index map (pixels still compared with ImageData::same)
and add a regression test with 3,000 distinct pictures.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-08 12:19:46 +01:00
vangel76andClaude Opus 5.5 86ed3d93b4 LINEST: treat only identical raw values as a constant predictor
The 64-ulp spread threshold still classified distinct representable
predictors such as [1e15, 1e15 + 1, 1e15 + 2] as constant and dropped
them. A column is now constant only when every raw value is the same
double; the 1e15 case is added to the offset regression test.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-08 12:19:34 +01:00
vangel76 ef320b988d Merge remote-tracking branch 'upstream/main' into HEAD 2026-11-08 12:18:59 +01:00
vangel76andClaude Sonnet 5.5 0144ffa51b Merge upstream/main into feat/wordart-784
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-07 18:39:57 +01:00
vangel76andClaude Sonnet 5.5 522120c34c Merge upstream/main into perf/pdf-writer-cleanup
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-07 18:39:27 +01:00
vangel76andClaude Sonnet 5.5 3e64ddbd80 Merge upstream/main into fix/group-resize-on-release-1082
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-07 18:39:12 +01:00
vangel76andClaude Sonnet 5.5 2cae4aa316 Merge upstream/main into perf/chart-frame-cache
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-07 18:38:57 +01:00
vangel76andClaude Sonnet 5.5 ed15db4101 Merge upstream/main into fix/linest-qr
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-07 18:37:48 +01:00
vangel76andClaude Sonnet 5.5 3d50413aff Resize drag: keep the last accepted preview and the redo history on Esc
A refused size no longer replaces the size the release applies to the
selection, and Esc puts back the redo stack the drag began with.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-07 17:34:38 +01:00
vangel76andClaude Sonnet 5.5 224d0e96d7 WordArt: refuse insertion on a protected sheet
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-07 17:32:14 +01:00
vangel76andClaude Sonnet 5.5 1baa723ae7 Merge upstream/main into perf/chart-frame-cache
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-07 17:28:55 +01:00
vangel76andClaude Sonnet 5.5 cca09cc8f4 PDF: track the first text run with a flag
text_rotated counted the Tf operators written so far on every run, which is
quadratic for text that alternates between WinAnsi and CID characters.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-07 17:19:10 +01:00
vangel76andClaude Sonnet 5.5 583c8a4819 LINEST: keep predictors that vary by little next to a large offset
A centred column was dropped when its length fell under 1e-12 of the raw
column, which also removed real variation such as [1e13, 1e13+1, 1e13+2].
Constant columns are now recognised on the raw values, within a few ulps.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-07 17:01:20 +01:00
vangel76andClaude Sonnet 5.5 8e3fba8a25 Chart cache: drop closed documents once per frame, skip volatile series
Move retain_docs out of the per-chart paint path into SheetApp::logic so closed
documents are forgotten even when no chart is painted. Charts whose series call
NOW, TODAY, RAND, RANDBETWEEN or RANDARRAY bypass the cache because their
resolved values change between evaluations.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-07 16:54:59 +01:00
vangel76andClaude Sonnet 5.5 dd5cd48b8f Regenerate parity checklist after merging main
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-05 04:29:48 +01:00
vangel76andClaude Sonnet 5.5 2a9a21d41c WordArt xlsx: only the textNoShape marker reads as WordArt, an empty WordArt keeps its body
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-05 04:25:50 +01:00
vangel76andClaude Sonnet 5.5 6a22a3b357 Merge upstream/main into feat/wordart-784
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-05 04:24:34 +01:00
vangel76andClaude Sonnet 5.5 38f48ad974 Merge upstream/main into fix/group-resize-on-release-1082
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-05 02:00:21 +01:00
vangel76andClaude Sonnet 5.5 ac0588dbaf Merge upstream/main into perf/chart-frame-cache
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-05 01:54:42 +01:00
vangel76andClaude Sonnet 5.5 a5c74edfec linest test: use f64::from directly (clippy)
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-04 00:18:00 +01:00
vangel76andClaude Sonnet 5.5 d0b40c3b30 linest: drop a constant column that centres to rounding noise (review point)
CodeRabbit pointed out that the drop test used the centred column length, so a
constant column such as [0.1; 3] (centred to about -1.4e-17) was scaled to a unit
vector and kept, giving a meaningless coefficient and wrong df. A centred column
shorter than 1e-12 of its uncentred length is now treated as collinear with the
intercept. The suggested 1e-6 threshold was not used: it would also drop columns
that sit far from zero, such as 1e9 + i.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-04 00:05:38 +01:00
vangel76andClaude Sonnet 5.5 f74d95542f LINEST: solve by Householder QR instead of the normal equations (#3322)
The normal equations square the condition number, so a degree-5 polynomial on
x = 1..12 came back with errors up to 2.6e-6 and x, x^2 near 1e6 gave slope
2.99976 and intercept 251 for y = 3x + 7. LINEST, LOGEST, TREND and GROWTH now
factor the centred, column-scaled data with Householder QR. Collinear columns
are still dropped under the same relative tolerance.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-03 23:38:55 +01:00
vangel76andClaude Haiku 5.5 f3e24e2b68 Regenerate parity checklist after merging main
The parity CI step failed because docs/parity-checklist.md was stale
after merging upstream main. Regenerated with cargo xtask parity.
Counts now 278 / 292 (Insert: WordArt moved to implemented).

Co-Authored-By: Claude Haiku 5.5 <noreply@anthropic.com>
2026-11-02 20:58:00 +01:00
vangel76andClaude Sonnet 5.5 5b3b3bdc0e Keytip pending-sequence test: use NSC so it does not race the NJ go-live test
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-02 20:19:10 +01:00
vangel76andClaude Sonnet 5.5 f8a764f20c Fix merge: Shape::math for WordArt, fmt
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-02 20:07:54 +01:00
vangel76andClaude Sonnet 5.5 0d1296e532 Merge upstream/main into feat/wordart-784
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-02 20:03:35 +01:00
vangel76andClaude Sonnet 5.5 b396e6c0bd Merge upstream/main into perf/pdf-writer-cleanup
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-02 19:52:51 +01:00
vangel76andClaude Sonnet 5.5 9bd6fa1d75 Merge upstream/main into perf/chart-frame-cache
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-02 19:50:48 +01:00
vangel76 e624f4d178 Merge remote-tracking branch 'upstream/main' into HEAD 2026-10-30 00:58:28 +01:00
vangel76andClaude Sonnet 5.5 96aece4e57 Keep Esc on a resize drag from undoing an earlier size edit
A resize drag shares its undo label with an earlier width/height edit, so
coalescing removed the drag's own entry and Esc undid the earlier edit too.
Track the workbook the drag started from and merge/cancel only entries from
there. Esc is also handled when egui has already ended the drag.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-30 00:58:28 +01:00
vangel76andClaude Sonnet 5.5 218aa884be Merge upstream/main into feat/wordart-784
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-29 23:17:05 +01:00
vangel76 4f372ff470 Name the test case type (clippy type_complexity) 2026-10-29 23:09:29 +01:00
vangel76andClaude Sonnet 5.5 5ca5e6b61e Merge upstream/main into perf/pdf-writer-cleanup
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-29 23:09:10 +01:00
vangel76andClaude Sonnet 5.5 5d440c82ac Merge upstream/main into fix/group-resize-on-release-1082
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-29 23:07:01 +01:00
vangel76 57e0eb5b0f Merge upstream/main into perf/chart-frame-cache 2026-10-29 23:06:07 +01:00
vangel76andClaude Sonnet 5.5 71469495bc Merge upstream/main into feat/wordart-784
Main moved shape text editing, PDF shape drawing, grid interaction and the Insert ribbon into submodules; the WordArt changes are re-applied there.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-27 20:16:35 +01:00
vangel76andClaude Sonnet 5.5 527abcfc7d Merge upstream/main into fix/group-resize-on-release-1082
grid.rs was split into grid/ modules on main; the resize-on-release changes are re-applied in grid.rs and grid/interact.rs.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-27 20:01:56 +01:00
vangel76andClaude Sonnet 5.5 37cf274a03 Merge upstream/main into perf/chart-frame-cache
SheetApp setup and font handling moved to app.rs and app/fonts.rs on main; the cache field and its clears are re-applied there. The cache tests use the ActiveSheet accessors.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-27 19:57:18 +01:00
vangel76andClaude Sonnet 5.5 f9bd1e7eca Fix WordArt for ActiveSheet API change after merge
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-26 20:52:27 +01:00
vangel76andClaude Sonnet 5.5 5a93bc3311 Merge upstream/main into feat/wordart-784
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-26 20:47:05 +01:00
vangel76andClaude Sonnet 5.5 f1d8d2e1e8 Merge upstream/main into feat/wordart-784
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-26 00:07:13 +01:00
vangel76andClaude Sonnet 5.5 3afaf39584 Merge upstream/main into perf/pdf-writer-cleanup
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-26 00:02:43 +01:00
vangel76andClaude Sonnet 5.5 4777381dec Merge upstream/main into fix/group-resize-on-release-1082
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-26 00:00:00 +01:00
vangel76andClaude Sonnet 5.5 97e43b84fa Chart cache test: set the MouseWheel source field added upstream
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-25 23:59:30 +01:00
vangel76andClaude Sonnet 5.5 6e2ec96c85 Merge upstream/main into perf/chart-frame-cache
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-25 23:55:51 +01:00
vangel76andClaude Sonnet 5.5 e6b6d2d65f Merge upstream/main into perf/chart-frame-cache
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-25 10:22:23 +01:00
vangel76andClaude Opus 5.5 d59c51ba1f Merge upstream/main into feat/wordart-784
print.rs: main moved shape drawing into draw_shape; the WordArt shadow
pass now sits in its text loop. ja.rs: main's catalog and tests, plus
the two WordArt CORE labels.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-24 20:12:18 +02:00
vangel76andClaude Opus 5.5 bce01e7789 Merge upstream/main into fix/group-resize-on-release-1082
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-24 19:54:27 +02:00
vangel76andClaude Sonnet 5.5 4b75f3ea00 docs: regenerate parity checklist after merging main
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-22 20:26:34 +02:00
vangel76 a9069cb8f9 Merge remote-tracking branch 'upstream/main' into feat/wordart-784 2026-10-22 20:23:53 +02:00
vangel76 fb71f723fc Merge upstream/main into perf/pdf-writer-cleanup 2026-10-22 19:49:10 +02:00
vangel76 caf897daad Add WordArt labels to the catalogs added on main 2026-10-22 19:40:36 +02:00
vangel76 a9cc381332 Merge upstream/main into feat/wordart-784 2026-10-22 19:35:37 +02:00
vangel76 451debe5e8 Merge upstream/main into fix/group-resize-on-release-1082 2026-10-22 19:32:49 +02:00
vangel76 5f53afd72e Merge remote-tracking branch 'upstream/main' into perf/chart-frame-cache
# Conflicts:
#	ROADMAP.md
#	crates/ui-egui/src/chartview.rs
2026-10-22 19:30:01 +02:00
vangel76andClaude Sonnet 5.5 c7e4d6a19c shape.setText: apply the WordArt length limit
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-20 01:35:46 +02:00
vangel76 30dfc3fbd8 PR789: merge main and preserve WordArt with RTL paragraph export 2026-10-20 00:57:39 +02:00
vangel76andClaude Sonnet 5.5 8e30c095db Charts: resolved data and rendering are cached between frames (#1139)
Part of #1098. Charts were resolved and rendered on every frame. The
primitives are now cached per document/sheet/chart and checked against a
Weak<Workbook> (any write to the workbook moves or clones it), the zoom and
pixels-per-point; capped, LRU, closed documents dropped.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-13 20:26:01 +02:00
vangel76andClaude Sonnet 5.5 6090366562 Grid: resizing several selected columns applies the width on release (#1082)
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-13 20:09:53 +02:00
vangel76andClaude Sonnet 5.5 c59575b766 Merge main into #789
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-13 19:05:22 +02:00
vangel76andClaude Sonnet 5.5 30ef61982b Merge upstream/main into perf/pdf-writer-cleanup
Combine the writer cleanup with the PDF hardening (#812) and UTF-16BE info strings (#813): sanitised widths/dashes and finite/extent guards now feed the style tracking; tests adapted to emit-on-change.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-13 19:02:32 +02:00
vangel76andClaude Sonnet 5.5 e04e559da3 PDF: writer cleanup, q nesting limit, image dedupe, style only on change (#816)
Direct object writing, image dedupe, per-page style tracking, 28-level q limit,
explicit joins, /ProcSet dropped. See the PR description.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-12 22:28:19 +02:00
vangel76andClaude Sonnet 5.5 3109f2a9e0 Keytips: NW runs insert.wordArt now that the command exists; pending-sequence test uses NJ (insert.object)
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-12 21:47:39 +02:00
vangel76andClaude Sonnet 5.5 a39c6b8977 Calc: SUBTOTAL(10x) recalculates when Row Height, AutoFit Row Height or Ungroup reveal rows
home.rowHeight, home.autofitRowHeight and data.ungroup change row hidden
state without marking the edit structural, so SUBTOTAL(101-111) kept a stale
value. Found by the command-sequence fuzz (seed 3).

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-12 21:09:41 +02:00
vangel76andClaude Sonnet 5.5 470968fcdc Insert: WordArt (insert.wordArt) (#784)
Floating decorative text built on the text-box shape path: ShapeKind::WordArt, ten original
styles, outline/shadow, wordArt.set, gallery in the ribbon, XLSX and print.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-12 20:38:11 +02:00
105 changed files with 6820 additions and 593 deletions
+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:
# Match the main CI gate so coverage exercises every glyph-sensitive UI case.
fonts-ref: b076417b5880bd4154bd22f00695b1d28c6bea83
secrets: inherit
+3 -1
View File
@@ -47,5 +47,7 @@ Generated-in-code art is original and has no file to list: the UI icon set (`cra
| `docs/images/pivot.png` | GridCraft contributors | screenshot of GridCraft rendered offscreen (`crates/ui-egui/examples/snapshot.rs`) showing an original sample workbook | MIT OR Apache-2.0 | README screenshot; no third-party content |
| `docs/images/format-chart.png` | GridCraft contributors | screenshot of GridCraft rendered offscreen (`crates/ui-egui/examples/snapshot.rs`) showing an original sample workbook | MIT OR Apache-2.0 | README screenshot; no third-party content |
| `docs/images/page-break.png` | GridCraft contributors | screenshot of GridCraft rendered offscreen (`crates/ui-egui/examples/snapshot.rs`) showing an original sample workbook | MIT OR Apache-2.0 | README screenshot; no third-party content |
| Core 14 AFM metric numbers in `crates/pdf/src/symbol.rs` (Symbol: character codes and advance widths) and `crates/pdf/src/metrics.rs` (Helvetica, Times and Courier advance widths); no font file | Adobe Systems Incorporated | Adobe's Core 14 AFM font metrics files (`Symbol.afm` 001.008 and the Helvetica, Times and Courier AFMs) | Adobe's Core 14 metrics notice: the files may be used, copied and distributed for any purpose and without charge, provided the notice is kept (quoted in `crates/pdf/src/metrics.rs`) | Numbers only, typed in from the public metrics. PDF export embeds no font: Symbol and the Times faces are base-14 fonts every PDF reader supplies, and text outside WinAnsiEncoding is set in a predefined, non-embedded Adobe-GB1 CID font |
| Core 14 AFM metric numbers in `crates/pdf/src/symbol.rs` (Symbol: character codes and advance widths) and `crates/pdf/src/metrics.rs` (Helvetica, Times and Courier advance widths); no font file | Adobe Systems Incorporated | Adobe's Core 14 AFM font metrics files (`Symbol.afm` 001.008 and the Helvetica, Times and Courier AFMs) | Adobe's Core 14 metrics notice: the files may be used, copied and distributed for any purpose and without charge, provided the notice is kept (quoted in `crates/pdf/src/metrics.rs`) | Numbers only, typed in from the public metrics. PDF export embeds none of these fonts: Symbol and the Times faces are base-14 fonts every PDF reader supplies, and non-Arabic text outside WinAnsiEncoding is set in a predefined, non-embedded Adobe-GB1 CID font |
| Unicode values of the Symbol encoding in `crates/pdf/src/symbol.rs` (the code-to-character map; numbers only, no file copied) | Unicode, Inc. | `symbol.txt`, "Adobe Symbol Encoding to Unicode", table version 1.0 (2011-07-12), at unicode.org/Public/MAPPINGS/VENDORS/ADOBE/ | Unicode, Inc.'s notice in the file: "Unicode, Inc. hereby grants the right to freely use the information supplied in this file in the creation of products supporting the Unicode Standard, and to make copies of this file in any form for internal or external distribution as long as this notice remains attached." The file is provided as-is, without warranties | Separate from Adobe's Core 14 notice (previous row), which covers the character codes and widths; the Unicode values come from this table |
Arabic PDF text uses Noto Sans Arabic from the optional [craft-fonts build input](https://github.com/storytold/craft-fonts), pinned by the release workflow. Author: The Noto Project Authors. Licence: SIL Open Font License 1.1. Native unbundled export uses an installed Noto Sans Arabic face. No new asset file is committed.
Generated
+33
View File
@@ -1007,6 +1007,17 @@ name = "craft-sheet"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=bb57d422d0bc842cbde430955825553ab7b976f4#bb57d422d0bc842cbde430955825553ab7b976f4"
[[package]]
name = "craft-stream-codecs"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=f7e0d7fd5577e102b4634bcbe062e649eb68165f#f7e0d7fd5577e102b4634bcbe062e649eb68165f"
dependencies = [
"fax",
"hayro-ccitt",
"hayro-jbig2",
"thiserror 2.0.21",
]
[[package]]
name = "craft-ui"
version = "0.1.0"
@@ -2219,6 +2230,7 @@ dependencies = [
"serde",
"serde_json",
"thiserror 2.0.21",
"unicode-segmentation",
"web-time",
"zip 3.0.0",
]
@@ -2282,6 +2294,13 @@ dependencies = [
[[package]]
name = "gridcraft-pdf"
version = "0.19.1"
dependencies = [
"craft-stream-codecs",
"harfrust",
"sha2 0.11.1",
"skrifa",
"unicode-bidi",
]
[[package]]
name = "gridcraft-sandbox"
@@ -2441,6 +2460,20 @@ dependencies = [
"foldhash 0.2.0",
]
[[package]]
name = "hayro-ccitt"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9f4d0e94ddd48749f06bbe4e5389fb9799a0c45bcaf00495042076ef05e3241a"
[[package]]
name = "hayro-jbig2"
version = "0.3.0"
source = "git+https://github.com/storytold/craft-libs?rev=f7e0d7fd5577e102b4634bcbe062e649eb68165f#f7e0d7fd5577e102b4634bcbe062e649eb68165f"
dependencies = [
"hayro-ccitt",
]
[[package]]
name = "heck"
version = "0.5.0"
+2
View File
@@ -31,6 +31,8 @@ gridcraft-math = { path = "crates/math" }
# craft-libs revision.
# craft-update: app-specific pretend versions apply to startup and manual checks.
craft-update = { git = "https://github.com/storytold/craft-libs", rev = "bb57d422d0bc842cbde430955825553ab7b976f4", version = "=0.1.0", features = ["egui"] }
# PDF RunLength encoding; this revision also fixes the vendored JBIG2 dependency for Git consumers.
craft-stream-codecs = { git = "https://github.com/storytold/craft-libs", rev = "f7e0d7fd5577e102b4634bcbe062e649eb68165f", version = "0.1.0" }
# Compound files ([MS-CFB]) and password-encrypted OOXML packages ([MS-OFFCRYPTO]).
craft-cfb = { git = "https://github.com/storytold/craft-libs", rev = "bb57d422d0bc842cbde430955825553ab7b976f4", version = "0.1.0" }
craft-offcrypto = { git = "https://github.com/storytold/craft-libs", rev = "bb57d422d0bc842cbde430955825553ab7b976f4", version = "0.1.0" }
+11
View File
@@ -149,6 +149,8 @@ Ranked; estimates in Opus 5.5 agent-hours. Detail and the full beta-gate list in
| 2026-10-31 | Recently Used lists the functions most recently entered in a formula from any source (ribbon, control channel, MCP, scripts), kept with the preferences and returned by `formulas.recentlyUsed`; the Insert Function dialog takes Excel's title and a working category list (Most Recently Used, All, each category) |
| 2026-10-31 | Formulas › Function Library as a big Insert Function button, the AutoSum split button and three columns of labelled small buttons, each category book in its own colour; category menus end with Insert Function… on that category; More Functions cascades into the remaining categories; Home › Editing shares the AutoSum menu; the MR key tip opens Recently Used |
| 2026-10-31 | System and embedded CJK fallback text shares the Latin baseline in cells, editors and window titles (#1265, #2621). Symbol and emoji alignment, manual row heights and clipping are unchanged |
| 2026-10-26 | PDF preserves Context/LTR/RTL reading direction through wrapping and drawing; RTL sheet cells, borders, headings, objects and sparklines mirror consistently |
| 2026-10-26 | Arabic PDF export shapes licensed glyph outlines and preserves searchable logical text; characters the font lacks, or a missing Arabic font, fall back to the standard fonts instead of failing the export |
| 2026-10-26 | Arabic bidi display/editing preserve logical source text; per-cell reading direction is editable and survives undo, XLSX and conditional-format priority |
| 2026-10-26 | Arabic text shows in cells and the interface through a system, fontconfig or craft-fonts Arabic face; workbook fonts keep their script fallbacks |
| 2026-10-25 | AutoSum over a selection does what Excel does: a selected row gets one total to its right (in its last cell if that is empty), not a one-cell total under each cell; a block whose last column is empty gets each row's total there, one whose last row is empty each column's, and with both the corner gets the total of the block; otherwise totals go under each column as before |
@@ -198,9 +200,13 @@ Ranked; estimates in Opus 5.5 agent-hours. Detail and the full beta-gate list in
| 2026-10-13 | XLSX export writes a picture used on several sheets once, as one `xl/media` part every drawing points to (it wrote a copy per drawing: a 16-sheet workbook with one 112 KB logo grew from 0.4 to 1.9 MB) (#985) |
| 2026-10-13 | XLSX: `[Content_Types].xml`, `_rels/.rels`, the workbook rels and `xl/workbook.xml` are the first zip entries (document properties last), so libmagic and PHP `finfo` detect the file type even with large properties (#1090) |
| 2026-10-13 | Conditional formatting: a rule gathers range statistics only when it reads them (top/bottom, above average, duplicates, scales, bars, icons) and borrows them instead of copying them per cell, so the per-frame lookup of an expression or cell-value rule no longer visits its whole range (#1098, part 1) |
| 2026-10-13 | Grid: resizing several selected columns or rows previews on the dragged one and applies the size to all on release; Esc cancels (#1082) |
| 2026-10-12 | Next/previous sheet navigation stops at the first/last visible worksheet instead of activating a hidden boundary sheet; the current selection is retained |
| 2026-10-12 | PDF writer: objects are written straight to the output, identical pictures are stored once, style operators are emitted only when they change, `q` nesting is limited to 28 and polyline joins no longer leak into later strokes (#816) |
| 2026-10-12 | Insert › Text › WordArt (`insert.wordArt`, `wordArt.set`): floating decorative text with 10 original styles, outline and shadow, in-place editing, XLSX and print (#784) |
| 2026-10-12 | Number formatting: one table of built-in formats (xlsx); numbers, dates and General render with one scratch buffer instead of per-token strings; output unchanged, checked against digests recorded from the old code (#817) |
| 2026-10-21 | Macro engine ([macros.md](docs/macros.md)): typed, declarative macros saved in the workbook (a JSON field; hidden names in xlsx); declared inputs checked with messages that name the cells; tokens (`Input.col(2)`, `Row`, `Output`, `Name:Total`, `{{…}}` in formulas); one undo step with full rollback; a footprint dry run with ask, fail, overwrite, shift down or shift right; a policy that keeps macros away from files and the app, with approval for macros in opened files; Repeat, If and Stop steps; a debugger; a relative recorder; `macro.*` commands beside the unchanged Automate scripts |
| 2026-10-13 | Performance: a chart is resolved and rendered once per change of its workbook, zoom or fonts instead of on every frame; idle frames, hovering and scrolling reuse it (#1139, part of #1098) |
| 2026-10-13 | Charts: work and memory are bounded by series x points (2,000,000 per chart: every series keeps its first points; 16 trendlines per chart), hairline columns and bars are merged per pixel column, series ranges are clipped before they are evaluated, the moving average is linear and rendering clean data no longer copies it (#1147) |
| 2026-10-13 | Charts: one combo plot-kind rule for resolving and drawing; ticks of a scale off the step grid keep their own values (#1146) |
| 2026-10-12 | Security: the `--control` server requires an auth token (random, kept in a 0600 file or chosen with `GRIDCRAFT_CONTROL_TOKEN`) on each connection's first line and closes bad connections (#777) |
@@ -281,6 +287,8 @@ Ranked; estimates in Opus 5.5 agent-hours. Detail and the full beta-gate list in
| 2026-10-31 | minor | Progress log: Recently Used and Insert Function categories |
| 2026-10-31 | minor | Progress log: Function Library |
| 2026-10-31 | minor | Progress log: shared CJK/Latin baselines in cells, editors and window titles |
| 2026-10-26 | minor | Progress log: PDF reading direction and RTL sheets |
| 2026-10-26 | minor | Progress log: Arabic PDF text |
| 2026-10-26 | minor | Progress log: Arabic bidi display and editing |
| 2026-10-26 | minor | Progress log: Arabic font fallback |
| 2026-10-25 | minor | Progress log: AutoSum over a selected row, and a selection's empty last row and column |
@@ -313,6 +321,9 @@ Ranked; estimates in Opus 5.5 agent-hours. Detail and the full beta-gate list in
| 2026-10-13 | trivial | Progress log: shared pictures written once on XLSX export (#985) |
| 2026-10-13 | minor | Progress log: conditional-format lookups no longer scan the range for rules without statistics (#1098) |
| 2026-10-12 | minor | Progress log: hidden-sheet navigation at workbook boundaries |
| 2026-10-13 | trivial | Progress log: charts cached between frames (#1139) |
| 2026-10-12 | minor | Progress log: PDF writer cleanup (#816) |
| 2026-10-12 | minor | Catalog 276 → 277 / 292: Insert › WordArt (#784) |
| 2026-10-12 | minor | Numfmt cleanup: one built-in format table (gridcraft-xlsx), fewer allocations rendering numbers, dates and General, equality test against the previous output (#817); progress log row |
| 2026-10-12 | minor | The control server requires an auth token and closes bad connections (#777); progress log row |
| 2026-10-12 | minor | Rows auto-fit oversized fonts on open and whole-row/column formatting (#833); progress log row |
+107 -1
View File
@@ -78,6 +78,8 @@ fn the_self_test_finds_every_denial() {
] {
assert!(out.contains(line), "missing `{line}` in:\n{out}");
}
#[cfg(target_os = "linux")]
assert!(out.contains("denied: switch a descriptor's notifications on"), "missing the notification switch in:\n{out}");
std::fs::remove_dir_all(home).unwrap();
}
@@ -181,7 +183,9 @@ fn system_python() -> Option<(String, String)> {
/// Confined, a program can't signal another process (this test, signal 0 delivering nothing), but can
/// still signal itself and its own threads. On Linux, where the filter names them, it also can't
/// change another process's limits or priority, or type into a terminal: no call here reaches a real
/// terminal, since its standard input isn't one.
/// terminal, since its standard input isn't one. Linux also refuses the `fcntl` commands that would
/// have the kernel signal a process for it: naming the owner, choosing the signal, or switching the
/// notification on.
#[test]
fn a_confined_program_leaves_other_processes_alone() {
if !confines() {
@@ -226,6 +230,13 @@ if sys.platform == "linux":
assert refused(os.setpriority, os.PRIO_USER, 0, 0), "every process's priority"
assert refused(os.sched_setaffinity, other, {0}), "another process's processors"
assert refused(os.pidfd_open, other), "a handle on another process"
read, write = os.pipe()
assert refused(fcntl.fcntl, write, fcntl.F_SETOWN, other), "giving a descriptor's notifications to another process"
# 15 is F_SETOWN_EX and 10 is F_SETSIG, which Python's fcntl doesn't name; the filter refuses
# them whatever owner or signal they name, so the argument doesn't matter.
assert refused(fcntl.fcntl, write, 15), "naming a descriptor's owner the extended way"
assert refused(fcntl.fcntl, write, 10), "choosing a descriptor's notification signal"
assert refused(fcntl.fcntl, write, fcntl.F_SETFL, fcntl.fcntl(write, fcntl.F_GETFL) | os.O_ASYNC), "switching a descriptor's notifications on"
resource.prlimit(0, resource.RLIMIT_NOFILE)
resource.prlimit(os.getpid(), resource.RLIMIT_NOFILE)
os.setpriority(os.PRIO_PROCESS, 0, os.getpriority(os.PRIO_PROCESS, 0))
@@ -240,6 +251,101 @@ print("left alone")
assert!(String::from_utf8_lossy(&o.stdout).contains("left alone"), "{}", text(&o));
}
/// A socket the parent made, which the program inherited as a standard stream, can't be pointed at
/// another process through the ioctls that do what `fcntl`'s notification commands do: `FIOSETOWN`
/// (0x8901) and `FIOASYNC` (0x5452), which Python's `fcntl` passes straight through. Linux only:
/// macOS's profile has no rule for them, and its standard streams here are pipes.
#[cfg(target_os = "linux")]
#[test]
fn a_confined_program_cant_point_an_inherited_socket_at_another_process() {
if !confines() {
return;
}
let Some((python, prefix)) = system_python() else {
return;
};
let code = r#"
import fcntl, sys
other = int(sys.argv[1])
def refused(call, *args):
try:
call(*args)
except PermissionError:
return True
except OSError as e:
print("other error", e)
return False
assert refused(fcntl.ioctl, 0, 0x8901, other), "giving a socket's notifications to another process"
assert refused(fcntl.ioctl, 0, 0x5452, 1), "switching a socket's notifications on"
print("socket quiet")
"#;
let (mine, _) = std::os::unix::net::UnixStream::pair().unwrap();
let socket: std::os::fd::OwnedFd = mine.into();
let me = std::process::id().to_string();
let o = Command::new(env!("CARGO_BIN_EXE_gridcraft-cli"))
.args(["sandbox-check", "--read", &prefix, "--", &python, "-I", "-c", code, &me])
.stdin(std::process::Stdio::from(socket))
.output()
.unwrap();
let out = text(&o);
assert!(o.status.success(), "{out}");
assert!(String::from_utf8_lossy(&o.stdout).contains("socket quiet"), "{out}");
}
/// The same inherited socket, by both ioctls that name the process to notify, `FIOSETOWN` (0x8901)
/// and `SIOCSPGRP` (0x8902), with the argument a real pointer. Named by value the kernel reads the
/// number as an address and fails with `EFAULT` whether or not the filter refuses it, so that form
/// shows only that a rule matched a request number; by pointer each call succeeds unconfined and is
/// `EPERM` confined, which is the transition the page claims. Kept apart from the test above so a
/// rule dropped for one request number fails for that request, not behind another. Linux only, as
/// those rules are: macOS's profile has none, and its standard streams here are pipes.
#[cfg(target_os = "linux")]
#[test]
fn a_confined_program_cant_point_an_inherited_socket_at_another_process_by_pointer() {
if !confines() {
return;
}
let Some((python, prefix)) = system_python() else {
return;
};
let code = r#"
import fcntl, socket, struct, sys
other = int(sys.argv[1])
def refused(call, *args):
try:
call(*args)
except PermissionError:
return True
except OSError as e:
print("other error", e)
return False
# Read first, so a standard stream that is not a socket can't pass for one: a pipe has no socket name.
# Detached, not dropped: a socket object closes the descriptor it wrapped when it is collected, and then
# the refusals below would be read off an invalid descriptor.
wrapped = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM, fileno=0)
name = wrapped.getsockname()
wrapped.detach()
assert name == ""
# The process group is a pointer, as a C caller passes it; naming it by value has the kernel read the
# number as an address and fail with EFAULT, which would leave the refusal unexplained by the filter.
group = bytearray(struct.pack("i", other))
assert refused(fcntl.ioctl, 0, 0x8901, group), "giving a socket's notifications to another process"
assert refused(fcntl.ioctl, 0, 0x8902, group), "giving a socket's notifications to another process's group"
print("socket owner quiet")
"#;
let (mine, _) = std::os::unix::net::UnixStream::pair().unwrap();
let socket: std::os::fd::OwnedFd = mine.into();
let me = std::process::id().to_string();
let o = Command::new(env!("CARGO_BIN_EXE_gridcraft-cli"))
.args(["sandbox-check", "--read", &prefix, "--", &python, "-I", "-c", code, &me])
.stdin(std::process::Stdio::from(socket))
.output()
.unwrap();
let out = text(&o);
assert!(o.status.success(), "{out}");
assert!(String::from_utf8_lossy(&o.stdout).contains("socket owner quiet"), "{out}");
}
/// Confined, a program changes no file, whether the policy lets it read that file or not, by path or
/// by a descriptor: not its contents, permissions, owner, extended attributes, times or flags.
/// Skipped when there is no `python3`.
+5 -1
View File
@@ -340,12 +340,16 @@ fn main() -> eframe::Result<()> {
for f in &files {
app.open_path(f);
}
// Linux/BSD: Excel's layout — no window-manager title bar above ours; our title bar carries the
// window controls. `GRIDCRAFT_SYSTEM_TITLEBAR=1` keeps the system frame.
app.window_controls = cfg!(not(any(target_os = "macos", target_os = "windows"))) && std::env::var_os("GRIDCRAFT_SYSTEM_TITLEBAR").is_none();
let mut viewport = egui::ViewportBuilder::default()
.with_title("GridCraft")
.with_inner_size([1440.0, 900.0])
.with_min_inner_size([640.0, 420.0])
.with_app_id("ai.storyteller.gridcraft")
.with_drag_and_drop(true);
.with_drag_and_drop(true)
.with_decorations(!app.window_controls);
if cfg!(target_os = "macos") {
viewport = viewport.with_fullsize_content_view(true).with_titlebar_shown(false).with_title_shown(false);
}
+137 -46
View File
@@ -27,62 +27,153 @@ pub fn resized_sum_range(sum: RangeRef, height: u32, width: u32) -> RangeRef {
RangeRef::new(sum.start, CellRef::new(row, col))
}
/// Most expression nodes [`precedents`] visits before giving up and marking the formula dynamic.
const MAX_PRECEDENT_NODES: usize = 1_000_000;
/// Collects the static references of an expression with their sheets resolved; `dynamic` is
/// set when the formula uses INDIRECT/OFFSET/names/tables whose targets can change.
///
/// Every node is visited once (#2183: range-operator chains used to re-walk shared operands,
/// costing 2^k for k operands), with an explicit stack, so a flat chain as long as Excel allows
/// (`1+1+…`, about 4,000 levels deep) never recurses. Past [`MAX_PRECEDENT_NODES`] the result
/// is conservative: `dynamic` is set so the formula recalculates every time.
pub fn precedents(wb: &Workbook, sheet: usize, e: &Expr) -> (Vec<Area>, bool) {
let mut out = Vec::new();
let mut dynamic = false;
let push = |out: &mut Vec<Area>, r: &Reference, range: RangeRef| match &r.sheet {
SheetSel::Current => out.push(Area { sheet, range }),
SheetSel::Named(n) => {
if let Some(i) = wb.sheet_index(n) {
out.push(Area { sheet: i, range });
}
let mut c = Precedents { wb, sheet, out: Vec::new(), dynamic: false, boxes: Vec::new() };
c.collect(e);
(c.out, c.dynamic)
}
/// Grows the per-sheet bounding box in `boxes` to cover `area`.
fn union_box(boxes: &mut Vec<Area>, area: Area) {
match boxes.iter_mut().find(|x| x.sheet == area.sheet) {
Some(x) => x.range = x.range.union(&area.range),
None => boxes.push(area),
}
}
/// One entry of [`Precedents::collect`]'s explicit stack. `boxes` indexes
/// [`Precedents::boxes`]: the bounding boxes of the innermost enclosing range operator, if any.
enum PrecedentStep<'e> {
/// Visit an expression and queue its children.
Visit(&'e Expr, Option<usize>),
/// Both operands of a range operator have been visited: record the bounding boxes they
/// collected in `inner`, growing the `outer` operator's boxes too.
Close { inner: usize, outer: Option<usize> },
}
struct Precedents<'w> {
wb: &'w Workbook,
sheet: usize,
out: Vec<Area>,
dynamic: bool,
/// Per-sheet bounding boxes, one list per range operator (`A1:INDEX(…)`) met so far.
boxes: Vec<Vec<Area>>,
}
impl Precedents<'_> {
/// Records `area`, also growing the bounding boxes of the enclosing range operator, if any.
fn add(&mut self, area: Area, boxes: Option<usize>) {
if let Some(b) = boxes.and_then(|i| self.boxes.get_mut(i)) {
union_box(b, area);
}
SheetSel::Span(a, b) => {
if let (Some(i), Some(j)) = (wb.sheet_index(a), wb.sheet_index(b)) {
for s in i.min(j)..=i.max(j) {
out.push(Area { sheet: s, range });
self.out.push(area);
}
fn push(&mut self, r: &Reference, range: RangeRef, boxes: Option<usize>) {
match &r.sheet {
SheetSel::Current => self.add(Area { sheet: self.sheet, range }, boxes),
SheetSel::Named(n) => {
if let Some(i) = self.wb.sheet_index(n) {
self.add(Area { sheet: i, range }, boxes);
}
}
SheetSel::Span(a, b) => {
if let (Some(i), Some(j)) = (self.wb.sheet_index(a), self.wb.sheet_index(b)) {
for s in i.min(j)..=i.max(j) {
self.add(Area { sheet: s, range }, boxes);
}
}
}
}
};
e.walk(&mut |x| match x {
Expr::Ref(r) => push(&mut out, r, r.range()),
// The cells SUMIF/AVERAGEIF really read from the sum range (see `resized_sum_range`); when
// the criteria range's size isn't known statically, recalculate the formula every time.
Expr::Call(n, args) if resizes_sum_range(n, args.len()) => match (args.first(), args.get(2)) {
(Some(Expr::Ref(c)), Some(Expr::Ref(s))) => {
let (crit, sum) = (c.range(), s.range());
push(&mut out, s, resized_sum_range(sum, crit.height(), crit.width()));
}
(_, Some(Expr::Number(_) | Expr::Text(_) | Expr::Bool(_) | Expr::Error(_) | Expr::Array(_) | Expr::Missing)) => {}
_ => dynamic = true,
},
Expr::Call(n, _)
if matches!(n.as_str(), "INDIRECT" | "OFFSET" | "NOW" | "TODAY" | "RAND" | "RANDBETWEEN" | "RANDARRAY" | "CELL" | "INFO") =>
{
dynamic = true
}
Expr::Name(_) | Expr::Struct(_) => dynamic = true,
Expr::Call(n, _) if gridcraft_functions::lookup(n).is_none() && !is_special(n) => dynamic = true,
// A range ending in a function's result (`A1:INDEX(B1:B9,n)`) covers the cells between
// the references inside it, not only those references.
Expr::Binary(BinOp::Range, a, b) if !matches!((&**a, &**b), (Expr::Ref(_), Expr::Ref(_))) => {
let mut inner = precedents(wb, sheet, a).0;
inner.extend(precedents(wb, sheet, b).0);
let mut boxes: Vec<Area> = Vec::new();
for area in inner {
match boxes.iter_mut().find(|x| x.sheet == area.sheet) {
Some(x) => x.range = x.range.union(&area.range),
None => boxes.push(area),
}
/// Visits every node of `root` once, parents before children, left to right. Areas found
/// inside a range operator (`A1:INDEX(…)`) also grow that operator's per-sheet bounding boxes.
fn collect(&mut self, root: &Expr) {
let mut pending = vec![PrecedentStep::Visit(root, None)];
let mut nodes = 0usize;
while let Some(step) = pending.pop() {
let (x, boxes) = match step {
PrecedentStep::Visit(x, boxes) => (x, boxes),
PrecedentStep::Close { inner, outer } => {
let areas = self.boxes.get_mut(inner).map(std::mem::take).unwrap_or_default();
for area in areas {
self.add(area, outer);
}
continue;
}
};
nodes = nodes.saturating_add(1);
if nodes > MAX_PRECEDENT_NODES {
self.dynamic = true;
return;
}
out.extend(boxes);
self.visit(x, boxes, &mut pending);
}
_ => {}
});
(out, dynamic)
}
/// Handles one node for [`Precedents::collect`], queueing the children still to visit.
fn visit<'e>(&mut self, x: &'e Expr, boxes: Option<usize>, pending: &mut Vec<PrecedentStep<'e>>) {
match x {
Expr::Ref(r) => self.push(r, r.range(), boxes),
// The cells SUMIF/AVERAGEIF really read from the sum range (see `resized_sum_range`); when
// the criteria range's size isn't known statically, recalculate the formula every time.
Expr::Call(n, args) if resizes_sum_range(n, args.len()) => match (args.first(), args.get(2)) {
(Some(Expr::Ref(c)), Some(Expr::Ref(s))) => {
let (crit, sum) = (c.range(), s.range());
self.push(s, resized_sum_range(sum, crit.height(), crit.width()), boxes);
}
(_, Some(Expr::Number(_) | Expr::Text(_) | Expr::Bool(_) | Expr::Error(_) | Expr::Array(_) | Expr::Missing)) => {}
_ => self.dynamic = true,
},
Expr::Call(n, _)
if matches!(n.as_str(), "INDIRECT" | "OFFSET" | "NOW" | "TODAY" | "RAND" | "RANDBETWEEN" | "RANDARRAY" | "CELL" | "INFO") =>
{
self.dynamic = true
}
Expr::Name(_) | Expr::Struct(_) => self.dynamic = true,
Expr::Call(n, _) if gridcraft_functions::lookup(n).is_none() && !is_special(n) => self.dynamic = true,
// A range ending in a function's result (`A1:INDEX(B1:B9,n)`), or a chain of plain
// references the parser can't fold into one (`A1:B2:C3`), covers the cells between the
// references inside it, not only those references. Both operands are visited once,
// collecting their bounding boxes on the way, which `Close` then records.
Expr::Binary(BinOp::Range, a, b) => {
let inner = self.boxes.len();
self.boxes.push(Vec::new());
pending.push(PrecedentStep::Close { inner, outer: boxes });
pending.push(PrecedentStep::Visit(b, Some(inner)));
pending.push(PrecedentStep::Visit(a, Some(inner)));
return;
}
_ => {}
}
// Children are pushed in reverse so they pop left to right.
let visit = |e: &'e Expr| PrecedentStep::Visit(e, boxes);
match x {
Expr::Array(rows) => pending.extend(rows.iter().flatten().rev().map(visit)),
Expr::Unary(_, e) | Expr::Paren(e) => pending.push(visit(e)),
Expr::Binary(_, a, b) => {
pending.push(visit(b));
pending.push(visit(a));
}
Expr::Call(_, args) => pending.extend(args.iter().rev().map(visit)),
Expr::Invoke(c, args) => {
pending.extend(args.iter().rev().map(visit));
pending.push(visit(c));
}
_ => {}
}
}
}
fn is_special(n: &str) -> bool {
+119 -4
View File
@@ -48,6 +48,8 @@ pub struct Calc {
/// Cells whose formulas have errors from cycles.
pub circular: Vec<Key>,
pub last_recalc_cells: usize,
/// Which anchors held a spill when the current calculation started (see [`Standing`]).
standing: Standing,
/// The cells whose value is `#SPILL!`, kept so that finding the formulas an emptied cell or a
/// freed spill area may unblock doesn't walk every formula or window of cells. Filled in
/// `rebuild`, kept up to date by `cells_changed` and by the write-back of a run; an entry is
@@ -55,6 +57,45 @@ pub struct Calc {
spill_errors: SpillErrors,
}
/// Who gets the cells when two arrays want the same ones. Excel (measured by a reviewer on
/// PR #2483) lets the spill that already exists keep its cells, whichever anchor comes first;
/// the other formula shows `#SPILL!`, and clearing the winner lets it spill. The rule here:
///
/// 1. an anchor that held a spill before this calculation outranks one that did not;
/// 2. otherwise the anchor first in reading order (row, then column) wins.
///
/// Rule 2 alone decides when nothing is remembered, so the result never depends on hash order
/// or evaluation order. A full recalculation remembers the layout the sheet held before it
/// started (rule 1), so it agrees with the incremental one; a workbook that is calculated for
/// the first time has no such layout (rule 2 only).
///
/// Known limits: (a) the xlsx reader does not restore spill layouts, so a workbook opened from a
/// file is laid out by rule 2 alone, although Excel keeps the layout the file records; (b) when
/// both anchors held a spill and one grows into the other, rule 2 decides, where Excel keeps
/// the cells the other already owns.
#[derive(Clone, Debug, Default)]
struct Standing {
/// `true`: `keys` are the anchors that held a spill (full recalculation, which lays every
/// spill out afresh). `false`: `keys` are the formulas that held none (incremental).
held: bool,
keys: HashSet<Key>,
}
impl Standing {
fn had_spill(&self, k: Key) -> bool {
self.keys.contains(&k) == self.held
}
/// Whether `a` takes cells from `b` when both want them.
fn outranks(&self, a: Key, b: Key) -> bool {
match (self.had_spill(a), self.had_spill(b)) {
(true, false) => true,
(false, true) => false,
_ => (a.1.row, a.1.col) < (b.1.row, b.1.col),
}
}
}
/// A set of cells by row, each row's columns in their own set: a window of rows and columns is
/// found by one column range per row that has an entry, so the cost follows the cells in the
/// window, not those to the side of it in the same rows.
@@ -101,6 +142,7 @@ impl Default for Calc {
fixed_now: None,
circular: vec![],
last_recalc_cells: 0,
standing: Standing::default(),
spill_errors: SpillErrors::default(),
}
}
@@ -269,6 +311,14 @@ impl Calc {
/// Recalculates every formula (F9 / Ctrl+Alt+F9, and after loading).
pub fn recalc_all(&mut self, wb: &mut Workbook) {
self.rebuild(wb);
// The layout the sheets hold now decides who keeps cells two arrays both want.
// (A Python cell that holds a spill counts too, as it does in the incremental pass.)
let mut held = HashSet::default();
for i in 0..wb.sheets.len() {
if let Some(sh) = wb.sheet(i) {
held.extend(sh.spill_ranges.keys().filter(|a| sh.cell(**a).is_some_and(|c| c.formula.is_some() || c.py.is_some())).map(|a| (i, *a)));
}
}
// Spills are laid out again from the formulas where they are now (a structural edit moves
// or deletes the formulas, not the values they spilled).
for i in 0..wb.sheets.len() {
@@ -280,7 +330,9 @@ impl Calc {
}
}
let all: Vec<Key> = self.graph.nodes.keys().copied().collect();
self.standing = Standing { held: true, keys: held };
self.run(wb, all, true);
self.standing = Standing::default();
}
/// Updates the graph for cells whose content changed and recalculates what depends on them.
@@ -391,6 +443,13 @@ impl Calc {
}
}
}
// So can the area a removed formula spilled over.
for (si, r) in &cleared {
match emptied.iter_mut().find(|x| x.0 == *si) {
Some(x) => x.1 = CellRef::new(x.1.row.max(r.end.row), x.1.col.max(r.end.col)),
None => emptied.push((*si, r.end)),
}
}
// An emptied cell can unblock an anchor any distance above or to the left of it.
for (si, end) in emptied {
seeds.extend(self.unblock_candidates(wb, si, end));
@@ -472,10 +531,22 @@ impl Calc {
fn run(&mut self, wb: &mut Workbook, mut dirty: Vec<Key>, full: bool) {
let mut dynamic_again = !self.graph.dynamic.is_empty();
self.last_recalc_cells = 0;
let mut seen: HashSet<Key> = HashSet::default();
if !full {
self.standing = Standing::default();
}
for _round in 0..8 {
if dirty.is_empty() {
break;
}
if !full {
// What each formula held before this calculation touched it.
for &k in &dirty {
if seen.insert(k) && wb.sheet(k.0).is_some_and(|s| !s.spill_ranges.contains_key(&k.1)) {
self.standing.keys.insert(k);
}
}
}
// Row-major order is a good topological guess; on-demand evaluation fixes the rest.
dirty.sort_by_key(|(s, c)| (*s, c.row, c.col));
let mut exprs: HashMap<Key, std::sync::Arc<Expr>> = HashMap::with_capacity_and_hasher(dirty.len(), Default::default());
@@ -493,6 +564,7 @@ impl Calc {
let tp = prof_now();
let (results, spills, cycles) = {
let mut host = PassHost::new(wb, &exprs, &mut rng, now).with_python(python);
host.standing = Some(&self.standing);
host.iterate = wb.calc.iterative;
for k in &dirty {
host.calculate(*k);
@@ -591,7 +663,40 @@ impl Calc {
if let Some(array) = new {
let end = CellRef::new(key.1.row.saturating_add(array.rows as u32 - 1), key.1.col.saturating_add(array.cols as u32 - 1));
let range = RangeRef::new(key.1, end);
let blocked = spill_is_blocked(sheet, key.1, range, end);
// Two arrays that want the same cells (see [`Standing`]): a spill already laid out
// that this anchor outranks is taken over, and recalculated.
let standing = &self.standing;
// A spill can only be in the way where it has cells besides its anchor, and an
// anchor itself blocks the array. When no spilled cell lies in the range, the owners
// are not scanned: a full recalculation of many disjoint spills stays linear.
let outranked: Vec<(CellRef, RangeRef)> = if range.iter().any(|cell| cell != key.1 && sheet.spill.contains_key(&cell)) {
#[cfg(test)]
OWNER_SCANS.with(|n| n.set(n.get() + 1));
sheet
.spill_ranges
.iter()
.filter(|(o, r)| **o != key.1 && r.intersects(&range) && standing.outranks(*key, (key.0, **o)))
.map(|(o, r)| (*o, *r))
.collect()
} else {
Vec::new()
};
let blocked = spill_is_blocked(sheet, *key, range, end, standing);
if !blocked {
for (o, r) in outranked {
for c in r.iter() {
sheet.spill.remove(&c);
}
sheet.spill_ranges.remove(&o);
if let Some(cell) = sheet.cells.get_mut(o) {
cell.value = Value::Error(CellError::Spill);
self.spill_errors.insert((key.0, o));
}
spill_changes.push((key.0, o));
self.graph.dependents_of_range(key.0, r, &mut spill_changes);
freed.push((key.0, r));
}
}
if blocked {
if let Some(cell) = sheet.cells.get_mut(key.1) {
cell.value = Value::Error(CellError::Spill);
@@ -628,12 +733,22 @@ impl Calc {
}
}
fn spill_is_blocked(sheet: &gridcraft_model::Sheet, anchor: CellRef, range: RangeRef, end: CellRef) -> bool {
// Owner scans done by `write_back`, to check that disjoint spills never walk every owner.
#[cfg(test)]
thread_local! {
pub(crate) static OWNER_SCANS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
}
/// Whether the array at `anchor` can't be laid out over `range`. A spill already laid out that
/// `anchor` outranks does not block it: it is taken over when written back.
fn spill_is_blocked(sheet: &gridcraft_model::Sheet, anchor: Key, range: RangeRef, end: CellRef, standing: &Standing) -> bool {
let outranked =
|cell: CellRef| sheet.spill_ranges.iter().any(|(o, r)| *o != anchor.1 && r.contains(cell) && standing.outranks(anchor, (anchor.0, *o)));
end.row >= gridcraft_core::MAX_ROWS
|| end.col >= gridcraft_core::MAX_COLS
|| range.iter().any(|cell| cell != anchor && (sheet.cells.has(cell) || sheet.spill.contains_key(&cell)))
|| range.iter().any(|cell| cell != anchor.1 && (sheet.cells.has(cell) || (sheet.spill.contains_key(&cell) && !outranked(cell))))
|| sheet.merges.iter().any(|merge| merge.intersects(&range))
|| sheet.tables.iter().any(|table| table.range.contains(anchor))
|| sheet.tables.iter().any(|table| table.range.contains(anchor.1))
}
fn fill_spill(sheet: &mut gridcraft_model::Sheet, anchor: CellRef, range: RangeRef, array: &Array) {
+13 -3
View File
@@ -31,6 +31,8 @@ pub(super) struct PassHost<'a> {
/// every row, so once per sheet rather than once per range read.
used: HashMap<usize, Option<RangeRef>>,
rng: &'a mut u64,
/// Who held a spill before the calculation; unset: every formula did (reading order decides).
pub(super) standing: Option<&'a super::Standing>,
now: f64,
cycle: bool,
pub(super) cycles: Vec<Key>,
@@ -99,6 +101,7 @@ impl<'a> PassHost<'a> {
spill_index: SpillIndex::default(),
used: HashMap::default(),
rng,
standing: None,
now,
cycle: false,
cycles: vec![],
@@ -160,19 +163,26 @@ fn spill_hits_overlap(index: &SpillIndex, sheet: usize, hits: &[CellRef], range:
}
/// Whether an array result at `k` can't spill: it is in a table, or its area runs off the sheet,
/// overlaps merged cells, holds other cells, or another formula's spill (unless that formula is
/// recalculated in this pass, and so may spill elsewhere now).
/// overlaps merged cells, holds other cells, or the spill of another formula that outranks it
/// (see `Standing`; unless that formula is recalculated in this pass, and so may spill elsewhere
/// now). A spill it outranks gives way to it when written back.
fn spill_blocked(host: &PassHost<'_>, (sheet, anchor): Key, a: &Array) -> bool {
let Some(sh) = host.wb.sheet(sheet) else { return false };
let end =
CellRef::new(anchor.row.saturating_add((a.rows as u32).saturating_sub(1)), anchor.col.saturating_add((a.cols as u32).saturating_sub(1)));
let range = RangeRef::new(anchor, end);
let own = sh.spill_ranges.get(&anchor);
let default = super::Standing::default();
let standing = host.standing.unwrap_or(&default);
let spilled_over = |c: CellRef| {
!own.is_some_and(|o| o.contains(c))
&& sh.spill_ranges.iter().any(|(o, r)| {
// A formula or Python cell recalculated in this pass lays its array out again.
*o != anchor && r.contains(c) && !host.exprs.contains_key(&(sheet, *o)) && !host.python.contains_key(&(sheet, *o))
*o != anchor
&& r.contains(c)
&& !host.exprs.contains_key(&(sheet, *o))
&& !host.python.contains_key(&(sheet, *o))
&& standing.outranks((sheet, *o), (sheet, anchor))
})
};
end.row >= gridcraft_core::MAX_ROWS
+178
View File
@@ -2331,6 +2331,85 @@ fn median_large_values_recalculate_dependents() {
}
}
/// #2183: `INDEX(…):INDEX(…):…` used to re-walk each operand of the left-associative range chain,
/// costing 2^k for k operands (28 took 40 s; 60 would take millennia), on open and on every edit.
#[test]
fn range_operator_chain_precedents_are_linear() {
let operands: Vec<String> = (1..=60).map(|i| format!("INDEX(A{i},1)")).collect();
let src = format!("=SUM({})", operands.join(":"));
let e = gridcraft_formula::parse(&src).unwrap();
let wb = Workbook::new();
// With the old 2^k walk this call would never return; #2183 asks for under 100 ms.
#[allow(clippy::disallowed_methods)] // a native test: the clock is there
let t0 = std::time::Instant::now();
let (areas, dynamic) = crate::eval::precedents(&wb, 0, &e);
let took = t0.elapsed();
assert!(took < std::time::Duration::from_millis(100), "precedents took {took:?}");
assert!(!dynamic);
// The chain covers A1:A60, not only the 60 cells named in it.
let whole = gridcraft_core::RangeRef::new(c("A1"), c("A60"));
assert!(areas.iter().any(|a| a.sheet == 0 && a.range == whole), "{areas:?}");
// Each node is visited once: 60 references plus one box per range operator.
assert!(areas.len() < 200, "{} areas", areas.len());
// Through the recalculation engine: setting it finishes and editing a cell in the box recalculates.
let mut t = T::new();
for i in 1..=60 {
t.set(&format!("A{i}"), "1");
}
t.set("B1", &src);
assert_eq!(t.num("B1"), 60.0);
t.set("A30", "5");
assert_eq!(t.num("B1"), 64.0);
}
/// A chained range of plain references (`A1:B2:C3`, which the parser can't fold into one
/// reference) covers their bounding box, as the evaluator expands it: an edit inside the box but
/// outside each operand still recalculates.
#[test]
fn chained_plain_range_precedents_cover_the_bounding_box() {
let e = gridcraft_formula::parse("=SUM(A1:B2:C3)").unwrap();
let (areas, dynamic) = crate::eval::precedents(&Workbook::new(), 0, &e);
assert!(!dynamic);
let whole = gridcraft_core::RangeRef::new(c("A1"), c("C3"));
assert!(areas.iter().any(|a| a.sheet == 0 && a.range == whole), "{areas:?}");
let mut t = T::new();
t.set("A1", "1");
t.set("E1", "=SUM(A1:B2:C3)");
assert_eq!(t.num("E1"), 1.0);
t.set("C1", "4");
assert_eq!(t.num("E1"), 5.0);
}
/// `precedents` walks with an explicit stack: an expression nested deeper than any formula
/// within the length limit can build still finds its references, on a small stack.
#[test]
fn precedents_of_deep_nesting_do_not_recurse() {
let (areas, dynamic) = std::thread::Builder::new()
.stack_size(256 * 1024)
.spawn(|| {
let mut e = gridcraft_formula::parse("=A1").unwrap();
for _ in 0..10_000 {
e = gridcraft_formula::Expr::Paren(Box::new(e));
}
let found = crate::eval::precedents(&Workbook::new(), 0, &e);
// Dropping the deep tree recurses; leak it so only `precedents` is under test.
std::mem::forget(e);
found
})
.unwrap()
.join()
.unwrap();
assert!(!dynamic);
assert_eq!(areas.len(), 1);
// Shallow nesting stays static.
let e = gridcraft_formula::parse("=((((A1))))").unwrap();
let (areas, dynamic) = crate::eval::precedents(&Workbook::new(), 0, &e);
assert!(!dynamic);
assert_eq!(areas.len(), 1);
}
#[test]
fn cell_filename_names_the_workbook_file() {
// Excel returns `<folder>/[<file>]<sheet>`, and the classic sheet-name formula splits it on
@@ -2881,6 +2960,105 @@ fn formulas_read_a_dirty_python_cell_after_it_is_laid_out() {
assert_eq!((t.num("A1"), t.num("A2"), t.num("A3")), (5.0, 100.0, 111.0));
}
#[test]
fn disjoint_spills_do_not_scan_every_spill_owner() {
// Many independent two-cell arrays: write-back must not walk all earlier owners for each one.
let mut t = T::new();
for i in 1..=2000 {
t.wb.sheet_mut(0).unwrap().cells.set(c(&format!("A{}", i * 2 - 1)), Cell::formula(Formula::new("=SEQUENCE(2)")));
}
crate::recalc::OWNER_SCANS.with(|n| n.set(0));
t.calc.recalc_all(&mut t.wb);
assert_eq!((t.num("A2"), t.num("A4000")), (2.0, 2.0));
let scans = crate::recalc::OWNER_SCANS.with(|n| n.get());
assert!(scans < 10, "{scans} owner scans for 2000 disjoint spills");
}
#[test]
fn overlapping_spill_edit_sequences_match_a_full_recalc() {
// Random short edit sequences on a small grid of arrays that run into each other (sizes from
// shared cells, so one edit resizes several at once), with constants and clears in their way.
// After every edit the incremental result must equal a full recalc of the same workbook.
let seeds: u64 = std::env::var("GRIDCRAFT_SPILL_SEEDS").ok().and_then(|v| v.parse().ok()).unwrap_or(200);
let steps: usize = std::env::var("GRIDCRAFT_SPILL_STEPS").ok().and_then(|v| v.parse().ok()).unwrap_or(20);
let only: Option<u64> = std::env::var("GRIDCRAFT_SPILL_SEED").ok().and_then(|v| v.parse().ok());
let next = |state: &mut u64| {
*state = state.wrapping_add(0x9E37_79B9_7F4A_7C15);
let mut z = *state;
z = (z ^ (z >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9);
z = (z ^ (z >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB);
z ^ (z >> 31)
};
let seeds: Vec<u64> = match only {
Some(s) => vec![s],
None => (0..seeds).collect(),
};
for seed in seeds {
let mut state = seed;
let mut t = T::new();
// Sizes in J1:J4.
for (i, n) in [2, 3, 1, 4].iter().enumerate() {
t.set(&format!("J{}", i + 1), &n.to_string());
}
let mut log: Vec<(String, String)> = Vec::new();
for step in 0..steps {
let r = next(&mut state);
let at = format!("{}{}", (b'A' + (r % 6) as u8) as char, 1 + (r >> 8) % 6);
let kind = (r >> 16) % 14;
let (at, input) = match kind {
0..=3 => {
let a = 1 + (r >> 24) % 4;
let b = 1 + (r >> 28) % 4;
(at, format!("=SEQUENCE($J${a},$J${b})"))
}
4 => (at, format!("=SEQUENCE({},{})", 1 + (r >> 24) % 3, 1 + (r >> 28) % 3)),
5 => (format!("J{}", 1 + (r >> 24) % 4), (1 + (r >> 28) % 4).to_string()),
6 => (at, "x".to_string()),
7 | 8 => (at, String::new()),
9 => (format!("K{}", 1 + (r >> 24) % 6), "=SUM(A1:F6)".to_string()),
10 => {
// An earlier edit again (often putting back what a cell held before, as undo does).
match log.len() {
0 => (at, String::new()),
n => log[(r >> 24) as usize % n].clone(),
}
}
11 => (format!("{}{}", (b'A' + ((r >> 24) % 6) as u8) as char, 1 + (r >> 32) % 6), (1 + (r >> 40) % 3).to_string()),
// Several cells in one edit (a fill, or clearing a range): a 2x2 block from `at`.
12 => (format!("{at}+"), String::new()),
_ => (format!("{at}+"), format!("=SEQUENCE($J${},$J${})", 1 + (r >> 24) % 4, 1 + (r >> 28) % 4)),
};
log.push((at.clone(), input.clone()));
if let Some(from) = at.strip_suffix('+') {
let from = c(from);
let keys: Vec<(usize, CellRef)> =
(0..2).flat_map(|dr| (0..2).map(move |dc| (0, CellRef { row: from.row + dr, col: from.col + dc }))).collect();
for k in &keys {
let cell = if input.is_empty() { Cell::value(Value::Empty) } else { Cell::formula(Formula::new(&input)) };
t.wb.sheet_mut(0).unwrap().cells.set(k.1, cell);
}
t.calc.cells_changed(&mut t.wb, &keys);
} else {
t.set(&at, &input);
}
let mut fresh = t.wb.clone();
Calc::new().recalc_all(&mut fresh);
let (a, b) = (t.wb.sheet(0).unwrap(), fresh.sheet(0).unwrap());
for row in 0..12 {
for col in 0..12 {
let cell = CellRef { row, col };
assert_eq!(a.value(cell), b.value(cell), "seed {seed} step {step}: {cell} incremental vs full recalc after {log:?}");
}
}
let mut ka: Vec<_> = a.spill_ranges.iter().map(|(k, v)| (*k, *v)).collect();
let mut kb: Vec<_> = b.spill_ranges.iter().map(|(k, v)| (*k, *v)).collect();
ka.sort_by_key(|(k, _)| (k.row, k.col));
kb.sort_by_key(|(k, _)| (k.row, k.col));
assert_eq!(ka, kb, "seed {seed} step {step}: spill layout after {log:?}");
}
}
}
/// A computed criterion whose formula runs a database function over the same criteria counts as
/// not met inside itself: before, each record's check ran the function again for every record, at
/// every level, so the work grew exponentially with the nesting allowed.
+1 -1
View File
@@ -26,7 +26,7 @@ use serde::{Deserialize, Serialize};
pub use axis::{Scale, format_number, nice_scale};
pub use raster::rasterize;
pub use render::{Swatch, legend_entries, render, supports_trendline};
pub use resolve::{default_palette, resolve, series_color, series_plot_kind};
pub use resolve::{default_palette, has_volatile_series, resolve, series_color, series_plot_kind};
pub use sparkline::render_sparkline;
/// Straight (non-premultiplied) RGBA colour.
+126 -5
View File
@@ -155,6 +155,131 @@ fn eval_list_in(wb: &Workbook, sheet: usize, formula: &str, limit: usize, depth:
}
}
/// Whether a series formula of `ch` (chart of `sheet`) calls a function whose result changes
/// between evaluations (`NOW`, `TODAY`, `RAND`, `RANDBETWEEN`, `RANDARRAY`), so a result resolved
/// earlier is stale. Defined names the formulas use (`=FreshClock`, `Sheet1!Rates`, a LAMBDA name)
/// are followed into their own formulas, the way the evaluator looks them up; each name once per
/// chart, so a cycle ends. Names nested deeper than [`MAX_NAME_DEPTH`], or more than
/// [`MAX_NAMES_FOLLOWED`] distinct names, count as volatile: a chart whose stability isn't
/// established is not cached.
pub fn has_volatile_series(wb: &Workbook, sheet: usize, ch: &Chart) -> bool {
let mut seen = Seen::new();
ch.series.iter().any(|s| {
[s.name.as_deref(), s.categories.as_deref(), Some(s.values.as_str()), s.bubble_sizes.as_deref()]
.into_iter()
.flatten()
.any(|f| formula_volatile(wb, sheet, f, 0, &mut seen))
})
}
/// Names followed inside names before a formula counts as volatile.
const MAX_NAME_DEPTH: u32 = 8;
/// Distinct defined names followed per chart before the chart counts as volatile.
const MAX_NAMES_FOLLOWED: usize = 64;
/// Defined names already followed for one chart, each with the sheet its formula is read on.
type Seen<'a> = Vec<(&'a gridcraft_model::DefinedName, usize)>;
fn formula_volatile<'a>(wb: &'a Workbook, sheet: usize, f: &str, depth: u32, seen: &mut Seen<'a>) -> bool {
if calls_volatile(f) {
return true;
}
name_tokens(f).into_iter().any(|t| {
let Some((n, at)) = defined_name(wb, sheet, t) else { return false };
// Followed already, or being followed (a cycle): a volatile call in it is found there.
if seen.iter().any(|&(m, s)| std::ptr::eq(m, n) && s == at) {
return false;
}
if depth >= MAX_NAME_DEPTH || seen.len() >= MAX_NAMES_FOLLOWED {
return true;
}
seen.push((n, at));
formula_volatile(wb, at, &n.formula, depth + 1, seen)
})
}
/// Whether formula text `f` calls one of the volatile functions by name.
fn calls_volatile(f: &str) -> bool {
const VOLATILE: [&str; 5] = ["NOW", "TODAY", "RAND", "RANDBETWEEN", "RANDARRAY"];
// Formulas read from a file may carry the `_xlfn.` prefix of newer functions.
let up = f.to_ascii_uppercase().replace("_XLFN.", "");
VOLATILE.iter().any(|name| {
up.match_indices(name).any(|(i, _)| {
let before = up[..i].chars().next_back();
let after = up[i + name.len()..].trim_start();
before.is_none_or(|c| !(c.is_alphanumeric() || c == '_' || c == '.')) && after.starts_with('(')
})
})
}
fn is_ident_char(c: char) -> bool {
c.is_alphanumeric() || c == '_' || c == '.' || c == '\\'
}
/// End of the identifier starting at byte `from` of `f`.
fn ident_end(f: &str, from: usize) -> usize {
f[from..].char_indices().find(|&(_, c)| !is_ident_char(c)).map_or(f.len(), |(j, _)| from + j)
}
/// End (past the closing quote) of the `q`-quoted text opening at byte `from`; a doubled quote
/// is an escaped one. `None` when it is not closed.
fn quoted_end(f: &str, from: usize, q: char) -> Option<usize> {
let mut i = from + q.len_utf8();
loop {
let j = i + f[i..].find(q)?;
if f[j + q.len_utf8()..].starts_with(q) {
i = j + 2 * q.len_utf8();
} else {
return Some(j + q.len_utf8());
}
}
}
/// The words of formula text `f` that may be defined names: `Name`, `Sheet1!Name`,
/// `'Bob''s'!Name`. String literals and numbers are skipped; function names, column letters and
/// the like come along too and simply aren't found as names.
fn name_tokens(f: &str) -> Vec<&str> {
let mut out = Vec::new();
let mut i = 0;
while let Some(c) = f[i..].chars().next() {
let start = i;
let end = match c {
'"' => {
i = quoted_end(f, i, '"').unwrap_or(f.len());
continue;
}
'\'' => quoted_end(f, i, '\'').unwrap_or(f.len()),
c if is_ident_char(c) => ident_end(f, i),
c => {
i += c.len_utf8();
continue;
}
};
i = end;
if f[end..].starts_with('!') {
let e = ident_end(f, end + 1);
if e > end + 1 {
out.push(&f[start..e]);
}
i = e;
} else if c != '\'' && !c.is_ascii_digit() {
out.push(&f[start..end]);
}
}
out
}
/// The defined name `t` (`Name` or `Sheet1!Name`) seen from `sheet`, and the sheet its own
/// formula is read on.
fn defined_name<'a>(wb: &'a Workbook, sheet: usize, t: &str) -> Option<(&'a gridcraft_model::DefinedName, usize)> {
// `'Bob''s'!Name`: the sheet is unquoted as everywhere else (#2012).
let (at, bare) = match gridcraft_core::split_sheet(t) {
(Some(s), bare) => (wb.sheet_index(&s)?, bare),
(None, bare) => (sheet, bare),
};
wb.name(bare, at).map(|n| (n, n.scope.unwrap_or(at)))
}
fn to_num(v: &Value) -> Option<f64> {
match v {
Value::Number(n) if n.is_finite() => Some(*n),
@@ -305,11 +430,7 @@ fn category_table(wb: &Workbook, sheet: usize, formula: &str, values: &str, limi
/// Whether `t` names a defined name seen from `sheet` (`Name`, or `Sheet1!Name` looked up on
/// that sheet), the way the evaluator looks names up.
fn is_defined_name(wb: &Workbook, sheet: usize, t: &str) -> bool {
// `'Bob''s'!Name`: the sheet is unquoted as everywhere else (#2012).
match gridcraft_core::split_sheet(t) {
(Some(s), bare) => wb.sheet_index(&s).is_some_and(|i| wb.name(bare, i).is_some()),
(None, _) => wb.name(t, sheet).is_some(),
}
defined_name(wb, sheet, t).is_some()
}
/// A series name: a reference/formula or a defined name (`[0]!Title` in a file) is evaluated,
+93
View File
@@ -1680,3 +1680,96 @@ fn a_series_named_by_a_name_on_a_sheet_with_a_bang_resolves() {
let d = resolve(&wb, 0, &c);
assert_eq!(d.series.first().map(|s| s.name.as_str()), Some("Takings"));
}
#[test]
fn volatile_series_formulas_are_detected() {
let wb = Workbook::new();
let with = |values: &str, name: Option<&str>| {
let mut c = chart(ChartKind::Line);
c.series.push(Series {
name: name.map(Into::into),
categories: None,
values: values.into(),
bubble_sizes: None,
color: None,
secondary: false,
kind: None,
smooth: false,
quartiles: Default::default(),
trendlines: vec![],
});
c
};
assert!(has_volatile_series(&wb, 0, &with("=NOW()", None)));
assert!(has_volatile_series(&wb, 0, &with("=SUM(A1:A3)*rand ()", None)));
assert!(has_volatile_series(&wb, 0, &with("Sheet1!$B$2:$B$9", Some("=TODAY()"))));
assert!(has_volatile_series(&wb, 0, &with("=RANDARRAY(5)", None)));
assert!(has_volatile_series(&wb, 0, &with("=_xlfn.RANDARRAY(5)", None)));
assert!(!has_volatile_series(&wb, 0, &with("Sheet1!$B$2:$B$9", Some("Sheet1!$B$1"))));
assert!(!has_volatile_series(&wb, 0, &with("=MYRAND(A1)", None)));
assert!(!has_volatile_series(&wb, 0, &with("=Sheet1!$NOW", None)));
assert!(!has_volatile_series(&wb, 0, &chart(ChartKind::Line)));
}
#[test]
fn volatile_defined_names_are_followed() {
let with = |values: &str| {
let mut c = chart(ChartKind::Line);
c.series.push(Series {
name: None,
categories: None,
values: values.into(),
bubble_sizes: None,
color: None,
secondary: false,
kind: None,
smooth: false,
quartiles: Default::default(),
trendlines: vec![],
});
c
};
let name = |name: &str, scope: Option<usize>, formula: &str| gridcraft_model::DefinedName {
name: name.into(),
scope,
formula: formula.into(),
comment: String::new(),
hidden: false,
};
let mut wb = Workbook::new();
wb.sheet_mut(0).unwrap().name = "Bob's".into();
wb.names.push(name("FreshClock", None, "NOW()"));
wb.names.push(name("Later", None, "FreshClock+1"));
wb.names.push(name("Dice", Some(0), "RANDBETWEEN(1,6)"));
wb.names.push(name("Rates", None, "'Bob''s'!$A$1:$A$3"));
wb.names.push(name("Loop", None, "Loop+1"));
wb.names.push(name("Spin", None, "Spin+NOW()"));
wb.names.push(name("Roll", None, "LAMBDA(n,n*RAND())"));
// A workbook-scoped name, a name used inside another, and a sheet-scoped one, bare or qualified.
assert!(has_volatile_series(&wb, 0, &with("=FreshClock")));
assert!(has_volatile_series(&wb, 0, &with("=SUM(Later, 1)")));
assert!(has_volatile_series(&wb, 0, &with("=Dice*2")));
assert!(has_volatile_series(&wb, 0, &with("='Bob''s'!Dice")));
assert!(has_volatile_series(&wb, 0, &with("=Roll(3)")));
// A self-referencing name ends (it evaluates to an error, not a changing value); one that
// also calls NOW is volatile.
assert!(!has_volatile_series(&wb, 0, &with("=Loop")));
assert!(has_volatile_series(&wb, 0, &with("=Spin")));
// Many series over the same stable name stay cacheable: each name is followed once.
let mut many = with("=Rates");
let first = many.series[0].clone();
many.series.extend(std::iter::repeat_n(first, 100));
assert!(!has_volatile_series(&wb, 0, &many));
// Names nested deeper than the limit are not known to be stable.
for i in 0..10 {
wb.names.push(name(&format!("Deep{i}"), None, &format!("Deep{}", i + 1)));
}
assert!(has_volatile_series(&wb, 0, &with("=Deep0")));
// A name that refers to cells, a name inside a string and a name of another scope are stable.
assert!(!has_volatile_series(&wb, 0, &with("=Rates")));
assert!(!has_volatile_series(&wb, 0, &with("=\"FreshClock\"")));
// Dice belongs to sheet 0: seen from another sheet it isn't defined.
wb.sheets.push(Arc::new(gridcraft_model::Sheet::new("Other")));
assert!(!has_volatile_series(&wb, 1, &with("=Dice")));
assert!(has_volatile_series(&wb, 1, &with("=FreshClock")));
}
+6 -2
View File
@@ -454,8 +454,9 @@ pub fn number_to_text(n: f64) -> String {
if !(1e-9..1e15).contains(&a) && a.round() != a || a >= 1e15 {
return sci_text(n, 15);
}
// A value just below 1e15 can round up to 1e15 at 15 significant digits.
if format!("{:.14e}", a).parse::<f64>().is_ok_and(|r| r >= 1e15) {
// A value just below 1e15 can round up to 1e15 at 15 significant digits. Only that narrow
// band pays for the exact formatting: it runs for every number literal a formula prints.
if a >= 9.999_999_999_999_9e14 && format!("{:.14e}", a).parse::<f64>().is_ok_and(|r| r >= 1e15) {
return sci_text(n, 15);
}
// 15 significant digits, trailing zeros trimmed.
@@ -506,6 +507,9 @@ mod tests {
assert_eq!(number_to_text(999999999999999.9), "1E+15");
assert_eq!(number_to_text(-999999999999999.9), "-1E+15");
assert_eq!(number_to_text(999999999999999.0), "999999999999999");
assert_eq!(number_to_text(999999999999999.5), "1E+15");
assert_eq!(number_to_text(999999999999999.4), "999999999999999");
assert_eq!(number_to_text(999999999999989.9), "999999999999990");
}
#[test]
+1
View File
@@ -26,6 +26,7 @@ gridcraft-chart = { workspace = true }
gridcraft-pdf = { workspace = true }
gridcraft-math = { workspace = true }
image = { workspace = true }
unicode-segmentation = "=1.13.3"
[dev-dependencies]
gridcraft-xlsx = { workspace = true, features = ["test-support"] }
+2
View File
@@ -26,6 +26,7 @@ pub mod spelling;
pub mod stash;
pub mod view;
pub mod whatif;
pub mod wordart;
use gridcraft_calc::Key;
use gridcraft_core::{CellRef, RangeRef};
@@ -176,6 +177,7 @@ pub fn command_specs() -> &'static [CommandSpec] {
v.extend(extra::specs());
v.extend(macros::specs());
v.extend(draw::specs());
v.extend(wordart::specs());
v.extend(spelling::specs());
v.extend(solver::specs());
v.extend(pivot::specs());
+4 -3
View File
@@ -166,14 +166,15 @@ fn filter_blank(v: &Value) -> bool {
/// A table's own filter is left to the table, and a row typed after a blank row does not count.
/// A formula counts before it is calculated: this runs inside the edit, ahead of the recalc.
pub(crate) fn grow_autofilter(sh: &mut Sheet, at: CellRef) {
if !sh.cells.get(at).is_some_and(|c| !filter_blank(&c.value) || c.formula.is_some()) {
return;
}
// The AutoFilter checks come first: they are cheap, and most sheets have none.
let Some(af) = sh.autofilter.as_ref() else { return };
let r = af.range;
if r.end.row.checked_add(1) != Some(at.row) || at.col < r.start.col || at.col > r.end.col || sh.tables.iter().any(|t| t.range == r) {
return;
}
if !sh.cells.get(at).is_some_and(|c| !filter_blank(&c.value) || c.formula.is_some()) {
return;
}
let grown = RangeRef::new(r.start, CellRef::new(at.row, r.end.col));
if let Some(af) = sh.autofilter.as_mut() {
af.range = grown;
+6 -1
View File
@@ -183,8 +183,11 @@ pub(super) fn split_delimited(text: &str, delims: &[char], consecutive: bool, qu
let mut in_q = false;
let mut last_delim = false;
let mut chars = text.chars().peekable();
let mut at_start = true;
while let Some(c) = chars.next() {
if c == quote {
if c == quote && (in_q || at_start) {
at_start = false;
last_delim = false;
if in_q && chars.peek() == Some(&quote) {
cur.push(quote);
chars.next();
@@ -199,9 +202,11 @@ pub(super) fn split_delimited(text: &str, delims: &[char], consecutive: bool, qu
}
out.push(std::mem::take(&mut cur));
last_delim = true;
at_start = true;
continue;
}
last_delim = false;
at_start = false;
cur.push(c);
}
out.push(cur);
+46 -10
View File
@@ -63,6 +63,11 @@ pub(super) fn selection_move(s: &mut Session, p: &Json) -> Result<Json> {
let d = s.doc_mut()?;
let Some(sheet) = d.wb.active() else { return Err(EngineError::NoDocument) };
let sel = &mut d.selection;
if extend && !jmp {
// Shift+arrows move the edge the anchor doesn't hold, keeping merged cells whole.
sel.extend_by(sheet, dr, dc);
return Ok(json!({"selection": sel.a1(), "active": sel.active.a1()}));
}
// Extension moves the far corner, not the active cell.
let from = if extend { sel.moving_end() } else { sel.active };
// Skip hidden rows/columns and step over merged areas.
@@ -77,23 +82,32 @@ pub(super) fn selection_move(s: &mut Session, p: &Json) -> Result<Json> {
jump(sheet, from, dr.signum(), dc.signum())
} else {
let mut t = from.offset_clamped(dr, dc);
if !extend && let Some(m) = sheet.merge_at(from) {
// Leaving a merged cell moves from its edge.
if dr > 0 {
t = CellRef::new(m.end.offset_clamped(dr, 0).row, t.col);
} else if dc > 0 {
t = CellRef::new(t.row, m.end.offset_clamped(0, dc).col);
}
}
let mut guard = 0;
while (sheet.is_row_hidden(t.row) || sheet.is_col_hidden(t.col)) && guard < 100_000 {
let n = t.offset_clamped(dr.signum(), dc.signum());
// Step each hidden axis along its own direction, so a diagonal exit from a merge
// (Tab-run return column) keeps its column while skipping hidden rows.
let mut n = CellRef::new(
if sheet.is_row_hidden(t.row) { t.offset_clamped(dr.signum(), 0).row } else { t.row },
if sheet.is_col_hidden(t.col) { t.offset_clamped(0, dc.signum()).col } else { t.col },
);
if n == t {
// The hidden axis has no direction (a move along the other axis): walk as before.
n = t.offset_clamped(dr.signum(), dc.signum());
}
if n == t {
break;
}
t = n;
guard += 1;
}
if !extend && let Some(m) = sheet.merge_at(from) {
// Leaving a merged cell moves from its edge.
if dr > 0 {
t = CellRef::new(m.end.offset_clamped(dr, 0).row, from.col);
} else if dc > 0 {
t = CellRef::new(from.row, m.end.offset_clamped(0, dc).col);
}
}
t
};
if let Some(m) = sheet.merge_at(to)
@@ -140,7 +154,29 @@ pub(super) fn selection_next(s: &mut Session, p: &Json) -> Result<Json> {
let fwd = bool_param(p, "forward").unwrap_or(true);
let by_row = bool_param(p, "byRow").unwrap_or(false);
let d = s.doc_mut()?;
d.selection.cycle(fwd, by_row);
let Some(sheet) = d.wb.active() else { return Err(EngineError::NoDocument) };
let sel = &d.selection;
if sel.is_one_merged_cell(sheet) {
// A selection that is just one merged cell is one cell, as in Excel: Enter and Tab leave
// it for the next cell instead of walking the cells it covers.
let step = if fwd { 1 } else { -1 };
let (dr, dc) = if by_row { (0, step) } else { (step, 0) };
selection_move(s, &json!({"dr": dr, "dc": dc}))?;
return Ok(json!({"active": s.doc()?.selection.active.a1()}));
}
// Inside a larger selection the cells a merged cell covers are skipped: it is visited once,
// at its top-left cell.
let area = sel.current();
let cells =
(u64::from(area.end.row.saturating_sub(area.start.row)) + 1).saturating_mul(u64::from(area.end.col.saturating_sub(area.start.col)) + 1);
let mut next = sel.clone();
for _ in 0..cells.min(1 << 20) {
next.cycle(fwd, by_row);
if sheet.merge_at(next.active).is_none_or(|m| m.start == next.active) {
break;
}
}
d.selection = next;
Ok(json!({"active": d.selection.active.a1()}))
}
+7 -1
View File
@@ -1222,9 +1222,15 @@ fn shape_set_text(s: &mut Session, p: &Json) -> Result<Json> {
let sheet = d.wb.active_sheet();
let sh = d.wb.active().ok_or_else(|| bad("shape.setText", "no such text box"))?;
let shape = sh.shapes.iter().find(|shape| shape.id == id).ok_or_else(|| bad("shape.setText", "no such text box"))?;
if shape.kind != ShapeKind::TextBox {
if !matches!(shape.kind, ShapeKind::TextBox | ShapeKind::WordArt) {
return Err(bad("shape.setText", "the shape is not a text box"));
}
if shape.kind == ShapeKind::WordArt && text.is_empty() {
return Err(bad("shape.setText", "WordArt text must not be empty"));
}
if shape.kind == ShapeKind::WordArt && text.chars().nth(super::wordart::MAX_CHARS).is_some() {
return Err(bad("shape.setText", format!("`text` is longer than {} characters", super::wordart::MAX_CHARS)));
}
// Sheet protection locks drawing objects (there is no "edit objects" allowance yet).
if sh.is_protected() {
return Err(EngineError::Other(PROTECTED.into()));
+37 -10
View File
@@ -13,13 +13,15 @@ use gridcraft_core::{CellRef, MAX_COLS, MAX_ROWS, RangeRef, Value};
#[cfg(test)]
use gridcraft_model::{Alignment, Image, SheetViewMode};
use gridcraft_model::{
Anchor, BorderLine, BorderStyle, Borders, Color, HAlign, Orientation, PageOrder, PatternType, PrintSettings, ShapeKind, Sheet, Style, StyleId,
StyleTable, Underline, VAlign, Visibility, Workbook,
Anchor, BorderLine, BorderStyle, Borders, Color, HAlign, Orientation, PageOrder, PatternType, PrintSettings, ReadingOrder, ShapeKind, Sheet,
Style, StyleId, StyleTable, Underline, VAlign, Visibility, Workbook,
};
use gridcraft_pdf::{Font, Page, PdfDoc, Point, Rect, Rgb};
use gridcraft_pdf::{Baseline, Font, Page, PdfDoc, Point, Rect, Rgb, TextDirection};
use serde_json::{Value as Json, json};
use super::{CommandSpec, Result, Session, bad, bool_param, cmd, edit, f64_param, has_doc, split_sheet, str_param, target_sheet, u32_param};
use super::{
CommandSpec, EngineError, Result, Session, bad, bool_param, cmd, edit, f64_param, has_doc, split_sheet, str_param, target_sheet, u32_param,
};
mod draw;
mod header_footer;
@@ -151,8 +153,17 @@ pub(crate) const PX_TO_PT: f32 = 0.75;
/// Most pages one export produces.
pub const MAX_PAGES: usize = 2000;
/// A rendered PDF and whether some of its Arabic text was set without an Arabic face.
pub struct RenderedPdf {
pub bytes: Vec<u8>,
pub pages: usize,
pub missing_arabic_font: bool,
}
const MISSING_ARABIC_FONT: &str = "Some Arabic text could not be drawn in this PDF because no Noto Sans Arabic face was found for it.";
/// Renders laid-out sheets to a PDF.
pub fn render_pdf(wb: &Workbook, layouts: &[SheetLayout], file: &str, path: &str) -> (Vec<u8>, usize) {
pub fn render_pdf(wb: &Workbook, layouts: &[SheetLayout], file: &str, path: &str) -> Result<RenderedPdf> {
let mut doc = PdfDoc::new();
doc.info.title = if wb.props.title.is_empty() { file.to_string() } else { wb.props.title.clone() };
doc.info.author = wb.props.author.clone();
@@ -188,7 +199,16 @@ pub fn render_pdf(wb: &Workbook, layouts: &[SheetLayout], file: &str, path: &str
let b = make_block(wb, lay.sheet, sh, *rs, *cs, (x, y), lay);
draw_block(pg, &b, lay.settings.gridlines, &mut cf);
draw_block_links(pg, &b, page_index, &mut pending_links);
printed_blocks.push(PrintedBlock { page: page_index, sheet: lay.sheet, rows: *rs, cols: *cs, x, y, k });
printed_blocks.push(PrintedBlock {
page: page_index,
sheet: lay.sheet,
rows: *rs,
cols: *cs,
x,
y,
k,
mirror_axis: sh.right_to_left.then_some(b.mirror_axis),
});
if lay.settings.headings {
draw_headings(pg, &b, rsi == 0, csi == 0, (ox, oy), (lay.heading_w * k, lay.heading_h * k));
}
@@ -204,6 +224,7 @@ pub fn render_pdf(wb: &Workbook, layouts: &[SheetLayout], file: &str, path: &str
}
if lay.settings.headings {
let fill = [0xF2, 0xF2, 0xF2];
let ox = if sh.right_to_left { lay.page_w - ox - lay.heading_w * k } else { ox };
pg.fill_rect(ox, oy, lay.heading_w * k, lay.heading_h * k, fill);
pg.rect_stroke(ox, oy, lay.heading_w * k, lay.heading_h * k, 0.3, [0xA0, 0xA0, 0xA0]);
}
@@ -227,18 +248,24 @@ pub fn render_pdf(wb: &Workbook, layouts: &[SheetLayout], file: &str, path: &str
page.link_page(Rect::new(lx, ly, w, h), target_page, Point::new(x, y));
}
}
let n = doc.page_count();
(doc.finish(), n)
let pages = doc.page_count();
let missing_arabic_font = doc.missing_arabic_font();
let bytes = doc.finish().map_err(|error| EngineError::Other(error.to_string()))?;
Ok(RenderedPdf { bytes, pages, missing_arabic_font })
}
// ---------------------------------------------------------------- commands
fn build_pdf(s: &Session, p: &Json, cmd: &str) -> Result<(Vec<u8>, usize)> {
fn build_pdf(s: &mut Session, p: &Json, cmd: &str) -> Result<(Vec<u8>, usize)> {
let opts = PrintOptions::from_params(p, cmd)?;
let d = s.doc()?;
let lays = layouts(&d.wb, &opts);
let path = d.path.clone().unwrap_or_default();
Ok(render_pdf(&d.wb, &lays, &d.display_title(), &path))
let pdf = render_pdf(&d.wb, &lays, &d.display_title(), &path)?;
if pdf.missing_arabic_font {
s.ui_requests.push(crate::UiRequest::Message(MISSING_ARABIC_FONT.into()));
}
Ok((pdf.bytes, pdf.pages))
}
pub(crate) fn export_pdf(s: &mut Session, p: &Json) -> Result<Json> {
+43 -23
View File
@@ -32,6 +32,9 @@ fn cell_look(wb: &Workbook, si: usize, sh: &Sheet, c: CellRef, cf: &mut Option<c
};
let cfl = cf.as_mut().and_then(|cache| cache.look(wb, si, c));
if let Some(st) = cfl.as_ref().and_then(|l| l.style.as_ref()) {
if st.align.reading_order.is_some() {
style.align.reading_order = st.align.reading_order;
}
if st.fill.pattern != PatternType::None {
style.fill = st.fill;
}
@@ -172,9 +175,20 @@ pub(super) struct Block<'a> {
pub(super) ys: Vec<f32>,
pub(super) k: f32,
pub(super) scale: f32,
pub(super) mirror_axis: f32,
}
impl Block<'_> {
fn point_x(&self, x: f32) -> f32 {
if self.sh.right_to_left { self.mirror_axis - x } else { x }
}
pub(super) fn text_x(&self, x: f32, width: f32) -> f32 {
if self.sh.right_to_left { self.mirror_axis - x - width } else { x }
}
pub(super) fn drawn_rect(&self, r: RangeRef) -> (f32, f32, f32, f32) {
let (x, y, w, h) = self.rect(r);
(self.text_x(x, w), y, w, h)
}
fn x(&self, col: u32) -> f32 {
if col >= self.cols.0 && col <= self.cols.1 + 1 {
return self.xs.get((col - self.cols.0) as usize).copied().unwrap_or(0.0);
@@ -328,15 +342,15 @@ pub(super) fn draw_block(pg: &mut Page, b: &Block, gridlines: bool, cf: &mut Opt
set
};
pg.save();
pg.clip_rect(bx, by, bw, bh);
pg.clip_rect(b.text_x(bx, bw), by, bw, bh);
if gridlines {
let grey = [0xB0, 0xB0, 0xB0];
let lw = (0.35 * b.scale).clamp(0.1, 0.5);
for x in &b.xs {
pg.stroke_line(*x, by, *x, by + bh, lw, grey);
pg.stroke_line(b.point_x(*x), by, b.point_x(*x), by + bh, lw, grey);
}
for y in &b.ys {
pg.stroke_line(bx, *y, bx + bw, *y, lw, grey);
pg.stroke_line(b.point_x(bx), *y, b.point_x(bx + bw), *y, lw, grey);
}
}
// Cheap pre-filter: blank, unstyled cells outside tables and conditional formats draw nothing.
@@ -379,17 +393,17 @@ pub(super) fn draw_block(pg: &mut Page, b: &Block, gridlines: bool, cf: &mut Opt
continue;
}
if let Some(f) = l.fill {
pg.fill_rect(x, y, w, h, f);
pg.fill_rect(b.text_x(x, w), y, w, h, f);
} else if merged && gridlines {
pg.fill_rect(x, y, w, h, [255, 255, 255]);
pg.fill_rect(b.text_x(x, w), y, w, h, [255, 255, 255]);
}
if merged && gridlines {
pg.rect_stroke(x, y, w, h, (0.35 * b.scale).clamp(0.1, 0.5), [0xB0, 0xB0, 0xB0]);
pg.rect_stroke(b.text_x(x, w), y, w, h, (0.35 * b.scale).clamp(0.1, 0.5), [0xB0, 0xB0, 0xB0]);
}
if let Some((frac, rgb, _)) = l.cf.as_ref().and_then(|cf| cf.bar) {
let pad = 1.5 * b.k;
let bwid = ((w - 2.0 * pad) * frac.clamp(0.0, 1.0)).max(0.0);
pg.fill_rect(x + pad, y + pad, bwid, (h - 2.0 * pad).max(0.0), rgb);
pg.fill_rect(b.text_x(x + pad, bwid), y + pad, bwid, (h - 2.0 * pad).max(0.0), rgb);
}
}
// Borders.
@@ -406,12 +420,12 @@ pub(super) fn draw_block(pg: &mut Page, b: &Block, gridlines: bool, cf: &mut Opt
),
None => (bd.right, bd.bottom),
};
draw_border(pg, &bd.top, b.wb, Point::new(x, y), Point::new(x + w, y), b.k);
draw_border(pg, &bottom, b.wb, Point::new(x, y + h), Point::new(x + w, y + h), b.k);
draw_border(pg, &bd.left, b.wb, Point::new(x, y), Point::new(x, y + h), b.k);
draw_border(pg, &right, b.wb, Point::new(x + w, y), Point::new(x + w, y + h), b.k);
draw_border(pg, &bd.diag_down, b.wb, Point::new(x, y), Point::new(x + w, y + h), b.k);
draw_border(pg, &bd.diag_up, b.wb, Point::new(x, y + h), Point::new(x + w, y), b.k);
draw_border(pg, &bd.top, b.wb, Point::new(b.point_x(x), y), Point::new(b.point_x(x + w), y), b.k);
draw_border(pg, &bottom, b.wb, Point::new(b.point_x(x), y + h), Point::new(b.point_x(x + w), y + h), b.k);
draw_border(pg, &bd.left, b.wb, Point::new(b.point_x(x), y), Point::new(b.point_x(x), y + h), b.k);
draw_border(pg, &right, b.wb, Point::new(b.point_x(x + w), y), Point::new(b.point_x(x + w), y + h), b.k);
draw_border(pg, &bd.diag_down, b.wb, Point::new(b.point_x(x), y), Point::new(b.point_x(x + w), y + h), b.k);
draw_border(pg, &bd.diag_up, b.wb, Point::new(b.point_x(x), y + h), Point::new(b.point_x(x + w), y), b.k);
}
// Text.
for (c, l) in &looks {
@@ -420,9 +434,9 @@ pub(super) fn draw_block(pg: &mut Page, b: &Block, gridlines: bool, cf: &mut Opt
continue;
}
if let Some(picture) = sh.cell_pictures.get(c) {
draw_cell_picture(pg, &picture.data, (x, y, w, h), b.k);
draw_cell_picture(pg, &picture.data, (b.text_x(x, w), y, w, h), b.k);
} else if let Some(on) = checkbox_state(l, &sh.value(*c)) {
draw_checkbox(pg, (x, y, w, h), b.k, on);
draw_checkbox(pg, (b.text_x(x, w), y, w, h), b.k, on);
} else {
draw_text(pg, b, TextPlacement { cell: *c, look: l, rect: (x, y, w, h), merged, merges: &merges, limits: (bx, bx + bw) });
}
@@ -476,6 +490,8 @@ pub(super) struct PrintedBlock {
pub(super) x: f32,
pub(super) y: f32,
pub(super) k: f32,
/// The page x that right-to-left sheets are mirrored about; `None` for left-to-right sheets.
pub(super) mirror_axis: Option<f32>,
}
/// PDF annotations are not affected by graphics clipping, so intersect each cell with its page
@@ -495,7 +511,7 @@ pub(super) fn draw_block_links(pg: &mut Page, b: &Block, page: usize, pending: &
if x1 <= x0 || y1 <= y0 {
continue;
}
let rect = (x0, y0, x1 - x0, y1 - y0);
let rect = (b.text_x(x0, x1 - x0), y0, x1 - x0, y1 - y0);
match crate::links::classify(&link.target) {
crate::links::LinkKind::External(uri) => pg.link_uri(rect.0, rect.1, rect.2, rect.3, &uri),
crate::links::LinkKind::Internal(target) if !link.external => {
@@ -514,6 +530,10 @@ pub(super) fn printed_target(wb: &Workbook, blocks: &[PrintedBlock], source_shee
let sh = wb.sheet(sheet)?;
let block = blocks.iter().find(|b| b.sheet == sheet && (b.rows.0..=b.rows.1).contains(&cell.row) && (b.cols.0..=b.cols.1).contains(&cell.col))?;
let x = block.x + (sh.col_left(cell.col) - sh.col_left(block.cols.0)) as f32 * block.k;
let x = match block.mirror_axis {
Some(axis) => axis - x - (sh.col_left(cell.col.saturating_add(1)) - sh.col_left(cell.col)) as f32 * block.k,
None => x,
};
let y = block.y + (sh.row_top(cell.row) - sh.row_top(block.rows.0)) as f32 * block.k;
Some((block.page, x, y))
}
@@ -530,11 +550,11 @@ pub(super) fn draw_headings(pg: &mut Page, b: &Block, col_heads: bool, row_heads
if x1 - x0 <= 0.0 {
continue;
}
pg.fill_rect(x0, y, x1 - x0, size.1, fill);
pg.rect_stroke(x0, y, x1 - x0, size.1, lw, line);
pg.fill_rect(b.text_x(x0, x1 - x0), y, x1 - x0, size.1, fill);
pg.rect_stroke(b.text_x(x0, x1 - x0), y, x1 - x0, size.1, lw, line);
let t = gridcraft_core::col_to_letters(col);
let tw = gridcraft_pdf::text_width(Font::Helvetica, fsize, &t);
pg.text(x0 + (x1 - x0 - tw) / 2.0, y + size.1 / 2.0 + fsize * 0.35, fsize, Font::Helvetica, [0x40, 0x40, 0x40], &t);
pg.text(b.text_x(x0 + (x1 - x0 - tw) / 2.0, tw), y + size.1 / 2.0 + fsize * 0.35, fsize, Font::Helvetica, [0x40, 0x40, 0x40], &t);
}
}
if row_heads {
@@ -544,11 +564,11 @@ pub(super) fn draw_headings(pg: &mut Page, b: &Block, col_heads: bool, row_heads
if y1 - y0 <= 0.0 {
continue;
}
pg.fill_rect(x, y0, size.0, y1 - y0, fill);
pg.rect_stroke(x, y0, size.0, y1 - y0, lw, line);
pg.fill_rect(b.text_x(x, size.0), y0, size.0, y1 - y0, fill);
pg.rect_stroke(b.text_x(x, size.0), y0, size.0, y1 - y0, lw, line);
let t = (row + 1).to_string();
let tw = gridcraft_pdf::text_width(Font::Helvetica, fsize, &t);
pg.text(x + (size.0 - tw) / 2.0, y0 + (y1 - y0) / 2.0 + fsize * 0.35, fsize, Font::Helvetica, [0x40, 0x40, 0x40], &t);
pg.text(b.text_x(x + (size.0 - tw) / 2.0, tw), y0 + (y1 - y0) / 2.0 + fsize * 0.35, fsize, Font::Helvetica, [0x40, 0x40, 0x40], &t);
}
}
}
@@ -579,7 +599,7 @@ pub(super) fn make_block<'a>(
acc += sh.row_height(r) * k;
ys.push(acc);
}
Block { wb, si, sh, rows, cols, xs, ys, k, scale: lay.scale }
Block { wb, si, sh, rows, cols, xs, ys, k, scale: lay.scale, mirror_axis: lay.page_w }
}
#[cfg(test)]
+35 -8
View File
@@ -1,6 +1,6 @@
use super::draw::{Block, PdfMeasure, Xf, draw_prims, rgb_of};
use super::text::wrap_lines;
use super::{Anchor, Font, Page, RangeRef, Rect, ShapeKind, Sheet, Value, Workbook};
use super::{Anchor, Font, Page, Point, RangeRef, Rect, ShapeKind, Sheet, TextDirection, Value, Workbook};
/// Cell pictures fit the current cell (or merged-cell) rectangle without changing aspect ratio.
pub(super) fn draw_cell_picture(pg: &mut Page, data: &[u8], rect: (f32, f32, f32, f32), k: f32) {
@@ -76,9 +76,11 @@ pub(super) fn draw_objects(pg: &mut Page, wb: &Workbook, si: usize, sh: &Sheet,
let (bx, by) = (b.xs.first().copied().unwrap_or(0.0), b.ys.first().copied().unwrap_or(0.0));
let (bw, bh) = (b.xs.last().copied().unwrap_or(bx) - bx, b.ys.last().copied().unwrap_or(by) - by);
let visible = |r: (f64, f64, f64, f64)| r.2 > 0.0 && r.3 > 0.0 && r.0 < sx1 && r.0 + r.2 > sx0 && r.1 < sy1 && r.1 + r.3 > sy0;
let place = |r: (f64, f64, f64, f64)| (bx + ((r.0 - sx0) as f32) * b.k, by + ((r.1 - sy0) as f32) * b.k, r.2 as f32 * b.k, r.3 as f32 * b.k);
let place = |r: (f64, f64, f64, f64)| {
(b.text_x(bx + ((r.0 - sx0) as f32) * b.k, r.2 as f32 * b.k), by + ((r.1 - sy0) as f32) * b.k, r.2 as f32 * b.k, r.3 as f32 * b.k)
};
pg.save();
pg.clip_rect(bx, by, bw, bh);
pg.clip_rect(b.text_x(bx, bw), by, bw, bh);
draw_sparklines(pg, wb, si, sh, b, block);
for (imi, im) in sh.images.iter().enumerate() {
let r = anchor_rect(sh, &im.anchor);
@@ -153,9 +155,19 @@ fn draw_sparklines(pg: &mut Page, wb: &Workbook, si: usize, sh: &Sheet, b: &Bloc
v => vec![v.as_f64()],
};
let color = rgb_of(sp.color, wb).unwrap_or([0x15, 0x60, 0x82]);
let (x, y, w, h) = b.rect(RangeRef::cell(sp.cell));
let (x, y, w, h) = b.drawn_rect(RangeRef::cell(sp.cell));
let (wpx, hpx) = (w / b.k, h / b.k);
let prims = gridcraft_chart::render_sparkline(sp.kind, &vals, [color[0], color[1], color[2], 255], sp.markers, wpx, hpx);
let mut prims = gridcraft_chart::render_sparkline(sp.kind, &vals, [color[0], color[1], color[2], 255], sp.markers, wpx, hpx);
if sh.right_to_left {
for prim in &mut prims {
match prim {
gridcraft_chart::Prim::Rect { x, w, .. } => *x = wpx - *x - *w,
gridcraft_chart::Prim::Line { pts, .. } => pts.iter_mut().for_each(|p| p[0] = wpx - p[0]),
gridcraft_chart::Prim::Circle { cx, .. } => *cx = wpx - *cx,
_ => {}
}
}
}
draw_prims(pg, &prims, Xf { ox: x, oy: y, k: b.k });
}
}
@@ -199,7 +211,7 @@ fn draw_shape(pg: &mut Page, wb: &Workbook, shp: &gridcraft_model::Shape, b: &Bl
let color = fm.text_color.and_then(|c| rgb_of(c, wb)).unwrap_or([0, 0, 0]);
let align = fm.align.unwrap_or(if text_box { ShapeTextAlign::Left } else { ShapeTextAlign::Center });
let anchor = fm.anchor.unwrap_or(if text_box { ShapeTextAnchor::Top } else { ShapeTextAnchor::Middle });
let lines = wrap_lines(&shp.text, font, size, (w - 4.0 * b.k).max(size));
let lines = wrap_lines(&shp.text, font, size, (w - 4.0 * b.k).max(size), TextDirection::Auto);
let block_h = lines.len().min(500) as f32 * size * 1.2;
let mut yy = match anchor {
ShapeTextAnchor::Top => y + 2.0 * b.k,
@@ -207,13 +219,28 @@ fn draw_shape(pg: &mut Page, wb: &Workbook, shp: &gridcraft_model::Shape, b: &Bl
ShapeTextAnchor::Bottom => y + h - 2.0 * b.k - block_h,
} + size * 0.8;
for l in lines.iter().take(500) {
let lw = gridcraft_pdf::text_width(font, size, l);
let lw = gridcraft_pdf::text_width_with_direction(font, size, &l.text, l.direction);
let lx = match align {
ShapeTextAlign::Left => x + 2.0 * b.k,
ShapeTextAlign::Center => x + (w - lw) / 2.0,
ShapeTextAlign::Right => x + w - 2.0 * b.k - lw,
};
pg.text(lx, yy, size, font, color, l);
// WordArt's drop shadow: the line again, offset, in the shadow colour (under the text).
if let Some(sc) = fm.text_shadow.and_then(|c| rgb_of(c, wb)) {
let off = (size * 0.06).max(0.5);
pg.text_with_direction(Point::new(lx + off, yy + off), size, font, sc, &l.text, l.direction);
}
// WordArt's text outline, as on screen: the line in the outline colour, offset in eight
// directions by half the outline width, under the filled text.
if let Some((c, ow)) = fm.text_outline
&& let Some(oc) = rgb_of(c, wb)
{
let d = (ow * b.scale / 2.0).clamp(0.25, 20.0);
for (dx, dy) in [(-1.0, -1.0), (0.0, -1.0), (1.0, -1.0), (-1.0, 0.0), (1.0, 0.0), (-1.0, 1.0), (0.0, 1.0), (1.0, 1.0)] {
pg.text_with_direction(Point::new(lx + dx * d, yy + dy * d), size, font, oc, &l.text, l.direction);
}
}
pg.text_with_direction(Point::new(lx, yy), size, font, color, &l.text, l.direction);
yy += size * 1.2;
}
}
+266 -6
View File
@@ -1,3 +1,4 @@
use gridcraft_model::{Sparkline, SparklineKind};
use serde_json::json;
use super::*;
@@ -15,6 +16,35 @@ fn pdf_of(s: &mut Session, p: Json) -> (Vec<u8>, u64) {
fn contains(hay: &[u8], needle: &str) -> bool {
hay.windows(needle.len()).any(|w| w == needle.as_bytes())
}
fn arabic_face_available() -> bool {
let mut doc = gridcraft_pdf::PdfDoc::new();
doc.add_page(100.0, 100.0).text(0.0, 50.0, 10.0, Font::Helvetica, [0, 0, 0], "مرحبا");
!doc.missing_arabic_font()
}
#[test]
fn right_to_left_sheets_mirror_link_rectangles_and_targets() {
fn numbers_after(pdf: &[u8], key: &str, n: usize) -> Vec<f32> {
let text = String::from_utf8_lossy(pdf);
let at = text.find(key).unwrap() + key.len();
text[at..].split([' ', ']']).filter_map(|t| t.parse().ok()).take(n).collect()
}
let mut s = s();
s.execute("insert.link", json!({"cell": "A1", "target": "https://example.org/report"})).unwrap();
s.execute("insert.link", json!({"cell": "A2", "target": "Sheet1!B60"})).unwrap();
s.execute("cell.set", json!({"cell": "B60", "input": "Destination"})).unwrap();
let (ltr, _) = pdf_of(&mut s, json!({}));
s.execute("view.rightToLeft", json!({"on": true})).unwrap();
let (rtl, _) = pdf_of(&mut s, json!({}));
let axis = numbers_after(&ltr, "/MediaBox [", 4)[2];
let (l, r) = (numbers_after(&ltr, "/Rect [", 4), numbers_after(&rtl, "/Rect [", 4));
assert!((r[0] - (axis - l[2])).abs() < 0.01 && (r[2] - (axis - l[0])).abs() < 0.01, "{l:?} mirrors to {r:?}");
assert_eq!(r[1], l[1]);
let b_width = s.doc().unwrap().wb.active().unwrap().col_width(1);
let (lx, rx) = (numbers_after(&ltr, "/XYZ ", 1)[0], numbers_after(&rtl, "/XYZ ", 1)[0]);
let k = (l[2] - l[0]) / s.doc().unwrap().wb.active().unwrap().col_width(0);
assert!((rx - (axis - lx - b_width * k)).abs() < 0.01, "target {lx} mirrors to {rx}");
}
#[test]
fn chart_data_table_prints_formatted_values_and_follows_recalculation() {
@@ -58,6 +88,199 @@ fn pdf_export_keeps_safe_links_on_their_printed_pages() {
assert!(!cropped.contains("/Dest ["));
}
#[test]
fn arabic_with_characters_its_font_lacks_still_exports() {
let mut s = s();
s.execute("cell.set", json!({"cell": "A1", "input": "مرحبا 😀"})).unwrap();
s.execute("cell.set", json!({"cell": "A2", "input": "مرحبا Привет"})).unwrap();
let out = s.execute("file.exportPdf", json!({})).unwrap();
assert_eq!(out["pages"], 1);
}
#[test]
fn wrapping_keeps_combining_marks_with_their_letters() {
let word = "a\u{301}a\u{301}a\u{301}a\u{301}";
let lines = wrap_lines(word, Font::Helvetica, 10.0, 7.0, TextDirection::Auto);
assert_eq!(lines.iter().map(|line| line.text.as_str()).collect::<String>(), word);
assert!(lines.iter().all(|line| line.text == "a\u{301}"));
}
#[test]
fn arabic_cells_headers_and_charts_export_searchable_shaped_text() {
if !arabic_face_available() && std::env::var_os("CRAFT_FONTS_REQUIRED").is_none() {
return;
}
let mut s = s();
s.execute("range.setValues", json!({"range": "A1", "values": [["مَرْحَبًا 123 (ABC)", "القيمة"], ["تفاح", 3], ["كمثرى", 5], ["العَرَبِيَّة العَرَبِيَّة العَرَبِيَّة العَرَبِيَّة العَرَبِيَّة", null], ["تقرير ١٢٣ (ABC)", null], ["مرحبا", null]]})).unwrap();
s.execute("home.columnWidth", json!({"cols": "A:B", "chars": 32})).unwrap();
s.execute("home.rowHeight", json!({"rows": "1:6", "height": 50})).unwrap();
s.execute("home.fontSize", json!({"range": "A1:B6", "size": 20})).unwrap();
s.execute("home.rowHeight", json!({"rows": "4:4", "height": 90})).unwrap();
s.execute("home.bold", json!({"range": "A2"})).unwrap();
s.execute("home.italic", json!({"range": "A3"})).unwrap();
s.execute("home.wrapText", json!({"range": "A4"})).unwrap();
s.execute("home.orientation", json!({"range": "A6", "angle": 30})).unwrap();
s.execute("pageLayout.pageSetup", json!({"header": "&Cتقرير المبيعات 2026", "gridlines": true})).unwrap();
s.execute("insert.chart", json!({"range": "A1:B3", "type": "column"})).unwrap();
{
let d = s.doc_mut().unwrap();
let wb = std::sync::Arc::make_mut(&mut d.wb);
for chart in &mut wb.sheet_mut(0).unwrap().charts {
chart.anchor.cell = CellRef::new(8, 0);
chart.anchor.width = 500.0;
chart.anchor.height = 280.0;
}
}
let (pdf, pages) = pdf_of(&mut s, json!({"fitToPage": true}));
assert_eq!(pages, 1);
assert!(contains(&pdf, "/Subtype /Type3"));
for text in ["مَرْحَبًا 123 (ABC)", "تقرير المبيعات 2026", "القيمة", "تفاح", "كمثرى"] {
let utf16 = text.encode_utf16().map(|unit| format!("{unit:04X}")).collect::<String>();
assert!(contains(&pdf, &format!("/ActualText <FEFF{utf16}>")), "missing text {text}");
}
let lines = wrap_lines("العَرَبِيَّةالعَرَبِيَّة", Font::Helvetica, 20.0, 40.0, TextDirection::Auto);
assert_eq!(lines.iter().map(|line| line.text.as_str()).collect::<String>(), "العَرَبِيَّةالعَرَبِيَّة");
assert!(lines.iter().all(|line| !line.text.starts_with(['َ', 'ِ', 'ُ', 'ّ', 'ْ'])));
assert!(lines.iter().all(|line| gridcraft_pdf::text_width_with_direction(Font::Helvetica, 20.0, &line.text, line.direction) <= 40.0));
let path = std::env::temp_dir().join(format!("gridcraft-arabic-export-{}.pdf", std::process::id()));
std::fs::write(&path, &pdf).unwrap();
eprintln!("Arabic PDF artifact: {}", path.display());
}
#[test]
fn arabic_reading_order_export_artifact() {
if !arabic_face_available() && std::env::var_os("CRAFT_FONTS_REQUIRED").is_none() {
return;
}
let mut s = s();
s.execute("range.setValues", json!({"range": "A1", "values": [["Context", "LeftToRight", "RightToLeft"], ["مرحبا ABC !", "مرحبا ABC !", "مرحبا ABC !"], ["123 مرحبا ABC", "123 مرحبا ABC", "123 مرحبا ABC"], ["(مرحبا) ABC", "(مرحبا) ABC", "(مرحبا) ABC"], ["مرحبا ABC ! DEF ? مرحبا", "مرحبا ABC ! DEF ? مرحبا", "مرحبا ABC ! DEF ? مرحبا"]]})).unwrap();
s.execute("home.columnWidth", json!({"cols": "A:C", "chars": 24})).unwrap();
s.execute("home.rowHeight", json!({"rows": "1:5", "height": 60})).unwrap();
s.execute("home.fontSize", json!({"range": "A2:C5", "size": 18})).unwrap();
for (range, order) in [("A2:A5", "Context"), ("B2:B5", "LeftToRight"), ("C2:C5", "RightToLeft")] {
s.execute("home.formatCells", json!({"range": range, "style": {"align": {"reading_order": order}}})).unwrap();
}
s.execute("home.wrapText", json!({"range": "A5:C5"})).unwrap();
s.execute("pageLayout.pageSetup", json!({"gridlines": true, "header": "&CArabic cell reading order"})).unwrap();
let (pdf, _) = pdf_of(&mut s, json!({}));
for text in ["مرحبا ABC !", "123 مرحبا ABC", "(مرحبا) ABC"] {
let utf16 = text.encode_utf16().map(|unit| format!("{unit:04X}")).collect::<String>();
assert!(contains(&pdf, &format!("/ActualText <FEFF{utf16}>")));
}
let path = std::env::temp_dir().join(format!("gridcraft-arabic-reading-order-{}.pdf", std::process::id()));
std::fs::write(&path, &pdf).unwrap();
eprintln!("Arabic reading-order PDF artifact: {}", path.display());
}
#[test]
fn wrapped_lines_keep_the_paragraph_direction() {
let lines = wrap_lines("مرحبا ABC ! DEF ?\nLatin مرحبا !", Font::Helvetica, 10.0, 30.0, TextDirection::Auto);
let split = lines.iter().position(|l| l.text.starts_with("Latin")).unwrap();
assert!(split > 0);
assert!(lines[..split].iter().all(|l| l.direction == TextDirection::RightToLeft));
assert!(lines[split..].iter().all(|l| l.direction == TextDirection::LeftToRight));
let lines = wrap_lines("123 مرحبا ABC !", Font::Helvetica, 10.0, 30.0, TextDirection::Context.resolve("123 مرحبا ABC !"));
assert!(lines.iter().all(|l| l.direction == TextDirection::LeftToRight));
}
fn exported_text_x(pdf: &[u8], text: &str) -> f32 {
let pdf = String::from_utf8_lossy(pdf);
let marker = format!("({text}) Tj");
let before = &pdf[..pdf.find(&marker).unwrap()];
let matrix = before.lines().rev().find(|line| line.ends_with(" Tm")).unwrap();
matrix.split_whitespace().nth(4).unwrap().parse().unwrap()
}
#[test]
fn cell_reading_order_and_conditional_context_reach_pdf() {
let mut s = s();
s.execute("cell.set", json!({"cell": "A1", "input": "ABC !"})).unwrap();
s.execute("home.formatCells", json!({"range": "A1", "style": {"align": {"reading_order": "RightToLeft"}}})).unwrap();
let (rtl, _) = pdf_of(&mut s, json!({}));
assert!(contains(&rtl, "(! ABC) Tj"));
assert!(!contains(&rtl, "/Subtype /Type3"));
s.execute("home.conditionalFormat", json!({"range": "A1", "rule": {"type": "noBlanks", "style": {"align": {"reading_order": "Context"}}}}))
.unwrap();
let (context, _) = pdf_of(&mut s, json!({}));
assert!(contains(&context, "(ABC !) Tj"));
assert!(!contains(&context, "(! ABC) Tj"));
assert!(exported_text_x(&rtl, "! ABC") > exported_text_x(&context, "ABC !"));
}
#[test]
fn rtl_sheet_sparkline_reflects_with_cell_geometry() {
let mut wb = Workbook::new();
let sh = wb.sheet_mut(0).unwrap();
sh.set_value(CellRef::new(0, 0), Value::Number(1.0));
sh.set_value(CellRef::new(1, 0), Value::Number(3.0));
sh.sparklines.push(Sparkline {
cell: CellRef::new(0, 1),
source: "A1:A2".into(),
kind: SparklineKind::Line,
color: Color::rgb(255, 0, 0),
markers: false,
});
let options = PrintOptions { range: RangeRef::parse("A1:B2"), ..PrintOptions::default() };
let ltr = render_pdf(&wb, &layouts(&wb, &options), "", "").unwrap().bytes;
wb.sheet_mut(0).unwrap().right_to_left = true;
let rtl = render_pdf(&wb, &layouts(&wb, &options), "", "").unwrap().bytes;
let points = |pdf: &[u8]| {
let pdf = String::from_utf8_lossy(pdf);
let after = pdf.split("1 0 0 RG\n").nth(1).unwrap();
let line = after.lines().find(|line| line.ends_with(" l S")).unwrap();
let values: Vec<_> = line.split_whitespace().collect();
(values[0].parse::<f32>().unwrap(), values[3].parse::<f32>().unwrap())
};
let (left0, left1) = points(&ltr);
let (right0, right1) = points(&rtl);
assert!(left0 < left1 && right0 > right1);
assert!((left0 + right0 - 612.0).abs() < 0.001);
assert!((left1 + right1 - 612.0).abs() < 0.001);
}
#[test]
fn explicit_left_and_right_keep_their_side_on_a_right_to_left_sheet() {
let mut s = s();
s.execute("range.setValues", json!({"range": "A1", "values": [["LEFT"], ["RIGHT"]]})).unwrap();
s.execute("home.alignLeft", json!({"range": "A1"})).unwrap();
s.execute("home.alignRight", json!({"range": "A2"})).unwrap();
let (ltr, _) = pdf_of(&mut s, json!({}));
s.execute("view.rightToLeft", json!({"on": true})).unwrap();
let (rtl, _) = pdf_of(&mut s, json!({}));
let width = |label| gridcraft_pdf::text_width(Font::Helvetica, 11.0, label);
let (left, right) = (width("LEFT"), width("RIGHT"));
let ltr_gap = exported_text_x(&ltr, "RIGHT") + right - exported_text_x(&ltr, "LEFT");
let rtl_gap = exported_text_x(&rtl, "RIGHT") + right - exported_text_x(&rtl, "LEFT");
assert!((ltr_gap - rtl_gap).abs() < 0.01, "Left stays left of Right in the cell: {ltr_gap}, {rtl_gap}");
assert!(exported_text_x(&rtl, "LEFT") + left < exported_text_x(&rtl, "RIGHT") + right);
}
#[test]
fn rtl_sheet_pdf_mirrors_cells_merges_headings_and_object_anchors() {
let mut s = s();
s.execute("range.setValues", json!({"range": "A1", "values": [["FIRST", "SECOND"], [null, "MERGED"]]})).unwrap();
s.execute("home.mergeCenter", json!({"range": "B2:C2"})).unwrap();
s.execute("pageLayout.pageSetup", json!({"printArea": "A1:D5", "headings": true, "gridlines": true, "left": 0.8, "right": 0.4})).unwrap();
s.execute("insert.shape", json!({"kind": "rectangle", "at": "B4", "width": 128, "height": 30, "text": "OBJECT"})).unwrap();
let (ltr, _) = pdf_of(&mut s, json!({}));
s.execute("view.rightToLeft", json!({"on": true})).unwrap();
let (rtl, _) = pdf_of(&mut s, json!({}));
for label in ["FIRST", "SECOND", "MERGED", "A", "B", "C", "D", "1", "2", "OBJECT"] {
let left = exported_text_x(&ltr, label);
let right = exported_text_x(&rtl, label);
let font_size = if ["A", "B", "C", "D", "1", "2"].contains(&label) { 9.0 } else { 11.0 };
let width = gridcraft_pdf::text_width(Font::Helvetica, font_size, label);
assert!((left + right + width - 612.0).abs() < 0.01, "{label}: {left}, {right}, {width}");
}
assert!(exported_text_x(&ltr, "FIRST") < exported_text_x(&ltr, "SECOND"));
assert!(exported_text_x(&rtl, "FIRST") > exported_text_x(&rtl, "SECOND"));
for (name, pdf) in [("ltr", ltr), ("rtl", rtl)] {
let path = std::env::temp_dir().join(format!("gridcraft-print-direction-{name}-{}.pdf", std::process::id()));
std::fs::write(&path, pdf).unwrap();
eprintln!("Print direction PDF artifact: {}", path.display());
}
}
#[test]
fn header_sections_split_join_and_field_names() {
let spec = "&L&\"Arial,Bold\"Sales &&Co&CPage &P of &N&R&D";
@@ -694,11 +917,32 @@ fn bands_unit() {
let b = bands(0, 2, |r| if r == 1 { 100.0 } else { 10.0 }, |_| 35.0, &[], 100);
assert_eq!(b, vec![(0, 0), (1, 1), (2, 2)]);
assert_eq!(bands(0, 1_000_000, |_| 10.0, |_| 5.0, &[], 3).len(), 3);
let w = wrap_lines("the quick brown fox jumps", Font::Helvetica, 10.0, 50.0);
let w = wrap_lines("the quick brown fox jumps", Font::Helvetica, 10.0, 50.0, TextDirection::Auto);
assert!(w.len() >= 2);
assert!(w.iter().all(|l| gridcraft_pdf::text_width(Font::Helvetica, 10.0, l) <= 50.0 || !l.contains(' ')));
let w = wrap_lines("Supercalifragilistic", Font::Helvetica, 10.0, 20.0);
assert!(w.iter().all(|l| gridcraft_pdf::text_width_with_direction(Font::Helvetica, 10.0, &l.text, l.direction) <= 50.0 || !l.text.contains(' ')));
let w = wrap_lines("Supercalifragilistic", Font::Helvetica, 10.0, 20.0, TextDirection::Auto);
assert!(w.len() > 2);
let long = "abcdefghij".repeat(300);
let w = wrap_lines(&long, Font::Helvetica, 10.0, 50.0, TextDirection::Auto);
assert_eq!(w.iter().map(|l| l.text.as_str()).collect::<String>(), long);
assert!(w.iter().all(|l| gridcraft_pdf::text_width_with_direction(Font::Helvetica, 10.0, &l.text, l.direction) <= 50.0));
let mut at = 0;
for l in &w[..w.len() - 1] {
let one_more = &long[at..at + l.text.len() + 1];
assert!(gridcraft_pdf::text_width_with_direction(Font::Helvetica, 10.0, one_more, l.direction) > 50.0, "each split is as long as fits");
at += l.text.len();
}
}
fn wrapped_text(text: &str, font: Font, size: f32, width: f32) -> Vec<String> {
wrap_lines(text, font, size, width, TextDirection::Auto).into_iter().map(|line| line.text).collect()
}
#[test]
fn wrapping_ignores_the_width_of_undrawn_bidi_marks() {
let word = "i\u{200e}".repeat(20);
assert!(gridcraft_pdf::text_width(Font::Helvetica, 10.0, &word) <= 50.0);
assert_eq!(wrapped_text(&word, Font::Helvetica, 10.0, 50.0), vec![word.clone()]);
}
/// The wrapper `wrap_lines` replaced, re-measuring strings, as the reference for its lines.
@@ -755,7 +999,11 @@ fn wrap_lines_matches_the_remeasuring_wrapper() {
for text in texts {
for font in [Font::Helvetica, Font::HelveticaBold, Font::Courier] {
for (size, width) in [(10.0, 50.0), (10.0, 20.0), (11.0, 1.0), (8.0, 300.0), (12.0, 0.0)] {
assert_eq!(wrap_lines(text, font, size, width), wrap_lines_remeasuring(text, font, size, width), "{text:?} {font:?} {size} {width}");
assert_eq!(
wrapped_text(text, font, size, width),
wrap_lines_remeasuring(text, font, size, width),
"{text:?} {font:?} {size} {width}"
);
}
}
}
@@ -766,12 +1014,24 @@ fn wrapping_a_long_word_in_a_narrow_box_stops_at_the_line_limit() {
// One character per line: the old wrapper re-measured and copied the rest of the word for
// each of the 100,000 lines before checking the limit.
let word = "w".repeat(100_000);
let lines = wrap_lines(&word, Font::Helvetica, 10.0, 1.0);
let lines = wrapped_text(&word, Font::Helvetica, 10.0, 1.0);
assert!(lines.len() <= 2002, "{}", lines.len());
assert!(lines.iter().all(|l| l == "w"));
// A long paragraph in a very wide box is one line.
let para = vec!["word"; 50_000].join(" ");
assert_eq!(wrap_lines(&para, Font::Helvetica, 10.0, 1.0e9), vec![para.clone()]);
assert_eq!(wrapped_text(&para, Font::Helvetica, 10.0, 1.0e9), vec![para.clone()]);
}
#[test]
fn wrapping_a_long_arabic_word_measures_pieces_not_the_rest_of_the_word() {
let word = "مرحبا".repeat(10_000);
if !arabic_face_available() {
return;
}
let lines = wrapped_text(&word, Font::Helvetica, 10.0, 20.0);
assert!(lines.len() > 2000 && lines.len() <= 2002, "{}", lines.len());
assert!(lines.iter().take(2000).all(|line| gridcraft_pdf::text_width(Font::Helvetica, 10.0, line) <= 20.0));
assert!(word.starts_with(&lines.concat()));
}
#[test]
+185 -68
View File
@@ -1,78 +1,176 @@
use super::draw::{Block, Look, rgb_of};
use super::{CellRef, Color, Font, HAlign, MAX_COLS, Page, Point, RangeRef, Sheet, Style, StyleTable, Underline, VAlign, Value};
use super::{
Baseline, CellRef, Color, Font, HAlign, MAX_COLS, Page, Point, RangeRef, ReadingOrder, Sheet, Style, StyleTable, TextDirection, Underline,
VAlign, Value,
};
use unicode_segmentation::UnicodeSegmentation;
const PAD_PX: f32 = 2.0;
/// Most lines [`wrap_lines`] returns (it may return one more, the rest of a paragraph).
const MAX_WRAP_LINES: usize = 2000;
/// Word-wraps `text` to `width` points.
pub(super) struct TextLine {
pub(super) text: String,
pub(super) direction: TextDirection,
}
/// Word-wraps `text` to `width` points, keeping each paragraph's base direction on every
/// continuation line.
///
/// Widths are kept as running sums of glyph widths (the sum `text_width` makes), so each
/// character is measured once: re-measuring the line for every word, or the rest of an
/// over-long word for every piece cut from it, made a long paragraph or word quadratic.
pub(super) fn wrap_lines(text: &str, font: Font, size: f32, width: f32) -> Vec<String> {
/// A paragraph whose width is not that sum is measured as drawn by [`wrap_measured_paragraph`].
pub(super) fn wrap_lines(text: &str, font: Font, size: f32, width: f32, direction: TextDirection) -> Vec<TextLine> {
let mut out = Vec::new();
for para in text.split('\n') {
let direction = direction.resolve(para);
if gridcraft_pdf::width_is_char_sum(font, para, direction) {
wrap_summed_paragraph(para, font, size, width, direction, &mut out);
} else {
let fits = |s: &str| gridcraft_pdf::text_width_with_direction(font, size, s, direction) <= width;
wrap_measured_paragraph(para, &fits, direction, &mut out);
}
if out.len() > MAX_WRAP_LINES {
return out;
}
}
out
}
fn wrap_summed_paragraph(para: &str, font: Font, size: f32, width: f32, direction: TextDirection, out: &mut Vec<TextLine>) {
let units_of = |s: &str| -> u64 { s.chars().map(|c| u64::from(font.char_width(c))).sum() };
let fits = |units: u64| units as f32 * size / 1000.0 <= width;
let space = units_of(" ");
let mut out = Vec::new();
for para in text.split('\n') {
let mut line = String::new();
let mut line_units: u64 = 0;
for word in para.split(' ') {
let word_units = units_of(word);
if line.is_empty() {
line.push_str(word);
line_units = word_units;
} else if fits(line_units + space + word_units) {
line.push(' ');
line.push_str(word);
line_units += space + word_units;
} else {
out.push(std::mem::take(&mut line));
line.push_str(word);
line_units = word_units;
}
// Break a single over-long word by characters: each piece is the longest that fits
// (at least one character).
if !fits(line_units) && line.chars().nth(1).is_some() {
let mut piece = String::new();
let mut units: u64 = 0;
for c in line.chars() {
let w = u64::from(font.char_width(c));
if !piece.is_empty() && !fits(units + w) {
out.push(std::mem::take(&mut piece));
units = 0;
if out.len() > MAX_WRAP_LINES {
return out;
}
let mut line = String::new();
let mut line_units: u64 = 0;
for word in para.split(' ') {
let word_units = units_of(word);
if line.is_empty() {
line.push_str(word);
line_units = word_units;
} else if fits(line_units + space + word_units) {
line.push(' ');
line.push_str(word);
line_units += space + word_units;
} else {
out.push(TextLine { text: std::mem::take(&mut line), direction });
line.push_str(word);
line_units = word_units;
}
if !fits(line_units) && line.graphemes(true).nth(1).is_some() {
let mut piece = String::new();
let mut units: u64 = 0;
for g in line.graphemes(true) {
let w = units_of(g);
if !piece.is_empty() && !fits(units + w) {
out.push(TextLine { text: std::mem::take(&mut piece), direction });
units = 0;
if out.len() > MAX_WRAP_LINES {
return;
}
piece.push(c);
units += w;
}
line = piece;
line_units = units;
piece.push_str(g);
units += w;
}
if out.len() > MAX_WRAP_LINES {
return out;
line = piece;
line_units = units;
}
if out.len() > MAX_WRAP_LINES {
return;
}
}
out.push(TextLine { text: line, direction });
}
/// One paragraph of [`wrap_lines`] whose width is not a sum of character widths (shaped Arabic,
/// right-to-left reordering or bidi controls), measuring each candidate line as drawn.
fn wrap_measured_paragraph(para: &str, fits: &impl Fn(&str) -> bool, direction: TextDirection, out: &mut Vec<TextLine>) {
let mut line = String::new();
for word in para.split(' ') {
if !line.is_empty() {
let candidate = format!("{line} {word}");
if fits(&candidate) {
line = candidate;
continue;
}
out.push(TextLine { text: std::mem::take(&mut line), direction });
}
line = if fits(word) { word.to_string() } else { break_measured_word(word, fits, direction, out) };
if out.len() > MAX_WRAP_LINES {
return;
}
}
out.push(TextLine { text: line, direction });
}
/// Cuts `word` into the longest grapheme prefixes that fit (at least one grapheme each), pushes
/// all but the last to `out` and returns the last. Each cut gallops from one grapheme, so it
/// measures prefixes about as long as the piece rather than the rest of the word.
fn break_measured_word(word: &str, fits: &impl Fn(&str) -> bool, direction: TextDirection, out: &mut Vec<TextLine>) -> String {
let ends: Vec<usize> = word.grapheme_indices(true).map(|(i, g)| i + g.len()).collect();
let (mut start, mut first) = (0, 0);
loop {
let len = ends.len().saturating_sub(first);
let end = |count: usize| ends.get(first + count.saturating_sub(1)).copied().unwrap_or(word.len());
let fits_prefix = |count: usize| fits(word.get(start..end(count)).unwrap_or_default());
let (mut fit, mut over, mut probe) = (1, len + 1, 2);
while fit < len {
let count = probe.min(len);
if fits_prefix(count) {
fit = count;
probe = count.saturating_mul(2);
} else {
over = count;
break;
}
}
out.push(line);
if fit >= len {
return word.get(start..).unwrap_or_default().to_string();
}
while over - fit > 1 {
let mid = fit + (over - fit) / 2;
if fits_prefix(mid) {
fit = mid;
} else {
over = mid;
}
}
let cut = end(fit);
out.push(TextLine { text: word.get(start..cut).unwrap_or_default().to_string(), direction });
start = cut;
first += fit;
if out.len() > MAX_WRAP_LINES {
return word.get(start..).unwrap_or_default().to_string();
}
}
out
}
fn font_for(style: &Style) -> Font {
Font::styled(Font::family_for(&style.font.name), style.font.bold, style.font.italic)
}
fn text_align(align: HAlign, value: &Value) -> HAlign {
fn text_direction(order: ReadingOrder) -> TextDirection {
match order {
ReadingOrder::Context => TextDirection::Context,
ReadingOrder::LeftToRight => TextDirection::LeftToRight,
ReadingOrder::RightToLeft => TextDirection::RightToLeft,
}
}
/// The alignment a cell is laid out with before a right-to-left sheet is mirrored. Explicit Left
/// and Right are swapped there, as in the grid, so they print on the side the user chose.
fn text_align(align: HAlign, value: &Value, direction: TextDirection, right_to_left_sheet: bool) -> HAlign {
match align {
HAlign::General => match value {
Value::Number(_) => HAlign::Right,
Value::Bool(_) | Value::Error(_) => HAlign::Center,
_ if direction == TextDirection::RightToLeft && !right_to_left_sheet => HAlign::Right,
_ => HAlign::Left,
},
HAlign::Left if right_to_left_sheet => HAlign::Right,
HAlign::Right if right_to_left_sheet => HAlign::Left,
HAlign::CenterAcross | HAlign::Distributed => HAlign::Center,
HAlign::Justify | HAlign::Fill => HAlign::Left,
other => other,
@@ -183,32 +281,46 @@ pub(super) fn draw_text(pg: &mut Page, b: &Block, placement: TextPlacement<'_>)
if text.is_empty() {
return;
}
let mut tw = gridcraft_pdf::text_width(font, size, &text);
let direction = text_direction(st.align.reading_order.unwrap_or_default()).resolve(&text);
let mut tw = gridcraft_pdf::text_width_with_direction(font, size, &text, direction);
if st.align.shrink && !wrap && tw > avail && tw > 0.0 {
size = (size * avail / tw).max(1.0);
tw = gridcraft_pdf::text_width(font, size, &text);
tw = gridcraft_pdf::text_width_with_direction(font, size, &text, direction);
}
if is_num && !wrap && tw > avail + 0.01 && !sh.show_formulas {
let hash = gridcraft_pdf::text_width(font, size, "#").max(0.1);
text = "#".repeat(((avail / hash).floor().max(1.0) as usize).min(255));
tw = gridcraft_pdf::text_width(font, size, &text);
tw = gridcraft_pdf::text_width_with_direction(font, size, &text, direction);
}
let h_align = text_align(st.align.h, &v);
let h_align = text_align(st.align.h, &v, direction, sh.right_to_left);
let rot = st.align.rotation;
let rotated = rot != 0 && rot != 255;
// Rotated text wraps along its own direction: upright (±90°) text to the row height.
let lines: Vec<String> = match (wrap, rotated) {
(true, false) => wrap_lines(&text, font, size, avail.max(size)),
(true, true) if rot.abs() == 90 => wrap_lines(&text, font, size, (h - 2.0 * pad).max(size)),
(true, true) => vec![text.lines().next().unwrap_or_default().to_string()],
(false, _) => vec![text],
let lines: Vec<TextLine> = match (wrap, rotated) {
(true, false) => wrap_lines(&text, font, size, avail.max(size), direction),
(true, true) if rot.abs() == 90 => wrap_lines(&text, font, size, (h - 2.0 * pad).max(size), direction),
(true, true) => vec![TextLine { text: text.lines().next().unwrap_or_default().to_string(), direction }],
(false, _) => vec![TextLine { text, direction }],
};
let line_h = size * 1.2;
let extents = lines
.iter()
.filter_map(|line| pg.text_vertical_extents_with_direction(font, size, &line.text, line.direction))
.reduce(|a, b| (a.0.max(b.0), a.1.max(b.1)))
.map(|(ascent, descent)| (ascent.max(size * 0.8), descent.max(size * 0.22)));
let line_h = extents.map_or(size * 1.2, |(ascent, descent)| (ascent + descent + size * 0.2).max(size * 1.2));
let n = lines.len().max(1) as f32;
let first_baseline = match st.align.v {
VAlign::Top => y + pad + size * 0.8,
VAlign::Center | VAlign::Justify | VAlign::Distributed => y + (h - n * line_h) / 2.0 + line_h * 0.5 + size * 0.33,
VAlign::Bottom => y + h - pad - size * 0.22 - (n - 1.0) * line_h,
let first_baseline = if let Some((ascent, descent)) = extents {
match st.align.v {
VAlign::Top => y + pad + ascent,
VAlign::Center | VAlign::Justify | VAlign::Distributed => y + (h - (n - 1.0) * line_h - ascent - descent) / 2.0 + ascent,
VAlign::Bottom => y + h - pad - descent - (n - 1.0) * line_h,
}
} else {
match st.align.v {
VAlign::Top => y + pad + size * 0.8,
VAlign::Center | VAlign::Justify | VAlign::Distributed => y + (h - n * line_h) / 2.0 + line_h * 0.5 + size * 0.33,
VAlign::Bottom => y + h - pad - size * 0.22 - (n - 1.0) * line_h,
}
};
// Overflow into empty neighbours (single-line text, not merged).
// Center Across Selection spans the empty Center Across cells to its right; the text stays within that run.
@@ -222,7 +334,7 @@ pub(super) fn draw_text(pg: &mut Page, b: &Block, placement: TextPlacement<'_>)
let clip_l = clip_l.max(limits.0);
let clip_r = clip_r.min(limits.1);
pg.save();
pg.clip_rect(clip_l, y, (clip_r - clip_l).max(0.0), h);
pg.clip_rect(b.text_x(clip_l, clip_r - clip_l), y, (clip_r - clip_l).max(0.0), h);
if rotated {
// Rotated text: anchored at the bottom-left (upward) or top-left (downward) of the cell.
// Wrapped lines stack rightward for upward text and leftward for downward text, so
@@ -233,23 +345,27 @@ pub(super) fn draw_text(pg: &mut Page, b: &Block, placement: TextPlacement<'_>)
for (i, t) in lines.iter().enumerate() {
let i = i as f32;
let (ox, oy) = if deg > 0.0 {
(x + pad + size * 0.8 * deg.to_radians().sin() + i * line_h, y + h - pad)
(x + pad + extents.map_or(size * 0.8, |e| e.0) * deg.to_radians().sin() + i * line_h, y + h - pad)
} else {
(x + pad + (last - i) * line_h, y + pad + size * 0.8)
(x + pad + (last - i) * line_h, y + pad + extents.map_or(size * 0.8, |e| e.0))
};
pg.text_rotated(Point::new(ox, oy), size, font, color, t, angle);
let tw = gridcraft_pdf::text_width_with_direction(font, size, &t.text, t.direction);
let (sn, cs) = angle.sin_cos();
let (ascent, descent) = extents.unwrap_or((size * 0.8, size * 0.22));
let ox = if sh.right_to_left { b.mirror_axis - ox - tw * cs - (ascent - descent) * sn } else { ox };
pg.text_rotated_with_direction(Baseline { origin: Point::new(ox, oy), angle }, size, font, color, &t.text, t.direction);
}
pg.restore();
return;
}
if rot == 255 {
// Vertical stacked text.
let chars: Vec<char> = lines.concat().chars().take(500).collect();
let mut yy = y + pad + size * 0.8;
let stacked: String = lines.iter().map(|line| line.text.as_str()).collect();
let chars: Vec<&str> = stacked.graphemes(true).take(500).collect();
let mut yy = y + pad + extents.map_or(size * 0.8, |e| e.0);
for ch in chars {
let s = ch.to_string();
let cw = gridcraft_pdf::text_width(font, size, &s);
pg.text(x + (w - cw) / 2.0, yy, size, font, color, &s);
let cw = gridcraft_pdf::text_width(font, size, ch);
pg.text_with_direction(Point::new(b.text_x(x + (w - cw) / 2.0, cw), yy), size, font, color, ch, direction);
yy += line_h;
if yy > y + h + line_h {
break;
@@ -259,7 +375,7 @@ pub(super) fn draw_text(pg: &mut Page, b: &Block, placement: TextPlacement<'_>)
return;
}
for (i, line) in lines.iter().enumerate() {
let lw = gridcraft_pdf::text_width(font, size, line);
let lw = gridcraft_pdf::text_width_with_direction(font, size, &line.text, line.direction);
let lx = match h_align {
HAlign::Right => x + w - pad - lw - indent,
HAlign::Center => x + (w + across - lw) / 2.0,
@@ -269,7 +385,8 @@ pub(super) fn draw_text(pg: &mut Page, b: &Block, placement: TextPlacement<'_>)
if ly - size > y + h || ly < y - line_h {
continue;
}
pg.text(lx, ly, size, font, color, line);
let lx = b.text_x(lx, lw);
pg.text_with_direction(Point::new(lx, ly), size, font, color, &line.text, line.direction);
if st.font.underline != Underline::None {
let uw = (size * 0.06).max(0.2);
pg.stroke_line(lx, ly + size * 0.12, lx + lw, ly + size * 0.12, uw, color);
+241
View File
@@ -0,0 +1,241 @@
//! Insert › Text › WordArt: decorative text as a floating shape (`ShapeKind::WordArt`) built on
//! the text-box machinery (anchor, move/resize/delete, undo, XLSX shape text body, printing).
//! The style palette below is original to GridCraft.
use gridcraft_model::{Anchor, Color, Shape, ShapeFormat, ShapeKind, ShapeTextAlign, ShapeTextAnchor};
use serde_json::{Value as Json, json};
use super::{
CommandSpec, EngineError, PROTECTED, Result, Session, anchor_mode_param, bad, bool_param, cell_param, cmd, edit, f64_param, has_doc, ok,
u32_param,
};
/// One entry of the style gallery.
pub struct WordArtStyle {
pub name: &'static str,
pub fill: Color,
pub outline: Option<(Color, f32)>,
pub shadow: Option<Color>,
pub bold: bool,
pub italic: bool,
/// Font size in points.
pub size: f32,
}
const fn rgb(v: u32) -> Color {
Color::Rgb(v)
}
/// GridCraft's own WordArt presets. Theme colours where it makes sense (they follow the theme),
/// fixed colours for the rest.
pub const STYLES: [WordArtStyle; 10] = [
WordArtStyle { name: "Classic", fill: Color::Theme(4, 0), outline: None, shadow: None, bold: true, italic: false, size: 36.0 },
WordArtStyle { name: "Midnight", fill: rgb(0x1B2A49), outline: None, shadow: Some(rgb(0x8A94A6)), bold: true, italic: false, size: 40.0 },
WordArtStyle { name: "Sunrise", fill: rgb(0xF2A33A), outline: Some((rgb(0xB5451B), 1.5)), shadow: None, bold: true, italic: false, size: 40.0 },
WordArtStyle {
name: "Lagoon",
fill: rgb(0x1F9E9A),
outline: Some((rgb(0x0B4F5C), 1.0)),
shadow: Some(rgb(0x9CC9C7)),
bold: true,
italic: true,
size: 36.0,
},
WordArtStyle { name: "Ember", fill: rgb(0xD64527), outline: None, shadow: Some(rgb(0x5A1A0E)), bold: true, italic: false, size: 44.0 },
WordArtStyle {
name: "Mint Outline",
fill: rgb(0xFFFFFF),
outline: Some((rgb(0x2E9B6A), 2.0)),
shadow: None,
bold: true,
italic: false,
size: 40.0,
},
WordArtStyle { name: "Ink Stamp", fill: rgb(0x2F3A8F), outline: Some((rgb(0x2F3A8F), 0.5)), shadow: None, bold: true, italic: false, size: 32.0 },
WordArtStyle { name: "Orchid", fill: rgb(0x8E4FB5), outline: None, shadow: Some(rgb(0xD9C2E8)), bold: false, italic: true, size: 40.0 },
WordArtStyle {
name: "Graphite",
fill: rgb(0x4A4F57),
outline: Some((rgb(0xFFFFFF), 1.0)),
shadow: Some(rgb(0x9AA0A8)),
bold: true,
italic: false,
size: 36.0,
},
WordArtStyle {
name: "Lime Pop",
fill: rgb(0xA6D61C),
outline: Some((rgb(0x3F5A00), 1.5)),
shadow: Some(rgb(0x6E8B2C)),
bold: true,
italic: true,
size: 40.0,
},
];
/// The text of a WordArt inserted without `text`.
pub const DEFAULT_TEXT: &str = "Your text here";
/// Longest WordArt text (characters).
pub const MAX_CHARS: usize = 1000;
const MAX_POINTS: f64 = 400.0;
const MAX_SIDE: f64 = 4000.0;
pub fn specs() -> Vec<CommandSpec> {
vec![
cmd!(
"insert.wordArt",
"WordArt",
["Insert", "Text"],
None,
"{style?: preset name or 0-based index (Classic, Midnight, Sunrise, Lagoon, Ember, Mint Outline, Ink Stamp, Orchid, Graphite, Lime Pop), text?, at?, width?, height?, fontSize?, bold?, italic?, fill?: hex, outline?: hex|false, outlineWidth?, shadow?: hex|bool}",
has_doc,
insert_word_art
),
cmd!(
"wordArt.set",
"Format WordArt",
[],
None,
"{id: WordArt id, style?, text?, fontSize?, bold?, italic?, fill?: hex, outline?: hex|false, outlineWidth?, shadow?: hex|bool}",
has_doc,
set_word_art
),
]
}
fn style_param(command: &str, p: &Json) -> Result<Option<&'static WordArtStyle>> {
match p.get("style") {
None | Some(Json::Null) => Ok(None),
Some(Json::Number(n)) => n
.as_u64()
.and_then(|i| STYLES.get(usize::try_from(i).ok()?))
.map(Some)
.ok_or_else(|| bad(command, format!("`style` index must be 0..{}", STYLES.len() - 1))),
Some(Json::String(name)) => STYLES
.iter()
.find(|s| s.name.eq_ignore_ascii_case(name.trim()))
.map(Some)
.ok_or_else(|| bad(command, format!("unknown WordArt style `{name}`"))),
Some(_) => Err(bad(command, "`style` must be a preset name or index")),
}
}
fn text_param(command: &str, p: &Json) -> Result<Option<String>> {
match p.get("text") {
None | Some(Json::Null) => Ok(None),
Some(Json::String(t)) if t.is_empty() => Err(bad(command, "`text` must not be empty")),
Some(Json::String(t)) if t.chars().nth(MAX_CHARS).is_some() => Err(bad(command, format!("`text` is longer than {MAX_CHARS} characters"))),
Some(Json::String(t)) => Ok(Some(t.clone())),
Some(_) => Err(bad(command, "`text` must be a string")),
}
}
/// Applies a preset, then explicit overrides, to a shape's format and fill.
fn apply(command: &str, shape: &mut Shape, style: Option<&WordArtStyle>, p: &Json) -> Result<()> {
if let Some(st) = style {
shape.format.text_color = Some(st.fill);
shape.format.text_outline = st.outline;
shape.format.text_shadow = st.shadow;
shape.format.bold = st.bold;
shape.format.italic = st.italic;
shape.format.font_size = Some(st.size);
}
let f = &mut shape.format;
if let Some(c) = p.get("fill").filter(|v| !v.is_null()) {
f.text_color = Some(super::format::color_param(Some(c)).ok_or_else(|| bad(command, "`fill` must be a hex colour"))?);
}
match p.get("outline") {
None | Some(Json::Null) => {}
Some(Json::Bool(false)) => f.text_outline = None,
Some(v) => {
let c = super::format::color_param(Some(v)).ok_or_else(|| bad(command, "`outline` must be a hex colour or false"))?;
let w = f64_param(p, "outlineWidth").map_or(f.text_outline.map_or(1.5, |o| o.1), |w| w.clamp(0.25, 20.0) as f32);
f.text_outline = Some((c, w));
}
}
if let (Some(w), Some((c, _))) = (f64_param(p, "outlineWidth"), f.text_outline) {
f.text_outline = Some((c, w.clamp(0.25, 20.0) as f32));
}
match p.get("shadow") {
None | Some(Json::Null) => {}
Some(Json::Bool(false)) => f.text_shadow = None,
Some(Json::Bool(true)) => f.text_shadow = Some(f.text_shadow.unwrap_or(rgb(0x808080))),
Some(v) => {
f.text_shadow = Some(super::format::color_param(Some(v)).ok_or_else(|| bad(command, "`shadow` must be a hex colour or a boolean"))?)
}
}
if let Some(b) = bool_param(p, "bold") {
f.bold = b;
}
if let Some(b) = bool_param(p, "italic") {
f.italic = b;
}
if let Some(sz) = f64_param(p, "fontSize") {
f.font_size = Some(sz.clamp(1.0, MAX_POINTS) as f32);
}
Ok(())
}
fn insert_word_art(s: &mut Session, p: &Json) -> Result<Json> {
let style = style_param("insert.wordArt", p)?.unwrap_or(&STYLES[0]);
let text = text_param("insert.wordArt", p)?.unwrap_or_else(|| DEFAULT_TEXT.to_string());
let d = s.doc()?;
if d.wb.active().is_some_and(|sh| sh.is_protected()) {
return Err(EngineError::Other(PROTECTED.into()));
}
let id = d.wb.next_object_id();
let at = cell_param(s, p, "at")?.unwrap_or(d.selection.active);
let mut shape = Shape {
id,
kind: ShapeKind::WordArt,
anchor: Anchor { cell: at, dx: 0.0, dy: 0.0, width: 0.0, height: 0.0, mode: anchor_mode_param(p).unwrap_or_default() },
fill: Color::Auto,
line: Color::Auto,
text: text.clone(),
format: ShapeFormat { no_line: true, align: Some(ShapeTextAlign::Center), anchor: Some(ShapeTextAnchor::Middle), ..Default::default() },
math: Default::default(),
};
apply("insert.wordArt", &mut shape, Some(style), p)?;
// Default box: the longest line at the font size (about 0.62 em per character) plus padding.
let pt = f64::from(shape.format.font_size.unwrap_or(36.0));
let longest = text.split('\n').map(|l| l.chars().count()).max().unwrap_or(1) as f64;
let lines = text.split('\n').count() as f64;
let width = f64_param(p, "width").unwrap_or(longest * pt * 0.62 * 96.0 / 72.0 + 24.0).clamp(8.0, MAX_SIDE);
let height = f64_param(p, "height").unwrap_or(lines * pt * 1.35 * 96.0 / 72.0 + 12.0).clamp(8.0, MAX_SIDE);
shape.anchor.width = width as f32;
shape.anchor.height = height as f32;
let sheet = d.wb.active_sheet();
edit(s, |cx| {
cx.sheet_mut(sheet)?.shapes.push(shape);
Ok(json!({"shape": id}))
})
}
fn set_word_art(s: &mut Session, p: &Json) -> Result<Json> {
let id = u32_param(p, "id").ok_or_else(|| bad("wordArt.set", "`id` must be a WordArt id"))?;
let style = style_param("wordArt.set", p)?;
let text = text_param("wordArt.set", p)?;
let d = s.doc()?;
let sheet = d.wb.active_sheet();
let sh = d.wb.active().ok_or_else(|| bad("wordArt.set", "no such WordArt"))?;
let current = sh.shapes.iter().find(|x| x.id == id).ok_or_else(|| bad("wordArt.set", "no such WordArt"))?;
if current.kind != ShapeKind::WordArt {
return Err(bad("wordArt.set", "the shape is not WordArt"));
}
if sh.is_protected() {
return Err(EngineError::Other(PROTECTED.into()));
}
let mut updated = current.clone();
apply("wordArt.set", &mut updated, style, p)?;
if let Some(t) = text {
updated.text = t;
}
if &updated == current {
return ok();
}
edit(s, |cx| {
let shape = cx.sheet_mut(sheet)?.shapes.iter_mut().find(|x| x.id == id).ok_or_else(|| bad("wordArt.set", "no such WordArt"))?;
*shape = updated;
Ok(Json::Null)
})
}
+18 -1
View File
@@ -305,6 +305,19 @@ fn trim_to_budget(history: &mut Vec<HistoryEntry>, byte_budget: usize) {
}
}
/// A writer that only counts the bytes written to it.
struct ByteCounter(usize);
impl std::io::Write for ByteCounter {
fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
self.0 = self.0.saturating_add(buf.len());
Ok(buf.len())
}
fn flush(&mut self) -> std::io::Result<()> {
Ok(())
}
}
impl DocState {
/// A document for `wb`, which came from where `trust` says: [`Trust::FromFile`] for anything
/// read from bytes (a file, a download, a recovery copy), [`Trust::Local`] only for a workbook
@@ -638,7 +651,11 @@ impl Session {
/// Journals a command, then trims the oldest entries past either cap. A recording in progress
/// keeps pointing at the same entry (the steps the trim dropped are lost).
fn push_journal(&mut self, id: &str, params: Json) {
let size = |e: &(String, Json)| serde_json::to_vec(e).map_or(0, |v| v.len());
// Counted as it is written, without building the text: a paste's params can be MBs.
let size = |e: &(String, Json)| {
let mut counter = ByteCounter(0);
serde_json::to_writer(&mut counter, e).map_or(0, |()| counter.0)
};
// `journal` is public: if it was changed from outside, measure it again.
if self.journal_sizes.len() != self.journal.len() {
self.journal_sizes = self.journal.iter().map(size).collect();
+141 -17
View File
@@ -43,6 +43,10 @@ impl Selection {
pub fn is_single_cell(&self) -> bool {
self.ranges.len() == 1 && self.current().is_single()
}
/// Whether the selection is exactly one merged cell, which Enter and Tab treat as one cell.
pub fn is_one_merged_cell(&self, sheet: &Sheet) -> bool {
self.ranges.len() == 1 && sheet.merge_at(self.active).is_some_and(|m| m == self.current())
}
/// The corner of the current area opposite the anchor: the end that Shift+arrows move.
pub fn moving_end(&self) -> CellRef {
let r = self.current();
@@ -67,23 +71,28 @@ impl Selection {
/// they are: clicking column B's header selects just B even when B1:C1 is merged, as in Excel.
pub fn expand_merges(&mut self, sheet: &Sheet) {
for r in self.ranges.iter_mut() {
if r.is_full_cols() || r.is_full_rows() {
continue;
}
let mut cur = *r;
loop {
let mut grown = cur;
for m in &sheet.merges {
if m.intersects(&grown) {
grown = grown.union(m);
}
}
if grown == cur {
break;
}
cur = grown;
}
*r = cur;
*r = with_merges(sheet, *r);
}
}
/// Shift+arrows: moves the edge of the current area that the anchor doesn't hold by `dr`
/// rows and `dc` columns, keeping merged cells whole, as Excel does. The anchor is the whole
/// merged cell it is in, so from a selected merged cell Shift+Left and Shift+Up widen the
/// selection past its left and top edges. A step that would shrink the area onto the inside
/// of a merged cell (where keeping it whole would undo the step) goes on to the next line
/// that does shrink it, and when the area can't shrink any more it grows in that direction.
pub fn extend_by(&mut self, sheet: &Sheet, dr: i64, dc: i64) {
let anchor = sheet.merge_at(self.anchor).unwrap_or(RangeRef::cell(self.anchor));
let mut r = self.current();
if dc != 0 {
r = step_edge(sheet, r, anchor, dc, true);
}
if dr != 0 {
r = step_edge(sheet, r, anchor, dr, false);
}
if let Some(last) = self.ranges.last_mut() {
*last = r;
} else {
self.ranges.push(r);
}
}
/// Moves the active cell within the selection (Enter/Tab inside a multi-cell selection).
@@ -128,6 +137,91 @@ impl Selection {
}
}
/// `r` grown until every merged cell it touches is inside it. Whole columns and whole rows stay
/// as they are.
fn with_merges(sheet: &Sheet, r: RangeRef) -> RangeRef {
if r.is_full_cols() || r.is_full_rows() {
return r;
}
let mut cur = r;
loop {
let mut grown = cur;
for m in &sheet.merges {
if m.intersects(&grown) {
grown = grown.union(m);
}
}
if grown == cur {
return cur;
}
cur = grown;
}
}
/// One Shift+arrow step of [`Selection::extend_by`] along one axis (`cols`: columns, else rows).
fn step_edge(sheet: &Sheet, r: RangeRef, anchor: RangeRef, d: i64, cols: bool) -> RangeRef {
let max = i64::from(if cols { MAX_COLS } else { MAX_ROWS }) - 1;
let hidden = |i: i64| if cols { sheet.is_col_hidden(i as u32) } else { sheet.is_row_hidden(i as u32) };
// `from` moved by `by`, then on past hidden lines in the same direction (not off the sheet).
let land = |from: i64, by: i64| {
let mut t = from.saturating_add(by).clamp(0, max);
// Bounded like the arrow keys' walk over hidden lines.
for _ in 0..100_000 {
if !hidden(t) {
break;
}
let n = (t + by.signum()).clamp(0, max);
if n == t {
break;
}
t = n;
}
t
};
let span = |x: &RangeRef| {
if cols { (i64::from(x.start.col), i64::from(x.end.col)) } else { (i64::from(x.start.row), i64::from(x.end.row)) }
};
let with = |lo: i64, hi: i64| {
let (lo, hi) = (lo.clamp(0, max) as u32, hi.clamp(0, max) as u32);
let (s, e) = if cols {
(CellRef::new(r.start.row, lo), CellRef::new(r.end.row, hi))
} else {
(CellRef::new(lo, r.start.col), CellRef::new(hi, r.end.col))
};
with_merges(sheet, RangeRef::new(s, e))
};
let (lo, hi) = span(&r);
let (alo, ahi) = span(&anchor);
// The anchor holds the low edge unless the area reaches past it on that side.
let moving_hi = lo >= alo;
let shrinking = if moving_hi { d < 0 && hi > ahi } else { d > 0 && lo < alo };
if shrinking {
let mut t = if moving_hi { hi } else { lo };
let mut by = d;
loop {
t = if moving_hi { land(t, by).max(ahi) } else { land(t, by).min(alo) };
let cand = if moving_hi { with(lo, t) } else { with(t, hi) };
if cand != r {
return cand;
}
if t == if moving_hi { ahi } else { alo } {
break;
}
// The step was undone because a merged cell crosses the new edge, and so is every
// edge up to where that merged cell starts (ends, for the low edge): go on from there
// so a tall or wide merged cell costs one step, not one per line it covers.
let across = sheet.merges.iter().filter(|m| m.intersects(&r)).filter_map(|m| {
let (ms, me) = span(m);
if moving_hi { (ms <= t && me > t).then_some(ms) } else { (ms < t && me >= t).then_some(me) }
});
t = if moving_hi { across.min().map_or(t, |ms| ms.min(t)) } else { across.max().map_or(t, |me| me.max(t)) };
by = d.signum();
}
}
// Grow the area on the side the arrow points to.
if d > 0 { with(lo, land(hi, d)) } else { with(land(lo, d), hi) }
}
impl Selection {
/// Ctrl+. (Next Corner of Selection): the active cell moves clockwise to the next corner of
/// the current area (top-left, top-right, bottom-right, bottom-left) and becomes the anchor,
@@ -287,6 +381,36 @@ mod tests {
assert_eq!(current_region(&s, CellRef::new(5, 0)).a1(), "A1:B20000");
}
#[test]
fn shift_arrows_from_a_merged_cell() {
let mut s = Sheet::new("S");
s.merges.push(RangeRef::parse("B2:C3").unwrap());
let at = |s: &Sheet, a1: &str| {
let mut sel = Selection::at(CellRef::parse(a1).unwrap());
sel.expand_merges(s);
sel
};
for ((dr, dc), want) in [((0, -1), "A2:C3"), ((-1, 0), "B1:C3"), ((0, 1), "B2:D3"), ((1, 0), "B2:C4")] {
let mut sel = at(&s, "B2");
sel.extend_by(&s, dr, dc);
assert_eq!(sel.a1(), want);
}
// Shrinking onto the inside of the merged cell goes on past it.
let mut sel = at(&s, "A1");
sel.extend_by(&s, 1, 1);
assert_eq!(sel.a1(), "A1:C3");
sel.extend_by(&s, 0, -1);
assert_eq!(sel.a1(), "A1:A3");
// A hidden column is stepped over, and the sheet edge stops the area.
s.cols.entry(3).or_default().hidden = true;
let mut sel = at(&s, "B2");
sel.extend_by(&s, 0, 1);
assert_eq!(sel.a1(), "B2:E3");
let mut sel = at(&s, "A1");
sel.extend_by(&s, -1, -1);
assert_eq!(sel.a1(), "A1");
}
#[test]
fn cycling() {
let mut sel = Selection::range(RangeRef::parse("A1:B2").unwrap());
+243
View File
@@ -532,6 +532,118 @@ fn shape_text_edit_survives_xlsx_roundtrip() {
assert_eq!(shape.text, text);
}
#[test]
fn word_art_insert_respects_sheet_protection() {
let mut s = s();
s.execute("review.protectSheet", json!({})).unwrap();
let before = s.doc().unwrap().wb.clone();
let undo_len = s.doc().unwrap().undo.len();
assert!(s.execute("insert.wordArt", json!({})).is_err());
assert!(std::sync::Arc::ptr_eq(&s.doc().unwrap().wb, &before));
assert_eq!(s.doc().unwrap().undo.len(), undo_len);
s.execute("review.unprotectSheet", json!({})).unwrap();
s.execute("insert.wordArt", json!({})).unwrap();
assert_eq!(s.doc().unwrap().wb.active().unwrap().shapes.len(), 1);
}
#[test]
fn word_art_inserts_with_defaults_and_undoes() {
use gridcraft_model::ShapeKind;
let mut s = s();
// Empty params: default style and text, no dialog.
let r = s.execute("insert.wordArt", json!({})).unwrap();
assert!(s.take_ui_requests().is_empty());
let shape = s.doc().unwrap().wb.active().unwrap().shapes[0].clone();
assert_eq!(shape.id, r["shape"].as_u64().unwrap() as u32);
assert_eq!(shape.kind, ShapeKind::WordArt);
assert_eq!(shape.text, crate::cmd::wordart::DEFAULT_TEXT);
assert!(shape.anchor.width > 8.0 && shape.format.text_color.is_some());
// Named style plus overrides; restyle and edit the text through wordArt.set.
s.execute("insert.wordArt", json!({"style": "ember", "text": "Q3", "fontSize": 60, "shadow": false, "outline": "#112233", "outlineWidth": 3}))
.unwrap();
let ember = s.doc().unwrap().wb.active().unwrap().shapes[1].clone();
assert_eq!(ember.format.font_size, Some(60.0));
assert_eq!((ember.format.text_shadow, ember.format.text_outline.map(|o| o.1)), (None, Some(3.0)));
s.execute("wordArt.set", json!({"id": ember.id, "style": 3, "text": "Q4"})).unwrap();
let styled = s.doc().unwrap().wb.active().unwrap().shapes[1].clone();
assert_eq!((styled.text.as_str(), styled.format.italic), ("Q4", true));
s.execute("shape.setText", json!({"id": ember.id, "text": "Q5"})).unwrap();
s.execute("edit.undo", json!({})).unwrap();
s.execute("edit.undo", json!({})).unwrap();
assert_eq!(s.doc().unwrap().wb.active().unwrap().shapes[1], ember);
s.execute("edit.redo", json!({})).unwrap();
assert_eq!(s.doc().unwrap().wb.active().unwrap().shapes[1].text, "Q4");
// Moves and deletes like any floating shape.
s.execute("object.move", json!({"kind": "shape", "id": ember.id, "at": "D4"})).unwrap();
s.execute("object.delete", json!({"kind": "shape", "id": ember.id})).unwrap();
assert_eq!(s.doc().unwrap().wb.active().unwrap().shapes.len(), 1);
}
#[test]
fn word_art_rejects_hostile_params() {
let mut s = s();
let id = s.execute("insert.wordArt", json!({})).unwrap()["shape"].clone();
let rectangle = s.execute("insert.shape", json!({"kind": "rectangle"})).unwrap()["shape"].clone();
let before = s.doc().unwrap().wb.clone();
for (cmd, params) in [
("insert.wordArt", json!({"style": "No Such Style"})),
("insert.wordArt", json!({"style": 99})),
("insert.wordArt", json!({"style": -1})),
("insert.wordArt", json!({"text": 5})),
("insert.wordArt", json!({"text": ""})),
("insert.wordArt", json!({"text": "x".repeat(crate::cmd::wordart::MAX_CHARS + 1)})),
("insert.wordArt", json!({"fill": "not a colour"})),
("wordArt.set", json!({})),
("wordArt.set", json!({"id": 999})),
("wordArt.set", json!({"id": rectangle})),
("shape.setText", json!({"id": id, "text": ""})),
] {
assert!(matches!(s.execute(cmd, params), Err(crate::EngineError::BadParams { .. })), "{cmd}");
assert!(std::sync::Arc::ptr_eq(&s.doc().unwrap().wb, &before));
}
// Absurd sizes are clamped, not trusted.
s.execute("insert.wordArt", json!({"fontSize": 1e12, "width": 1e300, "height": -5})).unwrap();
let big = &s.doc().unwrap().wb.active().unwrap().shapes[2];
assert!(big.anchor.width <= 4000.0 && big.anchor.height >= 8.0 && big.format.font_size == Some(400.0));
}
#[test]
fn word_art_survives_xlsx_roundtrip() {
use gridcraft_model::ShapeKind;
let mut s = s();
s.execute("insert.wordArt", json!({"style": "Lagoon", "text": "Sales <2026>\nOutlook & more"})).unwrap();
let before = s.doc().unwrap().wb.active().unwrap().shapes[0].clone();
let saved = s.execute("file.saveBytes", json!({"format": "xlsx"})).unwrap();
s.execute("file.open", json!({"name": "wordart.xlsx", "base64": saved["base64"]})).unwrap();
let after = &s.doc().unwrap().wb.active().unwrap().shapes[0];
assert_eq!(after.kind, ShapeKind::WordArt);
assert_eq!(after.text, before.text);
assert_eq!(after.format.text_color, before.format.text_color);
assert_eq!(after.format.text_outline, before.format.text_outline);
assert_eq!(after.format.text_shadow, before.format.text_shadow);
assert_eq!((after.format.bold, after.format.italic, after.format.font_size), (true, true, before.format.font_size));
assert!(after.format.no_line);
}
/// White text with a green outline (Mint Outline) prints its outline, so it is not invisible on a
/// white page.
#[test]
fn word_art_outline_prints() {
let mut s = s();
s.execute("insert.wordArt", json!({"style": "Mint Outline", "text": "VISIBLE", "at": "A1"})).unwrap();
let pdf = s.execute("file.exportPdf", json!({"range": "A1:G10"})).unwrap();
let data = crate::io::base64_decode(pdf["base64"].as_str().unwrap()).unwrap();
let text = String::from_utf8_lossy(&data);
let outline = text.matches("0.18 0.608 0.416 rg").count();
assert!(outline >= 1, "the outline colour (2E9B6A) is drawn");
assert_eq!(text.matches("(VISIBLE) Tj").count(), 9, "eight outline copies under the white text");
assert!(text.contains("1 1 1 rg"), "the white fill is drawn on top");
// The last copy drawn is the filled text, in white; every outline copy comes before it.
let before_fill = &text[..text.rfind("(VISIBLE) Tj").unwrap()];
assert!(before_fill.rfind("1 1 1 rg") > before_fill.rfind("0.18 0.608 0.416 rg"), "the white fill is drawn last");
assert_eq!(before_fill.matches("(VISIBLE) Tj").count(), 8);
}
#[test]
fn no_border_clears_only_shared_edges_and_undo_restores_them() {
use gridcraft_core::RangeRef;
@@ -2828,6 +2940,127 @@ fn validation_formulas_are_relative_and_see_the_new_value() {
assert!(!ok(&mut s, "C1", "50"));
}
/// Every value of the active sheet as the incremental recalculation left it must equal a full one.
fn assert_matches_full_recalc(s: &Session) {
let wb = &s.doc().unwrap().wb;
let mut fresh = (**wb).clone();
gridcraft_calc::Calc::new().recalc_all(&mut fresh);
let (a, b) = (wb.active().unwrap(), fresh.active().unwrap());
for row in 0..30 {
for col in 0..12 {
let cell = CellRef { row, col };
assert_eq!(a.value(cell), b.value(cell), "{cell} in memory vs after a full recalc");
}
}
}
#[test]
fn filling_a_formula_next_to_a_spill_matches_a_full_recalc() {
// Found by the command-sequence fuzzer: C14 spills along row 14; filling `=D14:E18` over
// E13:F13 puts two array formulas whose areas run into that spill and into each other. The
// incremental pass left F13 as #SPILL! while a full recalc gave F13 its array and C14
// #SPILL!. The spill that already exists keeps its cells (as in Excel), in both.
let mut s = s();
s.execute("range.setValues", json!({"range": "B18", "values": [[1], [2], [3], [4], [5], [6], [7]]})).unwrap();
s.execute("cell.set", json!({"cell": "C14", "input": "=TRANSPOSE(B18:B24)"})).unwrap();
s.execute("selection.set", json!({"range": "E13"})).unwrap();
s.execute("range.fill", json!({"range": "E13:F13", "input": "=D14:E18"})).unwrap();
assert_eq!(v(&s, "C14"), Value::Number(1.0));
assert_eq!(v(&s, "I14"), Value::Number(7.0));
assert_eq!(v(&s, "F13"), Value::Error(gridcraft_core::CellError::Spill));
assert_matches_full_recalc(&s);
}
#[test]
fn overlapping_spills_keep_the_one_that_exists_whichever_anchor_is_first() {
use gridcraft_core::CellError::Spill;
// E10 spills along row 10, F8 down over F10: F8 is first in reading order, E10 may be first
// to spill. Excel keeps whichever spilled first.
for (first, second) in [(("E10", "=SEQUENCE(1,3)"), ("F8", "=SEQUENCE(5)")), (("F8", "=SEQUENCE(5)"), ("E10", "=SEQUENCE(1,3)"))] {
let mut s = s();
s.execute("cell.set", json!({"cell": first.0, "input": first.1})).unwrap();
s.execute("cell.set", json!({"cell": second.0, "input": second.1})).unwrap();
assert_ne!(v(&s, first.0), Value::Error(Spill), "{} keeps its cells", first.0);
assert_eq!(v(&s, second.0), Value::Error(Spill), "{} is blocked", second.0);
assert_matches_full_recalc(&s);
// Clearing the winner lets the other one spill.
s.execute("edit.clearContents", json!({"range": first.0})).unwrap();
assert_ne!(v(&s, second.0), Value::Error(Spill), "{} spills once {} is cleared", second.0, first.0);
assert_matches_full_recalc(&s);
}
}
#[test]
fn a_spill_growing_into_another_and_back_matches_a_full_recalc_at_every_step() {
use gridcraft_core::CellError::Spill;
// Both arrays already spill; F8 (first in reading order) grows down over E10's spill, takes
// its cells, shrinks back and lets it spill again, then the steps are undone, redone, edited
// inside the contested area and cleared. Every state must match a full recalc.
let mut s = s();
s.execute("cell.set", json!({"cell": "H1", "input": "1"})).unwrap();
s.execute("cell.set", json!({"cell": "F8", "input": "=SEQUENCE(H1)"})).unwrap();
s.execute("cell.set", json!({"cell": "E10", "input": "=SEQUENCE(1,3)*10"})).unwrap();
assert_eq!(v(&s, "G10"), Value::Number(30.0));
assert_matches_full_recalc(&s);
let steps: [(&str, serde_json::Value); 9] = [
("cell.set", json!({"cell": "H1", "input": "5"})),
("cell.set", json!({"cell": "E10", "input": "=SEQUENCE(1,2)*10"})),
("cell.set", json!({"cell": "H1", "input": "1"})),
("edit.undo", json!({})),
("edit.undo", json!({})),
("edit.redo", json!({})),
("cell.set", json!({"cell": "F11", "input": "x"})),
("cell.set", json!({"cell": "H1", "input": "2"})),
("edit.clearContents", json!({"range": "E8:F10"})),
];
for (i, (id, params)) in steps.iter().enumerate() {
s.execute(id, params.clone()).unwrap();
assert_matches_full_recalc(&s);
if i == 0 {
// Both held a spill: reading order gives F8 the cells.
assert_eq!(v(&s, "F12"), Value::Number(5.0));
assert_eq!(v(&s, "E10"), Value::Error(Spill));
}
if i == 2 {
assert_eq!(v(&s, "E10"), Value::Number(10.0));
assert_eq!(v(&s, "F10"), Value::Number(20.0));
}
if i == 3 {
// Undone back to the grown F8.
assert_eq!(v(&s, "F12"), Value::Number(5.0));
assert_eq!(v(&s, "E10"), Value::Error(Spill));
}
if i == 8 {
assert_eq!((v(&s, "F8"), v(&s, "E10"), v(&s, "F9")), (Value::Empty, Value::Empty, Value::Empty));
}
}
}
#[test]
fn overlapping_spills_with_no_history_go_to_the_earlier_anchor() {
use gridcraft_core::CellError::Spill;
// A workbook calculated for the first time (a file that carries no layout) has no entry
// order: the anchor first in reading order wins, whatever order the formulas were set in.
for order in [["E10", "F8"], ["F8", "E10"]] {
let mut s = s();
for a in order {
let input = if a == "E10" { "=SEQUENCE(1,3)" } else { "=SEQUENCE(5)" };
s.execute("cell.set", json!({"cell": a, "input": input})).unwrap();
}
let mut fresh = (*s.doc().unwrap().wb).clone();
for i in 0..fresh.sheets.len() {
let sh = fresh.sheet_mut(i).unwrap();
sh.spill.clear();
sh.spill_ranges.clear();
}
gridcraft_calc::Calc::new().recalc_all(&mut fresh);
let a = fresh.active().unwrap();
let cell = |r: &str| a.value(CellRef::parse(r).unwrap());
assert_ne!(cell("F8"), Value::Error(Spill), "order {order:?}");
assert_eq!(cell("E10"), Value::Error(Spill), "order {order:?}");
}
}
#[test]
fn multi_area_rule_formulas_are_relative_to_the_top_left_cell_of_all_areas() {
// Issue #3152: Excel writes the formula for the top-left cell of all the areas (H26), whatever
@@ -6266,6 +6499,16 @@ mod objects;
mod python_cells;
mod python_commands;
mod python_files;
#[test]
fn text_to_columns_keeps_a_mid_field_quote() {
let mut s = s();
s.execute("cell.set", json!({"cell": "A1", "input": "'5\" pipe,abc"})).unwrap();
s.execute("data.textToColumns", json!({"range": "A1", "delimiters": [","]})).unwrap();
assert_eq!(v(&s, "A1"), Value::text("5\" pipe"));
assert_eq!(v(&s, "B1"), Value::text("abc"));
}
mod seams;
#[test]
+2 -2
View File
@@ -175,8 +175,8 @@ fn text_to_columns_keeps_a_py_piece_as_text() {
s.execute("cell.set", json!({"cell": "A1", "input": "'=PY(\"x\");7"})).unwrap();
assert_eq!(super::v(&s, "A1"), Value::text("=PY(\"x\");7"));
s.execute("data.textToColumns", json!({"range": "A1", "delimiters": [";"]})).unwrap();
// The default text qualifier takes the quotes away, as in Excel.
assert_eq!(super::v(&s, "A1"), Value::text("=PY(x)"), "the piece is kept, not cleared");
// A quote in the middle of a field is kept, as in Excel.
assert_eq!(super::v(&s, "A1"), Value::text("=PY(\"x\")"), "the piece is kept, not cleared");
assert_eq!(code(&s, 0, "A1"), None, "and it is not a Python cell");
assert_eq!(super::v(&s, "B1"), Value::Number(7.0));
}
+1
View File
@@ -18,6 +18,7 @@ mod hidden_sheet_navigation;
mod ink_roundtrip;
mod line_count_overflow;
mod long_operator_chains;
mod merged_selection_keys;
mod offset_overflow;
mod percent_entry;
mod pivot_unknown_func;
@@ -0,0 +1,162 @@
//! Shift+arrows and Enter/Tab on merged cells, as Excel does them.
use gridcraft_engine::Session;
use serde_json::json;
/// A new workbook with B2:C3 merged and nothing selected but A1.
fn merged_book() -> Session {
let mut s = Session::new();
s.new_workbook();
s.execute("selection.set", json!({"range": "B2:C3"})).unwrap();
s.execute("home.mergeCells", json!({})).unwrap();
s.execute("selection.set", json!({"cell": "A1"})).unwrap();
s
}
fn shift(s: &mut Session, dr: i64, dc: i64) -> String {
s.execute("selection.move", json!({"dr": dr, "dc": dc, "extend": true})).unwrap();
s.doc().unwrap().selection.a1()
}
fn enter(s: &mut Session, forward: bool, by_row: bool) -> (String, String) {
s.execute("selection.next", json!({"forward": forward, "byRow": by_row})).unwrap();
let sel = &s.doc().unwrap().selection;
(sel.active.a1(), sel.a1())
}
#[test]
fn shift_arrows_from_a_merged_cell_widen_past_each_edge() {
let mut s = merged_book();
for ((dr, dc), want) in [((0, -1), "A2:C3"), ((-1, 0), "B1:C3"), ((0, 1), "B2:D3"), ((1, 0), "B2:C4")] {
s.execute("selection.set", json!({"cell": "B2"})).unwrap();
assert_eq!(s.doc().unwrap().selection.a1(), "B2:C3");
assert_eq!(shift(&mut s, dr, dc), want, "Shift+({dr},{dc}) from the merged cell B2:C3");
assert_eq!(s.doc().unwrap().selection.active.a1(), "B2", "the active cell stays");
}
}
#[test]
fn shift_arrows_keep_going_and_come_back_to_the_merged_cell() {
let mut s = merged_book();
s.execute("selection.set", json!({"cell": "B2"})).unwrap();
assert_eq!(shift(&mut s, 1, 0), "B2:C4");
assert_eq!(shift(&mut s, 1, 0), "B2:C5");
assert_eq!(shift(&mut s, 1, 0), "B2:C6");
assert_eq!(shift(&mut s, -1, 0), "B2:C5");
s.execute("selection.set", json!({"cell": "B2"})).unwrap();
assert_eq!(shift(&mut s, 0, -1), "A2:C3");
assert_eq!(shift(&mut s, 0, 1), "B2:C3", "back to just the merged cell");
assert_eq!(shift(&mut s, 0, 1), "B2:D3");
assert_eq!(shift(&mut s, -1, 0), "B1:D3");
assert_eq!(shift(&mut s, 1, 0), "B2:D3");
}
#[test]
fn shift_arrows_shrink_past_a_merged_cell_they_pulled_in() {
let mut s = merged_book();
assert_eq!(shift(&mut s, 0, 1), "A1:B1");
assert_eq!(shift(&mut s, 1, 0), "A1:C3", "B2 pulls in the whole merged cell");
assert_eq!(shift(&mut s, 0, -1), "A1:A3", "one step back leaves the merged cell out");
assert_eq!(shift(&mut s, 0, 1), "A1:C3");
assert_eq!(shift(&mut s, -1, 0), "A1:C1");
assert_eq!(shift(&mut s, 1, 0), "A1:C3");
assert_eq!(shift(&mut s, 1, 0), "A1:C4");
}
#[test]
fn enter_and_tab_leave_a_selected_merged_cell() {
let mut s = merged_book();
for (forward, by_row, want) in [(true, false, "B4"), (false, false, "B1"), (true, true, "D2"), (false, true, "A2")] {
s.execute("selection.set", json!({"cell": "B2"})).unwrap();
assert_eq!(enter(&mut s, forward, by_row), (want.to_string(), want.to_string()), "forward {forward} byRow {by_row}");
}
}
#[test]
fn enter_and_tab_out_of_a_merged_cell_step_over_hidden_lines() {
let mut s = merged_book();
s.execute("selection.set", json!({"range": "A4"})).unwrap();
s.execute("home.hideRows", json!({})).unwrap();
s.execute("selection.set", json!({"range": "D1"})).unwrap();
s.execute("home.hideColumns", json!({})).unwrap();
s.execute("selection.set", json!({"cell": "B2"})).unwrap();
assert_eq!(enter(&mut s, true, false).0, "B5", "row 4 is hidden");
s.execute("selection.set", json!({"cell": "B2"})).unwrap();
assert_eq!(enter(&mut s, true, true).0, "E2", "column D is hidden");
s.execute("selection.set", json!({"cell": "B2"})).unwrap();
s.execute("selection.move", json!({"dr": 1})).unwrap();
assert_eq!(s.doc().unwrap().selection.a1(), "B5", "the Down arrow too");
}
#[test]
fn enter_inside_a_selection_visits_a_merged_cell_once() {
let mut s = merged_book();
s.execute("selection.set", json!({"range": "A1:C3", "active": "A1"})).unwrap();
let seen: Vec<String> = (0..6).map(|_| enter(&mut s, true, false).0).collect();
assert_eq!(seen, ["A2", "A3", "B1", "B2", "C1", "A1"]);
assert_eq!(s.doc().unwrap().selection.a1(), "A1:C3", "the selection stays");
let back: Vec<String> = (0..2).map(|_| enter(&mut s, false, false).0).collect();
assert_eq!(back, ["C1", "B2"]);
}
#[test]
fn shift_arrow_that_cannot_shrink_the_area_grows_it() {
// A2:B3 merged, anchor B1: Shift+Down pulls the area out to column A, past the anchor.
// Shift+Right can't shrink it from the left (the merged cell would come back), so it grows.
let mut s = Session::new();
s.new_workbook();
s.execute("selection.set", json!({"range": "A2:B3"})).unwrap();
s.execute("home.mergeCells", json!({})).unwrap();
s.execute("selection.set", json!({"cell": "B1"})).unwrap();
assert_eq!(shift(&mut s, 1, 0), "A1:B3");
assert_eq!(shift(&mut s, 0, 1), "A1:C3");
assert_eq!(s.doc().unwrap().selection.active.a1(), "B1");
}
#[test]
fn shift_left_shrinks_past_a_chain_of_merged_cells_in_one_step() {
// B2:C3 and D3:E4 are both inside A1:E4. Shift+Left from E can't stop in column D (D3:E4
// would come back) and stops in C, where B2:C3 is whole.
let mut s = merged_book();
s.execute("selection.set", json!({"range": "D3:E4"})).unwrap();
s.execute("home.mergeCells", json!({})).unwrap();
s.execute("selection.set", json!({"cell": "A1"})).unwrap();
assert_eq!(shift(&mut s, 3, 4), "A1:E4");
assert_eq!(shift(&mut s, 0, -1), "A1:C4");
assert_eq!(shift(&mut s, -1, 0), "A1:C3", "row 4 holds nothing merged once column D is out");
assert_eq!(shift(&mut s, 0, -1), "A1:A3", "C can't stop inside B2:C3");
}
#[test]
fn shift_up_over_a_tall_merged_cell_takes_one_step() {
let mut s = Session::new();
s.new_workbook();
s.execute("selection.set", json!({"range": "B2:C500000"})).unwrap();
s.execute("home.mergeCells", json!({})).unwrap();
s.execute("selection.set", json!({"cell": "A1"})).unwrap();
assert_eq!(shift(&mut s, 0, 1), "A1:B1");
assert_eq!(shift(&mut s, 1, 0), "A1:C500000");
assert_eq!(shift(&mut s, -1, 0), "A1:C1", "row 1 is the last row above the merged cell");
assert_eq!(shift(&mut s, 1, 0), "A1:C500000");
assert_eq!(shift(&mut s, 0, -1), "A1:A500000");
}
#[test]
fn shift_arrows_change_only_the_last_area() {
let mut s = merged_book();
s.execute("selection.set", json!({"range": "E5:F6,B2"})).unwrap();
assert_eq!(s.doc().unwrap().selection.a1(), "E5:F6,B2:C3");
assert_eq!(shift(&mut s, 0, -1), "E5:F6,A2:C3");
}
#[test]
fn enter_skips_a_merged_cell_whose_start_is_outside_the_selection() {
// A whole column isn't widened to the merged cells it touches. B1 is covered by A1:B1, whose
// top-left cell is outside column B, so Enter skips it.
let mut s = Session::new();
s.new_workbook();
s.execute("selection.set", json!({"range": "A1:B1"})).unwrap();
s.execute("home.mergeCells", json!({})).unwrap();
s.execute("selection.set", json!({"range": "B:B", "active": "B2"})).unwrap();
assert_eq!(enter(&mut s, false, false).0, "B1048576", "B1 is skipped, going up wraps to the bottom");
}
+22 -1
View File
@@ -215,7 +215,9 @@ impl Expr {
/// Visits every node depth-first, parents before children, left to right.
pub fn walk<'a>(&'a self, f: &mut dyn FnMut(&'a Expr)) {
// An explicit stack: a long operator chain must not recurse once per operand.
let mut pending = vec![self];
// Room for a typical formula up front, so walking one costs one allocation, not several.
let mut pending = Vec::with_capacity(8);
pending.push(self);
while let Some(e) = pending.pop() {
f(e);
match e {
@@ -236,6 +238,19 @@ impl Expr {
}
/// Rewrites every node bottom-up, children left to right before their parent.
pub fn map(self, f: &mut dyn FnMut(Expr) -> Expr) -> Expr {
// One operator on a non-chain operand (`A1*2`), the common case, needs no spine: rewrite
// the operands in their boxes.
if let Expr::Binary(op, mut a, mut b) = self {
if !matches!(*a, Expr::Binary(..)) {
*a = std::mem::replace(&mut *a, Expr::Missing).map(f);
*b = std::mem::replace(&mut *b, Expr::Missing).map(f);
return f(Expr::Binary(op, a, b));
}
return Expr::Binary(op, a, b).map_chain(f);
}
self.map_chain(f)
}
fn map_chain(self, f: &mut dyn FnMut(Expr) -> Expr) -> Expr {
// Unwind the left spine of a long operator chain into a list, then rebuild it from the
// innermost operand outwards, in the order a recursive rewrite would visit the nodes.
let mut spine = Vec::new();
@@ -283,6 +298,12 @@ impl Expr {
impl Clone for Expr {
fn clone(&self) -> Self {
// One operator on a non-chain operand needs no spine.
if let Expr::Binary(op, a, b) = self
&& !matches!(**a, Expr::Binary(..))
{
return Expr::Binary(*op, a.clone(), b.clone());
}
// Copy the left spine of an operator chain in a loop (see [`Expr`]).
let mut spine = Vec::new();
let mut node = self;
+2 -1
View File
@@ -71,7 +71,8 @@ pub(super) fn accrintm(a: &[Arg], c: &mut dyn Ctx) -> R<Value> {
let (issue, settle, rate) = (date(a, 0)?, date(a, 1)?, num(a, 2)?);
let par = if has(a, 3) { num(a, 3)? } else { 1000.0 };
let basis = basis_arg(a, 4)?;
if issue >= settle || rate <= 0.0 || par <= 0.0 {
// Excel accepts equal (whole-day) dates and accrues nothing; only issue after settlement is #NUM!.
if issue > settle || rate <= 0.0 || par <= 0.0 {
return Err(CellError::Num);
}
num_val(par * rate * year_frac(c.date_system(), issue, settle, basis)?)
+25
View File
@@ -317,3 +317,28 @@ fn securities_read_dates_in_the_1904_system() {
let odd = vec![d4(2008, 11, 11), d4(2021, 3, 1), d4(2008, 10, 15), d4(2009, 3, 1), n(0.0785), n(0.0625), n(100.0), n(2.0), n(1.0)];
close_tol(ev4("ODDFPRICE", odd), 113.597717474079, 1e-9);
}
/// Excel truncates ACCRINTM's dates to whole days and accrues nothing when issue equals
/// settlement, in every basis and both date systems; only issue after settlement is #NUM! (#4096).
#[test]
fn accrintm_equal_dates_accrue_zero() {
let day = serial_from_ymd(DateSystem::D1900, 2025, 1, 15).unwrap();
for basis in 0..=4 {
close(ev("ACCRINTM", vec![n(day), n(day), n(0.05), n(1000.0), n(f64::from(basis))]), 0.0);
}
// Distinct times on the same day truncate to equal dates.
close(ev("ACCRINTM", vec![n(day + 0.1), n(day + 0.9), n(0.05), n(1000.0), n(2.0)]), 0.0);
close_tol(ev("ACCRINTM", vec![n(day), n(day + 1.0), n(0.05), n(1000.0), n(2.0)]), 0.1388888888888889, 1e-15);
is_err(ev("ACCRINTM", vec![n(day + 1.0), n(day), n(0.05), n(1000.0), n(2.0)]), CellError::Num);
// Equal dates do not excuse a zero rate or par, or an invalid basis.
is_err(ev("ACCRINTM", vec![n(day), n(day), n(0.0), n(1000.0), n(2.0)]), CellError::Num);
is_err(ev("ACCRINTM", vec![n(day), n(day), n(0.05), n(0.0), n(2.0)]), CellError::Num);
is_err(ev("ACCRINTM", vec![n(day), n(day), n(0.05), n(1000.0), n(5.0)]), CellError::Num);
let day4 = serial_from_ymd(DateSystem::D1904, 2025, 1, 15).unwrap();
for basis in 0..=4 {
let mut ctx = TestCtx { sys: DateSystem::D1904, ..TestCtx::default() };
let args = vec![n(day4), n(day4), n(0.05), n(1000.0), n(f64::from(basis))];
close(crate::call(crate::lookup("ACCRINTM").unwrap(), &args, &mut ctx), 0.0);
}
}
+1 -1
View File
@@ -520,7 +520,7 @@ fn integer_args(a: &[Arg]) -> R<Vec<u64>> {
v.iter()
.map(|x| {
let t = x.trunc();
if !(0.0..9.007_199_254_740_992e15).contains(&t) { Err(CellError::Num) } else { Ok(t as u64) }
if !(0.0..9.007_199_254_740_992e15).contains(x) { Err(CellError::Num) } else { Ok(t as u64) }
})
.collect()
}
+14
View File
@@ -229,6 +229,20 @@ fn combinatorics() {
is_err(ev("MULTINOMIAL", vec![n(-1.0), n(2.0)]), Num);
}
#[test]
fn gcd_and_lcm_reject_negative_fractions_before_truncation() {
for name in ["GCD", "LCM"] {
for x in [-0.1, -0.5, -0.999] {
is_err(ev2(name, x, 2.0), Num);
is_err(ev(name, vec![rf(row(&[2.0, x]))]), Num);
// A zero elsewhere must not hide an invalid negative argument.
is_err(ev2(name, 0.0, x), Num);
}
close(ev2(name, -0.0, 2.0), if name == "GCD" { 2.0 } else { 0.0 });
close(ev2(name, 12.9, 18.9), if name == "GCD" { 6.0 } else { 36.0 });
}
}
#[test]
fn trig() {
close(ev1("SIN", PI / 2.0), 1.0);
+145 -92
View File
@@ -55,12 +55,12 @@ fn strict_num(v: &Value) -> R<f64> {
}
}
/// Most predictor columns LINEST, LOGEST, TREND and GROWTH accept. The normal equations are a
/// k×k matrix inverted in O(k³), so an unbounded k (one `SEQUENCE(1,16384)` argument) allocated
/// Most predictor columns LINEST, LOGEST, TREND and GROWTH accept. The fit works on a k×k
/// triangle in O(k³), so an unbounded k (one `SEQUENCE(1,16384)` argument) allocated
/// gigabytes and could abort the process.
pub(super) const MAX_REGRESSORS: usize = 255;
/// Most multiply-adds (rows × k²) a regression may spend building its normal equations.
/// Most multiply-adds (rows × k²) a regression may spend on its factorisation.
const MAX_REGRESSION_WORK: usize = 1_000_000_000;
/// Rejects regressions too large to fit: more than [`MAX_REGRESSORS`] predictors is `#VALUE!`,
@@ -121,59 +121,136 @@ struct Fit {
ssresid: f64,
}
/// Inverts a symmetric positive semi-definite matrix by Gauss–Jordan on the diagonal, dropping
/// (zeroing) collinear variables. Returns the inverse and the dropped flags.
fn sym_inverse(m: &[Vec<f64>]) -> (Vec<Vec<f64>>, Vec<bool>) {
let p = m.len();
let mut a: Vec<Vec<f64>> = m.to_vec();
let mut inv: Vec<Vec<f64>> = (0..p).map(|i| (0..p).map(|j| if i == j { 1.0 } else { 0.0 }).collect()).collect();
let mut dropped = vec![false; p];
let diag: Vec<f64> = (0..p).map(|i| m.get(i).and_then(|r| r.get(i)).copied().unwrap_or(0.0).abs()).collect();
for j in 0..p {
let piv = a.get(j).and_then(|r| r.get(j)).copied().unwrap_or(0.0);
let scale = diag.get(j).copied().unwrap_or(0.0);
if piv.abs() <= 1e-12 * scale || piv.abs() < 1e-300 {
if let Some(d) = dropped.get_mut(j) {
*d = true;
}
for row in a.iter_mut() {
if let Some(v) = row.get_mut(j) {
*v = 0.0;
}
}
if let Some(r) = a.get_mut(j) {
r.iter_mut().for_each(|v| *v = 0.0);
}
if let Some(r) = inv.get_mut(j) {
r.iter_mut().for_each(|v| *v = 0.0);
}
/// Euclidean norm without intermediate overflow or underflow.
fn norm2(v: &[f64]) -> f64 {
let m = v.iter().fold(0.0f64, |m, x| m.max(x.abs()));
if m == 0.0 || !m.is_finite() {
return m;
}
m * v.iter().map(|x| (x / m) * (x / m)).sum::<f64>().sqrt()
}
/// Result of [`qr_solve`]: the least-squares solution on the kept columns, in the caller's
/// column scale, and what the standard errors need.
struct QrFit {
coef: Vec<f64>,
dropped: Vec<bool>,
/// Residual sum of squares of the fit.
ssresid: f64,
/// Diagonal of `(X'X)^-1` over the kept columns (0 for dropped ones).
diag: Vec<f64>,
/// `xm' (X'X)^-1 xm` over the kept columns.
quad: f64,
}
/// Least squares by Householder QR on unit-norm columns, instead of the normal equations, whose
/// condition number is the square of the data's. Columns are taken left to right; one whose part
/// outside the span of the kept columns is under 1e-6 of its own length (the 1e-12 relative
/// pivot of the earlier normal-equation solver, on squares) is collinear: it is dropped, with
/// coefficient and standard error 0, as Excel does.
///
/// `constant[j]` says column `j` was constant before centring. Centring it leaves rounding
/// residue, not 0 (`[0.1; 3]` centres to about -1.4e-17): it is collinear with the intercept, so
/// it is dropped instead of being scaled up to unit length. Whether a column is constant is
/// decided on its raw values, not by comparing the centred length with the offset: a predictor
/// like `[1e13, 1e13 + 1, 1e13 + 2]` is far smaller than its offset and still varies.
fn qr_solve(mut cols: Vec<Vec<f64>>, mut y: Vec<f64>, xm: &[f64], constant: &[bool]) -> QrFit {
let n = y.len();
let k = cols.len();
let mut scale = vec![1.0; k];
let mut dropped = vec![false; k];
// Householder vectors (unit norm, acting on rows `at..n`) and the columns of R.
let mut refl: Vec<(usize, Vec<f64>)> = Vec::new();
let mut r_cols: Vec<Vec<f64>> = Vec::new();
let mut kept: Vec<usize> = Vec::new();
for (j, col) in cols.iter_mut().enumerate() {
let len = norm2(col);
if constant.get(j).copied().unwrap_or(false) || !(len > 1e-300 && len.is_finite()) {
dropped[j] = true;
continue;
}
let arow: Vec<f64> = a.get(j).map(|r| r.iter().map(|v| v / piv).collect()).unwrap_or_default();
let irow: Vec<f64> = inv.get(j).map(|r| r.iter().map(|v| v / piv).collect()).unwrap_or_default();
for i in 0..p {
if i == j {
continue;
}
let f = a.get(i).and_then(|r| r.get(j)).copied().unwrap_or(0.0);
if f == 0.0 {
continue;
}
if let Some(r) = a.get_mut(i) {
r.iter_mut().zip(&arow).for_each(|(v, w)| *v -= f * w);
}
if let Some(r) = inv.get_mut(i) {
r.iter_mut().zip(&irow).for_each(|(v, w)| *v -= f * w);
}
col.iter_mut().for_each(|v| *v /= len);
scale[j] = len;
for (at, v) in &refl {
apply_reflector(*at, v, col);
}
if let Some(r) = a.get_mut(j) {
*r = arow;
let at = refl.len();
let tail = col.get(at..).unwrap_or(&[]);
let alpha = norm2(tail);
if alpha * alpha <= 1e-12 {
dropped[j] = true;
continue;
}
if let Some(r) = inv.get_mut(j) {
*r = irow;
let sign = if tail.first().is_some_and(|t| *t < 0.0) { -1.0 } else { 1.0 };
let mut v: Vec<f64> = tail.to_vec();
if let Some(h) = v.first_mut() {
*h += sign * alpha;
}
let vn = norm2(&v);
v.iter_mut().for_each(|x| *x /= vn);
let mut rc: Vec<f64> = col.get(..at).unwrap_or(&[]).to_vec();
rc.push(-sign * alpha);
r_cols.push(rc);
refl.push((at, v));
kept.push(j);
}
for (at, v) in &refl {
apply_reflector(*at, v, &mut y);
}
let r = kept.len();
// Back substitution R c = (Q'y)[..r], then undo the column scaling.
let mut c = vec![0.0; r];
for i in (0..r).rev() {
let mut t = y.get(i).copied().unwrap_or(0.0);
for jj in i + 1..r {
t -= r_cols.get(jj).and_then(|rc| rc.get(i)).copied().unwrap_or(0.0) * c.get(jj).copied().unwrap_or(0.0);
}
if let Some(ci) = c.get_mut(i) {
*ci = t / r_cols.get(i).and_then(|rc| rc.get(i)).copied().unwrap_or(f64::NAN);
}
}
(inv, dropped)
let ssresid = y.get(r..n).unwrap_or(&[]).iter().map(|v| v * v).sum::<f64>();
// R^-1 (upper triangular), row i of the inverse at rinv[i].
let rij = |i: usize, j: usize| r_cols.get(j).and_then(|rc| rc.get(i)).copied().unwrap_or(0.0);
let mut rinv = vec![vec![0.0; r]; r];
for t in 0..r {
for i in (0..=t).rev() {
let mut v = if i == t { 1.0 } else { 0.0 };
for jj in i + 1..=t {
v -= rij(i, jj) * rinv.get(jj).and_then(|row| row.get(t)).copied().unwrap_or(0.0);
}
if let Some(cell) = rinv.get_mut(i).and_then(|row| row.get_mut(t)) {
*cell = v / rij(i, i);
}
}
}
let mut coef = vec![0.0; k];
let mut diag = vec![0.0; k];
for (i, &j) in kept.iter().enumerate() {
let s = scale.get(j).copied().unwrap_or(1.0);
if let Some(v) = coef.get_mut(j) {
*v = c.get(i).copied().unwrap_or(0.0) / s;
}
let row = rinv.get(i);
if let Some(v) = diag.get_mut(j) {
*v = row.map_or(0.0, |rw| rw.iter().map(|x| x * x).sum::<f64>()) / (s * s);
}
}
// xm' (S R'R S)^-1 xm = |R^-T S^-1 xm|².
let w: Vec<f64> = kept.iter().map(|&j| xm.get(j).copied().unwrap_or(0.0) / scale.get(j).copied().unwrap_or(1.0)).collect();
let quad = (0..r)
.map(|t| {
(0..=t).map(|i| rinv.get(i).and_then(|row| row.get(t)).copied().unwrap_or(0.0) * w.get(i).copied().unwrap_or(0.0)).sum::<f64>().powi(2)
})
.sum::<f64>();
QrFit { coef, dropped, ssresid, diag, quad }
}
/// Applies the Householder reflection `I - 2vv'` on rows `at..` of `x`.
fn apply_reflector(at: usize, v: &[f64], x: &mut [f64]) {
let Some(tail) = x.get_mut(at..) else { return };
let dot: f64 = v.iter().zip(tail.iter()).map(|(a, b)| a * b).sum();
tail.iter_mut().zip(v).for_each(|(t, a)| *t -= 2.0 * dot * a);
}
fn regress(y: &[f64], x: &[Vec<f64>], k: usize, constant: bool) -> R<Fit> {
@@ -189,35 +266,22 @@ fn regress(y: &[f64], x: &[Vec<f64>], k: usize, constant: bool) -> R<Fit> {
} else {
(vec![0.0; k], 0.0)
};
// Normal equations on (centred) data.
let mut xtx = vec![vec![0.0; k]; k];
let mut xty = vec![0.0; k];
for (row, yv) in x.iter().zip(y) {
let d: Vec<f64> = (0..k).map(|j| row.get(j).copied().unwrap_or(0.0) - xm.get(j).copied().unwrap_or(0.0)).collect();
let yd = yv - ym;
for (i, di) in d.iter().enumerate() {
if let Some(t) = xty.get_mut(i) {
*t += di * yd;
}
if let Some(r) = xtx.get_mut(i) {
for (j, dj) in d.iter().enumerate() {
if let Some(v) = r.get_mut(j) {
*v += di * dj;
}
}
}
}
}
let (inv, dropped) = sym_inverse(&xtx);
let coef: Vec<f64> = (0..k).map(|i| inv.get(i).map(|r| r.iter().zip(&xty).map(|(a, b)| a * b).sum()).unwrap_or(0.0)).collect();
// (Centred) predictor columns and response.
let cols: Vec<Vec<f64>> =
(0..k).map(|j| x.iter().map(|r| r.get(j).copied().unwrap_or(0.0) - xm.get(j).copied().unwrap_or(0.0)).collect()).collect();
let yc: Vec<f64> = y.iter().map(|v| v - ym).collect();
let sstot: f64 = if constant { yc.iter().map(|v| v * v).sum() } else { y.iter().map(|v| v * v).sum() };
// Only centring leaves rounding residue behind; without an intercept a constant column is data.
// Constant means every raw value is the same double: distinct values, however close, vary.
let constant_cols: Vec<bool> = (0..k)
.map(|j| {
let mut col = x.iter().map(|r| r.get(j).copied().unwrap_or(0.0));
let first = col.next();
constant && first.is_some_and(|f| col.all(|v| v == f))
})
.collect();
let QrFit { coef, dropped, ssresid, diag, quad } = qr_solve(cols, yc, &xm, &constant_cols);
let b = if constant { ym - coef.iter().zip(&xm).map(|(c, m)| c * m).sum::<f64>() } else { 0.0 };
let mut ssresid = 0.0;
let mut sstot = 0.0;
for (row, yv) in x.iter().zip(y) {
let pred = b + coef.iter().zip(row).map(|(c, v)| c * v).sum::<f64>();
ssresid += (yv - pred).powi(2);
sstot += if constant { (yv - ym).powi(2) } else { yv * yv };
}
let used = dropped.iter().filter(|d| !**d).count() + usize::from(constant);
let df = nf - used as f64;
let ssreg = sstot - ssresid;
@@ -230,20 +294,9 @@ fn regress(y: &[f64], x: &[Vec<f64>], k: usize, constant: bool) -> R<Fit> {
_ => Err(CellError::Num),
};
let s2 = sey2.unwrap_or(f64::NAN);
let se: Vec<f64> = (0..k)
.map(|i| if dropped.get(i).copied().unwrap_or(true) { 0.0 } else { (inv.get(i).and_then(|r| r.get(i)).copied().unwrap_or(0.0) * s2).sqrt() })
.collect();
let se_b = if constant {
let mut q = 0.0;
for (i, mi) in xm.iter().enumerate() {
for (j, mj) in xm.iter().enumerate() {
q += mi * mj * inv.get(i).and_then(|r| r.get(j)).copied().unwrap_or(0.0);
}
}
Some((s2 * (1.0 / nf + q)).sqrt())
} else {
None
};
let se: Vec<f64> =
(0..k).map(|i| if dropped.get(i).copied().unwrap_or(true) { 0.0 } else { (diag.get(i).copied().unwrap_or(0.0) * s2).sqrt() }).collect();
let se_b = if constant { Some((s2 * (1.0 / nf + quad)).sqrt()) } else { None };
Ok(Fit { coef, b, se, se_b, r2, sey, f, df, ssreg, ssresid })
}
+179
View File
@@ -433,6 +433,185 @@ fn linest_family() {
is_err(ev("LINEST", vec![c(&[1.0, 2.0]), c(&[1.0, 2.0, 3.0])]), CellError::Ref);
}
/// LINEST on columns of predictors, `stats` on, as rows of numbers (`None` for an error cell).
fn linest_rows(y: &[f64], xs: &[Vec<f64>], constant: bool) -> Vec<Vec<Option<f64>>> {
let x = arr((0..y.len()).map(|i| xs.iter().map(|col| nv(col[i])).collect()).collect());
let r = rows_of(&ev("LINEST", vec![c(y), av(x), b(constant), b(true)]));
r.iter().map(|row| row.iter().map(Value::as_f64).collect()).collect()
}
fn rel_close(got: Option<f64>, want: f64, tol: f64, what: &str) {
let got = got.unwrap_or(f64::NAN);
assert!((got - want).abs() <= tol * want.abs().max(1e-300), "{what}: got {got:e}, want {want:e}, rel tol {tol:e}");
}
// B2: LINEST solved the normal equations, whose condition number is the square of the data's.
// Expected values below come from exact rational arithmetic: the normal equations solved with
// Python `fractions.Fraction` (no rounding at all), rounded once to f64 (script in the PR text).
#[test]
fn linest_ill_conditioned_polynomial_is_exact() {
// y = 1 + x + x² + x³ + x⁴ + x⁵ on x = 1..12: every coefficient is exactly 1. The normal
// equations were off by up to 2.6e-6.
let xs: Vec<f64> = (1..=12).map(f64::from).collect();
let ys: Vec<f64> = xs.iter().map(|x| (0..=5).map(|j| x.powi(j)).sum()).collect();
let cols: Vec<Vec<f64>> = (1..=5).map(|j| xs.iter().map(|x| x.powi(j)).collect()).collect();
let r = linest_rows(&ys, &cols, true);
for (i, v) in r[0].iter().enumerate() {
rel_close(*v, 1.0, 1e-9, &format!("coefficient {i}"));
}
}
#[test]
fn linest_large_offset_regressors_recover_the_line() {
// y = 3x + 7 exactly with x = 1e6 + i and regressors [x, x²]: the true fit has x² coefficient
// 0, x coefficient 3, intercept 7. The normal equations returned 2.99976 and 251.14.
let xs: Vec<f64> = (0..12).map(|i| 1_000_000.0 + f64::from(i)).collect();
let ys: Vec<f64> = xs.iter().map(|x| 3.0 * x + 7.0).collect();
let r = linest_rows(&ys, &[xs.clone(), xs.iter().map(|x| x * x).collect()], true);
assert!(r[0][0].unwrap().abs() < 1e-12, "x² coefficient {:?}", r[0][0]);
rel_close(r[0][1], 3.0, 1e-9, "x coefficient");
// The intercept subtracts 3e6 from 3e6 + 7 and carries the x² coefficient times 1e12, so
// it is good to about 1e-4 in absolute terms, not better.
assert!((r[0][2].unwrap() - 7.0).abs() < 1e-3, "intercept {:?}", r[0][2]);
// One regressor: exact.
let one = linest_rows(&ys, std::slice::from_ref(&xs), true);
rel_close(one[0][0], 3.0, 1e-12, "slope");
rel_close(one[0][1], 7.0, 1e-9, "intercept");
}
#[test]
fn linest_noisy_fits_match_exact_rational_least_squares() {
// Two predictors with noise, constant fitted. Order of each row: x2, x1, intercept.
let x1 = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0];
let x2 = [2.0, 1.0, 4.0, 3.0, 7.0, 5.0, 9.0, 6.0];
let y = [5.0, 6.0, 11.0, 12.0, 20.0, 19.0, 30.0, 28.0];
let r = linest_rows(&y, &[x1.to_vec(), x2.to_vec()], true);
let (coef, se) = ([1.4270152505446623, 2.452069716775599, -1.2592592592592593], [0.3376442444771937, 0.3679392851360571, 1.0847489958915801]);
for i in 0..3 {
rel_close(r[0][i], coef[i], 1e-12, "coef");
rel_close(r[1][i], se[i], 1e-12, "se");
}
rel_close(r[2][0], 0.985070139277778, 1e-12, "r2");
rel_close(r[2][1], 1.367057173604725, 1e-12, "sey");
rel_close(r[3][0], 164.94965318256004, 1e-11, "F");
assert_eq!(r[3][1], Some(5.0));
rel_close(r[4][0], 616.5307734204792, 1e-12, "ssreg");
rel_close(r[4][1], 9.344226579520697, 1e-11, "ssresid");
assert_eq!(r[2][2], None);
// const = FALSE: through the origin, R² and F from the uncentred sums.
let r = linest_rows(&y, &[x1.to_vec(), x2.to_vec()], false);
rel_close(r[0][0], 1.3529411764705883, 1e-12, "coef");
rel_close(r[0][1], 2.303921568627451, 1e-12, "coef");
assert_eq!(r[0][2], Some(0.0));
rel_close(r[1][0], 0.34102994374364876, 1e-12, "se");
rel_close(r[1][1], 0.35495521934550084, 1e-12, "se");
assert_eq!(r[1][2], None);
rel_close(r[2][0], 0.995718966041848, 1e-12, "r2");
rel_close(r[2][1], 1.4061024795535124, 1e-12, "sey");
rel_close(r[3][0], 697.7652892561983, 1e-11, "F");
assert_eq!(r[3][1], Some(6.0));
rel_close(r[4][0], 2759.1372549019607, 1e-12, "ssreg");
rel_close(r[4][1], 11.862745098039216, 1e-11, "ssresid");
// Cubic and quintic with noise on x = 1..12; order x^k .. x, intercept.
let xs: Vec<f64> = (1..=12).map(f64::from).collect();
let noise = [3.0, -2.0, 4.0, -1.0, 2.0, -3.0, 1.0, -4.0, 2.0, 3.0, -2.0, 1.0];
let cub: Vec<f64> = xs.iter().zip(noise).map(|(x, e)| 1.0 + x + x * x + x.powi(3) + e).collect();
let r = linest_rows(&cub, &(1..=3).map(|j| xs.iter().map(|x| x.powi(j)).collect()).collect::<Vec<Vec<f64>>>(), true);
let coef = [0.9955969955969955, 1.1452991452991452, -0.33514633514633513, 4.373737373737374];
let se = [0.02755463331301788, 0.5434124199147191, 3.102549978874372, 4.851885058051787];
for i in 0..4 {
rel_close(r[0][i], coef[i], 1e-11, "cubic coef");
rel_close(r[1][i], se[i], 1e-10, "cubic se");
}
rel_close(r[2][0], 0.9999837292113533, 1e-12, "cubic r2");
rel_close(r[4][1], 70.35586635586635, 1e-9, "cubic ssresid");
let quint: Vec<f64> = xs.iter().zip(noise).map(|(x, e)| (0..=5).map(|j| x.powi(j)).sum::<f64>() + 50.0 * e).collect();
let r = linest_rows(&quint, &(1..=5).map(|j| xs.iter().map(|x| x.powi(j)).collect()).collect::<Vec<Vec<f64>>>(), true);
let coef = [0.9330693815987934, 3.022273070067188, -20.97398190045249, 108.20489681886741, -250.24940010969422, 271.45454545454544];
let se = [0.20046539191103213, 6.538253746916523, 78.39635356777087, 421.2608646012634, 976.3504976093745, 736.5866411764556];
for i in 0..6 {
rel_close(r[0][i], coef[i], 1e-8, "quintic coef");
rel_close(r[1][i], se[i], 1e-8, "quintic se");
}
rel_close(r[2][1], 168.58174051770763, 1e-9, "quintic sey");
rel_close(r[4][1], 170518.81941587824, 1e-7, "quintic ssresid");
}
#[test]
fn linest_drops_collinear_columns() {
// x2 = 2·x1: the later column is dropped (coefficient and standard error 0), the fit is the
// one on x1 alone, and the degrees of freedom count only the kept column.
let x1 = [1.0, 2.0, 3.0, 4.0, 5.0];
let y = [2.0, 4.0, 5.0, 4.0, 5.0];
let x2: Vec<f64> = x1.iter().map(|v| 2.0 * v).collect();
let r = linest_rows(&y, &[x1.to_vec(), x2], true);
// Exact: slope 0.6, intercept 2.2, ssresid 2.4, ssreg 3.6, df 3 (Fraction arithmetic).
assert_eq!(r[0][0], Some(0.0));
rel_close(r[0][1], 0.6, 1e-12, "slope");
rel_close(r[0][2], 2.2, 1e-12, "intercept");
assert_eq!(r[1][0], Some(0.0));
rel_close(r[1][1], (0.8f64 / 10.0).sqrt(), 1e-12, "se slope");
assert_eq!(r[3][1], Some(3.0));
rel_close(r[4][0], 3.6, 1e-12, "ssreg");
rel_close(r[4][1], 2.4, 1e-12, "ssresid");
// A constant column is collinear with the intercept and dropped as well.
let r = linest_rows(&y, &[vec![7.0; 5], x1.to_vec()], true);
assert_eq!(r[0][1], Some(0.0));
assert_eq!(r[1][1], Some(0.0));
rel_close(r[0][0], 0.6, 1e-12, "slope");
rel_close(r[0][2], 2.2, 1e-12, "intercept");
// A constant column whose mean does not centre to exactly 0 (the mean of three 0.1 is
// 0.10000000000000002) is just as collinear with the intercept: dropped, not scaled up to a
// unit vector. Some length hits a rounding mean for each constant.
for c in [0.1, 1.1, 1e6 + 0.3] {
for n in 3..=12 {
let xs: Vec<f64> = (1..=n).map(f64::from).collect();
let ys: Vec<f64> = (1..=n).map(|i| f64::from(i * i % 7) + 0.5 * f64::from(i)).collect();
let r = linest_rows(&ys, &[vec![c; n as usize], xs], true);
assert_eq!(r[0][1], Some(0.0), "coefficient of the constant {c}, n={n}");
assert_eq!(r[1][1], Some(0.0), "standard error of the constant {c}, n={n}");
assert_eq!(r[3][1], Some(f64::from(n) - 2.0), "df with the constant {c}, n={n}");
}
}
// A column that merely sits far from zero is not noise and is kept.
let off: Vec<f64> = x1.iter().map(|v| 1e9 + v).collect();
let r = linest_rows(&y, &[off], true);
rel_close(r[0][0], 0.6, 1e-6, "slope on an offset column");
assert_eq!(r[3][1], Some(3.0));
// Distinct values far from zero, whose spread is below 1e-12 of the offset, still vary.
let r = linest_rows(&[0.0, 1.0, 2.0], &[vec![1e13, 1e13 + 1.0, 1e13 + 2.0]], true);
rel_close(r[0][0], 1.0, 1e-9, "slope on a predictor with a 1e13 offset");
assert_eq!(r[3][1], Some(1.0), "df: the predictor is kept");
// Same at 1e15, where the spread is only a few ulps of the offset: still distinct doubles.
let x15 = [1e15, 1e15 + 1.0, 1e15 + 2.0];
let r = linest_rows(&[0.0, 1.0, 2.0], &[x15.to_vec()], true);
rel_close(r[0][0], 1.0, 1e-9, "slope on a predictor with a 1e15 offset");
rel_close(r[0][1], -1e15, 1e-9, "intercept on a predictor with a 1e15 offset");
assert_eq!(r[3][1], Some(1.0), "df: the 1e15 predictor is kept");
assert!(r[4][1].is_some_and(|v| v.abs() < 1e-9), "ssresid: the 1e15 line is exact, got {:?}", r[4][1]);
let fitted = rows_of(&ev("TREND", vec![c(&[0.0, 1.0, 2.0]), c(&x15)]));
close(fitted[2][0].clone(), 2.0);
// More predictors than observations: the surplus columns drop, no panic.
let r = linest_rows(&[1.0, 2.0], &[vec![1.0, 2.0], vec![2.0, 1.0], vec![0.0, 5.0]], true);
assert_eq!(r[0].len(), 4);
}
#[test]
fn logest_is_linest_of_ln_y() {
// y = 5·2^x: m = 2, b = 5.
let x = [0.0, 1.0, 2.0, 3.0, 4.0];
let y: Vec<f64> = x.iter().map(|v| 5.0 * 2f64.powf(*v)).collect();
let l = rows_of(&ev("LOGEST", vec![c(&y), c(&x)]));
close_tol(l[0][0].clone(), 2.0, 1e-12);
close_tol(l[0][1].clone(), 5.0, 1e-12);
// The statistics are those of the fit on ln y, untransformed.
let ln: Vec<f64> = y.iter().map(|v| v.ln()).collect();
let ls = rows_of(&ev("LOGEST", vec![c(&y), c(&x), b(true), b(true)]));
let ns = rows_of(&ev("LINEST", vec![c(&ln), c(&x), b(true), b(true)]));
assert_eq!(ls[1..], ns[1..]);
close_tol(ls[0][0].clone(), ns[0][0].as_f64().unwrap().exp(), 1e-14);
}
// #2177: one predictor row of 16,384 columns built three 16,384² matrices (6 GB) and an O(k³)
// inversion; a wider TOROW aborted the process. It is now refused before allocating.
#[test]
+5
View File
@@ -668,6 +668,9 @@ pub enum ShapeKind {
/// A freehand ink stroke; `Shape::text` holds the points as `x,y;x,y;…` relative to the
/// anchor (sheet points), `Shape::line` the ink colour and `fill` unused.
Ink,
/// Decorative text (`insert.wordArt`): a transparent shape whose `Shape::text` is drawn with
/// the large, filled/outlined/shadowed text properties of `Shape::format`.
WordArt,
/// An equation: `Shape::text` holds its LaTeX source, `Shape::line` its ink colour
/// (`Color::Auto` for the sheet's text colour) and `Shape::math` its cached layout.
Equation,
@@ -1026,6 +1029,8 @@ pub struct ShapeFormat {
pub text_color: Option<Color>,
/// Text outline (`a:rPr/a:ln`): colour and width in points.
pub text_outline: Option<(Color, f32)>,
/// Text drop shadow colour (`a:rPr/a:effectLst/a:outerShdw`); `None` is no shadow.
pub text_shadow: Option<Color>,
/// `None`: the shape's default (left for text boxes, centred for other shapes).
pub align: Option<ShapeTextAlign>,
/// `None`: the shape's default (top for text boxes, middle for other shapes).
+2 -1
View File
@@ -235,11 +235,12 @@ impl CellStore {
bytes = bytes.saturating_add(size_of::<Band>());
for (row, cols) in &band.rows {
bytes = bytes.saturating_add(size_of::<u32>() + 3 * size_of::<usize>());
let next_row = next.and_then(|b| b.rows.get(row));
for (col, cell) in cols {
// Cells and BTreeMap nodes are duplicated with a cloned band even when
// their formula/value Arcs are still shared with the next snapshot.
bytes = bytes.saturating_add(size_of::<u32>() + size_of::<Cell>() + 3 * size_of::<usize>());
let next_cell = next.and_then(|b| b.rows.get(row)).and_then(|r| r.get(col));
let next_cell = next_row.and_then(|r| r.get(col));
if let Some(formula) = &cell.formula
&& !next_cell.and_then(|c| c.formula.as_ref()).is_some_and(|f| Arc::ptr_eq(f, formula))
{
+9 -1
View File
@@ -3,10 +3,18 @@ name = "gridcraft-pdf"
version.workspace = true
edition.workspace = true
license.workspace = true
description = "GridCraft's tiny self-contained PDF 1.7 writer (standard 14 fonts, vector drawing, RGBA images)"
description = "GridCraft PDF 1.7 writer with shaped Arabic text, vector drawing and RGBA images"
readme = "README.md"
[lints]
workspace = true
[dependencies]
craft-stream-codecs.workspace = true
harfrust = "=0.12.0"
skrifa = { workspace = true }
unicode-bidi = "=0.3.18"
[build-dependencies]
sha2 = { workspace = true }
skrifa = { workspace = true }
+1 -1
View File
@@ -1,6 +1,6 @@
# gridcraft-pdf
A small, dependency-free PDF 1.7 writer for vector drawing and RGBA images.
A small PDF 1.7 writer for shaped Arabic text, vector drawing and RGBA images.
## API migration
+88
View File
@@ -0,0 +1,88 @@
use std::fmt::Write as _;
fn main() -> Result<(), String> {
arabic_fonts()
}
/// Embed only Arabic fallback faces from the optional, separately licensed font bundle.
fn arabic_fonts() -> Result<(), String> {
use std::path::PathBuf;
println!("cargo::rerun-if-env-changed=CRAFT_FONTS_DIR");
println!("cargo::rerun-if-env-changed=CRAFT_FONTS_REQUIRED");
let required = std::env::var_os("CRAFT_FONTS_REQUIRED").is_some();
let entries = match std::env::var_os("CRAFT_FONTS_DIR").map(PathBuf::from) {
Some(dir) => arabic_font_entries(&dir),
None if required => Err("CRAFT_FONTS_REQUIRED needs CRAFT_FONTS_DIR".into()),
None => Ok(String::new()),
};
let entries = match entries {
Ok(entries) => entries,
Err(e) if required => return Err(e),
Err(e) => {
println!("cargo::warning=building without bundled Arabic fonts: {e}");
String::new()
}
};
let out = PathBuf::from(std::env::var_os("OUT_DIR").unwrap_or_default()).join("arabic_fonts.rs");
std::fs::write(&out, format!("pub(crate) static ARABIC_FONTS: &[(&str, &[u8])] = &[\n{entries}];\n"))
.map_err(|e| format!("writing {}: {e}", out.display()))
}
fn arabic_font_entries(dir: &std::path::Path) -> Result<String, String> {
use sha2::{Digest, Sha256};
use skrifa::MetadataProvider;
let root = dir.canonicalize().map_err(|e| format!("craft-fonts directory: {e}"))?;
let manifest = root.join("fonts/manifest.txt");
println!("cargo::rerun-if-changed={}", manifest.display());
let text = String::from_utf8(read_font_input(&manifest, 1 << 20)?).map_err(|e| e.to_string())?;
let mut out = String::new();
let mut has_regular = false;
for (line_number, line) in text.lines().enumerate() {
let line = line.trim();
if line.is_empty() || line.starts_with('#') {
continue;
}
let fields: Vec<_> = line.split(" | ").map(str::trim).collect();
let [family, style, file, scripts, _licence, licence_file, checksum, _source] = fields.as_slice() else {
return Err(format!("malformed craft-fonts manifest line {}", line_number + 1));
};
if !scripts.split(',').any(|script| script.trim() == "Arab") {
continue;
}
let path = root.join(file).canonicalize().map_err(|e| format!("{file}: {e}"))?;
let licence = root.join(licence_file).canonicalize().map_err(|e| format!("{licence_file}: {e}"))?;
if !path.starts_with(&root) || !licence.starts_with(&root) {
return Err("craft-fonts paths must stay inside the checkout".into());
}
println!("cargo::rerun-if-changed={}", path.display());
println!("cargo::rerun-if-changed={}", licence.display());
let bytes = read_font_input(&path, 64 << 20)?;
if Sha256::digest(&bytes).iter().map(|byte| format!("{byte:02x}")).collect::<String>() != *checksum {
return Err(format!("checksum mismatch for {file}"));
}
let font = skrifa::FontRef::from_index(&bytes, 0).map_err(|e| format!("invalid Arabic font {file}: {e}"))?;
if !"العربية١٢٣".chars().all(|ch| font.charmap().map(ch).is_some()) {
return Err(format!("{file} lacks Arabic glyphs"));
}
let _ = writeln!(out, " ({:?}, include_bytes!({:?})),", format!("craft:{family}:{style}"), path);
has_regular |= *style != "Bold";
}
if out.is_empty() {
return Err("craft-fonts manifest contains no Arabic face; update the checkout".into());
}
if !has_regular {
return Err("craft-fonts manifest has only bold Arabic faces; regular text needs a regular or variable face".into());
}
Ok(out)
}
fn read_font_input(path: &std::path::Path, limit: u64) -> Result<Vec<u8>, String> {
use std::io::Read as _;
let file = std::fs::File::open(path).map_err(|e| format!("{}: {e}", path.display()))?;
let mut bytes = Vec::new();
file.take(limit + 1).read_to_end(&mut bytes).map_err(|e| format!("{}: {e}", path.display()))?;
if bytes.len() as u64 > limit {
return Err(format!("{} exceeds the font input size limit", path.display()));
}
Ok(bytes)
}
+669
View File
@@ -0,0 +1,669 @@
//! Arabic shaping and subset Type3 fonts. Outlines use the same variation coordinates as the
//! shaper; ActualText preserves the logical source independently of visual glyph order.
use std::{borrow::Cow, collections::BTreeMap, fmt::Write as _, sync::OnceLock};
use harfrust::{Direction, ShaperData, ShaperInstance, UnicodeBuffer};
use skrifa::{
FontRef, MetadataProvider,
instance::Size,
outline::{DrawSettings, OutlinePen},
};
use unicode_bidi::BidiInfo;
use crate::{CID_FONT, Error, Font, TextDirection, dict_obj, n, needs_cid, pdf_string, pdf_utf16_string, stream_obj};
include!(concat!(env!("OUT_DIR"), "/arabic_fonts.rs"));
const MAX_TEXT_BYTES: usize = 128 * 1024;
const MAX_OUTLINE_BYTES: usize = 256 * 1024;
const MAX_SUBSET_BYTES: usize = 64 * 1024 * 1024;
const MAX_SUBSET_GLYPHS: usize = 16_384;
const SYNTHETIC_BOLD_STROKE: f32 = 30.0;
/// How `text` set in `font` is drawn. Symbol keeps its own one-run encoding, and Arabic without
/// an installed or bundled face falls back to the standard fonts.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum Shaping {
Plain,
Shaped,
NoFont,
}
pub(crate) fn shaping(font: Font, text: &str) -> Shaping {
if font == Font::Symbol || !needed(text) {
return Shaping::Plain;
}
match face(bold(font)) {
Ok(None) => Shaping::NoFont,
Ok(Some(_)) | Err(_) => Shaping::Shaped,
}
}
pub(crate) fn shaped(font: Font, text: &str) -> bool {
shaping(font, text) == Shaping::Shaped
}
pub(crate) fn needed(text: &str) -> bool {
text.chars().any(|ch| matches!(ch as u32, 0x0600..=0x06ff | 0x0750..=0x077f | 0x0870..=0x089f | 0x08a0..=0x08ff | 0xfb50..=0xfdff | 0xfe70..=0xfefc | 0x10e60..=0x10e7f | 0x1ee00..=0x1eeff))
}
fn bold(font: Font) -> bool {
matches!(
font,
Font::HelveticaBold | Font::HelveticaBoldOblique | Font::TimesBold | Font::TimesBoldItalic | Font::CourierBold | Font::CourierBoldOblique
)
}
fn italic(font: Font) -> bool {
matches!(
font,
Font::HelveticaOblique
| Font::HelveticaBoldOblique
| Font::TimesItalic
| Font::TimesBoldItalic
| Font::CourierOblique
| Font::CourierBoldOblique
)
}
struct Face {
bytes: Cow<'static, [u8]>,
data: ShaperData,
instance: ShaperInstance,
synthetic_bold: bool,
}
impl Face {
fn new(bytes: Cow<'static, [u8]>, bold: bool) -> Result<Self, Error> {
let font = FontRef::from_index(&bytes, 0).map_err(|e| Error(format!("Invalid Arabic PDF font: {e}")))?;
if !"العربية١٢٣".chars().all(|ch| font.charmap().map(ch).is_some()) {
return Err(Error("The PDF font lacks Arabic glyphs".into()));
}
let data = ShaperData::new(&font);
let instance = ShaperInstance::from_variations(&font, [("wght", if bold { 700.0 } else { 400.0 })]);
Ok(Self { bytes, data, instance, synthetic_bold: false })
}
fn font(&self) -> Result<FontRef<'_>, Error> {
FontRef::from_index(&self.bytes, 0).map_err(|e| Error(format!("Invalid Arabic PDF font: {e}")))
}
}
#[cfg(test)]
pub(crate) fn bold_face_is_synthetic() -> bool {
face(true).is_ok_and(|face| face.is_some_and(|face| face.synthetic_bold))
}
/// The Arabic face for a weight, or `None` when none is bundled or installed. The search runs
/// once per weight, so measuring text never rescans the font directories.
fn face(is_bold: bool) -> Result<Option<&'static Face>, Error> {
static REGULAR: OnceLock<Result<Option<Face>, Error>> = OnceLock::new();
static BOLD: OnceLock<Result<Option<Face>, Error>> = OnceLock::new();
let cache = if is_bold { &BOLD } else { &REGULAR };
cache.get_or_init(|| find_face(ARABIC_FONTS, &system_font_dirs(), is_bold)).as_ref().map(Option::as_ref).map_err(Error::clone)
}
fn loaded_face(font: Font) -> Result<&'static Face, Error> {
face(bold(font))?.ok_or_else(|| Error("Arabic PDF export needs Noto Sans Arabic".into()))
}
fn bundled_match(fonts: &[(&str, &'static [u8])], is_bold: bool) -> Option<&'static [u8]> {
fonts
.iter()
.find(|(name, bytes)| if is_bold { name.ends_with(":Bold") || has_weight_axis(bytes) } else { !name.ends_with(":Bold") })
.map(|&(_, bytes)| bytes)
}
#[cfg(not(target_arch = "wasm32"))]
fn system_font_dirs() -> Vec<std::path::PathBuf> {
use std::path::PathBuf;
let mut dirs: Vec<PathBuf> = [
"/usr/share/fonts/noto",
"/usr/share/fonts/google-noto-vf",
"/usr/share/fonts/truetype/noto",
"/usr/share/fonts/TTF",
"/usr/local/share/fonts",
"/usr/local/share/fonts/noto",
"/usr/local/share/fonts/TTF",
"/Library/Fonts",
]
.into_iter()
.map(Into::into)
.collect();
if let Some(home) = std::env::var_os("HOME").or_else(|| std::env::var_os("USERPROFILE")) {
let home = PathBuf::from(home);
dirs.extend([home.join(".local/share/fonts"), home.join(".fonts"), home.join("Library/Fonts")]);
}
if let Some(root) = std::env::var_os("WINDIR") {
dirs.push(PathBuf::from(root).join("Fonts"));
}
if let Some(root) = std::env::var_os("LOCALAPPDATA") {
dirs.push(PathBuf::from(root).join("Microsoft/Windows/Fonts"));
}
dirs
}
#[cfg(target_arch = "wasm32")]
fn system_font_dirs() -> Vec<std::path::PathBuf> {
Vec::new()
}
fn find_face(bundled: &[(&str, &'static [u8])], dirs: &[std::path::PathBuf], is_bold: bool) -> Result<Option<Face>, Error> {
use std::io::Read as _;
if let Some(bytes) = bundled_match(bundled, is_bold) {
return Face::new(Cow::Borrowed(bytes), is_bold).map(Some);
}
let filename = if is_bold { "NotoSansArabic-Bold.ttf" } else { "NotoSansArabic-Regular.ttf" };
for dir in dirs {
for name in ["NotoSansArabic.ttf", "NotoSansArabic[wght].ttf", filename] {
let path = dir.join(name);
let file = match std::fs::File::open(&path) {
Ok(file) => file,
Err(e) if e.kind() == std::io::ErrorKind::NotFound => continue,
Err(e) => return Err(Error(format!("Cannot read Arabic PDF font {}: {e}", path.display()))),
};
let mut bytes = Vec::new();
file.take((64 << 20) + 1).read_to_end(&mut bytes).map_err(|e| Error(format!("Cannot read Arabic PDF font: {e}")))?;
if bytes.len() > 64 << 20 {
return Err(Error("Arabic PDF font exceeds 64 MiB".into()));
}
if is_bold && name != filename && !has_weight_axis(&bytes) {
continue;
}
return Face::new(Cow::Owned(bytes), is_bold).map(Some);
}
}
if let Some((name, bytes)) = bundled_fallback(bundled, is_bold) {
let mut face = Face::new(Cow::Borrowed(bytes), is_bold)?;
face.synthetic_bold = needs_synthetic_bold(name, bytes, is_bold);
return Ok(Some(face));
}
Ok(None)
}
/// The bundled face to use when no face matches the requested weight: regular text never borrows a bold face.
fn bundled_fallback<'a>(fonts: &[(&'a str, &'static [u8])], is_bold: bool) -> Option<(&'a str, &'static [u8])> {
fonts.iter().find(|(name, _)| is_bold || !name.ends_with(":Bold")).copied()
}
/// A bold request served by a static regular face is emboldened by stroking its outlines.
fn needs_synthetic_bold(name: &str, bytes: &[u8], is_bold: bool) -> bool {
is_bold && !name.ends_with(":Bold") && !has_weight_axis(bytes)
}
fn has_weight_axis(bytes: &[u8]) -> bool {
FontRef::from_index(bytes, 0).is_ok_and(|font| font.axes().iter().any(|axis| axis.tag() == skrifa::raw::types::Tag::new(b"wght")))
}
#[derive(Debug)]
pub(crate) enum Item {
Glyph { id: u32, x: f32, y: f32, source: String },
Latin { text: String, x: f32 },
Cid { text: String, x: f32 },
}
pub(crate) struct Layout {
pub items: Vec<Item>,
pub width: f32,
}
/// Positions are in 1/1000 em, matching the Type3 font matrix.
pub(crate) fn layout(font: Font, text: &str, direction: TextDirection) -> Result<Layout, Error> {
if text.len() > MAX_TEXT_BYTES {
return Err(Error("Arabic PDF text exceeds the 128 KiB per-line limit".into()));
}
let direction = if direction == TextDirection::Context { direction.resolve(text) } else { direction };
let face = loaded_face(font)?;
let raw = face.font()?;
let shaper = face.data.shaper(&raw).instance(Some(&face.instance)).build();
let units = shaper.units_per_em();
if units <= 0 {
return Err(Error("Arabic PDF font has invalid units per em".into()));
}
let scale = 1000.0 / units as f32;
let single_line: String = text.chars().map(|ch| if is_paragraph_break(ch) { ' ' } else { ch }).collect();
let text = single_line.as_str();
let bidi = BidiInfo::new(text, direction.level());
let mut layout = Layout { items: Vec::new(), width: 0.0 };
for para in &bidi.paragraphs {
let (levels, runs) = bidi.visual_runs(para, para.range.clone());
for run in runs {
let rtl = levels.get(run.start).is_some_and(|level| level.is_rtl());
let run_text = text.get(run.clone()).ok_or_else(|| Error("Invalid PDF text boundary".into()))?;
let mut spans = Vec::new();
let mut start = 0;
let mut embedded = None;
for (i, ch) in run_text.char_indices() {
let supported = embeddable(raw.charmap().map(ch).is_some(), ch);
if embedded.is_some_and(|v| v != supported) {
spans.push((start..i, embedded.unwrap_or(false)));
start = i;
}
embedded = Some(supported);
}
spans.push((start..run_text.len(), embedded.unwrap_or(false)));
if rtl {
spans.reverse();
}
for (span, embedded) in spans {
let part = run_text.get(span.clone()).ok_or_else(|| Error("Invalid PDF text boundary".into()))?;
if !embedded {
let part = part.chars().map(|ch| if is_line_break(ch) { ' ' } else { ch });
let part: Vec<char> = if rtl { part.rev().map(mirror_ansi).collect() } else { part.collect() };
for run in part.chunk_by(|a, b| needs_cid(*a) == needs_cid(*b)) {
let (text, x) = (run.iter().collect(), layout.width);
layout.width += run.iter().map(|&ch| f32::from(font.char_width(ch))).sum::<f32>();
layout.items.push(if run.first().is_some_and(|&ch| needs_cid(ch)) { Item::Cid { text, x } } else { Item::Latin { text, x } });
}
continue;
}
let mut buffer = UnicodeBuffer::new();
buffer.push_str(part);
buffer.set_pre_context(run_text.get(..span.start).unwrap_or_default());
buffer.set_post_context(run_text.get(span.end..).unwrap_or_default());
buffer.set_direction(if rtl { Direction::RightToLeft } else { Direction::LeftToRight });
buffer.set_flags(harfrust::BufferFlags::REMOVE_DEFAULT_IGNORABLES);
if needed(part) {
buffer.set_script(harfrust::script::ARABIC);
}
buffer.guess_segment_properties();
let shaped = shaper.shape(buffer, harfrust::ShapeOptions::new());
let mut clusters: Vec<_> = shaped.glyph_infos().iter().map(|g| g.cluster as usize).collect();
clusters.push(part.len());
clusters.sort_unstable();
clusters.dedup();
let mut previous_cluster = None;
for (info, pos) in shaped.glyph_infos().iter().zip(shaped.glyph_positions()) {
if info.glyph_id == 0 {
return Err(Error("The Arabic PDF font produced a missing glyph".into()));
}
let cluster = info.cluster as usize;
let source = if previous_cluster == Some(cluster) {
String::new()
} else {
let index = clusters.binary_search(&cluster).map_err(|_| Error("Invalid PDF glyph cluster".into()))?;
let end = clusters.get(index + 1).copied().ok_or_else(|| Error("Invalid PDF glyph cluster".into()))?;
part.get(cluster..end).ok_or_else(|| Error("Invalid PDF glyph cluster".into()))?.to_string()
};
previous_cluster = Some(cluster);
layout.items.push(Item::Glyph {
id: info.glyph_id,
x: layout.width + pos.x_offset as f32 * scale,
y: pos.y_offset as f32 * scale,
source,
});
layout.width += pos.x_advance as f32 * scale;
}
}
}
}
Ok(layout)
}
pub(crate) fn vertical_extents(font: Font, text: &str, direction: TextDirection) -> Result<(f32, f32), Error> {
let layout = layout(font, text, direction)?;
let face = loaded_face(font)?;
let raw = face.font()?;
let metrics = raw.glyph_metrics(Size::new(1000.0), skrifa::instance::LocationRef::new(face.instance.coords()));
let (mut ascent, mut descent) = (0.0_f32, 0.0_f32);
for item in layout.items {
match item {
Item::Glyph { id, y, .. } => {
let (bottom, top) = if let Some(bounds) = metrics.bounds(id.into()) {
(bounds.y_min, bounds.y_max)
} else {
let glyph = raw.outline_glyphs().get(id.into()).ok_or_else(|| Error("Missing Arabic PDF glyph outline".into()))?;
let mut pen = Pen::default();
glyph
.draw(DrawSettings::unhinted(Size::new(1000.0), skrifa::instance::LocationRef::new(face.instance.coords())), &mut pen)
.map_err(|e| Error(format!("Cannot measure Arabic PDF glyph: {e}")))?;
if pen.full {
return Err(Error("Arabic PDF glyph exceeds the outline size limit".into()));
}
(pen.bounds[1], pen.bounds[3])
};
ascent = ascent.max(y + top);
descent = descent.max(-y - bottom);
}
Item::Latin { .. } | Item::Cid { .. } => {
ascent = ascent.max(800.0);
descent = descent.max(220.0);
}
}
}
Ok((ascent, descent))
}
/// Whether standard-font `text` is drawn in its logical order, unchanged.
pub(crate) fn is_logical_order(text: &str, direction: TextDirection) -> bool {
direction != TextDirection::RightToLeft && !text.chars().any(is_control)
}
/// Bidi reordering for standard-font text requires no optional Arabic font.
pub(crate) fn latin_visual(text: &str, direction: TextDirection) -> Result<Cow<'_, str>, Error> {
if is_logical_order(text, direction) {
return Ok(Cow::Borrowed(text));
}
if text.len() > MAX_TEXT_BYTES {
return Err(Error("Bidirectional PDF text exceeds the 128 KiB per-line limit".into()));
}
let single_line: String = text.chars().map(|ch| if is_paragraph_break(ch) { ' ' } else { ch }).collect();
let text = single_line.as_str();
let bidi = BidiInfo::new(text, direction.level());
let mut out = String::with_capacity(text.len());
for para in &bidi.paragraphs {
let (levels, runs) = bidi.visual_runs(para, para.range.clone());
for run in runs {
let part = text.get(run.clone()).unwrap_or_default();
if levels.get(run.start).is_some_and(|level| level.is_rtl()) {
out.extend(part.chars().rev().filter(|ch| !is_control(*ch)).map(mirror_ansi));
} else {
out.extend(part.chars().filter(|ch| !is_control(*ch)));
}
}
}
Ok(Cow::Owned(out))
}
fn mirror_ansi(ch: char) -> char {
match ch {
'(' => ')',
')' => '(',
'[' => ']',
']' => '[',
'{' => '}',
'}' => '{',
'<' => '>',
'>' => '<',
'«' => '»',
'»' => '«',
'‹' => '›',
'›' => '‹',
other => other,
}
}
/// Whether a character is drawn from the embedded Arabic face. Line breaks never are, so the
/// fallback path draws them as spaces even when the face maps them.
fn embeddable(mapped: bool, ch: char) -> bool {
(mapped || is_control(ch)) && !is_line_break(ch)
}
fn is_line_break(ch: char) -> bool {
matches!(ch, '\n' | '\r' | '\u{2028}' | '\u{2029}')
}
/// Bidi paragraph separators (class B). A drawn line is one paragraph: left in, they would split it
/// into paragraphs laid out left to right, swapping the parts of a right-to-left line.
fn is_paragraph_break(ch: char) -> bool {
matches!(ch, '\n' | '\r' | '\u{1C}'..='\u{1E}' | '\u{85}' | '\u{2029}')
}
fn is_control(ch: char) -> bool {
matches!(ch, '\u{061c}' | '\u{200c}'..='\u{200f}' | '\u{202a}'..='\u{202e}' | '\u{2066}'..='\u{2069}')
}
#[derive(Default)]
pub(crate) struct Subset {
keys: BTreeMap<(u32, bool, bool, String), usize>,
glyphs: Vec<Glyph>,
bytes: usize,
/// Some text on the page set a run in the CJK CID font, so the page must declare it.
pub(crate) uses_cid: bool,
}
struct Glyph {
path: String,
width: f32,
source: String,
bounds: [f32; 4],
emboldened: bool,
}
/// The Type3 glyph procedure: a filled outline, also stroked in the text colour when emboldened.
fn glyph_procedure(glyph: &Glyph) -> String {
if glyph.emboldened {
format!("{} 0 d0\n{} w 1 j\n{}B\n", n(glyph.width), n(SYNTHETIC_BOLD_STROKE), glyph.path)
} else {
format!("{} 0 d0\n{}f\n", n(glyph.width), glyph.path)
}
}
impl Subset {
fn insert(&mut self, font: Font, id: u32, source: String) -> Result<usize, Error> {
let key = (id, bold(font), italic(font), source.clone());
if let Some(index) = self.keys.get(&key) {
return Ok(*index);
}
if self.glyphs.len() >= MAX_SUBSET_GLYPHS {
return Err(Error("PDF page has too many distinct Arabic glyphs".into()));
}
let face = loaded_face(font)?;
let raw = face.font()?;
let location = skrifa::instance::LocationRef::new(face.instance.coords());
let glyph = raw.outline_glyphs().get(id.into()).ok_or_else(|| Error("Missing Arabic PDF glyph outline".into()))?;
let width =
raw.glyph_metrics(Size::new(1000.0), location).advance_width(id.into()).ok_or_else(|| Error("Missing Arabic PDF glyph width".into()))?;
let mut pen = Pen { shear: if italic(font) { 0.212_556_56 } else { 0.0 }, ..Default::default() };
glyph.draw(DrawSettings::unhinted(Size::new(1000.0), location), &mut pen).map_err(|e| Error(format!("Cannot draw Arabic PDF glyph: {e}")))?;
if pen.full || self.bytes.saturating_add(pen.path.len()).saturating_add(source.len().saturating_mul(2)) > MAX_SUBSET_BYTES {
return Err(Error("Arabic PDF outlines exceed the page size limit".into()));
}
let index = self.glyphs.len();
self.bytes += pen.path.len() + source.len() * 2;
let emboldened = face.synthetic_bold;
let grow = if emboldened { SYNTHETIC_BOLD_STROKE / 2.0 } else { 0.0 };
let [x0, y0, x1, y1] = pen.bounds;
self.glyphs.push(Glyph { path: pen.path, width, source, bounds: [x0 - grow, y0 - grow, x1 + grow, y1 + grow], emboldened });
self.keys.insert(key, index);
Ok(index)
}
pub(crate) fn text(&mut self, font: Font, text: &str, size: f32, direction: TextDirection) -> Result<String, Error> {
let layout = layout(font, text, direction)?;
let mut out = format!("/Span << /ActualText {} >> BDC\nBT\n", unicode_string(text, true));
for item in layout.items {
match item {
Item::Glyph { id, x, y, source } => {
let index = self.insert(font, id, source)?;
let _ = writeln!(
out,
"/A{} {} Tf 1 0 0 1 {} {} Tm <{:02X}> Tj",
index / 255 + 1,
n(size),
n(x * size / 1000.0),
n(y * size / 1000.0),
index % 255 + 1
);
}
Item::Latin { text, x } => {
let _ = writeln!(out, "/F{} {} Tf 1 0 0 1 {} 0 Tm {} Tj", font.index() + 1, n(size), n(x * size / 1000.0), pdf_string(&text));
}
Item::Cid { text, x } => {
self.uses_cid = true;
let _ = writeln!(out, "/F{} {} Tf 1 0 0 1 {} 0 Tm {} Tj", CID_FONT + 1, n(size), n(x * size / 1000.0), pdf_utf16_string(&text));
}
}
}
out.push_str("ET\nEMC");
Ok(out)
}
/// Writes the subset fonts into `out` and returns their page resource entries.
pub(crate) fn write_objects(&self, next: &mut u32, out: &mut Vec<u8>, offsets: &mut Vec<usize>) -> String {
let mut resources = String::new();
for (batch, glyphs) in self.glyphs.chunks(255).enumerate() {
let id = *next;
let cmap_id = id + 1;
*next += 2;
let mut procs = String::new();
let mut names = String::new();
let mut widths = String::new();
let mut mappings = Vec::new();
let mut bounds = [0.0_f32; 4];
for (i, glyph) in glyphs.iter().enumerate() {
let code = i + 1;
let _ = write!(procs, "/g{code} {} 0 R ", *next);
let _ = write!(names, "/g{code} ");
let _ = write!(widths, "{} ", n(glyph.width));
let body = glyph_procedure(glyph);
stream_obj(out, offsets, *next, "", body.as_bytes());
*next += 1;
bounds[0] = bounds[0].min(glyph.bounds[0]);
bounds[1] = bounds[1].min(glyph.bounds[1]);
bounds[2] = bounds[2].max(glyph.bounds[2]);
bounds[3] = bounds[3].max(glyph.bounds[3]);
if !glyph.source.is_empty() {
mappings.push(format!("<{code:02X}> {}\n", unicode_string(&glyph.source, false)));
}
}
let mut cmap = "/CIDInit /ProcSet findresource begin\n12 dict begin\nbegincmap\n/CIDSystemInfo << /Registry (Adobe) /Ordering (UCS) /Supplement 0 >> def\n/CMapName /GridCraftArabicUnicode def\n/CMapType 2 def\n1 begincodespacerange\n<00> <FF>\nendcodespacerange\n".to_string();
for group in mappings.chunks(100) {
let _ = writeln!(cmap, "{} beginbfchar", group.len());
for mapping in group {
cmap.push_str(mapping);
}
cmap.push_str("endbfchar\n");
}
cmap.push_str("endcmap\nCMapName currentdict /CMap defineresource pop\nend\nend\n");
stream_obj(out, offsets, cmap_id, "", cmap.as_bytes());
dict_obj(
out,
offsets,
id,
&format!(
"<< /Type /Font /Subtype /Type3 /Name /GridCraftArabic /FontBBox [{} {} {} {}] /FontMatrix [0.001 0 0 0.001 0 0] /CharProcs << {procs}>> /Encoding << /Type /Encoding /Differences [1 {names}] >> /FirstChar 1 /LastChar {} /Widths [{widths}] /Resources << >> /ToUnicode {cmap_id} 0 R >>",
n(bounds[0]),
n(bounds[1]),
n(bounds[2]),
n(bounds[3]),
glyphs.len()
),
);
let _ = write!(resources, "/A{} {id} 0 R ", batch + 1);
}
resources
}
}
pub(crate) fn unicode_string(text: &str, bom: bool) -> String {
let mut out = if bom { "<FEFF".to_string() } else { "<".to_string() };
for unit in text.encode_utf16() {
let _ = write!(out, "{unit:04X}");
}
out.push('>');
out
}
#[derive(Default)]
struct Pen {
path: String,
point: [f32; 2],
bounds: [f32; 4],
shear: f32,
full: bool,
}
impl Pen {
fn point(&mut self, x: f32, y: f32) -> [f32; 2] {
let x = x + self.shear * y;
self.bounds[0] = self.bounds[0].min(x);
self.bounds[1] = self.bounds[1].min(y);
self.bounds[2] = self.bounds[2].max(x);
self.bounds[3] = self.bounds[3].max(y);
[x, y]
}
fn op(&mut self, value: &str) {
if self.path.len().saturating_add(value.len()) > MAX_OUTLINE_BYTES {
self.full = true;
}
if !self.full {
self.path.push_str(value);
}
}
}
impl OutlinePen for Pen {
fn move_to(&mut self, x: f32, y: f32) {
let [px, py] = self.point(x, y);
self.op(&format!("{} {} m\n", n(px), n(py)));
self.point = [x, y];
}
fn line_to(&mut self, x: f32, y: f32) {
let [px, py] = self.point(x, y);
self.op(&format!("{} {} l\n", n(px), n(py)));
self.point = [x, y];
}
fn quad_to(&mut self, cx: f32, cy: f32, x: f32, y: f32) {
self.curve_to(
self.point[0] + (cx - self.point[0]) * 2.0 / 3.0,
self.point[1] + (cy - self.point[1]) * 2.0 / 3.0,
x + (cx - x) * 2.0 / 3.0,
y + (cy - y) * 2.0 / 3.0,
x,
y,
);
}
fn curve_to(&mut self, cx: f32, cy: f32, dx: f32, dy: f32, x: f32, y: f32) {
let [cx, cy] = self.point(cx, cy);
let [dx, dy] = self.point(dx, dy);
let [px, py] = self.point(x, y);
self.op(&format!("{} {} {} {} {} {} c\n", n(cx), n(cy), n(dx), n(dy), n(px), n(py)));
self.point = [x, y];
}
fn close(&mut self) {
self.op("h\n");
}
}
#[cfg(test)]
mod tests {
#[test]
fn fallback_mirrors_only_paired_ansi_punctuation() {
let visual: String = "(مرحبا)".chars().rev().map(super::mirror_ansi).collect();
assert_eq!(visual, "(ابحرم)");
assert_eq!("[(<«‹abc›»>)]".chars().rev().map(super::mirror_ansi).collect::<String>(), "[(<«‹cba›»>)]");
}
#[test]
fn a_bold_request_served_by_a_static_regular_face_is_emboldened() {
assert!(super::needs_synthetic_bold("craft:Noto Sans Arabic:Regular", b"static", true));
assert!(!super::needs_synthetic_bold("craft:Noto Sans Arabic:Regular", b"static", false));
assert!(!super::needs_synthetic_bold("craft:Noto Sans Arabic:Bold", b"static", true));
let glyph =
|emboldened| super::Glyph { path: "0 0 m 10 0 l 10 10 l h\n".into(), width: 500.0, source: String::new(), bounds: [0.0; 4], emboldened };
assert_eq!(super::glyph_procedure(&glyph(false)), "500 0 d0\n0 0 m 10 0 l 10 10 l h\nf\n");
assert_eq!(super::glyph_procedure(&glyph(true)), "500 0 d0\n30 w 1 j\n0 0 m 10 0 l 10 10 l h\nB\n");
}
#[test]
fn line_breaks_never_use_the_embedded_face() {
for ch in ['\n', '\r', '\u{2028}', '\u{2029}'] {
assert!(!super::embeddable(true, ch), "{ch:?}");
}
assert!(super::embeddable(true, 'م'));
assert!(super::embeddable(false, '\u{200f}'));
assert!(!super::embeddable(false, 'A'));
}
#[test]
fn no_bundled_or_installed_face_is_not_an_error() {
for bold in [false, true] {
assert!(matches!(super::find_face(&[], &[], bold), Ok(None)));
assert!(matches!(super::find_face(&[], &[std::env::temp_dir().join("gridcraft-no-fonts-here")], bold), Ok(None)));
}
}
#[test]
fn bundled_faces_match_the_requested_weight() {
const REGULAR: &[u8] = b"regular";
const BOLD: &[u8] = b"bold";
let bold_first = [("Noto Sans Arabic:Bold", BOLD), ("Noto Sans Arabic", REGULAR)];
assert_eq!(super::bundled_match(&bold_first, false), Some(REGULAR));
assert_eq!(super::bundled_match(&bold_first, true), Some(BOLD));
assert_eq!(super::bundled_match(&[("Noto Sans Arabic", REGULAR)], true), None);
assert_eq!(super::bundled_match(&[], false), None);
assert_eq!(super::bundled_fallback(&[("Noto Sans Arabic:Bold", BOLD)], false), None);
assert_eq!(super::bundled_fallback(&[("Noto Sans Arabic:Regular", REGULAR)], true), Some(("Noto Sans Arabic:Regular", REGULAR)));
}
}
+535 -191
View File
@@ -5,21 +5,68 @@
//! WinAnsiEncoding (CJK and other scripts) are set in a predefined, non-embedded Adobe-GB1 CID
//! font with the `UniGB-UTF16-H` CMap instead of being replaced by `?`. Symbol uses its own
//! built-in encoding ([`symbol_code`]), for Greek letters and mathematical operators.
//! - Arabic is shaped and set in embedded Type3 subsets, with exact shaped advances.
//! - Vector drawing: rectangles, lines (solid or dashed), polygons, circles (Bézier), clipping.
//! - RGBA images as RGB image XObjects with a soft mask for alpha (run-length encoded).
//! - Coordinates are points with a **top-left origin** (y grows down); text `y` is the baseline.
//!
//! Streams are written uncompressed (images use the trivial RunLengthDecode filter) so the crate
//! needs no dependencies.
//! Streams are written uncompressed (images use the RunLengthDecode filter).
#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
#![forbid(unsafe_code)]
mod arabic;
mod metrics;
mod symbol;
pub use symbol::{symbol_code, symbol_width};
/// Paragraph base direction. Context follows spreadsheet reading order: the first
/// non-whitespace character determines direction, including digits and punctuation.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum TextDirection {
#[default]
Auto,
Context,
LeftToRight,
RightToLeft,
}
impl TextDirection {
/// Resolve once for a paragraph before wrapping it into visual lines.
pub fn resolve(self, text: &str) -> Self {
use unicode_bidi::{BidiClass, BidiInfo, bidi_class};
let rtl = match self {
Self::Auto => BidiInfo::new(text, None).paragraphs.first().is_some_and(|p| p.level.is_rtl()),
Self::Context => text.chars().find(|ch| !ch.is_whitespace()).is_some_and(|ch| matches!(bidi_class(ch), BidiClass::R | BidiClass::AL)),
explicit => return explicit,
};
if rtl { Self::RightToLeft } else { Self::LeftToRight }
}
fn level(self) -> Option<unicode_bidi::Level> {
match self {
Self::Auto => None,
Self::LeftToRight | Self::Context => Some(unicode_bidi::Level::ltr()),
Self::RightToLeft => Some(unicode_bidi::Level::rtl()),
}
}
}
/// A PDF export could not preserve the requested text.
#[derive(Clone, Debug)]
pub struct Error(String);
impl std::fmt::Display for Error {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(&self.0)
}
}
impl std::error::Error for Error {}
use std::collections::HashMap;
use std::collections::hash_map::DefaultHasher;
use std::fmt::Write as _;
use std::hash::{Hash, Hasher};
/// RGB colour, 0–255 per channel.
pub type Rgb = [u8; 3];
@@ -37,6 +84,13 @@ impl Point {
}
}
/// A text baseline origin and its clockwise rotation in radians.
#[derive(Clone, Copy, Debug, Default, PartialEq)]
pub struct Baseline {
pub origin: Point,
pub angle: f32,
}
/// A page-space rectangle described by its top-left corner and extent.
#[derive(Clone, Copy, Debug, Default, PartialEq)]
pub struct Rect {
@@ -199,10 +253,29 @@ impl Font {
}
}
/// Whether [`text_width_with_direction`] is the sum of `text`'s character widths: not shaped,
/// not reordered right to left and holding no bidi controls. A prefix's width is then a running sum.
pub fn width_is_char_sum(font: Font, text: &str, direction: TextDirection) -> bool {
let direction = if direction == TextDirection::Context { direction.resolve(text) } else { direction };
!arabic::shaped(font, text) && arabic::is_logical_order(text, direction)
}
/// Width of `text` in points when set in `font` at `size` points.
/// Arabic uses shaped advances. If its font cannot render the text, measurement returns zero
/// and drawing that text causes [`PdfDoc::finish`] to return the rendering error.
pub fn text_width(font: Font, size: f32, text: &str) -> f32 {
text_width_with_direction(font, size, text, TextDirection::Auto)
}
/// Width measured with the same base direction as drawing.
pub fn text_width_with_direction(font: Font, size: f32, text: &str, direction: TextDirection) -> f32 {
let direction = if direction == TextDirection::Context { direction.resolve(text) } else { direction };
if arabic::shaped(font, text) {
return arabic::layout(font, text, direction).map(|layout| layout.width * size / 1000.0).unwrap_or(0.0);
}
// u64: a u32 sum overflows for ~8 million characters.
let units: u64 = text.chars().map(|c| u64::from(font.char_width(c))).sum();
let Ok(visual) = arabic::latin_visual(text, direction) else { return 0.0 };
let units: u64 = visual.chars().map(|c| u64::from(font.char_width(c))).sum();
units as f32 * size / 1000.0
}
@@ -322,6 +395,31 @@ fn n(v: f32) -> String {
}
}
/// Appends `v / 255` with at most three decimals, exactly what `n(v as f32 / 255.0)` gives, but
/// without a float round trip or an allocation per channel.
fn push_unit(s: &mut String, v: u8) {
let m = (u32::from(v) * 1000 + 127) / 255;
match m {
0 => s.push('0'),
1000 => s.push('1'),
_ => {
let _ = write!(s, "0.{m:03}");
while s.ends_with('0') {
s.pop();
}
}
}
}
/// Appends a colour operator line without the trailing newline: `r g b rg` (fill) or `r g b RG`.
fn push_rgb(s: &mut String, c: Rgb, stroke: bool) {
for v in c {
push_unit(s, v);
s.push(' ');
}
s.push_str(if stroke { "RG" } else { "rg" });
}
/// True when every value is finite (NaN and infinities are rejected).
fn finite(v: &[f32]) -> bool {
v.iter().all(|x| x.is_finite())
@@ -348,16 +446,44 @@ fn dash_values(dash: &[f32]) -> String {
d.iter().map(|v| n(*v)).collect::<Vec<_>>().join(" ")
}
fn rgb_op(c: Rgb, stroke: bool) -> String {
let f = |v: u8| n(v as f32 / 255.0);
format!("{} {} {} {}", f(c[0]), f(c[1]), f(c[2]), if stroke { "RG" } else { "rg" })
}
struct ImageData {
width: u32,
height: u32,
rgb: Vec<u8>,
/// `None` when every pixel is fully opaque (no soft mask is written).
alpha: Option<Vec<u8>>,
/// Hash of all of the above, to find duplicates quickly; equality still compares the bytes.
hash: u64,
}
impl ImageData {
fn new(width: u32, height: u32, rgb: Vec<u8>, alpha: Option<Vec<u8>>) -> ImageData {
let mut h = DefaultHasher::new();
width.hash(&mut h);
height.hash(&mut h);
rgb.hash(&mut h);
alpha.hash(&mut h);
ImageData { width, height, rgb, alpha, hash: h.finish() }
}
/// Same pixels (a hash match alone is never trusted).
fn same(&self, o: &ImageData) -> bool {
self.hash == o.hash && self.width == o.width && self.height == o.height && self.rgb == o.rgb && self.alpha == o.alpha
}
}
/// The part of the graphics state the writer tracks so that a style operator is only emitted
/// when it changes. `None` = not set yet on this page (or since the last restore that undid it).
#[derive(Clone, Debug, Default, PartialEq)]
struct Style {
fill: Option<Rgb>,
stroke: Option<Rgb>,
/// Formatted line width.
width: Option<String>,
/// Formatted dash array contents.
dash: Option<String>,
/// Line join; PDF's initial value is 0 (miter).
join: u8,
}
enum LinkTarget {
@@ -378,8 +504,21 @@ pub struct Page {
content: String,
fonts: [bool; FONT_SLOTS],
images: Vec<ImageData>,
/// Indexes into `images`, by content hash; a hash match is confirmed with [`ImageData::same`].
image_index: HashMap<u64, Vec<usize>>,
/// Pixel comparisons made while looking up duplicate pictures (test instrumentation).
#[cfg(test)]
image_comparisons: usize,
/// Style operators already in effect at the end of `content`.
style: Style,
/// One entry per accepted [`Page::save`], restored by [`Page::restore`].
saved: Vec<Style>,
/// `save` calls refused at the nesting limit; the same number of `restore` calls are ignored.
refused: u32,
links: Vec<LinkAnnotation>,
depth: u32,
arabic: arabic::Subset,
error: Option<Error>,
missing_arabic_font: bool,
}
/// Most bytes of content per page before further drawing is dropped (keeps hostile inputs from
@@ -387,6 +526,11 @@ pub struct Page {
const MAX_PAGE_CONTENT: usize = 64 * 1024 * 1024;
/// Largest image (pixels) embedded.
const MAX_IMAGE_PIXELS: u64 = 40_000_000;
/// Deepest `q` nesting a PDF consumer must support (the PDF specification's implementation limits).
const MAX_SAVE_DEPTH: usize = 28;
/// Line join styles, as the `j` operator takes them.
const JOIN_MITER: u8 = 0;
const JOIN_ROUND: u8 = 1;
const MAX_PAGE_LINKS: usize = 4096;
const MAX_LINK_URI_BYTES: usize = 4096;
@@ -410,6 +554,38 @@ impl Page {
}
}
/// Appends a fill colour operator to `s` unless that colour is already in effect.
fn set_fill(&mut self, s: &mut String, c: Rgb) {
if self.style.fill != Some(c) {
push_rgb(s, c, false);
s.push('\n');
self.style.fill = Some(c);
}
}
/// Appends the stroke colour, width, dash and join operators to `s` that differ from the
/// style already in effect.
fn set_stroke(&mut self, s: &mut String, c: Rgb, width: f32, dash: &str, join: u8) {
if self.style.stroke != Some(c) {
push_rgb(s, c, true);
s.push('\n');
self.style.stroke = Some(c);
}
let w = n(stroke_width(width));
if self.style.width.as_deref() != Some(w.as_str()) {
let _ = writeln!(s, "{w} w");
self.style.width = Some(w);
}
if self.style.dash.as_deref() != Some(dash) {
let _ = writeln!(s, "[{dash}] 0 d");
self.style.dash = Some(dash.to_string());
}
if self.style.join != join {
let _ = writeln!(s, "{join} j");
self.style.join = join;
}
}
fn link_rect(&self, rect: Rect) -> Option<[f32; 4]> {
let Rect { x, y, width, height } = rect;
if !finite(&[x, y, width, height]) || !extent(width) || !extent(height) || self.links.len() >= MAX_PAGE_LINKS {
@@ -447,15 +623,23 @@ impl Page {
}
}
/// Saves the graphics state (pair with [`Page::restore`]).
/// Saves the graphics state (pair with [`Page::restore`]). Nesting is limited to 28 levels, the
/// depth every PDF consumer must support; a `save` beyond that is ignored, and so is the
/// `restore` that would have matched it.
pub fn save(&mut self) {
self.depth = self.depth.saturating_add(1);
if self.saved.len() >= MAX_SAVE_DEPTH {
self.refused = self.refused.saturating_add(1);
return;
}
self.saved.push(self.style.clone());
self.content.push_str("q\n");
}
/// Restores the graphics state saved by [`Page::save`]; extra calls are ignored.
pub fn restore(&mut self) {
if self.depth > 0 {
self.depth -= 1;
if self.refused > 0 {
self.refused -= 1;
} else if let Some(style) = self.saved.pop() {
self.style = style;
self.content.push_str("Q\n");
}
}
@@ -466,18 +650,22 @@ impl Page {
}
pub fn fill_rect(&mut self, x: f32, y: f32, w: f32, h: f32, color: Rgb) {
if !(extent(w) && extent(h) && finite(&[x, y])) {
if !(extent(w) && extent(h) && finite(&[x, y])) || self.full() {
return;
}
let s = format!("{}\n{} {} {} {} re f", rgb_op(color, false), n(x), n(self.y(y + h)), n(w), n(h));
let mut s = String::new();
self.set_fill(&mut s, color);
let _ = write!(s, "{} {} {} {} re f", n(x), n(self.y(y + h)), n(w), n(h));
self.op(&s);
}
pub fn rect_stroke(&mut self, x: f32, y: f32, w: f32, h: f32, width: f32, color: Rgb) {
if !finite(&[x, y, w, h]) {
if !finite(&[x, y, w, h]) || self.full() {
return;
}
let s = format!("{}\n{} w [] 0 d\n{} {} {} {} re S", rgb_op(color, true), n(stroke_width(width)), n(x), n(self.y(y + h)), n(w), n(h));
let mut s = String::new();
self.set_stroke(&mut s, color, width, "", JOIN_MITER);
let _ = write!(s, "{} {} {} {} re S", n(x), n(self.y(y + h)), n(w), n(h));
self.op(&s);
}
@@ -487,28 +675,22 @@ impl Page {
/// A line with a dash pattern (`[on, off, …]` in points; empty = solid).
pub fn stroke_line_dashed(&mut self, start: Point, end: Point, width: f32, color: Rgb, dash: &[f32]) {
if !finite(&[start.x, start.y, end.x, end.y]) {
if !finite(&[start.x, start.y, end.x, end.y]) || self.full() {
return;
}
let s = format!(
"{}\n{} w [{}] 0 d\n{} {} m {} {} l S",
rgb_op(color, true),
n(stroke_width(width)),
dash_values(dash),
n(start.x),
n(self.y(start.y)),
n(end.x),
n(self.y(end.y))
);
let mut s = String::new();
self.set_stroke(&mut s, color, width, &dash_values(dash), JOIN_MITER);
let _ = write!(s, "{} {} m {} {} l S", n(start.x), n(self.y(start.y)), n(end.x), n(self.y(end.y)));
self.op(&s);
}
/// An open polyline.
/// An open polyline (round joins).
pub fn polyline(&mut self, pts: &[[f32; 2]], width: f32, color: Rgb, dash: &[f32]) {
if pts.len() < 2 || !pts.iter().all(|p| finite(p)) {
if pts.len() < 2 || !pts.iter().all(|p| finite(p)) || self.full() {
return;
}
let mut s = format!("{}\n{} w [{}] 0 d 1 j\n", rgb_op(color, true), n(stroke_width(width)), dash_values(dash));
let mut s = String::new();
self.set_stroke(&mut s, color, width, &dash_values(dash), JOIN_ROUND);
self.path(&mut s, pts, false);
s.push_str(" S");
self.op(&s);
@@ -523,18 +705,17 @@ impl Page {
}
}
/// A closed polygon, filled and/or stroked.
/// A closed polygon, filled and/or stroked (round joins).
pub fn polygon(&mut self, pts: &[[f32; 2]], fill: Option<Rgb>, stroke: Option<(Rgb, f32)>) {
if pts.len() < 2 || (fill.is_none() && stroke.is_none()) || !pts.iter().all(|p| finite(p)) {
if pts.len() < 2 || (fill.is_none() && stroke.is_none()) || !pts.iter().all(|p| finite(p)) || self.full() {
return;
}
let mut s = String::new();
if let Some(f) = fill {
s.push_str(&rgb_op(f, false));
s.push('\n');
self.set_fill(&mut s, f);
}
if let Some((c, w)) = stroke {
let _ = writeln!(s, "{}\n{} w [] 0 d 1 j", rgb_op(c, true), n(stroke_width(w)));
self.set_stroke(&mut s, c, w, "", JOIN_ROUND);
}
self.path(&mut s, pts, true);
s.push_str(match (fill.is_some(), stroke.is_some()) {
@@ -547,7 +728,7 @@ impl Page {
/// A circle approximated by four cubic Béziers.
pub fn circle(&mut self, cx: f32, cy: f32, r: f32, fill: Option<Rgb>, stroke: Option<(Rgb, f32)>) {
if !extent(r) || !finite(&[cx, cy]) || (fill.is_none() && stroke.is_none()) {
if !extent(r) || !finite(&[cx, cy]) || (fill.is_none() && stroke.is_none()) || self.full() {
return;
}
const K: f32 = 0.552_284_8;
@@ -555,11 +736,10 @@ impl Page {
let y = self.y(cy);
let mut s = String::new();
if let Some(f) = fill {
s.push_str(&rgb_op(f, false));
s.push('\n');
self.set_fill(&mut s, f);
}
if let Some((c, w)) = stroke {
let _ = writeln!(s, "{}\n{} w [] 0 d", rgb_op(c, true), n(stroke_width(w)));
self.set_stroke(&mut s, c, w, "", JOIN_MITER);
}
let _ = write!(
s,
@@ -599,48 +779,132 @@ impl Page {
self.op(&s);
}
/// Arabic ink extents above and below the baseline, in points. Standard font text returns
/// `None`. Font errors are recorded for [`PdfDoc::finish`], just as when drawing text.
pub fn text_vertical_extents(&mut self, font: Font, size: f32, text: &str) -> Option<(f32, f32)> {
self.text_vertical_extents_with_direction(font, size, text, TextDirection::Auto)
}
/// Arabic ink extents with an explicit paragraph base direction.
pub fn text_vertical_extents_with_direction(&mut self, font: Font, size: f32, text: &str, direction: TextDirection) -> Option<(f32, f32)> {
if !arabic::shaped(font, text) {
return None;
}
match arabic::vertical_extents(font, text, direction) {
Ok((ascent, descent)) => Some((ascent * size / 1000.0, descent * size / 1000.0)),
Err(error) => {
self.error.get_or_insert(error);
None
}
}
}
/// Text with its baseline starting at `(x, y)`.
pub fn text(&mut self, x: f32, y: f32, size: f32, font: Font, color: Rgb, text: &str) {
self.text_rotated(Point::new(x, y), size, font, color, text, 0.0);
self.text_with_direction(Point::new(x, y), size, font, color, text, TextDirection::Auto);
}
/// Text drawn with an explicit paragraph base direction.
pub fn text_with_direction(&mut self, origin: Point, size: f32, font: Font, color: Rgb, text: &str, direction: TextDirection) {
self.text_rotated_with_direction(Baseline { origin, angle: 0.0 }, size, font, color, text, direction);
}
/// Text rotated by `angle` radians (clockwise on the page, like the y-down coordinate
/// system) about its baseline origin.
pub fn text_rotated(&mut self, origin: Point, size: f32, font: Font, color: Rgb, text: &str, angle: f32) {
self.text_rotated_with_direction(Baseline { origin, angle }, size, font, color, text, TextDirection::Auto);
}
/// Rotated text with an explicit paragraph base direction.
pub fn text_rotated_with_direction(&mut self, baseline: Baseline, size: f32, font: Font, color: Rgb, text: &str, direction: TextDirection) {
let Baseline { origin, angle } = baseline;
if text.is_empty() || !extent(size) || !finite(&[origin.x, origin.y]) {
return;
}
let fi = font.index();
let size = n(size.min(10_000.0));
let direction = if direction == TextDirection::Context { direction.resolve(text) } else { direction };
let (sn, cs) = if angle.is_finite() { angle.sin_cos() } else { (0.0, 1.0) };
// Clockwise in y-down = counter-clockwise negated in PDF's y-up space.
let mut s = format!("BT\n{}\n{} {} {} {} {} {} Tm\n", rgb_op(color, false), n(cs), n(-sn), n(sn), n(cs), n(origin.x), n(self.y(origin.y)));
// Symbol text is one run in Symbol's own encoding (the CID font has no maths symbols).
if font == Font::Symbol {
if let Some(f) = self.fonts.get_mut(fi) {
*f = true;
}
let _ = writeln!(s, "/F{} {} Tf\n{} Tj", fi + 1, size, pdf_string_in(text, true));
s.push_str("ET");
self.op(&s);
let matrix = format!("{} {} {} {} {} {}", n(cs), n(-sn), n(sn), n(cs), n(origin.x), n(self.y(origin.y)));
let size = size.min(10_000.0);
let shaping = arabic::shaping(font, text);
self.missing_arabic_font |= shaping == arabic::Shaping::NoFont;
if shaping == arabic::Shaping::Shaped {
self.shaped_text(&matrix, size, font, color, text, direction);
} else {
self.standard_text(&matrix, size, font, color, text, direction);
}
}
fn shaped_text(&mut self, matrix: &str, size: f32, font: Font, color: Rgb, text: &str, direction: TextDirection) {
if self.saved.len() >= MAX_SAVE_DEPTH {
return;
}
// Runs of WinAnsi text use `font`; runs it cannot encode use the CID font. Each `Tj`
// advances the text position, so the runs follow each other on the baseline.
let mut rest = text;
while let Some(first) = rest.chars().next() {
let cid = needs_cid(first);
let end = rest.char_indices().find(|(_, c)| needs_cid(*c) != cid).map_or(rest.len(), |(i, _)| i);
let (run, tail) = rest.split_at(end);
let (slot, string) = if cid { (CID_FONT, pdf_utf16_string(run)) } else { (fi, pdf_string(run)) };
let body = match self.arabic.text(font, text, size, direction) {
Ok(body) => body,
Err(error) => {
self.error.get_or_insert(error);
return;
}
};
for slot in [Some(font.index()), self.arabic.uses_cid.then_some(CID_FONT)].into_iter().flatten() {
if let Some(f) = self.fonts.get_mut(slot) {
*f = true;
}
let _ = writeln!(s, "/F{} {} Tf\n{} Tj", slot + 1, size, string);
}
let mut s = format!("q\n{matrix} cm\n");
push_rgb(&mut s, color, false);
s.push(' ');
push_rgb(&mut s, color, true);
let _ = write!(s, "\n{body}\nQ");
self.text_op(&s);
}
fn standard_text(&mut self, matrix: &str, size: f32, font: Font, color: Rgb, text: &str, direction: TextDirection) {
let visual = match arabic::latin_visual(text, direction) {
Ok(visual) => visual,
Err(error) => {
self.error.get_or_insert(error);
return;
}
};
let fi = font.index();
let size = n(size);
let mut runs = String::new();
// Runs of WinAnsi text use `font`; runs it cannot encode use the CID font. Each `Tj`
// advances the text position, so the runs follow each other on the baseline.
// Symbol text is one run in Symbol's own encoding (the CID font has no maths symbols).
let symbol = font == Font::Symbol;
let uses_cid = |c: char| !symbol && needs_cid(c);
let mut rest: &str = &visual;
while let Some(first) = rest.chars().next() {
let cid = uses_cid(first);
let end = rest.char_indices().find(|(_, c)| uses_cid(*c) != cid).map_or(rest.len(), |(i, _)| i);
let (run, tail) = rest.split_at(end);
let (slot, string) = if cid { (CID_FONT, pdf_utf16_string(run)) } else { (fi, pdf_string_in(run, symbol)) };
if let Some(f) = self.fonts.get_mut(slot) {
*f = true;
}
let first_run = runs.is_empty();
let _ = writeln!(runs, "/F{} {} Tf", slot + 1, size);
if first_run {
let _ = writeln!(runs, "{matrix} Tm");
}
let _ = writeln!(runs, "{string} Tj");
rest = tail;
}
s.push_str("ET");
self.op(&s);
let mut s = String::new();
self.set_fill(&mut s, color);
let _ = write!(s, "BT\n{runs}ET");
let s = if visual != text { format!("/Span << /ActualText {} >> BDC\n{s}\nEMC", arabic::unicode_string(text, true)) } else { s };
self.text_op(&s);
}
fn text_op(&mut self, s: &str) {
if self.content.len().saturating_add(s.len()).saturating_add(1) > MAX_PAGE_CONTENT {
self.error.get_or_insert_with(|| Error("PDF page text exceeds the size limit".into()));
} else {
self.op(s);
}
}
/// Draws an RGBA image (`pw`×`ph` pixels, row-major, straight alpha) into the box
@@ -652,16 +916,47 @@ impl Page {
if pw == 0 || ph == 0 || px > MAX_IMAGE_PIXELS || (rgba.len() as u64) < px * 4 || !(extent(w) && extent(h) && finite(&[x, y])) {
return;
}
// The image is drawn inside its own q/Q, which counts towards the nesting limit.
if self.saved.len() >= MAX_SAVE_DEPTH {
return;
}
let px = px as usize;
let mut rgb = Vec::with_capacity(px * 3);
let mut alpha = Vec::with_capacity(px);
for p in rgba.as_chunks::<4>().0.iter().take(px) {
// The alpha plane is only allocated once a non-opaque pixel shows up.
let mut alpha: Option<Vec<u8>> = None;
for (i, p) in rgba.as_chunks::<4>().0.iter().take(px).enumerate() {
rgb.extend_from_slice(&[p[0], p[1], p[2]]);
alpha.push(p[3]);
match &mut alpha {
Some(a) => a.push(p[3]),
None if p[3] != 255 => {
let mut a = Vec::with_capacity(px);
a.resize(i, 255);
a.push(p[3]);
alpha = Some(a);
}
None => {}
}
}
let alpha = if alpha.iter().all(|a| *a == 255) { None } else { Some(alpha) };
let idx = self.images.len();
self.images.push(ImageData { width: pw, height: ph, rgb, alpha });
let img = ImageData::new(pw, ph, rgb, alpha);
// The same picture drawn again on this page shares one XObject.
let candidates = self.image_index.entry(img.hash).or_default();
#[cfg(test)]
let comparisons = &mut self.image_comparisons;
let known = candidates.iter().copied().find(|&i| {
#[cfg(test)]
{
*comparisons += 1;
}
self.images.get(i).is_some_and(|o| o.same(&img))
});
let idx = match known {
Some(i) => i,
None => {
candidates.push(self.images.len());
self.images.push(img);
self.images.len() - 1
}
};
let s = format!("q {} 0 0 {} {} {} cm /Im{} Do Q", n(w), n(h), n(x), n(self.y(y + h)), idx + 1);
self.op(&s);
}
@@ -684,39 +979,7 @@ pub struct PdfDoc {
/// PackBits-style run-length encoding (PDF `RunLengthDecode`).
fn run_length(data: &[u8]) -> Vec<u8> {
let mut out = Vec::with_capacity(data.len() / 2 + 16);
let mut i = 0;
while i < data.len() {
let b = data[i];
let mut run = 1;
while i + run < data.len() && run < 128 && data[i + run] == b {
run += 1;
}
if run >= 2 {
out.push((257 - run) as u8);
out.push(b);
i += run;
continue;
}
// Literal run until the next repeat of 3+ or 128 bytes.
let start = i;
let mut len = 0;
while i < data.len() && len < 128 {
if i + 2 < data.len() && data[i] == data[i + 1] && data[i] == data[i + 2] {
break;
}
i += 1;
len += 1;
}
if len == 0 {
// Next is a repeat; loop will handle it.
continue;
}
out.push((len - 1) as u8);
out.extend_from_slice(&data[start..start + len]);
}
out.push(128);
out
craft_stream_codecs::runlength::encode(data)
}
/// Longest Info string written, in characters; longer values are cut on a character boundary.
@@ -738,6 +1001,49 @@ fn pdf_text_string(text: &str) -> String {
s
}
/// Starts object `id` at the current end of `out` and records its offset for the xref table.
fn begin_obj(out: &mut Vec<u8>, offsets: &mut Vec<usize>, id: u32) {
let i = id as usize;
if offsets.len() <= i {
offsets.resize(i + 1, 0);
}
if let Some(slot) = offsets.get_mut(i) {
*slot = out.len();
}
let _ = writeln!(Utf8(out), "{id} 0 obj");
}
/// Writes `id 0 obj <body> endobj`.
fn dict_obj(out: &mut Vec<u8>, offsets: &mut Vec<usize>, id: u32, body: &str) {
begin_obj(out, offsets, id);
out.extend_from_slice(body.as_bytes());
out.extend_from_slice(b"\nendobj\n");
}
/// Writes a stream object: `dict` (the dictionary entries without `<<`, `>>` and `/Length`, may be
/// empty) and `data` as the stream body.
fn stream_obj(out: &mut Vec<u8>, offsets: &mut Vec<usize>, id: u32, dict: &str, data: &[u8]) {
begin_obj(out, offsets, id);
out.extend_from_slice(b"<<");
if !dict.is_empty() {
out.push(b' ');
out.extend_from_slice(dict.as_bytes());
}
let _ = write!(Utf8(out), " /Length {} >>\nstream\n", data.len());
out.extend_from_slice(data);
out.extend_from_slice(b"\nendstream\nendobj\n");
}
/// Lets `write!` append text to a byte buffer.
struct Utf8<'a>(&'a mut Vec<u8>);
impl std::fmt::Write for Utf8<'_> {
fn write_str(&mut self, s: &str) -> std::fmt::Result {
self.0.extend_from_slice(s.as_bytes());
Ok(())
}
}
impl PdfDoc {
pub fn new() -> PdfDoc {
PdfDoc::default()
@@ -747,7 +1053,23 @@ impl PdfDoc {
pub fn add_page(&mut self, width_pt: f32, height_pt: f32) -> &mut Page {
let width = if width_pt.is_finite() { width_pt.clamp(3.0, 14_400.0) } else { 612.0 };
let height = if height_pt.is_finite() { height_pt.clamp(3.0, 14_400.0) } else { 792.0 };
self.pages.push(Page { width, height, content: String::new(), fonts: [false; FONT_SLOTS], images: Vec::new(), links: Vec::new(), depth: 0 });
self.pages.push(Page {
width,
height,
content: String::new(),
fonts: [false; FONT_SLOTS],
images: Vec::new(),
image_index: HashMap::new(),
#[cfg(test)]
image_comparisons: 0,
links: Vec::new(),
style: Style::default(),
saved: Vec::new(),
refused: 0,
arabic: arabic::Subset::default(),
error: None,
missing_arabic_font: false,
});
let i = self.pages.len() - 1;
&mut self.pages[i]
}
@@ -761,11 +1083,34 @@ impl PdfDoc {
self.pages.get_mut(i)
}
/// Whether some Arabic text was set in the standard and CID fonts, which have no Arabic glyphs,
/// because no Arabic face was found for its weight.
pub fn missing_arabic_font(&self) -> bool {
self.pages.iter().any(|page| page.missing_arabic_font)
}
/// Serializes the document. A document without pages gets one blank Letter page.
pub fn finish(mut self) -> Vec<u8> {
///
/// Every object is written straight into the output buffer (nothing is staged in an
/// intermediate list of bodies); only the xref table needs the offset of each object id, and
/// the ids are contiguous from 1. Objects are therefore in the file in the order they are
/// numbered during writing (fonts, then per page its new images, content stream and page
/// dictionary), with the catalog, page tree and info dictionary last.
///
/// Returns an error if the Arabic font is unusable or Arabic text exceeds a size limit.
pub fn finish(mut self) -> Result<Vec<u8>, Error> {
if let Some(error) = self.pages.iter().find_map(|page| page.error.clone()) {
return Err(error);
}
if self.pages.is_empty() {
self.add_page(612.0, 792.0);
}
for page in &mut self.pages {
page.refused = 0;
while !page.saved.is_empty() {
page.restore();
}
}
// Object numbering: 1 catalog, 2 page tree, 3 info, then fonts, then per page.
let mut used = [false; FONT_SLOTS];
for p in &self.pages {
@@ -782,7 +1127,13 @@ impl PdfDoc {
next += if i == CID_FONT { 3 } else { 1 };
}
}
let mut objects: Vec<(u32, Vec<u8>)> = Vec::new();
// Page contents are moved out so each one is freed as soon as it is in the output.
let contents: Vec<String> = self.pages.iter_mut().map(|p| std::mem::take(&mut p.content)).collect();
let page_links: Vec<Vec<LinkAnnotation>> = self.pages.iter_mut().map(|p| std::mem::take(&mut p.links)).collect();
let reserve = contents.iter().fold(4096usize, |acc, c| acc.saturating_add(c.len()).saturating_add(1024));
let mut out: Vec<u8> = Vec::with_capacity(reserve);
out.extend_from_slice(b"%PDF-1.7\n%\xE2\xE3\xCF\xD3\n");
let mut offsets: Vec<usize> = vec![0; 4];
let mut kids = Vec::new();
let mut annotations = Vec::new();
let page_count = self.pages.len();
@@ -792,86 +1143,89 @@ impl PdfDoc {
let _ = write!(font_dict, "/F{} {} 0 R ", i + 1, id);
if i == CID_FONT {
let (cid_id, desc_id) = (id + 1, id + 2);
objects.push((
dict_obj(
&mut out,
&mut offsets,
*id,
format!(
&format!(
"<< /Type /Font /Subtype /Type0 /BaseFont /{CID_BASE_FONT} /Encoding /UniGB-UTF16-H /DescendantFonts [{cid_id} 0 R] >>"
)
.into_bytes(),
));
objects.push((
),
);
dict_obj(
&mut out,
&mut offsets,
cid_id,
format!(
&format!(
"<< /Type /Font /Subtype /CIDFontType0 /BaseFont /{CID_BASE_FONT} /CIDSystemInfo << /Registry (Adobe) /Ordering (GB1) /Supplement 4 >> /FontDescriptor {desc_id} 0 R /DW {CID_WIDTH} >>"
)
.into_bytes(),
));
objects.push((
),
);
dict_obj(
&mut out,
&mut offsets,
desc_id,
format!(
&format!(
"<< /Type /FontDescriptor /FontName /{CID_BASE_FONT} /Flags 6 /FontBBox [-25 -254 1000 880] /ItalicAngle 0 /Ascent 880 /Descent -120 /CapHeight 880 /StemV 93 >>"
)
.into_bytes(),
));
),
);
continue;
}
let name = Font::ALL.get(i).copied().unwrap_or_default().base_name();
let enc = if name.starts_with("Symbol") { "" } else { " /Encoding /WinAnsiEncoding" };
objects.push((*id, format!("<< /Type /Font /Subtype /Type1 /BaseFont /{name}{enc} >>").into_bytes()));
dict_obj(&mut out, &mut offsets, *id, &format!("<< /Type /Font /Subtype /Type1 /BaseFont /{name}{enc} >>"));
}
}
for page in &mut self.pages {
while page.depth > 0 {
page.restore();
}
// Images already written, by content hash: (page, image, object id). A hash match is
// confirmed by comparing the pixels before an object is shared.
let mut written: HashMap<u64, Vec<(usize, usize, u32)>> = HashMap::new();
for (pi, ((page, content), links)) in self.pages.iter().zip(contents).zip(page_links).enumerate() {
let arabic_fonts = page.arabic.write_objects(&mut next, &mut out, &mut offsets);
let page_fonts = format!("{font_dict}{arabic_fonts}");
let mut xobjects = String::new();
for (k, img) in page.images.iter().enumerate() {
let img_id = next;
next += 1;
let smask = match &img.alpha {
Some(a) => {
let id = next;
let known = written.get(&img.hash).and_then(|c| {
c.iter().find_map(|(p, i, id)| {
let other = self.pages.get(*p)?.images.get(*i)?;
img.same(other).then_some(*id)
})
});
let img_id = match known {
Some(id) => id,
None => {
let img_id = next;
next += 1;
let data = run_length(a);
let mut o = format!(
"<< /Type /XObject /Subtype /Image /Width {} /Height {} /ColorSpace /DeviceGray /BitsPerComponent 8 /Filter /RunLengthDecode /Length {} >>\nstream\n",
img.width,
img.height,
data.len()
)
.into_bytes();
o.extend_from_slice(&data);
o.extend_from_slice(b"\nendstream");
objects.push((id, o));
format!(" /SMask {id} 0 R")
let mut dict = format!("/Type /XObject /Subtype /Image /Width {} /Height {} /BitsPerComponent 8", img.width, img.height);
let smask_id = img.alpha.as_ref().map(|_| {
let id = next;
next += 1;
id
});
dict.push_str(" /ColorSpace /DeviceRGB");
if let Some(id) = smask_id {
let _ = write!(dict, " /SMask {id} 0 R");
}
dict.push_str(" /Filter /RunLengthDecode");
stream_obj(&mut out, &mut offsets, img_id, &dict, &run_length(&img.rgb));
if let (Some(id), Some(a)) = (smask_id, &img.alpha) {
let dict = format!(
"/Type /XObject /Subtype /Image /Width {} /Height {} /ColorSpace /DeviceGray /BitsPerComponent 8 /Filter /RunLengthDecode",
img.width, img.height
);
stream_obj(&mut out, &mut offsets, id, &dict, &run_length(a));
}
written.entry(img.hash).or_default().push((pi, k, img_id));
img_id
}
None => String::new(),
};
let data = run_length(&img.rgb);
let mut o = format!(
"<< /Type /XObject /Subtype /Image /Width {} /Height {} /ColorSpace /DeviceRGB /BitsPerComponent 8{} /Filter /RunLengthDecode /Length {} >>\nstream\n",
img.width,
img.height,
smask,
data.len()
)
.into_bytes();
o.extend_from_slice(&data);
o.extend_from_slice(b"\nendstream");
objects.push((img_id, o));
let _ = write!(xobjects, "/Im{} {} 0 R ", k + 1, img_id);
}
let content_id = next;
let page_id = next + 1;
next += 2;
let body = std::mem::take(&mut page.content);
let mut o = format!("<< /Length {} >>\nstream\n", body.len()).into_bytes();
o.extend_from_slice(body.as_bytes());
o.extend_from_slice(b"endstream");
objects.push((content_id, o));
stream_obj(&mut out, &mut offsets, content_id, "", content.as_bytes());
drop(content);
let xo = if xobjects.is_empty() { String::new() } else { format!(" /XObject << {xobjects}>>") };
let mut link_refs = String::new();
for link in std::mem::take(&mut page.links) {
for link in links {
if matches!(&link.target, LinkTarget::Page { index, .. } if *index >= page_count) {
continue;
}
@@ -881,19 +1235,20 @@ impl PdfDoc {
annotations.push((id, link));
}
let annots = if link_refs.is_empty() { String::new() } else { format!(" /Annots [{link_refs}]") };
objects.push((
dict_obj(
&mut out,
&mut offsets,
page_id,
format!(
"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 {} {}] /Resources << /ProcSet [/PDF /Text /ImageB /ImageC] /Font << {}>>{} >> /Contents {} 0 R{} >>",
&format!(
"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 {} {}] /Resources << /Font << {}>>{} >> /Contents {} 0 R{} >>",
n(page.width),
n(page.height),
font_dict,
page_fonts,
xo,
content_id,
annots
)
.into_bytes(),
));
),
);
kids.push(page_id);
}
for (id, link) in annotations {
@@ -906,14 +1261,16 @@ impl PdfDoc {
format!("/Dest [{page_id} 0 R /XYZ {} {} null]", n(x), n(height - y))
}
};
objects.push((
dict_obj(
&mut out,
&mut offsets,
id,
format!("<< /Type /Annot /Subtype /Link /Rect [{} {} {} {}] /Border [0 0 0] {action} >>", n(x0), n(y0), n(x1), n(y1)).into_bytes(),
));
&format!("<< /Type /Annot /Subtype /Link /Rect [{} {} {} {}] /Border [0 0 0] {action} >>", n(x0), n(y0), n(x1), n(y1)),
);
}
objects.push((1, b"<< /Type /Catalog /Pages 2 0 R >>".to_vec()));
dict_obj(&mut out, &mut offsets, 1, "<< /Type /Catalog /Pages 2 0 R >>");
let kids_s: Vec<String> = kids.iter().map(|k| format!("{k} 0 R")).collect();
objects.push((2, format!("<< /Type /Pages /Kids [{}] /Count {} >>", kids_s.join(" "), kids.len()).into_bytes()));
dict_obj(&mut out, &mut offsets, 2, &format!("<< /Type /Pages /Kids [{}] /Count {} >>", kids_s.join(" "), kids.len()));
let creator = if self.info.creator.is_empty() { "GridCraft" } else { &self.info.creator };
let mut info = format!("<< /Producer {} /Creator {}", pdf_text_string("GridCraft PDF"), pdf_text_string(creator));
if !self.info.title.is_empty() {
@@ -923,28 +1280,15 @@ impl PdfDoc {
let _ = write!(info, " /Author {}", pdf_text_string(&self.info.author));
}
info.push_str(" >>");
objects.push((3, info.into_bytes()));
objects.sort_by_key(|(id, _)| *id);
dict_obj(&mut out, &mut offsets, 3, &info);
let mut out: Vec<u8> = Vec::new();
out.extend_from_slice(b"%PDF-1.7\n%\xE2\xE3\xCF\xD3\n");
let mut offsets = vec![0usize; next as usize];
for (id, body) in &objects {
if let Some(slot) = offsets.get_mut(*id as usize) {
*slot = out.len();
}
out.extend_from_slice(format!("{id} 0 obj\n").as_bytes());
out.extend_from_slice(body);
out.extend_from_slice(b"\nendobj\n");
}
let xref = out.len();
let mut x = format!("xref\n0 {}\n0000000000 65535 f \n", next);
let _ = write!(Utf8(&mut out), "xref\n0 {}\n0000000000 65535 f \n", next);
for off in offsets.iter().skip(1) {
let _ = writeln!(x, "{off:010} 00000 n ");
let _ = writeln!(Utf8(&mut out), "{off:010} 00000 n ");
}
let _ = write!(x, "trailer\n<< /Size {} /Root 1 0 R /Info 3 0 R >>\nstartxref\n{}\n%%EOF\n", next, xref);
out.extend_from_slice(x.as_bytes());
out
let _ = write!(Utf8(&mut out), "trailer\n<< /Size {} /Root 1 0 R /Info 3 0 R >>\nstartxref\n{}\n%%EOF\n", next, xref);
Ok(out)
}
}
+922 -15
View File
File diff suppressed because it is too large Load Diff
+351
View File
@@ -0,0 +1,351 @@
//! The content-stream emission of the writer before the cleanup (a verbatim copy of the old
//! per-operator formatting, which re-emitted the full style for every operator, had no `q` limit
//! and left `1 j` set after polylines), plus an interpreter that reduces a content stream to the
//! effective graphics state of every painting operator.
use super::super::*;
fn old_rgb_op(c: Rgb, stroke: bool) -> String {
let f = |v: u8| n(v as f32 / 255.0);
format!("{} {} {} {}", f(c[0]), f(c[1]), f(c[2]), if stroke { "RG" } else { "rg" })
}
/// The old content writer.
#[derive(Default)]
pub struct OldPage {
pub height: f32,
pub content: String,
depth: u32,
images: usize,
}
impl OldPage {
pub fn new(height: f32) -> OldPage {
OldPage { height, ..Default::default() }
}
fn y(&self, y: f32) -> f32 {
self.height - y
}
fn op(&mut self, s: &str) {
self.content.push_str(s);
self.content.push('\n');
}
pub fn save(&mut self) {
self.depth += 1;
self.content.push_str("q\n");
}
pub fn restore(&mut self) {
if self.depth > 0 {
self.depth -= 1;
self.content.push_str("Q\n");
}
}
pub fn clip_rect(&mut self, x: f32, y: f32, w: f32, h: f32) {
let s = format!("{} {} {} {} re W n", n(x), n(self.y(y + h)), n(w.max(0.0)), n(h.max(0.0)));
self.op(&s);
}
pub fn fill_rect(&mut self, x: f32, y: f32, w: f32, h: f32, color: Rgb) {
if w <= 0.0 || h <= 0.0 {
return;
}
let s = format!("{}\n{} {} {} {} re f", old_rgb_op(color, false), n(x), n(self.y(y + h)), n(w), n(h));
self.op(&s);
}
pub fn rect_stroke(&mut self, x: f32, y: f32, w: f32, h: f32, width: f32, color: Rgb) {
let s = format!("{}\n{} w [] 0 d\n{} {} {} {} re S", old_rgb_op(color, true), n(width), n(x), n(self.y(y + h)), n(w), n(h));
self.op(&s);
}
pub fn stroke_line_dashed(&mut self, start: Point, end: Point, width: f32, color: Rgb, dash: &[f32]) {
let (x0, y0, x1, y1) = (start.x, start.y, end.x, end.y);
let d: Vec<String> = dash.iter().take(8).map(|v| n(v.max(0.0))).collect();
let s = format!(
"{}\n{} w [{}] 0 d\n{} {} m {} {} l S",
old_rgb_op(color, true),
n(width),
d.join(" "),
n(x0),
n(self.y(y0)),
n(x1),
n(self.y(y1))
);
self.op(&s);
}
pub fn polyline(&mut self, pts: &[[f32; 2]], width: f32, color: Rgb, dash: &[f32]) {
if pts.len() < 2 {
return;
}
let d: Vec<String> = dash.iter().take(8).map(|v| n(v.max(0.0))).collect();
let mut s = format!("{}\n{} w [{}] 0 d 1 j\n", old_rgb_op(color, true), n(width), d.join(" "));
self.path(&mut s, pts, false);
s.push_str(" S");
self.op(&s);
}
fn path(&self, s: &mut String, pts: &[[f32; 2]], close: bool) {
for (i, p) in pts.iter().enumerate() {
let _ = write!(s, "{} {} {} ", n(p[0]), n(self.y(p[1])), if i == 0 { "m" } else { "l" });
}
if close {
s.push('h');
}
}
pub fn polygon(&mut self, pts: &[[f32; 2]], fill: Option<Rgb>, stroke: Option<(Rgb, f32)>) {
if pts.len() < 2 || (fill.is_none() && stroke.is_none()) {
return;
}
let mut s = String::new();
if let Some(f) = fill {
s.push_str(&old_rgb_op(f, false));
s.push('\n');
}
if let Some((c, w)) = stroke {
let _ = writeln!(s, "{}\n{} w [] 0 d 1 j", old_rgb_op(c, true), n(w));
}
self.path(&mut s, pts, true);
s.push_str(match (fill.is_some(), stroke.is_some()) {
(true, true) => " B",
(true, false) => " f",
_ => " S",
});
self.op(&s);
}
pub fn circle(&mut self, cx: f32, cy: f32, r: f32, fill: Option<Rgb>, stroke: Option<(Rgb, f32)>) {
if r <= 0.0 || (fill.is_none() && stroke.is_none()) {
return;
}
let y = self.y(cy);
let mut s = String::new();
if let Some(f) = fill {
s.push_str(&old_rgb_op(f, false));
s.push('\n');
}
if let Some((c, w)) = stroke {
let _ = writeln!(s, "{}\n{} w [] 0 d", old_rgb_op(c, true), n(w));
}
const K: f32 = 0.552_284_8;
let k = r * K;
let _ = write!(
s,
"{} {} m {} {} {} {} {} {} c {} {} {} {} {} {} c {} {} {} {} {} {} c {} {} {} {} {} {} c h",
n(cx + r),
n(y),
n(cx + r),
n(y + k),
n(cx + k),
n(y + r),
n(cx),
n(y + r),
n(cx - k),
n(y + r),
n(cx - r),
n(y + k),
n(cx - r),
n(y),
n(cx - r),
n(y - k),
n(cx - k),
n(y - r),
n(cx),
n(y - r),
n(cx + k),
n(y - r),
n(cx + r),
n(y - k),
n(cx + r),
n(y)
);
s.push_str(match (fill.is_some(), stroke.is_some()) {
(true, true) => " B",
(true, false) => " f",
_ => " S",
});
self.op(&s);
}
pub fn text_rotated(&mut self, origin: Point, size: f32, font: Font, color: Rgb, text: &str, angle: f32) {
let (x, y) = (origin.x, origin.y);
let fi = font.index();
let (sn, cs) = angle.sin_cos();
let s = format!(
"BT\n{}\n/F{} {} Tf\n{} {} {} {} {} {} Tm\n{} Tj\nET",
old_rgb_op(color, false),
fi + 1,
n(size),
n(cs),
n(-sn),
n(sn),
n(cs),
n(x),
n(self.y(y)),
pdf_string(text)
);
self.op(&s);
}
pub fn image(&mut self, x: f32, y: f32, w: f32, h: f32) {
self.images += 1;
let s = format!("q {} 0 0 {} {} {} cm /Im{} Do Q", n(w), n(h), n(x), n(self.y(y + h)), self.images);
self.op(&s);
}
}
/// The effective state at one painting operator. Fields that cannot influence the operator
/// (the stroke state of a fill, the fill of a stroke) are left empty.
#[derive(Clone, Debug, PartialEq, Default)]
pub struct Paint {
pub op: String,
/// Path construction / text operands since the previous painting operator.
pub geometry: String,
pub fill: String,
pub stroke: String,
pub width: String,
pub dash: String,
pub join: String,
/// Clip paths in effect (innermost last).
pub clip: Vec<String>,
}
#[derive(Default, Debug)]
pub struct Interp {
pub paints: Vec<Paint>,
pub max_depth: usize,
/// Number of `q` operators.
pub qs: usize,
/// Number of colour/width/dash/join operators.
pub style_ops: usize,
pub balanced: bool,
}
fn tokens(content: &str) -> Vec<String> {
let mut out = Vec::new();
let mut cur = String::new();
let mut chars = content.chars();
while let Some(c) = chars.next() {
match c {
'(' => {
if !cur.is_empty() {
out.push(std::mem::take(&mut cur));
}
let mut s = String::from("(");
while let Some(d) = chars.next() {
s.push(d);
if d == '\\' {
if let Some(e) = chars.next() {
s.push(e);
}
} else if d == ')' {
break;
}
}
out.push(s);
}
'[' | ']' => {
if !cur.is_empty() {
out.push(std::mem::take(&mut cur));
}
out.push(c.to_string());
}
c if c.is_whitespace() => {
if !cur.is_empty() {
out.push(std::mem::take(&mut cur));
}
}
c => cur.push(c),
}
}
if !cur.is_empty() {
out.push(cur);
}
out
}
#[derive(Clone)]
struct State {
fill: String,
stroke: String,
width: String,
dash: String,
join: String,
clip: Vec<String>,
}
/// Interprets a content stream: tracks q/Q, colours, width, dash, join and clips.
pub fn interpret(content: &str) -> Interp {
let mut st = State { fill: "0 0 0".into(), stroke: "0 0 0".into(), width: "1".into(), dash: String::new(), join: "0".into(), clip: Vec::new() };
let mut stack: Vec<State> = Vec::new();
let mut r = Interp { balanced: true, ..Default::default() };
let mut operands: Vec<String> = Vec::new();
let mut path: Vec<String> = Vec::new();
let mut pending_clip = false;
for t in tokens(content) {
let is_op = t.chars().next().is_some_and(|c| c.is_ascii_alphabetic() || c == '*') && !t.starts_with('/');
if !is_op {
operands.push(t);
continue;
}
let ops = std::mem::take(&mut operands);
match t.as_str() {
"q" => {
stack.push(st.clone());
r.qs += 1;
r.max_depth = r.max_depth.max(stack.len());
}
"Q" => match stack.pop() {
Some(s) => st = s,
None => r.balanced = false,
},
"rg" => {
st.fill = ops.join(" ");
r.style_ops += 1;
}
"RG" => {
st.stroke = ops.join(" ");
r.style_ops += 1;
}
"w" => {
st.width = ops.join(" ");
r.style_ops += 1;
}
"d" => {
// `[a b] 0` -> `a b`
st.dash = ops.iter().take_while(|o| *o != "]").skip(1).cloned().collect::<Vec<_>>().join(" ");
r.style_ops += 1;
}
"j" => {
st.join = ops.join(" ");
r.style_ops += 1;
}
"re" | "m" | "l" | "c" | "h" | "cm" | "Tf" | "Tm" => {
path.push(format!("{} {}", ops.join(" "), t));
}
"BT" | "ET" => {}
"W" => pending_clip = true,
"n" => {
if pending_clip {
st.clip.push(path.join(" "));
pending_clip = false;
}
path.clear();
}
"Tj" => {
path.push(format!("{} {}", ops.join(" "), t));
r.paints.push(Paint { op: t.clone(), geometry: path.join(" "), fill: st.fill.clone(), clip: st.clip.clone(), ..Default::default() });
path.clear();
}
"f" | "S" | "B" | "Do" => {
let mut p = Paint { op: t.clone(), geometry: path.join(" "), clip: st.clip.clone(), ..Default::default() };
if t == "f" || t == "B" {
p.fill = st.fill.clone();
}
if t == "S" || t == "B" {
p.stroke = st.stroke.clone();
p.width = st.width.clone();
p.dash = st.dash.clone();
p.join = st.join.clone();
}
r.paints.push(p);
path.clear();
}
_ => {}
}
}
r.balanced &= stack.is_empty();
r
}
+44 -1
View File
@@ -268,12 +268,38 @@ const TIOCLINUX: u64 = libc::TIOCLINUX as u64;
const IOC_WRITE: u64 = 0x4000_0000;
/// Changes a directory, though its number says it only reads, as the kernel's headers have it.
const FS_IOC_SET_ENCRYPTION_POLICY: u64 = 0x800C_6613;
#[allow(clippy::unnecessary_cast)]
const F_SETOWN: u64 = libc::F_SETOWN as u64;
#[allow(clippy::unnecessary_cast)]
const F_SETFL: u64 = libc::F_SETFL as u64;
#[allow(clippy::unnecessary_cast)]
const O_ASYNC: u64 = libc::O_ASYNC as u64;
/// The two `fcntl` commands of the same family that the kernel's headers name and `libc` doesn't;
/// the numbers are the same on every architecture (`asm-generic/fcntl.h`).
const F_SETOWN_EX: u64 = 15;
const F_SETSIG: u64 = 10;
/// Socket ioctls that do what those commands do: `FIOSETOWN` and `SIOCSPGRP` name the process to
/// notify, and `FIOASYNC` switches the notification on. Their requests carry no data-direction
/// bit, so the [`IOC_WRITE`] rule doesn't name them. `libc` doesn't name them; the numbers are
/// the kernel's, the same on every architecture (`asm-generic/sockios.h`).
const FIOSETOWN: u64 = 0x8901;
const SIOCSPGRP: u64 = 0x8902;
const FIOASYNC: u64 = 0x5452;
/// What the main filter refuses with `EPERM`: the calls above, and these when their arguments match.
/// - `clone` without `CLONE_THREAD`: a new process.
/// - A signal to any process but `me`, whose ID `exec` keeps. Landlock's signal scope needs a newer
/// kernel than the rest (ABI 6), and `kill(-1, 9)` must not get through on an older one.
/// - A change to the limits, priority or scheduling of any process but `me`.
/// - The `fcntl` commands that arrange asynchronous notification: naming the process to notify
/// (`F_SETOWN`, `F_SETOWN_EX`), choosing its signal (`F_SETSIG`), and `F_SETFL` when it sets
/// `O_ASYNC`, the switch without which nothing is sent. None is a signal call, and the only rule
/// that would cover them is Landlock's signal scope, which needs ABI 6, newer than a launch
/// requires; without these a confined program could have the kernel signal any process of its
/// user. `F_SETFL` itself still works, as `O_NONBLOCK` comes from it. A socket answers the same
/// arrangement through ioctls — `FIOSETOWN` and `SIOCSPGRP` to name the process, `FIOASYNC` to
/// switch the notification on — and those requests carry no data-direction bit, so they are
/// named alongside the others.
/// - `TIOCSTI` and `TIOCLINUX`, which type into a terminal the program inherited, as when
/// `gridcraft-cli sandbox-check` runs a program from a shell.
/// - An `ioctl` that hands the kernel data ([`IOC_WRITE`]), as those that change a file's flags or
@@ -307,10 +333,22 @@ fn main_rules(me: u32) -> Result<BTreeMap<i64, Vec<SeccompRule>>> {
vec![
rule(vec![word(1, SeccompCmpOp::Eq, TIOCSTI)?])?,
rule(vec![word(1, SeccompCmpOp::Eq, TIOCLINUX)?])?,
rule(vec![word(1, SeccompCmpOp::Eq, FIOSETOWN)?])?,
rule(vec![word(1, SeccompCmpOp::Eq, SIOCSPGRP)?])?,
rule(vec![word(1, SeccompCmpOp::Eq, FIOASYNC)?])?,
rule(vec![word(1, SeccompCmpOp::MaskedEq(IOC_WRITE), IOC_WRITE)?])?,
rule(vec![word(1, SeccompCmpOp::Eq, FS_IOC_SET_ENCRYPTION_POLICY)?])?,
],
);
rules.insert(
libc::SYS_fcntl,
vec![
rule(vec![word(1, SeccompCmpOp::Eq, F_SETOWN)?])?,
rule(vec![word(1, SeccompCmpOp::Eq, F_SETOWN_EX)?])?,
rule(vec![word(1, SeccompCmpOp::Eq, F_SETSIG)?])?,
rule(vec![word(1, SeccompCmpOp::Eq, F_SETFL)?, word(2, SeccompCmpOp::MaskedEq(O_ASYNC), O_ASYNC)?])?,
],
);
Ok(rules)
}
@@ -378,6 +416,9 @@ mod tests {
#[test]
fn the_calls_that_reach_another_process_have_rules() {
let rules = main_rules(4242).unwrap();
// `fcntl`'s notification commands: naming the owner to notify, both ways, choosing its
// signal, and the switch itself.
assert_eq!(rules.get(&libc::SYS_fcntl).map(Vec::len), Some(4), "the asynchronous-notification commands");
for nr in [
libc::SYS_kill,
libc::SYS_tkill,
@@ -415,7 +456,9 @@ mod tests {
] {
assert_eq!(rules.get(&nr).map(Vec::len), Some(0), "{nr} is refused outright");
}
assert_eq!(rules.get(&libc::SYS_ioctl).map(Vec::len), Some(4));
// The terminal rules, the socket notification ioctls (`FIOSETOWN`, `SIOCSPGRP`,
// `FIOASYNC`), the data-carrying rule and the encryption rule.
assert_eq!(rules.get(&libc::SYS_ioctl).map(Vec::len), Some(7));
}
#[test]
+25
View File
@@ -44,6 +44,8 @@ pub fn enforcement(canary: &Path, exe: &Path, target: u32) -> Vec<Check> {
Check { name: "TCP connection", outcome: denied(tcp_probe()) },
Check { name: "start a process", outcome: spawn_probe(exe) },
Check { name: "signal another process", outcome: signal_probe(target) },
#[cfg(target_os = "linux")]
Check { name: "switch a descriptor's notifications on", outcome: async_probe() },
]
}
@@ -128,6 +130,20 @@ fn write_probe(dir: &Path) -> Outcome {
denied(r.map(drop))
}
/// `O_ASYNC` on a descriptor of the program's own: the switch that has the kernel signal the
/// descriptor's owner when its state changes. The owner may be a process the program didn't name, a
/// standard stream the parent made, so on Linux the filter refuses setting it, the same way it
/// refuses the commands that name another owner. Naming one can't be asked here without `fcntl`'s
/// variable-argument form, which no safe API wraps; the rules refuse those commands, and the
/// confined-program test covers them.
#[cfg(target_os = "linux")]
fn async_probe() -> Outcome {
let r = nix::unistd::pipe().map_err(std::io::Error::from).and_then(|(_, write)| {
nix::fcntl::fcntl(write, nix::fcntl::FcntlArg::F_SETFL(nix::fcntl::OFlag::O_ASYNC)).map(drop).map_err(std::io::Error::from)
});
denied(r)
}
fn tcp_probe() -> std::io::Result<()> {
TcpStream::connect_timeout(&SocketAddr::from(TCP_TARGET), Duration::from_secs(2)).map(drop)
}
@@ -216,6 +232,15 @@ mod tests {
}
}
/// Unconfined, the notification probe reports what the system allows; confined, the launch
/// check needs it `Denied`. Either way it comes out of the same three calls, so this proves
/// the probe runs and classifies rather than failing outright.
#[cfg(target_os = "linux")]
#[test]
fn the_notification_probe_classifies() {
assert!(matches!(async_probe(), Outcome::Allowed(_)), "unconfined the switch can be set");
}
#[test]
fn the_checks_on_the_canary_change_nothing_where_they_are_allowed() {
let canary = crate::Canary::create().unwrap();
+13
View File
@@ -71,12 +71,15 @@ impl SheetApp {
capture_geometry: None,
capture_geometry_from_raw: false,
selected_object: None,
chart_cache: Default::default(),
clipboard_text_at_copy: None,
cut_text: None,
tab_run: None,
macros: macro_ui::MacroUi::default(),
started: now_ms(),
allow_close: false,
window_controls: false,
viewport_commands: Vec::new(),
bring_forward: false,
open_switch_windows: false,
ui_window: None,
@@ -114,6 +117,7 @@ impl SheetApp {
// Floating pictures' textures go with their workbook, even when no sheet is painted.
let open: Vec<u64> = self.session.documents().iter().map(|d| d.uid).collect();
floating_pictures::forget_closed(ctx, &open);
self.chart_cache.get_mut().unwrap_or_else(std::sync::PoisonError::into_inner).retain_docs(open.iter().copied());
self.apply_font_state(ctx);
if let Some(answer) = self.desktop_theme.take_change() {
self.desktop_dark = Some(answer);
@@ -250,6 +254,9 @@ impl SheetApp {
macro_ui::question_box(self, &ctx);
widgets::message_box(self, &ctx);
widgets::toast(self, &ctx);
// Last, so its resize cursors win over the widgets under the window edges.
ribbon::window_frame(self, &ctx);
self.flush_viewport_commands(&ctx);
// Requests are admitted in `logic`, for the root viewport, so only its pass issues them.
if ctx.viewport_id() == egui::ViewportId::ROOT {
control::issue_screenshots(self, &ctx);
@@ -302,6 +309,12 @@ impl SheetApp {
}
sel.active.a1()
}
pub(crate) fn flush_viewport_commands(&mut self, ctx: &egui::Context) {
for command in self.viewport_commands.drain(..) {
ctx.send_viewport_cmd(command);
}
}
}
#[cfg(test)]
+20
View File
@@ -163,6 +163,26 @@ impl SheetApp {
/// UI-only commands (dialogs, view toggles that aren't saved in the file).
fn run_ui_command(&mut self, id: &str, p: &Json) -> Option<Result<Json, String>> {
let r = match id {
"ui.window.minimize" => {
self.viewport_commands.push(egui::ViewportCommand::Minimized(true));
Ok(Json::Null)
}
"ui.window.maximize" => {
let on = p.get("on").and_then(Json::as_bool).unwrap_or(true);
self.viewport_commands.push(egui::ViewportCommand::Maximized(on));
Ok(Json::Null)
}
"ui.window.close" => {
self.viewport_commands.push(egui::ViewportCommand::Close);
Ok(Json::Null)
}
"ui.window.beginResize" => {
let Some(direction) = p.get("direction").and_then(Json::as_str).and_then(crate::parse_resize_direction) else {
return Some(Err("direction must be north, south, east, west, northeast, northwest, southeast, or southwest".into()));
};
self.viewport_commands.push(egui::ViewportCommand::BeginResize(direction));
Ok(Json::Null)
}
"app.checkForUpdates" | "help.checkForUpdates" => {
self.check_for_updates();
Ok(Json::Null)
+63 -1
View File
@@ -409,7 +409,11 @@ impl SheetApp {
/// Enter/Tab move inside a multi-cell selection, otherwise to the next cell.
pub fn move_after_enter(&mut self, dr: i64, dc: i64) {
let multi = self.session.active().is_some_and(|d| !d.selection.is_single_cell());
// A selection that is just one merged cell moves like one cell (Enter leaves it).
let multi = self
.session
.active()
.is_some_and(|d| !d.selection.is_single_cell() && !d.wb.active().is_some_and(|sh| d.selection.is_one_merged_cell(sh)));
// Any other move (arrows, clicks, another sheet) leaves the selection off the cell the
// last Tab landed on, which ends the run.
let here = self.session.active().map(|d| (d.uid, d.wb.active_sheet(), d.selection.active));
@@ -508,3 +512,61 @@ mod protected_cell_tests {
assert!(app.run("file.saveBytes", json!({"format": "xlsx"})).is_ok());
}
}
#[cfg(test)]
mod merged_cell_enter_tests {
use super::*;
use gridcraft_engine::Session;
#[test]
fn enter_and_tab_leave_a_selected_merged_cell_and_keep_the_tab_run() {
let mut session = Session::new();
session.new_workbook();
let mut app = SheetApp::new(session, Default::default());
app.run("selection.set", json!({"range": "B2:C3"})).unwrap();
app.run("home.mergeCells", json!({})).unwrap();
let sel = |app: &SheetApp| app.session.active().map(|d| d.selection.a1()).unwrap_or_default();
for ((dr, dc), want) in [((1, 0), "B4"), ((-1, 0), "B1"), ((0, 1), "D2"), ((0, -1), "A2")] {
app.run("selection.set", json!({"cell": "B2"})).unwrap();
assert_eq!(sel(&app), "B2:C3");
app.move_after_enter(dr, dc);
assert_eq!(sel(&app), want, "Enter/Tab ({dr},{dc}) from the merged cell B2:C3");
}
// A Tab run through the merged cell goes on past it: Enter then goes back to the column
// the run started in, on the next row.
app.tab_run = None; // the Shift+Tab above ended on A2 and started a run there
app.run("selection.set", json!({"cell": "A2"})).unwrap();
app.move_after_enter(0, 1);
assert_eq!(sel(&app), "B2:C3");
app.move_after_enter(0, 1);
assert_eq!(sel(&app), "D2");
app.move_after_enter(1, 0);
assert_eq!(sel(&app), "A3");
// Enter straight from the merged cell in a Tab run leaves it below its bottom edge and
// still goes back to the run's start column.
app.tab_run = None;
app.run("selection.set", json!({"cell": "A2"})).unwrap();
app.move_after_enter(0, 1);
assert_eq!(sel(&app), "B2:C3");
app.move_after_enter(1, 0);
assert_eq!(sel(&app), "A4");
}
#[test]
fn enter_from_a_merged_cell_in_a_tab_run_skips_a_hidden_row_and_keeps_the_column() {
let mut session = Session::new();
session.new_workbook();
let mut app = SheetApp::new(session, Default::default());
app.run("selection.set", json!({"range": "D2:E3"})).unwrap();
app.run("home.mergeCells", json!({})).unwrap();
app.run("selection.set", json!({"range": "A4"})).unwrap();
app.run("home.hideRows", json!({})).unwrap();
let sel = |app: &SheetApp| app.session.active().map(|d| d.selection.a1()).unwrap_or_default();
app.run("selection.set", json!({"cell": "C2"})).unwrap();
app.move_after_enter(0, 1);
assert_eq!(sel(&app), "D2:E3");
// Row 4 is hidden: Enter lands on C5, the run's column, not B5.
app.move_after_enter(1, 0);
assert_eq!(sel(&app), "C5");
}
}
+3
View File
@@ -65,6 +65,7 @@ impl SheetApp {
} else if self.fonts_rebind {
// A font-set change made last frame is active now.
self.fonts_rebind = false;
self.chart_cache.get_mut().unwrap_or_else(std::sync::PoisonError::into_inner).clear();
} else if !defer_font_change && !self.prepared_fonts && fonts::scan_done() {
self.rebind_workbook_fonts(ctx);
}
@@ -75,6 +76,8 @@ impl SheetApp {
fn start_font_setup(&mut self, ctx: &egui::Context) {
if self.fonts_set {
self.fonts_ready = true;
// The new set is active now: chart text was measured with the old one.
self.chart_cache.get_mut().unwrap_or_else(std::sync::PoisonError::into_inner).clear();
return;
}
if self.prepared_fonts {
+495
View File
@@ -0,0 +1,495 @@
//! Rendered charts kept between frames.
//!
//! Resolving a chart's series and laying it out is O(points). Doing it for every visible chart on
//! every frame kept the UI thread busy while scrolling a workbook with a few big charts (#1139,
//! part of #1098). The primitives a chart renders to depend on the workbook, the chart's place in
//! it, the zoom, the screen's pixels-per-point and the fonts text is measured with, so those are
//! what an entry is checked against.
//!
//! **Why "the workbook is unchanged" can be known without a change counter.** A document's
//! workbook is an `Arc<Workbook>` and its content is only reachable for writing through
//! `Arc::make_mut` (or by replacing the `Arc`), because the model has no interior mutability and
//! the code base forbids `unsafe`. While a `Weak` to the allocation exists, `make_mut` never
//! mutates it in place: it clones (other strong owners, e.g. an undo snapshot) or moves the value
//! to a new allocation (the `Weak` is cut loose). So if the document's current `Arc` still points
//! at the allocation the cache holds a `Weak` to, nothing was written since the entries were
//! built, however the write would have been made (command, undo, redo, recalculation, file load,
//! a direct edit from the UI, a future code path). The `Weak` also keeps the allocation from being
//! freed and reused, so a pointer match cannot be a stranger that landed on the same address.
use std::collections::HashMap;
use std::sync::{Arc, Weak};
use gridcraft_chart::Prim;
use gridcraft_engine::model::Workbook;
/// Most charts kept, over all documents.
const MAX_ENTRIES: usize = 64;
/// Most memory kept (estimated from the primitives), over all documents.
const MAX_BYTES: usize = 48 << 20;
struct Entry {
/// Zoom and pixels-per-point the primitives were measured for (`f32::to_bits`).
z: u32,
ppp: u32,
prims: Arc<[Prim]>,
bytes: usize,
/// Tick of the last use; the smallest is evicted first.
used: u64,
}
struct DocCharts {
/// The workbook the entries were built from.
wb: Weak<Workbook>,
/// (sheet index, index in the sheet's `charts`). The workbook is unchanged while the entries
/// live, so the pair names one chart.
charts: HashMap<(usize, usize), Entry>,
}
#[derive(Default)]
pub(crate) struct ChartCache {
docs: HashMap<u64, DocCharts>,
tick: u64,
bytes: usize,
/// Charts built (resolved and rendered) so far; for tests.
#[cfg(test)]
pub(crate) builds: usize,
}
fn prim_bytes(p: &Prim) -> usize {
std::mem::size_of::<Prim>()
+ match p {
Prim::Line { pts, .. } | Prim::Polygon { pts, .. } => pts.len().saturating_mul(std::mem::size_of::<[f32; 2]>()),
Prim::Text { text, .. } => text.len(),
_ => 0,
}
}
impl ChartCache {
/// The primitives of chart `index` of `sheet` in document `uid` whose workbook is `wb`, for
/// zoom and pixels per point `(z, ppp)`. `build` renders the chart when there is no valid entry.
pub(crate) fn get(
&mut self,
uid: u64,
wb: &Arc<Workbook>,
sheet: usize,
index: usize,
(z, ppp): (f32, f32),
build: impl FnOnce() -> Vec<Prim>,
) -> Arc<[Prim]> {
self.tick = self.tick.wrapping_add(1);
let tick = self.tick;
let doc = self.docs.entry(uid).or_insert_with(|| DocCharts { wb: Arc::downgrade(wb), charts: HashMap::new() });
if !std::ptr::eq(doc.wb.as_ptr(), Arc::as_ptr(wb)) {
// The document changed (or is another one with this uid): nothing built from the old
// workbook can be trusted.
let dropped: usize = doc.charts.values().map(|e| e.bytes).sum();
doc.charts.clear();
doc.wb = Arc::downgrade(wb);
self.bytes = self.bytes.saturating_sub(dropped);
}
let (zb, pb) = (z.to_bits(), ppp.to_bits());
if let Some(e) = doc.charts.get_mut(&(sheet, index))
&& e.z == zb
&& e.ppp == pb
{
e.used = tick;
return e.prims.clone();
}
#[cfg(test)]
{
self.builds += 1;
}
let prims: Arc<[Prim]> = build().into();
let bytes = prims.iter().map(prim_bytes).fold(0usize, usize::saturating_add);
let Some(doc) = self.docs.get_mut(&uid) else { return prims };
if let Some(old) = doc.charts.remove(&(sheet, index)) {
self.bytes = self.bytes.saturating_sub(old.bytes);
}
// A chart that alone would fill a quarter of the budget is not worth keeping.
if bytes <= MAX_BYTES / 4 {
doc.charts.insert((sheet, index), Entry { z: zb, ppp: pb, prims: prims.clone(), bytes, used: tick });
self.bytes = self.bytes.saturating_add(bytes);
self.evict();
}
prims
}
/// Drops least recently used entries until the caps hold.
fn evict(&mut self) {
loop {
let count: usize = self.docs.values().map(|d| d.charts.len()).sum();
if count <= MAX_ENTRIES && self.bytes <= MAX_BYTES {
return;
}
let oldest = self.docs.iter().flat_map(|(uid, d)| d.charts.iter().map(move |(k, e)| (e.used, *uid, *k))).min();
let Some((_, uid, key)) = oldest else { return };
if let Some(e) = self.docs.get_mut(&uid).and_then(|d| d.charts.remove(&key)) {
self.bytes = self.bytes.saturating_sub(e.bytes);
}
}
}
/// Forgets the documents that are not in `live` (closed workbooks).
pub(crate) fn retain_docs(&mut self, live: impl Iterator<Item = u64>) {
let live: Vec<u64> = live.collect();
let bytes = &mut self.bytes;
self.docs.retain(|uid, d| {
let keep = live.contains(uid);
if !keep {
*bytes = bytes.saturating_sub(d.charts.values().map(|e| e.bytes).sum());
}
keep
});
}
/// Forgets everything (the fonts text was measured with changed).
pub(crate) fn clear(&mut self) {
self.docs.clear();
self.bytes = 0;
}
#[cfg(test)]
pub(crate) fn len(&self) -> usize {
self.docs.values().map(|d| d.charts.len()).sum()
}
#[cfg(test)]
pub(crate) fn docs(&self) -> usize {
self.docs.len()
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::SheetApp;
use crate::chartview::tests::RENDERS;
use egui::{Event, vec2};
use gridcraft_chart::ApproxMeasure;
use gridcraft_engine::Session;
use serde_json::json;
type Harness = egui_kittest::Harness<'static, SheetApp>;
fn wb() -> Arc<Workbook> {
Arc::new(Workbook::new())
}
fn rect_prim(w: f32) -> Vec<Prim> {
vec![Prim::Rect { x: 0.0, y: 0.0, w, h: 1.0, fill: None, stroke: None, radius: 0.0 }]
}
fn line_prim(points: usize) -> Vec<Prim> {
vec![Prim::Line { pts: vec![[0.0, 0.0]; points], color: [0, 0, 0, 255], width: 1.0, dash: false }]
}
#[test]
fn a_workbook_written_after_caching_is_never_taken_for_the_cached_one() {
let mut cache = ChartCache::default();
let mut w = wb();
let build = || rect_prim(1.0);
cache.get(1, &w, 0, 0, (1.0, 1.0), build);
cache.get(1, &w, 0, 0, (1.0, 1.0), build);
assert_eq!(cache.builds, 1, "same workbook: a hit");
// Sole owner of the Arc: without the Weak this write would happen in place, at the same address.
Arc::make_mut(&mut w).active_sheet.set(0);
cache.get(1, &w, 0, 0, (1.0, 1.0), build);
assert_eq!(cache.builds, 2, "a write through make_mut moved the workbook to a new allocation");
// Shared with an undo snapshot: make_mut clones, the pointer changes as well.
let snapshot = w.clone();
Arc::make_mut(&mut w).active_sheet.set(0);
cache.get(1, &w, 0, 0, (1.0, 1.0), build);
assert_eq!(cache.builds, 3);
// Replacing the Arc with an equal workbook (a reload) is a change too.
w = Arc::new((*snapshot).clone());
cache.get(1, &w, 0, 0, (1.0, 1.0), build);
assert_eq!(cache.builds, 4);
// The old allocation is still held by the cache's Weak while its owner is gone, so a new
// workbook can't be mistaken for it by landing on the same address.
drop(snapshot);
cache.get(1, &w, 0, 0, (1.0, 1.0), build);
assert_eq!(cache.builds, 4);
}
#[test]
fn zoom_scale_chart_and_document_are_part_of_the_key() {
let mut cache = ChartCache::default();
let w = wb();
let build = || rect_prim(1.0);
cache.get(1, &w, 0, 0, (1.0, 1.0), build);
cache.get(1, &w, 0, 0, (1.25, 1.0), build);
cache.get(1, &w, 0, 0, (1.25, 2.0), build);
cache.get(1, &w, 0, 1, (1.25, 2.0), build);
cache.get(1, &w, 1, 0, (1.25, 2.0), build);
cache.get(2, &w, 0, 0, (1.25, 2.0), build);
assert_eq!(cache.builds, 6);
cache.get(1, &w, 0, 1, (1.25, 2.0), build);
cache.get(2, &w, 0, 0, (1.25, 2.0), build);
assert_eq!(cache.builds, 6, "each of those is cached");
}
#[test]
fn the_cache_is_capped_in_entries_and_bytes_and_drops_the_least_recently_used() {
let mut cache = ChartCache::default();
let w = wb();
for i in 0..MAX_ENTRIES + 10 {
cache.get(1, &w, 0, i, (1.0, 1.0), || rect_prim(1.0));
// Chart 0 is used all the time, so it survives.
cache.get(1, &w, 0, 0, (1.0, 1.0), || rect_prim(1.0));
}
assert_eq!(cache.len(), MAX_ENTRIES);
let before = cache.builds;
cache.get(1, &w, 0, 0, (1.0, 1.0), || rect_prim(1.0));
assert_eq!(cache.builds, before, "the busy chart is still there");
cache.get(1, &w, 0, 1, (1.0, 1.0), || rect_prim(1.0));
assert_eq!(cache.builds, before + 1, "the idle one was evicted");
// Bytes: each of these is ~4 MiB of points; only a handful fit.
let mut cache = ChartCache::default();
let points = (4 << 20) / std::mem::size_of::<[f32; 2]>();
for i in 0..40 {
cache.get(1, &w, 0, i, (1.0, 1.0), || line_prim(points));
}
assert!(cache.bytes <= MAX_BYTES && cache.len() < 40, "{} entries, {} bytes", cache.len(), cache.bytes);
// One that would fill a quarter of the budget is not kept, and is still returned.
let mut cache = ChartCache::default();
let big = cache.get(1, &w, 0, 0, (1.0, 1.0), || line_prim(MAX_BYTES / 4 / std::mem::size_of::<[f32; 2]>() + 1000));
assert!(!big.is_empty());
assert_eq!((cache.len(), cache.bytes), (0, 0));
}
#[test]
fn closed_documents_are_forgotten() {
let mut cache = ChartCache::default();
let w = wb();
cache.get(1, &w, 0, 0, (1.0, 1.0), || line_prim(10));
cache.get(2, &w, 0, 0, (1.0, 1.0), || line_prim(10));
cache.retain_docs([2].into_iter());
assert_eq!((cache.docs(), cache.len()), (1, 1));
cache.retain_docs(std::iter::empty());
assert_eq!((cache.docs(), cache.len(), cache.bytes), (0, 0, 0));
}
/// A workbook with charts of several kinds over numbers, dates and categories.
fn corpus() -> Session {
let mut s = Session::new();
s.new_workbook();
s.execute("range.setValues", json!({"range": "A1", "values": [["Date", "Sales", "Cost", "Share"]]})).unwrap();
for i in 0..40u32 {
let date = format!("2024-{:02}-{:02}", 1 + i / 28, 1 + i % 28);
s.execute("cell.set", json!({"cell": format!("A{}", i + 2), "input": date})).unwrap();
s.execute("cell.set", json!({"cell": format!("B{}", i + 2), "input": format!("{}", (i * 37) % 101)})).unwrap();
s.execute("cell.set", json!({"cell": format!("C{}", i + 2), "input": format!("=B{}/2+{}", i + 2, i)})).unwrap();
s.execute("cell.set", json!({"cell": format!("D{}", i + 2), "input": format!("{}", (i % 5) + 1)})).unwrap();
}
for (i, (kind, range)) in [
("column", "A1:C41"),
("line", "A1:C41"),
("scatter", "B1:C41"),
("pie", "A1:B6"),
("combo", "A1:C41"),
("area", "A1:B41"),
("bar", "A1:D41"),
("doughnut", "A1:B6"),
]
.into_iter()
.enumerate()
{
s.execute("insert.chart", json!({"range": range, "type": kind, "at": format!("H{}", 2 + i * 16), "width": 320, "height": 220})).unwrap();
}
s
}
#[test]
fn cached_output_equals_a_fresh_render_for_a_corpus_of_charts() {
let s = corpus();
let d = s.doc().unwrap();
let sh = d.wb.active().unwrap();
assert_eq!(sh.charts.len(), 8);
let mut cache = ChartCache::default();
for (i, ch) in sh.charts.iter().enumerate() {
let fresh = || {
let data = gridcraft_chart::resolve(&d.wb, d.wb.active_sheet.get(), ch);
gridcraft_chart::render(ch, &data, ch.anchor.width, ch.anchor.height, &ApproxMeasure)
};
let expect = fresh();
assert!(expect.len() > 3, "{:?} renders something", ch.kind);
let first = cache.get(d.uid, &d.wb, d.wb.active_sheet.get(), i, (1.0, 1.0), fresh);
let second = cache.get(d.uid, &d.wb, d.wb.active_sheet.get(), i, (1.0, 1.0), || panic!("must be a hit"));
assert_eq!(&*first, &expect[..], "{:?}: built entry", ch.kind);
assert_eq!(&*second, &expect[..], "{:?}: cached entry", ch.kind);
}
assert_eq!(cache.builds, 8);
}
// --- frames ---
fn harness(s: Session) -> Harness {
let mut h = egui_kittest::Harness::builder().with_size(vec2(1400.0, 900.0)).build_ui_state(
|ui, app: &mut SheetApp| {
let ctx = ui.ctx().clone();
app.logic(&ctx);
app.ui(ui);
},
SheetApp::new(s, Default::default()),
);
h.run_steps(8);
h
}
/// Two charts side by side, both in view, over A1:B12 (B3 is `=B2*2`).
fn two_charts() -> Session {
let mut s = Session::new();
s.new_workbook();
s.execute("range.setValues", json!({"range": "A1", "values": [["Day", "Sales"]]})).unwrap();
for i in 2..=12u32 {
let input = if i == 3 { "=B2*2".to_string() } else { format!("{}", i * 3 % 17) };
s.execute("cell.set", json!({"cell": format!("A{i}"), "input": format!("2024-03-{i:02}")})).unwrap();
s.execute("cell.set", json!({"cell": format!("B{i}"), "input": input})).unwrap();
}
s.execute("insert.chart", json!({"range": "A1:B12", "type": "column", "at": "D2", "width": 300, "height": 200})).unwrap();
s.execute("insert.chart", json!({"range": "A1:B12", "type": "scatter", "at": "L2", "width": 300, "height": 200})).unwrap();
s
}
fn builds() -> usize {
RENDERS.with(|c| c.get())
}
/// Runs `change`, lets a few frames pass and returns how many charts were rendered meanwhile.
fn rendered_after(h: &mut Harness, change: impl FnOnce(&mut Harness)) -> usize {
let before = builds();
change(h);
h.run_steps(4);
builds() - before
}
fn exec(h: &mut Harness, id: &str, params: serde_json::Value) {
h.state_mut().session.execute(id, params).unwrap();
}
#[test]
fn frames_without_a_change_render_each_chart_once() {
let mut h = harness(two_charts());
assert!(builds() >= 2, "the charts were drawn");
let n = rendered_after(&mut h, |h| h.run_steps(30));
assert_eq!(n, 0, "30 idle frames render nothing again");
// Pointer movement and wheel scrolling (view state only) change no workbook.
let scroll_before = h.state().view().scroll;
let n = rendered_after(&mut h, |h| {
for i in 0..10 {
h.input_mut().events.push(Event::PointerMoved(egui::pos2(300.0 + i as f32 * 7.0, 400.0)));
h.input_mut().events.push(Event::MouseWheel {
unit: egui::MouseWheelUnit::Point,
source: egui::MouseWheelSource::Unknown,
delta: vec2(0.0, -2.0),
phase: egui::TouchPhase::Move,
modifiers: egui::Modifiers::NONE,
});
h.run_steps(1);
}
});
assert_ne!(h.state().view().scroll, scroll_before, "the sheet did scroll");
assert_eq!(n, 0, "hover and scrolling reuse the rendered charts");
assert_eq!(h.state().chart_cache.lock().unwrap().len(), 2);
}
#[test]
fn every_kind_of_change_renders_the_charts_again_exactly_once() {
let mut h = harness(two_charts());
type Case<'a> = (&'a str, Box<dyn Fn(&mut Harness)>);
let cases: Vec<Case> = vec![
("cell edit", Box::new(|h| exec(h, "cell.set", json!({"cell": "B5", "input": "99"})))),
("recalc through a dependency", Box::new(|h| exec(h, "cell.set", json!({"cell": "B2", "input": "7"})))),
("calculate now", Box::new(|h| exec(h, "formulas.calculateNow", json!({})))),
("undo", Box::new(|h| exec(h, "edit.undo", json!({})))),
("redo", Box::new(|h| exec(h, "edit.redo", json!({})))),
("row hide", Box::new(|h| exec(h, "home.hideRows", json!({"rows": "6:7"})))),
("chart resize", Box::new(|h| exec(h, "chart.set", json!({"chart": 1, "width": 360, "height": 240})))),
("format change", Box::new(|h| exec(h, "home.bold", json!({"range": "A1:B1"})))),
("number format", Box::new(|h| exec(h, "home.numberFormat", json!({"range": "B2:B12", "format": "0.00"})))),
(
"document theme",
Box::new(|h| {
exec(
h,
"pageLayout.themeColors",
json!({"colors": ["#000000", "#FFFFFF", "#44546A", "#E7E6E6", "#C00000", "#ED7D31", "#A5A5A5", "#FFC000", "#5B9BD5", "#70AD47", "#0563C1", "#954F72"]}),
)
}),
),
];
for (what, change) in cases {
let n = rendered_after(&mut h, |h| change(h));
assert_eq!(n, 2, "{what}: both visible charts rendered once");
let n = rendered_after(&mut h, |h| h.run_steps(5));
assert_eq!(n, 0, "{what}: and then nothing more");
}
// Zoom is part of the key too.
let n = rendered_after(&mut h, |h| exec(h, "view.zoom", json!({"percent": 150})));
assert_eq!(n, 2, "zoom");
}
#[test]
fn switching_sheets_and_loading_files_render_the_new_charts_once() {
let mut h = harness(two_charts());
exec(&mut h, "home.insertSheet", json!({"before": 1}));
h.run_steps(4);
// The new sheet has no charts; coming back renders this sheet's two once.
let n = rendered_after(&mut h, |h| exec(h, "sheet.activate", json!({"sheet": 0})));
assert_eq!(n, 2, "sheet switch");
let n = rendered_after(&mut h, |h| h.run_steps(5));
assert_eq!(n, 0);
// File load: the same workbook opened from bytes is a new document with its own charts.
let bytes = h.state_mut().session.execute("file.saveBytes", json!({})).unwrap();
let b64 = bytes["base64"].as_str().unwrap().to_string();
let n = rendered_after(&mut h, |h| exec(h, "file.open", json!({"name": "again.xlsx", "base64": b64})));
assert_eq!(n, 2, "file load");
assert_eq!(h.state().session.documents().len(), 2);
let n = rendered_after(&mut h, |h| h.run_steps(5));
assert_eq!(n, 0);
assert_eq!(h.state().chart_cache.lock().unwrap().docs(), 2, "both open documents are cached");
// Back in the first document nothing is rendered: its entries were kept.
let n = rendered_after(&mut h, |h| h.state_mut().session.set_active(0));
assert_eq!(n, 0, "the first document's charts were still cached");
// Closing a document forgets its entries; the other one is shown (and rendered) now.
let n = rendered_after(&mut h, |h| exec(h, "file.close", json!({"force": true})));
assert_eq!(h.state().session.documents().len(), 1);
assert_eq!(h.state().chart_cache.lock().unwrap().docs(), 1);
assert_eq!(n, 0, "the remaining document's charts were cached too");
}
#[test]
fn a_chart_with_a_volatile_series_is_rendered_on_every_frame() {
let mut h = harness(two_charts());
{
let d = h.state_mut().session.active_mut().unwrap();
let sh = Arc::make_mut(&mut d.wb).sheet_mut(0).unwrap();
sh.charts[0].series[0].values = "=RAND()".into();
}
h.run_steps(4);
let n = rendered_after(&mut h, |h| h.run_steps(6));
assert!(n >= 6, "the volatile chart is resolved again on each frame, got {n}");
assert!(n < 12, "the other chart still comes from the cache, got {n}");
}
#[test]
fn closed_documents_are_forgotten_without_painting_a_chart() {
let mut h = harness(two_charts());
assert_eq!(h.state().chart_cache.lock().unwrap().docs(), 1);
exec(&mut h, "file.new", json!({}));
h.run_steps(4);
assert_eq!(h.state().session.documents().len(), 2);
// The charts' document is no longer shown, but still open.
assert_eq!(h.state().chart_cache.lock().unwrap().docs(), 1);
h.state_mut().session.set_active(0);
h.run_steps(2);
exec(&mut h, "file.close", json!({"force": true, "document": true}));
h.run_steps(2);
assert_eq!(h.state().session.documents().len(), 1);
assert_eq!(h.state().chart_cache.lock().unwrap().docs(), 0, "no chart is painted, yet the closed document's entries are gone");
}
}
+47 -7
View File
@@ -1,6 +1,8 @@
//! Floating objects on the sheet: charts (rendered by `gridcraft-chart` into primitives that
//! we paint with egui), pictures, shapes, equations, slicers and form controls (`form_controls.rs`).
use std::sync::Arc;
use egui::epaint::{PathShape, PathStroke};
use egui::{Align2, Color32, FontId, Painter, Pos2, Rect, Stroke, StrokeKind, pos2, vec2};
use gridcraft_chart::{HAlign, Prim, VAlign};
@@ -198,10 +200,11 @@ fn area_mesh(v: &[Pos2], col: Color32) -> egui::Mesh {
fn paint_shape_text(p: &Painter, wb: &Workbook, sp: &gridcraft_engine::model::Shape, r: Rect, z: f32) {
use gridcraft_engine::model::{ShapeTextAlign, ShapeTextAnchor};
let f = &sp.format;
let word_art = sp.kind == ShapeKind::WordArt;
let text_box = sp.kind == ShapeKind::TextBox;
let align = f.align.unwrap_or(if text_box { ShapeTextAlign::Left } else { ShapeTextAlign::Center });
let anchor = f.anchor.unwrap_or(if text_box { ShapeTextAnchor::Top } else { ShapeTextAnchor::Middle });
let default_color = if text_box { Color32::BLACK } else { Color32::WHITE };
let default_color = if text_box || word_art { Color32::BLACK } else { Color32::WHITE };
let color = f.text_color.and_then(|c| c.resolve(&wb.theme)).map(theme::color32).unwrap_or(default_color);
// Default 14 px (as before); a set size is in points.
let size = f.font_size.map_or(14.0, |pt| pt * 96.0 / 72.0).clamp(1.0, 2000.0) * z;
@@ -227,6 +230,11 @@ fn paint_shape_text(p: &Painter, wb: &Workbook, sp: &gridcraft_engine::model::Sh
};
let pos = pos2(x, y);
let clip = p.with_clip_rect(r.intersect(p.clip_rect()));
// WordArt's drop shadow: the text again, offset down and right, under everything else.
if let Some(sc) = f.text_shadow.and_then(|c| c.resolve(&wb.theme)).map(theme::color32) {
let d = (size * 0.05).clamp(1.0, 24.0);
clip.galley_with_override_text_color(pos + vec2(d, d), g.clone(), sc);
}
// egui has no stroked text: the outline is the text drawn in the outline colour, offset in
// eight directions by the outline width, under the filled text.
if let Some((c, w)) = f.text_outline
@@ -240,6 +248,31 @@ fn paint_shape_text(p: &Painter, wb: &Workbook, sp: &gridcraft_engine::model::Sh
clip.galley(pos, g, color);
}
/// Resolves and renders `ch` (chart `ci` of sheet `si`), at zoom `z`.
fn render_chart(p: &Painter, z: f32, wb: &Workbook, si: usize, ch: &gridcraft_engine::model::Chart) -> Vec<Prim> {
#[cfg(test)]
tests::RENDERS.with(|c| c.set(c.get() + 1));
let data = gridcraft_chart::resolve(wb, si, ch);
let m = EguiMeasure { painter: p, z };
gridcraft_chart::render(ch, &data, ch.anchor.width, ch.anchor.height, &m)
}
/// The primitives of chart `ci` of sheet `si`: from the frame cache when the workbook, zoom and
/// screen scale are those it was rendered for, else rendered now (see [`crate::chartcache`]).
fn chart_prims(app: &SheetApp, p: &Painter, z: f32, wb: &Arc<Workbook>, si: usize, ci: usize, ch: &gridcraft_engine::model::Chart) -> Arc<[Prim]> {
// Only the active document's own workbook is cached: anything else cannot be tied to a uid.
let Some(d) = app.session.active().filter(|d| Arc::ptr_eq(&d.wb, wb)) else {
return render_chart(p, z, wb, si, ch).into();
};
// A series that calls NOW or RAND, directly or through a defined name, must be evaluated
// again on every paint.
if gridcraft_chart::has_volatile_series(wb, si, ch) {
return render_chart(p, z, wb, si, ch).into();
}
let mut cache = app.chart_cache.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
cache.get(d.uid, wb, si, ci, (z, p.ctx().pixels_per_point()), || render_chart(p, z, wb, si, ch))
}
pub(crate) fn anchor_rect(geo: &Geo, sh: &Sheet, a: &Anchor) -> Rect {
let x = geo.x(sh, a.cell.col) + a.dx * geo.z;
let y = geo.y(sh, a.cell.row) + a.dy * geo.z;
@@ -259,7 +292,7 @@ pub(crate) fn objects_hidden(wb: &Workbook) -> bool {
wb.show_objects == gridcraft_engine::model::ShowObjects::None
}
pub(crate) fn paint_objects(app: &SheetApp, p: &Painter, geo: &Geo, wb: &Workbook, si: usize, sh: &Sheet) -> Vec<PaintedObject> {
pub(crate) fn paint_objects(app: &SheetApp, p: &Painter, geo: &Geo, wb: &Arc<Workbook>, si: usize, sh: &Sheet) -> Vec<PaintedObject> {
let mut painted = Vec::new();
if objects_hidden(wb) {
return painted;
@@ -295,6 +328,8 @@ pub(crate) fn paint_objects(app: &SheetApp, p: &Painter, geo: &Geo, wb: &Workboo
let line =
if sp.format.no_line { Color32::TRANSPARENT } else { sp.line.resolve(&wb.theme).map(theme::color32).unwrap_or(Color32::DARK_GRAY) };
match sp.kind {
// WordArt is only its text (no fill or outline of its own).
ShapeKind::WordArt => {}
ShapeKind::Rectangle | ShapeKind::TextBox => {
p.rect_filled(r, 0.0, fill);
p.rect_stroke(r, 0.0, Stroke::new(1.0, line), StrokeKind::Inside);
@@ -365,7 +400,7 @@ pub(crate) fn paint_objects(app: &SheetApp, p: &Painter, geo: &Geo, wb: &Workboo
}
done(start, r);
}
for ch in &sh.charts {
for (ci, ch) in sh.charts.iter().enumerate() {
let r = anchor_rect(geo, sh, &ch.anchor);
if !r.intersects(p.clip_rect()) {
continue;
@@ -374,9 +409,7 @@ pub(crate) fn paint_objects(app: &SheetApp, p: &Painter, geo: &Geo, wb: &Workboo
// Soft shadow + white card.
p.rect_filled(r.translate(vec2(0.0, 1.5)), 2.0, Color32::from_black_alpha(18));
p.rect_filled(r, 0.0, Tokens::get(p.ctx()).grid_bg);
let data = gridcraft_chart::resolve(wb, si, ch);
let m = EguiMeasure { painter: p, z: geo.z };
let prims = gridcraft_chart::render(ch, &data, ch.anchor.width, ch.anchor.height, &m);
let prims = chart_prims(app, p, geo.z, wb, si, ci, ch);
paint_prims(&p.with_clip_rect(r.intersect(p.clip_rect())), r.min, &prims, geo.z);
done(start, r);
}
@@ -583,11 +616,18 @@ pub(crate) fn ink_color(line: Color32, width_pt: f32) -> Color32 {
}
#[cfg(test)]
mod tests {
pub(crate) mod tests {
use std::cell::Cell;
use gridcraft_chart::Measure;
use super::*;
thread_local! {
/// Charts resolved and rendered on this thread (a test runs on its own thread).
pub(crate) static RENDERS: Cell<usize> = const { Cell::new(0) };
}
/// The production measure is not monotone for labels with a line break: egui lays the text out
/// line by line, so ending a prefix with `\n…` can be narrower than the shorter `iii…`. The
/// chart's label fitting must not assume otherwise (#1152).
+4
View File
@@ -275,6 +275,10 @@ pub fn handle(app: &mut SheetApp, ctx: &egui::Context, method: &str, p: &Json) -
("options.autoComplete", "Enable AutoComplete for cell values", "{on?: bool} (toggles without it) → {on}"),
("options.highlightActiveRow", "Highlight the active cell's row", "{on?: bool} (toggles without it) → {on}"),
("view.interfaceScale", "Interface Size", "{percent: 75–200 | \"auto\"} (100 = auto; clamped)"),
("ui.window.minimize", "Minimize Window", ""),
("ui.window.maximize", "Maximize Window", "{on: bool}"),
("ui.window.close", "Close Window", ""),
("ui.window.beginResize", "Resize Window", "{direction: north|south|east|west|northeast|northwest|southeast|southwest}"),
("ui.dialog", "Open Dialog", ""),
("ui.backstage", "File (Backstage view)", "{page?: home|new|open|info|saveAs|print|export|options|account|close}"),
(
+10
View File
@@ -112,15 +112,19 @@ pub enum Drag {
source: RangeRef,
before: Option<u32>,
},
/// `to`: the previewed size once the pointer moved. Only the dragged line changes while the
/// button is held; the release applies the size to every selected line (Excel).
ResizeCol {
col: u32,
start: f32,
orig: f32,
to: Option<f32>,
},
ResizeRow {
row: u32,
start: f32,
orig: f32,
to: Option<f32>,
},
/// Dragging the fill handle; `menu` when the right button drags it (the fill menu opens on release).
Fill {
@@ -244,6 +248,12 @@ pub struct GridState {
/// active sheet's rules, kept the same way: they are read from that sheet's cells alone.
pub(crate) cf: Option<(std::sync::Weak<Sheet>, CfCache)>,
pub drag: Drag,
/// A header-boundary resize drag: the workbook as it was when the drag began. The drag's own
/// undo entries are the ones from the first entry that snapshots it; earlier edits with the
/// same label are not the drag's to merge or cancel.
pub resize_base: Option<Arc<Workbook>>,
/// The redo stack when that drag began; Esc puts it back (the preview commands clear it).
pub resize_redo: Vec<gridcraft_engine::HistoryEntry>,
pub ensure_visible: bool,
/// With `ensure_visible`: scroll to the moving end of the selection instead of the active cell
/// (Shift/Ctrl+Shift+arrows keep the active cell on the anchor while the far corner moves).
+124 -27
View File
@@ -325,7 +325,8 @@ fn handle_column_header_press(app: &mut SheetApp, input: &InteractionInput<'_>,
let in_col_header = input.in_column_header;
if in_col_header {
if let Some((c, x)) = col_edge(geo, sh, p.x) {
app.grid.drag = Drag::ResizeCol { col: c, start: p.x, orig: sh.col_width(c).max(0.0) * 0.0 + (x - geo.x(sh, c)) / geo.z };
begin_resize(app);
app.grid.drag = Drag::ResizeCol { col: c, start: p.x, orig: sh.col_width(c).max(0.0) * 0.0 + (x - geo.x(sh, c)) / geo.z, to: None };
return;
}
let c = geo.col_at(sh, p.x);
@@ -362,7 +363,8 @@ fn handle_row_header_press(app: &mut SheetApp, input: &InteractionInput<'_>, p:
let in_row_header = input.in_row_header;
if in_row_header {
if let Some((r, y)) = row_edge(geo, sh, p.y) {
app.grid.drag = Drag::ResizeRow { row: r, start: p.y, orig: (y - geo.y(sh, r)) / geo.z };
begin_resize(app);
app.grid.drag = Drag::ResizeRow { row: r, start: p.y, orig: (y - geo.y(sh, r)) / geo.z, to: None };
return;
}
let r = geo.row_at(sh, p.y);
@@ -631,6 +633,31 @@ fn handle_context_menu_and_keyboard(app: &mut SheetApp, input: &InteractionInput
fn handle_dragging(app: &mut SheetApp, input: &InteractionInput<'_>) {
let (geo, sh, wb, sel, pos) = (input.geo, input.sheet, input.workbook, &input.selection, input.position);
let resp = input.response;
// Esc during a header-boundary drag cancels it: undo the preview, ignore the release. egui
// aborts the drag on Esc, so `resp.dragged()` is already false in this frame. The key is
// spent on the drag, so the grid's Esc doesn't also drop a pending copy or Format Painter.
if matches!(app.grid.drag, Drag::ResizeCol { .. } | Drag::ResizeRow { .. })
&& input.context.input_mut(|i| {
let pressed = i.key_pressed(egui::Key::Escape);
if pressed {
// With any modifiers, as before: the drag is cancelled and every Esc press spent.
i.events.retain(|e| !matches!(e, egui::Event::Key { key: egui::Key::Escape, pressed: true, .. }));
}
pressed
})
{
// Undo back to where the drag began, but never past it into an earlier edit.
let steps = resize_steps(app);
if steps > 0 {
let _ = app.session.run("edit.undo", json!({"steps": steps}));
}
// Undo pushes the cancelled preview onto the redo stack; put back what the drag began with.
if let Some(d) = app.session.active_mut() {
d.redo = std::mem::take(&mut app.grid.resize_redo);
}
app.grid.drag = Drag::None;
app.grid.resize_base = None;
}
if resp.dragged()
&& let Some(p) = pos
{
@@ -682,35 +709,22 @@ fn handle_dragging(app: &mut SheetApp, input: &InteractionInput<'_>) {
app.grid.drag = Drag::MoveCols { source, before };
scroll_by(app, vec2(auto.x, 0.0));
}
Drag::ResizeCol { col, start, orig } => {
let w = (orig + (p.x - start) / geo.z).max(0.0);
Drag::ResizeCol { col, start, orig, to } => {
let w = nan_safe_size(orig + (p.x - start) / geo.z);
app.toast =
Some((format!("Width: {:.2} ({} pixels)", gridcraft_engine::cmd::format::points_to_chars(w as f64), w.round()), crate::now_ms()));
// Inside a selection of whole columns, every selected column takes the new width
// (Ctrl-selected areas included); otherwise only the dragged one.
let cols = if sel.ranges.iter().any(|r| r.is_full_cols() && col >= r.start.col && col <= r.end.col) {
sel.ranges.iter().filter(|r| r.is_full_cols()).map(|r| r.a1()).collect::<Vec<_>>().join(",")
} else {
RangeRef::cols(col, col).a1()
};
let _ = app.session.run("home.columnWidth", json!({"cols": cols, "width": w.round()}));
coalesce_last_undo(app);
// Preview on the dragged column only; the release applies it to the selection. A
// rejected size leaves the last shown preview (and `to`) as it was.
let ok = app.session.run("home.columnWidth", json!({"cols": RangeRef::cols(col, col).a1(), "width": w.round()})).is_ok();
coalesce_resize_undo(app);
app.grid.drag = Drag::ResizeCol { col, start, orig, to: if ok { Some(w) } else { to } };
}
Drag::ResizeRow { row, start, orig } => {
let h = (orig + (p.y - start) / geo.z).max(0.0);
Drag::ResizeRow { row, start, orig, to } => {
let h = nan_safe_size(orig + (p.y - start) / geo.z);
app.toast = Some((format!("Height: {:.2} ({} pixels)", h * 0.75, h.round()), crate::now_ms()));
let rows = if sel.ranges.iter().any(|r| r.is_full_rows() && row >= r.start.row && row <= r.end.row) {
sel.ranges
.iter()
.filter(|r| r.is_full_rows())
.map(|r| format!("{}:{}", r.start.row + 1, r.end.row + 1))
.collect::<Vec<_>>()
.join(",")
} else {
format!("{}:{}", row + 1, row + 1)
};
let _ = app.session.run("home.rowHeight", json!({"rows": rows, "height": h.round()}));
coalesce_last_undo(app);
let ok = app.session.run("home.rowHeight", json!({"rows": format!("{}:{}", row + 1, row + 1), "height": h.round()})).is_ok();
coalesce_resize_undo(app);
app.grid.drag = Drag::ResizeRow { row, start, orig, to: if ok { Some(h) } else { to } };
}
Drag::Freeze { cols, .. } => {
app.grid.drag = Drag::Freeze { cols, to: Some(freeze_boundary(geo, sh, p, cols)) };
@@ -794,6 +808,21 @@ fn handle_release(app: &mut SheetApp, input: &InteractionInput<'_>) {
crate::macro_ui::call(app, "GridCraft", "range.move", json!({"range": src.a1(), "to": to.a1()}));
}
}
Drag::ResizeCol { col, to: Some(w), .. } => {
// The preview already sized the dragged column; the other selected ones follow now.
let cols = resize_targets(&sel.ranges, col, true);
if cols != RangeRef::cols(col, col).a1() {
let _ = app.session.run("home.columnWidth", json!({"cols": cols, "width": w.round()}));
coalesce_resize_undo(app);
}
}
Drag::ResizeRow { row, to: Some(h), .. } => {
let rows = resize_targets(&sel.ranges, row, false);
if rows != format!("{}:{}", row + 1, row + 1) {
let _ = app.session.run("home.rowHeight", json!({"rows": rows, "height": h.round()}));
coalesce_resize_undo(app);
}
}
Drag::MoveCols { source, before: Some(before) } => {
if let Err(e) = app.run("sheet.moveColumns", json!({"cols": source.a1(), "before": before})) {
app.message = Some(("GridCraft".into(), crate::clean_error(&e)));
@@ -936,6 +965,29 @@ fn select_to_pointer(app: &mut SheetApp, geo: &Geo, sh: &Sheet, wb: &Workbook, p
}
}
/// A drag size in points: NaN or negative becomes 0 (a hidden line).
fn nan_safe_size(v: f32) -> f32 {
if v.is_nan() { 0.0 } else { v.max(0.0) }
}
/// The lines a header-boundary drag resizes on release: every selected whole line when the
/// dragged one is part of the selection (Ctrl-selected areas included), otherwise only it.
fn resize_targets(ranges: &[RangeRef], index: u32, cols: bool) -> String {
let whole = |r: &RangeRef| if cols { r.is_full_cols() } else { r.is_full_rows() };
let span = |r: &RangeRef| if cols { (r.start.col, r.end.col) } else { (r.start.row, r.end.row) };
let name = |r: &RangeRef| {
let (a, b) = span(r);
if cols { RangeRef::cols(a, b).a1() } else { format!("{}:{}", a + 1, b + 1) }
};
if ranges.iter().any(|r| whole(r) && (span(r).0..=span(r).1).contains(&index)) {
ranges.iter().filter(|r| whole(r)).map(name).collect::<Vec<_>>().join(",")
} else if cols {
RangeRef::cols(index, index).a1()
} else {
format!("{}:{}", index + 1, index + 1)
}
}
fn coalesce_last_undo(app: &mut SheetApp) {
// Merge consecutive drag steps into one undo entry.
if let Some(d) = app.session.active_mut()
@@ -948,6 +1000,29 @@ fn coalesce_last_undo(app: &mut SheetApp) {
}
}
/// Starts a header resize drag: remembers the workbook and the redo stack it began with.
fn begin_resize(app: &mut SheetApp) {
app.grid.resize_base = app.session.active().map(|d| d.wb.clone());
app.grid.resize_redo = app.session.active().map(|d| d.redo.clone()).unwrap_or_default();
}
/// Undo entries a header resize drag has pushed so far: those from the first one that snapshots
/// the workbook the drag started from (`resize_base`). A failed command pushes none.
fn resize_steps(app: &SheetApp) -> usize {
let (Some(base), Some(d)) = (&app.grid.resize_base, app.session.active()) else { return 0 };
d.undo.iter().position(|e| std::sync::Arc::ptr_eq(&e.wb, base)).map_or(0, |first| d.undo.len() - first)
}
/// Like [`coalesce_last_undo`] for a resize drag: merges only the drag's own entries, so an
/// earlier edit with the same label ("Column width") stays a separate undo step.
fn coalesce_resize_undo(app: &mut SheetApp) {
if resize_steps(app) >= 2
&& let Some(d) = app.session.active_mut()
{
d.undo.pop();
}
}
fn scroll_by(app: &mut SheetApp, d: egui::Vec2) {
if d != egui::Vec2::ZERO
&& let Some(v) = app.view_mut()
@@ -1161,6 +1236,28 @@ pub fn point_move(app: &mut SheetApp, ed: &mut EditState, dr: i64, dc: i64, exte
app.grid.ensure_visible = true;
}
#[cfg(test)]
mod resize_tests {
use super::*;
#[test]
fn resize_targets_follow_the_selection_only_when_the_dragged_line_is_in_it() {
let sel = [RangeRef::cols(0, 0), RangeRef::cols(2, 3)];
assert_eq!(resize_targets(&sel, 3, true), "A:A,C:D");
assert_eq!(resize_targets(&sel, 1, true), "B:B");
assert_eq!(resize_targets(&[RangeRef::rows(1, 2)], 2, false), "2:3");
assert_eq!(resize_targets(&[RangeRef::rows(1, 2)], 5, false), "6:6");
assert_eq!(resize_targets(&[], 0, true), "A:A");
}
#[test]
fn drag_sizes_are_nan_safe() {
assert_eq!(nan_safe_size(f32::NAN), 0.0);
assert_eq!(nan_safe_size(-4.0), 0.0);
assert_eq!(nan_safe_size(12.5), 12.5);
}
}
#[cfg(test)]
mod tests {
use super::*;
+3
View File
@@ -278,6 +278,9 @@ pub(super) fn translate(text: &str) -> Option<&'static str> {
"Save" => "Uložit",
"Save As" => "Uložit jako",
"Export" => "Exportovat",
"Minimize" => "Minimalizovat",
"Maximize" => "Maximalizovat",
"Restore Down" => "Obnovit dolů",
"Close" => "Zavřít",
"Options" => "Možnosti",
"Account" => "Účet",
+3
View File
@@ -294,6 +294,9 @@ pub(super) fn translate(text: &str) -> Option<&'static str> {
"Save" => "Speichern",
"Save As" => "Speichern unter",
"Export" => "Exportieren",
"Minimize" => "Minimieren",
"Maximize" => "Maximieren",
"Restore Down" => "Nach unten wiederherstellen",
"Close" => "Schließen",
"Options" => "Optionen",
"Account" => "Konto",
+3
View File
@@ -271,6 +271,9 @@ pub(super) fn translate(text: &str) -> Option<&'static str> {
"Save" => "Αποθήκευση",
"Save As" => "Αποθήκευση ως",
"Export" => "Εξαγωγή",
"Minimize" => "Ελαχιστοποίηση",
"Maximize" => "Μεγιστοποίηση",
"Restore Down" => "Επαναφορά",
"Close" => "Κλείσιμο",
"Options" => "Επιλογές",
"Blank workbook" => "Κενό βιβλίο εργασίας",
+3
View File
@@ -283,6 +283,9 @@ pub(super) fn translate(text: &str) -> Option<&'static str> {
"Save" => "Guardar",
"Save As" => "Guardar como",
"Export" => "Exportar",
"Minimize" => "Minimizar",
"Maximize" => "Maximizar",
"Restore Down" => "Restaurar",
"Close" => "Cerrar",
"Options" => "Opciones",
"Account" => "Cuenta",
+3
View File
@@ -370,6 +370,9 @@ pub(super) fn translate(text: &str) -> Option<&'static str> {
"Save" => "Enregistrer",
"Save As" => "Enregistrer sous",
"Export" => "Exporter",
"Minimize" => "Réduire",
"Maximize" => "Agrandir",
"Restore Down" => "Restaurer",
"Close" => "Fermer",
"Options" => "Options",
"Account" => "Compte",
+3
View File
@@ -365,6 +365,9 @@ pub(super) fn translate(text: &str) -> Option<&'static str> {
"Save" => "Salva",
"Save As" => "Salva con nome",
"Export" => "Esporta",
"Minimize" => "Riduci a icona",
"Maximize" => "Ingrandisci",
"Restore Down" => "Ripristina",
"Close" => "Chiudi",
"Options" => "Opzioni",
"Blank workbook" => "Cartella di lavoro vuota",
+3
View File
@@ -364,6 +364,9 @@ pub(super) const CORE: &[(&str, &str)] = &[
("Save", "上書き保存"),
("Save As", "名前を付けて保存"),
("Export", "エクスポート"),
("Minimize", "最小化"),
("Maximize", "最大化"),
("Restore Down", "元のサイズに戻す"),
("Close", "閉じる"),
("Options", "オプション"),
("Blank workbook", "空白のブック"),
+3
View File
@@ -370,6 +370,9 @@ pub(super) fn translate(text: &str) -> Option<&'static str> {
"Save" => "저장",
"Save As" => "다른 이름으로 저장",
"Export" => "내보내기",
"Minimize" => "최소화",
"Maximize" => "최대화",
"Restore Down" => "이전 크기로 복원",
"Close" => "닫기",
"Options" => "옵션",
"Account" => "계정",
+3
View File
@@ -364,6 +364,9 @@ pub(super) fn translate(text: &str) -> Option<&'static str> {
"Save" => "Opslaan",
"Save As" => "Opslaan als",
"Export" => "Exporteren",
"Minimize" => "Minimaliseren",
"Maximize" => "Maximaliseren",
"Restore Down" => "Vorig formaat",
"Close" => "Sluiten",
"Options" => "Opties",
"Blank workbook" => "Lege werkmap",
+3
View File
@@ -357,6 +357,9 @@ pub(super) fn translate(text: &str) -> Option<&'static str> {
"Save" => "Zapisz",
"Save As" => "Zapisz jako",
"Export" => "Eksportuj",
"Minimize" => "Minimalizuj",
"Maximize" => "Maksymalizuj",
"Restore Down" => "Przywróć w dół",
"Close" => "Zamknij",
"Options" => "Opcje",
"Blank workbook" => "Pusty skoroszyt",
+3
View File
@@ -367,6 +367,9 @@ pub(super) fn translate(text: &str) -> Option<&'static str> {
"Save" => "Salvar",
"Save As" => "Salvar como",
"Export" => "Exportar",
"Minimize" => "Minimizar",
"Maximize" => "Maximizar",
"Restore Down" => "Restaurar",
"Close" => "Fechar",
"Options" => "Opções",
"Account" => "Conta",
+3
View File
@@ -364,6 +364,9 @@ pub(super) fn translate(text: &str) -> Option<&'static str> {
"Save" => "Salvare",
"Save As" => "Salvare ca",
"Export" => "Exportare",
"Minimize" => "Minimizare",
"Maximize" => "Maximizare",
"Restore Down" => "Restaurare",
"Close" => "Închidere",
"Options" => "Opțiuni",
"Blank workbook" => "Registru gol",
+3
View File
@@ -372,6 +372,9 @@ pub(super) fn translate(text: &str) -> Option<&'static str> {
"Save" => "Сохранить",
"Save As" => "Сохранить как",
"Export" => "Экспорт",
"Minimize" => "Свернуть",
"Maximize" => "Развернуть",
"Restore Down" => "Восстановить",
"Close" => "Закрыть",
"Options" => "Параметры",
"Account" => "Учетная запись",
+3
View File
@@ -363,6 +363,9 @@ pub(super) fn translate(text: &str) -> Option<&'static str> {
"Save" => "Sačuvaj",
"Save As" => "Sačuvaj kao",
"Export" => "Izvezi",
"Minimize" => "Minimizuj",
"Maximize" => "Maksimizuj",
"Restore Down" => "Vrati",
"Close" => "Zatvori",
"Options" => "Opcije",
"Account" => "Nalog",
+3
View File
@@ -277,6 +277,9 @@ pub(super) fn translate(text: &str) -> Option<&'static str> {
"Save" => "Kaydet",
"Save As" => "Farklı Kaydet",
"Export" => "Dışarı Aktar",
"Minimize" => "Simge durumuna küçült",
"Maximize" => "Ekranı kapla",
"Restore Down" => "Önceki boyuta getir",
"Close" => "Kapat",
"Options" => "Seçenekler",
"Blank workbook" => "Boş çalışma kitabı",
+3
View File
@@ -361,6 +361,9 @@ pub(super) fn translate(text: &str) -> Option<&'static str> {
"Save" => "Зберегти",
"Save As" => "Зберегти як",
"Export" => "Експорт",
"Minimize" => "Згорнути",
"Maximize" => "Розгорнути",
"Restore Down" => "Відновити",
"Close" => "Закрити",
"Options" => "Параметри",
"Blank workbook" => "Порожня книга",
+3
View File
@@ -367,6 +367,9 @@ pub(super) fn translate(text: &str) -> Option<&'static str> {
"Save" => "Lưu",
"Save As" => "Lưu thành",
"Export" => "Xuất",
"Minimize" => "Thu nhỏ",
"Maximize" => "Phóng to",
"Restore Down" => "Khôi phục",
"Close" => "Đóng",
"Options" => "Tùy chọn",
"Blank workbook" => "Sổ làm việc trống",
+3
View File
@@ -368,6 +368,9 @@ pub(super) fn translate(text: &str) -> Option<&'static str> {
"Save" => "保存",
"Save As" => "另存为",
"Export" => "导出",
"Minimize" => "最小化",
"Maximize" => "最大化",
"Restore Down" => "向下还原",
"Close" => "关闭",
"Options" => "选项",
"Account" => "账户",
+5
View File
@@ -103,6 +103,7 @@ pub enum Icon {
Comment,
Note,
TextBox,
WordArt,
Symbol,
/// An equation: a radical sign over an italic x.
Equation,
@@ -631,6 +632,10 @@ fn paint_with(p: &Painter, rect: Rect, icon: Icon, c: Color32, pal: &Palette) {
g.rect(2.0, 3.0, 12.0, 10.0, None, Some(c));
g.text(8.0, 8.0, "A", 8.0, c, (false, false));
}
Icon::WordArt => {
g.text(9.0, 9.0, "A", 13.0, Color32::from_rgb(0x8E, 0x4F, 0xB5), (true, false));
g.text(8.0, 8.0, "A", 13.0, c, (true, false));
}
Icon::Symbol => g.text(8.0, 8.0, "Ω", 12.0, c, (false, false)),
Icon::Equation => {
g.line(&[(1.5, 9.0), (3.5, 8.0), (5.5, 13.5), (8.5, 2.5), (14.5, 2.5)], c, 1.2);
@@ -194,7 +194,7 @@ pub const SEQUENCES: &[(&str, Entry)] = &[
("NU", Entry::Finish(Action::Command("insert.symbol"))), // Excel: Symbols; containment(Symbol)
("NZS", Entry::Finish(Action::Command("insert.symbol"))), // Excel: Excel: Symbol (modern)
("NV", Entry::Finish(Action::Command("insert.pivotTable"))), // Excel: PivotTable
("NW", Entry::Finish(Action::Pending("insert.wordArt"))), // pending; Excel: WordArt; WordArt; reserved until the command lands
("NW", Entry::Finish(Action::Command("insert.wordArt"))), // Excel: WordArt
("NX", Entry::Finish(Action::Command("insert.textBox"))), // Excel: Text Box
("NZK", Entry::Continue), // Excel: Sparklines Menu; group level:
("NZKSL", Entry::Finish(Action::Dialog("sparkline"))), // Excel: Line Sparkline
+1 -3
View File
@@ -1336,9 +1336,7 @@
"seq": "NW",
"kind": "command",
"target": "insert.wordArt",
"pending": true,
"excel": "WordArt",
"note": "WordArt; reserved until the command lands"
"excel": "WordArt"
},
{
"seq": "NX",
+51
View File
@@ -18,6 +18,7 @@ pub const UPDATE_APP: craft_update::app::App = craft_update::app::App {
pub mod backstage;
mod border_preview;
mod cell_pictures;
mod chartcache;
pub mod chartview;
pub mod code_editor;
pub mod control;
@@ -59,6 +60,7 @@ pub mod theme;
mod updates_ui;
pub mod widgets;
mod window_ui;
pub mod wordart;
pub use window_ui::WindowUi;
@@ -81,6 +83,20 @@ pub use services::{Chrome, Inbox, Services};
pub use state::{NoticeKind, OpenWindow, SaveAnswer, SheetView};
pub mod desktop_theme;
fn parse_resize_direction(value: &str) -> Option<egui::ResizeDirection> {
match value {
"north" => Some(egui::ResizeDirection::North),
"south" => Some(egui::ResizeDirection::South),
"east" => Some(egui::ResizeDirection::East),
"west" => Some(egui::ResizeDirection::West),
"northeast" => Some(egui::ResizeDirection::NorthEast),
"northwest" => Some(egui::ResizeDirection::NorthWest),
"southeast" => Some(egui::ResizeDirection::SouthEast),
"southwest" => Some(egui::ResizeDirection::SouthWest),
_ => None,
}
}
/// Persisted UI preferences.
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
@@ -287,6 +303,8 @@ pub struct SheetApp {
pub(crate) capture_geometry_from_raw: bool,
/// The floating object selected on the sheet (chart, picture, shape, equation or slicer).
pub selected_object: Option<gridcraft_engine::model::ObjRef>,
/// Rendered charts kept between frames ([`chartcache`]).
pub(crate) chart_cache: std::sync::Mutex<chartcache::ChartCache>,
/// The system clipboard's text when GridCraft last copied without publishing to it (a
/// control-channel or MCP `edit.copy`/`edit.cut`). While the system clipboard still holds this
/// text, GridCraft's copy is the newer one and Paste uses it.
@@ -304,6 +322,10 @@ pub struct SheetApp {
/// Every unsaved workbook has been answered for quitting (or `app.quit` asked): the next
/// window close goes through.
pub allow_close: bool,
/// Linux/BSD: the window has no system frame; the title bar draws minimize, maximize and
/// close, and the window resizes from its edges (`ribbon::window_frame`).
pub window_controls: bool,
viewport_commands: Vec<egui::ViewportCommand>,
/// A quit question is waiting in the active window: [`doc_windows`] brings its native window
/// to the front, also when the app is hidden or the window minimized (a Dock quit).
pub bring_forward: bool,
@@ -337,3 +359,32 @@ pub fn clean_error(e: &str) -> String {
pub fn cell(r: u32, c: u32) -> CellRef {
CellRef::new(r, c)
}
#[cfg(test)]
mod viewport_command_tests {
use super::parse_resize_direction;
#[test]
fn resize_direction_parser_accepts_all_edges_and_rejects_unknown_values() {
for name in ["north", "south", "east", "west", "northeast", "northwest", "southeast", "southwest"] {
assert!(parse_resize_direction(name).is_some(), "{name}");
}
assert!(parse_resize_direction("middle").is_none());
}
#[test]
fn window_commands_queue_viewport_commands_without_a_workbook() {
use egui::ViewportCommand;
let mut a = crate::SheetApp::new(gridcraft_engine::Session::new(), crate::Services::default());
for (id, params, expected) in [
("ui.window.minimize", serde_json::json!({}), ViewportCommand::Minimized(true)),
("ui.window.maximize", serde_json::json!({"on": true}), ViewportCommand::Maximized(true)),
("ui.window.close", serde_json::json!({}), ViewportCommand::Close),
("ui.window.beginResize", serde_json::json!({"direction": "east"}), ViewportCommand::BeginResize(egui::ResizeDirection::East)),
] {
assert!(a.run(id, params).is_ok(), "{id} should route without a workbook");
assert!(a.viewport_commands.contains(&expected), "{id} queues {expected:?}");
}
assert!(a.run("ui.window.beginResize", serde_json::json!({"direction": "diagonal"})).is_err());
}
}
+3 -1
View File
@@ -128,7 +128,9 @@ pub fn open_action(sh: &Sheet, o: ObjRef) -> OpenAction {
match o.kind {
ObjKind::Chart => OpenAction::FormatChart(o.id),
ObjKind::Equation => OpenAction::EditEquation(o.id),
ObjKind::Shape if sh.shapes.iter().any(|s| s.id == o.id && s.kind == ShapeKind::TextBox) => OpenAction::EditText(o.id),
ObjKind::Shape if sh.shapes.iter().any(|s| s.id == o.id && matches!(s.kind, ShapeKind::TextBox | ShapeKind::WordArt)) => {
OpenAction::EditText(o.id)
}
ObjKind::Control => OpenAction::EditControl(o.id),
ObjKind::Shape | ObjKind::Image | ObjKind::Slicer => OpenAction::Select,
}
+1 -1
View File
@@ -38,7 +38,7 @@ use insert::{draw, insert};
use page_layout::page_layout;
use review::review;
pub use shortcuts::shortcut;
pub use title_bar::{MAC_CONTENT_LEFT, MAC_TITLE_BAR, TITLE_LEFT_PAD, title_bar};
pub use title_bar::{MAC_CONTENT_LEFT, MAC_TITLE_BAR, TITLE_LEFT_PAD, title_bar, window_frame};
use title_bar::{TITLE_BAR_H, TITLE_CONTROL_H};
use view::view;
+6
View File
@@ -208,6 +208,12 @@ pub(super) fn insert(app: &mut SheetApp, ui: &mut Ui) {
if __k.clicked() {
act(app, "insert.textBox", json!({}));
}
// Two lines like its neighbours, so the Insert tab stays as wide as before; the translated label is split, the catalog key is one line.
let label = app.ui.language.tr("Decorative Text").replacen(' ', "\n", 1);
let wa = big_button(ui, Icon::WordArt, &label, "Decorative Text", true);
anchor_keytip(app, ui, &wa, &["insert.wordArt"]);
// Menu invocation shows the style gallery; the command itself never opens a dialog.
egui::Popup::menu(&wa).show(|ui| crate::wordart::gallery(app, ui));
let __k = big_button(ui, Icon::PageLayout, "Header &\nFooter", "Header & Footer", false);
control_keytip(app, ui, &__k, "dialog:headerFooter");
if __k.clicked() {
+117
View File
@@ -120,6 +120,9 @@ pub fn title_bar(app: &mut SheetApp, ui: &mut Ui) {
});
let left_end = ui.min_rect().right();
let right = ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
if app.window_controls {
ui.add_space(3.0 * CONTROL_W);
}
ui.add_space(8.0);
let __k = icon_button(ui, Icon::Search, t.text_dim, "Search commands", vec2(28.0, ch));
control_keytip(app, ui, &__k, "commandSearch");
@@ -206,6 +209,120 @@ fn paint_title(ui: &Ui, center: egui::Pos2, title: &str, dirty: bool, max_w: f32
}
}
/// Width of one window-control button on the title bar.
pub const CONTROL_W: f32 = 46.0;
const CONTROL_TITLE_H: f32 = 38.0;
const RESIZE_BAND: f32 = 5.0;
/// Draw application controls and edge resizing for frameless windows.
pub fn window_frame(app: &mut SheetApp, ctx: &egui::Context) {
if !app.window_controls {
return;
}
let (maximized, fullscreen) = ctx.input(|i| (i.viewport().maximized.unwrap_or(false), i.viewport().fullscreen.unwrap_or(false)));
if fullscreen {
return;
}
let t = Tokens::get(ctx);
let screen = ctx.content_rect();
let controls = egui::Rect::from_min_size(egui::pos2(screen.max.x - 3.0 * CONTROL_W, screen.min.y), egui::vec2(3.0 * CONTROL_W, CONTROL_TITLE_H));
egui::Area::new(egui::Id::unique("gc_window_controls")).order(egui::Order::Foreground).fixed_pos(controls.min).show(ctx, |ui| {
ui.spacing_mut().item_spacing = egui::vec2(0.0, 0.0);
ui.horizontal(|ui| {
for kind in ["minimize", "maximize", "close"] {
let (r, resp) = ui.allocate_exact_size(egui::vec2(CONTROL_W, CONTROL_TITLE_H), egui::Sense::click());
let label = app.ui.language.tr(match kind {
"minimize" => "Minimize",
"maximize" if maximized => "Restore Down",
"maximize" => "Maximize",
_ => "Close",
});
let hot = resp.hovered() || resp.is_pointer_button_down_on();
if hot {
ui.painter().rect_filled(
r,
0.0,
if kind == "close" {
egui::Color32::from_rgb(0xC4, 0x2B, 0x1C)
} else if resp.is_pointer_button_down_on() {
t.pressed
} else {
t.hover
},
);
}
resp.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, true, label));
let m = r.center();
let stroke = egui::Stroke::new(1.0, if kind == "close" && hot { egui::Color32::WHITE } else { t.text });
match kind {
"minimize" => {
ui.painter().line_segment([egui::pos2(m.x - 5.0, m.y), egui::pos2(m.x + 5.0, m.y)], stroke);
}
"maximize" if maximized => {
let front = egui::Rect::from_min_size(egui::pos2(m.x - 5.0, m.y - 3.0), egui::vec2(8.0, 8.0));
ui.painter().rect_stroke(front, 0.0, stroke, egui::StrokeKind::Inside);
ui.painter().line_segment([egui::pos2(m.x - 3.0, m.y - 5.0), egui::pos2(m.x + 5.0, m.y - 5.0)], stroke);
ui.painter().line_segment([egui::pos2(m.x + 5.0, m.y - 5.0), egui::pos2(m.x + 5.0, m.y + 3.0)], stroke);
}
"maximize" => {
ui.painter().rect_stroke(r.shrink(15.0), 0.0, stroke, egui::StrokeKind::Inside);
}
_ => {
ui.painter().line_segment([m - egui::vec2(5.0, 5.0), m + egui::vec2(5.0, 5.0)], stroke);
ui.painter().line_segment([m + egui::vec2(5.0, -5.0), m - egui::vec2(5.0, -5.0)], stroke);
}
}
if resp.on_hover_text(label).clicked() {
match kind {
"minimize" => app.run_or_alert("ui.window.minimize", json!({})),
"maximize" => app.run_or_alert("ui.window.maximize", json!({"on": !maximized})),
"close" => app.run_or_alert("ui.window.close", json!({})),
_ => {}
}
}
}
});
});
if maximized {
return;
}
let Some(pos) = ctx.input(|i| i.pointer.hover_pos()) else {
return;
};
let l = pos.x <= screen.min.x + RESIZE_BAND;
let r = pos.x >= screen.max.x - RESIZE_BAND;
let top = pos.y <= screen.min.y + RESIZE_BAND;
let b = pos.y >= screen.max.y - RESIZE_BAND;
let dir = match (l, r, top, b) {
(true, false, true, false) => Some(egui::viewport::ResizeDirection::NorthWest),
(false, true, true, false) => Some(egui::viewport::ResizeDirection::NorthEast),
(true, false, false, true) => Some(egui::viewport::ResizeDirection::SouthWest),
(false, true, false, true) => Some(egui::viewport::ResizeDirection::SouthEast),
(true, false, _, _) => Some(egui::viewport::ResizeDirection::West),
(false, true, _, _) => Some(egui::viewport::ResizeDirection::East),
(_, _, true, false) => Some(egui::viewport::ResizeDirection::North),
(_, _, false, true) => Some(egui::viewport::ResizeDirection::South),
_ => None,
};
if let Some(dir) = dir
&& ctx.input(|i| i.pointer.primary_pressed())
&& !controls.contains(pos)
{
let direction = match dir {
egui::ResizeDirection::North => "north",
egui::ResizeDirection::South => "south",
egui::ResizeDirection::East => "east",
egui::ResizeDirection::West => "west",
egui::ResizeDirection::NorthEast => "northeast",
egui::ResizeDirection::NorthWest => "northwest",
egui::ResizeDirection::SouthEast => "southeast",
egui::ResizeDirection::SouthWest => "southwest",
};
app.run_or_alert("ui.window.beginResize", json!({"direction": direction}));
}
app.flush_viewport_commands(ctx);
}
#[cfg(test)]
mod title_bar_tests {
use super::*;
+11 -3
View File
@@ -33,7 +33,7 @@ impl SheetApp {
}
let Some(d) = self.session.active() else { return false };
let Some(sh) = d.wb.active() else { return false };
let Some(shape) = sh.shapes.iter().find(|s| s.id == id && s.kind == ShapeKind::TextBox) else {
let Some(shape) = sh.shapes.iter().find(|s| s.id == id && matches!(s.kind, ShapeKind::TextBox | ShapeKind::WordArt)) else {
return false;
};
// shape.setText refuses edits on a protected sheet; don't open an editor that can't commit.
@@ -118,7 +118,7 @@ pub(crate) fn show(app: &mut SheetApp, ui: &mut egui::Ui, geo: &Geo, sh: &gridcr
app.text_box_editor = Some(ed);
return;
}
let Some(shape) = sh.shapes.iter().find(|s| s.id == ed.id && s.kind == ShapeKind::TextBox) else {
let Some(shape) = sh.shapes.iter().find(|s| s.id == ed.id && matches!(s.kind, ShapeKind::TextBox | ShapeKind::WordArt)) else {
app.session.mode = Mode::Ready;
return;
};
@@ -153,7 +153,15 @@ pub(crate) fn show(app: &mut SheetApp, ui: &mut egui::Ui, geo: &Geo, sh: &gridcr
.add(
TextEdit::multiline(&mut ed.text)
.id(id)
.font(FontId::new(14.0 * geo.z, egui::FontFamily::Name(theme::CELL.into())))
.font(FontId::new(
// WordArt is edited at its own size (clamped so the box stays usable).
if shape.kind == ShapeKind::WordArt {
shape.format.font_size.map_or(14.0, |pt| (pt * 96.0 / 72.0).clamp(8.0, 200.0))
} else {
14.0
} * geo.z,
egui::FontFamily::Name(theme::CELL.into()),
))
.text_color(Color32::BLACK)
.frame(egui::Frame::NONE)
.margin(egui::Margin::ZERO)
+50
View File
@@ -0,0 +1,50 @@
//! Insert › Text › WordArt: the style gallery. Previews are drawn in code from the engine's
//! preset palette (`gridcraft_engine::cmd::wordart::STYLES`); picking one runs `insert.wordArt`.
use egui::{Align2, Color32, FontId, Painter, Rect, Sense, Ui, vec2};
use gridcraft_engine::cmd::wordart::{STYLES, WordArtStyle};
use gridcraft_engine::model::Theme;
use serde_json::json;
use crate::{SheetApp, theme};
/// Paints "Abc" in `style` centred in `r` (fill, outline and shadow as the sheet object has them).
pub(crate) fn paint_sample(p: &Painter, r: Rect, style: &WordArtStyle, theme: &Theme) {
let px = 24.0;
let family = theme::cell_family("", style.bold, style.italic);
let font = FontId::new(px, family);
let c = r.center();
let col = |c: gridcraft_engine::model::Color| c.resolve(theme).map(theme::color32).unwrap_or(Color32::BLACK);
if let Some(sh) = style.shadow {
p.text(c + vec2(1.5, 1.5), Align2::CENTER_CENTER, "Abc", font.clone(), col(sh));
}
if let Some((oc, w)) = style.outline {
let d = (w * 96.0 / 72.0 / 2.0).clamp(0.5, 3.0);
for (dx, dy) in [(-1.0, -1.0), (0.0, -1.0), (1.0, -1.0), (-1.0, 0.0), (1.0, 0.0), (-1.0, 1.0), (0.0, 1.0), (1.0, 1.0)] {
p.text(c + vec2(dx * d, dy * d), Align2::CENTER_CENTER, "Abc", font.clone(), col(oc));
}
}
p.text(c, Align2::CENTER_CENTER, "Abc", font, col(style.fill));
}
/// The gallery popup content: two rows of previews; a click inserts that style.
pub(crate) fn gallery(app: &mut SheetApp, ui: &mut Ui) {
let theme = app.session.active().map(|d| d.wb.theme.clone()).unwrap_or_default();
ui.set_width(5.0 * 72.0);
egui::Grid::new("wordart_gallery").spacing(vec2(4.0, 4.0)).show(ui, |ui| {
for (i, style) in STYLES.iter().enumerate() {
let (r, resp) = ui.allocate_exact_size(vec2(68.0, 44.0), Sense::click());
let t = theme::Tokens::get(ui.ctx());
ui.painter().rect_filled(r, 4.0, if resp.hovered() { t.hover } else { Color32::WHITE });
ui.painter().rect_stroke(r, 4.0, egui::Stroke::new(1.0, t.input_border), egui::StrokeKind::Inside);
paint_sample(&ui.painter().with_clip_rect(r), r, style, &theme);
if resp.on_hover_text(style.name).clicked() {
app.run_or_alert("insert.wordArt", json!({"style": style.name}));
ui.close();
}
if (i + 1) % 5 == 0 {
ui.end_row();
}
}
});
}
+224
View File
@@ -153,6 +153,110 @@ fn dragging_a_boundary_inside_a_multi_area_selection_resizes_every_selected_line
}
}
#[test]
fn a_multi_selection_resize_previews_on_the_dragged_line_and_applies_on_release() {
// Issue #1082: only the dragged line moves while the button is held; Esc cancels.
for rows in [false, true] {
let mut h = harness(if rows { "1:3" } else { "A:C" });
let before = sizes(&h, rows);
let (start, zoom) = edge(&h, rows, 1);
let delta = if rows { vec2(0.0, 30.0) } else { vec2(30.0, 0.0) };
button(&mut h, start, true);
h.input_mut().events.push(Event::PointerMoved(start + delta / 2.0));
h.step();
h.input_mut().events.push(Event::PointerMoved(start + delta));
h.step();
let held = sizes(&h, rows);
assert_eq!(held[1], (before[1] + 30.0 / zoom).round(), "the dragged line previews");
for index in [0, 2, 3] {
assert_eq!(held[index], before[index], "line {index} waits for the release");
}
button(&mut h, start + delta, false);
h.run_steps(2);
let after = sizes(&h, rows);
for (index, size) in after.iter().take(3).enumerate() {
assert_eq!(*size, held[1], "line {index} takes the width on release");
}
assert_eq!(after[3], before[3]);
assert_eq!(h.state().session.active().unwrap().undo.len(), 1);
h.state_mut().session.execute("edit.undo", json!({})).unwrap();
assert_eq!(sizes(&h, rows), before);
// Esc during the drag cancels everything.
let mut h = harness(if rows { "1:3" } else { "A:C" });
button(&mut h, start, true);
h.input_mut().events.push(Event::PointerMoved(start + delta));
h.step();
h.input_mut().events.push(Event::Key {
key: egui::Key::Escape,
physical_key: None,
pressed: true,
repeat: false,
modifiers: Modifiers::NONE,
});
h.step();
button(&mut h, start + delta, false);
h.run_steps(2);
assert_eq!(sizes(&h, rows), before, "Esc restores the sizes");
}
}
#[test]
fn escaping_a_resize_drag_keeps_an_earlier_size_edit() {
// A resize drag right after another resize shares its undo label; Esc must cancel only the drag.
for (rows, selection) in [(false, "B:B"), (true, "2:2"), (false, "A:C"), (true, "1:3")] {
let mut h = harness(selection);
let key = if rows { ("home.rowHeight", "rows", "2:2", "height") } else { ("home.columnWidth", "cols", "B:B", "width") };
h.state_mut().session.execute(key.0, json!({key.1: key.2, key.3: 80})).unwrap();
h.run_steps(2);
let earlier = sizes(&h, rows);
let undo_len = h.state().session.active().unwrap().undo.len();
let (start, _) = edge(&h, rows, 1);
let delta = if rows { vec2(0.0, 30.0) } else { vec2(30.0, 0.0) };
button(&mut h, start, true);
h.input_mut().events.push(Event::PointerMoved(start + delta / 2.0));
h.step();
h.input_mut().events.push(Event::PointerMoved(start + delta));
h.step();
assert_ne!(sizes(&h, rows), earlier, "the drag previews");
h.input_mut().events.push(Event::Key {
key: egui::Key::Escape,
physical_key: None,
pressed: true,
repeat: false,
modifiers: Modifiers::NONE,
});
h.step();
button(&mut h, start + delta, false);
h.run_steps(2);
assert_eq!(sizes(&h, rows), earlier, "Esc cancels only the drag (rows: {rows}, selection {selection})");
assert_eq!(h.state().session.active().unwrap().undo.len(), undo_len, "the earlier edit stays on the undo stack");
}
}
#[test]
fn a_resize_drag_after_another_resize_is_its_own_undo_step() {
for (rows, selection) in [(false, "B:B"), (true, "2:2"), (false, "A:C"), (true, "1:3")] {
let mut h = harness(selection);
let key = if rows { ("home.rowHeight", "rows", "2:2", "height") } else { ("home.columnWidth", "cols", "B:B", "width") };
h.state_mut().session.execute(key.0, json!({key.1: key.2, key.3: 80})).unwrap();
h.run_steps(2);
let earlier = sizes(&h, rows);
let (start, _) = edge(&h, rows, 1);
let delta = if rows { vec2(0.0, 30.0) } else { vec2(30.0, 0.0) };
button(&mut h, start, true);
h.input_mut().events.push(Event::PointerMoved(start + delta / 2.0));
h.step();
h.input_mut().events.push(Event::PointerMoved(start + delta));
h.step();
button(&mut h, start + delta, false);
h.run_steps(2);
assert_eq!(h.state().session.active().unwrap().undo.len(), 2, "selection {selection}: two undo steps");
h.state_mut().session.execute("edit.undo", json!({})).unwrap();
assert_eq!(sizes(&h, rows), earlier, "selection {selection}: one undo reverts only the drag");
}
}
#[test]
fn table_filter_autofit_works_through_command_and_header_double_click() {
for zoom in [50, 100, 200] {
@@ -191,3 +295,123 @@ fn table_filter_autofit_works_through_command_and_header_double_click() {
}
}
}
fn press_escape(h: &mut egui_kittest::Harness<'_, SheetApp>) {
h.input_mut().events.push(Event::Key { key: egui::Key::Escape, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::NONE });
h.step();
}
#[test]
fn a_rejected_final_preview_releases_with_the_size_last_shown() {
// The engine refuses rows over 546 px and columns over 1800 px; the release must apply the last
// accepted preview to the whole selection, not retry the refused size.
for rows in [false, true] {
let mut h = harness(if rows { "1:3" } else { "A:C" });
let before = sizes(&h, rows);
let (start, zoom) = edge(&h, rows, 1);
let unit = |d: f32| if rows { vec2(0.0, d) } else { vec2(d, 0.0) };
button(&mut h, start, true);
h.input_mut().events.push(Event::PointerMoved(start + unit(15.0)));
h.step();
h.input_mut().events.push(Event::PointerMoved(start + unit(30.0)));
h.step();
let shown = sizes(&h, rows)[1];
assert_eq!(shown, (before[1] + 30.0 / zoom).round());
h.input_mut().events.push(Event::PointerMoved(start + unit(4000.0 * zoom)));
h.step();
assert_eq!(sizes(&h, rows)[1], shown, "the refused size is not shown");
button(&mut h, start + unit(4000.0 * zoom), false);
h.run_steps(2);
let after = sizes(&h, rows);
for (index, size) in after.iter().take(3).enumerate() {
assert_eq!(*size, shown, "line {index} takes the size that was shown (rows: {rows})");
}
assert_eq!(after[3], before[3]);
}
}
#[test]
fn escaping_a_resize_drag_leaves_redo_history_as_it_was() {
for rows in [false, true] {
for with_redo in [false, true] {
let mut h = harness(if rows { "1:3" } else { "A:C" });
let cmd = if rows { ("home.rowHeight", "rows", "4:4", "height") } else { ("home.columnWidth", "cols", "D:D", "width") };
let mut redo_len = 0;
let mut d_size = 0.0;
if with_redo {
h.state_mut().session.execute(cmd.0, json!({cmd.1: cmd.2, cmd.3: 80})).unwrap();
h.state_mut().session.execute("edit.undo", json!({})).unwrap();
h.run_steps(2);
redo_len = h.state().session.active().unwrap().redo.len();
assert_eq!(redo_len, 1);
d_size = sizes(&h, rows)[3];
}
let before = sizes(&h, rows);
let (start, _) = edge(&h, rows, 1);
let delta = if rows { vec2(0.0, 30.0) } else { vec2(30.0, 0.0) };
button(&mut h, start, true);
h.input_mut().events.push(Event::PointerMoved(start + delta / 2.0));
h.step();
h.input_mut().events.push(Event::PointerMoved(start + delta));
h.step();
assert_ne!(sizes(&h, rows), before, "the drag previews");
press_escape(&mut h);
button(&mut h, start + delta, false);
h.run_steps(2);
assert_eq!(sizes(&h, rows), before);
assert_eq!(h.state().session.active().unwrap().redo.len(), redo_len, "Esc leaves the redo stack alone (rows: {rows}, redo: {with_redo})");
// Ctrl+Y brings back only what was undone before the drag.
let redone = h.state_mut().session.execute("edit.redo", json!({}));
if with_redo {
redone.unwrap();
let redone = sizes(&h, rows);
assert_eq!(redone[3], 80.0);
assert_ne!(redone[3], d_size);
assert_eq!(redone[..3], before[..3], "the cancelled drag does not come back");
} else {
assert!(redone.is_err(), "nothing to redo after a cancelled drag");
}
}
}
}
#[test]
fn escaping_a_resize_drag_keeps_a_pending_copy_and_format_painter() {
// Esc cancels the drag only: the marked copy and Format Painter stay, whether the release comes
// in a later frame or in the same frame as Esc.
for rows in [false, true] {
for (same_frame, modifiers) in [(false, Modifiers::NONE), (true, Modifiers::NONE), (false, Modifiers::SHIFT)] {
let mut h = harness(if rows { "1:3" } else { "A:C" });
h.state_mut().session.execute("edit.copy", json!({"range": "A1:B2"})).unwrap();
h.state_mut().session.execute("edit.formatPainter", json!({"sticky": true})).unwrap();
h.run_steps(2);
assert!(h.state().session.clipboard.is_some() && h.state().session.format_painter.is_some());
let before = sizes(&h, rows);
let (start, _) = edge(&h, rows, 1);
let delta = if rows { vec2(0.0, 30.0) } else { vec2(30.0, 0.0) };
button(&mut h, start, true);
h.input_mut().events.push(Event::PointerMoved(start + delta / 2.0));
h.step();
h.input_mut().events.push(Event::PointerMoved(start + delta));
h.step();
assert_ne!(sizes(&h, rows), before, "the drag previews");
let pos = start + delta;
let esc = Event::Key { key: egui::Key::Escape, physical_key: None, pressed: true, repeat: false, modifiers };
if same_frame {
h.input_mut().events.extend([esc, Event::PointerButton { pos, button: PointerButton::Primary, pressed: false, modifiers }]);
} else {
h.input_mut().events.push(esc);
h.step();
h.input_mut()
.events
.extend([Event::PointerMoved(pos), Event::PointerButton { pos, button: PointerButton::Primary, pressed: false, modifiers }]);
}
h.step();
h.run_steps(2);
let what = format!("rows: {rows}, same frame: {same_frame}, modifiers: {modifiers:?}");
assert_eq!(sizes(&h, rows), before, "the drag is cancelled ({what})");
assert!(h.state().session.clipboard.is_some(), "the copy is still marked ({what})");
assert!(h.state().session.format_painter.is_some(), "Format Painter is still on ({what})");
}
}
}
+1 -4
View File
@@ -1417,10 +1417,7 @@ fn keytip_nv_() {
fn keytip_nw_() {
let mut h = harness(blank());
sequence(&mut h, "NW", false);
assert!(h.state().dialog.is_none(), "NW must not open a dialog");
assert!(h.state().message.is_none(), "NW must not open a message box");
assert!(h.state().toast.is_none(), "NW must not raise a toast");
assert!(h.state().session.journal.is_empty(), "NW must not journal");
assert!(h.state().session.journal.iter().any(|(id, _)| id == "insert.wordArt"), "NW must journal insert.wordArt");
}
#[test]
+2 -2
View File
@@ -1064,8 +1064,8 @@ fn the_windows_cancel_with_an_unsavable_draft_closes_the_dialog_and_says_why() {
assert_eq!(draft_text(&h).as_deref(), Some("Picked note"), "the draft is kept");
assert_eq!(selection(&h).0, 2, "the selection stays where it is");
let wb = &h.state().session.active().unwrap().wb;
for sheet in 0..3 {
assert!(wb.sheets[sheet].value(CellRef::parse("H1").unwrap()).is_empty(), "nothing ran on sheet {sheet}");
for (index, sheet) in wb.sheets[..3].iter().enumerate() {
assert!(sheet.value(CellRef::parse("H1").unwrap()).is_empty(), "nothing ran on sheet {index}");
}
}
+1 -1
View File
@@ -495,7 +495,7 @@ fn vertical_alignment_keytips_run_their_commands() {
fn pending_sequences_are_silent_no_ops() {
let mut h = harness(blank());
let journal = h.state().session.journal.len();
sequence(&mut h, &[Key::N, Key::W], false); // NW -> insert.wordArt (missing)
sequence(&mut h, &[Key::N, Key::S, Key::C], false); // NSC -> insert.screenshot (missing)
assert!(h.state().dialog.is_none(), "no dialog for a pending sequence");
assert!(h.state().message.is_none(), "no message box for a pending sequence");
assert!(h.state().toast.is_none(), "no toast for a pending sequence");
+28 -3
View File
@@ -221,7 +221,16 @@ fn read_shape(obj: &El, anchor: Anchor) -> Option<Shape> {
let tx_box = obj.path(&["nvSpPr", "cNvSpPr"]).is_some_and(|c| c.flag("txBox", false));
let ln = sp.child("ln");
let arrow = ln.is_some_and(|l| l.child("tailEnd").or_else(|| l.child("headEnd")).is_some_and(|t| t.attr("type").is_some_and(|v| v != "none")));
// WordArt: our marker, a text body with the non-warping text warp `textNoShape`, on a rectangle
// that is a text box (as the writer saves it) or has no fill and no outline of its own (as
// WordArt usually comes). `textNoShape` is the standard "no warp" value, so on an ordinary
// shape (an ellipse, a filled rectangle) it, like any other warp, leaves the shape what its
// geometry says.
let word_art = prst == "rect"
&& (tx_box || (sp.child("noFill").is_some() && !ln.is_some_and(|l| l.child("solidFill").is_some())))
&& obj.path(&["txBody", "bodyPr", "prstTxWarp"]).is_some_and(|w| w.attr("prst") == Some("textNoShape"));
let kind = match prst {
_ if word_art => ShapeKind::WordArt,
_ if tx_box => ShapeKind::TextBox,
"roundRect" => ShapeKind::RoundedRectangle,
"ellipse" => ShapeKind::Ellipse,
@@ -294,6 +303,7 @@ fn read_text_format(body: Option<&El>) -> ShapeFormat {
f.italic = r.flag("i", false);
f.font = r.child("latin").and_then(|l| l.attr("typeface")).filter(|t| !t.is_empty() && !t.starts_with('+')).map(str::to_string);
f.text_color = r.child("solidFill").and_then(dml_color);
f.text_shadow = r.child("effectLst").and_then(|e| e.child("outerShdw")).and_then(dml_color);
f.text_outline = r.child("ln").and_then(|l| {
let c = l.child("solidFill").and_then(dml_color)?;
// Width in EMU (12700 per point); Excel's default hairline is 0.75 pt.
@@ -520,7 +530,7 @@ pub fn write_drawing(sheet: &Sheet, theme: &Theme, objs: &[Obj<'_>]) -> String {
ShapeKind::Triangle => ("triangle", false),
ShapeKind::Line | ShapeKind::Arrow => ("line", false),
// Equations are written by `write_equation`; this arm keeps the match whole.
ShapeKind::TextBox | ShapeKind::Equation => ("rect", true),
ShapeKind::TextBox | ShapeKind::WordArt | ShapeKind::Equation => ("rect", true),
ShapeKind::Icon | ShapeKind::Ink => ("rect", false),
};
let _ = write!(
@@ -550,7 +560,8 @@ pub fn write_drawing(sheet: &Sheet, theme: &Theme, objs: &[Obj<'_>]) -> String {
s.push_str("</a:ln>");
}
s.push_str("</xdr:spPr>");
if !sh.text.is_empty() {
// A WordArt with no text still writes its body, which carries the WordArt marker.
if !sh.text.is_empty() || sh.kind == ShapeKind::WordArt {
let f = &sh.format;
let anchor = match f.anchor {
Some(ShapeTextAnchor::Top) => " anchor=\"t\"",
@@ -559,7 +570,15 @@ pub fn write_drawing(sheet: &Sheet, theme: &Theme, objs: &[Obj<'_>]) -> String {
None if sh.kind == ShapeKind::TextBox => " anchor=\"t\"",
None => "",
};
let _ = write!(s, "<xdr:txBody><a:bodyPr wrap=\"square\" rtlCol=\"0\"{anchor}/><a:lstStyle/>");
if sh.kind == ShapeKind::WordArt {
// Our WordArt marker: a (non-warping) text warp, which the reader maps back to WordArt.
let _ = write!(
s,
"<xdr:txBody><a:bodyPr wrap=\"square\" rtlCol=\"0\"{anchor}><a:prstTxWarp prst=\"textNoShape\"><a:avLst/></a:prstTxWarp></a:bodyPr><a:lstStyle/>"
);
} else {
let _ = write!(s, "<xdr:txBody><a:bodyPr wrap=\"square\" rtlCol=\"0\"{anchor}/><a:lstStyle/>");
}
let algn = match f.align {
None => "",
Some(ShapeTextAlign::Left) => " algn=\"l\"",
@@ -614,6 +633,12 @@ fn run_props(f: &ShapeFormat, theme: &Theme) -> (String, String) {
if let Some(c) = f.text_color.as_ref().and_then(|c| srgb(c, theme)) {
let _ = write!(body, "<a:solidFill>{c}</a:solidFill>");
}
if let Some(c) = f.text_shadow.as_ref().and_then(|c| srgb(c, theme)) {
let _ = write!(
body,
"<a:effectLst><a:outerShdw blurRad=\"38100\" dist=\"38100\" dir=\"2700000\" algn=\"tl\" rotWithShape=\"0\">{c}</a:outerShdw></a:effectLst>"
);
}
if let Some(font) = &f.font {
let _ = write!(body, "<a:latin typeface=\"{}\"/>", esc_attr(font));
}
+1
View File
@@ -47,6 +47,7 @@ fn prefix_params(e: Expr, scope: &[String]) -> Expr {
Expr::Name(n) if scope.iter().any(|s| s.eq_ignore_ascii_case(&n)) => Expr::Name(format!("{PARAM_PREFIX}{n}")),
Expr::Unary(op, x) => Expr::Unary(op, sub(x, scope)),
Expr::Paren(x) => Expr::Paren(sub(x, scope)),
Expr::Binary(op, a, b) if !matches!(*a, Expr::Binary(..)) => Expr::Binary(op, sub(a, scope), sub(b, scope)),
Expr::Binary(op, a, b) => {
// A long chain such as A1+A2+… nests on its left: follow it in a loop, not one
// level of recursion per operand.
+17 -1
View File
@@ -69,7 +69,23 @@ fn item_label_el(e: &El, sys: DateSystem) -> String {
}
fn read_cache(cx: &mut Ctx<'_>, part: &str, sheet_name: &str) -> Option<CacheIn> {
let x = cx.optional_xml(part).ok().flatten()?;
// A cache that can't be read loses its PivotTable: say so instead of dropping it silently.
// An oversized cache is refused before it inflates, so warning and opening the rest is safe.
let x = match cx.optional_xml(part) {
Ok(Some(x)) => x,
Ok(None) => {
cx.warn(format!("a PivotTable's cache {part} is missing or could not be read; kept as plain cells"));
return None;
}
Err(IoError::TooLarge(m)) => {
cx.warn(format!("a PivotTable's cache is too large to read ({m}); kept as plain cells"));
return None;
}
Err(e) => {
cx.warn(format!("a PivotTable's cache could not be read ({e}); kept as plain cells"));
return None;
}
};
if x.name != "pivotCacheDefinition" {
cx.warn(format!("{part} is not a pivot cache definition; its PivotTable was kept as plain cells"));
return None;
+45
View File
@@ -711,6 +711,51 @@ fn data_on_rows_with_one_value_field_reads_without_warning() {
assert!(back.sheet(0).unwrap().pivots[0].values_on_rows);
}
const SIMPLE_TABLE: &str = r#"<pivotTableDefinition name="Sales"><location ref="C1:D4"/><pivotFields><pivotField axis="axisRow"><items><item x="0"/><item t="default"/></items></pivotField><pivotField dataField="1"/></pivotFields><rowFields><field x="0"/></rowFields><dataFields><dataField name="Total" fld="1"/></dataFields></pivotTableDefinition>"#;
const CACHE_PART: &str = "xl/pivotCache/pivotCacheDefinition1.xml";
/// Rewrites the uncompressed size a zip's central directory declares for `name`.
fn declare_size(mut zip: Vec<u8>, name: &str, size: u32) -> Vec<u8> {
let at = (0..zip.len().saturating_sub(46))
.find(|&i| {
zip[i..i + 4] == [0x50, 0x4b, 0x01, 0x02] && {
let len = u16::from_le_bytes([zip[i + 28], zip[i + 29]]) as usize;
zip.get(i + 46..i + 46 + len) == Some(name.as_bytes())
}
})
.unwrap();
zip[at + 24..at + 28].copy_from_slice(&size.to_le_bytes());
zip
}
#[test]
fn unreadable_pivot_cache_warns() {
// Control: a readable cache gives a PivotTable and no cache warning.
let (wb, report) = read_xlsx(&with_pivot(SIMPLE_TABLE, Some(GOOD_CACHE))).unwrap();
assert_eq!(wb.sheet(0).unwrap().pivots.len(), 1, "{:?}", report.warnings);
assert!(!report.warnings.iter().any(|w| w.contains("PivotTable's cache")), "{:?}", report.warnings);
// Malformed and missing caches: the workbook opens and the lost PivotTable is reported.
let lost = format!("a PivotTable's cache {CACHE_PART} is missing or could not be read; kept as plain cells");
for cache in [Some("garbage <<<"), None] {
let (wb, report) = read_xlsx(&with_pivot(SIMPLE_TABLE, cache)).unwrap();
assert!(wb.sheet(0).unwrap().pivots.is_empty());
assert!(report.warnings.contains(&lost), "{cache:?}: {:?}", report.warnings);
}
}
#[test]
fn oversized_pivot_cache_warns() {
// The cache declares more than the per-part limit, so it is refused before it inflates.
let declared = u32::try_from(crate::package::MAX_PART + 1).unwrap();
let bytes = declare_size(with_pivot(SIMPLE_TABLE, Some(GOOD_CACHE)), CACHE_PART, declared);
let (wb, report) = read_xlsx(&bytes).unwrap();
assert_eq!(wb.sheet(0).unwrap().name, "Data");
assert!(wb.sheet(0).unwrap().pivots.is_empty());
let limit = crate::package::MAX_PART;
let lost = format!("a PivotTable's cache is too large to read ({CACHE_PART} expands to more than {limit} bytes); kept as plain cells");
assert!(report.warnings.contains(&lost), "{:?}", report.warnings);
}
/// A one-sheet-of-data workbook with a pivot on "Report": `columns` are the source columns
/// (header, values), `pt` the pivot built on `Data!A1:<last>`.
fn small_pivot(columns: &[(&str, Vec<Value>)], pt: impl FnOnce(&mut PivotTable)) -> HashMap<String, String> {
+1
View File
@@ -395,6 +395,7 @@ fn sample() -> Workbook {
font: Some("Arial".into()),
text_color: Some(Color::Rgb(0x112233)),
text_outline: Some((Color::Rgb(0xFF0000), 1.5)),
text_shadow: Some(Color::Rgb(0x445566)),
align: Some(ShapeTextAlign::Right),
anchor: Some(ShapeTextAnchor::Bottom),
rtl: true,
+66
View File
@@ -86,6 +86,72 @@ fn shape_text_without_rtl_writes_unchanged_ppr() {
assert!(!xml.contains("<a:pPr"), "no paragraph properties without alignment or direction: {xml}");
}
#[test]
fn word_art_keeps_right_to_left_paragraphs() {
let mut wb = text_box("مرحبا\nبالعالم", ShapeFormat { rtl: true, align: Some(ShapeTextAlign::Right), ..Default::default() });
wb.sheet_mut(0).unwrap().shapes[0].kind = ShapeKind::WordArt;
let xml = written_drawing(&wb);
assert!(xml.contains(r#"<a:prstTxWarp prst="textNoShape">"#));
assert_eq!(xml.matches(r#"<a:pPr algn="r" rtl="1"/>"#).count(), 2);
let (reopened, _) = read_xlsx(&write_xlsx(&wb).unwrap()).unwrap();
let shape = &reopened.sheet(0).unwrap().shapes[0];
assert_eq!(shape.kind, ShapeKind::WordArt);
assert!(shape.format.rtl);
assert_eq!(shape.format.align, Some(ShapeTextAlign::Right));
assert_eq!(shape.text, "مرحبا\nبالعالم");
}
#[test]
fn word_art_with_empty_text_keeps_its_kind() {
let mut wb = text_box("", ShapeFormat::default());
wb.sheet_mut(0).unwrap().shapes[0].kind = ShapeKind::WordArt;
let (reopened, _) = read_xlsx(&write_xlsx(&wb).unwrap()).unwrap();
assert_eq!(reopened.sheet(0).unwrap().shapes[0].kind, ShapeKind::WordArt);
}
#[test]
fn a_text_warp_on_a_filled_ellipse_does_not_make_it_word_art() {
let drawing = ARABIC_TEXT_BOX
.replace(r#"<xdr:cNvSpPr txBox="1"/>"#, "<xdr:cNvSpPr/>")
.replace(r#"prst="rect""#, r#"prst="ellipse""#)
.replace(r#"anchor="t"/>"#, r#"anchor="t"><a:prstTxWarp prst="textTriangle"><a:avLst/></a:prstTxWarp></a:bodyPr>"#);
let wb = read_drawing(&drawing);
assert_eq!(wb.sheet(0).unwrap().shapes[0].kind, ShapeKind::Ellipse);
}
/// `textNoShape` is the standard "no text warp" value, so on its own it does not make an ordinary
/// shape WordArt: a filled ellipse that carries it reads and saves as the same filled ellipse.
#[test]
fn an_explicit_no_warp_on_a_filled_ellipse_stays_an_ellipse() {
let drawing = ARABIC_TEXT_BOX
.replace(r#"<xdr:cNvSpPr txBox="1"/>"#, "<xdr:cNvSpPr/>")
.replace(
r#"<a:prstGeom prst="rect"><a:avLst/></a:prstGeom>"#,
r#"<a:prstGeom prst="ellipse"><a:avLst/></a:prstGeom><a:solidFill><a:srgbClr val="FF0000"/></a:solidFill>"#,
)
.replace(r#"anchor="t"/>"#, r#"anchor="t"><a:prstTxWarp prst="textNoShape"><a:avLst/></a:prstTxWarp></a:bodyPr>"#);
let wb = read_drawing(&drawing);
let shape = &wb.sheet(0).unwrap().shapes[0];
assert_eq!(shape.kind, ShapeKind::Ellipse);
assert_eq!(shape.fill, Color::Rgb(0xFF0000));
let xml = written_drawing(&wb);
assert!(xml.contains(r#"<a:prstGeom prst="ellipse">"#), "{xml}");
assert!(xml.contains(r#"<a:solidFill><a:srgbClr val="FF0000"/></a:solidFill>"#), "{xml}");
assert!(!xml.contains(r#"txBox="1""#), "{xml}");
let (reopened, _) = read_xlsx(&write_xlsx(&wb).unwrap()).unwrap();
assert_eq!(reopened.sheet(0).unwrap().shapes[0].kind, ShapeKind::Ellipse);
// The same warp on a filled rectangle that is not a text box keeps it a rectangle too.
let rect = drawing.replace(r#"prst="ellipse""#, r#"prst="rect""#);
assert_eq!(read_drawing(&rect).sheet(0).unwrap().shapes[0].kind, ShapeKind::Rectangle);
// WordArt as written (a text box) or as a fill-less, line-less rectangle still reads as WordArt.
let text_box = ARABIC_TEXT_BOX.replace(r#"anchor="t"/>"#, r#"anchor="t"><a:prstTxWarp prst="textNoShape"><a:avLst/></a:prstTxWarp></a:bodyPr>"#);
assert_eq!(read_drawing(&text_box).sheet(0).unwrap().shapes[0].kind, ShapeKind::WordArt);
let bare = text_box
.replace(r#"<xdr:cNvSpPr txBox="1"/>"#, "<xdr:cNvSpPr/>")
.replace(r#"<a:prstGeom prst="rect"><a:avLst/></a:prstGeom>"#, r#"<a:prstGeom prst="rect"><a:avLst/></a:prstGeom><a:noFill/>"#);
assert_eq!(read_drawing(&bare).sheet(0).unwrap().shapes[0].kind, ShapeKind::WordArt);
}
/// #2170: a shape font typeface holding `"`, `<` or `&` is escaped as an attribute, so it can't
/// close the `typeface` attribute early and inject others; it survives a save and reopen.
#[test]
+9 -2
View File
@@ -1,6 +1,6 @@
# File-format parity
> **Last reviewed:** 2026-11-01 · **Last updated:** 2026-11-12 · **Change:** minor (.xls data validation is read; earlier: .xls is read by the shared craft-xls crate: the workbook opens on the sheet it was saved on, and rich-text (RString) cells are read; earlier: form controls: buttons, scroll bars and spin buttons read and written; earlier: a web page's first table opens as a sheet, also when the page is named `.xls`; earlier: `workbookPr filterPrivacy` kept, and honoured on save; earlier: a workbook's R1C1 reference style, `calcPr refMode`, is kept through open and save; earlier: XLSX page margins are written as their decimals, `0.3` rather than `0.30000001192092896`; earlier: Python cells in `.xlsx` as [MS-XLSX] specifies, `_xlfn._xlws.PY(…)` naming code in the Python part, with cached values, and in GridCraft JSON, with limits on open; earlier: equations in xlsx as Office Math with a marker in `descr` so an edit made in Excel reads back, read back only up to the equation source cap, and a brace with a label and a script on its other side keeps both; Symbol font in PDF; earlier: XLSX reads and writes Page Setup's page order, `pageSetup pageOrder`, and PDF export follows it; earlier: chart data tables: native c:dTable import/export; earlier: XLSX workbook-view selection, normalized tab ratios and sheet-edit regressions; fidelity estimates unchanged; earlier: formulas from Google Sheets' XLSX export open as the original formula instead of `IFERROR(__xludf.DUMMYFUNCTION(…),…)` when GridCraft calculates every function in it, and save as it; `file.exportCsv {values: true}` writes raw values for automation; .xls dialog sheets are skipped instead of read as worksheets; `.xls` import reads each sheet's display options from WINDOW2: right-to-left, gridlines, headings, zeros, formulas; XLSX text boxes and shapes keep their paragraphs' right-to-left direction on save; CSV/TSV/TXT can open with every field kept as text via `file.open {csvAsText}`; formulas over Excel's 8,192 characters, and `%` or call chains past the nesting limit, are parse errors instead of stack overflows when a file is opened; XLSX PivotTables read and write `rowGrandTotals`/`colGrandTotals` the way Excel does, so a table saved with only one grand total opens with the right one; HTML export keeps right-to-left; CSV and text import detects likely Windows-1256 Arabic when invalid UTF-8 has Arabic byte runs; other invalid UTF-8 remains Windows-1252; HTML export places pictures and charts, as inline SVG, at their anchors; earlier: `file.exportCsv {values: true}` writes raw values for automation; .xls dialog sheets are skipped instead of read as worksheets; `.xls` import reads each sheet's display options from WINDOW2: right-to-left, gridlines, headings, zeros, formulas; XLSX text boxes and shapes keep their paragraphs' right-to-left direction on save; CSV/TSV/TXT can open with every field kept as text via `file.open {csvAsText}`; formulas over Excel's 8,192 characters, and `%` or call chains past the nesting limit, are parse errors instead of stack overflows when a file is opened; XLSX PivotTables read and write `rowGrandTotals`/`colGrandTotals` the way Excel does, so a table saved with only one grand total opens with the right one; HTML export keeps right-to-left; CSV and text import detects likely Windows-1256 Arabic when invalid UTF-8 has Arabic byte runs; other invalid UTF-8 remains Windows-1252; HTML export places pictures and charts, as inline SVG, at their anchors; CSV and text open detects each column's date order from values that read only one way, warns when every date is ambiguous, and keeps a column with both kinds as text (#2765)) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4
> **Last reviewed:** 2026-11-01 · **Last updated:** 2026-11-13 · **Change:** minor (PDF honours cell reading direction and mirrors right-to-left sheets; earlier: Arabic PDF export no longer fails when a character or the Arabic font is missing; earlier: Arabic PDF text is shaped with embedded Noto Arabic glyphs beside the non-embedded standard, Symbol and CID fonts; earlier: .xls data validation is read; earlier: .xls is read by the shared craft-xls crate: the workbook opens on the sheet it was saved on, and rich-text (RString) cells are read; earlier: form controls: buttons, scroll bars and spin buttons read and written; earlier: a web page's first table opens as a sheet, also when the page is named `.xls`; earlier: `workbookPr filterPrivacy` kept, and honoured on save; earlier: a workbook's R1C1 reference style, `calcPr refMode`, is kept through open and save; earlier: XLSX page margins are written as their decimals, `0.3` rather than `0.30000001192092896`; earlier: Python cells in `.xlsx` as [MS-XLSX] specifies, `_xlfn._xlws.PY(…)` naming code in the Python part, with cached values, and in GridCraft JSON, with limits on open; earlier: equations in xlsx as Office Math with a marker in `descr` so an edit made in Excel reads back, read back only up to the equation source cap, and a brace with a label and a script on its other side keeps both; Symbol font in PDF; earlier: XLSX reads and writes Page Setup's page order, `pageSetup pageOrder`, and PDF export follows it; earlier: chart data tables: native c:dTable import/export; earlier: XLSX workbook-view selection, normalized tab ratios and sheet-edit regressions; fidelity estimates unchanged; earlier: formulas from Google Sheets' XLSX export open as the original formula instead of `IFERROR(__xludf.DUMMYFUNCTION(…),…)` when GridCraft calculates every function in it, and save as it; `file.exportCsv {values: true}` writes raw values for automation; .xls dialog sheets are skipped instead of read as worksheets; `.xls` import reads each sheet's display options from WINDOW2: right-to-left, gridlines, headings, zeros, formulas; XLSX text boxes and shapes keep their paragraphs' right-to-left direction on save; CSV/TSV/TXT can open with every field kept as text via `file.open {csvAsText}`; formulas over Excel's 8,192 characters, and `%` or call chains past the nesting limit, are parse errors instead of stack overflows when a file is opened; XLSX PivotTables read and write `rowGrandTotals`/`colGrandTotals` the way Excel does, so a table saved with only one grand total opens with the right one; HTML export keeps right-to-left; CSV and text import detects likely Windows-1256 Arabic when invalid UTF-8 has Arabic byte runs; other invalid UTF-8 remains Windows-1252; HTML export places pictures and charts, as inline SVG, at their anchors; earlier: `file.exportCsv {values: true}` writes raw values for automation; .xls dialog sheets are skipped instead of read as worksheets; `.xls` import reads each sheet's display options from WINDOW2: right-to-left, gridlines, headings, zeros, formulas; XLSX text boxes and shapes keep their paragraphs' right-to-left direction on save; CSV/TSV/TXT can open with every field kept as text via `file.open {csvAsText}`; formulas over Excel's 8,192 characters, and `%` or call chains past the nesting limit, are parse errors instead of stack overflows when a file is opened; XLSX PivotTables read and write `rowGrandTotals`/`colGrandTotals` the way Excel does, so a table saved with only one grand total opens with the right one; HTML export keeps right-to-left; CSV and text import detects likely Windows-1256 Arabic when invalid UTF-8 has Arabic byte runs; other invalid UTF-8 remains Windows-1252; HTML export places pictures and charts, as inline SVG, at their anchors; CSV and text open detects each column's date order from values that read only one way, warns when every date is ambiguous, and keeps a column with both kinds as text (#2765)) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4
Every format Excel opens or saves, with GridCraft's read and write support, fidelity and tests.
Part of [target-app-parity.md](target-app-parity.md). **File formats: ~50% ready, 80–120 h**
@@ -14,6 +14,8 @@ support comes from `crates/engine/src/io.rs` (`FileKind`), `crates/xlsx/src` and
Legacy scalar `INDEX(range, MATCH(...))` formulas remain ordinary formulas on save, including when
shared formulas are expanded during import (`array_export.rs`, #1505).
Arabic PDF output uses harfrust shaping, Unicode bidi and licensed Noto Arabic glyph outlines with ToUnicode and logical ActualText. Cells, headers and chart labels support marks, digits, rotation and style. Bundled builds use the optional `CRAFT_FONTS_DIR` input; unbundled native builds look for Noto Sans Arabic. Characters the Arabic face lacks fall back to the standard and CID fonts, and without an Arabic face for the text's weight Arabic is set in the CID font, which has no Arabic glyphs, with a message. Cell Context/LTR/RTL direction is carried through measurement, wrapping and drawing. RTL sheet geometry mirrors while text stays readable. Latin-only RTL text uses bidi ordering without requiring an Arabic font.
Cell text now uses shared Unicode bidi layout while retaining logical source indexes for editing, copy and XLSX. Format Cells exposes Context, Left to right and Right to left reading direction, independent of sheet geometry. OOXML Context uses the first non-whitespace character. Optional direction preserves absent versus explicit Context in differential styles. The renderer is pinned to a reviewed egui 0.36.2 backport with real-font, editing, accessibility and WASM checks. Physical screen-reader behavior remains unverified.
## Workbook window settings
@@ -122,7 +124,7 @@ past the parser's limit, and a wrapper inside the text. **Saving writes the real
| Format | Excel | GridCraft | Notes |
|---|---|---|---|
| PDF | Save As / Export | yes (own PDF 1.7 writer; CLI `convert` output) | Printed cell hyperlinks export as clickable HTTP(S)/mailto links or destinations within printed pages (#954); unsafe schemes and destinations outside the print range are omitted. No font is embedded: text uses the standard Helvetica, Times and Courier faces (13 base-14 entries with Symbol), and characters outside WinAnsiEncoding are set in a predefined, non-embedded CID font (STSong-Light, Adobe-GB1, `UniGB-UTF16-H`), so **Simplified Chinese displays where the reader supplies that font, and scripts outside Adobe-GB1 (Arabic, Devanagari, Thai) export as code points but show as the reader's missing-glyph box**; equations use Symbol for the Greek letters and operators it has, the Times faces for letters and digits, and a `[?]` box for the rest; web build exports without a file prompt (#141) |
| PDF | Save As / Export | yes (own PDF 1.7 writer; CLI `convert` output) | Printed cell hyperlinks export as clickable HTTP(S)/mailto links or destinations within printed pages (#954); unsafe schemes and destinations outside the print range are omitted. Latin text uses the standard Helvetica, Times and Courier faces (13 base-14 entries with Symbol), not embedded; Arabic exports as shaped, embedded Noto Arabic glyphs; cell reading direction and RTL sheet geometry are kept; other characters outside WinAnsiEncoding are set in a predefined, non-embedded CID font (STSong-Light, Adobe-GB1, `UniGB-UTF16-H`, #1912), so **Simplified Chinese displays where the reader supplies that font, and scripts outside Adobe-GB1 (Devanagari, Thai) export as code points but show as the reader's missing-glyph box**; equations use Symbol for the Greek letters and operators it has, the Times faces for letters and digits, and a `[?]` box for the rest; web build exports without a file prompt (#141) |
| XPS | Windows | no | Low priority |
| Print | yes | yes (via PDF, system dialog on desktop; PR #143 for web) | Pages print in the sheet's page order: down, then over (the default) or over, then down |
| Images of ranges/charts (Copy as Picture) | yes | chart raster in `crates/chart` | No range-to-image command |
@@ -161,9 +163,12 @@ refresh. Counted under features (Get & Transform, ~10% ready), not here.
| Date | Change | Summary |
|---|---|---|
| 2026-11-13 | minor | PDF of a right-to-left sheet keeps explicit Left and Right alignment on the side the grid shows them |
| 2026-11-12 | minor | `.xls` files open with their data validation (drop-down lists, input messages, error alerts and the rules), read by craft-xls and mapped as the `.xlsx` reader maps the same rules. A rule Excel would refuse, or one past 65,536 in a workbook, is skipped with a warning (#3634, from #3636) |
| 2026-11-12 | minor | .xls import reads the file with craft-xls (storytold/craft-libs), the reader that moved there from this repository; GridCraft keeps the mapping onto its model. The workbook now opens on the sheet it was saved on (WINDOW1 `itabCur`), falling back to the first visible sheet as before (from #3551), and cells saved as RString records (text with formatting runs) are read as text instead of skipped |
| 2026-11-10 | minor | `.xls` import: every formula except a Ctrl+Shift+Enter array is read as a legacy one with Excel's implicit `@` (a title row `=Other!A1:G1` shows its first cell instead of `#SPILL!`), one-cell Ctrl+Shift+Enter arrays stay arrays, and `@` of a 2-D range meets the formula's row and column (#410, PR #1367) |
| 2026-11-09 | minor | Arabic PDF export no longer fails on a character the Arabic face lacks (it falls back like other text) or when no Arabic font is available (Arabic is set in the CID font, which has no Arabic glyphs, and a message says so) |
| 2026-11-03 | trivial | The PDF row lists Arabic's shaped, embedded Noto glyphs beside the non-embedded standard faces, Symbol and the Adobe-GB1 CID font; Symbol text keeps its own encoding and is never shaped as Arabic |
| 2026-11-02 | minor | XLSX: buttons, scroll bars and spin buttons read and written (control properties parts, `<controls>`, VML `x:ClientData`); other form controls stay with pass-through; a button's command, fixed input or output cell travels in a hidden defined name and comes back only while the file still assigns the button's macro (or none, for a command) |
| 2026-11-03 | minor | SYLK (`.slk`) import: values, R1C1 formulas as A1 (shared formulas too) with cached results, number formats and column widths; import only (#1481) |
| 2026-11-03 | minor | Opening a web page (HTML) reads its first table as a sheet, whatever the file is called: a web app's "Export to Excel" saved as `.xls` no longer opens as lines of markup. Values read as in a CSV (or as text with `csvAsText`), `<th>` cells are bold and centred, `<x:Name>` names the sheet, and a page not named `.htm`/`.html` opens with a warning (#3166) |
@@ -185,6 +190,8 @@ refresh. Counted under features (Get & Transform, ~10% ready), not here.
| 2026-11-01 | trivial | XLSX selects the first visible workbook view as one unit and bounds imported/exported tab ratios; isolated attributes and sheet-edit round trips covered, with firstSheet left to #2264 (#3057) |
| 2026-10-31 | minor | CSV and text open detects each column's date order: a value that reads only day first (`31/05/2026`) makes the column day first, a value that reads only month first (`12/31/2026`) makes it month first, an all-ambiguous column keeps month first with a warning, and a column with both kinds stays text with a warning (#2765) |
| 2026-10-31 | minor | XLSX open reads Google Sheets' `IFERROR(__xludf.DUMMYFUNCTION("…"),cached)` export wrapper as the formula inside when GridCraft calculates every function in it (plain, shared and array formulas, whole or nested; Google-only functions and unparseable, over-long or over-deep inner text keep the wrapper and the cached value) and keeps the cached value; saving writes the real formula with Excel's `_xlfn.` prefixes (#2871) |
| 2026-10-26 | minor | PDF honors cell Context/LTR/RTL, preserves paragraph direction across wrapping, and mirrors RTL sheet geometry without reversing glyphs |
| 2026-10-26 | minor | Arabic PDF export embeds licensed glyph outlines, joins letters and marks, preserves logical text and reports unsupported glyphs before writing; Arabic runs take the embedded faces ahead of the CJK CID font, and CJK inside Arabic text is set in the CID font instead of failing the export |
| 2026-10-26 | minor | Alignment readingOrder 0/1/2 survives cell, named-style and differential-style round-trips; Format Cells exposes reading direction and CF priority preserves unspecified inheritance |
| 2026-10-21 | minor | HTML (Save as Web Page) writes pictures (`data:` URI `<img>`) and charts (inline SVG from the chart crate's drawing primitives, text included) at their anchors; the table uses the sheet's column widths and row heights when the sheet has either, and output for sheets without pictures or charts is unchanged |
| 2026-10-20 | trivial | XLSX shared strings: Japanese phonetic runs (ふりがな, `<rPh sb="…" eb="…">` with `<phoneticPr>`) are read into the workbook and written back next to the string with the same text, so an open + save no longer deletes them; bad offsets and readings are dropped with a warning, a `<phoneticPr>` without runs is kept on its own, and when duplicate `<si>` items share a text but not a reading only the first reading is written (reported on open) (`phonetic_tests.rs`) |
+7 -1
View File
@@ -1,6 +1,6 @@
# Function parity: worksheet functions and formulas
> **Last reviewed:** 2026-10-31 · **Last updated:** 2026-11-03 · **Change:** minor (GROUPBY total depth 2 or more adds subtotals; earlier: Python cells are edited in the formula bar; earlier: the Python errors `#PYTHON!`, `#BUSY!`, `#TIMEOUT!` and `#BLOCKED!`, and a Python in cells row; earlier: YEARFRAC basis 0 February-end rule, MOD quotient limit, PERCENTRANK significance; earlier: edge cases matched to Excel: base conversions, BITLSHIFT/BITRSHIFT, UNICHAR noncharacters, UPPER/LOWER/PROPER casing, FIXED/DOLLAR output, F/T/GAMMA/WEIBULL/BETA distributions, BINOM trial cap, HARMEAN; earlier: ECMA.CEILING listed with USDOLLAR as not on Microsoft's list; earlier: IMSQRT reproduces the stray real part Excel gives for negative reals) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4
> **Last reviewed:** 2026-10-31 · **Last updated:** 2026-11-04 · **Change:** minor (GCD and LCM reject negative fractional arguments before truncation; earlier: GROUPBY total depth 2 or more adds subtotals; earlier: Python cells are edited in the formula bar; earlier: the Python errors `#PYTHON!`, `#BUSY!`, `#TIMEOUT!` and `#BLOCKED!`, and a Python in cells row; earlier: YEARFRAC basis 0 February-end rule, MOD quotient limit, PERCENTRANK significance; earlier: edge cases matched to Excel: base conversions, BITLSHIFT/BITRSHIFT, UNICHAR noncharacters, UPPER/LOWER/PROPER casing, FIXED/DOLLAR output, F/T/GAMMA/WEIBULL/BETA distributions, BINOM trial cap, HARMEAN; earlier: ECMA.CEILING listed with USDOLLAR as not on Microsoft's list; earlier: IMSQRT reproduces the stray real part Excel gives for negative reals) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4
Excel's worksheet functions, category by category, against GridCraft's function library. Part of
[target-app-parity.md](target-app-parity.md); gaps feed [gaps.md](gaps.md).
@@ -132,10 +132,16 @@ Work to close (16–26 h in total): the in-scope missing functions (10–16 h wi
an oracle corpus of Excel-computed results per function (owner runs Excel on generated
workbooks; results checked in as data, not Excel files) and fixing what it finds (6–10 h).
GCD and LCM validate the sign of the original argument before truncating it. Negative
fractions such as `-0.5` return `#NUM!`, including inside ranges and beside a zero argument.
Positive fractional inputs still truncate, and signed zero remains valid. Covered by
`gcd_and_lcm_reject_negative_fractions_before_truncation`; function counts and estimates are unchanged.
## Revision history
| Date | Change | Summary |
|---|---|---|
| 2026-11-04 | minor | GCD and LCM reject negative fractional arguments before truncation; scalar and range regressions in the extracted math tests preserve positive truncation and signed-zero behavior; estimates unchanged |
| 2026-11-03 | minor | GROUPBY: a total depth of 2 or more adds a subtotal line for each group of the leading key columns (after the group, or before it for a negative depth) and labels the last line Grand Total; a depth past the key columns, or above 1 with `field_relationship` 1, is `#VALUE!`, as in Excel (#1456 item 1) |
| 2026-11-01 | minor | Python in cells row: Python mode in the formula bar |
| 2026-11-01 | minor | Python in cells (stored, not run): `#PYTHON!`, `#BUSY!`, `#TIMEOUT!` and `#BLOCKED!` done, with their `ERROR.TYPE` numbers; `PY` still counted as missing |

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