f9bc83ba8d021af8654cbcc81911ebdf519cf89c
246
Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
 vicrodh
|
fda56f9ea2 |
fix(qt): pin the artist jump nav bar and round it at the pane edge
The strip scrolled away with the body; the reference clamps it to the top. Lifted out of the flow with a slot holding its place, using the reference's clamp verbatim -- the formula must not add the viewport y or the scroll is double-counted and the bar lifts ahead of the body mid-transition. Pinned at the pane's top edge it then showed the square-corner defect already fixed in Discover: Qt's clip is a rectangular scissor that ignores radius, and the shell hides its bezel nubs while the dynamic background shows through the corners, so a full-bleed child has to round itself. Driven off the live y, so the rounding exists only while the bar is actually at the top -- rounded corners in mid-page would be a notch with nothing behind them. cc |
||
|
vicrodh
|
c2944db973 |
feat(qt): source-aware playback, session persistence and loading affordances
One batch, committed together because the changes interleave in main.rs and
splitting them after the fact would be a fiction.
Playback routing: a track now carries its source, so a local or Plex row played
from Discover stops being resolved against Qobuz first (the 404s and the long
silent wait before audio). Jellyfin and Navidrome land on the same seam.
Plex tracks stream through the player instead of downloading whole files first;
the feeder moved into qbz-player so both frontends can reach it.
Session persistence, both levels the port was missing:
- The startup-page preference is finally read. It had been rendering and
persisting a value nothing consumed. `last_view` is written in the SHARED
ui_prefs vocabulary, not this port's route ids -- four of the six differ,
and writing the raw ids would have silently broken the other frontend's
restore. `on_session_entered` recorded "home" unconditionally, which also
rewrote last_view on every boot, so the setting could not survive its own
startup.
- Queue and active track survive a restart. session_persist was tied to a
frontend by exactly one type alias, so it moved to qbz-app generic over the
adapter rather than being copied. Verified end to end: the snapshot restored
here had been written by the Slint binary, and the exit flush keeps an
un-consumed resume position instead of overwriting it with the engine's
idle 0.
Loading affordances: the transport shows a spinner from the moment a play is
dispatched, and the restored session explicitly takes it back down -- a
restored track has no dispatch behind it and no audio ahead of it, so nothing
would ever have cleared it. Cortinilla results now navigate at album and artist
level.
Verified by the offscreen smoke gate and by driving a restore/quit cycle over
MPRIS.
cc
|
||
|
vicrodh
|
3b03682e09 |
fix(qt): pane corners stay round under the dynamic background
AppShell hides its BezelCorner nubs while the field is meant to show
through the pane's corners, and Qt's clip is a rectangular scissor that
ignores radius — so any full-bleed child at y=0 squares the pane. The
doctrine was already written in AppShell.qml ("a full-bleed pane child
must round itself; there is no mask that can do it for it here"); these
eight surfaces predated it or, in the two thin bars added with the
ambient port, ignored it.
- The seven fixed 56px headers (Home, Search, DiscoverBrowse,
ArtistReleases, PlaylistBrowse, PlaylistManager, PlayHistory) take
topLeftRadius/topRightRadius. Invisible with the background off, where
the view root paints the same colour beneath. PlaylistBrowse's SECOND
bar is the category strip at mid-page and keeps square corners;
PlayHistory keeps its unconditional opaque fill, which is reference
parity (:43/:34) and a separate question from the corner.
- LocalAlbumView's neutral header band is now gated on the background,
1:1 with the Qobuz page's atmosphere (AlbumView headerAtmoOn,
AlbumPageView.slint:168): the two dark backdrops clash and the field
already provides one. That band had been square since it was written;
the nubs had been hiding it, and they only stand down when the field
is showing. Header text there is theme.textPrimary, not the Qobuz
page's light-on-dark hdrStrong, so it does not depend on the band to
stay readable — checked before removing the backdrop from under it.
Gate: cargo build -p qbz-qt, both QML audits, offscreen smoke 0
complaints.
cc
|
||
|
vicrodh
|
eb80e2f367 |
feat(qt): animated now-playing indicator in track rows
Restores the eq-bars indicator behind the existing play-indicator-animation pref (the toggle already lived in AppearanceSettings; the pref was plumbed but unconsumed). The bars ride the shared shell pulse, so they cost zero extra presents — the affordable version of what used to be a display-rate animation. Pref OFF keeps the static accent pill + ring, per TrackPlayCell.slint. km |
||
|
vicrodh
|
a2a99a72cc |
perf(qt): bring the immersive onto the pulse (83% -> 25% GPU)
- AlbumReactivePanel: drop the eight 100ms Behaviors on 30 Hz data (a retriggered Behavior animates at display rate and every animation frame is a full-window present), and read the settle — not the publishing bridge list — in the energy formulas (the .length guard re-evaluated the visual bindings on every FFT publish). - LyricsSyncEngine: the fast cadence rides the pulse; the 250 ms idle re-check keeps its own timer. - EqualizerBars: the phase accumulates on the pulse and the 'active' gate is host-provided (invisible subtrees still dirty the window). Measured on the owner's machine, immersive reactive panel open: 132 -> ~33 presents/s, 83% -> ~25% GPU. km |
||
|
vicrodh
|
f46c5c95d4 |
perf(qt): one repaint pulse for the whole shell (GPU 95% -> 25%)
Qt Quick has no partial redraws: any dirty item presents the WHOLE window, and on the owner's hybrid laptop each full-window present costs ~1.2% GPU flat (KWin composite + dGPU scanout; area-independent, while the app's own render is 0.08 ms/frame). The bill was presents/s, and the shell ran unsynchronised ~30 Hz clocks plus two leaks: - QbzShell.pulseMs: ONE Rust-driven 33 ms edge that every continuous animator ticks on (knob QBZ_PULSE_MS). VizSettle now stashes on publish and applies on the pulse (its 16 ms interpolation timer is gone); AmbientField and ImmersiveAtmosphere ride the same edge. - VizSettle writes NOTHING while not live: the always-mounted but invisible immersive panels were dirtying 28 bar rects per FFT publish (named via QT_LOGGING_RULES=qt.quick.dirty=true). - AmbientField renders inline again: ShaderEffectSource scheduleUpdate() double-presents (minimal repro fbo_repro.qml in the investigation folder). - Background mode 2 (ImmersiveAtmosphere) composites its four drifting layers + base + dim + scrim in ONE opaque ShaderEffect (atmosphere.frag, baked by build.rs); numeric parity vs the Image stack verified (atmo-shader-parity-check.py, delta 0.0). The four-Image stack stays as the software/failure fallback. Measured on the owner's machine: 93-97% -> 25-26% GPU, ~34 W -> 12-13 W, ~33 presents/s in both background modes. Full story: qbz-nix-docs/qt-frontend/2026-08-11-scenegraph-batches/GPU-COST-INVESTIGATION.md km |
||
|
vicrodh
|
b136c9cf5d |
feat(qt): ambient background port, clip sweep and measurement tooling
Accumulated qt-frontend work from the 2026-08-11/12 sessions (cc), uncommitted until now: the app-wide dynamic background in both modes (AmbientField with GPU/Canvas arms, AppShell layering, ambient palette pipeline), the wave-1 clip/batch sweep across the tree (alpha batches 449 -> 327, reproducible), the rounded-cover and icon-tint arms, and scripts/qt-batches.sh (batches + presents/s sampler). The GPU behaviour of these pieces was finalized in the follow-up pulse commits; see qbz-nix-docs/qt-frontend/2026-08-11-scenegraph-batches/ GPU-COST-INVESTIGATION.md for the full campaign. km |
||
|
vicrodh
|
21e941bdf6 |
feat(qt): renderer tier, GPU selection and a real shader build
Closes PARITY-DEBT #83 and #104, and unblocks the immersive shader scenes. THE TIER. Slint resolves one bool, use_gpu_renderer, and hands it to three features: the shader scenes, the dynamic background and half of reduce-motion. This port had none of it, which is why the scenes could not be offered — off the GPU tier they render black and nothing could tell. QbzShell now carries rendererApi, gpuTier, shaderScenesAvailable and appBackgroundAvailable, all written from one latch. Only QML can source it: QRhi picks the backend after QGuiApplication, so the pre-init code knows only what it asked for. Per-item GraphicsInfo.api stays where it is. "Can this item draw?" and "should this feature be offered?" are different questions, and routing the first through Rust would make every cover wait on a round trip. SHADERS ARE BUILT NOW. build.rs bakes every .frag/.vert to .qsb with ten variants and the batching rewrite. They used to be baked by hand and committed carrying no GLES variants at all, so any GLES context failed them with "No GLSL shader code found" — which is exactly how the NPB Large visualiser went blank while this branch was being tested. Adding a scene is now dropping a .frag in the folder. GPU SELECTION enumerates real devices through Vulkan and lists them by model, never by class: a machine with no discrete GPU can no longer be told to use one. Legacy class keys still resolve, but only against hardware that exists. Picking a non-default device implies the Vulkan backend, which the row's own description states in all eight locales — measured as the only route that keeps a working context: DRI_PRIME lands on llvmpipe and the NVIDIA PRIME pair lands on OpenGL ES. The renderer row gains the auto-revert sentinel and the frame-liveness watchdog it shipped without. The sentinel arms only for a choice that truly forces a backend, and liveness means frames rendered over a window, not merely a window that opened. Also fixes the kiosk toggle overwriting the tier half of reduce-motion. Verified by 312 tests, both QML audits, the offscreen smoke, and a probe against the real hybrid GPU: both devices enumerate by name and the stored preference applies. cc |
||
|
vicrodh
|
8ba9483462 |
feat(qt): HiFi Wizard — guided DAC setup ported from Slint
Six-step modal (Welcome / Check / DACs / Configure / Test / Done) opened from Settings > Audio. It probes the audio stack and renders per-distro remediations, enumerates DACs with a manual node.name escape hatch, generates the PipeWire / WirePlumber snippets to copy, and plays four tracks spanning 16/44.1 to 24/192 with a live requested-vs-negotiated read-back. Read-only: it never writes a system file or runs a command. The logic was unreachable from Qt — every public function in qbz-dac-wizard takes a &AppWindow and writes straight into Slint globals. It is lifted into a new frontend-agnostic crate, qbz-dac-wizard-core, which returns plain data. qbz-dac-wizard itself is left untouched. Rust owns everything it computes plus `open`, so the reset and the probe are one act; QML owns the step navigation and the four progress checkboxes, which is how the reference splits them too. Two deliberate divergences from the reference: the row sits at the end of OUTPUT rather than BIT-PERFECT, and it is offered on every backend instead of PipeWire only — someone on ALSA direct is exactly who needs the walkthrough. The green glyphs use the accent tint, not success: success has no qrc bake directory, so a degraded tint set would render nothing at all. Every success-toned text keeps theme.success (#3fae6a verbatim). Verified by 309 tests, both QML audits and the offscreen smoke, plus a forced-route probe that mounts Settings and walks the wizard's steps — the standard smoke only mounts Home, so it is no evidence for a modal. The modal was also driven and screenshotted over VNC. cc |
||
|
vicrodh
|
79e3cdc46b |
feat(qt): multi-select bulk bar on every Qobuz track listing
The album-page pattern (selection in QML, actions in Rust) generalized: - New shared engine bulk_tracks_qt.rs: one catalog batch-resolve that preserves the selection's visible order, then queue / play-next / play-later / add-to-playlist / add-to-mixtape / add-to-favorites / make-offline, with the queue context stamped per host. - PlaylistView: toggle in the header action row, bar inline above the column header, selection resets when the playlist changes. - ArtistView: the Popular Tracks header's dimmed toggle goes live; one selection covers Popular Tracks + Appears On + the in-library rows; the PopularTrackRow fork gets the select checkbox AND its offline cell/menu block stop being inert stubs. - LabelView: Popular Tracks gets the same treatment. - AlbumView: the bar moves from a floating overlay to the inline spot the Local Library album view uses (bar in flow, content below). km |
||
|
vicrodh
|
d112c726b6 |
fix(qt): custom album covers propagate to every surface
The per-builder sweep was whack-a-mole — the report caught empty cards in Home > Recently Played Albums and the NPB, and mosaics still showing the Qobuz art. Overrides are keyed by album id but most surfaces carry only the art URL, so the link is now the artwork HASH: every size variant of one Qobuz cover shares its filename stem. Setting a cover records hash -> path in a Qt-side store (custom_cover_keys.json — same reason as the playlist store: the Slint file round-trips known keys only), the album page backfills it for covers set before the map existed, and artwork_qt's cached_path / cached_raw_path answer the override for any URL whose hash has one — cards, NPB, MPRIS, queue, collage tiles, no per-surface wiring. download_missing skips overridden URLs. km |
||
|
vicrodh
|
a53e8a7af7 |
feat(qt): custom covers for playlists + the app-wide custom-art sweep
Two halves of one feature: - Playlist custom covers (Qt-first; no Slint counterpart yet): the playlist header cover gets the cover menu (Add/Change/Remove) and the lightbox on left-click. The store is a NEW file, custom_playlist_covers.json — a `playlists` key inside the shared custom_artwork.json would be silently dropped the next time the Slint app wrote an override (its store round-trips only known keys). The override beats the playlist's own Qobuz graphic AND the member-cover mosaic on the header, the sidebar rows, the cards and the library grid. - Album custom covers now apply everywhere, not just the album header: doc builders route an album's art URL through cover_artwork_qt::prefer_album_cover (the override's path flows through the ordinary artwork pipeline — artwork_qt::classify's LocalFile arm resolves it synchronously, no QML change). Swept: album page carousels (more-from-artist / suggestions / Last.fm similar), artist page releases, search result cards, and the playlist mosaics (a member album with a custom cover contributes THAT art to the collage tiles). km |
||
|
vicrodh
|
83b8bd8890 |
feat(qt): offline downloads + multi-select on the album page
Two AlbumView parity features sharing the row machinery: OFFLINE CACHE (the menu rows and the per-track state the report was missing): - offline_qt.rs activates the per-user OfflineCacheState on login / session-restore / offline-session (one fan-out point in bind_per_user_stores) and tears it down on logout — same on-disk store as the other frontends, so copies made in Slint/Tauri show here and play here. - playback_qt's play funnel now passes the active cache + the row sink to play_track_resolved (it passed None, None: the offline tier was unreachable even for downloaded tracks). - offline_cache_qt.rs ports the action set: cache_track / cache_tracks / cache_album / redownload_album / remove_cached / refresh_cached, with toasts and a bridge-signal row sink (trackCacheStatusChanged). - TrackRow's download column is live: cloud / spinner / accent check / red alert per status (0/1/2/3/4), click map ready->remove else download, and the context menu's offline block (Make available offline / Refresh / Remove). Status is seeded per row from the session cached-id set (album/artist/label/for-you docs) and pushed live over the signal. - Album ⋯ menu: "Make available offline" swaps to "Refresh offline copy" on the live all-cached aggregate. MULTI-SELECT: the toolbar toggle is live; selection state stays in QML (LibraryView precedent), rows check off in select mode, the bulk bar carries the reference's full inventory — select-all, play-next, play-later, queue, add-to-playlist, add-to-mixtape/collection, Add to Library, make-offline, clear — and the Ctrl+A/Escape router duck-types the view's selectAll/exitMultiSelectMode like the other tabbed views. Still out (documented in place): the Offline Manager view, the row padlock on unlock, per-disc actions, playlist-level cache button. km |
||
|
vicrodh
|
704fd7e60a |
fix(qt): artist Latest-release card renders its data again
The card bound `artist.lastRelease.*` unqualified, and inside an AlbumCard instantiation the bare name `artist` resolves to the CARD'S OWN string property — a string has no .lastRelease, so every binding fell back to "" and the card rendered as an empty tile (section visible, no art, no title) while the grids' modelData-driven cards were fine. Caught live on a VNC-driven session: the published document carries the full lastRelease object; only the QML scope shadowing ate it. Every read in the block is now root.artist.lastRelease. km |
||
|
vicrodh
|
af95ce164a |
fix(qt): search top-result track hero no longer invades the Artists rail + crown icon
Two Most-popular regressions on the search results page: - When the top result is a TRACK, the hero painted from its slot's center ~100px into the Artists carousel: SearchTrackHero's root Rectangle had no size, and a bare Item's implicit size is 0x0 (it does not size from children), so the slot's horizontalCenter anchor pushed the whole card sideways. The artist/album arms carry explicit sizes and never shifted. The hero now declares its 200px width explicitly. - The header glyph was "award", which reads as a mic. The reference uses the crown (SearchResultsView.slint:584); crown.svg is ported into the icon masters (primary + the warning bake) and the header uses it. Both verified live on a VNC-driven session with the exact "all things" search from the report. km |
||
|
vicrodh
|
1fe20e9af0 |
fix(qt): album info modal never shows a previous album's document
Opening album A's info, closing, and opening B's left A's fetch in flight with nothing stopping it from publishing A's document over B's loading state — the modal rendered A's credits inside B's page (smoke catch, 2026-08-10). The carousel rows in album_qt.rs already carry the "late replies are generation-guarded" pattern; the modal now does too: a monotonic open counter gates every publish, open() clears the stale document with the loading flag, and the QML overlay additionally holds until the published document's albumId matches the requested one. km |
||
|
vicrodh
|
d9b1c26ff3 |
feat(qt): album page parity — cover menu + lightbox, header actions, album info modal
Four wired surfaces on AlbumView, all previously inert stubs: - Cover menu (right-click, AlbumPageView.slint:300-370): Add/Change/Remove custom cover over the SAME custom_artwork.json store the Slint app uses (a cover set in one app shows in both), Open in browser, Save as…. Plus the NEW lightbox (menu entry + left-click): the art at its best available quality fitted to the window, custom override preferred. - Header action row: radio (the existing foryou_qt album-radio seam), booklet (visible when a PDF goody exists; downloads via save-as — no in-app reader, like the reference), and add-to-mixtape/collection — the MyQBZ picker's Accepts engine already lets albums target Collections (the Tauri rule), so the button just feeds it. - Album Info modal (the extensive one): fresh /album/get → credits grouped through the shared qbz_qobuz::performers parser, per-track copyright, review tab when the album has editorial text, label link, musician navigation, per-track play in album context. Tauri layout (left fixed meta column, right scrollable tabs) per the project ruling for this feature; the header's label link is wired along the way (LabelView has existed for a while — the POC-NOTE was stale). - … menu: Add to playlist (the loaded view's track ids into the picker), Add to mixtape, Share Qobuz link, Share Album.link (UPC -> Deezer -> album.link, #514 path — the resolver half of share.rs is now ported for the album arm). The offline rows stay out: no Qt album-cache seam. i18n: "View cover" + "Could not load the image" catalogued in all seven locales. Gate: both QML audits + 305 tests + debug/release builds green. km |
||
|
vicrodh
|
98dfcd8173 |
fix(qt): nav flyout entries land on their own tab
Every flyout entry (Discover > For You, Library > Albums, Local > Folders...) navigated to the section but landed on its default tab: the port handed the tab to the mounted view through a depth-capped scene search (NavFlyout.findTabHost, cap 7), and the ContentRouter extraction (kiosk port D3) added a mount level the walk never reached — flagged as a latent desktop regression in the kiosk audit (2026-08-02 AUDIT-REPORTS.md, finding 11) and confirmed by smoke test. The tab now travels the way this codebase crosses documents: the bridge. NavFlyout.activate calls the new QbzShell.navigateToTab(view, tab), which publishes navTab/navTabView/navTabSeq, and a Binding in ContentRouter applies it to the mounted view's activeTab — the same pattern as the MyQBZ kind discriminator. The seq counter re-applies on a repeated click of the same entry, the navTabView guard keeps a cross-view request off the outgoing view, and a plain navigateTo clears the request so section navigation never drags a stale tab along. A click for the already-mounted view skips navigation (no duplicate history entry) and re-applies the tab live. Verified by smoke: cross-section, same-section, repeated-click and plain-navigation cases all land where Slint lands. km |
||
|
vicrodh
|
479921af52 |
feat(qt): Offline settings 'Check now'
Hands out the connectivity actor's existing public request_recheck so the row probes immediately instead of waiting for the next scheduled check — the passthrough was the whole gap. cc |
||
|
vicrodh
|
eca07d4370 |
fix(qt): settings export honors the include-auth gate
The export row hard-coded include_auth=false, so the 'portable bundle' the UI described could never sign you in — the reference's single checkbox (default OFF) is now wired through, as session state rather than a persisted pref. cc |
||
|
vicrodh
|
c198afb33c |
feat(qt): queue drag-and-drop insert at position
Dragging rows onto the queue panel now lands them AT the pointed slot (insertion line included) instead of appending: add_track + move_track compose the position locally (QueueManager has no insert-at-index and the manual-block adds would corrupt manual_next_count), and the QConnect controller path routes through CtrlSrvrQueueInsertTracks' insert_after so the position survives to the peer. Multi-row drops keep their own order. Dropping onto an EMPTY queue raises a one-shot 'start playing?' prompt rather than hijacking a running queue or leaving the user one click short. cc |
||
|
vicrodh
|
7754b8bc00 |
feat(qt): Plex PIN sign-in and connection check
The Authorize half of the Plex settings: pin/start + pin/check polling against plex.tv over the shared qbz_plex protocol (the stable per-install client id is reused across both calls or the check never sees the authorization), manual-token mode, and the Check-connection ping that stamps the server's machineIdentifier onto the cache. The panel gates Connect on a pure is-local-address predicate while the user types, matching the reference. cc |
||
|
vicrodh
|
c807d24463 |
feat(qt): local library folder editing
Per-folder settings modal (alias, enabled, network/FS-type override), change-path and a native folder picker feeding the same add path as the typed field, plus the shared double-confirm host used by the destructive rows. Panel refresh no longer blocks on dead network mounts (accessibility probes run off the publish path), and removing a folder prunes its albums from Recently Played so the rail stops pointing at deleted database rows. cc |
||
|
vicrodh
|
13996a0566 |
feat(qt): in-app log viewer
The Developer > Share-logs handoff (open::that on the log file) becomes a filterable in-app view: level filter + substring search run Rust-side over qbz_log's ring and only the survivors cross the bridge (one document, max 500 rows), with auto-tail, copy-all, a GitHub-ready <details> bundle and paste upload. The bundle header now reports the real audio backend via settings_qt::current_backend_label. cc |
||
|
vicrodh
|
5e1eb46a71 |
feat(qt): window chrome parity — macOS tray, native chrome, appearance wiring
Three Slint-parity pieces that share the chrome surface: - macOS menu-bar tray (NSStatusItem, tray_macos.rs) ported from the reference — the K2 'macOS is a new implementation' ruling read the reference backwards (it avoids muda entirely), and its absence made close-to-tray quit the app on the Mac. Plus the custom-chrome window mode (macos_chrome.rs): Qt 6.9 ExpandedClientAreaHint / NoTitleBarBackgroundHint instead of fighting QCocoaWindow's style-mask recompute, traffic-light centring, and the SafeArea inset in HeaderBar. - Appearance rows that rendered, persisted and drove nothing now push live: hide/show title bar, window-controls cluster side, track in the window title, invert swipe navigation, auto-theme source selection (wallpaper/image/system) with regeneration on source change. - use_system_title_bar now defaults per-OS (custom chrome on macOS), matching the reference — the hard-coded 'true' also leaked into the Slint build through the shared ui_prefs.json. cc |
||
|
vicrodh
|
b46924bcc0 |
feat(qt): IconTextButton control and external-link icon
Shared button-with-icon control (used by the queue panel, Plex settings, the log viewer and the library folder editor) plus the external-link icon in every theme tint. cc |
||
|
vicrodh
|
0372b4d66f |
fix(qt): the mini footer sat 1px outside the card on every side
Measured on the owner's screenshot rather than estimated: the artwork and meta rows span 366 px, the seek and transport rows 368. Qt draws a Rectangle's border INSIDE its bounds, so the card's visible fill is already 1 px in on each side — but the footer was anchored to the card's outer edges and painted straight over the hairline, so the outline stopped exactly where the footer began. Micro looked right because there the footer IS the card and there are no two layers to misalign. Inset by the border width on the three edges it touches, with its corner radius reduced to match so the curve nests inside the card's instead of racing it. No gap opens above it: the surface area still ends at the old boundary, so the two now overlap by a pixel rather than parting. cc |
||
|
vicrodh
|
b7706bdf38 |
fix(qt): drop always-on-top, pin the mini's size, and report seeks to MPRIS
Four things from the owner's smoke, all polish, all measured on real Plasma Wayland rather than inferred. ALWAYS-ON-TOP IS GONE. It shipped as owner ruling K1's default — new work the reference promises in three comments and implements nowhere — and it does not work: a Wayland client cannot raise itself above other clients. There is no such request in the core protocol; it takes a compositor policy or a KWin rule, and Qt has nothing to send. The owner's call was explicit, so the button, the property, the invokable and the pref are all removed rather than left as a control that lies. The capsule is nine buttons again. THE MINI'S SIZE IS NOW FIXED PER SURFACE, min == max. A Plasma tiling shortcut resized the mini to half the screen, the debounced persist wrote 1720 px into the shared ui_prefs.json, and every expanded surface opened giant from then on — with no way back, because this port never gave the mini a resize handle. So the only thing that could ever write those prefs was the window manager, i.e. the bug. The owner asked for exactly this: force the sizes even when the OS says otherwise, stay sensitive to position. min == max gives both — a compositor may still move the window; a resize is refused. That drops the reference's resizable expanded mini and the persisted pair with it (A-6b / AC-15). `saveGeometry` and `geometry_to_persist` stay, with UT-3: they are the right rule for the day a real resize handle exists, and deleting a tested guard to re-derive it later is how this comes back. The micro capsule now centres on the CARD, not on its 17 px header. The reference centres it on the header, but in micro that header is a strip at the top of a 45 px card while the capsule is 26 px tall, so it sat visibly high. A SEEK NOW REPORTS ITS NEW POSITION TO MPRIS. Position was only refreshed on the play/pause edge, so a desktop widget extrapolated from a base the seek had invalidated — the owner measured ~40 s of lag. The shared crate exposes no Seeked emitter and set_playback already carries a position, so the seek re-asserts the state at its target. The shipping Slint build has the same gap; closing it there is a shared-crate conversation, not this one. Not fixed, and it cannot be here: the mini does not remember its POSITION. Wayland gives a client no way to place itself. Contract ruling K4 said so; the owner's session confirms it. It would work on X11. cc |
||
|
vicrodh
|
d003d67b30 |
fix(qt): the mini footer squared the card's rounded corners
The owner photographed it against a white background: every mini surface rounded on top and SQUARE at the bottom, and the micro card — the smallest of them — square on all four. Their read was right: "los NPB son cuadrados y no tienen transparencia, así que aunque el fondo tenga esquinas redondeadas, el npb prevalece". The footer is an opaque Rectangle anchored to the card's bottom edge, and the card cannot round it: QML's clip is RECTANGULAR. theme/RoundedImage.qml records that as measured fact on this Qt build — "the child paints square over the rounded fill" — which is the same reason the artwork backdrop needed a mask two commits ago. So the footer rounds its own corners, with per-corner radii (Qt 6.7+; this tree builds against 6.11): the bottom two in every mode, and all four in micro, where the footer IS the whole card. That last case is exactly why the smallest surface was the one with no rounding at all. cc |
||
|
vicrodh
|
721841a4b8 |
fix(qt): Qt.quit() was vetoed by our own windows, so Quit never quit
The owner reported it three times and their second wording was the whole
diagnosis: "Quit QBZ debe cerrar la aplicación, NO SOLO LA VENTANA."
ROOT CAUSE. `Qt.quit()` in Qt 6 is a REQUEST, not an order. It posts
QEvent::Quit, and QGuiApplication answers it by calling close() on every
top-level window that has a platform handle — hidden ones included. If any
window refuses its close event, the quit is silently cancelled. Two of ours
refuse:
1. Main.qml's closeOrHide refuses whenever trayLive && closeToTray, and
hides the window on the way out. That IS "cierra la ventana, no la app".
2. MiniWindow's onClosing refuses unconditionally, because for the mini a
close means "leave the mini" — so once the mini had ever been opened,
quit was blocked regardless of any setting.
It also explains "Close to tray does nothing": with the setting ON, the X
hid (correct) and Quit hid too (the bug), so the two were indistinguishable
and the toggle looked inert. Nothing was ever wrong with that plumbing.
FIX. Both quit sites call Qt.exit(0), which exits the event loops directly —
no QEvent::Quit, no window to veto it, and no need to touch the miniplayer's
onClosing, whose refusal is correct for what it means. A one-shot 5 s
watchdog thread, armed only at the three quit sites, flushes the log and
_exit(0)s if anything downstream ever wedges; it cannot fire in a live
session. main() now names each teardown step, so a future hang says which
statement it hung on instead of going quiet.
closeOrHide reports its decision through the bridge — tray_live,
close_to_tray and the arm taken — because a report of "the tray does
nothing" was not previously separable from "the signal arrived and QML
ignored it".
MEASURED, with waitpid on a child rather than /proc (a zombie reads as alive
and that produced a false diagnosis earlier in this session). Old binary:
alive ≥25 s with the window visible, hidden, and with the mini open. Fixed:
exit 0 in 0.35-0.68 s across eleven driven scenarios — the tray Quit in all
three window states, the drawn X and the app-menu Close with the setting
both ON and OFF, the mini's own close button, and the MPRIS Quit method.
One arm remains static-only: a real WM close event with close-to-tray OFF.
VNC delivers no such event, so the owner's first titlebar X is its first
real execution.
cc
|
||
|
vicrodh
|
684fffd7f8 |
feat(qt): the mini queue and lyrics surfaces
Block B4, the last code block of the miniplayer/tray contract. MiniQueueSurface — the current track first, then the FULL upcoming list: uncapped, unpaginated, a position number where the main list has artwork, and hover beating active on the row background. A recycling ListView, since a 2,000-track queue in a 380 px card is exactly the case the track's perf rule forbids materialising. Its document is applied IMPERATIVELY, and that is the perf rule, not style. A bound model hands the view a new array on every publish that differs, which is a full model reset: a user scrolled to row 120 gets yanked to the top every time the track advances. The upstream guard only suppresses IDENTICAL republishes — a real change is precisely what it lets through. The cure is the port's own, from Cortinilla: latch contentY, apply, restore under Qt.callLater so a burst costs one restore. MiniLyricsSurface — the empty test is on the line COUNT, not on status; there is no loading, error or offline state in the mini. It mounts its own LyricsSyncEngine, which is what makes the reference's ensure_lyrics_engine hack unnecessary: the karaoke advances with the sidebar panel closed. Both surfaces are gated on QbzMini.open, not on the surface alone. The mini window is created once and never destroyed, so a surface-only gate would leave them mounted and re-parsing a whole JSON document on every queue or lyrics edit for the rest of the session with the mini nowhere on screen. The lyrics pump additionally reads the MINI WINDOW's visibility. Section 4.5 spells the gate as open + surface + synced, but QbzMini.open is a logical flag that stays true when the window is minimised, and the general rule says that gate must read the mini's own window. The window term is added, not substituted. queue_play routes remote-first and RETURNS on Err — an error must never fall through to local playback — and its row-to-index mapping calls the tested helper rather than restating it. Row 0 resumes only when a current track exists; with none it plays upcoming[0], which is the reference's off-by-one this port declines to inherit. mini_qt::clamp_to_implemented is DELETED. It was the temporary guard that kept an unimplemented surface from stranding the user on a blank card, and its doc said the last block to land would remove it. Driven and seen: ten rows with their numbers, titles, artists, durations, the E badges on the two explicit tracks, and no artwork. What is NOT seen, because it needs sound: a row click actually playing, the off-by-one on live behaviour, and the karaoke advancing. cc |
||
|
vicrodh
|
6b17db90dd |
feat(qt): the mini footer, the hover capsule and always-on-top
Block B3. The owner's verdict on the four blocks that landed before it was that the miniplayer was "no draggeable, no hay controles de ningun tipo. Ni de reproducción, ni para cambiar entre modos, no es pinneable." All of that lived here. qml/miniplayer/ — MiniFooter with its three modes, and the five primitives the reference declares as inner components: MiniSeek, MiniTransport, MiniVolume, TBtn and CapBtn, one file each because a 396-line Slint footer folded into one QML file lands well past the size rule. MiniWindowControls is the hover capsule: five surface tabs, a separator, then expand, pin, backdrop, drag and close, plus the collapsed square trigger. The transport in full and compact is centred by a PHANTOM SPACER the width of the volume button, not by a centred layout — micro has no volume and is the one mode genuinely centred. The seek carries the reference's pending machine: the -1.0 sentinel, the 0.02 convergence window and the 8s watchdog. The capsule is a conditional MOUNT, so leaving the card destroys its expanded flag and its 250ms timer with it. ALWAYS-ON-TOP is new work, not a port: three comments in the Slint tree promise it and no code implements it. The owner asked for it back because Tauri had it and Slint structurally cannot. Qt.WindowStaysOnTopHint, a pin button, and a persisted pref that defaults ON. COLOUR LITERALS: six were carried over from the reference verbatim and every one of them was WRONG. Slint writes #RRGGBBAA; Qt parses #AARRGGBB, so #ffffff33 is not white at 20% but opaque pale yellow — which is exactly how the capsule rendered until it was driven and looked at. This is the second time this trap has landed in this port. Each converted literal now carries the reference form beside it. One of the six is MiniShell's, from B2. mini_qt.rs — surface 0 leaves the temporary clamp, because the micro footer IS the card and now exists. Surfaces 3 and 4 stay clamped until B4. Driven and seen, not inferred: the footer in artwork and micro, the capsule revealing on hover and collapsing on leave, the micro card at 380x57 with its centred transport, and the pin persisting mini_always_on_top across a toggle. The drag handle is wired to startSystemMove on pressed; the VNC platform cannot move a window, so that one is owed a real compositor. cc |
||
|
vicrodh
|
a64c20b09f |
fix(qt): never let the shutdown path outlive the UI, and log the tray hop
An owner smoke reported no way to close the app but killing the process. That was not reproduced here — driven through D-Bus exactly as a panel does it, the tray's Quit exits in 0.4s and the app-menu Close with close-to-tray OFF exits in 0.5s, both code 0 — so this is insurance and instrumentation, not a claimed cure. The insurance: once the event loop is gone the process has no UI, so nothing on that path may block without a bound. The cast shutdown ran unbounded and takes a tokio Mutex the cast poll task also holds, aborted only AFTER the lock is acquired. Two seconds is the cap; a cast device that keeps playing that much longer beats an app that cannot be closed. The instrumentation: tray_qt logs when it SENDS, and nothing logged on the QML side, so "the tray does nothing" could not be told apart from "the signal arrived and QML ignored it". The three handlers now say which. That ambiguity cost a diagnosis today; one line each ends it. cc |
||
|
vicrodh
|
088387f2c1 |
feat(qt): close-to-tray across every exit, and the macOS tray settings rows
Block B6 of the miniplayer/tray contract. B5 landed a tray whose clicks reached Rust and stopped there; this is the other half. qml/Main.qml — hideToTray(), showFromTray() and the ONE close choreography every exit now calls, plus the handlers for the tray bridge's four signals and the mini's close-app signal. The close predicate is both conditions, trayLive && closeToTray: with the tray off a close QUITS, because gating on the setting alone strands the process with no window on a desktop that has no SNI host. close.accepted = false happens before the hide — hiding never arms Qt's quit check, an accepted close does. The miniplayer's enter and exit are rewired onto those two verbs, which is what makes the tray toggle honest: the reference hides the main window behind the tray's back and its second tray click brings the main window up beside a live mini. THE EXITS ARE FIVE, NOT FOUR. The contract enumerated four and gave the grep that finds them; re-run today it returns a fifth, because the kiosk shell grew its own drawn close button after the contract was written. It goes through the same choreography. Four POC-NOTEs die here. showFromTray also un-iconifies. Qt's hide() preserves windowStates where the reference destroys the surface, so a window minimized before it was hidden would otherwise come back minimized — present in the taskbar, invisible on screen, which reads as the tray having done nothing. qml/settings/AppearanceSettings.qml + src/settings_qt.rs — the three macOS rows: the MENU BAR header swap, the macOS wording on Close-to-tray, and the Hide-Dock row, all absent on Linux. minimize_to_tray gets storage and no row, which is the owner's standing decision. And the tray-close-to-tray write arm now pushes to the bridge beside its persist, so toggling it changes the very next close with no restart. src/mini_bridge.rs — close_app and the signal it routes through, so the mini's red X will honour close-to-tray like every other exit. Its button is B3's, so the chain has no caller yet. Driven, not assumed: with the tray live and close-to-tray just pushed false, the app-menu Close row QUIT the process — which can only happen if the push reached the bridge, since the seed had set it true. And Shift+M then Escape returns the main window pixel-identical, zero of 1.6 M pixels changed, with the mini alone on a black framebuffer in between: the main window really is hidden, and Qt's hide/show preserves its geometry with no restore call. cc |
||
|
vicrodh
|
cd89b40945 |
feat(qt): the miniplayer window, shell and the two display surfaces
Block B2 of the miniplayer/tray contract, and the block that settles the premise the whole port rests on: a second top-level Window in the same QQmlApplicationEngine reads the SAME bridge singletons as the shell. Proven by driving it — a probe window with one Text bound to QbzPlayer.npTitle tracked the main window across a track change with no mirror code. Slint needs ~155 lines of mirroring for this; Qt needs none. qml/miniplayer/ (new, six files) — MiniWindow (frameless, transparent, transientParent null, its own key host and its own onClosing), MiniShell (the card, the artwork backdrop, the surface router), MiniCoverArt and MiniExplicitBadge (the two components MiniBits.slint exports, which cannot share one .qml file), and the compact and artwork surfaces. The card is the window minus a 6 px gutter, its radius is 9 for the condensed surfaces and 10 otherwise, and switching the surface RESIZES THE WINDOW — 540 to 178 and back, driven and measured, not inferred. The backdrop lives inside a masked container. `clip: true` on a rounded Rectangle does NOT round its children on this Qt build — theme/RoundedImage.qml records that as measured fact — so without the mask the scrim and the atmosphere's own opaque root would paint square corners over the card the moment the backdrop is on. That is reachable before its toggle exists, because the pref is co-owned with the shipping Slint app. src/mini_bridge.rs — enter/exit, the mini's own key dispatcher, and toggle(). Re-entering an open mini re-raises it rather than doing nothing, which is what the reference does and what present() will want. src/hotkeys_qt.rs — action_for_mini_key, a SIBLING of action_for_key with the context arm inverted. The main window still refuses Context::Mini and the test that pins it is untouched; a new test pins the mirror. src/hotkeys_bridge.rs — the ui.miniPlayer arm stops logging and toggles. qml/shell/ViewModeMenu.qml — the Miniplayer row goes live with its own dispatch arm, and it is hidden under the kiosk profile, 1:1 with PlayerBarSmall.slint:819. The kiosk port landed first, so that gate was owed here. Three comments claiming the row is inert are corrected. Surfaces 0, 3 and 4 are clamped to the artwork surface until their content exists (B3 and B4), because mini_surface and mini_default_view live in the prefs file shared with the Slint app: a user whose Slint mini was last on Queue would otherwise open onto a blank card with no visible way out. Each block deletes its own entry from that clamp. Enter does not hide the main window yet — window.hideToTray() is B6's, and open-coding a bare hide() here is what the one-visibility-owner rule forbids. So the main window stays visible behind the mini in this commit, by design. cc |
||
|
vicrodh
|
56d4387172 |
feat(qt): system tray via ksni
Block B5 of the miniplayer/tray contract. The tray settings rows have rendered and persisted since the Settings port and driven nothing; this is what they drive. src/tray_linux.rs (new) — the ksni StatusNotifierItem: the twelve icon pixmaps, the variant ladder, the tooltip, the six-item menu, left/middle click and scroll, and the qbz-tray-updater thread every mutation crosses. Note the filename inversion it reproduces: tray-light-* holds the BLACK glyph, so the "mono-light" setting loads tray-dark-*.png. src/tray_qt.rs (new) — the portable half: init's three gates, the window verbs, the 400 ms toggle debounce, the transport dispatchers and in_gamescope(). toggle_window is mini-aware — while the mini is open a tray click raises the MINI, because a mini-blind toggle would put the main window beside a live mini on the first click. src/tray_bridge.rs (new) — QbzTray: trayLive, closeToTray, and the four signals the ksni thread reaches QML through. Rust cannot touch a QQuickWindow, so every verb is a signal. icons/ — the twelve PNGs, copied rather than include_bytes!'d across crates, so this crate does not depend on a file inside the Slint binary crate. src/playback_qt.rs — the three live-update pushes: set_track and clear_track in both arms of refresh_now_playing (the publisher with 23 call sites, so a QConnect or cast track change updates the tooltip too), and set_playing in BOTH is_playing != was_playing blocks, each beside the existing discord_push. src/settings_qt.rs — tray() widened to pub(crate) for the session-entry read; the tray_close_to_tray snapshot default corrected from false to true, which was cosmetic while nothing consumed it and becomes behavioural now; and the tray-icon-theme select arm re-themes the running icon with no restart. Cargo.toml + Cargo.lock — ksni 0.3 with default-features off. Never the tokio feature: the blocking API panics inside tokio and the panic is swallowed, which is why the two dedicated threads exist. src/main.rs, build.rs, qml/Main.qml — the registrations, and tray_qt::init in on_session_entered. That call site is also deliberately the process's first settings_qt::tray(), because the store binds per user and a read from the bridge's construction seed would latch an empty one at the login screen. The Connections block that answers the four signals lands with B6, together with the window verbs it calls. Until then the tray renders, its tooltip and menu are live, and its clicks reach Rust and stop there. cc |
||
|
vicrodh
|
0d6e7d3498 |
feat(qt): QbzMini bridge, mini queue projection and mini prefs
Block B1 of the miniplayer/tray contract. No UI: this lands the state the five surfaces will bind to, so B2 can mount a window against a bridge that is already correct. src/mini_bridge.rs (new) — the QbzMini singleton. Six properties (open, surface, backgroundBlur, miniQueueJson, miniWidth, miniHeight), boot(), and the two custom-WRITE funnels. `open` mirrors into a static AtomicBool with is_open() beside it, because the hotkeys pipeline runs on another singleton and cannot read this QObject's properties. src/mini_qt.rs (new) — the plain projection module: mini_queue_doc (current track first, then the FULL unfiltered upcoming, no page cap, no art field), the row-to-upcoming-index mapping, the geometry guards, and the pref seeds. Five unit tests, three of them the contract's UT-1/UT-2/UT-3. src/queue_qt.rs — display_title and fmt_duration widened to pub(crate) so mini_qt reuses them instead of growing a third private copy; new publish_mini_queue with its own identical-document guard, published from THE queue funnel beside publish_coverflow. No second queue fetch. src/settings_qt.rs — pref_f32, the reader with a default that the two geometry keys need. Also reattaches three doc lines that sat on read_pref_f32 while describing save_pref, which had none. src/main.rs, build.rs, qml/Main.qml — the registrations: two mod lines (mini_qt is a plain module and is deliberately absent from rust_files), the bridge in rust_files, and QbzMini.boot() after QbzSession.boot(). Two deviations worth naming. Contract row A-9 asks for an invokable set_surface, but row A-3 fixes a property named surface whose generated setter is also set_surface — one QObject cannot carry both, so the funnel sits on the property. QML assigns `QbzMini.surface = n`; there is no setSurface member. And the surface write persists and re-kicks the queue refresh unconditionally, 1:1 with the reference, suppressing only the change notification when nothing moved. cc |
||
|
vicrodh
|
00eaa00027 |
docs(qt): the ambient POC-NOTE in AppShell was a fossil that lied
AmbientField is mounted at :46 and ambientOn derives from QbzShell.ambientMode, so the note claiming the artwork-derived background is unimplemented had been false for some time. Corrected in passing because this port's diff touches the file -- LESSONS-2026-08-03 L10 asks for exactly that rather than propagating it. cc |
||
|
vicrodh
|
28d66352cb |
fix(qt): four defects the independent deferral hunt found
An agent that did not write this code audited it against the contract's §9, §7 and §11.3. Four of its five findings are fixed here (the fifth, the sync() ordering, landed in the previous commit). 1. QBZ_KIOSK_FULLSCREEN was INERT and the log LIED about it. fullscreen_at_boot() had exactly one caller -- choosing a log string -- so an appliance boot with the env set stayed windowed while printing "-> fullscreen-at-boot". The reference does the real thing at qbz/src/main.rs:8611. Now a seeded-at- construction QbzShell.kioskFullscreenBoot drives Main.qml's `visibility` declaratively, so it is part of the FIRST mapped frame. It is one-shot by construction and requires BOTH the profile and the env, which is what keeps a desktop user who toggles kiosk and restarts from being trapped in a shell with no titlebar control (incident 2026-07-11). 2. Shift+I was a reachable DEAD STATE. The rebindable ui.focusMode action reaches the hotkeys dispatcher from the kiosk root like any other non-nav key, so QbzImmersive.open went true over the sanctioned EMPTY mount -- and the kiosk root then rejects every arrow, Enter and Esc while it is true, so the whole zone model froze against a surface that renders nothing. The visualizer tile already declined to open it for this exact reason; the guard now sits in apply_open, the funnel every entry passes through, because the tile was not the only door. It refuses to OPEN, never to close. 3. Kiosk chrome on the small bar was half-ported. The reference HIDES the Lyrics and Queue buttons in kiosk (PlayerBarSmall.slint:846, :983); the port gated only their click handlers, so both still rendered and still toggled side panels the kiosk shell never mounts -- inert affordances, which §9.2 forbids. 4. "Kiosk mode" and "Desktop mode" shipped untranslated. My check_msgids.py compared against the 31 @tr strings in the Slint KIOSK sources, which do not include the two strings this port adds to the view-mode menu -- the checker was right and its input was incomplete. Both now in all 7 translated locales. Verified by driving, in one frame: the small bar's right cluster no longer carries the Lyrics and Queue glyphs, and after Shift+I two Rights still move the shelf cursor (scratchpad/kiosk/f-02-after-shiftI.png). The fullscreen arm is verified only as far as a headless run can go -- both env branches log correctly and the binding resolves -- since actual fullscreen needs a real display, which is Pi/owner-smoke territory. cc |
||
|
vicrodh
|
e5f93d6805 |
fix(qt): the stale-derived-read hazard, swept across the kiosk views
KioskArtist's TypeError was found by luck, not by a method, so an independent agent swept every on<X>Changed handler in the kiosk tree for the same class: a handler reading a property that is DERIVED from the very thing it fired for. Three more, all silent: - KioskDiscover.publishNav() read `navSectionCount` from inside onActiveTabChanged, so it published the PREVIOUS tab's section count (and NaN on the creation pass). publish() clamps `index` into the count it is handed, so a wrong count is a focus ring parked on nothing, not a cosmetic slip. - KioskMyQBZ.publishNav() had the same shape against `cards` and onOnCollectionsChanged, counting the previous route's document. - KioskArtist's shelf skip-cascade read QbzKioskNav.dir inside onIndexChanged. That last one was MY defect, not the view's: sync() wrote `index` before `dir`, and each cxx-qt setter emits its NOTIFY synchronously, so the handler ran while `dir` still held the previous move. The first Down of a session read dir == 0 and refused to skip, parking the ring on a shelf of zero height; a direction reversal skipped back the way it came. Fixed at the source: sync() now writes every CONTEXT field (zone, columns, count, tabs, shelves, dir, hmove, nav_active) before the two fields consumers actually react to (index, activate_seq). The QML keeps its Qt.callLater as well -- that covers Qt's own binding re-evaluation order, which is a different hazard from the setter order. Two independent guards, because this class is invisible to every static check. The general remedy, in all four sites: compute from the source value at call time, never read a cached derived property inside its own handler. Written up at qml/Main.qml:233-247 from the window-geometry work. Gate: 9 warnings = baseline, 291 tests, both audits OK, qmllint clean on every touched file, kiosk-profile smoke clean, and the shelf skip cascade re-driven over VNC (scratchpad/kiosk/s-01-skip-cascade.png). cc |
||
|
vicrodh
|
ea26d743ab |
fix(qt): KioskArtist threw on every mount and skipped the first cover dispatch
Found by DRIVING the app, not by the gate: opening an artist logged "TypeError: Cannot read property 'length' of undefined" at KioskArtist.qml:106 on every mount. The view still rendered, which is why nothing else caught it. collectArtwork() read root.sections -- a readonly property derived from `artist` -- from inside onArtistChanged, which is connected to the very notify that dirties it. The handler runs BEFORE the dependent binding re-evaluates, so the read saw undefined. Main.qml:233-247 already documents this hazard and its remedy from the window-geometry work: compute from the value at call time, never read a cached derived property inside its own handler. Cost of the bug: the first artwork dispatch for an artist page was skipped entirely, so covers only arrived if a later pass happened to re-request them. Verified BY EFFECT -- rebuilt, re-drove to the artist page over VNC, and the run log is now clean -- not by re-reading the diff. cc |
||
|
vicrodh
|
63e36c7543 |
feat(qt): the kiosk shell, its NavRail, the 4 card primitives and the 8 views
Contract sections 4, 5, 6 and the QML half of 7.
ContentRouter.qml is the D3 extraction: ONE view-mount chain, shared by both
shells. The Slint kiosk's content block is a verbatim copy of AppShell's and
KioskShell.slint:10-17 names this extraction as the follow-up it was waiting
for. 23 desktop arms carried over with their comments, 8 kiosk overrides, and
the kiosk-only nowplaying route. AppShell's four viewLoader.item sites now go
through contentRouter.currentItem; a tree-wide grep confirmed no other
reference (LESSONS L4 -- grep, do not trust memory about "both places").
KioskShell.qml carries the back bar with the full search focus lifecycle, the
content-height arithmetic including the now-playing exception, the offline
gate, the forced small transport, the player-zone focus ring, the root key
handler and the 30ms initial focus grab. Two findings worth keeping:
- the NavRail tiles fire header-menu-navigate("favorites-tracks") in the
reference, which switches the view AND selects a landing tab; navigateTo
carries only the route, so the tiles reuse the port's existing pending-tab
handshake rather than landing on the wrong tab.
- the visualizer tile's action is a sanctioned no-op (R2). Wiring
QbzImmersive would be worse than nothing: `open` would go true over an
empty mount and the key guard would then reject every key against a
surface that renders nothing.
Three fractional font sizes had to be rounded. Qt's font.pixelSize is an INT
property, so the reference's 11.5px (NavRail.slint:47) and 12.5px
(KioskNowPlaying.slint:59,67) are not expressible; font.pointSize is the only
real-valued alternative and is DPI-relative, which would make those three
labels scale differently from every other in the tree.
The NavRail one was caught by the offscreen smoke run IN THE KIOSK PROFILE --
it made the whole rail unavailable, i.e. a kiosk with no footer. The build,
both QML audits and qmllint were all green while that was true, and the
desktop smoke was clean because it never mounts KioskShell. The other two
were still latent: KioskNowPlaying is not on the smoke's route.
Gate: build 9 warnings = baseline, 291 tests, both audits OK over 229 QML
files (+15), qmllint filtered = the same 20 pre-existing ArtistView lines and
nothing else, kiosk-profile offscreen smoke clean.
cc
|
||
|
vicrodh
|
221f8704d5 |
feat(qt): kiosk profile — resolution, boot and the live toggle
Port of contract section 8. Three Slint blocks, faithfully:
- main.rs:7855-7876 kiosk_profile_active() / resolved_shell_screen()
- main.rs:8586-8618 kiosk entry (forced reduce-motion; fullscreen ONLY via
QBZ_KIOSK_FULLSCREEN, windowed otherwise -- incident 2026-07-11: a user who
toggles kiosk on the desktop and restarts would be trapped, since the kiosk
shell has no titlebar control and neither Esc nor F11 leave fullscreen)
- main.rs:11767-11780 the live toggle, in the reference's order: persist,
flip the flag, then swap the screen. The flag first means the shell that
mounts next reads a correct kioskProfile on its FIRST frame.
"kiosk" is a SIBLING screen of "shell", not a mode inside it, which is how
app.slint:38 models it (AppScreen { splash, login, shell, kiosk }, sibling
mounts at :145 and :205). Both shells read the same bridges, so the toggle
tears nothing down and playback keeps running.
The toggle reads the CURRENT profile rather than re-resolving: resolving
would let a QBZ_PROFILE env override pin the reading and a user on a kiosk
image could never toggle out (the reference says so at :11764-11765).
ViewModeMenu's delegate called QbzImmersive.openFromMenu() unconditionally,
so flipping any row's `live` would have made it open Immersive. Each row now
carries its own action. Miniplayer stays the one inert row.
The small bar's view button becomes the toggle itself in kiosk
(PlayerBarSmall.slint:746-750): every other flyout row is gated
!kiosk-profile there, so the menu would carry a single row.
reduce_motion's kiosk half is now live -- shell_bridge.rs had the seam
pre-built with a `false` literal and a note saying one line, on their side.
Also: the gear icon. NavRail tile 7 uses settings.svg; this port only had
settings-2.svg, which is two sliders, a different glyph.
288 tests (4 new), 9 warnings = baseline, both QML audits OK.
cc
|
||
|
vicrodh
|
28c04bd990 |
docs(qt): correct the stale search notes
The two whose falsifying commit does not touch their file, so R7 rule 2 could not put them beside the code. QbzEmptyState claimed it had consolidated SearchView's and Cortinilla's no-results states. Neither uses it - both draw their own line inline, and the cortinilla's is a single 28px row inside a dropdown rather than a centred block. SearchView's SOURCE note justified its Qobuz-only assumption by saying the local sections "are not ported". They are now. The assumption still holds for the results PAGE, which is Qobuz-only, so the note is narrowed rather than deleted - the cortinilla is a different document whose rows carry their own source field. Contract: qbz-nix-docs/qt-frontend/2026-08-03-cortinilla-parity, commit C12 (R7-7, R7-8). cc |
||
|
vicrodh
|
b38b0b3d57 |
feat(qt): instant cached cortinilla paint (default on, ui_prefs opt-out)
The reference shows a skeleton while loading and never paints cached rows
first, and its comments present that as the design. It is not: the instant
paint existed during development and was removed because it GLITCHED -
results visibly jumped between the cached paint and the fresh one. The
owner's reading is that the glitch was a Slint rendering problem rather than
something inherent to stale-while-revalidate, so it comes back here as a
reversible experiment: DEFAULT ON, with a ui_prefs opt-out
(cortinilla_instant_paint) that needs no rebuild to flip. The skeleton path
stays fully implemented as both the opt-out target and the cold-miss path.
What is cached is the FINISHED payload, not the API response. Reviving the
existing CAPA A result cache would have left the expensive half on the table:
a cortinilla payload is the response AFTER ranking, truncation, i18n titles,
the top-result pick and - the part no API cache can shortcut - the local
library query and its derived grouping.
qbz-app gains a generic PayloadCache<T>. The store never inspects T, which is
what lets both frontends share it despite their payload types having diverged
(one raw artwork_url vs an art_url/art_path pair). In-memory only: process
lifetime IS the TTL, because a payload embeds local rows and resolved artwork
paths and a persisted entry would resurrect albums the user has deleted.
Four properties are what should keep it from glitching, and each is a real
constraint rather than a hope:
- Same shape in both paints. The entry is written AFTER the local sections
are appended, so there is no mid-apply reflow left to see.
- Equality-gated replacement. CortinillaData derives PartialEq, so an
unchanged repeat query produces ZERO second paint.
- The selection survives - the publish path never writes selectedIndex.
- The scroll survives - C5's contentY latch. Without it the second paint
yanks the user to the top, which is the glitch by another name.
There are exactly TWO write points, and the placement is load-bearing: after
pass-1 artwork resolution, and again at the pass-2 republish once downloaded
covers land. Writing earlier caches rows with empty art_path, and since the
QML draws art_path only, a hit would paint cover-less rows AND the gate would
fire on every hit - the exact repaint this exists to avoid.
Invalidation: bound per session, dropped on logout, and cleared from
reload_browse - the single chokepoint every local-library mutation passes
through, since there is no library-changed signal to subscribe to.
Also fixes the immersive skeleton's scope bug, which is the twin of the one
C4b fixed on the desktop and which I missed there: a Timer derives from
QtObject, which has no parent property, so the unqualified parent resolved
out of the block entirely - the timer ran forever, pulse never changed, and
the skeleton never pulsed. Found by qmllint, not by reading. It picks up the
reduceMotion tick with the fix.
Contract: qbz-nix-docs/qt-frontend/2026-08-03-cortinilla-parity, commit C11
(section 5.c, rulings R1/R6, R7-10).
Gate: build clean, 258/258 tests + 2 new in qbz-app, both QML audits OK,
qmllint clean on both cortinillas, offscreen smoke 0 complaints + home
published.
cc
|
||
|
vicrodh
|
06e8b4ba4d |
fix(qt): pass the cortinilla row's block padding in instead of reading parent
The row width read parent.leftPadding / parent.rightPadding. It works at runtime - the parent is always a Column that has them - but `parent` is typed QQuickItem, which does not, so qmllint cannot verify it and a wrong mount would fail silently at runtime instead of loudly in the audit. Parent-chain bindings are a documented trap in this port for exactly that reason. The padding is now a property each mount site sets. Cortinilla.qml is qmllint-clean. Found by running qmllint over the files this branch touched, after two identifiers were written before being verified against the source - a Flickable forceLayout() that does not exist, caught by the smoke, and a tracksQuery property that does not exist, caught by reading. Neither the resolution audit nor the singleton xref can see this class of error: they check component types and BRIDGE members, not view-local properties. qmllint does, and it is now part of the gate. cc |
||
|
vicrodh
|
4806584ee2 |
feat(qt): local "View more" routes into the LocalLibrary tabs
The three local sections' View more links now leave the search surface entirely and land on the matching Local Library tab. Sending them to the Qobuz results page instead would show a page with no on-device content at all, which reads as the link having done nothing. local-album -> Albums tab local-artist -> Artists tab local -> Tracks tab, pre-filtered with the live query The query pre-filters the TRACKS tab only. Albums and artists have no search box of their own, so handing them a query would be a lie - the list would come back unfiltered while something claimed otherwise. The active tab is QML-owned state, so the route is a pending property the view consumes, mirroring the localPendingArtist mechanism that already existed for "go to artist" on a local album. It is released after being applied, because the property CHANGE is the trigger and an unreleased route could not fire twice in a row. The consumer also runs on mount, so a route set while the view was unmounted still lands. Setting the tracks filter writes the view's own search state as well as issuing the query, or the search box would render empty next to a filtered list. Contract: qbz-nix-docs/qt-frontend/2026-08-03-cortinilla-parity, commit C9 (sections 3.4-3.5). Gate: build clean, 258/258 tests, both QML audits OK, offscreen smoke 0 complaints + home published. cc |
||
|
vicrodh
|
263b82a694 |
fix(qt): cortinilla robustness - scroll latch, hover, hasTop, index guard
Six defects, plus one owner-requested behaviour change.
- The document is now applied imperatively instead of bound. cortinillaJson
is republished wholesale when the artwork pass lands, about 1.5s after
the rows, and a bound Repeater model made that a full model reset: every
delegate destroyed and rebuilt, contentHeight momentarily 0, and
StopAtBounds clamping contentY to 0. The user was yanked back to the top
mid-read. The offset is latched and restored via Qt.callLater - NOT
forceLayout(), which is a QQuickItemView method and does not exist on a
plain Flickable; calling it threw a TypeError and clamped against a stale
contentHeight.
- panelHovered could latch true forever: if the panel went invisible while
the pointer was over it, the hover source never reported false again.
- Hover detection moved from a MouseArea to a HoverHandler. The MouseArea
was declared first, so the Flickable and every row's MouseArea sat on top
of it and took the hover events - containsMouse stayed false across most
of the panel, which is why hovering did not hold the dropdown open. A
plain MouseArea stays behind it purely to swallow background clicks.
- hasTop tested the top row's id for emptiness. Local ARTIST rows carry an
intentionally empty id - routing is by name - so the top-result block
would have vanished for them once the local sections land. It now trusts
the Option the payload already models.
- The row click passed flatIndex raw across the i32 boundary, where
undefined coerces to 0 - the top result's index - so a malformed row
would activate the wrong thing rather than nothing. The highlight already
guarded; the action now does too.
- The nested Repeaters both used an unqualified modelData. It resolves
correctly today, but one added `required` on the inner delegate would
silently flip every row to render its section. Both are named now.
- LAST_CORT's locks no longer unwrap(). row_clicked and move_selection are
invokable bodies, i.e. Qt GUI thread, so a poisoned lock there would take
the UI down over a snapshot that is stale at worst.
OWNER DIVERGENCE (2026-08-03, unplanned): hovering the panel no longer
pauses the idle timer indefinitely - it stretches it to 30s. The reference
pauses outright, which means a cursor left over the panel by accident holds
it open forever. 30s satisfies both halves of the owner's ask: reading is
never interrupted at 4.5s, and a forgotten cursor still lets it go.
Contract: qbz-nix-docs/qt-frontend/2026-08-03-cortinilla-parity, commit C5
(D-BUG-6/9/10/11/12/13).
Gate: build clean, 258/258 tests, both QML audits OK, offscreen smoke
0 complaints + home published.
cc
|
||
|
vicrodh
|
4e1703c436 |
feat(qt): reduceMotion seam and a coarse skeleton tick
The owner ruled 3-C: build the seam here so the kiosk port consumes it instead of having to invent it. The earlier plan was to wait for kiosk to define it, but kiosk is not implemented - it is a contract - so "wait for kiosk" meant waiting on a date that does not exist. The shape is no longer a guess, which was the only objection to building it early. Two independent sources fix it: the kiosk contract mandates "FORCED reduce-motion while in kiosk", and the reference computes the flag as kiosk_profile || !use_gpu_renderer. QbzShell.reduceMotion is derived, never a preference - do not add a Settings row for it. The existing play-indicator toggle is a preference and a different thing; binding them would make "animate the play indicator" change this dropdown's pulse rate. Only the kiosk half is wired, and the omission is deliberate rather than partial: the renderer tier has no honest source here. It is a QML-side fact, this port runs on the GPU in every real session, and the one place a probe would report software is the offscreen smoke, which forces it by definition. Wiring it would turn reduce-motion on exactly where it means nothing. The kiosk literal is a named const with a pointer to their contract; flipping it is one line on their side. The cortinilla skeleton is the ONE consumer: its single host Timer drops from 700ms to 2000ms. No new timer, no per-delegate animation - the reference's own note records that this pulse was the main cost of opening the cortinilla on weak GPUs. Giving that Column an id also fixes a real scope bug on the way past. The Timer read an unqualified `parent`, and Timer derives from QtObject, which has no parent property - so it resolved up the scope chain, out of the block entirely. The sibling rectangles' parent.parent[.parent] chains are now explicit too. EqualizerBars.qml and the immersive contract's D11 both recorded that Qt had no reduce-motion twin. Both are corrected: the seam exists, those surfaces are simply not consumers yet, and wiring each is its own one-liner. Contract: qbz-nix-docs/qt-frontend/2026-08-03-cortinilla-parity, commit C4b (section 5.g G1-G5, ruling R10; D-BUG-1 folded in). Gate: build clean, 258/258 tests, both QML audits OK, offscreen smoke 0 complaints + home published. AC-39: exactly one behavioural consumer. cc |
||
|
vicrodh
|
033b838b98 |
fix(qt): cortinilla geometry - NPB-aware cap, scrim inset, row width, scroll base
Five geometry defects, all latent while the Qobuz-only panel held at most 14
rows and never scrolled, and all reachable the moment the local sections land.
- The height cap hardcoded 42 for the now-playing bar in every mode. The
bar is 42 only in NPB mode 2; everywhere else it is 112, so the panel
could run up to 70px into it. The cap is now mode-aware, reading the same
theme tokens AppShell uses. The header height literals in the scrims and
the panel anchor became theme.headerHeight at the same time.
- The click-outside scrims left a gap for the search field computed without
the 60px the field gives up when the section nav sits in the header, so
with nav-in-header there was a 30px dead strip on each side of the field
that neither dismissed the panel nor reached the input. The scrim now
tracks HeaderBar's own width rule exactly.
- Rows were 12px wider than their block: a QML Column's padding does not
size its children, and parent.width ignored it. clip hid the overflow,
but the highlight ran flush to the right edge while staying inset 6px on
the left.
- flat_index_content_y started at 6.0, mirroring the panel's 6px top
padding - which is a Flickable VIEWPORT margin, not content space. Every
row was reported 6px low, so scroll-into-view over-scrolled going down
and clipped the row's top going up. The immersive twin, written later
against the same layout, already started at 0.0.
Two unit tests now pin the arithmetic. There were none for the desktop
arm, which is why the 6.0 survived; the immersive arm had its equivalent
and was correct.
- The scrollbar used the primitive's default 14px gutter where the
reference overrides it to 10.
Plus the "Enter" affordance glyph (U+23CE + one space -> U+21B5 + two, as in
the reference) and the panel drop shadow, which reuses the immersive twin's
idiom - a mirror rectangle blurred by MultiEffect, skipped when there are no
shaders - rather than introducing a second shadow mechanism. NavFlyout still
has none and says so; that is its own parity pass.
AppShell's comment claiming the cortinilla is the "LAST child so it renders
above every surface" is corrected: four siblings are declared after it, and
that is fine.
Contract: qbz-nix-docs/qt-frontend/2026-08-03-cortinilla-parity, commit C4
(D-BUG-3/4/5/7, rows A5/A7/A10/A12/A13/A19/A28/A2, UT-1).
Gate: build clean, 258/258 tests (2 new), both QML audits OK, offscreen
smoke 0 complaints + home published.
cc
|