A frame that finds Use Monitor Profile for Canvas off drops a waiting
request; a request made with the preference on is kept when the
preference goes off and on again between two frames.
Overrides::is_set is only called from main under cfg(not(macos)), so it is allowed to be unused there (the repo's cfg_attr pattern). settle_cut_edges walks blended with iter_mut().enumerate() instead of indexing it.
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.
Preferences › Performance › Low-Latency Drawing (lowLatencyDrawing, off by
default) is read when the app starts and asks for wgpu's AutoNoVsync. The
present mode comes from --present-mode, then VECTORCRAFT_PRESENT_MODE, then
the preference, then the default; with the preference off and no override
the window surface is unchanged. The startup log names "(preference)" or
"(override)" after the mode.
Whenever the window presents without vsync, from the preference or an
override, main-window frames start at most 240 times a second (about
4.17 ms apart). The wait comes before egui reads the frame's input, and
the frame's time moves on by it. With vsync the display paces the frames
and no cap applies.
The checkbox shows on the desktop with the note that it applies the next
time VectorCraft starts. A value that is not a boolean is an error.
Fixes#6013
The Windows sampler read the pointer with GetCursorPos when it handled
WM_LBUTTONUP, so a pointer that moved after the release picked a
different pixel. It now takes the point from the release message's
lParam, a signed client point, and converts it to screen coordinates.
lParam holds each coordinate in 16 bits, so on a virtual screen wider
or taller than 32,767 pixels the high bits come from the message's own
pointer position (MSG.pt).
Windows had no screen color sampler, so the Color Picker's eyedropper
button was gray and ui.sampleScreenColor returned an error there.
The new sampler copies the virtual screen (every monitor, including
ones at negative coordinates and at other display scales) and covers it
with a borderless topmost window that shows the copy under a crosshair.
A left click picks the copied pixel, read as sRGB. Escape, a click of
another mouse button, Alt+F4 or switching to another window cancels.
The window runs on its own thread, so the app keeps drawing, and the
copy's size is checked before it is allocated.
Docs: docs/mcp.md, docs/control-protocol.md, docs/target-app-parity.md
and the ui.sampleScreenColor params text.
Use Monitor Profile for Canvas reads the display's profile every 10
seconds and when the window moves to another display. The new command
view.refreshMonitorProfile (Edit › Refresh Monitor Profile, after Assign
Profile…) makes the next frame read it at once, past both the 10-second
reading and the 1-second display check. A request made while a reading
runs waits for that reading to end and then starts.
The command returns {requested: true} before the profile is read, and
ui.inspect's displayProfile reports readRequested while the request
waits. It is off and returns an error while the preference is off
(nothing is queued) and where nothing reads the display's profile (the
web build). It changes no document, proof setting or preference.
The reading thread now clears its busy flag before it asks for a
repaint, and it also asks for one when a request is pending.
The size of a CF_UNICODETEXT block is checked against the most UTF-8 it
could come to (3 bytes a code unit), so the converted text is never
larger than the limit. CF_DIBV5 and CF_DIB are each copied when they
fit the limit, so a large first format that doesn't decode still
leaves the second to paste.
Paste takes at most 64 MiB of a format another app copied, VectorCraft's
existing limit for copied files, and reads the size before the copy:
- On Windows, each registered format, the CF_DIBV5 and CF_DIB bitmaps
(together), CF_UNICODETEXT and the CF_HDROP file list. A larger format
is skipped and the next one is tried.
- On macOS, each pasteboard type's data length is checked before it is
copied.
- A copied file list of more than 1,024 files pastes no file, and no
file in it is opened, on every platform, as the Linux text/uri-list
reader already does. On Windows the CF_HDROP names are counted before
they are read.
File Info's menu saves the fields as an XMP metadata template (into the
Metadata Templates folder next to the preferences, or any file), imports
one with a choice of three merges, lists the saved templates and opens
the folder. The import is one undo step and records nothing when no
field changes.
- file.info.saveTemplate writes the title (when it is not the
document's name), author, author title, description, keywords,
rating, copyright status, notice and URL that have a value.
- file.info.applyTemplate reads a file, a saved template or XMP text
(at most 8 MB) and merges it: replace clears the fields first, keep
takes each field the template has, append adds keywords and fills
only empty fields. apply: false returns the merged fields without
changing the document.
- file.info.templates lists the folder's .xmp files.
- A PDF or .ai also opens with the rating and author title its XMP
packet gives.
Docs: docs/mcp.md, docs/target-app-parity.md.
On X11 and the Wayland data-control clipboard (through arboard), the
Paste menu check read only the clipboard's text, so a file manager copy
with no text left Edit > Paste disabled while the paste keys pasted the
first copied file that is art. After a text miss, the check now reads
the copied file list when the paste can take files, without opening a
file. Copied files already enabled Paste through the core Wayland check
and the Windows check. A paste of text alone does not read the list.
--present-mode (fifo, autovsync or novsync) and --frame-latency (1 to 3),
or VECTORCRAFT_PRESENT_MODE and VECTORCRAFT_FRAME_LATENCY, change the
window surface for one launch. A flag overrides its variable, and a value
outside these stops the app with a message. The log records the surface
the app requests at startup. On Windows and Linux, a launch that sets
either one opens its files in a new window, as --new-instance does.
Without them the window keeps autovsync with one frame queued.
Paste read a file copied in a file manager whole with std::fs::read,
with no size limit. It now checks the opened file's size against
MAX_BYTES (64 MiB, the limit the Wayland clipboard reads already use,
now shared) before reading its first bytes, and reads the rest with a
bounded reader, so a file that grows after the check is read to at
most one byte past the limit and skipped. A skipped file lets the next
copied file that is art paste, as an unreadable one does.
Where the clipboard goes through the compositor's core Wayland protocol
(the Flatpak on GNOME), Paste now reads the text/uri-list a file manager
offers, else GNOME Files' x-special/gnome-copied-files, and pastes the
first file that is art before the clipboard's other types, as on the
other platforms. The list is read on the read worker and the files on
the paste's background thread. Only file: URIs with no host or
localhost are taken (RFC 8089), percent escapes decoded once (RFC
3986); other URIs are skipped, and a list of more than 1,024 URIs, a
limit of VectorCraft's own, names no file. The Paste menu item is
enabled when a file list is offered.
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.
Quitting can wait up to 27 s for the clipboard handles to let go before
eframe closes the windows. winit cannot hide a native Wayland window, so
the main window stayed on screen for that wait, and the X11 windows of
floating panels and documents were not hidden at all.
- A native Wayland main window is unmapped by attaching no buffer to its
surface. The window and its connection stay open for the Wayland
clipboard. An X11 main window, XWayland included, is hidden as before.
- On Linux the X11 windows of floating panels and documents are recorded
as eframe creates and drops them (viewport hooks), and quitting unmaps
them through a second X11 connection before the wait.
- The new module apps/vectorcraft/src/quit_windows.rs replaces
app::hide_before_teardown, with tests of which windows are hidden or
unmapped. portal_save's Wayland surface helper is shared with it.