Commit Graph
61 Commits
Author SHA1 Message Date
dotCooCoo 3829880993 .ai save: a live blend's steps carry no text wrap; metric distances stay live
- 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.
2026-11-16 21:19:00 -08:00
dotCooCoo 4b2868bd07 .ai save: the editing copy keeps live blends
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.html
https://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.
2026-11-16 17:31:04 -08:00
dotCooCoo 5fcccce7ce Paths: Reverse Path Direction turns a compound path's own stroke width profile and pen records
Reverse Path Direction reversed each member path of a compound path and
turned the members' own stroke records, but left the compound path's
strokes as they were. A compound path's strokes run along its members'
subpaths in order, so its width profile and pen pressure, tilt, bearing
and rotation then ran the old way and the stroke drew differently.

reverse_stroke_records now also takes a compound path, reading its
members' subpaths in order, and path.reverse turns each compound path's
strokes with the combined reversal of its members before they reverse.
As for a path, the strokes turn only when every subpath turns alike.
2026-11-14 14:52:36 -08:00
dotCooCoo 81ec6498dc Merge main into fix/blend-reversed-key-stroke-direction 2026-11-14 12:28:54 -08:00
BFlat 85ce363b93 Merge pull request #7548 from dotCooCoo/fix/objects-on-path-widgets-flatten-once
Objects on Path: the widgets flatten the group's path once per lookup
2026-11-15 03:22:27 +07:00
dotCooCoo 6a078a0030 Blend: dashes on a closed key reversed from its own start read back from its end
A closed key that winds the other way is reversed keeping its start anchor.
Its dash offset was computed as if the reversed path ran back from position
0 instead of from the end of the subpath, so the dashes shifted by the
subpath length modulo the pattern period. The offset now uses the full
length in that case, and the dash test covers a closed key 40 long with a
7.5 period.
2026-11-14 11:41:09 -08:00
dotCooCoo 3be00f4bd3 Blend: a gradient steps where the other does only at a step of its own
When two gradients with different stop counts are blended, the second stop at the other
gradient's step took the last stop within the step tolerance, so two close but distinct stops
became a hard step. It now takes the last stop of a step of its own there, and otherwise paints
what the gradient paints at that place.
2026-11-14 10:14:38 -08:00
dotCooCoo 22ec066bb7 Blend: a turned hue gradient that reflects keeps its swatch links
A hue gradient that reflects unrolls through its curve, whose stops have no swatch links, so a
gradient along a closed key started elsewhere lost its links. The links now come from the
gradient's own stops unrolled as a Classic gradient's, in order, so stops at one place and the
stops where two runs meet keep their own links.
2026-11-14 10:03:08 -08:00
BFlat 3d895d9ac7 Merge pull request #7448 from dotCooCoo/fix/reverse-path-profiles
Paths: Reverse Path Direction turns the stroke's width profile and pen records with the path
2026-11-15 00:40:08 +07:00
dotCooCoo 43823fc844 Blend: a stroke gradient started on a step keeps the link after it
When a closed key path now starts where its stroke gradient steps between
two stops of one color linked to different swatches, the gradient's new
first stop takes the swatch link of the stop after the step instead of
the one before it.
2026-11-14 07:51:15 -08:00
dotCooCoo 09eab2c93c Merge main into fix/blend-reversed-key-stroke-direction 2026-11-14 07:14:47 -08:00
dotCooCoo 3a6b016253 Blend: steps between gradients linked to the same spot swatch keep its process plates
A blend between two gradients whose matching stops are tints of one spot
swatch kept the link and interpolated the tint, but every step's stop lost
the process inks (C, M, Y, K) printed with the spot ink, so PDF export wrote
the steps as the spot ink alone.

- Matching stops linked to one swatch interpolate each process ink with the
  tint; a stop without process inks counts as none of each, and the ends
  keep their own.
- Gradients with different stop counts keep the inks at every resampled
  stop, interpolated with the midpoint-adjusted fraction between two stops
  of one swatch.
- A solid blended with a gradient brings no process inks of its own: its
  stand-in gradient no longer copies the other gradient's.

Stops of different swatches, or linked and unlinked stops, still blend into
unlinked process colors without plates.
2026-11-14 04:25:55 -08:00
dotCooCoo cde9a27b4f Objects on Path: the widgets flatten the group's path once per lookup
Finding where the Rotate All, Space, Move All and Select/Move widgets
go and testing whether the pointer is over one flattened the group's
path two to three times per widget. Starting a Space, Move All or
Select/Move drag flattened it five times, and one pointer move over the
group could flatten it eleven times. Each lookup now flattens the path
once and shares that measurement across the widgets:

- vectorcraft-doc makes `Measured` public with `stop` and `stops`, and
  adds `attachable`, which returns the path with its measurement.
- `Widgets::of` gives all four widgets for the canvas, `widget_at` gives
  the widget under the pointer, and `WidgetDrag::hit` gives the drag a
  press starts, each from one flattening. The Selection and Objects on
  Path tools and the canvas use them.
- A Space, Move All or Select/Move drag keeps its measurement and
  measures again only when the group's path changes.

Widget places, hits, cursors and drag results are unchanged. The new
`spine-count` feature of vectorcraft-doc exposes the flattening counter
to vectorcraft-tools' tests; it is enabled only as a dev-dependency and
leaves Cargo.lock unchanged.
2026-11-14 03:01:29 -08:00
dotCooCoo 2f8301671e Blend: stroke gradients and dashes follow a key path the blend turns
When a blend starts a key's path at another anchor or runs it the other
way, the steps already read that key's width profile and pen recordings
along the turned path. Its stroke gradient and dashes still followed the
key's own direction, so steps near that key showed them flipped or
shifted.

- A gradient along the path starts where the turned path starts and
  runs backwards on a reversed one; a gradient across the path swaps
  sides on a reversed one. Stops that reflect an even number of times
  are left as they are.
- Dashes run backwards on a reversed path, and exact dashes start where
  the turned path starts, when every subpath needs the same offset.
- Two gradients with different stop counts keep a step (two stops at
  one offset) when they are resampled to common stops.
2026-11-13 21:16:01 -08:00
dotCooCoo cf250db2e8 Paths: Reverse Path Direction turns the stroke's width profile and pen records with the path
Reverse Path Direction reversed the anchors but left the stroke's width
profile, pressure, tilt, bearing and rotation running the old way, so a
tapered or pressure-drawn stroke changed shape. They now turn with the
path through the blend code's stroke reorientation (the width profile's
sides swap), and the stroke draws as before. A path whose subpaths do
not all turn alike keeps its stroke as it was, as blends do. Arrowheads
stay at the path's start and end.
2026-11-13 21:05:44 -08:00
BFlat 200b65feea Merge pull request #7247 from dotCooCoo/fix/blend-spine-measured-once
Blend: spreading keys along a replaced spine measures it once
2026-11-14 04:31:35 +07:00
dotCooCoo 8091e4861e Blend: a spine whose length overflows gives two keys no anchors
Spreading two keys along a spine whose length overflows splits nothing, so
it returned the end anchors, and a closed spine was then opened at its start.
spread_anchors now rejects a length that is not finite before it makes any
target, so two keys get no anchors and the path stays as it was, as for
three or more keys.
2026-11-13 11:47:15 -08:00
dotCooCoo 6326b17b0e Blend: spreading keys along a replaced spine measures it once
Giving the keys of a blend whose spine came from Replace Spine anchors of
their own flattened and measured the whole spine again for every key,
then walked its segments one by one. 1,000 keys on a spine of 4,096
segments flattened it 999 times.

The spine is now flattened once into one buffer. A split flattens only
its two halves and measures the segments after it again, in order, only
as far as the next key, so the arc lengths are summed as before and the
keys get the same anchors. A binary search finds each key's segment.

A spine so large that its length overflows no longer gets an anchor
split at a parameter that is not a number: spreading keys along it
returns nothing and leaves it as it was.
2026-11-13 11:21:31 -08:00
dotCooCoo 444f50a4c4 Objects on Path: each path is flattened once per placement or transform
stops and stop flattened the path twice, once for the points and once
for its length, and stop did both before rejecting an index past the
last object. place validated the path with attachable_path first, and
transform measured the old and new paths up to three times each.

A private Measured value now holds the flattened first subpath with its
length and closed flag, and path_length, stops, stop and transform use
it. stop returns None for an out-of-range index without measuring, and
a move of the group measures no path.

attachable_path now uses path_length, so a path whose length overflows
to infinity is no longer offered as one objects can attach to when
placement cannot measure it.
2026-11-13 10:50:24 -08:00
dotCooCoo e13384ebb4 Merge main into fix/blend-without-spine-widget 2026-11-13 08:06:40 -08:00
dotCooCoo 666084fb81 Blend: find the spine segment for an arc length with a binary search
Spine::at_length walked the first subpath's segments from the start
until one ended at or past the arc length, so placing every blend step,
spread key, blend widget and Objects on Path attachment cost one
comparison per earlier segment. It now searches the anchors' arc
lengths, which never decrease, and picks the same segment: the first
whose end is at or past the length, so an exact anchor length and
repeated lengths from zero-length segments keep their segment. The
point and tangent evaluation is unchanged.

Tests compare the search with the old walk on open and closed spines,
one segment, curves, zero-length segments, every anchor, both ends,
out-of-range and non-finite lengths, and check that a 4,096-segment
spine needs at most 13 comparisons.
2026-11-13 06:46:06 -08:00
dotCooCoo fc70b08f71 Blend: a blend without a spine shows the Appearance widget
A blend made with Create Spine set to Never now shows the Appearance
widget with the Selection and Blend tools, so its color Shift can be
dragged on the canvas as on a blend with a spine. The Easing widget
stays hidden, since easing needs a spine.

The widget sits 16 px above the halfway point, by length, of the
straight lines between the key centers that the steps are laid out
along, and a drag follows those lines' direction there. The lines are
not drawn. `blend_layout_line` exposes that line; `blend_spine` still
returns `None` for such a blend.
2026-11-13 06:17:47 -08:00
BFlat f976979a2f Merge pull request #6955 from dotCooCoo/fix/blend-profiles-follow-key-start
Blend: stroke profiles turn with a key path started at another anchor
2026-11-13 03:27:08 +07:00
BFlat 813b24b0a5 Merge pull request #6835 from dotCooCoo/feat/blend-canvas-easing-handles
Blend: on-canvas widgets set a selected blend's color shift and easing
2026-11-13 02:47:08 +07:00
dotCooCoo 7b97708c43 Blend: stroke profiles turn with a key path started at another anchor
When a blend starts a key's path elsewhere (an open path clicked at its
last anchor, a closed path turned to another start or reversed to match
the other key's winding), the steps now read that key's width profile,
pen pressure, tilt, bearing and rotation along the turned path, and a
reversed open path's arrowheads swap ends. A width profile's sides swap
when its path is reversed, a closed path's samples move past the new
start keeping the step at the old one, and a split width span is sampled
so its curve keeps its shape. A key whose subpaths turned differently
keeps its stroke as it is.

Width profiles in the steps also keep their discontinuous points instead
of only the width before them, and are sampled between their points so
each key's curve keeps its shape where the other key adds points; keys
whose points sit at the same positions are not sampled, so a preset on
both keys stays that preset. A sample of one key that lies within a
millionth of the other key's step no longer hides that step.
2026-11-12 10:38:00 -08:00
BFlat 30fbb81778 Merge pull request #6918 from dotCooCoo/fix/blend-steps-interpolate-pen-data
Blend: steps of brushed strokes interpolate the pen pressure, tilt and angles
2026-11-13 00:50:15 +07:00
dotCooCoo 9df4a83f07 Merge main into feat/blend-canvas-easing-handles 2026-11-12 08:46:06 -08:00
dotCooCoo a5541ab42a Blend: steps of brushed strokes interpolate the pen pressure, tilt and angles
A blend between two strokes drawn with a pressure-sensitive brush gave
every step the pen recording of the nearer key, so the brush jumped at
the middle step. The steps now interpolate the pressure, tilt, bearing
and rotation at every position either key has a sample. A key without a
recording counts as half pressure, half tilt and 0 degrees, as brushes
read it. Angles turn the shorter way round, and steps and whole turns in
a recording stay in the steps. Different brushes still switch halfway.
2026-11-12 08:26:32 -08:00
dotCooCoo 91d705e155 Gradients: repeat or reflect a gradient's stops a set number of times
A linear, radial, conic or diamond gradient has a spread: Pad (the
default, as before), Repeat or Reflect, with a count of 1 to 100
(VectorCraft's own limit). Repeat and Reflect run the stops that many
times along the vector (around the turn for a conic) and keep going past
both ends, Reflect running every other run backwards, as SVG's
spreadMethod does.

The Gradient panel has a Spread menu and a Repeats field, and the
Gradient tool marks where the runs meet. paint.setFill and
paint.editGradient take `spread` and `repeats`; bad values are errors.
Presets, swatches, blends, strokes along or across a path, Outline
Stroke and Object › Expand follow the spread; Expand gives each run the
same whole number of objects, and Outline Stroke's mesh keeps the color
on each side of a sharp step between two stops at one offset.

SVG writes and reads spreadMethod: SVG import now reads a repeating or
reflecting gradient as one that repeats or reflects once, instead of
expanding its stops over the shape. CSS writes repeating gradients.
PDF writes a conic's sweep shading over one run. PDF, EPS, legacy .ai
and the .ai editing data write the other kinds with their stops
repeated across the shape: at most 256 runs and 16,384 stops (256 stops
in .ai files), and for a radial or diamond no farther than 65,536 runs
from its center, with a warning past those. PDF import now finds sharp
steps in any axial or radial shading instead of blurring them.

Docs: docs/mcp.md (Spread), docs/target-app-parity.md, docs/gaps.md.
2026-11-12 06:52:38 -08:00
HassanKhan fb9a3a813b Blend: pinning a closed replaced spine gives its end keys points of their own (#6809)
Pinning a closed spine from Replace Spine (a spine edit, Reverse Spine)
stored it closed with both end keys on its first point, so moving the
first key afterwards landed it on the last. Pinning now opens the spine
there as the layout of a moved key does.
2026-11-12 13:57:30 +05:00
HassanKhan a8b5a5b6c9 Blend: moving an end key of a closed replaced spine moves its end (#6809)
On a closed spine from Replace Spine both end keys sit on its first
point, so moving one moved that point onto it and then back onto the
other. Once a key is moved off, the spine is now opened at its first
point, with a copy of it at the end taking the closing segment and the
last key.
2026-11-12 13:15:22 +05:00
dotCooCoo bd82a598dd Blend: on-canvas widgets set a selected blend's color shift and easing
With one whole blend selected, the Selection and Blend tools show two
widgets at the halfway point of its spine. Dragging the upper widget
along the spine sets the color shift (-100 to 100), and dragging the
lower one sets the easing strength (0 to 100). The lower widget shows
only when the steps follow a spine (a replaced spine or Align to Path),
the rule the step placement uses; a blend made without a spine shows
neither. When the boxes of three or more other visible objects hold a
widget's spot, the widget moves out in 16 px steps, up to 144 px, and
its line to the halfway point grows with it. While a widget is held,
the arrow keys step its value by 1 (Shift: by 10), and Escape or a
switch to another tool cancels the drag. A drag is one undo step; a
click or a drag that ends where it started records none.

- object.blend.setEasing sets easingType, ramp and colorShift on one
  blend, refuses a hidden or locked blend and easing on a blend without
  a spine, and records no undo step when nothing changes.
- BlendSpec::eases_along_spine holds the rule the step placement and
  the widget share.
- While a tool is busy, an arrow it claims arrives with the press's
  Shift and Alt; before, it always arrived plain.

Docs: docs/mcp.md, docs/target-app-parity.md.
2026-11-12 00:07:35 -08:00
HassanKhan aec586b840 Blend: moving a key of a blend with a replaced spine moves it (#6809)
After Replace Spine the keys are not pinned to spine anchors, so the
steps spread them evenly along the spine by arc length and put a moved
key straight back where it was. Once a key is moved off its place, the
spine is laid out pinned at the anchors where the keys were spread, and
the moved key takes its point of the spine along, as on a pinned spine.
2026-11-12 12:51:06 +05:00
dotCooCoo f82a31045c Blend: the Blend panel's Create Spine menu sets whether new blends get a spine
The Blend panel gets a Create Spine menu (Auto, Always, Never) under Make,
and object.blend.createSpine {mode?} sets or reads it. It is kept with the
preferences, is not an undo step and leaves blends already made as they are.
object.blend.make takes createSpine to choose for one new blend.

Auto and Always give every new blend a straight spine, as before. Never
makes a blend without one: its steps sit where a straight spine puts them,
object.blend.info reports hasSpine: false, easing is refused and dimmed,
Reverse Spine and the spine point commands refuse it, Release gives back
no spine path, and Replace Spine gives it a spine. A blend taking more keys
keeps whether it has a spine. Native files save noSpine; older files open
with their spines.

Builds on #5177 by adambelis.
2026-11-11 21:11:12 -08:00
dotCooCoo a1949095c6 Type: an option fits a text object's bounds to its glyph outlines
Measure Type by Glyph Bounds (`typeGlyphBounds`, off by default) is in
Preferences > Type > Glyph Bounds and the Transform panel menu. With it
on, the bounding box, the Transform, Control bar and Properties X, Y, W
and H, `object.setBounds`, the transform tools' reference point and the
Arrange commands measure point type selected on its own by the ink of
its glyphs instead of its em box. A typed W or H scales the live type
until its ink has that size.

- The engine caches each type object's ink in text space with its
  layout bounds; the cache is not saved.
- Use Preview Bounds adds the characters' strokes, and type with
  geometry effects is measured as drawn. Skewed type is measured by its
  outlines.
- Type that draws nothing, area type, type on a path and type inside a
  selected group are measured as before. Align and Distribute keep
  following Align to Glyph Bounds.

Docs: docs/mcp.md, docs/control-protocol.md, docs/target-app-parity.md,
object.setBounds params text.
2026-11-09 21:07:55 -08:00
adambelis 585621a661 Blend: the spine keeps only the subpath it samples
Spine stored a full clone of the blend's PathData but only ever read its
first subpath. Store that SubPath instead, which drops the extra
allocation and makes the field's purpose clear. Document the field and
the two cases where Spine::new returns None.
2026-11-09 10:06:49 +01:00
bflatastic 8e45313501 Blend: the spine's ends are its exact end points 2026-11-09 05:06:28 +07:00
bflatastic 863023d7de Blend: a vanished spine tangent takes the curve's direction nearby; the unreachable copy after the loop goes 2026-11-09 04:45:17 +07:00
adambelisandCraft Bot 2709a5191f M2.1: blend Align-to-Path smooth on curved spines
Spine::at_length computed tangents from flattened polyline chords, which
are piecewise constant and jump discretely between chords on curved
spines. Steps oriented to the spine with Align to Path stuttered at
large step counts.

Fix: store the original PathData in Spine and compute the tangent from
the original cubic at the true arc-length position via ParamCurveDeriv,
proportionally mapping flattened arc-length s onto each segment's curve
arclength using anchor_length values, instead of using piecewise-constant
chord directions.

Updated segment-selection condition in Spine::at_length to skip segments
whose flattened end is not greater than start before checking whether s is
within the segment. Preserve the existing final-segment fallback so
at_length(0.0) selects a nonzero segment and uses its tangent.

Added zero-derivative fallback tangent for blend-step sampling to keep
Align to Path from passing a zero tangent to atan2.

Added missing docstrings for Spine::new and Spine::length to satisfy
docstring coverage requirements.

Co-authored-by: Craft Bot <bot@storytold.dev>
2026-11-09 04:42:48 +07:00
adambelisandCraft Bot cb5300415a M2.1: blend Align-to-Path smooth on curved spines
Spine::at_length computed tangents from flattened polyline chords, which
are piecewise constant and jump discretely between chords on curved
spines. Steps oriented to the spine with Align to Path stuttered at
large step counts.

Fix: store the original PathData in Spine and compute the tangent from
the original cubic at the true arc-length position via ParamCurveDeriv,
proportionally mapping flattened arc-length s onto each segment's curve
arclength using anchor_length values, instead of using piecewise-constant
chord directions.

Updated segment-selection condition in Spine::at_length to skip segments
whose flattened end is not greater than start before checking whether s is
within the segment. Preserve the existing final-segment fallback so
at_length(0.0) selects a nonzero segment and uses its tangent.

Added missing docstrings for Spine::new and Spine::length to satisfy
docstring coverage requirements.

Co-authored-by: Craft Bot <bot@storytold.dev>
2026-11-09 04:42:48 +07:00
adambelisandCraft Bot b8d23e280b M2.1: blend Align-to-Path smooth on curved spines
Spine::at_length computed tangents from flattened polyline chords, which
are piecewise constant and jump discretely between chords on curved
spines. Steps oriented to the spine with Align to Path stuttered at
large step counts.

Fix: store the original PathData in Spine and compute the tangent from
the original cubic at the true arc-length position via ParamCurveDeriv,
proportionally mapping flattened arc-length s onto each segment's curve
arclength using anchor_length values, instead of using piecewise-constant
chord directions.

Added missing docstrings for Spine::new and Spine::length to satisfy
docstring coverage requirements.

Co-authored-by: Craft Bot <bot@storytold.dev>
2026-11-09 04:42:48 +07:00
adambelisandCraft Bot 5589049a47 M2.1: blend Align-to-Path smooth on curved spines
Spine::at_length computed tangents from flattened polyline chords, which
are piecewise constant and jump discretely between chords on curved
spines. Steps oriented to the spine with Align to Path stuttered at
large step counts.

Fix: store the original PathData in Spine and compute the tangent from
the original cubic at the true arc-length position via ParamCurveDeriv,
proportionally mapping flattened arc-length s onto each segment's curve
arclength using anchor_length values, instead of using piecewise-constant
chord directions.

Reviewed-by: craft-house-rules

Co-authored-by: Craft Bot <bot@storytold.dev>
2026-11-09 04:42:48 +07:00
Adam Belis 4851736364 M2.x: blend Align-to-Path smooth on curved spines
Spine::at_length computed tangents from flattened polyline chords, which
are piecewise constant and jump discretely between chords on curved
spines. Steps oriented to the spine with Align to Path stuttered at
large step counts.

Store the original PathData in Spine and compute the tangent from the
original cubic at the true arc-length position via ParamCurveDeriv,
instead of flattened chord directions.

Adds a regression test walking 200 samples along a curved spine and
asserting each tangent step stays under 0.1 radians.
2026-11-09 04:42:48 +07:00
dotCooCoo 888bf32f82 Blend: Smooth Color counts a step per level of color change
Smooth Color now counts the steps between each pair of keys from the
keys' colors and visible bounds, which changes the step count of most
Smooth Color blends. The counts are VectorCraft's own values:

- When the keys' solid fills or strokes differ (in groups, member by
  member; in text, run by run), the count is 255 times the largest
  change of one channel as a fraction of its range, a half step
  rounding down, from 1 to 254. An RGB channel's range is 256 values,
  CMYK and gray count in percent, and two tints of one swatch by their
  tints. It is at most eight per point of the largest of the keys'
  widths and heights and the distance between their centers. Black to
  white was 128 steps and is now 254.
- When the colors match, a solid paint meets no paint, or a key holds
  a gradient or a pattern, the count is the largest distance between
  corresponding visible bounding-box edges divided by the keys' mean
  width or height, rounded, less one, from 1 to 1000. Two 20 pt
  squares 200 pt apart were 100 steps and are now 9.

Keys without bounds make the color count when their colors differ,
and 1 step otherwise.

A blend nested in another blend's keys counts toward the step limit
by its color steps when its colors differ, and as up to 1000 steps
when they match (256 before). An outer blend of 200 steps between two
such same-color Smooth Color blends now draws 99 steps.

A Smooth Color blend in an .ai file whose drawn steps follow this rule
now opens as a live blend.

Blend Options: https://web.archive.org/web/20241217212108/https://helpx.adobe.com/illustrator/using/blending-objects.html
Docs: docs/mcp.md, docs/target-app-parity.md.
2026-11-08 12:59:32 +07:00
dotCooCoo 2b29a680f3 Objects on Path: the Space widget spaces the attached objects along the path
With one Objects on Path group of two or more objects selected, the
Selection and Objects on Path tools show a square Space widget beyond the
last object, ahead along the path. Dragging it moves the last object
along the path, around its bends, as far as the pointer moves along it,
and the objects between follow evenly while the first one stays. With
Alt (Option on macOS) the objects spread from both ends toward or away
from the center of an open path, or of the first anchor of a closed one.
The distance between the objects shows next to the pointer in the
document's units; the drag is one undo step, and Escape cancels it.

- object.objectsOnPath.options takes spacing (points, or "auto", the
  default even spread) and start (points from the first anchor). A
  spacing the path has no room for is drawn smaller and kept, so a
  longer path brings it back. Older files read as Auto.
- Moving the group, Pivot, Rotate, path edits, copies and saving keep
  the Space. Scaling, rotating or shearing the group keeps the first
  and last objects where the transform takes them on the new path, live
  shapes included; a value that cannot be kept that way scales with the
  path's length.
- The Rotate All widget follows the first object when Space moves it.

Behavior: https://helpx.adobe.com/illustrator/desktop/manage-objects/arrange-objects/rearrange-and-edit-objects-on-a-path.html
and https://helpx.adobe.com/illustrator/using/objects-on-path.html.
2026-11-03 16:03:40 +07:00
dotCooCoo 8362b7532c Eyedropper: Shift-click samples a blend's steps and an envelope's distorted art
Squashed from #4949 onto main.
2026-11-01 09:24:18 +07:00
NetterSilverandClaude Haiku 5.5 d38e3b9015 Close all gaps in solid-like dash pattern for odd-length dashes
Found while testing crates/doc/src/blend.rs:197-201 (lerp_dash, solid_like)

Co-Authored-By: Claude Haiku 5.5 <noreply@anthropic.com>
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-30 05:52:33 +07:00
Don Omondi def9e0f08e Blend: nested blends keep to a step budget (#3579)
A blend whose keys are blends draws each of its steps as a copy of a key,
and that copy makes its own steps when it is drawn, so step counts capped
per pair multiplied with nesting: five levels of 15 steps were 1.3 million
steps from a 23 KB file, 3.4 GB to export.

A blend now makes at most 100,000 steps in all (MAX_BLEND_STEPS), counting
the steps of the blends inside its keys and steps. Past the budget each pair
of keys keeps the same share of its steps; a copy of a blend spaced by
distance counts the most steps its spacing can make, since scaling it up
adds steps. Blends within the budget draw every step as before.
2026-10-29 09:57:33 +07:00
Taha-Mahmoodi 2bad646821 Gradients: a Perceptual gradient mixes its colours in OKLab, and SVG and PDF write it as an image
Illustrator 30.0's gradient Method, from the public documentation
(https://helpx.adobe.com/illustrator/desktop/paint-and-fill/create-and-edit-gradients/control-perceptual-interpolation-in-gradients.html):
Classic or Perceptual; perceptual interpolation matches colour transitions to
how the eye perceives differences between colours, and perceptual gradients
are rasterised when saved as PDF or SVG.

- Gradient gains `method` (Classic | Perceptual; serde default Classic,
  written only when Perceptual, so older files open as Classic and Classic
  files are written as before). The colour crate's OKLab helpers open up for it.
- Perceptual mixes neighbouring stop colours in OKLab (sample, and
  sample_keep_model for the stroke meshes, Expand and blends); opacity stays
  linear. Renderers that mix linearly get stops on the perceptual curve,
  placed by halving each half segment where a straight line strays more than
  0.4 of a colour level (a nearly straight segment needs none). Classic
  gradients expand exactly as before.
- draws_as_pixels includes Perceptual gradients, so SVG and PDF write a
  Perceptual fill or stroke as an image at the document's raster effects
  resolution, clipped to what it paints. A gradient along or across a stroke
  stays slices (PDF no longer draws it as a within-stroke image).
- With Dither: a dithered Perceptual fill is the perceptual mix with dither's
  noise (the canvas's dithered grids are keyed by method too); SVG and PDF
  write it as an image with the noise, and a dithered Perceptual stroke as an
  image without it, as the canvas draws it (GradientPaint::pixels, SVG's
  raster_paint and PDF's area are told whether they paint a fill).
2026-10-23 01:53:29 +07:00
bflatastic 92f295d2a2 Blend: Ease In / Ease Out and separate Color Ease in Blend Options (#1124)
Squashed from #2539 onto main.
2026-10-22 04:40:10 +07:00