Extruded type with a taper showed a row of light ticks along its walls,
and with a stroke a long light line down a wall (#7019).
A taper only scales each wall's far edge toward the center of the
bounds as it goes back: the scale is linear in depth, so without a
twist each wall stays a flat trapezoid, bevel bands included. The walls
were cut into 8 slices all the same, and at every joint between slices
a neighbor's seam painted a light tick onto the wall. Walls are now cut
into slices only for a twist, which bends them; the ticks and the long
line are gone from tapered, untwisted walls. Twisted walls and Inflate's
sides are sliced as before.
A tapered wall now draws like an untapered one, with three effects:
- A wall seen almost edge-on ends in one longer sliver instead of the
last of its slices. With mitered seams that sliver's thorn is longer;
round seam joins (#6980) keep it within half the seam's width.
- Its seam is as wide as an untapered wall's (the width follows the
face's thickness, up to 0.75 pt), wider than a slice's was.
- It is sorted by one depth, like an untapered wall, so at a concave
corner it can be drawn over a nearer face where the slices had
happened to avoid that (#7023).
Test: solid::tests::a_tapered_wall_is_one_flat_face_and_a_twisted_one_is_sliced
checks that a tapered square's four walls are four flat faces, that a
taper adds no faces to a circle's walls, with bevels (both sides,
inside), in perspective or hollow, and that a twisted wall is still
sliced. With taper slicing it fails (32 wall faces for the square's 4,
608 for the circle's 76).
Docs: docs/three-d.md, docs/target-app-parity.md.
- a_faces_seam_stays_within_half_its_width_of_the_face checks Rotate
(Classic)'s branches too: No Shading keeps its paint, a gradient keeps
the gradient, and Diffuse shades its plane darker at some view.
- classic_revolves_seams_are_round checks each seam's reach as well as
its join, and covers a gradient.
- The Wireframe edge takes seam_stroke (the same stroke it built by hand).
- Docs: which seams went from miter to round and which already were;
the white-light difference from the 2026-10-17 comparison is expected,
not measured; the 3D area rows record the change; the performance note
says its measurement predates the Classic Rotate and Revolve paths.
Each 3D facet is stroked with a narrow seam of its own paint (0.05 to
0.75 pt; Revolve's is always 0.75 pt) so neighboring facets meet without
an antialiasing hairline. In Extrude & Bevel, Inflate and Rotate under a
white light, and in every face of the 3D (Classic) effects (Extrude &
Bevel, Rotate and Revolve (Classic); shaded, No Shading, gradient and
pattern alike), that seam kept the default Miter Join with its limit
of 10. Revolve's seams and the colored-light seams
were already round. A facet seen almost edge-on is a sharp sliver, and
its mitered seam reached up to ten times its half-width past the facet's
tip: thorns of up to 3.75 pt past the solid, along the tops of type seen
tilted and at every edge-on bevel facet.
#2706 (multiple lights) deliberately kept white-light seam joins as they
were, so that legacy white-light output stayed byte-identical to main
(its comment "Preserve existing white-light paints, alpha composition and
seam joins exactly", and four PNGs compared byte for byte). That kept
the thorns too. This change reverses that one part on purpose: the
paints and alpha composition stay exactly as #2706 left them; only the
join changes.
- Outputs change, the document model doesn't. Exports draw the new
joins (SVG writes stroke-linejoin="round", PDF and .ai draw round
joins), and Expand Appearance writes round seams into the document.
But nothing a document stores selects the join, and the format is
unchanged, so there is no version gate: an old file drawn now simply
has no thorns.
- Round joins. Projected facets rarely have right-angle corners (a
square seen at an angle is a parallelogram with acute corners, and an
exact 90° corner sits at a √2 limit), and round is what the seams of
colored lights and Revolve already draw. The cost: where a facet has
no neighbor (Rotate's plane, every silhouette corner) its convex
corners are drawn rounded by up to 0.375 pt instead of sharp.
Alternatives weighed and not taken: a Miter Join with a limit near √2
at every seam, the composed clip included, which would bevel slivers
but chamfer most projected corners as well; and seaming only the edges
facets share, or clipping facets to their union as solid_surface
does, which would keep every outer corner sharp but means a new
geometry pass for every 3D effect. Round is the smallest change that
matches the seams already drawn.
- A seam no longer reaches past its facet by more than half its width,
so the art's visual bounds shrink by up to 3.375 pt where a thorn
stood (10 × 0.375 less the 0.375 a round seam still reaches).
White-light output is no longer byte-identical to #2706's comparison;
docs/3d-lighting-performance.md says so.
Every seam stroke is made by lighting::seam_stroke. The colored clip in
composed_art already outlined its seam with round joins and is
unchanged. Tests: every seam of Extrude & Bevel, Extrude & Bevel (Classic, each
branch), Rotate (Classic), Inflate and Rotate, under white and colored
light, has round joins and reaches no more than half its width past its
face, at views that make a sliver; Revolve (Classic)'s seams are round
on each surface; a mitered seam fails them, and so does the legacy
white-light Inflate test, which now expects Round.
A new test changes the document in place (Arc::make_mut, with no other
holder and no change of revision) and checks the answer is measured
again: keyed on the document's address alone, it would keep the old
answer. The kept answer's doc says what it holds after the measure,
and that the fonts set the bounds of all type. Should measuring ever
ask again while it runs, it is measured without being kept, rather
than borrowed twice.
The stack overflow fixed in d5d04f868 also hit EPS export, and the
parity rows now say so. Two test docs are corrected: the fill-only
clipping is an older bug on main, and the outline-view difference runs
both ways on a few dozen hairline pixels.
- The parity rows say what the fix covers: a 3D effect on a fill or
stroke that builds nothing overflowed the stack with no effect of the
object's own too, on the canvas, in Object › Rasterize and in raster
exports.
- The builds-nothing test says the fill-only difference (a raster
effect clipped to the path, cutting Roughen's spikes, when drawn
without the 3D effect) is an older bug, not the design.
- The traced-shape test says why its area is bounded rather than drawn
again: a partial render in outline view differs from the whole by one
in alpha on 37 pixels, older than the test and unrelated to the edit.
- A doc comment rewrapped.
The answer whether Fit to Artwork Bounds has art to fit moves from a
function-local thread_local to DocState, beside any_empty_artboards, and
drops with the document. It is kept for that version of the document
(held weakly, as any_empty_artboards holds its own) and the artboards
asked about, and measured again when the installed plug-ins, whose
effects draw art, or the installed fonts, which set type drawn by its
effects' art, change: their generations are an explicit input of the
measure. A change of the selection or the view keeps it.
The test counts the measures, as the Delete Empty Artboards check's
does: a later frame, select.set and a view change keep the answer; an
edit, other artboards, and each generation measure again. Taking any
part out of the key fails it.
fit_has_art kept its answer for the document's uid and revision, which
don't follow every change of what it measures: a document's tab coming
to the front replaces it with its composite fonts synced, and a plug-in
installed or removed changes what its effects draw, with no revision
moving either time. The answer is now kept for that document Arc, held
weakly as DocState::any_empty_artboards keeps its own, and the artboards
asked about, until the plug-ins' revision moves. A selection or view
change keeps it.
The test replaces the document with art on an artboard, its revision as
it was, and asks again: kept by revision, the answer was stale.
- A 3D effect that builds nothing: af754bcb2 said the object draws exactly
as without it under a Drop Shadow or Gaussian Blur. That holds only for
a stroked object. With only a fill, the raster effect draws from the
art made for the object, where without the 3D effect it is clipped to
the path, so Roughen's spikes differ: the earlier wording was right.
The test keeps the stroked cases exact and restores fill-only cases
with a Drop Shadow and a Gaussian Blur, which differ in under 4% of
the pixels and nowhere inside the path. Its reach check compares with
the object drawn without its raster effect, since Roughen alone
reaches past the path.
- The Vector Halftone test's bounds are a consistency check, and only
holding no art tests the branch: its doc no longer says no solid is
built (the free measure's halftone arm builds one). The overprint
test's area check is labeled likewise.
- Recoloring a traced shape bounds the area the renderer that drew the
trace object measures too, inflated by half the stroke and a pixel.
- The let-go test pins the nothing-to-draw branch: no frame, whole or
part, began since the measure.
- The parity doc's feature row names the stack overflow fix and its
test; a group test's doc says what its fixture holds.
Review follow-ups:
- The test that art measured for an edit not drawn on this thread is let
go first checks that measuring the edit through the canvas's renderer
holds art, so a measure that held nothing can't pass it. Its worker is
a test channel whose job the test receives, in place of a real thread's
pending job, which a finished frame could clear. Taking out either
let_go_of_measured fails it.
- fit_has_art's comment says why its one kept answer can't be stale: a
document's uid is never reused in the process and its revision only
moves forward.
Review follow-ups:
- The tests that a group with effects of its own is measured once a pass
plant its kept bounds after the first artboard and read them back over
the next two, so a measure made again fails. Its solid is built by the
free measure, which the renderer's three_d_built doesn't count.
- The budget test checks that every object, past the budget too, is
measured as the free measure does and draws as a new renderer draws it.
- A 3D effect that builds nothing draws the object exactly as without it,
with a Drop Shadow or Gaussian Blur too, which reach past the path. The
doc comment said those differ past the path; they don't.
- The brush widened in view first checks that the wider brush draws
otherwise.
- Recoloring a traced shape changes no more than the shape, its stroke
and a pixel's anti-aliasing.
Review follow-up: these three branches of what a renderer measures had no
test. Under Overprint Preview a renderer measures an edit as changed()
does and holds none of the 3D art it made for it; a 3D effect with
Vector Halftone is measured by the free measure, with no solid built and
no art held; and on screen in symbol editing mode, an edit to the
instance it was entered from changes nothing. Each test fails with its
branch taken out.
Diff took the Image Trace flag of the old version for both sides when it
read each version's first member. Both versions have the same extras
there (same_but_members), so the result was right, but each side now
reads its own node.
The doc of Renderer's three_d_bounds now says what adds an entry, when
entries are swept, and the bound that follows: about twice the live 3D
art plus 1024 entries.
Review of #6290.
- An Image Trace object's hidden source image counts as shown in each
version by that version's own first member: an edit that puts it
first again (undoing Send to Back on a traced shape), or a new source
image in its place, redraws where it shows. Tested with an image
source on screen with the objects' views.
- A shape of an Image Trace object in Outline view is left out by the
rule every object is (node_checks::left_out), so the drawing and the
measure of an edit can't disagree.
- The renderer keeps the brush library's key from its first measure of
3D art until the library changes; the test says so, and that a change
lets it go.
- The test of a 3D effect that builds nothing covers it on a fill and
on a stroke, without effects of the object's own (exactly as without
it) and under a raster effect.
On the commit before, "Canvas: a 3D effect on a fill that builds nothing
draws without it": it needs no effect of the object's own. A 3D effect
on a fill or stroke that builds nothing overflowed the stack on its own
too. With a raster effect, the object now draws from its art, where
without the 3D effect it draws as a path, whose raster effects are
clipped to the path's own geometry, cutting off the item's Roughen
spikes: the new drawing is the one that keeps them.
An object with an effect of its own (Drop Shadow, Roughen) and a 3D
effect on its fill or stroke that builds nothing (Revolve after
Roughen, a solid too complex) overflowed the stack when drawn, on the
canvas and in Object › Rasterize: the art made for the object kept the
item's 3D effect, so drawing it drew it as an object with effects again,
and that art again, without end.
That art now leaves out the 3D effects on its fills and strokes when
none built anything, as a group's or layer's own are left to the art of
each fill or stroke. The fill draws as without the effect; with a raster
effect the object draws from that art, so its edges differ a little
from the same object without the 3D effect, drawn as a path.
Review of #6290.
- An edit is measured as the renderer draws: an object it leaves out
(hidden, a template layer or guide the view hides, drawn hidden, the
instance a symbol is edited from) is measured as nothing, by one
predicate the renderer and the measure share (node_checks::left_out,
before culling).
- An Image Trace object's members are compared one by one again, its
hidden source image, which some views draw, counted as shown: moving
the source redraws where it was and is, and recoloring a traced shape
redraws only the shape.
- The renderer checks the brush library between frames only while it
keeps bounds measured with brushed strokes in 3D art.
- Tests: the sweep of 3D art's bounds counted while the art is held,
and Fit to Artwork Bounds' menu answer kept for a revision.
When an edit changes an object, the canvas draws again only the area
the object painted before and after it, measured by its cull bounds.
Type and groups with Extrude & Bevel, Inflate or Rotate were measured by
their letters or members, not by the solid the effect draws, which
reaches well past them. Making the solid shallower or turning it left
pieces of the old solid on the canvas outside that area until the view
was drawn again.
An object with a 3D effect is now measured by the effect's art, as the
renderer draws it: with its geometry effects, each object in it with
the raster effects of its own fills and strokes and the art its brushed
strokes draw, grown by the reach of the object's own raster effects.
One function measures that art for every bounds the renderer and
exports take, where three copies of it disagreed.
- The renderer measures the art it draws. What it makes to measure an
object it holds until the frame ends, with what the art read from
outside the object (fonts, symbols, color settings), and keeps it
with the art it draws if it draws the object while that is
unchanged. Art measured but not drawn (culled, off the view) isn't
kept. It holds at most as much as it keeps for the art it draws
(64 MB); past that, an object is made again to draw it. An object
whose 3D effect builds nothing (Revolve on a group, a solid too
complex) is measured as it is drawn otherwise, as without a renderer.
FrameStats::three_d_built counts the 3D art the renderer makes.
- The canvas measures what an edit changed through the renderer that
drew the frame shown (Renderer::changed). When it draws the part on
its own thread, it draws it with the art it made to measure it; when
the render worker draws the frame, or nothing in view changed, that
art is let go. Under Overprint Preview or Separations Preview, which
draw copies of the objects, the edit is measured afresh. An object
the frame doesn't draw (hidden, in a hidden group or layer, or
hidden by the view) is measured as nothing, before and after, so an
edit to it builds no solid: changed() without a renderer counts it as
nothing too, where it measured it. The canvas measures the edit
before it knows where the frame is drawn: when the worker draws it,
the solids it built to measure it are built again there.
- Fit to Artwork Bounds, the Artboards panel's check for it and
per-artboard SVG export measure every artboard through one renderer
(Renderer::art_bounds_on, Renderer::effect_bounds), which keeps each
object's bounds for the pass, a group holding 3D art or a hidden
member included, so each solid is built once: 30 extruded type
objects over 30 artboards take about 2 ms, where measuring their
letters took under 1 ms and building each solid for each artboard
would take 70 ms. Objects with brushed strokes, which culling leaves
room for and exports don't, are measured on each artboard. The
Artboard tool's canvas menu keeps whether Fit to Artwork Bounds has
art to fit for the document's revision, where it measured it on
every frame it was open.
- Other exports, Object › Rasterize and changed() without a renderer
build the art on each call, as 3D paths and groups already did.
Exports and Rasterize now take the solid of 3D type, where they
cropped it to the letters, and the art its brushed strokes draw, not
the room culling leaves for it. Rasterize on drawn 3D art measures it
once while the art is kept.
- A shadow after a 3D effect, on the object or on a fill after the
fill's own 3D effect, reaches past the solid once; it was counted
twice.
- With Crop Marks or Vector Halftone, which draw other art, the object
is measured by that art, as before.
- Culling leaves room for a 3D object's brushed strokes as for any
object's, and the renderer measures a 3D object again when the brush
library changes: a brush widened past that room would leave the
object culled.
A document's first frame builds the solid of every 3D object, those off
the view too, to know whether it reaches into the view: 200 extruded
words with 150 off the view take about 12 ms, where measuring their
letters took 6 ms.
Type whose object effects leave it as it is (Revolve builds no art from
type) is measured by its own box grown to hold its glyphs, as plain
type is; it was measured by its box alone, which needn't hold them.
The boolean's answer went through orient(), which judges each ring's
side from its first point. The boolean often starts a contour where it
touches another, so a triangle whose tip rests on a square's edge was
dropped, and an even-odd hole touching its outline was filled. The
boolean already runs holes against their outlines, so its rings are now
only turned as a whole.
Other fixes:
- A bowtie drawn as one contour has no area of its own. It was dropped
before the meet check and built nothing, although it fills both lobes.
Sampling now keeps rings with no area, and orient() drops them after
the check. Flat rings, every point on one line, fill nothing and are
still dropped, so a stray flat contour doesn't send separate art
through the boolean.
- An open subpath was closed along its end handles when the profile went
through the boolean, but straight otherwise, as the renderer fills it.
It is now closed straight before the boolean too.
- An empty union was taken as a refusal. Contours that cancel (a square
drawn twice under even-odd) built a square. They now build nothing.
- Contours meet within twice the boolean's own sweep tolerance,
computed by its rule from every anchor and handle of the path it is
given. pathops snaps anchors onto nearby heights before the sweep
joins edges within that tolerance, so contours up to about 1.4 times
it apart can come out as one; within twice it, every contour it
might join goes through it, even far from the origin, and the few it
leaves apart cost a boolean that builds the same shape.
- A one-anchor subpath draws nothing, so it is skipped, as the renderer
and the boolean skip it.
- A profile the boolean refuses reuses the rings already sampled.
Tests:
- touching parts and holes;
- an open subpath with handles, alone and beside crossing bars;
- a flat contour beside separate squares;
- contours joined far from the origin, including by handles alone,
and contours a few millionths apart near it kept apart;
- triangles snapped together and joined at 1.4 times the tolerance,
the same triangles left apart and kept whole, and the factor pinned
between 1.9 and 2.2 times, with the worst case just past twice the
tolerance left apart by pathops;
- a 24-bar grid: too complex for Extrude and Inflate, whole under Rotate;
- the merged rings turned as a whole;
- a one-anchor loop;
- the bowtie and the cancelling squares under all three effects;
- a 3,001-point star that the boolean refuses (TooComplex), built as
drawn.
Docs: the pathops README's Limits section now says only the try_
functions refuse, lists OpenPath and the caught panic, and describes
unite_all's answers, and which calls take a precision. three-d.md and effects-parity.md (the 3D row, its
history and status line) describe the merge and its limits.
The boolean that merges crossing contours cost about as much as the rest
of a plain extrusion, and it ran on every profile. Most art has no
contours that meet, so the profile is now sampled first (its point limit
checked there, before any boolean) and resolved only when two edges
cross, touch, run along each other or fold back, in one contour or
across two. Edges are swept by their left ends, within a pair budget past
which the boolean decides. Touching counts: squares sharing an edge
inflate as one puff, not two with a seam.
On a release build, Extrude of 120 separate contours takes 0.31 ms
instead of 4.18 ms; profiles that do cross cost what they did.
Tests: the meeting cases, squares sharing an edge, the fallback for a
profile the boolean refuses, Inflate's extent and area for the crossing
k, and the coincident circles' area. The hairline test now holds a
crossing pair so that its profile still goes through the boolean.
Docs: the merge is described once for all three effects, linking to a new
Limits section in the pathops README instead of repeating its limits,
and the point limit notes that a merged outline can have more points.
try_normalize refits its result at Pathfinder's default precision and
drops every contour thinner than 0.01 pt on average as a sliver. A
hairline beside a larger shape is art, not debris, and resolved() only
fell back to the input when nothing at all was left, so the hairline lost
its cap, walls and surface.
Resolve with try_unite_all_with at a precision far below any art, which
still drops the debris a boolean leaves where curves coincide: a circle
drawn twice, exactly or 1e-7 pt off, stays one outline.
Extrude & Bevel, Inflate and Rotate broke on shapes whose contours cross.
Type often draws a glyph that way: Roboto Slab's "k" has its arm and leg
as one contour that crosses both the stem and the leg's foot serif.
rings() decided each contour's role (outline, hole, or no edge at all
under nonzero) from the contour's first point only. A contour that starts
inside another was dropped or flipped into a hole, cutting part of the
glyph away. A contour that starts outside was kept whole, so its walls and
bevels ran through the overlap and the overlapping parts drew as separate
boxes.
The profile now goes through vectorcraft_pathops::try_normalize first, so
rings() only ever sees simple contours that do not cross. A path the
boolean refuses is used as it was.
`tests_alternate`'s Arabic tests look up installed fonts by name
(`FontDb::face`), which loads each one into the global database and so
changes its generation, without `tests_fontchange::adding_fonts()`.
When that lands in the first frame of
`tests_charstroke::character_stroke_outlines_are_kept_between_frames`,
the second frame lays the type out again and expands the stroke again,
and the test fails (3 runs in 30 on macOS, where Arial and Geeza Pro
are installed; where no Arabic font is, those tests return early and
nothing changes). They now hold the lock, and its documentation says
looking up an installed font counts as changing the fonts.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A follow-up to #3677. A data URL in CSS, `style="fill:url(data:…)"` or a paint's
`url(…)`, stayed in the text the prepass searches, since only a value beginning with `data:`
was left out (CodeRabbit's review of #3677). Each `url(` in an element's quoted value whose URL
begins with `data:` is now left out up to the byte that closes it, its quote or `)`, so what
follows it, `display:none` say, stays. A `url(` that does not close inside its value is kept
whole: where the end is unclear, less is left out, never more.
The scan now jumps over a data URL with one search for the byte that ends it, instead of
stepping through it a byte at a time. The markers' capacity is a saturating sum, so no range can
panic it.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
One import is checked first and its document kept through the memory reading after the row, so
a failure stops the run with its error rather than being timed as an import (CodeRabbit). The
row's comment now gives the picture's real size, about 2 MB as a PNG.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The prepass decided what to look for in the tree by a dozen substring searches over the whole
SVG text (`:not(`, the event attributes, `script`, `transform:` and nine more), and a separate
pass counted the elements' depth before roxmltree. With an embedded picture the text is mostly
its data URL: a 1.35 MB card SVG (a 968 KB PNG) paid about 7 ms of searches and 1 ms of depth
scan per import, on a 64 ms render, and a 54-page PDF export 54 times that.
`depth::prescan` is the one pass: it counts the depth as `xml_too_deep` did (the DOCTYPE entity
count included) and, in the same walk, notes every `data:` attribute value, answering the text
with those values left out, their quotes kept. The prepass and `fx::blends` search that text;
the edits are still made in the source. A data URL can hold no tag, attribute name, selector or
CSS declaration, and everything else, a `style="display:none"` included, is kept, so what is
found is what was found before.
`vectorcraft-cli perf --deep` gains a tracked row, "import SVG, one embedded PNG", beside the
export row it had.
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
The panels and dialogs draw in their own egui families (`ui`,
`ui-semibold`, `mono`), and egui panics drawing text in a family no
font is bound to. Only `theme::install_fonts` binds them, and only
`VectorcraftApp::logic` calls it, on its first frame. An embedder that
draws the panels or dialogs itself (`dialogs::show`, a panel's `ui`)
on its own context, without `logic`, panics on the first semibold
title it draws, an effect dialog's for one. Calling `install_fonts`
avoids that, but it embeds the interface's five faces (about 2 MB)
whatever the embedder wants: today such an embedder keeps them out of
its binary only by never calling it, so that the linker drops them.
vectorcraft-ui-egui gets an `interface-fonts` feature, on by default,
that embeds those faces. Without it `install_fonts` binds the same
three families to egui's built-in fonts, so an embedder can always
call it. Those lack some symbols the panels show (→ ▾ ● ✓), which the
docs say. With the feature, `install_fonts` installs exactly what it
did before: the same font data and the same family stacks.
`tests/install_fonts.rs` draws an effect dialog on a context only
`install_fonts` prepared, and checks the face at the head of each
family in both configurations. `cargo xtask ci`'s `no-bundled-fonts`
step runs it without default features and lints the crate that way.
Without the `install_fonts` call, or without the semibold binding,
both tests fail with egui's "FontFamily::Name(\"ui-semibold\") is not
bound to any fonts". The two lib tests about the interface faces are
adjusted: the graphics-loss test checks a family install_fonts binds,
and the catalogs' glyph coverage test needs `interface-fonts`.
docs/development.md says when an embedder calls `install_fonts`, and
that it replaces the context's font definitions.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
With one clip group selected, the Properties panel has Edit Clipping
Path and Edit Contents at its top, under the Clip Group heading, as the
reference app does: "With the clip group selected, click the Edit
Clipping Path button at the top of the Properties panel to select and
edit the mask, or click the Edit Contents button to select and edit the
masked content"
(https://www.adobe.com/learn/illustrator/web/crop-using-masks). They
run the existing object.clippingMask.editMask and editContents, which
select the clipping path or the clipped art for the selection tools, as
Object > Clipping Mask does. Edit Contents shows only when the group
clips something. With several objects selected they don't show (the
tutorial describes one selected clip group); the Contextual Task Bar
does the same. Both labels are already in every catalog.
Test: panels::properties::tests::one_clip_group_has_edit_clipping_path_and_edit_contents_at_the_top
(first under the heading, each selecting its part; Edit Clipping Path
alone once the clipped art is deleted; neither for a clip group
selected with another object in either order, or for a plain group).
Documented in docs/target-app-parity.md, docs/ui-parity.md and
docs/gaps.md.
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
#2027 gave vectorcraft-text and vectorcraft-engine a `bundled-fonts`
feature for an embedder that supplies every document font at run
time, but vectorcraft-ui-egui (and vectorcraft-mcp) named the engine
with its default features, so an embedder that hosts the panels got
the fonts whatever it asked for. Each now has a `bundled-fonts`
feature of its own, on by default, that turns the engine's on, so a
downstream user keeps the fonts unless it asks otherwise. For a
member to leave the engine's default features out, the workspace has
to declare the engine without them, as it already declares
vectorcraft-text; the crates that used the engine's default now ask
for the fonts: the three apps and vectorcraft-testkit. Off,
vectorcraft-text's copy of the fonts (3.4 MB) is left out; theme.rs's
own copies of five of them, the panels' interface faces, stay either
way.
Nothing the workspace builds changes: for every workspace member and
for the whole workspace, with and without dev-dependencies, for all
targets, wasm32-unknown-unknown, aarch64-apple-darwin and
x86_64-pc-windows-msvc, `cargo tree -e normal[,dev] -f '{p} [{f}]'`
resolves the same features for every package as on main, apart from
the new feature names (the engine's `default` no longer listed;
ui-egui's and mcp's `bundled-fonts` and `default`).
A test of the panels can't see their configuration without the fonts
(their dev-dependencies turn them on), so `cargo xtask ci`'s
`no-bundled-fonts` step now also reads that tree for
vectorcraft-ui-egui and vectorcraft-mcp: with their default features
it must show the fonts, and without them, for any target (a wasm-only
dependency too), it must not. Documented in docs/development.md
(Fonts › Leaving out the bundled fonts).
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
The selection tools' clipping-path outline hit was also used where the
Selection and Direct Selection tools act on what is drawn rather than
select. Near a layer's clipping mask edge, with art drawn over it:
loaded text threaded into the unpainted mask instead of the art, a
double-click on type entered isolation on the mask instead of editing
the type (Selection) or did nothing (Direct Selection), and Cmd/Ctrl+
Shift double-click could not release a guide path there. These now
take the ordinary hit (ToolContext::hit_options); a press or hover
that selects keeps the outline hit.
Tests (each fails with the selection hit options):
select::tests::loaded_text_threads_into_the_art_on_a_layer_masks_edge,
a_double_click_on_type_at_a_layer_masks_edge_edits_it (Selection and
Direct Selection) and a_guide_on_a_layer_masks_edge_is_released, over
the new testutil helpers add_masked_layer and
doc_with_type_on_a_layer_masks_edge. Recorded in
docs/target-app-parity.md.
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
A clip group answered a press only strictly inside its clipping path,
and there the art above the path came first in the hit test, so where
the clipped art extends past the mask's edge the clipping path's
segments could not be reached on the canvas.
With the new HitOptions::clip_outlines, which the Selection, Direct
Selection and Group Selection tools set
(ToolContext::selection_hit_options), a press within the selection
tolerance of a clipping path's outline, inside or just outside it,
hits the clipping path (HitKind::Outline) before the art it clips:
Direct Selection takes its segments and the Selection tool the clip
group. It applies to a clip group's clipping path and to a layer's
clipping mask, and only to one a click may hit (may_hit: visible,
editable, within reach). Inside the mask the art is hit as before.
The other tools, which act on what is drawn (the eyedropper, type,
gradients...), leave the option off, and hit_test_visible never
applies it, so they still take the art at the mask's edge rather
than the mask's empty appearance. Select Behind's one-pass walk takes
a layer mask's outline first too, so it lists what the repeated hit
test finds. Object Highlighting and a right-click's selection in the
canvas (selection_hit_at) take what those tools take; dropping a
swatch on art still hits what is drawn.
The reference app reshapes a clipping path with Direct Selection:
https://helpx.adobe.com/illustrator/desktop/manage-objects/edit-objects/edit-clipping-masks.html
Tests in doc: a_clipping_path_is_hit_on_its_outline_before_its_art,
only_the_selection_tools_hit_a_clipping_path_on_its_outline and
select_behind_takes_a_layer_masks_outline_first; the random Select
Behind test now clips layers and sublayers and sets clip_outlines,
and fails without the Select Behind change. In tools,
a_press_on_a_clipping_path_takes_its_segment_over_the_art fails
without the change; select::a_press_on_a_masks_edge_selects_its_clip_group
fails when the Selection tool uses the plain options; the eyedropper
copies the art on the edge. Recorded in docs/ui-parity.md,
docs/gaps.md and docs/target-app-parity.md.
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Drew Dibble