Answers the fourth CodeRabbit review on #8549.
When a fill pass finishes lines beyond MAX_PARKED, their unstroked
glyphs are recorded (bounded at 4096). The first stroke after that
which could have gone over one of them ends the stroke pass, so a TJ
over more than 65 lines that comes back to where it began stays a
filled object and a stroked one for each part, as documented. Any
other first stroke drops the record, so type after an overflowing TJ,
filled only or not, is matched as before.
MAX_HELD's doc now says that one operator filling the same run of more
than 4096 glyphs twice at the same places is matched as well as it can
be: the reader tells no operator's start.
Answers the third CodeRabbit review on #8549.
- stroke_last no longer restyles the glyph drawn last once a boundary
(end_fills) closed it: a stroke after an ActualText span no longer
strokes its replacement text. A glyph stroked again where it was just
drawn still stays one object.
- Past MAX_HELD, the held strokes go over the last run of consecutive
fills they match with room for all of them, not the first, so a long
stroke pass no longer takes the same glyphs an earlier operator
filled at the same place.
- Docs: the limit is 64 kept-back lines plus the open one, so a TJ over
up to 65 lines stays filled and stroked.
Answers the second CodeRabbit review on #8549.
- A stroke that goes over no filled glyph (stroked type of its own) and
the start and end of an ActualText span now end the stroke pass
(Builder::end_fills): the held strokes are matched, the parked lines
finished and the open line's fills closed, so a later stroke can't go
over an earlier fill and a later span keeps its own replacement text.
- ActualText fills are ordinary entries in the line's fill list, and
span strokes are held and matched in replay order like any other, so
an A/B/A TJ in a span strokes the replacement. The actual_fills map,
stroke_parked and has_actual_fill are gone.
- Past MAX_HELD, the held strokes are matched to the first run of
glyphs filled one right after another that they go over
(Builder::replayed), with bounded work, instead of each to its first
match, which could reach an earlier operator's fill.
- Docs state that past 64 lines in one operator each part stays a
filled object and a stroked one.
A TJ can draw the same glyph at the same place twice (its kerning goes
back), so a stroke can't be matched to a filled glyph as it arrives:
[(A) -3500 (B) 4834 (A)] TJ put the first A's stroke on the last A and
left the earlier parts unstroked. Strokes over filled glyphs are now
held until their stroke pass ends and then matched to the glyphs filled
last, in the order they were filled, so each copy is stroked where it
was filled, while a glyph filled and stroked where one filled before
stands still strokes only the newest. At most 4096 strokes are held.
Docs: ordinary text gives one filled and stroked object per part; in an
ActualText span it stays one replacement object on the first glyph's
line and style.
The reader fills every glyph of a text-showing operator, then strokes
them. When a TJ's kerning started a new line part way through, the
first line was finished before the stroke pass came back to it, so its
strokes found no filled glyph and came in as stroke-only type over
fill-only type.
A line a glyph doesn't fit is now parked while a stroke may still be
drawn over it, and a stroke-only glyph is matched against the open line
and then the parked lines, newest first. Parked lines are finished
oldest first before the open line, so drawing order is kept, and at
most 64 are parked.
The writer passed no language to craft-pdf, so exported and printed
PDFs had no /Lang and accessibility checkers failed primary-language.
Writer::new now passes the BCP 47 tag of the Document Setup language
(new vectorcraft_doc::setup::language_tag, en-US by default) through
write::Writer::new_with_language, which writes the catalog's /Lang and
the XMP dc:language. A language with no tag writes none. /MarkInfo is
left for tagged PDF (#3643).
File > Open's Import PDF dialog now starts with Import PDF pages as links
checked for All, so every page of a PDF opened from its file opens
linked, and clears the box when Range is picked, so a range opens as
art. A box checked or cleared by hand keeps that state until the other
of All and Range is picked; ui.dialog.set of allPages does the same.
The box stays clear for a file without its path, with a password, or
over the 256 MB that linkPages takes (fileio::pages_can_link).
Docs: docs/mcp.md, docs/target-app-parity.md, docs/file-format-parity.md.
Conflicts in docs only (the status lines, the changelog rows, the M4 Files
row and the File formats rows): main's entries and this branch's are both
kept, each once.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Look::takes let a glyph filled only join a run whose glyphs were also
stroked, so after mode 2 text a mode 0 glyph took the run's stroke:
`2 Tr (B) Tj 0 Tr (C) Tj` came in as "BC" stroked throughout. A glyph
now joins only a run drawn alike (fill, stroke, overprints), so a glyph
filled only starts a run of its own and takes a stroke only when the
matched-stroke path (#8039) strokes it.
flush_stroke no longer strokes a whole run in place: a whole run goes
through the split and join code, so fill and stroke rendering glyph by
glyph still builds one stroked run.
The check that a stack's patterns are each its own took each style item's
pattern once, but not that the drawn look places it one way:
`placed_paints` keeps a pattern's first placement, so a look filling with
one pattern at two placements, for a style that names it once, came in
with the first placement for both. `placed_paints` now also notes each
pattern the look places otherwise than its first placement, and a stack
with such a pattern keeps its drawn look. The same placement again, as a
compound path's look has for each subpath, is still one.
Test `a_look_placing_a_stacks_pattern_twice_keeps_the_drawn_look` (two
placements keep the look; the same one twice comes in as the path).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A fill and a stroke at the same opacity below 1 were joined into one
type object whose opacity then applies to both together, losing the
darker overlap the file composites. stroke_filled now takes a stroke
only when the fill and the stroke are opaque.
An upright glyph filled and stroked was kept as an outline for the
reshaped-outline fallback while upright glyphs filled only were not;
it is no longer kept either, so such a line can't come in as the
outlines of its stroked glyphs alone.
Docs: the #8015 entries say what is left (translucent type, and a TJ
that starts a new line part way through).
- The steps of a live blend are written as drawn art: copies of key
objects with text wrap options no longer write those options again.
The keys keep theirs on the hidden lines and the blend keeps its own.
- The record holds Specified Distance as a 32-bit float, which the
reader reads back as its shortest decimal. The writer now compares the
blend with that distance, so a distance typed in another unit (10 mm
is 28.346456... pt) is written live when it lays out as many steps.
- blend_steps_settled has unit tests for each of its cases.
- blends_write_the_same_bytes_again checks that every blend is written
live both times.
- Comments name the blend plugin's XP line by its constant.
- docs/target-app-parity.md lists live blends in the .ai editing copy;
a line in docs/file-format-parity.md is wrapped like the rest.
Tests: a_live_blends_steps_carry_no_text_wrap_options,
a_blend_spaced_in_millimeters_is_written_live,
steps_settle_unless_rounding_can_change_their_count.
The reader also counts pattern brushes, a pen's included, whose bitmap
it could not read, so the warning now says "image or pattern brush".
The document.open and clipboard.importEmf params text, docs/mcp.md and
the crate doc list the new warnings. A WMF test covers an unreadable
pattern brush and a DSTINVERT bit block transfer.
craft-metafile now reports what it does not read or play as the file
asks. The importer uses it:
- A file, or a metafile image inside it, cut short by any of the
reader's limits (items, bytes kept, saved states, clip paths) warns
that what came after the limit was not read. The warning no longer
depends on the count of objects, so a file with exactly 200,000
objects opens without it.
- Images that are not read, clips that are not applied and raster
operations other than a plain copy each add a warning with a count.
The editing copy of a PDF-compatible .ai wrote every blend as its steps.
Blends the .ai reader opens live are now written live:
- The blend's key objects and, when it has a spine of its own, its
spine are written as a group on hidden lines, each key's dictionary
naming it a key and its id and the spine's naming it the spine. Its
steps follow as a group, then the Path Blends record of its spacing
(Smooth Color, Specified Steps, Specified Distance with its distance),
orientation (Align to Page, Align to Path) and keys, then its
dictionary (name, text wrap options, variables) and its opacity and
blending mode as a group's after its end. A spine edited on the canvas
is written with each key's anchor on the key. A replaced spine is
written with an anchor where each key sits, so it opens with those
anchors and lays out the same steps.
- Each blend is checked with the reader's own reading before it is
written, and the blends together against the objects the reader lays
out in one file. Written as their steps with a warning: blends with
easing, a color shift or start points; with effects, an appearance or
an opacity mask of their own; of objects other than paths, compound
paths and groups, of clipping groups, of more than 62 key objects, of
hidden keys or keys holding a blend; of keys with geometry or
Pathfinder effects or a group's own fills and strokes, which the
editing copy writes as their result; of keys the editing copy would
change otherwise (empty paths or subpaths, paths and compound path
members of several subpaths, several fills or strokes, strokes a plain
line can't draw, dashes of more than 64 lengths, hidden fills or strokes, fills or strokes other than
a color, in a Lab color or with transparency or effects of their own,
effects, opacity masks); blends where one key has a fill or stroke of
no paint or a stroke of no width and another has one that draws;
blends whose spine has more than one part;
blends whose step count is close to where rounding the written
coordinates and colors changes it; blends the reader would open with
other settings or not as drawn; blends inside objects with geometry or
Pathfinder effects or a group's own fills and strokes; blends in
opacity masks, pattern tiles, symbols and art cut to a clipping object
or nested eight levels deep in art written in place of other objects;
blends whose art would pass the most objects the reader reads; and
every blend on a large canvas.
- The steps set their own transparency and lock and hidden state after
the hidden lines, for readers of the printed form.
Each construct is written in the form the .ai reader reads (blend.rs,
read/document.rs blend roles, read/containers.rs end_blend, read/ops.rs
XP and transparency), and every object written counts toward the
reader's object limit as the reader counts it. The record's orientation
word and a blend with no spine part are read as #8243 reads them.
Blend Options, key objects and spines:
https://helpx.adobe.com/illustrator/desktop/manage-colors/apply-transparency-and-blending/blend-options-overview.htmlhttps://help.adobe.com/archive/en_US/illustrator/cs5/illustrator_cs5_help.pdf#page=260
Tests: the round trip of blends of each spacing and orientation, with
no spine of their own, an edited spine and replaced curved spines,
named, at half opacity, hidden and locked, with text wrap options, of
compound paths, of groups and of 62 keys, each laying out the same steps
as the document's blend; the record's words (Align to Path's angle
included) and the dictionaries; the steps' own state after the hidden
lines; the same bytes on a second write; each case written as its
steps, with as many steps as are drawn, where they are drawn (among
them Specified Distance 0.03 pt from where its count changes, on a
spine of 200 segments, which comes back live on a spine of two); blends in
pattern tiles, opacity masks, symbols, art cut to a clipping object and
eight levels down; the object limit; the reader's blend limit; a large
canvas; fuzz cases for damaged written blends.
Docs: docs/file-format-parity.md.
The writer measured which way each patch turns only at its first corner,
along the straight lines to the next corners. A patch whose point is
dragged across it, or whose handles cross at a corner, passed as a
plain patch and was written as a mesh. Each corner of each patch is now
measured along the straight lines and along its handles, and a mesh
whose corners turn different ways is written as its drawn look with the
warning.
- Tests: a patch folded at a corner by a moved point and by crossed
handles; a reflected mesh read back draws the same points and opacity
across each patch; an envelope in a symbol's art with its grid and
contents in the symbol's own space opens as the art it draws, and one
in a file without a template box is left unread.
- The fuzz case for written meshes moves next to the other editing-data
cases in import_fuzz.rs.
- Docs: file-format-parity.md says a reflected mesh opens with each
row's points in reverse order, and how envelopes in symbols open;
target-app-parity.md links the help page on mesh point opacity.
The editing copy of a PDF-compatible .ai wrote every gradient mesh as
its drawn look. Meshes the .ai reader reads back as they are are now
written as meshes:
- Each mesh is a /Mesh record: 2 /Version, its type and grid size,
/Data, then each patch row by row with its place, the color space
where it changes (gray, RGB or CMYK) and its four corners: color,
opacity, point, and the handles towards the next corner and the one
before it. Its opacity, blending mode and knockout shape are set
before the record, and its name and opacity mask follow it.
- A reflected mesh, whose patches all turn the other way, is written
with its columns in reverse order, which draws the same mesh.
- In a symbol's art the corners are written about the canvas point of
the ruler origin, y up, as an image's matrix there is. An envelope's
grid in a symbol's art is now written in the same space, and the
envelope's contents in its dictionary in the canvas's space, y down.
- Each mesh is checked with the reader's own reading before it is
written. Written as their drawn look with a warning: meshes with a
point in a Lab color, with more than 128 rows or columns, folded
meshes (patches that turn different ways), meshes the reader would
read with other points, handles or colors, meshes in pattern tiles
and in art cut to a clipping object, and every mesh on a large
canvas. A mesh's drawn look is written at any depth of nested
symbols and live objects.
Each construct is written in the form the .ai reader at e142c5fcee
reads: /CS, /Type, /Size, /P, /N and /E in mesh.rs:180-234, corners
with or without an opacity by their count of values in read_corners
(mesh.rs:239), the patches joined into one mesh in one_mesh
(mesh.rs:298); /Mesh X!, X# and /End X! in read/ops.rs:219-232; the
transparency after the record in read/art.rs:281 (end_mesh) and
read/ops.rs:344. /Version and /Data are passed over by that reader
(mesh.rs:234). Corners in a symbol's art rest on a reader change in
this commit.
The reader changes how any .ai opens:
- Mesh records and envelope grids in a symbol's art are read in canvas
space (read/document.rs:947 image_space), and an envelope's contents
in its dictionary in the canvas's space, y down. In a file without a
template box such a mesh is left unread, its symbol is not read
whole, as with an image there (read/art.rs:634), and its instances
open as the page draws them. Envelopes in symbols in .ai files saved
by earlier VectorCraft builds open differently.
- A point of a patch whose corners differ in color model keeps its own
color when the patches are joined into one mesh.
Gradient meshes, mesh points and their opacity:
https://help.adobe.com/archive/en_US/illustrator/cs5/illustrator_cs5_help.pdf#page=200
Patch meshes (corners joined by cubic edges with control points):
https://opensource.adobe.com/dc-acrobat-sdk-docs/pdfstandards/pdfreference1.7old.pdf#page=321
Tests: the round trip of meshes with RGB, CMYK and gray points, a moved
point with handles of its own, part-transparent points, a name,
opacity, blending mode and knockout shape, hidden and locked, with an
inverted, unlinked opacity mask, in groups, opacity masks, symbols,
opacity masks in symbols, a document of two artboards and eight levels
down, compared point by point, handle by handle and channel by channel
at the 4 decimals written; reflected meshes, mirrored across and
along; the record's form, including corners in a symbol's art and an
envelope's grid and contents there; an envelope in a symbol read back
with its contents and their gradient in place; the same bytes on a
second write; each case written as its drawn look, with its paths read
back over the mesh's box; reading a mesh in a symbol's art with and
without a template box; /Version and /Data passed over; the color
model rule; fuzz cases for damaged written meshes, a symbol's
included.
Docs: docs/file-format-parity.md, docs/target-app-parity.md.
WebP Options has a Compression menu (Lossless, Lossy) and a Quality
slider from 0 to 100 that is enabled for Lossy. document.export,
document.serialize and Export for Screens take lossless: false with
quality (default 90) and write a VP8 file, with an ALPH chunk that keeps
the alpha exactly when some pixels are not opaque. Lossless stays the
default. A WebP quality above 100, or one that is not a whole number,
is refused with an error.
The encoder is the one craft-image-codecs already provides; no
dependency changes. The note that lossy WebP isn't available, its
catalog rows and the format text that described it are removed.
The Character Set menu of Text Import Options now lists Shift JIS, GB2312,
Chinese Big 5, Cyrillic, GB18030, Greek, Turkish, Baltic and Central European
beside Unicode and ANSI, and `file.place {text: {characterSet}}` takes
"shiftJis", "gb2312", "chineseBig5", "cyrillic", "gb18030", "greek",
"turkish", "baltic" and "centralEuropean". Each set decodes with its WHATWG
Encoding Standard decoder from encoding_rs, which the workspace already
locks: GB2312 reads as GBK, Cyrillic as windows-1251 (x-mac-cyrillic with
platform "mac"), and Greek, Turkish, Baltic and Central European as
windows-1253, 1254, 1257 and 1250 on both platforms. A byte-order mark is
read as ordinary bytes and a malformed sequence as U+FFFD. Unicode and ANSI
read as before.
An unknown character set is an error that lists the sets, and nothing is
placed. A `text` option of the wrong type (`characterSet: 3`,
`removeLineReturns: "yes"`) is now an error instead of the default. The
dialog remembers the last set confirmed, and Show Import Options off places
with it.
A gradient definition in the .ai editing data holds each stop's color, opacity, midpoint and ramp point, and VectorCraft's reader opens it as a Classic gradient. A Perceptual gradient was written with its own stops, so the file opened with different colors between them.
The writer now treats a Perceptual gradient as it treats a gradient mixed around the hue wheel, in the art and in the Swatches panel: the colors on its curve become stops of their own in process colors, at most 256, with a warning that names Perceptual gradients. A stop linked to a global process color reports its lost link for both methods. Dither is reported as its own loss. A freeform gradient, or one with more than 256 stops, is still written as its average color whatever its method.
Match a stroke to a filled glyph by its whole placement (origin, size,
horizontal scale, slant and direction), not just its origin, so a stroke
drawn at another size over a filled word stays type of its own. Restyle
only the matched glyphs' text instead of the rest of their run: strokes
over neighbouring glyphs gather and restyle once, so a word filled and
stroked whole stays one run, while a stroke over one glyph of a filled
word strokes that glyph alone.
With text rendering modes 2 and 6 the reader fills every glyph of a
text-showing operator before stroking them, but the importer only joined
a stroke to the glyph filled last, so a word shown in one Tj came in as
a stroke-only Type over a fill-only one. TextLine now records the glyphs
it fills and stroke_filled matches each stroke to its filled glyph in
order, splitting a run where the stroke differs.
Area type with wrap shapes was always written as outlines in the editing
data for other apps. It is now written as type when the reader works the
same wrap out again from the objects above it: each wrap object is a path
of one subpath, a compound path of visible members, or an unclipped group
of such objects, with no paint, or a solid fill, a plain solid stroke or
both, without effects, art style, opacity mask or clipping, with an
offset within -1000 to 1000 pt; the type's stored shapes match the ones
those objects give it; and the shapes of all area type stay within the
2,000,000 anchors the reader copies. Each frame of a thread is checked on
its own. When art is left out at the object limit, such type is written
as outlines again. Other wrapped area type stays outlines.
The reader recomputes the wrap with resolve_wrap after reading
(resolve_text_wrap in crates/eps/src/import/native/build.rs) and reads the
options with text_wrap in crates/eps/src/import/ai/read/document.rs; the
round-trip tests check the reopened characters, frame, wrap shapes and
wrap objects. resolve_wrap's layer walk is shared through a new
wrap_sources so the check follows the same traversal.
A default legend swatch of a stacked column, stacked bar, area or pie
series now has the thin white stroke the series' marks have, beside the
plot or across the top. Before, the swatch had no stroke, so the series
group painted with two strokes and a drawn stacked column or area graph
was saved to .ai as plain art with a warning. Both now open again as live
graphs. Stacked bar graphs are still written as art: the .ai reader has
no type for them.