Every storytold/craft-libs git dependency, the hayro, krilla and
linesweeper patches and the web app's craft-web-api now use one
revision, 64b181977a, so Cargo.lock holds one copy of each craft-libs
crate. craft-ui's docking Monitor has a new work_area field; the
monitors VectorCraft lists set it to None, as winit reports no work
area.
craft-image-codecs moves from a499742a93 to 3af718585c on craft-libs main.
It brings in storytold/craft-libs#1758: a deep EXR file with more than one
part now finds each part's chunks after every part's offset table, and an
offset table that runs past the end of the file is an error.
The move also brings in the other merged changes to craft-image-codecs and
the craft-jpeg, craft-metadata and craft-tiff copies it uses: #1646, #1686,
#1837, #1838, #1867 and #1889. #1774 moves DDS reading and writing into the
new craft-dds crate, which adds BC4 and BC5 textures. The other craft-libs
crates stay at their current revisions. craft-svg keeps its own
craft-image-codecs at 431f704478, which it only uses for PNG, JPEG, GIF and
WebP images.
The XML declaration, DOCTYPE entity subset and root <svg> open now go
through SvgWriter. Mapping and the rest of the document stay in the app.
Width and height stay unitless in one place so #7105 can rebase.
Object › Plug-ins › Packaging Tools › Check Fold Lines, and the Fold Lines
panel's Check button, check the fold lines of the selection, or of the
document while nothing is selected (`addon.packaging.check`).
- Cut lines bound the material: each connected piece that encloses an
area is one blank, its largest closed cut line is the outline, and a
closed cut line inside it is a hole. A slot drawn as a rectangle across
the outline leaves the same material as a notch drawn in it, and an
outline drawn as several open cut lines works too.
- Creases, partial cuts and perforations divide a blank into panels; the
pieces between the same two panels form one hinge.
- 15 issue codes, errors and warnings, each naming its lines; cut line
ends within a tolerance (0.1 pt, 0.01 to 10) are joined and reported as
a gap. With `select`, the lines the issues name are selected.
- The panel lists the issues in the interface language, with a summary
line; clicking an issue or its Select button selects its lines. The
list is kept until the document changes.
`vectorcraft_pathops::adjacency` maps paths as live_paint does and keeps,
for each edge, every input it lies on and the faces on both sides; the
blank model is `vectorcraft_three_d::fold::blanks`. The engine now depends
on vectorcraft-three-d directly.
Docs: docs/mcp.md (Check Fold Lines), crates/pathops/README.md, ROADMAP.
Embedded and linked images read their pixels with decode_within: the
size from the header against the allowance first (as samples and as
RGBA, #1717), then the pixels as stored. map_rgb, sampling, coverage,
link previews and checked_with_pixels all go through it.
decoded_pixels_are_those_the_image_crate_read compares PNG, GIF, WebP,
TIFF and BMP at each depth the image crate writes with its pixels, and
JPEG within two steps, including the pixels checked_with_pixels hands
on. The 11,586² allowance test is a compact PNG; craft-image-codecs
refuses a GIF whose unbacked logical screen is past 256 MiB.
craft-libs main with the JPEG inks reader vectorcraft-doc's CMYK JPEGs use
(#1779) and the craft-jpeg fallback for frames zune-jpeg panics on
(#1782). Cargo.lock regenerated.
* cad: export DXF through craft-dxf's drawing writer
Delete the local ASCII writer and map the document through
craft_dxf::drawing. Public vectorcraft_cad::export, DxfOptions and
DxfVersion stay so vectorcraft#3068 can rebase without a writer API
change. Pin craft-dxf at the craft-libs#1588 branch tip; update the
rev after that PR merges. Golden files lock shapes_doc() bytes for
R12 and 2018 against the old writer. Part of storytold/craft-libs#791
and #778.
* cad: pin craft-dxf to the #1588 tip with Dylan's writer fixes
Point craft-dxf (and craft-codepage from the same rev) at
0b6244f2b9971deaeb6a79d932c818ff94479757, which includes the
Windows golden line-ending fix, BYBLOCK and image-dictionary
key changes, and the compile fix for the dictionary-key test.
Update the pin again to the merge commit after #1588 lands.
* cad: pin shared DXF writer to merged craft-libs #1588
---------
Co-authored-by: FredApps <FredApps@users.noreply.github.com>
a_jpegs_blocks_are_not_traced_as_steps measures how many traced edges land
on JPEG block boundaries, which depends on the encoder's artifacts. With the
craft-image-codecs encoder 18 of 40 segments sit on block edges; with the
original encoder and the new shared decoder the test passes unchanged, so
the trace itself is unaffected. image stays a dev-dependency only.
Port main's new variable-library parsing (variable kinds, image, visibility
and graph values) from roxmltree to craft-xml with the branch's strict
options and attribute validation. Keep both sides' variable tests.
Drop the stale docx::nesting doc link.
A click on the status bar's info field, which showed only the tool in
use, opens a Show menu. Its items choose the readout: Artboard Name
(the artboard the navigator shows), Current Tool (the default), Date
and Time (local on the desktop, UTC on the web), Number of Undos (the
active document's undo and redo step counts) and Document Color
Profile (the profile the document's colors use for its color mode: the
assigned one, else that mode's working space). The choice is kept with
the UI state.
The new command view.statusBarShow {show} sets the readout and rejects
any other value. The labels have rows in every catalog, and
docs/mcp.md and docs/ui-parity.md describe the command.
A native save now sets the stored brushes' art on the document while it
tells linked images from embedded ones and while it converts placed
documents for older versions, then writes the changed brushes back.
- A linked image shown only in a brush's art is saved as its preview, or
with Include Linked Files as its file's bytes; an image key that the
layers or a brush's art shows embedded keeps its full bytes.
- Saving for an older version replaces placed documents in a brush's art
with groups of their art and its resources, before a precision rounds
it, and the precision preview and PDF use the same conversion.
- Data Recovery copies count the images in brush art the same way.
Docs: docs/target-app-parity.md, docs/mcp.md.
usvg decodes an image data URL every time it converts the element that
holds it, a `<use>` copy, a filter or a nested SVG image included, before
the image resolver is called, and nothing bounded the bytes decoded per
import.
Before usvg reads the imported SVG and each SVG shown as an image, every
`href` and `xlink:href` of an `<image>` or `<feImage>` that is a data URL
is replaced with a key. The resolver decodes each URL once, the first
time its key comes, and every later use gets the same image. All data
URLs of one import decode to at most 512 MB together (MAX_DATA_URL_BYTES):
decoding stops where a URL would pass it, and that image is left out with
a warning. A link spelled like a key gets a key too and is still read as
that link.
EMF and WMF import now plays the records with the shared craft-metafile
reader (storytold/craft-libs#778, at the craft-libs rev the SVG, EPS and
DXF crates already use) and maps its picture onto the document here:
paths with their fills, strokes, caps, joins, miter limits and dashes,
clipping groups, images and point type. The EMF and WMF record players in
crates/metafile/src/import and the DIB decoder they used are removed. The
writers are unchanged, and the PICT reader keeps its own player.
What changes for a file being opened, placed or pasted, and for an EPS
file's Windows metafile preview (read when its PostScript can't be):
- An EMF that draws with EMF+ records is read from them. It opened empty,
with a warning that EMF+ is not read. A file with both kinds of record
is read from its EMF+ records too.
- Hatched and pattern brushes fill with the average color of the brush's
tile, translucent where the tile has gaps. Hatches filled with the hatch
color and pattern brushes with gray.
- Translucent fills, strokes and EMF+ text keep their alpha as opacity.
- Text keeps a stretch across from the world transform; it kept only the
turn. Text the file clips to a rectangle is clipped to it, and an
underlined or struck-through font gives underlined or struck-through
type.
- A clip path whose bounding box holds the whole picture is kept unless
it is that rectangle; a diamond or a bow tie around the picture was
dropped.
- Images drawn with SRCAND, SRCPAINT or SRCINVERT are drawn as they look
over white, and images drawn with other raster operations are drawn as
a plain copy. They were left out with a warning.
- Excluded clip rectangles and the other clip region modes are applied.
A clip path combined with RGN_OR, RGN_XOR or RGN_DIFF is ignored
without the warning it gave.
- An image past the reader's size or pixel limits, or one that can't be
decoded, is left out without a warning of its own. A file past the
reader's limits (more than 32 nested clip paths, 200,000 drawn items,
256 MiB held) is read up to that point without a warning.
- An EMF record whose size is not a multiple of 4 ends the file, with the
"ends early" warning.
Tests: an EMF+ only picture imports its fill (it failed before), a dual
EMF+ file draws its translucent EMF+ fill and not its fallback, hatch and
pattern brush colors, clipped and underlined text, excluded clip
rectangles, a shared clipping group, an odd record size, WMF at 1440
units an inch without a placeable header and at its own units with an
inverted box, an EMF without a frame, diamond and bow-tie clips, text with a
stretch, clips nested past the stack and 200,000 clip records; the fuzz
test gains random EMF+ records.
With `unicode-bidi: plaintext`, SVG import looked for the first strong
character of an element in each text node on its own and kept the
first answer. An isolate that opened in one text node and closed in a
later one hid the rest of that node, and the node then answered left
to right. For `⁧ab<tspan>⁩א</tspan>` the element
ran left to right, where UAX #9 P2 skips the isolate and finds the
right-to-left letter after it
(https://www.unicode.org/reports/tr9/#P2).
The characters of the whole `<text>` are now read once, in order, and
each isolate initiator is matched with its PDI (UAX #9 BD9). Each
element's first strong character is then found in constant time, so
nested `plaintext` elements do not read the same characters again. An
isolate that opens inside an element and closes after it hides the
rest of that element.
vectorcraft-svg takes `unicode-bidi` 0.3.18, which vectorcraft-text
already uses, for the bidi classes.
On the core Wayland clipboard, a read waited for the app that copied to
close its pipe, and a send wrote until the app that pastes took all of
the data. An app that left its pipe open and stopped held the one read
worker, so later pastes failed at once, or held one of the eight send
threads until it closed its end.
Reads and sends now use the pipe nonblocking and wait for it with poll.
When no byte moves for 2 s (VectorCraft's own limit, the existing text
wait) the read fails without pasting partial data and the send stops;
both close their pipe. The wait starts again after each byte that moves,
so a large transfer that keeps going is not cut short.
craft_dxf::parse_recovering reads the tags (ASCII and binary, any code
page), model::Document::read the sections, tables, blocks, layouts and
entity followers, and Entity::read each entity. The pair parser, the
records, the header, layer, block and layout readers and the colour
palette are gone; what stays is the mapping onto VectorCraft art.
Binary DXF files now open instead of being refused. A damaged binary
file says so.
When a painted live effect on a fill or stroke returned several fills or
strokes, the next effect in that stack ran only on the first of them and
the others took its geometry. A later live-effect plug-in, and a later
geometry effect on strokes, now runs once on each of them in paint order,
given the piece's fills and strokes and its own `_context.item`. Each
run's pieces replace only that fill or stroke; a run that fails, is
refused, is deferred or would pass the effects' budget leaves only its own
fill or stroke as it was. Fills and strokes that keep the same path stay
on one path, and a deferred run is listed at the source fill's or
stroke's place.
The results that are kept share the effects' budget, and each run's
result is kept or left out whole. They are first placed with all the
room the art leaves, and placed again with room kept for the piece's path
when a fill or stroke left on that path finds no room. A result on the
path before it costs nothing and is taken whatever room is left; a
built-in effect that finds no room is built again with all the room the
art leaves, and that result is taken only when it is on the path before
it. A plug-in result is held only while it is placed: one that does not
fit, or that moves onto the path before it, is let go at once, so the
results held at one time stay within the budget however many fills and
strokes the piece has. A result kept in the first placing is reused in
the second without running the plug-in again. A painted piece's share of
the budget is counted once at each later effect.
Where arboard has neither data-control nor X11 (the Flatpak on a GNOME
Wayland session), Copy and Paste used smithay-clipboard on the window's
connection, which carries text only. They now use a core wl_data_device
client on that connection.
- One Copy offers the PNG as image/png, the SVG as image/svg+xml (with
Include SVG Code on) and the text as text/plain;charset=utf-8,
UTF8_STRING and text/plain. A format with no data is not offered.
- Paste reads SVG, then text, then PNG. Blank text, or text that only
names a picture, gives way to the PNG, and a failed or empty SVG read
falls back to the types after it. The Paste menu item is enabled by the
types offered, without reading any data.
- The clipboard holds VectorCraft's Copy while its data source is not
canceled and the offer has the Copy's types.
- A read takes 64 MiB at most. Text waits 2 s, SVG and PNG 10 s off the
UI thread. Another app's paste is sent on its own thread, 8 at once.
smithay-clipboard is no longer a dependency of the app.
A parameter schema's error ("`zoom` must be a number > 0, not -1") was
translated around its requirement, which stayed in English in every
language: only "a number", "a string" and "true or false" had rows.
- Every complete catalog gets a row for each requirement a schema
writes: a number with each kind of range and with a unit, an integer
and its range, a list of names, an object id, a list of object ids,
a color, a point, an object and a list. The bounds, unit and names
stay as the English gives them.
- An enum error no longer matches the `{key}` must be one of {_1} row,
which took `"a", "b", not "c"` as its list and left ", not ..." in
English: a `{path}` must be one of {_1}, not {got} row translates it,
in the complete catalogs and in Bulgarian, Bosnian, Danish,
Indonesian and Dutch.
- A part of a message that starts with `{` or `[` is translated only
when it is an exact message, so "[x, y] (two numbers)" translates and
JSON values, shown cut short or whole, stay as they are.
Docs: docs/mcp.md (Parameter schemas), docs/target-app-parity.md.
Pin craft-ui to c4b8405d, which adds a top edge and the canvas-side top
corner to icon-strip flyouts and saves the moved top per group. Accept
its new MoveFlyoutTop docking action, and restore the saved top when a
group returns to its place. A docking regression checks the cursors, an
upward top-edge and free-corner drag with the bottom and icon-column edge
fixed, and the top after reopening and in a saved layout.
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: Codex <codex@openai.com>
craft-update and craft-vectorcraft-format move from storytold/craft-libs
at 6e03f65bf to e98299546, craft-libs main with 47b6bbadf. The startup
check's thread now reads whether the copy installs itself, so a slow
disk no longer stalls a frame when the startup prompt is built. Both
crates stay on one craft-libs revision; the other craft-libs pins are
unchanged. Cargo.lock changes only the two crates' source.