Hidden tabs live in disabled scene trees, so
wlr_scene_output_send_frame_done() never reaches them and
frame-callback-throttled clients stop committing: only the shown
window's thumbnail tracked live while the rest sat at their last
frame.
Fan frame-done out to every hidden tab window once per output frame
while the overlay is held (overlay_send_hidden_frames after the scene
frame-done in both render_standalone and render_and_present). The
walk covers main plus subsurface trees for both xdg and X11 windows
via window_surface(), and skips the shown window the scene path
already handles.
Gated on --overlay-previews plus overlay_visible, so the steady state
with the menu hidden costs nothing and background clients are not
woken. The existing thumb_capture snapshot and draw-time tree
composite paths are unchanged; they simply receive the commits they
were missing.
Tests: new test_standalone_headless_overlay_previews_hidden_live uses
a hidden --pulse tab and asserts the red thumbnail count swings while
Alt is held. README overlay-previews paragraph updated from freeze to
live-while-held.
Verified: ./build.sh clean; overlay-previews suite 6 passed; full
suite 179 passed with -n4.
New --cursor-size N (8..128px, both --cursor-size N and --cursor-size=N forms) sizing the standalone wlr_cursor. Precedence: CLI flag over $XCURSOR_SIZE over the 24px default. Out-of-range, missing or non-numeric values are startup errors (rc 2) naming the flag, matching the existing --start-cmd-index/--tab-groups handling. Nested mode is unaffected (the host draws the pointer there); the flag is silently ignored. Help text, README usage + cursor-shapes section, and a test_cursor_size_flag_errors regression test included. Verified: debug + release builds warning-free; cursor_size + tab-groups flag-error tests pass; --cursor-size 32 boots headless, --cursor-size 999 exits rc 2.
Adds test_standalone_headless_session_lock_no_overlay_or_disturb: while
ext-session-lock holds the session, holding the tab prefix must not
show the overlay and a passive key must leave the lock undisturbed
with the session alive. Guards the removal of the session_locked
early-return that swallowed every key (PIN typing now reaches the
locker). Verified to fail on the pre-fix compositor and pass after.
Preview menus open with a full-width header naming the active tab's current window (icon plus ellipsized title). Full width keeps menu sizing independent of the selection, so moving the highlight never resizes anything; thumbnail fill-share accounts for the header block within the existing margins. Taps on the header are swallowed.
Preview rows divide the content-sized menu (centered, 50px top/bottom margins) instead of using a fixed triple-title height, with each thumbnail capped at a quarter of the screen height. Measure, draw and hit-test share one metrics helper; snapshot size follows a cache with a legacy fallback. Adds a menu-band regression test.
Firefox paints into subsurfaces while its main surface stays transparent, so the single-buffer snapshot saw only black. Windows with subsurface content now composite at overlay-draw time from each live surface texture (which outlives current.buffer), while plain windows keep the legacy snapshot path. Adds wltest --subsurface repro mode and a regression test.
Drop the ~15fps frame-done tick that woke hidden windows while
the preview overlay was held. Hidden clients now freeze on their
own (no scene frame callbacks), so their thumbnails sit at the
last-shown frame; the shown window keeps its thumbnail live
through its normal commits. Spontaneous hidden commits (a
window mapping mid-hold) still refresh via the unchanged
capture path.
Removes the preview timer, tree walk and arm/disarm logic, the
pulse smoke test that needed tick-driven hidden frames, and
rewrites the README/help wording to last-appeared semantics.
wltest --pulse stays for manual QA.
Adds a --overlay-previews flag that switches the hold-Alt tab
overlay from icon+title rows to icon plus a small live view of
each window (three times as tall as a title row, no captions).
Tabs with no mapped window keep their command-line text row.
Thumbnails stay live while the overlay is held: hidden windows
get no scene frame callbacks, so a ~15fps tick paces them with
frame-done (disarmed on release; the plain title list never
wakes background clients). Each commit is routed to its fresh
source -- a CPU snapshot for SHM attaches, a locked dma-buf
import for GPU clients, or the surface's own texture for
in-place SHM updates -- and hidden commits force a repaint.
Also adds a wltest --pulse MS mode (alternating color/black on
frame callbacks) as a deterministic live source, three smoke
tests (appear on open, map mid-hold, pulse flip), and README
docs.
Park the hardware cursor plane while the overlay is held and paint
the themed cursor image into the plane buffer after the menu, so the
stack is cursor, overlay, content by construction on every backend:
no cursor layer exists for the menu layer to trade planes with, and
the menu buffer carries its own cursor wherever it lands. On the
composite path re-add software cursors after the menu pass (a no-op
while a hardware cursor plane is active).
Extend the VT test with kernel-side placement (debugfs crtc-pos and
normalized-zpos must match the logged box on top) and a single-snapshot
cursor-above-menu order check.
Replace the per-frame overlay layer churn with one persistent layer
per output (NULL buffer parks it), so libliftoff allocations settle
instead of re-solving around a fresh layer object every frame.
Repaint the held overlay from a per-frame content hash checked in the
main-loop bodies: any drift schedules a frame, clean walks cost one
cheap string pass. Deliberately not from the output frame handler --
scheduling there re-emits the same event via idle and wedges the loop
at 100% CPU with dead stdin (caught via gdb). Drop all scattered
explicit overlay refresh calls; the confirm-quit modal stays on its
explicit damage path.
Cover transient plane rejects with one composite frame then retry the
plane; lock software cursors while the overlay is held on DRM so the
menu layer can never trade planes with the cursor across re-solves.
Log the plane verdict and box (WxH+X+Y) every plane frame as the
off-process handle for VT verification.
Add tests/test_vt_plane.py: foot + Alt-held probe + Alt+Shift+T
alacritty on the real DRM backend, asserting the layer stays accepted
and the menu FB sits topmost at the logged geometry (libdrm plane
reads plus debugfs crtc-pos/zpos), with cursor warps and held-key
repeats churning the allocation.
On DRM standalone outputs the Alt tab list / confirm-quit modal is
scanned out on a hardware plane via wlr_output_layer (libliftoff), so
the primary buffer stays untouched and direct scanout of the focused
client keeps running underneath. Plane capability is probed once per
output from the first overlay commit and forced via
WLR_DRM_FORCE_LIBLIFTOFF; KICK_OVERLAY_PLANE=0 keeps the composite
fallback. Unlock the plane buffer only after commit, destroy the
per-frame layer after state finish, and recompute the attach-render
lock from capability on output recreate.
Overlay freshness no longer depends on scattered explicit refresh
calls: while held, each frame decision point hashes what the overlay
would draw (rows, titles, highlight, icons) and repaints on drift.
The confirm-quit modal stays on its explicit damage path.
Adds test_alt_shift_t_refreshes_held_overlay.
Reverts 01fd76e. Tested against the real jittery hardware it was meant
to steady and it did not help, so out it goes rather than carrying a
knob nobody can tune into working. Overlay wheel cycling returns to
one step per discrete tick; the smooth accumulator is untouched.
This reverts both the compositor change and its test plus the
_nested_session extra_env knob, which nothing else uses.
A bouncy old wheel emits a burst of discrete ticks per physical notch,
and each tick stepped one overlay tab, so the selection jumped around.
Discrete ticks now accumulate toward a per-step threshold with net
remainders (a +2/-1 burst leaves +1 instead of jumping), mirroring the
smooth-scroll accumulator: deliberate flicks still skip multiple tabs.
The threshold is KICK_WHEEL_TICKS, read per event like
KICK_REPEAT_DELAY_MS; unset or invalid means 1, today's
one-notch-per-step, so good hardware sees no change. It only affects
overlay cycling, never client scrolling, and the leftover fraction
resets when the overlay hides. The smooth 15px threshold is untouched.
Covered by test_overlay_wheel_ticks_env, which spawns with
KICK_WHEEL_TICKS=3 (via a new _nested_session extra_env knob) and
proves two ticks step nowhere while three step exactly once; it fails
on unpatched code.
One wheel notch in standalone did nothing with the overlay up: libinput
reports discrete ticks scaled by WLR_POINTER_AXIS_DISCRETE_STEP (x120),
so a single notch ran cycle_tab 120 times -- an even number of wraps on
two tabs, netting zero visible movement while still swallowing the
event. The standalone axis handler now divides by the macro before
calling overlay_handle_axis; the client forward path stays raw since
the wlroots seat divides it back itself. Nested was never affected
(its discrete values already arrive in wire units).
Proven by test_standalone_overlay_wheel_libinput_scale, which drives
one notch through the real standalone handler via a new wltest
--virtual-axis mode and asserts exactly one step (it fails with 120
steps without the fix). wltest also grows the missing
axis_source/stop/discrete pointer handlers, without which libwayland
aborts any test client forwarded a scroll event, plus axis lines in
--pointer-out.
Rolling the wheel while the overlay is up now steps through tabs
exactly like Alt+Up/Down: wheel down goes to the next tab, wheel up
to the previous one, wrapping at the ends, previewed live and
committed when Alt is released. Notched wheels step one tab per tick;
smooth touchpad-style scroll accumulates to 15px per step. Horizontal
scroll still goes to clients, and with the overlay down nothing
changes.
Swallowed vertical scroll never reaches clients (both the nested and
standalone axis paths share one overlay_handle_axis gate); wltest
grows axis_source/stop/discrete handlers so forwarded scroll no
longer aborts test clients, plus axis lines in --pointer-out.
Moving the cursor over an overlay row now previews that window, the
same as dragging a finger across it; sliding off every row keeps the
last preview. Clicks while the overlay is up do nothing and never
reach clients, and releasing Alt commits the preview.
A leaked WLR_BACKENDS (e.g. drm,libinput) or KICK_MODE in the ambient environment flips spawned nested compositors to standalone, where the DRM backend fails and every test dies at boot for reasons unrelated to what it asserts. Seen when running the suite from a shell carrying the agent session's own WLR_BACKENDS export. Strip just those two (host connection and socket dir must pass through); precedent: kick-in-kick pops and standalone env -i.
Every tab is maximized and kick draws no frames, so new toplevels
are pinned to client-side mode (headerbars keep working) and later
server-side requests are ignored. Pinning happens at map -- set_mode
asserts on a never-committed surface, and decoration-before-commit is
the normal order (calling it in new_toplevel_decoration aborts
wlroots); late binds pin immediately when already initialized.
Adds an xdeco probe (maps one shm-backed toplevel, reports the
configured mode) with a regression test asserting mode=1, tracks it
in build.sh staleness, and covers the global in protocol_globals.
Full suite: 153 passed, 2 skipped.
All 16 assert _wait_log(s, rx, timeout) sites become s.wait_for(rx,
timeout); every caller only asserted truthiness, and both poll the
whole log identically, so behavior is unchanged (failures now report
the pattern plus a log tail instead of a custom one-liner). Sites on
_wait_log's 15s default keep timeout=15.0 explicitly since wait_for
defaults to 20s. The helper is deleted. Full suite: 152 passed,
2 skipped.
146 assert X.proc.poll() is None spellings (bare, log-tail tails of
varying length, custom operation messages) become _assert_alive(s,
msg): custom messages are preserved up front, the log tail is always
attached. The 4 crash-indicator loops become _assert_no_crash(log)
over the union tuple. Full suite: 152 passed, 2 skipped.
Mechanical whitespace-only follow-up to phases 1-2: continuation
lines that were paren-aligned to the old s = _spawn_* heads now align
to the with _run_* heads. Verified with git diff -w (empty).
28 deadline/while/exists polling loops become one-line
assert _wait_out(path, contains, timeout) calls; the helper retries
empty/partial reads and survives exists/read races, and callers keep
their own assert messages (including the live '(missing)' payload
diagnostics). Deliberately untouched: in-loop liveness asserts
(fail-fast under load), pixel/dump/log-touch loops, line-count gates,
XWayland DISPLAY export loops, and the _oneshot_*/_poll_* helpers.
Full suite: 152 passed, 2 skipped.
101 single-session sites go from s = _spawn_* + try/finally
s.close() to with _run_*() as s:. Standard boot preambles fold into
wait= (any/any_frame/app0/app0_mapped). Client-cleanup tails are kept
as inner try/finally so kill order is unchanged; the dead
if poll() is None: terminate() after close() is dropped (close already
terminate+wait/kills). Fixtures, kick-in-kick outer/inner pairs and
_run_* internals are untouched. Full suite: 152 passed, 2 skipped.
Deeper-X11 instrumentation (permanent, DEBUG): every associate event
now logs surface null/mapped/hooked state, classify logs wid/xpid/pgid
at entry, and pending-map has its own line -- closing the blind spot
between xwm pairing and tab claim. Plus kick_monotonic_ms() timestamps
on the new lines for stall measurement (prefix-safe for all test
regexes).
Paid off immediately: two stalls autopsied to paired-but-never-mapped
wlr_surfaces (associate ran with surface mapped=0, no map for 15-30s,
classify never invoked -- proven by the absent entry line). The stall
is therefore upstream of kick classification (X MapNotify delivery /
xwm mapping under -n15), not in it; locating it further needs live
capture during a stall, not post-hoc logs.
test_xwayland_ready_and_claim failed once the same way (paired xmessage
surface never mapped within 15s): marked flaky per the seen-it rule
(passes serially).
The 15s os.kill poll asked for trouble (fixed window on a foreign event
loop). Replaced with kick's own SIGCHLD reap line ([child] pid N
exited, written unbuffered per reaped child) -- the same signal, event
anchored, 30s backstop only.
Two bugs found along the way, both in the test not the product:
- claim pid != reaped pid (sh -c forks; the claim is the grandchild,
the reap is the direct-child launcher) -- wait on [launch] app=0's pid.
- [child] uses 'pid ' (space) vs [launch]/[claim] 'pid=' -- the first
version of this wait matched nothing for 30s, deterministically.
(Also: earlier validation runs silently deselected this marked test;
always pass -m flaky when validating marked tests.)
Unmarked after 12/12 at -n15 + serial green.
hold_alt_down_repeats + alt_tab_hold_repeats asserted repeat COUNTS in
fixed windows -- pure wall-clock. Now: press -> wait [repeat] start
(new DEBUG lifecycle lines in kbd_repeat_start/cancel; stop logged only
when disarming a live timer) -> wait for ONE synthesized repeat
(count-based, unbounded time) -> release -> wait [repeat] stop ->
immediate count assert (no timer exists post-disarm, so no silence
window needed). Generous timeouts bound hangs only; slow boxes take
longer without failing a rate. hold_alt unmarked (6/6 at -n15).
xwayland_alt_delete_closes_x11_tab: 1 failure in 13 runs, no body --
marked flaky per the seen-it rule.
Evidence: -n15 gate clean (153 passed), serial gate clean (153).
The 7 host-timed tests failed not (only) on timeouts: autopsy showed
parallel workers stealing each other's live-host clipboard (wl-paste
returns another test's token -- no timeout survives that).
Clipboard x3: the failure is cross-talk on ONE shared host clipboard.
Serialize just those sections with an flock file across xdist workers
(the 45s polls stay as backstops for genuine host slowness -- marks
kept; focus-based backend still needs the real host).
Fullscreen x3 + cursor-shape: migrate to per-test outer-kick hosts
(same xdg/fullscreen/shape protocols, deterministic compositor instead
of GNOME). No coverage lost (single code path; timing was the only
host variable). cursor-shape uses deterministic warp-enter; fullscreen
uses tap/chord acks. Added KICK_REPEAT_DELAY_MS + extra_args to
_spawn_nested_in. Unmarked after -n15 validation.
hold_alt stays (wall-clock timer).
Evidence: -n15 gate 3x clean (152 passed), serial gate clean (152),
migrated tests 6/6 at -n15. 12 -> 7 flaky.
Killing the embedded Xwayland server aborted the compositor:
surface_handle_resource_destroy assert (non-empty map listener list)
via wl_client_destroy in the main loop's flush_clients.
Mechanism: the dead server's Wayland client connection is purged before
wlroots' xwm cascade dissociates anything, so wlr_surfaces die with our
map/unmap/commit listeners still attached.
Fix: watch the Xwayland Wayland client (its destroy signal fires before
its resources are purged) and proactively detach surface listeners only
-- across claimed windows, override-redirect windows and unclaimed
pendings -- leaving xsurface-level listeners for the later tab teardown.
Idempotent; later dissociate/xsurface-destroy find clean flags. The
restart test now also waits for the X11 window's map before killing, so
the crash path (listeners attached at death) is deterministically
exercised instead of raced.
Also re-mark output_mgmt_apply flaky (1 post-fix assertion under -n15;
budgets help but the modeset roundtrip stays load-sensitive).
Evidence: restart test 12/12 at the -n15 repro config (was ~2/9
crashing), detach handler firing on every server death, -n15 gate
clean, serial gate clean (148), flaky set green (11).
Fixed + unmarked (all green serially, holding at -n15):
- dead_command: wait for the exit line (event) before proc.wait instead
of a fixed 10s reap timeout.
- output_mgmt_apply: phase on the existing [output] apply line so the
commit wait covers only client reconfigure lag (30s budgets).
- gestures_roundtrip: cursor-line + [gesture] forward-line acks per
sequence (offset), single client-file poll; no more resend-on-slow.
- x11_client_requests_driven: phased [xwayland] ready wait (own budget)
+ startup-crown settle/nav.
Hardened, marks kept (host-timed roundtrips): 3 fullscreen tests use
tap_ack/chord_ack + 30s host-configure waits.
Marked flaky (post-fix sightings under load):
- x11_menu_popup (associate never lands in X11-heavy -n15 runs),
- x11_leader (1 claim timeout post-fix),
- xwayland_server_restart_survived (real SIGSEGV in
wl_display_flush_clients on Xwayland SIGKILL restart -- pre-existing
race, unrelated to this work; needs a proper fix, not a test tweak).
Net flaky 14 -> 11. Evidence: -n15 gate 2x clean (148 passed),
serial gate clean, flaky set green serially.
