diff --git a/Cargo.lock b/Cargo.lock index 59e5fec9bb..69ddc08af5 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1009,6 +1009,15 @@ dependencies = [ "ruzstd", ] +[[package]] +name = "craft-cdr" +version = "0.1.0" +source = "git+https://github.com/storytold/craft-libs?rev=9b28b56bc7207ef7ce806f37df72cb94c0ad5c37#9b28b56bc7207ef7ce806f37df72cb94c0ad5c37" +dependencies = [ + "crc32fast", + "flate2", +] + [[package]] name = "craft-cms" version = "0.1.0" @@ -6724,16 +6733,6 @@ dependencies = [ "vectorcraft-text", ] -[[package]] -name = "vectorcraft-cdr" -version = "0.24.1" -dependencies = [ - "crc32fast", - "flate2", - "proptest", - "vectorcraft-cdr", -] - [[package]] name = "vectorcraft-cli" version = "0.24.1" @@ -6818,6 +6817,7 @@ version = "0.24.1" dependencies = [ "cfb", "chrono", + "craft-cdr", "craft-docpath", "craft-image-codecs", "craft-jxl", @@ -6849,7 +6849,6 @@ dependencies = [ "vectorcraft-apischema", "vectorcraft-brush", "vectorcraft-cad", - "vectorcraft-cdr", "vectorcraft-color", "vectorcraft-doc", "vectorcraft-eps", @@ -7065,6 +7064,7 @@ dependencies = [ "vectorcraft-doc", "vectorcraft-geom 0.24.1", "wasmi", + "wasmparser 0.228.0", "wat", "web-time", ] diff --git a/Cargo.toml b/Cargo.toml index 0279fa081a..9c933c3549 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -27,6 +27,8 @@ craft-gzip = { git = "https://github.com/storytold/craft-libs", rev = "d7c9632bf # craft-update: app-specific pretend versions apply to startup and manual checks. # Native Affinity documents (craft-libs#914). craft-affinity = { git = "https://github.com/storytold/craft-libs", rev = "d7c9632bfb3040cf45db394e7500cc93c81c49e0" } +# Bounded CDR (v1-v27) and CMX (32-bit) reader (craft-libs#778). +craft-cdr = { git = "https://github.com/storytold/craft-libs", rev = "9b28b56bc7207ef7ce806f37df72cb94c0ad5c37" } # SVG parsing, limits, SVGZ and writer (craft-libs#778). craft-svg = { git = "https://github.com/storytold/craft-libs", rev = "d7c9632bfb3040cf45db394e7500cc93c81c49e0", features = ["tree"] } craft-mime = { git = "https://github.com/storytold/craft-libs", rev = "d7c9632bfb3040cf45db394e7500cc93c81c49e0" } @@ -78,7 +80,6 @@ vectorcraft-affinity = { path = "crates/affinity" } vectorcraft-scriptcheck = { path = "crates/scriptcheck" } vectorcraft-js = { path = "crates/js" } vectorcraft-apischema = { path = "crates/apischema" } -vectorcraft-cdr = { path = "crates/cdr" } # foundation kurbo = { version = "0.13", features = ["serde"] } @@ -97,6 +98,9 @@ socket2 = "0.6" # too. Without `wat` (text parsing is test-only) and memory64; `validate` keeps full module # validation on; the portable dispatcher can't overflow the host stack on long-running modules. wasmi = { version = "2.0.0", default-features = false, features = ["std", "validate", "stable", "portable-dispatch"] } +# The plug-in host's check of the WebAssembly features a module uses (Apache-2.0 WITH +# LLVM-exception). It is the version wasmi 2.0.0 uses. +wasmparser = { version = "0.228.0", default-features = false, features = ["std", "validate", "features"] } # Tests: WebAssembly text -> binary for the plug-in fixtures (Apache-2.0 WITH LLVM-exception). wat = "1.228" diff --git a/crates/cdr/Cargo.toml b/crates/cdr/Cargo.toml deleted file mode 100644 index ca2066c879..0000000000 --- a/crates/cdr/Cargo.toml +++ /dev/null @@ -1,22 +0,0 @@ -[package] -name = "vectorcraft-cdr" -description = "Bounded reader for .cdr drawings of versions 1 to 27 and .cmx files: WL records, RIFF index, compressed lists, ZIP packages, shapes, fills, outlines, pages and layers" -version.workspace = true -edition.workspace = true -license.workspace = true -rust-version.workspace = true - -[lints] -workspace = true - -[features] -# Synthetic-file builders for tests and fuzz seeds; not a .cdr writer. -synth = [] - -[dependencies] -crc32fast = { workspace = true } -flate2 = { workspace = true } - -[dev-dependencies] -proptest = { workspace = true } -vectorcraft-cdr = { path = ".", features = ["synth"] } diff --git a/crates/cdr/LICENSE-kaitai.txt b/crates/cdr/LICENSE-kaitai.txt deleted file mode 100644 index 296cf04d0e..0000000000 --- a/crates/cdr/LICENSE-kaitai.txt +++ /dev/null @@ -1,33 +0,0 @@ -The record layouts this crate reads are described in the Kaitai Struct -specification `coreldraw_cdr.ksy` -(https://github.com/kaitai-io/coreldraw_cdr.ksy, commit -9d8e2704b946961f5114115f1a488750a3c86ed0), which is published under the -license below. No part of that specification is copied into this crate; -`PROVENANCE.md` cites it by line. - -Some layouts are also taken from the fork of that specification by Zach Wolfe -(https://github.com/filestar/coreldraw_cdr.ksy, branch new_stuff, commit -2189b68f07e0cafe9afec3dcf699ebc0342144c7), which is published under the same -license and copyright notice. - -MIT License - -Copyright (c) 2020 Kaitai team - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. diff --git a/crates/cdr/PROVENANCE.md b/crates/cdr/PROVENANCE.md deleted file mode 100644 index b710c7d4b2..0000000000 --- a/crates/cdr/PROVENANCE.md +++ /dev/null @@ -1,127 +0,0 @@ -# Where each layout comes from - -The reader relies on the record layouts below. Code cites a row by its id (`R1` ...), and -`tests/it/provenance.rs` fails when a cited id has no row here. - -Sources: - -- **K**: the Kaitai Struct specification `coreldraw_cdr.ksy` (MIT, notice in `LICENSE-kaitai.txt`), - https://github.com/kaitai-io/coreldraw_cdr.ksy/blob/9d8e2704b946961f5114115f1a488750a3c86ed0/coreldraw_cdr.ksy -- **KF**: the fork of K by Zach Wolfe, `filestar/coreldraw_cdr.ksy`, branch `new_stuff`, under the same - MIT license and notice as K (`LICENSE-kaitai.txt`), - https://github.com/filestar/coreldraw_cdr.ksy/blob/2189b68f07e0cafe9afec3dcf699ebc0342144c7/coreldraw_cdr.ksy -- **KR**: the README and the `bin/cdr-unpk` script of the Kaitai Struct specification (MIT), at - the same commit as K, - https://github.com/kaitai-io/coreldraw_cdr.ksy/blob/9d8e2704b946961f5114115f1a488750a3c86ed0/README.md - and https://github.com/kaitai-io/coreldraw_cdr.ksy/blob/9d8e2704b946961f5114115f1a488750a3c86ed0/bin/cdr-unpk -- **Z**: the PKWARE ZIP specification, APPNOTE.TXT version 6.3.10, - https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT, and RFC 1951 (DEFLATE), - https://www.rfc-editor.org/rfc/rfc1951 -- **F**: the magic database of the `file` utility (BSD-2-Clause), - https://github.com/file/file/blob/b778217dbd35/magic/Magdir/images and - https://github.com/file/file/blob/b778217dbd35/magic/Magdir/riff -- **PR**: the PRONOM registry's signatures for versions 1.0, 2.0 and 4.0, - https://pronom.nationalarchives.gov.uk/fmt/467.xml, - https://pronom.nationalarchives.gov.uk/fmt/466.xml and - https://pronom.nationalarchives.gov.uk/fmt/465.xml -- **S**: own inspection of the bytes of public sample files, checked against the picture each file - carries of its drawing where it has one (versions 2 and 4 to 25; files of versions 1 and 3 carry - none). The files come from: - - **TP**: https://telparia.com/fileFormatSamples/image/cdr/, by file name - - **LT**: https://git.libreoffice.org/libcdr-test at commit - `dafe4fe53d685d89df20a5c0bb18f318ccefb4a8`, `testset//` - - **UC**: https://svn.code.sf.net/p/uniconvertor/code/formats/CDR/testing%20base/ at revision - 434, by file name - - **TDF**: attachments to The Document Foundation's bug tracker, - https://bugs.documentfoundation.org/attachment.cgi?id= - - **NR**: Natural Resources Canada's tactile maps, - https://ftp.maps.canada.ca/pub/nrcan_rncan/raster/tactile/approach-approch/cdr/banff_ap_en.cdr and - https://ftp.maps.canada.ca/pub/nrcan_rncan/raster/tactile/atlas-atlas/cdr/ab_en_br.cdr - - **DM**: the clip art of https://discmaster.textfiles.com/browse/31541, by file name - - **CX**: the `.cmx` files of https://telparia.com/fileFormatSamples/image/cmx/, by file name. The - nine with 32-bit coordinates are `balloon.cmx`, `bars.cmx`, `bluecros.cmx`, `bluedrop.cmx`, - `gold_bar.cmx`, `goldblue.cmx`, `PC.CMX`, `squares.cmx` and `thatch.cmx`; they carry no picture - of their drawing. -- **CN**: the `.cmx` notes of an MIT OR Apache-2.0 drawing program, which mark each layout - "confirmed" when the program's authors found it in sample files, - https://github.com/tracedraw/tracedraw/blob/2ac6d02e97773e040a51be6cfb27cc424e3deeaa/docs/cmx-format.md. - The same program's `.cmx` reader at that commit, - https://github.com/tracedraw/tracedraw/blob/2ac6d02e97773e040a51be6cfb27cc424e3deeaa/crates/cdr/src/cmx.rs, - was read for the order of fields that the notes do not spell out (the table entries, the rendering - attributes and the curve body); no code was copied from it - -Status: `public-spec` (K, KF, KR, Z, F or PR), `sample` (S), `public-notes` (a layout CN marks -confirmed that no CX file shows), `unconfirmed` (a point no source states and no sample file shows; -listed so it can be checked against a file, with what the reader does when it is wrong). - -Public specifications cover only parts of versions 1 to 4: the rows that cite K, F or PR, such as -the version 3 fill (R34) and page settings (R38). The other rows of those versions rest on the -sample files they name. -The test inputs are the synthetic files that `src/synth.rs` builds from the rows below; no sample -file is committed. - -| Id | What the code relies on | Source | Status | -|---|---|---|---| -| R1 | `RIFF`, the body length, then the form type `CDR` or `cdr` and a version character: `1` to `9`, `A` (10) to `H` (17), `J` (18) on, `I` unused; `cdr8` is 8.01 from the form type alone, whatever its `vrsn` chunk names, `CDR ` is 3, `CDRX` is another format. Files of versions 23 to 25 carry `O` (23), `P` (24), `Q` (24.3, with a `vrsn` of 2430) and `R` (25), which count differently from the version 24 update on, so their `vrsn` chunk decides (R2) | K L68-L133; S: LT `testset/23` to `testset/25`, such as `circle_redfill_nooutline_cdr25.cdr` | public-spec (letters from version 23: sample; letters of versions 26 and 27: unconfirmed, and the `vrsn` chunk decides when the file has one) | -| R2 | `vrsn`: the version as a u16, in hundreds | K L276-L278 | public-spec | -| R3 | `LIST cmpr`: two (compressed, uncompressed) u32 pairs, then two blocks of `CPng`, `01 00 04 00` and a zlib stream; the first inflates to the chunk stream, the second to a pool of u32 sizes that each chunk's size field indexes | K L193-L220, L2626-L2682 | public-spec | -| R4 | A chunk is an id, a u32 size and the body, padded to an even length; a `LIST` body starts with its form type; from version 7 a `LIST stlt` holds the style tables, not chunks | K L68-L78, L135-L155, L307-L334 | public-spec | -| R5 | Coordinates: i16 in 1/1000 inch before version 6, else i32 in 1/254000 inch; header fields, counts and offsets are u16 before version 6, else u32 | K L58-L66, L2688-L2700 | public-spec | -| R6 | `loda` and `lobj`: length, argument count, offsets table, types table, object type; count + 1 offsets bound the arguments; the types table runs in reverse; object types (1 rectangle, 2 ellipse, 3 curve, 0x14 polygon) and argument types (10 outline, 20 fill, 30 coordinates, 1000 name, 11000 polygon, 19130 page size) | K L335-L450, L846-L893 | public-spec | -| R7 | Angles: i16 tenths of a degree before version 6, else i32 millionths of a degree | K L2835-L2855 | public-spec | -| R8 | `trfd`: length, count, offsets table; each entry has 8 bytes first from version 13, a u16 type, and type 8 is a matrix after 6 bytes (from version 6) of six f64 `a c tx b d ty`, `tx` and `ty` in coordinate units; the matrices of one record apply in file order | K L895-L953, L2808-L2834 | public-spec | -| R9 | Name argument (1000): Windows-1252 up to a NUL before version 12, UTF-16LE from it | K L601-L630 | public-spec | -| R10 | `mcfg`: 12 bytes (13 on), 4 (9 to 12), 28 (6) or none, then the page width and height as coordinates | K L1670-L1765 | public-spec | -| R11 | `fild` (`fill` before 7): id; from 13 a record tagged 1300 with its length, which records tagged 2400 or more may precede; the fill type u16 (0 none, 1 uniform, others not read); uniform: 2 bytes then a color before 13, from 13 a record tagged 1300 holding a property list (u8 type, u32 length, body; 0 ends it; 1 a color, 8 a palette id and a UTF-16 name, 3 a UTF-16 name) | K L1025-L1302; S: LT `testset/15` to `testset/25` `circle_redfill_nooutline_cdr.cdr`, whose fill records hold a record tagged 2400 before the one tagged 1300 | public-spec (2400 records: sample) | -| R12 | `outl`: id; from 13 records (u32 id, u32 length, body) up to id 1, whose body follows; a record of id 2 holds a property list laid out as R11's, and the reader takes the outline's color from it when it names a library color; line type, caps and join u16; 2 bytes (6 to 12); width; stretch u16; 2 bytes (6 on); nib angle; 52 bytes (6 to 12) or 46 (13 on); the color; 16 bytes (10 before 6); the dash count u16 and the dashes, in multiples of the width; the arrowhead ids 22 bytes after the first dash in versions 6 to 12, 20 bytes from 13. Caps 0 butt, 1 round, 2 square; joins 0 miter, 1 round, 2 bevel | K L954-L1024; KF L1225-L1249 (the id 2 record); S: caps and joins in UC `outl_line_caps_cdr7.cdr` and `outl_corner_cdr7.cdr`; arrowhead ids, matched against the drawing's `arrw` records, in TP `web_cd.cdr` (6), UC `rogan_logo_cdr7.cdr`, `rogan_logo_cdr8.cdr` and `rogan_logo_cdr11.cdr`, NR `ab_en_br.cdr` (9) and `banff_ap_en.cdr` (10), TDF 76820 (12) and 140638 (13) | public-spec (caps, joins and arrowhead places: sample; arrowheads before version 6: no sample names one, and the reader does not look for them; the id 2 record: no sample names a library color in it, and a wrong guess changes only the outline's color) | -| R13 | Bit 0 of the outline's line type: no outline | S: LT `square_blackfill_nooutline_cdr.cdr` and the other `nooutline` files of `testset/15` to `testset/25`, whose outline records all have line type 1 and whose pictures show no outline | sample | -| R14 | A color record from version 5: model u16, palette u16, 4 bytes, four value bytes. Models: 2 CMYK in percent, 3 and 17 CMYK 0 to 255, 4 CMY 0 to 255, 5 blue, green, red, 9 gray 0 to 255, 20 registration, 21 blue, green, red and a tint in percent already applied; 1, 14 and 25 a library color's number (u16) and tint in percent (u16) | K L2856-L2965; S: model 25 in LT `testset/12/square_pantoneblackfill_nooutline.cdr` (number 14, tint 100), model 1 in UC `rogan_logo_cdr11.cdr` (number 4, tint 50) | public-spec (library values of models 1 and 25: sample; model 14: unconfirmed, and its color opens as a spot color without a look) | -| R15 | Rectangle coordinates: width, height and one radius, three more radii from version 9, running counterclockwise from the corner at (width, 0) | K L674-L700 | public-spec | -| R16 | Point list: u32 count (before version 6 as R39 gives it), the points, then one type byte each, the count held to what fits; type bits 7 and 6 move, line, curve end, control point; bit 3 closes the subpath | K L782-L787, L840-L845, L2701-L2807 | public-spec | -| R17 | Ellipse coordinates: width, height, start and end angles, pie flag (u16 before 6, else u32); the radii are half the width and height; the angles turn from the ellipse's own axes, which a negative width or height points the other way | K L754-L781; S: the pies of negative height in the ellipse-sector drawings of versions 12 and 13 in UC | public-spec (axis direction of a negative size: sample) | -| R18 | Polygon argument (11000): 4 bytes before 13, the side count u32, the next point u32 (the u32 after it when it is 0 or 1, else 4 bytes), 4 more from 13, rx and ry f64, the centre; the base curve is one side on a circle of 1000 mm from the top vertex to the vertex it runs to clockwise, copied once for each side | K L631-L655; S: the polygons and stars of UC `shapes_cdr10.cdr` | public-spec (base curve: sample) | -| R19 | `flgs`: byte 3 the record type, byte 2 marks the master page. On a layer, group or object, bit 0x01 of byte 1 hides it and bit 0x10 of byte 0 locks it. A layer's own `loda` names what it is by its object type: 11 a grid, 12 guides, 17 the desktop, any other a drawing layer (version 3 one less, R32). Only a layer without a `loda` is taken by the low four bits of its byte 0: 0x0a guides, or a grid when bit 0x10 is also set; in versions 7 to 13 0x02 the same way; 0x08 the desktop when byte 2 is set and a drawing layer when it is clear; any other a drawing layer, except [0, 1, 1] in versions 7 to 13, the desktop | K L1602-L1639 (record types); KF L1831-L1866 (the hidden and lock bits); S: every grid layer of versions 14 to 25 in the sample files (631) carries byte 1 = 1, and 206 of the 927 of versions 7 to 13 do; desktop layers carry byte 1 = 0 except TDF 114901's [0, 1, 1]; the drawing layers with byte 1 = 1 (TDF 114901, NR `banff_ap_en.cdr` and `symbology_en.cdr`) also carry bit 0x08; of the group and object lists in the sample files, only one object of TDF 60491 (version 14) sets either bit, the lock bit; in every sample file of versions 3 to 25 the layer's object type agrees with its name; byte 0 does not: TDF 114901 (version 8) flags its master page's guides [2, 1, 1], desktop [0, 1, 1], grid [0x12, 0, 1] and drawing layer [8, 1, 0], and NR `ab_en_br.cdr` (version 9) flags drawing layers 0x10 and its guides 0x1a; over the sample files of versions 3 to 25, drawing layers carry 0, 0x10, 0x40, or 0x08, 0x18 or 0x58 with byte 2 clear, desktop layers 0x08, 0x18 or 0x48 with byte 2 set, guides 0x0a, 0x4a, 0x02 or (in `ab_en_br.cdr`) 0x1a, and grids 0x1a, 0x5a or 0x12 | public-spec (layer types: sample; byte 0 of a layer without a `loda`: unconfirmed, as no sample has such a layer, and a wrong guess drops or shows that layer's objects; bit 0x10 is also the lock bit, so a locked guides layer without a `loda` reads as a grid) | -| R20 | Fill and outline arguments (20, 10): a u32 record id | K L452-L460, L548-L556 | public-spec | -| R21 | Page size argument (19130): width and height | K L666-L672 | public-spec | -| R22 | `LIST page` holds `LIST layr` lists, directly or in a list it holds (a `LIST gobj` in the samples); a layer holds `LIST obj ` and `LIST grp `; a page, layer or object keeps its own `loda` (and an object its `trfd`, in a `trfl` list) among its chunks or in a `LIST lgob` | K L1602-L1639 (record types); S: the chunk trees of every sample file of versions 3 to 25 | sample | -| R23 | Guideline (object type 0x16), argument 16000: 12 bytes, the angle in millionths of a degree, then points from the page centre; version 7 keeps them in a `guid` chunk: a u32 count, the count again, 40-byte records laid out the same way | S: argument 16000 in NR `ab_en_br.cdr` (9) and TDF 194220 (13); the `guid` chunk of TDF 123971 (7). Pictures do not show guidelines | sample | -| R24 | ZIP: the end of central directory record (signature `PK\5\6`, 22 bytes and a comment of up to 65,535 bytes) gives the member count and where the central directory lies; each central directory entry (46 bytes, then name, extra field and comment) gives the flags, method, CRC-32, sizes and its local header; a local header is 30 bytes, then its name and extra field, then the member's bytes. Flag bit 0 marks an encrypted member; method 0 is stored and 8 deflated; 0xFFFF and 0xFFFFFFFF mark ZIP64 fields, and a ZIP64 locator (`PK\6\7`, 20 bytes) precedes the end record of a ZIP64 archive; disk numbers other than 0 mark an archive split across files | Z 4.3.7, 4.3.12, 4.3.15, 4.3.16, 4.4.1.4, 4.4.4, 4.4.5, 4.4.7, 4.4.8, 4.4.13 | public-spec | -| R25 | Versions 14 and 15 save a ZIP package whose member `content/riffData.cdr` is the RIFF file | KR README L33, `cdr-unpk` L30 | public-spec | -| R26 | From version 16 the package's member `content/root.dat` is the RIFF file; `content/dataFileList.dat` names the data streams, one per line, members of `content/data/`; a redirect's stream number counts lines from 0 | KR README L34, L40, `cdr-unpk` L34-L66; K L173-L180 | public-spec | -| R27 | In a package of version 16 on, a chunk outside a compressed list whose size is 16 (in `root.dat` or in a redirected list's body) is a redirect record: stream u32, length u32, offset u32 and a reserved u32; its body is `length` bytes at `offset` of the stream; stream `0xFFFFFFFF` holds the body (at most 8 bytes) in the record after the length; a redirected list's body starts with its form type | K L144-L193 | public-spec | -| R28 | Templates have the form type `CDT` and a letter of their own; the `vrsn` chunk names the version. The reader takes any letter `A` to `Z` there | none: no sample template | unconfirmed (a template is read as a drawing of the version its `vrsn` chunk names, and one without that chunk is refused) | -| R29 | Rectangle coordinates from version 15: width and height as f64 coordinate units, scale x and y (f64, repeating the transform's scale), the scale-with flag (u8) and 7 bytes, then the four radii as f64, 16 bytes apart (a corner type byte and 15 bytes after the first), in the order of R15. With the flag clear each radius is a share of half the shorter side; with it set the radii are multiplied by 254000 coordinate units, which makes them inches | K L674-L752; S: LT `square_blackfill_nooutline_roundedcorners_cdr.cdr` of `testset/15` to `testset/25` (flag clear, a share of 0.25) | public-spec (radius share with the flag clear: sample; that the scale is not applied: unconfirmed, as every sample has a scale of 1, and a wrong guess changes only the corners' size) | -| R30 | Object type 0x25 (version 10 on) is a path: 4 bytes, two u16 counts that add up to the point count, 16 bytes, then the points and their type bytes as in R16 | K L788-L799, L892; S: TDF 78250 (version 15) and UC `shapes_cdr10.cdr`, `shapes_cdr11.cdr`, `shapes_cdr12.cdr` and `shapes_x3.cdr` (versions 10 to 13), whose type bytes start where the counts put them; no sample before version 10 holds the type | public-spec (from version 10: sample) | -| R31 | Version 3 is a RIFF file with the form type `CDR ` (a space) and a `vrsn` of 300; version 4 has the form type `CDR4` and a `vrsn` chunk. Both use the 16-bit fields of R5 and R7. Their pages, layers, groups and objects are read by the rules of R19 and R22 | K L117-L134; PR fmt/465; F `riff` L786; S: TP `FOX.CDR` and `DALI.CDR` (3), DM `lion1.cdr` and `tiger.cdr` (4) | public-spec (pages and layers as R19 and R22: sample) | -| R32 | Version 3 counts its object types from 0: rectangle 0, ellipse 1, curve 2, text 3, bitmap 4; later versions use these plus one | S: the rectangles, curves and text of TP `ARMYSTF1.CDR`, `DALI.CDR` and `FOX.CDR`, which come out whole | sample (ellipse 1 and bitmap 4: unconfirmed, as no sample holds them; a bitmap is left out with a warning) | -| R33 | Version 3 keeps an object's transforms in argument 100 of its `lobj`: a u16, the entry count (u16), then 10-byte entries of a type (u16) and, at byte 6, where the entry's data starts, counted from the start of the argument. Type 0x8c is a matrix as R37, and the matrices apply in file order. Type 0x14 is an envelope, which this reader does not apply: the shape keeps its outline, placed by the matrices alone, and the drawing's warnings name the envelopes. A group's own `lobj` holds an argument 100 that places all of the group's objects after their own transforms | K L851; S: the matrices of every version 3 file in TP, whose drawings come out whole | sample (envelope type 0x14: unconfirmed, as no sample holds one; it is not applied, with a warning) | -| R34 | Version 3 fill, argument 20: a type byte (0 none, 1 uniform, 2 and 4 fountain, 6 texture, 7 and 10 pattern); a uniform fill's color follows as R36 | K L452-L547 | public-spec | -| R35 | Version 3 outline, argument 10: a flags byte with bit 0 set when the object is outlined, the width (coordinate), the stretch (u16), the nib angle, the color as R36, 7 bytes, the dash count (u8) and 10 bytes that hold the dashes as one byte each, the join (u16 at byte 30) and the caps (u16 at byte 32) numbered as R12, then the two arrowhead ids (u32). Dashes are read in multiples of the width as R12 | K L548-L592; S: the outlines of the version 3 files in TP | public-spec (flag bit: sample; dash unit, and the join, where bytes 32 and 33 of some samples hold 2 and 2: unconfirmed, and a wrong guess changes only how corners, ends and dashes are drawn) | -| R36 | A color before version 5: in versions 1 to 3 a model byte and four value bytes, in version 4 a model u16, four u16 values and 2 bytes. Model 1 is cyan, magenta, yellow and black in percent. Model 0 is an ink number (u16) and a tint in percent (u16): ink 0 is black at the tint, ink 1 is white, and other numbers are inks of a numbered library that the file does not store. Other models are read as R14 | K L2882-L2908; S: model 1 in TP `ARMYSTF1.CDR` (3) and DM `lion1.cdr` (4), model 0 in TP `ARROW5.CDR` (3) and `WI.CDR` (1) | sample (ink 1, and models other than 0 and 1: unconfirmed; an ink of another number opens as a spot color without a look) | -| R37 | A matrix of versions 3 and 4: six i32 `a c tx b d ty`, the four factors in 16.16 fixed point and `tx` and `ty` in coordinate units. A version 4 `trfd` entry of type 8 holds one where R8 has six f64 | S: TP `FOX.CDR` and `DALI.CDR` (3), DM `lion1.cdr` and `tiger.cdr` (4) | sample | -| R38 | `mcfg` of version 3: 2 bytes, then the page's two corners as four coordinates; the page size is the distance between them | K L1676-L1678, L1745-L1756 | public-spec | -| R39 | A point list before version 6 starts with a u16 count and another u16 (1 in some curves of versions 1, 2 and 4, 0 in the others), where K reads the two as one u32 | S: TP `DALI.CDR` (3), DM `headup.cdr` and `lion1.cdr` (4), TP `WI.CDR` (1), `FLAG.CDR` and `MENU.CDR` (2) | sample | -| R40 | Versions 1 and 2 are not RIFF files. A file starts with `WL`, a marker byte, a zero byte and five u32: the start of the settings, the start and the end of the object records, the start of the trailer and that value minus two. Version 1 has the marker `e` and its settings start at byte 28. Version 2 has the marker `m` or `l`, and its settings start after a 1-bit picture of the drawing, whose header starts where the u32 at byte 28 says. The reader takes these three markers | F `images` L4159-L4172; PR fmt/467, fmt/466; S: TP `WI.CDR` (`e`), `FLAG.CDR` (`m`), `MENU.CDR` and `DRINKS.CDR` (`l`) | public-spec (markers `e` and `m`: F and PR; the offsets and the marker `l`: sample) | -| R41 | The page's box in a file of version 1 or 2: four i16 two bytes after the start of the settings (left, top, right, bottom) in 1/1000 inch around the page's centre, y pointing up | S: TP `WI.CDR`, `FLAG.CDR` and `MENU.CDR` | sample | -| R42 | The records of a file of version 1 or 2 run from the front of the stacking order to the back. Every record starts with the u32 24. A group or layer record is 28 bytes, and bit 0x40 of its flags byte at 26 is clear. A drawn object has that bit set (0x40 in files with the markers `e` and `m`, 0xc0 with `l`) and a u16 body size at byte 28; it is the body size plus 32 bytes long. A drawn object of another type than those of R43 gives its length otherwise, and the records after it are not read | S: TP `WI.CDR`, `FLAG.CDR`, `MENU.CDR` and `DRINKS.CDR`; the order checked against the picture of `MENU.CDR` | sample | -| R43 | A drawn object of version 1 or 2: a point (two i16) at byte 32; six i32 in 16.16 fixed point at 36, `a b tx c d ty`, with x' = a x + b y + tx + the point's x and y' = c x + d y + ty + the point's y; the object type at 60 (0 rectangle, 1 ellipse, 2 curve, 3 text); a byte at 67 that is not 0 when the object is outlined, the outline's width (u16) at 68 and its color at 74; the fill type (0 none, 1 uniform) and its color after it, at 94 and 95 with the marker `e` and at 105 and 106 with `l` and `m`; the shape from byte 114 with `e` and 136 with `l` and `m`. Colors are as R36 | S: TP `WI.CDR` (`e`), `FLAG.CDR` (`m`) and `MENU.CDR` (`l`), checked against the pictures of `FLAG.CDR` and `MENU.CDR` | sample | -| R44 | Shapes of version 1 or 2: a rectangle's width and height (i16), then a corner radius; an ellipse's width and height, then two angles; a curve's point list as R39 and R16 | S: rectangles in TP `FLAG.CDR`, ellipses and curves in TP `WI.CDR`, curves in TP `MENU.CDR` | sample (the radius of files with the marker `e`, which no sample shows, and how the angles make an arc: unconfirmed; a radius is kept only when it is at most half the shorter side, and an ellipse whose angles differ is left out with a warning) | -| R45 | `LIST stlt` from version 7: a u32 style count, and when it is not 0: the fill table (a u32 count, entries of a table id, 4 bytes and a `fild` id, 12 bytes each, 60 from version 13), the outline table (12-byte entries laid out the same way, naming `outl` ids), the text tables (fonts of 44 bytes, 60 from version 10; alignments of 12; spacings of 52; tables of 152 and 784; bullets whose length a u32 inside them sets; indents of 28; hyphenation of 32, 36 from 13; drop caps of 28; from 8.01 a table of 12), then the styles: kind (u32), id, parent id, 8 bytes, name length and name (bytes before 12, UTF-16 units from it), the fill and outline table ids, then 16 bytes (20 from 8.01) for kinds above 1 and 20 more for kinds above 2. An object names its style in argument 200 (u16 before version 6, u32 from it). An object without argument 20 or 10 takes the fill or outline of its style; a style whose table id is 0 takes its parent's | K L593-L600, L852, L1926-L2198; S: UC `outl_width_cdr7.cdr`, one of whose lines carries argument 200 and neither 10 nor 20 and names the style whose outline is black and 0.003 inch wide and whose fill is none, as the file's picture shows; the table parses exactly to the end of the list in each of the 498 sample files of versions 7 to 15 that has one, and every object with argument 200 in them names a style whose table ids are in the tables; argument 200 is 2 bytes on all 844 objects of versions 4 and 5 in the sample files that carry it, and 4 bytes on all 18 of version 6 | public-spec (what the table ids name, and that an object takes its style's fill and outline: sample; a style taking its parent's entry: unconfirmed, as only text styles in the samples leave theirs to the parent, and a wrong guess draws a shape without that fill or outline) | -| R46 | A clipping container carries argument 8005; its first u32 is the id that the `spnd` chunk (a u32, a u16 before version 6) of one `LIST grp ` in the document's `LIST clpt` holds. That group's objects are the ones the container clips; they keep their own transforms, in page space like the container's | K L252, L860-L862, L1895-L1901 (the argument and the chunk); S: LT `powerclipsquare_blackfill_whiterectangleinside` of `testset/12` to `testset/25` and eight UC files of versions 7 to 13, in each of which the id in argument 8005 matches one group's `spnd`; in the UC file of version 7 the group's box, -1.96 to 1.97 inches across, overlaps the container's, -1.81 to 1.84 inches, and the file's picture shows the group cut to the container | public-spec (what the id names, and the space of the group's objects: sample) | -| R47 | Argument 8000 marks an object seen through: a lens or a transparency. From version 13 it holds records of a u32 version, a u32 length and a body; a body of version 1300 that is 117 bytes long holds an f64 at byte 61 and a merge mode byte at byte 77, which the reader applies as a uniform transparency. VectorCraft reads the f64 as the transparency in percent (0 opaque, 100 clear) and maps the merge modes 0 normal, 9 multiply, 11 lighten, 12 darken, 14 color, 15 hue, 16 saturation, 17 luminosity, 24 difference, 28 screen, 29 overlay, 30 soft light, 31 hard light, 33 color dodge, 34 color burn and 36 exclusion to its blend modes. Other merge modes, other records (a lens record of version 13 is 84 bytes) and the argument before version 13 are not applied, and the reader names them with lenses in the warnings | K L859 (the argument); KF L707-L798 (the records, the 117-byte body and the merge modes); S: the version 1300 record of LT `square_blackfill_nooutline_transparency50percent` of `testset/15` to `testset/25` is 117 bytes long, with 50.0 at byte 61 and 0 at byte 77; the lens records of UC `corel_lens_test_x3.cdr` (13) are 84 bytes long; of the sample files of versions 7 to 25, the argument is on the see-through objects that the pictures of LT `square_blackfill_nooutline_transparency50percent` of `testset/12` to `testset/25`, TDF 80103 and eight UC lens test files of versions 7 to 13 show, and otherwise only on text in UC `fancytext_cdr7.cdr` to `fancytext_x3.cdr` and on two objects of TDF 114901. The value K reads at byte 10 (14 from version 13) is not the transparency in these samples | public-spec (the argument: K; what it marks: sample; the direction of the value: VectorCraft's own reading, as every sample is at 50%, and a wrong reading shows a 25% transparency at 75%; the layout before version 13: unconfirmed, and it is not read) | -| R48 | Bit 2 (0x04) of the outline's line type marks the outline dashed; the dashes of an outline without it are not drawn | S: every outline of versions 6 to 25 in the sample files with that bit set (316 of them, in 29 files) stores dashes; TDF 76771 (version 15) stores dashes 2 and 1 in an outline of line type 0x22, and the file's picture draws that outline solid | sample | -| R49 | Bit 4 (0x10) of the outline's line type puts the outline behind the fill | S: UC `outl_behind_fill_cdr7.cdr` to `outl_behind_fill_x3.cdr`, whose outline of line type 0x12 the file's picture shows behind the fill, and whose other outlines (0x02) it shows over the fill | sample | -| R50 | Bit 5 (0x20) of the outline's line type scales the outline's width and dashes with the shape's matrix. The engine multiplies them by the square root of the matrix's area factor (VectorCraft's own value for a matrix that scales x and y differently) | S: UC `outl_scale_with_cdr7.cdr` to `outl_scale_with_cdr12.cdr`, of whose outlines only one, 3.969 mm wide, has line type 0x22 and the others 0x02 or 0x01; TDF 76771 (version 15), whose outline of line type 0x22 is 10 mm wide on a shape that the matrix stretches and skews, and whose picture draws that outline several times wider and skewed | sample (the bit; the single width for a matrix that scales x and y differently: VectorCraft's own) | -| R51 | A `trfd` offsets table holds one offset more than the entries; each entry runs from its offset to the next, and the last offset is the record's end | KF L1079, L1113-L1121; S: every `trfd` of versions 4 to 25 in the sample files (25,425 records) has the extra offset, equal to the record's length | public-spec | -| R52 | Byte 0 of argument 14001 is the fill's winding flag. VectorCraft reads a byte other than 0 as the nonzero fill rule, and 0 or an object without the argument as even-odd | KF L575-L583, L1047; S: the argument is 4 bytes in the sample files that carry it, with byte 0 = 1 on LT `complexshape_blackfill_nooutline` of `testset/12` and `testset/15` to `testset/25` and on objects of TDF 127576 (13) and 60026 (14), and 0 on 27 objects of TP `example.cdr` (17) | public-spec (the flag: KF; which rule each value means, and the rule without the argument: VectorCraft's own reading, and a wrong reading fills or leaves holes where a curve's subpaths overlap) | -| R53 | A `.cmx` file is a RIFF form of type `CMX1`, little-endian (a `RIFX` form is big-endian and is refused); its chunks are laid out as R4. A chunk can run short of its contents: when the bytes after it don't read as a chunk id (an ASCII letter, then three ASCII letters, digits or spaces), the next id is the first at an even distance of 2 to 64 bytes that names a chunk the reader uses or whose length keeps it inside its list (VectorCraft's own rule) | CN "Container"; S: all 14 CX files are `RIFF` forms of type `CMX1`; in `balloon.cmx`, `bars.cmx`, `bluecros.cmx`, `bluedrop.cmx`, `gold_bar.cmx`, `goldblue.cmx`, `squares.cmx` and `thatch.cmx` 16 bytes follow `ccmm` and 4 follow `rlst` before the next id | sample | -| R54 | `cont`: byte 52 is the coordinate size as an ASCII digit, `4` for 32-bit coordinates and `2` for 16-bit ones (refused); bytes 64 to 72 hold an f64, the size of a coordinate unit in meters. A value that isn't above 0 and at most 1 reads as 0.1 µm (VectorCraft's own fallback) | CN "Container"; S: the nine CX files with `4` all hold 1e-7; `abydos.cmx`, `CM33.CMX`, `LIZARDS.CMX`, `output.000.cmx` and `test.cmx` hold `2` | sample | -| R55 | A table (`rclr`, `rpen`, `rott`, `rdot`, `rotl`) is a u16 entry count, then one field list per entry; an instruction's body is field lists too. A field is a u8 tag, a u16 length counting its 3 header bytes, and the data; 0xff ends the list. Objects name table entries from 1 | CN "Tables"; S: every one of these tables in the nine CX files with 32-bit coordinates reads its count of entries with no bytes left | sample | -| R56 | A color entry: a property list in field 10 (a u32 length, then parts laid out as R11's, the color in part 1 as R14), or in older files the model and palette bytes in field 1 and the values in field 2. Models of the older fields: 2 cyan, magenta, yellow and black in percent; 3 the same in 0 to 255; 4 cyan, magenta and yellow in 0 to 255; 5 red, green and blue in 0 to 255; 9 gray in 0 to 255, 255 white. Other models read as black with a warning | CN "Tables" (`rclr`); S: every color of the nine CX files is model 2 in the older fields | sample (model 2), public-notes (field 10), unconfirmed (models 3 and 5 of the older fields, read as the program of CN reads them, and models 4 and 9, read as R14's; a wrong reading gives a wrong color) | -| R57 | `rpen` field 1: the width as a u32 in coordinate units (then an aspect, an angle and a matrix, not read). `rott` field 1: a flags byte (1 no outline, 2 solid, 4 dashed, 8 behind the fill, 16 scaled with the object), then the caps in the low 4 bits and the join in the high 4 bits, numbered as R12. `rdot` field 1: a u16 count, then the dash and gap lengths in outline widths (u16 each). A pattern whose lengths are all 0 draws a solid line, as R48's | CN "Tables"; S: line types 0x02 and 0x22 with caps and joins 0x00, 0x01 and 0x11 in the CX files | public-notes (the flags 4, 8 and 16 and the cap and join numbering; bit 0x20, set in `balloon.cmx`, is not read) | -| R58 | `rotl` field 1: six u16, the 1-based entries of the outline's line type, screen, color, arrowhead pair, pen and dash pattern | CN "Tables"; S: every `rotl` entry of the CX files names entries that exist | sample | -| R59 | `rota`: a u16 count, then pairs of u16 (start and end arrowheads, 0 for none), not field lists | CN "Tables"; S: `rota` is `01 00 00 00 00 00` in every CX file | sample (pairs of 0), public-notes (other values) | -| R60 | A `page` chunk is a stream of instructions: a u16 size counting the whole instruction and an i16 code, or 0xFFFF, a u32 size and the code (the long form); then field lists. Codes: 9 and 10 begin and end a page, 11 and 12 a layer, 13 and 14 a group, 67 a curve; 20 and 21 a text object, 65 its drawn characters, 66 an ellipse, 68 a rectangle, 69 an image, 88 and 89 add and remove a clipping path, 111 a jump whose field 1 is the u32 file offset to go on from (the bytes jumped over hold images). Objects are drawn in file order, the first at the back | CN "page: instructions"; S: codes 9 to 14 and 67 in the CX files; in `squares.cmx` the large square comes first and the two smaller ones inside it after | sample (9 to 14, 67, the order), public-notes (the long form and the other codes) | -| R61 | Field 4 of instruction 9: the page's width and height, u32 each in coordinate units. Without it, field 1 gives the drawing's bounds: a u16 page number, a u32, then the left, top, right and bottom edges as i32 in coordinate units; the page takes the bounds' size and is centered on them (VectorCraft's own choice). Without either, the page has no size, and the importer gives it 612 × 792 pt as it does a `.cdr` page without one (VectorCraft's own size) | CN "page: instructions"; S: none of the CX files has field 4; in all nine with 32-bit coordinates, the four edges in field 1 match the extent of the file's curves | public-notes (field 4), sample (field 1) | -| R62 | A layer's name: field 4 as a u32 count and UTF-16 units, or field 1 from byte 12 as a u16 count and 8-bit characters (read as Windows-1252, VectorCraft's own choice); a layer without a name is left unnamed, as a `.cdr` layer is. A curve: field 1 its rendering attributes, field 2 a u16 point count, the points as i32 x and y, then a type byte for each as R16; coordinates are from the page's center, y up. A field 2 too short for its count is read as whole points with their type bytes when its length is a multiple of 9, and the curve is left out as damaged otherwise (VectorCraft's own rule) | CN "page: instructions" and "Coordinates"; S: the 8-bit names `Layer 1`, `Desktop`, `Grid` and `Guides` of the CX files (the last three hold nothing in every file); every curve of the CX files has field 2 of exactly 2 + 9 bytes per point | sample (8-bit names, curves), public-notes (field 4) | -| R63 | Rendering attributes: a mask (1 fill, 2 outline, 4 lens, 8 canvas, 16 container; lenses, canvases and containers are not read, with a warning), then a field list for the fill when the mask names it and one for the outline. The fill's field 1 is a u16 type and a field list; type 0 is no fill, type 1 a uniform fill whose field 1 is the color entry (u16) and a screen (u16); other types (2 fountain and more) are not read. The outline's field 1 is its `rotl` entry (u16) | CN "Rendering attributes"; S: masks 1, 2 and 3, fill types 1, 2 and 6, and uniform fills with a 4-byte field 1 in the CX files | sample | diff --git a/crates/cdr/README.md b/crates/cdr/README.md deleted file mode 100644 index 007258e931..0000000000 --- a/crates/cdr/README.md +++ /dev/null @@ -1,98 +0,0 @@ -# vectorcraft-cdr - -A bounded Rust reader for `.cdr` drawings of versions 1 to 27 (and `.cdt` templates). -It reads the `WL` files of versions 1 and 2, the RIFF chunk tree of versions 3 and later with its -compressed lists, the ZIP packages that versions 14 and later save (with the data streams of -versions 16 and later) and the records listed below, and hands the engine a drawing in points, -with each object's transform. It does not write `.cdr` files. - -## What is read - -| In the `.cdr` file | Read as | -|---|---| -| ZIP packages: `content/riffData.cdr` (versions 14 and 15), `content/root.dat` with the data streams `content/dataFileList.dat` names (16 on) | the RIFF chunk tree; a data stream is inflated only when a chunk the reader reads, or a list it splits, points into it | -| Pages, the page size in `mcfg` or a page's own size | pages, laid out by the engine as artboards side by side | -| Layers (drawing, desktop, guides and grid layers), the master page's among them | layers by name and kind | -| The hidden and locked flags of layers, groups and objects | flags | -| Guidelines (object type 0x16, and the version 7 `guid` chunk) | guidelines at their point and angle | -| Groups (`LIST grp `) | groups | -| Clipping containers and the groups of `LIST clpt` they clip | the container with the objects it clips | -| Curves (point lists of moves, lines and cubic curves) and paths (object type 0x25, version 10 on) | paths | -| Rectangles (one corner radius, four from version 9) | rectangles with each corner's radius | -| Ellipses, arcs and pies | ellipses, and paths for arcs and pies | -| Polygons and stars (a base side copied for each side) | paths | -| Uniform fills: CMYK, CMY, RGB, gray, registration, library colors | colors, spot colors with their tints | -| The fill's winding flag | the nonzero fill rule, or even-odd | -| Outlines: width, caps, joins, dashes, the no-outline and behind-the-fill flags, and from version 13 a library color named in their property list | outlines | -| Uniform transparency (version 13 on) and its merge mode | the shape's opacity and blend mode | -| Styles (`LIST stlt`, versions 7 to 15) that objects name | the fill and outline of an object that has none of its own | - -Text, bitmaps, linked groups (blends, contours, brush strokes), B-spline curves, fountain, -pattern, texture and PostScript fills, outline arrowheads, lenses, transparency other than uniform -transparency of version 13 and later, and merge modes without a VectorCraft blend mode are not -read; the drawing's -`warnings` name each kind it held. Drawings of versions after 27 are refused, and so are packages -that are encrypted, ZIP64 archives or split across files. - -VectorCraft reads a uniform transparency's stored value as the transparency in percent (0 opaque, -100 clear), and a winding flag other than 0 as the nonzero fill rule. These are VectorCraft's own -readings: no public source states either direction. - -## Versions 1 to 4 - -Public specifications cover only parts of these versions, such as the version 3 fill and page -settings. For the rest, the reader follows the layouts of public sample files that -`PROVENANCE.md` lists (rows R31 to R44), and its tests read the synthetic files that -`src/synth.rs` builds from those rows. - -| Version | Read | Left out or refused | -|---|---|---| -| 1 and 2 (`WL` files) | the page size; rectangles with one corner radius, whole ellipses and curves, each with its matrix; uniform fills and outlines with their width and color, in CMYK percent and the inks black and white. The objects come in on one page and one layer, front to back | text and objects of other types, and ellipses whose two angles differ (arcs and pies), with the unsupported-objects warning; fills of other types, with the unsupported-fills warning; inks of a numbered library, which read as spot colors without a look; groups and layers, whose records are passed over; dashes, caps, joins and arrowheads, which the reader does not look for; the records after a drawn object of another type, with the unsupported-objects warning | -| 3 (RIFF, form type `CDR `) | the page size from the page's corners; pages, layers and groups; rectangles, ellipses, arcs and curves with the matrices of the object and of the groups around it; uniform fills; outlines with their width, color, caps, joins and dashes | text and bitmaps; envelopes, with the envelopes warning (the objects and groups under one keep their outlines and matrices); fountain, pattern and texture fills; arrowheads | -| 4 (RIFF, form type `CDR4`) | as version 5, with the colors and the fixed-point transforms of version 4 | as version 5 | - -A file is taken for version 1 or 2 by its content only when, after `WL`, its marker byte is one of -`e`, `l` and `m`, the next byte is zero, and the offsets of its header fit the file. The reader -reports version 1 for the marker `e` and version 2 for the other two. A RIFF file that names -a version before 3 is refused, and so is the version 4 template form type `CDST`, which reads as -not a `.cdr` drawing. - -## `.cmx` files - -`read_cmx` reads `.cmx` exchange files with 32-bit coordinates (rows R53 to R63) into the same -drawing model, with a version of 0. It reads the color, pen, line type, dash, outline and -arrowhead tables, then each page's instructions in drawing order: - -| In the `.cmx` file | Read as | -|---|---| -| Pages, with the size the page gives, or else the size of the drawing's bounds that the page stores | pages; a page sized to the bounds is centered on them | -| Layers, by their UTF-16 or 8-bit name | drawing layers, unnamed when the file gives no name; a layer that holds nothing is left out | -| Groups | groups | -| Curves (moves, lines and cubic curves, as `.cdr` point lists) | paths | -| Uniform fills: CMYK in percent or 0 to 255, CMY, RGB, gray, and library colors with their names | colors, spot colors | -| Outlines: width, color, caps, joins, dashes, the no-outline, behind-the-fill and scaled-with flags | outlines | - -Text, images, rectangles, ellipses, clipping paths, fills other than uniform ones, outline -arrowheads and lenses are not read; the drawing's `warnings` name each kind it held. A clipping -path is left out and the objects it clips are read without it. Files in big-endian byte order and -files with 16-bit coordinates are refused. - -## Provenance - -`PROVENANCE.md` lists every record layout the reader relies on, with its public source and status. -Code cites the rows by id (`R1` ...), and `tests/it/provenance.rs` fails when a cited id has no row. -The test inputs are synthetic drawings built by `src/synth.rs` and `src/synth_cmx.rs` (the -`synth` feature); no third-party file is committed. - -## Limits - -`Limits` bounds the input size, the bytes inflated from compressed lists and package members, the -size of one package member, the number of members, the nesting depth, the chunk count, the -objects, the coordinates and the outline dashes of one read. Past a limit the reader stops with an -error or leaves the rest out with a warning; it does not recurse and does not panic. Each record -of a version 1 or 2 file counts toward the chunk count, and the transform entries of a version 3 -object are held to the arguments one record may have. A package's -data stream is read once however many lines of `content/dataFileList.dat` name it. A redirected -list whose bytes overlap those of an earlier redirected list is left out with the damage warning. -Other records may share bytes, and the bytes read again may add up to the member limit; past it -the records are left out with the limit warning. diff --git a/crates/cdr/src/build.rs b/crates/cdr/src/build.rs deleted file mode 100644 index 758c8886b6..0000000000 --- a/crates/cdr/src/build.rs +++ /dev/null @@ -1,816 +0,0 @@ -//! The drawing the chunk index holds: pages, layers, objects and the fills and outlines they name -//! (R19 to R23). Records are decoded only when an object refers to them. - -use std::collections::HashMap; - -use crate::bytes::Rd; -use crate::geometry; -use crate::inline; -use crate::layout::{self, Profile}; -use crate::limits::Budget; -use crate::model::{Blend, Color, Drawing, Flags, Geometry, Guideline, Layer, LayerKind, Matrix, Object, Outline, Page, Pt, Shape}; -use crate::records::{self, Loda}; -use crate::riff::{Chunk, Index, push}; -use crate::styles::Styles; -use crate::{Error, Warning}; - -/// Object types (R6). -const RECTANGLE: u32 = 1; -const ELLIPSE: u32 = 2; -const CURVE: u32 = 3; -const POLYGON: u32 = 0x14; -const GUIDELINE: u32 = 0x16; -const PATH: u32 = 0x25; -/// Argument types (R6, R20, R21, R33, R52). -const ARG_OUTLINE: u32 = 10; -const ARG_FILL: u32 = 20; -const ARG_COORDS: u32 = 30; -const ARG_TRANSFORMS: u32 = 100; -const ARG_STYLE: u32 = 200; -const ARG_NAME: u32 = 1000; -const ARG_LENS: u32 = 8000; -const ARG_CONTAINER: u32 = 8005; -const ARG_POLYGON: u32 = 11000; -const ARG_WINDING: u32 = 14001; -const ARG_GUIDE: u32 = 16000; -const ARG_PAGE_SIZE: u32 = 19130; - -/// What a RIFF file that names a version before 3 is refused as. -const BEFORE_3: &str = "RIFF files of versions before 3"; - -/// What one read keeps while mapping. -struct Ctx<'a, 'b> { - ix: &'b Index<'a>, - p: Profile, - budget: &'b mut Budget, - warn: &'b mut Vec, - /// Fill and outline records by id, decoded on first use. - fill_chunks: HashMap, - outline_chunks: HashMap, - fills: HashMap>, - outlines: HashMap>, - /// The styles objects name in argument 200 (R45): `Err` when the file's style table doesn't - /// parse. - styles: Result, - /// The groups of `LIST clpt` that containers clip, by the id in their `spnd` chunk (R46). - clips: HashMap, - /// The clipped groups being read, innermost last. - open_clips: Vec, - /// Whether the walk of a clipped group stopped at the clipped chunk limit. - clip_cut: bool, -} - -/// The most clipped groups read one inside another: VectorCraft's own limit. -const MAX_CLIP_DEPTH: usize = 64; - -pub(crate) fn drawing(ix: &Index, budget: &mut Budget, warn: &mut Vec) -> Result { - let root = ix.root().ok_or(Error::NotCdr)?; - let version = ix.version(); - // A template whose `vrsn` chunk doesn't name a version read (R28). - if version == 0 { - return Err(Error::NotCdr); - } - // Versions 1 and 2 are `WL` files (R40); no source shows a RIFF file that names a version - // before 3. - if version < layout::OLDEST_RIFF { - return Err(Error::Unsupported(BEFORE_3)); - } - let p = layout::for_version(version).ok_or(Error::Version(version))?; - let mut found = Found::default(); - collect(ix, root, &mut found); - let page_size = found.mcfg.and_then(|c| page_size(ix.data(c), &p)); - // Before version 7 a `LIST stlt` holds chunks, not the style table (R4). - let styles = match found.stlt { - Some(c) if version >= 700 => Styles::read(ix.data(c), version, budget)?.ok_or(()), - _ => Ok(Styles::default()), - }; - let mut cx = Ctx { - ix, - p, - budget, - warn, - fill_chunks: HashMap::new(), - outline_chunks: HashMap::new(), - fills: HashMap::new(), - outlines: HashMap::new(), - styles, - clips: HashMap::new(), - open_clips: Vec::new(), - clip_cut: false, - }; - // The `spnd` id is a u16 in files of 16-bit fields (R46). - let spnd = |b: &[u8]| if p.short { Rd::new(b).u16().map(u32::from) } else { Rd::new(b).u32() }; - for g in found.clpt.iter().flat_map(|c| ix.children(c)).filter(|g| g.is_list(b"grp ")) { - if let Some(id) = ix.children(g).iter().find(|c| &c.id == b"spnd").and_then(|c| spnd(ix.data(c))) { - cx.clips.entry(id).or_insert(g); - } - } - for c in &found.fills { - if let Some(id) = Rd::new(ix.data(c)).u32() { - cx.fill_chunks.entry(id).or_insert(ix.data(c)); - } - } - for c in &found.outlines { - if let Some(id) = Rd::new(ix.data(c)).u32() { - cx.outline_chunks.entry(id).or_insert(ix.data(c)); - } - } - let mut guides = found.guid.map(|c| guid_chunk(ix.data(c), &cx.p, cx.budget, cx.warn)).unwrap_or_default(); - let mut pages = Vec::new(); - let mut master = Vec::new(); - for page in &found.pages { - let (is_master, read) = cx.page(page); - if is_master { - // Guidelines on any of the master page's layers show on every page. - for mut layer in read.layers { - guides.append(&mut layer.guides); - if !layer.objects.is_empty() && layer.kind != LayerKind::Grid { - master.push(layer); - } - } - } else { - pages.push(read); - } - } - // A file of only a master page keeps it as its page. - if pages.is_empty() && !master.is_empty() { - pages.push(Page { size: None, layers: std::mem::take(&mut master) }); - } - Ok(Drawing { version, page_size, pages, master, guides, warnings: std::mem::take(cx.warn) }) -} - -#[derive(Default)] -struct Found<'i> { - fills: Vec<&'i Chunk>, - outlines: Vec<&'i Chunk>, - mcfg: Option<&'i Chunk>, - guid: Option<&'i Chunk>, - stlt: Option<&'i Chunk>, - clpt: Vec<&'i Chunk>, - pages: Vec<&'i Chunk>, -} - -/// Every fill, outline, `LIST clpt` and page in file order, and the first `mcfg`, `guid` and -/// `LIST stlt`; pages are not looked into. -fn collect<'i>(ix: &'i Index, root: &'i Chunk, found: &mut Found<'i>) { - let mut stack: Vec<&Chunk> = ix.children(root).iter().rev().collect(); - while let Some(c) = stack.pop() { - match &c.id { - b"fild" | b"fill" => found.fills.push(c), - b"outl" => found.outlines.push(c), - b"mcfg" => found.mcfg = found.mcfg.or(Some(c)), - b"guid" => found.guid = found.guid.or(Some(c)), - // Before version 7 the list holds chunks, which are looked through. - _ if c.is_list(b"stlt") => { - found.stlt = found.stlt.or(Some(c)); - stack.extend(ix.children(c).iter().rev()); - } - _ if c.is_list(b"clpt") => found.clpt.push(c), - _ if c.is_list(b"page") => found.pages.push(c), - _ => stack.extend(ix.children(c).iter().rev()), - } - } -} - -/// The page size in `mcfg` (R10); in version 3 the distance between the page's two corners, after -/// 2 bytes (R38). -fn page_size(b: &[u8], p: &Profile) -> Option<(f64, f64)> { - let mut r = Rd::at(b, p.mcfg_skip); - if p.mcfg_corners { - r.skip(2)?; - let (x0, y0, x1, y1) = (records::coord(&mut r, p)?, records::coord(&mut r, p)?, records::coord(&mut r, p)?, records::coord(&mut r, p)?); - return sane_size(x1 - x0, y1 - y0); - } - sane_size(records::coord(&mut r, p)?, records::coord(&mut r, p)?) -} - -fn sane_size(w: f64, h: f64) -> Option<(f64, f64)> { - let (w, h) = (w.abs(), h.abs()); - (w > 0.0 && h > 0.0).then_some((w, h)) -} - -/// The version 7 `guid` chunk (R23): two counts, then 40-byte records laid out as argument 16000. -/// Each guideline counts toward the objects a read maps; past them the rest are left out. -fn guid_chunk(b: &[u8], p: &Profile, budget: &mut Budget, warn: &mut Vec) -> Vec { - let mut r = Rd::new(b); - let Some(n) = r.u32() else { return Vec::new() }; - let _again = r.u32(); - let fits = r.left() / 40; - if n as usize > fits { - push(warn, Warning::Damaged); - } - let n = (n as usize).min(fits); - let mut out = Vec::new(); - for i in 0..n { - if !budget.take_object() { - push(warn, Warning::TooDeep); - break; - } - out.extend(b.get(8 + i * 40..8 + (i + 1) * 40).and_then(|g| guideline(g, p))); - } - out -} - -/// A guideline record (R23): 12 bytes, the angle in millionths of a degree, then a point. -fn guideline(b: &[u8], p: &Profile) -> Option { - if p.short { - return None; - } - let mut r = Rd::at(b, 12); - let angle = f64::from(r.i32()?) / 1_000_000.0; - let at = Pt { x: records::coord(&mut r, p)?, y: records::coord(&mut r, p)? }; - Some(Guideline { at, angle, hidden: false }) -} - -/// Marks the guidelines from `from` on hidden when `flags` hide what holds them. -fn hide_guides(guides: &mut [Guideline], from: usize, flags: Flags) { - if flags.hidden { - for g in guides.iter_mut().skip(from) { - g.hidden = true; - } - } -} - -/// A list's flags (R19): four bytes. -fn flags(ix: &Index, list: &Chunk) -> Option<[u8; 4]> { - let c = ix.children(list).iter().find(|c| &c.id == b"flgs")?; - ix.data(c).get(..4)?.try_into().ok() -} - -/// Whether a layer, group or object list is hidden (bit 0x01 of byte 1) or locked (bit 0x10 of -/// byte 0) (R19). -fn state(ix: &Index, list: &Chunk) -> Flags { - flags(ix, list).map_or(Flags::default(), |[b0, b1, _, _]| Flags { hidden: b1 & 0x01 != 0, locked: b0 & 0x10 != 0 }) -} - -/// `o` with `f` added to its own flags: the objects of a group left ungrouped keep the group's. -fn inherit(o: &mut Object, f: Flags) { - let own = match o { - Object::Shape(s) => &mut s.flags, - Object::Group { flags, .. } => flags, - Object::Clip { container, .. } => &mut container.flags, - }; - own.hidden |= f.hidden; - own.locked |= f.locked; -} - -/// What a layer's object type makes it (R19): 11 a grid, 12 guides, 17 the desktop, any other a -/// drawing layer. Version 3 counts its types from 0, one less (R32). -fn layer_kind_of_type(kind: u32, types_from_zero: bool) -> LayerKind { - match kind.saturating_add(u32::from(types_from_zero)) { - 11 => LayerKind::Grid, - 12 => LayerKind::Guides, - 17 => LayerKind::Desktop, - _ => LayerKind::Drawing, - } -} - -/// What a layer's flags make it, for a layer without an object type of its own (R19). The low -/// four bits of byte 0 hold the kind: 0x0a guides, or a grid with bit 0x10 set (versions 7 to 13 -/// also flag them 0x02); 0x08 the desktop when byte 2 is set, a drawing layer when it is clear. -/// Versions 7 to 13 may flag the master page's desktop layer 0 with bytes 1 and 2 set. Bit 0x10 -/// alone does not make a grid. -fn layer_kind(f: [u8; 4], version_below_14: bool) -> LayerKind { - let [b0, b1, b2, _] = f; - let grid_bit = b0 & 0x10 != 0; - match b0 & 0x0f { - 0x0a if grid_bit => LayerKind::Grid, - 0x0a => LayerKind::Guides, - 0x02 if version_below_14 && grid_bit => LayerKind::Grid, - 0x02 if version_below_14 => LayerKind::Guides, - 0x08 if b2 != 0 => LayerKind::Desktop, - 0 if version_below_14 && b1 == 1 && b2 == 1 => LayerKind::Desktop, - _ => LayerKind::Drawing, - } -} - -/// The first chunk of one of `ids` that a page, layer or object keeps for itself: among its own -/// chunks, or in its `lgob` list and the `trfl` list there (R22). -fn own_chunk<'i>(ix: &'i Index, list: &'i Chunk, ids: &[&[u8; 4]]) -> Option<&'i Chunk> { - let mut stack: Vec<(&Chunk, u8)> = ix.children(list).iter().rev().map(|c| (c, 0)).collect(); - while let Some((c, depth)) = stack.pop() { - if ids.contains(&&c.id) { - return Some(c); - } - if depth < 2 && (c.is_list(b"lgob") || c.is_list(b"trfl")) { - stack.extend(ix.children(c).iter().rev().map(|k| (k, depth + 1))); - } - } - None -} - -/// The `loda` (or `lobj`) a page, layer or object keeps for itself. -fn own_loda<'i>(ix: &'i Index, list: &'i Chunk) -> Option<&'i Chunk> { - own_chunk(ix, list, &[b"loda", b"lobj"]) -} - -/// A page's layer lists in file order: its own, and those in the lists it holds, such as the -/// `gobj` list of files of versions 7 to 13 (R22). -fn page_layers<'i>(ix: &'i Index, page: &'i Chunk) -> Vec<&'i Chunk> { - let mut out = Vec::new(); - let mut stack: Vec<&Chunk> = ix.children(page).iter().rev().collect(); - while let Some(c) = stack.pop() { - if c.is_list(b"layr") { - out.push(c); - } else if c.id == crate::riff::LIST && !c.is_list(b"lgob") { - stack.extend(ix.children(c).iter().rev()); - } - } - out -} - -/// One frame of the object walk: a list's chunks, the next one to look at, and the objects so far. -struct Frame<'i> { - chunks: &'i [Chunk], - next: usize, - objects: Vec, - /// Whether its objects form a group in the frame below. - group: bool, - /// The group's own flags. - flags: Flags, - /// The first of the guidelines read inside it. - guides_from: usize, - /// What places its objects after their own transforms: the matrices of the version 3 groups - /// around them (R33). The identity in other versions, whose objects hold their whole transform. - outer: Matrix, -} - -impl<'a, 'b> Ctx<'a, 'b> { - /// A page: whether it is the master page, and its layers. - fn page(&mut self, page: &Chunk) -> (bool, Page) { - let ix = self.ix; - let is_master = flags(ix, page).is_some_and(|f| f[2] != 0); - let size = own_loda(ix, page) - .and_then(|c| records::loda(ix.data(c), &self.p, &self.budget.limits, self.warn)) - .and_then(|l| l.arg(ARG_PAGE_SIZE).and_then(|b| self.size_arg(b))); - let mut layers = Vec::new(); - for l in page_layers(ix, page) { - let layer = self.layer(l); - let empty = layer.objects.is_empty() && layer.guides.is_empty(); - // The entries that stand for the master page's layers hold nothing of the page's own. - if empty && (is_master || layer.kind != LayerKind::Drawing) { - continue; - } - layers.push(layer); - } - (is_master, Page { size, layers }) - } - - fn size_arg(&self, b: &[u8]) -> Option<(f64, f64)> { - let mut r = Rd::new(b); - sane_size(records::coord(&mut r, &self.p)?, records::coord(&mut r, &self.p)?) - } - - fn layer(&mut self, list: &Chunk) -> Layer { - let ix = self.ix; - let loda = own_loda(ix, list).and_then(|c| records::loda(ix.data(c), &self.p, &self.budget.limits, self.warn)); - // The layer's own object type says what it is; its flags, only when it has none (R19). - let kind = match &loda { - Some(l) => layer_kind_of_type(l.kind, self.p.types_from_zero), - None => flags(ix, list).map_or(LayerKind::Drawing, |f| layer_kind(f, self.p.old_master_flags)), - }; - let name = loda.and_then(|l| l.arg(ARG_NAME).map(|b| records::name(b, &self.p, self.warn))).unwrap_or_default(); - let mut guides = Vec::new(); - let objects = self.objects(ix.children(list), &mut guides); - let flags = state(ix, list); - hide_guides(&mut guides, 0, flags); - Layer { name, kind, flags, objects, guides } - } - - /// The objects of a layer's chunks, groups nested, front to back; guidelines go to `guides`. - fn objects(&mut self, chunks: &'b [Chunk], guides: &mut Vec) -> Vec { - let ix = self.ix; - let mut stack = vec![Frame { - chunks, - next: 0, - objects: Vec::new(), - group: false, - flags: Flags::default(), - guides_from: guides.len(), - outer: Matrix::IDENTITY, - }]; - loop { - let Some(top) = stack.last_mut() else { return Vec::new() }; - let (here, outer) = (top.chunks, top.outer); - let Some(c) = here.get(top.next) else { - let Some(done) = stack.pop() else { return Vec::new() }; - // A hidden group hides the guidelines inside it. - hide_guides(guides, done.guides_from, done.flags); - match stack.last_mut() { - // A group counts toward the objects a read maps; past them its objects stay, - // ungrouped, with the group's flags. - Some(parent) if done.group && !done.objects.is_empty() => { - if self.budget.take_object() { - parent.objects.push(Object::Group { objects: done.objects, flags: done.flags }); - } else { - push(self.warn, Warning::TooDeep); - let mut objects = done.objects; - for o in &mut objects { - inherit(o, done.flags); - } - parent.objects.extend(objects); - } - } - Some(parent) if !done.group => parent.objects.extend(done.objects), - Some(_) => {} - None => return done.objects, - } - continue; - }; - top.next += 1; - // Every chunk of a clipped group counts, empty groups included, each time a container - // names the group; past the limit the group is left out. - if !self.open_clips.is_empty() && !self.budget.take_clipped_chunk() { - push(self.warn, Warning::TooDeep); - self.clip_cut = true; - return Vec::new(); - } - if c.is_list(b"obj ") { - if let Some(o) = self.object(c, guides, &outer) { - top.objects.push(o); - } - } else if c.is_list(b"grp ") { - let own = self.group_placement(c); - let flags = state(ix, c); - let guides_from = guides.len(); - stack.push(Frame { chunks: ix.children(c), next: 0, objects: Vec::new(), group: true, flags, guides_from, outer: outer.after(&own) }); - } else if c.is_list(b"lnkg") { - // Linked groups (brush strokes, blends, contours) place their objects with a - // matrix of their own, which this reader doesn't apply: they are left out. - push(self.warn, Warning::UnsupportedObjects); - } else if c.id == crate::riff::LIST && !c.is_list(b"lgob") { - // Other lists under a layer are looked through (R22). - let guides_from = guides.len(); - stack.push(Frame { chunks: ix.children(c), next: 0, objects: Vec::new(), group: false, flags: Flags::default(), guides_from, outer }); - } - } - } - - /// The matrix a group places its objects with. Only a version 3 group has one, in the - /// transforms argument of its own `lobj` (R33); one that can't be read is damage, and the - /// group's objects stay where their own transforms put them. - fn group_placement(&mut self, list: &Chunk) -> Matrix { - if !self.p.inline_styles { - return Matrix::IDENTITY; - } - let ix = self.ix; - let Some(arg) = - own_loda(ix, list).and_then(|c| records::loda(ix.data(c), &self.p, &self.budget.limits, self.warn)).and_then(|l| l.arg(ARG_TRANSFORMS)) - else { - return Matrix::IDENTITY; - }; - self.placement(arg) - } - - /// The matrices of a transforms argument (R33). An envelope among them is not applied: the - /// shapes keep their outlines, placed by the matrices alone, with the envelopes warning. - fn placement(&mut self, arg: &[u8]) -> Matrix { - match inline::transforms(arg, &self.p, &self.budget.limits, self.warn) { - Some(t) => { - if t.envelope { - push(self.warn, Warning::Envelopes); - } - t.matrix - } - None => { - push(self.warn, Warning::Damaged); - Matrix::IDENTITY - } - } - } - - /// One `LIST obj `: a shape placed by its own transform and then by `outer`, or `None` (a - /// guideline goes to `guides`). - fn object(&mut self, list: &Chunk, guides: &mut Vec, outer: &Matrix) -> Option { - let ix = self.ix; - let Some(loda) = own_loda(ix, list).and_then(|c| records::loda(ix.data(c), &self.p, &self.budget.limits, self.warn)) else { - push(self.warn, Warning::Damaged); - return None; - }; - // Guidelines count toward the objects a read maps. - if !self.budget.take_object() { - push(self.warn, Warning::TooDeep); - return None; - } - let flags = state(ix, list); - if loda.kind == GUIDELINE { - guides.extend(loda.arg(ARG_GUIDE).and_then(|b| guideline(b, &self.p)).map(|g| Guideline { hidden: flags.hidden, ..g })); - return None; - } - if self.p.inline_styles { - return self.inline_object(&loda, outer, flags); - } - let geometry = self.geometry(&loda)?; - // A uniform transparency from version 13 applies (R47); a lens, and a transparency of - // another kind or version, is not applied: the shape shows opaque. - let (opacity, blend) = match loda.arg(ARG_LENS) { - None => (1.0, Blend::Normal), - Some(b) => match records::transparency(b).filter(|_| self.p.tagged) { - Some(t) => t, - None => { - push(self.warn, Warning::Lenses); - (1.0, Blend::Normal) - } - }, - }; - let nonzero = self.nonzero(&loda); - // A transform that is there but can't be read is damage; the shape stays where it is. - let matrix = match own_chunk(ix, list, &[b"trfd"]) { - None => Matrix::IDENTITY, - Some(c) => records::trfd(ix.data(c), &self.p).unwrap_or_else(|| { - push(self.warn, Warning::Damaged); - Matrix::IDENTITY - }), - }; - // Without a fill or outline argument of its own, an object takes its style's (R45). The - // style id is a u16 in files of 16-bit fields. - let style = loda.arg(ARG_STYLE).and_then(|b| if self.p.short { self.short_id(b) } else { self.id(b) }); - let fill_id = match loda.arg(ARG_FILL) { - Some(b) => self.id(b), - None => style.and_then(|s| self.style_entry(s, Styles::fill)), - }; - let outline_id = match loda.arg(ARG_OUTLINE) { - Some(b) => self.id(b), - None => style.and_then(|s| self.style_entry(s, Styles::outline)), - }; - let fill = fill_id.and_then(|id| self.fill(id)); - let outline = outline_id.and_then(|id| self.outline(id)); - let shape = Box::new(Shape { geometry, matrix, fill, outline, nonzero, opacity, blend, flags }); - // A container clips the group its argument 8005 names (R46). - Some(match loda.arg(ARG_CONTAINER).and_then(|b| self.id(b)) { - Some(id) => self.clip(shape, id, guides), - None => Object::Shape(shape), - }) - } - - /// `container` and the objects of the clipped group `id`, which keep their own transforms. - /// A group that isn't there is damage; one already being read, past the depth limit or past - /// the chunks clipped groups may walk is left out with the limit warning, the guidelines it - /// holds included. Either way the container stays, as a plain shape. - fn clip(&mut self, container: Box, id: u32, guides: &mut Vec) -> Object { - let Some(&group) = self.clips.get(&id) else { - push(self.warn, Warning::Damaged); - return Object::Shape(container); - }; - if self.open_clips.contains(&id) || self.open_clips.len() >= MAX_CLIP_DEPTH { - push(self.warn, Warning::TooDeep); - return Object::Shape(container); - } - self.open_clips.push(id); - let (ix, mark) = (self.ix, guides.len()); - let objects = self.objects(ix.children(group), guides); - self.open_clips.pop(); - if std::mem::take(&mut self.clip_cut) { - guides.truncate(mark); - return Object::Shape(container); - } - // The clipped group's own flags hide or lock the objects it holds; it and the container - // hide its guidelines. - let flags = state(ix, group); - hide_guides(guides, mark, flags); - hide_guides(guides, mark, container.flags); - if objects.is_empty() { - return Object::Shape(container); - } - let mut objects = objects; - for o in &mut objects { - inherit(o, flags); - } - Object::Clip { container, objects } - } - - /// The record id that argument `b` names; an argument too short for one is damage. - fn id(&mut self, b: &[u8]) -> Option { - let id = id_of(b); - if id.is_none() { - push(self.warn, Warning::Damaged); - } - id - } - - /// A u16 id at the start of argument `b`; an argument too short for one is damage. - fn short_id(&mut self, b: &[u8]) -> Option { - let id = Rd::new(b).u16().map(u32::from); - if id.is_none() { - push(self.warn, Warning::Damaged); - } - id - } - - /// Whether the object's fill rule is nonzero: byte 0 of argument 14001 set (R52). Without the - /// argument the fill is even-odd; an argument without its byte is damage. - fn nonzero(&mut self, loda: &Loda) -> bool { - let Some(b) = loda.arg(ARG_WINDING) else { return false }; - match b.first() { - Some(v) => *v != 0, - None => { - push(self.warn, Warning::Damaged); - false - } - } - } - - /// The fill or outline record that style `id` names; a style table that doesn't parse is - /// damage, and the object is drawn without it. - fn style_entry(&mut self, id: u32, entry: fn(&Styles, u32) -> Option) -> Option { - match &self.styles { - Ok(s) => entry(s, id), - Err(()) => { - push(self.warn, Warning::Damaged); - None - } - } - } - - /// A version 3 object, whose transforms, fill and outline are arguments of its own record - /// (R33, R34, R35). A fill or an outline that is there but can't be read is damage. - fn inline_object(&mut self, loda: &Loda, outer: &Matrix, flags: Flags) -> Option { - let own = match loda.arg(ARG_TRANSFORMS) { - None => Matrix::IDENTITY, - Some(arg) => self.placement(arg), - }; - let geometry = self.geometry(loda)?; - let fill = loda.arg(ARG_FILL).and_then(|b| { - let read = inline::fill(b, &self.p, self.warn); - if read.is_none() { - push(self.warn, Warning::Damaged); - } - read.flatten() - }); - let outline = loda.arg(ARG_OUTLINE).and_then(|b| { - let read = inline::outline(b, &self.p, self.warn); - if read.is_none() { - push(self.warn, Warning::Damaged); - } - read.flatten() - }); - // Past the dashes a read takes, the outline is solid. - let outline = outline.map(|mut o| { - if !o.dashes.is_empty() && !self.budget.take_dashes(o.dashes.len()) { - o.dashes = Vec::new(); - push(self.warn, Warning::TooDeep); - } - o - }); - let nonzero = self.nonzero(loda); - let shape = Shape { nonzero, flags, ..Shape::new(geometry, outer.after(&own), fill, outline) }; - Some(Object::Shape(Box::new(shape))) - } - - fn geometry(&mut self, loda: &Loda) -> Option { - let coords = loda.arg(ARG_COORDS); - // Version 3 counts the first object types from 0, one below the later numbers (R32). - let kind = if self.p.types_from_zero && loda.kind <= 4 { loda.kind + 1 } else { loda.kind }; - // A shape without its coordinates, or a polygon without its sides, is damage like a shape - // whose coordinates can't be read; one left out at the coordinate limit is not. - self.budget.coordinates_refused(); - let g = match kind { - RECTANGLE => coords.and_then(|c| geometry::rect(c, &self.p)), - ELLIPSE => coords.and_then(|c| geometry::ellipse(c, &self.p)), - CURVE => coords.and_then(|c| geometry::point_list(c, &self.p, self.budget, self.warn)).map(Geometry::Path), - PATH if self.p.paths => coords.and_then(|c| geometry::path_record(c, &self.p, self.budget, self.warn)).map(Geometry::Path), - POLYGON => match loda.arg(ARG_POLYGON) { - Some(sides) => coords - .and_then(|c| geometry::point_list(c, &self.p, self.budget, self.warn)) - .and_then(|base| geometry::polygon(&base, sides, &self.p, self.budget, self.warn)), - None => { - push(self.warn, Warning::Damaged); - return None; - } - }, - _ => { - push(self.warn, Warning::UnsupportedObjects); - return None; - } - }; - if g.is_none() && !self.budget.coordinates_refused() { - push(self.warn, Warning::Damaged); - } - g - } - - fn fill(&mut self, id: u32) -> Option { - if let Some(f) = self.fills.get(&id) { - return f.clone(); - } - // A record that is missing or can't be read is damage, and the shape is drawn without a - // fill; id 0 without a record is no fill. - if id != 0 && !self.fill_chunks.contains_key(&id) { - push(self.warn, Warning::Damaged); - } - let read = self.fill_chunks.get(&id).and_then(|b| { - let read = records::fill(b, &self.p, self.warn); - if read.is_none() { - push(self.warn, Warning::Damaged); - } - read.and_then(|(_, c)| c) - }); - self.fills.insert(id, read.clone()); - read - } - - /// The outline of record `id`. Its dashes count toward the read's dashes for every shape that - /// uses it; past them the shape's outline is solid. - fn outline(&mut self, id: u32) -> Option { - if !self.outlines.contains_key(&id) { - // A record that is missing is damage, as one that can't be read is; id 0 without a - // record is no outline. - if id != 0 && !self.outline_chunks.contains_key(&id) { - push(self.warn, Warning::Damaged); - } - let read = self.outline_chunks.get(&id).and_then(|b| { - let read = records::outline(b, &self.p, self.warn); - if read.is_none() { - push(self.warn, Warning::Damaged); - } - read.and_then(|(_, o)| o) - }); - // An outline with more dashes than the read may still take is kept solid. - let read = read.map(|mut o| { - if o.dashes.len() > self.budget.dashes_left() { - o.dashes = Vec::new(); - push(self.warn, Warning::TooDeep); - } - o - }); - self.outlines.insert(id, read); - } - let o = self.outlines.get_mut(&id)?.as_mut()?; - // The dashes left only shrink, so an outline refused once is refused for every later - // shape: its dashes are dropped from the cache, and later shapes take it solid. - if !o.dashes.is_empty() && !self.budget.take_dashes(o.dashes.len()) { - o.dashes = Vec::new(); - push(self.warn, Warning::TooDeep); - } - Some(o.clone()) - } -} - -/// A fill or outline argument: the record id (R20). -fn id_of(b: &[u8]) -> Option { - Rd::new(b).u32() -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn layer_flags_name_the_kinds() { - assert_eq!(layer_kind([0, 0, 0, 0x98], true), LayerKind::Drawing); - assert_eq!(layer_kind([0x0a, 0, 0, 0x98], true), LayerKind::Guides); - assert_eq!(layer_kind([0x02, 1, 1, 0x98], true), LayerKind::Guides); - assert_eq!(layer_kind([0x08, 0, 1, 0x98], true), LayerKind::Desktop); - assert_eq!(layer_kind([0, 1, 1, 0x98], true), LayerKind::Desktop); - assert_eq!(layer_kind([0x1a, 0, 1, 0x98], true), LayerKind::Grid); - assert_eq!(layer_kind([0x12, 0, 1, 0x98], true), LayerKind::Grid); - // From version 14 the master page flags its layers by byte 0 alone. - assert_eq!(layer_kind([0x0a, 0, 1, 0x98], false), LayerKind::Guides); - assert_eq!(layer_kind([0x08, 0, 1, 0x98], false), LayerKind::Desktop); - assert_eq!(layer_kind([0x5a, 1, 1, 0x98], false), LayerKind::Grid); - assert_eq!(layer_kind([0x02, 1, 1, 0x98], false), LayerKind::Drawing); - assert_eq!(layer_kind([0, 1, 1, 0x98], false), LayerKind::Drawing); - // Drawing layers flagged 0x10, 0x08, 0x18, 0x40 and 0x58 with byte 2 clear, as sample - // files flag them, and desktop and guides layers with bit 0x40 or 0x10 set. - for f in [[0x10, 0, 0, 0x98], [0x08, 1, 0, 0x98], [0x18, 1, 0, 0x98], [0x40, 0, 0, 0x98], [0x58, 1, 0, 0x98]] { - assert_eq!(layer_kind(f, true), LayerKind::Drawing, "{f:?}"); - assert_eq!(layer_kind(f, false), LayerKind::Drawing, "{f:?}"); - } - assert_eq!(layer_kind([0x18, 0, 1, 0x98], true), LayerKind::Desktop); - assert_eq!(layer_kind([0x48, 0, 1, 0x98], false), LayerKind::Desktop); - assert_eq!(layer_kind([0x4a, 1, 1, 0x98], true), LayerKind::Guides); - } - - /// An outline record refused at the dash limit keeps no dashes in the cache, so the shapes - /// that use it later copy none. - #[test] - fn an_outline_past_the_dash_limit_keeps_no_dashes() { - let v = crate::synth::V(1100); - let pen = crate::synth::Pen { line_type: 4, width: 1.0, cap: 0, join: 0 }; - let record = v.outline(1, pen, &crate::synth::color(5, [0, 0, 0, 255]), &[3, 1, 3]); - let file = crate::synth::riff(1100, &[]); - let mut budget = Budget::new(crate::Limits { dashes: 4, ..crate::Limits::default() }); - let mut warn = Vec::new(); - let ix = crate::riff::Index::build(&file, None, &mut budget, &mut warn).unwrap(); - let mut cx = Ctx { - ix: &ix, - p: layout::for_version(1100).unwrap(), - budget: &mut budget, - warn: &mut warn, - fill_chunks: HashMap::new(), - outline_chunks: HashMap::from([(1, record.as_slice())]), - fills: HashMap::new(), - outlines: HashMap::new(), - styles: Ok(Styles::default()), - clips: HashMap::new(), - open_clips: Vec::new(), - clip_cut: false, - }; - assert_eq!(cx.outline(1).map(|o| o.dashes.len()), Some(3)); - for _ in 0..3 { - assert_eq!(cx.outline(1).map(|o| o.dashes.len()), Some(0)); - assert_eq!(cx.outlines.get(&1).and_then(|o| o.as_ref()).map(|o| o.dashes.len()), Some(0)); - } - assert_eq!(*cx.warn, vec![Warning::TooDeep]); - } -} diff --git a/crates/cdr/src/bytes.rs b/crates/cdr/src/bytes.rs deleted file mode 100644 index 216bd90024..0000000000 --- a/crates/cdr/src/bytes.rs +++ /dev/null @@ -1,76 +0,0 @@ -//! Little-endian reads that fail instead of panicking. - -/// A cursor over one record's bytes. Every read returns `None` past the end. -#[derive(Clone, Copy, Debug)] -pub(crate) struct Rd<'a> { - b: &'a [u8], - pos: usize, -} - -impl<'a> Rd<'a> { - pub(crate) fn new(b: &'a [u8]) -> Self { - Rd { b, pos: 0 } - } - - pub(crate) fn at(b: &'a [u8], pos: usize) -> Self { - Rd { b, pos } - } - - pub(crate) fn pos(&self) -> usize { - self.pos - } - - pub(crate) fn left(&self) -> usize { - self.b.len().saturating_sub(self.pos) - } - - pub(crate) fn skip(&mut self, n: usize) -> Option<()> { - let end = self.pos.checked_add(n)?; - (end <= self.b.len()).then(|| self.pos = end) - } - - pub(crate) fn bytes(&mut self, n: usize) -> Option<&'a [u8]> { - let end = self.pos.checked_add(n)?; - let s = self.b.get(self.pos..end)?; - self.pos = end; - Some(s) - } - - fn array(&mut self) -> Option<[u8; N]> { - self.bytes(N)?.try_into().ok() - } - - pub(crate) fn u8(&mut self) -> Option { - Some(self.array::<1>()?[0]) - } - - pub(crate) fn u16(&mut self) -> Option { - self.array().map(u16::from_le_bytes) - } - - pub(crate) fn i16(&mut self) -> Option { - self.array().map(i16::from_le_bytes) - } - - pub(crate) fn u32(&mut self) -> Option { - self.array().map(u32::from_le_bytes) - } - - pub(crate) fn i32(&mut self) -> Option { - self.array().map(i32::from_le_bytes) - } - - /// A finite f64; NaN and the infinities read as `None`. - pub(crate) fn f64(&mut self) -> Option { - self.array().map(f64::from_le_bytes).filter(|v| v.is_finite()) - } - - pub(crate) fn fourcc(&mut self) -> Option<[u8; 4]> { - self.array() - } -} - -/// The u32 at `pos` of `b`. -pub(crate) fn u32_at(b: &[u8], pos: usize) -> Option { - Rd::at(b, pos).u32() -} diff --git a/crates/cdr/src/cmx.rs b/crates/cdr/src/cmx.rs deleted file mode 100644 index fc343a1870..0000000000 --- a/crates/cdr/src/cmx.rs +++ /dev/null @@ -1,651 +0,0 @@ -//! Reader for `.cmx` exchange files with 32-bit coordinates: the RIFF form `CMX1` (R53), its -//! header (R54), the color, pen, line type, dash, outline and arrowhead tables (R55 to R59) and the -//! instructions of each page (R60): pages, layers, groups and curves (R61, R62) with uniform fills -//! and outlines (R63). Text, images, rectangles, ellipses, clipping paths, other fills and lenses -//! are left out with a warning. - -use crate::bytes::{Rd, u32_at}; -use crate::geometry::path_of; -use crate::layout::{self, Profile}; -use crate::limits::Budget; -use crate::model::{Cap, Color, Drawing, Geometry, Join, Layer, LayerKind, Matrix, Object, Outline, Page, Pt, Shape}; -use crate::records::{name, property_color}; -use crate::riff::{LIST, push}; -use crate::{Error, Warning}; - -const FORM: [u8; 4] = *b"CMX1"; -/// Meters per coordinate unit when the header gives no usable value: the 0.1 µm of every sample -/// file with 32-bit coordinates (R54). -const DEFAULT_UNIT: f64 = 1e-7; -/// How far past a chunk that runs short the next chunk id is looked for (R53). -const RESYNC: usize = 64; -/// The chunks the reader uses (R53 to R60). -const READ_IDS: [[u8; 4]; 9] = [*b"LIST", *b"cont", *b"page", *b"rclr", *b"rpen", *b"rott", *b"rdot", *b"rotl", *b"rota"]; -/// The most UTF-16 units read of a layer's name; [`name`] keeps 256 of them. -const MAX_NAME_UNITS: usize = 4096; - -// Instruction codes (R60). -const BEGIN_PAGE: i16 = 9; -const END_PAGE: i16 = 10; -const BEGIN_LAYER: i16 = 11; -const END_LAYER: i16 = 12; -const BEGIN_GROUP: i16 = 13; -const END_GROUP: i16 = 14; -const BEGIN_TEXT: i16 = 20; -const END_TEXT: i16 = 21; -const GLYPH_RUN: i16 = 65; -const ELLIPSE: i16 = 66; -const CURVE: i16 = 67; -const RECTANGLE: i16 = 68; -const IMAGE: i16 = 69; -const ADD_CLIP: i16 = 88; -const REMOVE_CLIP: i16 = 89; -const JUMP: i16 = 111; - -/// Does `bytes` start as a CMX file: a RIFF or RIFX form of type `CMX1` (R53)? -pub(crate) fn is_cmx(bytes: &[u8]) -> bool { - matches!(bytes.get(0..4), Some(b"RIFF" | b"RIFX")) && bytes.get(8..12) == Some(FORM.as_slice()) -} - -/// A chunk outside the `LIST` chunks: its id, its body and where the body starts in the file. -struct Chunk<'a> { - id: [u8; 4], - body: &'a [u8], - start: usize, -} - -/// The tables that page instructions refer to by 1-based index (R55 to R59). -#[derive(Default)] -struct Tables { - colors: Vec>, - /// Outline widths in points. - pens: Vec>, - /// Flags, and the caps and join. - line_types: Vec>, - dashes: Vec>, - /// Line type, screen, color, arrowheads, pen and dashes. - outlines: Vec>, - arrowheads: Vec<(u16, u16)>, -} - -pub(crate) fn drawing(bytes: &[u8], budget: &mut Budget) -> Result { - if !is_cmx(bytes) { - return Err(Error::NotCmx); - } - if bytes.get(0..4) == Some(b"RIFX") { - return Err(Error::Unsupported("big-endian CMX files")); - } - let mut warn = Vec::new(); - let chunks = chunks(bytes, budget, &mut warn)?; - let cont = chunks.iter().find(|c| c.id == *b"cont").map(|c| c.body).ok_or(Error::Damaged("CMX header"))?; - match cont.get(52) { - Some(b'4') => {} - Some(b'2') => return Err(Error::Unsupported("CMX files with 16-bit coordinates")), - _ => return Err(Error::Damaged("CMX header")), - } - let meters = Rd::at(cont, 64).f64().filter(|m| *m > 0.0 && *m <= 1.0).unwrap_or(DEFAULT_UNIT); - let unit = meters / 0.0254 * 72.0; - let tables = Tables::read(&chunks, unit, budget, &mut warn)?; - let mut pages = Vec::new(); - for c in chunks.iter().filter(|c| c.id == *b"page") { - pages.push(PageRead::new(&tables, unit, budget, &mut warn).read(c)?); - } - Ok(Drawing { version: 0, page_size: None, pages, master: Vec::new(), guides: Vec::new(), warnings: warn }) -} - -/// The chunks of the file in order, those inside `LIST` chunks in place (R53). -fn chunks<'a>(b: &'a [u8], budget: &mut Budget, warn: &mut Vec) -> Result>, Error> { - let declared = u32_at(b, 4).and_then(|n| (n as usize).checked_add(8)).unwrap_or(b.len()); - if declared > b.len() { - // The file was cut short of the size its header gives. - push(warn, Warning::Damaged); - } - let end = declared.min(b.len()); - let mut out = Vec::new(); - // (position, end, depth) of the lists still to walk; a list's children go before the rest of - // the list that holds it. - let mut stack = vec![(12usize, end, 0usize)]; - while let Some((mut pos, end, depth)) = stack.pop() { - while pos.saturating_add(8) <= end { - let Some(id) = Rd::at(b, pos).fourcc() else { break }; - if !is_id(&id) { - match resync(b, pos, end) { - Some(next) => { - pos = next; - continue; - } - None => { - push(warn, Warning::Damaged); - break; - } - } - } - budget.take_chunk()?; - let size = u32_at(b, pos + 4).map_or(0, |s| s as usize); - let start = pos + 8; - let stop = start.saturating_add(size); - if stop > end { - // Stray bytes that happen to start with four letters give a length past the list: - // look for the next chunk id after them. A chunk the reader uses is kept, cut at - // the end of the list. - if !READ_IDS.contains(&id) - && let Some(next) = resync(b, pos, end) - { - pos = next; - continue; - } - push(warn, Warning::Damaged); - } - let stop = stop.min(end); - let next = stop.saturating_add(size & 1); - if id == LIST { - if depth >= budget.limits.depth { - push(warn, Warning::TooDeep); - pos = next; - continue; - } - stack.push((next, end, depth)); - stack.push((start + 4, stop, depth + 1)); - break; - } - if let Some(body) = b.get(start..stop) { - out.push(Chunk { id, body, start }); - } - pos = next; - } - } - Ok(out) -} - -/// Is `t` a chunk id: an ASCII letter, then three ASCII letters, digits or spaces (R53)? -fn is_id(t: &[u8]) -> bool { - matches!(t, [first, rest @ ..] if t.len() == 4 && first.is_ascii_alphabetic() && rest.iter().all(|c| c.is_ascii_alphanumeric() || *c == b' ')) -} - -/// Where the next chunk after `pos` lies: the first chunk id at an even distance of 2 to [`RESYNC`] -/// bytes that names a chunk the reader uses, or another chunk whose length keeps it inside the list -/// that ends at `end` (R53). -fn resync(b: &[u8], pos: usize, end: usize) -> Option { - let fits = |p: usize| u32_at(b, p + 4).and_then(|s| (p + 8).checked_add(s as usize)).is_some_and(|stop| stop <= end); - let chunk_at = |p: usize| Rd::at(b, p).fourcc().is_some_and(|id| is_id(&id) && (READ_IDS.contains(&id) || fits(p))); - (pos + 2..=pos.saturating_add(RESYNC).min(end.saturating_sub(8))).step_by(2).find(|&p| chunk_at(p)) -} - -/// The end of the field list at `pos` of `b`: after its 0xff, or the end of `b` when a field runs -/// past it (R55). -fn list_end(b: &[u8], mut pos: usize) -> usize { - while let Some(&tag) = b.get(pos) { - if tag == 0xff { - return pos + 1; - } - match Rd::at(b, pos + 1).u16().map(usize::from).filter(|n| *n >= 3) { - Some(n) if pos + n <= b.len() => pos += n, - _ => break, - } - } - b.len() -} - -/// The data of field `tag` in the field list `b` (R55). -fn field(b: &[u8], tag: u8) -> Option<&[u8]> { - let mut pos = 0; - while let Some(&t) = b.get(pos) { - if t == 0xff { - return None; - } - let n = usize::from(Rd::at(b, pos + 1).u16()?); - let data = b.get(pos + 3..pos.checked_add(n)?).filter(|_| n >= 3)?; - if t == tag { - return Some(data); - } - pos += n; - } - None -} - -/// The field lists of a table: a u16 count, then that many lists (R55). Each entry counts toward -/// the chunk limit. -fn entries<'a>(d: &'a [u8], budget: &mut Budget) -> Result, Error> { - let count = Rd::new(d).u16().map_or(0, usize::from); - let mut out = Vec::new(); - let mut pos = 2; - for _ in 0..count { - if pos >= d.len() { - break; - } - budget.take_chunk()?; - let end = list_end(d, pos); - out.push(d.get(pos..end).unwrap_or_default()); - pos = end; - } - Ok(out) -} - -impl Tables { - /// The first chunk of each table; a table that is missing is empty. - fn read(chunks: &[Chunk], unit: f64, budget: &mut Budget, warn: &mut Vec) -> Result { - let first = |id: &[u8; 4]| chunks.iter().find(|c| c.id == *id).map_or(&[][..], |c| c.body); - // A color record of field 10 holds a property list as a `.cdr` fill does (R56). - let record = layout::for_version(1300); - let mut t = Tables::default(); - for e in entries(first(b"rclr"), budget)? { - t.colors.push(color(e, record.as_ref(), warn)); - } - for e in entries(first(b"rpen"), budget)? { - t.pens.push(field(e, 1).and_then(|f| Rd::new(f).u32()).map(|w| f64::from(w) * unit)); - } - for e in entries(first(b"rott"), budget)? { - t.line_types.push(field(e, 1).and_then(|f| Some((*f.first()?, f.get(1).copied().unwrap_or(0))))); - } - for e in entries(first(b"rdot"), budget)? { - let mut r = Rd::new(field(e, 1).unwrap_or_default()); - let n = r.u16().map_or(0, usize::from); - t.dashes.push((0..n).map_while(|_| r.u16()).collect()); - } - for e in entries(first(b"rotl"), budget)? { - t.outlines.push(field(e, 1).and_then(|f| { - let mut r = Rd::new(f); - Some([r.u16()?, r.u16()?, r.u16()?, r.u16()?, r.u16()?, r.u16()?]) - })); - } - // Arrowhead pairs are plain u16 pairs after the count, not field lists (R59). - let mut r = Rd::new(first(b"rota")); - let n = r.u16().map_or(0, usize::from); - for _ in 0..n { - let Some(pair) = r.u16().zip(r.u16()) else { break }; - budget.take_chunk()?; - t.arrowheads.push(pair); - } - Ok(t) - } - - /// Entry `index` (1-based) of `list`, or `None` with a warning when there is none. - fn get(list: &[Option], index: u16, warn: &mut Vec) -> Option { - let found = usize::from(index).checked_sub(1).and_then(|i| list.get(i)).cloned().flatten(); - if found.is_none() { - push(warn, Warning::Damaged); - } - found - } - - fn color(&self, index: u16, warn: &mut Vec) -> Color { - Tables::get(&self.colors, index, warn).unwrap_or(Color::Rgb([0.0; 3])) - } - - /// The outline of `rotl` entry `index`, or `None` when its line type draws none (R57, R58). - fn outline(&self, index: u16, budget: &mut Budget, warn: &mut Vec) -> Option { - let [line, _screen, color, arrows, pen, dash] = Tables::get(&self.outlines, index, warn)?; - let (flags, caps_join) = Tables::get(&self.line_types, line, warn).unwrap_or((2, 0)); - if flags & 1 != 0 { - return None; - } - let width = Tables::get(&self.pens, pen, warn).unwrap_or(0.0); - let mut dashes = Vec::new(); - if flags & 4 != 0 { - let stored = usize::from(dash).checked_sub(1).and_then(|i| self.dashes.get(i)); - match stored { - // A pattern of zero lengths draws as a solid line, as in a `.cdr` outline (R48). - Some(d) if d.iter().all(|x| *x == 0) => {} - Some(d) if budget.take_dashes(d.len()) => dashes = d.iter().map(|x| f64::from(*x)).collect(), - Some(_) => push(warn, Warning::TooDeep), - None => push(warn, Warning::Damaged), - } - } - if usize::from(arrows).checked_sub(1).and_then(|i| self.arrowheads.get(i)).is_some_and(|(s, e)| *s != 0 || *e != 0) { - push(warn, Warning::Arrowheads); - } - Some(Outline { - width, - color: self.color(color, warn), - cap: match caps_join & 0x0f { - 1 => Cap::Round, - 2 => Cap::Square, - _ => Cap::Butt, - }, - join: match caps_join >> 4 { - 1 => Join::Round, - 2 => Join::Bevel, - _ => Join::Miter, - }, - dashes, - behind_fill: flags & 8 != 0, - scale_with: flags & 16 != 0, - }) - } -} - -/// A color entry (R56): the property list of field 10 when there is one, else the model and -/// palette bytes of field 1 and the values of field 2. Colors in other models read as black with a -/// warning. -fn color(e: &[u8], record: Option<&Profile>, warn: &mut Vec) -> Option { - if let (Some(f), Some(p)) = (field(e, 10), record) { - let mut r = Rd::new(f); - let len = r.u32()? as usize; - return property_color(r.bytes(len.min(r.left()))?, p, warn); - } - let model = *field(e, 1)?.first()?; - let v = field(e, 2)?; - let byte = |i: usize| v.get(i).map(|b| f32::from(*b)); - let pct = |i: usize| byte(i).map(|x| (x / 100.0).clamp(0.0, 1.0)); - let full = |i: usize| byte(i).map(|x| x / 255.0); - Some(match model { - 2 => Color::Cmyk([pct(0)?, pct(1)?, pct(2)?, pct(3)?]), - 3 => Color::Cmyk([full(0)?, full(1)?, full(2)?, full(3)?]), - 4 => Color::Cmyk([full(0)?, full(1)?, full(2)?, 0.0]), - 5 => Color::Rgb([full(0)?, full(1)?, full(2)?]), - 9 => Color::Gray(1.0 - full(0)?), - _ => { - push(warn, Warning::UnknownColors); - Color::Rgb([0.0; 3]) - } - }) -} - -/// The objects of one layer while it is read: the layer's own list, then one list for each group -/// left open. -struct LayerRead { - name: String, - lists: Vec>, -} - -impl LayerRead { - /// The layer, its open groups closed. Lists are drawn back to front (R60), and the model holds - /// them front to back. - fn finish(mut self) -> Layer { - while self.lists.len() > 1 { - close_group(&mut self.lists); - } - let mut objects = self.lists.pop().unwrap_or_default(); - objects.reverse(); - Layer { name: self.name, kind: LayerKind::Drawing, flags: Default::default(), objects, guides: Vec::new() } - } -} - -/// Close the innermost open group of `lists` into the one that holds it. -fn close_group(lists: &mut Vec>) { - if lists.len() < 2 { - return; - } - let mut objects = lists.pop().unwrap_or_default(); - objects.reverse(); - if let Some(top) = lists.last_mut() { - top.push(Object::Group { objects, flags: Default::default() }); - } -} - -/// The reading of one page chunk. -struct PageRead<'t, 'b> { - tables: &'t Tables, - unit: f64, - budget: &'b mut Budget, - warn: &'b mut Vec, - size: Option<(f64, f64)>, - /// The page's center in the file's coordinates when the page takes its size from the - /// drawing's bounds; points are moved by it so the art lies on the page. - center: (f64, f64), - layers: Vec, - open: Option, - /// Groups nested past the depth limit that are still open; their content is left out. - skipped: usize, -} - -impl<'t, 'b> PageRead<'t, 'b> { - fn new(tables: &'t Tables, unit: f64, budget: &'b mut Budget, warn: &'b mut Vec) -> Self { - PageRead { tables, unit, budget, warn, size: None, center: (0.0, 0.0), layers: Vec::new(), open: None, skipped: 0 } - } - - /// The instructions of a page chunk: a u16 size counting the whole instruction and an i16 code, - /// or 0xFFFF, a u32 size and the code; then the code's field lists (R60). - fn read(mut self, c: &Chunk) -> Result { - let d = c.body; - let mut pos = 0usize; - while pos.saturating_add(4) <= d.len() { - self.budget.take_chunk()?; - let mut r = Rd::at(d, pos); - let (size, code, head) = match r.u16() { - Some(0xFFFF) => match (r.u32(), r.i16()) { - (Some(size), Some(code)) => (size as usize, code, 8), - _ => break, - }, - Some(size) => match r.i16() { - Some(code) => (usize::from(size), code, 4), - None => break, - }, - None => break, - }; - if size < head { - push(self.warn, Warning::Damaged); - break; - } - let end = pos.saturating_add(size); - if end > d.len() { - push(self.warn, Warning::Damaged); - } - let body = d.get(pos + head..end.min(d.len())).unwrap_or_default(); - if code == JUMP { - // Field 1 is the file offset the instructions go on from; the bytes passed over - // hold the page's images (R60). - let target = field(body, 1).and_then(|f| Rd::new(f).u32()).and_then(|t| (t as usize).checked_sub(c.start)); - pos = target.filter(|t| *t >= end && *t <= d.len()).unwrap_or(end); - if pos > end { - push(self.warn, Warning::UnsupportedObjects); - } - continue; - } - self.instruction(code, body); - pos = end; - } - if pos < d.len() { - // An instruction whose head runs past the page was not read. - push(self.warn, Warning::Damaged); - } - self.close_layer(); - // A layer that holds nothing (the special layers every sample file lists empty) is left - // out. The file lists layers back to front. - let mut layers = self.layers; - layers.retain(|l| !l.objects.is_empty()); - layers.reverse(); - Ok(Page { size: self.size, layers }) - } - - fn instruction(&mut self, code: i16, body: &[u8]) { - match code { - BEGIN_PAGE => { - // Field 4: the page's width and height (R61). - let mut r = Rd::new(field(body, 4).unwrap_or_default()); - if let (Some(w), Some(h)) = (r.u32(), r.u32()) { - let (w, h) = (f64::from(w) * self.unit, f64::from(h) * self.unit); - self.size = (w > 0.0 && h > 0.0).then_some((w, h)); - } - if self.size.is_none() { - self.size_from_bounds(field(body, 1).unwrap_or_default()); - } - } - BEGIN_LAYER => { - self.close_layer(); - // A layer without a name is left unnamed, as in a `.cdr` drawing. - let name = self.layer_name(body).unwrap_or_default(); - self.open = Some(LayerRead { name, lists: vec![Vec::new()] }); - } - END_LAYER => self.close_layer(), - BEGIN_GROUP => { - let open = self.layer().lists.len(); - if self.skipped > 0 || open > self.budget.limits.depth { - self.skipped += 1; - push(self.warn, Warning::TooDeep); - } else if self.budget.take_object() { - self.layer().lists.push(Vec::new()); - } else { - // Past the object limit the group's content joins the group that holds it. - self.skipped += 1; - push(self.warn, Warning::TooDeep); - } - } - END_GROUP => { - if self.skipped > 0 { - self.skipped -= 1; - } else { - close_group(&mut self.layer().lists); - } - } - CURVE if self.skipped == 0 => { - if let Some(shape) = self.curve(body) { - if self.budget.take_object() { - if let Some(list) = self.layer().lists.last_mut() { - list.push(Object::Shape(Box::new(shape))); - } - } else { - push(self.warn, Warning::TooDeep); - } - } - } - BEGIN_TEXT | GLYPH_RUN | ELLIPSE | RECTANGLE | IMAGE | ADD_CLIP => push(self.warn, Warning::UnsupportedObjects), - // These and the other codes (text styles and characters, color contexts) draw nothing - // on their own. - END_PAGE | END_TEXT | REMOVE_CLIP => {} - _ => {} - } - } - - /// A page without a size of its own is sized to the drawing's bounds in field 1 (R61): a u16 - /// page number, a u32 of flags, then the left, top, right and bottom edges as i32 in - /// coordinate units. The page is centered on those bounds. - fn size_from_bounds(&mut self, f: &[u8]) { - let mut r = Rd::new(f); - if r.u16().is_none() || r.u32().is_none() { - return; - } - let (Some(l), Some(t), Some(rt), Some(b)) = (r.i32(), r.i32(), r.i32(), r.i32()) else { - return; - }; - let (l, t, rt, b) = (f64::from(l) * self.unit, f64::from(t) * self.unit, f64::from(rt) * self.unit, f64::from(b) * self.unit); - let (w, h) = ((rt - l).abs(), (t - b).abs()); - if w > 0.0 && h > 0.0 { - self.size = Some((w, h)); - self.center = ((l + rt) / 2.0, (t + b) / 2.0); - } - } - - /// The open layer, or a new unnamed one when objects come before any layer begins. - fn layer(&mut self) -> &mut LayerRead { - self.open.get_or_insert_with(|| LayerRead { name: String::new(), lists: vec![Vec::new()] }) - } - - fn close_layer(&mut self) { - self.skipped = 0; - if let Some(l) = self.open.take() { - self.layers.push(l.finish()); - } - } - - /// A layer's name: field 4 as a u32 count and UTF-16 units, else field 1 from byte 12 as a - /// u16 count and 8-bit characters (R62). - fn layer_name(&mut self, body: &[u8]) -> Option { - // A field 4 that can't be read leaves the name to field 1. - let wide = field(body, 4).and_then(|f| { - let mut r = Rd::new(f); - let n = (r.u32()? as usize).min(MAX_NAME_UNITS).min(r.left() / 2); - Some((r.bytes(n * 2)?, layout::for_version(1200)?)) - }); - if let Some((units, l)) = wide { - let s = name(units, &l, self.warn); - if !s.trim().is_empty() { - return Some(s); - } - } - let mut r = Rd::at(field(body, 1)?, 12); - let n = usize::from(r.u16()?).min(r.left()); - let s = name(r.bytes(n)?, &layout::for_version(1100)?, self.warn); - (!s.trim().is_empty()).then_some(s) - } - - /// A curve (R62): field 1 its rendering attributes, field 2 a u16 point count, the points (i32 - /// x and y) and one type byte for each. Points are from the page's center, y up. - fn curve(&mut self, body: &[u8]) -> Option { - let mut r = Rd::new(field(body, 2).unwrap_or_default()); - let Some(count) = r.u16().map(usize::from) else { - // A curve without its points is lost. - push(self.warn, Warning::Damaged); - return None; - }; - // `stored` points are read, so the type bytes are found after all of them, and the first - // `n`, those that have a type byte, are kept. When the field holds every point, a short - // field has lost type bytes. When it holds whole points and their types for fewer points, - // the count is too large. Otherwise the field lost points, and its type bytes can't be - // found: the curve is lost. - let left = r.left(); - let (stored, n) = match count.checked_mul(8).filter(|c| *c <= left) { - Some(c) => (count, count.min(left - c)), - None if left.is_multiple_of(9) => (left / 9, left / 9), - None => { - push(self.warn, Warning::Damaged); - return None; - } - }; - if n < count { - push(self.warn, Warning::Damaged); - } - if !self.budget.take_coordinates(stored) { - push(self.warn, Warning::TooDeep); - return None; - } - let mut points = Vec::with_capacity(stored); - for _ in 0..stored { - let (x, y) = (f64::from(r.i32()?) * self.unit, f64::from(r.i32()?) * self.unit); - points.push(Pt { x: x - self.center.0, y: y - self.center.1 }); - } - points.truncate(n); - let path = path_of(&points, r.bytes(n)?); - if path.subpaths.is_empty() { - return None; - } - let (fill, outline) = self.attributes(field(body, 1).unwrap_or_default()); - Some(Shape::new(Geometry::Path(path), Matrix::IDENTITY, fill, outline)) - } - - /// Rendering attributes (R63): a mask (1 fill, 2 outline, 4 lens), then a field list for the - /// fill and one for the outline when the mask names them. - fn attributes(&mut self, a: &[u8]) -> (Option, Option) { - let Some(&mask) = a.first() else { return (None, None) }; - let mut pos = 1; - let mut fill = None; - if mask & 1 != 0 { - let end = list_end(a, pos); - let list = a.get(pos..end).unwrap_or_default(); - pos = end; - // Field 1: the fill type (u16), then its own field list; type 1, uniform, names its - // color in field 1. - let v = field(list, 1).unwrap_or_default(); - match Rd::new(v).u16() { - Some(0) | None => {} - Some(1) => { - let index = field(v.get(2..).unwrap_or_default(), 1).and_then(|c| Rd::new(c).u16()); - fill = Some(match index { - Some(i) => self.tables.color(i, self.warn), - None => { - push(self.warn, Warning::Damaged); - Color::Rgb([0.0; 3]) - } - }); - } - Some(_) => push(self.warn, Warning::UnsupportedFills), - } - } - let mut outline = None; - if mask & 2 != 0 { - let list = a.get(pos..list_end(a, pos)).unwrap_or_default(); - match field(list, 1).and_then(|f| Rd::new(f).u16()) { - Some(i) => outline = self.tables.outline(i, self.budget, self.warn), - None => push(self.warn, Warning::Damaged), - } - } - if mask & 4 != 0 { - push(self.warn, Warning::Lenses); - } - // A canvas (8) or a container (16) is not read. - if mask & (8 | 16) != 0 { - push(self.warn, Warning::UnsupportedObjects); - } - (fill, outline) - } -} diff --git a/crates/cdr/src/geometry.rs b/crates/cdr/src/geometry.rs deleted file mode 100644 index 61b776f23a..0000000000 --- a/crates/cdr/src/geometry.rs +++ /dev/null @@ -1,455 +0,0 @@ -//! The coordinates argument (30) of each object type read as geometry: curves (R16), rectangles -//! (R15), ellipses and arcs (R17) and polygons (R18). - -use std::f64::consts::PI; - -use crate::Warning; -use crate::bytes::Rd; -use crate::layout::Profile; -use crate::limits::Budget; -use crate::model::{Geometry, Path, Pt, Segment, SubPath}; -use crate::records::{angle, coord}; -use crate::riff::push; - -/// The most sides a polygon record may give (VectorCraft's own bound). -const MAX_POLYGON_SIDES: u32 = 1000; -/// The base curve of a polygon lies on a circle of 1000 mm (R18), in points. -const POLYGON_UNIT_RADIUS: f64 = 1000.0 / 25.4 * 72.0; - -/// What a point type byte asks for (R16): bits 7 and 6. -#[derive(Clone, Copy, PartialEq, Eq)] -enum Op { - Move, - Line, - Curve, - Control, -} - -fn op(t: u8) -> Op { - match t >> 6 { - 0 => Op::Move, - 1 => Op::Line, - 2 => Op::Curve, - _ => Op::Control, - } -} - -/// Bit 3 closes the subpath (R16). -const CLOSES: u8 = 0x08; - -/// A point list (R16): the count, the points, then one type byte each. The count is a u32 from -/// version 6 and a u16 followed by another u16 before it (R39). It is held to what the bytes hold; -/// `None` when the points are past the budget. -pub(crate) fn point_list(b: &[u8], p: &Profile, budget: &mut Budget, warn: &mut Vec) -> Option { - let mut r = Rd::new(b); - let count = if p.short { - let count = usize::from(r.u16()?); - r.skip(2)?; - count - } else { - r.u32()? as usize - }; - points(b, r, count, p, budget, warn) -} - -/// A path record (object type 0x25, R30): 4 bytes, two u16 counts whose sum is the point count, 16 -/// bytes, then the points and their type bytes as in a point list. -pub(crate) fn path_record(b: &[u8], p: &Profile, budget: &mut Budget, warn: &mut Vec) -> Option { - let mut r = Rd::new(b); - r.skip(4)?; - let count = usize::from(r.u16()?) + usize::from(r.u16()?); - r.skip(16)?; - points(b, r, count, p, budget, warn) -} - -/// `count` points from `r` over `b`, then their type bytes. A list cut short is read two ways: as -/// all `count` points with the type bytes after them, and as the points and type bytes the bytes -/// hold split evenly. The reading that keeps more points with a type byte wins, the first on a tie. -fn points(b: &[u8], mut r: Rd, count: usize, p: &Profile, budget: &mut Budget, warn: &mut Vec) -> Option { - let each = 2 * p.word(); - let left = r.left(); - let split = (left / (each + 1)).min(count); - let whole = count.checked_mul(each).filter(|len| *len <= left).map(|len| (left - len).min(count)); - let stored = match whole { - Some(typed) if typed >= split => count, - _ => split, - }; - let types = b.get(r.pos() + stored * each..)?; - let n = stored.min(types.len()); - if count > n { - push(warn, Warning::Damaged); - } - if !budget.take_coordinates(n) { - push(warn, Warning::TooDeep); - return None; - } - let mut points = Vec::with_capacity(n); - for _ in 0..n { - points.push(Pt { x: coord(&mut r, p)?, y: coord(&mut r, p)? }); - } - Some(path_of(&points, types)) -} - -/// The subpaths that points and their type bytes draw. -pub(crate) fn path_of(points: &[Pt], types: &[u8]) -> Path { - let mut subpaths = Vec::new(); - let mut cur: Option = None; - // The last two control points: a curve end uses only those. - let mut controls: Vec = Vec::with_capacity(2); - for (&pt, &t) in points.iter().zip(types) { - let o = op(t); - if o == Op::Control { - if controls.len() == 2 { - controls.remove(0); - } - controls.push(pt); - continue; - } - if o == Op::Move || cur.is_none() { - subpaths.extend(cur.take()); - cur = Some(SubPath { start: pt, segments: Vec::new(), closed: t & CLOSES != 0 && o == Op::Move }); - controls.clear(); - if o == Op::Move { - continue; - } - } - let Some(sp) = cur.as_mut() else { continue }; - let seg = match (o, controls.as_slice()) { - (Op::Curve, [c1, c2]) => Segment::Cubic(*c1, *c2, pt), - _ => Segment::Line(pt), - }; - controls.clear(); - sp.segments.push(seg); - if t & CLOSES != 0 { - sp.closed = true; - } - } - subpaths.extend(cur); - // A closed subpath with no segments, or an open one with none, draws nothing. - subpaths.retain(|s| !s.segments.is_empty()); - Path { subpaths } -} - -/// A rectangle record (R15): width, height, then one corner radius for every corner, four from -/// version 9. -pub(crate) fn rect(b: &[u8], p: &Profile) -> Option { - if p.f64_rect { - return rect_f64(b, p); - } - let mut r = Rd::new(b); - let (w, h) = (coord(&mut r, p)?, coord(&mut r, p)?); - let first = coord(&mut r, p)?.abs(); - let mut radii = [first; 4]; - if p.four_radii { - for slot in radii.iter_mut().skip(1) { - *slot = coord(&mut r, p)?.abs(); - } - } - Some(Geometry::Rect { w, h, radii }) -} - -/// A rectangle record from version 15 (R29): width and height as f64 coordinate units, two scale -/// factors that repeat the transform's (not applied), the scale-with flag and 7 bytes, then the -/// four radii as f64 16 bytes apart. With the flag clear each radius is a share of half the shorter -/// side; with it set the radius is in inches. A corner is held to half the shorter side, and -/// sizes to the range of the 32-bit coordinates of earlier versions. -fn rect_f64(b: &[u8], p: &Profile) -> Option { - let mut r = Rd::new(b); - let size = |v: f64| (v.abs() <= f64::from(i32::MAX)).then(|| v * p.unit()); - let (w, h) = (size(r.f64()?)?, size(r.f64()?)?); - r.skip(8 + 8)?; - let inches = r.u8()? != 0; - r.skip(7)?; - let short = w.abs().min(h.abs()); - let mut radii = [0.0; 4]; - for (k, slot) in radii.iter_mut().enumerate() { - if k > 0 { - r.skip(16)?; - } - let v = r.f64()?.abs(); - let radius = if inches { v * 72.0 } else { v * short / 2.0 }; - *slot = radius.min(short / 2.0); - } - Some(Geometry::Rect { w, h, radii }) -} - -/// An ellipse record (R17): the box's width and height, the start and end angles and whether -/// the arc closes through the centre. Equal angles make a whole ellipse. -pub(crate) fn ellipse(b: &[u8], p: &Profile) -> Option { - let mut r = Rd::new(b); - let (w, h) = (coord(&mut r, p)?, coord(&mut r, p)?); - let (a1, a2) = (angle(&mut r, p)?, angle(&mut r, p)?); - let pie = if p.short { r.u16()? != 0 } else { r.u32()? != 0 }; - let sweep = (a2 - a1).rem_euclid(360.0); - if sweep.abs() < 1e-9 { - return Some(Geometry::Ellipse { w, h }); - } - Some(Geometry::Path(arc(w, h, a1, sweep, pie))) -} - -/// The arc of the ellipse in the box from the origin to (`w`, `h`), from `start` degrees through -/// `sweep` degrees, in the ellipse's own axes; a pie runs from the centre and closes there. The -/// radii are half the size, and a negative width or height points its axis the other way (R17), so -/// with a negative height 0 to 180 degrees is the half below the centre. -fn arc(w: f64, h: f64, start: f64, sweep: f64, pie: bool) -> Path { - let (cx, cy, rx, ry) = (w / 2.0, h / 2.0, w / 2.0, h / 2.0); - let at = |t: f64| Pt { x: cx + rx * t.cos(), y: cy + ry * t.sin() }; - let tangent = |t: f64| Pt { x: -rx * t.sin(), y: ry * t.cos() }; - let pieces = (sweep / 90.0).ceil().max(1.0) as usize; - let step = sweep.to_radians() / pieces as f64; - let k = 4.0 / 3.0 * (step / 4.0).tan(); - let t0 = start.to_radians(); - let mut segments = Vec::with_capacity(pieces + 2); - if pie { - segments.push(Segment::Line(at(t0))); - } - for i in 0..pieces { - let (a, b) = (t0 + step * i as f64, t0 + step * (i + 1) as f64); - let (p0, p1, d0, d1) = (at(a), at(b), tangent(a), tangent(b)); - segments.push(Segment::Cubic(Pt { x: p0.x + k * d0.x, y: p0.y + k * d0.y }, Pt { x: p1.x - k * d1.x, y: p1.y - k * d1.y }, p1)); - } - let start = if pie { Pt { x: cx, y: cy } } else { at(t0) }; - Path { subpaths: vec![SubPath { start, segments, closed: pie }] } -} - -/// A polygon (R18): its base curve, one side of the outline on a circle of 1000 mm with its top -/// vertex first, copied once per side and turned clockwise each time by the vertices the side -/// spans, then scaled by (`rx`, `ry`) and moved to the centre the polygon argument (11000) gives. -/// A star whose sides skip vertices draws as one outline, or as several when the side count and -/// the step share a factor. -pub(crate) fn polygon(base: &Path, b: &[u8], p: &Profile, budget: &mut Budget, warn: &mut Vec) -> Option { - let mut r = Rd::new(b); - if !p.tagged { - r.skip(4)?; - } - let sides = r.u32()?; - // The next point: the first field, or the second when the first is 0 or 1. - let (first, second) = (r.u32()?, r.u32()?); - let next = if first > 1 { first } else { second }; - if p.tagged { - r.skip(4)?; - } - let (rx, ry) = (r.f64()?, r.f64()?); - let (cx, cy) = (coord(&mut r, p)?, coord(&mut r, p)?); - let side = base.subpaths.first()?; - if !(1..=MAX_POLYGON_SIDES).contains(&sides) { - push(warn, Warning::Damaged); - return None; - } - if !budget.take_coordinates(side.segments.len().saturating_mul(3).saturating_mul(sides as usize)) { - push(warn, Warning::TooDeep); - return None; - } - // The base curve's own unit radius, measured from its first point, keeps the scale right - // whatever unit the file's coordinates are in. - let unit = side.start.x.hypot(side.start.y); - let unit = if unit > 0.0 { unit } else { POLYGON_UNIT_RADIUS }; - let place = |q: Pt, turn: f64| { - let (s, c) = turn.sin_cos(); - let (x, y) = (q.x * c - q.y * s, q.x * s + q.y * c); - Pt { x: x / unit * POLYGON_UNIT_RADIUS * rx + cx, y: y / unit * POLYGON_UNIT_RADIUS * ry + cy } - }; - let step = side_step(side, sides, next); - let outlines = gcd(sides, step); - let each = sides / outlines; - let angle = |k: u32| -2.0 * PI * f64::from(k % sides) / f64::from(sides); - let mut subpaths = Vec::with_capacity(outlines as usize); - for o in 0..outlines { - let mut segments = Vec::with_capacity(side.segments.len() * each as usize); - for j in 0..each { - let turn = angle(o + j * step); - segments.extend(side.segments.iter().map(|s| match *s { - Segment::Line(a) => Segment::Line(place(a, turn)), - Segment::Cubic(a, b, c) => Segment::Cubic(place(a, turn), place(b, turn), place(c, turn)), - })); - } - subpaths.push(SubPath { start: place(side.start, angle(o)), segments, closed: true }); - } - Some(Geometry::Path(Path { subpaths })) -} - -/// How many vertices the base side moves on from its first point (R18): the vertex its last -/// point lies at, clockwise; else the next-point field when it names one; else 1. -fn side_step(side: &SubPath, sides: u32, next: u32) -> u32 { - let field = if (1..sides).contains(&next) { next } else { 1 }; - let Some(end) = side.segments.last().map(|s| match *s { - Segment::Line(e) | Segment::Cubic(_, _, e) => e, - }) else { - return field; - }; - let (r0, r1) = (side.start.x.hypot(side.start.y), end.x.hypot(end.y)); - if !(r0 > 0.0 && (r1 - r0).abs() <= r0 * 1e-3) { - return field; - } - let turned = (side.start.y.atan2(side.start.x) - end.y.atan2(end.x)) / (2.0 * PI / f64::from(sides)); - let k = turned.round(); - if !k.is_finite() || (turned - k).abs() > 1e-3 { - return field; - } - match k.rem_euclid(f64::from(sides)) as u32 { - 0 => field, - k => k, - } -} - -fn gcd(a: u32, b: u32) -> u32 { - let (mut a, mut b) = (a, b); - while b != 0 { - (a, b) = (b, a % b); - } - a.max(1) -} - -#[cfg(test)] -mod tests { - use super::*; - - fn pt(x: f64, y: f64) -> Pt { - Pt { x, y } - } - - #[test] - fn type_bytes_make_moves_lines_curves_and_closes() { - let points = [pt(0.0, 0.0), pt(10.0, 0.0), pt(10.0, 5.0), pt(5.0, 10.0), pt(0.0, 10.0), pt(20.0, 20.0), pt(30.0, 20.0)]; - // move (closed), line, control, control, curve end closing; move, line. - let types = [0x08, 0x40, 0xC0, 0xC0, 0x88, 0x00, 0x40]; - let path = path_of(&points, &types); - assert_eq!(path.subpaths.len(), 2); - let first = &path.subpaths[0]; - assert!(first.closed); - assert_eq!(first.segments, vec![Segment::Line(pt(10.0, 0.0)), Segment::Cubic(pt(10.0, 5.0), pt(5.0, 10.0), pt(0.0, 10.0))]); - assert!(!path.subpaths[1].closed); - } - - #[test] - fn a_point_list_short_of_type_bytes_reads_them_after_all_its_points() { - let p = crate::layout::for_version(1300).unwrap_or_else(|| panic!("profile")); - // Three points, (0, 0), (1 inch, 0) and (0, 0), and type bytes for the first two only. - let mut b = 3u32.to_le_bytes().to_vec(); - for v in [0i32, 0, 254_000, 0, 0, 0] { - b.extend(v.to_le_bytes()); - } - b.extend([0x00, 0x40]); - let mut warn = vec![]; - let path = point_list(&b, &p, &mut Budget::new(crate::Limits::default()), &mut warn).unwrap_or_else(|| panic!("path")); - assert_eq!(path.subpaths.len(), 1); - assert_eq!(path.subpaths[0].segments, vec![Segment::Line(pt(72.0, 0.0))]); - assert_eq!(warn, vec![Warning::Damaged]); - // A count past the points the bytes hold keeps the points that have a type byte. - // Eight points and their eight type bytes take the bytes of nine points. - let mut b = 9u32.to_le_bytes().to_vec(); - for i in 0..8 { - b.extend((i * 254_000i32).to_le_bytes()); - b.extend(0i32.to_le_bytes()); - } - b.extend([0x00, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40]); - let mut warn = vec![]; - let path = point_list(&b, &p, &mut Budget::new(crate::Limits::default()), &mut warn).unwrap_or_else(|| panic!("path")); - assert_eq!(path.subpaths[0].segments.len(), 7); - assert!(matches!(path.subpaths[0].segments[6], Segment::Line(end) if (end.x - 504.0).abs() < 1e-9 && end.y == 0.0)); - assert_eq!(warn, vec![Warning::Damaged]); - } - - #[test] - fn a_run_of_control_points_keeps_the_last_two() { - let points: Vec = (0..7).map(|i| pt(f64::from(i), 0.0)).collect(); - let path = path_of(&points, &[0x00, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0x80]); - assert_eq!(path.subpaths[0].segments, vec![Segment::Cubic(pt(4.0, 0.0), pt(5.0, 0.0), pt(6.0, 0.0))]); - } - - #[test] - fn a_curve_end_without_two_controls_is_a_line() { - let path = path_of(&[pt(0.0, 0.0), pt(1.0, 1.0)], &[0x00, 0x80]); - assert_eq!(path.subpaths[0].segments, vec![Segment::Line(pt(1.0, 1.0))]); - } - - #[test] - fn a_quarter_arc_ends_on_the_ellipse() { - let p = arc(20.0, 10.0, 0.0, 90.0, false); - let sp = &p.subpaths[0]; - assert_eq!(sp.start, pt(20.0, 5.0)); - let Some(Segment::Cubic(_, _, end)) = sp.segments.last() else { panic!("no curve") }; - assert!((end.x - 10.0).abs() < 1e-9 && (end.y - 10.0).abs() < 1e-9); - let pie = arc(20.0, 10.0, 0.0, 180.0, true); - assert!(pie.subpaths[0].closed && pie.subpaths[0].start == pt(10.0, 5.0)); - } - - #[test] - fn a_negative_height_turns_the_arc_below_the_centre() { - let p = arc(20.0, -10.0, 0.0, 180.0, false); - let sp = &p.subpaths[0]; - assert_eq!(sp.start, pt(20.0, -5.0)); - let Some(Segment::Cubic(_, _, mid)) = sp.segments.first() else { panic!("no curve") }; - assert!((mid.x - 10.0).abs() < 1e-9 && (mid.y + 10.0).abs() < 1e-9, "{mid:?}"); - } - - /// A version 13 polygon argument: `sides`, the two next-point fields, then rx = ry = 1 at the - /// origin. - fn polygon_arg(sides: u32, first: u32, second: u32) -> Vec { - let mut b = Vec::new(); - for v in [sides, first, second, 0] { - b.extend(v.to_le_bytes()); - } - b.extend(1.0f64.to_le_bytes()); - b.extend(1.0f64.to_le_bytes()); - b.extend([0; 8]); - b - } - - /// Vertex `k` of `sides`, counted clockwise from the top, on the base circle. - fn vertex(k: u32, sides: u32) -> Pt { - let a = PI / 2.0 - 2.0 * PI * f64::from(k) / f64::from(sides); - pt(POLYGON_UNIT_RADIUS * a.cos(), POLYGON_UNIT_RADIUS * a.sin()) - } - - fn ends(sp: &SubPath) -> Vec { - sp.segments - .iter() - .map(|s| match *s { - Segment::Line(e) | Segment::Cubic(_, _, e) => e, - }) - .collect() - } - - fn close(a: &[Pt], b: &[Pt]) -> bool { - a.len() == b.len() && a.iter().zip(b).all(|(p, q)| (p.x - q.x).abs() < 1e-6 && (p.y - q.y).abs() < 1e-6) - } - - fn star(sides: u32, step: u32, first: u32, second: u32) -> Path { - let p = crate::layout::for_version(1300).unwrap(); - let base = Path { subpaths: vec![SubPath { start: vertex(0, sides), segments: vec![Segment::Line(vertex(step, sides))], closed: false }] }; - let mut budget = Budget::new(crate::Limits::default()); - let Some(Geometry::Path(path)) = polygon(&base, &polygon_arg(sides, first, second), &p, &mut budget, &mut vec![]) else { - panic!("no polygon") - }; - path - } - - #[test] - fn a_star_whose_sides_skip_a_vertex_chains_its_points() { - // {5/2}: each side runs two vertices on, so the outline visits 2, 4, 1, 3 and 0. - let path = star(5, 2, 2, 0); - assert_eq!(path.subpaths.len(), 1); - let want: Vec = [2, 4, 1, 3, 0].iter().map(|&k| vertex(k, 5)).collect(); - assert!(close(&ends(&path.subpaths[0]), &want), "{:?}", ends(&path.subpaths[0])); - // The base side alone tells the step when the field doesn't. - assert!(close(&ends(&star(5, 2, 0, 0).subpaths[0]), &want)); - } - - #[test] - fn a_star_sharing_a_factor_with_its_sides_draws_one_outline_for_each() { - // {6/2}: two triangles, 0-2-4 and 1-3-5. - let path = star(6, 2, 0, 2); - assert_eq!(path.subpaths.len(), 2); - assert!(close(&ends(&path.subpaths[0]), &[vertex(2, 6), vertex(4, 6), vertex(0, 6)])); - assert!(close(&[path.subpaths[1].start], &[vertex(1, 6)])); - assert!(close(&ends(&path.subpaths[1]), &[vertex(3, 6), vertex(5, 6), vertex(1, 6)])); - } - - #[test] - fn a_plain_polygon_turns_one_vertex_for_each_side() { - let path = star(4, 1, 0, 1); - assert_eq!(path.subpaths.len(), 1); - assert!(close(&ends(&path.subpaths[0]), &[1, 2, 3, 0].map(|k| vertex(k, 4)))); - } -} diff --git a/crates/cdr/src/inline.rs b/crates/cdr/src/inline.rs deleted file mode 100644 index 3d5214f136..0000000000 --- a/crates/cdr/src/inline.rs +++ /dev/null @@ -1,230 +0,0 @@ -//! What a version 3 object holds as arguments where later versions name records: its transforms -//! (argument 100, R33), its fill (argument 20, R34) and its outline (argument 10, R35). - -use crate::bytes::Rd; -use crate::layout::Profile; -use crate::model::{Cap, Color, Join, Matrix, Outline}; -use crate::records::{self, angle, coord}; -use crate::riff::push; -use crate::{Limits, Warning}; - -/// Transform entry types (R33): a matrix, and an envelope. -const MATRIX: u16 = 0x8c; -const ENVELOPE: u16 = 0x14; -/// The bytes of one transform entry (R33). -const ENTRY: usize = 10; -/// The bytes an outline keeps for its dashes, one byte each (R35). -const DASH_AREA: usize = 10; - -/// The transforms of one object or group. -#[derive(Clone, Copy, Debug, PartialEq)] -pub(crate) struct Placement { - /// The matrices composed in file order, in points. - pub(crate) matrix: Matrix, - /// An envelope bends the shape. The reader doesn't apply envelopes. - pub(crate) envelope: bool, -} - -/// The transforms argument (R33): a u16, the entry count, then 10-byte entries of a type and, at -/// byte 6, where the entry's data starts in the argument. The count is held to the entries the -/// argument holds and to the arguments a record may have. Entries of other types are passed over. -pub(crate) fn transforms(b: &[u8], p: &Profile, limits: &Limits, warn: &mut Vec) -> Option { - let mut r = Rd::new(b); - r.skip(2)?; - let stored = usize::from(r.u16()?); - let count = stored.min(r.left() / ENTRY).min(limits.arguments); - if count < stored { - push(warn, Warning::Damaged); - } - let mut out = Placement { matrix: Matrix::IDENTITY, envelope: false }; - for _ in 0..count { - let mut e = Rd::new(r.bytes(ENTRY)?); - let kind = e.u16()?; - e.skip(4)?; - let at = usize::from(e.u16()?); - match kind { - MATRIX => out.matrix = records::fixed_matrix(&mut Rd::at(b, at), p.unit())?.after(&out.matrix), - ENVELOPE => out.envelope = true, - _ => {} - } - } - Some(out) -} - -/// The fill argument (R34): a type byte, 0 for none and 1 for a uniform fill with its color. Fills -/// of other types read as none with a warning. The outer `None` is an argument that can't be read. -pub(crate) fn fill(b: &[u8], p: &Profile, warn: &mut Vec) -> Option> { - let mut r = Rd::new(b); - match r.u8()? { - 0 => Some(None), - 1 => Some(Some(records::color(&mut r, p, warn)?)), - _ => { - push(warn, Warning::UnsupportedFills); - Some(None) - } - } -} - -/// The outline argument (R35): a flags byte whose bit 0 is set when the object is outlined, the -/// width, the stretch, the nib angle, the color, 7 bytes, the dash count and 10 bytes that hold the -/// dashes, the join and the caps (u16 each), then the two arrowhead ids. An argument that ends -/// after its color gives a solid line with butt caps and miter joins. The outer `None` is an -/// argument that can't be read. -pub(crate) fn outline(b: &[u8], p: &Profile, warn: &mut Vec) -> Option> { - let mut r = Rd::new(b); - if r.u8()? & 1 == 0 { - return Some(None); - } - let width = coord(&mut r, p)?.abs(); - let _stretch = r.u16()?; - let _nib = angle(&mut r, p)?; - let color = records::color(&mut r, p, warn)?; - let mut out = Outline { width, color, cap: Cap::Butt, join: Join::Miter, dashes: Vec::new(), behind_fill: false, scale_with: false }; - let Some(stored) = r.skip(7).and_then(|()| r.u8()).map(usize::from) else { return Some(Some(out)) }; - let Some(area) = r.bytes(DASH_AREA) else { return Some(Some(out)) }; - if stored > DASH_AREA { - push(warn, Warning::Damaged); - } - let dashes: Vec = area.iter().take(stored).map(|d| f64::from(*d)).collect(); - if dashes.iter().any(|d| *d > 0.0) { - out.dashes = dashes; - } - out.join = match r.u16() { - Some(1) => Join::Round, - Some(2) => Join::Bevel, - _ => Join::Miter, - }; - out.cap = match r.u16() { - Some(1) => Cap::Round, - Some(2) => Cap::Square, - _ => Cap::Butt, - }; - if matches!((r.u32(), r.u32()), (Some(s), Some(e)) if s != 0 || e != 0) { - push(warn, Warning::Arrowheads); - } - Some(Some(out)) -} - -#[cfg(test)] -mod tests { - use super::*; - - fn p3() -> Profile { - crate::layout::for_version(300).unwrap() - } - - /// A transforms argument of `entries` (type, data offset), then `data` from byte 4 + 10 for - /// each entry. - fn arg(count: u16, entries: &[(u16, u16)], data: &[i32]) -> Vec { - let mut b = vec![0, 0]; - b.extend(count.to_le_bytes()); - for (kind, at) in entries { - b.extend(kind.to_le_bytes()); - b.extend([0; 4]); - b.extend(at.to_le_bytes()); - b.extend([0; 2]); - } - b.extend(data.iter().flat_map(|v| v.to_le_bytes())); - b - } - - #[test] - fn matrices_compose_in_file_order_and_other_entries_are_passed_over() { - // Scale by 2, then move 1 inch right: entry types 0x8c, an unknown one and 0x8c. - let scale = [131072, 0, 0, 0, 131072, 0]; - let shift = [65536, 0, 1000, 0, 65536, 0]; - let b = arg(3, &[(MATRIX, 34), (0x99, 0), (MATRIX, 58)], &[scale, shift].concat()); - let mut w = vec![]; - let t = transforms(&b, &p3(), &Limits::default(), &mut w).unwrap(); - assert_eq!((t.matrix, t.envelope), (Matrix([2.0, 0.0, 0.0, 2.0, 72.0, 0.0]), false)); - assert!(w.is_empty()); - let b = arg(2, &[(MATRIX, 24), (ENVELOPE, 0)], &scale); - assert!(transforms(&b, &p3(), &Limits::default(), &mut vec![]).unwrap().envelope); - } - - #[test] - fn hostile_transform_arguments_do_not_read_past_their_bytes() { - let scale = [131072, 0, 0, 0, 131072, 0]; - // A count of 65,535 over one entry reads that entry, with the damage warning. - let b = arg(u16::MAX, &[(MATRIX, 14)], &scale); - let mut w = vec![]; - assert_eq!(transforms(&b, &p3(), &Limits::default(), &mut w).unwrap().matrix.0[0], 2.0); - assert_eq!(w, vec![Warning::Damaged]); - // A data offset past the argument, and one that leaves less than a matrix. - for at in [5000, 14 + 4] { - assert!(transforms(&arg(1, &[(MATRIX, at)], &scale), &p3(), &Limits::default(), &mut vec![]).is_none(), "{at}"); - } - // More entries than a record may have arguments. - let many: Vec<(u16, u16)> = vec![(0x99, 0); 100]; - let limits = Limits { arguments: 8, ..Limits::default() }; - let mut w = vec![]; - assert!(transforms(&arg(100, &many, &[]), &p3(), &limits, &mut w).is_some()); - assert_eq!(w, vec![Warning::Damaged]); - for len in 0..4 { - assert!(transforms(&b[..len], &p3(), &Limits::default(), &mut vec![]).is_none()); - } - } - - /// An outline argument: flags, width in 1/1000 inch, black, `dashes`, join, caps, arrowheads. - fn outline_arg(flags: u8, count: u8, dashes: &[u8], join: u16, cap: u16, heads: [u32; 2]) -> Vec { - let mut b = vec![flags]; - b.extend(28i16.to_le_bytes()); - b.extend([100, 0, 0, 0]); - b.extend([1, 0, 0, 0, 100]); - b.extend([0; 7]); - b.push(count); - let mut area = dashes.to_vec(); - area.resize(DASH_AREA, 0); - b.extend(area); - b.extend(join.to_le_bytes()); - b.extend(cap.to_le_bytes()); - b.extend(heads.iter().flat_map(|h| h.to_le_bytes())); - b - } - - #[test] - fn an_outline_reads_its_width_color_dashes_join_and_caps() { - let mut w = vec![]; - let o = outline(&outline_arg(1, 2, &[3, 1], 1, 2, [0, 0]), &p3(), &mut w).unwrap().unwrap(); - assert!((o.width - 2.016).abs() < 1e-9, "{}", o.width); - assert_eq!((o.color, o.join, o.cap, o.dashes), (Color::Cmyk([0.0, 0.0, 0.0, 1.0]), Join::Round, Cap::Square, vec![3.0, 1.0])); - assert!(w.is_empty()); - // Bit 0 clear: no outline, whatever follows. - assert_eq!(outline(&outline_arg(0, 2, &[3, 1], 1, 2, [7, 0]), &p3(), &mut w), Some(None)); - assert_eq!(outline(&[0], &p3(), &mut w), Some(None)); - assert!(w.is_empty()); - outline(&outline_arg(1, 0, &[], 0, 0, [0, 9]), &p3(), &mut w).unwrap().unwrap(); - assert_eq!(w, vec![Warning::Arrowheads]); - } - - #[test] - fn a_dash_count_past_the_dash_bytes_is_held_to_them() { - let mut w = vec![]; - let o = outline(&outline_arg(1, 255, &[2; 10], 0, 0, [0, 0]), &p3(), &mut w).unwrap().unwrap(); - assert_eq!(o.dashes.len(), DASH_AREA); - assert_eq!(w, vec![Warning::Damaged]); - // An argument that ends inside the dashes keeps a solid line; one cut before the color is - // unreadable. - let full = outline_arg(1, 255, &[2; 10], 0, 0, [0, 0]); - assert_eq!(outline(&full[..25], &p3(), &mut vec![]).unwrap().unwrap().dashes, Vec::::new()); - assert_eq!(outline(&full[..12], &p3(), &mut vec![]).unwrap().unwrap().cap, Cap::Butt); - for len in 0..12 { - assert!(outline(&full[..len], &p3(), &mut vec![]).is_none(), "{len}"); - } - } - - #[test] - fn fills_read_none_uniform_and_other_types() { - let mut w = vec![]; - assert_eq!(fill(&[0], &p3(), &mut w), Some(None)); - assert_eq!(fill(&[1, 1, 100, 0, 0, 0], &p3(), &mut w), Some(Some(Color::Cmyk([1.0, 0.0, 0.0, 0.0])))); - assert!(w.is_empty()); - for kind in [2, 4, 6, 7, 10] { - let mut w = vec![]; - assert_eq!(fill(&[kind, 0, 0], &p3(), &mut w), Some(None)); - assert_eq!(w, vec![Warning::UnsupportedFills], "{kind}"); - } - assert_eq!(fill(&[], &p3(), &mut w), None); - assert_eq!(fill(&[1, 1, 100], &p3(), &mut w), None); - } -} diff --git a/crates/cdr/src/layout.rs b/crates/cdr/src/layout.rs deleted file mode 100644 index 46c28496cf..0000000000 --- a/crates/cdr/src/layout.rs +++ /dev/null @@ -1,181 +0,0 @@ -//! Where the fields of each record lie, by version: one table, resolved once per file. Each field -//! names the `PROVENANCE.md` row it rests on. - -/// The layouts of one range of versions. -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub(crate) struct Profile { - /// Coordinates are i16 in 1/1000 inch, record headers, counts and angles 16-bit (R5, R6, R7). - pub(crate) short: bool, - /// Bytes before the page size in `mcfg` (R10). - pub(crate) mcfg_skip: usize, - /// Bytes before a `trfd` entry's type (R8). - pub(crate) trfd_head: usize, - /// Bytes between a matrix entry's type and its six numbers (R8). - pub(crate) matrix_skip: usize, - /// Fill and outline records start with tagged records (R11, R12). - pub(crate) tagged: bool, - /// Outline: bytes after the join, after the stretch, after the nib angle and after the color - /// (R12). - pub(crate) outl_after_join: usize, - pub(crate) outl_after_stretch: usize, - pub(crate) outl_after_angle: usize, - pub(crate) outl_after_color: usize, - /// Where the start marker id lies after the first dash (R13); `None` where no source says. - pub(crate) marker_after_dash: Option, - /// Rectangles carry four corner radii, not one (R15). - pub(crate) four_radii: bool, - /// Rectangles are f64 sizes with radii as shares of half the shorter side (R29). - pub(crate) f64_rect: bool, - /// The master page flags its guides and desktop layers the way of versions 7 to 13 (R19). - pub(crate) old_master_flags: bool, - /// Object type 0x25 is a path (R30). - pub(crate) paths: bool, - /// Names are UTF-16LE, not Windows-1252 (R9). - pub(crate) utf16_names: bool, - /// An object holds its transform, fill and outline as arguments; there are no `trfd`, `fill` - /// or `outl` records (R33, R34, R35). - pub(crate) inline_styles: bool, - /// Object types count from 0: rectangle 0, ellipse 1, curve 2, text 3, bitmap 4 (R32). - pub(crate) types_from_zero: bool, - /// How a color is laid out (R14, R36). - pub(crate) color: ColorLayout, - /// A matrix is six i32 with its factors in 16.16 fixed point, not six f64 (R37). - pub(crate) fixed_matrix: bool, - /// `mcfg` holds 2 bytes and the page's two corners, not its width and height (R38). - pub(crate) mcfg_corners: bool, -} - -/// The layouts of a color. -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub(crate) enum ColorLayout { - /// A model byte and four value bytes (R36). - Bytes5, - /// A model u16, four u16 values and 2 bytes (R36). - Words12, - /// A model u16, a palette u16, 4 bytes and four value bytes (R14). - Record12, -} - -const fn profile(from: u16) -> Profile { - let short = from < 600; - Profile { - short, - inline_styles: from < 400, - types_from_zero: from < 400, - color: if from < 400 { - ColorLayout::Bytes5 - } else if from < 500 { - ColorLayout::Words12 - } else { - ColorLayout::Record12 - }, - fixed_matrix: from < 500, - mcfg_corners: from < 400, - mcfg_skip: if from >= 1300 { - 12 - } else if from >= 900 { - 4 - } else if from >= 600 && from < 700 { - 28 - } else { - 0 - }, - trfd_head: if from >= 1300 { 8 } else { 0 }, - matrix_skip: if short { 0 } else { 6 }, - tagged: from >= 1300, - outl_after_join: if from >= 600 && from < 1300 { 2 } else { 0 }, - outl_after_stretch: if short { 0 } else { 2 }, - outl_after_angle: if from >= 1300 { - 46 - } else if !short { - 52 - } else { - 0 - }, - outl_after_color: if short { 10 } else { 16 }, - marker_after_dash: if from >= 1300 { - Some(20) - } else if from >= 600 { - Some(22) - } else { - None - }, - four_radii: from >= 900, - f64_rect: from >= 1500, - old_master_flags: from < 1400, - paths: from >= 1000, - utf16_names: from >= 1200, - } -} - -/// The newest version read: 27, as the `vrsn` chunk names it (R1, R2). -pub(crate) const NEWEST: u16 = 2799; - -/// The first version of each range, with its layouts. Ranges start where a field moves. -const PROFILES: &[(u16, Profile)] = &[ - (300, profile(300)), - (400, profile(400)), - (500, profile(500)), - (600, profile(600)), - (700, profile(700)), - (800, profile(800)), - (900, profile(900)), - (1000, profile(1000)), - (1100, profile(1100)), - (1200, profile(1200)), - (1300, profile(1300)), - (1400, profile(1400)), - (1500, profile(1500)), - (1600, profile(1600)), -]; - -/// The oldest version of a RIFF file read: 3 (R31). Versions 1 and 2 are not RIFF files (`wl.rs`). -pub(crate) const OLDEST_RIFF: u16 = 300; - -/// The layouts of the RIFF file of `version` (hundreds; 801 is the 8.01 variant, 2430 is 24.3), or -/// `None` outside 3 to 27. -pub(crate) fn for_version(version: u16) -> Option { - if !(OLDEST_RIFF..=NEWEST).contains(&version) { - return None; - } - PROFILES.iter().rev().find(|(from, _)| *from <= version).map(|(_, p)| *p) -} - -impl Profile { - /// Points per coordinate unit. - pub(crate) fn unit(&self) -> f64 { - if self.short { 72.0 / 1000.0 } else { 72.0 / 254_000.0 } - } - - /// Bytes of a coordinate, and of header fields and counts. - pub(crate) fn word(&self) -> usize { - if self.short { 2 } else { 4 } - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn every_version_from_3_to_27_has_one_profile() { - assert!(for_version(299).is_none() && for_version(2800).is_none()); - assert!(for_version(300).is_some_and(|p| p.short && p.inline_styles && p.types_from_zero && p.mcfg_corners && p.fixed_matrix)); - assert!(for_version(399).is_some_and(|p| p.color == ColorLayout::Bytes5)); - assert!(for_version(400).is_some_and(|p| p.short && !p.inline_styles && !p.mcfg_corners && p.fixed_matrix)); - assert!(for_version(499).is_some_and(|p| p.color == ColorLayout::Words12)); - assert!(for_version(500).is_some_and(|p| !p.fixed_matrix && !p.types_from_zero && p.color == ColorLayout::Record12)); - assert!(for_version(1300).is_some_and(|p| p.old_master_flags)); - assert!(for_version(1400).is_some_and(|p| p.tagged && !p.f64_rect && !p.old_master_flags)); - assert!(for_version(1500).is_some_and(|p| p.tagged && p.f64_rect && p.mcfg_skip == 12 && p.paths)); - assert!(for_version(2430).is_some_and(|p| p.f64_rect && p.paths && p.utf16_names)); - assert!(for_version(500).is_some_and(|p| p.short && p.mcfg_skip == 0 && p.marker_after_dash.is_none())); - assert!(for_version(600).is_some_and(|p| !p.short && p.mcfg_skip == 28 && p.marker_after_dash == Some(22))); - assert!(for_version(801).is_some_and(|p| p.mcfg_skip == 0 && p.marker_after_dash == Some(22))); - assert!(for_version(999).is_some_and(|p| !p.paths && p.marker_after_dash == Some(22))); - assert!(for_version(1000).is_some_and(|p| p.mcfg_skip == 4 && p.four_radii && !p.utf16_names && p.paths)); - assert!(for_version(1300).is_some_and(|p| p.tagged && p.trfd_head == 8 && p.outl_after_angle == 46)); - // The table is in order, so the search finds each range's own row. - assert!(PROFILES.windows(2).all(|w| w[0].0 < w[1].0)); - } -} diff --git a/crates/cdr/src/lib.rs b/crates/cdr/src/lib.rs deleted file mode 100644 index 64cdae512a..0000000000 --- a/crates/cdr/src/lib.rs +++ /dev/null @@ -1,110 +0,0 @@ -//! Reader for `.cdr` drawings of versions 1 to 27 (`.cdr`, and `.cdt` templates): the `WL` files -//! of versions 1 and 2, the RIFF chunk tree of versions 3 on with its compressed lists, the ZIP -//! packages of versions 14 on with their data streams, then pages, layers, guidelines, groups, -//! curves, rectangles, ellipses, arcs and polygons with uniform fills and outlines. It also reads -//! `.cmx` exchange files with 32-bit coordinates ([`read_cmx`]): their pages, layers, groups and -//! curves with uniform fills and outlines. -//! -//! Every record layout the reader relies on is listed in `PROVENANCE.md` with its public source -//! and status; code cites the row ids (R1 ...). Reading is bounded by [`Limits`], never recurses and does not -//! panic. Nothing here writes `.cdr` or `.cmx` files. -#![forbid(unsafe_code)] -#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)] - -use std::fmt; - -mod build; -mod bytes; -mod cmx; -mod geometry; -mod inline; -mod layout; -mod limits; -pub mod model; -mod package; -mod records; -mod riff; -mod styles; -#[cfg(any(test, feature = "synth"))] -pub mod synth; -#[cfg(any(test, feature = "synth"))] -pub mod synth_cmx; -mod wl; -mod zip; - -pub use limits::Limits; -pub use model::{Drawing, Warning}; - -/// Does `bytes` look like a `.cdr` drawing: a RIFF file, a ZIP package holding one, or a `WL` file -/// of version 1 or 2 whose header offsets fit the file? -pub fn is_cdr(bytes: &[u8]) -> bool { - riff::is_cdr_riff(bytes) || package::is_package(bytes) || wl::is_wl(bytes) -} - -/// Does `bytes` start as a `.cmx` exchange file: a RIFF form (or its big-endian RIFX form) of type -/// `CMX1`? -pub fn is_cmx(bytes: &[u8]) -> bool { - cmx::is_cmx(bytes) -} - -/// Why a file can't be read. -#[derive(Clone, Debug, PartialEq, Eq)] -pub enum Error { - /// Not a `.cdr` drawing. - NotCdr, - /// Not a `.cmx` file. - NotCmx, - /// A drawing of a version this reader doesn't read (hundreds: 2800 is version 28). - Version(u16), - /// A container structure that doesn't parse. - Damaged(&'static str), - /// Past one of the [`Limits`]. - Limit(&'static str), - /// A file this reader doesn't open: an encrypted, ZIP64 or split package, or a RIFF file that - /// names a version before 3; a big-endian `.cmx` file or one with 16-bit coordinates. - Unsupported(&'static str), -} - -impl fmt::Display for Error { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - match self { - Error::NotCdr => write!(f, "not a CDR drawing"), - Error::NotCmx => write!(f, "not a CMX file"), - Error::Version(v) => write!(f, "version {} drawings are not read", v / 100), - Error::Damaged(what) => write!(f, "damaged {what}"), - Error::Limit(what) => write!(f, "past the {what} limit"), - Error::Unsupported(what) => write!(f, "{what} are not read"), - } - } -} - -impl std::error::Error for Error {} - -/// Read a drawing within `limits`. -pub fn read(bytes: &[u8], limits: Limits) -> Result { - if bytes.len() > limits.input { - return Err(Error::Limit("input size")); - } - let mut budget = limits::Budget::new(limits); - // Versions 1 and 2 are not RIFF files (R40). - if wl::is_wl(bytes) { - return wl::drawing(bytes, &mut budget); - } - let mut warnings = Vec::new(); - // Versions 14 on save a ZIP package around the RIFF stream (R24, R25, R26). - let (stream, streams) = if zip::is_zip(bytes) { package::open(bytes, &mut budget)? } else { (std::borrow::Cow::Borrowed(bytes), None) }; - let ix = riff::Index::build(&stream, streams, &mut budget, &mut warnings)?; - let mut drawing = build::drawing(&ix, &mut budget, &mut warnings)?; - ix.stream_warnings(&mut drawing.warnings); - Ok(drawing) -} - -/// Read a `.cmx` exchange file within `limits`. Files in big-endian byte order and files with -/// 16-bit coordinates are refused with [`Error::Unsupported`]. Its [`Drawing::version`] is 0. -pub fn read_cmx(bytes: &[u8], limits: Limits) -> Result { - if bytes.len() > limits.input { - return Err(Error::Limit("input size")); - } - let mut budget = limits::Budget::new(limits); - cmx::drawing(bytes, &mut budget) -} diff --git a/crates/cdr/src/limits.rs b/crates/cdr/src/limits.rs deleted file mode 100644 index 684029c014..0000000000 --- a/crates/cdr/src/limits.rs +++ /dev/null @@ -1,166 +0,0 @@ -//! What one read may take. The values are VectorCraft's own; wasm32 gets half the memory limits. - -use crate::Error; - -/// The most a read may take, checked before every allocation and descent. -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct Limits { - /// Bytes of input. - pub input: usize, - /// Bytes inflated from compressed lists and package members, all of one file together. - pub inflated: usize, - /// Bytes of one package member. - pub member: usize, - /// Members of a package. - pub members: usize, - /// Nested lists below the file's own. Deeper content is left out with a warning. - pub depth: usize, - /// Chunks in the index, nested ones included, and the entries and styles of the style table; - /// in a `.cmx` file, its chunks, table entries and page instructions. - pub chunks: usize, - /// Objects mapped (shapes, groups and guidelines). - pub objects: usize, - /// Points of all curves together. - pub coordinates: usize, - /// Arguments of one `loda` record. - pub arguments: usize, - /// Dashes of all outlines together, an outline's counted again for every shape that uses it. - /// Past them a shape's outline is solid, with a warning. - pub dashes: usize, - /// Chunks walked inside clipped groups, all containers together, a group's counted again for - /// every container that names it. Past them a container's group is left out, with a warning. - pub clipped_chunks: usize, -} - -#[cfg(not(target_arch = "wasm32"))] -const MIB: usize = 1 << 20; - -impl Default for Limits { - #[cfg(not(target_arch = "wasm32"))] - fn default() -> Self { - Limits { - input: 512 * MIB, - inflated: 1024 * MIB, - member: 512 * MIB, - members: 4096, - depth: 256, - chunks: 2_000_000, - objects: 1_000_000, - coordinates: 16_000_000, - arguments: 64, - dashes: 16_000_000, - clipped_chunks: 2_000_000, - } - } - - #[cfg(target_arch = "wasm32")] - fn default() -> Self { - Limits { - input: 256 << 20, - inflated: 512 << 20, - member: 256 << 20, - members: 4096, - depth: 256, - chunks: 2_000_000, - objects: 1_000_000, - coordinates: 16_000_000, - arguments: 64, - dashes: 8_000_000, - clipped_chunks: 2_000_000, - } - } -} - -/// The running counters of one read against its [`Limits`]. -#[derive(Debug)] -pub(crate) struct Budget { - pub(crate) limits: Limits, - inflated: usize, - chunks: usize, - objects: usize, - coordinates: usize, - dashes: usize, - clipped_chunks: usize, - /// A request for coordinates was refused since [`Budget::coordinates_refused`] last asked. - refused: bool, -} - -impl Budget { - pub(crate) fn new(limits: Limits) -> Self { - Budget { limits, inflated: 0, chunks: 0, objects: 0, coordinates: 0, dashes: 0, clipped_chunks: 0, refused: false } - } - - /// Whether a request for coordinates was refused since the last call, which tells a shape - /// left out at the limit from one whose bytes don't parse. - pub(crate) fn coordinates_refused(&mut self) -> bool { - std::mem::take(&mut self.refused) - } - - /// Bytes an inflate may still produce. - pub(crate) fn inflate_left(&self) -> usize { - self.limits.inflated.saturating_sub(self.inflated) - } - - pub(crate) fn take_inflated(&mut self, n: usize) -> Result<(), Error> { - self.inflated = self.inflated.checked_add(n).filter(|&t| t <= self.limits.inflated).ok_or(Error::Limit("inflated size"))?; - Ok(()) - } - - pub(crate) fn take_chunk(&mut self) -> Result<(), Error> { - self.take_chunks(1) - } - - /// `n` more chunks or style table entries. - pub(crate) fn take_chunks(&mut self, n: usize) -> Result<(), Error> { - self.chunks = self.chunks.saturating_add(n); - if self.chunks > self.limits.chunks { Err(Error::Limit("chunk count")) } else { Ok(()) } - } - - /// One more object, or `false` when the drawing already holds as many as a read maps. - pub(crate) fn take_object(&mut self) -> bool { - if self.objects >= self.limits.objects { - return false; - } - self.objects += 1; - true - } - - /// `n` more curve points, or `false` past the limit (nothing is taken then). - pub(crate) fn take_coordinates(&mut self, n: usize) -> bool { - match self.coordinates.checked_add(n).filter(|&t| t <= self.limits.coordinates) { - Some(t) => { - self.coordinates = t; - true - } - None => { - self.refused = true; - false - } - } - } - - /// Dashes the read may still take. - pub(crate) fn dashes_left(&self) -> usize { - self.limits.dashes.saturating_sub(self.dashes) - } - - /// `n` more dashes, or `false` past the limit (nothing is taken then). - pub(crate) fn take_dashes(&mut self, n: usize) -> bool { - match self.dashes.checked_add(n).filter(|&t| t <= self.limits.dashes) { - Some(t) => { - self.dashes = t; - true - } - None => false, - } - } - - /// One more chunk walked inside a clipped group, or `false` past the limit. - pub(crate) fn take_clipped_chunk(&mut self) -> bool { - if self.clipped_chunks >= self.limits.clipped_chunks { - return false; - } - self.clipped_chunks += 1; - true - } -} diff --git a/crates/cdr/src/model.rs b/crates/cdr/src/model.rs deleted file mode 100644 index e4af34f365..0000000000 --- a/crates/cdr/src/model.rs +++ /dev/null @@ -1,255 +0,0 @@ -//! What a drawing reads as. Lengths are in points (1/72 inch), from the centre of the page, with y -//! pointing up, as the file stores them. - -/// A point in points. -#[derive(Clone, Copy, Debug, PartialEq)] -pub struct Pt { - pub x: f64, - pub y: f64, -} - -/// An affine map `[a, b, c, d, e, f]`: x' = a x + c y + e, y' = b x + d y + f. -#[derive(Clone, Copy, Debug, PartialEq)] -pub struct Matrix(pub [f64; 6]); - -impl Matrix { - pub const IDENTITY: Matrix = Matrix([1.0, 0.0, 0.0, 1.0, 0.0, 0.0]); - - /// `self` after `first`: the map that applies `first`, then `self`. - pub fn after(&self, first: &Matrix) -> Matrix { - let [a, b, c, d, e, f] = self.0; - let [p, q, r, s, t, u] = first.0; - Matrix([a * p + c * q, b * p + d * q, a * r + c * s, b * r + d * s, a * t + c * u + e, b * t + d * u + f]) - } - - pub fn apply(&self, p: Pt) -> Pt { - let [a, b, c, d, e, f] = self.0; - Pt { x: a * p.x + c * p.y + e, y: b * p.x + d * p.y + f } - } -} - -/// One segment after the previous point. -#[derive(Clone, Copy, Debug, PartialEq)] -pub enum Segment { - Line(Pt), - /// Two control points, then the end point. - Cubic(Pt, Pt, Pt), -} - -#[derive(Clone, Debug, PartialEq)] -pub struct SubPath { - pub start: Pt, - pub segments: Vec, - pub closed: bool, -} - -#[derive(Clone, Debug, Default, PartialEq)] -pub struct Path { - pub subpaths: Vec, -} - -/// The shape of an object, in its own space ([`Shape::matrix`] places it). -#[derive(Clone, Debug, PartialEq)] -pub enum Geometry { - Path(Path), - /// A rectangle from the origin to (`w`, `h`) (either may be negative). `radii` round its - /// corners counterclockwise from the one at (`w`, 0): (`w`, 0), (`w`, `h`), (0, `h`), (0, 0). - Rect { - w: f64, - h: f64, - radii: [f64; 4], - }, - /// A whole ellipse in the box from the origin to (`w`, `h`). - Ellipse { - w: f64, - h: f64, - }, -} - -#[derive(Clone, Debug, PartialEq)] -pub enum Color { - Rgb([f32; 3]), - Cmyk([f32; 4]), - /// Ink: 0 is white, 1 black. - Gray(f32), - /// Every ink at full strength. - Registration, - /// A color of a named library, printed on its own plate. `look` is its full-strength color - /// when the file stores one (an approximation in sRGB); `tint` is 0 to 1. - Spot { - name: String, - tint: f32, - look: Option<[f32; 3]>, - }, -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub enum Cap { - Butt, - Round, - Square, -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub enum Join { - Miter, - Round, - Bevel, -} - -#[derive(Clone, Debug, PartialEq)] -pub struct Outline { - pub width: f64, - pub color: Color, - pub cap: Cap, - pub join: Join, - /// Dash and gap lengths, in outline widths; empty for a solid line. - pub dashes: Vec, - /// Drawn behind the fill, so that a filled shape shows only the outer half of it. - pub behind_fill: bool, - /// Scaled with the shape: the shape's matrix scales the width and dashes as it scales the - /// geometry. - pub scale_with: bool, -} - -/// Whether a layer, group or shape is hidden or locked. -#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)] -pub struct Flags { - pub hidden: bool, - pub locked: bool, -} - -/// How a shape's colors combine with the art below it. -#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)] -pub enum Blend { - #[default] - Normal, - Multiply, - Screen, - Overlay, - SoftLight, - HardLight, - ColorDodge, - ColorBurn, - Darken, - Lighten, - Difference, - Exclusion, - Hue, - Saturation, - Color, - Luminosity, -} - -#[derive(Clone, Debug, PartialEq)] -pub struct Shape { - pub geometry: Geometry, - pub matrix: Matrix, - pub fill: Option, - pub outline: Option, - /// The fill covers every area its subpaths wind around (nonzero); otherwise subpaths that - /// overlap leave holes (even-odd). - pub nonzero: bool, - /// 1 opaque, 0 clear. - pub opacity: f32, - pub blend: Blend, - pub flags: Flags, -} - -impl Shape { - /// An opaque, shown shape filled even-odd. - pub fn new(geometry: Geometry, matrix: Matrix, fill: Option, outline: Option) -> Shape { - Shape { geometry, matrix, fill, outline, nonzero: false, opacity: 1.0, blend: Blend::Normal, flags: Flags::default() } - } -} - -#[derive(Clone, Debug, PartialEq)] -pub enum Object { - Shape(Box), - Group { - objects: Vec, - flags: Flags, - }, - /// A clipping container and the objects it clips: `objects` (front to back) show only - /// inside the container's shape, with its fill behind them and its outline over them. - Clip { - container: Box, - objects: Vec, - }, -} - -/// A guideline through `at`, at `angle` degrees counterclockwise from horizontal. -#[derive(Clone, Copy, Debug, PartialEq)] -pub struct Guideline { - pub at: Pt, - pub angle: f64, - /// The guideline, a group around it or its layer is hidden. - pub hidden: bool, -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub enum LayerKind { - Drawing, - /// The objects left beside the pages. - Desktop, - Guides, - Grid, -} - -#[derive(Clone, Debug, PartialEq)] -pub struct Layer { - pub name: String, - pub kind: LayerKind, - pub flags: Flags, - /// Front to back, as the file lists them. - pub objects: Vec, - pub guides: Vec, -} - -#[derive(Clone, Debug, PartialEq)] -pub struct Page { - /// Width and height in points, when the page gives its own. - pub size: Option<(f64, f64)>, - /// Front to back, as the file lists them. - pub layers: Vec, -} - -/// What was left out or changed while reading. Each kind is listed once. -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub enum Warning { - /// Text, bitmaps, splines and other objects not read yet. - UnsupportedObjects, - /// Fountain, pattern, texture and PostScript fills. - UnsupportedFills, - /// Colors in models not read; shown black. - UnknownColors, - /// Library spot colors whose look the file doesn't store; shown black. - SpotLooks, - /// Outline arrowheads. - Arrowheads, - /// Envelopes, which are not applied: the shapes under them keep their outlines. - Envelopes, - /// Lenses, and object transparency that isn't read, which are not applied: the objects show - /// opaque. - Lenses, - /// Content nested deeper, or past the counts, that a read takes. - TooDeep, - /// Chunks or records that end early or don't parse. - Damaged, -} - -#[derive(Clone, Debug, PartialEq)] -pub struct Drawing { - /// In hundreds, as a RIFF file stores it: 300 to 2799. A file of version 1 or 2 stores no - /// number: it gives 200 when its marker byte is the one of version 2, and 100 otherwise. A - /// `.cmx` file gives 0. - pub version: u16, - /// Page size from the document settings, in points. - pub page_size: Option<(f64, f64)>, - pub pages: Vec, - /// Layers every page shows, from the master page. - pub master: Vec, - /// Guidelines every page shows, kept outside any layer. - pub guides: Vec, - pub warnings: Vec, -} diff --git a/crates/cdr/src/package.rs b/crates/cdr/src/package.rs deleted file mode 100644 index c46fa31e39..0000000000 --- a/crates/cdr/src/package.rs +++ /dev/null @@ -1,147 +0,0 @@ -//! The packages of versions 14 on (R25, R26): a ZIP archive holding the RIFF stream as -//! `content/riffData.cdr` (14 and 15), or as `content/root.dat` with its chunk bodies in the data -//! streams that `content/dataFileList.dat` names (16 on). A data stream is inflated only when a -//! chunk the reader reads, or a list it splits, points into it. - -use std::borrow::Cow; -use std::cell::{Cell, OnceCell}; - -use crate::limits::{Budget, Limits}; -use crate::riff::push; -use crate::zip::{self, Archive}; -use crate::{Error, Warning}; - -const RIFF_DATA: &[u8] = b"content/riffData.cdr"; -const ROOT: &[u8] = b"content/root.dat"; -const DATA_FILE_LIST: &[u8] = b"content/dataFileList.dat"; -const DATA_DIR: &[u8] = b"content/data/"; - -/// Is `bytes` a ZIP archive with a `.cdr` drawing's root stream? -pub(crate) fn is_package(bytes: &[u8]) -> bool { - zip::is_zip(bytes) && Archive::open(bytes, Limits::default().members).is_ok_and(|a| a.find(RIFF_DATA).or_else(|| a.find(ROOT)).is_some()) -} - -/// The RIFF stream of the package `bytes`, and its data streams when it has them (16 on). -pub(crate) fn open<'a>(bytes: &'a [u8], budget: &mut Budget) -> Result<(Cow<'a, [u8]>, Option>), Error> { - let zip = Archive::open(bytes, budget.limits.members)?; - if let Some(i) = zip.find(RIFF_DATA) { - return Ok((member(&zip, i, budget)?, None)); - } - let root = zip.find(ROOT).ok_or(Error::NotCdr)?; - let root = member(&zip, root, budget)?; - let list = match zip.find(DATA_FILE_LIST) { - Some(i) => member(&zip, i, budget)?, - None => Cow::Borrowed(&[][..]), - }; - // One name for each line; a line feed after the last name ends it. - let list = list.strip_suffix(b"\n").unwrap_or(&list); - let mut members = Vec::new(); - if !list.is_empty() { - for line in list.split(|&b| b == b'\n') { - if members.len() == budget.limits.members { - return Err(Error::Limit("package member count")); - } - let name = line.strip_suffix(b"\r").unwrap_or(line); - let found = zip.find(&[DATA_DIR, name].concat()); - // A data stream that is encrypted or packed some other way refuses the file, as the - // root stream does. - if let Some(i) = found { - zip.check(i)?; - } - members.push(found); - } - } - let loaded = (0..zip.count()).map(|_| OnceCell::new()).collect(); - let streams = Streams { zip, members, loaded, member_limit: budget.limits.member, damaged: Cell::new(false) }; - Ok((root, Some(streams))) -} - -/// Member `i` within the member limit and, when deflated, what is left to inflate. -fn member<'a>(zip: &Archive<'a>, i: usize, budget: &mut Budget) -> Result, Error> { - let m = zip.read(i, budget.limits.member, budget.inflate_left())?; - if let Cow::Owned(v) = &m { - budget.take_inflated(v.len())?; - } - Ok(m) -} - -/// What reading one package member gave. -#[derive(Debug)] -enum Slot<'a> { - Read(Cow<'a, [u8]>), - Damaged, - PastLimit, -} - -/// The data streams of a version 16+ package, in `dataFileList.dat` order (R26). -#[derive(Debug)] -pub(crate) struct Streams<'a> { - zip: Archive<'a>, - /// The member holding each stream; `None` when the archive lacks it. - members: Vec>, - /// Each member's bytes once read, so that streams naming one member read it once. - loaded: Vec>>, - member_limit: usize, - /// A stream, or a chunk's bytes in one, could not be found. - damaged: Cell, -} - -impl<'a> Streams<'a> { - /// The member holding stream `s`; `None` when there is no such stream. - pub(crate) fn member_of(&self, s: usize) -> Option { - *self.members.get(s)? - } - - /// The size the archive gives stream `s`; `None` when there is no such stream. - pub(crate) fn size(&self, s: usize) -> Option { - Some(self.zip.size(self.member_of(s)?)) - } - - /// Stream `s`, its member read on first use within the member limit and, when deflated, - /// within `left` more inflated bytes (which it takes from). - pub(crate) fn get(&self, s: usize, left: &Cell) -> Option<&[u8]> { - let Some(i) = self.member_of(s) else { - self.damaged.set(true); - return None; - }; - let slot = self.loaded.get(i)?.get_or_init(|| { - let read = self.zip.read(i, self.member_limit, left.get()); - if !matches!(read, Err(Error::Limit(_))) { - left.set(left.get().saturating_sub(self.zip.inflate_cost(i))); - } - match read { - Ok(b) => Slot::Read(b), - Err(Error::Limit(_)) => Slot::PastLimit, - Err(_) => { - self.damaged.set(true); - Slot::Damaged - } - } - }); - match slot { - Slot::Read(b) => Some(b.as_ref()), - Slot::Damaged | Slot::PastLimit => None, - } - } - - /// Was stream `s` left out because it is past a limit? Chunks in it are then not damage. - pub(crate) fn past_limit(&self, s: usize) -> bool { - let slot = self.member_of(s).and_then(|i| self.loaded.get(i)).and_then(OnceCell::get); - matches!(slot, Some(Slot::PastLimit)) - } - - /// Mark a chunk whose stream bytes could not be found. - pub(crate) fn note_damage(&self) { - self.damaged.set(true); - } - - /// The warnings for streams that were left out. - pub(crate) fn warnings(&self, warn: &mut Vec) { - if self.damaged.get() { - push(warn, Warning::Damaged); - } - if self.loaded.iter().any(|s| matches!(s.get(), Some(Slot::PastLimit))) { - push(warn, Warning::TooDeep); - } - } -} diff --git a/crates/cdr/src/records.rs b/crates/cdr/src/records.rs deleted file mode 100644 index f4f2a3b6ef..0000000000 --- a/crates/cdr/src/records.rs +++ /dev/null @@ -1,655 +0,0 @@ -//! Hand-written decoders of the records a drawing's objects refer to: the `loda` argument table -//! (R6), transforms (R8), colors (R14), fills (R11) and outlines (R12, R13). - -use crate::bytes::Rd; -use crate::layout::{ColorLayout, Profile}; -use crate::model::{Blend, Cap, Color, Join, Matrix, Outline}; -use crate::riff::push; -use crate::{Limits, Warning}; - -/// The tag of a record's current layout in tagged files (R11, R12). -const TAG_1300: u32 = 1300; -/// The most tagged records skipped before a fill's own (R11). -const MAX_SKIPPED: usize = 4; -/// The most records skipped before an outline's own (R12). -const MAX_OUTLINE_RECORDS: usize = 16; -/// The most UTF-16 units of a library color's name kept, and the most bytes or UTF-16 units of -/// a layer's. -const MAX_NAME: usize = 256; - -/// A header field: u16 in short files, u32 otherwise. -fn word(r: &mut Rd, p: &Profile) -> Option { - if p.short { r.u16().map(usize::from) } else { r.u32().map(|v| v as usize) } -} - -/// A coordinate in points. -pub(crate) fn coord(r: &mut Rd, p: &Profile) -> Option { - let raw = if p.short { f64::from(r.i16()?) } else { f64::from(r.i32()?) }; - Some(raw * p.unit()) -} - -/// An angle in degrees: tenths in short files, millionths otherwise (R7). -pub(crate) fn angle(r: &mut Rd, p: &Profile) -> Option { - if p.short { Some(f64::from(r.i16()?) / 10.0) } else { Some(f64::from(r.i32()?) / 1_000_000.0) } -} - -/// A `loda` record (R6): its object type and arguments as (type, bytes). -pub(crate) struct Loda<'a> { - pub(crate) kind: u32, - pub(crate) args: Vec<(u32, &'a [u8])>, -} - -impl<'a> Loda<'a> { - pub(crate) fn arg(&self, kind: u32) -> Option<&'a [u8]> { - self.args.iter().find(|(k, _)| *k == kind).map(|(_, b)| *b) - } -} - -pub(crate) fn loda<'a>(b: &'a [u8], p: &Profile, limits: &Limits, warn: &mut Vec) -> Option> { - let mut r = Rd::new(b); - let (_len, count, offsets_at, types_at, kind) = (word(&mut r, p)?, word(&mut r, p)?, word(&mut r, p)?, word(&mut r, p)?, word(&mut r, p)?); - // The types table is indexed from the stored count, however many arguments are read. - let stored = count; - let count = if count > limits.arguments { - push(warn, Warning::Damaged); - limits.arguments - } else { - count - }; - let mut offsets = Vec::with_capacity(count + 1); - let mut ro = Rd::at(b, offsets_at); - for _ in 0..=count { - offsets.push(word(&mut ro, p)?); - } - let mut args = Vec::with_capacity(count); - for i in 0..count { - // The types table runs the other way: offset i pairs with type stored - 1 - i. - let kind = word(&mut Rd::at(b, types_at.checked_add((stored - 1 - i).checked_mul(p.word())?)?), p)? as u32; - let (start, end) = (*offsets.get(i)?, *offsets.get(i + 1)?); - match b.get(start..end) { - Some(body) => args.push((kind, body)), - None => push(warn, Warning::Damaged), - } - } - Some(Loda { kind: kind as u32, args }) -} - -/// The matrices of a `trfd` record composed in file order, in points (R8). Each entry ends where -/// the next offset points, and the last at the offset after it (R51); an entry too short for its -/// matrix makes the record unreadable. -pub(crate) fn trfd(b: &[u8], p: &Profile) -> Option { - let mut r = Rd::new(b); - let (_len, count, offsets_at) = (word(&mut r, p)?, word(&mut r, p)?, word(&mut r, p)?); - let mut m = Matrix::IDENTITY; - let k = p.unit(); - // Each entry takes at least its offset's bytes, which bounds the count by the record's size. - for i in 0..count.min(b.len() / p.word()) { - let slot = offsets_at.checked_add(i.checked_mul(p.word())?)?; - let start = word(&mut Rd::at(b, slot), p)?; - // A table that stops before the last entry's end offset leaves that entry the rest of the - // record. - let end = word(&mut Rd::at(b, slot.checked_add(p.word())?), p).unwrap_or(b.len()); - let mut e = Rd::at(b.get(start..end)?, p.trfd_head); - if e.u16()? != 8 { - continue; - } - e.skip(p.matrix_skip)?; - let next = if p.fixed_matrix { - fixed_matrix(&mut e, k)? - } else { - let (a, c, tx, bb, d, ty) = (e.f64()?, e.f64()?, e.f64()?, e.f64()?, e.f64()?, e.f64()?); - Matrix([a, bb, c, d, tx * k, ty * k]) - }; - m = next.after(&m); - } - Some(m) -} - -/// A number in 16.16 fixed point. -pub(crate) fn fixed(r: &mut Rd) -> Option { - Some(f64::from(r.i32()?) / 65536.0) -} - -/// A matrix of versions 3 and 4 (R37): six i32 `a c tx b d ty`, the factors in 16.16 fixed point -/// and `tx` and `ty` in coordinate units of `k` points. -pub(crate) fn fixed_matrix(r: &mut Rd, k: f64) -> Option { - let (a, c, tx) = (fixed(r)?, fixed(r)?, f64::from(r.i32()?)); - let (b, d, ty) = (fixed(r)?, fixed(r)?, f64::from(r.i32()?)); - Some(Matrix([a, b, c, d, tx * k, ty * k])) -} - -/// A color in the layout of the file's version (R14, R36). Unknown models read as black with a -/// warning. -pub(crate) fn color(r: &mut Rd, p: &Profile, warn: &mut Vec) -> Option { - match p.color { - ColorLayout::Record12 => { - let model = r.u16()?; - let palette = r.u16()?; - r.skip(4)?; - let v: [u8; 4] = r.bytes(4)?.try_into().ok()?; - Some(model_color(model, palette, v, warn)) - } - ColorLayout::Words12 => { - let model = r.u16()?; - let w = [r.u16()?, r.u16()?, r.u16()?, r.u16()?]; - r.skip(2)?; - // The models take 8-bit values, as in the other layouts; a larger value reads as 255. - Some(early_color(model, w.map(|x| u8::try_from(x).unwrap_or(u8::MAX)), w[0], w[1], warn)) - } - ColorLayout::Bytes5 => Some(color5(r.bytes(5)?.try_into().ok()?, warn)), - } -} - -/// A 5-byte color (R36): a model byte and four value bytes. -pub(crate) fn color5(b: [u8; 5], warn: &mut Vec) -> Color { - let [model, v @ ..] = b; - early_color(u16::from(model), v, u16::from_le_bytes([v[0], v[1]]), u16::from_le_bytes([v[2], v[3]]), warn) -} - -/// A color of versions 1 to 4 (R36). Model 1 is CMYK in percent. Model 0 is a numbered ink and -/// its tint in percent: 0 is black, 1 is white, and other numbers are inks of a library the file -/// doesn't store. Other models read as in later versions. -fn early_color(model: u16, v: [u8; 4], index: u16, tint: u16, warn: &mut Vec) -> Color { - let pct = |x: f32| (x / 100.0).clamp(0.0, 1.0); - match (model, index) { - (1, _) => Color::Cmyk(v.map(|x| pct(f32::from(x)))), - (0, 0) => Color::Gray(pct(f32::from(tint))), - (0, 1) => Color::Gray(0.0), - (0, number) => { - push(warn, Warning::SpotLooks); - Color::Spot { name: format!("Spot 0:{number}"), tint: pct(f32::from(tint)), look: None } - } - _ => model_color(model, 0, v, warn), - } -} - -/// The color of `model` with the four value bytes `v`, from version 5 (R14). -fn model_color(model: u16, palette: u16, v: [u8; 4], warn: &mut Vec) -> Color { - let (v0, v1, v2, v3) = (f32::from(v[0]), f32::from(v[1]), f32::from(v[2]), f32::from(v[3])); - let pct = |x: f32| (x / 100.0).clamp(0.0, 1.0); - let byte = |x: f32| x / 255.0; - match model { - 2 => Color::Cmyk([pct(v0), pct(v1), pct(v2), pct(v3)]), - 3 | 17 => Color::Cmyk([byte(v0), byte(v1), byte(v2), byte(v3)]), - 4 => Color::Cmyk([byte(v0), byte(v1), byte(v2), 0.0]), - 5 | 21 => Color::Rgb([byte(v2), byte(v1), byte(v0)]), - 9 => Color::Gray(1.0 - byte(v0)), - 20 => Color::Registration, - 1 | 14 | 25 => { - let number = u16::from_le_bytes([v[0], v[1]]); - let tint = pct(f32::from(u16::from_le_bytes([v[2], v[3]]))); - push(warn, Warning::SpotLooks); - // Each library numbers its own colors: the name holds the palette and the number. - Color::Spot { name: format!("Spot {palette}:{number}"), tint, look: None } - } - _ => { - push(warn, Warning::UnknownColors); - Color::Rgb([0.0; 3]) - } - } -} - -/// A UTF-16 name stored as a character count and its code units. Every shape that uses the color -/// gets its own copy of the name: a name longer than [`MAX_NAME`] units keeps its first ones and a -/// hash of the whole name, with a warning, so two long names that start alike stay apart. -fn counted_utf16(r: &mut Rd, warn: &mut Vec) -> Option { - let n = r.u32()? as usize; - let b = r.bytes(n.checked_mul(2)?)?; - // Trailing NULs are padding. - let all = b.as_chunks::<2>().0; - let all = all.get(..all.iter().rposition(|c| *c != [0, 0]).map_or(0, |i| i + 1)).unwrap_or_default(); - let units = all.iter().map(|c| u16::from_le_bytes(*c)); - if all.len() <= MAX_NAME { - let units: Vec = units.collect(); - return Some(String::from_utf16_lossy(&units)); - } - push(warn, Warning::TooDeep); - // FNV-1a over the code units. - let hash = units.clone().fold(0xcbf2_9ce4_8422_2325_u64, |h, u| (h ^ u64::from(u)).wrapping_mul(0x0100_0000_01b3)); - let kept: Vec = units.take(MAX_NAME).collect(); - Some(format!("{} {hash:016x}", String::from_utf16_lossy(&kept))) -} - -/// The color of the property list of a tagged uniform fill (R11) or outline (R12): its color -/// record, named by the library name it carries. -pub(crate) fn property_color(b: &[u8], p: &Profile, warn: &mut Vec) -> Option { - let mut r = Rd::new(b); - let (mut found, mut name) = (None, None); - while r.left() >= 5 { - let kind = r.u8()?; - let len = r.u32()? as usize; - if kind == 0 { - break; - } - let body = r.bytes(len)?; - let mut br = Rd::new(body); - match kind { - 1 => found = color(&mut br, p, warn), - 8 => name = br.skip(16).and_then(|_| counted_utf16(&mut br, warn)), - 3 => name = name.or_else(|| counted_utf16(&mut br, warn)), - _ => {} - } - } - match (found?, name.filter(|n| !n.is_empty())) { - // A library color with its name: the record's sRGB has the tint applied already. - (Color::Rgb(rgb), Some(name)) => { - let tint = b_tint(b).unwrap_or(1.0); - Some(Color::Spot { name, tint, look: Some(untinted(rgb, tint)) }) - } - (c, _) => Some(c), - } -} - -/// The tint byte of the first color property of a property list (model 21 keeps it last). -fn b_tint(b: &[u8]) -> Option { - let mut r = Rd::new(b); - while r.left() >= 5 { - let kind = r.u8()?; - let len = r.u32()? as usize; - let body = r.bytes(len)?; - if kind == 1 { - let mut c = Rd::new(body); - return (c.u16()? == 21).then(|| f32::from(*body.get(11).unwrap_or(&100)) / 100.0).map(|t| t.clamp(0.0, 1.0)); - } - } - None -} - -/// The full-strength color behind sRGB `rgb` shown at `tint` (a tint mixes toward white). -fn untinted(rgb: [f32; 3], tint: f32) -> [f32; 3] { - if tint <= 0.0 { - return rgb; - } - rgb.map(|v| (1.0 - (1.0 - v) / tint).clamp(0.0, 1.0)) -} - -/// A fill record: its id, and its color (`None`: no fill). Fills of other kinds read as none with -/// a warning (R11). -pub(crate) fn fill(b: &[u8], p: &Profile, warn: &mut Vec) -> Option<(u32, Option)> { - let mut r = Rd::new(b); - let id = r.u32()?; - let body = if p.tagged { tagged_body(&mut r)? } else { r.bytes(r.left())? }; - let mut r = Rd::new(body); - let kind = r.u16()?; - let color = match kind { - 0 => None, - 1 if p.tagged => { - if r.u32()? != TAG_1300 { - push(warn, Warning::Damaged); - return Some((id, None)); - } - // A uniform fill whose color can't be read is damage, not a fill of none. - let len = r.u32()? as usize; - Some(property_color(r.bytes(len.min(r.left()))?, p, warn)?) - } - 1 => { - r.skip(2)?; - Some(color(&mut r, p, warn)?) - } - _ => { - push(warn, Warning::UnsupportedFills); - None - } - }; - Some((id, color)) -} - -/// The body of the record tagged 1300 that follows tagged records of later layouts (R11). -fn tagged_body<'a>(r: &mut Rd<'a>) -> Option<&'a [u8]> { - for _ in 0..=MAX_SKIPPED { - let (tag, len) = (r.u32()?, r.u32()? as usize); - let body = r.bytes(len.min(r.left()))?; - if tag == TAG_1300 { - return Some(body); - } - } - None -} - -/// An outline record: its id and the outline (`None`: no outline) (R12, R13). -pub(crate) fn outline(b: &[u8], p: &Profile, warn: &mut Vec) -> Option<(u32, Option)> { - let mut r = Rd::new(b); - let id = r.u32()?; - // A library color named in a record of type 2, with the warnings its read gave. - let mut named = None; - if p.tagged { - let mut found = false; - for _ in 0..MAX_OUTLINE_RECORDS { - let (rec, len) = (r.u32()?, r.u32()? as usize); - if rec == 1 { - found = true; - break; - } - let body = r.bytes(len)?; - // Type 2 holds the outline's color as a property list, as a uniform fill does (R12). - // Only a library color with its name is taken from it; any other color comes from - // the fixed field below. - if rec == 2 { - let mut w = Vec::new(); - if let Some(c @ Color::Spot { look: Some(_), .. }) = property_color(body, p, &mut w) { - named = Some((c, w)); - } - } - } - if !found { - return None; - } - } - let (line_type, cap, join) = (r.u16()?, r.u16()?, r.u16()?); - r.skip(p.outl_after_join)?; - let width = coord(&mut r, p)?.abs(); - let _stretch = r.u16()?; - r.skip(p.outl_after_stretch)?; - let _nib = angle(&mut r, p)?; - r.skip(p.outl_after_angle)?; - let color = match named { - Some((named, w)) => { - color(&mut r, p, &mut Vec::new())?; - for x in w { - push(warn, x); - } - named - } - None => color(&mut r, p, warn)?, - }; - r.skip(p.outl_after_color)?; - let count = usize::from(r.u16()?); - let first_dash = r.pos(); - let fits = r.left() / 2; - if count > fits { - push(warn, Warning::Damaged); - } - // At most 65,535; the read's dash limit is applied where shapes use them. - let dashes: Vec = (0..count.min(fits)).filter_map(|_| r.u16().map(f64::from)).collect(); - if let Some(after) = p.marker_after_dash { - let mut m = Rd::at(b, first_dash + after); - if matches!((m.u32(), m.u32()), (Some(s), Some(e)) if s != 0 || e != 0) { - push(warn, Warning::Arrowheads); - } - } - // Bit 0 of the line type: no outline (R13). - if line_type & 1 != 0 { - return Some((id, None)); - } - let cap = match cap { - 1 => Cap::Round, - 2 => Cap::Square, - _ => Cap::Butt, - }; - let join = match join { - 1 => Join::Round, - 2 => Join::Bevel, - _ => Join::Miter, - }; - // Bit 2 of the line type marks the outline dashed; without it the dashes stored are not drawn - // (R48). - let dashes = if line_type & 4 != 0 && dashes.iter().any(|d| *d > 0.0) { dashes } else { Vec::new() }; - // Bit 4 of the line type: behind the fill (R49). - let behind_fill = line_type & 0x10 != 0; - // Bit 5 of the line type: scaled with the shape (R50). - let scale_with = line_type & 0x20 != 0; - Some((id, Some(Outline { width, color, cap, join, dashes, behind_fill, scale_with }))) -} - -/// The opacity and blend of argument 8000 from version 13 (R47): records of a u32 version, a u32 -/// length and a body. A body of version 1300 that is [`UNIFORM_LEN`] bytes long is a uniform -/// transparency: an f64 at byte 61 and the merge mode at byte 77. VectorCraft reads the f64 as the -/// transparency in percent, 0 opaque and 100 clear. `None` for any other argument, such as a lens, -/// and for a value out of range or a merge mode without a VectorCraft blend mode. -pub(crate) fn transparency(b: &[u8]) -> Option<(f32, Blend)> { - let mut r = Rd::new(b); - while r.left() >= 8 { - let (since, len) = (r.u32()?, r.u32()? as usize); - let body = r.bytes(len)?; - if since != TAG_1300 { - continue; - } - if body.len() != UNIFORM_LEN { - return None; - } - let value = Rd::at(body, 61).f64()?; - if !(0.0..=100.0).contains(&value) { - return None; - } - return Some(((1.0 - value / 100.0) as f32, blend(*body.get(77)?)?)); - } - None -} - -/// The length of a uniform transparency's record body (R47). -const UNIFORM_LEN: usize = 117; - -/// The blend mode of a transparency's merge mode byte (R47); `None` for the modes VectorCraft has -/// no blend mode for. -fn blend(mode: u8) -> Option { - Some(match mode { - 0 => Blend::Normal, - 9 => Blend::Multiply, - 11 => Blend::Lighten, - 12 => Blend::Darken, - 14 => Blend::Color, - 15 => Blend::Hue, - 16 => Blend::Saturation, - 17 => Blend::Luminosity, - 24 => Blend::Difference, - 28 => Blend::Screen, - 29 => Blend::Overlay, - 30 => Blend::SoftLight, - 31 => Blend::HardLight, - 33 => Blend::ColorDodge, - 34 => Blend::ColorBurn, - 36 => Blend::Exclusion, - _ => return None, - }) -} - -/// A name argument (R9): Windows-1252 up to a NUL before version 12, UTF-16LE from it. A name -/// longer than [`MAX_NAME`] bytes or UTF-16 units keeps its first ones (without half of a -/// surrogate pair) and a hash of the whole name, with a warning, as a library color's name does. -pub(crate) fn name(b: &[u8], p: &Profile, warn: &mut Vec) -> String { - if p.utf16_names { - let units = b.as_chunks::<2>().0.iter().map(|c| u16::from_le_bytes(*c)).take_while(|u| *u != 0); - let (mut kept, hash) = capped(units, warn); - if hash.is_some() && kept.last().is_some_and(|u| (0xD800..0xDC00).contains(u)) { - kept.pop(); - } - with_hash(String::from_utf16_lossy(&kept), hash) - } else { - let bytes = b.iter().copied().take_while(|c| *c != 0); - let (kept, hash) = capped(bytes, warn); - with_hash(kept.into_iter().map(windows_1252).collect(), hash) - } -} - -/// The first [`MAX_NAME`] of `units`, and when there are more, an FNV-1a hash of them all, with a -/// warning. -fn capped>(units: impl Iterator + Clone, warn: &mut Vec) -> (Vec, Option) { - if units.clone().nth(MAX_NAME).is_none() { - return (units.collect(), None); - } - push(warn, Warning::TooDeep); - let hash = units.clone().fold(0xcbf2_9ce4_8422_2325_u64, |h, u| (h ^ u.into()).wrapping_mul(0x0100_0000_01b3)); - (units.take(MAX_NAME).collect(), Some(hash)) -} - -/// `name`, followed by `hash` in hexadecimal when there is one. -fn with_hash(name: String, hash: Option) -> String { - match hash { - Some(h) => format!("{name} {h:016x}"), - None => name, - } -} - -/// The characters Windows-1252 puts at 0x80 to 0x9F (U+FFFD where it has none); the other bytes -/// are Latin-1. -const CP1252_HIGH: [char; 32] = [ - '€', '\u{FFFD}', '‚', 'ƒ', '„', '…', '†', '‡', 'ˆ', '‰', 'Š', '‹', 'Œ', '\u{FFFD}', 'Ž', '\u{FFFD}', '\u{FFFD}', '‘', '’', '“', '”', '•', '–', - '—', '˜', '™', 'š', '›', 'œ', '\u{FFFD}', 'ž', 'Ÿ', -]; - -fn windows_1252(c: u8) -> char { - match c { - 0x80..=0x9F => CP1252_HIGH.get(usize::from(c - 0x80)).copied().unwrap_or('\u{FFFD}'), - _ => char::from(c), - } -} - -#[cfg(test)] -mod tests { - use super::*; - - /// An outline that names an arrowhead says so with a warning, in each version whose arrowhead - /// ids have a known place: 22 bytes after the first dash in versions 6 to 12, 20 from 13. - #[test] - fn arrowheads_are_named_from_version_6() { - let pen = crate::synth::Pen { line_type: 0, width: 1.0, cap: 0, join: 0 }; - let color = [2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 100]; - for (version, place) in [ - (500, None), - (600, Some(22)), - (700, Some(22)), - (800, Some(22)), - (900, Some(22)), - (1000, Some(22)), - (1100, Some(22)), - (1200, Some(22)), - (1300, Some(20)), - (1700, Some(20)), - ] { - let p = crate::layout::for_version(version).unwrap(); - let plain = crate::synth::V(version).outline(7, pen, &color, &[]); - // The record ends with 32 bytes after its dashes, and this one has none. - let first_dash = plain.len() - 32; - let mut w = vec![]; - assert!(outline(&plain, &p, &mut w).is_some_and(|(id, o)| id == 7 && o.is_some()), "{version}"); - assert!(w.is_empty(), "{version}: {w:?}"); - let Some(place) = place else { continue }; - let mut arrow = plain.clone(); - arrow[first_dash + place..first_dash + place + 4].copy_from_slice(&9u32.to_le_bytes()); - let mut w = vec![]; - assert!(outline(&arrow, &p, &mut w).is_some(), "{version}"); - assert_eq!(w, vec![Warning::Arrowheads], "{version}"); - } - } - - #[test] - fn single_byte_names_read_as_windows_1252() { - let p = crate::layout::for_version(1100).unwrap(); - assert_eq!(name(b"Caf\xe9 \x80\x96\0junk", &p, &mut vec![]), "Café €–"); - let p = crate::layout::for_version(1200).unwrap(); - assert_eq!(name(&[0x41, 0, 0x42, 0, 0, 0, 0x43, 0], &p, &mut vec![]), "AB"); - } - - /// A layer name longer than [`MAX_NAME`] bytes or UTF-16 units keeps its first ones and a hash - /// of the whole name, with a warning, in both encodings. A cut never keeps half of a surrogate - /// pair. - #[test] - fn long_layer_names_are_cut_with_a_hash() { - for version in [1100, 1200] { - let p = crate::layout::for_version(version).unwrap(); - let bytes = - |s: &str| if p.utf16_names { s.encode_utf16().flat_map(u16::to_le_bytes).collect::>() } else { s.as_bytes().to_vec() }; - let mut w = vec![]; - let a = name(&bytes(&"N".repeat(100_000)), &p, &mut w); - let b = name(&bytes(&format!("{}M", "N".repeat(99_999))), &p, &mut vec![]); - assert_ne!(a, b, "{version}"); - assert!(a.starts_with(&"N".repeat(MAX_NAME)) && a.chars().count() == MAX_NAME + 17, "{version}: {}", a.len()); - assert_eq!(w, vec![Warning::TooDeep], "{version}"); - let mut w = vec![]; - assert_eq!(name(&bytes(&"N".repeat(MAX_NAME)), &p, &mut w), "N".repeat(MAX_NAME), "{version}"); - assert!(w.is_empty(), "{version}"); - } - let p = crate::layout::for_version(1200).unwrap(); - let emoji: Vec = format!("N{}", "\u{1F600}".repeat(200)).encode_utf16().flat_map(u16::to_le_bytes).collect(); - let cut = name(&emoji, &p, &mut vec![]); - assert!(!cut.contains('\u{FFFD}'), "{cut}"); - assert_eq!(cut.chars().filter(|c| *c == '\u{1F600}').count(), (MAX_NAME - 1) / 2); - } - - #[test] - fn colors_read_in_their_models() { - let p = crate::layout::for_version(500).unwrap(); - let rec = |model: u16, v: [u8; 4]| { - let mut b = model.to_le_bytes().to_vec(); - b.extend([0; 6]); - b.extend(v); - let mut w = vec![]; - (color(&mut Rd::new(&b), &p, &mut w), w) - }; - assert_eq!(rec(2, [100, 50, 0, 10]).0, Some(Color::Cmyk([1.0, 0.5, 0.0, 0.1]))); - assert_eq!(rec(5, [255, 0, 0, 0]).0, Some(Color::Rgb([0.0, 0.0, 1.0]))); - assert_eq!(rec(9, [255, 0, 0, 0]).0, Some(Color::Gray(0.0))); - assert_eq!(rec(25, [7, 0, 40, 0]).0, Some(Color::Spot { name: "Spot 0:7".into(), tint: 0.4, look: None })); - // The same number in another library is another color. - let mut other = 25u16.to_le_bytes().to_vec(); - other.extend(3u16.to_le_bytes()); - other.extend([0; 4]); - other.extend([7, 0, 40, 0]); - assert_eq!(color(&mut Rd::new(&other), &p, &mut vec![]), Some(Color::Spot { name: "Spot 3:7".into(), tint: 0.4, look: None })); - let (c, w) = rec(6, [1, 2, 3, 4]); - assert_eq!((c, w), (Some(Color::Rgb([0.0; 3])), vec![Warning::UnknownColors])); - } - - #[test] - fn colors_of_versions_3_and_4_read_models_0_and_1() { - let read = |version: u16, model: u8, v: [u16; 4]| { - let p = crate::layout::for_version(version).unwrap(); - let b: Vec = if version < 400 { - std::iter::once(model).chain(v.map(|x| x as u8)).collect() - } else { - u16::from(model).to_le_bytes().into_iter().chain(v.iter().flat_map(|x| x.to_le_bytes())).chain([0, 0]).collect() - }; - let mut r = Rd::new(&b); - let mut w = vec![]; - let c = color(&mut r, &p, &mut w); - assert_eq!(r.left(), 0, "{version}"); - (c, w) - }; - for version in [300, 400] { - // Model 1 is CMYK in percent, not a library color as from version 5. - assert_eq!(read(version, 1, [0, 100, 50, 10]).0, Some(Color::Cmyk([0.0, 1.0, 0.5, 0.1])), "{version}"); - assert_eq!(read(version, 2, [0, 100, 50, 10]).0, Some(Color::Cmyk([0.0, 1.0, 0.5, 0.1])), "{version}"); - } - // Model 0: an ink number and a tint. Version 3 stores each as a u16 in its four bytes. - assert_eq!(read(300, 0, [0, 0, 60, 0]).0, Some(Color::Gray(0.6))); - assert_eq!(read(300, 0, [1, 0, 60, 0]).0, Some(Color::Gray(0.0))); - assert_eq!(read(300, 0, [44, 1, 60, 0]), (Some(Color::Spot { name: "Spot 0:300".into(), tint: 0.6, look: None }), vec![Warning::SpotLooks])); - assert_eq!(read(400, 0, [0, 60, 0, 0]).0, Some(Color::Gray(0.6))); - assert_eq!(read(400, 0, [1, 60, 0, 0]).0, Some(Color::Gray(0.0))); - assert_eq!(read(400, 0, [300, 60, 0, 0]), (Some(Color::Spot { name: "Spot 0:300".into(), tint: 0.6, look: None }), vec![Warning::SpotLooks])); - } - - #[test] - fn a_fixed_point_matrix_reads_its_factors_and_offsets() { - let raw: Vec = [65536i32, -32768, 1000, 131072, 16384, -500].iter().flat_map(|v| v.to_le_bytes()).collect(); - let m = fixed_matrix(&mut Rd::new(&raw), 0.5).unwrap(); - assert_eq!(m, Matrix([1.0, 2.0, -0.5, 0.25, 500.0, -250.0])); - assert!(fixed_matrix(&mut Rd::new(&raw[..23]), 0.5).is_none()); - } - - #[test] - fn long_names_that_start_alike_stay_apart() { - let read = |name: &str| { - let mut b = (name.encode_utf16().count() as u32).to_le_bytes().to_vec(); - b.extend(name.encode_utf16().flat_map(u16::to_le_bytes)); - let mut w = vec![]; - (counted_utf16(&mut Rd::new(&b), &mut w).unwrap(), w) - }; - let (a, w) = read(&"N".repeat(300)); - let (b, _) = read(&format!("{}M", "N".repeat(299))); - assert_ne!(a, b); - assert!(a.starts_with(&"N".repeat(MAX_NAME)) && a.chars().count() == MAX_NAME + 17, "{a}"); - assert_eq!(w, vec![Warning::TooDeep]); - assert_eq!(read("Sky Blue"), ("Sky Blue".to_string(), vec![])); - // Padding doesn't count toward the length or the name. - let (padded, w) = read(&format!("{}\0\0", "N".repeat(MAX_NAME - 1))); - assert_eq!((padded, w), ("N".repeat(MAX_NAME - 1), vec![])); - } - - #[test] - fn a_tint_mixes_toward_white_and_comes_off_again() { - let shown = [0.6, 0.8, 1.0]; - let base = untinted(shown, 0.5); - assert!((base[0] - 0.2).abs() < 1e-6 && (base[1] - 0.6).abs() < 1e-6 && base[2] == 1.0); - } -} diff --git a/crates/cdr/src/riff.rs b/crates/cdr/src/riff.rs deleted file mode 100644 index 3f041b4c37..0000000000 --- a/crates/cdr/src/riff.rs +++ /dev/null @@ -1,465 +0,0 @@ -//! The chunk index: one flat table of every chunk, a list's children contiguous, built without -//! recursion. Payloads are not copied: an entry names a range of the RIFF stream, of the bytes -//! inflated from `LIST cmpr`, or of a package's data stream (layouts R1 to R4, R27). - -use std::cell::Cell; -use std::collections::BTreeMap; -use std::io::Read as _; - -use crate::bytes::{Rd, u32_at}; -use crate::layout; -use crate::limits::Budget; -use crate::package::Streams; -use crate::{Error, Warning}; - -pub(crate) const LIST: [u8; 4] = *b"LIST"; -const CMPR: [u8; 4] = *b"cmpr"; -const CPNG: [u8; 4] = *b"CPng"; -/// What follows `CPng` before the zlib stream (R3). -const CPNG_HEAD: [u8; 4] = [1, 0, 4, 0]; -/// The size of a redirect record, and the stream number of one that holds its body (R27). -const REDIRECT: usize = 16; -const INLINE: u32 = u32::MAX; - -/// One chunk: 28 bytes. `start` and `len` give the payload (after a list's form type) in its -/// source: 0 is the RIFF stream followed by the inflated bytes, `s + 1` is data stream `s`. -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub(crate) struct Chunk { - pub(crate) id: [u8; 4], - /// A list's form type; zeros for other chunks. - pub(crate) form: [u8; 4], - src: u32, - start: u32, - len: u32, - first: u32, - count: u32, -} - -impl Chunk { - pub(crate) fn is_list(&self, form: &[u8; 4]) -> bool { - self.id == LIST && &self.form == form - } -} - -/// Every chunk of a file, and the bytes they point into. -pub(crate) struct Index<'a> { - input: &'a [u8], - inflated: Vec, - chunks: Vec, - /// The version the form type names: hundreds, as `vrsn` stores it (0 when the `vrsn` chunk - /// decides). - pub(crate) form_version: u16, - /// A version 16+ package's data streams; chunks of 16 bytes are redirect records then. - streams: Option>, - /// Bytes that inflating may still produce. - left: Cell, - /// The bytes redirected lists have taken: (package member, start) to end. - lists: Cell>, - /// The bytes other redirected chunks have taken, the same way. - leaves: Cell>, - /// Bytes that redirects to bytes another chunk already took may still read. - shared_left: Cell, - /// The first `vrsn` chunk among the file's own chunks, once seen, and the version it names - /// (`None` when it can't be read) (R2). - vrsn: Option>, -} - -/// A list still to be split into its children. -struct Pending { - entry: usize, - src: u32, - /// Its children's bytes. - start: usize, - end: usize, - /// The size pool of a compressed list's stream (`start..end` in source 0). - pool: Option<(usize, usize)>, - depth: usize, -} - -/// What reading one chunk header gives. -enum Read { - Chunk(Chunk), - /// A redirect record whose body can't be found: the chunk is left out, its list read on. - Lost, - /// A redirect record into a data stream past a limit: the chunk is left out without the - /// damage warning. - PastLimit, - /// A redirect record to bytes another chunk took, past the shared-bytes limit: the chunk is - /// left out with the limit warning. - SharedPastLimit, -} - -/// The version the RIFF form type names (R1): `CDR5`..`CDR9`, `CDRA` (10) to `CDRH` (17) with `I` -/// unused, then `J` (18) on; `CDR ` is version 3. Some files use a lower-case `cdr`, which names -/// the same versions except that `cdr8` is the 8.01 variant. Templates of version 21 have the form -/// type `CDTQ`; for `CDT` the `vrsn` chunk names the version, so this gives 0 (R28). -pub(crate) fn form_version(form: [u8; 4]) -> Option { - let [a, b, c, v] = form; - match (&[a, b, c], v) { - (b"cdr", b'8') => Some(801), - (b"CDR" | b"cdr", b' ') => Some(300), - (b"CDR" | b"cdr", b'1'..=b'9') => Some(100 * u16::from(v - b'0')), - (b"CDR" | b"cdr", b'A'..=b'H') => Some(100 * u16::from(v - b'A' + 10)), - (b"CDR" | b"cdr", b'J'..=b'W') => Some(100 * u16::from(v - b'J' + 18)), - (b"CDT", b'A'..=b'Z') => Some(0), - _ => None, - } -} - -/// Does `bytes` start like a RIFF `.cdr` drawing (not the `CDRX` exchange variant)? -pub(crate) fn is_cdr_riff(bytes: &[u8]) -> bool { - bytes.get(..4) == Some(b"RIFF") && bytes.get(8..12).and_then(|f| f.try_into().ok()).and_then(form_version).is_some() -} - -impl<'a> Index<'a> { - pub(crate) fn build(input: &'a [u8], streams: Option>, budget: &mut Budget, warn: &mut Vec) -> Result { - if input.len() > budget.limits.input { - return Err(Error::Limit("input size")); - } - let mut r = Rd::new(input); - if r.fourcc() != Some(*b"RIFF") { - return Err(Error::NotCdr); - } - let declared = r.u32().ok_or(Error::NotCdr)? as usize; - let form = r.fourcc().ok_or(Error::NotCdr)?; - let version = form_version(form).ok_or(Error::NotCdr)?; - // A file cut short keeps what it holds: its last chunk is truncated with a warning. A - // length that ends inside the form type is damage too, and the chunks after it are read. - let end = match declared.checked_add(8) { - Some(e) if (12..=input.len()).contains(&e) => e, - _ => { - push(warn, Warning::Damaged); - input.len() - } - }; - let left = Cell::new(budget.inflate_left()); - let mut ix = Index { - input, - inflated: Vec::new(), - chunks: Vec::new(), - form_version: version, - streams, - left, - lists: Cell::default(), - leaves: Cell::default(), - shared_left: Cell::new(budget.limits.member), - vrsn: None, - }; - ix.chunks.push(Chunk { id: *b"RIFF", form, src: 0, start: 12, len: 0, first: 0, count: 0 }); - let mut queue = vec![Pending { entry: 0, src: 0, start: 12, end, pool: None, depth: 0 }]; - while let Some(p) = queue.pop() { - ix.split(p, &mut queue, budget, warn)?; - } - Ok(ix) - } - - /// The bytes `start..end` of source `src`, or `None` when the range crosses its end. A data - /// stream is read on first use. - fn span(&self, src: u32, start: usize, end: usize) -> Option<&[u8]> { - if src > 0 { - let s = self.streams.as_ref()?; - return s.get(src as usize - 1, &self.left)?.get(start..end); - } - let n = self.input.len(); - if end <= n { - self.input.get(start..end) - } else if start >= n { - self.inflated.get(start - n..end - n) - } else { - None - } - } - - pub(crate) fn data(&self, c: &Chunk) -> &[u8] { - let start = c.start as usize; - match self.span(c.src, start, start + c.len as usize) { - Some(b) => b, - None => { - if let Some(s) = &self.streams - && !self.past_limit(c.src) - { - s.note_damage(); - } - &[] - } - } - } - - /// Was source `src` a data stream left out because it is past a limit? Its chunks are then - /// left out with that warning alone. - fn past_limit(&self, src: u32) -> bool { - src > 0 && self.streams.as_ref().is_some_and(|s| s.past_limit(src as usize - 1)) - } - - pub(crate) fn children(&self, c: &Chunk) -> &[Chunk] { - let first = c.first as usize; - self.chunks.get(first..first + c.count as usize).unwrap_or_default() - } - - pub(crate) fn root(&self) -> Option<&Chunk> { - self.chunks.first() - } - - /// The version: the `vrsn` chunk's when it names one from 3 to 27, else the form type's (R1, - /// R2). A template's form type names no version, so its `vrsn` chunk decides whatever it names - /// (R28). Letters count differently from the version 24 update on (R1), so when both name a - /// version after 27 the `vrsn` chunk's is the one refused. The `cdr8` form type alone makes a - /// file the 8.01 variant, whatever its `vrsn` chunk names (R1). - pub(crate) fn version(&self) -> u16 { - match self.vrsn.flatten() { - _ if self.form_version == 801 => 801, - Some(v) if (layout::OLDEST_RIFF..=layout::NEWEST).contains(&v) => v, - Some(v) if self.form_version == 0 => v, - Some(v) if v > layout::NEWEST && self.form_version > layout::NEWEST => v, - _ => self.form_version, - } - } - - /// The warnings for data streams that were left out. - pub(crate) fn stream_warnings(&self, warn: &mut Vec) { - if let Some(s) = &self.streams { - s.warnings(warn); - } - } - - /// Split list `p` into its children, appended to the table together; their lists are queued. - fn split(&mut self, p: Pending, queue: &mut Vec, budget: &mut Budget, warn: &mut Vec) -> Result<(), Error> { - let first = self.chunks.len(); - let mut at = p.start; - let mut lists = Vec::new(); - while at < p.end { - let Some((read, next, cut)) = self.read_chunk(p.src, at, p.end, p.pool) else { - push(warn, Warning::Damaged); - break; - }; - if cut { - push(warn, Warning::Damaged); - } - at = next; - // A redirect record whose body can't be found counts as well, so that lists redirected - // to again and again can't repeat such records past the limit. - budget.take_chunk()?; - let chunk = match read { - Read::Chunk(chunk) => chunk, - Read::Lost => { - push(warn, Warning::Damaged); - continue; - } - Read::PastLimit => continue, - Read::SharedPastLimit => { - push(warn, Warning::TooDeep); - continue; - } - }; - if p.entry == 0 && chunk.id == *b"vrsn" && self.vrsn.is_none() { - let at = chunk.start as usize; - self.vrsn = Some(self.span(chunk.src, at, at + chunk.len as usize).and_then(|b| Rd::new(b).u16())); - } - if chunk.id == LIST { - lists.push(self.chunks.len()); - } - self.chunks.push(chunk); - } - let count = (self.chunks.len() - first) as u32; - if let Some(parent) = self.chunks.get_mut(p.entry) { - parent.first = first as u32; - parent.count = count; - } - for i in lists { - let Some(c) = self.chunks.get(i).copied() else { continue }; - // From version 7 a `LIST stlt` holds the style tables, not chunks (R4); its body is read - // whole (R45). Before version 7 it holds chunks. The file's own chunks, its `vrsn` - // among them, are all read before this. - if c.form == *b"stlt" && self.version() >= 700 { - continue; - } - if p.depth + 1 > budget.limits.depth { - push(warn, Warning::TooDeep); - continue; - } - let (start, end) = (c.start as usize, c.start as usize + c.len as usize); - if c.form == CMPR && p.pool.is_none() { - match self.inflate_cmpr(c.src, start, end) { - Ok((s, e, pool)) => queue.push(Pending { entry: i, src: 0, start: s, end: e, pool: Some(pool), depth: p.depth + 1 }), - Err(Error::Limit(what)) => return Err(Error::Limit(what)), - Err(_) => push(warn, Warning::Damaged), - } - } else { - queue.push(Pending { entry: i, src: c.src, start, end, pool: p.pool, depth: p.depth + 1 }); - } - } - Ok(()) - } - - /// The chunk at `at` (before `end`) of source `src`, and where the next one starts. In a - /// compressed stream the size field is an index into the size pool (R3); in a version 16+ - /// package a chunk of 16 bytes outside one is a redirect record (R27). The flag is set for a - /// list cut short at `end`. - fn read_chunk(&self, src: u32, at: usize, end: usize, pool: Option<(usize, usize)>) -> Option<(Read, usize, bool)> { - let head = self.span(src, at, at.checked_add(8)?.min(end))?; - let id: [u8; 4] = head.get(..4)?.try_into().ok()?; - let raw = u32_at(head, 4)? as usize; - let size = match pool { - None => raw, - Some((ps, pe)) => { - let off = raw.checked_mul(4)?.checked_add(ps)?; - (off.checked_add(4)? <= pe).then_some(())?; - u32_at(self.span(0, off, off + 4)?, 0)? as usize - } - }; - let body = at + 8; - // A list cut short by the end of its parent keeps the bytes it has, so the children - // before the cut are read; the caller warns that it is damaged. Other chunks are lost. - let (size, cut) = match body.checked_add(size) { - Some(e) if e <= end => (size, false), - _ if id == LIST => (end.checked_sub(body)?, true), - _ => return None, - }; - let next = (body + size + (size & 1)).min(end); - if cut { - return Some((self.chunk(id, src, body, size).map_or(Read::Lost, Read::Chunk), next, true)); - } - if self.streams.is_some() && pool.is_none() && size == REDIRECT { - let read = match self.redirect(id, src, body) { - Some(read) => read, - None if self.redirect_past_limit(src, body) => Read::PastLimit, - None => Read::Lost, - }; - return Some((read, next, false)); - } - Some((Read::Chunk(self.chunk(id, src, body, size)?), next, false)) - } - - /// Chunk `id` whose body is `len` bytes at `body` of source `src`; a list's body starts with - /// its form type. - fn chunk(&self, id: [u8; 4], src: u32, body: usize, len: usize) -> Option { - let (form, start) = if id == LIST { - let f: [u8; 4] = self.span(src, body, body.checked_add(4).filter(|_| len >= 4)?)?.try_into().ok()?; - (f, body + 4) - } else { - ([0; 4], body) - }; - let len = len - (start - body); - Some(Chunk { id, form, src, start: u32::try_from(start).ok()?, len: u32::try_from(len).ok()?, first: 0, count: 0 }) - } - - /// The chunk the redirect record at `body` of `src` stands for (R27): stream, length, offset - /// and a reserved u32. Stream `0xFFFFFFFF` holds at most 8 bytes in the record itself, after - /// the length. The body is not read again as a redirect record. `None` when the body can't - /// be found. - /// - /// A redirected list whose bytes overlap those of an earlier redirected list, in any stream of - /// the same package member, is left out, so that no list is split twice. Other chunks may - /// share bytes: each one after the first to read them takes their length from the - /// shared-bytes limit (the member limit), so that many redirects to one body can't decode it - /// without end. - fn redirect(&self, id: [u8; 4], src: u32, body: usize) -> Option { - let mut r = Rd::new(self.span(src, body, body + REDIRECT)?); - let stream = r.u32()?; - let len = r.u32()? as usize; - if stream == INLINE { - return (len <= 8).then(|| self.chunk(id, src, body + 8, len).map(Read::Chunk))?; - } - let off = r.u32()? as usize; - let streams = self.streams.as_ref()?; - let size = streams.size(stream as usize)?; - let end = off.checked_add(len).filter(|&e| e <= size)?; - let member = streams.member_of(stream as usize)?; - if id == LIST { - if !claim(&self.lists, member, off, end) { - return None; - } - } else if !claim(&self.leaves, member, off, end) { - let left = self.shared_left.get(); - if len > left { - return Some(Read::SharedPastLimit); - } - self.shared_left.set(left - len); - } - // Only a list's form type is read now; other bodies are read when the mapping asks. - self.chunk(id, stream.checked_add(1)?, off, len).map(Read::Chunk) - } - - /// Does the redirect record at `body` of `src` point into a data stream past a limit? - fn redirect_past_limit(&self, src: u32, body: usize) -> bool { - let stream = self.span(src, body, body + 4).and_then(|b| u32_at(b, 0)); - stream.is_some_and(|s| s != INLINE && self.past_limit(s.saturating_add(1))) - } - - /// Inflate the two blocks of a `LIST cmpr` body at `start..end` of `src` (R3) → the chunk - /// stream and the size pool, as ranges of source 0. - fn inflate_cmpr(&mut self, src: u32, start: usize, end: usize) -> Result<(usize, usize, (usize, usize)), Error> { - let body = self.span(src, start, end).ok_or(Error::Damaged("compressed list"))?; - let mut r = Rd::new(body); - let c1 = r.u32().ok_or(Error::Damaged("compressed list"))? as usize; - r.skip(4).ok_or(Error::Damaged("compressed list"))?; - let c2 = r.u32().ok_or(Error::Damaged("compressed list"))? as usize; - let block = |at: usize, len: usize| -> Result<&[u8], Error> { - let b = body.get(at..at.checked_add(len).ok_or(Error::Damaged("compressed list"))?).ok_or(Error::Damaged("compressed list"))?; - let mut h = Rd::new(b); - if h.fourcc() != Some(CPNG) || h.fourcc() != Some(CPNG_HEAD) { - return Err(Error::Damaged("compressed block")); - } - Ok(b.get(8..).unwrap_or_default()) - }; - let second_at = c1.checked_add(16).ok_or(Error::Damaged("compressed list"))?; - let (first, second) = (block(16, c1)?.to_vec(), block(second_at, c2)?.to_vec()); - let base = self.input.len(); - let stream = self.inflate(&first)?; - let pool = self.inflate(&second)?; - Ok((base + stream.0, base + stream.1, (base + pool.0, base + pool.1))) - } - - /// Inflate zlib `data` onto the end of the inflated bytes, within what is left → its range - /// there. - fn inflate(&mut self, data: &[u8]) -> Result<(usize, usize), Error> { - let at = self.inflated.len(); - let left = self.left.get(); - let reader = flate2::read::ZlibDecoder::new(data); - // One byte past what is left tells a stream that is too long from one that just fits. - let got = match reader.take((left as u64).saturating_add(1)).read_to_end(&mut self.inflated) { - Ok(n) => n, - Err(_) => { - // What a stream inflated before it failed counts toward the limit too, so that - // streams that fail late can't inflate past it again and again. - let produced = self.inflated.len().saturating_sub(at); - self.left.set(left.saturating_sub(produced)); - self.inflated.truncate(at); - return Err(Error::Damaged("compressed block")); - } - }; - if got > left { - self.inflated.truncate(at); - return Err(Error::Limit("inflated size")); - } - self.left.set(left - got); - if self.input.len().saturating_add(self.inflated.len()) > u32::MAX as usize { - return Err(Error::Limit("inflated size")); - } - Ok((at, at + got)) - } -} - -/// Take bytes `start..end` of package member `member` in `claimed`, or `false` when an earlier -/// redirect there took any of them. Empty ranges take nothing. -fn claim(claimed: &Cell>, member: usize, start: usize, end: usize) -> bool { - if start == end { - return true; - } - let mut taken = claimed.take(); - let before = taken.range(..=(member, start)).next_back().is_some_and(|(&(m, _), &e)| m == member && e > start); - let after = taken.range((member, start)..).next().is_some_and(|(&(m, s), _)| m == member && s < end); - let free = !before && !after; - if free { - taken.insert((member, start), end); - } - claimed.set(taken); - free -} - -/// Add `w` to the warnings once. -pub(crate) fn push(warn: &mut Vec, w: Warning) { - if !warn.contains(&w) { - warn.push(w); - } -} diff --git a/crates/cdr/src/styles.rs b/crates/cdr/src/styles.rs deleted file mode 100644 index e4022563c2..0000000000 --- a/crates/cdr/src/styles.rs +++ /dev/null @@ -1,258 +0,0 @@ -//! The style table in a `LIST stlt` of versions 7 to 15 (R45): the fill and outline records that a -//! style gives the objects that name it and have no fill or outline argument of their own. - -use std::collections::{HashMap, HashSet}; - -use crate::Error; -use crate::bytes::{Rd, u32_at}; -use crate::limits::Budget; - -/// One style: its parent, and the fill and outline table entries it names (0: none). -#[derive(Clone, Copy)] -struct Style { - parent: u32, - fill: u32, - outline: u32, -} - -/// The styles of a drawing: for each style id, the fill and outline records it gives, its -/// parents' included. -#[derive(Default)] -pub(crate) struct Styles { - fills: HashMap, - outlines: HashMap, -} - -impl Styles { - /// The style table in body `b` of a `LIST stlt` of `version` (R45), or `None` when it doesn't - /// parse to its end. Its fill and outline entries and its styles count toward the chunks a - /// read takes. - pub(crate) fn read(b: &[u8], version: u16, budget: &mut Budget) -> Result, Error> { - let mut limit = None; - let styles = parse(b, version, &mut |n| match budget.take_chunks(n) { - Ok(()) => true, - Err(e) => { - limit = Some(e); - false - } - }); - match limit { - Some(e) => Err(e), - None => Ok(styles), - } - } - - /// The fill record that style `id` gives. - pub(crate) fn fill(&self, id: u32) -> Option { - self.fills.get(&id).copied() - } - - /// The outline record that style `id` gives. - pub(crate) fn outline(&self, id: u32) -> Option { - self.outlines.get(&id).copied() - } -} - -/// The style table in `b`. `take` is asked for each count of entries or styles before they are -/// read; a `false` stops the read. -fn parse(b: &[u8], version: u16, take: &mut dyn FnMut(usize) -> bool) -> Option { - let mut r = Rd::new(b); - let count = r.u32()? as usize; - if count == 0 { - return (r.left() == 0).then(Styles::default); - } - // Fill entries carry 48 more bytes from version 13. - let fills = table(&mut r, if version >= 1300 { 60 } else { 12 }, take)?; - let outlines = table(&mut r, 12, take)?; - // The text style tables: fonts, alignments, spacings, two tables of fixed records, bullets, - // indents, hyphenation and drop caps, and from version 8.01 one more. - skip_table(&mut r, if version >= 1000 { 60 } else { 44 })?; - skip_table(&mut r, 12)?; - skip_table(&mut r, 52)?; - skip_table(&mut r, 152)?; - skip_table(&mut r, 784)?; - let bullets = r.u32()?; - for _ in 0..bullets { - bullet(&mut r, version)?; - } - skip_table(&mut r, 28)?; - skip_table(&mut r, if version >= 1300 { 36 } else { 32 })?; - skip_table(&mut r, 28)?; - if version >= 801 { - skip_table(&mut r, 12)?; - } - // Each style is at least 32 bytes. - if count > r.left() / 32 || !take(count) { - return None; - } - let mut styles = HashMap::new(); - for _ in 0..count { - let (id, s) = style(&mut r, version)?; - styles.entry(id).or_insert(s); - } - if r.left() != 0 { - return None; - } - let mut work = 0; - Some(Styles { fills: resolve(&styles, &fills, |s| s.fill, &mut work), outlines: resolve(&styles, &outlines, |s| s.outline, &mut work) }) -} - -/// For each style, the record of `table` that its own entry names, or the nearest parent's where -/// its entry is 0. Each style is resolved once, and each path forgets only the styles on it, so a -/// chain of any length takes time in proportion to the styles; a chain that comes back to a style -/// on it, or reaches a style that isn't there, gives no record. `work` counts the styles visited -/// and forgotten. -fn resolve(styles: &HashMap, table: &HashMap, entry: impl Fn(&Style) -> u32, work: &mut usize) -> HashMap { - // `None`: resolved to no record. - let mut done: HashMap> = HashMap::new(); - let mut path = Vec::new(); - let mut on_path = HashSet::new(); - for &start in styles.keys() { - let mut id = start; - let found = loop { - *work += 1; - if let Some(&known) = done.get(&id) { - break known; - } - let Some(s) = styles.get(&id) else { break None }; - // Back at a style on this path: a cycle. - if !on_path.insert(id) { - break None; - } - path.push(id); - match entry(s) { - 0 => id = s.parent, - e => break table.get(&e).copied(), - } - }; - for id in path.drain(..) { - *work += 1; - on_path.remove(&id); - done.insert(id, found); - } - } - done.into_iter().filter_map(|(id, r)| Some((id, r?))).collect() -} - -/// A table of a u32 count and entries of `size` bytes, each a table id, 4 bytes and a record id. -fn table(r: &mut Rd, size: usize, take: &mut dyn FnMut(usize) -> bool) -> Option> { - let n = r.u32()? as usize; - if n > r.left() / size || !take(n) { - return None; - } - let mut out = HashMap::new(); - for _ in 0..n { - let e = r.bytes(size)?; - out.entry(u32_at(e, 0)?).or_insert(u32_at(e, 8)?); - } - Some(out) -} - -/// A table of a u32 count and entries of `size` bytes, passed over. -fn skip_table(r: &mut Rd, size: usize) -> Option<()> { - let n = r.u32()? as usize; - r.skip(n.checked_mul(size)?) -} - -/// A bullet record, passed over: its length depends on a u32 inside it. -fn bullet(r: &mut Rd, version: u16) -> Option<()> { - r.skip(40)?; - if version >= 1300 { - if version >= 1400 { - r.skip(4)?; - } - let more = r.u32()?; - return r.skip(if more != 0 { 68 } else { 12 }); - } - r.skip(if version >= 1000 { 28 } else { 20 })?; - let more = r.u32()?; - if more != 0 { - r.skip(8)?; - } - r.skip(8) -} - -/// A style record: its kind (u32), id, parent, 8 bytes, a name length and the name (bytes before -/// version 12, UTF-16 units from it), the fill and outline entries, then the entries of text -/// styles (kinds 2 and 3). -fn style(r: &mut Rd, version: u16) -> Option<(u32, Style)> { - let kind = r.u32()?; - let (id, parent) = (r.u32()?, r.u32()?); - r.skip(8)?; - let len = r.u32()? as usize; - r.skip(len.checked_mul(if version >= 1200 { 2 } else { 1 })?)?; - let (fill, outline) = (r.u32()?, r.u32()?); - if kind > 1 { - r.skip(if version >= 801 { 20 } else { 16 })?; - } - if kind > 2 { - r.skip(20)?; - } - Some((id, Style { parent, fill, outline })) -} - -#[cfg(test)] -mod tests { - use super::*; - use crate::Limits; - use crate::synth::{self, V}; - - fn read(b: &[u8], version: u16) -> Option { - Styles::read(b, version, &mut Budget::new(Limits::default())).unwrap() - } - - #[test] - fn styles_that_name_each_other_as_parents_end() { - let looped = [synth::Style { id: 0x10, parent: 0x11, fill: 0, outline: 0 }, synth::Style { id: 0x11, parent: 0x10, fill: 0, outline: 0 }]; - let s = read(&synth::stlt_body(V(700), &[(0x100, 1)], &[], &looped, false), 700).unwrap(); - assert_eq!((s.fill(0x10), s.outline(0x11), s.fill(0x12)), (None, None, None)); - } - - #[test] - fn a_long_chain_of_parents_reaches_the_style_that_names_an_entry() { - let mut chain = vec![synth::Style { id: 1, parent: 0, fill: 0x100, outline: 0 }]; - chain.extend((2..=500).map(|id| synth::Style { id, parent: id - 1, fill: 0, outline: 0 })); - let s = read(&synth::stlt_body(V(1100), &[(0x100, 7)], &[], &chain, false), 1100).unwrap(); - assert_eq!((s.fill(500), s.fill(250), s.outline(500)), (Some(7), Some(7), None)); - } - - /// A loop of 2,000 styles, which every walk into it follows around, leaves the walks of 20,000 - /// other styles no more work than the styles they visit. - #[test] - fn one_long_walk_does_not_slow_the_walks_after_it() { - let mut styles: HashMap = (1..=2000).map(|id| (id, Style { parent: id % 2000 + 1, fill: 0, outline: 0 })).collect(); - styles.extend((10_001..=30_000).map(|id| (id, Style { parent: 0, fill: 0x100, outline: 0 }))); - let table = HashMap::from([(0x100, 7)]); - let mut work = 0; - let fills = resolve(&styles, &table, |s| s.fill, &mut work); - assert_eq!((fills.get(&1), fills.get(&10_001), fills.len()), (None, Some(&7), 20_000)); - assert!(work <= 4 * styles.len(), "{work}"); - } - - #[test] - fn an_entry_missing_from_its_table_names_no_record() { - let styles = [synth::Style { id: 0x10, parent: 0, fill: 0x101, outline: 0x200 }]; - let s = read(&synth::stlt_body(V(1300), &[(0x100, 1)], &[(0x200, 2)], &styles, false), 1300).unwrap(); - assert_eq!((s.fill(0x10), s.outline(0x10)), (None, Some(2))); - } - - #[test] - fn counts_past_the_body_do_not_parse() { - let mut b = synth::stlt_body(V(900), &[], &[], &[], false); - b[..4].copy_from_slice(&u32::MAX.to_le_bytes()); - assert!(read(&b, 900).is_none()); - let empty = 0u32.to_le_bytes(); - assert!(read(&empty, 900).is_some()); - assert!(read(&[], 900).is_none()); - } - - #[test] - fn entries_and_styles_count_toward_the_chunk_limit() { - let styles: Vec<_> = (1..=10).map(|id| synth::Style { id, parent: 0, fill: 0x100, outline: 0 }).collect(); - let b = synth::stlt_body(V(1000), &[(0x100, 1)], &[], &styles, false); - let mut budget = Budget::new(Limits { chunks: 10, ..Limits::default() }); - assert_eq!(Styles::read(&b, 1000, &mut budget).err(), Some(Error::Limit("chunk count"))); - let mut budget = Budget::new(Limits { chunks: 11, ..Limits::default() }); - assert!(Styles::read(&b, 1000, &mut budget).is_ok_and(|s| s.is_some())); - } -} diff --git a/crates/cdr/src/synth.rs b/crates/cdr/src/synth.rs deleted file mode 100644 index e109d8bf1d..0000000000 --- a/crates/cdr/src/synth.rs +++ /dev/null @@ -1,1083 +0,0 @@ -//! Synthetic drawings for tests and fuzz seeds, built from the layouts in `PROVENANCE.md`. Not a -//! `.cdr` writer: nothing checks that other programs open these files. - -use std::io::Write as _; - -/// A chunk or a list, before it is laid out. -#[derive(Clone, Debug)] -pub enum Node { - Chunk([u8; 4], Vec), - List([u8; 4], Vec), -} - -pub fn chunk(id: &[u8; 4], data: Vec) -> Node { - Node::Chunk(*id, data) -} - -pub fn list(form: &[u8; 4], children: Vec) -> Node { - Node::List(*form, children) -} - -fn put(out: &mut Vec, id: &[u8; 4], size: u32, body: &[u8], len: usize) { - out.extend(id); - out.extend(size.to_le_bytes()); - out.extend(body); - if len % 2 == 1 { - out.push(0); - } -} - -/// `n` laid out with real sizes. -pub fn plain(n: &Node) -> Vec { - let mut out = Vec::new(); - match n { - Node::Chunk(id, data) => put(&mut out, id, data.len() as u32, data, data.len()), - Node::List(form, kids) => { - let mut body = form.to_vec(); - body.extend(kids.iter().flat_map(plain)); - put(&mut out, b"LIST", body.len() as u32, &body, body.len()); - } - } - out -} - -/// `n` laid out for a compressed stream: each size field is an index into `pool`. -fn pooled(n: &Node, pool: &mut Vec) -> Vec { - let mut out = Vec::new(); - let (id, body) = match n { - Node::Chunk(id, data) => (*id, data.clone()), - Node::List(form, kids) => { - let mut body = form.to_vec(); - for k in kids { - body.extend(pooled(k, pool)); - } - (*b"LIST", body) - } - }; - let index = pool.len() as u32; - pool.push(body.len() as u32); - put(&mut out, &id, index, &body, body.len()); - out -} - -fn zlib(data: &[u8]) -> Vec { - let mut e = flate2::write::ZlibEncoder::new(Vec::new(), flate2::Compression::default()); - let _ = e.write_all(data); - e.finish().unwrap_or_default() -} - -/// A `LIST cmpr` holding `children` (R3). -pub fn cmpr(children: &[Node]) -> Node { - let mut pool = Vec::new(); - let stream: Vec = children.iter().flat_map(|c| pooled(c, &mut pool)).collect(); - let sizes: Vec = pool.iter().flat_map(|s| s.to_le_bytes()).collect(); - let block = |raw: &[u8]| { - let mut b = b"CPng".to_vec(); - b.extend([1, 0, 4, 0]); - b.extend(zlib(raw)); - b - }; - let (b1, b2) = (block(&stream), block(&sizes)); - let mut body = Vec::new(); - for (c, u) in [(b1.len(), stream.len()), (b2.len(), sizes.len())] { - body.extend((c as u32).to_le_bytes()); - body.extend((u as u32).to_le_bytes()); - } - body.extend(b1); - body.extend(b2); - Node::Chunk(*b"LIST", [b"cmpr".to_vec(), body].concat()) -} - -/// The form type letter of `version` (hundreds) (R1). -pub fn form(version: u16) -> [u8; 4] { - let n = (version / 100) as u8; - let c = match n { - // Version 3 has a space where later versions have their character. - 3 => b' ', - 0..=9 => b'0' + n, - 10..=17 => b'A' + n - 10, - _ => b'J' + n - 18, - }; - [b'C', b'D', b'R', c] -} - -/// A RIFF file of `version` holding `children`. -pub fn riff(version: u16, children: &[Node]) -> Vec { - let mut body = form(version).to_vec(); - for c in children { - body.extend(match c { - // A prebuilt `LIST cmpr` carries its own form type. - Node::Chunk(id, data) if id == b"LIST" => { - let mut o = Vec::new(); - put(&mut o, id, data.len() as u32, data, data.len()); - o - } - _ => plain(c), - }); - } - let mut out = b"RIFF".to_vec(); - out.extend((body.len() as u32).to_le_bytes()); - out.extend(body); - out -} - -/// Field writers for one version. -#[derive(Clone, Copy, Debug)] -pub struct V(pub u16); - -impl V { - pub fn short(self) -> bool { - self.0 < 600 - } - - pub fn word(self, v: usize) -> Vec { - if self.short() { (v as u16).to_le_bytes().to_vec() } else { (v as u32).to_le_bytes().to_vec() } - } - - /// Rectangle coordinates of `w` × `h` points with corners of `radius` points: coordinates - /// before version 15 (R15), from 15 f64 sizes and radii as shares of half the shorter side - /// (R29). - pub fn rect(self, w: f64, h: f64, radius: f64) -> Vec { - if self.0 < 1500 { - let n = if self.0 >= 900 { 4 } else { 1 }; - let mut out = [self.coord(w), self.coord(h)].concat(); - for _ in 0..n { - out.extend(self.coord(radius)); - } - return out; - } - let units = |pt: f64| pt / 72.0 * 254_000.0; - let mut out = Vec::new(); - for v in [units(w), units(h), 1.0, 1.0] { - out.extend(v.to_le_bytes()); - } - out.extend([0; 8]); - let share = radius / (w.abs().min(h.abs()) / 2.0); - for k in 0..4 { - if k > 0 { - out.extend([0; 16]); - } - out.extend(share.to_le_bytes()); - } - out - } - - /// A length in points as a coordinate. - pub fn coord(self, pt: f64) -> Vec { - if self.short() { - ((pt / 72.0 * 1000.0).round() as i16).to_le_bytes().to_vec() - } else { - ((pt / 72.0 * 254_000.0).round() as i32).to_le_bytes().to_vec() - } - } - - pub fn angle(self, deg: f64) -> Vec { - if self.short() { ((deg * 10.0).round() as i16).to_le_bytes().to_vec() } else { ((deg * 1_000_000.0).round() as i32).to_le_bytes().to_vec() } - } - - /// A `loda` record of object type `kind` (R6): header, arguments, offsets, then the types in - /// reverse. - pub fn loda(self, kind: u32, args: &[(u32, Vec)]) -> Vec { - let w = if self.short() { 2 } else { 4 }; - let head = 5 * w; - let mut body: Vec = Vec::new(); - let mut offsets = Vec::new(); - for (_, a) in args { - offsets.push(head + body.len()); - body.extend(a); - } - offsets.push(head + body.len()); - let offsets_at = head + body.len(); - let types_at = offsets_at + offsets.len() * w; - let total = types_at + args.len() * w; - let mut out = Vec::new(); - for f in [total, args.len(), offsets_at, types_at, kind as usize] { - out.extend(self.word(f)); - } - out.extend(body); - for o in offsets { - out.extend(self.word(o)); - } - for (t, _) in args.iter().rev() { - out.extend(self.word(*t as usize)); - } - out - } - - /// A `trfd` of `matrices` `[a, b, c, d, e, f]` with offsets in points (R8); before version 5 - /// each matrix is in fixed point (R37). - pub fn trfd(self, matrices: &[[f64; 6]]) -> Vec { - let w = if self.short() { 2 } else { 4 }; - let head = 3 * w; - let table = head; - let mut entries = Vec::new(); - let mut offsets = Vec::new(); - // The table holds one offset more than the entries: the record's end (R51). - let first = table + (matrices.len() + 1) * w; - for m in matrices { - offsets.push(first + entries.len()); - if self.0 >= 1300 { - entries.extend([0; 8]); - } - entries.extend(8u16.to_le_bytes()); - if !self.short() { - entries.extend([0; 6]); - } - if self.0 < 500 { - entries.extend(fixed_matrix(m)); - continue; - } - let unit = if self.short() { 1000.0 / 72.0 } else { 254_000.0 / 72.0 }; - let [a, b, c, d, e, f] = *m; - for v in [a, c, e * unit, b, d, f * unit] { - entries.extend(v.to_le_bytes()); - } - } - offsets.push(first + entries.len()); - let mut out = Vec::new(); - for f in [first + entries.len(), matrices.len(), table] { - out.extend(self.word(f)); - } - for o in offsets { - out.extend(self.word(o)); - } - out.extend(entries); - out - } - - /// A curve's point list (R16). - pub fn points(self, pts: &[(f64, f64, u8)]) -> Vec { - let mut out = (pts.len() as u32).to_le_bytes().to_vec(); - for (x, y, _) in pts { - out.extend(self.coord(*x)); - out.extend(self.coord(*y)); - } - out.extend(pts.iter().map(|p| p.2)); - out - } - - /// A uniform fill record (R11) of 12-byte color `color`. - pub fn fill(self, id: u32, color: &[u8; 12]) -> Vec { - let mut out = id.to_le_bytes().to_vec(); - if self.0 >= 1300 { - let mut props = vec![1]; - props.extend(12u32.to_le_bytes()); - props.extend(color); - props.extend([0, 0, 0, 0, 0]); - let mut solid = 1300u32.to_le_bytes().to_vec(); - solid.extend((props.len() as u32).to_le_bytes()); - solid.extend(props); - let mut body = 1u16.to_le_bytes().to_vec(); - body.extend(solid); - out.extend(1300u32.to_le_bytes()); - out.extend((body.len() as u32).to_le_bytes()); - out.extend(body); - } else { - out.extend(1u16.to_le_bytes()); - out.extend([0, 0]); - out.extend(color); - } - out - } - - /// An outline record (R12) of `pen`, `color` and `dashes`. - pub fn outline(self, id: u32, pen: Pen, color: &[u8; 12], dashes: &[u16]) -> Vec { - let Pen { line_type, width, cap, join } = pen; - let mut out = id.to_le_bytes().to_vec(); - if self.0 >= 1300 { - out.extend(1u32.to_le_bytes()); - out.extend(0u32.to_le_bytes()); - } - for f in [line_type, cap, join] { - out.extend(f.to_le_bytes()); - } - let v = self.0; - out.extend(vec![0; if (600..1300).contains(&v) { 2 } else { 0 }]); - out.extend(self.coord(width)); - out.extend(100u16.to_le_bytes()); - out.extend(vec![0; if self.short() { 0 } else { 2 }]); - out.extend(self.angle(0.0)); - out.extend(vec![ - 0; - if v >= 1300 { - 46 - } else if self.short() { - 0 - } else { - 52 - } - ]); - out.extend(color); - out.extend(vec![0; if self.short() { 10 } else { 16 }]); - out.extend((dashes.len() as u16).to_le_bytes()); - for d in dashes { - out.extend(d.to_le_bytes()); - } - out.extend([0; 32]); - out - } -} - -/// An outline's line type (bit 0: none), width in points, cap and join. -#[derive(Clone, Copy, Debug)] -pub struct Pen { - pub line_type: u16, - pub width: f64, - pub cap: u16, - pub join: u16, -} - -/// A 12-byte color record (R14) of `model` and its four value bytes. -pub fn color(model: u16, v: [u8; 4]) -> [u8; 12] { - let mut c = [0; 12]; - c[..2].copy_from_slice(&model.to_le_bytes()); - c[8..].copy_from_slice(&v); - c -} - -/// A version 4 color (R36): `model` and its four values as u16, then 2 bytes. -pub fn color4(model: u16, v: [u16; 4]) -> [u8; 12] { - let mut c = [0; 12]; - c[..2].copy_from_slice(&model.to_le_bytes()); - for (k, x) in v.into_iter().enumerate() { - c[2 + 2 * k..4 + 2 * k].copy_from_slice(&x.to_le_bytes()); - } - c -} - -/// A color of versions 1 to 3 (R36): `model` and its four value bytes. -pub fn color3(model: u8, v: [u8; 4]) -> [u8; 5] { - [model, v[0], v[1], v[2], v[3]] -} - -/// A matrix `[a, b, c, d, e, f]` with offsets in points as six i32 `a c tx b d ty`: the factors in -/// 16.16 fixed point, the offsets in 1/1000 inch (R37). -fn fixed_matrix(m: &[f64; 6]) -> Vec { - let [a, b, c, d, e, f] = *m; - let fixed = |v: f64| (v * 65536.0).round() as i32; - let units = |pt: f64| (pt / 72.0 * 1000.0).round() as i32; - [fixed(a), fixed(c), units(e), fixed(b), fixed(d), units(f)].iter().flat_map(|v| v.to_le_bytes()).collect() -} - -/// The transforms argument (100) of a version 3 object or group (R33): one matrix entry for each -/// of `matrices` `[a, b, c, d, e, f]` with offsets in points, applied in the order given. -pub fn transforms3(matrices: &[[f64; 6]]) -> Vec { - let first = 4 + 10 * matrices.len(); - let mut out = vec![0, 0]; - out.extend((matrices.len() as u16).to_le_bytes()); - for i in 0..matrices.len() { - out.extend(0x8cu16.to_le_bytes()); - out.extend([0; 4]); - out.extend(((first + 24 * i) as u16).to_le_bytes()); - out.extend([0; 2]); - } - out.extend(matrices.iter().flat_map(fixed_matrix)); - out -} - -/// The fill argument (20) of a version 3 object (R34): the type byte, then `color` for a uniform -/// fill (type 1). -pub fn fill3(kind: u8, color: &[u8]) -> Vec { - let mut out = vec![kind]; - out.extend(color); - out -} - -/// The outline argument (10) of a version 3 object (R35) of `pen`, `color` and `dashes`; bit 0 of -/// its flags is set unless the pen's line type says no outline. -pub fn outline3(pen: Pen, color: [u8; 5], dashes: &[u8]) -> Vec { - let v = V(300); - let mut out = vec![u8::from(pen.line_type & 1 == 0)]; - out.extend(v.coord(pen.width)); - out.extend(100u16.to_le_bytes()); - out.extend(v.angle(0.0)); - out.extend(color); - out.extend([0; 7]); - out.push(dashes.len() as u8); - let mut area = dashes.to_vec(); - area.resize(10, 0); - out.extend(area); - out.extend(pen.join.to_le_bytes()); - out.extend(pen.cap.to_le_bytes()); - out.extend([0; 8]); - out -} - -/// A version 3 group (R33): its own `lobj` with the transforms that place `objects`, then the -/// objects. -pub fn group3(matrices: &[[f64; 6]], objects: Vec) -> Node { - let mut kids = vec![chunk(b"flgs", vec![0, 0, 0, 0x10]), chunk(b"lobj", V(300).loda(0, &[(100, transforms3(matrices))]))]; - kids.extend(objects); - list(b"grp ", kids) -} - -/// An object list: flags, then a `lgob` list with the `loda` and an optional transform in a `trfl` -/// list (R22). A version 3 object is a `lobj` whose type counts from 0 (R32) and whose transform is -/// its argument 100 (R33). -pub fn object(v: V, kind: u32, args: &[(u32, Vec)], matrix: Option<[f64; 6]>) -> Node { - if v.0 < 400 { - let kind = if (1..=5).contains(&kind) { kind - 1 } else { kind }; - let mut args = args.to_vec(); - args.extend(matrix.map(|m| (100, transforms3(&[m])))); - return list(b"obj ", vec![chunk(b"flgs", vec![0, 0, 0, 0x08]), chunk(b"lobj", v.loda(kind, &args))]); - } - let mut own = vec![chunk(b"loda", v.loda(kind, args))]; - if let Some(m) = matrix { - own.push(list(b"trfl", vec![chunk(b"trfd", v.trfd(&[m]))])); - } - list(b"obj ", vec![chunk(b"flgs", vec![0, 0, 0, 0x08]), list(b"lgob", own)]) -} - -/// A layer list of `kind` flags named `name` holding `objects`, its `loda` in a `lgob` list (R22), -/// with the object type that layers of such flags have in sample files (R19). -pub fn layer(v: V, flags: [u8; 4], name: &str, objects: Vec) -> Node { - let kind = match flags { - [b0, ..] if (b0 & 0x0f == 0x0a || b0 & 0x0f == 0x02) && b0 & 0x10 != 0 => 11, - [b0, ..] if b0 & 0x0f == 0x0a || b0 & 0x0f == 0x02 => 12, - [b0, _, b2, _] if b0 & 0x0f == 0x08 && b2 != 0 => 17, - [0, 1, 1, _] => 17, - _ => 0, - }; - // Version 3 counts its types from 0, one less (R32). - let kind = if v.0 < 400 && kind > 0 { kind - 1 } else { kind }; - layer_of_type(v, flags, kind, name, objects) -} - -/// A layer list as [`layer`] writes it, with the object type `kind` in its `loda`. -pub fn layer_of_type(v: V, flags: [u8; 4], kind: u32, name: &str, objects: Vec) -> Node { - let name: Vec = - if v.0 >= 1200 { name.encode_utf16().chain([0]).flat_map(|u| u.to_le_bytes()).collect() } else { name.bytes().chain([0]).collect() }; - let mut kids = vec![chunk(b"flgs", flags.to_vec()), list(b"lgob", vec![chunk(b"loda", v.loda(kind, &[(1000, name)]))])]; - kids.extend(objects); - list(b"layr", kids) -} - -/// A page list: flags (byte 2 set for the master page), then its layers in a `gobj` list (R22). -pub fn page(master: bool, layers: Vec) -> Node { - list(b"page", vec![chunk(b"flgs", vec![0, 0, u8::from(master), 0x90]), list(b"gobj", layers)]) -} - -/// The `mcfg` chunk of `version` with a page of `w` × `h` points (R10); in version 3, 2 bytes and -/// the page's top left and bottom right corners (R38). -pub fn mcfg(v: V, w: f64, h: f64) -> Node { - if v.0 < 400 { - let mut b = vec![0; 2]; - b.extend([v.coord(-w / 2.0), v.coord(h / 2.0), v.coord(w / 2.0), v.coord(-h / 2.0)].concat()); - b.extend([0; 16]); - return chunk(b"mcfg", b); - } - let skip = if v.0 >= 1300 { - 12 - } else if v.0 >= 900 { - 4 - } else if (600..700).contains(&v.0) { - 28 - } else { - 0 - }; - let mut b = vec![0; skip]; - b.extend(v.coord(w)); - b.extend(v.coord(h)); - b.extend([0; 16]); - chunk(b"mcfg", b) -} - -/// A style of a [`stlt_body`]: its id, its parent's id, and its fill and outline table entries. -#[derive(Clone, Copy, Debug)] -pub struct Style { - pub id: u32, - pub parent: u32, - pub fill: u32, - pub outline: u32, -} - -/// The body of a `LIST stlt` of `v` (R45): the style count, the fill table (`(entry, fild id)`) and -/// the outline table (`(entry, outl id)`), the text style tables (each with one record when -/// `text`), then `styles` as styles of kind 1, and when `text` a style of kind 2 and one of kind 3. -pub fn stlt_body(v: V, fills: &[(u32, u32)], outlines: &[(u32, u32)], styles: &[Style], text: bool) -> Vec { - let version = v.0; - let u32s = |vals: &[u32]| -> Vec { vals.iter().flat_map(|x| x.to_le_bytes()).collect() }; - let count = styles.len() + if text { 2 } else { 0 }; - let mut b = u32s(&[count as u32]); - // A table without styles holds nothing else. - if count == 0 { - return b; - } - for (table, size) in [(fills, if version >= 1300 { 60 } else { 12 }), (outlines, 12)] { - b.extend(u32s(&[table.len() as u32])); - for (entry, record) in table { - let mut e = u32s(&[*entry, 0, *record]); - e.resize(size, 0); - b.extend(e); - } - } - let n = u32::from(text); - let fixed = |size: usize| -> Vec { - let mut t = n.to_le_bytes().to_vec(); - t.extend(vec![0x5a; size * n as usize]); - t - }; - // Fonts, alignments, spacings and two tables of fixed records. - for size in [if version >= 1000 { 60 } else { 44 }, 12, 52, 152, 784] { - b.extend(fixed(size)); - } - // One bullet, whose u32 inside asks for the longer form. - b.extend(n.to_le_bytes()); - if text { - b.extend([0x5a; 40]); - if version >= 1300 { - if version >= 1400 { - b.extend([0x5a; 4]); - } - b.extend(u32s(&[1])); - b.extend([0x5a; 68]); - } else { - b.extend(vec![0x5a; if version >= 1000 { 28 } else { 20 }]); - b.extend(u32s(&[1])); - b.extend([0x5a; 16]); - } - } - // Indents, hyphenation, drop caps, and from version 8.01 one more table. - for size in [28, if version >= 1300 { 36 } else { 32 }, 28] { - b.extend(fixed(size)); - } - if version >= 801 { - b.extend(fixed(12)); - } - let text_styles = [(2, Style { id: 0x7f02, parent: 0, fill: 0, outline: 0 }), (3, Style { id: 0x7f03, parent: 0x7f02, fill: 0, outline: 0 })]; - let all = styles.iter().map(|s| (1u32, *s)).chain(text_styles.into_iter().filter(|_| text)); - for (kind, s) in all { - b.extend(u32s(&[kind, s.id, s.parent, 1, 1])); - if version >= 1200 { - b.extend(u32s(&[7])); - b.extend("Graphic".encode_utf16().flat_map(u16::to_le_bytes)); - } else { - b.extend(u32s(&[8])); - b.extend(b"Graphic\0"); - } - b.extend(u32s(&[s.fill, s.outline])); - if kind > 1 { - b.extend(vec![0; if version >= 801 { 20 } else { 16 }]); - } - if kind > 2 { - b.extend([0; 20]); - } - } - b -} - -/// A `LIST stlt` of [`stlt_body`]. -pub fn stlt(v: V, fills: &[(u32, u32)], outlines: &[(u32, u32)], styles: &[Style], text: bool) -> Node { - Node::Chunk(*b"LIST", [b"stlt".to_vec(), stlt_body(v, fills, outlines, styles, text)].concat()) -} - -/// A `LIST clpt` of clipped groups (R46): each a `LIST grp ` with its `spnd` id, then its objects. -pub fn clpt(groups: Vec<(u32, Vec)>) -> Node { - let groups = groups - .into_iter() - .map(|(id, objects)| { - let mut kids = vec![chunk(b"spnd", id.to_le_bytes().to_vec())]; - kids.extend(objects); - list(b"grp ", kids) - }) - .collect(); - list(b"clpt", groups) -} - -/// The container argument (8005) naming clipped group `id` (R46), laid out as sample files lay it -/// out. -pub fn container(id: u32) -> (u32, Vec) { - (8005, [id, 1, 0, 1].iter().flat_map(|v| v.to_le_bytes()).collect()) -} - -/// The argument 8000 of a uniform transparency from version 13 (R47): one record of version 1300 -/// whose 117-byte body holds `percent` at byte 61 and `merge` at byte 77. -pub fn transparency(percent: f64, merge: u8) -> (u32, Vec) { - let mut body = vec![0; 117]; - body[61..69].copy_from_slice(&percent.to_le_bytes()); - body[77] = merge; - let mut out = 1300u32.to_le_bytes().to_vec(); - out.extend((body.len() as u32).to_le_bytes()); - out.extend(body); - (8000, out) -} - -/// A property list (R11, R12) of 12-byte color `color` and, when `name` is given, a type 8 -/// property with that library name. -pub fn properties(color: &[u8; 12], name: Option<&str>) -> Vec { - let mut out = vec![1]; - out.extend(12u32.to_le_bytes()); - out.extend(color); - if let Some(name) = name { - let mut body = vec![0; 16]; - body.extend((name.encode_utf16().count() as u32).to_le_bytes()); - body.extend(name.encode_utf16().flat_map(u16::to_le_bytes)); - out.push(8); - out.extend((body.len() as u32).to_le_bytes()); - out.extend(body); - } - out.extend([0, 0, 0, 0, 0]); - out -} - -/// `n` (an object, group or layer list) with its `flgs` chunk replaced by `flags` (R19). -pub fn flagged(n: Node, flags: [u8; 4]) -> Node { - match n { - Node::List(form, kids) => { - let kids = kids - .into_iter() - .map(|k| if matches!(&k, Node::Chunk(id, _) if id == b"flgs") { chunk(b"flgs", flags.to_vec()) } else { k }) - .collect(); - Node::List(form, kids) - } - chunk => chunk, - } -} - -/// A RIFF drawing of `version` (7 to 13) with a style table, a clipping container and a lens: a rectangle -/// that takes its fill and outline from its style, a container that clips two rectangles, one -/// with an outline behind the fill, a rectangle with a lens, a hidden and locked rectangle with a -/// winding flag and a uniform transparency, and a hidden group whose rectangle's outline names a -/// library color from version 13; compressed when `compress`. Before version 7, the [`sample`]. -pub fn feature_sample(version: u16, compress: bool) -> Vec { - if version < 700 { - return sample(version, false); - } - let v = V(version); - let black = color(2, [0, 0, 0, 100]); - let rect = |w: f64, extra: Vec<(u32, Vec)>, at: f64| { - let mut args = vec![(30, v.rect(w, w, 0.0))]; - args.extend(extra); - object(v, 1, &args, Some([1.0, 0.0, 0.0, 1.0, at, at])) - }; - let style = (200, 0x10u32.to_le_bytes().to_vec()); - let clipped = - vec![rect(30.0, vec![style.clone()], 10.0), rect(30.0, vec![(10, 3u32.to_le_bytes().to_vec()), (20, 1u32.to_le_bytes().to_vec())], -10.0)]; - // From version 13 outline 4 names a library color in a record of type 2 (R12). - let mut named = v.outline(4, Pen { line_type: 0, width: 1.0, cap: 0, join: 0 }, &color(25, [7, 0, 100, 0]), &[]); - if version >= 1300 { - let props = properties(&color(5, [0, 0, 255, 0]), Some("Sky Blue")); - let mut record = 2u32.to_le_bytes().to_vec(); - record.extend((props.len() as u32).to_le_bytes()); - record.extend(props); - named.splice(4..4, record); - } - let doc = list( - b"doc ", - vec![ - mcfg(v, 612.0, 792.0), - list(b"filt", vec![chunk(b"fild", v.fill(1, &color(5, [0, 0, 255, 0])))]), - list( - b"otlt", - vec![ - chunk(b"outl", v.outline(2, Pen { line_type: 4, width: 2.0, cap: 1, join: 1 }, &black, &[3, 1])), - chunk(b"outl", v.outline(3, Pen { line_type: 0x12, width: 4.0, cap: 0, join: 0 }, &black, &[])), - chunk(b"outl", named), - ], - ), - stlt(v, &[(0x100, 1)], &[(0x200, 2)], &[Style { id: 0x10, parent: 0, fill: 0x100, outline: 0x200 }], true), - clpt(vec![(7, clipped)]), - ], - ); - let objects = vec![ - rect(20.0, vec![style.clone()], 0.0), - rect(40.0, vec![style.clone(), container(7)], 50.0), - rect(20.0, vec![style.clone(), (8000, vec![1, 0, 0, 0])], -50.0), - // Hidden and locked, filled nonzero, 25% transparent with merge mode 9 (R19, R47, R52). - flagged(rect(10.0, vec![style.clone(), (14001, vec![1, 0, 0, 0]), transparency(25.0, 9)], 80.0), [0x10, 1, 0, 0x08]), - list(b"grp ", vec![chunk(b"flgs", vec![0, 1, 0, 0x10]), rect(10.0, vec![(10, 4u32.to_le_bytes().to_vec())], -80.0)]), - ]; - let page = page(false, vec![layer(v, [0, 0, 0, 0x98], "Art", objects)]); - let mut body = vec![chunk(b"vrsn", version.to_le_bytes().to_vec())]; - if compress { - body.push(cmpr(&[doc, page])); - } else { - body.extend([doc, page]); - } - riff(version, &body) -} - -/// A file of `version` holding `content` as the program of that version saves it: a RIFF file -/// before 14, then a package (R25, R26). -pub fn file_of(version: u16, content: Vec) -> Vec { - let mut body = vec![chunk(b"vrsn", version.to_le_bytes().to_vec())]; - body.extend(content); - match version { - ..1400 => riff(version, &body), - 1400..1600 => package14(riff(version, &body), false), - _ => package16(version, &body, false, &[]), - } -} - -/// The document list and pages of the [`sample`] of `version`. -pub fn sample_content(version: u16) -> Vec { - let v = V(version); - // Before version 5 the sample's colors are CMYK in percent, model 1 (R36). - let (red, black) = - if version < 500 { (color4(1, [0, 100, 100, 0]), color4(1, [0, 0, 0, 100])) } else { (color(5, [0, 0, 255, 0]), color(2, [0, 0, 0, 100])) }; - let (round, none) = (Pen { line_type: 0, width: 2.0, cap: 1, join: 1 }, Pen { line_type: 1, width: 1.0, cap: 0, join: 0 }); - let mut settings = vec![mcfg(v, 612.0, 792.0)]; - // Version 3 keeps fills and outlines in the objects (R34, R35). - if version >= 400 { - settings.push(list(b"filt", vec![chunk(if version >= 700 { b"fild" } else { b"fill" }, v.fill(1, &red))])); - settings.push(list(b"otlt", vec![chunk(b"outl", v.outline(2, round, &black, &[])), chunk(b"outl", v.outline(3, none, &black, &[]))])); - } - let doc = list(b"doc ", settings); - // Fill 1 is red and 0 none; outline 2 is 2 pt with round caps and joins, 3 none. - let style = |fill: u32, outline: u32| { - if version >= 400 { - return vec![(20, fill.to_le_bytes().to_vec()), (10, outline.to_le_bytes().to_vec())]; - } - let fill = if fill == 1 { fill3(1, &color3(1, [0, 100, 100, 0])) } else { fill3(0, &[]) }; - vec![(20, fill), (10, outline3(if outline == 2 { round } else { none }, color3(1, [0, 0, 0, 100]), &[]))] - }; - let mut rect_args = style(1, 2); - rect_args.push((30, v.rect(100.0, 50.0, 5.0))); - let mut ellipse_args = style(1, 3); - ellipse_args.push((30, [v.coord(40.0), v.coord(-40.0), v.angle(0.0), v.angle(0.0), v.word(0)].concat())); - let mut curve_args = style(0, 2); - curve_args.push((30, v.points(&[(0.0, 0.0, 0x08), (50.0, 0.0, 0x40), (50.0, 20.0, 0xC0), (20.0, 50.0, 0xC0), (0.0, 50.0, 0x88)]))); - let mut arc_args = style(0, 2); - arc_args.push((30, [v.coord(30.0), v.coord(30.0), v.angle(0.0), v.angle(90.0), v.word(1)].concat())); - let side = POLYGON_SIDE; - let mut poly_args = style(1, 2); - poly_args.push((30, v.points(&[(0.0, side, 0x0C), (side * 0.587, side * 0.809, 0x44), (side * 0.951, side * 0.309, 0x44)]))); - let mut poly = if version >= 1300 { vec![] } else { vec![0; 4] }; - poly.extend(5u32.to_le_bytes()); - poly.extend([0; 8]); - if version >= 1300 { - poly.extend([0; 4]); - } - poly.extend(0.05f64.to_le_bytes()); - poly.extend(0.05f64.to_le_bytes()); - poly.extend([v.coord(0.0), v.coord(0.0)].concat()); - poly_args.push((11000, poly)); - let art = layer( - v, - [0, 0, 0, 0x98], - "Art", - vec![ - object(v, 1, &rect_args, Some([1.0, 0.0, 0.0, 1.0, -100.0, 100.0])), - object(v, 2, &ellipse_args, Some([1.0, 0.0, 0.0, 1.0, 50.0, -50.0])), - object(v, 3, &curve_args, None), - list(b"grp ", vec![chunk(b"flgs", vec![0, 0, 0, 0x10]), object(v, 0x14, &poly_args, None), object(v, 2, &arc_args, None)]), - object(v, 4, &[(30, [v.coord(0.0), v.coord(0.0)].concat())], None), - ], - ); - let mut guide = vec![0; 12]; - guide.extend((90_000_000i32).to_le_bytes()); - guide.extend([v.coord(36.0), v.coord(0.0), v.coord(36.0), v.coord(100.0), v.coord(36.0), v.coord(0.0)].concat()); - let guides = layer(v, [0x0a, 0, 1, 0x98], "Guides", vec![object(v, 0x16, &[(16000, guide)], None)]); - let desktop = - layer(v, [0x08, 0, 1, 0x98], "Desktop", vec![object(v, 1, &[(30, v.rect(10.0, 10.0, 0.0))], Some([1.0, 0.0, 0.0, 1.0, 400.0, 0.0]))]); - let pages = vec![page(true, vec![guides, desktop]), page(false, vec![art])]; - std::iter::once(doc).chain(pages).collect() -} - -/// A drawing of `version` with one page of each kind of object this reader reads, a text object -/// it doesn't, a master page with a guideline and a desktop object; compressed (version 7 on) -/// when `compress`. -pub fn sample(version: u16, compress: bool) -> Vec { - let content = sample_content(version); - let mut body = vec![chunk(b"vrsn", version.to_le_bytes().to_vec())]; - if compress { - body.push(cmpr(&content)); - } else { - body.extend(content); - } - riff(version, &body) -} - -/// The sample of `version` as the program of that version saves it: a RIFF file before 14, then -/// a package (R25, R26); `compress` compresses the RIFF stream before 16 and deflates the package -/// members. -pub fn sample_file(version: u16, compress: bool) -> Vec { - match version { - ..1400 => sample(version, compress), - 1400..1600 => package14(sample(version, compress), compress), - _ => { - // The full version chunk comes first from 16; the reader doesn't use it. - let fver: Vec = [u32::from(version), 1, 0, u32::from(version / 100)].iter().flat_map(|v| v.to_le_bytes()).collect(); - let mut body = vec![chunk(b"fver", fver), chunk(b"vrsn", version.to_le_bytes().to_vec())]; - body.extend(sample_content(version)); - package16(version, &body, compress, &[]) - } - } -} - -/// One member of a synthetic ZIP archive. -#[derive(Clone, Debug)] -pub struct Member { - pub name: String, - pub data: Vec, - pub deflate: bool, -} - -fn deflate(data: &[u8]) -> Vec { - let mut e = flate2::write::DeflateEncoder::new(Vec::new(), flate2::Compression::default()); - let _ = e.write_all(data); - e.finish().unwrap_or_default() -} - -/// A ZIP archive of `members`, stored or deflated, with `comment` after the end record (R24). -pub fn zip(members: &[Member], comment: &[u8]) -> Vec { - let (mut out, mut dir) = (Vec::new(), Vec::new()); - for m in members { - let packed = if m.deflate { deflate(&m.data) } else { m.data.clone() }; - let method: u16 = if m.deflate { 8 } else { 0 }; - // Version needed, flags, method, time, date, CRC-32, packed and full sizes, name length. - let mut common = Vec::new(); - common.extend(20u16.to_le_bytes()); - common.extend(0u16.to_le_bytes()); - common.extend(method.to_le_bytes()); - common.extend([0; 4]); - common.extend(crc32fast::hash(&m.data).to_le_bytes()); - common.extend((packed.len() as u32).to_le_bytes()); - common.extend((m.data.len() as u32).to_le_bytes()); - common.extend((m.name.len() as u16).to_le_bytes()); - let at = out.len() as u32; - out.extend(0x0403_4b50u32.to_le_bytes()); - out.extend(&common); - out.extend(0u16.to_le_bytes()); - out.extend(m.name.as_bytes()); - out.extend(&packed); - dir.extend(0x0201_4b50u32.to_le_bytes()); - dir.extend(20u16.to_le_bytes()); - dir.extend(&common); - // Extra and comment lengths, disk, internal and external attributes, header offset. - dir.extend([0; 12]); - dir.extend(at.to_le_bytes()); - dir.extend(m.name.as_bytes()); - } - let dir_at = out.len() as u32; - let n = members.len() as u16; - out.extend(&dir); - out.extend(0x0605_4b50u32.to_le_bytes()); - out.extend([0; 4]); - out.extend(n.to_le_bytes()); - out.extend(n.to_le_bytes()); - out.extend((dir.len() as u32).to_le_bytes()); - out.extend(dir_at.to_le_bytes()); - out.extend((comment.len() as u16).to_le_bytes()); - out.extend(comment); - out -} - -/// A version 14 or 15 package: the RIFF file `riff` as `content/riffData.cdr` (R25). -pub fn package14(riff: Vec, deflate: bool) -> Vec { - zip(&[Member { name: "content/riffData.cdr".into(), data: riff, deflate }], b"") -} - -/// A version 16+ package of a drawing of `version` holding `children` (R26, R27): the chunk tree -/// in `content/root.dat`, each chunk body of more than 8 bytes moved to a data stream (the -/// document's and other chunks' to `data1.dat`, each page's to `page.dat`, each other list's -/// to a stream named after its form type) behind a redirect record, and shorter bodies kept in -/// theirs. Lists stay in the tree. `extra` members are added to the archive. -pub fn package16(version: u16, children: &[Node], deflate: bool, extra: &[Member]) -> Vec { - package16_with(version, children, deflate, extra, &[]) -} - -/// [`package16`], moving the lists whose form types are in `moved_lists` whole into their stream. -pub fn package16_with(version: u16, children: &[Node], deflate: bool, extra: &[Member], moved_lists: &[[u8; 4]]) -> Vec { - let mut members = package16_members(version, children, deflate, moved_lists); - members.extend(extra.iter().cloned()); - zip(&members, b"") -} - -/// The members of a [`package16_with`] archive. -pub fn package16_members(version: u16, children: &[Node], deflate: bool, moved_lists: &[[u8; 4]]) -> Vec { - let mut streams: Vec<(String, Vec)> = vec![("data1.dat".into(), Vec::new())]; - let mut body = form(version).to_vec(); - for c in children { - let s = match c { - Node::List(f, _) if *f != *b"doc " => { - let name = if *f == *b"page" { format!("page{}", streams.len()) } else { String::from_utf8_lossy(f).trim().to_string() }; - streams.push((format!("{name}.dat"), Vec::new())); - streams.len() - 1 - } - _ => 0, - }; - body.extend(redirected(c, s, &mut streams, moved_lists)); - } - let mut root = b"RIFF".to_vec(); - root.extend((body.len() as u32).to_le_bytes()); - root.extend(body); - let list: Vec = streams.iter().map(|(n, _)| n.clone()).collect(); - let mut members = vec![ - Member { name: "content/root.dat".into(), data: root, deflate }, - Member { name: "content/dataFileList.dat".into(), data: list.join("\n").into_bytes(), deflate }, - ]; - members.extend(streams.into_iter().map(|(n, data)| Member { name: format!("content/data/{n}"), data, deflate })); - members -} - -/// `n` laid out for `root.dat`, its bodies moved into stream `s`. -fn redirected(n: &Node, s: usize, streams: &mut [(String, Vec)], moved_lists: &[[u8; 4]]) -> Vec { - let mut out = Vec::new(); - match n { - Node::List(f, kids) if !moved_lists.contains(f) => { - let mut body = f.to_vec(); - body.extend(kids.iter().flat_map(|k| redirected(k, s, streams, moved_lists))); - put(&mut out, b"LIST", body.len() as u32, &body, body.len()); - } - _ => { - // A moved list's children are laid out in the stream by the same rule. - let (id, data) = match n { - Node::Chunk(id, data) => (*id, data.clone()), - Node::List(f, kids) => { - let mut body = f.to_vec(); - for k in kids { - body.extend(redirected(k, s, streams, moved_lists)); - } - (*b"LIST", body) - } - }; - let mut rec = Vec::new(); - if data.len() <= 8 && id != *b"LIST" { - rec.extend(u32::MAX.to_le_bytes()); - rec.extend((data.len() as u32).to_le_bytes()); - rec.extend(&data); - rec.resize(16, 0); - } else { - let Some((_, stream)) = streams.get_mut(s) else { return out }; - rec.extend((s as u32).to_le_bytes()); - rec.extend((data.len() as u32).to_le_bytes()); - rec.extend((stream.len() as u32).to_le_bytes()); - rec.extend(0u32.to_le_bytes()); - stream.extend(&data); - } - put(&mut out, &id, 16, &rec, 16); - } - } - out -} - -/// The radius the base curve of a polygon lies on, 1000 mm, in points (R18). -pub const POLYGON_SIDE: f64 = 1000.0 / 25.4 * 72.0; - -/// The shape of a drawn object in a file of version 1 or 2 (R43, R44), sizes in points. -#[derive(Clone, Debug)] -pub enum WlShape { - Rect { - w: f64, - h: f64, - radius: f64, - }, - /// The two angle fields are written as given. - Ellipse { - w: f64, - h: f64, - angles: (i16, i16), - }, - /// Points with their type bytes, as [`V::points`] takes them. - Curve(Vec<(f64, f64, u8)>), - Text, -} - -/// A drawn object's record of a version 1 file (R42, R43, R44): `shape` placed by `matrix` -/// `[a, b, c, d, e, f]` with offsets in points, a uniform fill of `fill` and an outline of a width -/// in points and a color. The record's point holds the matrix's x offset and its `ty` the y -/// offset. [`wl_file`] moves the fill and the shape to their places in a version 2 file. -pub fn wl_object(shape: WlShape, matrix: [f64; 6], fill: Option<[u8; 5]>, outline: Option<(f64, [u8; 5])>) -> Vec { - let v = V(300); - let (kind, body): (u8, Vec) = match shape { - WlShape::Rect { w, h, radius } => (0, [v.coord(w), v.coord(h), v.coord(radius), vec![0; 2]].concat()), - WlShape::Ellipse { w, h, angles } => (1, [v.coord(w), v.coord(h), angles.0.to_le_bytes().to_vec(), angles.1.to_le_bytes().to_vec()].concat()), - WlShape::Curve(points) => (2, v.points(&points)), - WlShape::Text => (3, vec![0; 30]), - }; - let mut r = vec![0u8; (114 + body.len()).max(118)]; - r[..4].copy_from_slice(&WL_RECORD_START); - r[26] = 0x40; - r[27] = 0x20; - let size = (r.len() - 32) as u16; - r[28..30].copy_from_slice(&size.to_le_bytes()); - let [a, b, c, d, e, f] = matrix; - r[32..34].copy_from_slice(&v.coord(e)); - let fixed = |x: f64| ((x * 65536.0).round() as i32).to_le_bytes(); - // a, b, tx, c, d, ty: x' = a x + b y + tx, y' = c x + d y + ty. - for (k, x) in [a, c, 0.0, b, d, f / 72.0 * 1000.0].into_iter().enumerate() { - r[36 + 4 * k..40 + 4 * k].copy_from_slice(&fixed(x)); - } - r[60] = kind; - if let Some((width, color)) = outline { - r[67] = 1; - r[68..70].copy_from_slice(&v.coord(width)); - r[74..79].copy_from_slice(&color); - } - if let Some(color) = fill { - r[94] = 1; - r[95..100].copy_from_slice(&color); - } - r[114..114 + body.len()].copy_from_slice(&body); - r -} - -/// The u32 that starts every record of a version 1 or 2 file (R42). -const WL_RECORD_START: [u8; 4] = 24u32.to_le_bytes(); - -/// A group or layer record of a version 1 or 2 file (R42): 28 bytes. -pub fn wl_group() -> Vec { - let mut r = vec![0u8; 28]; - r[..4].copy_from_slice(&WL_RECORD_START); - r[26] = 1; - r[27] = 0x60; - r -} - -/// A drawn object's record of a version 1 file laid out as in a version 2 file (R43): 11 more bytes -/// before the fill and 11 more before the shape. Group records stay as they are. -fn wl_v2_record(rec: &[u8]) -> Vec { - if rec.get(26).is_none_or(|flags| flags & 0x40 == 0) || rec.len() < 114 { - return rec.to_vec(); - } - let mut out = [&rec[..94], &[0; 11], &rec[94..114], &[0; 11], &rec[114..]].concat(); - let size = (out.len() - 32) as u16; - out[28..30].copy_from_slice(&size.to_le_bytes()); - out -} - -/// A file of version 1 or 2 (R40, R41): the header with `marker` (`e` for version 1, `l` or `m` -/// for version 2), a page of `page` points, the `records` and an empty font table. A version 1 -/// file's settings start after the header; a version 2 file's start further on, where a picture -/// lies in the files of that version, and its drawn objects are laid out as [`wl_v2_record`] says. -pub fn wl_file(marker: u8, page: (f64, f64), records: &[Vec]) -> Vec { - let v = V(300); - let settings = if marker == b'e' { 28u32 } else { 40 }; - let start = 64u32; - let mut out = vec![0u8; start as usize]; - out[..4].copy_from_slice(&[b'W', b'L', marker, 0]); - let (w, h) = page; - let page_box = settings as usize + 2; - out[page_box..page_box + 8].copy_from_slice(&[v.coord(-w / 2.0), v.coord(h / 2.0), v.coord(w / 2.0), v.coord(-h / 2.0)].concat()); - for r in records { - if marker == b'e' { - out.extend(r); - } else { - out.extend(wl_v2_record(r)); - } - } - let end = out.len() as u32; - out.extend([0; 2]); - let trailer = out.len() as u32; - for (k, offset) in [settings, start, end, trailer, trailer - 2].into_iter().enumerate() { - out[4 + 4 * k..8 + 4 * k].copy_from_slice(&offset.to_le_bytes()); - } - out -} - -/// A drawing of version 1 or 2 with a group record and one of each kind of object: a rounded -/// rectangle with a fill and an outline, an ellipse, a closed curve and a text object, front to -/// back. -pub fn wl_sample(marker: u8) -> Vec { - let (red, black) = (color3(1, [0, 100, 100, 0]), color3(1, [0, 0, 0, 100])); - let curve = vec![(0.0, 0.0, 0x08), (50.0, 0.0, 0x40), (50.0, 20.0, 0xC0), (20.0, 50.0, 0xC0), (0.0, 50.0, 0x88)]; - let records = [ - wl_object(WlShape::Rect { w: 100.0, h: 50.0, radius: 5.0 }, [1.0, 0.0, 0.0, 1.0, -100.0, 100.0], Some(red), Some((2.0, black))), - wl_group(), - wl_object(WlShape::Ellipse { w: 40.0, h: -40.0, angles: (0, 0) }, [1.0, 0.0, 0.0, 1.0, 50.0, -50.0], Some(red), None), - wl_object(WlShape::Curve(curve), [2.0, 0.0, 0.0, 2.0, 0.0, 0.0], None, Some((2.0, black))), - wl_object(WlShape::Text, [1.0, 0.0, 0.0, 1.0, 0.0, 0.0], Some(black), None), - ]; - wl_file(marker, (612.0, 792.0), &records) -} diff --git a/crates/cdr/src/synth_cmx.rs b/crates/cdr/src/synth_cmx.rs deleted file mode 100644 index c70fd8545c..0000000000 --- a/crates/cdr/src/synth_cmx.rs +++ /dev/null @@ -1,287 +0,0 @@ -//! Synthetic `.cmx` files for tests and fuzz seeds, built from the layouts in `PROVENANCE.md` (R53 -//! to R63). Not a `.cmx` writer: nothing checks that other programs open these files. - -/// A chunk: its id, a u32 size, the body and a pad byte after an odd body (R53). -pub fn chunk(id: &[u8; 4], body: &[u8]) -> Vec { - let mut out = id.to_vec(); - out.extend((body.len() as u32).to_le_bytes()); - out.extend(body); - if body.len() % 2 == 1 { - out.push(0); - } - out -} - -/// A `LIST` chunk of form `form`. -pub fn list(form: &[u8; 4], children: &[Vec]) -> Vec { - let mut body = form.to_vec(); - body.extend(children.concat()); - chunk(b"LIST", &body) -} - -/// The RIFF form `CMX1` around `children`. -pub fn riff(children: &[Vec]) -> Vec { - let mut body = b"CMX1".to_vec(); - body.extend(children.concat()); - chunk(b"RIFF", &body) -} - -/// The header (R54): `coord` is the coordinate size digit (`b'4'` or `b'2'`) and `meters` the size -/// of a coordinate unit. The header string and the system name, which the reader doesn't read, -/// are left as zeros. -pub fn cont(coord: u8, meters: f64) -> Vec { - let mut c = vec![0u8; 180]; - c[48] = b'2'; - c[52] = coord; - c[54] = b'2'; - c[64..72].copy_from_slice(&meters.to_le_bytes()); - chunk(b"cont", &c) -} - -/// A field: its tag, a u16 length counting the 3 header bytes, then `data` (R55). -pub fn field(tag: u8, data: &[u8]) -> Vec { - let mut f = vec![tag]; - f.extend(((data.len() + 3) as u16).to_le_bytes()); - f.extend(data); - f -} - -/// A field list: the fields, then 0xff (R55). -pub fn fields(fields: &[Vec]) -> Vec { - let mut l = fields.concat(); - l.push(0xff); - l -} - -/// A table chunk: a u16 count, then the entries (field lists) (R55). -pub fn table(id: &[u8; 4], entries: &[Vec]) -> Vec { - let mut d = (entries.len() as u16).to_le_bytes().to_vec(); - d.extend(entries.concat()); - chunk(id, &d) -} - -/// A color entry in the older form: the model and palette bytes in field 1, the values in field 2 -/// (R56). -pub fn color(model: u8, values: &[u8]) -> Vec { - fields(&[field(1, &[model, 5]), field(2, values)]) -} - -/// A color entry with a property list in field 10 whose color record (part 1) holds `model` and -/// the four value bytes `v` (R56). -pub fn color_record(model: u16, v: [u8; 4]) -> Vec { - color_record_named(model, v, None) -} - -/// A color entry as [`color_record`], with a name part (part 3: a u32 count and UTF-16 units) -/// after the color when `name` is given (R56). -pub fn color_record_named(model: u16, v: [u8; 4], name: Option<&str>) -> Vec { - let mut part = vec![1u8]; - part.extend(12u32.to_le_bytes()); - part.extend(model.to_le_bytes()); - part.extend(5u16.to_le_bytes()); - part.extend([0; 4]); - part.extend(v); - if let Some(name) = name { - let units: Vec = name.encode_utf16().collect(); - part.push(3); - part.extend((4 + 2 * units.len() as u32).to_le_bytes()); - part.extend((units.len() as u32).to_le_bytes()); - part.extend(units.iter().flat_map(|u| u.to_le_bytes())); - } - let mut rec = (part.len() as u32).to_le_bytes().to_vec(); - rec.extend(part); - fields(&[field(10, &rec)]) -} - -/// A pen entry (R57): the width in coordinate units, an aspect of 100 and no angle, with the -/// identity matrix. -pub fn pen(width: u32) -> Vec { - let mut d = width.to_le_bytes().to_vec(); - d.extend(100u16.to_le_bytes()); - d.extend(0i32.to_le_bytes()); - d.extend(1u16.to_le_bytes()); - fields(&[field(1, &d)]) -} - -/// A line type entry (R57): its flags and the caps (low 4 bits) and join (high 4 bits). -pub fn line_type(flags: u8, caps_join: u8) -> Vec { - fields(&[field(1, &[flags, caps_join])]) -} - -/// A dash pattern entry (R57): the lengths in outline widths. -pub fn dashes(lengths: &[u16]) -> Vec { - let mut d = (lengths.len() as u16).to_le_bytes().to_vec(); - d.extend(lengths.iter().flat_map(|l| l.to_le_bytes())); - fields(&[field(1, &d)]) -} - -/// An outline entry (R58): 1-based indexes of the line type, screen, color, arrowhead pair, pen and -/// dash pattern. -pub fn outline(parts: [u16; 6]) -> Vec { - fields(&[field(1, &parts.iter().flat_map(|p| p.to_le_bytes()).collect::>())]) -} - -/// The arrowhead pairs chunk (R59): a u16 count, then start and end (u16 each). -pub fn arrowheads(pairs: &[(u16, u16)]) -> Vec { - let mut d = (pairs.len() as u16).to_le_bytes().to_vec(); - for (s, e) in pairs { - d.extend(s.to_le_bytes()); - d.extend(e.to_le_bytes()); - } - chunk(b"rota", &d) -} - -/// An instruction in the short form: a u16 size counting the whole instruction, the code, the -/// body (R60). -pub fn instr(code: i16, body: &[u8]) -> Vec { - let mut i = ((body.len() + 4) as u16).to_le_bytes().to_vec(); - i.extend(code.to_le_bytes()); - i.extend(body); - i -} - -/// An instruction in the long form: 0xFFFF, a u32 size counting the whole instruction, the code, -/// the body (R60). -pub fn long_instr(code: i16, body: &[u8]) -> Vec { - let mut i = 0xFFFFu16.to_le_bytes().to_vec(); - i.extend(((body.len() + 8) as u32).to_le_bytes()); - i.extend(code.to_le_bytes()); - i.extend(body); - i -} - -/// Begin a page (R61), with its width and height in coordinate units in field 4 when given. -pub fn begin_page(size: Option<(u32, u32)>) -> Vec { - let mut f = vec![field(1, &[1, 0, 0, 0, 0, 0])]; - if let Some((w, h)) = size { - let mut d = w.to_le_bytes().to_vec(); - d.extend(h.to_le_bytes()); - f.push(field(4, &d)); - } - instr(9, &fields(&f)) -} - -/// Begin a page (R61) without a size of its own, with the drawing's left, top, right and bottom -/// edges in field 1. -pub fn begin_page_in_bounds(left: i32, top: i32, right: i32, bottom: i32) -> Vec { - let mut d = vec![1, 0, 0, 0, 0, 0]; - for v in [left, top, right, bottom] { - d.extend(v.to_le_bytes()); - } - instr(9, &fields(&[field(1, &d)])) -} - -/// Begin a layer (R62) named in 8-bit characters in field 1 from byte 12, and in UTF-16 in -/// field 4 when `wide` is given. -pub fn begin_layer(name: &str, wide: Option<&str>) -> Vec { - let mut d = vec![1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0]; - d.extend((name.len() as u16).to_le_bytes()); - d.extend(name.bytes()); - let mut f = vec![field(1, &d)]; - if let Some(w) = wide { - let units: Vec = w.encode_utf16().collect(); - let mut d = (units.len() as u32).to_le_bytes().to_vec(); - d.extend(units.iter().flat_map(|u| u.to_le_bytes())); - f.push(field(4, &d)); - } - instr(11, &fields(&f)) -} - -pub fn end_layer() -> Vec { - instr(12, &[]) -} - -pub fn end_page() -> Vec { - instr(10, &[]) -} - -pub fn begin_group() -> Vec { - instr(13, &fields(&[field(1, &[0; 26])])) -} - -pub fn end_group() -> Vec { - instr(14, &[]) -} - -/// Rendering attributes (R63): a uniform fill of color `fill` and the outline `outline` (1-based -/// indexes; `None` leaves the part out of the mask), and `lens` sets the lens bit. -pub fn attrs(fill: Option, outline: Option, lens: bool) -> Vec { - let mask = u8::from(fill.is_some()) | (u8::from(outline.is_some()) << 1) | (u8::from(lens) << 2); - let mut a = vec![mask]; - if let Some(c) = fill { - let mut v = 1u16.to_le_bytes().to_vec(); - let mut uniform = c.to_le_bytes().to_vec(); - uniform.extend(0u16.to_le_bytes()); - v.extend(fields(&[field(1, &uniform)])); - a.extend(fields(&[field(1, &v)])); - } - if let Some(o) = outline { - a.extend(fields(&[field(1, &o.to_le_bytes())])); - } - a -} - -/// Rendering attributes with a fill of type `kind` and no settings of its own. -pub fn attrs_fill_type(kind: u16) -> Vec { - let mut a = vec![1u8]; - a.extend(fields(&[field(1, &kind.to_le_bytes())])); - a -} - -/// A curve (R62): `attrs`, then a u16 count, the points (i32 x, y) and their type bytes. -pub fn curve(attrs: &[u8], points: &[(i32, i32)], types: &[u8]) -> Vec { - let mut g = (points.len() as u16).to_le_bytes().to_vec(); - for (x, y) in points { - g.extend(x.to_le_bytes()); - g.extend(y.to_le_bytes()); - } - g.extend(types); - instr(67, &fields(&[field(1, attrs), field(2, &g), field(3, &[0; 16])])) -} - -/// A closed square of side `side` with its lower left corner at (`x`, `y`). -pub fn square(attrs: &[u8], x: i32, y: i32, side: i32) -> Vec { - curve(attrs, &[(x, y), (x + side, y), (x + side, y + side), (x, y + side), (x, y)], &[0x0c, 0x44, 0x44, 0x44, 0x48]) -} - -/// A `page` chunk of `instructions`. -pub fn page(instructions: &[Vec]) -> Vec { - chunk(b"page", &instructions.concat()) -} - -/// The tables of [`sample`]: colors red (RGB), black (CMYK in percent) and blue (a color record, -/// blue, green, red); pens of 0.5 mm and 1 mm; line types solid with round caps and joins, none, -/// and dashed behind the fill; one dash pattern; three outlines; one empty arrowhead pair. -pub fn tables() -> Vec> { - vec![ - table(b"rclr", &[color(5, &[255, 0, 0]), color(2, &[0, 0, 0, 100]), color_record(5, [255, 0, 0, 0])]), - table(b"rpen", &[pen(5_000), pen(10_000)]), - table(b"rott", &[line_type(2, 0x11), line_type(1, 0), line_type(2 | 4 | 8, 0x02)]), - table(b"rdot", &[dashes(&[3, 1])]), - table(b"rotl", &[outline([1, 1, 2, 1, 1, 1]), outline([2, 1, 2, 1, 1, 1]), outline([3, 1, 3, 1, 2, 1])]), - arrowheads(&[(0, 0)]), - ] -} - -/// One page of 210 x 297 mm with two layers: "Art" holds a red square outlined in black, then a -/// group of a square with no outline and a blue one with the dashed outline; "Top" holds a black -/// square drawn last. Units are 0.1 µm. -pub fn sample() -> Vec { - let p = page(&[ - begin_page(Some((2_100_000, 2_970_000))), - begin_layer("Art", None), - square(&attrs(Some(1), Some(1), false), -500_000, -500_000, 1_000_000), - begin_group(), - square(&attrs(Some(2), Some(2), false), 0, 0, 100_000), - square(&attrs(Some(3), Some(3), false), 200_000, 0, 100_000), - end_group(), - end_layer(), - begin_layer("Top", Some("Top")), - square(&attrs(Some(2), None, false), 0, 0, 10_000), - end_layer(), - end_page(), - ]); - let mut children = vec![cont(b'4', 1e-7), p]; - children.extend(tables()); - riff(&children) -} diff --git a/crates/cdr/src/wl.rs b/crates/cdr/src/wl.rs deleted file mode 100644 index bae22ba5a0..0000000000 --- a/crates/cdr/src/wl.rs +++ /dev/null @@ -1,358 +0,0 @@ -//! Drawings of versions 1 and 2: the file before RIFF, which starts with `WL` (R40 to R44). A -//! header of offsets, the settings with the page's box, then one flat list of records: 28 bytes -//! for a group or a layer, and a longer record for each drawn object, which holds its matrix, fill, -//! outline and shape. The reader maps the rectangles, ellipses and curves onto one page with one -//! layer and keeps no groups. - -use crate::bytes::{Rd, u32_at}; -use crate::geometry; -use crate::layout::{self, Profile}; -use crate::limits::Budget; -use crate::model::{Cap, Drawing, Flags, Geometry, Join, Layer, LayerKind, Matrix, Object, Outline, Page, Shape}; -use crate::records::{self, coord, fixed}; -use crate::riff::push; -use crate::{Error, Warning}; - -/// The header: the signature, a marker byte, a zero and five u32 offsets (R40). -const HEADER: usize = 28; -/// The marker bytes read after `WL` (R40): `e` for version 1, `l` and `m` for version 2. -const MARKERS: [u8; 3] = *b"elm"; -/// Where the page's box lies after the start of the settings (R41). -const PAGE_BOX: usize = 2; -/// The bytes of a group or layer record (R42). -const GROUP: usize = 28; -/// The u32 that starts every record (R42). -const RECORD_START: u32 = 24; -/// The flag bit, in byte 26, of a drawn object (R42). -const DRAWN: u8 = 0x40; -/// The bytes after a drawn object's body size (R42). -const AFTER_BODY: usize = 32; -/// Where a drawn object's fields lie (R43, R44). -const POINT: usize = 32; -const KIND: usize = 60; -const OUTLINED: usize = 67; -const OUTLINE_WIDTH: usize = 68; -const OUTLINE_COLOR: usize = 74; - -/// Where a drawn object's fill and shape lie, which differs between the markers (R43, R44). -#[derive(Clone, Copy)] -struct Fields { - fill_kind: usize, - shape: usize, -} - -impl Fields { - fn of(marker: u8) -> Self { - if marker == b'e' { Fields { fill_kind: 94, shape: 114 } } else { Fields { fill_kind: 105, shape: 136 } } - } - - /// The least a drawn object takes: its fixed fields and the 4 bytes of a shape's size. - fn least(self) -> usize { - self.shape + 4 - } -} -/// Object types (R43). -const RECTANGLE: u8 = 0; -const ELLIPSE: u8 = 1; -const CURVE: u8 = 2; -const TEXT: u8 = 3; - -/// Where the settings start, and where the records start and end, when `b` has a `WL` header -/// whose offsets fit the file. -fn header(b: &[u8]) -> Option<(usize, usize, usize)> { - if b.get(..2)? != b"WL" || !MARKERS.contains(b.get(2)?) || *b.get(3)? != 0 { - return None; - } - let (settings, start, end) = (u32_at(b, 4)? as usize, u32_at(b, 8)? as usize, u32_at(b, 12)? as usize); - (settings >= HEADER && settings <= start && start <= end && end <= b.len()).then_some((settings, start, end)) -} - -/// Does `b` start like a drawing of version 1 or 2? The two letters alone are not enough: the -/// marker byte, the zero after it and the record offsets must fit too. -pub(crate) fn is_wl(b: &[u8]) -> bool { - header(b).is_some() -} - -pub(crate) fn drawing(b: &[u8], budget: &mut Budget) -> Result { - let (settings, start, end) = header(b).ok_or(Error::NotCdr)?; - let marker = b.get(2).copied().ok_or(Error::NotCdr)?; - let fields = Fields::of(marker); - // Lengths are i16 in 1/1000 inch, as in version 3 (R5). - let p = layout::for_version(layout::OLDEST_RIFF).ok_or(Error::NotCdr)?; - let mut warn = Vec::new(); - let mut objects = Vec::new(); - let mut at = start; - // Every step takes at least a group record's bytes, so the file's size bounds the steps. - while end - at >= GROUP { - budget.take_chunk()?; - // A record that doesn't start as records do is past one whose length isn't known. - if u32_at(b, at) != Some(RECORD_START) { - break; - } - if b.get(at + 26).is_none_or(|flags| flags & DRAWN == 0) { - at += GROUP; - continue; - } - // A drawn object of another type than rectangle, ellipse, curve and text doesn't say its - // length in the same way, so the records after it can't be found. - if b.get(at + KIND).is_none_or(|kind| *kind > TEXT) { - push(&mut warn, Warning::UnsupportedObjects); - at = end; - break; - } - let len = Rd::at(b, at + 28).u16().map_or(0, |body| usize::from(body) + AFTER_BODY); - let Some(rec) = b.get(at..at + len).filter(|_| len >= fields.least() && at + len <= end) else { - push(&mut warn, Warning::Damaged); - at = end; - break; - }; - at += len; - if !budget.take_object() { - push(&mut warn, Warning::TooDeep); - at = end; - break; - } - objects.extend(object(rec, fields, &p, budget, &mut warn)); - } - if at != end { - push(&mut warn, Warning::Damaged); - } - let version = if marker == b'e' { 100 } else { 200 }; - let layer = Layer { name: String::new(), kind: LayerKind::Drawing, flags: Flags::default(), objects, guides: Vec::new() }; - let pages = vec![Page { size: None, layers: vec![layer] }]; - Ok(Drawing { version, page_size: page_box(b, settings, &p), pages, master: Vec::new(), guides: Vec::new(), warnings: warn }) -} - -/// The page's size from its box (R41): left, top, right and bottom around the page's centre. -fn page_box(b: &[u8], settings: usize, p: &Profile) -> Option<(f64, f64)> { - let mut r = Rd::at(b, settings + PAGE_BOX); - let (left, top, right, bottom) = (coord(&mut r, p)?, coord(&mut r, p)?, coord(&mut r, p)?, coord(&mut r, p)?); - let (w, h) = ((right - left).abs(), (top - bottom).abs()); - (w > 0.0 && h > 0.0).then_some((w, h)) -} - -/// One drawn object's record (R43, R44): a shape, or `None` with a warning for text, for an object -/// of another type and for a shape that can't be read. -fn object(rec: &[u8], fields: Fields, p: &Profile, budget: &mut Budget, warn: &mut Vec) -> Option { - // A curve left out at the coordinate limit is not damage. - budget.coordinates_refused(); - let read = shape(rec, fields, p, budget, warn); - if read.is_none() && !budget.coordinates_refused() { - push(warn, Warning::Damaged); - } - read?.map(|s| Object::Shape(Box::new(s))) -} - -/// The shape of a record. The outer `None` is a record that can't be read; the inner one an object -/// the reader leaves out, with its warning. -fn shape(rec: &[u8], fields: Fields, p: &Profile, budget: &mut Budget, warn: &mut Vec) -> Option> { - let k = p.unit(); - let mut r = Rd::at(rec, POINT); - let (x, y) = (f64::from(r.i16()?), f64::from(r.i16()?)); - // x' = a x + b y + tx + x of the point, y' = c x + d y + ty + y of the point. - let (a, b, tx, c, d, ty) = (fixed(&mut r)?, fixed(&mut r)?, fixed(&mut r)?, fixed(&mut r)?, fixed(&mut r)?, fixed(&mut r)?); - let matrix = Matrix([a, c, b, d, (tx + x) * k, (ty + y) * k]); - let body = rec.get(fields.shape..)?; - let geometry = match *rec.get(KIND)? { - RECTANGLE => rect(body, p)?, - ELLIPSE => { - let mut s = Rd::new(body); - let (w, h) = (coord(&mut s, p)?, coord(&mut s, p)?); - // Two angles follow. No source confirms how they make an arc, so an ellipse whose - // angles differ is left out; one whose angles are missing is damage. - let (from, to) = (s.i16()?, s.i16()?); - if from != to { - push(warn, Warning::UnsupportedObjects); - return Some(None); - } - Geometry::Ellipse { w, h } - } - CURVE => Geometry::Path(geometry::point_list(body, p, budget, warn)?), - _ => { - push(warn, Warning::UnsupportedObjects); - return Some(None); - } - }; - let color_at = |at: usize, warn: &mut Vec| Some(records::color5(rec.get(at..at + 5)?.try_into().ok()?, warn)); - let fill = match *rec.get(fields.fill_kind)? { - 0 => None, - 1 => Some(color_at(fields.fill_kind + 1, warn)?), - _ => { - push(warn, Warning::UnsupportedFills); - None - } - }; - let outline = if *rec.get(OUTLINED)? != 0 { - let width = f64::from(Rd::at(rec, OUTLINE_WIDTH).u16()?) * k; - Some(Outline { - width, - color: color_at(OUTLINE_COLOR, warn)?, - cap: Cap::Butt, - join: Join::Miter, - dashes: Vec::new(), - behind_fill: false, - scale_with: false, - }) - } else { - None - }; - Some(Some(Shape::new(geometry, matrix, fill, outline))) -} - -/// A rectangle (R44): its width and height, then a corner radius, which is kept when it is at most -/// half the shorter side. -fn rect(body: &[u8], p: &Profile) -> Option { - let mut r = Rd::new(body); - let (w, h) = (coord(&mut r, p)?, coord(&mut r, p)?); - let radius = coord(&mut r, p).filter(|v| *v > 0.0 && *v <= w.abs().min(h.abs()) / 2.0).unwrap_or(0.0); - Some(Geometry::Rect { w, h, radii: [radius; 4] }) -} - -#[cfg(test)] -mod tests { - use super::*; - use crate::Limits; - use crate::model::Color; - use crate::synth::{self, WlShape}; - - fn read(b: &[u8]) -> Result { - drawing(b, &mut Budget::new(Limits::default())) - } - - #[test] - fn the_header_is_taken_only_when_its_offsets_fit() { - let file = synth::wl_file(b'e', (612.0, 792.0), &[synth::wl_group()]); - assert!(is_wl(&file)); - // The two letters, a marker and a zero are not enough. - assert!(!is_wl(b"WLe\0")); - assert!(!is_wl(b"WLe\0 and then some text that is long enough to hold offsets")); - let with = |at: usize, v: u32| { - let mut f = file.clone(); - f[at..at + 4].copy_from_slice(&v.to_le_bytes()); - f - }; - // Records that start inside the header, start after their end, or end past the file. - assert!(!is_wl(&with(8, 27))); - assert!(!is_wl(&with(8, file.len() as u32))); - assert!(!is_wl(&with(12, file.len() as u32 + 1))); - // Settings that start inside the header or after the records. - assert!(!is_wl(&with(4, 27))); - assert!(!is_wl(&with(4, 65))); - let mut other = file.clone(); - other[2] = b'x'; - assert!(!is_wl(&other)); - // No sample shows the marker `d`, so it is not taken. - other[2] = b'd'; - assert!(!is_wl(&other)); - for marker in *b"lm" { - assert!(is_wl(&synth::wl_file(marker, (612.0, 792.0), &[synth::wl_group()]))); - } - other[2] = b'e'; - other[3] = 1; - assert!(!is_wl(&other)); - } - - #[test] - fn a_version_2_file_keeps_its_page_box_fill_and_shape_where_that_version_puts_them() { - let (red, black) = ([1, 0, 100, 100, 0], [1, 0, 0, 0, 100]); - let rect = synth::wl_object(WlShape::Rect { w: 72.0, h: 36.0, radius: 9.0 }, [1.0, 0.0, 0.0, 1.0, 0.0, 0.0], Some(red), Some((2.0, black))); - for marker in *b"elm" { - let file = synth::wl_file(marker, (720.0, 504.0), std::slice::from_ref(&rect)); - // Version 2 files start their settings after a picture, not after the header. - assert_eq!(u32_at(&file, 4) == Some(28), marker == b'e'); - let d = read(&file).unwrap(); - let near = |a: f64, b: f64| (a - b).abs() < 0.02; - assert_eq!((d.version, d.warnings.clone()), (if marker == b'e' { 100 } else { 200 }, vec![])); - assert!(d.page_size.is_some_and(|(w, h)| near(w, 720.0) && near(h, 504.0)), "{:?}", d.page_size); - let Object::Shape(s) = &d.pages[0].layers[0].objects[0] else { panic!("group") }; - assert!( - matches!(s.geometry, Geometry::Rect { w, h, radii } if near(w, 72.0) && near(h, 36.0) && near(radii[0], 9.0)), - "{}", - marker as char - ); - assert_eq!(s.fill, Some(Color::Cmyk([0.0, 1.0, 1.0, 0.0])), "{}", marker as char); - assert!(s.outline.as_ref().is_some_and(|o| near(o.width, 2.0) && o.color == Color::Cmyk([0.0, 0.0, 0.0, 1.0])), "{}", marker as char); - } - } - - #[test] - fn a_drawn_object_is_marked_by_its_flag_bit() { - let rect = synth::wl_object(WlShape::Rect { w: 72.0, h: 36.0, radius: 0.0 }, [1.0, 0.0, 0.0, 1.0, 0.0, 0.0], None, None); - let mut file = synth::wl_file(b'l', (612.0, 792.0), &[rect]); - // Files with the marker `l` set another flag bit beside it. - file[64 + 26] = 0xc0; - let d = read(&file).unwrap(); - assert_eq!((d.pages[0].layers[0].objects.len(), d.warnings), (1, vec![])); - } - - #[test] - fn the_walk_stops_where_records_can_no_longer_be_found() { - let unit = [1.0, 0.0, 0.0, 1.0, 0.0, 0.0]; - let rect = || synth::wl_object(WlShape::Rect { w: 72.0, h: 36.0, radius: 0.0 }, unit, None, None); - // An object of another type doesn't give its length in the same way. - let mut other = rect(); - other[KIND] = 0xff; - let d = read(&synth::wl_file(b'm', (612.0, 792.0), &[rect(), other, rect()])).unwrap(); - assert_eq!((d.pages[0].layers[0].objects.len(), d.warnings), (1, vec![Warning::UnsupportedObjects])); - // A record that doesn't start as records do. - let mut lost = rect(); - lost[0] = 0x84; - let d = read(&synth::wl_file(b'e', (612.0, 792.0), &[rect(), lost, rect()])).unwrap(); - assert_eq!((d.pages[0].layers[0].objects.len(), d.warnings), (1, vec![Warning::Damaged])); - } - - #[test] - fn a_rectangle_keeps_a_radius_of_at_most_half_its_shorter_side() { - let p = layout::for_version(300).unwrap(); - let body = |radius: i16| [1000i16, 500, radius].iter().flat_map(|v| v.to_le_bytes()).collect::>(); - let radius_of = |b: &[u8]| match rect(b, &p) { - Some(Geometry::Rect { w, h, radii }) if (w - 72.0).abs() < 1e-9 && (h - 36.0).abs() < 1e-9 => radii[0], - other => panic!("{other:?}"), - }; - assert!((radius_of(&body(200)) - 14.4).abs() < 1e-9); - for radius in [300, -5, 0] { - assert_eq!(radius_of(&body(radius)), 0.0, "{radius}"); - } - // A record that ends after the size has square corners. - assert_eq!(radius_of(&body(200)[..4]), 0.0); - assert_eq!(rect(&body(200)[..3], &p), None); - } - - #[test] - fn a_record_shorter_than_its_fields_ends_the_walk_as_damage() { - let rect = synth::wl_object(WlShape::Rect { w: 72.0, h: 36.0, radius: 0.0 }, [1.0, 0.0, 0.0, 1.0, 0.0, 0.0], Some([1, 0, 0, 0, 100]), None); - let mut short = rect.clone(); - // A body size that leaves less than the fixed fields. - short[28..30].copy_from_slice(&((Fields::of(b'e').least() - AFTER_BODY - 1) as u16).to_le_bytes()); - let d = read(&synth::wl_file(b'e', (612.0, 792.0), &[rect.clone(), short, rect])).unwrap(); - assert_eq!(d.pages[0].layers[0].objects.len(), 1); - assert_eq!(d.warnings, vec![Warning::Damaged]); - } - - #[test] - fn an_ellipse_without_its_angles_is_damage() { - let ellipse = - synth::wl_object(WlShape::Ellipse { w: 72.0, h: 36.0, angles: (0, 0) }, [1.0, 0.0, 0.0, 1.0, 0.0, 0.0], Some([1, 0, 0, 0, 100]), None); - let mut cut = ellipse.clone(); - // A body size that ends the record after the ellipse's width and height. - cut[28..30].copy_from_slice(&((Fields::of(b'e').least() - AFTER_BODY) as u16).to_le_bytes()); - cut.truncate(Fields::of(b'e').least()); - let d = read(&synth::wl_file(b'e', (612.0, 792.0), &[ellipse, cut])).unwrap(); - assert_eq!(d.pages[0].layers[0].objects.len(), 1); - assert_eq!(d.warnings, vec![Warning::Damaged]); - } - - #[test] - fn fill_types_other_than_uniform_and_unknown_inks_are_named() { - let mut textured = - synth::wl_object(WlShape::Rect { w: 72.0, h: 36.0, radius: 0.0 }, [1.0, 0.0, 0.0, 1.0, 0.0, 0.0], Some([0, 9, 0, 50, 0]), None); - let d = read(&synth::wl_file(b'm', (612.0, 792.0), std::slice::from_ref(&textured))).unwrap(); - let Object::Shape(s) = &d.pages[0].layers[0].objects[0] else { panic!("group") }; - assert_eq!(s.fill, Some(Color::Spot { name: "Spot 0:9".into(), tint: 0.5, look: None })); - assert_eq!((d.version, d.warnings), (200, vec![Warning::SpotLooks])); - textured[Fields::of(b'e').fill_kind] = 5; - let d = read(&synth::wl_file(b'm', (612.0, 792.0), &[textured])).unwrap(); - let Object::Shape(s) = &d.pages[0].layers[0].objects[0] else { panic!("group") }; - assert_eq!((s.fill.clone(), d.warnings), (None, vec![Warning::UnsupportedFills])); - } -} diff --git a/crates/cdr/src/zip.rs b/crates/cdr/src/zip.rs deleted file mode 100644 index 67994192a0..0000000000 --- a/crates/cdr/src/zip.rs +++ /dev/null @@ -1,308 +0,0 @@ -//! The ZIP archives of `.cdr` drawings from version 14 on (R24): the central directory, then stored -//! and deflated members read on request. Archives that span disks, ZIP64 archives and encrypted -//! members are refused; so are directories whose members overlap or repeat a name. - -use std::borrow::Cow; -use std::io::Read as _; - -use crate::Error; -use crate::bytes::Rd; - -/// End of central directory record: signature and fixed length. -const END: u32 = 0x0605_4b50; -const END_LEN: usize = 22; -/// The longest archive comment, which the end record may be followed by. -const MAX_COMMENT: usize = 0xFFFF; -/// ZIP64 end of central directory locator, 20 bytes before the end record when present. -const ZIP64_LOCATOR: u32 = 0x0706_4b50; -/// Central directory header: signature and fixed length. -const CENTRAL: u32 = 0x0201_4b50; -const CENTRAL_LEN: usize = 46; -/// Local file header: signature and fixed length. -const LOCAL: u32 = 0x0403_4b50; -const LOCAL_LEN: usize = 30; -/// General purpose flag bit 0: the member is encrypted. -const ENCRYPTED: u16 = 1; -const STORED: u16 = 0; -const DEFLATED: u16 = 8; -/// What members packed by another method are refused as. -const OTHER_METHODS: &str = "package compression methods other than storing and deflate"; - -/// One member, as the central directory and its local header give it. -#[derive(Clone, Copy, Debug)] -struct Entry<'a> { - name: &'a [u8], - flags: u16, - method: u16, - crc: u32, - packed: usize, - size: usize, - /// Where its local header starts and where its packed bytes start. - header: usize, - data: usize, -} - -/// An archive's directory over its bytes. -#[derive(Debug)] -pub(crate) struct Archive<'a> { - bytes: &'a [u8], - entries: Vec>, - /// The entries in name order, for lookups. - by_name: Vec, -} - -/// Does `bytes` start with a local file header? -pub(crate) fn is_zip(bytes: &[u8]) -> bool { - bytes.starts_with(b"PK\x03\x04") -} - -impl<'a> Archive<'a> { - /// The directory of `bytes`, holding at most `max_entries` members. - pub(crate) fn open(bytes: &'a [u8], max_entries: usize) -> Result { - let end = find_end(bytes).ok_or(Error::Damaged("package directory"))?; - if end >= 20 && Rd::at(bytes, end - 20).u32() == Some(ZIP64_LOCATOR) { - return Err(Error::Unsupported("ZIP64 packages")); - } - let mut r = Rd::at(bytes, end + 4); - let dir = || Error::Damaged("package directory"); - let (disk, dir_disk) = (r.u16().ok_or_else(dir)?, r.u16().ok_or_else(dir)?); - let (on_disk, total) = (r.u16().ok_or_else(dir)?, r.u16().ok_or_else(dir)?); - let (dir_len, dir_at) = (r.u32().ok_or_else(dir)?, r.u32().ok_or_else(dir)?); - if total == u16::MAX || dir_len == u32::MAX || dir_at == u32::MAX { - return Err(Error::Unsupported("ZIP64 packages")); - } - if disk != 0 || dir_disk != 0 || on_disk != total { - return Err(Error::Unsupported("packages split across files")); - } - let total = usize::from(total); - if total > max_entries { - return Err(Error::Limit("package member count")); - } - let (dir_at, dir_len) = (dir_at as usize, dir_len as usize); - let dir_end = dir_at.checked_add(dir_len).filter(|&e| e <= end).ok_or_else(dir)?; - let mut r = Rd::at(bytes, dir_at); - let mut entries = Vec::with_capacity(total); - for _ in 0..total { - let e = central_entry(bytes, &mut r, dir_end)?; - entries.push(e); - } - // Each member's bytes end before the next member's header and before the directory. - let mut order: Vec<&Entry> = entries.iter().collect(); - order.sort_unstable_by_key(|e| e.header); - for (i, e) in order.iter().enumerate() { - let stop = order.get(i + 1).map_or(dir_at, |n| n.header); - if e.data.checked_add(e.packed).is_none_or(|x| x > stop) { - return Err(Error::Damaged("package members overlap")); - } - } - let mut by_name: Vec = (0..entries.len()).collect(); - by_name.sort_unstable_by_key(|&i| entries.get(i).map(|e| e.name)); - let name = |i: &usize| entries.get(*i).map(|e| e.name); - if by_name.windows(2).any(|w| name(&w[0]) == name(&w[1])) { - return Err(Error::Damaged("package member named twice")); - } - Ok(Archive { bytes, entries, by_name }) - } - - /// The member named `name`. - pub(crate) fn find(&self, name: &[u8]) -> Option { - let at = self.by_name.binary_search_by(|&i| self.entries.get(i).map(|e| e.name).cmp(&Some(name))).ok()?; - self.by_name.get(at).copied() - } - - /// The size member `i`'s directory entry gives. - pub(crate) fn size(&self, i: usize) -> usize { - self.entries.get(i).map_or(0, |e| e.size) - } - - /// How many members the archive holds. - pub(crate) fn count(&self) -> usize { - self.entries.len() - } - - /// The bytes reading member `i` may inflate: its stated size when it is deflated, else 0. - pub(crate) fn inflate_cost(&self, i: usize) -> usize { - self.entries.get(i).filter(|e| e.method == DEFLATED).map_or(0, |e| e.size) - } - - /// An error when member `i` is encrypted or packed by a method other than storing or deflate. - pub(crate) fn check(&self, i: usize) -> Result<(), Error> { - let e = self.entries.get(i).ok_or(Error::Damaged("package member"))?; - if e.flags & ENCRYPTED != 0 { - return Err(Error::Unsupported("encrypted packages")); - } - if e.method != STORED && e.method != DEFLATED { - return Err(Error::Unsupported(OTHER_METHODS)); - } - Ok(()) - } - - /// Member `i`'s bytes when they come to at most `limit`, and a deflated member's when they - /// also come to at most `inflate_left`. A stored member is borrowed; a deflated one inflates to - /// at most its stated size plus one byte, so a member that inflates past what it states stops - /// there. The length and CRC-32 must match the directory's. - pub(crate) fn read(&self, i: usize, limit: usize, inflate_left: usize) -> Result, Error> { - self.check(i)?; - let e = self.entries.get(i).ok_or(Error::Damaged("package member"))?; - if e.size > limit { - return Err(Error::Limit("package member size")); - } - if e.method == DEFLATED && e.size > inflate_left { - return Err(Error::Limit("inflated size")); - } - let packed = self.bytes.get(e.data..e.data + e.packed).ok_or(Error::Damaged("package member"))?; - let out: Cow<'a, [u8]> = match e.method { - STORED if e.packed == e.size => Cow::Borrowed(packed), - STORED => return Err(Error::Damaged("package member")), - DEFLATED => { - let mut out = Vec::new(); - let got = flate2::read::DeflateDecoder::new(packed) - .take(e.size as u64 + 1) - .read_to_end(&mut out) - .map_err(|_| Error::Damaged("package member"))?; - if got != e.size { - return Err(Error::Damaged("package member")); - } - Cow::Owned(out) - } - _ => return Err(Error::Unsupported(OTHER_METHODS)), - }; - if crc32fast::hash(&out) != e.crc { - return Err(Error::Damaged("package member")); - } - Ok(out) - } -} - -/// Where the end of central directory record starts: searched back from the end over at most the -/// longest comment, among the records whose comment reaches exactly to the end the first that -/// names members in a directory before it, else the first. A comment or a member may hold bytes -/// that look like an empty archive's end record. -fn find_end(bytes: &[u8]) -> Option { - let last = bytes.len().checked_sub(END_LEN)?; - let first = last.saturating_sub(MAX_COMMENT); - let mut found = None; - for at in (first..=last).rev() { - let mut r = Rd::at(bytes, at); - if r.u32() != Some(END) || r.skip(6).is_none() { - continue; - } - let (total, dir_len, dir_at, comment) = (r.u16(), r.u32(), r.u32(), r.u16()); - if !comment.is_some_and(|c| at + END_LEN + usize::from(c) == bytes.len()) { - continue; - } - let names_members = total.is_some_and(|t| t > 0) - && dir_len.zip(dir_at).is_some_and(|(len, dir)| { - (dir as usize).checked_add(len as usize).is_some_and(|e| e <= at) && Rd::at(bytes, dir as usize).u32() == Some(CENTRAL) - }); - if names_members { - return Some(at); - } - found = found.or(Some(at)); - } - found -} - -/// The central directory entry at `r` (before `dir_end`) and its local header. -fn central_entry<'a>(bytes: &'a [u8], r: &mut Rd<'a>, dir_end: usize) -> Result, Error> { - let dir = || Error::Damaged("package directory"); - if r.pos().checked_add(CENTRAL_LEN).is_none_or(|e| e > dir_end) || r.u32() != Some(CENTRAL) { - return Err(dir()); - } - r.skip(4).ok_or_else(dir)?; - let flags = r.u16().ok_or_else(dir)?; - let method = r.u16().ok_or_else(dir)?; - r.skip(4).ok_or_else(dir)?; - let crc = r.u32().ok_or_else(dir)?; - let (packed, size) = (r.u32().ok_or_else(dir)?, r.u32().ok_or_else(dir)?); - let name_len = usize::from(r.u16().ok_or_else(dir)?); - let extra_len = usize::from(r.u16().ok_or_else(dir)?); - let comment_len = usize::from(r.u16().ok_or_else(dir)?); - let disk = r.u16().ok_or_else(dir)?; - r.skip(6).ok_or_else(dir)?; - let header = r.u32().ok_or_else(dir)?; - if packed == u32::MAX || size == u32::MAX || header == u32::MAX { - return Err(Error::Unsupported("ZIP64 packages")); - } - if disk != 0 { - return Err(Error::Unsupported("packages split across files")); - } - let name = r.bytes(name_len).ok_or_else(dir)?; - r.skip(extra_len).and_then(|()| r.skip(comment_len)).ok_or_else(dir)?; - if r.pos() > dir_end { - return Err(dir()); - } - // The local header repeats the name; its own extra field may differ in length. - let header = header as usize; - let mut l = Rd::at(bytes, header); - let local = || Error::Damaged("package member header"); - if l.u32() != Some(LOCAL) { - return Err(local()); - } - // The signature, 22 bytes, then the name and extra field lengths. - l.skip(LOCAL_LEN - 8).ok_or_else(local)?; - let (local_name, local_extra) = (usize::from(l.u16().ok_or_else(local)?), usize::from(l.u16().ok_or_else(local)?)); - if l.bytes(local_name) != Some(name) { - return Err(local()); - } - l.skip(local_extra).ok_or_else(local)?; - Ok(Entry { name, flags, method, crc, packed: packed as usize, size: size as usize, header, data: l.pos() }) -} - -#[cfg(test)] -mod tests { - use super::*; - use crate::synth::{Member, zip}; - - fn stored(name: &str, data: &[u8]) -> Member { - Member { name: name.into(), data: data.to_vec(), deflate: false } - } - - #[test] - fn stored_and_deflated_members_read_back() { - let bytes = zip(&[stored("a", b"hello"), Member { name: "b".into(), data: vec![7; 5000], deflate: true }], b""); - let a = Archive::open(&bytes, 10).unwrap(); - assert!(matches!(a.read(a.find(b"a").unwrap(), 100, 100).unwrap(), Cow::Borrowed(b"hello"))); - assert_eq!(a.read(a.find(b"b").unwrap(), 5000, 5000).unwrap().as_ref(), &[7; 5000][..]); - assert_eq!(a.read(a.find(b"b").unwrap(), 4999, 5000), Err(Error::Limit("package member size"))); - assert_eq!(a.find(b"c"), None); - // What is left to inflate holds back deflated members only. - assert_eq!(a.read(a.find(b"b").unwrap(), 5000, 4999), Err(Error::Limit("inflated size"))); - assert!(a.read(a.find(b"a").unwrap(), 100, 0).is_ok()); - } - - #[test] - fn the_end_record_is_found_behind_a_comment() { - let bytes = zip(&[stored("a", b"x")], &[b'c'; 300]); - assert!(Archive::open(&bytes, 10).is_ok()); - // A comment longer than the record says leaves no end record to find. - let mut cut = bytes.clone(); - cut.push(0); - assert_eq!(Archive::open(&cut, 10).unwrap_err(), Error::Damaged("package directory")); - // A comment that ends in bytes like an empty archive's end record: the record that names - // members in a directory is the archive's. - let mut fake = END.to_le_bytes().to_vec(); - fake.resize(END_LEN, 0); - let bytes = zip(&[stored("a", b"x")], &fake); - let a = Archive::open(&bytes, 10).unwrap(); - assert_eq!(a.count(), 1); - } - - #[test] - fn a_member_whose_crc_or_length_is_wrong_is_damage() { - let bytes = zip(&[Member { name: "a".into(), data: vec![1; 64], deflate: true }], b""); - let a = Archive::open(&bytes, 10).unwrap(); - // The directory's CRC-32 sits 16 bytes into its entry. - let dir_at = bytes.windows(4).position(|w| w == CENTRAL.to_le_bytes()).unwrap(); - let mut bad = bytes.clone(); - bad[dir_at + 16] ^= 1; - let b = Archive::open(&bad, 10).unwrap(); - assert_eq!(b.read(0, 1000, 1000).unwrap_err(), Error::Damaged("package member")); - // A stated size one short: the inflate runs past it. - let mut short = bytes.clone(); - short[dir_at + 24] -= 1; - let s = Archive::open(&short, 10).unwrap(); - assert_eq!(s.read(0, 1000, 1000).unwrap_err(), Error::Damaged("package member")); - assert!(a.read(0, 1000, 1000).is_ok()); - } -} diff --git a/crates/cdr/tests/it/bench.rs b/crates/cdr/tests/it/bench.rs deleted file mode 100644 index 6ec024423a..0000000000 --- a/crates/cdr/tests/it/bench.rs +++ /dev/null @@ -1,65 +0,0 @@ -//! Read time of a large synthetic drawing. Run with -//! `cargo test --release -p vectorcraft-cdr --test it bench -- --ignored --nocapture`. - -use vectorcraft_cdr::synth::{self, V, chunk, list}; -use vectorcraft_cdr::{Limits, read}; - -/// A version 13 drawing of `n` curves of 22 points each, filled and outlined, compressed when -/// `compress`. -fn many_curves(n: usize, compress: bool) -> Vec { - let v = V(1300); - let red = synth::color(5, [0, 0, 255, 0]); - let black = synth::color(2, [0, 0, 0, 100]); - let styles = list( - b"doc ", - vec![ - synth::mcfg(v, 612.0, 792.0), - list(b"filt", vec![chunk(b"fild", v.fill(1, &red))]), - list(b"otlt", vec![chunk(b"outl", v.outline(2, synth::Pen { line_type: 0, width: 1.0, cap: 0, join: 0 }, &black, &[]))]), - ], - ); - let objects: Vec<_> = (0..n) - .map(|i| { - let o = (i % 500) as f64; - // A move, then curves of two control points and an end point each. - let kind = |k: i32| { - if k == 0 { - 0x08 - } else if k % 3 == 0 { - 0x80 - } else { - 0xC0 - } - }; - let pts: Vec<(f64, f64, u8)> = (0..22).map(|k| (o + f64::from(k), o + f64::from(k % 5), kind(k))).collect(); - let args = vec![(20, 1u32.to_le_bytes().to_vec()), (10, 2u32.to_le_bytes().to_vec()), (30, v.points(&pts))]; - synth::object(v, 3, &args, Some([1.0, 0.0, 0.0, 1.0, o, -o])) - }) - .collect(); - let page = synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "Art", objects)]); - let body = vec![styles, page]; - let mut kids = vec![chunk(b"vrsn", 1300u16.to_le_bytes().to_vec())]; - if compress { - kids.push(synth::cmpr(&body)); - } else { - kids.extend(body); - } - synth::riff(1300, &kids) -} - -#[test] -#[ignore = "manual timing probe; wall-clock performance depends on machine load"] -fn read_a_large_drawing() { - for compress in [false, true] { - let file = many_curves(50_000, compress); - let mut times = Vec::new(); - for _ in 0..5 { - let t = std::time::Instant::now(); - let d = read(&file, Limits::default()).unwrap(); - times.push(t.elapsed().as_secs_f64() * 1000.0); - assert_eq!(d.pages.len(), 1); - } - times.sort_by(f64::total_cmp); - println!("compress={compress} bytes={} median_ms={:.1} min_ms={:.1}", file.len(), times[2], times[0]); - } -} diff --git a/crates/cdr/tests/it/cmx.rs b/crates/cdr/tests/it/cmx.rs deleted file mode 100644 index 381eaddfcb..0000000000 --- a/crates/cdr/tests/it/cmx.rs +++ /dev/null @@ -1,568 +0,0 @@ -//! Reading synthetic `.cmx` files built from the layouts in `PROVENANCE.md` (R53 to R63), and -//! hostile ones. - -use proptest::prelude::*; -use vectorcraft_cdr::model::{Cap, Color, Geometry, Join, Object, Shape}; -use vectorcraft_cdr::synth_cmx::*; -use vectorcraft_cdr::{Error, Limits, Warning, is_cdr, is_cmx, read_cmx}; - -fn shape(o: &Object) -> &Shape { - match o { - Object::Shape(s) => s, - other => panic!("not a shape: {other:?}"), - } -} - -/// The (x, y) bounds of a shape's path. -fn bounds(s: &Shape) -> (f64, f64, f64, f64) { - let Geometry::Path(p) = &s.geometry else { panic!("not a path") }; - let mut b = (f64::MAX, f64::MAX, f64::MIN, f64::MIN); - for sp in &p.subpaths { - for pt in std::iter::once(sp.start).chain(sp.segments.iter().map(|s| match s { - vectorcraft_cdr::model::Segment::Line(p) | vectorcraft_cdr::model::Segment::Cubic(_, _, p) => *p, - })) { - b = (b.0.min(pt.x), b.1.min(pt.y), b.2.max(pt.x), b.3.max(pt.y)); - } - } - b -} - -fn near(a: f64, b: f64) -> bool { - (a - b).abs() < 1e-6 -} - -/// The file with `children` after a 32-bit header and the sample tables. -fn file(pages: &[Vec]) -> Vec { - let mut children = vec![cont(b'4', 1e-7)]; - children.extend(pages.iter().cloned()); - children.extend(tables()); - riff(&children) -} - -#[test] -fn a_cmx_file_is_told_from_a_cdr_drawing() { - let f = sample(); - assert!(is_cmx(&f) && !is_cdr(&f)); - let mut rifx = f.clone(); - rifx[..4].copy_from_slice(b"RIFX"); - assert!(is_cmx(&rifx)); - assert!(!is_cmx(b"RIFF\0\0\0\0CDR9")); - assert_eq!(read_cmx(b"RIFF\0\0\0\0CDR9", Limits::default()), Err(Error::NotCmx)); -} - -#[test] -fn pages_layers_groups_and_curves() { - let d = read_cmx(&sample(), Limits::default()).unwrap(); - assert_eq!(d.version, 0); - assert!(d.warnings.is_empty(), "{:?}", d.warnings); - assert_eq!(d.pages.len(), 1); - let page = &d.pages[0]; - // 2,100,000 units of 0.1 µm are 210 mm. - let (w, h) = page.size.unwrap(); - assert!(near(w, 210.0 / 25.4 * 72.0) && near(h, 297.0 / 25.4 * 72.0), "{w} {h}"); - // The layer drawn last is in front: the model lists layers front to back. - let names: Vec<&str> = page.layers.iter().map(|l| l.name.as_str()).collect(); - assert_eq!(names, ["Top", "Art"]); - let art = &page.layers[1].objects; - assert_eq!(art.len(), 2); - // The group, drawn after the red square, is in front of it. - let Object::Group { objects: kids, .. } = &art[0] else { panic!("{:?}", art[0]) }; - assert_eq!(kids.len(), 2); - let red = shape(&art[1]); - assert_eq!(red.fill, Some(Color::Rgb([1.0, 0.0, 0.0]))); - // 1,000,000 units are 100 mm; the square's corner is 50 mm left of and below the center. - let mm = 72.0 / 25.4; - let b = bounds(red); - assert!(near(b.0, -50.0 * mm) && near(b.1, -50.0 * mm) && near(b.2, 50.0 * mm) && near(b.3, 50.0 * mm), "{b:?}"); - let Geometry::Path(p) = &red.geometry else { panic!() }; - assert!(p.subpaths.len() == 1 && p.subpaths[0].closed && p.subpaths[0].segments.len() == 4); - let o = red.outline.as_ref().unwrap(); - assert!(near(o.width, 0.5 * mm)); - assert_eq!((o.color.clone(), o.cap, o.join), (Color::Cmyk([0.0, 0.0, 0.0, 1.0]), Cap::Round, Join::Round)); - assert!(o.dashes.is_empty() && !o.behind_fill && !o.scale_with); - // Line type 1 draws no outline. - let blue = shape(&kids[0]); - let black = shape(&kids[1]); - assert!(black.outline.is_none()); - assert_eq!(black.fill, Some(Color::Cmyk([0.0, 0.0, 0.0, 1.0]))); - // The color record's values are blue, green and red. - assert_eq!(blue.fill, Some(Color::Rgb([0.0, 0.0, 1.0]))); - let o = blue.outline.as_ref().unwrap(); - assert!(near(o.width, 1.0 * mm)); - assert_eq!((o.dashes.clone(), o.behind_fill, o.cap, o.join), (vec![3.0, 1.0], true, Cap::Square, Join::Miter)); - assert_eq!(page.layers[0].name, "Top"); -} - -#[test] -fn layer_names_and_layers_without_objects() { - let p = page(&[ - begin_page(None), - begin_layer("Ebene 1", Some("Слой 1")), - square(&attrs(Some(1), None, false), 0, 0, 1000), - end_layer(), - begin_layer("Gitter", None), - end_layer(), - begin_layer("Caf\u{e9}", None), - square(&attrs(Some(1), None, false), 0, 0, 1000), - end_layer(), - end_page(), - ]); - let d = read_cmx(&file(&[p]), Limits::default()).unwrap(); - let page = &d.pages[0]; - assert_eq!(page.size, None); - // The empty layer is left out, and the UTF-16 name wins over the 8-bit one. - let names: Vec<&str> = page.layers.iter().map(|l| l.name.as_str()).collect(); - assert_eq!(names, ["Caf\u{c3}\u{a9}", "Слой 1"]); -} - -#[test] -fn objects_before_any_layer_get_one() { - let p = page(&[begin_page(None), square(&attrs(Some(1), None, false), 0, 0, 1000)]); - let d = read_cmx(&file(&[p]), Limits::default()).unwrap(); - assert_eq!(d.pages[0].layers.len(), 1); - // The layer is left unnamed, as a `.cdr` drawing's is; the importer names it by its place. - assert_eq!(d.pages[0].layers[0].name, ""); -} - -#[test] -fn a_page_without_a_size_takes_the_drawings_bounds() { - // A square of 100 mm whose bounds lie off the file's origin, above and to the right. - let p = page(&[ - begin_page_in_bounds(1_000_000, 3_000_000, 2_000_000, 2_000_000), - begin_layer("L", None), - square(&attrs(Some(1), None, false), 1_000_000, 2_000_000, 1_000_000), - end_layer(), - end_page(), - ]); - let d = read_cmx(&file(&[p]), Limits::default()).unwrap(); - let page = &d.pages[0]; - let side = 100.0 / 25.4 * 72.0; - let (w, h) = page.size.unwrap(); - assert!(near(w, side) && near(h, side), "{w} x {h}"); - // The page is centered on the bounds, so the square fills it. - let (x0, y0, x1, y1) = bounds(shape(&page.layers[0].objects[0])); - assert!(near(x0, -side / 2.0) && near(x1, side / 2.0) && near(y0, -side / 2.0) && near(y1, side / 2.0), "{x0} {y0} {x1} {y1}"); -} - -#[test] -fn curves_and_open_groups() { - let c = - curve(&attrs(None, Some(1), false), &[(0, 0), (100, 0), (100, 100), (0, 100), (200, 200), (300, 200)], &[0x00, 0xc0, 0xc0, 0x84, 0x00, 0x44]); - // A group the layer leaves open closes with it. - let p = page(&[begin_page(None), begin_layer("L", None), begin_group(), c, end_layer()]); - let d = read_cmx(&file(&[p]), Limits::default()).unwrap(); - let objects = &d.pages[0].layers[0].objects; - let Object::Group { objects: kids, .. } = &objects[0] else { panic!("{objects:?}") }; - let s = shape(&kids[0]); - assert!(s.fill.is_none()); - let Geometry::Path(p) = &s.geometry else { panic!() }; - assert_eq!(p.subpaths.len(), 2); - assert!(matches!(p.subpaths[0].segments[..], [vectorcraft_cdr::model::Segment::Cubic(..)])); - assert!(!p.subpaths[1].closed); -} - -#[test] -fn a_curve_without_its_points_is_reported() { - let p = page(&[begin_page(None), begin_layer("L", None), instr(67, &fields(&[field(1, &attrs(Some(1), None, false))])), end_layer()]); - let d = read_cmx(&file(&[p]), Limits::default()).unwrap(); - assert!(d.warnings.contains(&Warning::Damaged), "{:?}", d.warnings); -} - -#[test] -fn a_layer_name_too_short_to_read_in_utf_16_reads_in_8_bit() { - let mut d = vec![1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0]; - d.extend(b"Art"); - let layer = instr(11, &fields(&[field(1, &d), field(4, &[3, 0])])); - let p = page(&[begin_page(None), layer, square(&attrs(Some(1), None, false), 0, 0, 1000), end_layer()]); - let d = read_cmx(&file(&[p]), Limits::default()).unwrap(); - assert_eq!(d.pages[0].layers[0].name, "Art"); -} - -#[test] -fn what_is_not_read_is_reported() { - let other = |code: i16| instr(code, &fields(&[field(1, &[0; 8])])); - let p = page(&[ - begin_page(None), - begin_layer("L", None), - other(66), - other(68), - other(20), - other(88), - square(&attrs_fill_type(2), 0, 0, 1000), - square(&attrs(Some(1), None, true), 0, 0, 1000), - end_layer(), - ]); - let d = read_cmx(&file(&[p]), Limits::default()).unwrap(); - for w in [Warning::UnsupportedObjects, Warning::UnsupportedFills, Warning::Lenses] { - assert!(d.warnings.contains(&w), "{w:?}: {:?}", d.warnings); - } - // A fill of another type leaves the curve unfilled; the curve is still read. - let objects = &d.pages[0].layers[0].objects; - assert_eq!(objects.len(), 2); - assert!(shape(&objects[1]).fill.is_none()); -} - -#[test] -fn colors_of_other_models_and_missing_entries() { - let mut children = vec![cont(b'4', 1e-7)]; - children.push(page(&[ - begin_page(None), - begin_layer("L", None), - square(&attrs(Some(1), None, false), 0, 0, 1000), - square(&attrs(Some(9), None, false), 0, 0, 1000), - square(&attrs(Some(2), None, false), 0, 0, 1000), - ])); - children.push(table(b"rclr", &[color(7, &[1, 2, 3, 4]), color(3, &[255, 0, 0, 255])])); - let d = read_cmx(&riff(&children), Limits::default()).unwrap(); - assert!(d.warnings.contains(&Warning::UnknownColors) && d.warnings.contains(&Warning::Damaged), "{:?}", d.warnings); - let objects = &d.pages[0].layers[0].objects; - assert_eq!(shape(&objects[0]).fill, Some(Color::Cmyk([1.0, 0.0, 0.0, 1.0]))); - assert_eq!(shape(&objects[1]).fill, Some(Color::Rgb([0.0; 3]))); -} - -#[test] -fn gray_cmy_and_rgb_colors_of_the_older_fields() { - let mut children = vec![cont(b'4', 1e-7)]; - children.push(page(&[ - begin_page(None), - begin_layer("L", None), - square(&attrs(Some(1), None, false), 0, 0, 1000), - square(&attrs(Some(2), None, false), 0, 0, 1000), - square(&attrs(Some(3), None, false), 0, 0, 1000), - ])); - children.push(table(b"rclr", &[color(9, &[51]), color(4, &[255, 0, 51]), color(5, &[255, 0, 0])])); - let d = read_cmx(&riff(&children), Limits::default()).unwrap(); - assert!(d.warnings.is_empty(), "{:?}", d.warnings); - let objects = &d.pages[0].layers[0].objects; - // The model holds objects front to back: the RGB square, the CMY one, then the gray one. - assert_eq!(shape(&objects[0]).fill, Some(Color::Rgb([1.0, 0.0, 0.0]))); - match (shape(&objects[1]).fill.clone(), shape(&objects[2]).fill.clone()) { - (Some(Color::Cmyk([c, m, y, k])), Some(Color::Gray(g))) => { - assert!((c - 1.0).abs() < 1e-6 && m == 0.0 && (y - 0.2).abs() < 1e-6 && k == 0.0, "{c} {m} {y} {k}"); - assert!((g - 0.8).abs() < 1e-6, "{g}"); - } - other => panic!("{other:?}"), - } -} - -#[test] -fn outline_arrowheads_are_reported() { - let mut children = vec![cont(b'4', 1e-7)]; - children.push(page(&[begin_page(None), begin_layer("L", None), square(&attrs(None, Some(1), false), 0, 0, 1000)])); - children.extend(tables().into_iter().filter(|t| !t.starts_with(b"rota"))); - children.push(arrowheads(&[(0, 2)])); - let d = read_cmx(&riff(&children), Limits::default()).unwrap(); - assert_eq!(d.warnings, vec![Warning::Arrowheads]); -} - -#[test] -fn a_long_instruction_and_a_jump_over_image_bytes() { - // The jump's target counts from the start of the file: header, `cont`, then the page body. - let before = riff(&[cont(b'4', 1e-7), page(&[])]).len() - 8; - let head = [begin_page(None), begin_layer("L", None)].concat(); - let jump_len = 4 + 1 + 3 + 4; - let image = vec![0xEEu8; 37]; - let target = (before + 8 + head.len() + jump_len + image.len()) as u32; - let jump = instr(111, &fields(&[field(1, &target.to_le_bytes())])); - assert_eq!(jump.len(), jump_len); - let body = [ - head, - jump, - image, - long_instr(67, &curve(&attrs(Some(1), None, false), &[(0, 0), (10, 0), (10, 10)], &[0x0c, 0x44, 0x48])[4..]), - end_layer(), - ] - .concat(); - let mut children = vec![cont(b'4', 1e-7), chunk(b"page", &body)]; - children.extend(tables()); - let d = read_cmx(&riff(&children), Limits::default()).unwrap(); - // The images jumped over are not read, and the warning says so. - assert_eq!(d.warnings, [Warning::UnsupportedObjects]); - assert_eq!(d.pages[0].layers[0].objects.len(), 1); -} - -#[test] -fn bytes_after_a_chunk_that_runs_short_are_passed_over() { - let stray = vec![0x10, 0x00, 0x16, 0x00, 0x01, 0x0b, 0x00, 0x01, 0, 0, 0, 0, 0, 0, 0, 0xff]; - let mut children = vec![cont(b'4', 1e-7), stray, list(b"pgls", &[page(&[begin_page(None), square(&attrs(Some(1), None, false), 0, 0, 1000)])])]; - children.extend(tables()); - let d = read_cmx(&riff(&children), Limits::default()).unwrap(); - assert!(d.warnings.is_empty(), "{:?}", d.warnings); - assert_eq!(d.pages[0].layers[0].objects.len(), 1); -} - -#[test] -fn other_byte_orders_and_coordinate_sizes_are_refused() { - let mut f = sample(); - f[..4].copy_from_slice(b"RIFX"); - assert_eq!(read_cmx(&f, Limits::default()), Err(Error::Unsupported("big-endian CMX files"))); - let mut children = vec![cont(b'2', 1e-3)]; - children.extend(tables()); - assert_eq!(read_cmx(&riff(&children), Limits::default()), Err(Error::Unsupported("CMX files with 16-bit coordinates"))); - assert_eq!(read_cmx(&riff(&tables()), Limits::default()), Err(Error::Damaged("CMX header"))); - assert_eq!(read_cmx(&riff(&[cont(b'9', 1e-7)]), Limits::default()), Err(Error::Damaged("CMX header"))); -} - -#[test] -fn a_header_without_a_usable_unit_reads_0_1_micrometers() { - for meters in [0.0, -1.0, f64::NAN, 2.0] { - let mut children = vec![cont(b'4', meters), page(&[begin_page(Some((2_100_000, 2_970_000)))])]; - children.extend(tables()); - let d = read_cmx(&riff(&children), Limits::default()).unwrap(); - let (w, _) = d.pages[0].size.unwrap(); - assert!(near(w, 210.0 / 25.4 * 72.0), "{meters}: {w}"); - } -} - -#[test] -fn groups_past_the_depth_limit_are_left_out() { - let mut ins = vec![begin_page(None), begin_layer("L", None)]; - for _ in 0..6 { - ins.push(begin_group()); - } - ins.push(square(&attrs(Some(1), None, false), 0, 0, 1000)); - for _ in 0..6 { - ins.push(end_group()); - } - ins.push(square(&attrs(Some(1), None, false), 0, 0, 1000)); - let d = read_cmx(&file(&[page(&ins)]), Limits { depth: 3, ..Limits::default() }).unwrap(); - assert!(d.warnings.contains(&Warning::TooDeep)); - // The square after the groups is still read, beside the three groups kept. - let objects = &d.pages[0].layers[0].objects; - assert_eq!(objects.len(), 2); - let mut depth = 0; - let mut o = &objects[1]; - while let Object::Group { objects: kids, .. } = o { - depth += 1; - match kids.first() { - Some(k) => o = k, - None => break, - } - } - assert_eq!(depth, 3); -} - -#[test] -fn counts_past_the_limits_are_bounded() { - let ins: Vec> = std::iter::once(begin_page(None)).chain((0..50).map(|_| square(&attrs(Some(1), None, false), 0, 0, 1000))).collect(); - let f = file(&[page(&ins)]); - let d = read_cmx(&f, Limits { objects: 10, ..Limits::default() }).unwrap(); - assert_eq!(d.pages[0].layers[0].objects.len(), 10); - assert!(d.warnings.contains(&Warning::TooDeep)); - let d = read_cmx(&f, Limits { coordinates: 12, ..Limits::default() }).unwrap(); - assert_eq!(d.pages[0].layers[0].objects.len(), 2); - assert_eq!(read_cmx(&f, Limits { chunks: 20, ..Limits::default() }), Err(Error::Limit("chunk count"))); - assert_eq!(read_cmx(&f, Limits { input: 10, ..Limits::default() }), Err(Error::Limit("input size"))); - let dashed = |n: u16| { - let mut children = vec![cont(b'4', 1e-7)]; - children.push(page(&[begin_page(None), square(&attrs(None, Some(3), false), 0, 0, 1000), square(&attrs(None, Some(3), false), 0, 0, 1000)])); - children.extend(tables()); - read_cmx(&riff(&children), Limits { dashes: usize::from(n), ..Limits::default() }).unwrap() - }; - let d = dashed(3); - let o: Vec = d.pages[0].layers[0].objects.iter().map(|o| shape(o).outline.as_ref().unwrap().dashes.len()).collect(); - assert_eq!(o, [0, 2]); - assert!(d.warnings.contains(&Warning::TooDeep)); -} - -#[test] -fn a_curve_cut_short_keeps_the_points_it_holds() { - let mut c = curve(&attrs(Some(1), None, false), &[(0, 0), (10, 0), (10, 10)], &[0x0c, 0x44, 0x48]); - // Claim 9 points where 3 are stored: the field's own length still covers only 3. - let at = c.windows(2).position(|w| w == [3, 0]).unwrap(); - c[at] = 9; - let p = page(&[begin_page(None), c]); - let d = read_cmx(&file(&[p]), Limits::default()).unwrap(); - assert!(d.warnings.contains(&Warning::Damaged)); - assert_eq!(d.pages[0].layers[0].objects.len(), 1); -} - -#[test] -fn a_curve_that_lost_type_bytes_keeps_its_first_points() { - // Three whole points and only two of their type bytes. - let mut g = 3u16.to_le_bytes().to_vec(); - for (x, y) in [(0i32, 0i32), (1_000_000, 0), (1_000_000, 1_000_000)] { - g.extend(x.to_le_bytes()); - g.extend(y.to_le_bytes()); - } - g.extend([0x0c, 0x44]); - let c = instr(67, &fields(&[field(1, &attrs(None, Some(1), false)), field(2, &g)])); - let d = read_cmx(&file(&[page(&[begin_page(None), c])]), Limits::default()).unwrap(); - assert!(d.warnings.contains(&Warning::Damaged), "{:?}", d.warnings); - let Geometry::Path(p) = &shape(&d.pages[0].layers[0].objects[0]).geometry else { panic!() }; - let side = 100.0 / 25.4 * 72.0; - assert!(near(p.subpaths[0].start.x, 0.0) && near(p.subpaths[0].start.y, 0.0)); - match p.subpaths[0].segments[..] { - [vectorcraft_cdr::model::Segment::Line(e)] => assert!(near(e.x, side) && near(e.y, 0.0), "{e:?}"), - ref other => panic!("{other:?}"), - } -} - -#[test] -fn a_file_cut_short_of_its_declared_size_is_reported() { - let mut f = file(&[]); - let declared = (f.len() as u32 - 8 + 100).to_le_bytes(); - f[4..8].copy_from_slice(&declared); - let d = read_cmx(&f, Limits::default()).unwrap(); - assert!(d.warnings.contains(&Warning::Damaged), "{:?}", d.warnings); -} - -#[test] -fn a_page_that_ends_inside_an_instruction_is_reported() { - let p = page(&[begin_page(None), begin_layer("L", None), square(&attrs(Some(1), None, false), 0, 0, 1000), end_layer(), vec![1, 0]]); - let d = read_cmx(&file(&[p]), Limits::default()).unwrap(); - assert!(d.warnings.contains(&Warning::Damaged), "{:?}", d.warnings); - assert_eq!(d.pages[0].layers[0].objects.len(), 1); -} - -#[test] -fn a_chunk_64_bytes_past_stray_bytes_is_found() { - let p = page(&[begin_page(None), begin_layer("L", None), square(&attrs(Some(1), None, false), 0, 0, 1000), end_layer()]); - let mut children = vec![cont(b'4', 1e-7), [vec![1u8; 64], p].concat()]; - children.extend(tables()); - let d = read_cmx(&riff(&children), Limits::default()).unwrap(); - assert_eq!(d.pages.len(), 1); - assert_eq!(d.pages[0].layers[0].objects.len(), 1); -} - -#[test] -fn stray_letters_with_a_length_past_the_file_are_passed_over() { - let mut stray = b"abcd".to_vec(); - stray.extend(0xFFFF_FF00u32.to_le_bytes()); - let p = page(&[begin_page(None), begin_layer("L", None), square(&attrs(Some(1), None, false), 0, 0, 1000), end_layer()]); - let mut children = vec![cont(b'4', 1e-7), [stray, p].concat()]; - children.extend(tables()); - let d = read_cmx(&riff(&children), Limits::default()).unwrap(); - assert_eq!(d.pages.len(), 1); - assert_eq!(d.pages[0].layers[0].objects.len(), 1); -} - -#[test] -fn a_dash_pattern_of_zero_lengths_draws_a_solid_line() { - let mut children = vec![cont(b'4', 1e-7)]; - children.push(page(&[begin_page(None), begin_layer("L", None), square(&attrs(None, Some(1), false), 0, 0, 1000)])); - children.extend(tables().into_iter().filter(|t| !t.starts_with(b"rdot") && !t.starts_with(b"rotl"))); - children.push(table(b"rdot", &[dashes(&[0, 0])])); - children.push(table(b"rotl", &[outline([3, 1, 2, 1, 1, 1])])); - let d = read_cmx(&riff(&children), Limits::default()).unwrap(); - assert!(d.warnings.is_empty(), "{:?}", d.warnings); - let o = shape(&d.pages[0].layers[0].objects[0]).outline.clone().unwrap(); - assert!(o.dashes.is_empty(), "{:?}", o.dashes); -} - -#[test] -fn a_curve_field_that_lost_points_is_left_out() { - // Three points claimed, two whole points stored and the third cut inside its y: the type - // bytes can't be found, so no node types are read from coordinates. - let mut g = 3u16.to_le_bytes().to_vec(); - for (x, y) in [(0i32, 0i32), (1_000_000, 0)] { - g.extend(x.to_le_bytes()); - g.extend(y.to_le_bytes()); - } - g.extend(1_000_000i32.to_le_bytes()); - g.extend([0x40, 0x42]); - let c = instr(67, &fields(&[field(1, &attrs(Some(1), None, false)), field(2, &g)])); - let d = read_cmx(&file(&[page(&[begin_page(None), begin_layer("L", None), c])]), Limits::default()).unwrap(); - assert!(d.warnings.contains(&Warning::Damaged), "{:?}", d.warnings); - assert!(d.pages[0].layers.is_empty(), "{:?}", d.pages[0].layers); -} - -#[test] -fn a_chunk_whose_id_has_a_digit_is_found_after_stray_bytes() { - // Stray bytes, a chunk the reader passes over whose id ends in a digit, then the page. - let p = page(&[begin_page(None), begin_layer("L", None), square(&attrs(Some(1), None, false), 0, 0, 1000), end_layer()]); - let mut b = vec![1u8; 6]; - b.extend(chunk(b"inf1", &[0; 70])); - b.extend(p); - let mut children = vec![cont(b'4', 1e-7), b]; - children.extend(tables()); - let d = read_cmx(&riff(&children), Limits::default()).unwrap(); - assert!(d.warnings.is_empty(), "{:?}", d.warnings); - assert_eq!(d.pages.len(), 1); - assert_eq!(d.pages[0].layers[0].objects.len(), 1); -} - -#[test] -fn padding_and_ids_with_impossible_lengths_are_not_taken_for_chunks() { - // After stray bytes, four spaces with a small length, or letters with a length past the list, - // come before the page: neither is taken for a chunk, so the page is found. - for filler in [b" \x08\x00\x00\x00".to_vec(), b"junk\x40\x42\x0f\x00".to_vec()] { - let p = page(&[begin_page(None), begin_layer("L", None), square(&attrs(Some(1), None, false), 0, 0, 1000), end_layer()]); - let mut b = vec![1u8; 2]; - b.extend(filler); - b.extend(p); - let mut children = vec![cont(b'4', 1e-7), b]; - children.extend(tables()); - let d = read_cmx(&riff(&children), Limits::default()).unwrap(); - assert!(d.warnings.is_empty(), "{:?}", d.warnings); - assert_eq!(d.pages.len(), 1); - assert_eq!(d.pages[0].layers[0].objects.len(), 1); - } -} - -#[test] -fn after_stray_bytes_a_chunk_the_reader_passes_over_keeps_what_it_holds() { - // Stray bytes, then a chunk the reader passes over whose body starts with the letters of a - // page chunk, then the page: only the page is read. - let p = page(&[begin_page(None), begin_layer("L", None), square(&attrs(Some(1), None, false), 0, 0, 1000), end_layer()]); - let mut inner = b"page".to_vec(); - inner.extend(4u32.to_le_bytes()); - inner.extend([0; 10]); - let mut b = vec![1u8; 2]; - b.extend(chunk(b"inf1", &inner)); - b.extend(p); - let mut children = vec![cont(b'4', 1e-7), b]; - children.extend(tables()); - let d = read_cmx(&riff(&children), Limits::default()).unwrap(); - assert!(d.warnings.is_empty(), "{:?}", d.warnings); - assert_eq!(d.pages.len(), 1); - assert_eq!(d.pages[0].layers[0].objects.len(), 1); -} - -#[test] -fn a_canvas_or_a_container_is_reported() { - for bit in [8u8, 16] { - let mut a = attrs(Some(1), None, false); - a[0] |= bit; - let p = page(&[begin_page(None), begin_layer("L", None), square(&a, 0, 0, 1000), end_layer()]); - let d = read_cmx(&file(&[p]), Limits::default()).unwrap(); - assert_eq!(d.warnings, vec![Warning::UnsupportedObjects], "{bit}"); - assert!(shape(&d.pages[0].layers[0].objects[0]).fill.is_some()); - } -} - -#[test] -fn a_library_color_with_its_name_reads_as_a_spot_color() { - let mut children = vec![cont(b'4', 1e-7)]; - children.push(page(&[begin_page(None), begin_layer("L", None), square(&attrs(Some(1), None, false), 0, 0, 1000)])); - children.push(table(b"rclr", &[color_record_named(5, [0, 0, 255, 0], Some("Brick 12"))])); - let d = read_cmx(&riff(&children), Limits::default()).unwrap(); - match shape(&d.pages[0].layers[0].objects[0]).fill.clone() { - Some(Color::Spot { name, tint, look }) => { - assert_eq!((name.as_str(), tint), ("Brick 12", 1.0)); - assert!(look.is_some()); - } - other => panic!("{other:?}"), - } -} - -proptest! { - #![proptest_config(ProptestConfig { cases: 256, ..ProptestConfig::default() })] - - #[test] - fn never_panics_on_garbage(bytes in prop::collection::vec(any::(), 0..2048)) { - let mut b = b"RIFF\0\0\0\0CMX1".to_vec(); - b.extend(bytes); - let _ = read_cmx(&b, Limits::default()); - } - - #[test] - fn never_panics_on_mutated_samples(edits in prop::collection::vec((any::(), any::()), 1..24)) { - let mut b = sample(); - let n = b.len(); - for (at, v) in edits { - b[at % n] = v; - } - let _ = read_cmx(&b, Limits::default()); - } -} diff --git a/crates/cdr/tests/it/main.rs b/crates/cdr/tests/it/main.rs deleted file mode 100644 index 4fc7dcbdc9..0000000000 --- a/crates/cdr/tests/it/main.rs +++ /dev/null @@ -1,8 +0,0 @@ -//! Integration tests: one test binary for the crate, one module per area. -// Unwrapping and panicking on failure is fine here, unlike in shipped code (AGENTS.md › Robustness). -#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)] - -mod bench; -mod cmx; -mod provenance; -mod read; diff --git a/crates/cdr/tests/it/provenance.rs b/crates/cdr/tests/it/provenance.rs deleted file mode 100644 index fffc006cb4..0000000000 --- a/crates/cdr/tests/it/provenance.rs +++ /dev/null @@ -1,43 +0,0 @@ -//! Every layout id the code cites (`R1` ...) has a row in `PROVENANCE.md`. - -use std::collections::BTreeSet; - -/// The ids `R` in `text`. -fn ids(text: &str) -> BTreeSet { - let b = text.as_bytes(); - let mut out = BTreeSet::new(); - for (i, c) in b.iter().enumerate() { - let starts = *c == b'R' && (i == 0 || !b[i - 1].is_ascii_alphanumeric()); - if !starts { - continue; - } - let digits: String = b[i + 1..].iter().take_while(|d| d.is_ascii_digit()).map(|d| *d as char).collect(); - let ends = b.get(i + 1 + digits.len()).is_none_or(|d| !d.is_ascii_alphanumeric()); - if !digits.is_empty() && ends { - out.insert(digits.parse().unwrap()); - } - } - out -} - -#[test] -fn every_cited_layout_has_a_row() { - let dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR")); - let table = std::fs::read_to_string(dir.join("PROVENANCE.md")).unwrap(); - let rows: BTreeSet = table.lines().filter_map(|l| l.strip_prefix("| R")).filter_map(|l| l.split(' ').next()?.parse().ok()).collect(); - let mut cited = BTreeSet::new(); - for entry in std::fs::read_dir(dir.join("src")).unwrap() { - let path = entry.unwrap().path(); - if path.extension().is_some_and(|e| e == "rs") { - cited.extend(ids(&std::fs::read_to_string(&path).unwrap())); - } - } - assert!(!cited.is_empty()); - let missing: Vec<_> = cited.difference(&rows).collect(); - assert!(missing.is_empty(), "cited without a PROVENANCE.md row: {missing:?}"); -} - -#[test] -fn ids_are_found_only_as_whole_words() { - assert_eq!(ids("(R1, R12) RIFF R3x xR4 R"), BTreeSet::from([1, 12])); -} diff --git a/crates/cdr/tests/it/read.rs b/crates/cdr/tests/it/read.rs deleted file mode 100644 index 5c944a6c16..0000000000 --- a/crates/cdr/tests/it/read.rs +++ /dev/null @@ -1,2163 +0,0 @@ -//! Reading synthetic drawings of every version the reader takes, plain and compressed, and -//! hostile files. - -use proptest::prelude::*; -use vectorcraft_cdr::model::{Blend, Cap, Color, Flags, Geometry, Join, LayerKind, Matrix, Object, Segment}; -use vectorcraft_cdr::synth::{self, V, chunk, list}; -use vectorcraft_cdr::{Error, Limits, Warning, read}; - -fn shapes(objects: &[Object]) -> Vec<&vectorcraft_cdr::model::Shape> { - let mut out = Vec::new(); - let mut stack: Vec<&Object> = objects.iter().rev().collect(); - while let Some(o) = stack.pop() { - match o { - Object::Shape(s) => out.push(&**s), - Object::Group { objects: kids, .. } => stack.extend(kids.iter().rev()), - Object::Clip { container, objects } => { - out.push(&**container); - stack.extend(objects.iter().rev()); - } - } - } - out -} - -/// The page and layers of the sample of `version`. -fn check_pages(d: &vectorcraft_cdr::Drawing, version: u16) { - assert_eq!(d.version, version); - let (w, h) = d.page_size.unwrap(); - assert!((w - 612.0).abs() < 0.1 && (h - 792.0).abs() < 0.1, "{version}: {w} {h}"); - assert_eq!(d.pages.len(), 1, "{version}"); - let art = &d.pages[0].layers[0]; - assert_eq!((art.name.as_str(), art.kind), ("Art", LayerKind::Drawing)); - assert!(matches!(art.objects[3], Object::Group { objects: ref g, .. } if g.len() == 2)); - assert!(d.warnings.contains(&Warning::UnsupportedObjects)); - // The master page: its guideline every page shows, and its desktop object. - if version >= 600 { - assert_eq!(d.guides.len(), 1); - assert!((d.guides[0].angle - 90.0).abs() < 1e-9 && (d.guides[0].at.x - 36.0).abs() < 0.01); - } - assert_eq!(d.master.len(), 1); - assert_eq!(d.master[0].kind, LayerKind::Desktop); -} - -/// The shapes of the sample of `version`: rectangle, ellipse, curve, and the group's polygon and -/// arc; the text is left out. -fn check_shapes(d: &vectorcraft_cdr::Drawing, version: u16) { - let s = shapes(&d.pages[0].layers[0].objects); - assert_eq!(s.len(), 5, "{version}"); - assert!(matches!(s[0].geometry, Geometry::Rect { radii, .. } if radii.iter().all(|r| (r - 5.0).abs() < 0.1))); - // The samples of versions 3 and 4 store their red as CMYK in percent. - let red = if version < 500 { Color::Cmyk([0.0, 1.0, 1.0, 0.0]) } else { Color::Rgb([1.0, 0.0, 0.0]) }; - assert_eq!(s[0].fill, Some(red), "{version}"); - let o = s[0].outline.as_ref().unwrap(); - assert!((o.width - 2.0).abs() < 0.05 && o.cap == Cap::Round, "{version}: {o:?}"); - assert!((s[0].matrix.0[4] + 100.0).abs() < 0.1 && (s[0].matrix.0[5] - 100.0).abs() < 0.1); - assert!(matches!(s[1].geometry, Geometry::Ellipse { .. }) && s[1].outline.is_none()); - assert!(matches!(&s[2].geometry, Geometry::Path(p) if p.subpaths[0].closed && matches!(p.subpaths[0].segments[1], Segment::Cubic(..)))); - assert!(s[2].fill.is_none()); - if version >= 600 { - let Geometry::Path(p) = &s[3].geometry else { panic!("polygon") }; - assert_eq!(p.subpaths[0].segments.len(), 10, "five sides of two segments"); - // 5 % of 1000 mm. - let r = p.subpaths[0].start.y; - assert!((r - 0.05 * synth::POLYGON_SIDE).abs() < 0.5, "{r}"); - } - assert!(matches!(&s[4].geometry, Geometry::Path(p) if p.subpaths[0].closed)); -} - -#[test] -fn every_version_from_5_to_13_reads_its_sample() { - for version in [500, 600, 700, 800, 900, 1000, 1100, 1200, 1300] { - for compress in [false, version >= 700] { - let d = read(&synth::sample(version, compress), Limits::default()).unwrap_or_else(|e| panic!("{version} {compress}: {e}")); - check_pages(&d, version); - check_shapes(&d, version); - } - } -} - -#[test] -fn versions_3_and_4_read_their_sample() { - for version in [300, 400] { - let file = synth::sample(version, false); - assert_eq!(&file[8..12], if version == 300 { b"CDR " } else { b"CDR4" }); - assert!(vectorcraft_cdr::is_cdr(&file)); - let d = read(&file, Limits::default()).unwrap_or_else(|e| panic!("{version}: {e}")); - assert!(!d.warnings.contains(&Warning::Damaged), "{version}: {:?}", d.warnings); - check_pages(&d, version); - check_shapes(&d, version); - let s = shapes(&d.pages[0].layers[0].objects); - let o = s[0].outline.as_ref().unwrap(); - assert_eq!((o.join, &o.color), (Join::Round, &Color::Cmyk([0.0, 0.0, 0.0, 1.0])), "{version}"); - // The ellipse 50 pt right of and below the page centre, and the curve where it was drawn. - assert!((s[1].matrix.0[4] - 50.0).abs() < 0.1 && (s[1].matrix.0[5] + 50.0).abs() < 0.1, "{version}: {:?}", s[1].matrix); - assert_eq!(s[2].matrix, Matrix::IDENTITY, "{version}"); - } - // The form type alone names version 3, and a `vrsn` chunk names it under another form type. - let mut plain = vec![]; - plain.extend(synth::sample_content(300)); - check_shapes(&read(&synth::riff(300, &plain), Limits::default()).unwrap(), 300); - let mut relabeled = synth::sample(300, false); - relabeled[11] = b'5'; - assert_eq!(read(&relabeled, Limits::default()).unwrap().version, 300); -} - -/// A version 3 drawing of one layer holding `objects`. -fn drawing3(objects: Vec) -> Vec { - let page = synth::page(false, vec![synth::layer(V(300), [0, 0, 0, 0x98], "L", objects)]); - synth::riff(300, &[chunk(b"vrsn", 300u16.to_le_bytes().to_vec()), page]) -} - -/// A version 3 rectangle of 10 × 10 pt with the transforms `matrices`. -fn rect3(matrices: &[[f64; 6]]) -> synth::Node { - let v = V(300); - let mut args = vec![(30, v.rect(10.0, 10.0, 0.0))]; - if !matrices.is_empty() { - args.push((100, synth::transforms3(matrices))); - } - synth::object(v, 1, &args, None) -} - -#[test] -fn version_3_groups_place_their_objects() { - let shift = |x: f64, y: f64| [1.0, 0.0, 0.0, 1.0, x, y]; - let double = [2.0, 0.0, 0.0, 2.0, 0.0, 0.0]; - // A rectangle moved 72 pt right, in a group that doubles sizes, in a group that moves 36 pt - // up; beside the inner group, a rectangle of the outer group alone; then one outside both. - let inner = synth::group3(&[double], vec![rect3(&[shift(72.0, 0.0)])]); - let outer = synth::group3(&[shift(0.0, 36.0)], vec![inner, rect3(&[])]); - let d = read(&drawing3(vec![outer, rect3(&[shift(7.2, 0.0)])]), Limits::default()).unwrap(); - assert!(d.warnings.is_empty(), "{:?}", d.warnings); - let objects = &d.pages[0].layers[0].objects; - assert!( - matches!(&objects[0], Object::Group { objects: g, .. } if matches!(&g[0], Object::Group { objects: i, .. } if i.len() == 1) && g.len() == 2) - ); - let s = shapes(objects); - let close = |m: &Matrix, want: [f64; 6]| m.0.iter().zip(want).all(|(a, b)| (a - b).abs() < 0.01); - // Its own shift, then the inner group's scale, then the outer group's shift. - assert!(close(&s[0].matrix, [2.0, 0.0, 0.0, 2.0, 144.0, 36.0]), "{:?}", s[0].matrix); - assert!(close(&s[1].matrix, [1.0, 0.0, 0.0, 1.0, 0.0, 36.0]), "{:?}", s[1].matrix); - assert!(close(&s[2].matrix, [1.0, 0.0, 0.0, 1.0, 7.2, 0.0]), "{:?}", s[2].matrix); - // Two matrices of one object apply in file order. - let d = read(&drawing3(vec![rect3(&[shift(72.0, 0.0), double])]), Limits::default()).unwrap(); - assert!(close(&shapes(&d.pages[0].layers[0].objects)[0].matrix, [2.0, 0.0, 0.0, 2.0, 144.0, 0.0])); -} - -#[test] -fn version_3_objects_and_groups_under_an_envelope_keep_their_outlines_and_matrices() { - // A transforms argument of one envelope entry (type 0x14). - let mut envelope = vec![0, 0, 1, 0, 0x14, 0]; - envelope.resize(14 + 24, 0); - // A matrix that moves 72 pt right, then an envelope entry whose data follows the matrix's. - let matrix = synth::transforms3(&[[1.0, 0.0, 0.0, 1.0, 72.0, 0.0]]).split_off(14); - let mut shifted = vec![0, 0, 2, 0, 0x8c, 0, 0, 0, 0, 0, 24, 0, 0, 0, 0x14, 0, 0, 0, 0, 0, 48, 0, 0, 0]; - shifted.extend(matrix); - shifted.resize(48 + 24, 0); - let v = V(300); - let bent = synth::object(v, 1, &[(30, v.rect(10.0, 10.0, 0.0)), (100, envelope.clone())], None); - let moved = synth::object(v, 1, &[(30, v.rect(10.0, 10.0, 0.0)), (100, shifted)], None); - let group = list(b"grp ", vec![chunk(b"lobj", v.loda(0, &[(100, envelope)])), rect3(&[])]); - let d = read(&drawing3(vec![bent, moved, group, rect3(&[])]), Limits::default()).unwrap(); - let objects = &d.pages[0].layers[0].objects; - assert_eq!(objects.len(), 4); - assert!(matches!(&objects[2], Object::Group { objects: g, .. } if g.len() == 1)); - let s = shapes(objects); - assert_eq!(s.len(), 4); - assert!(matches!(s[0].geometry, Geometry::Rect { .. }) && s[0].matrix == Matrix::IDENTITY); - assert!((s[1].matrix.0[4] - 72.0).abs() < 0.01 && s[1].matrix.0[5].abs() < 0.01, "{:?}", s[1].matrix); - assert_eq!(s[2].matrix, Matrix::IDENTITY); - assert_eq!(d.warnings, vec![Warning::Envelopes]); -} - -#[test] -fn version_3_object_types_count_from_0() { - let v = V(300); - // `lobj` records written with their stored types: 0 rectangle, 2 curve, 3 text, 4 bitmap. - let raw = |kind: u32, coords: Vec| list(b"obj ", vec![chunk(b"lobj", v.loda(kind, &[(30, coords)]))]); - let curve = v.points(&[(0.0, 0.0, 0x00), (10.0, 0.0, 0x40)]); - let ellipse = [v.coord(40.0), v.coord(20.0), v.angle(0.0), v.angle(0.0), v.word(0)].concat(); - let d = read( - &drawing3(vec![raw(0, v.rect(10.0, 10.0, 0.0)), raw(1, ellipse), raw(2, curve), raw(3, vec![0; 8]), raw(4, vec![0; 8])]), - Limits::default(), - ) - .unwrap(); - let s = shapes(&d.pages[0].layers[0].objects); - assert_eq!(s.len(), 3); - assert!(matches!(s[0].geometry, Geometry::Rect { .. }) && matches!(s[1].geometry, Geometry::Ellipse { .. })); - assert!(matches!(&s[2].geometry, Geometry::Path(p) if p.subpaths.len() == 1)); - assert_eq!(d.warnings, vec![Warning::UnsupportedObjects]); -} - -#[test] -fn version_3_fills_and_outlines_read_from_the_object() { - let v = V(300); - let styled = |fill: Vec, outline: Vec| synth::object(v, 1, &[(20, fill), (10, outline), (30, v.rect(10.0, 10.0, 0.0))], None); - let pen = |line_type: u16| synth::Pen { line_type, width: 3.0, cap: 2, join: 2 }; - let black = synth::color3(1, [0, 0, 0, 100]); - let d = read( - &drawing3(vec![ - styled(synth::fill3(1, &synth::color3(0, [0, 0, 40, 0])), synth::outline3(pen(0), black, &[3, 1])), - styled(synth::fill3(1, &synth::color3(0, [1, 0, 100, 0])), synth::outline3(pen(1), black, &[])), - styled(synth::fill3(0, &[]), synth::outline3(pen(0), synth::color3(0, [200, 0, 80, 0]), &[])), - ]), - Limits::default(), - ) - .unwrap(); - let s = shapes(&d.pages[0].layers[0].objects); - // Ink 0 is black at its tint, ink 1 white, and another number a library ink. - assert_eq!((s[0].fill.clone(), s[1].fill.clone(), s[2].fill.clone()), (Some(Color::Gray(0.4)), Some(Color::Gray(0.0)), None)); - let o = s[0].outline.as_ref().unwrap(); - assert!((o.width - 3.0).abs() < 0.05, "{}", o.width); - assert_eq!((o.cap, o.join, &o.dashes), (Cap::Square, Join::Bevel, &vec![3.0, 1.0])); - assert!(s[1].outline.is_none()); - assert_eq!(s[2].outline.as_ref().unwrap().color, Color::Spot { name: "Spot 0:200".into(), tint: 0.8, look: None }); - assert_eq!(d.warnings, vec![Warning::SpotLooks]); - // Fountain, texture and pattern fills are named and leave the shape unfilled; a fill or an - // outline cut short is damage. - for kind in [2, 4, 6, 7, 10] { - let d = read(&drawing3(vec![styled(synth::fill3(kind, &[0; 12]), synth::outline3(pen(1), black, &[]))]), Limits::default()).unwrap(); - assert_eq!(d.warnings, vec![Warning::UnsupportedFills], "{kind}"); - assert!(shapes(&d.pages[0].layers[0].objects)[0].fill.is_none()); - } - let d = read(&drawing3(vec![styled(vec![1, 1], vec![1, 0])]), Limits::default()).unwrap(); - let s = shapes(&d.pages[0].layers[0].objects); - assert!(s[0].fill.is_none() && s[0].outline.is_none()); - assert_eq!(d.warnings, vec![Warning::Damaged]); -} - -#[test] -fn version_3_dashes_count_toward_the_dash_limit() { - let v = V(300); - let pen = synth::Pen { line_type: 0, width: 1.0, cap: 0, join: 0 }; - let dashed = - || synth::object(v, 1, &[(10, synth::outline3(pen, synth::color3(1, [0, 0, 0, 100]), &[2, 2, 2])), (30, v.rect(10.0, 10.0, 0.0))], None); - let d = read(&drawing3(vec![dashed(), dashed()]), Limits { dashes: 4, ..Limits::default() }).unwrap(); - let s = shapes(&d.pages[0].layers[0].objects); - assert_eq!((s[0].outline.as_ref().unwrap().dashes.len(), s[1].outline.as_ref().unwrap().dashes.len()), (3, 0)); - assert_eq!(d.warnings, vec![Warning::TooDeep]); -} - -#[test] -fn hostile_version_3_transforms_are_damage() { - let v = V(300); - let with = |arg: Vec| synth::object(v, 1, &[(30, v.rect(10.0, 10.0, 0.0)), (100, arg)], None); - // A matrix whose data offset lies past the argument, and an argument cut inside its header. - let mut past = synth::transforms3(&[[1.0, 0.0, 0.0, 1.0, 5.0, 5.0]]); - past[10..12].copy_from_slice(&60000u16.to_le_bytes()); - for arg in [past, vec![0, 0, 9]] { - let d = read(&drawing3(vec![with(arg)]), Limits::default()).unwrap(); - let s = shapes(&d.pages[0].layers[0].objects); - assert_eq!(s[0].matrix, Matrix::IDENTITY); - assert_eq!(d.warnings, vec![Warning::Damaged]); - } - // A count of 65,535 over one entry reads that entry. - let mut many = synth::transforms3(&[[1.0, 0.0, 0.0, 1.0, 72.0, 0.0]]); - many[2..4].copy_from_slice(&u16::MAX.to_le_bytes()); - let d = read(&drawing3(vec![with(many)]), Limits::default()).unwrap(); - assert!((shapes(&d.pages[0].layers[0].objects)[0].matrix.0[4] - 72.0).abs() < 0.01); - assert_eq!(d.warnings, vec![Warning::Damaged]); -} - -#[test] -fn version_4_transforms_are_fixed_point_and_compose_in_file_order() { - let v = V(400); - let own = vec![ - chunk(b"loda", v.loda(1, &[(30, v.rect(10.0, 10.0, 0.0))])), - list(b"trfl", vec![chunk(b"trfd", v.trfd(&[[1.0, 0.0, 0.0, 1.0, 72.0, 0.0], [0.0, 2.0, -2.0, 0.0, 0.0, 0.0]]))]), - ]; - let object = list(b"obj ", vec![list(b"lgob", own)]); - let page = synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![object])]); - let d = read(&synth::riff(400, &[chunk(b"vrsn", 400u16.to_le_bytes().to_vec()), page]), Limits::default()).unwrap(); - assert!(d.warnings.is_empty(), "{:?}", d.warnings); - // Moved 72 pt right, then turned a quarter and doubled: (0, 0) lands at (0, 144). - let m = shapes(&d.pages[0].layers[0].objects)[0].matrix; - assert!(m.0.iter().zip([0.0, 2.0, -2.0, 0.0, 0.0, 144.0]).all(|(a, b)| (a - b).abs() < 0.01), "{m:?}"); -} - -#[test] -fn version_4_colors_are_words() { - let v = V(400); - let file = |fill: [u8; 12]| { - let doc = list(b"doc ", vec![list(b"filt", vec![chunk(b"fill", v.fill(1, &fill))])]); - let rect = synth::object(v, 1, &[(20, 1u32.to_le_bytes().to_vec()), (30, v.rect(10.0, 10.0, 0.0))], None); - let page = synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![rect])]); - synth::riff(400, &[chunk(b"vrsn", 400u16.to_le_bytes().to_vec()), doc, page]) - }; - let fill_of = |fill: [u8; 12]| { - let d = read(&file(fill), Limits::default()).unwrap(); - (shapes(&d.pages[0].layers[0].objects)[0].fill.clone(), d.warnings) - }; - assert_eq!(fill_of(synth::color4(1, [20, 40, 60, 80])), (Some(Color::Cmyk([0.2, 0.4, 0.6, 0.8])), vec![])); - assert_eq!(fill_of(synth::color4(0, [0, 30, 0, 0])), (Some(Color::Gray(0.3)), vec![])); - assert_eq!(fill_of(synth::color4(0, [1, 30, 0, 0])), (Some(Color::Gray(0.0)), vec![])); - assert_eq!( - fill_of(synth::color4(0, [513, 30, 0, 0])), - (Some(Color::Spot { name: "Spot 0:513".into(), tint: 0.3, look: None }), vec![Warning::SpotLooks]) - ); - // The version 5 record read in the version 4 layout would take these values from other bytes. - assert_ne!(fill_of(synth::color(2, [20, 40, 60, 80])).0, Some(Color::Cmyk([0.2, 0.4, 0.6, 0.8]))); -} - -#[test] -fn the_version_3_page_size_is_the_distance_between_its_corners() { - let v = V(300); - for corners in [[-306.0, 396.0, 306.0, -396.0], [306.0, -396.0, -306.0, 396.0]] { - let mut b = vec![0xff; 2]; - b.extend(corners.iter().flat_map(|c| v.coord(*c))); - let d = read(&synth::riff(300, &[list(b"doc ", vec![chunk(b"mcfg", b)])]), Limits::default()).unwrap(); - let (w, h) = d.page_size.unwrap(); - assert!((w - 612.0).abs() < 0.1 && (h - 792.0).abs() < 0.1, "{w} {h}"); - } - // Corners that give no width, and a chunk cut inside them, give no page size. - let mut flat = vec![0; 2]; - flat.extend([v.coord(10.0), v.coord(5.0), v.coord(10.0), v.coord(-5.0)].concat()); - for b in [flat.clone(), flat[..9].to_vec()] { - assert_eq!(read(&synth::riff(300, &[list(b"doc ", vec![chunk(b"mcfg", b)])]), Limits::default()).unwrap().page_size, None); - } -} - -#[test] -fn a_point_list_before_version_6_counts_its_points_with_a_u16() { - for version in [300, 400, 500] { - let v = V(version); - let mut points = v.points(&[(0.0, 0.0, 0x00), (10.0, 0.0, 0x40), (10.0, 10.0, 0x40)]); - // The u16 after the count is 1 in some curves; as part of a u32 count it would run the - // count past the points. - points[2] = 1; - let page = synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![synth::object(v, 3, &[(30, points)], None)])]); - let d = read(&synth::riff(version, &[chunk(b"vrsn", version.to_le_bytes().to_vec()), page]), Limits::default()).unwrap(); - assert!(d.warnings.is_empty(), "{version}: {:?}", d.warnings); - let s = shapes(&d.pages[0].layers[0].objects); - assert!(matches!(&s[0].geometry, Geometry::Path(p) if p.subpaths[0].segments.len() == 2), "{version}"); - } -} - -/// The objects of the one layer of a version 1 or 2 drawing. -fn wl_objects(d: &vectorcraft_cdr::Drawing) -> &[Object] { - assert_eq!((d.pages.len(), d.pages[0].layers.len(), d.master.len(), d.guides.len()), (1, 1, 0, 0)); - &d.pages[0].layers[0].objects -} - -#[test] -fn versions_1_and_2_read_their_sample() { - for (marker, version) in [(b'e', 100), (b'l', 200), (b'm', 200)] { - let file = synth::wl_sample(marker); - assert!(file.starts_with(b"WL") && vectorcraft_cdr::is_cdr(&file)); - let d = read(&file, Limits::default()).unwrap(); - assert_eq!(d.version, version); - let (w, h) = d.page_size.unwrap(); - assert!((w - 612.0).abs() < 0.1 && (h - 792.0).abs() < 0.1, "{w} {h}"); - // The text is left out, and the group record holds nothing. - assert_eq!(d.warnings, vec![Warning::UnsupportedObjects]); - let s = shapes(wl_objects(&d)); - assert_eq!(s.len(), 3); - // Front to back: the rounded rectangle, the ellipse, the curve. - assert!( - matches!(s[0].geometry, Geometry::Rect { w, h, radii } if (w - 100.0).abs() < 0.1 && (h - 50.0).abs() < 0.1 && radii.iter().all(|r| (r - 5.0).abs() < 0.1)) - ); - assert_eq!(s[0].fill, Some(Color::Cmyk([0.0, 1.0, 1.0, 0.0]))); - let o = s[0].outline.as_ref().unwrap(); - assert!((o.width - 2.0).abs() < 0.05, "{}", o.width); - assert_eq!((&o.color, o.cap, o.join, o.dashes.len()), (&Color::Cmyk([0.0, 0.0, 0.0, 1.0]), Cap::Butt, Join::Miter, 0)); - assert!((s[0].matrix.0[4] + 100.0).abs() < 0.1 && (s[0].matrix.0[5] - 100.0).abs() < 0.1, "{:?}", s[0].matrix); - assert!(matches!(s[1].geometry, Geometry::Ellipse { w, h } if (w - 40.0).abs() < 0.1 && (h + 40.0).abs() < 0.1)); - assert!(s[1].outline.is_none() && (s[1].matrix.0[4] - 50.0).abs() < 0.1 && (s[1].matrix.0[5] + 50.0).abs() < 0.1); - assert!(matches!(&s[2].geometry, Geometry::Path(p) if p.subpaths[0].closed && matches!(p.subpaths[0].segments[1], Segment::Cubic(..)))); - assert!(s[2].fill.is_none() && s[2].outline.is_some()); - assert_eq!(&s[2].matrix.0[..4], &[2.0, 0.0, 0.0, 2.0]); - } -} - -#[test] -fn a_version_1_matrix_and_point_place_the_shape() { - use synth::WlShape; - // x' = 0 x - 1 y + 72 and y' = 1 x + 0 y + 36: a quarter turn, then a shift. - let turned = synth::wl_object(WlShape::Rect { w: 10.0, h: 10.0, radius: 0.0 }, [0.0, 1.0, -1.0, 0.0, 72.0, 36.0], None, None); - let d = read(&synth::wl_file(b'e', (612.0, 792.0), &[turned]), Limits::default()).unwrap(); - let m = shapes(wl_objects(&d))[0].matrix; - assert!(m.0.iter().zip([0.0, 1.0, -1.0, 0.0, 72.0, 36.0]).all(|(a, b)| (a - b).abs() < 0.01), "{m:?}"); - let at = m.apply(vectorcraft_cdr::model::Pt { x: 10.0, y: 0.0 }); - assert!((at.x - 72.0).abs() < 0.01 && (at.y - 46.0).abs() < 0.01, "{at:?}"); -} - -#[test] -fn version_1_arcs_and_text_are_left_out_with_a_warning() { - use synth::WlShape; - let unit = [1.0, 0.0, 0.0, 1.0, 0.0, 0.0]; - let arc = synth::wl_object(WlShape::Ellipse { w: 40.0, h: 40.0, angles: (0, 900) }, unit, None, None); - let whole = synth::wl_object(WlShape::Ellipse { w: 40.0, h: 40.0, angles: (900, 900) }, unit, None, None); - let mut other = synth::wl_object(WlShape::Text, unit, None, None); - other[60] = 9; - for (records, kept) in [(vec![arc], 0), (vec![whole], 1), (vec![synth::wl_object(WlShape::Text, unit, None, None)], 0), (vec![other], 0)] { - let d = read(&synth::wl_file(b'e', (612.0, 792.0), &records), Limits::default()).unwrap(); - assert_eq!(wl_objects(&d).len(), kept); - assert_eq!(d.warnings.contains(&Warning::UnsupportedObjects), kept == 0); - assert!(!d.warnings.contains(&Warning::Damaged)); - } -} - -#[test] -fn hostile_version_1_files_stop_within_their_bytes_and_limits() { - use synth::WlShape; - let unit = [1.0, 0.0, 0.0, 1.0, 0.0, 0.0]; - let rect = || synth::wl_object(WlShape::Rect { w: 10.0, h: 10.0, radius: 0.0 }, unit, None, None); - let file = synth::wl_sample(b'e'); - // Cut at every length: an error, or what the bytes still hold. - for len in 0..file.len() { - let _ = read(&file[..len], Limits::default()); - } - // A body size that runs past the records' end. - let mut long = rect(); - long[28..30].copy_from_slice(&u16::MAX.to_le_bytes()); - let d = read(&synth::wl_file(b'e', (612.0, 792.0), &[rect(), long]), Limits::default()).unwrap(); - assert_eq!((wl_objects(&d).len(), d.warnings.clone()), (1, vec![Warning::Damaged])); - // A point count larger than the record holds reads the points that fit. - let mut curve = synth::wl_object(WlShape::Curve(vec![(0.0, 0.0, 0x00), (10.0, 0.0, 0x40), (10.0, 10.0, 0x40)]), unit, None, None); - curve[114..116].copy_from_slice(&u16::MAX.to_le_bytes()); - let d = read(&synth::wl_file(b'e', (612.0, 792.0), &[curve.clone()]), Limits::default()).unwrap(); - assert_eq!((wl_objects(&d).len(), d.warnings.clone()), (1, vec![Warning::Damaged])); - // Points past the coordinate limit leave the curve out. - curve[114..116].copy_from_slice(&3u16.to_le_bytes()); - let d = read(&synth::wl_file(b'e', (612.0, 792.0), &[curve]), Limits { coordinates: 2, ..Limits::default() }).unwrap(); - assert_eq!(wl_objects(&d).len(), 0); - assert_eq!(d.warnings, vec![Warning::TooDeep]); - // Objects past the object limit are left out, and records past the chunk limit stop the read. - let many: Vec> = (0..10).map(|_| rect()).collect(); - let d = read(&synth::wl_file(b'e', (612.0, 792.0), &many), Limits { objects: 4, ..Limits::default() }).unwrap(); - assert_eq!((wl_objects(&d).len(), d.warnings.clone()), (4, vec![Warning::TooDeep])); - let groups: Vec> = (0..10).map(|_| synth::wl_group()).collect(); - assert_eq!(read(&synth::wl_file(b'e', (612.0, 792.0), &groups), Limits { chunks: 4, ..Limits::default() }), Err(Error::Limit("chunk count"))); - assert_eq!(read(&file, Limits { input: file.len() - 1, ..Limits::default() }), Err(Error::Limit("input size"))); - // Bytes left after the last whole record are damage. - let mut ragged = vec![rect()]; - ragged.push(vec![0; 5]); - let d = read(&synth::wl_file(b'e', (612.0, 792.0), &ragged), Limits::default()).unwrap(); - assert_eq!((wl_objects(&d).len(), d.warnings.clone()), (1, vec![Warning::Damaged])); -} - -#[test] -fn a_wl_prefix_alone_is_not_a_drawing() { - for bytes in [ - &b"WL"[..], - b"WLe\0", - b"WLAN settings, exported as plain text for the help desk", - // Records that start inside the header, and a marker and a fourth byte no source gives. - b"WLe\0\x1c\0\0\0\x10\0\0\0\x1c\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", - b"WLAN\x1c\0\0\0\x1c\0\0\0\x1c\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", - ] { - assert!(!vectorcraft_cdr::is_cdr(bytes)); - assert_eq!(read(bytes, Limits::default()), Err(Error::NotCdr)); - } -} - -#[test] -fn versions_outside_1_to_27_and_other_files_are_refused() { - // No source shows a RIFF file of version 1 or 2: those versions are `WL` files. - for version in [100, 200] { - let refused = read(&synth::riff(version, &[]), Limits::default()).unwrap_err(); - assert_eq!(refused, Error::Unsupported("RIFF files of versions before 3"), "{version}"); - assert_eq!(refused.to_string(), "RIFF files of versions before 3 are not read"); - } - assert_eq!(read(&synth::riff(2800, &[]), Limits::default()), Err(Error::Version(2800))); - assert_eq!(read(b"RIFF\x04\0\0\0WAVE", Limits::default()), Err(Error::NotCdr)); - assert_eq!(read(b"RIFF\x04\0\0\0CDRX", Limits::default()), Err(Error::NotCdr)); - assert!(!vectorcraft_cdr::is_cdr(b"PK\x03\x04")); - assert!(vectorcraft_cdr::is_cdr(&synth::sample(1100, true))); -} - -#[test] -fn letters_that_count_differently_take_the_vrsn_version() { - // Version 27 saves the letter `U`, which counts as 29 the older way; the next letter with a - // `vrsn` of 2800 is refused as version 28. - let mut file = synth::sample(2700, false); - file[11] = b'U'; - let d = read(&file, Limits::default()).unwrap(); - check_pages(&d, 2700); - check_shapes(&d, 2700); - let mut file = synth::riff(2800, &[chunk(b"vrsn", 2800u16.to_le_bytes().to_vec())]); - file[11] = b'V'; - assert_eq!(read(&file, Limits::default()), Err(Error::Version(2800))); -} - -#[test] -fn every_version_from_14_to_27_reads_its_package() { - for version in [1400, 1500, 1600, 1700, 1800, 2000, 2200, 2400, 2430, 2600, 2700] { - for compress in [false, true] { - let file = synth::sample_file(version, compress); - assert!(file.starts_with(b"PK\x03\x04") && vectorcraft_cdr::is_cdr(&file), "{version}"); - let d = read(&file, Limits::default()).unwrap_or_else(|e| panic!("{version} {compress}: {e}")); - assert!(!d.warnings.contains(&Warning::Damaged), "{version} {compress}: {:?}", d.warnings); - check_pages(&d, version); - check_shapes(&d, version); - } - } -} - -/// The version 17 sample's content with `extra` added after it, as a package. -fn package17(extra: Vec, members: &[synth::Member]) -> Vec { - let mut body = vec![chunk(b"vrsn", 1700u16.to_le_bytes().to_vec())]; - body.extend(synth::sample_content(1700)); - body.extend(extra); - synth::package16(1700, &body, true, members) -} - -#[test] -fn lists_whose_bodies_move_to_a_data_stream_read_the_same() { - let mut body = vec![chunk(b"vrsn", 1700u16.to_le_bytes().to_vec())]; - body.extend(synth::sample_content(1700)); - for moved in [*b"layr", *b"obj ", *b"page"] { - let file = synth::package16_with(1700, &body, true, &[], &[moved]); - let d = read(&file, Limits::default()).unwrap(); - assert!(!d.warnings.contains(&Warning::Damaged), "{moved:?}: {:?}", d.warnings); - check_pages(&d, 1700); - check_shapes(&d, 1700); - } -} - -#[test] -fn a_data_stream_no_chunk_reads_is_not_inflated() { - // 32 MiB of picture data that the reader doesn't use, in a stream of its own. - let bitmaps = list(b"bmpt", vec![chunk(b"bmp ", vec![0; 32 << 20])]); - let file = package17(vec![bitmaps], &[]); - assert!(file.len() < 1 << 20); - let d = read(&file, Limits { inflated: 4 << 20, ..Limits::default() }).unwrap(); - assert_eq!(d.warnings, vec![Warning::UnsupportedObjects]); - check_shapes(&d, 1700); -} - -#[test] -fn a_redirected_list_is_inflated_and_counts_toward_the_limit() { - // A list whose body is in a stream must be inflated to be split; past the limit it is left - // out with a warning, and the rest of the drawing reads. - let mut body = vec![chunk(b"vrsn", 1700u16.to_le_bytes().to_vec())]; - body.extend(synth::sample_content(1700)); - body.push(list(b"bmpt", vec![chunk(b"bmp ", vec![0; 32 << 20])])); - let file = synth::package16_with(1700, &body, true, &[], &[*b"bmpt"]); - let d = read(&file, Limits { inflated: 4 << 20, ..Limits::default() }).unwrap(); - assert!(d.warnings.contains(&Warning::TooDeep) && !d.warnings.contains(&Warning::Damaged), "{:?}", d.warnings); - check_shapes(&d, 1700); - let d = read(&file, Limits::default()).unwrap(); - assert!(!d.warnings.contains(&Warning::TooDeep)); -} - -#[test] -fn chunks_in_a_data_stream_past_a_limit_are_not_damage() { - // A record and a list in a 2 MiB stream, read with a 1 MiB member limit, stored and deflated - // with a 1 MiB inflate limit: only the limit warning. - let mcfg = synth::mcfg(V(1700), 300.0, 200.0); - let synth::Node::Chunk(_, mcfg) = mcfg else { panic!() }; - let n = mcfg.len() as u32; - let mut stream = mcfg.clone(); - stream.resize(2 << 20, 0); - stream[(1 << 20)..(1 << 20) + 4].copy_from_slice(b"fntt"); - let mut root = b"RIFF".to_vec(); - let body = doc_of(&[redirect(b"mcfg", 0, n, 0), redirect(b"LIST", 0, 4, 1 << 20)]); - root.extend(((body.len() + 4) as u32).to_le_bytes()); - root.extend(b"CDRH"); - root.extend(body); - let m = |name: &str, data: Vec, deflate: bool| synth::Member { name: name.into(), data, deflate }; - for (deflate, limits) in [(false, Limits { member: 1 << 20, ..Limits::default() }), (true, Limits { inflated: 1 << 20, ..Limits::default() })] { - let file = synth::zip( - &[ - m("content/root.dat", root.clone(), false), - m("content/dataFileList.dat", b"data1.dat".to_vec(), false), - m("content/data/data1.dat", stream.clone(), deflate), - ], - b"", - ); - let d = read(&file, limits).unwrap(); - assert_eq!(d.warnings, vec![Warning::TooDeep], "{deflate}"); - assert!(d.page_size.is_none()); - let d = read(&file, Limits::default()).unwrap(); - assert!(d.page_size.is_some() && d.warnings.is_empty(), "{deflate}: {:?}", d.warnings); - } -} - -#[test] -fn encrypted_data_streams_and_other_methods_are_refused() { - let good = synth::sample_file(1700, false); - assert!(read(&good, Limits::default()).is_ok()); - // The directory entry of a data stream: its name's last place, 46 bytes after the entry start. - let name = b"content/data/data1.dat"; - let entry = good.windows(name.len()).rposition(|w| w == name).unwrap() - 46; - assert_eq!(&good[entry..entry + 4], b"PK\x01\x02"); - let mut encrypted = good.clone(); - encrypted[entry + 8] |= 1; - assert_eq!(read(&encrypted, Limits::default()), Err(Error::Unsupported("encrypted packages"))); - let mut other = good.clone(); - other[entry + 10] = 12; - assert_eq!(read(&other, Limits::default()), Err(Error::Unsupported("package compression methods other than storing and deflate"))); -} - -/// A version 17 package whose `root.dat` is `root` (the RIFF body after the form type) and whose -/// one data stream is `stream`. -fn raw_package(root: &[u8], stream: &[u8], list: &[u8]) -> Vec { - let mut riff = b"RIFF".to_vec(); - riff.extend(((root.len() + 4) as u32).to_le_bytes()); - riff.extend(b"CDRH"); - riff.extend(root); - let m = |name: &str, data: &[u8]| synth::Member { name: name.into(), data: data.to_vec(), deflate: false }; - synth::zip(&[m("content/root.dat", &riff), m("content/dataFileList.dat", list), m("content/data/data1.dat", stream)], b"") -} - -/// A chunk header for a redirect record of `stream`, `len` and `offset`. -fn redirect(id: &[u8; 4], stream: u32, len: u32, offset: u32) -> Vec { - let mut out = id.to_vec(); - out.extend(16u32.to_le_bytes()); - for v in [stream, len, offset, 0] { - out.extend(v.to_le_bytes()); - } - out -} - -#[test] -fn a_list_redirected_into_its_own_bytes_is_read_once() { - // The stream holds a `grp ` body whose children are lists redirected to that body again: - // the bytes are taken, so each child is damage and the list is read once. - for children in [1, 2] { - let len = 4 + 24 * children; - let mut stream = b"grp ".to_vec(); - for _ in 0..children { - stream.extend(redirect(b"LIST", 0, len, 0)); - } - let file = raw_package(&redirect(b"LIST", 0, len, 0), &stream, b"data1.dat"); - let d = read(&file, Limits { chunks: 100, ..Limits::default() }).unwrap(); - assert_eq!(d.warnings, vec![Warning::Damaged], "{children}"); - } -} - -/// A `doc ` list holding `records`, as `root.dat`'s body. -fn doc_of(records: &[Vec]) -> Vec { - let records = records.concat(); - let mut body = b"LIST".to_vec(); - body.extend(((records.len() + 4) as u32).to_le_bytes()); - body.extend(b"doc "); - body.extend(records); - body -} - -#[test] -fn records_share_bytes_within_the_member_limit() { - let mcfg = synth::mcfg(V(1700), 300.0, 200.0); - let synth::Node::Chunk(_, mcfg) = mcfg else { panic!() }; - let n = mcfg.len() as u32; - let mut stream = mcfg.clone(); - stream.extend(&mcfg); - // The same bytes, bytes that overlap them, bytes that only touch them, and the same bytes - // through a second line naming the same member: both redirects read. - for (second, list) in [ - (redirect(b"mcfg", 0, n, 0), &b"data1.dat"[..]), - (redirect(b"mcfg", 0, n, n - 1), b"data1.dat"), - (redirect(b"mcfg", 0, n, n), b"data1.dat"), - (redirect(b"mcfg", 1, n, 0), b"data1.dat\ndata1.dat"), - ] { - let file = raw_package(&doc_of(&[redirect(b"mcfg", 0, n, 0), second.clone()]), &stream, list); - let d = read(&file, Limits::default()).unwrap(); - assert!(d.page_size.is_some() && d.warnings.is_empty(), "{:?}: {:?}", &second[8..], d.warnings); - } - // Bytes read again take from the member limit: with a limit of the stream's 1,024 bytes, a - // record of all of them reads twice, and a third read is left out with the limit warning. - let mut stream = mcfg.clone(); - stream.resize(1024, 0); - let limits = Limits { member: 1024, ..Limits::default() }; - for (reads, warnings) in [(2, vec![]), (3, vec![Warning::TooDeep])] { - let records = vec![redirect(b"mcfg", 0, 1024, 0); reads]; - let d = read(&raw_package(&doc_of(&records), &stream, b"data1.dat"), limits).unwrap(); - assert!(d.page_size.is_some(), "{reads}"); - assert_eq!(d.warnings, warnings, "{reads}"); - } -} - -#[test] -fn a_member_two_streams_name_is_inflated_once() { - // One deflated member of 2 MiB named on two lines, a list read from one and the page size - // from the other: within a 3 MiB inflate limit it is inflated once. - let mcfg = synth::mcfg(V(1700), 300.0, 200.0); - let synth::Node::Chunk(_, mcfg) = mcfg else { panic!() }; - let n = mcfg.len() as u32; - let mut stream = mcfg.clone(); - stream.resize(2 << 20, 0); - stream[(1 << 20)..(1 << 20) + 4].copy_from_slice(b"fntt"); - let mut root = b"RIFF".to_vec(); - let body = doc_of(&[redirect(b"LIST", 1, 4, 1 << 20), redirect(b"mcfg", 0, n, 0)]); - root.extend(((body.len() + 4) as u32).to_le_bytes()); - root.extend(b"CDRH"); - root.extend(body); - let m = |name: &str, data: Vec, deflate: bool| synth::Member { name: name.into(), data, deflate }; - let file = synth::zip( - &[ - m("content/root.dat", root, false), - m("content/dataFileList.dat", b"data1.dat\ndata1.dat".to_vec(), false), - m("content/data/data1.dat", stream, true), - ], - b"", - ); - let d = read(&file, Limits { inflated: 3 << 20, ..Limits::default() }).unwrap(); - assert!(d.page_size.is_some() && d.warnings.is_empty(), "{:?}", d.warnings); -} - -#[test] -fn redirects_past_their_stream_or_to_a_missing_one_are_damage() { - let mcfg = synth::mcfg(V(1700), 300.0, 200.0); - let synth::Node::Chunk(_, mcfg) = mcfg else { panic!() }; - let n = mcfg.len() as u32; - for (root, list, damaged) in [ - (redirect(b"mcfg", 0, n, 0), &b"data1.dat"[..], false), - (redirect(b"mcfg", 0, n, 0), b"data1.dat\r\n", false), - (redirect(b"mcfg", 0, n + 1, 0), b"data1.dat", true), - (redirect(b"mcfg", 0, n, u32::MAX), b"data1.dat", true), - (redirect(b"mcfg", 1, n, 0), b"data1.dat", true), - (redirect(b"mcfg", 0, n, 0), b"gone.dat", true), - (redirect(b"mcfg", 0, n, 0), b"", true), - ] { - let mut body = b"LIST".to_vec(); - body.extend(((root.len() + 4) as u32).to_le_bytes()); - body.extend(b"doc "); - body.extend(&root); - let d = read(&raw_package(&body, &mcfg, list), Limits::default()).unwrap(); - assert_eq!(d.warnings.contains(&Warning::Damaged), damaged, "{list:?} {:?}", &root[8..]); - assert_eq!(d.page_size.is_some(), !damaged); - } -} - -#[test] -fn a_redirect_record_holds_up_to_8_bytes_itself() { - let mut inline = b"vrsn".to_vec(); - inline.extend(16u32.to_le_bytes()); - inline.extend(u32::MAX.to_le_bytes()); - inline.extend(2u32.to_le_bytes()); - inline.extend(1800u16.to_le_bytes()); - inline.extend([0; 6]); - let d = read(&raw_package(&inline, b"", b""), Limits::default()).unwrap(); - assert_eq!(d.version, 1800); - // A length past the record's 8 bytes is damage, and the form type's version stands. - inline[12] = 9; - let d = read(&raw_package(&inline, b"", b""), Limits::default()).unwrap(); - assert!(d.warnings.contains(&Warning::Damaged)); - assert_eq!(d.version, 1700); -} - -fn zip_of(members: &[(&str, Vec)]) -> Vec { - let m: Vec<_> = members.iter().map(|(n, d)| synth::Member { name: (*n).into(), data: d.clone(), deflate: false }).collect(); - synth::zip(&m, b"") -} - -/// Where the first central directory entry starts. -fn directory(bytes: &[u8]) -> usize { - bytes.windows(4).position(|w| w == b"PK\x01\x02").unwrap() -} - -#[test] -fn hostile_packages_are_refused() { - let riff = synth::sample(1400, false); - let good = zip_of(&[("content/riffData.cdr", riff.clone())]); - assert!(read(&good, Limits::default()).is_ok()); - // More members than a read takes. - let many: Vec<(String, Vec)> = (0..4097).map(|i| (format!("m{i}"), vec![])).collect(); - let many: Vec<(&str, Vec)> = many.iter().map(|(n, d)| (n.as_str(), d.clone())).collect(); - assert_eq!(read(&zip_of(&many), Limits::default()), Err(Error::Limit("package member count"))); - assert_eq!(read(&zip_of(&many[..4096]), Limits::default()), Err(Error::NotCdr)); - // A member named twice. - let twice = zip_of(&[("content/riffData.cdr", riff.clone()), ("content/riffData.cdr", riff.clone())]); - assert_eq!(read(&twice, Limits::default()), Err(Error::Damaged("package member named twice"))); - // A member whose bytes run into the next member's header. - let two = zip_of(&[("a", vec![1; 10]), ("content/riffData.cdr", riff.clone())]); - let mut overlap = two.clone(); - let at = directory(&two) + 20; - overlap[at..at + 4].copy_from_slice(&20u32.to_le_bytes()); - assert_eq!(read(&overlap, Limits::default()), Err(Error::Damaged("package members overlap"))); - // A central directory cut short, and an archive without its end record. - let mut short = good.clone(); - let n = short.len(); - let len_at = n - 22 + 12; - let len = u32::from_le_bytes(short[len_at..len_at + 4].try_into().unwrap()); - short[len_at..len_at + 4].copy_from_slice(&(len - 10).to_le_bytes()); - assert_eq!(read(&short, Limits::default()), Err(Error::Damaged("package directory"))); - assert_eq!(read(&good[..directory(&good) + 30], Limits::default()), Err(Error::Damaged("package directory"))); - // Encrypted members, ZIP64 fields and archives split across files. - let mut encrypted = good.clone(); - encrypted[directory(&good) + 8] |= 1; - assert_eq!(read(&encrypted, Limits::default()), Err(Error::Unsupported("encrypted packages"))); - let mut zip64 = good.clone(); - zip64[n - 22 + 10..n - 22 + 12].copy_from_slice(&[0xff, 0xff]); - assert_eq!(read(&zip64, Limits::default()), Err(Error::Unsupported("ZIP64 packages"))); - let mut split = good.clone(); - split[n - 22 + 4] = 1; - assert_eq!(read(&split, Limits::default()), Err(Error::Unsupported("packages split across files"))); -} - -#[test] -fn a_package_member_bomb_stops_at_its_stated_size_or_the_limit() { - let riff = synth::sample(1400, false); - let m = synth::Member { name: "content/riffData.cdr".into(), data: riff.clone(), deflate: true }; - let good = synth::zip(std::slice::from_ref(&m), b""); - assert!(read(&good, Limits::default()).is_ok()); - // A member that inflates past the size its entry states stops one byte past it. - let bomb = synth::zip(&[synth::Member { data: [riff.clone(), vec![0; 64 << 20]].concat(), ..m.clone() }], b""); - assert!(bomb.len() < 1 << 20); - let mut lying = bomb.clone(); - let at = directory(&bomb) + 24; - lying[at..at + 4].copy_from_slice(&(riff.len() as u32).to_le_bytes()); - assert_eq!(read(&lying, Limits::default()), Err(Error::Damaged("package member"))); - // One that states more than a member may hold, or than is left to inflate, is not inflated. - assert_eq!(read(&bomb, Limits { member: 1 << 20, ..Limits::default() }), Err(Error::Limit("package member size"))); - assert_eq!(read(&bomb, Limits { inflated: 1 << 20, ..Limits::default() }), Err(Error::Limit("inflated size"))); -} - -#[test] -fn stored_package_members_take_nothing_from_the_inflate_limit() { - // Nothing may be inflated, and the stored members of either package layout still read, as - // the same drawing does as a plain RIFF file. - let none = Limits { inflated: 0, ..Limits::default() }; - assert!(read(&synth::sample(1400, false), none).is_ok()); - for version in [1400, 1700] { - let d = read(&synth::sample_file(version, false), none).unwrap_or_else(|e| panic!("{version}: {e}")); - assert!(d.warnings.iter().all(|w| *w == Warning::UnsupportedObjects), "{version}: {:?}", d.warnings); - check_shapes(&d, version); - } - // Deflated members do take from it. - assert_eq!(read(&synth::sample_file(1400, true), none), Err(Error::Limit("inflated size"))); -} - -#[test] -fn redirect_records_that_lead_nowhere_count_toward_the_chunk_limit() { - // 3,000 redirects to a stream the package lacks: each lost record is counted. - let root: Vec = (0..3000).flat_map(|_| redirect(b"mcfg", 7, 4, 0)).collect(); - let file = raw_package(&root, b"", b"data1.dat"); - assert_eq!(read(&file, Limits { chunks: 2_000, ..Limits::default() }), Err(Error::Limit("chunk count"))); - let d = read(&file, Limits { chunks: 4_000, ..Limits::default() }).unwrap(); - assert!(d.warnings.contains(&Warning::Damaged), "{:?}", d.warnings); -} - -#[test] -fn rectangles_from_version_15_give_radii_as_shares_of_half_the_shorter_side() { - let v = V(1500); - let mut c = synth::V(1500).rect(100.0, 50.0, 0.0); - // The four shares: 0.2, 0.4, 0, and 3, which half the shorter side holds to 25 pt. - for (k, share) in [0.2f64, 0.4, 0.0, 3.0].iter().enumerate() { - let at = 40 + 24 * k; - c[at..at + 8].copy_from_slice(&share.to_le_bytes()); - } - let file = - synth::riff(1500, &[synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![synth::object(v, 1, &[(30, c.clone())], None)])])]); - let d = read(&file, Limits::default()).unwrap(); - let s = shapes(&d.pages[0].layers[0].objects); - let Geometry::Rect { w, h, radii } = s[0].geometry else { panic!("{:?}", s[0].geometry) }; - assert!((w - 100.0).abs() < 1e-6 && (h - 50.0).abs() < 1e-6); - for (got, want) in radii.iter().zip([5.0, 10.0, 0.0, 25.0]) { - assert!((got - want).abs() < 1e-6, "{radii:?}"); - } - // With the scale-with flag set the radii are inches, held to half the shorter side as well. - c[32] = 1; - let file = synth::riff(1500, &[synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![synth::object(v, 1, &[(30, c)], None)])])]); - let d = read(&file, Limits::default()).unwrap(); - let s = shapes(&d.pages[0].layers[0].objects); - let Geometry::Rect { radii, .. } = s[0].geometry else { panic!("{:?}", s[0].geometry) }; - for (got, want) in radii.iter().zip([14.4, 25.0, 0.0, 25.0]) { - assert!((got - want).abs() < 1e-6, "{radii:?}"); - } -} - -#[test] -fn paths_from_version_10_read_their_points() { - let v = V(1700); - let mut c = vec![0; 4]; - c.extend(2u16.to_le_bytes()); - c.extend(1u16.to_le_bytes()); - c.extend([0; 16]); - c.extend(&v.points(&[(0.0, 0.0, 0x08), (50.0, 0.0, 0x40), (50.0, 20.0, 0x48)])[4..]); - let objects = |version: u16| { - let v = V(version); - synth::riff( - version, - &[synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![synth::object(v, 0x25, &[(30, c.clone())], None)])])], - ) - }; - for version in [1000, 1300, 1500, 1700] { - let d = read(&objects(version), Limits::default()).unwrap(); - let s = shapes(&d.pages[0].layers[0].objects); - let Geometry::Path(p) = &s[0].geometry else { panic!("{version}: {:?}", s[0].geometry) }; - assert_eq!(p.subpaths[0].segments.len(), 2); - assert!(d.warnings.is_empty(), "{version}: {:?}", d.warnings); - } - // No sample before version 10 holds the type, so it is not read as a path there. - let d = read(&objects(900), Limits::default()).unwrap(); - assert!(d.pages[0].layers[0].objects.is_empty() && d.warnings.contains(&Warning::UnsupportedObjects)); -} - -#[test] -fn a_template_takes_its_version_from_the_vrsn_chunk() { - let mut file = synth::sample(2100, false); - file[8..12].copy_from_slice(b"CDTQ"); - assert!(vectorcraft_cdr::is_cdr(&file)); - let d = read(&file, Limits::default()).unwrap(); - assert_eq!(d.version, 2100); - check_shapes(&d, 2100); - let mut bare = synth::riff(2100, &[]); - bare[8..12].copy_from_slice(b"CDTQ"); - assert_eq!(read(&bare, Limits::default()), Err(Error::NotCdr)); - // A template of a version after 27 is refused by its version, and one before 3 as a RIFF - // file of those versions. - for (version, refused) in [(2800u16, Error::Version(2800)), (200, Error::Unsupported("RIFF files of versions before 3"))] { - let mut t = synth::riff(2100, &[chunk(b"vrsn", version.to_le_bytes().to_vec())]); - t[8..12].copy_from_slice(b"CDTQ"); - assert_eq!(read(&t, Limits::default()), Err(refused)); - } -} - -#[test] -fn layers_take_their_kind_from_their_object_type() { - for version in [300, 800, 1300, 1700] { - let v = V(version); - let rect = || synth::object(v, 1, &[(30, v.rect(10.0, 10.0, 0.0))], None); - // Version 3 counts its types from 0 (R32). - let ty = |t: u32| if version < 400 { t - 1 } else { t }; - // Master page layers flagged in the older way, with the types of guides and desktop layers, - // and a drawing layer whose flags would make it a desktop layer. - let master = synth::page( - true, - vec![ - synth::layer_of_type(v, [2, 1, 1, 0x98], ty(12), "G", vec![rect()]), - synth::layer_of_type(v, [0, 1, 1, 0x98], ty(17), "D", vec![rect()]), - synth::layer_of_type(v, [8, 1, 0, 0x98], 0, "M", vec![rect()]), - ], - ); - // A drawing layer with flag bit 0x10 set, and a grid layer. - let own = synth::page( - false, - vec![ - synth::layer_of_type(v, [0x10, 0, 0, 0x98], 0, "L", vec![rect()]), - synth::layer_of_type(v, [0x1a, 0, 1, 0x98], ty(11), "Grid", vec![rect()]), - ], - ); - let body = [chunk(b"vrsn", version.to_le_bytes().to_vec()), master, own]; - let file = if version < 1400 { synth::riff(version, &body) } else { synth::package16(version, &body, true, &[]) }; - let d = read(&file, Limits::default()).unwrap(); - let kinds: Vec<_> = d.master.iter().map(|l| l.kind).collect(); - assert_eq!(kinds, [LayerKind::Guides, LayerKind::Desktop, LayerKind::Drawing], "{version}"); - let kinds: Vec<_> = d.pages[0].layers.iter().map(|l| (l.kind, l.objects.len())).collect(); - assert_eq!(kinds, [(LayerKind::Drawing, 1), (LayerKind::Grid, 1)], "{version}"); - } -} - -#[test] -fn a_lower_case_form_type_names_the_same_versions() { - let mut file = synth::sample(600, false); - file[8..12].copy_from_slice(b"cdr6"); - // The `vrsn` chunk agrees; without it the form type alone decides. - assert_eq!(read(&file, Limits::default()).unwrap().version, 600); - assert!(vectorcraft_cdr::is_cdr(&file)); - file[8..12].copy_from_slice(b"cdrX"); - assert_eq!(read(&file, Limits::default()), Err(Error::NotCdr)); -} - -#[test] -fn rectangles_keep_four_corner_radii_from_version_9() { - let v = V(900); - let c = [v.coord(100.0), v.coord(50.0), v.coord(1.0), v.coord(2.0), v.coord(3.0), v.coord(4.0)].concat(); - let file = synth::riff(900, &[synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![synth::object(v, 1, &[(30, c)], None)])])]); - let d = read(&file, Limits::default()).unwrap(); - let s = shapes(&d.pages[0].layers[0].objects); - let Geometry::Rect { radii, .. } = s[0].geometry else { panic!("{:?}", s[0].geometry) }; - for (got, want) in radii.iter().zip([1.0, 2.0, 3.0, 4.0]) { - assert!((got - want).abs() < 0.01, "{radii:?}"); - } - // Before version 9 one radius rounds every corner. - let v = V(800); - let c = [v.coord(100.0), v.coord(50.0), v.coord(6.0)].concat(); - let file = synth::riff(800, &[synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![synth::object(v, 1, &[(30, c)], None)])])]); - let s = read(&file, Limits::default()).unwrap(); - let s = shapes(&s.pages[0].layers[0].objects); - assert!(matches!(s[0].geometry, Geometry::Rect { radii, .. } if radii.iter().all(|r| (r - 6.0).abs() < 0.01))); -} - -#[test] -fn version_7_guidelines_count_toward_the_object_limit() { - let v = V(700); - let mut guid = 1000u32.to_le_bytes().to_vec(); - guid.extend(1000u32.to_le_bytes()); - for i in 0..1000 { - guid.extend([0; 12]); - guid.extend(90_000_000i32.to_le_bytes()); - guid.extend([v.coord(f64::from(i)), v.coord(0.0), v.coord(f64::from(i)), v.coord(1.0), v.coord(f64::from(i)), v.coord(0.0)].concat()); - } - let file = synth::riff(700, &[chunk(b"vrsn", 700u16.to_le_bytes().to_vec()), list(b"doc ", vec![chunk(b"guid", guid)])]); - let d = read(&file, Limits::default()).unwrap(); - assert_eq!(d.guides.len(), 1000); - let d = read(&file, Limits { objects: 10, ..Limits::default() }).unwrap(); - assert_eq!(d.guides.len(), 10); - assert!(d.warnings.contains(&Warning::TooDeep)); -} - -/// Guidelines on any layer of the master page show on every page, not only those of its guides -/// layer: one on a drawing layer that also holds art, and one alone on the desktop layer. -#[test] -fn master_guidelines_on_any_layer_show_on_every_page() { - let v = V(1100); - let guide = |x: f64| { - let mut g = vec![0; 12]; - g.extend(90_000_000i32.to_le_bytes()); - g.extend([v.coord(x), v.coord(0.0)].concat()); - synth::object(v, 0x16, &[(16000, g)], None) - }; - let rect = synth::object(v, 1, &[(30, [v.coord(1.0), v.coord(1.0), v.coord(0.0), v.coord(0.0), v.coord(0.0), v.coord(0.0)].concat())], None); - let master = synth::page( - true, - vec![synth::layer(v, [0, 0, 1, 0x98], "Art", vec![guide(10.0), rect]), synth::layer(v, [0x08, 0, 1, 0x98], "Desktop", vec![guide(20.0)])], - ); - let file = synth::riff(1100, &[master, synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "Art", vec![])])]); - let d = read(&file, Limits::default()).unwrap(); - let mut xs: Vec = d.guides.iter().map(|g| g.at.x).collect(); - xs.sort_by(f64::total_cmp); - assert_eq!(xs.len(), 2, "{:?}", d.guides); - assert!((xs[0] - 10.0).abs() < 0.01 && (xs[1] - 20.0).abs() < 0.01, "{xs:?}"); - assert_eq!(d.master.len(), 1); - assert_eq!(d.master[0].objects.len(), 1); -} - -/// An object with more arguments than the limit keeps the ones read paired with their own types: -/// the types table runs from the stored count, not from the limit. -#[test] -fn arguments_past_the_limit_leave_the_first_ones_paired_with_their_types() { - let v = V(1100); - let mut args = vec![(30, [v.coord(40.0), v.coord(20.0), v.coord(0.0), v.coord(0.0), v.coord(0.0), v.coord(0.0)].concat())]; - args.extend((0..69).map(|i| (500 + i, vec![0; 4]))); - let file = synth::riff(1100, &[synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![synth::object(v, 1, &args, None)])])]); - let d = read(&file, Limits::default()).unwrap(); - let s = shapes(&d.pages[0].layers[0].objects); - assert!( - matches!(s.first().map(|s| &s.geometry), Some(Geometry::Rect { w, h, .. }) if (w - 40.0).abs() < 0.01 && (h - 20.0).abs() < 0.01), - "{s:?}" - ); - assert!(d.warnings.contains(&Warning::Damaged)); -} - -/// Groups count toward the object limit; a group past it leaves its objects ungrouped. -#[test] -fn groups_count_toward_the_object_limit() { - fn count(objects: &[Object]) -> usize { - objects.iter().map(|o| 1 + if let Object::Group { objects: kids, .. } = o { count(kids) } else { 0 }).sum() - } - let v = V(1100); - let rect = synth::object(v, 1, &[(30, [v.coord(1.0), v.coord(1.0), v.coord(0.0), v.coord(0.0), v.coord(0.0), v.coord(0.0)].concat())], None); - let nested = list(b"grp ", vec![list(b"grp ", vec![rect])]); - let file = synth::riff(1100, &[synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![nested])])]); - let d = read(&file, Limits { objects: 2, ..Limits::default() }).unwrap(); - let objects = &d.pages[0].layers[0].objects; - assert_eq!(count(objects), 2, "{objects:?}"); - assert!(matches!(objects.as_slice(), [Object::Group { objects: kids, .. }] if matches!(kids.as_slice(), [Object::Shape(_)])), "{objects:?}"); - assert!(d.warnings.contains(&Warning::TooDeep)); -} - -/// A rectangle, ellipse, curve or polygon stored without its coordinates is left out as damage. -#[test] -fn shapes_without_their_coordinates_are_damage() { - let v = V(1100); - for kind in [1, 2, 3, 0x14] { - let file = synth::riff(1100, &[synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![synth::object(v, kind, &[], None)])])]); - let d = read(&file, Limits::default()).unwrap(); - assert!(d.pages[0].layers[0].objects.is_empty(), "{kind}"); - assert!(d.warnings.contains(&Warning::Damaged), "{kind}: {:?}", d.warnings); - } -} - -/// An object list without its `loda`, a fill or outline record that can't be read, and a `guid` -/// chunk that counts more guidelines than it holds are each damage. -#[test] -fn unreadable_records_and_lists_are_damage() { - let v = V(1300); - let rect = |args: Vec<(u32, Vec)>| { - let mut args = args; - args.push((30, [v.coord(1.0), v.coord(1.0), v.coord(0.0), v.coord(0.0), v.coord(0.0), v.coord(0.0)].concat())); - synth::object(v, 1, &args, None) - }; - let on_page = |objects: Vec, styles: Vec| { - let mut kids = vec![chunk(b"vrsn", 1300u16.to_le_bytes().to_vec())]; - kids.extend(styles); - kids.push(synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", objects)])); - read(&synth::riff(1300, &kids), Limits::default()).unwrap() - }; - let d = on_page(vec![list(b"obj ", vec![chunk(b"flgs", vec![0, 0, 0, 0x08])])], vec![]); - assert!(d.warnings.contains(&Warning::Damaged), "no loda: {:?}", d.warnings); - // A fill record of only its id. - let d = on_page(vec![rect(vec![(20, 4u32.to_le_bytes().to_vec())])], vec![list(b"filt", vec![chunk(b"fild", 4u32.to_le_bytes().to_vec())])]); - assert_eq!(shapes(&d.pages[0].layers[0].objects)[0].fill, None); - assert!(d.warnings.contains(&Warning::Damaged), "fill: {:?}", d.warnings); - // A tagged outline whose first records are none of record 1. - let mut outl = 9u32.to_le_bytes().to_vec(); - for _ in 0..16 { - outl.extend(5u32.to_le_bytes()); - outl.extend(0u32.to_le_bytes()); - } - let d = on_page(vec![rect(vec![(10, 9u32.to_le_bytes().to_vec())])], vec![list(b"otlt", vec![chunk(b"outl", outl)])]); - assert!(shapes(&d.pages[0].layers[0].objects)[0].outline.is_none()); - assert!(d.warnings.contains(&Warning::Damaged), "outline: {:?}", d.warnings); - // Version 7: a `guid` chunk counting three guidelines and holding one. - let mut guid = 3u32.to_le_bytes().to_vec(); - guid.extend(3u32.to_le_bytes()); - guid.extend([0; 40]); - let d = read(&synth::riff(700, &[chunk(b"vrsn", 700u16.to_le_bytes().to_vec()), list(b"doc ", vec![chunk(b"guid", guid)])]), Limits::default()) - .unwrap(); - assert_eq!(d.guides.len(), 1); - assert!(d.warnings.contains(&Warning::Damaged), "guid: {:?}", d.warnings); -} - -/// Pages keep their layers in a `gobj` list, and layers and objects their `loda` (and objects -/// their transform) in a `lgob` list. The layout with those chunks directly in the page, layer and -/// object lists reads the same. -#[test] -fn layers_and_objects_read_from_their_gobj_and_lgob_lists() { - let v = V(1000); - let c = [v.coord(10.0), v.coord(20.0), v.coord(0.0), v.coord(0.0), v.coord(0.0), v.coord(0.0)].concat(); - let m = [1.0, 0.0, 0.0, 1.0, 5.0, 6.0]; - let nested = synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![synth::object(v, 1, &[(30, c.clone())], Some(m))])]); - let plain_object = list(b"obj ", vec![chunk(b"loda", v.loda(1, &[(30, c)])), list(b"trfl", vec![chunk(b"trfd", v.trfd(&[m]))])]); - let plain_layer = list(b"layr", vec![chunk(b"flgs", vec![0, 0, 0, 0x98]), chunk(b"loda", v.loda(0, &[(1000, b"L\0".to_vec())])), plain_object]); - let plain = list(b"page", vec![chunk(b"flgs", vec![0, 0, 0, 0x90]), plain_layer]); - for page in [nested, plain] { - let d = read(&synth::riff(1000, &[page]), Limits::default()).unwrap(); - let layer = &d.pages[0].layers[0]; - assert_eq!(layer.name, "L"); - let s = shapes(&layer.objects); - assert_eq!(s.len(), 1, "{:?}", layer.objects); - assert!(matches!(s[0].geometry, Geometry::Rect { w, .. } if (w - 10.0).abs() < 0.01)); - assert!((s[0].matrix.0[4] - 5.0).abs() < 0.01 && (s[0].matrix.0[5] - 6.0).abs() < 0.01, "{:?}", s[0].matrix); - assert!(d.warnings.is_empty(), "{:?}", d.warnings); - } -} - -/// From version 7 a `LIST stlt` holds the style tables, which don't parse as chunks: it is not -/// damage. -#[test] -fn a_style_table_list_is_not_read_as_chunks() { - let v = V(1000); - let stlt = chunk(b"LIST", [b"stlt".to_vec(), 3u32.to_le_bytes().to_vec(), vec![0xff; 30]].concat()); - let d = read(&synth::riff(1000, &[list(b"doc ", vec![stlt, synth::mcfg(v, 100.0, 50.0)])]), Limits::default()).unwrap(); - assert!(d.warnings.is_empty(), "{:?}", d.warnings); - assert!(d.page_size.is_some_and(|(w, h)| (w - 100.0).abs() < 0.01 && (h - 50.0).abs() < 0.01)); -} - -/// Before version 7 a `LIST stlt` holds chunks (R4), which are read like the document's others. -#[test] -fn a_style_list_before_version_7_is_read_as_chunks() { - for version in [400, 500, 600] { - let v = V(version); - let red = if version < 500 { synth::color4(1, [0, 100, 100, 0]) } else { synth::color(5, [0, 0, 255, 0]) }; - let styles = list(b"stlt", vec![list(b"filt", vec![chunk(b"fill", v.fill(1, &red))])]); - let rect = synth::object(v, 1, &[(20, 1u32.to_le_bytes().to_vec()), (30, v.rect(10.0, 10.0, 0.0))], None); - let page = synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![rect])]); - let content = vec![list(b"doc ", vec![styles]), page]; - let d = read(&synth::file_of(version, content.clone()), Limits::default()).unwrap(); - let s = shapes(&d.pages[0].layers[0].objects); - assert!(s[0].fill.is_some(), "{version}"); - assert!(d.warnings.is_empty(), "{version}: {:?}", d.warnings); - // A template, whose form type names no version, by its `vrsn` chunk. - let mut template = synth::file_of(version, content); - template[8..12].copy_from_slice(b"CDTA"); - let d = read(&template, Limits::default()).unwrap(); - assert!(shapes(&d.pages[0].layers[0].objects)[0].fill.is_some(), "{version}"); - } -} - -/// The objects of a styled drawing: a rectangle with only its style (argument 200), one whose -/// style leaves the fill and outline to its parent, and one with an outline argument of its own. -fn graphic_style_drawing(version: u16, table: synth::Node) -> Vec { - let v = V(version); - let black = synth::color(2, [0, 0, 0, 100]); - let doc = list( - b"doc ", - vec![ - synth::mcfg(v, 612.0, 792.0), - list(b"filt", vec![chunk(if version >= 700 { b"fild" } else { b"fill" }, v.fill(1, &synth::color(5, [0, 0, 255, 0])))]), - list( - b"otlt", - vec![ - chunk(b"outl", v.outline(2, synth::Pen { line_type: 0, width: 2.0, cap: 1, join: 1 }, &black, &[])), - chunk(b"outl", v.outline(3, synth::Pen { line_type: 1, width: 1.0, cap: 0, join: 0 }, &black, &[])), - ], - ), - table, - ], - ); - let rect = (30, v.rect(20.0, 10.0, 0.0)); - let styled = |style: u32, own: &[(u32, Vec)]| { - let mut args = vec![(200, style.to_le_bytes().to_vec())]; - args.extend(own.iter().cloned()); - args.push(rect.clone()); - synth::object(v, 1, &args, None) - }; - let objects = vec![styled(0x10, &[]), styled(0x11, &[]), styled(0x10, &[(10, 3u32.to_le_bytes().to_vec())])]; - let page = synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", objects)]); - synth::file_of(version, vec![doc, page]) -} - -/// From version 7 an object without a fill or outline argument of its own takes its style's -/// (argument 200, `LIST stlt`), through the style's parent where the style names none; its own -/// argument wins over the style's. -#[test] -fn objects_without_their_own_fill_or_outline_take_their_styles() { - let styles = [synth::Style { id: 0x10, parent: 0, fill: 0x100, outline: 0x200 }, synth::Style { id: 0x11, parent: 0x10, fill: 0, outline: 0 }]; - for version in [700, 800, 801, 900, 1000, 1100, 1200, 1300, 1400, 1500] { - for text in [false, true] { - let table = synth::stlt(V(version), &[(0x100, 1)], &[(0x200, 2)], &styles, text); - let d = read(&graphic_style_drawing(version, table), Limits::default()).unwrap_or_else(|e| panic!("{version}: {e}")); - let s = shapes(&d.pages[0].layers[0].objects); - assert_eq!(s.len(), 3, "{version}"); - for shape in &s[..2] { - assert_eq!(shape.fill, Some(Color::Rgb([1.0, 0.0, 0.0])), "{version} {text}"); - assert!(shape.outline.as_ref().is_some_and(|o| (o.width - 2.0).abs() < 0.05), "{version} {text}: {:?}", shape.outline); - } - assert_eq!(s[2].fill, Some(Color::Rgb([1.0, 0.0, 0.0])), "{version} {text}"); - assert!(s[2].outline.is_none(), "{version} {text}"); - assert!(d.warnings.is_empty(), "{version} {text}: {:?}", d.warnings); - } - } -} - -/// A template whose style table comes before its `vrsn` chunk still reads the table by the -/// version that chunk names. -#[test] -fn a_style_table_before_the_version_chunk_reads_by_that_version() { - let styles = [synth::Style { id: 0x10, parent: 0, fill: 0x100, outline: 0x200 }, synth::Style { id: 0x11, parent: 0x10, fill: 0, outline: 0 }]; - let table = synth::stlt(V(1000), &[(0x100, 1)], &[(0x200, 2)], &styles, true); - let mut file = graphic_style_drawing(1000, chunk(b"junk", vec![])); - // The drawing's chunks, the table put first, ahead of `vrsn`. - let body = file.split_off(12); - file.extend(synth::plain(&table)); - file.extend(body); - file[8..12].copy_from_slice(b"CDTA"); - let len = (file.len() - 8) as u32; - file[4..8].copy_from_slice(&len.to_le_bytes()); - let d = read(&file, Limits::default()).unwrap(); - let s = shapes(&d.pages[0].layers[0].objects); - assert_eq!(s[0].fill, Some(Color::Rgb([1.0, 0.0, 0.0]))); - assert!(d.warnings.is_empty(), "{:?}", d.warnings); -} - -/// A style table that doesn't parse to its end is damage when an object needs a style from it; -/// the object is drawn with what it holds itself. -#[test] -fn a_style_table_that_does_not_parse_is_damage_when_an_object_needs_it() { - let styles = [synth::Style { id: 0x10, parent: 0, fill: 0x100, outline: 0x200 }, synth::Style { id: 0x11, parent: 0x10, fill: 0, outline: 0 }]; - let mut body = synth::stlt_body(V(1000), &[(0x100, 1)], &[(0x200, 2)], &styles, true); - body.push(0); - let table = chunk(b"LIST", [b"stlt".to_vec(), body].concat()); - let d = read(&graphic_style_drawing(1000, table), Limits::default()).unwrap(); - let s = shapes(&d.pages[0].layers[0].objects); - assert_eq!(s.len(), 3); - assert!(s[0].fill.is_none() && s[0].outline.is_none()); - assert_eq!(d.warnings, vec![Warning::Damaged]); -} - -/// A drawing with fill 1 (red), whose `LIST clpt` holds `groups` and whose page holds `objects`. -fn clip_drawing(version: u16, groups: Vec<(u32, Vec)>, objects: Vec) -> Vec { - let v = V(version); - let doc = list( - b"doc ", - vec![ - synth::mcfg(v, 612.0, 792.0), - list(b"filt", vec![chunk(if version >= 700 { b"fild" } else { b"fill" }, v.fill(1, &synth::color(5, [0, 0, 255, 0])))]), - synth::clpt(groups), - ], - ); - let page = synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", objects)]); - synth::file_of(version, vec![doc, page]) -} - -fn clip_rect(v: V, w: f64, extra: &[(u32, Vec)], at: [f64; 2]) -> synth::Node { - let mut args = vec![(20, 1u32.to_le_bytes().to_vec()), (30, v.rect(w, w, 0.0))]; - args.extend(extra.iter().cloned()); - synth::object(v, 1, &args, Some([1.0, 0.0, 0.0, 1.0, at[0], at[1]])) -} - -/// A container (argument 8005) clips the group of `LIST clpt` whose `spnd` id it names; the -/// group's objects keep their own transforms, front to back. -#[test] -fn a_container_clips_the_group_it_names() { - for version in [700, 900, 1200, 1300, 1500, 1600, 2000] { - let v = V(version); - let contents = vec![clip_rect(v, 10.0, &[], [5.0, 6.0]), clip_rect(v, 20.0, &[], [-50.0, 0.0])]; - let container = clip_rect(v, 40.0, &[synth::container(0x77)], [0.0, 0.0]); - let d = read(&clip_drawing(version, vec![(0x77, contents)], vec![container]), Limits::default()).unwrap_or_else(|e| panic!("{version}: {e}")); - let objects = &d.pages[0].layers[0].objects; - let [Object::Clip { container, objects: clipped }] = objects.as_slice() else { panic!("{version}: {objects:?}") }; - assert!(matches!(container.geometry, Geometry::Rect { w, .. } if (w - 40.0).abs() < 0.01), "{version}"); - let s = shapes(clipped); - assert_eq!(s.len(), 2, "{version}"); - assert!((s[0].matrix.0[4] - 5.0).abs() < 0.01 && (s[1].matrix.0[4] + 50.0).abs() < 0.01, "{version}: {:?}", s[0].matrix); - assert!(d.warnings.is_empty(), "{version}: {:?}", d.warnings); - } -} - -/// The feature sample, the seed of the importer's fuzz tests, reads its style table, clipping -/// container, lens, flags, winding flag, transparency and named outline color in every version -/// from 7 to 13, plain and compressed. -#[test] -fn the_feature_sample_reads_its_styles_container_and_lens() { - for version in [700, 800, 900, 1000, 1100, 1200, 1300] { - for compress in [false, true] { - let d = read(&synth::feature_sample(version, compress), Limits::default()).unwrap_or_else(|e| panic!("{version}: {e}")); - let objects = &d.pages[0].layers[0].objects; - let [ - Object::Shape(styled), - Object::Clip { objects: clipped, .. }, - Object::Shape(_), - Object::Shape(flagged), - Object::Group { objects: grouped, flags }, - ] = objects.as_slice() - else { - panic!("{version}: {objects:?}") - }; - assert_eq!(styled.fill, Some(Color::Rgb([1.0, 0.0, 0.0])), "{version}"); - assert!(styled.outline.as_ref().is_some_and(|o| o.dashes == [3.0, 1.0]), "{version}"); - let s = shapes(clipped); - assert_eq!(s.len(), 2, "{version}"); - assert!(s[1].outline.as_ref().is_some_and(|o| o.behind_fill), "{version}"); - assert_eq!(flagged.flags, Flags { hidden: true, locked: true }, "{version}"); - assert!(flagged.nonzero, "{version}"); - assert_eq!(*flags, Flags { hidden: true, locked: false }, "{version}"); - let named = shapes(grouped)[0].outline.as_ref().map(|o| o.color.clone()); - // A transparency and a named outline color are read from version 13. - if version >= 1300 { - assert_eq!((flagged.opacity, flagged.blend), (0.75, Blend::Multiply), "{version}"); - assert_eq!(named, Some(Color::Spot { name: "Sky Blue".into(), tint: 1.0, look: Some([1.0, 0.0, 0.0]) }), "{version}"); - assert_eq!(d.warnings, vec![Warning::Lenses], "{version} {compress}"); - } else { - assert_eq!((flagged.opacity, flagged.blend), (1.0, Blend::Normal), "{version}"); - assert_eq!(named, Some(Color::Spot { name: "Spot 0:7".into(), tint: 1.0, look: None }), "{version}"); - assert_eq!(d.warnings, vec![Warning::Lenses, Warning::SpotLooks], "{version} {compress}"); - } - } - } -} - -/// A container whose group isn't there is damage, and one whose group holds a container naming -/// it again is read once, with the limit warning; the containers stay as plain shapes. -#[test] -fn a_missing_or_repeating_clipped_group_keeps_the_container() { - let v = V(1100); - let missing = clip_rect(v, 40.0, &[synth::container(0x78)], [0.0, 0.0]); - let d = read(&clip_drawing(1100, vec![(0x77, vec![clip_rect(v, 10.0, &[], [0.0, 0.0])])], vec![missing]), Limits::default()).unwrap(); - assert!(matches!(d.pages[0].layers[0].objects.as_slice(), [Object::Shape(_)])); - assert_eq!(d.warnings, vec![Warning::Damaged]); - let inner = clip_rect(v, 10.0, &[synth::container(0x77)], [0.0, 0.0]); - let outer = clip_rect(v, 40.0, &[synth::container(0x77)], [0.0, 0.0]); - let d = read(&clip_drawing(1100, vec![(0x77, vec![inner])], vec![outer]), Limits::default()).unwrap(); - let [Object::Clip { objects: clipped, .. }] = d.pages[0].layers[0].objects.as_slice() else { panic!("{:?}", d.pages[0].layers[0].objects) }; - assert!(matches!(clipped.as_slice(), [Object::Shape(_)]), "{clipped:?}"); - assert_eq!(d.warnings, vec![Warning::TooDeep]); -} - -/// Each chunk of a clipped group counts toward the clipped chunk limit every time a container -/// names the group, empty groups included; past it the containers stay as plain shapes, and a -/// group cut off at the limit leaves out its guidelines too. -#[test] -fn containers_naming_one_group_stop_at_the_clipped_chunk_limit() { - let v = V(1100); - // The group walks 53 chunks: its `spnd`, a guideline, 50 empty groups and a rectangle. - let mut guide = vec![0; 12]; - guide.extend(90_000_000i32.to_le_bytes()); - guide.extend([v.coord(36.0), v.coord(0.0)].concat()); - let mut contents = vec![synth::object(v, 0x16, &[(16000, guide)], None)]; - contents.extend((0..50).map(|_| list(b"grp ", vec![]))); - contents.push(clip_rect(v, 10.0, &[], [0.0, 0.0])); - let containers: Vec = (0..20).map(|_| clip_rect(v, 40.0, &[synth::container(0x77)], [0.0, 0.0])).collect(); - let file = clip_drawing(1100, vec![(0x77, contents)], containers); - let count = |objects: &[Object]| objects.iter().filter(|o| matches!(o, Object::Clip { .. })).count(); - let d = read(&file, Limits::default()).unwrap(); - assert_eq!((count(&d.pages[0].layers[0].objects), d.pages[0].layers[0].guides.len()), (20, 20)); - assert!(d.warnings.is_empty(), "{:?}", d.warnings); - // The sixth container's walk stops after its guideline and 8 empty groups. - let d = read(&file, Limits { clipped_chunks: 53 * 5 + 10, ..Limits::default() }).unwrap(); - let layer = &d.pages[0].layers[0]; - assert_eq!((layer.objects.len(), count(&layer.objects), layer.guides.len()), (20, 5, 5)); - assert_eq!(d.warnings, vec![Warning::TooDeep]); -} - -/// A container, fill, outline or style argument too short for the id it names is damage: the -/// shape comes in as a plain shape without that id. -#[test] -fn an_id_argument_cut_short_is_damage() { - for version in [700, 1100, 1600] { - let v = V(version); - let group = vec![(0x77, vec![clip_rect(v, 10.0, &[], [0.0, 0.0])])]; - let container = clip_rect(v, 40.0, &[(8005, vec![0x77, 0, 0])], [0.0, 0.0]); - let d = read(&clip_drawing(version, group, vec![container]), Limits::default()).unwrap_or_else(|e| panic!("{version}: {e}")); - assert!(matches!(d.pages[0].layers[0].objects.as_slice(), [Object::Shape(_)]), "{version}: {:?}", d.pages[0].layers[0].objects); - assert_eq!(d.warnings, vec![Warning::Damaged], "{version}"); - for kind in [20, 10, 200] { - let short = synth::object(v, 1, &[(kind, vec![1, 0]), (30, v.rect(10.0, 10.0, 0.0))], None); - let d = read(&clip_drawing(version, vec![], vec![short]), Limits::default()).unwrap_or_else(|e| panic!("{version} {kind}: {e}")); - let s = shapes(&d.pages[0].layers[0].objects); - assert!(s.len() == 1 && s[0].fill.is_none() && s[0].outline.is_none(), "{version} {kind}"); - assert_eq!(d.warnings, vec![Warning::Damaged], "{version} {kind}"); - } - } -} - -/// A fill or outline id that no record has is damage: the shape comes in without that paint. Id 0 -/// without a record is no paint. -#[test] -fn a_fill_or_outline_without_its_record_is_damage() { - for version in [700, 1100, 1600] { - let v = V(version); - for kind in [20, 10] { - for (id, want) in [(9u32, vec![Warning::Damaged]), (0, vec![])] { - let object = synth::object(v, 1, &[(kind, id.to_le_bytes().to_vec()), (30, v.rect(10.0, 10.0, 0.0))], None); - let d = - read(&clip_drawing(version, vec![], vec![object]), Limits::default()).unwrap_or_else(|e| panic!("{version} {kind} {id}: {e}")); - let s = shapes(&d.pages[0].layers[0].objects); - assert!(s.len() == 1 && s[0].fill.is_none() && s[0].outline.is_none(), "{version} {kind} {id}"); - assert_eq!(d.warnings, want, "{version} {kind} {id}"); - } - } - } -} - -/// An object with a lens or transparency (argument 8000) comes in opaque, with the lenses -/// warning; one without the argument gives no warning. -#[test] -fn lenses_and_transparency_are_named_in_the_warnings() { - for (version, lens) in [(1000, [1u8, 0, 0, 0].to_vec()), (1200, [5, 0, 0, 0].to_vec()), (1500, [0x14, 5, 0, 0, 0x75, 0, 0, 0, 5].to_vec())] { - let v = V(version); - let plain = clip_rect(v, 10.0, &[], [0.0, 0.0]); - let d = read(&clip_drawing(version, vec![], vec![plain]), Limits::default()).unwrap(); - assert!(d.warnings.is_empty(), "{version}: {:?}", d.warnings); - let see_through = clip_rect(v, 10.0, &[(8000, lens)], [0.0, 0.0]); - let d = read(&clip_drawing(version, vec![], vec![see_through]), Limits::default()).unwrap(); - assert_eq!(shapes(&d.pages[0].layers[0].objects).len(), 1, "{version}"); - assert_eq!(d.warnings, vec![Warning::Lenses], "{version}"); - } -} - -/// From version 13 a uniform transparency (a 117-byte record of version 1300 in argument 8000) -/// gives the shape its opacity and blend mode, records of other versions before it skipped. A -/// lens record, a value outside 0 to 100, a merge mode without a blend mode, and the record in an -/// earlier version are not applied: the shape stays opaque, with the lenses warning. -#[test] -fn a_uniform_transparency_from_version_13_applies() { - let record = |since: u32, body: Vec| [since.to_le_bytes().to_vec(), (body.len() as u32).to_le_bytes().to_vec(), body].concat(); - for version in [1300, 1500, 1600, 2000] { - let v = V(version); - let read_with = |arg: Vec| { - let d = read(&clip_drawing(version, vec![], vec![clip_rect(v, 10.0, &[(8000, arg)], [0.0, 0.0])]), Limits::default()) - .unwrap_or_else(|e| panic!("{version}: {e}")); - let s = shapes(&d.pages[0].layers[0].objects)[0]; - ((s.opacity, s.blend), d.warnings) - }; - for (percent, merge, want) in [(25.0, 0, Blend::Normal), (0.0, 9, Blend::Multiply), (100.0, 28, Blend::Screen), (60.0, 36, Blend::Exclusion)] - { - let opacity = (1.0 - percent / 100.0) as f32; - assert_eq!(read_with(synth::transparency(percent, merge).1), ((opacity, want), vec![]), "{version} {percent} {merge}"); - } - // A record of a later version comes first. - let later = [record(1600, vec![0; 20]), synth::transparency(25.0, 0).1].concat(); - assert_eq!(read_with(later), ((0.75, Blend::Normal), vec![]), "{version}"); - let opaque = ((1.0, Blend::Normal), vec![Warning::Lenses]); - assert_eq!(read_with(record(1300, vec![0; 84])), opaque, "{version}: a lens"); - for bad in [150.0, -1.0, f64::NAN] { - assert_eq!(read_with(synth::transparency(bad, 0).1), opaque, "{version} {bad}"); - } - for merge in [1, 2, 3, 6, 7, 8, 10, 13, 18, 19, 20, 27, 37, 255] { - assert_eq!(read_with(synth::transparency(25.0, merge).1), opaque, "{version} {merge}"); - } - assert_eq!(read_with(vec![]), opaque, "{version}: empty"); - } - let d = - read(&clip_drawing(1200, vec![], vec![clip_rect(V(1200), 10.0, &[synth::transparency(25.0, 0)], [0.0, 0.0])]), Limits::default()).unwrap(); - assert_eq!(shapes(&d.pages[0].layers[0].objects)[0].opacity, 1.0); - assert_eq!(d.warnings, vec![Warning::Lenses]); -} - -/// Bit 0x01 of byte 1 of a layer's, group's or object's flags hides it and bit 0x10 of byte 0 -/// locks it, in every version; a group left ungrouped at the object limit passes its flags to its -/// objects. -#[test] -fn flags_hide_and_lock_layers_groups_and_objects() { - for version in [300, 700, 1100, 1300, 1600] { - let v = V(version); - let rect = |flags: [u8; 4]| synth::flagged(synth::object(v, 1, &[(30, v.rect(10.0, 10.0, 0.0))], None), flags); - let group = |flags: [u8; 4], objects: Vec| { - let mut kids = vec![chunk(b"flgs", flags.to_vec())]; - kids.extend(objects); - list(b"grp ", kids) - }; - let objects = vec![ - rect([0, 0, 0, 8]), - rect([0, 1, 0, 8]), - rect([0x10, 0, 0, 8]), - rect([0x10, 1, 0, 8]), - group([0x10, 1, 0, 0x10], vec![rect([0, 0, 0, 8])]), - ]; - let layers = - vec![synth::layer(v, [0, 0, 0, 0x98], "Shown", objects), synth::layer(v, [0x10, 1, 0, 0x98], "Hidden", vec![rect([0, 0, 0, 8])])]; - let file = synth::file_of(version, vec![synth::page(false, layers)]); - let d = read(&file, Limits::default()).unwrap_or_else(|e| panic!("{version}: {e}")); - let [shown, hidden] = d.pages[0].layers.as_slice() else { panic!("{version}: {:?}", d.pages[0].layers) }; - assert_eq!(shown.flags, Flags::default(), "{version}"); - assert_eq!(hidden.flags, Flags { hidden: true, locked: true }, "{version}"); - let f = |hidden: bool, locked: bool| Flags { hidden, locked }; - let own: Vec = shown - .objects - .iter() - .map(|o| match o { - Object::Shape(s) => s.flags, - Object::Group { flags, .. } => *flags, - Object::Clip { container, .. } => container.flags, - }) - .collect(); - assert_eq!(own, [f(false, false), f(true, false), f(false, true), f(true, true), f(true, true)], "{version}"); - assert!( - matches!(&shown.objects[4], Object::Group { objects, .. } if matches!(&objects[0], Object::Shape(s) if s.flags == Flags::default())), - "{version}" - ); - assert!(d.warnings.contains(&Warning::UnsupportedObjects) || d.warnings.is_empty(), "{version}: {:?}", d.warnings); - // Past the object limit the group's rectangle comes in ungrouped, hidden and locked. - let d = read(&file, Limits { objects: 5, ..Limits::default() }).unwrap_or_else(|e| panic!("{version}: {e}")); - let last = d.pages[0].layers[0].objects.last(); - assert!(matches!(last, Some(Object::Shape(s)) if s.flags == f(true, true)), "{version}: {last:?}"); - } -} - -/// A guideline is hidden when its own object, a group around it or its layer is. -#[test] -fn hidden_guidelines_say_so() { - for version in [700, 1300, 1600] { - let v = V(version); - let guide = |flags: [u8; 4]| { - let mut arg = vec![0; 12]; - arg.extend(90_000_000i32.to_le_bytes()); - arg.extend([v.coord(36.0), v.coord(0.0)].concat()); - synth::flagged(synth::object(v, 0x16, &[(16000, arg)], None), flags) - }; - let group = list(b"grp ", vec![chunk(b"flgs", vec![0, 1, 0, 0x10]), guide([0, 0, 0, 8])]); - let layers = vec![ - synth::layer(v, [0, 0, 0, 0x98], "Shown", vec![guide([0, 0, 0, 8]), guide([0, 1, 0, 8]), group]), - synth::layer(v, [0, 1, 0, 0x98], "Hidden", vec![guide([0, 0, 0, 8])]), - ]; - let d = read(&synth::file_of(version, vec![synth::page(false, layers)]), Limits::default()).unwrap_or_else(|e| panic!("{version}: {e}")); - let hidden: Vec> = d.pages[0].layers.iter().map(|l| l.guides.iter().map(|g| g.hidden).collect()).collect(); - assert_eq!(hidden, [vec![false, true, true], vec![true]], "{version}"); - } -} - -/// Byte 0 of argument 14001 other than 0 fills the shape nonzero; 0, or no argument, fills it -/// even-odd; an argument without its byte is damage. -#[test] -fn a_winding_flag_fills_nonzero() { - for version in [300, 700, 1200, 1600] { - let v = V(version); - let read_with = |extra: &[(u32, Vec)]| { - let mut args = vec![(30, v.rect(10.0, 10.0, 0.0))]; - args.extend(extra.iter().cloned()); - let file = synth::file_of( - version, - vec![synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![synth::object(v, 1, &args, None)])])], - ); - let d = read(&file, Limits::default()).unwrap_or_else(|e| panic!("{version}: {e}")); - (shapes(&d.pages[0].layers[0].objects)[0].nonzero, d.warnings) - }; - assert_eq!(read_with(&[(14001, vec![1, 0, 0, 0])]), (true, vec![]), "{version}"); - assert_eq!(read_with(&[(14001, vec![2])]), (true, vec![]), "{version}"); - assert_eq!(read_with(&[(14001, vec![0, 0, 0, 0])]), (false, vec![]), "{version}"); - assert_eq!(read_with(&[]), (false, vec![]), "{version}"); - assert_eq!(read_with(&[(14001, vec![])]), (false, vec![Warning::Damaged]), "{version}"); - } -} - -/// A `cdr8` form type makes the file the 8.01 variant whatever its `vrsn` chunk names: its style -/// table is read with the 8.01 layout. -#[test] -fn a_cdr8_file_whose_version_chunk_names_800_reads_as_801() { - let styles = [synth::Style { id: 0x10, parent: 0, fill: 0x100, outline: 0x200 }, synth::Style { id: 0x11, parent: 0x10, fill: 0, outline: 0 }]; - for named in [800u16, 900, 1300] { - let table = synth::stlt(V(801), &[(0x100, 1)], &[(0x200, 2)], &styles, true); - let mut file = graphic_style_drawing(801, table); - file[8..12].copy_from_slice(b"cdr8"); - let at = file.windows(4).position(|w| w == b"vrsn").unwrap() + 8; - assert_eq!(&file[at..at + 2], &801u16.to_le_bytes()); - file[at..at + 2].copy_from_slice(&named.to_le_bytes()); - let d = read(&file, Limits::default()).unwrap_or_else(|e| panic!("{named}: {e}")); - assert_eq!(d.version, 801, "{named}"); - let s = shapes(&d.pages[0].layers[0].objects); - assert_eq!(s[0].fill, Some(Color::Rgb([1.0, 0.0, 0.0])), "{named}"); - assert!(d.warnings.is_empty(), "{named}: {:?}", d.warnings); - } -} - -/// Before version 6 an object names its style in 2 bytes, which is not damage; an argument too -/// short for them is. -#[test] -fn a_style_id_before_version_6_is_two_bytes() { - for version in [400, 500] { - let v = V(version); - let read_with = |style: Vec| { - let object = synth::object(v, 1, &[(200, style), (30, v.rect(10.0, 10.0, 0.0))], None); - let file = synth::file_of(version, vec![synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![object])])]); - let d = read(&file, Limits::default()).unwrap_or_else(|e| panic!("{version}: {e}")); - (shapes(&d.pages[0].layers[0].objects).len(), d.warnings) - }; - assert_eq!(read_with(vec![0x10, 0]), (1, vec![]), "{version}"); - assert_eq!(read_with(vec![0x10]), (1, vec![Warning::Damaged]), "{version}"); - } -} - -/// A hidden or locked group of `LIST clpt` hides or locks the objects a container clips from it. -#[test] -fn a_clipped_groups_flags_reach_its_objects() { - for version in [700, 1300, 1600] { - let v = V(version); - let group = list( - b"grp ", - vec![chunk(b"flgs", vec![0x10, 1, 0x80, 0x10]), chunk(b"spnd", 0x77u32.to_le_bytes().to_vec()), clip_rect(v, 10.0, &[], [0.0, 0.0])], - ); - let doc = list(b"doc ", vec![synth::mcfg(v, 612.0, 792.0), list(b"clpt", vec![group])]); - let page = synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![clip_rect(v, 40.0, &[synth::container(0x77)], [0.0, 0.0])])]); - let d = read(&synth::file_of(version, vec![doc, page]), Limits::default()).unwrap_or_else(|e| panic!("{version}: {e}")); - let [Object::Clip { container, objects }] = d.pages[0].layers[0].objects.as_slice() else { - panic!("{version}: {:?}", d.pages[0].layers[0].objects) - }; - assert_eq!(container.flags, Flags::default(), "{version}"); - assert!(matches!(objects.as_slice(), [Object::Shape(s)] if s.flags == Flags { hidden: true, locked: true }), "{version}: {objects:?}"); - } -} - -/// Before version 6 a clipped group's `spnd` id is 2 bytes. -#[test] -fn a_clipped_group_id_before_version_6_is_two_bytes() { - for version in [400, 500] { - let v = V(version); - let rect = |w: f64, extra: Vec<(u32, Vec)>| { - let mut args = vec![(30, v.rect(w, w, 0.0))]; - args.extend(extra); - synth::object(v, 1, &args, None) - }; - let clpt = list(b"clpt", vec![list(b"grp ", vec![chunk(b"spnd", vec![0x77, 0]), rect(10.0, vec![])])]); - let page = synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![rect(40.0, vec![synth::container(0x77)])])]); - let d = read(&synth::file_of(version, vec![list(b"doc ", vec![synth::mcfg(v, 612.0, 792.0), clpt]), page]), Limits::default()) - .unwrap_or_else(|e| panic!("{version}: {e}")); - let objects = &d.pages[0].layers[0].objects; - assert!(matches!(objects.as_slice(), [Object::Clip { objects, .. }] if objects.len() == 1), "{version}: {objects:?}"); - assert!(d.warnings.is_empty(), "{version}: {:?}", d.warnings); - } -} - -/// A `trfd` entry ends at the next offset: one too short for its matrix makes the transform -/// damage and leaves the shape in place, even when the bytes after it would read as a matrix. A -/// table that stops before the last entry's end offset leaves that entry the rest of the record. -#[test] -fn a_transform_entry_ends_at_the_next_offset() { - for version in [400, 1100, 1300, 1600] { - let v = V(version); - let w = if version < 600 { 2 } else { 4 }; - let moved = [1.0, 0.0, 0.0, 1.0, 72.0, 0.0]; - let object = |trfd: Vec| { - let own = vec![chunk(b"loda", v.loda(1, &[(30, v.rect(10.0, 10.0, 0.0))])), list(b"trfl", vec![chunk(b"trfd", trfd)])]; - list(b"obj ", vec![chunk(b"flgs", vec![0, 0, 0, 8]), list(b"lgob", own)]) - }; - let read_with = |trfd: Vec| { - let file = synth::file_of(version, vec![synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![object(trfd)])])]); - let d = read(&file, Limits::default()).unwrap_or_else(|e| panic!("{version}: {e}")); - (shapes(&d.pages[0].layers[0].objects)[0].matrix.0[4], d.warnings) - }; - let whole = v.trfd(&[moved]); - assert!((read_with(whole.clone()).0 - 72.0).abs() < 0.01, "{version}"); - // The end offset, right after the first, made 4 bytes past the entry's start. - let mut short = whole.clone(); - let start = if w == 2 { - usize::from(u16::from_le_bytes([short[3 * w], short[3 * w + 1]])) - } else { - u32::from_le_bytes(short[12..16].try_into().unwrap()) as usize - }; - short[4 * w..5 * w].copy_from_slice(&v.word(start + 4)); - assert_eq!(read_with(short), (0.0, vec![Warning::Damaged]), "{version}"); - // The entry first, then a table of its start alone at the record's end. - let entry = whole[5 * w..].to_vec(); - let at = 3 * w + entry.len(); - let mut end = [v.word(at + w), v.word(1), v.word(at)].concat(); - end.extend(entry); - end.extend(v.word(3 * w)); - let (x, warnings) = read_with(end); - assert!((x - 72.0).abs() < 0.01 && warnings.is_empty(), "{version}: {x} {warnings:?}"); - } -} - -/// From version 13 an outline's record of type 2 that names a library color gives the outline -/// that color; one without a name leaves the fixed color field. -#[test] -fn an_outline_takes_a_named_library_color_from_its_property_list() { - for version in [1300, 1500, 1600] { - let v = V(version); - let read_with = |props: Vec| { - let mut outl = v.outline(4, synth::Pen { line_type: 0, width: 1.0, cap: 0, join: 0 }, &synth::color(2, [0, 0, 0, 100]), &[]); - let mut record = 2u32.to_le_bytes().to_vec(); - record.extend((props.len() as u32).to_le_bytes()); - record.extend(props); - outl.splice(4..4, record); - let doc = list(b"doc ", vec![synth::mcfg(v, 612.0, 792.0), list(b"otlt", vec![chunk(b"outl", outl)])]); - let object = synth::object(v, 1, &[(10, 4u32.to_le_bytes().to_vec()), (30, v.rect(10.0, 10.0, 0.0))], None); - let file = synth::file_of(version, vec![doc, synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![object])])]); - let d = read(&file, Limits::default()).unwrap_or_else(|e| panic!("{version}: {e}")); - (shapes(&d.pages[0].layers[0].objects)[0].outline.as_ref().map(|o| o.color.clone()), d.warnings) - }; - let named = synth::properties(&synth::color(5, [0, 0, 255, 0]), Some("Sky Blue")); - assert_eq!(read_with(named), (Some(Color::Spot { name: "Sky Blue".into(), tint: 1.0, look: Some([1.0, 0.0, 0.0]) }), vec![]), "{version}"); - let plain = synth::properties(&synth::color(5, [0, 0, 255, 0]), None); - assert_eq!(read_with(plain), (Some(Color::Cmyk([0.0, 0.0, 0.0, 1.0])), vec![]), "{version}"); - } -} - -#[test] -fn linked_groups_are_left_out_with_a_warning() { - let v = V(1100); - let rect = synth::object(v, 1, &[(30, [v.coord(1.0), v.coord(1.0), v.coord(0.0), v.coord(0.0), v.coord(0.0), v.coord(0.0)].concat())], None); - let file = synth::riff(1100, &[synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![list(b"lnkg", vec![rect])])])]); - let d = read(&file, Limits::default()).unwrap(); - assert!(d.pages[0].layers[0].objects.is_empty()); - assert!(d.warnings.contains(&Warning::UnsupportedObjects)); -} - -#[test] -fn a_file_cut_short_keeps_what_it_holds() { - let full = synth::sample(900, false); - let cut = &full[..full.len() - 40]; - let d = read(cut, Limits::default()).unwrap(); - assert!(d.warnings.contains(&Warning::Damaged)); - // The last page is cut inside its layer: the lists that hold the cut keep their whole - // children, so the rectangle, ellipse and curve before the cut are read. - assert_eq!(d.pages.len(), 1); - let s = shapes(&d.pages[0].layers[0].objects); - assert!(s.len() >= 3, "{}", s.len()); - assert!(matches!(s[0].geometry, Geometry::Rect { .. }) && matches!(s[1].geometry, Geometry::Ellipse { .. })); -} - -#[test] -fn a_riff_length_shorter_than_the_form_type_is_damage() { - for declared in 0u32..4 { - let mut file = synth::sample(900, false); - file[4..8].copy_from_slice(&declared.to_le_bytes()); - let d = read(&file, Limits::default()).unwrap(); - assert!(d.warnings.contains(&Warning::Damaged), "{declared}"); - check_shapes(&d, 900); - } -} - -#[test] -fn a_zip_bomb_stops_at_the_inflate_limit() { - let v = V(1100); - let big = chunk(b"junk", vec![0; 4 << 20]); - let file = synth::riff(1100, &[chunk(b"vrsn", 1100u16.to_le_bytes().to_vec()), synth::cmpr(&[big, synth::mcfg(v, 10.0, 10.0)])]); - assert!(file.len() < 64 << 10); - let limits = Limits { inflated: 1 << 20, ..Limits::default() }; - assert_eq!(read(&file, limits), Err(Error::Limit("inflated size"))); -} - -/// What a compressed stream inflates before it fails counts toward the inflate limit, so that -/// streams failing at their checksum can't each inflate up to the limit. -#[test] -fn bytes_inflated_by_a_failing_stream_count_toward_the_limit() { - let failing = || { - let mut cmpr = synth::cmpr(&[chunk(b"junk", vec![0; 600 << 10])]); - if let synth::Node::Chunk(_, body) = &mut cmpr { - // The last byte of the first block's zlib stream is part of its checksum. - let first = u32::from_le_bytes(body[4..8].try_into().unwrap()) as usize; - body[4 + 16 + first - 1] ^= 0xff; - } - cmpr - }; - let file = synth::riff(1100, &[chunk(b"vrsn", 1100u16.to_le_bytes().to_vec()), failing(), failing()]); - let one = - read(&synth::riff(1100, &[chunk(b"vrsn", 1100u16.to_le_bytes().to_vec()), failing()]), Limits { inflated: 1 << 20, ..Limits::default() }); - assert!(one.is_ok_and(|d| d.warnings == vec![Warning::Damaged])); - assert_eq!(read(&file, Limits { inflated: 1 << 20, ..Limits::default() }), Err(Error::Limit("inflated size"))); -} - -#[test] -fn a_million_empty_chunks_stop_at_the_chunk_limit() { - let kids: Vec<_> = (0..5000).map(|_| chunk(b"junk", vec![])).collect(); - let file = synth::riff(1100, &[list(b"doc ", kids)]); - let limits = Limits { chunks: 1000, ..Limits::default() }; - assert_eq!(read(&file, limits), Err(Error::Limit("chunk count"))); - assert!(read(&file, Limits::default()).is_ok()); -} - -#[test] -fn deep_nesting_is_left_out_with_a_warning() { - let v = V(1100); - let mut inner = synth::object(v, 1, &[(30, [v.coord(1.0), v.coord(1.0), v.coord(0.0), v.coord(0.0), v.coord(0.0), v.coord(0.0)].concat())], None); - for _ in 0..300 { - inner = list(b"grp ", vec![inner]); - } - let file = synth::riff(1100, &[synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![inner])])]); - let d = read(&file, Limits::default()).unwrap(); - assert!(d.warnings.contains(&Warning::TooDeep)); -} - -#[test] -fn a_size_pool_index_out_of_range_is_damage() { - // A compressed stream whose one chunk names pool entry 7 of a pool of one. - let mut cmpr = synth::cmpr(&[chunk(b"mcfg", vec![0; 8])]); - if let synth::Node::Chunk(_, body) = &mut cmpr { - // Rebuild the stream with a bad index: the pool keeps its one size. - let mut stream = b"mcfg".to_vec(); - stream.extend(7u32.to_le_bytes()); - stream.extend([0; 8]); - let mut e = flate2::write::ZlibEncoder::new(Vec::new(), flate2::Compression::default()); - std::io::Write::write_all(&mut e, &stream).unwrap(); - let z = e.finish().unwrap(); - let pool_block = body[4 + 16 + u32::from_le_bytes(body[4..8].try_into().unwrap()) as usize..].to_vec(); - let mut b = b"cmpr".to_vec(); - b.extend(((z.len() + 8) as u32).to_le_bytes()); - b.extend((stream.len() as u32).to_le_bytes()); - b.extend(body[12..20].to_vec()); - b.extend(b"CPng\x01\x00\x04\x00"); - b.extend(z); - b.extend(pool_block); - *body = b; - } - let d = read(&synth::riff(1100, &[cmpr]), Limits::default()).unwrap(); - assert!(d.warnings.contains(&Warning::Damaged), "{:?}", d.warnings); -} - -#[test] -fn backward_and_huge_loda_offsets_do_not_panic() { - let v = V(1100); - let mut loda = v.loda(3, &[(30, v.points(&[(0.0, 0.0, 0), (1.0, 1.0, 0x40)]))]); - // The offsets table now points before the header and far past the end. - let at = u32::from_le_bytes(loda[8..12].try_into().unwrap()) as usize; - loda[at..at + 4].copy_from_slice(&40u32.to_le_bytes()); - loda[at + 4..at + 8].copy_from_slice(&2u32.to_le_bytes()); - let obj = list(b"obj ", vec![chunk(b"loda", loda)]); - let file = synth::riff(1100, &[synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![obj])])]); - let d = read(&file, Limits::default()).unwrap(); - assert!(d.warnings.contains(&Warning::Damaged)); -} - -#[test] -fn outlines_flagged_none_and_dashes_read() { - let v = V(1300); - let black = synth::color(2, [0, 0, 0, 100]); - let dashed = v.outline(9, synth::Pen { line_type: 4, width: 1.0, cap: 2, join: 2 }, &black, &[3, 1]); - let style = vec![(10, 9u32.to_le_bytes().to_vec()), (30, v.points(&[(0.0, 0.0, 0), (10.0, 0.0, 0x40)]))]; - let file = synth::riff( - 1300, - &[ - chunk(b"vrsn", 1300u16.to_le_bytes().to_vec()), - list(b"otlt", vec![chunk(b"outl", dashed)]), - synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![synth::object(v, 3, &style, None)])]), - ], - ); - let d = read(&file, Limits::default()).unwrap(); - let s = shapes(&d.pages[0].layers[0].objects); - let o = s[0].outline.as_ref().unwrap(); - assert_eq!(o.dashes, vec![3.0, 1.0]); - assert_eq!((o.cap, o.join), (Cap::Square, vectorcraft_cdr::model::Join::Bevel)); -} - -/// A curve or polygon left out at the coordinate limit gives the limit warning, not the damage -/// warning. -#[test] -fn shapes_past_the_coordinate_limit_are_not_damage() { - let v = V(1100); - let curve = synth::object(v, 3, &[(30, v.points(&[(0.0, 0.0, 0), (10.0, 0.0, 0x40), (10.0, 10.0, 0x40)]))], None); - let side = synth::POLYGON_SIDE; - let mut sides = vec![0; 4]; - sides.extend(5u32.to_le_bytes()); - sides.extend([0; 8]); - sides.extend(0.05f64.to_le_bytes()); - sides.extend(0.05f64.to_le_bytes()); - sides.extend([v.coord(0.0), v.coord(0.0)].concat()); - let base = v.points(&[(0.0, side, 0x0C), (side * 0.587, side * 0.809, 0x44)]); - let polygon = synth::object(v, 0x14, &[(30, base.clone()), (11000, sides)], None); - for (objects, limit) in [(vec![curve], 2), (vec![polygon], 4)] { - let file = synth::riff(1100, &[synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", objects)])]); - let d = read(&file, Limits { coordinates: limit, ..Limits::default() }).unwrap(); - assert!(d.pages[0].layers[0].objects.is_empty()); - assert_eq!(d.warnings, vec![Warning::TooDeep]); - } - // A polygon without its sides is damage, past the limit too. - let sideless = synth::object(v, 0x14, &[(30, base)], None); - let file = synth::riff(1100, &[synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![sideless])])]); - let d = read(&file, Limits { coordinates: 1, ..Limits::default() }).unwrap(); - assert_eq!(d.warnings, vec![Warning::Damaged]); -} - -/// Dashes stored in an outline whose line type doesn't mark it dashed (bit 2) are not drawn: the -/// outline is solid. -#[test] -fn dashes_are_drawn_only_when_the_line_type_marks_them() { - let black = synth::color(2, [0, 0, 0, 100]); - for version in [700, 1200, 1500] { - for (line_type, dashed) in [(2, false), (0x22, false), (0x42, false), (4, true), (0x24, true), (0x44, true)] { - let v = V(version); - let outline = v.outline(9, synth::Pen { line_type, width: 1.0, cap: 0, join: 0 }, &black, &[2, 1]); - let style = vec![(10, 9u32.to_le_bytes().to_vec()), (30, v.points(&[(0.0, 0.0, 0), (10.0, 0.0, 0x40)]))]; - let page = synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![synth::object(v, 3, &style, None)])]); - let d = read(&synth::file_of(version, vec![list(b"otlt", vec![chunk(b"outl", outline)]), page]), Limits::default()).unwrap(); - let s = shapes(&d.pages[0].layers[0].objects); - let o = s[0].outline.as_ref().unwrap(); - assert_eq!(o.dashes.is_empty(), !dashed, "{version} {line_type:#x}: {:?}", o.dashes); - } - } -} - -/// Bit 4 of the line type puts the outline behind the fill. -#[test] -fn outlines_flagged_behind_the_fill_say_so() { - let black = synth::color(2, [0, 0, 0, 100]); - for version in [700, 1300, 1600] { - for (line_type, behind) in [(2, false), (0x22, false), (0x12, true), (0x14, true)] { - let v = V(version); - let outline = v.outline(9, synth::Pen { line_type, width: 4.0, cap: 0, join: 0 }, &black, &[]); - let style = vec![(10, 9u32.to_le_bytes().to_vec()), (30, v.rect(10.0, 10.0, 0.0))]; - let page = synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![synth::object(v, 1, &style, None)])]); - let d = read(&synth::file_of(version, vec![list(b"otlt", vec![chunk(b"outl", outline)]), page]), Limits::default()).unwrap(); - let s = shapes(&d.pages[0].layers[0].objects); - assert_eq!(s[0].outline.as_ref().map(|o| o.behind_fill), Some(behind), "{version} {line_type:#x}"); - } - } -} - -/// Bit 5 of the line type scales the outline with the shape. -#[test] -fn outlines_flagged_to_scale_with_the_shape_say_so() { - let black = synth::color(2, [0, 0, 0, 100]); - for version in [700, 1300, 1600] { - for (line_type, scale_with) in [(2, false), (0x22, true), (0x12, false), (0x26, true)] { - let v = V(version); - let outline = v.outline(9, synth::Pen { line_type, width: 4.0, cap: 0, join: 0 }, &black, &[]); - let style = vec![(10, 9u32.to_le_bytes().to_vec()), (30, v.rect(10.0, 10.0, 0.0))]; - let page = synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![synth::object(v, 1, &style, None)])]); - let d = read(&synth::file_of(version, vec![list(b"otlt", vec![chunk(b"outl", outline)]), page]), Limits::default()).unwrap(); - let s = shapes(&d.pages[0].layers[0].objects); - assert_eq!(s[0].outline.as_ref().map(|o| o.scale_with), Some(scale_with), "{version} {line_type:#x}"); - } - } -} - -#[test] -fn library_colors_from_version_13_keep_their_names_and_tints() { - // A model 21 color (blue, green, red, tint) shown at 50 %, and its library name. - let shown = synth::color(21, [255, 191, 128, 50]); - let mut props = vec![1]; - props.extend(12u32.to_le_bytes()); - props.extend(shown); - props.push(8); - let name: Vec = "Sky Blue".encode_utf16().flat_map(|u| u.to_le_bytes()).collect(); - props.extend((16 + 4 + name.len() as u32).to_le_bytes()); - props.extend([0; 16]); - props.extend(8u32.to_le_bytes()); - props.extend(name); - props.extend([0, 0, 0, 0, 0]); - let mut solid = 1300u32.to_le_bytes().to_vec(); - solid.extend((props.len() as u32).to_le_bytes()); - solid.extend(props); - let mut body = 1u16.to_le_bytes().to_vec(); - body.extend(solid); - let mut fill = 4u32.to_le_bytes().to_vec(); - // A record of a later layout first, which the reader steps over. - fill.extend(2400u32.to_le_bytes()); - fill.extend(16u32.to_le_bytes()); - fill.extend([0; 16]); - fill.extend(1300u32.to_le_bytes()); - fill.extend((body.len() as u32).to_le_bytes()); - fill.extend(body); - // The same records in a plain file of version 13 and the packages of later versions. - for version in [1300, 1400, 1700, 2700] { - let v = V(version); - let style = vec![(20, 4u32.to_le_bytes().to_vec()), (30, v.rect(1.0, 1.0, 0.0))]; - let body = [ - chunk(b"vrsn", version.to_le_bytes().to_vec()), - list(b"filt", vec![chunk(b"fild", fill.clone())]), - synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![synth::object(v, 1, &style, None)])]), - ]; - let file = match version { - ..1400 => synth::riff(version, &body), - 1400..1600 => synth::package14(synth::riff(version, &body), true), - _ => synth::package16(version, &body, true, &[]), - }; - let d = read(&file, Limits::default()).unwrap(); - let s = shapes(&d.pages[0].layers[0].objects); - let Some(Color::Spot { name, tint, look: Some(look) }) = &s[0].fill else { panic!("{version}: {:?}", s[0].fill) }; - assert_eq!((name.as_str(), *tint), ("Sky Blue", 0.5)); - // 128/255 shown at half strength comes from about 1/255 at full strength. - assert!(look[0] < 0.01 && (look[2] - 1.0).abs() < 1e-6, "{version}: {look:?}"); - } -} - -/// One rectangle of version `v` that uses fill `fill` and outline `outline` (0: none). -fn styled_rect(v: V, fill: u32, outline: u32) -> synth::Node { - let mut args = vec![(30, [v.coord(1.0), v.coord(1.0), v.coord(0.0), v.coord(0.0), v.coord(0.0), v.coord(0.0)].concat())]; - if fill != 0 { - args.push((20, fill.to_le_bytes().to_vec())); - } - if outline != 0 { - args.push((10, outline.to_le_bytes().to_vec())); - } - synth::object(v, 1, &args, None) -} - -/// A drawing of version `v` with `styles` in its `doc` list and `objects` on one page. -fn styled_drawing(v: V, styles: Vec, objects: Vec) -> Vec { - let page = synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", objects)]); - synth::riff(v.0, &[chunk(b"vrsn", v.0.to_le_bytes().to_vec()), list(b"doc ", styles), page]) -} - -/// An outline's dashes count toward the read's dashes for every shape that uses it: one outline -/// of 65,535 dashes on 260 shapes would copy 17 million dashes, past the default limit. -#[test] -fn a_shared_dashed_outline_counts_its_dashes_for_every_shape() { - let v = V(1300); - let pen = synth::Pen { line_type: 4, width: 1.0, cap: 0, join: 0 }; - let outl = |dashes: &[u16]| list(b"otlt", vec![chunk(b"outl", v.outline(9, pen, &synth::color(2, [0, 0, 0, 100]), dashes))]); - let file = styled_drawing(v, vec![outl(&[2, 1].repeat(10))], (0..20).map(|_| styled_rect(v, 0, 9)).collect()); - let d = read(&file, Limits { dashes: 100, ..Limits::default() }).unwrap(); - let s = shapes(&d.pages[0].layers[0].objects); - assert_eq!(s.len(), 20); - let dashed = s.iter().filter(|s| s.outline.as_ref().is_some_and(|o| o.dashes.len() == 20)).count(); - assert_eq!(dashed, 5, "100 dashes hold five outlines of 20"); - assert!(s.iter().all(|s| s.outline.as_ref().is_some_and(|o| o.dashes.is_empty() || o.dashes.len() == 20))); - assert!(d.warnings.contains(&Warning::TooDeep), "{:?}", d.warnings); - // An outline with more dashes than the limit is solid, not cut short. - let file = styled_drawing(v, vec![outl(&[2, 1])], vec![styled_rect(v, 0, 9)]); - let d = read(&file, Limits { dashes: 1, ..Limits::default() }).unwrap(); - let s = shapes(&d.pages[0].layers[0].objects); - assert!(s[0].outline.as_ref().is_some_and(|o| o.dashes.is_empty()), "{:?}", s[0].outline); - assert_eq!(d.warnings, vec![Warning::TooDeep]); - // At the default limit. - let file = styled_drawing(v, vec![outl(&[1; 65_535])], (0..260).map(|_| styled_rect(v, 0, 9)).collect()); - assert!(file.len() < 256 << 10); - let d = read(&file, Limits::default()).unwrap(); - let s = shapes(&d.pages[0].layers[0].objects); - let total: usize = s.iter().filter_map(|s| s.outline.as_ref()).map(|o| o.dashes.len()).sum(); - assert!(total <= Limits::default().dashes, "{total}"); - assert!(d.warnings.contains(&Warning::TooDeep), "{:?}", d.warnings); -} - -/// A library color's name is copied for every shape that uses it: a long one keeps its first 256 -/// units and a hash of the whole name. -#[test] -fn a_library_color_keeps_the_first_256_units_of_its_name() { - let v = V(1300); - let mut props = vec![1]; - props.extend(12u32.to_le_bytes()); - props.extend(synth::color(21, [255, 191, 128, 100])); - props.push(8); - let name: Vec = "N".repeat(10_000).encode_utf16().flat_map(|u| u.to_le_bytes()).collect(); - props.extend((16 + 4 + name.len() as u32).to_le_bytes()); - props.extend([0; 16]); - props.extend(10_000u32.to_le_bytes()); - props.extend(name); - props.extend([0, 0, 0, 0, 0]); - let mut body = 1u16.to_le_bytes().to_vec(); - body.extend(1300u32.to_le_bytes()); - body.extend((props.len() as u32).to_le_bytes()); - body.extend(props); - let mut fill = 4u32.to_le_bytes().to_vec(); - fill.extend(1300u32.to_le_bytes()); - fill.extend((body.len() as u32).to_le_bytes()); - fill.extend(body); - let d = read(&styled_drawing(v, vec![list(b"filt", vec![chunk(b"fild", fill)])], vec![styled_rect(v, 4, 0)]), Limits::default()).unwrap(); - let s = shapes(&d.pages[0].layers[0].objects); - let Some(Color::Spot { name, .. }) = &s[0].fill else { panic!("{:?}", s[0].fill) }; - assert_eq!(name.chars().count(), 256 + 17, "{name}"); - assert!(name.starts_with(&"N".repeat(256)), "{name}"); - assert!(d.warnings.contains(&Warning::TooDeep), "{:?}", d.warnings); -} - -/// A transform or a uniform fill's color that is there but can't be read is damage: the shape -/// stays, without its transform or its fill, and the warnings say so. -#[test] -fn unreadable_transforms_and_fill_colors_are_damage() { - let v = V(1100); - let rect = [v.coord(1.0), v.coord(1.0), v.coord(0.0), v.coord(0.0), v.coord(0.0), v.coord(0.0)].concat(); - let obj = list(b"obj ", vec![chunk(b"loda", v.loda(1, &[(30, rect)])), list(b"trfl", vec![chunk(b"trfd", vec![1, 2])])]); - let d = read(&styled_drawing(v, vec![], vec![obj]), Limits::default()).unwrap(); - let s = shapes(&d.pages[0].layers[0].objects); - assert_eq!((s.len(), s[0].matrix), (1, vectorcraft_cdr::model::Matrix::IDENTITY)); - assert!(d.warnings.contains(&Warning::Damaged), "trfd: {:?}", d.warnings); - // A uniform fill cut off in its color record, before version 13 and from it. - for v in [V(1100), V(1300)] { - let mut fill = v.fill(4, &synth::color(2, [0, 100, 0, 0])); - fill.truncate(fill.len() - 10); - let d = read(&styled_drawing(v, vec![list(b"filt", vec![chunk(b"fild", fill)])], vec![styled_rect(v, 4, 0)]), Limits::default()).unwrap(); - let s = shapes(&d.pages[0].layers[0].objects); - assert_eq!(s[0].fill, None, "{}", v.0); - assert!(d.warnings.contains(&Warning::Damaged), "fill {}: {:?}", v.0, d.warnings); - } -} - -/// The inflate limit may be as large as `usize` holds. -#[test] -fn the_largest_inflate_limit_reads_compressed_lists() { - let d = read(&synth::sample(1100, true), Limits { inflated: usize::MAX, ..Limits::default() }).unwrap(); - check_shapes(&d, 1100); -} - -proptest! { - #![proptest_config(ProptestConfig { cases: 256, ..ProptestConfig::default() })] - - #[test] - fn never_panics_on_garbage(bytes in prop::collection::vec(any::(), 0..2048)) { - let mut b = b"RIFF".to_vec(); - b.extend(bytes); - let _ = read(&b, Limits::default()); - } - - #[test] - fn never_panics_on_mutated_samples(version in prop::sample::select(vec![300u16, 400, 500, 700, 900, 1100, 1300]), compress: bool, edits in prop::collection::vec((any::(), any::()), 1..24)) { - let mut b = synth::sample(version, compress && version >= 700); - let n = b.len(); - for (at, v) in edits { - b[at % n] = v; - } - let _ = read(&b, Limits::default()); - } - - #[test] - fn never_panics_on_garbage_after_a_wl_header(marker in prop::sample::select(vec![b'e', b'l', b'm']), bytes in prop::collection::vec(any::(), 0..2048)) { - // Offsets that fit the file, so the garbage is walked as records. - let mut b = vec![b'W', b'L', marker, 0]; - b.extend(28u32.to_le_bytes()); - b.extend(28u32.to_le_bytes()); - b.extend((28 + bytes.len() as u32).to_le_bytes()); - b.extend([0; 12]); - b.extend(bytes); - prop_assert!(vectorcraft_cdr::is_cdr(&b)); - let _ = read(&b, Limits::default()); - } - - #[test] - fn never_panics_on_mutated_wl_files(marker in prop::sample::select(vec![b'e', b'l', b'm']), cut in any::(), edits in prop::collection::vec((any::(), any::()), 1..24)) { - let mut b = synth::wl_sample(marker); - let n = b.len(); - for (at, v) in edits { - b[at % n] = v; - } - let _ = read(&b, Limits::default()); - let _ = read(&b[..cut % (n + 1)], Limits::default()); - } - - #[test] - fn never_panics_on_mutated_packages(version in prop::sample::select(vec![1400u16, 1500, 1700, 2700]), edits in prop::collection::vec((any::(), any::(), any::()), 1..24)) { - // The members are edited before they are zipped, so that the edits reach the chunks and - // redirect records rather than stop at the CRC-32. - let mut body = vec![chunk(b"vrsn", version.to_le_bytes().to_vec())]; - body.extend(synth::sample_content(version)); - let mut members = if version < 1600 { - vec![synth::Member { name: "content/riffData.cdr".into(), data: synth::sample(version, false), deflate: false }] - } else { - synth::package16_members(version, &body, false, &[]) - }; - for (m, at, v) in edits { - let k = m % members.len(); - let data = &mut members[k].data; - if !data.is_empty() { - let n = data.len(); - data[at % n] = v; - } - } - let _ = read(&synth::zip(&members, b""), Limits::default()); - } -} diff --git a/crates/doc/src/hit.rs b/crates/doc/src/hit.rs index fcbe2f9db1..7c0de44cab 100644 --- a/crates/doc/src/hit.rs +++ b/crates/doc/src/hit.rs @@ -78,6 +78,9 @@ pub struct HitOptions { /// Off, the empty part of the frame (away from its edge and its lines of type) takes no /// clicks, so they reach the art behind (#7274). pub area_type_interior: bool, + /// The point hit tests ([`hit_test`], [`hit_test_visible`] and [`hit_test_visible_skipping`]) + /// hit the art on a layer whose Preview is off as painted, not in outline. + pub ignore_layer_preview: bool, } impl Default for HitOptions { @@ -90,6 +93,7 @@ impl Default for HitOptions { skip_guides: false, clip_outlines: false, area_type_interior: false, + ignore_layer_preview: false, scope: None, } } @@ -847,7 +851,7 @@ fn hit_test_skipping(doc: &Document, p: Point, opt: HitOptions, skip: &dyn Fn(No continue; } chain.push(layer.id); - let opt = if matches!(layer.kind, NodeKind::Layer { preview: false, .. }) { HitOptions { outline: true, ..opt } } else { opt }; + let opt = if !opt.ignore_layer_preview && previews_off(layer) { HitOptions { outline: true, ..opt } } else { opt }; if let Some(h) = hit_children(layer, p, opt, &symbols, skip, &mut chain, editable_only) { return Some(finish(h)); } @@ -1211,7 +1215,9 @@ fn hit_children( chain.push(c.id); let hit = plain(i == 0 && clip.is_some(), || match &c.kind { // A sublayer whose Preview is off is clicked in outline, like an outline view. - NodeKind::Layer { preview: false, .. } => hit_children(c, p, HitOptions { outline: true, ..opt }, symbols, skip, chain, editable_only), + NodeKind::Layer { preview: false, .. } if !opt.ignore_layer_preview => { + hit_children(c, p, HitOptions { outline: true, ..opt }, symbols, skip, chain, editable_only) + } NodeKind::Layer { .. } | NodeKind::Group { .. } | NodeKind::Intertwine { .. } => { hit_children(c, p, opt, symbols, skip, chain, editable_only) } @@ -1325,7 +1331,7 @@ fn art_hit(n: &Node, p: Point, opt: HitOptions, symbols: &SymbolBoxes, accept: & match &n.kind { NodeKind::Group { children, .. } | NodeKind::Layer { children, .. } | NodeKind::Intertwine { children } => { // A layer with Preview off is clicked in outline, as [`hit_children`] clicks it. - let opt = HitOptions { outline: opt.outline || previews_off(n), ..opt }; + let opt = HitOptions { outline: opt.outline || !opt.ignore_layer_preview && previews_off(n), ..opt }; if n.clips() && let Some(clip) = children.first() { diff --git a/crates/doc/src/hit/tests.rs b/crates/doc/src/hit/tests.rs index e94b2b8ba8..ad037931a0 100644 --- a/crates/doc/src/hit/tests.rs +++ b/crates/doc/src/hit/tests.rs @@ -1463,6 +1463,7 @@ const SELECTING: HitOptions = HitOptions { skip_guides: false, clip_outlines: true, area_type_interior: false, + ignore_layer_preview: false, scope: None, }; diff --git a/crates/effects/src/group.rs b/crates/effects/src/group.rs index aeffaacfb6..55e3ad6fe3 100644 --- a/crates/effects/src/group.rs +++ b/crates/effects/src/group.rs @@ -583,9 +583,10 @@ pub fn pathfinder_children(doc: Option<&Document>, group: &Node, hook: Option Option { @@ -644,13 +645,19 @@ pub fn pathfinder_children(doc: Option<&Document>, group: &Node, hook: Option = vec![]; let mut shapes: Vec = vec![]; + // Keys of the group operands whose art has no area left at the precision. + let mut collapsed: Vec = vec![]; for mut lv in all { if shape_mode && lv.len() > 1 { let parts: Vec<(PathData, FillRule)> = lv.iter().filter_map(geometry).collect(); let refs: Vec<(&PathData, FillRule)> = parts.iter().map(|(p, r)| (p, *r)).collect(); let key = sources.len() as u64; if let Some(top) = lv.pop() { - shapes.push(po::Shape::new(po::unite_all_with(&refs, options.precision), FillRule::NonZero, key)); + let united = po::unite_all_with(&refs, options.precision); + if united.is_empty() && !parts.is_empty() { + collapsed.push(key); + } + shapes.push(po::Shape::new(united, FillRule::NonZero, key)); sources.push(top); } } else { @@ -662,6 +669,18 @@ pub fn pathfinder_children(doc: Option<&Document>, group: &Node, hook: Option shapes.iter().any(is_collapsed), + PathfinderOp::MinusFront => shapes.first().is_some_and(is_collapsed), + PathfinderOp::MinusBack => shapes.last().is_some_and(is_collapsed), + _ => false, + }; + if nothing_left { + return Some(vec![]); + } shapes.retain(|s| !s.path.is_empty() && s.path.subpaths.iter().all(|sp| sp.anchors.iter().all(|a| a.p.x.is_finite() && a.p.y.is_finite()))); if shapes.is_empty() { return Some(vec![]); diff --git a/crates/effects/src/group/tests.rs b/crates/effects/src/group/tests.rs index 1c62508347..b3fa27aee1 100644 --- a/crates/effects/src/group/tests.rs +++ b/crates/effects/src/group/tests.rs @@ -196,6 +196,49 @@ fn shape_modes_follow_the_pathfinder_panel() { assert_eq!(div.len(), 3); } +/// An Intersect effect draws nothing when a group member's art has no area left at the effect's +/// precision, and so do Minus Back when that group is in front and Subtract when it is at the +/// back. Add, and Subtract with the group in front, leave such a member out. +#[test] +fn intersect_with_a_group_that_collapses_at_its_precision_draws_nothing() { + let thin_pair = |width: f64| { + let bar = |id: u64, x: f64| { + let fill = Appearance::basic(Paint::solid(Color::rgb(0.0, 0.0, 1.0)), Paint::None, 0.0); + Arc::new(Node::path(NodeId(id), shapes::rectangle(Rect::new(x, 10.0, x + width, 30.0)), fill)) + }; + Node::group(NodeId(5), vec![bar(3, 10.0), bar(4, 50.0)]) + }; + let with_precision = |front: Node, effect: &str| { + let mut g = square_and(Some(front), effect); + g.appearance.effects[0].params = serde_json::json!({"precision": 1.0}); + g + }; + let int = results(&with_precision(thin_pair(0.5), "pathfinder.intersect")); + assert!(int.is_empty(), "{int:#?}"); + // Bars wider than the precision keep their area. + let int = results(&with_precision(thin_pair(2.0), "pathfinder.intersect")); + let total: f64 = int.iter().map(|n| area(n)).sum(); + assert!((total - 80.0).abs() < 1.0, "{total}: {int:#?}"); + // Add keeps the square alone. + let add = results(&with_precision(thin_pair(0.5), "pathfinder.add")); + assert_eq!(add.len(), 1); + assert!((area(&add[0]) - 10_000.0).abs() < 1.0, "{add:#?}"); + // Minus Back cuts the square from the empty group in front, and Subtract cuts nothing from + // the square. + let minus_back = results(&with_precision(thin_pair(0.5), "pathfinder.minusBack")); + assert!(minus_back.is_empty(), "{minus_back:#?}"); + let subtract = results(&with_precision(thin_pair(0.5), "pathfinder.subtract")); + assert_eq!(subtract.len(), 1); + assert!((area(&subtract[0]) - 10_000.0).abs() < 1.0, "{subtract:#?}"); + // With the group at the back, Subtract cuts the square from it and leaves nothing. + let mut back = with_precision(thin_pair(0.5), "pathfinder.subtract"); + if let NodeKind::Group { children, .. } = &mut back.kind { + children.reverse(); + } + let subtract = results(&back); + assert!(subtract.is_empty(), "{subtract:#?}"); +} + /// Divide and Outline draw no piece of a member without fill or stroke, the same as when such /// pieces are left out. #[test] @@ -263,6 +306,25 @@ fn outline_strokes_a_compound_shapes_area_in_its_fill() { } } +/// Outline of a compound shape with no fill gives the edges no paint of their own when Remove +/// Unpainted Artwork is off. The shape's own appearance strokes the result, so the shape's stroke +/// is not copied onto the edges. +#[test] +fn outline_of_an_unfilled_compound_shape_adds_no_stroke() { + let mut g = compound_shape(ShapeMode::Add); + let mut a = Appearance::basic(Paint::None, Paint::solid(Color::BLACK), 4.0); + if let Some(AppearanceItem::Stroke(s)) = a.items.last_mut() { + s.opacity = 0.5; + } + g.appearance = a.into(); + g.appearance.effects.push(Effect { id: "pathfinder.outline".into(), params: serde_json::json!({"removeUnpainted": false}), visible: true }); + let out = pathfinder_children(None, &g, None).unwrap(); + assert!(!out.is_empty(), "{out:#?}"); + for n in &out { + assert!(!n.appearance.items.iter().any(paints), "{n:#?}"); + } +} + /// With Remove Unpainted Artwork, Divide keeps the pieces of an unfilled member when its group's /// own visible fill paints them and leaves them out when the group has no fill. Outline leaves out /// the member's segments either way. diff --git a/crates/effects/src/revolve.rs b/crates/effects/src/revolve.rs index 19522873f3..a6f0d6b2ae 100644 --- a/crates/effects/src/revolve.rs +++ b/crates/effects/src/revolve.rs @@ -158,14 +158,16 @@ pub(crate) fn validate_in(doc: Option<&Document>, n: &Node, id: &str, p: &Value) let mut copies = 0; // In wireframe mode the edges are drawn with no paint copies, graphics or shadow. let wire = wireframe_params(id, p); - shapes.iter().try_for_each(|s| check_surface(&s.path, b, options, surface_item(&s.items).filter(|_| !wire), &mut copies))?; + // Each member is swept with its own fill rule, as it is drawn. + let ruled = |s: &Profile| Revolve { fill_rule: s.rule, ..options }; + shapes.iter().try_for_each(|s| check_surface(&s.path, b, ruled(s), surface_item(&s.items).filter(|_| !wire), &mut copies))?; if wire { return Ok(()); } // Without graphics, or without the document they draw from, no member is measured for them. if let Some(doc) = doc.filter(|_| id == REVOLVE && !crate::solids::mapped_graphics(p).is_empty()) { match graphics_member(&shapes, b, options).and_then(|k| shapes.get(k)) { - Some(s) => check_graphics(Some(doc), id, &s.path, b, options, p, &mut 0)?, + Some(s) => check_graphics(Some(doc), id, &s.path, b, ruled(s), p, &mut 0)?, // With no member to carry them, the graphics' art must still fit its limits. None => { crate::solids::graphics::validate_symbols(doc, p)?; @@ -174,9 +176,9 @@ pub(crate) fn validate_in(doc: Option<&Document>, n: &Node, id: &str, p: &Value) } } let casting = shapes.iter().filter(|s| surface_item(&s.items).is_some_and(|i| crate::solids::shadow::casts(paint_of(i).1 * s.opacity))); - return check_shadow(p, casting.map(|s| &s.path), b, options); + return check_shadow(p, casting.map(|s| (&s.path, s.rule)), b, options); } - let (path, _) = object_profile(n, "Revolve")?; + let (path, rule) = object_profile(n, "Revolve")?; if !has_two_anchors(&path) { return Err("Revolve requires a shape with at least two anchors".into()); } @@ -184,12 +186,13 @@ pub(crate) fn validate_in(doc: Option<&Document>, n: &Node, id: &str, p: &Value) let b = path.bounds().ok_or("Revolve requires a shape with at least two anchors")?; let paints = solid_paints(n); let wire = wireframe_params(id, p); - check_surface(&path, b, options_of(id, p), surface_item(&paints).filter(|_| !wire), &mut 0)?; + let options = Revolve { fill_rule: rule, ..options_of(id, p) }; + check_surface(&path, b, options, surface_item(&paints).filter(|_| !wire), &mut 0)?; if wire { return Ok(()); } - check_graphics(doc, id, &path, b, options_of(id, p), p, &mut 0)?; - check_shadow(p, [&path], b, options_of(id, p)) + check_graphics(doc, id, &path, b, options, p, &mut 0)?; + check_shadow(p, [(&path, rule)], b, options) } /// An error when the graphics in Revolve (`id`) parameters `p`, with the symbols of `doc`, are past @@ -226,14 +229,14 @@ pub(crate) fn graphics_member(shapes: &[Profile], b: Rect, options: Revolve) -> .map(|(k, _)| k) } -/// With the shadow of Revolve parameters `p` on, an error when the surfaces of `paths` it is cast -/// from, about the axis of `b`, are past the limits together. -fn check_shadow<'a>(p: &Value, paths: impl IntoIterator, b: Rect, options: Revolve) -> Result<(), String> { +/// With the shadow of Revolve parameters `p` on, an error when the surfaces of `paths`, each filled +/// with its rule, it is cast from, about the axis of `b`, are past the limits together. +fn check_shadow<'a>(p: &Value, paths: impl IntoIterator, b: Rect, options: Revolve) -> Result<(), String> { if crate::solids::shadow::options(p).is_none() { return Ok(()); } let mut caster = vectorcraft_three_d::ShadowCaster::new(); - paths.into_iter().try_for_each(|path| caster.revolve(path, options.fill_rule, b, options).map(|_| ())) + paths.into_iter().try_for_each(|(path, rule)| caster.revolve(path, rule, b, Revolve { fill_rule: rule, ..options }).map(|_| ())) } /// [`validate_revolve`] for a Revolve with parameters `p` at index `index` of the effects of @@ -269,7 +272,7 @@ pub(crate) fn validate_item_of(doc: Option<&Document>, n: &Node, id: &str, p: &V validate_params_of(id, p)?; validate_map_symbols(doc, id, p)?; const EMPTY: &str = "Revolve requires a shape with at least two anchors"; - let (path, _) = object_profile(n, "Revolve")?; + let (path, rule) = object_profile(n, "Revolve")?; if !has_two_anchors(&path) { return Err(EMPTY.into()); } @@ -284,7 +287,7 @@ pub(crate) fn validate_item_of(doc: Option<&Document>, n: &Node, id: &str, p: &V Some(fx) if crate::paints(item) => (fx.id.as_str(), merged_params(&fx.id, &fx.params)), _ => continue, }; - let options = options_of(kind, ¶ms); + let options = Revolve { fill_rule: rule, ..options_of(kind, ¶ms) }; let path = geometry(&path, at.and_then(|at| effects.get(..at)).unwrap_or(effects), &ctx.item(item)); let b = path.bounds().ok_or(EMPTY)?; let wire = wireframe_params(kind, ¶ms); @@ -298,7 +301,7 @@ pub(crate) fn validate_item_of(doc: Option<&Document>, n: &Node, id: &str, p: &V if i == target { graphics?; } - check_shadow(¶ms, [&path], b, options)?; + check_shadow(¶ms, [(&path, rule)], b, options)?; } Ok(()) } @@ -1950,6 +1953,65 @@ mod tests { assert_eq!(revolve_art(&drawn), None, "past the budget the source draws"); } + #[test] + fn paint_copies_are_counted_on_the_faces_the_fill_rule_draws() { + use vectorcraft_doc::color::{Gradient, GradientKind, GradientPaint, GradientStop}; + use vectorcraft_geom::FillRule; + // Three nested squares drawn in the same direction, swept part way with Cap: under the + // even-odd rule each cut side is a ring and the inner square, and under the nonzero rule + // each cut side is one whole square. + let both = PathData::new( + [(100.0, 200.0), (120.0, 180.0), (140.0, 160.0)] + .iter() + .flat_map(|&(lo, hi)| { + let mut b = BezPath::new(); + b.move_to((lo, lo)); + b.line_to((hi, lo)); + b.line_to((hi, hi)); + b.line_to((lo, hi)); + b.close_path(); + PathData::from_bezpath(&b).subpaths + }) + .collect(), + ); + let p = json!({"angle": 180, "cap": true}); + let b = both.bounds().unwrap(); + let faces = |rule| vectorcraft_three_d::revolve(&both, b, Revolve { fill_rule: rule, ..revolve_options(&p) }).unwrap().len(); + let (drawn, other) = (faces(FillRule::EvenOdd), faces(FillRule::NonZero)); + assert_ne!(drawn, other, "the two rules draw different faces"); + // A gradient whose copies fit on the faces of one rule and not on those of the other. + let gradient = |n: usize| { + let stops = (0..n).map(|i| GradientStop::new(i as f32 / n as f32, Color::BLACK)).collect(); + Paint::Gradient(Box::new(GradientPaint::new(Gradient::new(GradientKind::Linear, stops)))) + }; + let target = MAX_PAINT_COPIES / 4 * 2 / (drawn + other); + let paint = gradient(target / std::mem::size_of::()); + let bytes = paint_bytes(&paint); + let fits = |faces: usize| faces * 4 * bytes <= MAX_PAINT_COPIES; + assert_ne!(fits(drawn), fits(other), "{bytes} bytes per copy on {drawn} and {other} faces"); + // The surface is drawn on the even-odd faces, so validation counts the copies on them. + let expected = if fits(drawn) { + Ok(()) + } else { + Err("Revolve paint is too complex for this surface; reduce Segments or simplify the gradient".to_string()) + }; + let shape = |effects: Vec| { + let mut fill = AppearanceItem::Fill(FillLayer::new(paint.clone())); + fill.effects_mut().extend(effects); + crate::group::shape_node(NodeId(1), both.clone(), FillRule::EvenOdd, Appearance { items: vec![fill], ..Default::default() }) + }; + let revolve = || crate::new_effect(REVOLVE, &p).unwrap(); + let mut object = shape(vec![]); + assert_eq!(validate_revolve(&object, &p), expected, "an object"); + object.appearance.effects.push(revolve()); + assert_eq!(revolve_art(&object).is_some(), expected.is_ok(), "the object's surface draws when it is accepted"); + let group = group_with(p.clone(), vec![Arc::new(shape(vec![]))]); + assert_eq!(validate_revolve(&group, &p), expected, "a group's member"); + assert_eq!(revolve_art(&group).is_some(), expected.is_ok(), "the group's surface draws when it is accepted"); + let item = shape(vec![revolve()]); + assert_eq!(validate_item_of(None, &item, REVOLVE, &p, 0, 0), expected, "a fill's Revolve"); + } + /// Is `u` the underlay [`crate::lighting::underlay`] draws for `face`, a face [`surface`] draws? fn underlies(u: &Node, face: &Node) -> bool { match (&u.kind, &face.kind) { diff --git a/crates/engine/Cargo.toml b/crates/engine/Cargo.toml index b9e21f6fab..075211dc1a 100644 --- a/crates/engine/Cargo.toml +++ b/crates/engine/Cargo.toml @@ -41,7 +41,7 @@ vectorcraft-eps = { workspace = true } vectorcraft-metafile = { workspace = true } vectorcraft-plugins = { workspace = true } vectorcraft-affinity = { workspace = true } -vectorcraft-cdr = { workspace = true } +craft-cdr = { workspace = true } vectorcraft-scriptcheck = { workspace = true } vectorcraft-js = { workspace = true } # The commands' parameter schemas (schemas.rs). @@ -96,7 +96,7 @@ craft-jxl = { workspace = true } hayro-ccitt = { workspace = true } craft-stream-codecs = { workspace = true } vectorcraft-affinity = { workspace = true, features = ["synth"] } -vectorcraft-cdr = { workspace = true, features = ["synth"] } +craft-cdr = { workspace = true, features = ["synth"] } crc32fast = { workspace = true } vectorcraft-testkit = { workspace = true } proptest = { workspace = true } diff --git a/crates/engine/src/cmd/appearance.rs b/crates/engine/src/cmd/appearance.rs index 3b23d62634..037983da5c 100644 --- a/crates/engine/src/cmd/appearance.rs +++ b/crates/engine/src/cmd/appearance.rs @@ -67,7 +67,7 @@ pub fn specs() -> Vec { "Clear Appearance", ["Window", "Appearance"], None, - "{ids?|id?, target?} leave each object one empty fill and stroke (None; a group none of its own) and reset its opacity and blend mode. On a path directly in a graph series (a series group's id stands for those paths and the group), the graph also stores the paint, weight, opacity and blend mode of the topmost visible fill and stroke and the object's opacity and blend mode (exceptions, and the art of a graph design in a series, which is left out: docs/mcp.md); on a graph label, or a graph's axis line, tick mark or radar ring (a graph's Axes group stands for the lines and labels directly in it, its Legend group for the labels), the graph stores that object's topmost visible fill and stroke rows and object opacity and blend mode for every label or line of its kind", + "{ids?|id?, target?} leave each object one empty fill and stroke (None; a group none of its own; in the contents of a Live Paint group, a face one empty fill and an edge one empty stroke) and reset its opacity and blend mode. On a path directly in a graph series (a series group's id stands for those paths and the group), the graph also stores the paint, weight, opacity and blend mode of the topmost visible fill and stroke and the object's opacity and blend mode (exceptions, and the art of a graph design in a series, which is left out: docs/mcp.md); on a graph label, or a graph's axis line, tick mark or radar ring (a graph's Axes group stands for the lines and labels directly in it, its Legend group for the labels), the graph stores that object's topmost visible fill and stroke rows and object opacity and blend mode for every label or line of its kind", has_doc, clear_appearance ), @@ -76,7 +76,7 @@ pub fn specs() -> Vec { "Reduce to Basic Appearance", ["Window", "Appearance"], None, - "{ids?|id?, target?} keep only one visible fill and stroke (without ids: the Appearance panel's active row in place of the topmost one of its kind; else the topmost), without their own opacity, blend mode or effects (a group keeps no rows it lacked), and drop the object's effects. On a path directly in a graph series (a series group's id stands for those paths and the group), the graph also stores the paint, weight, opacity and blend mode of the topmost visible fill and stroke (exceptions, and the art of a graph design in a series, which is left out: docs/mcp.md); on a graph label, or a graph's axis line, tick mark or radar ring (a graph's Axes group stands for the lines and labels directly in it, its Legend group for the labels), the graph stores that object's topmost visible fill and stroke rows and object opacity and blend mode for every label or line of its kind (of a line, only what the edit changes)", + "{ids?|id?, target?} keep only one visible fill and stroke (without ids: the Appearance panel's active row in place of the topmost one of its kind; else the topmost), without their own opacity, blend mode or effects (a group keeps no rows it lacked; in the contents of a Live Paint group, a face keeps only the fill and an edge only the stroke), and drop the object's effects. On a path directly in a graph series (a series group's id stands for those paths and the group), the graph also stores the paint, weight, opacity and blend mode of the topmost visible fill and stroke (exceptions, and the art of a graph design in a series, which is left out: docs/mcp.md); on a graph label, or a graph's axis line, tick mark or radar ring (a graph's Axes group stands for the lines and labels directly in it, its Legend group for the labels), the graph stores that object's topmost visible fill and stroke rows and object opacity and blend mode for every label or line of its kind (of a line, only what the edit changes)", has_doc, reduce_basic ), @@ -529,6 +529,24 @@ pub(crate) fn contents_skipped(s: &Session, p: &Value, fill: bool) -> Result Result<(HashSet, HashSet)> { + if !targets_contents(p)? { + return Ok((HashSet::new(), HashSet::new())); + } + let (faces, edges, _) = super::paint::live_paint_split(&s.doc()?.doc, &appearance_roots(s, p)?); + Ok((faces, edges)) +} + +/// Remove from `n` its stroke rows (`fill`) or its fill rows: a Live Paint face draws fills and an edge strokes. +pub(crate) fn keep_rows_of_kind(n: &mut Node, fill: bool) { + if n.appearance.items.iter().any(|it| it.is_fill() != fill) { + n.appearance.items.retain(|it| it.is_fill() == fill); + } +} + /// The refusal of an appearance edit whose targets are all the art of graph designs drawn in graph series. const DESIGN_ART: &str = "the art of a graph design in a graph series is drawn again from the design: edit the design to change it"; @@ -1044,12 +1062,17 @@ fn add_item(s: &mut Session, p: &Value, fill: bool) -> Result { fn clear_appearance(s: &mut Session, p: &Value) -> Result { let ids = require_whole_targets(s, p, "appearance.clear")?; + let (faces, edges) = contents_parts(s, p)?; // When every object is cleared already, the document and its undo history stay as they are. let before = s.doc()?.doc.clone(); super::overprint::edit_counted(s, "Clear Appearance", |d| { for id in &ids { if let Some(n) = d.node_mut(*id) { clear(n); + // A Live Paint group's face keeps an empty fill and its edge an empty stroke. + if faces.contains(id) || edges.contains(id) { + keep_rows_of_kind(n, faces.contains(id)); + } super::object::snap_if_aligned(n); } } @@ -1284,6 +1307,7 @@ fn is_group(n: &Node) -> bool { fn reduce_basic(s: &mut Session, p: &Value) -> Result { let ids = require_whole_targets(s, p, "appearance.reduceToBasic")?; + let (faces, edges) = contents_parts(s, p)?; // When every object comes out as it was, the document and its undo history stay as they are. let before = s.doc()?.doc.clone(); // The Appearance panel's active row (a row of the first selected object's stack, and in each @@ -1322,6 +1346,10 @@ fn reduce_basic(s: &mut Session, p: &Value) -> Result { st.blend = BlendMode::Normal; n.appearance.items.push(AppearanceItem::Stroke(st)); } + // A Live Paint group's face keeps only its fill and its edge only its stroke. + if faces.contains(id) || edges.contains(id) { + keep_rows_of_kind(n, faces.contains(id)); + } super::object::snap_if_aligned(n); } } diff --git a/crates/engine/src/cmd/brushsym.rs b/crates/engine/src/cmd/brushsym.rs index fbd4512fa3..580f2d7a30 100644 --- a/crates/engine/src/cmd/brushsym.rs +++ b/crates/engine/src/cmd/brushsym.rs @@ -48,7 +48,7 @@ use dynamic::{symbol_instance_reset, symbol_instance_select_part, symbol_instanc use symbolism::symbol_set_density; use symbols::selected_instances; pub(crate) use symbols::{ - expand_instances_under, expandable_instances, instance_in_place, natural_size, normalize, place_xf, set_natural_size, store_symbol, + Placement, expand_instances_under, expandable_instances, instance_in_place, natural_size, normalize, place_xf, set_natural_size, store_symbol, stored_natural_size, }; use symbols::{ @@ -234,7 +234,7 @@ pub fn specs() -> Vec { "Place Symbol Instance", [], None, - "{name?, x?, y?} place an instance so its registration point is at (x, y) (default: artboard centre; name default: current) → {id}", + "{name?, x?, y?} place an instance so its registration point is at (x, y) (default: artboard centre; name default: current), on top of the current layer, or in Draw Behind directly below the bottommost selected object (at the bottom of the current layer with nothing selected) → {id}", has_doc, symbol_place ), diff --git a/crates/engine/src/cmd/brushsym/symbols.rs b/crates/engine/src/cmd/brushsym/symbols.rs index 14e52ffe4f..ac85e71de4 100644 --- a/crates/engine/src/cmd/brushsym/symbols.rs +++ b/crates/engine/src/cmd/brushsym/symbols.rs @@ -33,6 +33,40 @@ pub(crate) fn place_xf(at: Point, (w, h): (f64, f64), reg: SymbolRegistration) - Affine::translate(c.to_vec2()) * Affine::scale_non_uniform(w / (2.0 * HALF), h / (2.0 * HALF)) } +/// Where a placed symbol instance goes in the active document, worked out before the edit from +/// the drawing mode, the selection and the layer new art goes into. +pub(crate) struct Placement { + parent: Option, + behind: bool, + anchor: Option, +} + +impl Placement { + /// On top of the layer new art goes into; in Draw Behind, directly below the bottommost + /// selected object (beside the compound path that holds it), or at the bottom of that layer + /// when nothing is selected. An error when that layer is locked or hidden. + pub(crate) fn of(s: &Session) -> Result { + let st = s.doc()?; + let parent = st.target_parent()?; + let behind = s.draw_mode == crate::DrawMode::Behind; + let compound_of = |id: NodeId| st.doc.parent_of(id).filter(|p| st.doc.node(*p).is_some_and(|n| matches!(n.kind, NodeKind::Compound { .. }))); + let anchor = behind.then(|| st.selection.in_paint_order(&st.doc).first().copied()).flatten().map(|id| compound_of(id).unwrap_or(id)); + Ok(Self { parent, behind, anchor }) + } + + /// Inserts instance `n` where this placement puts it. In a clip group or a clipping layer the + /// clipping path stays at the bottom. + pub(crate) fn insert(&self, d: &mut Document, n: Node) -> Result { + let (parent, index) = match (self.behind, self.anchor.and_then(|a| d.position(a))) { + (false, _) => return Ok(d.insert(self.parent, usize::MAX, n)?), + (true, Some((par, i, _))) => (par, i), + (true, None) => (self.parent, 0), + }; + let floor = usize::from(parent.and_then(|p| d.node(p)).is_some_and(Node::clips)); + Ok(d.insert(parent, index.max(floor), n)?) + } +} + fn registration_param(p: &Value, cmd: &str) -> Result> { match p.get("registration") { None => Ok(None), @@ -437,10 +471,10 @@ pub(super) fn symbol_place(s: &mut Session, p: &Value) -> Result { let at = Point::new(number_or(p, "x", centre.x, "symbol.place")?, number_or(p, "y", centre.y, "symbol.place")?); let size = natural_size(d, &name); let reg = d.symbol_registration(&name); - let parent = s.doc()?.target_parent()?; + let spot = Placement::of(s)?; let id = s.edit("Place Symbol Instance", |d, sel| { let id = d.alloc_id(); - d.insert(parent, usize::MAX, Node::new(id, NodeKind::SymbolInstance { symbol: name.clone(), xf: place_xf(at, size, reg) }))?; + spot.insert(d, Node::new(id, NodeKind::SymbolInstance { symbol: name.clone(), xf: place_xf(at, size, reg) }))?; sel.set([id]); Ok(id) })?; diff --git a/crates/engine/src/cmd/effectcmd.rs b/crates/engine/src/cmd/effectcmd.rs index edb5561796..cb399eca1c 100644 --- a/crates/engine/src/cmd/effectcmd.rs +++ b/crates/engine/src/cmd/effectcmd.rs @@ -97,7 +97,7 @@ fn effect_specs() -> Vec { "Expand Appearance", ["Object"], None, - "{ids?|id?: [..], target?} turn each object's appearance into objects: every fill and stroke becomes an object of its own (a stroke stays a stroke, with its weight, dashes, arrowheads and width profile, on its own copy of the path, which object.expand or object.path.outlineStroke outline; brushed strokes become their brush art) grouped in paint order under the object's id and transparency, geometry effects are baked, raster effects become an embedded image (shadows and outer glows below the art; blur, feather and inner glow replace it; an object whose only raster effect is its own Rasterize becomes the image object.rasterize makes with the effect's options), type with effects or fills of its own is outlined; Crop Marks become a group of the object and its marks; Vector Halftone (addon.color.halftone) becomes a group of its dot paths, one per ink; a group's or layer's own fills and strokes become objects among its members, which are expanded too; a symbol instance whose topmost fill or stroke is visible, has an opacity above 0 and has a geometry or raster effect becomes a group of its art, that fill's effects reshaping the art's filled shapes and that stroke's effects reshaping its stroked shapes, as the canvas draws them, its raster effects an image as for other objects; a symbol instance in that art whose topmost fill or stroke has such an effect (its own or one the outer instance passes on) becomes its art and image in turn. An outlined frame of threaded text leaves its thread with the text it shows, and a frame kept as type in a group stays in its thread. A dimension whose art it changes becomes a plain group of its art, except one selected with art it measures, directly or in groups without fills, strokes or effects of their own: its lines and label stay as they are, and if the new art no longer fits its link it stays where it was, no longer linked. Hidden fills, strokes and effects are dropped. One expansion makes at most 1,024 images of raster effects, 256 megapixels in all (VectorCraft's own limits): an object or symbol instance whose image would go past them stays as it is, with its effects, and when nothing else expands that is an error. In Safe Mode, an object with a visible plug-in effect (in it, or in a symbol it places) is an error and nothing changes. Enabled when a selected or targeted object's appearance isn't basic (`ids` then pick which objects) → {ids, warning? (an image in the art couldn't be decoded, as object.rasterize says; or raster effects were left past the limits), rasterLeft? (how many objects were left so)}", + "{ids?|id?: [..], target?} turn each object's appearance into objects: every fill and stroke becomes an object of its own (a stroke stays a stroke, with its weight, dashes, arrowheads and width profile, on its own copy of the path, which object.expand or object.path.outlineStroke outline; brushed strokes become their brush art) grouped in paint order under the object's id and transparency, geometry effects are baked, raster effects become an embedded image (shadows and outer glows below the art; blur, feather and inner glow replace it; an object whose only raster effect is its own Rasterize becomes the image object.rasterize makes with the effect's options), type with effects or fills of its own is outlined; Crop Marks become a group of the object and its marks; Vector Halftone (addon.color.halftone) becomes a group of its dot paths, one per ink; a group's or layer's own fills and strokes become objects among its members, which are expanded too; a symbol instance whose topmost fill or stroke is visible, has an opacity above 0 and has a geometry or raster effect becomes a group of its art, that fill's effects reshaping the art's filled shapes and that stroke's effects reshaping its stroked shapes, as the canvas draws them, its raster effects an image as for other objects; a symbol instance in that art whose topmost fill or stroke has such an effect (its own or one the outer instance passes on) becomes its art and image in turn. An outlined frame of threaded text leaves its thread with the text it shows, and a frame kept as type in a group stays in its thread. A dimension whose art it changes becomes a plain group of its art, except one selected with art it measures, directly or in groups without fills, strokes or effects of their own: its lines and label stay as they are, and if the new art no longer fits its link it stays where it was, no longer linked. Hidden fills, strokes and effects are dropped. One expansion makes at most 1,024 images of raster effects, 256 megapixels in all (VectorCraft's own limits): an object or symbol instance whose image would go past them stays as it is, with its effects, and when nothing else expands that is an error. In Safe Mode, an object with a visible plug-in effect (in it, or in a symbol it places, a plain instance in a group or layer whose raster effect makes an image of it included) is an error and nothing changes. Enabled when a selected or targeted object's appearance isn't basic (`ids` then pick which objects) → {ids, warning? (an image in the art couldn't be decoded, as object.rasterize says; or raster effects were left past the limits), rasterLeft? (how many objects were left so)}", can_expand, expand_appearance ), @@ -1611,13 +1611,18 @@ fn expanded_node( /// Does `n`, an object in it, or the art of a symbol placed in it hold a plug-in effect that /// expanding it draws: a visible one, the object's own or a visible fill's or stroke's, on an -/// object that expands ([`expandable`]; in a symbol's art, `in_art`, every object does). A symbol's +/// object that expands ([`expandable`]; in a symbol's art, `in_art`, every object does, and so does +/// every object in a group or layer with a raster effect, whose image draws all of it). A symbol's /// art counts where an instance of it expands. `seen` holds the symbols already looked into. fn holds_plugin_effect(d: &Document, n: &Node, in_art: bool, seen: &mut std::collections::HashSet) -> bool { let plugin = |e: &Effect| e.visible && vectorcraft_plugins::effect::plugin_id(&e.id).is_some(); let mut symbols = vec![]; + let mut drawn = vec![]; let mut holds = false; n.walk(&mut |c| { + if !in_art && is_container(c) && !rasterfx::raster_fx(c).is_empty() { + drawn.push(c); + } if !in_art && !expandable(c) { return; } @@ -1627,6 +1632,7 @@ fn holds_plugin_effect(d: &Document, n: &Node, in_art: bool, seen: &mut std::col } }); holds + || drawn.into_iter().any(|g| holds_plugin_effect(d, g, true, seen)) || symbols.into_iter().any(|name| { seen.insert(name.clone()) && d.symbols.iter().find(|s| s.name == name).is_some_and(|s| holds_plugin_effect(d, &s.art, true, seen)) }) diff --git a/crates/engine/src/cmd/fileio/cdr.rs b/crates/engine/src/cmd/fileio/cdr.rs index aaa3f46ad0..c341f03e69 100644 --- a/crates/engine/src/cmd/fileio/cdr.rs +++ b/crates/engine/src/cmd/fileio/cdr.rs @@ -1,7 +1,7 @@ //! `.cdr` drawings of versions 1 to 27 (`.cdr`, and `.cdt` templates): the pages, layers, //! guidelines, groups, curves, rectangles, ellipses, arcs and polygons with uniform fills and //! outlines, their hidden and locked states, fill rules and uniform transparency that -//! `vectorcraft-cdr` reads, mapped to editable VectorCraft art. Pages become +//! `craft-cdr` reads, mapped to editable VectorCraft art. Pages become //! artboards side by side; layers of the same name on different pages become one layer where the //! pages stack them in the same order. What the //! reader leaves out is listed in the warnings, one line for each kind ([`note`]). `.cmx` exchange @@ -10,9 +10,9 @@ use std::collections::HashMap; use std::sync::Arc; +use craft_cdr::model::{self as cd, LayerKind}; +use craft_cdr::{Limits, Warning}; use kurbo::{Affine, Rect}; -use vectorcraft_cdr::model::{self as cd, LayerKind}; -use vectorcraft_cdr::{Limits, Warning}; use vectorcraft_doc::{Artboard, ColorMode, Document, Guide, LayerColor, Node, NodeKind}; use super::load::err; @@ -92,12 +92,12 @@ const MAX_LAYERS: usize = 10_000; /// Is `bytes` a `.cdr` drawing this importer reads? pub(super) fn is_cdr(bytes: &[u8]) -> bool { - vectorcraft_cdr::is_cdr(bytes) + craft_cdr::is_cdr(bytes) } pub(super) fn import(bytes: &[u8]) -> Result<(Document, Vec)> { - let d = vectorcraft_cdr::read(bytes, Limits::default()).map_err(|e| match e { - vectorcraft_cdr::Error::Version(v) => { + let d = craft_cdr::read(bytes, Limits::default()).map_err(|e| match e { + craft_cdr::Error::Version(v) => { let version = v / 100; err(format!("CDR {version} drawings can't be opened: VectorCraft reads versions 1 to 27")) } @@ -108,13 +108,13 @@ pub(super) fn import(bytes: &[u8]) -> Result<(Document, Vec)> { /// Is `bytes` a `.cmx` file, of any byte order or coordinate size? pub(super) fn is_cmx(bytes: &[u8]) -> bool { - vectorcraft_cdr::is_cmx(bytes) + craft_cdr::is_cmx(bytes) } /// A `.cmx` file with 32-bit coordinates: its pages, layers, groups and curves with uniform fills /// and outlines, mapped as a `.cdr` drawing's are. pub(super) fn import_cmx(bytes: &[u8]) -> Result<(Document, Vec)> { - let d = vectorcraft_cdr::read_cmx(bytes, Limits::default()).map_err(|why| err(format!("this CMX file can't be read ({why})")))?; + let d = craft_cdr::read_cmx(bytes, Limits::default()).map_err(|why| err(format!("this CMX file can't be read ({why})")))?; Ok(build(&d, cmx_note, CMX_PAGES_CUT)) } diff --git a/crates/engine/src/cmd/fileio/cdr/shapes.rs b/crates/engine/src/cmd/fileio/cdr/shapes.rs index 6427d49e97..320fda877c 100644 --- a/crates/engine/src/cmd/fileio/cdr/shapes.rs +++ b/crates/engine/src/cmd/fileio/cdr/shapes.rs @@ -4,9 +4,9 @@ use std::collections::HashMap; use std::sync::Arc; +use craft_cdr::Warning; +use craft_cdr::model::{self as cd, Geometry}; use kurbo::{Affine, BezPath, Point, Rect}; -use vectorcraft_cdr::Warning; -use vectorcraft_cdr::model::{self as cd, Geometry}; use vectorcraft_color::swatch::REGISTRATION; use vectorcraft_color::{BlendMode, Color, Paint, Swatch}; use vectorcraft_doc::appearance::{Appearance, AppearanceItem, Dash, FillLayer, LineCap, LineJoin, StrokeLayer}; diff --git a/crates/engine/src/cmd/fileio/formats.rs b/crates/engine/src/cmd/fileio/formats.rs index 3b520d5635..0db990ad4c 100644 --- a/crates/engine/src/cmd/fileio/formats.rs +++ b/crates/engine/src/cmd/fileio/formats.rs @@ -533,11 +533,11 @@ pub const FORMATS: &[Format] = &[ // jxl-oxide reads a JPEG XL file's first frame, which is stored as PNG. Exports don't write it. reader("jxl", "JPEG XL", &["jxl"], "image/jxl", true), // `.cdr` drawings of versions 1 to 27 (`WL` files, RIFF files from version 3, and the ZIP packages of 14 on), read by - // `vectorcraft-cdr`; a `.cdt` template opens as a new untitled document. Exports don't write + // `craft-cdr`; a `.cdt` template opens as a new untitled document. Exports don't write // them. reader("cdr", "CDR Drawing", &["cdr"], "application/vnd.corel-draw", false), // brand-ok: shared MIME type reader("cdt", "CDR Template", &["cdt"], "application/vnd.corel-draw", false), // brand-ok: shared MIME type - // `.cmx` exchange files with 32-bit coordinates, read by `vectorcraft-cdr`; exports don't write + // `.cmx` exchange files with 32-bit coordinates, read by `craft-cdr`; exports don't write // them. reader("cmx", "CMX", &["cmx"], "image/x-cmx", false), // QuickDraw pictures, read by `vectorcraft_metafile::import_pict` into paths, type and images. diff --git a/crates/engine/src/cmd/fileio/tests_cdr.rs b/crates/engine/src/cmd/fileio/tests_cdr.rs index a8782eca89..2645e86c76 100644 --- a/crates/engine/src/cmd/fileio/tests_cdr.rs +++ b/crates/engine/src/cmd/fileio/tests_cdr.rs @@ -2,8 +2,8 @@ //! artboards, layers, guides, live shapes, solid paint and strokes. use super::*; +use craft_cdr::synth::{self, V, chunk, list}; use serde_json::json; -use vectorcraft_cdr::synth::{self, V, chunk, list}; use vectorcraft_doc::{LiveShape, Node, NodeKind}; fn walk(nodes: &[std::sync::Arc], out: &mut Vec) { diff --git a/crates/engine/src/cmd/fileio/tests_cmx.rs b/crates/engine/src/cmd/fileio/tests_cmx.rs index 527c0be1be..f353caa008 100644 --- a/crates/engine/src/cmd/fileio/tests_cmx.rs +++ b/crates/engine/src/cmd/fileio/tests_cmx.rs @@ -2,8 +2,8 @@ //! paths, solid paint and strokes, with their warnings and refusals. use super::*; +use craft_cdr::synth_cmx::*; use serde_json::json; -use vectorcraft_cdr::synth_cmx::*; use vectorcraft_doc::{Node, NodeKind}; fn paths(nodes: &[std::sync::Arc], out: &mut Vec) { diff --git a/crates/engine/src/cmd/kinsokusets/tests.rs b/crates/engine/src/cmd/kinsokusets/tests.rs index 1d1c8980c0..04456872b2 100644 --- a/crates/engine/src/cmd/kinsokusets/tests.rs +++ b/crates/engine/src/cmd/kinsokusets/tests.rs @@ -332,6 +332,36 @@ fn pasted_type_brings_its_kinsoku_sets() { assert_eq!(style_set(&s), Value::Null); } +/// Type pasted back after its set was edited breaks its lines by the set as it is now: with B in +/// Cannot End Line the first line of `A B C` ends at A, and once the set holds nothing, it ends at B. +#[test] +fn pasted_type_relayouts_after_its_kinsoku_set_was_edited() { + let mut s = session(); + s.execute("type.kinsokuSets.set", &json!({"sets": [{"name": "Tight", "cannotEnd": "B"}]})).unwrap(); + let create = json!({"x": 10, "y": 10, "text": "A B C", "size": 20, "font": "JetBrains Mono", "area": {"width": 40, "height": 120}}); + let id = s.execute("text.create", &create).unwrap()["id"].as_u64().unwrap(); + s.execute("select.set", &json!({"ids": [id]})).unwrap(); + s.execute("text.setFormat", &json!({"kinsoku": "Tight"})).unwrap(); + let lines = |t: &vectorcraft_doc::TextObject| t.baselines().collect::>(); + let first_width = |t: &vectorcraft_doc::TextObject| t.baselines().next().map(|(a, b)| b.x - a.x).unwrap_or_default(); + let copied = text(&s, id); + s.execute("edit.copy", &json!({})).unwrap(); + s.execute("type.kinsokuSets.set", &json!({"sets": [{"name": "Tight"}]})).unwrap(); + // The set's edit lays the type in the document out anew, and its first line takes B. + let edited = text(&s, id); + assert_eq!(lines(&edited).len(), 2); + assert!(first_width(&edited) > first_width(&copied), "{:?} against {:?}", lines(&edited), lines(&copied)); + + let v = s.execute("edit.paste", &json!({})).unwrap(); + let t = text(&s, v["ids"][0].as_u64().unwrap()); + let now = s.doc().unwrap().doc.kinsoku_sets[0].clone(); + assert_eq!(t.para_at(0).kinsoku_set.as_deref(), Some(&now)); + let mut fresh = t.clone(); + crate::cmd::typecmd::refresh_bounds(&mut fresh); + assert_eq!(lines(&t), lines(&fresh), "the pasted type is laid out with the edited set"); + assert_eq!(first_width(&t), first_width(&edited)); +} + /// A pasted set whose name, at the longest a name can be, the document's set with other /// characters already has comes in under a free name that fits: the number takes the place of the /// name's last characters, and a space left at the end of them is dropped. A second paste uses diff --git a/crates/engine/src/cmd/retype.rs b/crates/engine/src/cmd/retype.rs index 174d77c4a9..b0d37a1d61 100644 --- a/crates/engine/src/cmd/retype.rs +++ b/crates/engine/src/cmd/retype.rs @@ -13,8 +13,14 @@ //! per line of glyphs, with the first glyph's fill and stroke. A line whose glyphs are evenly spaced //! apart takes that spacing as its tracking ([`Line::tracked`]), and lines stacked at one leading //! and lined up at their starts, ends or centers become one area type object ([`blocks`]). Shapes -//! that match no font stay as they are and are reported. Near matches (another version of the -//! font, simplified outlines, merged glyphs) and images are phase 2. +//! that match no font stay as they are and are reported. +//! +//! With a `tolerance`, a shape that matches no glyph exactly may still nearly match one: another +//! version of the font, or the outline simplified or built another way +//! ([`RetypeIndex::near_matches`]); each line reports how closely its glyphs fit. A compound path +//! holding several glyphs (a word outlined as one path) is split into its glyphs +//! ([`vectorcraft_text::retype::clusters`]), and becomes type only when every one of them does. +//! The tolerance, the score and the splitting rules are VectorCraft's own. Images are phase 2. use std::f64::consts::{PI, TAU}; use std::sync::Arc; @@ -22,6 +28,7 @@ use std::sync::Arc; use kurbo::{BezPath, Point, Vec2}; use serde_json::{Value, json}; use vectorcraft_doc::{Appearance, CharStyle, Document, Node, NodeId, NodeKind, TextObject}; +use vectorcraft_geom::FillRule; use vectorcraft_text::FontDb; use vectorcraft_text::retype::{GlyphMatch, RetypeIndex}; @@ -41,7 +48,7 @@ pub fn specs() -> Vec { "Retype", ["Type"], None, - "{fonts?: [family…]} turn the selected outlined text (glyph paths and compound paths, inside groups too) back into live type: each shape is matched against the glyphs of the fonts the app has loaded, the document's fonts and the families in fonts, the same up to uniform scale, rotation and translation (exact matches only); matched glyphs become point text in that font and size at the same baseline, one object per line unless lines stack into one (below), with the first glyph's fill, stroke, opacity and blend mode, in one undo step; a line of three or more glyphs takes the spacing most of its gaps share as its tracking (pair kerning left out) when tracked type draws all of it in place, or more of it than untracked type (when untracked type also draws it, untracked type is kept if the tracking is under one unit or the tracked type would drop a gap one space wide (a b c keeps its spaces), and the tracked type otherwise), and negative tracking only when the line is opaque, Normal, with a solid fill or none and no stroke (its glyphs may overlap); lines that follow each other in paint order with the same group, paint, font, size, turn and tracking (an untracked line of one or two glyphs takes the others' tracking), each one the same leading (0.25 to 3 times the size) below the one before, and lined up at their starts, ends or centers become one area type object with that leading (Auto when Auto gives it) and left, right or center alignment, or one multi-line point type object when area type (after Text Wrap) would not draw the outlines' glyphs in their places or when checking the Text Wrap objects on the changed layers would copy more than 2,000,000 anchors, subpaths and shapes; where even that type would move a glyph, the lines before that glyph's line stay one object and the rest are joined again from that line; lines with an opacity below 100%, a blend mode other than Normal, a gradient or pattern fill or a stroke stay one object each; a line splits where its type would not draw the outlines' glyphs in their places (uneven spacing, manual kerning, font substitutions); shapes that match no font, glyphs type cannot draw as they are, and shapes with their own opacity mask stay as they are → {ids (the new type), texts (lines joined by \\n), fonts: [{family, style, size, tracking (1/1000 em), leading (pt, null for Auto or one line), area (bool)}], unmatched: [id…], truncated (shapes past the limits of 2048 shapes or 16 nested groups were left out)}; an error when no shape matches", + "{fonts?: [family…], tolerance?: 0..0.05 (default 0: exact matches only)} turn the selected outlined text (glyph paths and compound paths, inside groups too) back into live type: each shape is matched against the glyphs of the fonts the app has loaded, the document's fonts and the families in fonts, the same up to uniform scale, rotation and translation; with a tolerance above 0, a shape that is no glyph exactly may nearly be one (an outline simplified, a curve split in two, contours in another order, start or direction) when its leftover distance from the glyph, relative to the shape's outline spread (the root mean square distance of its sampled outline points from their center), is at most the tolerance (VectorCraft's own measure; shapes of at most 8 contours); a compound path holding several glyphs (a word outlined as one path, at most 256 contour groups, 512 contours and 65,536 path elements, and 16,384 contours per command) is split into them, and becomes type only when every one of them matches; matched glyphs become point text in that font and size at the same baseline, one object per line unless lines stack into one (below), with the first glyph's fill, stroke, opacity and blend mode, in one undo step; a line of three or more exactly matched glyphs takes the spacing most of its gaps share as its tracking (pair kerning left out) when tracked type draws all of it in place, or more of it than untracked type (when untracked type also draws it, untracked type is kept if the tracking is under one unit or the tracked type would drop a gap one space wide (a b c keeps its spaces), and the tracked type otherwise), and negative tracking only when the line is opaque, Normal, with a solid fill or none and no stroke (its glyphs may overlap); lines that follow each other in paint order with the same group, paint, font, size, turn and tracking (an untracked line of one or two glyphs takes the others' tracking), each one the same leading (0.25 to 3 times the size) below the one before, and lined up at their starts, ends or centers become one area type object with that leading (Auto when Auto gives it) and left, right or center alignment, or one multi-line point type object when area type (after Text Wrap) would not draw the outlines' glyphs in their places or when checking the Text Wrap objects on the changed layers would copy more than 2,000,000 anchors, subpaths and shapes; where even that type would move a glyph, the lines before that glyph's line stay one object and the rest are joined again from that line; lines with an opacity below 100%, a blend mode other than Normal, a gradient or pattern fill or a stroke stay one object each; a line splits where its type would not draw the outlines' glyphs in their places (uneven spacing, manual kerning, font substitutions; with a tolerance, within it), and before a near-matched glyph the line's size and turn would draw further from its shape than the tolerance; a glyph must also paint the area the shape paints under its fill rule (a nonzero compound whose inner contour runs the same way as its outer one paints its center, so a ring glyph does not replace it; a counter narrower than three times the outline tolerance across in some direction, an outline too large to check, or parts of a split compound that overlap where its fill rule leaves the overlap unpainted, or that overlap at all when the compound has an opacity below 100%, a blend mode other than Normal, a gradient or pattern fill or a stroke, also keep the shape an outline); shapes that match no font, glyphs type cannot draw as they are, and shapes with their own opacity mask stay as they are → {ids (the new type), texts (lines joined by \\n), fonts: [{family, style, size, tracking (1/1000 em), leading (pt, null for Auto or one line), area (bool), score (how closely the line's least close glyph fits, 1 for exact, 0 at a leftover distance of 0.05)}], unmatched: [id…] (shapes that stayed as they are when another shape became type), truncated (shapes past the limits of 2048 shapes or 16 nested groups were left out)}; an error, with no unmatched list, when no shape becomes type, or when tolerance is not a number from 0 to 0.05", has_selected_path, retype )] @@ -60,6 +67,10 @@ struct Piece { /// art must stay painted after it: the line ends here. after_barrier: bool, path: BezPath, + /// The shape is filled by the nonzero rule, not the even-odd rule. + nonzero: bool, + /// The shape has a visible fill: a shape that only has a stroke paints no area to compare. + filled: bool, appearance: Appearance, /// The shape's own transparency, which the new type takes. opacity: f32, @@ -83,11 +94,13 @@ fn collect(n: &Node, parent: Option, depth: usize, barrier: &mut bool, t *barrier = true; return; } - let piece = |path: BezPath, after_barrier: bool| Piece { + let piece = |path: BezPath, after_barrier: bool, rule: FillRule| Piece { id: n.id, parent, after_barrier, path, + nonzero: rule == FillRule::NonZero, + filled: n.appearance.fill().is_some_and(|f| f.visible && !f.paint.is_none()), appearance: (*n.appearance).clone(), opacity: n.opacity, blend: n.blend, @@ -100,8 +113,10 @@ fn collect(n: &Node, parent: Option, depth: usize, barrier: &mut bool, t } } // Only closed shapes can be glyphs: an open path stroked along a glyph's outline is not one. - NodeKind::Path { path, clipping: false, guide: false, .. } if path.is_closed() => out.push(piece(path.to_bezpath(), std::mem::take(barrier))), - NodeKind::Compound { children, .. } => { + NodeKind::Path { path, rule, clipping: false, guide: false, .. } if path.is_closed() => { + out.push(piece(path.to_bezpath(), std::mem::take(barrier), *rule)) + } + NodeKind::Compound { children, rule } => { let mut path = BezPath::new(); for c in children { match &c.kind { @@ -113,7 +128,7 @@ fn collect(n: &Node, parent: Option, depth: usize, barrier: &mut bool, t } } } - out.push(piece(path, std::mem::take(barrier))); + out.push(piece(path, std::mem::take(barrier), *rule)); } // Live type, images, clip groups and the rest stay, and the type after them stays after them. _ => *barrier = true, @@ -185,6 +200,9 @@ struct Line { parent: Option, opacity: f32, blend: vectorcraft_color::BlendMode, + /// The tolerance near matches were taken with (0: exact only): a near-matched glyph may differ + /// that much in size, turn and place from the rest of its line ([`Self::slack_for`]). + slack: f64, } impl Line { @@ -192,6 +210,12 @@ impl Line { Vec2::new(self.angle.cos(), self.angle.sin()) } + /// The slack glyph `m` of this line is allowed: [`Self::slack`] when `m` or the line's first + /// glyph, whose size and turn the line takes, is a near match, else 0. + fn slack_for(&self, m: &GlyphMatch) -> f64 { + if m.exact && self.matches.first().is_none_or(|f| f.exact) { 0.0 } else { self.slack } + } + /// Does glyph `m` of shape `pc` continue this line (same group, paint and transparency, same /// font, size and turn, on its baseline, after its end)? fn continues(&self, pc: &Piece, m: &GlyphMatch) -> bool { @@ -199,15 +223,16 @@ impl Line { let d = m.origin - self.origin; let dir = self.dir(); let across = d.cross(dir).abs(); + let slack = self.slack_for(m); pc.parent == self.parent && pc.appearance == self.appearance && pc.opacity == self.opacity && pc.blend == self.blend && m.face.id() == self.face.id() // One size and turn for the whole line: the type sets every glyph at the first one's. - && (m.scale - self.scale).abs() <= self.scale * 1e-4 + && (m.scale - self.scale).abs() <= self.scale * slack.max(1e-4) // Wrapped: type turned 180° has angles near +π and −π. - && ((m.angle - self.angle + PI).rem_euclid(TAU) - PI).abs() < 1e-5 + && ((m.angle - self.angle + PI).rem_euclid(TAU) - PI).abs() < slack.max(1e-5) && across < size * 0.05 // After the line's end, or, for type tracked tighter than that, still ahead of the // last glyph's start (by more than rounding); the layout check decides whether it fits. @@ -319,6 +344,7 @@ impl Line { parent: self.parent, opacity: self.opacity, blend: self.blend, + slack: self.slack, }; for (id, m) in ids.iter().zip(ms).skip(1) { l.push(*id, m); @@ -370,7 +396,7 @@ impl Line { /// (a substitution the font makes) or the same glyph elsewhere (tracking, manual spacing, /// more space than whole spaces make); `None` when the type draws every glyph in its place. fn first_mismatch(&self, t: &TextObject) -> Option { - first_mismatch(t, &self.matches, self.size()) + first_mismatch(t, &self.matches, self.size(), self.slack) } /// Along the line, where its first glyph starts and its last glyph's advance ends, from @@ -395,14 +421,16 @@ impl Line { /// untracked type does. When untracked type with the spaces also draws the whole line, the line stays /// untracked if the tracking is under one unit or the tracked reading drops a gap untracked /// type reads as one space. The line also stays as it is when its tracking is 0 or outside - /// -1000..10000, and when its tracking is negative and the line does not paint the same as one + /// -1000..10000, when one of its glyphs is a near match, and when its tracking is negative and the line does not paint the same as one /// object ([`paints_as_one`]: its glyphs may overlap). Each of the nine layouts at most takes /// its characters, spaces included, from `budget` before it runs; without enough left, the /// line stays as it is, or becomes the best tracked reading laid out before the budget ran out. fn tracked(self, system_layout: bool, budget: &mut usize) -> Line { let size = self.size(); let n = self.pieces.len(); - if n < 3 || size <= 0.0 { + // A near-matched glyph sits within the tolerance of where the font draws it, so the gaps + // of a line with one say nothing about spacing. + if n < 3 || size <= 0.0 || self.matches.iter().any(|m| !m.exact) { return self; } // Each layout takes its characters, spaces included, from `budget` before it runs. @@ -568,10 +596,16 @@ impl Line { /// Normal blend, a solid fill or none, and no stroke? One object composites its transparency and /// blend once, spans a gradient over all of it, and strokes after filling every glyph. fn paints_as_one(l: &Line) -> bool { - l.opacity == 1.0 - && l.blend == vectorcraft_color::BlendMode::Normal - && matches!(l.appearance.fill_paint(), vectorcraft_color::Paint::None | vectorcraft_color::Paint::Solid { .. }) - && matches!(l.appearance.stroke_paint(), vectorcraft_color::Paint::None) + paints_once(l.opacity, l.blend, &l.appearance) +} + +/// Does art with `opacity`, `blend` and `appearance` paint its overlaps the same as one object +/// and as several ([`paints_as_one`])? +fn paints_once(opacity: f32, blend: vectorcraft_color::BlendMode, appearance: &Appearance) -> bool { + opacity == 1.0 + && blend == vectorcraft_color::BlendMode::Normal + && matches!(appearance.fill_paint(), vectorcraft_color::Paint::None | vectorcraft_color::Paint::Solid { .. }) + && matches!(appearance.stroke_paint(), vectorcraft_color::Paint::None) } /// The tracking Retype sets, in 1/1000 em. @@ -596,21 +630,64 @@ fn round_tracking(t: f64) -> f64 { /// The first of `matches` that type `t` (at `size`) does not draw as the outlines did: another /// glyph (a substitution the font makes) or the same glyph elsewhere (tracking, manual spacing, /// more space than whole spaces make); `None` when the type draws every glyph in its place. -fn first_mismatch(t: &TextObject, matches: &[GlyphMatch], size: f64) -> Option { +fn first_mismatch(t: &TextObject, matches: &[GlyphMatch], size: f64, slack: f64) -> Option { let lay = vectorcraft_text::layout(FontDb::global(), t); let mut drawn = lay.glyphs.iter().filter(|g| !g.outline.elements().is_empty()); - let tol = (size * 0.01).max(0.01); + // With a tolerance, a near-matched glyph, or any glyph of a line whose first glyph is one, + // may sit that much further (as a fraction of the size) from where the type draws it. + let first_exact = matches.first().is_none_or(|f| f.exact); for (k, m) in matches.iter().enumerate() { let Some(g) = drawn.next() else { return Some(k) }; + let tol = (size * (0.01 + if m.exact && first_exact { 0.0 } else { slack })).max(0.01); let at = t.xf * (g.xf * Point::ORIGIN); if g.font_id != m.face.id() || g.gid != m.gid || at.distance(m.origin) > tol { return Some(k); } + // The type sets the glyph at its line's size and turn, which may differ from the glyph's + // own: the glyph drawn so must still lie within the tolerance of the shape (its center + // within the same distance as its origin). + if !(m.exact && first_exact) { + let (shape, moved) = set_apart(t, g, m); + // An exact match's own leftover is within the exact matcher's reach, not the tolerance. + let own = if m.exact { 0.0 } else { m.pose_residual }; + if own.hypot(shape) > slack + 1e-9 || moved > tol { + return Some(k); + } + } } // Ink the outlines did not have: the last glyph is where it went wrong. drawn.next().map(|_| matches.len().saturating_sub(1)) } +/// How glyph `g`, as type `t` draws it, differs from glyph `m` in the size, turn and place `m` +/// was matched in. The first value bounds, whatever points the outline is sampled at, the root +/// mean square distance between the two outlines' points about their center, relative to the +/// root mean square distance of `m`'s points from that center (the measure of near matches' +/// leftover distance): the largest stretch of the change from `m`'s size and turn to the drawn +/// one, which for a change of size and turn alone is that distance exactly. The second is how far +/// apart the two draw the center of the glyph's bounding box. Both are infinite when they cannot +/// be measured. +fn set_apart(t: &TextObject, g: &vectorcraft_text::PositionedGlyph, m: &GlyphMatch) -> (f64, f64) { + let (sin, cos) = m.angle.sin_cos(); + let matched = kurbo::Affine::new([m.scale * cos, m.scale * sin, -m.scale * sin, m.scale * cos, m.origin.x, m.origin.y]); + let (gd, md) = (g.xf.determinant(), matched.determinant()); + if !gd.is_finite() || gd.abs() < 1e-12 || !md.is_finite() || md.abs() < 1e-12 { + return (f64::INFINITY, f64::INFINITY); + } + let drawn = t.xf * g.xf; + // The change from the matched glyph to the drawn one, less the identity, without the move. + let [a, b, c, d, _, _] = (drawn * matched.inverse()).as_coeffs(); + let (a, d) = (a - 1.0, d - 1.0); + // The largest singular value of [[a, c], [b, d]]. + let (p, q) = ((a * a + b * b + c * c + d * d) / 2.0, a * d - b * c); + let shape = (p + (p * p - q * q).max(0.0).sqrt()).sqrt(); + // The center of the glyph's box, in font units. + let center = g.xf.inverse() * kurbo::Shape::bounding_box(&g.outline).center(); + let moved = (drawn * center).distance(matched * center); + let finite = |v: f64| if v.is_finite() { v } else { f64::INFINITY }; + (finite(shape), finite(moved)) +} + /// `lines` checked against their own layout: a line splits where its type stops drawing the /// outlines, and a glyph its type cannot draw even on its own stays an outline (`unmatched`). /// The glyphs laid out are bounded by a multiple of the number of glyphs. @@ -739,6 +816,8 @@ struct Made { text: String, face: Arc, size: f64, + /// The tolerance near matches were taken with ([`Line::slack`]). + slack: f64, tracking: f64, /// The leading set on the type: None for Auto or a single line. leading: Option, @@ -756,6 +835,7 @@ impl Made { text: l.text.clone(), face: l.face.clone(), size: l.size(), + slack: l.slack, tracking: l.tracking, leading: None, opacity: l.opacity, @@ -888,7 +968,7 @@ impl Block { t.xf = kurbo::Affine::translate(m.origin - at) * t.xf; } super::typecmd::refresh_bounds(&mut t); - if let Some(k) = first_mismatch(&t, &matches, size) { + if let Some(k) = first_mismatch(&t, &matches, size, first.slack) { // The line that holds glyph `k`. let mut seen = 0usize; let at = self.lines.iter().position(|l| { @@ -917,7 +997,7 @@ impl Block { let mut area = t.clone(); super::typemenu::point_to_area(&mut area); let mut point = None; - if in_range(&area) && first_mismatch(&area, &matches, size).is_none() { + if in_range(&area) && first_mismatch(&area, &matches, size, first.slack).is_none() { point = Some(std::mem::replace(&mut t, area)); } vec![Made { @@ -928,6 +1008,7 @@ impl Block { text: all.text, face: first.face.clone(), size, + slack: first.slack, tracking: all.tracking, leading: set_leading, opacity: first.opacity, @@ -964,7 +1045,7 @@ fn share_tracking(lines: &mut [Line], system_layout: bool) { /// `lines`, in paint order, as the objects Retype makes: runs of lines that stack as the lines of /// one paragraph do become one object ([`Block`]). `follows(a, b)`: shape `b` comes right after -/// shape `a`, with nothing between them in paint order. `budget`: see [`Block::made`]. +/// shape `a`, or is `a`, with nothing between them in paint order. `budget`: see [`Block::made`]. fn blocks(lines: Vec, follows: impl Fn(NodeId, NodeId) -> bool, system_layout: bool, budget: &mut usize) -> Vec { let mut out = vec![]; let mut block: Option = None; @@ -1054,11 +1135,13 @@ fn reposed(l: &Line, id: NodeId, m: &GlyphMatch) -> Line { parent: l.parent, opacity: l.opacity, blend: l.blend, + slack: l.slack, } } -/// A new line of shape `pc` alone, as the first of its candidate glyphs `cands` (none: `None`). -fn new_line(pc: &Piece, cands: &[GlyphMatch]) -> Option { +/// A new line of shape `pc` alone, as the first of its candidate glyphs `cands` (none: `None`), +/// with near matches taken at tolerance `slack`. +fn new_line(pc: &Piece, cands: &[GlyphMatch], slack: f64) -> Option { let m = cands.first()?; let dir = Vec2::new(m.angle.cos(), m.angle.sin()); Some(Line { @@ -1076,18 +1159,344 @@ fn new_line(pc: &Piece, cands: &[GlyphMatch]) -> Option { parent: pc.parent, opacity: pc.opacity, blend: pc.blend, + slack, }) } +/// The lines, by index, to drop so that no shape of several glyphs becomes type in part: each line +/// is given by the shapes it sets, one per glyph, and `glyphs_of` says how many glyphs a shape +/// is. A line setting a glyph of a shape not all of whose glyphs are set goes, and then so do the +/// lines setting the other glyphs of the shapes it held. +fn partial_lines(lines: &[Vec], glyphs_of: &std::collections::HashMap) -> std::collections::HashSet { + let mut dropped = std::collections::HashSet::new(); + loop { + let mut set: std::collections::HashMap = std::collections::HashMap::new(); + for (_, l) in lines.iter().enumerate().filter(|(i, _)| !dropped.contains(i)) { + for id in l { + *set.entry(*id).or_default() += 1; + } + } + let partial: std::collections::HashSet = + set.iter().filter(|(id, n)| glyphs_of.get(*id).is_some_and(|want| *n < want)).map(|(id, _)| *id).collect(); + let before = dropped.len(); + for (i, l) in lines.iter().enumerate() { + if l.iter().any(|id| partial.contains(id)) { + dropped.insert(i); + } + } + if dropped.len() == before { + return dropped; + } + } +} + +/// Glyph runs longer than this (in contour groups) are not tried when a shape is split. +const MAX_RUN: usize = 3; + +/// Complete splits of one shape that one [`split_parts`] search (exact or near) checks the paint +/// of, at most. When none of them is accepted, that search leaves the shape whole. +const MAX_SPLIT_TRIES: usize = 32; + +/// A shape of more contour groups than this is not split: it is matched whole only. +const MAX_SPLIT_GROUPS: usize = 256; + +/// A shape of more contours than this is not split either, and its contours are not grouped. +const MAX_SPLIT_CONTOURS: usize = 512; + +/// Contours of all the selected shapes one command groups, at most: the shapes past them are +/// matched whole only. +const MAX_SPLIT_TOTAL_CONTOURS: usize = 16_384; + +/// A shape of more path elements than this is not split, and its contours are not grouped: 16 +/// times the most a glyph may have ([`vectorcraft_text::retype::MAX_ELEMENTS`]). +const MAX_SPLIT_ELEMENTS: usize = 16 * vectorcraft_text::retype::MAX_ELEMENTS; + +/// `path`'s contour groups when it is split into glyphs: none for fewer than two or more than +/// [`MAX_SPLIT_GROUPS`], for more than [`MAX_SPLIT_CONTOURS`] contours or [`MAX_SPLIT_ELEMENTS`] +/// path elements, and for more contours than `budget` holds. A path of two or more contours takes +/// them from `budget` when it is grouped. +fn split_groups(path: &BezPath, budget: &mut usize) -> Vec { + // Grouping copies the contours and compares every contour with every other: count first. + let n = path.elements().iter().filter(|e| matches!(e, kurbo::PathEl::MoveTo(_))).count(); + if !(2..=MAX_SPLIT_CONTOURS).contains(&n) || n > *budget || path.elements().len() > MAX_SPLIT_ELEMENTS { + return vec![]; + } + *budget -= n; + let groups = vectorcraft_text::retype::clusters(path); + if (2..=MAX_SPLIT_GROUPS).contains(&groups.len()) { groups } else { vec![] } +} + +/// The parts of shape `path` to match: the whole shape, or, when it is no glyph and holds several +/// contour `groups` ([`split_groups`]), runs of up to [`MAX_RUN`] groups in order, the longest that matches first (an i before a dotless i and a dot) among the runs after +/// which the rest of the groups can still be matched. Each part with its candidates; empty when +/// the shape matches nothing and its groups cannot all be matched. `find(path, part, near)` gives +/// a path's candidates: its `part` flag is set for a part of a split shape, whose contours Make +/// Compound Path may have turned the other way round, and its `near` flag allows near matches. +/// Exact matches come first: the whole shape, then its groups, then the whole shape nearly, then +/// its groups nearly. A split of several parts is kept only when `together(runs, near)` accepts the +/// paths of its runs (the parts, set one beside another, paint what the shape paints); `near` is +/// set when the parts were found by near matching. +fn parts( + path: &BezPath, + groups: &[BezPath], + find: &dyn Fn(&BezPath, bool, bool) -> Vec, + together: &dyn Fn(&[BezPath], bool) -> bool, +) -> Vec> { + let whole = find(path, false, false); + if !whole.is_empty() { + return vec![whole]; + } + let exact = split_parts(groups, &|run| find(run, true, false), &|runs| together(runs, false)); + if !exact.is_empty() { + return exact; + } + let whole = find(path, false, true); + if !whole.is_empty() { + return vec![whole]; + } + split_parts(groups, &|run| find(run, true, true), &|runs| together(runs, true)) +} + +/// [`parts`] of a shape split into contour `groups`, each run's candidates from `find`; empty for +/// no groups, when the groups cannot all be matched and when `together` rejects every split of +/// several parts it is asked about. The complete splits are tried with the longest runs first, +/// then with the shortest runs, then the others in order, a longer run at an earlier group first. +/// `together` is asked about at most [`MAX_SPLIT_TRIES`] splits. `find` is asked about a run only +/// when the search reaches it, and about each run at most once, so at most [`MAX_RUN`] times per +/// group. +fn split_parts(groups: &[BezPath], find: &dyn Fn(&BezPath) -> Vec, together: &dyn Fn(&[BezPath]) -> bool) -> Vec> { + let g = groups.len(); + let mut s = Splits { groups, find, found: (0..g).map(|_| (0..MAX_RUN).map(|_| None).collect()).collect(), whole: vec![None; g] }; + // A split is the runs it takes, each as (start, number of groups). + let mut first = vec![]; + if g == 0 || !s.extend(&mut first, false) { + return vec![]; + } + let runs_of = + |split: &[(usize, usize)]| -> Vec { split.iter().map(|&(at, n)| groups.get(at..at + n).map(joined).unwrap_or_default()).collect() }; + let accepted = 'search: { + if first.len() == 1 { + break 'search Some(first); + } + // The shortest runs are looked up only once the longest are rejected. + let mut shortest = vec![]; + let mut shortest_next = true; + let mut rest = first.clone(); + let mut candidate = Some(first.clone()); + let mut tried = 0; + while let Some(split) = candidate.take() { + if tried == MAX_SPLIT_TRIES { + break; + } + tried += 1; + if together(&runs_of(&split)) { + break 'search Some(split); + } + if std::mem::take(&mut shortest_next) && s.extend(&mut shortest, true) && shortest != first { + candidate = Some(shortest.clone()); + continue; + } + candidate = loop { + if !s.advance(&mut rest) { + break None; + } + if rest != shortest { + break Some(rest.clone()); + } + }; + } + None + }; + let Some(split) = accepted else { return vec![] }; + let mut out = vec![]; + for (at, n) in split { + let Some(Some(cands)) = s.found.get_mut(at).and_then(|f| f.get_mut(n.wrapping_sub(1))).map(Option::take) else { return vec![] }; + out.push(cands); + } + out +} + +/// The state of one [`split_parts`] search: each run's candidates and whether the groups from each +/// start can all be matched, each found when the search first needs it. +struct Splits<'a, M> { + groups: &'a [BezPath], + find: &'a dyn Fn(&BezPath) -> Vec, + /// By start and length less one: the run's candidates, once looked up. + found: Vec>>>, + /// By start: whether the groups from there on can all be matched, once known. + whole: Vec>, +} + +impl Splits<'_, M> { + /// Whether the run of `n` groups at `at` matches, looking it up the first time. + fn matches(&mut self, at: usize, n: usize) -> bool { + let Some(slot) = self.found.get_mut(at).and_then(|f| f.get_mut(n.wrapping_sub(1))) else { return false }; + if slot.is_none() { + let cands = self.groups.get(at..at + n).map(|run| (self.find)(&joined(run))).unwrap_or_default(); + *slot = Some(cands); + } + slot.as_ref().is_some_and(|c| !c.is_empty()) + } + + /// Whether the groups from `at` on can all be matched. The search goes from `at` forward, the + /// longest run first, and no start is searched twice, so it ends after at most [`MAX_RUN`] + /// lookups and checks per group. + fn completes(&mut self, at: usize) -> bool { + let g = self.groups.len(); + if at >= g { + return at == g; + } + if let Some(known) = self.whole.get(at).copied().flatten() { + return known; + } + // From `at`: the starts still to settle, each with the run length to try next. + let mut stack: Vec<(usize, usize)> = vec![(at, MAX_RUN.min(g - at))]; + while let Some(&(i, n)) = stack.last() { + if self.whole.get(i).copied().flatten().is_some() { + stack.pop(); + continue; + } + if n == 0 { + if let Some(w) = self.whole.get_mut(i) { + *w = Some(false); + } + stack.pop(); + continue; + } + if let Some(top) = stack.last_mut() { + top.1 = n - 1; + } + if !self.matches(i, n) { + continue; + } + let next = i + n; + match if next == g { Some(true) } else { self.whole.get(next).copied().flatten() } { + Some(true) => { + if let Some(w) = self.whole.get_mut(i) { + *w = Some(true); + } + stack.pop(); + } + Some(false) => {} + None => { + // Settle `next` first, then try this run again. + if let Some(top) = stack.last_mut() { + top.1 = n; + } + stack.push((next, MAX_RUN.min(g - next))); + } + } + } + self.whole.get(at).copied().flatten() == Some(true) + } + + /// Whether `n` groups at `at` are a run a complete split can take. + fn fits(&mut self, at: usize, n: usize) -> bool { + self.matches(at, n) && self.completes(at + n) + } + + /// Takes `split` on to the last group, with the longest run that fits at each start (or, with + /// `shortest`, the shortest); false when no run fits. + fn extend(&mut self, split: &mut Vec<(usize, usize)>, shortest: bool) -> bool { + let g = self.groups.len(); + let mut i = split.last().map_or(0, |&(at, n)| at + n); + while i < g { + let most = MAX_RUN.min(g - i); + let lens: Vec = if shortest { (1..=most).collect() } else { (1..=most).rev().collect() }; + let Some(n) = lens.into_iter().find(|&n| self.fits(i, n)) else { return false }; + split.push((i, n)); + i += n; + } + true + } + + /// Moves `split` on to the next complete split, in order: the runs before the last start where + /// a shorter run fits kept, that shorter run, and the longest runs after it. False past the last. + fn advance(&mut self, split: &mut Vec<(usize, usize)>) -> bool { + while let Some((at, n)) = split.pop() { + if let Some(m) = (1..n).rev().find(|&m| self.fits(at, m)) { + split.push((at, m)); + return self.extend(split, false); + } + } + false + } +} + +/// Contour groups joined into one path. +fn joined(run: &[BezPath]) -> BezPath { + let mut p = BezPath::new(); + for g in run { + p.extend(g.iter()); + } + p +} + +/// Every run of contour `groups` ([`split_groups`]) [`parts`] may try. +fn runs(groups: &[BezPath]) -> Vec { + let mut out = vec![]; + for i in 0..groups.len() { + for n in 1..=MAX_RUN.min(groups.len() - i) { + if let Some(run) = groups.get(i..i + n) { + out.push(joined(run)); + } + } + } + out +} + +/// The keys the index looks glyphs up by for the `shapes` (each with its contour groups) and +/// every run of their groups: their exact [`shape_key`](vectorcraft_text::retype::shape_key)s and, +/// with a `tolerance` above 0, at most [`MAX_NEAR_KEYS`](vectorcraft_text::retype::MAX_NEAR_KEYS) +/// distinct [`near_key`](vectorcraft_text::retype::near_key)s: every whole shape's first, in the +/// order the shapes come, then the runs of their groups. Paths past that many near keys are not +/// looked up for near matches. +fn lookup_keys<'a>( + shapes: impl IntoIterator, + tolerance: f64, +) -> (std::collections::BTreeSet, Vec) { + use vectorcraft_text::retype::{MAX_NEAR_KEYS, near_key, shape_key}; + let mut wanted = std::collections::BTreeSet::new(); + let mut near_wanted = vec![]; + let mut add = |run: &BezPath| { + wanted.extend(shape_key(run)); + if tolerance > 0.0 + && near_wanted.len() < MAX_NEAR_KEYS + && let Some(k) = near_key(run) + && !near_wanted.contains(&k) + { + near_wanted.push(k); + } + }; + let shapes: Vec<(&BezPath, &[BezPath])> = shapes.into_iter().collect(); + // The whole shapes first, then the runs of their groups. + for (path, _) in &shapes { + add(path); + } + for (_, groups) in &shapes { + for run in runs(groups) { + add(&run); + } + } + (wanted, near_wanted) +} + fn retype(s: &mut Session, p: &Value) -> Result { const C: &str = "type.retype"; let fonts: Vec = match p.get("fonts") { - None | Some(Value::Null) => vec![], + None => vec![], Some(Value::Array(a)) => { a.iter().map(|v| v.as_str().map(str::to_owned).ok_or_else(|| bad(C, "fonts must be a list of family names"))).collect::>()? } Some(_) => return Err(bad(C, "fonts must be a list of family names")), }; + let tolerance = match p.get("tolerance") { + None => 0.0, + Some(v) => match v.as_f64() { + Some(t) if (0.0..=vectorcraft_text::retype::MAX_TOLERANCE).contains(&t) => t, + _ => return Err(bad(C, "tolerance must be a number from 0 to 0.05")), + }, + }; let roots = selected_roots(s)?; let db = FontDb::global(); let system_layout = s.doc()?.doc.setup.system_layout; @@ -1114,59 +1523,130 @@ fn retype(s: &mut Session, p: &Value) -> Result { if pieces.is_empty() { return Err(EngineError::Other("Retype: select outlined text (paths or compound paths)".into())); } - // Only glyphs with a selected shape's key (segments per contour) can match one: the others are - // not sampled. - let wanted: std::collections::BTreeSet = - pieces.iter().filter(|pc| !pc.keeps_outline).filter_map(|pc| vectorcraft_text::retype::shape_key(&pc.path)).collect(); + // Only glyphs with a selected shape's key (segments per contour) can match one exactly, and + // only glyphs with as many contours and a close area-to-length ratio nearly: the others are + // not sampled. A shape of several glyphs is looked up by the runs of its groups too. + let mut budget = MAX_SPLIT_TOTAL_CONTOURS; + let groups: Vec> = pieces.iter().map(|pc| if pc.keeps_outline { vec![] } else { split_groups(&pc.path, &mut budget) }).collect(); + let (wanted, near_wanted) = + lookup_keys(pieces.iter().zip(&groups).filter(|(pc, _)| !pc.keeps_outline).map(|(pc, g)| (&pc.path, g.as_slice())), tolerance); // Nothing to match (every shape stays an outline): no font is read. - let index = if wanted.is_empty() { RetypeIndex::default() } else { RetypeIndex::build(db, candidate_faces(db, d, &fonts), &wanted) }; - let found: Vec> = pieces.iter().map(|pc| if pc.keeps_outline { vec![] } else { index.matches(&pc.path) }).collect(); + let index = if wanted.is_empty() && near_wanted.is_empty() { + RetypeIndex::default() + } else { + RetypeIndex::build_near(db, candidate_faces(db, d, &fonts), &wanted, &near_wanted) + }; + // Exact matches first; near ones, when allowed, only for a path with none. + // With a visible fill, a glyph is kept only when it paints the area the shape paints under + // the shape's fill rule (`fill` is `Some(nonzero)`). + let find = |path: &BezPath, part: bool, near: bool, fill: Option| { + let painted = |ms: Vec, tol: f64| -> Vec { + match fill { + Some(nonzero) => ms.iter().filter_map(|m| index.painted_agrees(m, path, nonzero, tol)).collect(), + None => ms, + } + }; + let exact = painted(if part { index.matches_either_way(path) } else { index.all_matches(path) }, 0.0); + if exact.is_empty() && near { painted(index.near_matches(path, tolerance), tolerance) } else { exact } + }; + // Each shape's parts (one, unless it holds several glyphs), each with its candidates. + let found: Vec>> = pieces + .iter() + .zip(&groups) + .map(|(pc, g)| { + if pc.keeps_outline { + return vec![]; + } + let fill = pc.filled.then_some(pc.nonzero); + // Parts that all match exactly are checked at tolerance 0, in the near phase as in + // the exact one; only a part that matches nearly brings the tolerance in. + // The glyphs of a split may become separate objects: when the shape does not paint + // its overlaps as several objects would (translucent, another blend, a gradient or + // pattern fill, a stroke), its parts must not overlap, which the parts read by the + // even-odd rule against them all joined show. + let once = paints_once(pc.opacity, pc.blend, &pc.appearance); + let together = |runs: &[BezPath], near: bool| { + if fill.is_none() && once { + return true; + } + let nearly = near && runs.iter().any(|r| find(r, true, false, fill).is_empty()); + let tol = if nearly { tolerance } else { 0.0 }; + fill.is_none_or(|nz| vectorcraft_text::retype::parts_paint_alike(&pc.path, runs, nz, tol)) + && (once || vectorcraft_text::retype::parts_paint_alike(&joined(runs), runs, false, tol)) + }; + parts(&pc.path, g, &|p, part, near| find(p, part, near, fill), &together) + }) + .collect(); // The face most shapes match, so a glyph several fonts share is set in the same font as - // the glyphs around it. - let mut votes: Vec<(u32, usize)> = vec![]; - for ms in &found { - // Each shape votes once for each face it fits. - let mut faces: Vec = ms.iter().map(|m| m.face.id()).collect(); - faces.sort_unstable(); - faces.dedup(); - for f in faces { - match votes.iter_mut().find(|(v, _)| *v == f) { - Some(v) => v.1 += 1, - None => votes.push((f, 1)), + // the glyphs around it. Among faces that as many shapes match, the one whose glyphs fit + // them closest in all (the least leftover distance summed over those shapes), so every + // part that fits it takes the same face, exact matches as near ones. Simplified outlines + // of one font can nearly fit another font's look-alike glyphs, some of them more closely. + // A part's matches are all exact or all near, so the distances a face sums compare alike. + let mut votes: Vec<(u32, usize, f64)> = vec![]; + for ms in found.iter().flatten() { + // Each shape votes once for each face it fits, with the leftover distance of its + // closest glyph in that face. + let mut faces: Vec<(u32, f64)> = vec![]; + for m in ms { + let residual = if m.residual.is_finite() { m.residual } else { f64::INFINITY }; + match faces.iter_mut().find(|(f, _)| *f == m.face.id()) { + Some(f) => f.1 = f.1.min(residual), + None => faces.push((m.face.id(), residual)), + } + } + for (f, residual) in faces { + match votes.iter_mut().find(|(v, ..)| *v == f) { + Some(v) => { + v.1 += 1; + v.2 += residual; + } + None => votes.push((f, 1, residual)), } } } - let rank = |face: u32| votes.iter().find(|(f, _)| *f == face).map_or(0, |v| v.1); + let rank = |face: u32| votes.iter().find(|(f, ..)| *f == face).map_or((0, f64::INFINITY), |v| (v.1, v.2)); + // Most votes, then the least summed distance, then the first (the matches come upright and + // closest first). + let ranked = |(i, a): &(usize, &GlyphMatch), (j, b): &(usize, &GlyphMatch)| { + let ((va, da), (vb, db)) = (rank(a.face.id()), rank(b.face.id())); + va.cmp(&vb).then(db.total_cmp(&da)).then(j.cmp(i)) + }; let mut lines: Vec = vec![]; let mut unmatched = vec![]; // An unmatched shape between glyphs ends the line: the type after it is painted after it. let mut open = false; - for (pc, ms) in pieces.iter().zip(&found) { + // How many glyphs each shape is: a shape of several becomes type only when all of them do. + let mut glyphs_of: std::collections::HashMap = std::collections::HashMap::new(); + for (pc, parts) in pieces.iter().zip(&found) { if pc.after_barrier { open = false; } - // The shape's candidates in the face most shapes fit (the first such face, as the - // matches come upright and closest first). - let face = ms.iter().enumerate().max_by_key(|(i, m)| (rank(m.face.id()), std::cmp::Reverse(*i))).map(|(_, m)| m.face.id()); - let cands: Vec = ms.iter().filter(|m| Some(m.face.id()) == face).cloned().collect(); - if cands.is_empty() { + if parts.is_empty() { unmatched.push(pc.id); open = false; continue; } - let joined = match lines.last_mut() { - Some(l) if open => join(l, pc, &cands), - _ => false, - }; - if !joined { - lines.extend(new_line(pc, &cands)); + glyphs_of.insert(pc.id, parts.len()); + for ms in parts { + // The part's candidates in the face most shapes fit (see `ranked`). + let face = ms.iter().enumerate().max_by(ranked).map(|(_, m)| m.face.id()); + let cands: Vec = ms.iter().filter(|m| Some(m.face.id()) == face).cloned().collect(); + let joined = match lines.last_mut() { + Some(l) if open => join(l, pc, &cands), + _ => false, + }; + if !joined { + lines.extend(new_line(pc, &cands, tolerance)); + } + open = true; } - open = true; } // A lone one-contour glyph (a period, a hyphen, a bullet) is too plain to tell from drawn - // art (a dot, a bar): beside other shapes it stays an outline. Selected on its own, it is - // what was asked for. Lone means alone on its baseline as the outlines lie, before the - // layout check splits lines (tracking and manual kerning split them glyph by glyph). + // art (a dot, a bar): beside other shapes, the other glyphs of a split compound path + // included, it stays an outline. Selected on its own, it is what was asked for. Lone means + // alone on its baseline as the outlines lie, before the layout check splits lines (tracking + // and manual kerning split them glyph by glyph). let lone_pieces: std::collections::HashSet = lines.iter().flat_map(Line::lone_one_contour).collect(); // Each line's tracking is measured with nine layouts at most: the line as read (its // characters), its glyphs without and with one space between them (three times its @@ -1177,7 +1657,7 @@ fn retype(s: &mut Session, p: &Value) -> Result { let mut lines: Vec = lines.into_iter().map(|l| l.tracked(system_layout, &mut budget)).collect(); share_tracking(&mut lines, system_layout); let mut lines = verified(lines, system_layout, &mut unmatched); - if pieces.len() > 1 { + if pieces.len() > 1 || glyphs_of.values().any(|n| *n > 1) { lines.retain(|l| { let lone = matches!(l.pieces.as_slice(), [id] if lone_pieces.contains(id)); if lone { @@ -1186,9 +1666,24 @@ fn retype(s: &mut Session, p: &Value) -> Result { !lone }); } + let dropped = partial_lines(&lines.iter().map(|l| l.pieces.clone()).collect::>(), &glyphs_of); + let mut k = 0; + lines.retain(|l| { + let keep = !dropped.contains(&k); + k += 1; + if !keep { + unmatched.extend(l.pieces.iter().copied()); + } + keep + }); + // A shape of several glyphs is reported once, and not when it became type. + let kept: std::collections::HashSet = lines.iter().flat_map(|l| l.pieces.iter().copied()).collect(); + let mut seen = std::collections::HashSet::new(); + unmatched.retain(|id| !kept.contains(id) && seen.insert(*id)); let at: std::collections::HashMap = pieces.iter().enumerate().map(|(i, pc)| (pc.id, i)).collect(); + // Lines split from one compound path share its shape, with nothing between them. let follows = |a: NodeId, b: NodeId| match (at.get(&a), at.get(&b)) { - (Some(i), Some(j)) => *j == i + 1 && pieces.get(*j).is_some_and(|pc| !pc.after_barrier), + (Some(i), Some(j)) => *j == *i || (*j == i + 1 && pieces.get(*j).is_some_and(|pc| !pc.after_barrier)), _ => false, }; // Joining lines takes at most four tries' work per glyph (see [`Block::made`]), with room @@ -1204,6 +1699,9 @@ fn retype(s: &mut Session, p: &Value) -> Result { let before = lines.iter().any(|l| l.point.is_some()).then(|| d.clone()); let mut ids = vec![]; let mut emptied = vec![]; + // Every line's type goes in before the shapes go: a shape of several glyphs is the first + // shape of more than one line. Each goes just before its first shape, so lines from one + // shape keep their order. for l in &lines { let Some(first) = l.pieces.first() else { continue }; let (par, idx, _) = d.position(*first).ok_or(EngineError::NoNode(*first))?; @@ -1213,14 +1711,18 @@ fn retype(s: &mut Session, p: &Value) -> Result { node.opacity = l.opacity; node.blend = l.blend; d.insert(par, idx, node)?; - for pc in &l.pieces { - if let Some((Some(parent), _, _)) = d.position(*pc) { - emptied.push(parent); - } - d.remove(*pc)?; - } ids.push(id); } + let mut removed = std::collections::HashSet::new(); + for pc in lines.iter().flat_map(|l| l.pieces.iter()) { + if !removed.insert(*pc) { + continue; + } + if let Some((Some(parent), _, _)) = d.position(*pc) { + emptied.push(parent); + } + d.remove(*pc)?; + } // A group left holding only the new type (Create Outlines' group) gives way to it, unless // the group has transparency, effects, a mask or a name of its own, which then keep // applying to the type inside it. A group left empty goes. @@ -1284,7 +1786,7 @@ fn retype(s: &mut Session, p: &Value) -> Result { for (l, id) in lines.iter().zip(&ids).filter(|_| units > 0) { let Some(point) = &l.point else { continue }; let Some(NodeKind::Text(t)) = probe.node(*id).map(|n| &n.kind) else { continue }; - if flowed && (t.wrap.is_empty() || first_mismatch(t, &l.matches, l.size).is_none()) { + if flowed && (t.wrap.is_empty() || first_mismatch(t, &l.matches, l.size, l.slack).is_none()) { continue; } if let Some(NodeKind::Text(t)) = d.node_mut(*id).map(|n| &mut n.kind) { @@ -1306,14 +1808,18 @@ fn retype(s: &mut Session, p: &Value) -> Result { "fonts": lines .iter() .zip(&made) - .map(|(l, id)| json!({ - "family": l.face.family, - "style": l.face.style, - "size": l.size, - "tracking": l.tracking, - "leading": l.leading, - "area": area(id), - })) + .map(|(l, id)| { + let score = l.matches.iter().map(GlyphMatch::score).fold(1.0, f64::min); + json!({ + "family": l.face.family, + "style": l.face.style, + "size": l.size, + "tracking": l.tracking, + "leading": l.leading, + "area": area(id), + "score": (score * 1000.0).round() / 1000.0, + }) + }) .collect::>(), "unmatched": unmatched.iter().map(|i| i.0).collect::>(), "truncated": truncated, diff --git a/crates/engine/src/cmd/retype_tests.rs b/crates/engine/src/cmd/retype_tests.rs index de2122fc09..2727dd4432 100644 --- a/crates/engine/src/cmd/retype_tests.rs +++ b/crates/engine/src/cmd/retype_tests.rs @@ -10,7 +10,13 @@ fn session() -> Session { } /// Point text, outlined: the id of the outlines' group. -fn outlined(s: &mut Session, p: serde_json::Value) -> u64 { +fn outlined(s: &mut Session, mut p: serde_json::Value) -> u64 { + // A text without a font is set in the system's default face, which differs from machine to + // machine and decides which glyphs a near match can tell apart. + if p.get("font").is_none() { + p["font"] = json!("Source Sans 3"); + p["style"] = json!("Regular"); + } let id = s.execute("text.create", &p).unwrap()["id"].as_u64().unwrap(); s.execute("select.set", &json!({"ids": [id]})).unwrap(); s.execute("type.createOutlines", &json!({})).unwrap()["ids"][0].as_u64().unwrap() @@ -84,7 +90,7 @@ fn a_drawn_shape_is_reported_and_left_alone() { let g = outlined(&mut s, json!({"x": 40, "y": 200, "text": "AB", "size": 40})); s.execute("select.set", &json!({"ids": [g]})).unwrap(); let before = s.doc().unwrap().doc.clone(); - for bad in [json!("Source Sans 3"), json!([1]), json!({"family": "x"})] { + for bad in [json!("Source Sans 3"), json!([1]), json!({"family": "x"}), json!(null)] { let e = s.execute("type.retype", &json!({"fonts": bad})).unwrap_err().to_string(); assert!(e.contains("fonts must be a list of family names"), "{e}"); } @@ -539,6 +545,118 @@ fn a_long_tracked_line_is_checked_in_time() { eprintln!("450 tracked glyphs: {:?}, {} objects", t0.elapsed(), texts.len()); } +/// Every path in the document flattened into lines `tol` from its curves, each contour started at +/// its second point and run backwards: outlines simplified and built nothing like the font's. +fn simplify_every_path(s: &mut Session, tol: f64) { + let mut ids = vec![]; + s.doc().unwrap().doc.walk(|n| { + if matches!(n.kind, NodeKind::Path { .. }) { + ids.push(n.id); + } + }); + simplify_paths(s, &ids, tol); +} + +/// [`simplify_every_path`] for the paths `ids` only. +fn simplify_paths(s: &mut Session, ids: &[NodeId], tol: f64) { + s.edit("test", |d, _| { + for id in ids { + let data = d.node_mut(*id).unwrap().path_data_mut().unwrap(); + let mut contours: Vec> = vec![]; + kurbo::flatten(data.to_bezpath().iter(), tol, |el| match el { + kurbo::PathEl::MoveTo(q) => contours.push(vec![q]), + kurbo::PathEl::LineTo(q) => contours.last_mut().unwrap().push(q), + _ => {} + }); + let mut out = kurbo::BezPath::new(); + for mut c in contours { + if c.len() > 1 && c.first() == c.last() { + c.pop(); + } + c.rotate_left(1); + c.reverse(); + out.move_to(c[0]); + for q in &c[1..] { + out.line_to(*q); + } + out.close_path(); + } + *data = vectorcraft_geom::PathData::from_bezpath(&out); + } + Ok(()) + }) + .unwrap(); +} + +#[test] +fn simplified_outlines_retype_only_with_a_tolerance_and_report_their_score() { + let mut s = session(); + let g = outlined(&mut s, json!({"x": 40, "y": 100, "text": "Rag", "size": 40, "font": "Source Sans 3", "style": "Regular"})); + simplify_every_path(&mut s, 0.05); + s.execute("select.set", &json!({"ids": [g]})).unwrap(); + let before = s.doc().unwrap().doc.clone(); + let e = s.execute("type.retype", &json!({})).unwrap_err().to_string(); + assert!(e.contains("no selected shape matches"), "no exact match: {e}"); + for bad in [json!(-0.01), json!(0.06), json!("0.02"), json!(true), json!(null)] { + let e = s.execute("type.retype", &json!({"tolerance": bad})).unwrap_err().to_string(); + assert!(e.contains("tolerance must be a number from 0 to 0.05"), "{e}"); + } + assert!(s.doc().unwrap().doc == before, "nothing changes"); + let r = s.execute("type.retype", &json!({"tolerance": 0.02})).unwrap(); + assert_eq!(r["texts"], json!(["Rag"]), "{r}"); + assert_eq!(r["unmatched"], json!([])); + assert_eq!((r["fonts"][0]["family"].as_str(), r["fonts"][0]["style"].as_str()), (Some("Source Sans 3"), Some("Regular"))); + let score = r["fonts"][0]["score"].as_f64().unwrap(); + assert!(score > 0.5 && score < 1.0, "a near match scores below an exact one: {score}"); + let t = text_of(&s, r["ids"][0].as_u64().unwrap()); + assert!(near(t.first_style().size, 40.0, 0.4), "size {}", t.first_style().size); + let o = t.xf.translation(); + assert!(near(o.x, 40.0, 0.4) && near(o.y, 100.0, 0.4), "baseline start {o:?}"); +} + +#[test] +fn exact_matches_score_one() { + let mut s = session(); + let g = outlined(&mut s, json!({"x": 40, "y": 100, "text": "Rag", "size": 40})); + s.execute("select.set", &json!({"ids": [g]})).unwrap(); + let r = s.execute("type.retype", &json!({"tolerance": 0.02})).unwrap(); + assert_eq!(r["texts"], json!(["Rag"]), "{r}"); + assert_eq!(r["fonts"][0]["score"], json!(1.0)); +} + +#[test] +fn exact_matches_with_a_small_leftover_still_score_one() { + let mut s = session(); + let g = outlined(&mut s, json!({"x": 40, "y": 100, "text": "Rag", "size": 40})); + // Each glyph stretched 0.1% across its own centre: still within the exact matcher's reach, with + // a leftover distance above 0. + let mut ids = vec![]; + s.doc().unwrap().doc.walk(|n| { + if matches!(n.kind, NodeKind::Path { .. }) { + ids.push(n.id); + } + }); + s.edit("test", |d, _| { + for id in &ids { + let data = d.node_mut(*id).unwrap().path_data_mut().unwrap(); + let p = data.to_bezpath(); + let c = kurbo::Shape::bounding_box(&p).center(); + let xf = kurbo::Affine::translate(c.to_vec2()) * kurbo::Affine::scale_non_uniform(1.001, 1.0) * kurbo::Affine::translate(-c.to_vec2()); + *data = vectorcraft_geom::PathData::from_bezpath(&(xf * p)); + } + Ok(()) + }) + .unwrap(); + s.execute("select.set", &json!({"ids": [g]})).unwrap(); + let r = s.execute("type.retype", &json!({})).unwrap(); + // Each glyph's size now differs a little, so each is its own line. + let texts: Vec<&str> = r["texts"].as_array().unwrap().iter().map(|t| t.as_str().unwrap()).collect(); + assert_eq!(texts.concat(), "Rag", "{r}"); + for f in r["fonts"].as_array().unwrap() { + assert_eq!(f["score"], json!(1.0), "{r}"); + } +} + #[test] fn two_overlapping_lone_glyphs_beside_art_stay_outlines() { // Two M outlines start 0.3 em apart, closer than the first one's advance: a tight-tracking @@ -583,6 +701,55 @@ fn assert_same_places(a: &TextObject, b: &TextObject) { } } +#[test] +fn exact_glyphs_of_another_size_are_another_line_even_with_a_tolerance() { + let mut s = session(); + let g = outlined(&mut s, json!({"x": 40, "y": 100, "text": "Tia", "size": 40})); + // The a (two contours, so not a lone one-contour glyph) made 4% larger about where it starts + // on the baseline: still exactly the glyph. + let a = *children_of(&s, g).last().unwrap(); + // The a's paths (a compound path's, or its own). + let paths: Vec = match s.doc().unwrap().doc.node(NodeId(a)).unwrap().children() { + Some(c) => c.iter().map(|c| c.id.0).collect(), + None => vec![a], + }; + s.edit("test", |d, _| { + let x0 = paths + .iter() + .map(|id| kurbo::Shape::bounding_box(&d.node_mut(NodeId(*id)).unwrap().path_data_mut().unwrap().to_bezpath()).x0) + .fold(f64::INFINITY, f64::min); + let at = kurbo::Vec2::new(x0, 100.0); + let xf = kurbo::Affine::translate(at) * kurbo::Affine::scale(1.04) * kurbo::Affine::translate(-at); + for id in &paths { + let data = d.node_mut(NodeId(*id)).unwrap().path_data_mut().unwrap(); + *data = vectorcraft_geom::PathData::from_bezpath(&(xf * data.to_bezpath())); + } + Ok(()) + }) + .unwrap(); + s.execute("select.set", &json!({"ids": [g]})).unwrap(); + let r = s.execute("type.retype", &json!({"tolerance": 0.05})).unwrap(); + assert_eq!(r["texts"], json!(["Ti", "a"]), "{r}"); + let sizes: Vec = r["fonts"].as_array().unwrap().iter().map(|f| f["size"].as_f64().unwrap()).collect(); + assert!(near(sizes[0], 40.0, 0.01) && near(sizes[1], 41.6, 0.01), "{sizes:?}"); + assert!(r["fonts"].as_array().unwrap().iter().all(|f| f["score"] == json!(1.0)), "{r}"); +} + +#[test] +fn turned_near_matched_round_glyphs_keep_the_line_turn() { + // Round glyphs (o, O, the period) and glyphs that look alike half round (N, x, z) fit + // simplified outlines at more than one turn: each takes the turn of its line. + for (text, rotation) in [("no.", 90), ("no.", 180), ("zoo", 135), ("NOON", 180), ("xoxo", 200), ("on", 120)] { + let mut s = session(); + let g = outlined(&mut s, json!({"x": 300, "y": 200, "text": text, "size": 40, "rotation": rotation})); + simplify_every_path(&mut s, 0.05); + s.execute("select.set", &json!({"ids": [g]})).unwrap(); + let r = s.execute("type.retype", &json!({"tolerance": 0.02})).unwrap(); + assert_eq!(r["texts"], json!([text]), "turned {rotation}: {r}"); + assert_eq!(r["unmatched"], json!([]), "{r}"); + } +} + #[test] fn several_lines_become_one_area_type_object() { let mut s = session(); @@ -870,6 +1037,660 @@ fn spaced_letters_keep_their_spaces_when_type_draws_them() { } } +#[test] +fn a_near_glyph_moved_by_more_than_the_tolerance_ends_the_line() { + // The m (one path) of simplified outlines moved along the baseline by `shift` of the font + // size (40), retyped with a tolerance of 0.03: it may sit 1% + 3% of the size from where the + // type draws it. + let run = |shift: f64| { + let mut s = session(); + let g = outlined(&mut s, json!({"x": 40, "y": 100, "text": "Tim", "size": 40})); + simplify_every_path(&mut s, 0.05); + let m = *children_of(&s, g).last().unwrap(); + s.edit("test", |d, _| { + let data = d.node_mut(NodeId(m)).unwrap().path_data_mut().unwrap(); + *data = vectorcraft_geom::PathData::from_bezpath(&(kurbo::Affine::translate((40.0 * shift, 0.0)) * data.to_bezpath())); + Ok(()) + }) + .unwrap(); + s.execute("select.set", &json!({"ids": [g]})).unwrap(); + let r = s.execute("type.retype", &json!({"tolerance": 0.03})).unwrap(); + let texts: Vec = r["texts"].as_array().unwrap().iter().map(|t| t.as_str().unwrap().to_owned()).collect(); + assert_eq!(texts.concat(), "Tim", "{r}"); + texts.len() + }; + assert_eq!(run(0.02), 1, "within the tolerance: one line"); + assert!(run(0.06) > 1, "past it: the line splits where the m was moved"); +} + +/// The bounding box of shape `id` (a path, or a compound path's paths), in document space. +fn shape_box(s: &Session, id: u64) -> kurbo::Rect { + let d = &s.doc().unwrap().doc; + let n = d.node(NodeId(id)).unwrap(); + let paths: Vec<&vectorcraft_doc::Node> = match n.children() { + Some(c) => c.iter().map(|c| &**c).collect(), + None => vec![n], + }; + paths + .iter() + .filter_map(|p| match &p.kind { + NodeKind::Path { path, .. } => Some(kurbo::Shape::bounding_box(&path.to_bezpath())), + _ => None, + }) + .reduce(|a, b| a.union(b)) + .unwrap() +} + +/// The bounding box of each glyph with ink that type `t` draws, in document space. +fn drawn_boxes(t: &TextObject) -> Vec { + let lay = vectorcraft_text::layout(vectorcraft_text::FontDb::global(), t); + lay.glyphs.iter().filter(|g| !g.outline.elements().is_empty()).map(|g| kurbo::Shape::bounding_box(&(t.xf * g.outline.clone()))).collect() +} + +#[test] +fn a_near_glyph_whose_size_and_turn_differ_past_the_tolerance_ends_the_line() { + // The m of simplified outlines made 4% larger, and turned 0.04 radians as well, about where it + // starts on the baseline, retyped with a tolerance of 0.05. Each change alone is within the + // size and turn a near-matched line allows, but drawn at the line's size and turn the m would + // lie further than 0.05 of its spread from its outline: it becomes type of its own. Larger + // alone, it is still within the tolerance and stays on the line. + for (scale, turn, lines) in [(1.04, 0.0, 1), (1.04, 0.04, 2)] { + let mut s = session(); + let g = outlined(&mut s, json!({"x": 40, "y": 100, "text": "Tim", "size": 40})); + simplify_every_path(&mut s, 0.05); + let kids = children_of(&s, g); + let m = *kids.last().unwrap(); + let x0 = shape_box(&s, m).x0; + s.edit("test", |d, _| { + let at = kurbo::Vec2::new(x0, 100.0); + let xf = kurbo::Affine::translate(at) * kurbo::Affine::rotate(turn) * kurbo::Affine::scale(scale) * kurbo::Affine::translate(-at); + let data = d.node_mut(NodeId(m)).unwrap().path_data_mut().unwrap(); + *data = vectorcraft_geom::PathData::from_bezpath(&(xf * data.to_bezpath())); + Ok(()) + }) + .unwrap(); + let before: Vec = kids.iter().map(|k| shape_box(&s, *k)).collect(); + s.execute("select.set", &json!({"ids": [g]})).unwrap(); + let r = s.execute("type.retype", &json!({"tolerance": 0.05})).unwrap(); + let texts: Vec<&str> = r["texts"].as_array().unwrap().iter().map(|t| t.as_str().unwrap()).collect(); + assert_eq!(texts.concat(), "Tim", "{r}"); + assert_eq!(texts.len(), lines, "scale {scale}, turn {turn}: {r}"); + if lines == 1 { + continue; + } + let drawn: Vec = r["ids"].as_array().unwrap().iter().flat_map(|id| drawn_boxes(&text_of(&s, id.as_u64().unwrap()))).collect(); + assert_eq!(drawn.len(), before.len(), "{r}"); + for b in &before { + // The glyph drawn nearest where the outline was. + let d = drawn.iter().min_by(|p, q| p.center().distance(b.center()).total_cmp(&q.center().distance(b.center()))).unwrap(); + let size = b.width().hypot(b.height()); + assert!( + (d.width() - b.width()).abs() < size * 0.01 && (d.height() - b.height()).abs() < size * 0.01, + "scale {scale}, turn {turn}: the outline's box {b:?}, the type's {d:?}: {r}" + ); + } + } +} + +#[test] +fn an_exact_glyph_moved_splits_the_line_whatever_the_tolerance() { + let mut s = session(); + let g = outlined(&mut s, json!({"x": 40, "y": 100, "text": "Tim", "size": 40})); + let m = *children_of(&s, g).last().unwrap(); + s.edit("test", |d, _| { + let data = d.node_mut(NodeId(m)).unwrap().path_data_mut().unwrap(); + *data = vectorcraft_geom::PathData::from_bezpath(&(kurbo::Affine::translate((40.0 * 0.03, 0.0)) * data.to_bezpath())); + Ok(()) + }) + .unwrap(); + s.execute("select.set", &json!({"ids": [g]})).unwrap(); + let r = s.execute("type.retype", &json!({"tolerance": 0.05})).unwrap(); + assert_eq!(r["texts"], json!(["Ti", "m"]), "exact glyphs keep the exact limits: {r}"); +} + +#[test] +fn an_exact_glyph_after_a_near_one_keeps_the_exact_limits() { + // T exact, o simplified (a near match), m exact moved by 3% of the size along the baseline. + let mut s = session(); + let g = outlined(&mut s, json!({"x": 40, "y": 100, "text": "Tom", "size": 40})); + let kids = children_of(&s, g); + let o: Vec = match s.doc().unwrap().doc.node(NodeId(kids[1])).unwrap().children() { + Some(c) => c.iter().map(|c| c.id).collect(), + None => vec![NodeId(kids[1])], + }; + simplify_paths(&mut s, &o, 0.05); + let m = kids[2]; + s.edit("test", |d, _| { + let data = d.node_mut(NodeId(m)).unwrap().path_data_mut().unwrap(); + *data = vectorcraft_geom::PathData::from_bezpath(&(kurbo::Affine::translate((40.0 * 0.03, 0.0)) * data.to_bezpath())); + Ok(()) + }) + .unwrap(); + s.execute("select.set", &json!({"ids": [g]})).unwrap(); + let r = s.execute("type.retype", &json!({"tolerance": 0.05})).unwrap(); + assert_eq!(r["texts"], json!(["To", "m"]), "the near o does not loosen the m's limits: {r}"); +} + +/// The outlines of `text` made into one compound path: the compound's id. +fn one_compound(s: &mut Session, text: &str) -> u64 { + let g = outlined(s, json!({"x": 40, "y": 100, "text": text, "size": 40})); + let glyphs = children_of(s, g); + s.execute("select.set", &json!({"ids": glyphs})).unwrap(); + s.execute("object.compoundPath.make", &json!({})).unwrap()["id"].as_u64().unwrap() +} + +#[test] +fn a_word_outlined_as_one_compound_path_splits_into_its_glyphs() { + let mut s = session(); + let c = one_compound(&mut s, "Tim"); + s.execute("select.set", &json!({"ids": [c]})).unwrap(); + let r = s.execute("type.retype", &json!({})).unwrap(); + assert_eq!(r["texts"], json!(["Tim"]), "the i's stem and dot are one glyph: {r}"); + assert_eq!(r["unmatched"], json!([])); + assert!(s.doc().unwrap().doc.node(NodeId(c)).is_none(), "the compound becomes the type"); +} + +#[test] +fn a_lone_period_in_a_compound_selected_alone_stays_an_outline() { + let mut s = session(); + // An A and, far below it, a period, made into one compound path and selected alone: the + // period, alone on its baseline beside the A, is a dot as much as a period, so it stays an + // outline, and so does the A in the same compound. + let t = outlined(&mut s, json!({"x": 40, "y": 100, "text": "A", "size": 40})); + let dot = outlined(&mut s, json!({"x": 40, "y": 300, "text": ".", "size": 40})); + let mut ids = children_of(&s, t); + ids.extend(children_of(&s, dot)); + s.execute("select.set", &json!({"ids": ids})).unwrap(); + let c = s.execute("object.compoundPath.make", &json!({})).unwrap()["id"].as_u64().unwrap(); + s.execute("select.set", &json!({"ids": [c]})).unwrap(); + let before = s.doc().unwrap().doc.clone(); + let e = match s.execute("type.retype", &json!({})) { + Ok(r) => panic!("the period became type: {r}"), + Err(e) => e.to_string(), + }; + assert!(e.contains("(1 checked)"), "{e}"); + assert!(s.doc().unwrap().doc == before, "nothing changes"); +} + +#[test] +fn lines_from_one_compound_path_keep_their_order() { + let mut s = session(); + // Two lines of outlines made into one compound path, farther apart than the lines of one + // paragraph, so each stays an object of its own. + let top = outlined(&mut s, json!({"x": 40, "y": 100, "text": "Tim", "size": 40})); + let low = outlined(&mut s, json!({"x": 40, "y": 300, "text": "Ham", "size": 40})); + let mut glyphs = children_of(&s, top); + glyphs.extend(children_of(&s, low)); + s.execute("select.set", &json!({"ids": glyphs})).unwrap(); + let c = s.execute("object.compoundPath.make", &json!({})).unwrap()["id"].as_u64().unwrap(); + s.execute("select.set", &json!({"ids": [c]})).unwrap(); + let r = s.execute("type.retype", &json!({})).unwrap(); + let ids: Vec = r["ids"].as_array().unwrap().iter().map(|v| v.as_u64().unwrap()).collect(); + assert_eq!(ids.len(), 2, "{r}"); + let texts: Vec = ids.iter().map(|id| text_of(&s, *id).plain_text()).collect(); + let d = &s.doc().unwrap().doc; + let at: Vec = ids.iter().map(|id| d.position(NodeId(*id)).unwrap().1).collect(); + // The lines stack in the order of the compound's contours: the first line behind the second. + let first = texts.iter().position(|t| t == "Tim").unwrap(); + let second = texts.iter().position(|t| t == "Ham").unwrap(); + assert!(at[first] < at[second], "{texts:?} at {at:?}"); +} + +#[test] +fn stacked_lines_from_one_compound_path_become_one_object() { + let mut s = session(); + // Two lines of one paragraph, outlined and made into one compound path: they join as the + // lines of separate outlines do. + let text = "Tim\nHam"; + let g = outlined(&mut s, json!({"x": 40, "y": 100, "text": text, "size": 40})); + let glyphs = children_of(&s, g); + s.execute("select.set", &json!({"ids": glyphs})).unwrap(); + let c = s.execute("object.compoundPath.make", &json!({})).unwrap()["id"].as_u64().unwrap(); + s.execute("select.set", &json!({"ids": [c]})).unwrap(); + let r = s.execute("type.retype", &json!({})).unwrap(); + assert_eq!(r["texts"], json!([text]), "{r}"); + assert_eq!(r["unmatched"], json!([]), "{r}"); + assert!(s.doc().unwrap().doc.node(NodeId(c)).is_none(), "the compound becomes the type"); +} + +#[test] +fn a_compound_whose_parts_are_not_all_glyphs_stays_whole() { + let mut s = session(); + let g = outlined(&mut s, json!({"x": 40, "y": 100, "text": "Ti", "size": 40})); + let mut ids = children_of(&s, g); + // A shape no glyph is, beside the letters, in the same compound. + ids.push(s.execute("shape.star", &json!({"cx": 140, "cy": 85, "radius1": 12, "radius2": 5, "points": 7})).unwrap()["id"].as_u64().unwrap()); + s.execute("select.set", &json!({"ids": ids})).unwrap(); + let c = s.execute("object.compoundPath.make", &json!({})).unwrap()["id"].as_u64().unwrap(); + s.execute("select.set", &json!({"ids": [c]})).unwrap(); + let before = s.doc().unwrap().doc.clone(); + let e = s.execute("type.retype", &json!({})).unwrap_err().to_string(); + assert!(e.contains("(1 checked)"), "reported once: {e}"); + assert!(s.doc().unwrap().doc == before, "nothing changes"); +} + +#[test] +fn glyphs_that_overlap_in_an_even_odd_compound_stay_an_outline() { + let mut s = session(); + // Two o's moved onto each other and made into one compound path: the even-odd rule leaves + // the overlap unpainted, and two glyphs set side by side would paint it. + let g = outlined(&mut s, json!({"x": 40, "y": 100, "text": "oo", "size": 40})); + let kids = children_of(&s, g); + s.execute("object.move", &json!({"ids": [kids[1]], "dx": -9, "dy": 0})).unwrap(); + s.execute("select.set", &json!({"ids": kids})).unwrap(); + let c = s.execute("object.compoundPath.make", &json!({})).unwrap()["id"].as_u64().unwrap(); + s.execute("select.set", &json!({"ids": [c]})).unwrap(); + let before = s.doc().unwrap().doc.clone(); + let e = match s.execute("type.retype", &json!({})) { + Ok(r) => panic!("the overlapping o's became type: {r}"), + Err(e) => e.to_string(), + }; + assert!(e.contains("(1 checked)"), "{e}"); + assert!(s.doc().unwrap().doc == before, "nothing changes"); +} + +#[test] +fn a_translucent_compound_whose_glyphs_overlap_stays_an_outline() { + // Two i's, the second moved half onto the first and down off its baseline, made into one + // compound path filled by the nonzero rule with every contour running one way: the parts paint + // the shape's area, but on two lines they become two objects, and at 50% opacity their + // overlap would be painted twice. + for opacity in [1.0f32, 0.5] { + let mut s = session(); + let g = outlined(&mut s, json!({"x": 40, "y": 100, "text": "ii", "size": 40})); + let kids = children_of(&s, g); + let dx = shape_box(&s, kids[0]).x0 - shape_box(&s, kids[1]).x0 + 2.0; + s.execute("object.move", &json!({"ids": [kids[1]], "dx": dx, "dy": 6})).unwrap(); + s.execute("select.set", &json!({"ids": kids})).unwrap(); + let c = s.execute("object.compoundPath.make", &json!({})).unwrap()["id"].as_u64().unwrap(); + let paths = children_of(&s, c); + s.edit("test", |d, _| { + // Make Compound Path turns the second glyph's contours the other way round. + for p in &paths { + let data = d.node_mut(NodeId(*p)).unwrap().path_data_mut().unwrap(); + let b = data.to_bezpath(); + if kurbo::Shape::area(&b) < 0.0 { + *data = vectorcraft_geom::PathData::from_bezpath(&b.reverse_subpaths()); + } + } + let n = d.node_mut(NodeId(c)).unwrap(); + n.opacity = opacity; + if let NodeKind::Compound { rule, .. } = &mut n.kind { + *rule = vectorcraft_geom::FillRule::NonZero; + } + Ok(()) + }) + .unwrap(); + s.execute("select.set", &json!({"ids": [c]})).unwrap(); + let r = s.execute("type.retype", &json!({})); + if opacity == 1.0 { + let r = r.unwrap(); + assert_eq!(r["texts"], json!(["i", "i"]), "opaque, the two lines become type: {r}"); + } else { + assert!(r.is_err(), "translucent, the compound stays an outline: {r:?}"); + } + } +} + +#[test] +fn overlapping_exact_glyphs_stay_an_outline_when_near_matches_are_allowed() { + // Exact parts the even-odd rule rejects stay rejected when the near phase finds them again. + for dx in [-9.0, -11.0, -12.0, -13.0, -14.0] { + let mut s = session(); + let g = outlined(&mut s, json!({"x": 40, "y": 100, "text": "oo", "size": 40})); + let kids = children_of(&s, g); + s.execute("object.move", &json!({"ids": [kids[1]], "dx": dx, "dy": 0})).unwrap(); + s.execute("select.set", &json!({"ids": kids})).unwrap(); + let c = s.execute("object.compoundPath.make", &json!({})).unwrap()["id"].as_u64().unwrap(); + s.execute("select.set", &json!({"ids": [c]})).unwrap(); + for tolerance in [0.0, 0.05] { + if let Ok(r) = s.execute("type.retype", &json!({"tolerance": tolerance})) { + panic!("the overlapping o's became type at dx {dx}, tolerance {tolerance}: {r}"); + } + } + } +} + +#[test] +fn exact_parts_of_a_compound_are_checked_at_tolerance_zero() { + let mut s = session(); + // A T and an o whose boxes overlap by 4 units, one painted area apart (the o sits under the + // bar's arm): a strip that the probes of tolerance 0.05 cannot see into but those of an exact + // match can. Both parts match exactly, so asking for near matches does not change the result. + let g = outlined(&mut s, json!({"x": 40, "y": 100, "text": "To", "size": 40})); + let kids = children_of(&s, g); + let (t, o) = (kids[0], kids[1]); + let bounds = |s: &Session, id: u64| s.doc().unwrap().doc.node(NodeId(id)).unwrap().geometric_bounds().unwrap(); + let dx = bounds(&s, t).x1 - 4.0 - bounds(&s, o).x0; + s.execute("object.move", &json!({"ids": [o], "dx": dx, "dy": 0})).unwrap(); + s.execute("select.set", &json!({"ids": kids})).unwrap(); + let c = s.execute("object.compoundPath.make", &json!({})).unwrap()["id"].as_u64().unwrap(); + for params in [json!({}), json!({"tolerance": 0.05})] { + s.execute("select.set", &json!({"ids": [c]})).unwrap(); + let before = s.doc().unwrap().doc.clone(); + let r = s.execute("type.retype", ¶ms).unwrap(); + assert_eq!(r["unmatched"], json!([]), "{params}: {r}"); + assert!(s.doc().unwrap().doc.node(NodeId(c)).is_none(), "{params}: the compound becomes type"); + s.execute("edit.undo", &json!({})).unwrap(); + assert!(s.doc().unwrap().doc == before, "{params}: undo restores it"); + } +} + +#[test] +fn glyphs_side_by_side_in_an_even_odd_compound_still_become_type() { + let mut s = session(); + let c = one_compound(&mut s, "oo"); + s.execute("select.set", &json!({"ids": [c]})).unwrap(); + let r = s.execute("type.retype", &json!({})).unwrap(); + assert_eq!(r["texts"], json!(["oo"]), "{r}"); +} + +#[test] +fn a_compound_whose_glyph_stays_an_outline_keeps_its_other_glyphs_too() { + let mut s = session(); + // An A (two contours), and far below it a period: a lone one-contour glyph beside other + // shapes stays an outline, so the A, in the same compound, must stay too. + let t = outlined(&mut s, json!({"x": 40, "y": 100, "text": "A", "size": 40})); + let dot = outlined(&mut s, json!({"x": 40, "y": 300, "text": ".", "size": 40})); + let paths = |s: &Session, id: u64| match s.doc().unwrap().doc.node(NodeId(id)).unwrap().children() { + Some(c) => c.iter().map(|c| c.id.0).collect(), + None => vec![id], + }; + let mut ids: Vec = paths(&s, t); + ids.extend(paths(&s, dot)); + assert_eq!(ids.len(), 2, "one path each"); + s.execute("select.set", &json!({"ids": ids})).unwrap(); + let c = s.execute("object.compoundPath.make", &json!({})).unwrap()["id"].as_u64().unwrap(); + let r = s.execute("shape.rectangle", &json!({"x": 300, "y": 300, "width": 40, "height": 20})).unwrap()["id"].as_u64().unwrap(); + s.execute("select.set", &json!({"ids": [c, r]})).unwrap(); + let before = s.doc().unwrap().doc.clone(); + let e = match s.execute("type.retype", &json!({})) { + Ok(r) => panic!("the A became type without its period: {r}"), + Err(e) => e.to_string(), + }; + assert!(e.contains("(2 checked)"), "{e}"); + assert!(s.doc().unwrap().doc == before, "nothing changes"); +} + +#[test] +fn a_split_takes_a_shorter_run_when_the_longest_leaves_a_group_unmatched() { + use kurbo::Shape; + // Three groups A, B and C side by side. A and B together are a glyph, but then C alone is + // none; A alone and B and C together are glyphs, so the split is A, BC. + let mut p = kurbo::BezPath::new(); + for x in [0.0, 100.0, 200.0] { + p.extend(kurbo::Rect::new(x, 0.0, x + 40.0, 40.0).path_elements(0.1)); + } + let find = |path: &kurbo::BezPath, part: bool, _near: bool| -> Vec<&'static str> { + let b = path.bounding_box(); + match (part, b.x0.round() as i64, b.x1.round() as i64) { + (true, 0, 140) => vec!["AB"], + (true, 0, 40) => vec!["A"], + (true, 100, 240) => vec!["BC"], + _ => vec![], + } + }; + let groups = all_groups(&p); + assert_eq!(super::parts(&p, &groups, &find, &|_, _| true), vec![vec!["A"], vec!["BC"]]); + // A split the parts' paint does not allow is dropped. + assert!(super::parts(&p, &groups, &find, &|_, _| false).is_empty()); + // With no way to match every group, nothing. + let none = |path: &kurbo::BezPath, part: bool, _near: bool| -> Vec<&'static str> { + let b = path.bounding_box(); + if part && b.x0.round() as i64 == 0 && b.x1.round() as i64 == 140 { vec!["AB"] } else { vec![] } + }; + assert!(super::parts(&p, &groups, &none, &|_, _| true).is_empty()); +} + +#[test] +fn a_split_the_paint_check_rejects_gives_way_to_another_complete_split() { + use kurbo::Shape; + let mut p = kurbo::BezPath::new(); + for x in [0.0, 100.0, 200.0] { + p.extend(kurbo::Rect::new(x, 0.0, x + 40.0, 40.0).path_elements(0.1)); + } + let find = |path: &kurbo::BezPath, part: bool, _near: bool| -> Vec<&'static str> { + let b = path.bounding_box(); + match (part, b.x0.round() as i64, b.x1.round() as i64) { + (true, 0, 140) => vec!["AB"], + (true, 0, 40) => vec!["A"], + (true, 100, 140) => vec!["B"], + (true, 200, 240) => vec!["C"], + _ => vec![], + } + }; + let groups = all_groups(&p); + // The longest runs first (AB, C) are rejected; the three single glyphs are kept. + let singles = |runs: &[kurbo::BezPath], _near: bool| runs.len() == 3; + assert_eq!(super::parts(&p, &groups, &find, &singles), vec![vec!["A"], vec!["B"], vec!["C"]]); + // When no complete split is accepted, nothing. + assert!(super::parts(&p, &groups, &find, &|_, _| false).is_empty()); +} + +#[test] +fn a_split_between_the_longest_and_the_shortest_runs_is_tried() { + use kurbo::Shape; + // Four groups A, B, C and D. ABC and D (the longest runs first) and the four single glyphs + // (the shortest) are complete splits the paint check rejects; AB and CD is the one it accepts. + let mut p = kurbo::BezPath::new(); + for x in [0.0, 100.0, 200.0, 300.0] { + p.extend(kurbo::Rect::new(x, 0.0, x + 40.0, 40.0).path_elements(0.1)); + } + let find = |path: &kurbo::BezPath, part: bool, _near: bool| -> Vec<&'static str> { + let b = path.bounding_box(); + match (part, b.x0.round() as i64, b.x1.round() as i64) { + (true, 0, 240) => vec!["ABC"], + (true, 0, 140) => vec!["AB"], + (true, 200, 340) => vec!["CD"], + (true, 0, 40) => vec!["A"], + (true, 100, 140) => vec!["B"], + (true, 200, 240) => vec!["C"], + (true, 300, 340) => vec!["D"], + _ => vec![], + } + }; + let groups = all_groups(&p); + let pairs = |runs: &[kurbo::BezPath], _near: bool| runs.len() == 2 && runs.first().is_some_and(|r| r.bounding_box().x1.round() as i64 == 140); + assert_eq!(super::parts(&p, &groups, &find, &pairs), vec![vec!["AB"], vec!["CD"]]); +} + +#[test] +fn at_most_max_split_tries_complete_splits_are_checked() { + use kurbo::Shape; + // Twelve groups, every run of up to three of them a glyph: far more complete splits than the + // cap. The paint check is asked about the cap's number of them and no more, and each run is + // looked up at most once. + let mut p = kurbo::BezPath::new(); + for i in 0..12 { + let x = f64::from(i) * 100.0; + p.extend(kurbo::Rect::new(x, 0.0, x + 40.0, 40.0).path_elements(0.1)); + } + let groups = all_groups(&p); + assert_eq!(groups.len(), 12); + let looked_up = std::cell::Cell::new(0usize); + let find = |_: &kurbo::BezPath| -> Vec<&'static str> { + looked_up.set(looked_up.get() + 1); + vec!["glyph"] + }; + let asked = &std::cell::Cell::new(0usize); + let accept_at = |n: usize| { + move |_: &[kurbo::BezPath]| { + asked.set(asked.get() + 1); + asked.get() == n + } + }; + // Rejected every time: the search stops at the cap. + assert!(super::split_parts(&groups, &find, &accept_at(usize::MAX)).is_empty()); + assert_eq!(asked.get(), super::MAX_SPLIT_TRIES); + assert!(looked_up.get() <= super::MAX_RUN * groups.len(), "{} lookups", looked_up.get()); + // A first split that is accepted looks up its own runs only: four runs of three groups. + asked.set(0); + looked_up.set(0); + assert_eq!(super::split_parts(&groups, &find, &accept_at(1)).len(), 4); + assert_eq!(looked_up.get(), 4); + // The last split tried is still taken; the one past the cap is not tried. + asked.set(0); + assert!(super::split_parts(&groups, &find, &accept_at(super::MAX_SPLIT_TRIES)).len() > 1); + asked.set(0); + assert!(super::split_parts(&groups, &find, &accept_at(super::MAX_SPLIT_TRIES + 1)).is_empty()); + assert_eq!(asked.get(), super::MAX_SPLIT_TRIES); +} + +/// `path`'s contour groups, with no limit on the contours grouped. +fn all_groups(path: &kurbo::BezPath) -> Vec { + let mut budget = usize::MAX; + super::split_groups(path, &mut budget) +} + +#[test] +fn exact_matches_of_the_parts_come_before_a_near_match_of_the_whole() { + use kurbo::Shape; + // Two groups side by side, each exactly a glyph (two periods), and the whole only nearly one + // (a dieresis): the parts win. + let mut p = kurbo::BezPath::new(); + for x in [0.0, 100.0] { + p.extend(kurbo::Rect::new(x, 0.0, x + 40.0, 40.0).path_elements(0.1)); + } + let find = |path: &kurbo::BezPath, part: bool, near: bool| -> Vec<&'static str> { + let b = path.bounding_box(); + match (part, near, b.x0.round() as i64, b.x1.round() as i64) { + (false, true, 0, 140) => vec!["dieresis"], + (true, _, 0, 40) | (true, _, 100, 140) => vec!["period"], + _ => vec![], + } + }; + let groups = all_groups(&p); + assert_eq!(super::parts(&p, &groups, &find, &|_, _| true), vec![vec!["period"], vec!["period"]]); + // When the parts match only nearly too, the whole near match comes first. + let near_only = |path: &kurbo::BezPath, part: bool, near: bool| -> Vec<&'static str> { + let b = path.bounding_box(); + match (part, near, b.x0.round() as i64, b.x1.round() as i64) { + (false, true, 0, 140) => vec!["dieresis"], + (true, true, 0, 40) | (true, true, 100, 140) => vec!["period"], + _ => vec![], + } + }; + assert_eq!(super::parts(&p, &groups, &near_only, &|_, _| true), vec![vec!["dieresis"]]); + // The split's paint check is told whether the parts were found nearly: exact parts are + // checked at tolerance 0 whatever tolerance the command was given. + let seen = std::cell::RefCell::new(vec![]); + let record = |_: &[kurbo::BezPath], near: bool| { + seen.borrow_mut().push(near); + true + }; + assert_eq!(super::parts(&p, &groups, &find, &record), vec![vec!["period"], vec!["period"]]); + assert_eq!(*seen.borrow(), vec![false]); + seen.borrow_mut().clear(); + let split_near_only = |path: &kurbo::BezPath, part: bool, near: bool| -> Vec<&'static str> { + let b = path.bounding_box(); + match (part, near, b.x0.round() as i64, b.x1.round() as i64) { + (true, true, 0, 40) | (true, true, 100, 140) => vec!["period"], + _ => vec![], + } + }; + assert_eq!(super::parts(&p, &groups, &split_near_only, &record), vec![vec!["period"], vec!["period"]]); + assert_eq!(*seen.borrow(), vec![true]); +} + +#[test] +fn a_shape_that_lost_a_glyph_drops_the_lines_of_its_other_glyphs() { + use std::collections::HashMap; + // Shapes 1 and 2 are two glyphs each, shape 3 one. Line 0 sets one glyph of 1 and one of 2; + // line 1 sets the other glyph of 2 and shape 3. Shape 1's other glyph is set nowhere. + let (a, b, c) = (NodeId(1), NodeId(2), NodeId(3)); + let glyphs_of: HashMap = [(a, 2), (b, 2), (c, 1)].into(); + let lines = vec![vec![a, b], vec![b, c]]; + let dropped = super::partial_lines(&lines, &glyphs_of); + assert!(dropped.contains(&0), "shape 1 is set only in part: {dropped:?}"); + assert!(dropped.contains(&1), "then shape 2 is too: {dropped:?}"); + // Every glyph set: nothing goes. + let whole = vec![vec![a, b], vec![a, b, c]]; + assert!(super::partial_lines(&whole, &glyphs_of).is_empty()); +} + +#[test] +fn a_compound_of_too_many_path_elements_is_not_grouped() { + // Two contours side by side, each a polygon of `k` corners. + let two = |k: usize| { + let mut p = kurbo::BezPath::new(); + for x in [0.0, 300.0] { + for i in 0..k { + let a = i as f64 / k as f64 * std::f64::consts::TAU; + let q = kurbo::Point::new(x + 100.0 + 100.0 * a.cos(), 100.0 + 100.0 * a.sin()); + if i == 0 { p.move_to(q) } else { p.line_to(q) } + } + p.close_path(); + } + p + }; + let mut budget = usize::MAX; + assert_eq!(super::split_groups(&two(100), &mut budget).len(), 2, "a small compound is grouped"); + let big = two(super::MAX_SPLIT_ELEMENTS / 2); + assert!(big.elements().len() > super::MAX_SPLIT_ELEMENTS); + let mut budget = usize::MAX; + assert!(super::split_groups(&big, &mut budget).is_empty(), "past the element limit it is matched whole only"); + assert_eq!(budget, usize::MAX, "and takes no contours from the budget"); +} + +#[test] +fn the_runs_and_near_keys_a_selection_is_looked_up_by_are_bounded() { + use kurbo::Shape; + use vectorcraft_text::retype::MAX_NEAR_KEYS; + // A compound path of `n` rectangles side by side, each of another width: every run of up to + // three of them has its own near key. + let row = |n: usize| { + let mut p = kurbo::BezPath::new(); + for i in 0..n { + let x = i as f64 * 100.0; + p.extend(kurbo::Rect::new(x, 0.0, x + 10.0 + i as f64 * 0.37, 40.0).path_elements(0.1)); + } + p + }; + // Each shape with its contour groups, as the command looks them up. + let with_groups = |shapes: &[kurbo::BezPath]| -> Vec<(kurbo::BezPath, Vec)> { + let mut budget = super::MAX_SPLIT_TOTAL_CONTOURS; + shapes.iter().map(|p| (p.clone(), super::split_groups(p, &mut budget))).collect() + }; + let keys_of = |shapes: &[(kurbo::BezPath, Vec)], tolerance: f64| { + super::lookup_keys(shapes.iter().map(|(p, g)| (p, g.as_slice())), tolerance) + }; + let few = with_groups(&[row(20)]); + assert_eq!(super::runs(&few[0].1).len(), 20 + 19 + 18, "every run of 1 to 3 groups"); + let (_, keys) = keys_of(&few, 0.01); + assert!(keys.len() > 20, "{}", keys.len()); + assert!(keys_of(&few, 0.0).1.is_empty(), "no near keys without a tolerance"); + // Past 256 groups the shape is matched whole only, and past 512 contours its contours are not + // grouped at all. + assert!(all_groups(&row(300)).is_empty()); + assert_eq!(all_groups(&row(256)).len(), 256); + let mut nested = kurbo::BezPath::new(); + for i in 0..200 { + // Each square with two squares inside it: 200 groups of 3 contours. + let x = i as f64 * 100.0; + nested.extend(kurbo::Rect::new(x, 0.0, x + 90.0, 90.0).path_elements(0.1)); + nested.extend(kurbo::Rect::new(x + 10.0, 10.0, x + 40.0, 40.0).path_elements(0.1)); + nested.extend(kurbo::Rect::new(x + 50.0, 50.0, x + 80.0, 80.0).path_elements(0.1)); + } + assert!(all_groups(&nested).is_empty(), "600 contours"); + assert_eq!(vectorcraft_text::retype::clusters(&nested).len(), 200, "which would make 200 groups"); + // Many shapes with many runs each: the near keys stop at the cap. + let mut shapes: Vec = (0..8).map(|k| kurbo::Affine::scale_non_uniform(1.0, 1.0 + k as f64 * 0.5) * row(200)).collect(); + let (_, keys) = keys_of(&with_groups(&shapes), 0.01); + assert_eq!(keys.len(), MAX_NEAR_KEYS); + // A plain shape selected after them still gets its own near key: whole shapes come first. + let plain = kurbo::Circle::new((0.0, 0.0), 30.0).to_path(0.1); + let key = vectorcraft_text::retype::near_key(&plain).unwrap(); + shapes.push(plain); + let (_, keys) = keys_of(&with_groups(&shapes), 0.01); + assert!(keys.contains(&key)); + // One command groups at most MAX_SPLIT_TOTAL_CONTOURS contours: the shapes after them are + // matched whole only. + let full = vec![row(256); super::MAX_SPLIT_TOTAL_CONTOURS / 256 + 1]; + let split: Vec = with_groups(&full).iter().map(|(_, g)| g.len()).collect(); + assert!(split[..split.len() - 1].iter().all(|n| *n == 256), "{split:?}"); + assert_eq!(split.last(), Some(&0)); +} + #[test] fn slight_tracking_without_spaces_is_kept() { // Tracking 3 moves the last glyph less than the layout check notices: both readings draw it. @@ -897,7 +1718,7 @@ fn lines_in(s: &Session, g: u64) -> Vec { for pc in &pieces { let cands: Vec<_> = index.matches(&pc.path).into_iter().filter(|m| m.face.id() == face).collect(); if !lines.last_mut().is_some_and(|l| super::join(l, pc, &cands)) { - lines.extend(super::new_line(pc, &cands)); + lines.extend(super::new_line(pc, &cands, 0.0)); } } lines diff --git a/crates/engine/src/cmd/style.rs b/crates/engine/src/cmd/style.rs index 1b5fec0a3b..14c6957e23 100644 --- a/crates/engine/src/cmd/style.rs +++ b/crates/engine/src/cmd/style.rs @@ -31,7 +31,7 @@ pub fn specs() -> Vec { "Apply Graphic Style", ["Window", "Graphic Styles"], None, - "{name, add?: bool, ids?|id? (layers too), target?: \"object\"|\"contents\"} give the objects (default: the selection; a group or layer itself, its fills and strokes painting its members and its effects applying to them as one piece; target contents: the objects inside instead) the style's appearance, opacity, blend mode, isolate and knockout, and link them to it (placed gradients land at the same place relative to each object's bounds); add: true (Alt-click) adds its fills, strokes and effects on top of the existing appearance instead and unlinks. On a path directly in a graph series (a series group's id stands for those paths), the graph also stores the paint, weight, opacity and blend mode of the topmost visible fill and stroke (with `add`: of the kinds of row the style shows) and, without `add`, the object's opacity and blend mode (exceptions, and the art of a graph design in a series, which is left out: docs/mcp.md); on a graph label, or a graph's axis line, tick mark or radar ring (a graph's Axes group stands for the lines and labels directly in it, its Legend group for the labels), the graph stores that object's topmost visible fill and stroke rows (with `add`: of the kinds of row the style shows) and, without `add`, its object opacity and blend mode for every label or line of its kind. With nothing selected (and no ids) the next object drawn takes the style instead (see appearance.newArt) → {newArt: true}", + "{name, add?: bool, ids?|id? (layers too), target?: \"object\"|\"contents\"} give the objects (default: the selection; a group or layer itself, its fills and strokes painting its members and its effects applying to them as one piece; target contents: the objects inside instead) the style's appearance, opacity, blend mode, isolate and knockout, and link them to it (placed gradients land at the same place relative to each object's bounds); add: true (Alt-click) adds its fills, strokes and effects on top of the existing appearance instead and unlinks. In the contents of a Live Paint group, each face takes only the style's fills and each edge only its strokes, and neither is linked. On a path directly in a graph series (a series group's id stands for those paths), the graph also stores the paint, weight, opacity and blend mode of the topmost visible fill and stroke (with `add`: of the kinds of row the style shows) and, without `add`, the object's opacity and blend mode (exceptions, and the art of a graph design in a series, which is left out: docs/mcp.md); on a graph label, or a graph's axis line, tick mark or radar ring (a graph's Axes group stands for the lines and labels directly in it, its Legend group for the labels), the graph stores that object's topmost visible fill and stroke rows (with `add`: of the kinds of row the style shows) and, without `add`, its object opacity and blend mode for every label or line of its kind. With nothing selected (and no ids) the next object drawn takes the style instead (see appearance.newArt) → {newArt: true}", has_doc, style_apply ), @@ -351,6 +351,9 @@ fn style_apply(s: &mut Session, p: &Value) -> Result { // The series groups their paths stand for: a style that replaces the appearance clears what they hold themselves, // and a style added on top unlinks them. let groups = super::appearance::stood_for(&own, &ids); + // In the contents of a Live Paint group, a face takes the style's fills and an edge its strokes. + let (faces, edges) = super::appearance::contents_parts(s, p)?; + let part = |id: &NodeId| (faces.contains(id) || edges.contains(id)).then(|| faces.contains(id)); if ids.is_empty() { if p.get("ids").is_some() || p.get("id").is_some() { return Err(bad("graphicStyle.apply", "no such objects")); @@ -361,13 +364,20 @@ fn style_apply(s: &mut Session, p: &Value) -> Result { return Ok(json!({ "newArt": true })); } let before = s.doc()?.doc.clone(); - s.edit("Apply Graphic Style", |d, _| { + // An apply that changes nothing (a fill-only style added to edges only) records no undo step. + super::overprint::edit_counted(s, "Apply Graphic Style", |d| { if add { let g = d.graphic_styles[i].clone(); for id in &ids { if let Some(n) = d.node_mut(*id) { let ap = g.appearance_on(n).into_owned(); - n.appearance.items.extend(ap.items); + let kind = part(id); + let rows: Vec<_> = ap.items.into_iter().filter(|it| kind.is_none_or(|fill| it.is_fill() == fill)).collect(); + // A face or edge the style adds nothing to keeps its appearance and its link. + if kind.is_some() && rows.is_empty() && ap.effects.is_empty() { + continue; + } + n.appearance.items.extend(rows); n.appearance.effects.extend(ap.effects); n.extras_mut().graphic_style = None; } @@ -387,13 +397,18 @@ fn style_apply(s: &mut Session, p: &Value) -> Result { let mut shared = None; for id in &ids { apply_style(d, *id, &g, &mut shared, chars); + // A face or edge that keeps only the rows of its kind no longer has the style's look, so it is not linked. + if let (Some(fill), Some(n)) = (part(id), d.node_mut(*id)) { + super::appearance::keep_rows_of_kind(n, fill); + n.extras_mut().graphic_style = None; + } } super::appearance::clear_stood_for(d, &groups); super::appearance::capture_series_writes(&before, d, &ids, (true, true), (true, true), false, true); // A label or graph line keeps its new rows for its kind. super::graph::capture_label_rows(d, &ids); } - Ok(()) + Ok(usize::from(*d != *before)) })?; ok() } diff --git a/crates/engine/src/cmd/symbollib.rs b/crates/engine/src/cmd/symbollib.rs index 660e15248c..60db399f42 100644 --- a/crates/engine/src/cmd/symbollib.rs +++ b/crates/engine/src/cmd/symbollib.rs @@ -15,7 +15,7 @@ use vectorcraft_color::{Color, Paint}; use vectorcraft_doc::{Appearance, Document, Node, NodeId, NodeKind, Symbol, SymbolNineSlice}; use vectorcraft_geom::{Affine, Anchor, AnchorKind, PathData, Point, Rect, SubPath, shapes}; -use super::brushsym::{CURRENT_SYMBOL, natural_size, normalize, place_xf, set_natural_size}; +use super::brushsym::{CURRENT_SYMBOL, Placement, natural_size, normalize, place_xf, set_natural_size}; use super::clipboard::Clipboard; use super::clipboard::resources::SwatchChoices; use super::swatch::str_list; @@ -50,7 +50,7 @@ pub fn specs() -> Vec { "Add to Symbols", ["Window", "Symbol Libraries"], None, - "{library: id or name, name? | names?: [symbol names in the library] (default: all of it), place?: false (also place an instance of the first one, its registration point at x, y: default the first artboard's centre), x?, y?, swatchConflict? (as edit.paste)} copy library symbols into the document's Symbols as one undo step (with the place), with their Symbol Options and the resources they use (the symbols they nest, patterns, swatches, brushes, graphic styles, images). A symbol the document already has (same name and art) isn't added again; a name another symbol has gets a number (\"Star 2\"). The first one becomes the current symbol → {library, names: [each symbol's name in the document], added: [names added], existing: [names already there], placed?: id}", + "{library: id or name, name? | names?: [symbol names in the library] (default: all of it), place?: false (also place an instance of the first one, its registration point at x, y: default the first artboard's centre, in the stacking order symbol.place gives it, Draw Behind included), x?, y?, swatchConflict? (as edit.paste)} copy library symbols into the document's Symbols as one undo step (with the place), with their Symbol Options and the resources they use (the symbols they nest, patterns, swatches, brushes, graphic styles, images). A symbol the document already has (same name and art) isn't added again; a name another symbol has gets a number (\"Star 2\"). The first one becomes the current symbol → {library, names: [each symbol's name in the document], added: [names added], existing: [names already there], placed?: id}", has_doc, add ), @@ -59,7 +59,7 @@ pub fn specs() -> Vec { "Place Symbol Instance", [], None, - "{sourceDocument: uid, name: a symbol of that document, x?, y?} place an instance of a symbol of another open document so its registration point is at (x, y) (default: the first artboard's center), as a symbol dragged from that document's Symbols panel onto the canvas is placed. The symbol, the symbols it nests and the resources they use are added as a drop of art from that document adds them, in the same undo step as the instance: a symbol the active document already has with the same name, art and Symbol Options is used, and one with the same name but other art or Symbol Options gets a number (\"Leaf 2\"); each symbol added takes its Symbol Options along. When sourceDocument is the active document, its own symbol is placed, as symbol.place places it. An error, with no edit, when that document is no longer open or has no symbol `name` → {id, name: the symbol's name in the active document}", + "{sourceDocument: uid, name: a symbol of that document, x?, y?} place an instance of a symbol of another open document so its registration point is at (x, y) (default: the first artboard's center), in the stacking order symbol.place gives it (Draw Behind included), as a symbol dragged from that document's Symbols panel onto the canvas is placed. The symbol, the symbols it nests and the resources they use are added as a drop of art from that document adds them, in the same undo step as the instance: a symbol the active document already has with the same name, art and Symbol Options is used, and one with the same name but other art or Symbol Options gets a number (\"Leaf 2\"); each symbol added takes its Symbol Options along. When sourceDocument is the active document, its own symbol is placed, as symbol.place places it. An error, with no edit, when that document is no longer open or has no symbol `name` → {id, name: the symbol's name in the active document}", has_doc, place_from_document ), @@ -816,7 +816,7 @@ fn add(s: &mut Session, p: &Value) -> Result { let doc_names: Vec = picked.iter().map(|n| target(&imported.renamed, n)).collect(); let centre = st.doc.artboards.first().map(|a| a.rect.center()).unwrap_or(Point::ZERO); let at = if place { Some(Point::new(number_or(p, "x", centre.x, C)?, number_or(p, "y", centre.y, C)?)) } else { None }; - let parent = if place { st.target_parent()? } else { None }; + let spot = if place { Some(Placement::of(s)?) } else { None }; let mut out = json!({ "library": shown_library_id(s, &info.id) }); if imported.added > 0 || place { let placed = s.edit("Add to Symbols", |d, sel| { @@ -830,10 +830,10 @@ fn add(s: &mut Session, p: &Value) -> Result { } let Some(first) = doc_names.first() else { return Ok(None) }; d.unknown.insert(CURRENT_SYMBOL.into(), json!(first)); - let Some(at) = at else { return Ok(None) }; + let (Some(at), Some(spot)) = (at, &spot) else { return Ok(None) }; let xf = place_xf(at, natural_size(d, first), d.symbol_registration(first)); let id = d.alloc_id(); - d.insert(parent, usize::MAX, Node::new(id, NodeKind::SymbolInstance { symbol: first.clone(), xf }))?; + spot.insert(d, Node::new(id, NodeKind::SymbolInstance { symbol: first.clone(), xf }))?; sel.set([id]); Ok(Some(id)) })?; @@ -860,7 +860,7 @@ fn place_from_document(s: &mut Session, p: &Value) -> Result { let st = s.doc()?; let centre = st.doc.artboards.first().map(|a| a.rect.center()).unwrap_or(Point::ZERO); let at = Point::new(number_or(p, "x", centre.x, C)?, number_or(p, "y", centre.y, C)?); - let parent = st.target_parent()?; + let spot = Placement::of(s)?; let same = uid == st.uid; let src = s.documents().iter().find(|d| d.uid == uid).map(|d| Arc::clone(&d.doc)); let src = src.ok_or_else(|| bad(C, "the document the symbol came from is no longer open"))?; @@ -883,7 +883,7 @@ fn place_from_document(s: &mut Session, p: &Value) -> Result { }; let xf = place_xf(at, natural_size(d, &placed), d.symbol_registration(&placed)); let id = d.alloc_id(); - d.insert(parent, usize::MAX, Node::new(id, NodeKind::SymbolInstance { symbol: placed.clone(), xf }))?; + spot.insert(d, Node::new(id, NodeKind::SymbolInstance { symbol: placed.clone(), xf }))?; sel.set([id]); Ok((id, placed)) })?; diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs index c39c88cbbb..d92bcb7d71 100644 --- a/crates/engine/src/tests.rs +++ b/crates/engine/src/tests.rs @@ -112,6 +112,7 @@ mod live; mod livecorners; mod maskview; pub(super) mod menucmds; +mod mesh_picks; mod nativefile; mod newart; mod newdoc; diff --git a/crates/engine/src/tests/brushsym.rs b/crates/engine/src/tests/brushsym.rs index 1d53214ec9..62b1bac629 100644 --- a/crates/engine/src/tests/brushsym.rs +++ b/crates/engine/src/tests/brushsym.rs @@ -2228,6 +2228,73 @@ fn place_and_break_link_round_trip_geometry() { assert_eq!(n.appearance.stroke_width(), 1.0, "strokes are not scaled by normalisation"); } +/// In Draw Behind, Place Symbol Instance puts the instance directly below the bottommost selected +/// object (beside the compound path that holds a selected path, above a clipping path), or at the +/// bottom of the current layer with nothing selected, selected and in one undo step. Draw Normal +/// and Draw Inside keep it on top, and a locked layer refuses it with no edit. +#[test] +fn placed_instances_go_below_the_selection_in_draw_behind() { + let mut s = session(); + let (inst, name, _) = make_symbol(&mut s); + let (a, b) = (rect(&mut s, 0.0, 0.0, 10.0, 10.0), rect(&mut s, 20.0, 0.0, 10.0, 10.0)); + let layer = s.doc().unwrap().doc.layers[0].id; + let kids = |s: &Session, id: NodeId| node(s, id).children().unwrap().iter().map(|c| c.id).collect::>(); + let place = |s: &mut Session| NodeId(s.execute("symbol.place", &json!({"name": name, "x": 300, "y": 200})).unwrap()["id"].as_u64().unwrap()); + s.execute("view.drawMode", &json!({"mode": "behind"})).unwrap(); + select(&mut s, &[b]); + let before = undo_len(&s); + let p = place(&mut s); + assert_eq!(kids(&s, layer), vec![inst, a, p, b], "directly below the selected object"); + assert_eq!(undo_len(&s), before + 1); + assert_eq!(s.doc().unwrap().selection.objects, [p]); + assert!(close(bounds(&s, p), Rect::new(260.0, 180.0, 340.0, 220.0), 1e-9), "{:?}", bounds(&s, p)); + s.execute("edit.undo", &json!({})).unwrap(); + assert_eq!(kids(&s, layer), vec![inst, a, b]); + // Below the bottommost of several selected objects. + select(&mut s, &[b, a]); + let p = place(&mut s); + assert_eq!(kids(&s, layer), vec![inst, p, a, b]); + s.execute("edit.undo", &json!({})).unwrap(); + // With nothing selected, at the bottom of the current layer. + select(&mut s, &[]); + let p = place(&mut s); + assert_eq!(kids(&s, layer), vec![p, inst, a, b]); + s.execute("edit.undo", &json!({})).unwrap(); + // A path selected in a compound path: beside the compound path, not inside it. + select(&mut s, &[a, b]); + s.execute("object.compoundPath.make", &json!({})).unwrap(); + let compound = kids(&s, layer)[1]; + let member = kids(&s, compound)[1]; + select(&mut s, &[member]); + let p = place(&mut s); + assert_eq!(kids(&s, layer), vec![inst, p, compound]); + assert_eq!(kids(&s, compound).len(), 2); + s.execute("edit.undo", &json!({})).unwrap(); + // Draw Normal and Draw Inside put it on top of the layer. + for mode in ["normal", "inside"] { + select(&mut s, &[compound]); + s.execute("view.drawMode", &json!({"mode": mode})).unwrap(); + let p = place(&mut s); + assert_eq!(kids(&s, layer), vec![inst, compound, p], "{mode}"); + s.execute("edit.undo", &json!({})).unwrap(); + } + // In a clipping layer the clipping path stays at the bottom, the selected clipping path too. + s.execute("view.drawMode", &json!({"mode": "behind"})).unwrap(); + s.execute("layer.clippingMask.toggle", &json!({"id": layer.0})).unwrap(); + assert_eq!(kids(&s, layer), vec![compound, inst]); + for picked in [&[][..], &[compound]] { + select(&mut s, picked); + let p = place(&mut s); + assert_eq!(kids(&s, layer), vec![compound, p, inst], "{picked:?}"); + s.execute("edit.undo", &json!({})).unwrap(); + } + // A locked layer takes nothing. + s.execute("layer.setProps", &json!({"id": layer.0, "locked": true})).unwrap(); + let before = (undo_len(&s), s.doc().unwrap().doc.clone()); + assert!(s.execute("symbol.place", &json!({"name": name})).is_err()); + assert_eq!((undo_len(&s), &s.doc().unwrap().doc), (before.0, &before.1)); +} + #[test] fn hidden_instance_fill_does_not_tint_expanded_symbol_art() { for command in ["symbol.breakLink", "object.expand"] { diff --git a/crates/engine/src/tests/build.rs b/crates/engine/src/tests/build.rs index 316e9b8ffc..b37550d5c5 100644 --- a/crates/engine/src/tests/build.rs +++ b/crates/engine/src/tests/build.rs @@ -4630,6 +4630,93 @@ fn live_paint_group_with_only_source_paths_ignores_add_fill_and_add_stroke_of_it assert!(s.execute("appearance.addFill", &json!({"target": "contents"})).is_err(), "no selection is still refused"); } +/// Whether every face of Live Paint group `g` holds only fill rows and every edge only stroke rows. +fn parts_hold_their_kind(s: &Session, g: NodeId) -> bool { + let (faces, edges) = part_looks(s, g); + faces.iter().all(|a| a.items.iter().all(|it| it.is_fill())) && edges.iter().all(|a| a.items.iter().all(|it| !it.is_fill())) +} + +/// A graphic style applied to the contents of a Live Paint group, replacing their appearance or added to it, gives +/// the faces its fills and the edges its strokes, and the faces and edges are not linked to it. +#[test] +fn live_paint_group_contents_take_a_graphic_style_by_kind() { + let red = Paint::solid(Color::from_hex("#ff0000").unwrap()); + let blue = Paint::solid(Color::from_hex("#0000ff").unwrap()); + for add in [false, true] { + let mut s = session(); + let g = live(&mut s); + let r = rect(&mut s, 400.0, 0.0, 50.0, 50.0); + s.execute("select.set", &json!({"ids": [r.0]})).unwrap(); + s.execute("paint.setFill", &json!({"color": "#ff0000"})).unwrap(); + s.execute("paint.setStroke", &json!({"color": "#0000ff"})).unwrap(); + s.execute("graphicStyle.new", &json!({"name": "Both", "id": r.0})).unwrap(); + s.execute("select.set", &json!({"ids": [g.0]})).unwrap(); + s.execute("graphicStyle.apply", &json!({"name": "Both", "target": "contents", "add": add})).unwrap(); + assert!(parts_hold_their_kind(&s, g), "add {add}: faces hold fills and edges strokes"); + let (faces, edges) = part_looks(&s, g); + assert!(faces.iter().all(|a| a.items.iter().any(|it| *it.paint() == red)), "add {add}: each face takes the style's fill"); + assert!(edges.iter().all(|a| a.items.iter().any(|it| *it.paint() == blue)), "add {add}: each edge takes the style's stroke"); + let n = node(&s, g); + let mut parts = vectorcraft_tools::builder::faces(&n).into_iter().chain(vectorcraft_tools::builder::edges(&n)); + assert!(parts.all(|p| p.extras().graphic_style.is_none()), "add {add}: no face or edge is linked"); + } +} + +/// A fill-only graphic style added to the contents of a Live Paint group without faces changes nothing and records no +/// undo step. +#[test] +fn live_paint_group_contents_without_faces_take_no_fill_only_style() { + let mut s = session(); + let g = live(&mut s); + let faces: Vec = vectorcraft_tools::builder::faces(&node(&s, g)).iter().map(|p| p.id).collect(); + s.edit("t", |d, _| { + d.children_mut(Some(g)).unwrap().retain(|c| !faces.contains(&c.id)); + Ok(()) + }) + .unwrap(); + let r = rect(&mut s, 400.0, 0.0, 50.0, 50.0); + s.edit("t", |d, _| { + let fill = AppearanceItem::Fill(FillLayer::new(Paint::solid(Color::from_hex("#ff0000").unwrap()))); + d.node_mut(r).unwrap().appearance = vectorcraft_doc::Appearance { items: vec![fill], ..Default::default() }.into(); + Ok(()) + }) + .unwrap(); + s.execute("graphicStyle.new", &json!({"name": "Fill", "id": r.0})).unwrap(); + // The edges are linked to a style of their own, which they keep. + let edge = vectorcraft_tools::builder::edges(&node(&s, g))[0].id; + s.execute("graphicStyle.new", &json!({"name": "Edge", "id": edge.0})).unwrap(); + assert!(node(&s, g).children().unwrap().iter().any(|c| c.extras().graphic_style.is_some()), "an edge is linked"); + s.execute("select.set", &json!({"ids": [g.0]})).unwrap(); + let (before, undo) = (node(&s, g), s.doc().unwrap().history.undo.len()); + s.execute("graphicStyle.apply", &json!({"name": "Fill", "target": "contents", "add": true})).unwrap(); + assert_eq!(node(&s, g), before, "the edges keep their rows and their link"); + assert_eq!(s.doc().unwrap().history.undo.len(), undo, "no undo step"); +} + +/// Clear Appearance and Reduce to Basic Appearance on the contents of a Live Paint group leave each face with fill +/// rows only and each edge with stroke rows only. +#[test] +fn live_paint_group_contents_clear_and_reduce_keep_each_part_to_its_kind() { + for cmd in ["appearance.clear", "appearance.reduceToBasic"] { + let mut s = session(); + let g = live(&mut s); + s.execute("select.set", &json!({"ids": [g.0]})).unwrap(); + s.execute("paint.setFill", &json!({"color": "#ff00ff"})).unwrap(); + s.execute("paint.setStroke", &json!({"color": "#0000ff"})).unwrap(); + // A face and an edge given rows of the other kind through their own ids. + let n = node(&s, g); + let (face, edge) = (vectorcraft_tools::builder::faces(&n)[0].id, vectorcraft_tools::builder::edges(&n)[0].id); + s.execute("appearance.addStroke", &json!({"ids": [face.0]})).unwrap(); + s.execute("appearance.addFill", &json!({"ids": [edge.0]})).unwrap(); + assert!(!parts_hold_their_kind(&s, g), "{cmd}: the face and the edge hold rows of the other kind"); + s.execute("select.set", &json!({"ids": [g.0]})).unwrap(); + s.execute(cmd, &json!({"target": "contents"})).unwrap(); + assert!(parts_hold_their_kind(&s, g), "{cmd}: faces hold fills and edges strokes"); + let (faces, edges) = part_looks(&s, g); + assert!(faces.iter().chain(&edges).all(|a| !a.items.is_empty()), "{cmd}: each face and edge keeps a row"); + } +} + /// A selected Live Paint group with no part of the edited kind is still a selection: a stroke edit /// of a group without edges, or a fill gradient edit of a group without faces, changes nothing and /// leaves the settings for new art as they are. diff --git a/crates/engine/src/tests/links.rs b/crates/engine/src/tests/links.rs index 5dd3357641..268fa79ad0 100644 --- a/crates/engine/src/tests/links.rs +++ b/crates/engine/src/tests/links.rs @@ -2617,6 +2617,37 @@ fn confined_screens_rows_check_the_artboard_each_file_holds() { } } +/// A confined caller's single-file PDF with Preserve Editing of several artboards carries the art +/// of every artboard on its pages: an image linked outside the read roots on the second artboard +/// alone refuses it. A single-file PDF of assets is refused before any link is checked. +#[test] +fn confined_single_file_pdf_checks_every_artboard_it_carries() { + use crate::file_access::{AutomationRoots, confine}; + + let away = Folder::new("single-pdf-away"); + let home = Folder::new("single-pdf-home"); + let photo = away.file("photo.png"); + write(&photo, &png(60, 30, RED)); + let mut s = session(); + let r = s.execute("shape.rectangle", &json!({"x": 10, "y": 10, "width": 50, "height": 20})).unwrap(); + let rect: vectorcraft_doc::NodeId = serde_json::from_value(r["id"].clone()).unwrap(); + s.execute("artboard.new", &json!({"x": 2000, "y": 0, "width": 200, "height": 200})).unwrap(); + let roots = AutomationRoots::new(&[home.0.as_path()], &[home.0.as_path()]).unwrap(); + let p = |folder: &str| json!({"range": "1-2", "folder": home.file(folder), "pdfs": "single", "formats": [{"format": "pdf", "preserveEditing": true}]}); + let r = confine(roots.as_ref(), || s.execute("document.exportForScreens", &p("plain"))).unwrap_or_else(|e| panic!("{e}")); + assert_eq!(r["files"].as_array().map(Vec::len), Some(1), "{r}"); + let r = s.execute("file.place", &json!({"path": photo, "at": [2100, 100]})).unwrap(); + assert_eq!(r["linked"], true, "{r}"); + let e = confine(roots.as_ref(), || s.execute("document.exportForScreens", &p("linked"))).expect_err("second artboard links outside").to_string(); + assert!(e.contains("a linked image file is outside the read roots"), "{e}"); + assert!(!Path::new(&home.file("linked")).exists(), "the refused export writes no folder"); + let asset = s.execute("assets.add", &json!({"ids": [rect.0]})).unwrap()["assets"][0].as_u64().unwrap(); + let assets = json!({"assets": [asset], "folder": home.file("assets"), "pdfs": "single", "formats": [{"format": "pdf", "preserveEditing": true}]}); + let e = confine(roots.as_ref(), || s.execute("assets.export", &assets)).expect_err("single-file PDF of assets").to_string(); + assert!(e.contains("pdfs `single` writes artboards as the pages of one PDF"), "{e}"); + assert!(!Path::new(&home.file("assets")).exists(), "the refused export writes no folder"); +} + /// A confined caller's native outputs (a native file or template, an EPS or `.ai` file, a PDF with /// Preserve Editing, a package's document) carry the document without the Export for Screens /// folder when it is outside the read roots, with the other export settings and the art; the open diff --git a/crates/engine/src/tests/mesh_picks.rs b/crates/engine/src/tests/mesh_picks.rs new file mode 100644 index 0000000000..93556481da --- /dev/null +++ b/crates/engine/src/tests/mesh_picks.rs @@ -0,0 +1,127 @@ +//! Gradient mesh points picked with one of the tools that pick them (the Mesh tool, Direct +//! Selection, the Lasso, the Polygonal Lasso) stay picked when another of them is chosen, or lent +//! for a Cmd-click, so a fill color then recolors just them. + +use serde_json::json; +use vectorcraft_color::Color; +use vectorcraft_doc::NodeKind; +use vectorcraft_tools::{Mods, PointerEvent, PointerKind}; + +use crate::*; + +/// A session with a selected 1 x 1 gradient mesh (four white points) at (10, 10), 50 pt square. +fn mesh_session() -> (Session, NodeId) { + let mut s = Session::new(); + s.execute("file.new", &json!({"width": 800, "height": 600})).unwrap(); + let m = NodeId(s.execute("shape.rectangle", &json!({"x": 10, "y": 10, "width": 50, "height": 50})).unwrap()["id"].as_u64().unwrap()); + s.execute("object.mesh.create", &json!({"ids": [m.0], "rows": 1, "cols": 1})).unwrap(); + s.execute("select.set", &json!({"ids": [m.0]})).unwrap(); + (s, m) +} + +fn colors(s: &Session, m: NodeId) -> Vec { + match &s.doc().unwrap().doc.node(m).unwrap().kind { + NodeKind::Mesh(g) => g.points.iter().map(|p| p.color).collect(), + k => panic!("not a mesh: {k:?}"), + } +} + +/// Click mesh point `i` of `m` with the active tool. +fn press(s: &mut Session, m: NodeId, i: usize, mods: Mods) { + let q = match &s.doc().unwrap().doc.node(m).unwrap().kind { + NodeKind::Mesh(g) => g.points[i].p, + k => panic!("not a mesh: {k:?}"), + }; + for kind in [PointerKind::Down, PointerKind::Up] { + s.pointer(&PointerEvent::new(kind, q.x, q.y).with_mods(mods), ViewInfo::default()).unwrap(); + } +} + +/// A point picked with the Mesh tool stays picked through Direct Selection, the Lasso and the +/// Polygonal Lasso and back to the Mesh tool: each fill color recolors just that point. +#[test] +fn mesh_point_picks_carry_between_the_mesh_point_tools() { + let (mut s, m) = mesh_session(); + let v = ViewInfo::default(); + let white = colors(&s, m)[0]; + s.select_tool("mesh", v).unwrap(); + press(&mut s, m, 0, Mods::default()); + for (tool, hex, c) in [ + ("directSelection", "#0000ff", Color::rgb8(0, 0, 255)), + ("lasso", "#00ff00", Color::rgb8(0, 255, 0)), + ("polygonalLasso", "#ff0000", Color::rgb8(255, 0, 0)), + ("directSelection", "#ffff00", Color::rgb8(255, 255, 0)), + ("mesh", "#00ffff", Color::rgb8(0, 255, 255)), + ] { + s.select_tool(tool, v).unwrap(); + s.execute("paint.setFill", &json!({"color": hex})).unwrap(); + assert_eq!(colors(&s, m), [c, white, white, white], "{tool} recolors only the picked point"); + } +} + +/// A point picked with Direct Selection stays picked for the Mesh tool. +#[test] +fn direct_selection_picks_carry_to_the_mesh_tool() { + let (mut s, m) = mesh_session(); + let v = ViewInfo::default(); + let white = colors(&s, m)[0]; + s.select_tool("directSelection", v).unwrap(); + press(&mut s, m, 2, Mods::default()); + s.select_tool("mesh", v).unwrap(); + s.execute("paint.setFill", &json!({"color": "#0000ff"})).unwrap(); + assert_eq!(colors(&s, m), [white, white, Color::rgb8(0, 0, 255), white]); +} + +/// The Selection tool picks no mesh points: after it, the Mesh tool starts with none picked, and a +/// fill color leaves every point as it was. +#[test] +fn a_tool_that_picks_no_mesh_points_drops_the_picks() { + let (mut s, m) = mesh_session(); + let v = ViewInfo::default(); + let before = colors(&s, m); + s.select_tool("mesh", v).unwrap(); + press(&mut s, m, 0, Mods::default()); + s.select_tool("selection", v).unwrap(); + s.execute("select.set", &json!({"ids": [m.0]})).unwrap(); + s.select_tool("mesh", v).unwrap(); + s.execute("paint.setFill", &json!({"color": "#0000ff"})).unwrap(); + assert_eq!(colors(&s, m), before, "no point is picked"); +} + +/// A plain Lasso click away from the art deselects it and unpicks the points the Mesh tool picked, +/// so the Mesh tool chosen next has none picked. +#[test] +fn a_lasso_click_that_deselects_unpicks_the_mesh_points() { + let (mut s, m) = mesh_session(); + let v = ViewInfo::default(); + let before = colors(&s, m); + s.select_tool("mesh", v).unwrap(); + press(&mut s, m, 0, Mods::default()); + s.select_tool("lasso", v).unwrap(); + for kind in [PointerKind::Down, PointerKind::Up] { + s.pointer(&PointerEvent::new(kind, 500.0, 500.0), v).unwrap(); + } + assert!(s.doc().unwrap().selection.objects.is_empty(), "the click deselects the mesh"); + s.execute("select.set", &json!({"ids": [m.0]})).unwrap(); + s.select_tool("mesh", v).unwrap(); + s.execute("paint.setFill", &json!({"color": "#0000ff"})).unwrap(); + assert_eq!(colors(&s, m), before, "no point is picked"); +} + +/// Direct Selection lent to the Mesh tool for a Cmd-click starts from the Mesh tool's picks, so a +/// Shift-click adds to them, and gives back what it left picked. +#[test] +fn the_lent_direct_selection_carries_the_mesh_tools_picks() { + let (mut s, m) = mesh_session(); + let v = ViewInfo::default(); + let white = colors(&s, m)[0]; + // Cmd lends the selection tool chosen last. + s.select_tool("directSelection", v).unwrap(); + s.select_tool("mesh", v).unwrap(); + press(&mut s, m, 0, Mods::default()); + press(&mut s, m, 3, Mods { cmd: true, shift: true, ..Default::default() }); + assert_eq!(s.tool_id(), "mesh"); + s.execute("paint.setFill", &json!({"color": "#0000ff"})).unwrap(); + let b = Color::rgb8(0, 0, 255); + assert_eq!(colors(&s, m), [b, white, white, b], "both points stay picked"); +} diff --git a/crates/engine/src/tests/symbollib.rs b/crates/engine/src/tests/symbollib.rs index de7f938f78..19d2333b6e 100644 --- a/crates/engine/src/tests/symbollib.rs +++ b/crates/engine/src/tests/symbollib.rs @@ -514,3 +514,45 @@ fn another_documents_symbol_is_added_and_placed_in_one_step() { let e = s.execute("symbol.placeFromDocument", &json!({"sourceDocument": source, "name": "Star"})).unwrap_err(); assert!(e.to_string().contains("no longer open"), "{e}"); } + +/// A symbol dragged onto the canvas, from another document's Symbols panel or from a symbol +/// library, is stacked as Place Symbol Instance stacks it: in Draw Behind directly below the +/// selected object, or at the bottom of the current layer with nothing selected, in one undo step +/// with the symbol it adds. A locked layer refuses it with no edit. +#[test] +fn dropped_symbols_go_below_the_selection_in_draw_behind() { + let mut s = kit(); + let source = s.doc().unwrap().uid; + run(&mut s, "file.new", json!({"width": 100, "height": 100})); + let rect = + |s: &mut Session, x: f64| NodeId(run(s, "shape.rectangle", json!({"x": x, "y": 0, "width": 10, "height": 10}))["id"].as_u64().unwrap()); + let (a, b) = (rect(&mut s, 0.0), rect(&mut s, 20.0)); + let layer = doc(&s).layers[0].id; + let kids = |s: &Session| doc(s).node(layer).unwrap().children().unwrap().iter().map(|c| c.id).collect::>(); + run(&mut s, "view.drawMode", json!({"mode": "behind"})); + let drops = [ + ("symbol.placeFromDocument", json!({"sourceDocument": source, "name": "Badge", "x": 30, "y": 40}), "id"), + ("symbol.addFromLibrary", json!({"library": "basic shapes", "name": "Square", "place": true, "x": 30, "y": 40}), "placed"), + ]; + for (cmd, p, key) in &drops { + for (picked, at) in [(vec![b], 1), (vec![], 0)] { + run(&mut s, "select.set", json!({"ids": picked.iter().map(|i| i.0).collect::>()})); + let before = undo_len(&s); + let placed = NodeId(run(&mut s, cmd, p.clone())[*key].as_u64().unwrap()); + let mut want = vec![a, b]; + want.insert(at, placed); + assert_eq!(kids(&s), want, "{cmd} {picked:?}"); + assert_eq!(undo_len(&s), before + 1, "{cmd}"); + assert_eq!(s.doc().unwrap().selection.objects, [placed]); + run(&mut s, "edit.undo", json!({})); + assert!(symbols(&s).is_empty(), "{cmd}: the undo takes the added symbol too"); + } + } + // A locked layer takes nothing. + run(&mut s, "layer.setProps", json!({"id": layer.0, "locked": true})); + let before = (undo_len(&s), doc(&s).clone()); + for (cmd, p, _) in &drops { + assert!(s.execute(cmd, p).is_err(), "{cmd}"); + assert_eq!((undo_len(&s), doc(&s)), (before.0, &before.1), "{cmd}"); + } +} diff --git a/crates/engine/src/tooling.rs b/crates/engine/src/tooling.rs index 7b1caffb7c..7c1af811ed 100644 --- a/crates/engine/src/tooling.rs +++ b/crates/engine/src/tooling.rs @@ -186,12 +186,13 @@ impl Session { let text_selection = ((id == "eyedropper" && is_type(self.tool.id())) || (self.tool.id() == "eyedropper" && is_type(id))) .then(|| self.tool.options()) .filter(|o| o.get("editing").is_some_and(|v| !v.is_null()) && o.get("start") != o.get("end")); - // The gradient mesh points the Mesh tool, Direct Selection or the Lasso picked stay picked - // for the Eyedropper, which samples into them (#8090), and for the tool after it. - let mesh_points = (id == "eyedropper" || self.tool.id() == "eyedropper") + // The gradient mesh points the Mesh tool, Direct Selection, the Lasso or the Polygonal Lasso + // picked stay picked when another of these tools or the Eyedropper, which samples into + // them (#8090), is chosen: a fill color then recolors just them. None stay picked when + // none were. + let mesh_points = (Self::picks_mesh_points(id) && Self::picks_mesh_points(self.tool.id())) .then(|| self.tool.options().get("meshPoints").cloned()) - .flatten() - .filter(|v| v.as_array().is_some_and(|a| !a.is_empty())); + .flatten(); self.deactivate_tool(view)?; self.keep_tool_settings(); self.tool = self.make_tool(id); @@ -208,6 +209,13 @@ impl Session { Ok(()) } + /// Does tool `id` pick gradient mesh points (its `meshPoints` option): the Mesh tool, Direct + /// Selection, the Lasso, the Polygonal Lasso and the Eyedropper? Group Selection, which + /// selects whole objects, does not. + fn picks_mesh_points(id: &str) -> bool { + matches!(id, "mesh" | "directSelection" | "lasso" | "polygonalLasso" | "eyedropper") + } + /// Deactivate the tool and apply the actions it returns. In a batch, a Cancel is left out: the /// batch settled the tool's drag when it began, and the open interaction holds the batch's /// steps, which the batch keeps or rolls back as a whole. @@ -292,9 +300,9 @@ impl Session { // double-click or triple-click compares. self.tool.press_elsewhere(); let mut lent = self.make_tool(id); - // The gradient mesh points the Eyedropper holds are the lent tool's picks, which a Shift - // click adds to (#8090). - if self.tool.id() == "eyedropper" { + // The gradient mesh points the lending tool picked (the Mesh tool's, the Lasso's, the + // Eyedropper's) are the lent tool's picks, which a Shift click adds to (#8090). + if Self::picks_mesh_points(self.tool.id()) && Self::picks_mesh_points(id) { let points = self.tool.options().get("meshPoints").cloned().unwrap_or_else(|| Value::Array(vec![])); lent.set_option("meshPoints", &points); } @@ -312,10 +320,14 @@ impl Session { /// Cmd+click that takes the type being edited out of the selection ends its edit (#3779). pub(crate) fn give_back_tool(&mut self, view: ViewInfo) -> Result<()> { let Some(lender) = self.lender.take() else { return Ok(()) }; - // The points the lent tool left picked go back to the Eyedropper, none when it unpicked - // them all (#8090). Group Selection picks no mesh points, so the Eyedropper keeps its own. - let mesh_points = - (lender.id() == "eyedropper" && self.tool.id() != "groupSelection").then(|| self.tool.options().get("meshPoints").cloned()).flatten(); + // The points the lent tool left picked go back to the tool it was lent to when that tool + // picks mesh points, none when it unpicked them all (#8090). Group Selection and the + // Selection tool pick no mesh points, so the tool keeps its own. Unchanged picks are not + // set again, so the Mesh tool keeps the point whose handles it shows. + let mesh_points = (Self::picks_mesh_points(lender.id()) && Self::picks_mesh_points(self.tool.id())) + .then(|| self.tool.options().get("meshPoints").cloned()) + .flatten() + .filter(|p| lender.options().get("meshPoints") != Some(p)); let r = self.deactivate_tool(view); self.keep_tool_settings(); self.tool = lender; diff --git a/crates/engine/tests/import_fuzz.rs b/crates/engine/tests/import_fuzz.rs index b5c069c749..9c83f697da 100644 --- a/crates/engine/tests/import_fuzz.rs +++ b/crates/engine/tests/import_fuzz.rs @@ -321,7 +321,7 @@ proptest! { // The feature sample adds a style table, a clipping container and a lens to the shapes. let compress = compress && version >= 700; let mut bytes = - if features { vectorcraft_cdr::synth::feature_sample(version, compress) } else { vectorcraft_cdr::synth::sample(version, compress) }; + if features { craft_cdr::synth::feature_sample(version, compress) } else { craft_cdr::synth::sample(version, compress) }; let n = bytes.len(); for (at, b) in edits { bytes[at % n] = b; } bytes.truncate(cut); @@ -344,11 +344,11 @@ proptest! { // The members are edited before they are zipped, so that the edits reach the drawing // rather than stop at the CRC-32; the archive may then be cut short. let mut members = if version < 1600 { - vec![vectorcraft_cdr::synth::Member { name: "content/riffData.cdr".into(), data: vectorcraft_cdr::synth::sample(version, true), deflate: false }] + vec![craft_cdr::synth::Member { name: "content/riffData.cdr".into(), data: craft_cdr::synth::sample(version, true), deflate: false }] } else { - let mut body = vec![vectorcraft_cdr::synth::chunk(b"vrsn", version.to_le_bytes().to_vec())]; - body.extend(vectorcraft_cdr::synth::sample_content(version)); - vectorcraft_cdr::synth::package16_members(version, &body, false, &[]) + let mut body = vec![craft_cdr::synth::chunk(b"vrsn", version.to_le_bytes().to_vec())]; + body.extend(craft_cdr::synth::sample_content(version)); + craft_cdr::synth::package16_members(version, &body, false, &[]) }; for (m, at, b) in edits { let k = m % members.len(); @@ -358,7 +358,7 @@ proptest! { data[at % n] = b; } } - let mut bytes = vectorcraft_cdr::synth::zip(&members, b""); + let mut bytes = craft_cdr::synth::zip(&members, b""); if let Some(cut) = cut { bytes.truncate(cut); } @@ -395,7 +395,7 @@ proptest! { cut in prop::option::of(0usize..1024), edits in prop::collection::vec((0usize..8192, any::()), 0..24), ) { - let mut bytes = vectorcraft_cdr::synth::wl_sample(marker); + let mut bytes = craft_cdr::synth::wl_sample(marker); let n = bytes.len(); for (at, b) in edits { bytes[at % n] = b; } if let Some(cut) = cut { @@ -444,7 +444,7 @@ proptest! { cut in prop::option::of(12usize..4096), edits in prop::collection::vec((0usize..8192, any::()), 0..24), ) { - let mut bytes = vectorcraft_cdr::synth_cmx::sample(); + let mut bytes = craft_cdr::synth_cmx::sample(); let n = bytes.len(); for (at, b) in edits { bytes[at % n] = b; } if let Some(cut) = cut { @@ -464,7 +464,7 @@ proptest! { fn cmx_garbage_opens_and_places_without_panicking(tail in prop::collection::vec(any::(), 0..2048)) { // A 32-bit header, so the garbage is walked as chunks, tables and instructions. let mut bytes = b"RIFF".to_vec(); - let cont = vectorcraft_cdr::synth_cmx::cont(b'4', 1e-7); + let cont = craft_cdr::synth_cmx::cont(b'4', 1e-7); bytes.extend(((4 + cont.len() + tail.len()) as u32).to_le_bytes()); bytes.extend(b"CMX1"); bytes.extend(cont); diff --git a/crates/engine/tests/it/main.rs b/crates/engine/tests/it/main.rs index 836190aca6..9a4644575d 100644 --- a/crates/engine/tests/it/main.rs +++ b/crates/engine/tests/it/main.rs @@ -32,6 +32,7 @@ mod pen_rubber_band; mod ruler_guide_nodes; mod ruler_guide_perf; mod ruler_origin; +mod script_host_vs_scriptcheck; mod selection_commands; mod stroke_visibility; mod text_stroke_scale; diff --git a/crates/engine/tests/it/script_host_vs_scriptcheck.rs b/crates/engine/tests/it/script_host_vs_scriptcheck.rs new file mode 100644 index 0000000000..660433b800 --- /dev/null +++ b/crates/engine/tests/it/script_host_vs_scriptcheck.rs @@ -0,0 +1,166 @@ +//! Every global and member the script host (`script.run`) adds to the JavaScript engine is in one of +//! the tables below, and each name that reaches outside the document has the `outside` id +//! `script.check` (`vectorcraft-scriptcheck`) gives it. The names are read from a run: the own +//! properties of the global object, of each object or function it holds and of each function's +//! `prototype`, with a setter listed again as `name=`. The names a plain `vectorcraft_js::Realm` also +//! has are the language's, which reach files and other apps only through the host; `eval` and +//! `Function` still have rows, since they run code the checker can't read. A name the host adds +//! without a row fails the test. + +use std::collections::BTreeSet; + +use serde_json::json; +use vectorcraft_engine::Session; +use vectorcraft_js::{DirectiveName, JsValue, Realm}; +use vectorcraft_scriptcheck::{Limits, check}; + +/// The names that reach outside the document: each with a script that uses it and the `outside` id +/// the checker gives that script. +const OUTSIDE: &[(&str, &str, &str)] = &[ + ("eval", "eval(s);", "unseenCode"), + ("Function", "var g = new Function(s);", "unseenCode"), + ("$.evalFile", "$.evalFile(p);", "unseenCode"), + ("$.getenv", "var h = $.getenv(n);", "environment"), + ("$.setenv", "$.setenv(n, v);", "environment"), + ("File.prototype.open", "var f = new File(p); f.open('w');", "filesWritten"), + ("File.prototype.write", "var f = new File(p); f.write(s);", "filesWritten"), + ("File.prototype.writeln", "var f = new File(p); f.writeln(s);", "filesWritten"), + ("File.prototype.copy", "var f = new File(p); f.copy(q);", "filesWritten"), + ("File.prototype.createAlias", "var f = new File(p); f.createAlias(q);", "filesWritten"), + ("File.prototype.remove", "var f = new File(p); f.remove();", "filesWritten"), + ("File.prototype.rename", "var f = new File(p); f.rename(q);", "filesWritten"), + ("File.prototype.length=", "var f = new File(p); f.length = 0;", "filesWritten"), + ("File.prototype.hidden=", "var f = new File(p); f.hidden = true;", "filesWritten"), + ("File.prototype.readonly=", "var f = new File(p); f.readonly = true;", "filesWritten"), + ("File.prototype.execute", "var f = new File(p); f.execute();", "filesOpened"), + ("Folder.prototype.create", "var d = new Folder(p); d.create();", "filesWritten"), + ("Folder.prototype.remove", "var d = new Folder(p); d.remove();", "filesWritten"), + ("Folder.prototype.rename", "var d = new Folder(p); d.rename(q);", "filesWritten"), + ("Folder.prototype.execute", "var d = new Folder(p); d.execute();", "filesOpened"), +]; + +/// The names the host adds that stay inside the document and the run, by the object that has them. +/// Reading a file or a folder, a file dialog and a message to the person do not change anything +/// outside it. +const INSIDE: &[(&str, &str)] = &[ + ("", "$ File Folder alert confirm localize prompt toSource"), + ("Object.prototype.", "toSource"), + ("localize.", "length"), + ("toSource.", "length"), + ( + "$.", + "about appEncoding appEncoding= bp build buildDate colorPicker decimalPoint engineName error fileName flags \ + flags= gc global hiresTimer includePath level line locale locale= localize localize= memCache memCache= os screens \ + sleep stack strict version write writeln", + ), + ("File.", "decode encode fs isEncodingAvailable openDialog saveDialog length prototype"), + ( + "File.prototype.", + "absoluteURI alias changePath close constructor created creator displayName encoding encoding= eof error error= \ + exists fsName fullName getRelativeURI hidden length lineFeed lineFeed= modified name openDlg parent path read \ + readch readln readonly relativeURI resolve saveDlg seek tell toString type", + ), + ( + "Folder.", + "appData appPackage commonFiles current current= decode desktop encode fs isEncodingAvailable length myDocuments \ + prototype selectDialog startup system temp trash userData", + ), + ( + "Folder.prototype.", + "absoluteURI alias changePath constructor created displayName error error= exists fsName fullName getFiles \ + getRelativeURI modified name parent path relativeURI resolve selectDlg toString", + ), +]; + +/// The name the checker does not read, which also stands for its members: `vc` is VectorCraft's +/// own API, and what `vc.run` does depends on the command it runs. +const NOT_CHECKED: &str = "vc"; + +/// An expression whose value is the list of names, one to a line. +const LIST: &str = r#"(function () { + var out = []; + function add(o, prefix) { + var own = Object.getOwnPropertyNames(o); + for (var i = 0; i < own.length; i++) { + out.push(prefix + own[i]); + var d = Object.getOwnPropertyDescriptor(o, own[i]); + if (d && d.set) out.push(prefix + own[i] + "="); + } + } + var g = (function () { return this; })(); + var globals = Object.getOwnPropertyNames(g); + add(g, ""); + for (var i = 0; i < globals.length; i++) { + var v = g[globals[i]]; + if (v !== null && (typeof v == "object" || typeof v == "function")) { + add(v, globals[i] + "."); + if (typeof v == "function" && v.prototype !== null && typeof v.prototype == "object") add(v.prototype, globals[i] + ".prototype."); + } + } + return out.join("\n"); +})()"#; + +/// The names a script run by the host has. +fn host_names() -> BTreeSet { + let mut s = Session::new(); + let r = s.execute("script.run", &json!({"source": format!("vc.log({LIST});"), "name": "list.js"})).unwrap(); + let text = r["log"][0].as_str().unwrap_or_else(|| panic!("no list in {r}")); + text.lines().map(str::to_string).collect() +} + +/// The names a plain JavaScript engine has. +fn language_names() -> BTreeSet { + match Realm::new().run(LIST) { + Ok(JsValue::String(text)) => text.lines().map(str::to_string).collect(), + other => panic!("no list: {other:?}"), + } +} + +fn table_names() -> BTreeSet { + let inside = INSIDE.iter().flat_map(|(prefix, names)| names.split_whitespace().map(move |n| format!("{prefix}{n}"))); + OUTSIDE.iter().map(|(n, ..)| n.to_string()).chain(inside).chain([NOT_CHECKED.to_string()]).collect() +} + +#[test] +fn every_name_the_host_adds_has_a_row() { + let host = host_names(); + let language = language_names(); + let table = table_names(); + let not_checked = |n: &&String| n.starts_with(&format!("{NOT_CHECKED}.")); + let missing: Vec<_> = host.difference(&language).filter(|n| !table.contains(*n) && !not_checked(n)).collect(); + assert!(missing.is_empty(), "the host adds these names, which no table here lists: {missing:?}"); + let gone: Vec<_> = table.difference(&host).collect(); + assert!(gone.is_empty(), "the tables list these names, which a script run by the host does not have: {gone:?}"); +} + +#[test] +fn every_name_that_reaches_outside_has_its_checker_id() { + for (name, script, id) in OUTSIDE { + let r = check("probe.jsx", script.as_bytes(), None, &Limits::default()); + let ids: Vec<_> = r.outside.iter().map(|o| o.id).collect(); + assert!(ids.contains(id), "{name}: the checker gives {ids:?} for {script:?}, not {id}"); + } +} + +/// A line with the directive `d`. The match has no catch-all, so a new directive needs a row, and +/// [`DirectiveName::from_name`] reads only the directives in [`DirectiveName::ALL`]. +fn directive_line(d: DirectiveName) -> &'static str { + match d { + DirectiveName::Include => "#include \"lib.jsxinc\"", + DirectiveName::IncludePath => "#includepath \"lib\"", + DirectiveName::Script => "#script Tidy", + DirectiveName::Strict => "#strict on", + DirectiveName::Target => "#target vectorcraft", + DirectiveName::TargetEngine => "#targetengine session", + } +} + +#[test] +fn the_checker_lists_every_directive_the_host_reads() { + for d in DirectiveName::ALL { + let line = directive_line(d); + let r = check("probe.jsx", format!("{line}\nvar a = 1;\n").as_bytes(), None, &Limits::default()); + let listed: Vec<_> = r.directives.iter().map(|d| d.name.to_string()).collect(); + assert_eq!(listed, [d.as_str()], "{line}"); + } +} diff --git a/crates/engine/tests/plugin_safe_mode.rs b/crates/engine/tests/plugin_safe_mode.rs index 9ff0d0668a..a469e68f20 100644 --- a/crates/engine/tests/plugin_safe_mode.rs +++ b/crates/engine/tests/plugin_safe_mode.rs @@ -463,6 +463,49 @@ fn expand_appearance_keeps_a_plug_in_effect_safe_mode_skips() { s.execute("effect.expandAppearance", &json!({})).unwrap(); } +/// In Safe Mode, Expand Appearance refuses a group whose raster effect makes an image of a plain +/// instance in it when the instance's symbol art holds a plug-in effect. +#[test] +fn expand_appearance_in_safe_mode_checks_symbol_art_a_group_image_draws() { + let _f = fresh(); + let mut s = Session::new(); + let fx = wat::parse_str(tpl::returning(&tpl::manifest("test.sm.sym", "effect", "{}"), r#"{"objects":[]}"#)).unwrap(); + s.execute("plugin.install", &json!({"dataBase64": vectorcraft_format::base64_encode(&fx)})).unwrap(); + s.execute("file.new", &json!({"width": 200, "height": 200})).unwrap(); + s.execute("shape.rectangle", &json!({"x": 10, "y": 10, "width": 50, "height": 50})).unwrap(); + s.execute("effect.apply", &json!({"effect": "plugin.test.sm.sym"})).unwrap(); + s.execute("symbol.new", &json!({"name": "fx"})).unwrap(); + let plain = s.execute("symbol.place", &json!({"name": "fx", "x": 100, "y": 100})).unwrap()["id"].clone(); + let refused = |s: &mut Session, group: &Value| { + let before = s.execute("document.inspect", &json!({})).unwrap(); + safe_mode::set_active(Some(safe_mode::Source::Flag)); + let err = s.execute("effect.expandAppearance", &json!({"ids": [group]})).unwrap_err().to_string(); + safe_mode::set_active(None); + assert!(err.contains("a plug-in effect in the selection can't be expanded in Safe Mode"), "{err}"); + assert_eq!(s.execute("document.inspect", &json!({})).unwrap(), before, "nothing changes"); + }; + // A Gaussian Blur of the group's own. + let group = s.execute("object.group", &json!({"ids": [plain]})).unwrap()["id"].clone(); + s.execute("effect.apply", &json!({"effect": "blur.gaussian", "ids": [group], "params": {"radius": 2}})).unwrap(); + refused(&mut s, &group); + // A Gaussian Blur on a fill of a group around a group that holds another plain instance. + let blurred_fill = { + let t = s.execute("shape.rectangle", &json!({"x": 150, "y": 10, "width": 10, "height": 10})).unwrap()["id"].as_u64().unwrap(); + s.execute("effect.apply", &json!({"effect": "blur.gaussian", "ids": [t], "item": 0, "params": {"radius": 2}})).unwrap(); + s.doc().unwrap().doc.node(vectorcraft_engine::doc::NodeId(t)).unwrap().appearance.items[0].clone() + }; + let plain = s.execute("symbol.place", &json!({"name": "fx", "x": 100, "y": 20})).unwrap()["id"].clone(); + let inner = s.execute("object.group", &json!({"ids": [plain]})).unwrap()["id"].clone(); + let outer = s.execute("object.group", &json!({"ids": [inner]})).unwrap()["id"].as_u64().unwrap(); + std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().doc) + .node_mut(vectorcraft_engine::doc::NodeId(outer)) + .unwrap() + .appearance + .items + .push(blurred_fill); + refused(&mut s, &json!(outer)); +} + /// In Safe Mode, a plug-in effect in the art of a graph design in a series stops Expand Appearance of the graph only /// when an effect of the series group draws that art with the group. #[test] diff --git a/crates/engine/tests/script_corpus.rs b/crates/engine/tests/script_corpus.rs new file mode 100644 index 0000000000..870bfbabc2 --- /dev/null +++ b/crates/engine/tests/script_corpus.rs @@ -0,0 +1,128 @@ +//! The runner of `cargo xtask scripts --pass-rate` (`xtask/src/script_corpus.rs`): the ignored test +//! `row` runs one script of the public script corpus and prints its result on one line, and xtask +//! starts it once for each script, in a process of its own that it stops after its time limit. +//! +//! A row gets a new session with one new document and runs `script.run` with the script's path, +//! 5,000,000 instructions and no dialog answers. Before the session starts, the process confines +//! itself to the automation roots the run's folders give: reads only in the script's repository +//! folder and the run's own folder, and writes only in the run's own folder, which holds the data +//! folder (`Folder.userData`) and, through the temporary-folder variables xtask sets, the run's +//! temporary folder (`Folder.temp`). The other tests check the result line on scripts given as +//! text. +// Integration tests: unwrapping and panicking on failure is fine here, unlike in shipped code (AGENTS.md › Robustness). +#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)] + +use std::path::PathBuf; + +use serde_json::{Value, json}; +use vectorcraft_engine::Session; +use vectorcraft_engine::file_access::{AutomationRoots, confine_process}; + +/// The instructions each script may run. +const FUEL: u64 = 5_000_000; +/// The most characters of a message a result keeps. +const MAX_MESSAGE_CHARS: usize = 300; + +/// A session with one new document. +fn session() -> Session { + let mut s = Session::new(); + s.execute("file.new", &json!({})).unwrap(); + s +} + +/// Runs `script.run` with `params` and gives the result line's JSON: whether the run started (a +/// script `script.run` refuses before it runs has no report), whether it ended well, and the +/// failure's kind, message (at most [`MAX_MESSAGE_CHARS`] characters), line and column, the fuel +/// and host calls it used, its `File.execute` calls, and whether a dialog found no answer. +fn result(s: &mut Session, params: &Value) -> Value { + let ran = s.execute("script.run", params); + let report = s.script_report().cloned().unwrap_or(Value::Null); + let message = report["message"].as_str().map(str::to_owned).or_else(|| ran.as_ref().err().map(ToString::to_string)).unwrap_or_default(); + json!({ + "started": !report.is_null(), + "ok": ran.is_ok(), + "kind": report["kind"], + "message": message.chars().take(MAX_MESSAGE_CHARS).collect::(), + "line": report["line"], + "column": report["column"], + "fuelUsed": report["fuelUsed"], + "hostCalls": report["hostCalls"], + "fileExecutes": report["hostCallCounts"]["fileExecutes"], + "missingAnswer": report["dialogs"].as_array().is_some_and(|d| d.iter().any(|x| x["answer"] == "missing")), + }) +} + +fn source(text: &str) -> Value { + json!({"source": text, "name": "corpus.js", "maxFuel": FUEL, "answers": []}) +} + +#[test] +#[ignore = "cargo xtask scripts --pass-rate runs it once for each script"] +fn row() { + let (Some(script), Some(folder), Some(work)) = ( + std::env::var_os("VECTORCRAFT_SCRIPT_CORPUS_ROW"), + std::env::var_os("VECTORCRAFT_SCRIPT_CORPUS_SOURCE"), + std::env::var_os("VECTORCRAFT_SCRIPT_CORPUS_WORK"), + ) else { + println!("skipped: run by cargo xtask scripts --pass-rate"); + return; + }; + let (folder, work) = (PathBuf::from(folder), PathBuf::from(work)); + let roots = AutomationRoots::new(&[folder.as_path(), work.as_path()], &[work.as_path()]).unwrap().unwrap(); + assert!(confine_process(roots)); + let mut s = session(); + s.attach_script_data(work.join("data")); + let script = script.to_string_lossy().into_owned(); + let line = result(&mut s, &json!({"path": script, "maxFuel": FUEL, "answers": []})); + println!("script-corpus-row {line}"); +} + +#[test] +fn a_script_that_ends_well_passes() { + let r = result(&mut session(), &source("var a = [1, 2].join('-');")); + assert_eq!(r["started"], true); + assert_eq!(r["ok"], true); + assert!(r["fuelUsed"].as_u64().unwrap() > 0); +} + +#[test] +fn a_failure_gives_its_kind_and_place() { + let r = result(&mut session(), &source("var a = 1;\nvar = ;")); + assert_eq!((r["ok"].clone(), r["kind"].clone(), r["line"].clone()), (json!(false), json!("syntax"), json!(2))); + let r = result(&mut session(), &source("var d = app.activeDocument;")); + assert_eq!(r["kind"], "thrown"); + assert!(r["message"].as_str().unwrap().starts_with("ReferenceError: app"), "{r}"); + let r = result(&mut session(), &source("while (true) {}")); + assert_eq!(r["kind"], "limit"); + assert!(r["fuelUsed"].as_u64().unwrap() <= FUEL); +} + +#[test] +fn a_dialog_without_an_answer_is_marked() { + let r = result(&mut session(), &source("alert('hello');")); + assert_eq!(r["ok"], false); + assert_eq!(r["missingAnswer"], true); + let r = result(&mut session(), &source("var n = 1;")); + assert_eq!(r["missingAnswer"], false); +} + +#[test] +fn file_execute_is_counted_and_refused() { + let r = result(&mut session(), &source("var ok = new File('x.txt').execute(); if (ok) throw new Error('ran');")); + assert_eq!(r["ok"], true, "{r}"); + assert_eq!(r["fileExecutes"], 1); +} + +#[test] +fn a_script_refused_before_it_runs_has_not_started() { + let r = result(&mut session(), &json!({"path": "notes.txt", "maxFuel": FUEL, "answers": []})); + assert_eq!(r["started"], false); + assert_eq!(r["ok"], false); + assert!(r["message"].as_str().unwrap().contains(".js or .jsx"), "{r}"); +} + +#[test] +fn a_long_message_is_cut() { + let r = result(&mut session(), &source(&format!("throw new Error('{}');", "x".repeat(1000)))); + assert_eq!(r["message"].as_str().unwrap().chars().count(), MAX_MESSAGE_CHARS); +} diff --git a/crates/eps/src/ai_editing/writer/paints.rs b/crates/eps/src/ai_editing/writer/paints.rs index 5a850d7db3..f1573c39ba 100644 --- a/crates/eps/src/ai_editing/writer/paints.rs +++ b/crates/eps/src/ai_editing/writer/paints.rs @@ -3,7 +3,6 @@ use std::collections::HashMap; use std::fmt::Write; -use std::hash::{Hash, Hasher}; use vectorcraft_color::gradient::GradientGeom; use vectorcraft_color::swatch::REGISTRATION; @@ -14,6 +13,7 @@ use vectorcraft_geom::{Affine, BezPath, Rect, Shape, Vec2}; use super::{MAX_NEST, Writer, Xy}; use crate::ai_ops::{self, average, unit}; +use crate::gradient_key::gradient_key; use crate::ps; pub(in crate::ai_editing) const GRADIENTS: &str = @@ -64,27 +64,6 @@ fn same_gradient(a: &Gradient, b: &Gradient) -> bool { a == b } -/// A key of `g` for [`GradientDefs`]: the same gradients have the same key (each number by its -/// bits, with -0 as 0); different gradients may share one. -fn gradient_key(g: &Gradient) -> u64 { - let bits = |x: f32| if x == 0.0 { 0 } else { x.to_bits() }; - let mut h = std::hash::DefaultHasher::new(); - std::mem::discriminant(&g.kind).hash(&mut h); - std::mem::discriminant(&g.method).hash(&mut h); - (g.dither, g.spread, g.repeats, g.stops.len()).hash(&mut h); - for s in &g.stops { - let (model, c) = match s.color { - Color::Rgb { r, g, b } => (0u8, [r, g, b, 0.0]), - Color::Cmyk { c, m, y, k } => (1, [c, m, y, k]), - Color::Gray { k } => (2, [k, 0.0, 0.0, 0.0]), - Color::Lab { l, a, b } => (3, [l, a, b, 0.0]), - }; - (model, c.map(bits), [s.offset, s.opacity, s.midpoint, s.tint].map(bits)).hash(&mut h); - (&s.swatch, s.plates.map(|p| p.map(bits))).hash(&mut h); - } - h.finish() -} - /// The gradient definitions, in the order they are first used, found by name and by gradient /// without comparing each one. #[derive(Default)] diff --git a/crates/eps/src/gradient_key.rs b/crates/eps/src/gradient_key.rs new file mode 100644 index 0000000000..3bdb7f833a --- /dev/null +++ b/crates/eps/src/gradient_key.rs @@ -0,0 +1,29 @@ +//! A key of a gradient for the gradient definitions the legacy `.ai` writer +//! ([`crate::legacy_ai`]) and the editing data writer ([`crate::ai_editing`]) look up: the writers +//! keep each definition's place under its gradient's key and compare only the gradients that +//! share it. + +use std::hash::{Hash, Hasher}; + +use vectorcraft_color::{Color, Gradient}; + +/// A key of `g`: the same gradients have the same key (each number by its bits, with -0 as 0); +/// different gradients may share one. +pub(crate) fn gradient_key(g: &Gradient) -> u64 { + let bits = |x: f32| if x == 0.0 { 0 } else { x.to_bits() }; + let mut h = std::hash::DefaultHasher::new(); + std::mem::discriminant(&g.kind).hash(&mut h); + std::mem::discriminant(&g.method).hash(&mut h); + (g.dither, g.spread, g.repeats, g.stops.len()).hash(&mut h); + for s in &g.stops { + let (model, c) = match s.color { + Color::Rgb { r, g, b } => (0u8, [r, g, b, 0.0]), + Color::Cmyk { c, m, y, k } => (1, [c, m, y, k]), + Color::Gray { k } => (2, [k, 0.0, 0.0, 0.0]), + Color::Lab { l, a, b } => (3, [l, a, b, 0.0]), + }; + (model, c.map(bits), [s.offset, s.opacity, s.midpoint, s.tint].map(bits)).hash(&mut h); + (&s.swatch, s.plates.map(|p| p.map(bits))).hash(&mut h); + } + h.finish() +} diff --git a/crates/eps/src/import.rs b/crates/eps/src/import.rs index d835b457c0..8182553b00 100644 --- a/crates/eps/src/import.rs +++ b/crates/eps/src/import.rs @@ -139,7 +139,8 @@ struct Dsc { own_legacy: bool, } -/// The four numbers of a bounding box comment's value, when it has them and they make a box. +/// The four numbers of a bounding box comment's value, when it has them and they make a box +/// within [`MAX_SIDE`]. fn box_of(v: &str) -> Option<[f64; 4]> { let n: Vec = v.split_whitespace().map_while(|w| w.parse::().ok()).collect(); let [x0, y0, x1, y1] = n.as_slice() else { return None }; @@ -148,50 +149,53 @@ fn box_of(v: &str) -> Option<[f64; 4]> { } impl Dsc { - /// The comments of `ps`: from the header, or (`(atend)`) the last ones in the file. + /// The comments of `ps`: from the header, or (`(atend)`) the last ones in the file, bounded by + /// `craft_eps::MAX_EXTENDED_HEADER` / `craft_eps::MAX_TRAILER`. Preserves the last in-range + /// header box within [`MAX_SIDE`]. fn read(ps: &[u8]) -> Self { - let mut d = Dsc::default(); - let (mut bbox, mut hires, mut atend) = (None, None, false); - let mut header = true; - for raw in ps.split(|b| matches!(b, b'\n' | b'\r')).filter(|l| !l.is_empty()) { - // Past the header only comments can matter. - if !header && !raw.starts_with(b"%%") { - continue; - } + let shared = craft_eps::Comments::read_with_header_limit(ps, craft_eps::MAX_EXTENDED_HEADER); + let head = &ps[..ps.len().min(craft_eps::MAX_EXTENDED_HEADER)]; + let (mut bbox, mut hires, mut atend, mut own_legacy) = (None, None, false, false); + for raw in head.split(|b| matches!(b, b'\n' | b'\r')).filter(|l| !l.is_empty()) { let line = String::from_utf8_lossy(raw); let line = line.trim_end(); - if header && (line.starts_with("%%EndComments") || !line.starts_with('%')) { - header = false; - if !atend { - break; - } + if line.starts_with("%%EndComments") || !line.starts_with('%') { + break; } let value = |key: &str| line.strip_prefix(key).map(str::trim); - let creator = value("%%Creator:").is_some_and(|v| v.contains("Illustrator")); // brand-ok: the creator its files name - if header && (line.starts_with("%AI") || line.starts_with("%%AI") || creator) { - d.illustrator = true; - } - if header && value("%%DocumentSuppliedResources:").is_some_and(|v| v.strip_prefix("procset ") == Some(crate::legacy_ai::PROCSET)) { - d.own_legacy = true; + if value("%%DocumentSuppliedResources:").is_some_and(|v| v.strip_prefix("procset ") == Some(crate::legacy_ai::PROCSET)) { + own_legacy = true; } if let Some(v) = value("%%HiResBoundingBox:") { - if header || atend { + if v.starts_with("(atend)") { + atend = true; + } else { hires = box_of(v).or(hires); } } else if let Some(v) = value("%%BoundingBox:") { if v.starts_with("(atend)") { atend = true; - } else if header || atend { + } else { bbox = box_of(v).or(bbox); } - } else if let Some(v) = value("%%Pages:") - && header - { - d.pages = v.split_whitespace().next().and_then(|n| n.parse().ok()); } } - d.bbox = hires.or(bbox); - d + if atend { + let tail = &ps[ps.len().saturating_sub(craft_eps::MAX_TRAILER)..]; + for raw in tail.split(|b| matches!(b, b'\n' | b'\r')).filter(|l| !l.is_empty()) { + if !raw.starts_with(b"%%") { + continue; + } + let line = String::from_utf8_lossy(raw); + let line = line.trim_end(); + if let Some(v) = line.strip_prefix("%%HiResBoundingBox:").map(str::trim) { + hires = box_of(v).or(hires); + } else if let Some(v) = line.strip_prefix("%%BoundingBox:").map(str::trim) { + bbox = box_of(v).or(bbox); + } + } + } + Self { bbox: hires.or(bbox), pages: shared.pages, illustrator: shared.illustrator, own_legacy } } } diff --git a/crates/eps/src/import/tests.rs b/crates/eps/src/import/tests.rs index 5fc5d910a4..cf0e890f38 100644 --- a/crates/eps/src/import/tests.rs +++ b/crates/eps/src/import/tests.rs @@ -766,6 +766,8 @@ fn the_bounding_box_comes_from_the_header_or_the_trailer() { assert_eq!(d.bbox, Some([1.5, 2.5, 29.5, 39.5])); let d = Dsc::read(b"%!PS-Adobe-3.0\n%%BoundingBox: (atend)\n%%Pages: 3\n%%EndComments\nshowpage\n%%Trailer\n%%BoundingBox: 0 0 10 20\n"); assert_eq!((d.bbox, d.pages), (Some([0.0, 0.0, 10.0, 20.0]), Some(3))); + let d = Dsc::read(b"%!PS-Adobe-3.0 EPSF-3.0\n%%BoundingBox: 0 0 200000 200000\n%%BoundingBox: 0 0 40 50\n%%EndComments\n"); + assert_eq!(d.bbox, Some([0.0, 0.0, 40.0, 50.0])); let r = import(b"%!PS-Adobe-3.0\n%%Pages: 2\n0 0 5 5 rectfill showpage 0 0 9 9 rectfill showpage\n").unwrap(); // No bounding box: a letter page; only the first page. assert_eq!(r.document.artboards[0].rect, Rect::new(0.0, 0.0, 612.0, 792.0)); diff --git a/crates/eps/src/import/tests_reads.rs b/crates/eps/src/import/tests_reads.rs index 3220edd028..50e2838cc4 100644 --- a/crates/eps/src/import/tests_reads.rs +++ b/crates/eps/src/import/tests_reads.rs @@ -357,3 +357,10 @@ fn one_pass_reads_timed() { let lines: Vec = (0..200_000).flat_map(|i| format!("{:<39}\n", format!("line {i}")).into_bytes()).collect(); compare("readline", &program(Form::Current(b"\n"), &lines), line_one_pass, line_by_bytes, 80, 200_000); } + +#[test] +fn currentfile_at_eof_without_trailing_newline_stops_cleanly() { + line_case(b"partial-eof", 32, b"partial-eof", true, b""); + line_case(b"partial-eof", 7, b"partial", false, b"-eof"); + hex_case(b"deadbeef", 16, &[0xde, 0xad, 0xbe, 0xef], b""); +} diff --git a/crates/eps/src/legacy_ai/tests.rs b/crates/eps/src/legacy_ai/tests.rs index 6018bc6920..2f5a528340 100644 --- a/crates/eps/src/legacy_ai/tests.rs +++ b/crates/eps/src/legacy_ai/tests.rs @@ -1696,6 +1696,119 @@ fn colliding_gradient_and_spot_names_are_numbered_as_before() { assert!(text.contains("%%DocumentCustomColors: (?)\n%%+ (? 2)\n%%+ (? 3)\n%%+ (? 2 2)\n"), "{text}"); } +/// `doc` written with its gradient definitions found by comparing each in turn (`scanned`) or +/// through their index. +fn export_scanned(doc: &Document, scanned: bool) -> LegacyAiOutput { + let o = LegacyAiOptions { created: Some(0), ..LegacyAiOptions::default() }; + super::writer::SCANNED_DEFINITIONS.with(|s| s.set(scanned)); + let out = export_legacy_ai(doc, &o); + super::writer::SCANNED_DEFINITIONS.with(|s| s.set(false)); + out.unwrap() +} + +/// A document of rectangles filled with gradients: one with a gradient swatch `Sky` of its own; +/// `distinct` with gradients of their own; `reused` with one of `ramps` others in turn; one with a +/// gradient swatch `Dawn` whose gradient is the first of those `ramps`; two whose gradients differ +/// only in the sign of a zero offset; and two with the same gradient, whose midpoint is not a +/// number. +fn many_gradients(distinct: u16, reused: u16, ramps: u16) -> Document { + let mut doc = Document::new(1000.0, 1000.0); + let layer = doc.layers[0].id; + let shade = |i: u16, n: u16| f32::from(i) / f32::from(n.max(1)); + let mut paints = vec![gradient_from(Color::rgb(0.1, 0.2, 0.3), Some("Sky"))]; + for i in 0..distinct { + paints.push(gradient_from(Color::rgb(shade(i, distinct), 0.5, 0.0), None)); + } + for i in 0..reused { + paints.push(gradient_from(Color::cmyk(0.0, shade(i % ramps.max(1), ramps), 0.5, 0.0), None)); + } + paints.push(gradient_from(Color::cmyk(0.0, 0.0, 0.5, 0.0), Some("Dawn"))); + let stops = |offset: f32, midpoint: f32| { + let mut first = GradientStop::new(offset, Color::rgb(0.2, 0.3, 0.4)); + first.midpoint = midpoint; + let g = Gradient::new(GradientKind::Linear, vec![first, GradientStop::new(1.0, Color::BLACK)]); + Paint::Gradient(Box::new(GradientPaint::new(g))) + }; + paints.extend([stops(0.0, 0.5), stops(-0.0, 0.5), stops(0.0, f32::NAN), stops(0.0, f32::NAN)]); + for (i, paint) in (0u16..).zip(paints) { + let (x, y) = (f64::from(i % 40) * 25.0, f64::from(i / 40 % 40) * 25.0); + let n = shape(&mut doc, shapes::rectangle(Rect::new(x, y, x + 20.0, y + 20.0)), paint, Paint::None); + doc.insert(Some(layer), usize::MAX, n).unwrap(); + } + doc +} + +/// Gradient definitions found through their index are those found by comparing each in turn: the +/// file is the same, byte for byte, with the same warnings. An earlier definition of the same +/// gradient serves a gradient swatch of another name; gradients that differ only in the sign of a +/// zero share a definition; a gradient that is not equal to itself is defined each time. +#[test] +fn indexed_gradient_definitions_write_the_same_file() { + let doc = many_gradients(300, 300, 7); + let (indexed, scanned) = (export_scanned(&doc, false), export_scanned(&doc, true)); + let differ = indexed.bytes.iter().zip(&scanned.bytes).position(|(a, b)| a != b); + assert!(indexed.bytes == scanned.bytes, "the files differ from byte {differ:?} ({} and {} bytes)", indexed.bytes.len(), scanned.bytes.len()); + assert_eq!(indexed.warnings, scanned.warnings); + assert_eq!(indexed.setting_notes, scanned.setting_notes); + let text = String::from_utf8(indexed.bytes).unwrap(); + let defined: Vec<&str> = text.lines().filter_map(|l| l.strip_suffix(" 0 2 Bd")).collect(); + // `Sky`, 300 of their own, 7 reused, 1 for both signs of zero and 2 for the gradient that + // is not a number. + assert_eq!(defined.len(), 1 + 300 + 7 + 1 + 2, "{defined:?}"); + assert_eq!(defined.first(), Some(&"(Sky)")); + assert!(!defined.contains(&"(Dawn)"), "{defined:?}"); +} + +/// A gradient is matched with the definitions of the same gradient, not with each definition: +/// 1,000 gradients of their own and 1,000 of 10 others take a comparison or so each, where +/// comparing each definition in turn takes hundreds of thousands. +#[test] +fn legacy_gradient_definitions_are_found_without_comparing_each() { + let doc = many_gradients(1000, 1000, 10); + let comparisons = |scanned: bool| { + super::writer::GRADIENT_COMPARISONS.with(|c| c.set(0)); + export_scanned(&doc, scanned); + super::writer::GRADIENT_COMPARISONS.with(std::cell::Cell::get) + }; + let (indexed, scanned) = (comparisons(false), comparisons(true)); + assert!(indexed <= 2 * 2006, "{indexed} comparisons through the index"); + assert!(scanned > 100 * indexed, "{scanned} comparisons scanning, {indexed} through the index"); +} + +/// The time to write 5,000 rectangles with gradients of their own and 5,000 with 50 others, with +/// the definitions found by comparing each in turn and through their index: the median of 7 runs +/// of each, alternating, with the files compared. Run with +/// `cargo test --release -p vectorcraft-eps --lib -- --ignored --nocapture legacy_gradient_definitions_timing`. +#[test] +#[ignore = "timing"] +fn legacy_gradient_definitions_timing() { + let doc = many_gradients(5000, 5000, 50); + let mut times = [vec![], vec![]]; + let mut files: [Option>; 2] = [None, None]; + let mut how = ""; + for _ in 0..7 { + for (k, scanned) in [true, false].into_iter().enumerate() { + let (start, h) = thread_time(); + let out = export_scanned(&doc, scanned); + times[k].push(thread_time().0.saturating_sub(start)); + how = h; + files[k].get_or_insert(out.bytes); + } + } + assert_eq!(files[0], files[1]); + for t in &mut times { + t.sort(); + } + let ms = |d: std::time::Duration| d.as_secs_f64() * 1000.0; + println!("10,006 gradient fills, median of 7 runs ({how}):"); + println!("| definitions found | median (ms) | runs (ms) |"); + println!("|---|---:|---|"); + for (k, label) in ["comparing each in turn", "through the index"].into_iter().enumerate() { + let runs: Vec = times[k].iter().map(|d| format!("{:.1}", ms(*d))).collect(); + println!("| {label} | {:.1} | {} |", ms(times[k][3]), runs.join(", ")); + } +} + /// The time this thread has run, and how it was measured. fn thread_time() -> (std::time::Duration, &'static str) { if let Some(ns) = std::fs::read_to_string("/proc/thread-self/schedstat").ok().and_then(|s| s.split_whitespace().next()?.parse::().ok()) { diff --git a/crates/eps/src/legacy_ai/writer.rs b/crates/eps/src/legacy_ai/writer.rs index 7e7dbfe4fc..2fa0fcb6c2 100644 --- a/crates/eps/src/legacy_ai/writer.rs +++ b/crates/eps/src/legacy_ai/writer.rs @@ -10,6 +10,7 @@ use super::{ TextObject, UNDECODED, Vec2, Write, ai_ops, latin, ps, stroke, }; use super::{CONIC, CONIC_WEDGES, DEEP_DISTORTED, DIAMOND, GRAPHS, HUE_STOPS, PERCEPTUAL_STOPS, SPREAD, SPREAD_CAPPED}; +use crate::gradient_key::gradient_key; #[cfg(test)] thread_local! { @@ -18,6 +19,18 @@ thread_local! { /// Whether [`Numbered::take`] numbers names on this thread by searching the names given so /// far, one number at a time, for each number it tries. pub(super) static SCANNED_NAMES: std::cell::Cell = const { std::cell::Cell::new(false) }; + /// Whether [`Writer::defined`] finds a gradient's definition on this thread by comparing the + /// gradient with each definition in turn. + pub(super) static SCANNED_DEFINITIONS: std::cell::Cell = const { std::cell::Cell::new(false) }; + /// How many times [`Writer::defined`] has compared two gradients on this thread. + pub(super) static GRADIENT_COMPARISONS: std::cell::Cell = const { std::cell::Cell::new(0) }; +} + +/// Are gradients `a` and `b` the same? +fn same_gradient(a: &Gradient, b: &Gradient) -> bool { + #[cfg(test)] + GRADIENT_COMPARISONS.with(|c| c.set(c.get() + 1)); + a == b } /// An image's coverage ([`ImageBlob::coverage`]): its width, its height and one byte a pixel. @@ -34,7 +47,7 @@ pub(super) struct Writer<'a> { /// Spot colors used: the name written and full CMYK equivalent. pub(super) spots: Vec<(String, [f32; 4])>, /// The name each spot color (by its swatch's name) is written with ([`Self::spot`]). - spot_names: Vec<(String, String)>, + spot_names: std::collections::HashMap, pub(super) warnings: Vec, /// Notes on what the options asked for ([`crate::LegacyAiOutput::setting_notes`]). pub(super) setting_notes: Vec, @@ -73,6 +86,13 @@ pub(super) struct Writer<'a> { gradient_names: Numbered, /// The names spot colors are written with ([`Self::spot`]). spot_written: Numbered, + /// The names of [`Self::spots`]. + spot_set: std::collections::HashSet, + /// The PostScript names of [`Self::fonts`]. + font_set: std::collections::HashSet, + /// The places in [`Self::gradients`] of the definitions, in order, by their gradient's key + /// ([`gradient_key`]). + gradient_index: std::collections::HashMap>, } impl<'a> Writer<'a> { @@ -84,7 +104,7 @@ impl<'a> Writer<'a> { body: String::new(), gradients: vec![], spots: vec![], - spot_names: vec![], + spot_names: std::collections::HashMap::new(), warnings: vec![], setting_notes: vec![], locked: false, @@ -103,6 +123,9 @@ impl<'a> Writer<'a> { in_graph: false, gradient_names: Numbered::default(), spot_written: Numbered::default(), + spot_set: std::collections::HashSet::new(), + font_set: std::collections::HashSet::new(), + gradient_index: std::collections::HashMap::new(), } } @@ -160,16 +183,17 @@ impl<'a> Writer<'a> { /// Windows-1252 are written as `?` (with a warning), and it is numbered when another spot color /// is already written with that name; the name is the same each time. fn spot(&mut self, name: &str, cmyk: [f32; 4]) -> String { - let written = match self.spot_names.iter().find(|(n, _)| n == name) { - Some((_, w)) => w.clone(), + let written = match self.spot_names.get(name) { + Some(w) => w.clone(), None => { let base = self.latin_name(name, TITLE_AND_COLOR_NAMES); let written = self.spot_written.take(base); - self.spot_names.push((name.to_string(), written.clone())); + self.spot_names.insert(name.to_string(), written.clone()); written } }; - if !self.spots.iter().any(|(n, _)| *n == written) { + if !self.spot_set.contains(&written) { + self.spot_set.insert(written.clone()); self.spots.push((written.clone(), cmyk)); } written @@ -178,7 +202,7 @@ impl<'a> Writer<'a> { /// The name spot color `name` (its swatch's name) is written with, once [`Self::spot`] has /// noted it. pub(super) fn spot_name<'n>(&'n self, name: &'n str) -> &'n str { - self.spot_names.iter().find(|(n, _)| n == name).map_or(name, |(_, w)| w.as_str()) + self.spot_names.get(name).map_or(name, String::as_str) } /// A top-level layer. False when it isn't a layer. @@ -831,15 +855,26 @@ impl<'a> Writer<'a> { /// The name of the definition of `g` (its swatch's name when it has one, with each character /// outside Windows-1252 written as `?` and a warning), defined the first time. fn define(&mut self, g: &Gradient, swatch: Option<&str>) -> String { - if let Some((name, _)) = self.gradients.iter().find(|(_, d)| d == g) { + let key = gradient_key(g); + if let Some((name, _)) = self.defined(g, key).and_then(|i| self.gradients.get(i)) { return name.clone(); } let base = self.latin_name(swatch.filter(|s| !s.is_empty()).unwrap_or("Gradient"), TITLE_AND_COLOR_NAMES); let name = self.gradient_names.take(base); + self.gradient_index.entry(key).or_default().push(self.gradients.len()); self.gradients.push((name.clone(), g.clone())); name } + /// The place in [`Self::gradients`] of the first definition of `g`, whose key is `key`. + fn defined(&self, g: &Gradient, key: u64) -> Option { + #[cfg(test)] + if SCANNED_DEFINITIONS.with(std::cell::Cell::get) { + return self.gradients.iter().position(|(_, d)| same_gradient(d, g)); + } + self.gradient_index.get(&key)?.iter().copied().find(|i| self.gradients.get(*i).is_some_and(|(_, d)| same_gradient(d, g))) + } + // ---------- type ---------- /// Type: a text object when the format can hold it as text, else its outlines (type with @@ -1016,7 +1051,8 @@ impl<'a> Writer<'a> { self.line_style(&st.stroke_layer()); } let (name, truetype, ascent, descent) = font_of(st); - if !self.fonts.iter().any(|(n, _)| *n == name) { + if !self.font_set.contains(&name) { + self.font_set.insert(name.clone()); self.fonts.push((name.clone(), truetype)); } let size = finite(st.size, 12.0); diff --git a/crates/eps/src/lib.rs b/crates/eps/src/lib.rs index 39737dae3a..44d974bd35 100644 --- a/crates/eps/src/lib.rs +++ b/crates/eps/src/lib.rs @@ -32,12 +32,14 @@ //! ([`export_ai_editing`], [`ai_private_data`]). //! - `ai_ops`: the path and line style operators those two write. //! - `ai_graph`: the records of a live graph those two write around its group. +//! - `gradient_key`: the key those two find gradient definitions by. //! - [`dcs`]: DCS files, an EPS file with one program per printing plate, read for placing. mod ai_editing; mod ai_graph; mod ai_ops; pub mod dcs; +mod gradient_key; mod import; mod latin; mod legacy_ai; diff --git a/crates/eps/src/tests.rs b/crates/eps/src/tests.rs index 8dc8efa94a..cf62695254 100644 --- a/crates/eps/src/tests.rs +++ b/crates/eps/src/tests.rs @@ -2138,3 +2138,52 @@ fn ruby_is_written_with_its_type() { }; assert_eq!(moves(true), moves(false) + reading, "the reading's contours are written"); } + +#[test] +fn tiff_preview_round_trips_when_postscript_is_unreadable() { + let d = doc_with(|d| vec![red_rect(d)]); + for kind in [Preview::TiffColor, Preview::TiffBlackWhite] { + let out = export(&d, &EpsOptions { preview: kind, ..opts(&d) }, Some(&preview()), None).unwrap(); + let (ps, tiff) = sections(&out.bytes).unwrap(); + let tiff = tiff.unwrap(); + // Corrupt the PostScript body while keeping the binary header and TIFF preview intact. + let bad_ps = b"%!PS-Adobe-3.0 EPSF-3.0\n%%BoundingBox: 0 0 100 100\n%%EndComments\nunknown_op\n%%EOF\n"; + let wrapped = craft_eps::wrap(bad_ps, Some(tiff), None).unwrap(); + let imported = import_with(&wrapped, false).unwrap(); + assert!(imported.preview, "{kind:?}: expected TIFF preview fallback"); + let mut has_image = false; + imported.document.walk(|n| { + if matches!(n.kind, NodeKind::Image(_)) { + has_image = true; + } + }); + assert!(has_image, "{kind:?}: expected preview image node"); + assert!(ps.starts_with(b"%!PS-Adobe-3.0 EPSF-3.0")); + } +} + +#[test] +fn edit_payloads_and_bounded_malformed_inputs_preserve_benign_fixtures() { + // Ordinary benign fixture with native edit payload + TIFF preview round-trips cleanly. + let d = doc_with(|d| vec![red_rect(d)]); + let payload = b"vectorcraft-native-edit-payload".to_vec(); + let out = export(&d, &EpsOptions { native: Some(payload.clone()), preview: Preview::TiffColor, ..opts(&d) }, Some(&preview()), None).unwrap(); + assert!(super::has_native(&out.bytes)); + assert_eq!(super::native(&out.bytes).as_deref(), Some(payload.as_slice())); + let benign = import_with(&out.bytes, false).unwrap(); + assert!(!benign.preview); + + // Truncated DOS EPS binary header is refused cleanly without panicking. + let mut bad_header = vec![0xC5, 0xD0, 0xD3, 0xC6]; + bad_header.extend_from_slice(&[0xFF; 26]); + assert!(sections(&bad_header).is_none()); + assert!(import_with(&bad_header, false).is_err()); + + // Bounded malformed currentfile filter hitting EOF early does not panic or hang. + let truncated_inline = b"%!PS-Adobe-3.0 EPSF-3.0\n%%BoundingBox: 0 0 10 10\n%%EndComments\n2 2 8 [2 0 0 -2 0 2] currentfile /ASCII85Decode filter false 3 colorimage\n9jqo^"; + let _ = import_with(truncated_inline, false); + + // Unterminated PostScript string at EOF is refused cleanly. + let unterminated = b"%!PS-Adobe-3.0 EPSF-3.0\n%%BoundingBox: 0 0 10 10\n%%EndComments\n(unterminated"; + assert!(import_with(unterminated, false).is_err()); +} diff --git a/crates/js/src/token.rs b/crates/js/src/token.rs index 7998822e53..304ea0e0ab 100644 --- a/crates/js/src/token.rs +++ b/crates/js/src/token.rs @@ -288,17 +288,19 @@ pub enum DirectiveName { } impl DirectiveName { + /// Every directive a preprocessor line can name. + pub const ALL: [DirectiveName; 6] = [ + DirectiveName::Include, + DirectiveName::IncludePath, + DirectiveName::Script, + DirectiveName::Strict, + DirectiveName::Target, + DirectiveName::TargetEngine, + ]; + /// The directive named `name`, compared without case. pub fn from_name(name: &str) -> Option { - const NAMES: [(&str, DirectiveName); 6] = [ - ("include", DirectiveName::Include), - ("includepath", DirectiveName::IncludePath), - ("script", DirectiveName::Script), - ("strict", DirectiveName::Strict), - ("target", DirectiveName::Target), - ("targetengine", DirectiveName::TargetEngine), - ]; - NAMES.iter().find(|(n, _)| n.eq_ignore_ascii_case(name)).map(|(_, d)| *d) + DirectiveName::ALL.into_iter().find(|d| d.as_str().eq_ignore_ascii_case(name)) } pub fn as_str(self) -> &'static str { diff --git a/crates/mcp/src/tests/shapewidgets.rs b/crates/mcp/src/tests/shapewidgets.rs index bce666d484..ce182358f8 100644 --- a/crates/mcp/src/tests/shapewidgets.rs +++ b/crates/mcp/src/tests/shapewidgets.rs @@ -92,6 +92,8 @@ fn a_batch_that_switches_documents_during_a_side_widget_drag_keeps_its_steps() { {"command": "document.activate", "params": {"index": 0}} ]}); h.call("engine.execute", json!({"command": "command.batch", "params": batch})).unwrap(); + assert_eq!(h.session.active_index(), Some(0), "the batch activates document 0"); + assert_ne!(h.session.doc().unwrap().uid, uid, "the batch leaves the polygon's document"); let st = h.session.documents().iter().find(|d| d.uid == uid).expect("the polygon's document"); let vectorcraft_doc::NodeKind::Path { live, .. } = &st.doc.node(id).unwrap().kind else { panic!("not a path") }; assert!(matches!(live.as_deref(), Some(vectorcraft_doc::LiveShape::Polygon { sides: 7, .. })), "the settled drag: {live:?}"); diff --git a/crates/plugins/Cargo.toml b/crates/plugins/Cargo.toml index 28b972d679..8cd7ceb62f 100644 --- a/crates/plugins/Cargo.toml +++ b/crates/plugins/Cargo.toml @@ -22,6 +22,7 @@ craft-vectorcraft-format = { workspace = true } sha2 = { version = "0.10", default-features = false } thiserror = { workspace = true } wasmi = { workspace = true } +wasmparser = { workspace = true } # The monotonic clock of run deadlines and the first-view budget: `std::time::Instant` on the # desktop, the page's `performance.now()` in the web build. It is MIT OR Apache-2.0 and already in # the build through eframe. diff --git a/crates/plugins/src/runtime.rs b/crates/plugins/src/runtime.rs index 0cb6197e97..1a25e9e6b0 100644 --- a/crates/plugins/src/runtime.rs +++ b/crates/plugins/src/runtime.rs @@ -4,6 +4,7 @@ use wasmi::{ Config, CustomFuelCosts, EnforcedLimits, Engine, Instance, Memory, Module, Store, StoreLimitsBuilder, TypedFunc, TypedResumableCall, Val, WasmParams, WasmResults, }; +use wasmparser::{Validator, WasmFeatures}; use crate::host::{self, Bridge, Deadline, Host, Report, Run}; use crate::manifest::{MAX_MANIFEST_BYTES, Manifest}; @@ -27,6 +28,44 @@ const FUEL_COSTS: CustomFuelCosts = CustomFuelCosts { bytes_copied_per_fuel: 64, /// Bytes a bulk memory instruction copies or fills for each unit of fuel. pub const BYTES_COPIED_PER_FUEL: u32 = FUEL_COSTS.bytes_copied_per_fuel; +/// The WebAssembly proposals a plug-in may use, as `docs/plugins.md` lists them. `GC_TYPES` lets +/// reference types use `funcref` and `externref`; the garbage collection proposal stays off. Every +/// proposal not listed here is off, whatever wasmi's defaults and crate features turn on. +const WASM_FEATURES: WasmFeatures = WasmFeatures::MUTABLE_GLOBAL + .union(WasmFeatures::SIGN_EXTENSION) + .union(WasmFeatures::SATURATING_FLOAT_TO_INT) + .union(WasmFeatures::MULTI_VALUE) + .union(WasmFeatures::BULK_MEMORY) + .union(WasmFeatures::REFERENCE_TYPES) + .union(WasmFeatures::GC_TYPES) + .union(WasmFeatures::TAIL_CALL) + .union(WasmFeatures::EXTENDED_CONST) + .union(WasmFeatures::FLOATS); + +/// Validates `bytes` with only [`WASM_FEATURES`] on, before wasmi reads the module. A module that +/// uses any other proposal is refused with the validator's error, which names the proposal. +fn check_features(bytes: &[u8]) -> Result<()> { + Validator::new_with_features(WASM_FEATURES).validate_all(bytes).map(|_| ()).map_err(|e| Error::Module(e.to_string())) +} + +/// Sets each WebAssembly proposal that wasmi's `Config` has a setter for in this build on or off, +/// to match [`WASM_FEATURES`]. +fn set_features(config: &mut Config) -> &mut Config { + config + .wasm_mutable_global(true) + .wasm_sign_extension(true) + .wasm_saturating_float_to_int(true) + .wasm_multi_value(true) + .wasm_bulk_memory(true) + .wasm_reference_types(true) + .wasm_tail_call(true) + .wasm_extended_const(true) + .floats(true) + .wasm_multi_memory(false) + .wasm_custom_page_sizes(false) + .wasm_wide_arithmetic(false) +} + /// Instructions a heavy filter's run may use besides [`Limits::fuel_per_byte`] for each byte of /// input ([`crate::Budget::Heavy`]): 20 times a light one's. Its output's size can't add to it: /// the host learns that only once the run has ended. @@ -171,8 +210,9 @@ impl Plugin { if !bytes.starts_with(b"\0asm") { return Err(Error::Module("not a WebAssembly binary (missing \\0asm header)".into())); } + check_features(bytes)?; let mut config = Config::default(); - config + set_features(&mut config) .consume_fuel(true) .fuel_cost(FUEL_COSTS) .enforced_limits(EnforcedLimits::strict()) diff --git a/crates/plugins/tests/abi.rs b/crates/plugins/tests/abi.rs index 26dec0a7d2..ae99846c69 100644 --- a/crates/plugins/tests/abi.rs +++ b/crates/plugins/tests/abi.rs @@ -149,6 +149,54 @@ fn malformed_and_oversized_modules_are_refused() { assert!(matches!(e, Error::Abi(_)), "{e}"); } +/// The WebAssembly proposals `docs/plugins.md` lets a plug-in use, each with module fields that +/// use it. +const ACCEPTED_PROPOSALS: &[(&str, &str)] = &[ + ("mutable globals", r#"(global (export "counter") (mut i32) (i32.const 0))"#), + ("sign extension", "(func (param i32) (result i32) (i32.extend8_s (local.get 0)))"), + ("saturating conversions", "(func (param f32) (result i32) (i32.trunc_sat_f32_s (local.get 0)))"), + ("multi-value", "(func (result i32 i32) (i32.const 1) (i32.const 2))"), + ("bulk memory", "(func (memory.fill (i32.const 0) (i32.const 0) (i32.const 0)))"), + ("reference types", "(func (result externref) (ref.null extern))"), + ("tail calls", "(func $again (param i32) (return_call $again (local.get 0)))"), + ("extended constant expressions", "(global i32 (i32.add (i32.const 1) (i32.const 2)))"), +]; + +/// Modules that use a WebAssembly proposal plug-ins may not use, each with the words its error +/// names it by. +const REFUSED_PROPOSALS: &[(&str, &str)] = &[ + ("(module (func (result v128) (v128.const i32x4 0 0 0 0)))", "SIMD"), + ("(module (func (result v128) (i32x4.relaxed_trunc_f32x4_s (v128.const i32x4 0 0 0 0))))", "SIMD"), + ("(module (memory i64 1))", "memory64"), + ("(module (memory 1) (memory 1))", "multiple memories"), + ("(module (memory 1 (pagesize 1)))", "custom page sizes"), + ( + "(module (func (param i64 i64 i64 i64) (result i64 i64) (i64.add128 (local.get 0) (local.get 1) (local.get 2) (local.get 3))))", + "wide arithmetic", + ), + ("(module (memory 1 1 shared))", "threads"), + ("(module (tag))", "exceptions"), + ("(module (func try catch_all end))", "legacy exceptions"), + ("(module (type $t (func)) (func (param (ref $t))))", "function references"), + ("(module (type (struct)))", "gc feature"), +]; + +#[test] +fn a_plugin_may_use_the_listed_webassembly_proposals_and_no_others() { + for (name, fields) in ACCEPTED_PROPOSALS { + let bytes = module(MANIFEST, tpl::ECHO, fields); + let out = Plugin::load(&bytes, Limits::default()).and_then(|p| p.run(INPUT.as_bytes(), b"{}")); + assert!(out.is_ok(), "{name}: {out:?}"); + } + for (src, name) in REFUSED_PROPOSALS { + match Plugin::load(&build(src), Limits::default()) { + Err(Error::Module(m)) => assert!(m.to_lowercase().contains(&name.to_lowercase()), "{name}: the error doesn't name it: {m}"), + Err(e) => panic!("{name}: refused with another kind of error: {e}"), + Ok(_) => panic!("{name}: a module that uses it must be refused"), + } + } +} + #[test] fn budgets_stop_runaway_plugins() { let spin = ok_module("(loop $l (br $l)) (i64.const 0)"); diff --git a/crates/scriptcheck/src/analyze.rs b/crates/scriptcheck/src/analyze.rs index b8f887ff37..b7c70345d0 100644 --- a/crates/scriptcheck/src/analyze.rs +++ b/crates/scriptcheck/src/analyze.rs @@ -239,6 +239,10 @@ enum Pending<'s> { MenuString(Option, &'s str), /// `.open(`: a string literal with the open mode may follow. Open(Option), + /// A File object's `length`, `hidden` or `readonly` (`f.length`, `f['length']`): an assignment + /// or an update (`++`, `--`) that sets it may follow. With `true`, a prefix update came before + /// the receiver, and it sets the property unless a member or a call follows it. + Setter(Option, bool), /// A platform name where a property key or a label may stand (first, or after `{`, `,`, `;` or /// `}`): it is a key or a label when `:` follows. Name(&'s str, Option), diff --git a/crates/scriptcheck/src/analyze/features.rs b/crates/scriptcheck/src/analyze/features.rs index b5dd2299eb..7bf8c9d203 100644 --- a/crates/scriptcheck/src/analyze/features.rs +++ b/crates/scriptcheck/src/analyze/features.rs @@ -1,6 +1,6 @@ //! The platform features, menu commands and later syntax the analysis recognises. -use super::{Analyzer, FeatureId, NEWER, OutsideId, Pending, Sig, T, catalog, is, member_mark, newer_number, report, unquote, word}; +use super::{Analyzer, COMPOUND, FeatureId, NEWER, OutsideId, Pending, Sig, T, catalog, is, member_mark, newer_number, report, unquote, word}; /// A global name of the platform the report looks for (`$`, `File`, `Socket`, `alert`, `eval`…). pub(super) fn platform_name(n: &str) -> bool { @@ -72,6 +72,17 @@ impl<'s, 'a, 'l> Analyzer<'s, 'a, 'l> { self.open_mode(&unquote(t.text, 2), l); } } + Pending::Setter(l, prefix) => { + let sets = if prefix { + !t.is(".") && !t.is("[") && !t.is("(") + } else { + // An update operator after a line break belongs to the next line's operand. + t.kind == T::Punct && (t.text == "=" || COMPOUND.contains(&t.text) || (matches!(t.text, "++" | "--") && !t.nl)) + }; + if sets { + self.file_setter(l); + } + } } match t.kind { T::Ident => self.name(t, line), @@ -113,7 +124,29 @@ impl<'s, 'a, 'l> Analyzer<'s, 'a, 'l> { match pending { Pending::Window(l) | Pending::WindowType(l) => self.acc.feature(FeatureId::ScriptuiWindow, l), Pending::Menu(l) | Pending::MenuString(l, _) => self.menu(None, l), - Pending::Open(_) | Pending::Name(..) | Pending::None => {} + Pending::Setter(l, true) => self.file_setter(l), + Pending::Open(_) | Pending::Setter(_, false) | Pending::Name(..) | Pending::None => {} + } + } + + /// A File object's `length`, `hidden` or `readonly` set at `line`: the file changes. + fn file_setter(&mut self, line: Option) { + self.acc.feature(FeatureId::FileWrite, line); + self.acc.outside(OutsideId::FilesWritten, line, None); + } + + /// `name`, a property of `receiver` read with `.` or as a string literal in brackets, `before` + /// coming before the receiver: when it is a File object's setter, the next token says whether it + /// is set ([`Pending::Setter`]). An update operator in `before` is a prefix (`++f.length`) when + /// the receiver is on its line, or when it starts a line or comes where an expression may start; + /// otherwise it ends the operand before it (`i++` and a line break, then `f.length`). + fn setter(&mut self, name: &str, receiver: Option>, before: Option>, line: Option) { + if catalog::FILE_SETTERS.contains(&name) && self.file_receiver(receiver, before) { + // Before a receiver that ends in `)` (`new File(i++).length`), the operator is inside the + // parentheses. + let update = before.filter(|b| (b.is("++") || b.is("--")) && receiver.is_some_and(|r| r.kind == T::Ident)); + let prefix = update.is_some_and(|b| b.nl || b.expr || receiver.is_some_and(|r| !r.nl)); + self.pending = Pending::Setter(line, prefix); } } @@ -170,6 +203,7 @@ impl<'s, 'a, 'l> Analyzer<'s, 'a, 'l> { if n == catalog::REFLECT { self.acc.feature(FeatureId::Reflection, line); } + self.setter(n, h1, h2, line); return; } if member_mark(h0) { @@ -231,6 +265,11 @@ impl<'s, 'a, 'l> Analyzer<'s, 'a, 'l> { fn punct(&mut self, t: &Sig<'s>, line: Option) { let [h0, h1, h2, h3] = self.h; match t.text { + // `f['length']`: a File object's setter may follow. + "]" if is(h1, "[") && h0.is_some_and(|s| s.kind == T::Str) => { + let name = h0.map(|s| unquote(s.text, 16)).unwrap_or_default(); + self.setter(&name, h2, h3, line); + } "(" => self.call(line), // `Name.prototype["+"] = …` defines an operator. "=" => { @@ -251,10 +290,7 @@ impl<'s, 'a, 'l> Analyzer<'s, 'a, 'l> { let Some(callee) = h0.filter(|s| s.kind == T::Ident) else { return }; let n = callee.text; if is(h1, ".") { - // The receiver is a variable holding a File or Folder object (not a property of the same - // name), or a File or Folder object made in place or held in grouping parentheses - // ([`Sig::file`]). - let file = h2.is_some_and(|r| r.file || (r.kind == T::Ident && !member_mark(h3) && self.files.contains(r.text))); + let file = self.file_receiver(h2, h3); if n == catalog::MENU_COMMAND { self.pending = Pending::Menu(line); } else if n == catalog::OPEN && file { @@ -288,6 +324,13 @@ impl<'s, 'a, 'l> Analyzer<'s, 'a, 'l> { } } + /// Whether `receiver`, which `before` comes before, is a variable holding a File or Folder object + /// (not a property of the same name), or a File or Folder object made in place or held in + /// grouping parentheses ([`Sig::file`]). + fn file_receiver(&self, receiver: Option>, before: Option>) -> bool { + receiver.is_some_and(|r| r.file || (r.kind == T::Ident && !member_mark(before) && self.files.contains(r.text))) + } + fn string(&mut self, t: &Sig<'s>, line: Option) { let [h0, h1, h2, _] = self.h; if t.text.contains(catalog::ACTION_TEXT) { diff --git a/crates/scriptcheck/src/catalog.rs b/crates/scriptcheck/src/catalog.rs index 8954736d25..6f25fe6df3 100644 --- a/crates/scriptcheck/src/catalog.rs +++ b/crates/scriptcheck/src/catalog.rs @@ -32,6 +32,9 @@ pub(crate) const FOLDER: &str = "Folder"; pub(crate) const FILE_READS: &[&str] = &["read", "readch", "readln"]; pub(crate) const FOLDER_READS: &[&str] = &["getFiles"]; pub(crate) const FILE_WRITES: &[&str] = &["write", "writeln", "remove", "rename", "copy", "createAlias", "create"]; +/// The properties of a File object whose setting changes the file: its length, and its hidden and +/// read-only flags. +pub(crate) const FILE_SETTERS: &[&str] = &["length", "hidden", "readonly"]; pub(crate) const FILE_DIALOGS: &[&str] = &["openDialog", "saveDialog"]; pub(crate) const FOLDER_DIALOGS: &[&str] = &["selectDialog"]; pub(crate) const INSTANCE_DIALOGS: &[&str] = &["openDlg", "saveDlg", "selectDlg"]; diff --git a/crates/scriptcheck/src/tests.rs b/crates/scriptcheck/src/tests.rs index 853f212c11..cf71cefc0f 100644 --- a/crates/scriptcheck/src/tests.rs +++ b/crates/scriptcheck/src/tests.rs @@ -530,6 +530,40 @@ fn the_scripts_own_platform_names_are_not_the_platforms() { assert_eq!(r.outside.iter().map(|o| o.id).collect::>(), ["filesWritten"]); } +/// Setting a File object's length, hidden or read-only flag changes the file; reading them, comparing +/// them and setting them on another object does not. +#[test] +fn setting_a_files_length_or_flags_writes_it() { + let r = report(concat!( + "var f = new File(p);\n", + "f.length = 0;\n", + "f.readonly = true;\n", + "f.hidden |= 1;\n", + "f.length++;\n", + "new File(q).length = 4;\n", + "if (x) --f.length;\n", + "f['readonly'] = false;\n", + "++\n", + "f.length;\n", + "var k = ++\n", + "f['length'];\n", + "++f.length.x; var z = new File(i++).length;\n", + "var n = f.length;\n", + "if (f.readonly == true) {}\n", + "o.length = 0;\n", + "o.f.length = 0;\n", + "var s = [1]; s.length = 0;\n", + "var m = f['length'];\n", + "i++\n", + "f.length;\n", + "f.length\n", + "++i;\n", + )); + let outside: Vec<(&str, &[usize])> = r.outside.iter().map(|o| (o.id, o.lines.as_slice())).collect(); + assert_eq!(outside, [("filesWritten", &[2, 3, 4, 5, 6, 7, 8, 10, 12][..])]); + assert_eq!(feature(&r, "file.write").map(|f| f.lines.as_slice()), Some(&[2, 3, 4, 5, 6, 7, 8, 10, 12][..])); +} + #[test] fn a_function_after_a_line_that_ends_a_statement_is_a_declaration() { let r = report("var n = 1\nfunction File() {}\nFile('x');\nvar m = 2 /* a\n */ function Socket() {}\nnew Socket();\n"); diff --git a/crates/text/src/fontdb/composite.rs b/crates/text/src/fontdb/composite.rs index 7b17fb74de..bdcb84ae8c 100644 --- a/crates/text/src/fontdb/composite.rs +++ b/crates/text/src/fontdb/composite.rs @@ -91,6 +91,8 @@ impl FontDb { /// guard's thread uses the fonts it lends and not this one. pub fn set_composite_font(&self, font: &CompositeFont) -> bool { let key = font.name.to_lowercase(); + #[cfg(any(test, feature = "test-fonts"))] + let _change = crate::test_fonts::font_change(); { let mut map = self.composites.write().unwrap_or_else(|e| e.into_inner()); if map.get(&key).is_some_and(|f| **f == *font) { @@ -104,6 +106,8 @@ impl FontDb { /// Forget the composite font named `name` (any case). Whether there was one. pub fn remove_composite_font(&self, name: &str) -> bool { + #[cfg(any(test, feature = "test-fonts"))] + let _change = crate::test_fonts::font_change(); let removed = self.composites.write().unwrap_or_else(|e| e.into_inner()).remove(&name.to_lowercase()).is_some(); if removed { self.changed(); diff --git a/crates/text/src/fontdb/db.rs b/crates/text/src/fontdb/db.rs index 3be2c871de..046db94dfd 100644 --- a/crates/text/src/fontdb/db.rs +++ b/crates/text/src/fontdb/db.rs @@ -305,6 +305,8 @@ impl FontDb { } } } + #[cfg(any(test, feature = "test-fonts"))] + let _change = (!made.is_empty()).then(crate::test_fonts::font_change); let mut faces = self.faces.write().unwrap_or_else(std::sync::PoisonError::into_inner); let before = faces.len(); for f in made { @@ -325,7 +327,7 @@ impl FontDb { /// Catalog the installed fonts unless that has been done: the first caller scans the font /// folders, any other waits for that scan to finish. A no-op on wasm. - pub(super) fn ensure_catalog(&self) { + pub(crate) fn ensure_catalog(&self) { #[cfg(not(target_arch = "wasm32"))] self.cataloged.get_or_init(|| { self.scan_font_dirs(); @@ -448,6 +450,9 @@ impl FontDb { } log::debug!("cataloged {n} system font faces"); let installed: std::collections::HashSet = catalog.values().flat_map(|c| c.faces.iter().map(|cf| cf.path.clone())).collect(); + // The first scan waits for nothing: a guard is made only for a database already cataloged. + #[cfg(any(test, feature = "test-fonts"))] + let _change = self.cataloged.get().is_some().then(crate::test_fonts::font_change); *self.stamp.lock().unwrap_or_else(|e| e.into_inner()) = Some(ScanStamp { paths, modified: modified_at }); *self.catalog.write().unwrap_or_else(|e| e.into_inner()) = catalog; *self.aliases.write().unwrap_or_else(|e| e.into_inner()) = aliases; diff --git a/crates/text/src/layout/wrapping_tests.rs b/crates/text/src/layout/wrapping_tests.rs index 96ccc3e5c7..225e58a053 100644 --- a/crates/text/src/layout/wrapping_tests.rs +++ b/crates/text/src/layout/wrapping_tests.rs @@ -1312,6 +1312,58 @@ fn shaped_composition_searches_share_the_frame_budget() { assert_eq!(three.steps_left.get(), breaking::MAX_TOTAL_STEPS, "the layout's own steps"); } +/// The every-line composer places a line where its first word fits, and measures that word by the +/// paragraph's custom Kinsoku set: with A in the set's Cannot End Line, the first word of `A BC` +/// runs past the space to the end, so the line `A` skips the frame's 20 pt top and takes the +/// 50 pt band below it. Without the set the word is `A` alone and the top holds it. +#[test] +fn shaped_first_word_uses_the_custom_kinsoku_set() { + use super::shaped::{Budget, Shaped}; + use crate::composer::Measure; + use std::cell::Cell; + use std::rc::Rc; + let text = "A BC"; + let glyphs = full_width(text); + let set = custom_set("", "A", "", &[]); + assert_eq!(breaking::word_width(&glyphs, 0, &[], breaking::KinsokuRules::Custom(&set), Burasagari::None), 40.0); + assert_eq!(breaking::word_width(&glyphs, 0, &[], Kinsoku::Hard, Burasagari::None), 10.0); + // 20 pt wide down to 40 pt, and 50 pt wide below. + let frame = BezPath::from_vec(vec![ + PathEl::MoveTo((0.0, 0.0).into()), + PathEl::LineTo((20.0, 0.0).into()), + PathEl::LineTo((20.0, 40.0).into()), + PathEl::LineTo((50.0, 40.0).into()), + PathEl::LineTo((50.0, 120.0).into()), + PathEl::LineTo((0.0, 120.0).into()), + PathEl::ClosePath, + ]); + let regions = region::Region::cells(&frame, &LayoutOptions::default(), &[]); + let pen = breaking::Pen { + regions: Some(®ions), + ri: 0, + prev: None, + pending: 0.0, + fb: FirstBaseline::Ascent, + fb_min: 0.0, + queued: vec![], + above: Default::default(), + model: LeadingModel::default(), + next_top: None, + no_room_for: f64::INFINITY, + steps_left: Rc::new(Cell::new(breaking::MAX_TOTAL_STEPS)), + search: Rc::new(Budget::default()), + }; + let first_line = |para: &ParaStyle| { + let mut measure = Shaped::new(&glyphs, &[], para, &|_| 0.0, false, false, &pen); + let state = measure.first(); + measure.line(&state, 0, 1).ok().flatten().map(|(width, _)| width) + }; + let hard = ParaStyle { kinsoku: Kinsoku::Hard, ..ParaStyle::default() }; + let custom = ParaStyle { kinsoku_set: Some(Arc::new(set)), ..hard.clone() }; + assert_eq!(first_line(&hard), Some(20.0), "the frame's top holds the word A"); + assert_eq!(first_line(&custom), Some(50.0), "the word A BC needs the band below"); +} + /// The glyphs of `text`, each 10 pt wide, with Korean words kept whole unless `anywhere` (Korean /// Line Break Anywhere on). fn korean(text: &str, anywhere: bool) -> Vec { diff --git a/crates/text/src/retype.rs b/crates/text/src/retype.rs index d7c7be71d6..0a991c669f 100644 --- a/crates/text/src/retype.rs +++ b/crates/text/src/retype.rs @@ -8,13 +8,22 @@ //! best similarity transform (a Procrustes fit) leaves a tiny leftover distance, and the whole //! outline, turned onto the shape, must then lie on it. That holds for outlines made from a font //! the app has (Create Outlines' output, and other apps' that keep each glyph's contours whole and -//! in the font's order). Near matches (other versions of a font, hinted or simplified outlines, -//! faux styles, glyphs merged into one path) are left unmatched; fuzzy identification is phase 2. +//! in the font's order). +//! +//! Near matches ([`RetypeIndex::near_matches`]) take a tolerance: the shape and the glyph are +//! both read at equal steps of length from any start and in either direction, their contours paired +//! by length, so outlines built another way (a simplified outline, a curve split in two, contours +//! in another order or direction) still fit, and [`GlyphMatch::score`] says how closely. +//! [`clusters`] splits a path holding several glyphs (a word outlined as one compound path) into +//! the contour groups that can each be a glyph. Glyphs fused into one contour are not split. use std::collections::{BTreeSet, HashMap}; use std::sync::Arc; +use std::sync::atomic::{AtomicU64, Ordering}; -use kurbo::{Affine, BezPath, CubicBez, Line, ParamCurve, ParamCurveArclen, ParamCurveNearest, PathEl, PathSeg, Point, QuadBez, Shape}; +use kurbo::{ + Affine, BezPath, CubicBez, Line, ParamCurve, ParamCurveArclen, ParamCurveArea, ParamCurveNearest, PathEl, PathSeg, Point, QuadBez, Shape, +}; use crate::{FontDb, FontFace}; @@ -42,10 +51,38 @@ const OUTLINE_TOLERANCE: f64 = 5e-3; const MAX_OUTLINE_POINTS: usize = 8192; /// Points along an outline past which the whole-outline check gives up (and so rejects). const MAX_CHECKED_POINTS: usize = 65_536; -/// The most glyphs one shape is reported to be ([`RetypeIndex::matches`]). +/// The most glyphs one shape is reported to be ([`RetypeIndex::matches`]), and the most of one face +/// [`RetypeIndex::near_matches`] reports. pub const MAX_CANDIDATES: usize = 16; /// How far apart two shapes' spread-to-length ratios may be and still be compared. const INVARIANT_SLACK: f64 = 0.02; +/// The largest tolerance [`RetypeIndex::near_matches`] takes, and the leftover distance at which +/// [`GlyphMatch::score`] reaches 0. +pub const MAX_TOLERANCE: f64 = 0.05; +/// Points sampled along each contour of a shape for near matching, per point of a glyph's. +const NEAR_OVERSAMPLE: usize = 4; +/// Shapes (and glyphs) with more contours than this are not near matched. +const MAX_NEAR_CONTOURS: usize = 8; +/// How far apart two shapes' spread-to-length ratios may be and still be near matched. +const NEAR_INVARIANT_SLACK: f64 = 0.1; +/// How far apart two shapes' area-to-squared-length ratios may be and still be near matched. +const NEAR_COMPACT_SLACK: f64 = 0.15; +/// Glyphs drawn to check whether they could near match a shape, at most. +const MAX_NEAR_CHECKS: usize = 262_144; +/// Glyphs indexed for near matching, at most. +const MAX_NEAR_GLYPHS: usize = 32_768; +/// Near keys [`RetypeIndex::build_near`] looks glyphs up by, at most: past them, the rest are left +/// out. +pub const MAX_NEAR_KEYS: usize = 1024; +/// Point comparisons near matching makes in all, over every shape of one index: past them, shapes +/// are not near matched. +const NEAR_WORK: u64 = 2_000_000_000; +/// Point comparisons near matching makes for one shape, at most. +const NEAR_SHAPE_WORK: u64 = 50_000_000; +/// Glyphs one shape is near matched against, at most: those closest to it in proportion. +const NEAR_FITS: usize = 256; +/// Contours [`clusters`] reads, at most: past it, none. +const MAX_CLUSTER_CONTOURS: usize = 1024; /// One glyph an outlined shape matched. #[derive(Clone)] @@ -62,10 +99,18 @@ pub struct GlyphMatch { pub origin: Point, /// The leftover distance, relative to the shape's spread. pub residual: f64, + /// Whether the shape is exactly the glyph ([`RetypeIndex::matches`]) rather than nearly + /// ([`RetypeIndex::near_matches`]). + pub exact: bool, /// How many contours the glyph has. pub contours: usize, /// Other poses the glyph fits the shape in equally (a glyph that looks the same turned). pub alts: Vec, + /// The leftover distance of each of [`Self::alts`], in the same order. + pub alt_residuals: Vec, + /// The leftover distance of the glyph's own pose: [`Self::residual`] is the least over all its + /// poses, which orders the matches. + pub pose_residual: f64, } /// Where and how a glyph lies: its size, turn and origin. @@ -80,13 +125,28 @@ pub struct Pose { } impl GlyphMatch { + /// How closely the glyph fits the shape: 1 for an exact match, and for a near one from 1 down + /// to 0 at a leftover distance of [`MAX_TOLERANCE`] or more. + pub fn score(&self) -> f64 { + if self.exact { + return 1.0; + } + if !self.residual.is_finite() { + return 0.0; + } + (1.0 - self.residual / MAX_TOLERANCE).clamp(0.0, 1.0) + } + /// This match in each pose it fits: its own first, then [`Self::alts`]. pub fn poses(&self) -> impl Iterator + '_ { - let own = Pose { scale: self.scale, angle: self.angle, origin: self.origin }; - std::iter::once(own).chain(self.alts.iter().copied()).map(move |p| GlyphMatch { + let own = (Pose { scale: self.scale, angle: self.angle, origin: self.origin }, self.pose_residual); + let alts = self.alts.iter().copied().zip(self.alt_residuals.iter().copied().chain(std::iter::repeat(self.residual))); + std::iter::once(own).chain(alts).map(move |(p, residual)| GlyphMatch { scale: p.scale, angle: p.angle, origin: p.origin, + residual, + pose_residual: residual, ..self.clone() }) } @@ -102,6 +162,8 @@ struct Signature { spread: f64, /// `spread` / the total contour length: unchanged by scale, turn and move. invariant: f64, + /// Each contour's length. + lens: Vec, } struct Entry { @@ -111,6 +173,9 @@ struct Entry { sig: Signature, /// The glyph's outline in font units, for the whole-outline check. outline: BezPath, + /// Whether the glyph was indexed for its exact key: only these take part in exact matching, + /// and the ones indexed only for near matching ([`RetypeIndex::near_matches`]) do not. + exact: bool, } /// The glyphs of a set of faces, ready to match shapes against. @@ -120,6 +185,10 @@ pub struct RetypeIndex { entries: Vec, /// Entry indices by contour count, sorted by invariant. buckets: HashMap>, + /// Entry indices by face id and glyph id. + by_glyph: HashMap<(u32, u32), usize>, + /// The point comparisons [`Self::near_matches`] may still make, over every shape. + near_work: AtomicU64, } impl RetypeIndex { @@ -128,6 +197,32 @@ impl RetypeIndex { /// they are not sampled. Outlines are read past the shared outline cache, which keeps the /// canvas's glyphs. pub fn build(db: &FontDb, faces: impl IntoIterator>, keys: &BTreeSet) -> Self { + Self::build_near(db, faces, keys, &[]) + } + + /// [`Self::build`], also indexing for [`Self::near_matches`] the glyphs that could near match + /// a shape with one of the [`near_key`]s in `near` (the first [`MAX_NEAR_KEYS`]): the same + /// number of contours (at most 8) and a close area-to-length ratio. At most 262,144 glyphs are + /// drawn to check that, and at most 32,768 indexed for it, each face taking an equal share of + /// both; of a face's glyphs, those closest in that ratio are indexed. + pub fn build_near(db: &FontDb, faces: impl IntoIterator>, keys: &BTreeSet, near: &[NearKey]) -> Self { + Self::build_near_within(db, faces, keys, near, MAX_NEAR_GLYPHS) + } + + /// [`Self::build_near`] indexing at most `near_glyphs` glyphs for near matching. + fn build_near_within( + db: &FontDb, + faces: impl IntoIterator>, + keys: &BTreeSet, + near: &[NearKey], + near_glyphs: usize, + ) -> Self { + let near: Vec = near + .iter() + .copied() + .filter(|k| k.contours <= MAX_NEAR_CONTOURS && k.compact.is_finite() && k.compact > 0.0) + .take(MAX_NEAR_KEYS) + .collect(); let mut kept: Vec> = vec![]; for f in faces { if kept.len() >= MAX_FACES { @@ -137,19 +232,52 @@ impl RetypeIndex { kept.push(f); } } + // Each face gets an equal share of the near checks and entries, so a face with many glyphs + // (a CJK face) does not use them up before the faces after it. + let share = |cap: usize| cap / kept.len().max(1); let mut entries = vec![]; 'faces: for (fi, face) in kept.iter().enumerate() { - for &(gid, ch, key) in face_keys(db, face).iter() { + let mut face_checks = 0usize; + // The face's glyphs that could near match, with how far their key is from the closest + // wanted one: the closest share of them are indexed, whatever their glyph order. + let keep = share(near_glyphs); + let mut close: Vec<(f64, u32, char, BezPath)> = vec![]; + let trim = |close: &mut Vec<(f64, u32, char, BezPath)>| { + close.sort_by(|a, b| a.0.total_cmp(&b.0).then(a.1.cmp(&b.1))); + close.truncate(keep); + }; + for &(gid, ch, key, count) in face_keys(db, face).iter() { // The budget holds inside a face too: no glyph is sampled past it. if entries.len() >= MAX_GLYPHS { break 'faces; } - if !keys.contains(&key) { + if keys.contains(&key) { + let outline = db.outline_uncached(face, gid); + if let Some(sig) = signatures(&outline, false).into_iter().next() { + entries.push(Entry { face: fi, gid, ch, sig, outline, exact: true }); + } continue; } + let count = usize::from(count); + if keep == 0 || face_checks >= share(MAX_NEAR_CHECKS) || !near.iter().any(|k| k.contours == count) { + continue; + } + face_checks += 1; let outline = db.outline_uncached(face, gid); + let Some(g) = near_key(&outline) else { continue }; + let Some(d) = near.iter().filter(|k| k.close_to(&g)).map(|k| k.apart(&g)).min_by(f64::total_cmp) else { continue }; + close.push((d, gid, ch, outline)); + if close.len() >= keep.saturating_mul(2) { + trim(&mut close); + } + } + trim(&mut close); + for (_, gid, ch, outline) in close { + if entries.len() >= MAX_GLYPHS { + break 'faces; + } if let Some(sig) = signatures(&outline, false).into_iter().next() { - entries.push(Entry { face: fi, gid, ch, sig, outline }); + entries.push(Entry { face: fi, gid, ch, sig, outline, exact: false }); } } } @@ -163,7 +291,39 @@ impl RetypeIndex { x.total_cmp(&y) }); } - RetypeIndex { faces: kept, entries, buckets } + let by_glyph = entries.iter().enumerate().filter_map(|(i, e)| Some(((kept.get(e.face)?.id(), e.gid), i))).collect(); + RetypeIndex { faces: kept, entries, buckets, by_glyph, near_work: AtomicU64::new(NEAR_WORK) } + } + + /// `m` kept to the poses in which the glyph paints the area `shape` paints, the shape filled + /// by the nonzero rule when `nonzero` is set and by the even-odd rule otherwise, the glyph + /// filled by the nonzero rule. Two outlines on each other can paint different areas: a ring + /// whose inner contour runs the same way as its outer one, filled by the nonzero rule, has no + /// hole. Probes lie on both sides of the shape's outline, left out where either outline is + /// within reach of them. `tolerance` is the one `m` was found with (0 for an exact match). The + /// first pose that agrees comes first; `None` when none does. + pub fn painted_agrees(&self, m: &GlyphMatch, shape: &BezPath, nonzero: bool, tolerance: f64) -> Option { + let Some(e) = self.by_glyph.get(&(m.face.id(), m.gid)).and_then(|i| self.entries.get(*i)) else { return Some(m.clone()) }; + let bb = shape.bounding_box(); + let tol = bb.width().hypot(bb.height()) * 0.5 * OUTLINE_TOLERANCE.max(3.0 * tolerance.clamp(0.0, MAX_TOLERANCE)); + let mut agreeing = m.poses().filter(|p| { + let onto = Affine::new([ + p.scale * p.angle.cos(), + p.scale * p.angle.sin(), + -p.scale * p.angle.sin(), + p.scale * p.angle.cos(), + p.origin.x, + p.origin.y, + ]); + paints_alike(shape, nonzero, &(onto * e.outline.clone()), tol) + }); + let first = agreeing.next()?; + let rest: Vec = agreeing.collect(); + Some(GlyphMatch { + alts: rest.iter().map(|p| Pose { scale: p.scale, angle: p.angle, origin: p.origin }).collect(), + alt_residuals: rest.iter().map(|p| p.pose_residual).collect(), + ..first + }) } /// The faces indexed. @@ -195,7 +355,23 @@ impl RetypeIndex { /// Every glyph `shape` fits exactly, in every face, in the order of [`RetypeIndex::matches`], /// which returns the first [`MAX_CANDIDATES`] of them. pub fn all_matches(&self, shape: &BezPath) -> Vec { - let variants = signatures(shape, true); + self.matches_read(shape, shape) + } + + /// [`Self::all_matches`], and when the shape fits no glyph as it is, its contours read the + /// other way round: for a part of a compound path, which Make Compound Path may have turned so + /// it cuts a hole in the paths behind it. + pub fn matches_either_way(&self, shape: &BezPath) -> Vec { + let found = self.matches_read(shape, shape); + if !found.is_empty() { + return found; + } + self.matches_read(shape, &shape.reverse_subpaths()) + } + + /// [`Self::all_matches`] of `shape`, its contours read as in `reading` (the same outline). + fn matches_read(&self, shape: &BezPath, reading: &BezPath) -> Vec { + let variants = signatures(reading, true); let Some(first) = variants.first() else { return vec![] }; let Some(list) = self.buckets.get(&first.contours) else { return vec![] }; let lo = first.invariant * (1.0 - INVARIANT_SLACK); @@ -210,6 +386,9 @@ impl RetypeIndex { if e.sig.invariant > hi { break; } + if !e.exact { + continue; + } let Some(face) = self.faces.get(e.face) else { continue }; // Each reading of the shape (its tied starting corners) that fits the glyph is a pose. let mut poses: Vec<(Pose, f64)> = vec![]; @@ -236,7 +415,7 @@ impl RetypeIndex { } // The upright-most pose first. poses.sort_by(|a, b| wrapped(a.0.angle).abs().total_cmp(&wrapped(b.0.angle).abs())); - let Some(((pose, _), rest)) = poses.split_first() else { continue }; + let Some(((pose, own_residual), rest)) = poses.split_first() else { continue }; let residual = poses.iter().map(|(_, r)| *r).fold(f64::INFINITY, f64::min); let m = GlyphMatch { face: face.clone(), @@ -246,8 +425,11 @@ impl RetypeIndex { angle: pose.angle, origin: pose.origin, residual, + exact: true, contours: e.sig.contours, alts: rest.iter().map(|(p, _)| *p).collect(), + alt_residuals: rest.iter().map(|(_, r)| *r).collect(), + pose_residual: *own_residual, }; out.push((e.face, m)); } @@ -257,6 +439,500 @@ impl RetypeIndex { }); out.into_iter().map(|(_, m)| m).collect() } + + /// The glyphs `shape` (in document space) nearly is: every glyph of the index with as many + /// contours whose best fit leaves a leftover distance of at most `tolerance` (relative to the + /// shape's spread, at most [`MAX_TOLERANCE`]) and whose whole outline, turned onto the shape, + /// lies within three times the tolerance of it (at least 0.5%). The shape and the glyph are + /// read from any start, in either direction, with their contours paired by length, so the + /// shape need not be built as the glyph is. Upright ones first, then the closest; the other + /// turns a glyph fits in (at most 7) are kept in [`GlyphMatch::alts`]; at most + /// [`MAX_CANDIDATES`] for each face. Empty for a tolerance of 0 or less, and for shapes of more + /// than 8 contours. A shape is compared with at most the 256 glyphs closest to it in proportion + /// (the spread-to-length ratio, and the share of the length each contour has), closest first, + /// in at most 50 million point comparisons, and the index's calls make at most 2 billion in + /// all (ranking a glyph by proportion counts as one per contour and one more); once they are + /// spent, the glyphs not yet ranked or compared are left out. + pub fn near_matches(&self, shape: &BezPath, tolerance: f64) -> Vec { + // NaN too. + if tolerance.is_nan() || tolerance <= 0.0 { + return vec![]; + } + let tolerance = tolerance.min(MAX_TOLERANCE); + // With no comparisons left, no shape is sampled or ranked. + if self.near_work.load(Ordering::Acquire) == 0 { + return vec![]; + } + let Some(s) = near_signature(shape) else { return vec![] }; + if !self.buckets.contains_key(&s.contours) { + return vec![]; + } + let tol = s.spread * OUTLINE_TOLERANCE.max(3.0 * tolerance); + let mut shape_flat: Option> = None; + let mut out: Vec<(usize, GlyphMatch)> = vec![]; + // This call's allowance comes out of the index's budget in one step, so calls that overlap + // never spend the same comparisons; what it leaves unspent goes back afterward. + let mut seen = self.near_work.load(Ordering::Acquire); + let mut work = loop { + let take = seen.min(NEAR_SHAPE_WORK); + match self.near_work.compare_exchange_weak(seen, seen - take, Ordering::AcqRel, Ordering::Acquire) { + Ok(_) => break take, + Err(now) => seen = now, + } + }; + let near = self.ranked_near(&s, &mut work); + for (_, e) in near { + if work == 0 { + break; + } + let Some(face) = self.faces.get(e.face) else { continue }; + let fits = near_fit(&e.sig, &s, tolerance, &mut work); + let flat = shape_flat.get_or_insert_with(|| Flat::new(shape, tol)); + let Some(flat) = flat.as_ref() else { break }; + // Every turn the glyph fits the shape at, nearest upright first: the first is its + // pose, the others its alternatives (a glyph that looks alike turned). + let mut poses = + fits.into_iter().filter(|f| f.1 <= tolerance).filter_map(|(z, r)| Some((near_pose(e, &s, z, flat, tol)?, r))).take(MAX_NEAR_POSES); + let Some((pose, residual)) = poses.next() else { continue }; + let rest: Vec<(Pose, f64)> = poses.collect(); + let m = GlyphMatch { + face: face.clone(), + gid: e.gid, + ch: e.ch, + scale: pose.scale, + angle: pose.angle, + origin: pose.origin, + residual, + exact: false, + contours: e.sig.contours, + alts: rest.iter().map(|(p, _)| *p).collect(), + alt_residuals: rest.iter().map(|(_, r)| *r).collect(), + pose_residual: residual, + }; + out.push((e.face, m)); + } + self.near_work.fetch_add(work, Ordering::AcqRel); + let upright = |m: &GlyphMatch| wrapped(m.angle).abs() >= 1e-3; + out.sort_by(|a, b| { + upright(&a.1).cmp(&upright(&b.1)).then(a.1.residual.total_cmp(&b.1.residual)).then(a.0.cmp(&b.0)).then(a.1.ch.cmp(&b.1.ch)) + }); + keep_per_face(&mut out); + out.into_iter().map(|(_, m)| m).collect() + } + + /// The glyphs of as many contours as near-matching shape `s` that are closest to it in + /// proportion, at most [`NEAR_FITS`], closest first: their spread-to-length ratio, and the + /// share of the length each contour has, longest first. Ranking a glyph takes one comparison + /// per contour, and one more, from `work`; once it is spent, the glyphs not yet ranked are + /// left out. + fn ranked_near(&self, s: &Signature, work: &mut u64) -> Vec<(f64, &Entry)> { + let Some(list) = self.buckets.get(&s.contours) else { return vec![] }; + let lo = s.invariant * (1.0 - NEAR_INVARIANT_SLACK); + let hi = s.invariant * (1.0 + NEAR_INVARIANT_SLACK); + let start = list.partition_point(|i| self.entries.get(*i).is_some_and(|e| e.sig.invariant < lo)); + // Each contour's share of the length, longest first (a near-matched shape has at most + // MAX_NEAR_CONTOURS contours, and the glyphs ranked as many). + let shares = |sig: &Signature| { + let mut v = [0.0f64; MAX_NEAR_CONTOURS]; + let total: f64 = sig.lens.iter().sum(); + for (o, l) in v.iter_mut().zip(&sig.lens) { + *o = l / total; + } + v.sort_by(|a, b| b.total_cmp(a)); + v + }; + let own = shares(s); + let apart = |e: &Entry| { + let d = (e.sig.invariant - s.invariant).abs() / s.invariant + shares(&e.sig).iter().zip(&own).map(|(a, b)| (a - b).abs()).sum::(); + if d.is_finite() { d } else { f64::INFINITY } + }; + let cost = s.contours as u64 + 1; + let mut near: Vec<(f64, &Entry)> = vec![]; + for e in list.iter().skip(start).filter_map(|i| self.entries.get(*i)).take_while(|e| e.sig.invariant <= hi) { + let Some(left) = work.checked_sub(cost) else { break }; + *work = left; + near.push((apart(e), e)); + } + if near.len() > NEAR_FITS { + near.select_nth_unstable_by(NEAR_FITS, |a, b| a.0.total_cmp(&b.0)); + near.truncate(NEAR_FITS); + } + near.sort_by(|a, b| a.0.total_cmp(&b.0)); + near + } +} + +/// Turns of one glyph [`RetypeIndex::near_matches`] keeps, at most: its pose and its alternatives. +const MAX_NEAR_POSES: usize = 8; + +/// `out` (each match with its face's index) without the matches past the first +/// [`MAX_CANDIDATES`] of each face, so faces drawn alike (copies of one font under other names) +/// do not crowd out the glyphs of the faces after them. +fn keep_per_face(out: &mut Vec<(usize, GlyphMatch)>) { + let mut seen: HashMap = HashMap::new(); + out.retain(|(face, _)| { + let n = seen.entry(*face).or_default(); + *n += 1; + *n <= MAX_CANDIDATES + }); +} + +/// Entry `e`'s pose on near-matching shape `s` at scaled turn `z`, when its whole outline, so +/// placed, lies within `tol` of the shape's (`flat`). +fn near_pose(e: &Entry, s: &Signature, z: (f64, f64), flat: &Flat, tol: f64) -> Option { + let gc = mul(z, e.sig.centre); + let origin = Point::new(s.centre.x - gc.x, s.centre.y - gc.y); + let onto = Affine::new([z.0, z.1, -z.1, z.0, origin.x, origin.y]); + Flat::new(&(onto * e.outline.clone()), tol).is_some_and(|g| g.agrees(flat)).then(|| Pose { scale: z.0.hypot(z.1), angle: z.1.atan2(z.0), origin }) +} + +/// What near matching compares first: a shape's number of contours and its area over its squared +/// length, both unchanged by scale, turn and move, and close for outlines drawn alike. +#[derive(Clone, Copy, Debug, PartialEq)] +pub struct NearKey { + pub contours: usize, + pub compact: f64, +} + +impl NearKey { + /// Could shapes with these keys near match? + fn close_to(&self, other: &NearKey) -> bool { + self.contours == other.contours && self.apart(other) <= NEAR_COMPACT_SLACK + } + + /// How far apart the two keys' area-to-squared-length ratios are, relative to the larger. + fn apart(&self, other: &NearKey) -> f64 { + (self.compact - other.compact).abs() / self.compact.max(other.compact) + } +} + +/// `path`'s [`NearKey`]; `None` past the size caps, for an empty shape or one of more than 8 +/// contours. +pub fn near_key(path: &BezPath) -> Option { + let (cs, _, _) = measured(path)?; + if cs.is_empty() || cs.len() > MAX_NEAR_CONTOURS { + return None; + } + let (mut area, mut len) = (0.0, 0.0); + for (c, lens) in &cs { + area += c.iter().map(|s| s.signed_area()).sum::().abs(); + len += lens.iter().sum::(); + } + let compact = area / (len * len); + (compact.is_finite() && compact > 0.0).then_some(NearKey { contours: cs.len(), compact }) +} + +/// `path` read for near matching: points at equal steps of length along each contour from where +/// it starts, [`NEAR_OVERSAMPLE`] times as many as a glyph's. `None` for more than 8 contours. +fn near_signature(path: &BezPath) -> Option { + let (cs, _, accuracy) = measured(path)?; + if cs.is_empty() || cs.len() > MAX_NEAR_CONTOURS { + return None; + } + let starts = vec![vec![0usize]; cs.len()]; + let pick = vec![0usize; cs.len()]; + sample(&cs, &starts, &pick, accuracy, SAMPLES * NEAR_OVERSAMPLE) +} + +/// The scaled turn that best takes glyph `g`'s points onto near-matching shape `s`'s (read by +/// [`near_signature`]), whatever contour each starts at, in either direction and order, and the +/// leftover distance relative to the shape's spread. The longest contours are paired first and give +/// the turns to try (spread over the circle when that pair fits about as well at many). Under each +/// turn, every glyph contour takes the shape contour, start and direction closest to it, and the +/// turn is fitted again over them all, for up to [`REFITS`] rounds. The turns that fit about +/// equally well (a glyph that looks alike turned) and within `limit` are kept, the one nearest +/// upright first ([`fits_within`]). Each point comparison is taken from `work`; none when it runs +/// out before the first turn is fitted, and the turns fitted so far when it runs out after. +fn near_fit(g: &Signature, s: &Signature, limit: f64, work: &mut u64) -> Vec<((f64, f64), f64)> { + fits_within(near_turns(g, s, work).unwrap_or_default(), limit) +} + +/// The turns [`near_fit`] fits, each with its leftover distance. +fn near_turns(g: &Signature, s: &Signature, work: &mut u64) -> Option> { + let nc = g.contours; + let m = SAMPLES * NEAR_OVERSAMPLE; + if nc == 0 || s.contours != nc || g.pts.len() != nc * SAMPLES || s.pts.len() != nc * m || g.lens.len() != nc || s.lens.len() != nc { + return None; + } + // Comparisons the longest pair's every start and direction take, and one round of pairing + // every contour and fitting the turn. + let first_cost = (4 * m * SAMPLES) as u64; + let round_cost = ((nc * (nc + 1) * m + 20 * nc) * SAMPLES) as u64; + let Some(left) = work.checked_sub(first_cost) else { + *work = 0; + return None; + }; + *work = left; + let by_len = |lens: &[f64]| { + let mut o: Vec = (0..lens.len()).collect(); + o.sort_by(|a, b| lens.get(*b).copied().unwrap_or(0.0).total_cmp(&lens.get(*a).copied().unwrap_or(0.0))); + o + }; + let (go, so) = (by_len(&g.lens), by_len(&s.lens)); + let (&ga, &sa) = (go.first()?, so.first()?); + let gpts = |c: usize| g.pts.get(c * SAMPLES..(c + 1) * SAMPLES); + let spts = |c: usize| s.pts.get(c * m..(c + 1) * m); + // The point of shape contour `b` matched to glyph sample j, from start k (in samples, and + // between two samples read on the line joining them), forward or back. + let at = |b: &[Point], k: f64, j: usize, back: bool| { + let step = (j * NEAR_OVERSAMPLE) as f64; + let x = (if back { k - step } else { k + step }).rem_euclid(m as f64); + let i = (x.floor() as usize).min(m - 1); + let (p, q) = (b.get(i).copied().unwrap_or(Point::ZERO), b.get((i + 1) % m).copied().unwrap_or(Point::ZERO)); + p.lerp(q, x - i as f64) + }; + // The fit of glyph contour `a` onto shape contour `b` from start k: Σ b·conj(a) and Σ|a|². + let sums = |a: &[Point], b: &[Point], k: f64, back: bool| { + let (mut re, mut im, mut aa) = (0.0, 0.0, 0.0); + for (j, p) in a.iter().enumerate() { + let q = at(b, k, j, back); + re += q.x * p.x + q.y * p.y; + im += q.y * p.x - q.x * p.y; + aa += p.x * p.x + p.y * p.y; + } + (re, im, aa) + }; + let sse = |a: &[Point], b: &[Point], k: f64, back: bool, z: (f64, f64)| { + a.iter().enumerate().map(|(j, p)| at(b, k, j, back).distance_squared(mul(z, *p))).sum::() + }; + // Every start and direction of the longest pair, with its own best turn. + let (a0, b0) = (gpts(ga)?, spts(sa)?); + let mut firsts: Vec<(f64, (f64, f64))> = vec![]; + for back in [false, true] { + for k in 0..m { + let (re, im, aa) = sums(a0, b0, k as f64, back); + if aa <= 0.0 || !aa.is_finite() { + return None; + } + let z = (re / aa, im / aa); + firsts.push((sse(a0, b0, k as f64, back, z), z)); + } + } + firsts.sort_by(|a, b| a.0.total_cmp(&b.0)); + let best = firsts.first()?.0; + // The turns that fit the longest pair about as well as the best. A longest contour that is + // nearly round fits at every angle, and only the other contours tell the turns apart, so + // besides the turns nearest upright, the best in each of TURN_BINS equal ranges of angle is + // tried, at most MAX_TURNS of them, evenly by angle. + const TURN_BINS: usize = 64; + const MAX_TURNS: usize = 24; + let window = best * 1.5 + 1e-12 * s.spread * s.spread; + let mut bins: Vec> = vec![None; TURN_BINS]; + for &(e, z) in firsts.iter().take_while(|(e, _)| *e <= window) { + let ang = z.1.atan2(z.0); + if !ang.is_finite() { + continue; + } + let b = (((ang + std::f64::consts::PI) / std::f64::consts::TAU * TURN_BINS as f64) as usize).min(TURN_BINS - 1); + if let Some(slot) = bins.get_mut(b) + && slot.is_none_or(|(old, _)| e < old) + { + *slot = Some((e, z)); + } + } + // First the best turn and up to five others nearest upright, told apart by their angle, then + // the spread ones. + let mut turns: Vec<(f64, f64)> = firsts.first().map(|f| f.1).into_iter().collect(); + let mut upright: Vec<(f64, f64)> = firsts.iter().take_while(|(e, _)| *e <= window).map(|(_, z)| *z).collect(); + upright.sort_by(|a, b| wrapped(a.1.atan2(a.0)).abs().total_cmp(&wrapped(b.1.atan2(b.0)).abs())); + for z in upright { + if turns.len() >= 6 { + break; + } + let ang = z.1.atan2(z.0); + if turns.iter().all(|t| wrapped(t.1.atan2(t.0) - ang).abs() > 0.05) { + turns.push(z); + } + } + // One contour: every start of it was tried above, and its own fit is final. + if nc > 1 { + let spread: Vec<(f64, f64)> = bins.into_iter().flatten().map(|(_, z)| z).collect(); + let step = spread.len().div_ceil(MAX_TURNS).max(1); + turns.extend(spread.into_iter().step_by(step)); + } + let rounds = if nc > 1 { REFITS } else { 1 }; + let n = (nc * SAMPLES) as f64; + // Each glyph contour, longest first, takes the shape contour, start and direction that fit it + // best under turn `z`; then the turn is fitted over every pair. The new turn and the leftover + // distance; `None` inside for a fit with nothing to go on, and `None` for malformed readings. + let pair_and_fit = |z: (f64, f64)| -> Option> { + let mut free: Vec = so.clone(); + let mut pairs: Vec<(usize, usize, f64, bool)> = vec![]; + for &gc in &go { + let a = gpts(gc)?; + let mut pick: Option<(f64, usize, f64, bool)> = None; + for (fi, &sc) in free.iter().enumerate() { + let b = spts(sc)?; + for back in [false, true] { + for k in 0..m { + let e = sse(a, b, k as f64, back, z); + if pick.is_none_or(|p| e < p.0) { + pick = Some((e, fi, k as f64, back)); + } + } + } + } + let (mut e, fi, mut k, back) = pick?; + let sc = free.remove(fi); + // The start between samples: the shape's samples need not fall where the glyph's do. + let b = spts(sc)?; + let k0 = k; + for d in 1..16 { + let kd = k0 - 0.5 + d as f64 / 16.0; + let ed = sse(a, b, kd, back, z); + if ed < e { + (e, k) = (ed, kd); + } + } + pairs.push((gc, sc, k, back)); + } + let (mut re, mut im, mut aa) = (0.0, 0.0, 0.0); + for &(gc, sc, k, back) in &pairs { + let (r, i, a) = sums(gpts(gc)?, spts(sc)?, k, back); + re += r; + im += i; + aa += a; + } + if aa <= 0.0 || !aa.is_finite() { + return Some(None); + } + let z = (re / aa, im / aa); + let mut total = 0.0; + for &(gc, sc, k, back) in &pairs { + total += sse(gpts(gc)?, spts(sc)?, k, back, z); + } + let rel = (total / n).sqrt() / s.spread; + Some(rel.is_finite().then_some((z, rel))) + }; + let mut results: Vec<((f64, f64), f64)> = vec![]; + 'turns: for z0 in turns { + // Each glyph contour is paired under the turn, the turn is fitted again over the pairs, + // and the contours are paired again under the new turn, until it settles: a turn that + // starts a little off (a round longest contour) moves onto the one the other contours set. + let mut z = z0; + let mut fitted: Option<((f64, f64), f64)> = None; + for _ in 0..rounds { + let Some(left) = work.checked_sub(round_cost) else { + *work = 0; + results.extend(fitted); + break 'turns; + }; + *work = left; + let Some((nz, rel)) = pair_and_fit(z)? else { break }; + let settled = (nz.0 - z.0).hypot(nz.1 - z.1) <= 1e-6 * z.0.hypot(z.1); + if fitted.is_none_or(|f| rel <= f.1) { + fitted = Some((nz, rel)); + } + z = nz; + if settled { + break; + } + } + results.extend(fitted); + } + Some(results) +} + +/// Of fitted turns and their leftover distances, those that fit about as well as the best (within +/// 1.5 times its distance) and within `limit`, nearest upright first, one per turn (turns less +/// than 0.001 apart are one); the best one alone when none is within `limit`. +fn fits_within(results: Vec<((f64, f64), f64)>, limit: f64) -> Vec<((f64, f64), f64)> { + let best = results.iter().map(|r| r.1).fold(f64::INFINITY, f64::min); + let cap = (best * 1.5 + 1e-9).min(limit.max(best)); + let turn = |r: &((f64, f64), f64)| r.0.1.atan2(r.0.0); + let mut kept: Vec<((f64, f64), f64)> = results.into_iter().filter(|r| r.1 <= cap).collect(); + kept.sort_by(|a, b| wrapped(turn(a)).abs().total_cmp(&wrapped(turn(b)).abs()).then(a.1.total_cmp(&b.1))); + let mut out: Vec<((f64, f64), f64)> = vec![]; + for r in kept { + if out.iter().all(|o| wrapped(turn(o) - turn(&r)).abs() >= 1e-3) { + out.push(r); + } + } + out +} + +/// Rounds of pairing and fitting [`near_fit`] gives each turn, at most. +const REFITS: usize = 4; + +/// Anchor points of a contour [`clusters`] tests against a candidate container, at most. +const MAX_CONTAINMENT_PROBES: usize = 8; + +/// `path`'s contours in groups that can each be one glyph: a contour with the contours that lie +/// inside it (a letter's counters, and what lies inside those), in the order the outer contours +/// come. A path of several glyphs (a word outlined as one compound path) gives one group per glyph +/// part (an i gives two: its stem and its dot). Empty past 1,024 contours. +pub fn clusters(path: &BezPath) -> Vec { + let mut subs: Vec = vec![]; + for el in path.elements() { + match el { + PathEl::MoveTo(_) => { + if subs.len() >= MAX_CLUSTER_CONTOURS { + return vec![]; + } + subs.push(BezPath::new()); + if let Some(s) = subs.last_mut() { + s.push(*el); + } + } + _ => match subs.last_mut() { + Some(s) => s.push(*el), + None => return vec![], + }, + } + } + let boxes: Vec = subs.iter().map(Shape::bounding_box).collect(); + // Up to MAX_CONTAINMENT_PROBES of each contour's anchor points, evenly spread: a contour lies in + // another only when every one of them does. + let probes: Vec> = subs + .iter() + .map(|s| { + let anchors: Vec = s.elements().iter().filter_map(|e| e.end_point()).collect(); + let step = anchors.len().div_ceil(MAX_CONTAINMENT_PROBES).max(1); + anchors.into_iter().step_by(step).collect() + }) + .collect(); + // Each contour's container: the smallest contour around it. + let parent: Vec> = (0..subs.len()) + .map(|i| { + let (Some(bi), Some(pi)) = (boxes.get(i), probes.get(i)) else { return None }; + if pi.is_empty() { + return None; + } + (0..subs.len()) + .filter(|&j| j != i) + .filter_map(|j| Some((j, boxes.get(j)?, subs.get(j)?))) + .filter(|(_, bj, sj)| { + bj.area() > bi.area() + && bj.x0 <= bi.x0 + && bj.y0 <= bi.y0 + && bj.x1 >= bi.x1 + && bj.y1 >= bi.y1 + && pi.iter().all(|p| sj.winding(*p) != 0) + }) + .min_by(|a, b| a.1.area().total_cmp(&b.1.area())) + .map(|(j, _, _)| j) + }) + .collect(); + let root = |mut i: usize| { + // Containers are strictly larger, so the chain ends; the bound keeps it so. + for _ in 0..subs.len() { + match parent.get(i).copied().flatten() { + Some(p) => i = p, + None => break, + } + } + i + }; + let mut groups: Vec<(usize, BezPath)> = vec![]; + for (i, s) in subs.iter().enumerate() { + let r = root(i); + match groups.iter_mut().find(|(g, _)| *g == r) { + Some((_, p)) => p.extend(s.iter()), + None => groups.push((r, s.clone())), + } + } + groups.sort_by_key(|(r, _)| *r); + groups.into_iter().map(|(_, p)| p).collect() } /// `a` wrapped into −π..π. @@ -264,11 +940,11 @@ fn wrapped(a: f64) -> f64 { (a + std::f64::consts::PI).rem_euclid(std::f64::consts::TAU) - std::f64::consts::PI } -/// A face's glyphs as the index looks them up: (glyph, character, [`shape_key`]), one per glyph -/// under the lowest character that maps to it. -type FaceKeys = Arc>; +/// A face's glyphs as the index looks them up: (glyph, character, [`shape_key`], contours), one per +/// glyph under the lowest character that maps to it. +type FaceKeys = Arc>; -/// How many glyph keys [`face_keys`] keeps in all (16 bytes each). +/// How many glyph keys [`face_keys`] keeps in all (24 bytes each). const KEPT_KEYS: usize = 1 << 20; /// The faces' keys [`face_keys`] keeps, for the database generation they were read in. @@ -306,7 +982,14 @@ fn face_keys(db: &FontDb, face: &FontFace) -> FaceKeys { } let mut gids: Vec<(u32, char)> = by_gid.into_iter().collect(); gids.sort_unstable(); - let keys: FaceKeys = Arc::new(gids.into_iter().filter_map(|(gid, ch)| Some((gid, ch, shape_key(&db.outline_uncached(face, gid))?))).collect()); + let keys: FaceKeys = Arc::new( + gids.into_iter() + .filter_map(|(gid, ch)| { + let (key, count) = key_and_count(&db.outline_uncached(face, gid))?; + Some((gid, ch, key, u16::try_from(count).ok()?)) + }) + .collect(), + ); let mut k = kept.lock().unwrap_or_else(|e| e.into_inner()); if k.generation != generation { return keys; @@ -475,6 +1158,186 @@ impl Flat { } } +/// Shape segments [`paints_alike`] probes beside, at most. +const MAX_FILL_PROBES: usize = 512; + +/// Do `shape` (filled by the nonzero rule when `nonzero` is set, else by the even-odd rule) and +/// `glyph` (filled by the nonzero rule), whose outlines lie within `tol` of each other, paint the +/// same area? Each probe lies `1.5 tol` or `3 tol` to a side of the middle of a segment of the shape's +/// outline; one within `tol` of either outline is skipped, so a region narrower than that is not +/// probed. `false` when a counter of the shape (a contour inside another) is narrower than `3 tol` +/// across in some direction, however it is turned, since the probes cannot then tell whether the +/// area inside it is painted, and `false` when an outline is too large to probe. +fn paints_alike(shape: &BezPath, nonzero: bool, glyph: &BezPath, tol: f64) -> bool { + if narrow_contour(shape, 3.0 * tol) { + return false; + } + let (Some(fs), Some(fg)) = (Flat::new(shape, tol), Flat::new(glyph, tol)) else { return false }; + let step = fs.segs.len().div_ceil(MAX_FILL_PROBES).max(1); + for (s, e) in fs.segs.iter().step_by(step) { + let d = *e - *s; + let len = d.hypot(); + if len <= 0.0 || !len.is_finite() { + continue; + } + let mid = s.midpoint(*e); + // The nearer probes reach counters and gaps too narrow for the farther ones. + for reach in [1.5, 3.0] { + let side = kurbo::Vec2::new(-d.y, d.x) * (reach * tol / len); + for q in [mid + side, mid - side] { + if fs.near(q) || fg.near(q) { + continue; + } + let w = shape.winding(q); + let painted = if nonzero { w != 0 } else { w.rem_euclid(2) == 1 }; + if painted != (glyph.winding(q) != 0) { + return false; + } + } + } + } + true +} + +/// The least width of the convex hull of `path` over every direction it could be measured in, its +/// points flattened to within `tol`; 0 when the hull has fewer than three corners and when the +/// path flattens to more than [`MAX_OUTLINE_POINTS`] points. +fn hull_width(path: &BezPath, tol: f64) -> f64 { + let mut pts: Vec = vec![]; + let mut too_many = false; + kurbo::flatten(path.iter(), tol, |el| { + if let PathEl::MoveTo(q) | PathEl::LineTo(q) = el { + if pts.len() >= MAX_OUTLINE_POINTS { + too_many = true; + } else { + pts.push(q); + } + } + }); + if too_many { + return 0.0; + } + pts.sort_by(|a, b| a.x.total_cmp(&b.x).then(a.y.total_cmp(&b.y))); + // Points a thousandth of `tol` apart are one point: their chord has no direction to speak of. + let eps = tol * 1e-3; + pts.dedup_by(|b, a| a.distance(*b) <= eps); + let cross = |o: Point, a: Point, b: Point| (a - o).cross(b - o); + let mut hull: Vec = vec![]; + for pass in 0..2 { + let from = hull.len(); + let ordered: Vec = if pass == 0 { pts.clone() } else { pts.iter().rev().copied().collect() }; + for p in ordered { + while hull.len() >= from + 2 && hull.get(hull.len() - 2).zip(hull.last()).is_some_and(|(a, b)| cross(*a, *b, p) <= 0.0) { + hull.pop(); + } + hull.push(p); + } + hull.pop(); + } + if hull.len() < 3 { + return 0.0; + } + // Rotating calipers: the point farthest from each edge only moves forward from one edge to the + // next, so the whole walk visits each hull point a bounded number of times. + let n = hull.len(); + let mut least = f64::INFINITY; + let mut j = 1; + for (i, a) in hull.iter().enumerate() { + let Some(b) = hull.get((i + 1) % n) else { continue }; + let edge = *b - *a; + let len = edge.hypot(); + if len <= 0.0 || !len.is_finite() { + continue; + } + let away = |k: usize| hull.get(k % n).map_or(0.0, |p| (edge.cross(*p - *a) / len).abs()); + let mut steps = 0; + while steps < n && away(j + 1) >= away(j) { + j += 1; + steps += 1; + } + least = least.min(away(j)); + j %= n; + } + if least.is_finite() { least } else { 0.0 } +} + +/// Does `path` have a contour inside another contour (a counter) whose convex hull is no wider +/// than `width` in some direction? +fn narrow_contour(path: &BezPath, width: f64) -> bool { + if !width.is_finite() || width <= 0.0 { + return false; + } + let mut all: Vec = vec![]; + for el in path.elements() { + if matches!(el, PathEl::MoveTo(_)) { + all.push(BezPath::new()); + } + if let Some(cur) = all.last_mut() { + cur.push(*el); + } + } + all.iter().enumerate().any(|(i, c)| { + let Some(PathEl::MoveTo(at)) = c.elements().first().copied() else { return false }; + all.iter().enumerate().any(|(j, o)| j != i && o.winding(at) != 0) && hull_width(c, width / 30.0) <= width + }) +} + +/// Do `parts` (the runs of contours a compound path `shape` is split into, each already checked +/// by [`RetypeIndex::painted_agrees`] on its own) paint together the area `shape` paints, the +/// shape filled by the nonzero rule when `nonzero` is set and by the even-odd rule otherwise? Each +/// part is read by the same rule, and the glyphs that replace them are set one beside another, so +/// an overlap that the shape's rule cancels would come out painted. Probes lie on both sides of +/// every part's outline, as in [`RetypeIndex::painted_agrees`]; `tolerance` is the one the parts +/// were found with (0 for exact matches). `false` when an outline is too large to probe, and when +/// two parts' boxes overlap in a strip no wider than `3 tol`, which the probes cannot see into. +pub fn parts_paint_alike(shape: &BezPath, parts: &[BezPath], nonzero: bool, tolerance: f64) -> bool { + let bb = shape.bounding_box(); + let tol = bb.width().hypot(bb.height()) * 0.5 * OUTLINE_TOLERANCE.max(3.0 * tolerance.clamp(0.0, MAX_TOLERANCE)); + let painted = |p: &BezPath, q: Point| { + let w = p.winding(q); + if nonzero { w != 0 } else { w.rem_euclid(2) == 1 } + }; + let mut flats = vec![]; + for p in parts.iter().chain(std::iter::once(shape)) { + let Some(f) = Flat::new(p, tol) else { return false }; + flats.push(f); + } + // Two parts whose boxes overlap in a strip too thin to probe cannot be told from parts that + // overlap in their paint. + let boxes: Vec = parts.iter().map(Shape::bounding_box).collect(); + for (i, a) in boxes.iter().enumerate() { + for b in boxes.iter().skip(i + 1) { + let both = a.intersect(*b); + if both.area() > 0.0 && both.width().min(both.height()) <= 3.0 * tol { + return false; + } + } + } + for own in flats.iter().take(parts.len()) { + let step = own.segs.len().div_ceil(MAX_FILL_PROBES).max(1); + for (s, e) in own.segs.iter().step_by(step) { + let d = *e - *s; + let len = d.hypot(); + if len <= 0.0 || !len.is_finite() { + continue; + } + let mid = s.midpoint(*e); + for reach in [1.5, 3.0] { + let side = kurbo::Vec2::new(-d.y, d.x) * (reach * tol / len); + for q in [mid + side, mid - side] { + if flats.iter().any(|f| f.near(q)) { + continue; + } + if painted(shape, q) != parts.iter().any(|o| painted(o, q)) { + return false; + } + } + } + } + } + true +} + /// Do outlines `a` and `b` (in one space) lie on each other: every point of each, flattened, within /// `tol` of the other? `false` when either is too large to check. #[cfg(test)] @@ -580,6 +1443,11 @@ fn contours(path: &BezPath) -> Option>> { /// each of its contours has, in order, as [`contours`] reads them, hashed. Glyphs whose key no /// selected shape has are not sampled. `None` past the size caps or for an empty shape. pub fn shape_key(path: &BezPath) -> Option { + key_and_count(path).map(|(k, _)| k) +} + +/// [`shape_key`] and the number of contours it counts. +fn key_and_count(path: &BezPath) -> Option<(u64, usize)> { let cs = contours(path)?; if cs.is_empty() { return None; @@ -592,32 +1460,14 @@ pub fn shape_key(path: &BezPath) -> Option { h = h.wrapping_mul(0x0000_0100_0000_01b3); } } - Some(h) + Some((h, cs.len())) } /// `path` read for matching: one reading per choice of starting corners (the corner of each contour /// farthest from the centre of all the shape's corners; every tied corner when `all_ties`, else the /// first), at most [`MAX_VARIANTS`] tried. Empty for a shape with nothing to match. fn signatures(path: &BezPath, all_ties: bool) -> Vec { - let bounds = path.bounding_box(); - let size = bounds.width().hypot(bounds.height()); - if !size.is_finite() || size <= 0.0 { - return vec![]; - } - let accuracy = size * 1e-6; - let Some(cs) = contours(path) else { return vec![] }; - // Each contour with length, with its segments' lengths. - let cs: Vec<(Vec, Vec)> = cs - .into_iter() - .map(|c| { - let lens: Vec = c.iter().map(|s| s.arclen(accuracy)).collect(); - (c, lens) - }) - .filter(|(_, lens)| { - let len: f64 = lens.iter().sum(); - len.is_finite() && len > size * 1e-9 - }) - .collect(); + let Some((cs, size, accuracy)) = measured(path) else { return vec![] }; let corners: Vec = cs.iter().flat_map(|(c, _)| c.iter().map(|s| s.start())).collect(); if corners.is_empty() { return vec![]; @@ -644,7 +1494,7 @@ fn signatures(path: &BezPath, all_ties: bool) -> Vec { break; } tried += 1; - if let Some(sig) = sample(&cs, &starts, &pick, accuracy) { + if let Some(sig) = sample(&cs, &starts, &pick, accuracy, SAMPLES) { out.push(sig); } // The next choice of tied corners (a counter in mixed radix). @@ -662,19 +1512,47 @@ fn signatures(path: &BezPath, all_ties: bool) -> Vec { out } -/// One reading of the contours `cs`, contour `i` starting at segment `starts[i][pick[i]]`. -fn sample(cs: &[(Vec, Vec)], starts: &[Vec], pick: &[usize], accuracy: f64) -> Option { - let mut pts = Vec::with_capacity(cs.len() * SAMPLES); +/// `path`'s contours as [`contours`] reads them, each with its segments' lengths, leaving out +/// contours of no length, the shape's size (its bounding box's diagonal) and the accuracy lengths +/// are measured to (a millionth of the size). `None` past the size caps and for a shape of no size. +#[allow(clippy::type_complexity)] +fn measured(path: &BezPath) -> Option<(Vec<(Vec, Vec)>, f64, f64)> { + let bounds = path.bounding_box(); + let size = bounds.width().hypot(bounds.height()); + if !size.is_finite() || size <= 0.0 { + return None; + } + let accuracy = size * 1e-6; + let cs = contours(path)? + .into_iter() + .map(|c| { + let lens: Vec = c.iter().map(|s| s.arclen(accuracy)).collect(); + (c, lens) + }) + .filter(|(_, lens)| { + let len: f64 = lens.iter().sum(); + len.is_finite() && len > size * 1e-9 + }) + .collect(); + Some((cs, size, accuracy)) +} + +/// One reading of the contours `cs`, contour `i` starting at segment `starts[i][pick[i]]`, `n` +/// points along each. +fn sample(cs: &[(Vec, Vec)], starts: &[Vec], pick: &[usize], accuracy: f64, n: usize) -> Option { + let mut pts = Vec::with_capacity(cs.len() * n); + let mut lens_out = Vec::with_capacity(cs.len()); let mut total = 0.0; for (((c, lens), s), p) in cs.iter().zip(starts).zip(pick) { let from = *s.get(*p)?; let m = c.len(); let len: f64 = lens.iter().sum(); total += len; + lens_out.push(len); let (mut k, mut before) = (0usize, 0.0); let at_k = |k: usize| (from + k) % m; - for j in 0..SAMPLES { - let at = len * j as f64 / SAMPLES as f64; + for j in 0..n { + let at = len * j as f64 / n as f64; while k + 1 < m && before + lens.get(at_k(k)).copied().unwrap_or(0.0) < at { before += lens.get(at_k(k)).copied().unwrap_or(0.0); k += 1; @@ -696,7 +1574,7 @@ fn sample(cs: &[(Vec, Vec)], starts: &[Vec], pick: &[usize] if !spread.is_finite() || spread <= 0.0 || !total.is_finite() || total <= 0.0 { return None; } - Some(Signature { contours: cs.len(), pts, centre, spread, invariant: spread / total }) + Some(Signature { contours: cs.len(), pts, centre, spread, invariant: spread / total, lens: lens_out }) } /// The first reading of `path` (for tests). @@ -899,6 +1777,500 @@ mod tests { assert!(t0.elapsed() < std::time::Duration::from_secs(5), "{:?}", t0.elapsed()); } + /// `p` flattened into lines `tol` from its curves, each contour started at its second point and + /// run backwards: a simplified outline built nothing like the original. + fn simplified(p: &BezPath, tol: f64) -> BezPath { + let mut contours: Vec> = vec![]; + kurbo::flatten(p.iter(), tol, |el| match el { + PathEl::MoveTo(q) => contours.push(vec![q]), + PathEl::LineTo(q) => { + if let Some(c) = contours.last_mut() { + c.push(q); + } + } + _ => {} + }); + let mut out = BezPath::new(); + for mut c in contours { + c.rotate_left(1); + c.reverse(); + out.move_to(c[0]); + for q in &c[1..] { + out.line_to(*q); + } + out.close_path(); + } + out + } + + fn near_residual(glyph: &BezPath, shape: &BezPath) -> f64 { + near_fit_all(&signature(glyph).unwrap(), &near_signature(shape).unwrap()).map_or(f64::INFINITY, |(_, r)| r) + } + + /// [`near_fit`]'s first fit, with no limit on its work. + fn near_fit_all(g: &Signature, s: &Signature) -> Option<((f64, f64), f64)> { + let mut work = u64::MAX; + near_fit(g, s, MAX_TOLERANCE, &mut work).into_iter().next() + } + + /// [`fits_within`]'s first fit. + fn nearest_upright(results: Vec<((f64, f64), f64)>, limit: f64) -> Option<((f64, f64), f64)> { + fits_within(results, limit).into_iter().next() + } + + #[test] + fn a_simplified_outline_near_matches_and_another_shape_does_not() { + let xf = Affine::translate((300.0, 200.0)) * Affine::rotate(0.4) * Affine::scale(0.024); + let shape = xf * simplified(&letter(), 2.0); + assert_ne!(shape_key(&shape), shape_key(&letter()), "built another way: the exact index never samples it"); + assert!(best_fit(&letter(), &shape) > TOLERANCE, "no exact match"); + let r = near_residual(&letter(), &shape); + assert!(r < 0.005, "near match {r}"); + let (z, _) = near_fit_all(&signature(&letter()).unwrap(), &near_signature(&shape).unwrap()).unwrap(); + // With too little work left, no fit, and nothing left after. + let mut work = 1000; + assert!(near_fit(&signature(&letter()).unwrap(), &near_signature(&shape).unwrap(), MAX_TOLERANCE, &mut work).is_empty()); + assert_eq!(work, 0); + assert!((z.0.hypot(z.1) - 0.024).abs() < 0.024 * 0.01 && (z.1.atan2(z.0) - 0.4).abs() < 0.01, "{z:?}"); + let (a, b) = (near_key(&letter()).unwrap(), near_key(&shape).unwrap()); + assert!(a.close_to(&b), "{a:?} {b:?}"); + // The exact reading of the letter itself near matches it too, with next to nothing left over. + assert!(near_residual(&letter(), &letter()) < 1e-3); + // A box is not near a circle. + let mut o = BezPath::new(); + o.extend(kurbo::Circle::new((200.0, -350.0), 300.0).path_elements(0.1)); + let mut box_ = BezPath::new(); + box_.extend(kurbo::Rect::new(0.0, -700.0, 600.0, 0.0).path_elements(0.1)); + assert!(near_residual(&o, &box_) > MAX_TOLERANCE); + assert!(!near_key(&o).unwrap().close_to(&near_key(&box_).unwrap())); + } + + #[test] + fn a_turned_round_glyph_near_matches_upright() { + // A circle fits at every turn: the turn kept is the upright one. + let mut o = BezPath::new(); + o.extend(kurbo::Circle::new((0.0, 0.0), 300.0).path_elements(0.1)); + let (z, r) = near_fit_all(&signature(&o).unwrap(), &near_signature(&simplified(&o, 1.0)).unwrap()).unwrap(); + assert!(r < 0.005, "{r}"); + assert!(z.1.atan2(z.0).abs() < 0.06, "{z:?}"); + } + + #[test] + fn the_upright_turn_is_kept_only_within_the_limit() { + let turned = |a: f64, r: f64| ((a.cos(), a.sin()), r); + // The best fit is turned a quarter round; an upright one fits nearly as well. + let fits = || vec![turned(std::f64::consts::FRAC_PI_2, 0.010), turned(0.0, 0.014)]; + let angle = |f: Option<((f64, f64), f64)>| f.map(|((c, s), _)| s.atan2(c)); + assert_eq!(angle(nearest_upright(fits(), 0.02)), Some(0.0), "both within the limit: the upright one"); + let kept = nearest_upright(fits(), 0.012).unwrap(); + assert!((kept.1 - 0.010).abs() < 1e-12, "only the best is within the limit: the best {kept:?}"); + let kept = nearest_upright(fits(), 0.005).unwrap(); + assert!((kept.1 - 0.010).abs() < 1e-12, "none within the limit: the best {kept:?}"); + assert!(nearest_upright(vec![], 0.05).is_none()); + // Every turn within the limit is kept, upright first, once each. + let all = fits_within( + vec![turned(std::f64::consts::PI, 0.011), turned(std::f64::consts::FRAC_PI_2, 0.010), turned(0.0, 0.014), turned(1e-4, 0.0141)], + 0.02, + ); + let angles: Vec = all.iter().map(|((c, s), _)| s.atan2(*c)).collect(); + assert_eq!(angles.len(), 3, "{angles:?}"); + assert!(angles[0] == 0.0 && (angles[1] - std::f64::consts::FRAC_PI_2).abs() < 1e-12, "{angles:?}"); + } + + #[test] + fn a_curve_split_in_two_still_near_matches() { + // letter() with its cubic split at its middle: exactly another shape, nearly the same. + let (a, b) = kurbo::CubicBez::new((0.0, -700.0), (300.0, -700.0), (450.0, -600.0), (450.0, -480.0)).subdivide(); + let mut p = BezPath::new(); + p.move_to((0.0, 0.0)); + p.line_to((0.0, -700.0)); + p.curve_to(a.p1, a.p2, a.p3); + p.curve_to(b.p1, b.p2, b.p3); + p.quad_to((450.0, -300.0), (120.0, -300.0)); + p.line_to((120.0, 0.0)); + p.close_path(); + p.move_to((120.0, -600.0)); + p.line_to((120.0, -400.0)); + p.quad_to((330.0, -400.0), (330.0, -500.0)); + p.quad_to((330.0, -600.0), (120.0, -600.0)); + p.close_path(); + assert_ne!(shape_key(&p), shape_key(&letter())); + let shape = Affine::translate((40.0, 90.0)) * Affine::scale(0.03) * p; + assert!(near_residual(&letter(), &shape) < 0.005); + } + + #[test] + fn contours_in_another_order_still_near_match() { + // letter() with its counter first, simplified. + let l = letter(); + let els = l.elements(); + let second = els.iter().rposition(|e| matches!(e, PathEl::MoveTo(_))).unwrap(); + let mut back = BezPath::new(); + back.extend(els[second..].iter().copied()); + back.extend(els[..second].iter().copied()); + let shape = Affine::translate((40.0, 90.0)) * Affine::rotate(0.3) * Affine::scale(0.03) * simplified(&back, 2.0); + assert!(near_residual(&letter(), &shape) < 0.005); + } + + #[test] + fn copies_of_a_font_do_not_crowd_out_the_faces_after_them() { + use crate::test_fonts::{HEIGHT_FAMILY, HEIGHT_OUTSIDE_FAMILY, HEIGHTLESS_FAMILY, NUMBERLESS_FAMILY}; + // Source Sans 3 Regular and four copies of it under other names: each face has several + // glyphs drawn as the period (. · ∙ ․), more than MAX_CANDIDATES in all. + let db = FontDb::with_font_dirs(vec![]); + for bytes in [ + crate::test_fonts::height_font(true), + crate::test_fonts::height_font(false), + crate::test_fonts::height_outside_font(), + crate::test_fonts::numberless_font(), + ] { + db.add_font(bytes.unwrap()); + } + let faces: Vec> = ["Source Sans 3", HEIGHT_FAMILY, HEIGHTLESS_FAMILY, HEIGHT_OUTSIDE_FAMILY, NUMBERLESS_FAMILY] + .iter() + .map(|f| db.face(f, "Regular").unwrap()) + .collect(); + let gid = faces[0].mapped_chars().iter().find(|(c, _)| *c == '.').map(|(_, g)| *g).unwrap(); + let period = Affine::translate((100.0, 200.0)) * Affine::scale(0.04) * db.outline_uncached(&faces[0], gid); + let has_every_period = |found: &[GlyphMatch]| faces.iter().all(|f| found.iter().any(|m| m.ch == '.' && m.face.id() == f.id())); + let keys: BTreeSet = shape_key(&period).into_iter().collect(); + let index = RetypeIndex::build(&db, faces.clone(), &keys); + // The parts of a split compound path are looked up in every face, as whole shapes are. + let found = index.matches_either_way(&period); + assert!(found.len() > MAX_CANDIDATES && has_every_period(&found), "exact: {} matches", found.len()); + let simple = simplified(&period, 0.05); + let index = RetypeIndex::build_near(&db, faces.clone(), &BTreeSet::new(), &[near_key(&simple).unwrap()]); + let found = index.near_matches(&simple, 0.02); + assert!(found.len() > MAX_CANDIDATES && has_every_period(&found), "near: {} matches", found.len()); + } + + #[test] + fn a_face_past_its_near_share_keeps_the_glyphs_closest_to_the_shapes() { + // One glyph of the face is indexed for near matching: the one closest to a simplified o, + // whatever comes before the o in glyph order. + let db = FontDb::global(); + let face = db.face("Source Sans 3", "Regular").unwrap(); + let gid = face.mapped_chars().iter().find(|(c, _)| *c == 'o').map(|(_, g)| *g).unwrap(); + let shape = Affine::translate((100.0, 200.0)) * Affine::scale(0.04) * simplified(&db.outline_uncached(&face, gid), 4.0); + let key = near_key(&shape).unwrap(); + let index = RetypeIndex::build_near_within(db, [face], &BTreeSet::new(), &[key], 1); + assert_eq!(index.len(), 1); + let found: Vec = index.near_matches(&shape, 0.02).iter().map(|m| m.ch).collect(); + // The Latin o or the Greek omicron, drawn the same. + assert!(found.iter().any(|c| matches!(c, 'o' | 'ο')), "{found:?}"); + } + + /// `p` with its first curve split in two at its middle: the same outline with another key. + fn first_curve_split(p: &BezPath) -> BezPath { + let mut out = BezPath::new(); + let (mut last, mut done) = (Point::ZERO, false); + for el in p.elements() { + match *el { + PathEl::CurveTo(a, b, c) if !done => { + let (x, y) = kurbo::CubicBez::new(last, a, b, c).subdivide(); + out.curve_to(x.p1, x.p2, x.p3); + out.curve_to(y.p1, y.p2, y.p3); + done = true; + last = c; + } + PathEl::QuadTo(a, c) if !done => { + let (x, y) = kurbo::QuadBez::new(last, a, c).subdivide(); + out.quad_to(x.p1, x.p2); + out.quad_to(y.p1, y.p2); + done = true; + last = c; + } + e => { + out.push(e); + if let PathEl::MoveTo(q) | PathEl::LineTo(q) | PathEl::QuadTo(_, q) | PathEl::CurveTo(_, _, q) = e { + last = q; + } + } + } + } + out + } + + #[test] + fn a_glyph_indexed_only_for_near_matching_is_no_exact_match() { + let db = FontDb::global(); + let face = db.face("Source Sans 3", "Regular").unwrap(); + let gid = face.mapped_chars().iter().find(|(c, _)| *c == 'o').map(|(_, g)| *g).unwrap(); + let split = first_curve_split(&db.outline_uncached(&face, gid)); + let shape = Affine::translate((100.0, 200.0)) * Affine::scale(0.04) * split; + assert_ne!(shape_key(&shape), shape_key(&(Affine::scale(0.04) * db.outline_uncached(&face, gid))), "another key"); + let keys: BTreeSet = shape_key(&shape).into_iter().collect(); + let index = RetypeIndex::build_near(db, [face], &keys, &[near_key(&shape).unwrap()]); + assert!(index.all_matches(&shape).is_empty(), "exact matching sees only the glyphs of the exact keys"); + assert!(index.matches_either_way(&shape).is_empty()); + assert!(index.near_matches(&shape, 0.02).iter().any(|m| m.ch == 'o')); + } + + #[test] + fn each_pose_of_a_match_reports_its_own_residual() { + let db = FontDb::global(); + let face = db.face("Source Sans 3", "Regular").unwrap(); + let turn = std::f64::consts::FRAC_PI_2; + let m = GlyphMatch { + face, + gid: 1, + ch: 'o', + scale: 1.0, + angle: 0.0, + origin: Point::ZERO, + residual: 0.010, + exact: false, + contours: 1, + alts: vec![Pose { scale: 1.0, angle: turn, origin: Point::ZERO }], + alt_residuals: vec![0.010], + pose_residual: 0.014, + }; + let seen: Vec<(f64, f64)> = m.poses().map(|p| (p.angle, p.residual)).collect(); + assert_eq!(seen, vec![(0.0, 0.014), (turn, 0.010)]); + } + + #[test] + fn a_ring_whose_contours_run_one_way_paints_no_hole() { + let db = FontDb::global(); + let face = db.face("Source Sans 3", "Regular").unwrap(); + let gid = face.mapped_chars().iter().find(|(c, _)| *c == 'o').map(|(_, g)| *g).unwrap(); + let ring = db.outline_uncached(&face, gid); + let els = ring.elements(); + let second = els.iter().rposition(|e| matches!(e, PathEl::MoveTo(_))).unwrap(); + let (mut outer, mut inner) = (BezPath::new(), BezPath::new()); + outer.extend(els[..second].iter().copied()); + inner.extend(els[second..].iter().copied()); + let mut same_way = outer.clone(); + same_way.extend(inner.reverse_subpaths().iter()); + let (ring, same_way) = + (Affine::translate((100.0, 200.0)) * Affine::scale(0.04) * ring, Affine::translate((100.0, 200.0)) * Affine::scale(0.04) * same_way); + let keys: BTreeSet = shape_key(&ring).into_iter().collect(); + let index = RetypeIndex::build_near(db, [face], &keys, &[near_key(&same_way).unwrap()]); + // Near matching reads each contour in either direction, so the outline matches the glyph's: + // only what it paints tells them apart. + let found = index.near_matches(&same_way, 0.02); + assert!(found.iter().any(|m| m.ch == 'o'), "the outline matches"); + assert!(found.iter().all(|m| index.painted_agrees(m, &same_way, true, 0.02).is_none()), "nonzero paints the counter"); + assert!(found.iter().any(|m| index.painted_agrees(m, &same_way, false, 0.02).is_some()), "even-odd leaves it empty"); + let found = index.all_matches(&ring); + assert!(found.iter().any(|m| index.painted_agrees(m, &ring, true, 0.0).is_some()), "the glyph's own windings paint a ring"); + } + + #[test] + fn a_counter_too_narrow_to_probe_does_not_count_as_agreeing() { + let square = |x0: f64, y0: f64, x1: f64, y1: f64, back: bool| { + let p = kurbo::Rect::new(x0, y0, x1, y1).to_path(0.1); + if back { p.reverse_subpaths() } else { p } + }; + // A 100 by 100 square with a 10 by 10 counter: the shape's counter runs the way its outer + // contour does (filled by the nonzero rule), the glyph's runs the other way (a hole). + let mut filled = square(0.0, 0.0, 100.0, 100.0, false); + filled.extend(square(45.0, 45.0, 55.0, 55.0, false).iter()); + let mut holed = square(0.0, 0.0, 100.0, 100.0, false); + holed.extend(square(45.0, 45.0, 55.0, 55.0, true).iter()); + let tol = 100.0_f64.hypot(100.0) * 0.5 * 3.0 * MAX_TOLERANCE; + assert!(!paints_alike(&filled, true, &holed, tol), "no probe can see the counter"); + // A counter wide enough to probe is told apart as before. + let mut wide = square(0.0, 0.0, 100.0, 100.0, false); + wide.extend(square(10.0, 10.0, 90.0, 90.0, false).iter()); + let mut wide_hole = square(0.0, 0.0, 100.0, 100.0, false); + wide_hole.extend(square(10.0, 10.0, 90.0, 90.0, true).iter()); + assert!(!paints_alike(&wide, true, &wide_hole, 1.0)); + assert!(paints_alike(&wide_hole, true, &wide_hole, 1.0)); + } + + #[test] + fn a_counter_turned_too_narrow_to_probe_does_not_count_as_agreeing() { + let square = |x0: f64, y0: f64, x1: f64, y1: f64, back: bool| { + let p = kurbo::Rect::new(x0, y0, x1, y1).to_path(0.1); + if back { p.reverse_subpaths() } else { p } + }; + // A 60 by 10 counter turned 45 degrees: its box is about 49.5 square, wider than the + // threshold of about 31.8, but it is 10 across. + let strip = |back: bool| { + let turn = Affine::translate((50.0, 50.0)) * Affine::rotate(std::f64::consts::FRAC_PI_4); + let mut p = kurbo::Rect::new(-30.0, -5.0, 30.0, 5.0).to_path(0.1); + if back { + p = p.reverse_subpaths(); + } + turn * p + }; + let mut filled = square(0.0, 0.0, 100.0, 100.0, false); + filled.extend(strip(false).iter()); + let mut holed = square(0.0, 0.0, 100.0, 100.0, false); + holed.extend(strip(true).iter()); + let tol = 100.0_f64.hypot(100.0) * 0.5 * 3.0 * MAX_TOLERANCE; + assert!(narrow_contour(&filled, 3.0 * tol)); + assert!(!paints_alike(&filled, true, &holed, tol)); + // The same strip with its sides along the axes is told apart as before. + let mut level = square(0.0, 0.0, 100.0, 100.0, false); + level.extend(square(20.0, 45.0, 80.0, 55.0, false).iter()); + assert!(narrow_contour(&level, 3.0 * tol)); + // A counter wider than the threshold in every direction is not narrow. + let mut wide = square(0.0, 0.0, 100.0, 100.0, false); + wide.extend(square(10.0, 10.0, 90.0, 90.0, false).iter()); + assert!(!narrow_contour(&wide, 3.0 * tol)); + } + + #[test] + fn a_contour_reaching_outside_a_concave_one_is_no_counter_of_it() { + // An L, and a triangle that starts inside the L and inside its box but reaches outside it. + let mut l = BezPath::new(); + for (i, (x, y)) in [(0.0, 0.0), (100.0, 0.0), (100.0, 20.0), (20.0, 20.0), (20.0, 100.0), (0.0, 100.0)].into_iter().enumerate() { + if i == 0 { l.move_to((x, y)) } else { l.line_to((x, y)) } + } + l.close_path(); + let mut tri = BezPath::new(); + tri.move_to((5.0, 5.0)); + tri.line_to((90.0, 90.0)); + tri.line_to((5.0, 50.0)); + tri.close_path(); + let mut both = l.clone(); + both.extend(tri.iter()); + assert_eq!(clusters(&both).len(), 2); + // A contour wholly inside stays with its container. + let mut inside = l.clone(); + inside.extend(kurbo::Rect::new(5.0, 5.0, 15.0, 15.0).to_path(0.1).iter()); + assert_eq!(clusters(&inside).len(), 1); + } + + #[test] + fn the_hull_width_is_the_least_width_in_any_direction() { + let strip = kurbo::Rect::new(-30.0, -5.0, 30.0, 5.0).to_path(0.1); + for deg in [0.0_f64, 17.0, 45.0, 90.0, 133.0] { + let w = hull_width(&(Affine::rotate(deg.to_radians()) * strip.clone()), 0.01); + assert!((w - 10.0).abs() < 0.05, "{deg} degrees: {w}"); + } + let circle = kurbo::Circle::new((5.0, 7.0), 50.0).to_path(0.1); + assert!((hull_width(&circle, 0.01) - 100.0).abs() < 0.5, "{}", hull_width(&circle, 0.01)); + // A triangle's least width is its shortest height. + let mut tri = BezPath::new(); + tri.move_to((0.0, 0.0)); + tri.line_to((40.0, 0.0)); + tri.line_to((0.0, 30.0)); + tri.close_path(); + assert!((hull_width(&tri, 0.01) - 24.0).abs() < 1e-9); + assert_eq!(hull_width(&BezPath::new(), 0.01), 0.0); + } + + #[test] + fn an_outline_too_large_to_probe_does_not_count_as_agreeing() { + let n = MAX_OUTLINE_POINTS + 64; + let mut many = BezPath::new(); + for i in 0..n { + let a = std::f64::consts::TAU * i as f64 / n as f64; + let p = Point::new(50.0 + 50.0 * a.cos(), 50.0 + 50.0 * a.sin()); + if i == 0 { many.move_to(p) } else { many.line_to(p) } + } + many.close_path(); + assert!(Flat::new(&many, 0.5).is_none(), "too many segments to flatten"); + assert!(!paints_alike(&many, true, &many, 0.5)); + assert!(paints_alike(&kurbo::Circle::new((50.0, 50.0), 50.0).to_path(0.1), true, &kurbo::Circle::new((50.0, 50.0), 50.0).to_path(0.1), 0.5)); + } + + #[test] + fn parts_that_overlap_under_the_even_odd_rule_do_not_paint_the_shape() { + let square = |x0: f64, y0: f64, x1: f64, y1: f64| kurbo::Rect::new(x0, y0, x1, y1).to_path(0.1); + let (a, b) = (square(0.0, 0.0, 60.0, 60.0), square(40.0, 0.0, 100.0, 60.0)); + let mut both = a.clone(); + both.extend(b.iter()); + assert!(!parts_paint_alike(&both, &[a.clone(), b.clone()], false, 0.0), "the overlap is a hole in the shape"); + assert!(parts_paint_alike(&both, &[a.clone(), b.clone()], true, 0.0), "the nonzero rule paints it"); + // Windings that cancel under the nonzero rule leave the overlap unpainted too. + let mut turned = a.clone(); + turned.extend(b.reverse_subpaths().iter()); + assert!(!parts_paint_alike(&turned, &[a.clone(), b.reverse_subpaths()], true, 0.0)); + // An overlap too thin for the probes to land in is not taken for none. + let thin = square(59.9, 0.0, 100.0, 60.0); + let mut strip = a.clone(); + strip.extend(thin.iter()); + assert!(!parts_paint_alike(&strip, &[a.clone(), thin], false, 0.0)); + let apart = square(80.0, 0.0, 140.0, 60.0); + let mut aside = a.clone(); + aside.extend(apart.iter()); + assert!(parts_paint_alike(&aside, &[a, apart], false, 0.0)); + } + + #[test] + fn near_matching_with_no_work_left_returns_nothing() { + let db = FontDb::global(); + let face = db.face("Source Sans 3", "Regular").unwrap(); + let gid = face.mapped_chars().iter().find(|(c, _)| *c == 'o').map(|(_, g)| *g).unwrap(); + let shape = Affine::translate((100.0, 200.0)) * Affine::scale(0.04) * simplified(&db.outline_uncached(&face, gid), 4.0); + let index = RetypeIndex::build_near(db, [face], &BTreeSet::new(), &[near_key(&shape).unwrap()]); + assert!(!index.near_matches(&shape, 0.02).is_empty()); + let after = index.near_work.load(Ordering::Acquire); + assert!((NEAR_WORK - NEAR_SHAPE_WORK..NEAR_WORK).contains(&after), "one allowance at most: {after}"); + index.near_work.store(0, Ordering::Release); + assert!(index.near_matches(&shape, 0.02).is_empty()); + assert_eq!(index.near_work.load(Ordering::Acquire), 0); + } + + #[test] + fn ranking_near_match_candidates_takes_from_the_work_budget() { + let db = FontDb::global(); + let face = db.face("Source Sans 3", "Regular").unwrap(); + let gid = face.mapped_chars().iter().find(|(c, _)| *c == 'o').map(|(_, g)| *g).unwrap(); + let shape = Affine::translate((100.0, 200.0)) * Affine::scale(0.04) * simplified(&db.outline_uncached(&face, gid), 4.0); + let index = RetypeIndex::build_near(db, [face], &BTreeSet::new(), &[near_key(&shape).unwrap()]); + let s = near_signature(&shape).unwrap(); + let mut all = u64::MAX; + let ranked = index.ranked_near(&s, &mut all).len(); + assert!(ranked >= 1, "the o is ranked"); + assert_eq!(u64::MAX - all, ranked as u64 * 3, "each glyph of two contours takes three"); + // Enough to rank one glyph of two contours and nothing more. + let mut work = 4; + assert_eq!(index.ranked_near(&s, &mut work).len(), 1); + assert_eq!(work, 1); + } + + #[test] + fn a_round_glyph_with_an_off_centre_counter_near_matches_at_its_turn() { + // A round outer contour fits the shape at every turn; only the counter, off the centre, + // tells the turn, which is far from upright. + let polygon = |cx: f64, cy: f64, r: f64, n: usize, back: bool| { + let mut p = BezPath::new(); + for i in 0..n { + let a = std::f64::consts::TAU * i as f64 / n as f64 * if back { -1.0 } else { 1.0 }; + let q = Point::new(cx + r * a.cos(), cy + r * a.sin()); + if i == 0 { p.move_to(q) } else { p.line_to(q) } + } + p.close_path(); + p + }; + // The outer contour has 720 corners: as round as the samples can tell. + let mut g = polygon(0.0, 0.0, 300.0, 720, false); + g.extend(polygon(120.0, 40.0, 80.0, 24, true).iter()); + let xf = Affine::translate((500.0, 400.0)) * Affine::rotate(2.0) * Affine::scale(0.05); + let shape = xf * simplified(&g, 1.0); + let (z, r) = near_fit_all(&signature(&g).unwrap(), &near_signature(&shape).unwrap()).unwrap(); + assert!(r < 0.01, "{r}"); + assert!(wrapped(z.1.atan2(z.0) - 2.0).abs() < 0.02, "{z:?}"); + } + + #[test] + fn clusters_split_a_word_into_its_glyph_parts() { + let mut word = letter(); + word.extend((Affine::translate((600.0, 0.0)) * letter()).iter()); + // An i: a stem and a dot beside it. + word.extend(kurbo::Rect::new(1200.0, -500.0, 1260.0, 0.0).path_elements(0.1)); + word.extend(kurbo::Circle::new((1230.0, -600.0), 40.0).path_elements(0.1)); + let parts = clusters(&word); + assert_eq!(parts.len(), 4, "two letters (each with its counter), a stem and a dot"); + assert_eq!(shape_key(&parts[0]), shape_key(&letter())); + assert_eq!(shape_key(&parts[1]), shape_key(&letter())); + assert_eq!(parts[2].elements().iter().filter(|e| matches!(e, PathEl::MoveTo(_))).count(), 1); + // A counter written before its outer contour still goes with it, in the outer's place. + let mut back = BezPath::new(); + let l = letter(); + let els = l.elements(); + let second = els.iter().rposition(|e| matches!(e, PathEl::MoveTo(_))).unwrap(); + back.extend(els[second..].iter().copied()); + back.extend(els[..second].iter().copied()); + assert_eq!(clusters(&back).len(), 1); + assert!(clusters(&BezPath::new()).is_empty()); + } + #[test] fn the_same_corners_joined_another_way_are_another_outline() { let poly = |pts: &[(f64, f64)]| { diff --git a/crates/text/src/test_fonts.rs b/crates/text/src/test_fonts.rs index 7a2a23f089..1ba4fe3f99 100644 --- a/crates/text/src/test_fonts.rs +++ b/crates/text/src/test_fonts.rs @@ -45,6 +45,136 @@ pub fn drop_kept_layouts() { crate::kept::drop_kept_layouts(); } +/// Who holds [`SteadyFonts`] and who changes fonts ([`font_change`]), guarded by [`steadiness`] and +/// signaled through [`STEADINESS_CHANGED`]. +struct Steadiness { + /// Threads that hold a [`SteadyFonts`]. + holders: usize, + /// Font changes waiting to start. + waiting: usize, + /// Of `waiting`, those made on a thread that holds a [`SteadyFonts`]. + holders_waiting: usize, + /// Whether a font change is under way. + changing: bool, +} + +static STEADINESS: std::sync::Mutex = std::sync::Mutex::new(Steadiness { holders: 0, waiting: 0, holders_waiting: 0, changing: false }); +static STEADINESS_CHANGED: std::sync::Condvar = std::sync::Condvar::new(); + +fn steadiness() -> std::sync::MutexGuard<'static, Steadiness> { + STEADINESS.lock().unwrap_or_else(std::sync::PoisonError::into_inner) +} + +/// Wait for [`STEADINESS_CHANGED`]. +fn await_steadiness(s: std::sync::MutexGuard<'static, Steadiness>) -> std::sync::MutexGuard<'static, Steadiness> { + STEADINESS_CHANGED.wait(s).unwrap_or_else(std::sync::PoisonError::into_inner) +} + +std::thread_local! { + /// How many [`SteadyFonts`] this thread holds. + static STEADY: std::cell::Cell = const { std::cell::Cell::new(0) }; + /// Whether this thread holds the [`FontChange`] under way. + static CHANGING: std::cell::Cell = const { std::cell::Cell::new(false) }; +} + +/// While held, a cataloged font database's fonts and its +/// [`FontDb::generation`](crate::FontDb::generation) change only on this thread: a change on another +/// thread (a system font loaded for a character no loaded font covers, fonts added, a rescan, a +/// composite font set or removed) waits until it is dropped, before it publishes anything. A change +/// on this thread waits until no other thread holds one, unless every other thread that holds one is +/// itself waiting to change fonts. Tests hold it to count the layouts that a cache keyed on the +/// generation keeps. The guards one thread holds count as one, until the last of them is dropped, in +/// whatever order they are. +pub struct SteadyFonts { + /// Dropped on the thread that made it. + _thread: std::marker::PhantomData<*const ()>, +} + +impl Drop for SteadyFonts { + fn drop(&mut self) { + let last = STEADY.with(|n| { + n.set(n.get() - 1); + n.get() == 0 + }); + if last { + steadiness().holders -= 1; + STEADINESS_CHANGED.notify_all(); + } + } +} + +/// [`SteadyFonts`] for `db`. Catalogs `db`'s installed fonts first: a first scan does not wait for +/// any guard, so this thread can wait for one running on another thread while it holds a guard. A +/// thread's first guard waits for the font changes under way or waiting. +pub fn steady_fonts(db: &crate::FontDb) -> SteadyFonts { + db.ensure_catalog(); + if STEADY.with(std::cell::Cell::get) == 0 { + let mut s = steadiness(); + while !CHANGING.with(std::cell::Cell::get) && (s.changing || s.waiting > 0) { + s = await_steadiness(s); + } + s.holders += 1; + } + STEADY.with(|n| n.set(n.get() + 1)); + SteadyFonts { _thread: std::marker::PhantomData } +} + +/// Held while a font database's fonts change, from before the change is published until its +/// generation has changed ([`font_change`]). +pub(crate) struct FontChange { + /// Made while this thread already held one (a change made inside another, as a test hook run + /// when faces are published can). + nested: bool, +} + +impl Drop for FontChange { + fn drop(&mut self) { + if !self.nested { + CHANGING.with(|c| c.set(false)); + steadiness().changing = false; + STEADINESS_CHANGED.notify_all(); + } + } +} + +/// [`FontChange`]: waits until no other change is under way and no other thread holds a +/// [`SteadyFonts`] (on a thread that holds one: none that is not itself waiting to change fonts). +/// Inside a change this thread is making, it does not wait. +pub(crate) fn font_change() -> FontChange { + if CHANGING.with(std::cell::Cell::get) { + return FontChange { nested: true }; + } + let holder = STEADY.with(std::cell::Cell::get) > 0; + let mut s = steadiness(); + #[cfg(test)] + font_changers().push(std::thread::current().id()); + s.waiting += 1; + s.holders_waiting += usize::from(holder); + while s.changing || if holder { s.holders > s.holders_waiting } else { s.holders > 0 } { + s = await_steadiness(s); + } + s.waiting -= 1; + s.holders_waiting -= usize::from(holder); + s.changing = true; + CHANGING.with(|c| c.set(true)); + FontChange { nested: false } +} + +/// Whether a font change on another thread would wait now (a [`SteadyFonts`] is held, or another +/// change is under way). +#[cfg(test)] +pub(crate) fn font_changes_held_back() -> bool { + let s = steadiness(); + s.holders > 0 || s.changing +} + +/// The threads that have asked to change a font database's generation ([`font_change`]). +#[cfg(test)] +pub(crate) fn font_changers() -> std::sync::MutexGuard<'static, Vec> { + static CHANGERS: std::sync::Mutex> = std::sync::Mutex::new(Vec::new()); + CHANGERS.lock().unwrap_or_else(std::sync::PoisonError::into_inner) +} + /// The family of [`variable_font`]. pub const VARIABLE_FAMILY: &str = "Varitest Sans"; diff --git a/crates/text/src/tests/combos.rs b/crates/text/src/tests/combos.rs index a2d837e286..aca8d6bbde 100644 --- a/crates/text/src/tests/combos.rs +++ b/crates/text/src/tests/combos.rs @@ -421,26 +421,27 @@ fn composer_x_mixed_sizes_around_text_wrap() { let l = layout(db(), &t); (line_texts(&t, &l), l, t) }; - let (every, l, t) = set(Composer::EveryLine); - assert_eq!( - every, - ["Destroy all creatures with", "toughness\u{a0}X", "or less. Then", "draw a card for", "each creature", "destroyed this", "way."] - ); - assert!(past_their_room(&t, &l).is_empty() && !l.overflow, "{:?}", l.lines); - // Two spans share each baseline beside the object. - assert_eq!(l.lines[1].baseline, l.lines[2].baseline); - assert!(l.lines[1].ascent > 30.0 && l.lines[2].avail.0 > object.x1, "{:?}", l.lines); - let text = t.plain_text(); - let hits = l.glyphs.iter().filter(|g| { - let li = &l.lines[g.line]; - let across = li.baseline - li.ascent < object.y1 && li.baseline + li.descent > object.y0; - across && !text[g.byte..].starts_with(char::is_whitespace) && g.origin.x < object.x1 && g.origin.x + g.advance > object.x0 - }); - assert_eq!(hits.count(), 0, "{:?}", l.lines); // The single-line composer measures each line across its height too, and breaks this - // paragraph the same way. - let (greedy, _, _) = set(Composer::SingleLine); - assert_eq!(every, greedy); + // paragraph the same way, with its lines set clear of the object as well. + for composer in [Composer::EveryLine, Composer::SingleLine] { + let (texts, l, t) = set(composer); + assert_eq!( + texts, + ["Destroy all creatures with", "toughness\u{a0}X", "or less. Then", "draw a card for", "each creature", "destroyed this", "way."], + "{composer:?}" + ); + assert!(past_their_room(&t, &l).is_empty() && !l.overflow, "{composer:?}: {:?}", l.lines); + // Two spans share each baseline beside the object. + assert_eq!(l.lines[1].baseline, l.lines[2].baseline, "{composer:?}"); + assert!(l.lines[1].ascent > 30.0 && l.lines[2].avail.0 > object.x1, "{composer:?}: {:?}", l.lines); + let text = t.plain_text(); + let hits = l.glyphs.iter().filter(|g| { + let li = &l.lines[g.line]; + let across = li.baseline - li.ascent < object.y1 && li.baseline + li.descent > object.y0; + across && !text[g.byte..].starts_with(char::is_whitespace) && g.origin.x < object.x1 && g.origin.x + g.advance > object.x0 + }); + assert_eq!(hits.count(), 0, "{composer:?}: {:?}", l.lines); + } } #[test] @@ -581,23 +582,23 @@ fn composer_x_mixed_sizes_overflow_around_text_wrap() { let l = layout(db(), &t); (line_texts(&t, &l), l, t) }; - let (every, l, t) = set(Composer::EveryLine); - assert!(l.overflow && l.lines.len() >= 3, "{:?}", l.lines); - assert!(l.lines.windows(2).all(|p| p[0].end == p[1].start && p[0].start < p[0].end), "{:?}", l.lines); - assert!(past_their_room(&t, &l).is_empty(), "{:?}", l.lines); - let text = t.plain_text(); - let hits = l.glyphs.iter().filter(|g| { - let li = &l.lines[g.line]; - let across = li.baseline - li.ascent < object.y1 && li.baseline + li.descent > object.y0; - across && !text[g.byte..].starts_with(char::is_whitespace) && g.origin.x < object.x1 && g.origin.x + g.advance > object.x0 - }); - assert_eq!(hits.count(), 0, "{:?}", l.lines); - // The lines that fit break as in `composer_x_mixed_sizes_around_text_wrap`'s taller frame. - assert_eq!(every, ["Destroy all creatures with", "toughness\u{a0}X", "or less. Then", "draw a card for", "each creature"]); - // The single-line composer measures each line across its height too, and breaks the lines - // that fit the same way. - let (greedy, ..) = set(Composer::SingleLine); - assert_eq!(every, greedy); + // The single-line composer measures each line across its height too, and breaks and sets the + // lines that fit the same way. + for composer in [Composer::EveryLine, Composer::SingleLine] { + let (texts, l, t) = set(composer); + assert!(l.overflow && l.lines.len() >= 3, "{composer:?}: {:?}", l.lines); + assert!(l.lines.windows(2).all(|p| p[0].end == p[1].start && p[0].start < p[0].end), "{composer:?}: {:?}", l.lines); + assert!(past_their_room(&t, &l).is_empty(), "{composer:?}: {:?}", l.lines); + let text = t.plain_text(); + let hits = l.glyphs.iter().filter(|g| { + let li = &l.lines[g.line]; + let across = li.baseline - li.ascent < object.y1 && li.baseline + li.descent > object.y0; + across && !text[g.byte..].starts_with(char::is_whitespace) && g.origin.x < object.x1 && g.origin.x + g.advance > object.x0 + }); + assert_eq!(hits.count(), 0, "{composer:?}: {:?}", l.lines); + // The lines that fit break as in `composer_x_mixed_sizes_around_text_wrap`'s taller frame. + assert_eq!(texts, ["Destroy all creatures with", "toughness\u{a0}X", "or less. Then", "draw a card for", "each creature"], "{composer:?}"); + } } #[test] diff --git a/crates/text/src/tests/sysfonts.rs b/crates/text/src/tests/sysfonts.rs index ada5c45dd1..06c4db899c 100644 --- a/crates/text/src/tests/sysfonts.rs +++ b/crates/text/src/tests/sysfonts.rs @@ -50,6 +50,121 @@ fn concurrent_fallback_lookups_all_find_the_installed_face() { std::fs::remove_dir(dir).unwrap(); } +/// Two [`test_fonts::steady_fonts`] guards on one thread hold font changes back until the last of +/// them is dropped, whichever was made first. +#[test] +fn steady_fonts_hold_back_font_changes_until_the_last_guard_is_dropped() { + let db = FontDb::with_font_dirs(vec![]); + let outer = crate::test_fonts::steady_fonts(&db); + let inner = crate::test_fonts::steady_fonts(&db); + drop(outer); + assert!(crate::test_fonts::font_changes_held_back(), "the inner guard is still held"); + drop(inner); + let first = crate::test_fonts::steady_fonts(&db); + let second = crate::test_fonts::steady_fonts(&db); + drop(second); + assert!(crate::test_fonts::font_changes_held_back(), "the first guard is still held"); + drop(first); +} + +/// While a thread holds [`test_fonts::steady_fonts`], a font added on another thread, which may +/// hold one too, changes the database's generation only once the guard is dropped. A thread that +/// holds the only guard adds a font itself while another thread's change waits, which then still +/// waits for the guard. +#[test] +fn steady_fonts_hold_back_other_threads_font_changes() { + for guarded in [false, true] { + let db = FontDb::with_font_dirs(vec![]); + let font = crate::test_fonts::variable_font().unwrap(); + let steady = crate::test_fonts::steady_fonts(&db); + let before = db.generation(); + std::thread::scope(|scope| { + let adding = scope.spawn(|| { + let _steady = guarded.then(|| crate::test_fonts::steady_fonts(&db)); + db.add_font(font) + }); + let id = adding.thread().id(); + while !adding.is_finished() && !crate::test_fonts::font_changers().contains(&id) { + std::thread::yield_now(); + } + assert_eq!(db.generation(), before, "guarded {guarded}: the other thread's change waits for the guard"); + let listed = db.families().iter().any(|f| f == crate::test_fonts::VARIABLE_FAMILY); + assert!(!listed, "guarded {guarded}: the other thread publishes the font only once the guard is dropped"); + drop(steady); + assert!(adding.join().unwrap() > 0, "guarded {guarded}: the font is new to this database"); + }); + assert_ne!(db.generation(), before, "guarded {guarded}: the change is made once the guard is dropped"); + } + let db = FontDb::with_font_dirs(vec![]); + let steady = crate::test_fonts::steady_fonts(&db); + std::thread::scope(|scope| { + let adding = scope.spawn(|| db.add_font(crate::test_fonts::two_axis_font().unwrap())); + let id = adding.thread().id(); + while !adding.is_finished() && !crate::test_fonts::font_changers().contains(&id) { + std::thread::yield_now(); + } + let before = db.generation(); + assert!(db.add_font(crate::test_fonts::variable_font().unwrap()) > 0); + let after = db.generation(); + assert_ne!(after, before, "the guard's own thread changes the fonts"); + assert!(!adding.is_finished(), "the waiting change still waits for the guard"); + assert_eq!(db.generation(), after, "the waiting change still waits for the guard"); + drop(steady); + assert!(adding.join().unwrap() > 0); + }); +} + +/// The first scan of a database's installed fonts does not wait for [`test_fonts::steady_fonts`] +/// held for another database, so a thread holding one can catalog a database that another thread +/// is scanning. +#[test] +fn a_first_scan_does_not_wait_for_steady_fonts() { + let (held, scanned) = (FontDb::with_font_dirs(vec![]), FontDb::with_font_dirs(vec![])); + let steady = crate::test_fonts::steady_fonts(&held); + std::thread::scope(|scope| { + let scanning = scope.spawn(|| scanned.load_system_fonts()); + let id = scanning.thread().id(); + while !scanning.is_finished() && !crate::test_fonts::font_changers().contains(&id) { + std::thread::yield_now(); + } + let finished = scanning.is_finished(); + drop(steady); + assert!(finished, "the first scan waited for the guard"); + scanning.join().unwrap(); + }); +} + +/// A font that a hook adds while another add publishes its faces, on the same thread, is added +/// without that thread waiting for its own change. +#[test] +fn a_font_added_while_faces_are_published_is_added() { + let db = Arc::new(FontDb::with_font_dirs(vec![])); + let adder = db.clone(); + // Not scoped: a thread that waits for its own change never finishes, and the test still reports. + let adding = std::thread::spawn(move || { + let (hook_db, mut extra) = (adder.clone(), crate::test_fonts::two_axis_font()); + crate::fontdb::on_faces_published(Some(Box::new(move || { + if let Some(font) = extra.take() { + hook_db.add_font(font); + } + }))); + let added = adder.add_font(crate::test_fonts::variable_font().unwrap()); + crate::fontdb::on_faces_published(None); + added + }); + let id = adding.thread().id(); + let changes = || crate::test_fonts::font_changers().iter().filter(|t| **t == id).count(); + while !adding.is_finished() && changes() < 2 { + std::thread::yield_now(); + } + assert!(adding.is_finished(), "the hook's add waited for the change around it"); + assert!(adding.join().unwrap() > 0); + let families = db.families(); + for family in [crate::test_fonts::VARIABLE_FAMILY, crate::test_fonts::TWO_AXIS_FAMILY] { + assert!(families.iter().any(|f| f == family), "{family} is added"); + } +} + /// A bundled Source Sans 3 file renamed [`FAMILY`] (as long as the original name). fn renamed(file: &str) -> Vec { renamed_to(file, FAMILY) diff --git a/crates/tools/src/addons/polygonal_lasso.rs b/crates/tools/src/addons/polygonal_lasso.rs index b212943117..2810b0b309 100644 --- a/crates/tools/src/addons/polygonal_lasso.rs +++ b/crates/tools/src/addons/polygonal_lasso.rs @@ -167,7 +167,7 @@ impl Tool for PolygonalLassoTool { self.mesh.options() } - /// Pick the gradient mesh points the Eyedropper held (`meshPoints`). + /// Pick the gradient mesh points the tool chosen before held (`meshPoints`). fn set_option(&mut self, key: &str, value: &serde_json::Value) { if key == "meshPoints" { self.mesh.set_options(value); diff --git a/crates/tools/src/addons/tangent_circle.rs b/crates/tools/src/addons/tangent_circle.rs index a8d24d8853..1ab964988e 100644 --- a/crates/tools/src/addons/tangent_circle.rs +++ b/crates/tools/src/addons/tangent_circle.rs @@ -12,8 +12,10 @@ //! three points can draw, a note says so. The circle is a new ellipse with the current paint, drawn //! with `shape.circleThroughPoints` in one undo step, so Align New Objects to Pixel Grid leaves it //! in place; the first segment stays picked until the circle is drawn, also when drawing fails or the -//! press on the second segment is dropped. Escape, an edit or Undo outside the tool, or another -//! document forgets the first segment. +//! press on the second segment is dropped. Escape, an edit or Undo outside the tool, another +//! document, or a change to the first segment that leaves no undo step (a live preview, or one that +//! was canceled) forgets the first segment. The circles are looked for again whenever either +//! segment's shape differs from the one they were found on. use kurbo::{CubicBez, Shape}; use serde_json::{Value, json}; @@ -55,7 +57,8 @@ struct Pick { /// A press on the second segment, kept while the button is down. #[derive(Clone, Debug, PartialEq)] struct Press { - /// The segments a circle may touch. + /// The segment pressed on, and the segments a circle may touch. + pick: Pick, second: Vec, /// Where the press was. at: Point, @@ -78,12 +81,13 @@ pub struct TangentCircleTool { found: Option, looked: bool, pointer: Point, - /// The circles the last second segment gave (its path, subpath and segment, and the radius - /// asked for), so that moving along it only picks among them. + /// The circles the last second segment gave (its path, subpath and segment, the radius asked + /// for, and the shapes of the first segment and of the segments a circle may touch), so that + /// moving along it only picks among them. cache: Option<(CacheKey, Vec)>, } -type CacheKey = (NodeId, usize, usize, Option); +type CacheKey = (NodeId, usize, usize, Option, CubicBez, Vec); impl Default for TangentCircleTool { fn default() -> Self { @@ -102,6 +106,17 @@ fn pick_at(cx: &ToolContext, p: Point) -> Option { Some(Pick { id, subpath, segment, t, p: curve.eval(t), curve }) } +/// The document's segment at `pick` as it is now: none when its path, subpath or segment is gone. +fn segment_now(cx: &ToolContext, pick: &Pick) -> Option { + let sp = cx.doc.node(pick.id)?.path_data()?.subpaths.get(pick.subpath)?; + (pick.segment < sp.segment_count()).then(|| sp.segment(pick.segment)) +} + +/// Whether the document's segment at `pick` still has the shape it had when it was picked. +fn unchanged(cx: &ToolContext, pick: &Pick) -> bool { + segment_now(cx, pick) == Some(pick.curve) +} + /// The segments a circle may touch when `second` is picked: it and the segments on either side of /// it, without `first`. None when `second` is the first segment again. fn second_set(cx: &ToolContext, first: &Pick, second: &Pick) -> Vec { @@ -192,24 +207,35 @@ impl TangentCircleTool { } /// The circles `pick` gives as the second segment, with Shift's `radius`: worked out again only - /// when the segment or the radius changes. + /// when the segment, the radius or the shape of either segment changes. fn circles_on(&mut self, cx: &ToolContext, pick: &Pick, radius: Option) -> Vec { - let key = (pick.id, pick.subpath, pick.segment, radius.map(f64::to_bits)); + let Some(first) = &self.first else { return vec![] }; + let second = second_set(cx, first, pick); + let key = (pick.id, pick.subpath, pick.segment, radius.map(f64::to_bits), first.curve, second); if let Some((k, found)) = &self.cache && *k == key { return found.clone(); } - let Some(first) = &self.first else { return vec![] }; - let found = circles(first, &second_set(cx, first, pick), radius); + let found = circles(first, &key.5, radius); self.cache = Some((key, found.clone())); found } + /// Forget the first segment when the document's no longer has the shape it was picked with: a + /// live preview, or one that was canceled, changes it without an undo step, so the tool is not + /// told ([`Tool::history_moved`]). + fn forget_if_changed(&mut self, cx: &ToolContext) { + if self.first.as_ref().is_some_and(|f| !unchanged(cx, f)) { + self.forget(); + } + } + /// Look for the circle the pointer at `p` would give over `hover`, before any press. fn look(&mut self, cx: &ToolContext, p: Point, mods: Mods) { self.found = None; self.looked = false; + self.forget_if_changed(cx); let Some(hover) = self.hover.clone().filter(|_| self.first.is_some()) else { return }; let found = self.circles_on(cx, &hover, mods.shift.then_some(self.radius)); self.found = nearest_to(found, p, cx.tol(DRAW_PX)); @@ -219,15 +245,25 @@ impl TangentCircleTool { /// The pointer at `ev` during a press on the second segment: once it is far enough from the /// press, the radius follows it (Cmd/Ctrl: a tenth of its movement; Shift: round steps). fn drag_to(&mut self, cx: &ToolContext, ev: &PointerEvent) { + if self.press.is_none() { + return; + } + // A change without an undo step since the press: a changed first segment is forgotten (the + // press then draws nothing), and the circle follows the segments it may touch as they are now. + self.forget_if_changed(cx); let radius = self.radius; let (Some(first), Some(press)) = (&self.first, &mut self.press) else { return }; + // A pressed segment that is gone leaves nothing to touch. + let second = if segment_now(cx, &press.pick).is_some() { second_set(cx, first, &press.pick) } else { vec![] }; + let moved = second != press.second; + press.second = second; let reach = ev.pos.distance(press.at); let gear = if ev.mods.cmd { SLOW } else { 1.0 }; let r = match press.radius { None if reach <= cx.tol(DRAG_PX) => { - // Shift pressed or let go before the drag starts: the click's circle, with or - // without the tool's radius. - if ev.mods.shift != press.shift { + // Shift pressed or let go before the drag starts, or the segments changed: the + // click's circle, with or without the tool's radius. + if moved || ev.mods.shift != press.shift { press.shift = ev.mods.shift; let found = circles(first, &press.second, press.shift.then_some(radius)); self.found = nearest_to(found, press.at, cx.tol(DRAW_PX)); @@ -273,6 +309,7 @@ impl Tool for TangentCircleTool { } PointerKind::Down => { let Some(pick) = pick_at(cx, ev.pos) else { return vec![] }; + self.forget_if_changed(cx); let Some(first) = self.first.clone() else { self.first = Some(pick); self.picking = true; @@ -286,7 +323,7 @@ impl Tool for TangentCircleTool { self.found = nearest_to(found, ev.pos, cx.tol(DRAW_PX)); self.looked = true; self.hover = None; - self.press = Some(Press { second, at: ev.pos, shift: ev.mods.shift, reach: 0.0, radius: None }); + self.press = Some(Press { pick, second, at: ev.pos, shift: ev.mods.shift, reach: 0.0, radius: None }); vec![] } PointerKind::Drag => { @@ -431,10 +468,14 @@ mod tests { /// Two open lines, (100, 100)–(300, 100) and (100, 140)–(300, 140), and an L from (100, 300) /// over to (300, 300) and down to (300, 400). fn doc() -> Document { + doc_at(100.0, 140.0) + } + + /// [`doc`] with the two open lines at heights `a` and `b`, with the same ids. + fn doc_at(a: f64, b: f64) -> Document { let mut d = Document::new(500.0, 500.0); let l = d.layers[0].id; - let lines: [&[(f64, f64)]; 3] = - [&[(100.0, 100.0), (300.0, 100.0)], &[(100.0, 140.0), (300.0, 140.0)], &[(100.0, 300.0), (300.0, 300.0), (300.0, 400.0)]]; + let lines: [&[(f64, f64)]; 3] = [&[(100.0, a), (300.0, a)], &[(100.0, b), (300.0, b)], &[(100.0, 300.0), (300.0, 300.0), (300.0, 400.0)]]; for pts in lines { let id = d.alloc_id(); let pts: Vec = pts.iter().map(|(x, y)| Point::new(*x, *y)).collect(); @@ -676,6 +717,58 @@ mod tests { assert!(t.first.is_some()); } + #[test] + fn a_change_without_an_undo_step_is_not_drawn_from_the_old_shapes() { + let (sel, p) = (Selection::default(), paint()); + let (d, previewed, first_previewed) = (doc(), doc_at(100.0, 180.0), doc_at(80.0, 140.0)); + let (cx, during, first_during) = (cx(&d, &sel, &p), cx(&previewed, &sel, &p), cx(&first_previewed, &sel, &p)); + let mut t = TangentCircleTool::default(); + // A live preview moves the second line down to 180, and the pointer over it shows a 40 pt + // circle. The preview is canceled, which leaves no undo step: the click draws the 20 pt circle + // touching the line where it is again, not the one found during the preview. + t.pointer(&cx, &ev(PointerKind::Down, 150.0, 101.0)); + t.pointer(&cx, &ev(PointerKind::Up, 150.0, 101.0)); + t.pointer(&during, &ev(PointerKind::Move, 200.0, 179.0)); + assert!(t.overlays(&during).iter().any(|o| matches!(o, Overlay::Measure { text, .. } if text.starts_with("R: 40.00")))); + t.pointer(&cx, &ev(PointerKind::Down, 200.0, 139.0)); + let released = up(&mut t, &cx, &ev(PointerKind::Up, 200.0, 139.0)); + assert!(close(drawn(&released), (130.0, 100.0, 40.0, 40.0)), "{released:?}"); + // The same for a press made during the preview and released after it was canceled. + t.pointer(&cx, &ev(PointerKind::Down, 150.0, 101.0)); + t.pointer(&cx, &ev(PointerKind::Up, 150.0, 101.0)); + t.pointer(&during, &ev(PointerKind::Down, 200.0, 179.0)); + let released = up(&mut t, &cx, &ev(PointerKind::Up, 200.0, 179.0)); + assert!(close(drawn(&released), (130.0, 100.0, 40.0, 40.0)), "{released:?}"); + // A first segment picked during a preview that moved it, canceled since: forgotten, with no + // circle shown from where it was. + t.pointer(&first_during, &ev(PointerKind::Down, 150.0, 81.0)); + t.pointer(&first_during, &ev(PointerKind::Up, 150.0, 81.0)); + assert!(t.first.is_some()); + t.pointer(&cx, &ev(PointerKind::Move, 200.0, 139.0)); + assert!(t.first.is_none() && t.found.is_none() && !t.looked); + // A press on a first segment that the preview changed since the press draws nothing. + t.pointer(&first_during, &ev(PointerKind::Down, 150.0, 81.0)); + t.pointer(&first_during, &ev(PointerKind::Up, 150.0, 81.0)); + t.pointer(&first_during, &ev(PointerKind::Down, 200.0, 139.0)); + assert!(t.busy()); + assert!(t.pointer(&cx, &ev(PointerKind::Up, 200.0, 139.0)).is_empty()); + assert!(t.first.is_none() && !t.busy()); + // A press on the L's second segment, which a preview then removes: nothing to touch, so the + // release draws no circle against the segment left beside it. + t.pointer(&cx, &ev(PointerKind::Down, 150.0, 101.0)); + t.pointer(&cx, &ev(PointerKind::Up, 150.0, 101.0)); + t.pointer(&cx, &ev(PointerKind::Down, 300.0, 350.0)); + let l = t.press.as_ref().map(|p| (p.pick.id, p.pick.segment)); + assert!(matches!(l, Some((_, 1))), "{l:?}"); + let mut cut = doc(); + if let Some(path) = l.and_then(|(id, _)| cut.node_mut(id)).and_then(|n| n.path_data_mut()) { + path.subpaths[0] = SubPath::polyline(&[Point::new(100.0, 300.0), Point::new(300.0, 300.0)], false); + } + let cut_cx = crate::testutil::cx(&cut, &sel, &p); + assert!(t.pointer(&cut_cx, &ev(PointerKind::Up, 300.0, 350.0)).is_empty(), "nothing drawn"); + assert!(t.first.is_some(), "the first segment stays for another try"); + } + #[test] fn a_circle_the_three_points_cannot_draw_keeps_the_first_segment() { // A circle the geometry found, moved to (x, 0) and given radius `r`. diff --git a/crates/tools/src/blendwidget.rs b/crates/tools/src/blendwidget.rs index e09df663bb..3f53287625 100644 --- a/crates/tools/src/blendwidget.rs +++ b/crates/tools/src/blendwidget.rs @@ -512,7 +512,7 @@ mod tests { assert_eq!(a, vec![Action::Preview("object.blend.setEasing".into(), json!({"id": id.0, "ramp": 0.0}))], "clamped at 0"); let a = t.pointer(&c, &ev(PointerKind::Drag, at + Vec2::new(500.0, 0.0))); assert_eq!(a, vec![Action::Preview("object.blend.setEasing".into(), json!({"id": id.0, "ramp": 100.0}))], "clamped at 100"); - assert_eq!(t.pointer(&c, &ev(PointerKind::Up, at)), vec![Action::Commit]); + assert_eq!(t.pointer(&c, &ev(PointerKind::Up, at + Vec2::new(500.0, 0.0))), vec![Action::Commit]); // A click that doesn't move sends nothing. assert!(t.pointer(&c, &ev(PointerKind::Down, at)).is_empty()); assert!(t.pointer(&c, &ev(PointerKind::Up, at)).is_empty()); @@ -546,6 +546,16 @@ mod tests { assert_eq!(a[1], Action::Preview("object.blend.setEasing".into(), json!({"id": id.0, "ramp": 50.0}))); } + /// A drag with the Selection tool reads where it is released, and a tool switch cancels it. + #[test] + fn a_drag_reads_its_release() { + let (d, _, s) = blend_doc(&[(100.0, 200.0), (300.0, 200.0)], eased()); + let p = paint(); + let c = cx(&d, &s, &p); + let at = Point::new(200.0, 216.0); + check_widget_release_and_tool_switch(&c, at, at + Vec2::new(20.0, 0.0), at + Vec2::new(40.0, 0.0)); + } + /// Switching away from the Selection or Blend tool during a drag cancels it, and after a press /// that has not moved there is nothing to put back. #[test] diff --git a/crates/tools/src/context.rs b/crates/tools/src/context.rs index 50553a87bc..1a37860179 100644 --- a/crates/tools/src/context.rs +++ b/crates/tools/src/context.rs @@ -451,6 +451,7 @@ impl ToolContext<'_> { skip_guides: !self.guides, clip_outlines: false, area_type_interior: false, + ignore_layer_preview: false, } } diff --git a/crates/tools/src/dimension.rs b/crates/tools/src/dimension.rs index 525c2ff547..dffe13a378 100644 --- a/crates/tools/src/dimension.rs +++ b/crates/tools/src/dimension.rs @@ -77,6 +77,13 @@ pub struct DimensionTool { /// The path that holds the first Linear point, when it was picked on a corner of that path's /// preview bounds. first_corner: Option, + /// The link the first Linear point took at its click when it was not on an anchor: held + /// against the path whose preview-bounds corner it was picked on, or on the segment under it. + /// When the art moves before the second click, the first point moves with it. + first_link: Option, + /// Where the first Linear point was picked. The point goes back there when its anchor or + /// [`Self::first_link`] no longer resolves. + first_pick: Option, /// Whether the press under way began on an anchor a Linear click picks. press_on_anchor: bool, /// The second point clicked for the Linear dimension being placed, and where the pointer was @@ -292,13 +299,13 @@ fn preview_corner(cx: &ToolContext, p: Point, cache: &mut PreviewBoxes) -> Optio [Point::new(r.x0, r.y0), Point::new(r.x1, r.y0), Point::new(r.x1, r.y1), Point::new(r.x0, r.y1)] } /// For each corner of `preview`, the path whose own box reaches nearest to it: in a compound - /// path, the member that puts that corner where it is. A hidden or locked member gives no - /// corner. One pass reads each member once for all four corners. + /// path, the member that puts that corner where it is. A hidden or locked member, or one made + /// into a guide, gives no corner. One pass reads each member once for all four corners. fn holders<'n>(members: impl Iterator, preview: Rect) -> [Option; 4] { let mut best: [Option<(f64, NodeId, bool)>; 4] = [None; 4]; for m in members { let Some(b) = m.geometric_bounds() else { continue }; - let editable = m.visible && !m.locked; + let editable = m.visible && !m.locked && !m.is_guide(); for ((holder, c), q) in best.iter_mut().zip(corners(b)).zip(corners(preview)) { let gap = c.distance(q); if holder.is_none_or(|(near, _, was)| gap < near || (gap == near && editable && !was)) { @@ -610,28 +617,34 @@ fn nearest_on(cx: &ToolContext, edge: &SegmentRef, p: Point) -> Option { /// point, so that it moves with that path. None when neither point has a path to link to. /// `held_a` and `held_b` name the path holding a point picked on a corner of that path's /// preview bounds: such a point is held against that path, however far its strokes or effects -/// put the corner from the path and whatever other segment lies there. +/// put the corner from the path and whatever other segment lies there. `link_a` is the link the +/// first point took at its own click ([`own_link`]): while it still resolves, the point keeps it, +/// whatever other art lies there now. fn points_source( cx: &ToolContext, (a, ra, held_a): (Point, &Option, Option), (b, rb, held_b): (Point, &Option, Option), + link_a: Option, ) -> Option { // A path deleted since the pick holds nothing. let holder = |held: Option| held.filter(|node| cx.doc.node(*node).is_some()); let (corner_a, corner_b) = (holder(held_a), holder(held_b)); + let link_a = link_a.filter(|link| ra.is_none() && link.position(cx.doc).is_some()); let edge = |p: Point, corner: Option| if corner.is_some() { None } else { pick(cx, p) }; - let (edge_a, edge_b) = (edge(a, corner_a), edge(b, corner_b)); + let (edge_a, edge_b) = (if link_a.is_some() { None } else { edge(a, corner_a) }, edge(b, corner_b)); let node = |r: &Option, corner: Option, e: &Option| { r.as_ref().map(|r| r.node).or(corner).or_else(|| e.as_ref().map(|e| e.node)) }; - let (path_a, path_b) = (node(ra, corner_a, &edge_a), node(rb, corner_b, &edge_b)); + let path_a = link_a.as_ref().map(FreePoint::node).or_else(|| node(ra, corner_a, &edge_a)); + let path_b = node(rb, corner_b, &edge_b); let free = |p: Point, r: &Option, edge: &Option, own: Option, other: Option| { if r.is_some() { return None; } edge.as_ref().and_then(|e| FreePoint::on_segment(cx.doc, e, p)).or_else(|| own.or(other).and_then(|node| FreePoint::on(cx.doc, node, p))) }; - let (free_a, free_b) = (free(a, ra, &edge_a, path_a, path_b), free(b, rb, &edge_b, path_b, path_a)); + let free_a = link_a.or_else(|| free(a, ra, &edge_a, path_a, path_b)); + let free_b = free(b, rb, &edge_b, path_b, path_a); (ra.is_some() || rb.is_some() || free_a.is_some() || free_b.is_some()).then(|| DimensionSource::Points { a: ra.clone(), b: rb.clone(), @@ -641,6 +654,17 @@ fn points_source( }) } +/// The link a point picked at `p` off any anchor takes from its own pick, as [`points_source`] +/// links it: held against `corner`'s path when it was picked on a corner of that path's preview +/// bounds, else on the segment under it, or held against that segment's path. None when nothing +/// under it holds it. +fn own_link(cx: &ToolContext, p: Point, corner: Option) -> Option { + match corner.filter(|node| cx.doc.node(*node).is_some()) { + Some(node) => FreePoint::on(cx.doc, node, p), + None => pick(cx, p).and_then(|e| FreePoint::on_segment(cx.doc, &e, p).or_else(|| FreePoint::on(cx.doc, e.node, p))), + } +} + impl DimensionTool { /// Where a Linear pick at `p` lands: with Use Preview Bounds on, on the nearest corner of a /// path's preview bounds within reach, where they differ from its anchors, unless another @@ -656,6 +680,7 @@ impl DimensionTool { /// A point the guides leave where the pointer is (right on a guide line) stays there, and with /// Snap to Pixel or Snap to Grid on a point stays where they place it. fn snap_linear(&mut self, cx: &ToolContext, p: Point) -> (Point, Option) { + self.follow_first(cx); let leave = self.points.last().map(|(first, anchor)| match anchor { Some(_) => crate::guides::Leave::segment(cx, *first, false), None => crate::guides::Leave::contact(*first), @@ -698,6 +723,30 @@ impl DimensionTool { None => (p, None), } } + /// Moves the first Linear point to where its link puts it in the document as it is now: on + /// its anchor, or where [`Self::first_link`] holds it. A point whose link no longer resolves, + /// or that has none, stays where it was picked, and an anchor that no longer resolves is + /// dropped from it. + fn follow_first(&mut self, cx: &ToolContext) { + if let Some(now) = self.first_now(cx) + && let [(at, reference)] = self.points.as_mut_slice() + { + *at = now; + if reference.as_ref().is_some_and(|r| r.position(cx.doc).is_none()) { + *reference = None; + } + } + } + /// Where the first Linear point is in the document as it is now ([`Self::follow_first`]), + /// while it is the only point picked. + fn first_now(&self, cx: &ToolContext) -> Option { + let [(at, reference)] = self.points.as_slice() else { return None }; + let now = match reference { + Some(r) => r.position(cx.doc), + None => self.first_link.as_ref().and_then(|link| link.position(cx.doc)), + }; + Some(now.or(self.first_pick).unwrap_or(*at)) + } fn target(&self, cx: &ToolContext, p: Point) -> Option { let edge = pick(cx, p)?; match self.kind { @@ -846,6 +895,8 @@ impl DimensionTool { self.on_end = false; self.corner = None; self.first_corner = None; + self.first_link = None; + self.first_pick = None; self.points.clear(); self.lines.clear(); self.dragging = false; @@ -870,13 +921,16 @@ impl DimensionTool { reference = reference.filter(|r| r.position(cx.doc) == Some(at)); corner = corner.filter(|_| at.distance(snapped) <= 1e-9); } - self.points.push((at, reference)); - if self.points.len() == 1 { + if self.points.is_empty() { self.first_corner = corner; + self.first_link = reference.is_none().then(|| own_link(cx, at, corner)).flatten(); + self.first_pick = Some(at); } + self.points.push((at, reference)); if let [(a, ra), (b, rb)] = self.points.as_slice() { - let source = points_source(cx, (*a, ra, self.first_corner), (*b, rb, corner)); + let source = points_source(cx, (*a, ra, self.first_corner), (*b, rb, corner), self.first_link.take()); self.first_corner = None; + self.first_pick = None; let mut d = self.recipe(DimensionMode::Linear, *a, *b, Point::ZERO, source); if d.resolve(cx.doc).is_ok() { self.second = Some((*b, p)); @@ -1087,8 +1141,10 @@ impl Tool for DimensionTool { None => {} } } + // The first point where the art puts it now, also when the art moved without a pointer move. + let first = self.first_now(cx); for (p, _) in &self.points { - out.push(Overlay::Anchor { p: *p, color, filled: true, size: 6.0 }); + out.push(Overlay::Anchor { p: first.unwrap_or(*p), color, filled: true, size: 6.0 }); } for edge in &self.lines { segment(edge, &mut out); @@ -1103,10 +1159,10 @@ impl Tool for DimensionTool { let on_anchor = reference.is_some() || self.on_end; out.push(Overlay::Anchor { p: *q, color, filled: !on_anchor, size: if on_anchor { 10.0 } else { 6.0 } }); } - if let Some((p, _)) = self.points.last() { + if let Some(p) = first.or_else(|| self.points.last().map(|(p, _)| *p)) { let target = snapped.map_or(self.at, |(q, _)| q); - let b = if self.shift { constrained(cx, *p, target) } else { target }; - out.push(Overlay::Line { a: *p, b, color, dashed: true }); + let b = if self.shift { constrained(cx, p, target) } else { target }; + out.push(Overlay::Line { a: p, b, color, dashed: true }); } // The Smart Guides of the point the next click picks (after the rubber band). if linear_pick { @@ -1881,6 +1937,23 @@ mod tests { let (q, _) = t.snap_linear(&c, Point::new(81.0, 81.0)); assert!(!near(q, Point::new(80.0, 80.0)) && t.corner.is_none(), "{kind}: {q:?}"); } + // A visible, unlocked member of a stroked compound path made into a guide does not hold + // the corner its box puts there. + let mut d = vectorcraft_doc::Document::new(500.0, 500.0); + let (l, hole, part, whole) = (d.layers[0].id, d.alloc_id(), d.alloc_id(), d.alloc_id()); + let mut guide = Node::path(part, vectorcraft_geom::shapes::rectangle(Rect::new(100.0, 100.0, 200.0, 200.0)), Default::default()); + if let NodeKind::Path { guide, .. } = &mut guide.kind { + *guide = true; + } + let small = Node::path(hole, vectorcraft_geom::shapes::rectangle(Rect::new(140.0, 140.0, 160.0, 160.0)), Default::default()); + let mut n = + Node::new(whole, NodeKind::Compound { children: vec![std::sync::Arc::new(small), std::sync::Arc::new(guide)], rule: Default::default() }); + n.appearance = vectorcraft_doc::Appearance::default_art().into(); + d.insert(Some(l), 0, n).expect("the compound path"); + let c = ToolContext { preview_bounds: true, ..cx(&d, &s, &p) }; + let mut t = DimensionTool::default(); + let (q, _) = t.snap_linear(&c, Point::new(99.6, 99.6)); + assert!(t.corner.is_none() && !near(q, Point::new(99.5, 99.5)), "{q:?} {:?}", t.corner); // Two stroked rectangles sharing the edge x = 200; the right one is on top. let (mut d, left) = doc_with_rect(); let (l, right) = (d.layers[0].id, d.alloc_id()); @@ -1914,7 +1987,7 @@ mod tests { let c = ToolContext { preview_bounds: true, ..cx(&d, &s, &p) }; let (corner, b) = (Point::new(99.5, 99.5), Point::new(250.0, 99.5)); for (held, node) in [(Some(id), id), (None, line)] { - let source = points_source(&c, (corner, &None, held), (b, &None, None)); + let source = points_source(&c, (corner, &None, held), (b, &None, None), None); let Some(DimensionSource::Points { free_a: Some(free), .. }) = &source else { panic!("{source:?}") }; let linked = match free { FreePoint::Anchors { node, .. } => *node, @@ -1924,6 +1997,105 @@ mod tests { } } + /// A first point keeps its link when the art moves before the second click: a point picked on + /// a corner of the preview bounds, on a segment or on an anchor is measured, shown and + /// constrained by Shift from where the art puts it now. + #[test] + fn a_first_point_follows_art_moved_before_the_second_click() { + let (d, id) = doc_with_rect(); + let (s, p) = (Selection::default(), paint()); + let near = |a: Point, b: Point| a.distance(b) < 1e-9; + let moved = |by: (f64, f64)| { + let mut m = d.clone(); + m.node_mut(id).expect("the rectangle").transform(vectorcraft_geom::Affine::translate(by), false); + m + }; + let click = |t: &mut DimensionTool, c: &ToolContext, (x, y): (f64, f64), shift: bool| { + for kind in [PointerKind::Move, PointerKind::Down, PointerKind::Up] { + let mut ev = PointerEvent::new(kind, x, y); + ev.mods.shift = shift; + t.pointer(c, &ev); + } + }; + let base = |doc| ToolContext { preview_bounds: true, smart_guides: false, snap_to_point: false, ..cx(doc, &s, &p) }; + // A corner of the preview bounds, then the rectangle moved 20 points right. + let right = moved((20.0, 0.0)); + let mut t = DimensionTool::default(); + click(&mut t, &base(&d), (101.0, 101.0), false); + let c = ToolContext { revision: (0, 1), ..base(&right) }; + let shown = t.overlays(&c).into_iter().any(|o| matches!(o, Overlay::Anchor { p, filled: true, .. } if near(p, Point::new(119.5, 99.5)))); + assert!(shown, "the first point shows at the moved corner before the pointer moves"); + t.pointer(&c, &PointerEvent::new(PointerKind::Move, 219.0, 101.0)); + let band = t.overlays(&c).into_iter().any(|o| matches!(o, Overlay::Line { a, dashed: true, .. } if near(a, Point::new(119.5, 99.5)))); + assert!(band, "the rubber band starts at the moved corner"); + click(&mut t, &c, (219.0, 101.0), false); + let pending = t.pending.take().expect("both points were picked"); + assert!(near(pending.a, Point::new(119.5, 99.5)) && near(pending.b, Point::new(220.5, 99.5)), "{:?} {:?}", pending.a, pending.b); + assert!((pending.length - 101.0).abs() < 1e-9, "{}", pending.length); + let Some(DimensionSource::Points { free_a: Some(free), .. }) = &pending.source else { panic!("{:?}", pending.source) }; + assert!(free.position(&right).is_some_and(|q| near(q, Point::new(119.5, 99.5))), "{free:?}"); + // The same corner, the rectangle moved 20 points right with the pointer moving, then + // deleted: the first point goes back to where it was picked. + let mut gone = right.clone(); + gone.remove(id).expect("the rectangle"); + let (l, line) = (gone.layers[0].id, gone.alloc_id()); + let path = + vectorcraft_geom::PathData::single(vectorcraft_geom::SubPath::polyline(&[Point::new(0.0, 300.0), Point::new(400.0, 300.0)], false)); + gone.insert(Some(l), 0, Node::path(line, path, Default::default())).expect("the line"); + let mut t = DimensionTool::default(); + click(&mut t, &base(&d), (101.0, 101.0), false); + let c = ToolContext { revision: (0, 1), ..base(&right) }; + t.pointer(&c, &PointerEvent::new(PointerKind::Move, 219.0, 101.0)); + let c = ToolContext { revision: (0, 2), ..base(&gone) }; + t.pointer(&c, &PointerEvent::new(PointerKind::Move, 300.0, 300.0)); + let shown = t.overlays(&c).into_iter().any(|o| matches!(o, Overlay::Anchor { p, filled: true, .. } if near(p, Point::new(99.5, 99.5)))); + assert!(shown, "the first point shows where it was picked once its rectangle is deleted"); + click(&mut t, &c, (300.0, 300.0), false); + let pending = t.pending.take().expect("both points were picked"); + assert!(near(pending.a, Point::new(99.5, 99.5)), "{:?}", pending.a); + // An anchor, then its rectangle deleted: the dimension starts where the anchor was picked. + let mut t = DimensionTool::default(); + let unbounded = |doc| ToolContext { preview_bounds: false, ..base(doc) }; + click(&mut t, &unbounded(&d), (100.0, 100.0), false); + click(&mut t, &ToolContext { revision: (0, 2), ..unbounded(&gone) }, (300.0, 300.0), false); + let pending = t.pending.take().expect("both points were picked"); + assert!(near(pending.a, Point::new(100.0, 100.0)), "{:?}", pending.a); + let Some(DimensionSource::Points { a: None, .. }) = &pending.source else { panic!("{:?}", pending.source) }; + // A point on the top segment, then the rectangle moved 20 points down. + let down = moved((0.0, 20.0)); + let mut t = DimensionTool::default(); + click(&mut t, &unbounded(&d), (150.0, 100.0), false); + click(&mut t, &ToolContext { revision: (0, 1), ..unbounded(&down) }, (300.0, 300.0), false); + let pending = t.pending.take().expect("both points were picked"); + assert!(near(pending.a, Point::new(150.0, 120.0)), "{:?}", pending.a); + let Some(DimensionSource::Points { free_a: Some(FreePoint::OnSegment { edge, .. }), .. }) = &pending.source else { + panic!("{:?}", pending.source) + }; + assert_eq!(edge.node, id); + // The same, with a line drawn on top along the moved segment before the second click: the + // point keeps the segment it was picked on, where a pick there now finds the line. + let mut covered = down.clone(); + let (l, line) = (covered.layers[0].id, covered.alloc_id()); + let path = + vectorcraft_geom::PathData::single(vectorcraft_geom::SubPath::polyline(&[Point::new(0.0, 120.0), Point::new(300.0, 120.0)], false)); + covered.insert(Some(l), 0, Node::path(line, path, Default::default())).expect("the line"); + let c = unbounded(&covered); + let at = Point::new(150.0, 120.0); + assert_eq!(pick(&c, at).map(|e| e.node), Some(line)); + let link = own_link(&unbounded(&d), Point::new(150.0, 100.0), None); + assert!(matches!(&link, Some(FreePoint::OnSegment { edge, .. }) if edge.node == id), "{link:?}"); + let source = points_source(&c, (at, &None, None), (Point::new(300.0, 300.0), &None, None), link); + let Some(DimensionSource::Points { free_a: Some(FreePoint::OnSegment { edge, .. }), .. }) = &source else { panic!("{source:?}") }; + assert_eq!(edge.node, id, "the line on top does not take the point"); + // An anchor, then the rectangle moved 20 points down: Shift constrains from the anchor's + // new place. + let mut t = DimensionTool::default(); + click(&mut t, &unbounded(&d), (100.0, 100.0), false); + click(&mut t, &ToolContext { revision: (0, 1), ..unbounded(&down) }, (300.0, 124.0), true); + let pending = t.pending.take().expect("both points were picked"); + assert!(near(pending.a, Point::new(100.0, 120.0)) && (pending.b.y - 120.0).abs() < 1e-9, "{:?} {:?}", pending.a, pending.b); + } + /// Hovering right on the end of a dimension's line shows the anchor ring there. #[test] fn hovering_right_on_a_dimension_lines_end_shows_the_anchor_ring() { diff --git a/crates/tools/src/direct.rs b/crates/tools/src/direct.rs index cd4432c3c8..c889671a6e 100644 --- a/crates/tools/src/direct.rs +++ b/crates/tools/src/direct.rs @@ -823,7 +823,7 @@ impl Tool for DirectSelectionTool { fn options(&self) -> Value { self.mesh.options() } - /// Direct Selection picks the gradient mesh points the Eyedropper held (`meshPoints`); Group + /// Direct Selection picks the gradient mesh points the tool chosen before held (`meshPoints`); Group /// Selection, which selects whole objects, does not. /// The session sets `lentByCmd` on the tool Cmd/Ctrl lends for one gesture /// ([`DirectSelectionTool::mirrors`]). diff --git a/crates/tools/src/draw2/family.rs b/crates/tools/src/draw2/family.rs index 87c11abba9..a815c02d2a 100644 --- a/crates/tools/src/draw2/family.rs +++ b/crates/tools/src/draw2/family.rs @@ -448,6 +448,10 @@ impl Tool for FamilyTool { _ => self.grid_skew_key(key).is_some(), } } + /// The pointer left the canvas: the Smart Guide of the hover goes. + fn hover_ended(&mut self, _cx: &ToolContext) { + self.snap.clear(); + } fn overlays(&self, cx: &ToolContext) -> Vec { let mut o = self.snap.guides().to_vec(); if let Some(s) = self.start.filter(|_| self.began && cx.measurement_labels) { @@ -1254,6 +1258,23 @@ mod tests { assert!(t.overlays(&cx).iter().any(|o| matches!(o, Overlay::Label { text, .. } if text == "align"))); } + /// The "anchor" label a hover shows goes when the pointer leaves the canvas. + #[test] + fn leaving_the_canvas_drops_the_hover_label() { + let (d, _) = doc_with_rect(); + let s = Selection::default(); + let p = paint(); + let cx = cx(&d, &s, &p); + let label = |o: &[Overlay]| o.iter().any(|o| matches!(o, Overlay::Label { text, .. } if text == "anchor")); + for id in ["arc", "spiral", "rectangularGrid", "polarGrid"] { + let mut t = FamilyTool::new(id); + t.pointer(&cx, &PointerEvent::new(PointerKind::Move, 98.0, 102.0)); + assert!(label(&t.overlays(&cx)), "{id}"); + t.hover_ended(&cx); + assert!(!label(&t.overlays(&cx)), "{id}: {:?}", t.overlays(&cx)); + } + } + /// A grid's Default Size and Reference Point are options for a click's dialog; the drag /// draws the box it is dragged to and leaves them out of its command. #[test] diff --git a/crates/tools/src/draw2/gesture.rs b/crates/tools/src/draw2/gesture.rs index ba5e8afe9c..dc123e6cc1 100644 --- a/crates/tools/src/draw2/gesture.rs +++ b/crates/tools/src/draw2/gesture.rs @@ -1300,12 +1300,6 @@ impl GestureTool { self.poses.len() == self.points.len() } - /// The tip at point `i` of the stroke, as `path.eraseRegion` reads the pen there - /// ([`Self::controls_of_point`]). - fn tip_of_point(&self, i: usize) -> [f64; 3] { - self.tip_of_controls(self.controls_of_point(i)) - } - /// The tip halfway along the step from point `j` to point `j + 1`, as `path.eraseRegion` reads /// the pen there: the pressure and tilt halfway between those at the two points, and the /// bearing and rotation halfway between them the shorter way round. A tip whose angle follows @@ -1945,7 +1939,7 @@ impl Tool for GestureTool { }; let mut area = self.area.take().filter(|a| a.fits(key, &self.points)).unwrap_or_else(|| AreaPreview::new(key, self.points[0])); let sized = |[angle, roundness, size]: [f64; 3]| [angle, roundness, if size_varies { size } else { self.size }]; - area.step(&self.points, &|i| sized(self.tip_of_point(i)), &|j| sized(self.tip_between(j))); + area.step(&self.points, &|j| sized(self.tip_between(j))); let paths = area.paths(&self.points); o.extend(paths.settled.into_iter().map(|path| Overlay::SharedPath { path, color, width: 1.0, dash: None })); o.extend(paths.live.into_iter().map(|path| Overlay::Path { path, color, width: 1.0, dashed: false })); @@ -1953,9 +1947,9 @@ impl Tool for GestureTool { self.area.set(Some(area)); } else if size_varies { // With Size on a mode that follows the pen, each step of the drag shows as wide as the - // tip the pen gives at its ends. A long drag's steps are kept from call to call - // ([`LinePreview::segments`]). - let width_of = |j: usize| ((self.tip_of_point(j)[2] + self.tip_of_point(j + 1)[2]) / 2.0 * cx.zoom) as f32; + // tip the pen gives halfway along it, as `path.eraseRegion` reads it. A long drag's + // steps are kept from call to call ([`LinePreview::segments`]). + let width_of = |j: usize| (self.tip_between(j)[2] * cx.zoom) as f32; if self.points.len() > line::PIECE_SEGMENTS + 1 { let mut kept = self.line.take().unwrap_or_default(); for (j, path) in kept.segments(&self.points).into_iter().enumerate() { diff --git a/crates/tools/src/draw2/gesture/area.rs b/crates/tools/src/draw2/gesture/area.rs index 5a33e6e77f..9c3a9f8cb6 100644 --- a/crates/tools/src/draw2/gesture/area.rs +++ b/crates/tools/src/draw2/gesture/area.rs @@ -157,8 +157,8 @@ pub(super) struct AreaPreview { sq: Vec, /// The last point taken, on the page. last: Point, - /// The tip at the last point taken, when the tip varies along the drag. - last_tip: Option, + /// The tip halfway along the last segment taken, when the tip varies along the drag. + last_middle: Option, /// The tip's radius along each segment, where its tip is round. It is also as far as the /// segment's area reaches from the segment in the grid's space. radius: Vec, @@ -196,7 +196,7 @@ impl AreaPreview { side: widest.max(MIN_BRUSH_SIZE), sq: vec![], last: first, - last_tip: None, + last_middle: None, radius: vec![], to_round: vec![], pieces: vec![], @@ -240,20 +240,22 @@ impl AreaPreview { } /// Take the points of the drag `pts` added since the last call and check outlines, within this - /// call's limits. When the tip varies along the drag, `tip(i)` gives the tip at point `i`, and - /// segment `j` takes `middle(j)`, the tip halfway along it. A last point whose tip changed since - /// it was taken (a pen turned or tilted in place) gives its segment the new tip. - pub(super) fn step(&mut self, pts: &[Point], tip: &dyn Fn(usize) -> Tip, middle: &dyn Fn(usize) -> Tip) { + /// call's limits. When the tip varies along the drag, segment `j` takes `middle(j)`, the tip + /// halfway along it. A last segment whose tip halfway along it changed since it was taken (a pen + /// turned or tilted in place at its end) takes the new tip, also where the tip at its end stays + /// the same (a size held at its least). + pub(super) fn step(&mut self, pts: &[Point], middle: &dyn Fn(usize) -> Tip) { self.work = AreaWork::default(); let mut changed = BTreeSet::new(); if self.key.varies && let Some(j) = self.sq.len().checked_sub(2) - && self.last_tip.is_some_and(|t| t != tip(j + 1)) + && self.last_middle.is_some_and(|t| t != middle(j)) { let k = self.piece_of(j); let old = self.radius[j]; - self.set_tip(j, middle(j)); - self.last_tip = Some(tip(j + 1)); + let tip = middle(j); + self.set_tip(j, tip); + self.last_middle = Some(tip); changed.insert(k); // The pieces near the old tip or the new one are checked again. let new = self.radius[j]; @@ -266,13 +268,12 @@ impl AreaPreview { self.sq.push(self.squash * pts[i]); self.last = pts[i]; self.work.points += 1; - if self.key.varies { - self.last_tip = Some(tip(i)); - } let Some(j) = i.checked_sub(1) else { continue }; if self.key.varies { self.radius.push(0.0); - self.set_tip(j, middle(j)); + let tip = middle(j); + self.set_tip(j, tip); + self.last_middle = Some(tip); } else { self.radius.push(self.key.size / 2.0); } diff --git a/crates/tools/src/draw2/gesture/tests.rs b/crates/tools/src/draw2/gesture/tests.rs index 87d18ca4b4..1ffcf1c37b 100644 --- a/crates/tools/src/draw2/gesture/tests.rs +++ b/crates/tools/src/draw2/gesture/tests.rs @@ -3622,6 +3622,73 @@ fn the_eraser_drag_area_takes_the_tip_halfway_along_each_step() { t.pointer(&cx, &PointerEvent { pressure: 1.0, ..PointerEvent::new(PointerKind::Up, 150.0, 150.0) }); } +/// A step of a round Eraser drag whose Size follows the pen shows as wide as the tip halfway along +/// it, as the release erases: with Size 10 pt on Pressure by up to 20 pt, a step from no pressure +/// (the tip at its 0.1 pt least) to full pressure (30 pt) shows 10 pt wide, not the 15.05 pt +/// halfway between the tips at its ends. +#[test] +fn a_round_eraser_drag_step_is_as_wide_as_the_tip_halfway_along_it() { + let (d, _) = doc_with_rect(); + let s = Selection::default(); + let p = paint(); + let cx = ToolContext { precise_cursors: true, ..cx(&d, &s, &p) }; + let mut t = GestureTool::new("eraser"); + for (k, v) in [("size", json!(10)), ("sizeMode", json!("pressure")), ("sizeVariation", json!(20))] { + t.set_option(k, &v); + } + t.pointer(&cx, &PointerEvent { pressure: 0.0, ..PointerEvent::new(PointerKind::Down, 50.0, 150.0) }); + t.pointer(&cx, &PointerEvent { pressure: 1.0, ..PointerEvent::new(PointerKind::Drag, 150.0, 150.0) }); + let o = t.overlays(&cx); + assert!(matches!(&o[..], [Overlay::Path { width, .. }] if (*width - 10.0).abs() < 1e-4), "{o:?}"); + t.pointer(&cx, &PointerEvent { pressure: 1.0, ..PointerEvent::new(PointerKind::Up, 150.0, 150.0) }); +} + +/// A pen tilted in place at the last point of an Eraser drag gives the last step the new tip halfway +/// along it, even where the tip at that point stays the same: with Size 10 pt on Tilt by up to 20 pt, +/// the tip at a pen leaning 80° and at one leaning 85° is the 0.1 pt least, while halfway along a +/// step from an upright pen it goes from 12.22 pt to 11.11 pt. +#[test] +fn the_eraser_drag_area_takes_the_new_tip_halfway_along_a_step_whose_end_tip_stays() { + let (d, _) = doc_with_rect(); + let s = Selection::default(); + let p = paint(); + let cx = ToolContext { precise_cursors: true, ..cx(&d, &s, &p) }; + let bounds = |t: &GestureTool| { + drain_area(t, &cx); + let o = t.overlays(&cx); + o.iter() + .filter_map(|o| match o { + Overlay::Path { path, .. } => Some(vectorcraft_geom::Shape::bounding_box(path)), + Overlay::SharedPath { path, .. } => Some(vectorcraft_geom::Shape::bounding_box(&**path)), + _ => None, + }) + .reduce(|a, b| a.union(b)) + .unwrap_or_else(|| panic!("{o:?}")) + }; + // The tip lying level, 4 times as long as it is wide: a step from x 50 to x 150 with a tip + // `size` long reaches `size` / 2 before and after it and `size` / 8 above and below. + let near = |b: vectorcraft_geom::Rect, size: f64| { + let want = (50.0 - size / 2.0, 150.0 - size / 8.0, 150.0 + size / 2.0, 150.0 + size / 8.0); + assert!([b.x0 - want.0, b.y0 - want.1, b.x1 - want.2, b.y1 - want.3].iter().all(|e| e.abs() < 0.01), "{b:?} vs {want:?}"); + }; + let mut t = GestureTool::new("eraser"); + for (k, v) in [("size", json!(10)), ("roundness", json!(25)), ("sizeMode", json!("tilt")), ("sizeVariation", json!(20))] { + t.set_option(k, &v); + } + let press = |t: &mut GestureTool, lean: f32, kind: PointerKind, x: f64| { + let pen = Some(PenPose { tilt: Some([lean, 0.0]), rotation: None, wheel: None }); + t.pointer(&cx, &PointerEvent { pen, pressure: 1.0, ..PointerEvent::new(kind, x, 150.0) }); + }; + press(&mut t, 0.0, PointerKind::Down, 50.0); + press(&mut t, 80.0, PointerKind::Drag, 150.0); + // Tilt reads 1 upright and 1/9 at 80°, 5/9 halfway: 10 + 20 × (2 × 5/9 − 1) pt. + near(bounds(&t), 10.0 + 20.0 / 9.0); + // At 85° Tilt reads 1/18, 19/36 halfway. + press(&mut t, 85.0, PointerKind::Drag, 150.0); + near(bounds(&t), 10.0 + 20.0 / 18.0); + press(&mut t, 85.0, PointerKind::Up, 150.0); +} + /// The outline of a long Eraser drag whose tip turns and changes shape with the pen is built a /// bounded amount per frame, and once finished it shows nothing inside the area: no point of it /// lies well inside the area of any step, each step with the tip halfway along it. diff --git a/crates/tools/src/lib.rs b/crates/tools/src/lib.rs index 688f295478..47ab6bd06c 100644 --- a/crates/tools/src/lib.rs +++ b/crates/tools/src/lib.rs @@ -618,6 +618,26 @@ pub(crate) mod testutil { PaintDefaults::default() } + /// With the Selection tool, a widget pressed at `at` and dragged to `q`, then released at `r`, is + /// dragged to `r` before the drag ends: the release keeps what a drag to `r` shows. Switching + /// tools during the drag cancels it, and the release after it commits nothing. + pub fn check_widget_release_and_tool_switch(cx: &ToolContext, at: Point, q: Point, r: Point) { + let pressed = || { + let mut t = crate::select::SelectionTool::default(); + t.pointer(cx, &PointerEvent::new(PointerKind::Down, at.x, at.y)); + assert!(!t.pointer(cx, &PointerEvent::new(PointerKind::Drag, q.x, q.y)).is_empty(), "the drag to {q:?} changes the widget"); + t + }; + let mut want = pressed().pointer(cx, &PointerEvent::new(PointerKind::Drag, r.x, r.y)); + assert!(!want.is_empty(), "the drag to {r:?} changes the widget"); + want.push(Action::Commit); + assert_eq!(pressed().pointer(cx, &PointerEvent::new(PointerKind::Up, r.x, r.y)), want, "released at {r:?}"); + let mut t = pressed(); + assert_eq!(t.deactivate(cx), vec![Action::Cancel], "a tool switch cancels the drag"); + assert!(!t.busy() && !t.transforming()); + assert!(t.pointer(cx, &PointerEvent::new(PointerKind::Up, q.x, q.y)).is_empty(), "the release commits nothing"); + } + /// An 800 × 600 window on a view at 100% turned `deg` degrees clockwise (Rotate View): at 90° /// one pixel right on screen is one point up the page. pub fn turned_view(deg: f64) -> Option { @@ -705,8 +725,12 @@ pub(crate) mod testutil { /// and a count must not include a refresh another test caused. static LAYOUT_INPUTS: std::sync::RwLock<()> = std::sync::RwLock::new(()); - pub fn steady_layout_inputs() -> std::sync::RwLockReadGuard<'static, ()> { - LAYOUT_INPUTS.read().unwrap_or_else(|e| e.into_inner()) + /// Catalogs the installed fonts, then also holds back the font changes other tests make without + /// [`changing_layout_inputs`] (a system font loaded for a character no loaded font covers, a + /// rescan) until it is dropped. + pub fn steady_layout_inputs() -> (std::sync::RwLockReadGuard<'static, ()>, vectorcraft_text::test_fonts::SteadyFonts) { + let inputs = LAYOUT_INPUTS.read().unwrap_or_else(|e| e.into_inner()); + (inputs, vectorcraft_text::test_fonts::steady_fonts(vectorcraft_text::FontDb::global())) } pub fn changing_layout_inputs() -> std::sync::RwLockWriteGuard<'static, ()> { diff --git a/crates/tools/src/meshblend.rs b/crates/tools/src/meshblend.rs index c9ab307028..89e640d48e 100644 --- a/crates/tools/src/meshblend.rs +++ b/crates/tools/src/meshblend.rs @@ -360,7 +360,7 @@ impl Tool for MeshTool { fn options(&self) -> serde_json::Value { self.edit.options() } - /// Pick the gradient mesh points the Eyedropper held (`meshPoints`). + /// Pick the gradient mesh points the tool chosen before held (`meshPoints`). fn set_option(&mut self, key: &str, value: &serde_json::Value) { if key == "meshPoints" { self.edit.set_options(value); diff --git a/crates/tools/src/meshedit.rs b/crates/tools/src/meshedit.rs index 71ae329c4c..2dbeaf07a7 100644 --- a/crates/tools/src/meshedit.rs +++ b/crates/tools/src/meshedit.rs @@ -325,7 +325,7 @@ impl MeshEdit { } /// Pick the points a `meshPoints` option lists (see [`points_of`]), with none focused: the - /// points the Eyedropper held when the tool switched back. + /// points the tool chosen before (another mesh-point tool or the Eyedropper) held. pub fn set_options(&mut self, value: &Value) { if self.drag.is_some() { return; diff --git a/crates/tools/src/mirror.rs b/crates/tools/src/mirror.rs index 31253003d9..feba99f51d 100644 --- a/crates/tools/src/mirror.rs +++ b/crates/tools/src/mirror.rs @@ -185,6 +185,22 @@ mod tests { assert!(MirrorAxis::of(&doc, &selection, 1.0).is_none()); } + /// With the Selection tool, a drag of the axis reads where it is released, and a tool switch + /// cancels it. + #[test] + fn an_axis_drag_reads_its_release_and_a_tool_switch_cancels_it() { + let (mut doc, id) = doc_with_rect(); + let mut source = doc.node(id).unwrap().clone(); + source.id = doc.alloc_id(); + doc.node_mut(id).unwrap().kind = NodeKind::Repeat(RepeatSpec::mirror(vec![Arc::new(source)], 90.0, 10.0)); + let mut selection = Selection::default(); + selection.set([id]); + let paint = paint(); + let cx = cx(&doc, &selection, &paint); + let at = MirrorAxis::of(&doc, &selection, 1.0).unwrap().center; + crate::testutil::check_widget_release_and_tool_switch(&cx, at, at + Vec2::new(20.0, 0.0), at + Vec2::new(40.0, 0.0)); + } + #[test] fn a_tool_switch_cancels_a_mirror_axis_drag() { use crate::{PointerEvent, PointerKind, Tool}; diff --git a/crates/tools/src/nineslice.rs b/crates/tools/src/nineslice.rs index 74f40b6bbf..d21a5f42a2 100644 --- a/crates/tools/src/nineslice.rs +++ b/crates/tools/src/nineslice.rs @@ -238,6 +238,15 @@ mod tests { assert_eq!(t.pointer(&c, &ev(PointerKind::Up, 150.0, 250.0)), vec![Action::Commit]); } + /// A guide drag reads where it is released, and a tool switch cancels it. + #[test] + fn a_guide_drag_reads_its_release_and_a_tool_switch_cancels_it() { + let d = editing(Some(SymbolNineSlice::default())); + let (s, p) = (Selection::default(), paint()); + let c = cx(&d, &s, &p); + check_widget_release_and_tool_switch(&c, Point::new(126.0, 150.0), Point::new(115.0, 150.0), Point::new(105.0, 150.0)); + } + /// Escape during a guide drag cancels it and is the tool's; the release after it commits /// nothing. A double-click on a guide neither edits the art nor leaves the mode. #[test] diff --git a/crates/tools/src/objects_on_path.rs b/crates/tools/src/objects_on_path.rs index dbb6f8bfdf..906600f334 100644 --- a/crates/tools/src/objects_on_path.rs +++ b/crates/tools/src/objects_on_path.rs @@ -948,6 +948,9 @@ pub struct ObjectsOnPathTool { member: Option, /// Where the pointer is while no button is down, for the Select/Move widget it is over. pointer: Option, + /// Where the pointer was at the last press or drag: a widget drag released anywhere else is + /// dragged there before it ends. + held_at: Option, /// The reference point of each object attached next (0-8, row by row from the top left). pivot: u8, /// The angle of each object attached next, in degrees counter-clockwise from upright on the path. @@ -956,7 +959,18 @@ pub struct ObjectsOnPathTool { impl Default for ObjectsOnPathTool { fn default() -> Self { - Self { hover: None, press: None, rotating: None, spacing: None, moving: None, member: None, pointer: None, pivot: CENTER, rotate: 0.0 } + Self { + hover: None, + press: None, + rotating: None, + spacing: None, + moving: None, + member: None, + pointer: None, + held_at: None, + pivot: CENTER, + rotate: 0.0, + } } } @@ -967,31 +981,51 @@ impl Tool for ObjectsOnPathTool { fn pointer(&mut self, cx: &ToolContext, ev: &PointerEvent) -> Vec { let p = ev.pos; + let released_away = ev.kind == PointerKind::Up && self.held_at != Some(p); + if matches!(ev.kind, PointerKind::Down | PointerKind::Drag) { + self.held_at = Some(p); + } if let Some(d) = &mut self.rotating { return match ev.kind { PointerKind::Drag => d.drag(cx, p, ev.mods.shift), - PointerKind::Up => self.rotating.take().map(RotateAllDrag::finish).unwrap_or_default(), + PointerKind::Up => { + let mut out = if released_away { d.drag(cx, p, ev.mods.shift) } else { vec![] }; + out.extend(self.rotating.take().map(RotateAllDrag::finish).unwrap_or_default()); + out + } _ => vec![], }; } if let Some(d) = &mut self.spacing { return match ev.kind { PointerKind::Drag => d.drag(cx, p, ev.mods.alt), - PointerKind::Up => self.spacing.take().map(SpaceDrag::finish).unwrap_or_default(), + PointerKind::Up => { + let mut out = if released_away { d.drag(cx, p, ev.mods.alt) } else { vec![] }; + out.extend(self.spacing.take().map(SpaceDrag::finish).unwrap_or_default()); + out + } _ => vec![], }; } if let Some(d) = &mut self.moving { return match ev.kind { PointerKind::Drag => d.drag(cx, p), - PointerKind::Up => self.moving.take().map(MoveAllDrag::finish).unwrap_or_default(), + PointerKind::Up => { + let mut out = if released_away { d.drag(cx, p) } else { vec![] }; + out.extend(self.moving.take().map(MoveAllDrag::finish).unwrap_or_default()); + out + } _ => vec![], }; } if let Some(d) = &mut self.member { return match ev.kind { PointerKind::Drag => d.drag(cx, p), - PointerKind::Up => self.member.take().map(MemberDrag::finish).unwrap_or_default(), + PointerKind::Up => { + let mut out = if released_away { d.drag(cx, p) } else { vec![] }; + out.extend(self.member.take().map(MemberDrag::finish).unwrap_or_default()); + out + } _ => vec![], }; } @@ -1084,6 +1118,11 @@ impl Tool for ObjectsOnPathTool { vec![] } + /// Switching tools while the button is down cancels the click or the drag, as Escape does. + fn deactivate(&mut self, cx: &ToolContext) -> Vec { + self.key(cx, ToolKey::Escape, Mods::default()) + } + fn options(&self) -> Value { json!({ "pivot": self.pivot, "rotate": self.rotate }) } @@ -1508,7 +1547,7 @@ mod tests { assert!(matches!(a.last(), Some(Action::Preview(_, p)) if p["spacing"] == "auto" && p["start"] == 0.0), "{id}: {a:?}"); assert_eq!(spaced(&t.pointer(&c, &ev(PointerKind::Drag, at.x - 900.0, at.y))), Some((0.0, 0.0)), "{id}"); assert_eq!(spaced(&t.pointer(&c, &alt(PointerKind::Drag, at.x - 900.0, at.y))), Some((0.0, 200.0)), "{id}"); - assert_eq!(t.pointer(&c, &ev(PointerKind::Up, at.x, at.y)), vec![Action::Commit], "{id}"); + assert_eq!(t.pointer(&c, &alt(PointerKind::Up, at.x - 900.0, at.y)), vec![Action::Commit], "{id}"); assert!(!t.busy(), "{id}"); // A click on the widget that does not move changes nothing. assert!(t.pointer(&c, &ev(PointerKind::Down, at.x, at.y)).is_empty()); @@ -1730,7 +1769,7 @@ mod tests { assert_eq!(moved(&t.pointer(&c, &ev(PointerKind::Drag, at.x + 900.0, at.y))), Some((300.0, None)), "{id}"); assert_eq!(moved(&t.pointer(&c, &ev(PointerKind::Drag, at.x + 880.0, at.y))), Some((280.0, None)), "{id}"); assert_eq!(moved(&t.pointer(&c, &ev(PointerKind::Drag, at.x - 900.0, at.y))), Some((0.0, None)), "{id}"); - assert_eq!(t.pointer(&c, &ev(PointerKind::Up, at.x, at.y)), vec![Action::Commit], "{id}"); + assert_eq!(t.pointer(&c, &ev(PointerKind::Up, at.x - 900.0, at.y)), vec![Action::Commit], "{id}"); assert!(!t.busy(), "{id}"); // A click on the widget that does not move changes nothing. assert!(t.pointer(&c, &ev(PointerKind::Down, at.x, at.y)).is_empty()); @@ -2007,6 +2046,85 @@ mod tests { } } + /// The release is read where it happens: a release away from the last drag event drags the + /// widget there before the drag ends, with the Selection tool and the Objects on Path tool. + #[test] + fn the_release_position_sets_each_widget() { + let new_tools = || -> [Box; 2] { [Box::new(crate::select::SelectionTool::default()), Box::new(ObjectsOnPathTool::default())] }; + let paint = paint(); + let (d, _, sel) = group_doc(0.0); + let c = cx(&d, &sel, &paint); + for mut t in new_tools() { + let (at, q, r) = (around(0.0), around(60.0), around(90.0)); + t.pointer(&c, &ev(PointerKind::Down, at.x, at.y)); + t.pointer(&c, &ev(PointerKind::Drag, q.x, q.y)); + let a = t.pointer(&c, &ev(PointerKind::Up, r.x, r.y)); + let (last, shown) = a.split_last().unwrap(); + assert_eq!(last, &Action::Commit, "{}", t.id()); + assert!(previewed(shown).is_some_and(|deg| (deg - 90.0).abs() < 1e-9), "{}: Rotate All {a:?}", t.id()); + } + let at = SpaceWidget::of(&d, &sel, 1.0).unwrap().at; + for mut t in new_tools() { + t.pointer(&c, &ev(PointerKind::Down, at.x, at.y)); + t.pointer(&c, &ev(PointerKind::Drag, at.x - 100.0, at.y)); + let a = t.pointer(&c, &ev(PointerKind::Up, at.x - 50.0, at.y)); + let (last, shown) = a.split_last().unwrap(); + assert_eq!(last, &Action::Commit, "{}", t.id()); + assert_eq!(spaced(shown), Some((350.0, 0.0)), "{}: Space {a:?}", t.id()); + } + let (d, _, sel) = spaced_doc(Some(100.0), 50.0); + let c = cx(&d, &sel, &paint); + let at = MoveAllWidget::of(&d, &sel, 1.0).unwrap().at; + for mut t in new_tools() { + t.pointer(&c, &ev(PointerKind::Down, at.x, at.y)); + t.pointer(&c, &ev(PointerKind::Drag, at.x + 80.0, at.y)); + let a = t.pointer(&c, &ev(PointerKind::Up, at.x + 90.0, at.y)); + let (last, shown) = a.split_last().unwrap(); + assert_eq!(last, &Action::Commit, "{}", t.id()); + assert_eq!(moved(shown), Some((140.0, None)), "{}: Move All {a:?}", t.id()); + } + let (d, _, sel, ids) = three_doc(); + let c = cx(&d, &sel, &paint); + for mut t in new_tools() { + t.pointer(&c, &ev(PointerKind::Down, 200.0, 300.0)); + t.pointer(&c, &ev(PointerKind::Drag, 280.0, 310.0)); + let a = t.pointer(&c, &ev(PointerKind::Up, 330.0, 300.0)); + assert_eq!(previewed_target(&a), Some(ids[2].0), "{}: Select/Move {a:?}", t.id()); + assert_eq!(a[1..], [Action::Commit, choose(ids[1])], "{}", t.id()); + } + } + + /// Switching tools during a widget drag cancels it, as Escape does, with the Selection tool and + /// the Objects on Path tool; after a press that has not moved there is nothing to put back. + #[test] + fn a_tool_switch_cancels_a_widget_drag() { + let new_tools = || -> [Box; 2] { [Box::new(crate::select::SelectionTool::default()), Box::new(ObjectsOnPathTool::default())] }; + let paint = paint(); + let (d, _, sel) = group_doc(0.0); + let (md, _, msel) = spaced_doc(Some(100.0), 50.0); + let (od, _, osel, _) = three_doc(); + let space = SpaceWidget::of(&d, &sel, 1.0).unwrap().at; + let move_all = MoveAllWidget::of(&md, &msel, 1.0).unwrap().at; + let presses = [ + (cx(&d, &sel, &paint), around(0.0), around(60.0)), + (cx(&d, &sel, &paint), space, space - Vec2::new(100.0, 0.0)), + (cx(&md, &msel, &paint), move_all, move_all + Vec2::new(80.0, 0.0)), + (cx(&od, &osel, &paint), Point::new(200.0, 300.0), Point::new(330.0, 300.0)), + ]; + for (c, at, q) in &presses { + for mut t in new_tools() { + t.pointer(c, &ev(PointerKind::Down, at.x, at.y)); + assert!(!t.pointer(c, &ev(PointerKind::Drag, q.x, q.y)).is_empty(), "{}", t.id()); + assert_eq!(t.deactivate(c), vec![Action::Cancel], "{} at {at:?}", t.id()); + assert!(!t.busy() && !t.transforming(), "{}", t.id()); + assert!(t.pointer(c, &ev(PointerKind::Up, q.x, q.y)).is_empty(), "{}: the release keeps nothing", t.id()); + t.pointer(c, &ev(PointerKind::Down, at.x, at.y)); + assert!(t.deactivate(c).is_empty(), "{}", t.id()); + assert!(!t.busy(), "{}", t.id()); + } + } + } + /// Round a closed path the drag goes on across the first anchor: the first object, dragged back /// past it, takes the last place. #[test] diff --git a/crates/tools/src/pie.rs b/crates/tools/src/pie.rs index ae9d934954..cf1b22bc57 100644 --- a/crates/tools/src/pie.rs +++ b/crates/tools/src/pie.rs @@ -310,6 +310,16 @@ mod tests { assert!(t.pointer(&c, &ev(PointerKind::Up, Point::new(100.0, 200.0))).is_empty(), "the release commits nothing"); } + /// A pie widget drag with the Selection tool reads where it is released, and a tool switch + /// cancels it. + #[test] + fn a_pie_widget_drag_reads_its_release_and_a_tool_switch_cancels_it() { + let (d, _, s) = doc_with_ellipse((0.0, 360.0)); + let p = paint(); + let c = cx(&d, &s, &p); + check_widget_release_and_tool_switch(&c, Point::new(312.0, 150.0), Point::new(200.0, 20.0), Point::new(100.0, 150.0)); + } + /// On a whole ellipse the two widgets sit at the very same point, whatever its size, place or /// angle, so a press there always takes the End widget. #[test] diff --git a/crates/tools/src/repeat_grid.rs b/crates/tools/src/repeat_grid.rs index eecc6ba0fe..3513e362d1 100644 --- a/crates/tools/src/repeat_grid.rs +++ b/crates/tools/src/repeat_grid.rs @@ -369,6 +369,17 @@ mod tests { assert!(GridDrag::hit(&c, g.rows_at, Mods { alt: true, ..Mods::default() }).is_none()); } + /// With the Selection tool, a handle drag reads where it is released, and a tool switch cancels + /// it. + #[test] + fn a_handle_drag_reads_its_release_and_a_tool_switch_cancels_it() { + let (doc, selection) = grid(); + let paint = paint(); + let c = cx(&doc, &selection, &paint); + let g = GridHandles::of(&doc, &selection, crate::select::selection_box(&c), 1.0).unwrap(); + crate::testutil::check_widget_release_and_tool_switch(&c, g.rows_at, g.rows_at + Vec2::new(0.0, 240.0), g.rows_at + Vec2::new(0.0, 360.0)); + } + #[test] fn a_bounding_box_handle_wins_where_they_overlap() { let (doc, selection) = grid(); diff --git a/crates/tools/src/repeat_radial.rs b/crates/tools/src/repeat_radial.rs index 7304570404..986d98bb49 100644 --- a/crates/tools/src/repeat_radial.rs +++ b/crates/tools/src/repeat_radial.rs @@ -533,6 +533,17 @@ mod tests { assert!(RadialDrag::hit(&c, h.instances_at, Mods { alt: true, ..Mods::default() }).is_none()); } + /// With the Selection tool, a handle drag reads where it is released, and a tool switch cancels + /// it. + #[test] + fn a_handle_drag_reads_its_release_and_a_tool_switch_cancels_it() { + let (doc, selection) = radial(); + let paint = paint(); + let c = cx(&doc, &selection, &paint); + let at = RadialHandles::of(&doc, &selection, crate::select::selection_box(&c), 1.0).unwrap().instances_at; + crate::testutil::check_widget_release_and_tool_switch(&c, at, at + Vec2::new(0.0, 32.0), at + Vec2::new(0.0, 64.0)); + } + #[test] fn dragging_the_radius_handle_moves_the_circle_in_and_out() { let (doc, selection) = radial(); diff --git a/crates/tools/src/select.rs b/crates/tools/src/select.rs index fc18a978e6..a562024839 100644 --- a/crates/tools/src/select.rs +++ b/crates/tools/src/select.rs @@ -58,6 +58,14 @@ use crate::sidewidget::{self, SideDrag}; use crate::typewidget; use crate::{Action, Cursor, Mods, Overlay, PixelOp, PointerEvent, PointerKind, Tool, ToolContext, ToolKey, json_ids}; +/// The release of the widget drag `d`: released away from the last press or drag (`away`), it is +/// dragged there first (`drag`); then it ends (`finish`). +fn released(mut d: D, away: bool, drag: impl FnOnce(&mut D) -> Vec, finish: impl FnOnce(D) -> Vec) -> Vec { + let mut out = if away { drag(&mut d) } else { vec![] }; + out.extend(finish(d)); + out +} + /// Direction is read on screen, even in a turned view. Within three pixels of the press's /// horizontal position, retain the previous rule so hand jitter does not flip it. fn marquee_direction(cx: &ToolContext, start: Point, cur: Point, previous: bool) -> bool { @@ -213,6 +221,9 @@ pub struct SelectionTool { loaded_at_press: Option<(NodeId, bool)>, /// Where the pointer last hovered: the type on a path bracket under it draws thicker. bracket_hover: Option, + /// Where the pointer was at the last press or drag: a widget drag released anywhere else is + /// dragged there before it ends. + held_at: Option, } /// What Distance Guides measure the selection to. @@ -784,6 +795,16 @@ impl SelectionTool { } } + /// Notes where a press or a drag last held the pointer, and says whether a release lands + /// somewhere else. + fn note_held_at(&mut self, ev: &PointerEvent) -> bool { + let released_away = ev.kind == PointerKind::Up && self.held_at != Some(ev.pos); + if matches!(ev.kind, PointerKind::Down | PointerKind::Drag) { + self.held_at = Some(ev.pos); + } + released_away + } + /// The pointer loaded with the text of area type or type on a path `from` ([`State::Loaded`]): /// a press starts placing it, and its release threads it (`text.thread.add`), into a frame put /// `before` `from` or after it. None when `from` can no longer thread: the press is an @@ -945,20 +966,33 @@ impl Tool for SelectionTool { out } - /// Switching tools during a drag of a blend widget, a corner widget, a pie widget, a - /// polygon's side widget, a mirror axis, a grid or radial repeat's handles or an Image Trace - /// divider cancels it, as Escape does: its value goes back. + /// Switching tools during a drag of a widget (a blend, corner, pie or side widget, an Objects on + /// Path widget, a bracket of type on a path, a repeat's control, a 9-slice guide or an Image + /// Trace divider) cancels it, as Escape does: its value goes back. fn deactivate(&mut self, _cx: &ToolContext) -> Vec { match std::mem::take(&mut self.state) { State::BlendWidget(d) if d.adjusting() => vec![Action::Cancel], State::Corner(c) if c.adjusting() => vec![Action::Cancel], State::Pie(d) if d.adjusting() => vec![Action::Cancel], + State::RotateAll(d) if d.adjusting() => vec![Action::Cancel], + State::Space(d) if d.adjusting() => vec![Action::Cancel], + State::MoveAll(d) if d.adjusting() => vec![Action::Cancel], + State::Member(d) if d.adjusting() => vec![Action::Cancel], + State::Bracket(b) if b.adjusting() => vec![Action::Cancel], State::Sides(d) => d.cancel(), State::Mirror(d) => d.cancel(), State::GridRepeat(d) => d.cancel(), State::RadialRepeat(d) => d.cancel(), + State::NineSlice(d) => d.cancel(), State::TraceSplit(d) => d.cancel(), - State::BlendWidget(_) | State::Corner(_) | State::Pie(_) => vec![], + State::BlendWidget(_) + | State::Corner(_) + | State::Pie(_) + | State::RotateAll(_) + | State::Space(_) + | State::MoveAll(_) + | State::Member(_) + | State::Bracket(_) => vec![], other => { self.state = other; vec![] @@ -1026,6 +1060,7 @@ impl Tool for SelectionTool { /// the art; the drags then move, scale, rotate, marquee or drag what it took. fn pointer(&mut self, cx: &ToolContext, ev: &PointerEvent) -> Vec { self.note_loaded_at_press(ev.kind); + let released_away = self.note_held_at(ev); let hovering = ev.kind == PointerKind::Move && matches!(self.state, State::Idle); self.bracket_hover = hovering.then_some(ev.pos); self.alt_hover = hovering && ev.mods.alt; @@ -1036,7 +1071,7 @@ impl Tool for SelectionTool { return out; } // The edited symbol's 9-slice guides take precedence over every other control and the art. - if let Some(out) = self.nine_slice_guides(cx, ev) { + if let Some(out) = self.nine_slice_guides(cx, ev, released_away) { return out; } // Mirror and grid repeat controls take precedence over art and ruler guides; the mirror @@ -1181,7 +1216,7 @@ impl Tool for SelectionTool { } (PointerKind::Up, State::Corner(c)) => { self.state = State::Idle; - c.finish() + released(c, released_away, |c| c.drag(cx, p), CornerDrag::finish) } (PointerKind::Drag, State::Pie(mut d)) => { let out = d.drag(cx, p); @@ -1190,7 +1225,7 @@ impl Tool for SelectionTool { } (PointerKind::Up, State::Pie(d)) => { self.state = State::Idle; - d.finish() + released(d, released_away, |d| d.drag(cx, p), PieDrag::finish) } (PointerKind::Drag, State::Sides(mut d)) => { let out = d.drag(cx, p); @@ -1210,7 +1245,7 @@ impl Tool for SelectionTool { } (PointerKind::Up, State::BlendWidget(d)) => { self.state = State::Idle; - d.finish() + released(d, released_away, |d| d.drag(cx, p), BlendWidgetDrag::finish) } (PointerKind::Drag, State::RotateAll(mut d)) => { let out = d.drag(cx, p, m.shift); @@ -1219,7 +1254,7 @@ impl Tool for SelectionTool { } (PointerKind::Up, State::RotateAll(d)) => { self.state = State::Idle; - d.finish() + released(d, released_away, |d| d.drag(cx, p, m.shift), RotateAllDrag::finish) } (PointerKind::Drag, State::Space(mut d)) => { let out = d.drag(cx, p, m.alt); @@ -1228,7 +1263,7 @@ impl Tool for SelectionTool { } (PointerKind::Up, State::Space(d)) => { self.state = State::Idle; - d.finish() + released(d, released_away, |d| d.drag(cx, p, m.alt), SpaceDrag::finish) } (PointerKind::Drag, State::MoveAll(mut d)) => { let out = d.drag(cx, p); @@ -1237,7 +1272,7 @@ impl Tool for SelectionTool { } (PointerKind::Up, State::MoveAll(d)) => { self.state = State::Idle; - d.finish() + released(d, released_away, |d| d.drag(cx, p), MoveAllDrag::finish) } (PointerKind::Drag, State::Member(mut d)) => { let out = d.drag(cx, p); @@ -1246,7 +1281,7 @@ impl Tool for SelectionTool { } (PointerKind::Up, State::Member(d)) => { self.state = State::Idle; - d.finish() + released(d, released_away, |d| d.drag(cx, p), MemberDrag::finish) } (PointerKind::Drag, State::Bracket(mut b)) => { let out = b.drag(cx, p, m.cmd); @@ -1255,7 +1290,7 @@ impl Tool for SelectionTool { } (PointerKind::Up, State::Bracket(b)) => { self.state = State::Idle; - b.finish() + released(b, released_away, |b| b.drag(cx, p, m.cmd), BracketDrag::finish) } (PointerKind::Up, State::Moving { began, deselect, key, exclude, .. }) => { self.release_move(cx, ev.backquote, began, deselect, key, exclude) @@ -1648,8 +1683,8 @@ impl SelectionTool { } /// A press on a 9-slice guide of the edited symbol starts dragging it; the drag and the - /// release go to it. - fn nine_slice_guides(&mut self, cx: &ToolContext, ev: &PointerEvent) -> Option> { + /// release go to it, and a release away from the last drag (`released_away`) moves it there. + fn nine_slice_guides(&mut self, cx: &ToolContext, ev: &PointerEvent, released_away: bool) -> Option> { if let State::NineSlice(mut d) = self.state.clone() { return Some(match ev.kind { PointerKind::Drag => { @@ -1659,7 +1694,7 @@ impl SelectionTool { } PointerKind::Up => { self.state = State::Idle; - d.finish() + released(d, released_away, |d| d.drag(cx, ev.pos), crate::nineslice::GuideDrag::finish) } _ => vec![], }); diff --git a/crates/tools/src/select/tests.rs b/crates/tools/src/select/tests.rs index dd9c25b74d..2cf9891693 100644 --- a/crates/tools/src/select/tests.rs +++ b/crates/tools/src/select/tests.rs @@ -654,6 +654,28 @@ fn escape_cancels_a_bracket_drag() { assert!(t.pointer(&cx, &ev(PointerKind::Up, 330.0, 290.0)).is_empty(), "the release commits nothing"); } +/// A bracket drag of type on a path reads where it is released, and a tool switch cancels it. +#[test] +fn a_bracket_drag_reads_its_release_and_a_tool_switch_cancels_it() { + let (d, id) = crate::testutil::doc_with_path_type(); + let mut s = Selection::default(); + s.add(id); + let p = paint(); + let cx = cx(&d, &s, &p); + check_widget_release_and_tool_switch(&cx, Point::new(280.0, 290.0), Point::new(320.0, 290.0), Point::new(340.0, 290.0)); +} + +/// A corner widget drag reads where it is released, and a tool switch cancels it. +#[test] +fn a_corner_widget_drag_reads_its_release_and_a_tool_switch_cancels_it() { + let (d, id) = doc_with_live_rect(); + let mut s = Selection::default(); + s.add(id); + let p = paint(); + let cx = cx(&d, &s, &p); + check_widget_release_and_tool_switch(&cx, Point::new(190.0, 191.0), Point::new(175.0, 176.0), Point::new(165.0, 166.0)); +} + /// #812: with Smart Guides on, hovering near an object's centre or an anchor labels it, and a /// press there grabs the object by that point. #[test] diff --git a/crates/tools/src/shape.rs b/crates/tools/src/shape.rs index 7376efd5b0..b93c94dddc 100644 --- a/crates/tools/src/shape.rs +++ b/crates/tools/src/shape.rs @@ -973,9 +973,11 @@ impl Tool for ShapeTool { fn ends_on_escape(&self, _cx: &ToolContext) -> bool { !self.through.is_empty() } - /// The pointer left the canvas: the circle's preview through it goes. + /// The pointer left the canvas: the circle's preview through it and the Smart Guide of the + /// hover go. fn hover_ended(&mut self, _cx: &ToolContext) { self.hover = None; + self.snap.clear(); } /// An edit, Undo or Redo made outside the tool, or another document, drops the points placed /// for a circle. diff --git a/crates/tools/src/shape/tests.rs b/crates/tools/src/shape/tests.rs index 59ae1d8e83..fa089bf4e7 100644 --- a/crates/tools/src/shape/tests.rs +++ b/crates/tools/src/shape/tests.rs @@ -968,6 +968,23 @@ fn corners_snap_to_smart_guides() { assert!(t.overlays(&cx).iter().any(|o| matches!(o, Overlay::Measure { text, .. } if text == &cx.segment_measure_label(from, to)))); } +/// The "anchor" label a hover shows goes when the pointer leaves the canvas, for every shape tool. +#[test] +fn leaving_the_canvas_drops_the_hover_label() { + let (d, _) = doc_with_rect(); + let s = Selection::default(); + let p = paint(); + let cx = cx(&d, &s, &p); + let label = |o: &[Overlay]| o.iter().any(|o| matches!(o, Overlay::Label { text, .. } if text == "anchor")); + for id in ["rectangle", "roundedRectangle", "ellipse", "polygon", "star", "lineSegment"] { + let mut t = ShapeTool::new(id); + t.pointer(&cx, &PointerEvent::new(PointerKind::Move, 98.0, 102.0)); + assert!(label(&t.overlays(&cx)), "{id}"); + t.hover_ended(&cx); + assert!(!label(&t.overlays(&cx)), "{id}: {:?}", t.overlays(&cx)); + } +} + /// Line Segment Tool Options: Length and Angle are options (for a click's dialog), and Fill /// Line makes the drag's line take the current fill. #[test] diff --git a/crates/tools/src/xform/freeform.rs b/crates/tools/src/xform/freeform.rs index 89c6faa933..3e3eef28b2 100644 --- a/crates/tools/src/xform/freeform.rs +++ b/crates/tools/src/xform/freeform.rs @@ -8,14 +8,15 @@ //! //! Points mode (the Gradient panel's Draw toggle): a click inside the selected art adds a point //! there, coloured as the gradient is there. Lines mode: successive clicks draw a smooth line -//! through the points they add, until Escape (or a click off the art) ends it; clicking an -//! existing point first starts the line from it. Delete or Backspace removes the selected point. +//! through the points they add, until Escape, a click off the art or moving the pointer out of +//! the object ends it; clicking an existing point first starts the line from it. Delete or +//! Backspace removes the selected point. use serde_json::{Value, json}; use vectorcraft_color::freeform::LineHit; use vectorcraft_color::{Color, Freeform, FreeformMode, FreeformPoint}; use vectorcraft_doc::NodeId; -use vectorcraft_doc::hit::hit_test; +use vectorcraft_doc::hit::{HitOptions, hit_test, hit_test_visible_skipping}; use vectorcraft_geom::{Point, Shape, Vec2}; use super::paint_owner; @@ -183,6 +184,44 @@ fn on_art(cx: &ToolContext, p: Point) -> bool { hit_test(cx.doc, p, cx.hit_options()).is_some_and(|h| cx.selection.objects.contains(&paint_owner(cx.doc, h.leaf))) } +/// Is `p` on object `id`: inside its path's area (where a dragged point stays) and every clipping +/// mask above it, or on its own art where a click hits it with the art lying over it left out (a +/// stroke, type's glyphs)? +fn on_object(cx: &ToolContext, id: NodeId, p: Point) -> bool { + let Some(n) = cx.doc.node(id) else { return false }; + let ancestry = cx.doc.ancestry(id).unwrap_or_default(); + let contains = |shapes: &[(vectorcraft_geom::BezPath, vectorcraft_geom::FillRule)]| { + shapes.iter().any(|(bp, rule)| vectorcraft_geom::hit::fill_contains(bp, *rule, p)) + }; + // A mask with a live effect clips by the effect's result, which the hit test below measures. + let plain = |clip: &vectorcraft_doc::Node| { + let mut effects = false; + clip.walk(&mut |c| { + effects |= c.appearance.effects.iter().any(|e| e.visible) || c.appearance.items.iter().any(|i| i.effects().iter().any(|e| e.visible)); + }); + !effects + }; + let unmasked = || { + ancestry.iter().filter_map(|a| cx.doc.node(*a)).filter(|a| a.clips()).all(|a| { + a.children() + .and_then(|c| c.first()) + .is_none_or(|clip| clip.id == id || plain(clip) && contains(&vectorcraft_doc::hit::clip_regions(clip))) + }) + }; + if contains(&n.clip_shapes(None)) && unmasked() { + return true; + } + let mut keep = std::collections::HashSet::new(); + n.walk(&mut |c| { + keep.insert(c.id); + }); + keep.extend(ancestry); + // The art as painted, whatever the view, the layers' Preview and the path-only selection + // preferences. + let opt = HitOptions { outline: false, path_only: false, type_path_only: false, ignore_layer_preview: true, ..cx.hit_options() }; + hit_test_visible_skipping(cx.doc, p, opt, &|n| !keep.contains(&n)).is_some_and(|h| h.leaf == id || h.ancestry.contains(&id)) +} + pub(super) fn press(cx: &ToolContext, a: &Annotator, p: Point) -> (Vec, Gesture) { let mut out = vec![]; let grab = if let Some(i) = a.point_at(cx, p) { @@ -293,8 +332,13 @@ pub(super) fn double_click(cx: &ToolContext, a: &Annotator, p: Point) -> Vec