Scroll panes: move surfaces instead of repainting windows

[nongio]

Summary

Scrolling in Otto's own apps now moves surfaces instead of repainting windows. A scroll or pan in Files, Settings, the launcher or the emoji picker is presented by the compositor moving a subsurface. The frosted window behind it is left alone.

This PR has four parts. Each builds on the one before it.

Depends on nongio/layers#28. Cargo.toml points laye-rs at that branch. Re-pin it to the release tag before merging.

1. Compositor: damage only what changed

• No re-append on every window update (src/state/mod.rs).
  • update_window_view_for_commit used to re-append the root surface layer on every update. Appending detaches and re-attaches the node.
  • A surface layer answers that repaint with the damage of its last buffer. So any style request on a subsurface, such as a band moving, redrew the whole window.
  • It now appends only when the root isn't already under the content layer.
• Moves aren't repaints (src/surface_config_cache.rs, configure_surface_layer).
  • The config cache keeps two hashes per surface: what it shows (buffer, crop, size) and where it sits.
  • A change in placement only (Reconfigure::Placement) repositions the layer and does not reinstall its draw content.
• Opaque regions reach the blur (sync_surface_opaque_region).
  • The client's wl_surface.set_opaque_region, as smithay tracks it, is scaled to physical pixels and passed to Layer::set_opaque_region.
  • The frost is then not computed under an opaque listing.
  • It is cached per surface, because setting it repaints the layer.
• Sampling for client-placed surfaces (surface_filter).
  • A surface whose position the client sets through the style protocol, drawn 1:1, is filtered bilinearly instead of bicubically.
  • A one-pixel buffer (clip, fill) uses nearest.
• fix(udev): builds with --features metrics again.

2. otto-kit: scroll components

All of this lives in components/otto-kit/src/components/scroll/. The design is in docs/developer/scroll-pane.md (new).

• Window
  • request_frame_damaged(&[Rect]) sends eglSwapBuffersWithDamage for a partial repaint.
  • set_opaque_region declares opaque pixels.
  • Frame pacing: one outstanding frame request per surface, so windows with a registered frame callback are paced at last.
  • The accessible tree is rebuilt only after a paint.
• ScrollSurfaces: a clip subsurface plus a band subsurface holding the content around the viewport, plus a thumb.
  • A scroll moves the band. The band is repainted only when the viewport nears its edge.
  • Moves wait for the previous frame to be presented.
  • It works on either axis, and can act as a container for nested panes.
  • Positions snap to whole pixels. The input can pass through to the window.
• ScrollPane / ScrollContent: physics (ScrollView) plus surfaces plus a content revision.
  • set_highlight is a selection marker that slides between rows on its own surface.
  • hovered() / wheel_at tell you what is under a still pointer while content flings past it.
  • update_container_at moves a container that is driven by physics outside the pane.
• Fill: a public one-pixel colour surface, stretched and rounded by the compositor. Used for dividers and highlights.
• RowLayout / GridLayout: row and cell geometry in content coordinates, with hit testing, visible range and marquee.
• ScrollGroup: gesture axis routing between nested panes.
• Examples:
  • damage_probe: damage on the wire.
  • virtual_fling: touchpad flings through zwlr_virtual_pointer_v1.
  • scroll_nested_probe: a nested stack.

3. Apps on the components

• otto-files
  • Columns. The Miller column stack is a horizontal container, clipped to the file area. Each column is a vertical pane placed inside it.
    • A column's tint is its clip colour and its divider is a Fill.
    • Status lines and the docked preview ride in the stack.
    • Scrolling a column or panning the stack doesn't commit the window. The scene loses its per-column layers.
  • List and grid stay window-painted. They report only the file area as damage on a scroll and declare it opaque.
  • Geometry. List and grid geometry and hit testing come from the kit layouts.
  • Palette. The palette result list scrolls on its own pane.
  • Accessibility. Only rows on screen are described, and selection is looked up per drawn row.
• otto-settings: the pane is a ScrollPane with pass-through input, and its ground is declared opaque.
• otto-launcher: results scroll on a pane. The highlight follows the row under the pointer during and after a fling.
• otto-emoji: the category grids are vertical panes in a horizontal container that follows the picker's paging. The selected cell is a pane highlight. Swipes and scrolls move surfaces; the card repaints only its field, tab marker and footer.

Specs updated: file-browser.md, settings-app.md, launcher.md, emoji-picker.md. file-previews.md was touched too.

4. otto-files and kit, restructured

After an architecture review of the result:

• Kit fixes. Dropping a ScrollSurfaces or ScrollPane destroys its surfaces (EGL first, frame bookkeeping forgotten); a frame the compositor never answers stops holding the next step after 500 ms; a band claims its size after the buffer that fits it; the thumb is re-claimed when the scale lands.
• PlacedSurface (kit). The painted child surface otto-files kept for itself, now shared: placed at the fractional scale, a size claimed only behind a matching buffer, paints keyed and paced, input withdrawn while hidden. Status lines, the docked preview and its video, the palette card and Quick View use it, which fixes their sizing on fractional scales.
• One place presents. Key and pointer handlers only change the browser; on_update, which runs after every batch, decides between a window repaint, a file-area repaint, or surfaces only. A column scroll never repaints the window; a thumbnail landing in list or grid repaints the file area.
• app.rs is app/. One module per concern (navigation, selection, the palette session, file operations, Quick View, keys, lifecycle, presentation), each test module in its own file. The thousand-line pointer closure is Browser::on_pointer: overlays (rename, Quick View, the sheet, the fields, the footer, the path bar) answer first as methods of their own, then the listing by event kind.
• Removed. The in-window palette fallback, OTTO_FILES_QV_TRACE, OTTO_FILES_PALETTE_TRACE, OTTO_FILES_NO_BLUR, and dead code.

Reading order

The commits are meant to be read one at a time, oldest first: the kit pacing and a11y commits, the compositor commit (perf: damage and blur only what changed), the kit scroll components, the apps moving onto them, and last the restructuring commits (fix(kit): tear down panes… onwards).

Known follow-ups (not in this PR)

• The palette list and the columns drive ScrollSurfaces::sync_state rather than ScrollPane, because their scroll views live in the browser state its headless tests drive. A pane that borrows its ScrollView would remove that bookkeeping.
• ScrollGroup has no consumer yet; pinned grid headers as their own surface are not built.
• A band's subsurface position lands with the clip's next commit (hidden by pass-through input).

Test plan

• cargo test --release --lib: otto-kit (351), otto-files (384), clippy clean for both, after the restructuring; launcher (24) and emoji (42) before it
• Takeover runs on hardware:
  • flings in Files (columns, list, grid, palette), Settings, launcher and emoji
  • commit counts per surface from WAYLAND_DEBUG, and screenshots
  • no panics
• Installed and used on a live session (before the restructuring; the restructured build is being installed now)

https://claude.ai/code/session_01NQwfuVAHbrQx7UUyEUgd54