85 Commits

Include renames

Author	SHA1	Message	Date
vicrodh	750c59034b	feat(qt): Excel-style multi-select — Shift ranges across every surface ... Selection existed but had no keyboard: every click was a single toggle, so picking 40 tracks meant 40 clicks. Slint and Tauri have had ranges since 2026-06; this is that port. NINE surfaces, not the five the track views suggested: Album, Artist, Playlist, Label, Local Album, plus Library's tracks and albums and Local Library's tracks and albums. Each carried its own hand-copied `selected` map and its own `toggleSelected`, so the rule went into controls/SelectionModel.qml and the maps stayed where they were — the smallest change that stops it being copied a tenth time. The rules are Tauri's `applyShiftRange`, unchanged: a plain click toggles one row without clearing the rest, Shift fills the range from the anchor ADDITIVELY (so re-dragging a range cannot eat the set) and leaves the anchor where it is, and Ctrl/Cmd is the same as a plain click — not a shortcut, but the behaviour both references already have, because an accumulating click is what "add without disturbing" means. Qt makes this CHEAPER than Slint, and the difference is worth recording: Slint had no modifiers at click time and had to read a thread-local set from a ModifiersChanged handler, with a documented stale-read edge case when the window lost focus mid-chord. A QML MouseArea delivers `mouse.modifiers` on the event itself, so the modifier and the click can never disagree and no such seam exists here. Three judgement calls, stated because they are not forced: - Library gets TWO models, one per kind. Its rows are mixed, and one anchor would let a Shift-click on a track sweep up the albums drawn between it and the anchor. - Ranges run over the VISIBLE rows. Local Library's search box is a view filter, and a range over rows the user cannot see is not the range they asked for — the same call `select-all` already made. - The Local Library tree rail keeps plain toggles. Its selection lives in Rust (QbzLocal.treeToggle*Select), so there is no QML map to hang an anchor off; teaching the Rust side about an anchor is its own change, and the file says so where a reader would expect otherwise. The anchor is an ID, not an index, because every one of these views can re-sort or filter under a live selection — an index anchor silently points at a different track the moment the order changes. Slint's selection.rs made the same call for the same reason. Verified by driving the app: in Abbey Road, click row 1 then Shift-click row 5 selects exactly rows 1-5 and leaves 6-8 untouched, with the bar reading "5 selected"; the same in a playlist, additively over a row that was already selected. cc	2026-08-22 02:03:10 -06:00
vicrodh	cf07f10a59	fix(settings): make the Font row actually change the font ... It shipped doing nothing. Measured on the built binary: picking a face persisted the pref and changed ZERO of 600600 pixels in the settings label column. The row was a control that lied. Two measurements say why, and both were run against this Qt build rather than reasoned about: - `ApplicationWindow.font.family` propagates through Qt Quick CONTROLS only. In a standalone scene with a family set on the window, a `Label` resolved to it and a sibling `Text` stayed on the APPLICATION font. This tree is 1082 plain `Text` items against 13 that name a family, so the app's typeface IS the application font. - The application font is read when an item is CONSTRUCTED. Driving PySide6 against the same Qt, `QGuiApplication::setFont` updated `QGuiApplication::font()` and left an already-built `Text` on its old family. Together those close the door on changing it live, so the ordering in main() is the feature: FontPreload.qml registers the bundled faces (a family does not exist until its file is loaded, and `load()` returns with its FontLoaders already in the database), the application font is set from the persisted choice, and only then does Main.qml build the UI. Swap any two of those and the setting silently does nothing again. The row now says "(requires restart)", the same wording Interface size two rows above already uses, in all eight catalogues. "System" resolves to "" and takes no branch, so anyone who never opens the row gets exactly the font this app rendered before — verified by capturing the window on both settings: 0 log lines and an untouched frame for System, 27065 changed pixels for Montserrat. NOT ADDRESSED, and worth its own decision: those 1082 Text items have never used the bundled Inter either. `Main.qml` has always named it, but that only ever reached the Controls, so the app renders in whatever Qt picks. Making "System" mean Inter is a one-line change and a visible one, so it is left alone here. cc	2026-08-22 01:31:42 -06:00
vicrodh	f50c1b5188	feat(settings): the library folder table becomes its own page ... The folder block — toolbar, add-path row, filter, the row-per-folder table and the scan progress — is the tallest thing in Settings and it sat at the TOP of Local Library, pushing Albums view, Library > All, Maintenance, Danger zone and the three media servers off the first screen. Behind a Manage row, the whole panel fits one screen again. The shape is the one Blacklist already uses for its manager, and this view is deliberately its twin: same 64px summary row, same metrics, same route-recorded-by-the-caller contract. Nothing about the table changed. LibraryFolderTable.qml is mounted verbatim, still driven by the settings document and still acting through the settingsString action keys. Two things had to travel with it, because SettingsView used to supply them and a routed page has no access to that: - LibFolderEditModal, or the per-folder pencil would open nothing, silently. - the refresh on entry. A view reached by Back runs no per-view load, so it asks for its own, where BlacklistManagerView puts its reload. Verified in a running window: the route mounts, the seven folders render with their per-row actions, and Back returns to Local Library with the section intact. cc	2026-08-22 00:01:13 -06:00
vicrodh	2273db9184	feat(qt): the disc surfaces — rip wizard, metadata correction, and a pane that ... can be read RIP WIZARD, three steps, each answering something the first version got wrong by not asking. What will happen — which disc, how many tracks, and that the output is FLAC, stated rather than implied. The tracks, editable, because a CD-DA carries no titles at all so "named wrong" is the ordinary case and once files are on disk it is a rename job. And what happens afterwards: a ripped album the library cannot see is a folder full of files, so the destination is compared against the registered folders — by path COMPONENTS, not by string prefix, since /music-backup starts with /music and is not inside it — and the right follow-up is offered, naming the folder it would re-scan. "Do nothing" is an explicit choice rather than the silent default. The follow-up runs only on success. Tracks can be deselected. Everything is ticked on arrival and the user goes from all to fewer; a wizard that starts empty makes the common case the one that costs the most clicks. On the Rust side an absent `selected` means yes, so an older form cannot silently rip nothing. A PROGRESS PANEL behind the ripping chip, which is a door rather than a label: it is the only thing on screen during a rip and the two questions it could not answer are the ones that matter. A soft lock says not to eject — soft because nothing here can hold a tray shut, so the honest move is to say it and keep saying it. Per-track state with a bar on the row that is actually moving. Stopping is offered, deletes nothing, and says so; a cancelled job does not jump to 100 %, which is the one lie a progress bar must not tell. CORRECT DISC DETAILS, for a CD and a SACD image and for neither on a folder, which has no identity to write a correction under. The list shows what distinguishes four pressings of one album rather than four identical titles, and flags a track count that disagrees with the disc. Selecting is not applying: the candidate is fetched in full and its track list shown, because that list is the only thing proving a plausible title is the right pressing. Applying renames the live session without renumbering ids — a re-open would orphan a playing track — and writes a user row. Only MusicBrainz re-resolves the cover; Discogs ids are not Cover Art Archive keys and a wrong cover is worse than the old one. The correction can be dropped, because without an escape a bad apply is permanent and that makes people afraid of the button. THE PANE SPLITS BY DISC. A box set scans as one album — measured on a 34-track set whose album_group_key is the box root for every file while the disc number sits in the data unused — so the pane was a flat list 247 rows long. The key carries the disc, unconditionally, because it round-trips through the play-album lookup. Its own client-side filter over what is already rendered, since finding one track meant scrolling past the other 246. EPHEMERAL TRACKS LOSE WHAT CANNOT OUTLIVE THEM. queue_qt has published isEphemeral on every row for a while and the queue panel respected it; the bar never read it. The heart goes inert, the add menu keeps only its queue actions, and the row menu comes back with those three and nothing else. Absent rather than rendered-and-inert. Also: a spinner on Open that blocks a second click onto a drive already being read, held by a counting RAII guard because opening is a relay and the chip must not blink off in the seam; the now-playing card routes a disc to the pane it came from instead of to an album id no catalogue can open; the file pickers use rfd, the platform's own dialog, which the POC-NOTE said was a five-line change once the dependency existed — it existed, Settings had been calling it from this crate for weeks, and on macOS the four Linux choosers do not exist so Open folder and Open SACD image opened nothing at all, in silence; the empty state stands down for the Open pane, which on a machine with no library drew both fully painted; tooltips on every disc control through one hover() helper, since two call sites had already mismatched their key, which does not fail — the bubble simply never goes away. cc	2026-08-21 18:58:22 -06:00
vicrodh	3cfce8a769	feat(qt): the media-server settings panel, driven and verified in the window ... ONE component instantiated twice, because it is one form twice. Every difference between the protocols is a property set at the call site, so they are visible in one place instead of drifting across two files: "Test" proves the address for Jellyfin and only "a Subsonic server answered" for Subsonic (which has no credential-free endpoint), the password is discarded for Jellyfin and kept for Subsonic (no session, md5(password+salt) per request), and the sync cost is stated up front — 45.8 s per 4924 tracks against 0.81 s per 6678 — so a long sweep does not read as a hang. The credential never leaves Rust; the panel gets `hasCredential`. Assets: the colour marks for cards, the monochrome ones for rows. Both mono files arrived as BLACK ink and are invisible on a dark theme untinted, so they were normalised to the #ffffff master ink and joined `icon_tint_qt::MASTERS` — the port's only shader-free way to recolour an SVG per theme. The Jellyfin colour asset had a white rounded-rect plate behind the mark; it was stripped, because every other brand mark here is transparent and a white tile beside them reads as a rendering bug. Rendered with Qt itself and looked at before any of it was wired. CAVEAT, recorded in SourceIcon: the Subsonic mark is NAVIDROME's logo, and `subsonic` covers Gonic, Airsonic, Astiga and Ampache too. `ping` reports the server's own type and it is already persisted, so branching later is cheap — a known wrongness, not an unnoticed one. THREE BUGS THAT ONLY THE RUNNING WINDOW COULD SHOW, all found by driving it under Xvfb rather than by reading the log: 1. `MediaServerSettings is not a type` — a .qml missing from build.rs is not in the QML module. It resolves fine on disk, compiles nothing, and blanks the WHOLE settings page at runtime. All three existing audits passed. `qml_module_registration_audit.py` is the missing check and is now in the gate. 2. The toggle would not move. The panel reads its state from the settings DOCUMENT, unlike Plex's toggle which reads a bridge property, so every mutation has to republish it — connect, enable, disconnect and the end of a sweep now do. 3. Every Jellyfin album in the grid drew the LOCAL HARD-DRIVE badge: `local_rows::badge_source` had never been taught the two words and folded them into `_ => local`. Not cosmetic — that string is what the source chips filter on. `play_single_from_source` also grew the arm it needed: a media-server row from the recently-played rail has no library.db row to mint a LocalTrack from, so it resolves through `registry.tracks_of` instead. END TO END, from the UI, against the real server: toggle on -> type the address -> Connect -> "jellyfin sync: 500/4924 ... 4924 saved, 0 pruned, 4924 cached" -> Local Library shows 461 albums with their covers and the Jellyfin badge. The cached quality distribution is identical to what the server reported in the original protocol sweep. 428/428. cc	2026-08-20 10:57:28 -06:00
vicrodh	c11bdf0654	feat(qt): bring back the New playlist modal, and delete the shortcut ... The sidebar "+" called create_playlist(), which made a playlist named literally "New Playlist" and navigated to it. Four of the modal's five fields had no other door, and one had NO door at all: name hardcoded reachable in Edit playlist description always empty reachable in Edit playlist folder always root reachable in the sidebar row menu public always false NOWHERE offline-only from connectivity NOWHERE for an online user That last row is why this counts as a regression rather than a rough edge. offline_only decides whether the playlist is a local_playlists row (local:<uuid>, library.db, no Qobuz account, never uploaded) or a Qobuz entity, and the shortcut derived it from connectivity alone — so someone with a Qobuz session could not create a local playlist without pulling the network cable. Ported against CreatePlaylistModal.slint plus on_create_playlist (main.rs:21107) and on_submit (:21496). The submit branches where the reference branches, and a creation forced local by being offline KEEPS the flag, as the reference's own note says, so Edit can unmark it later to enable "Upload to Qobuz". Two calls made here: - Create rides the QbzPlaylistEdit singleton rather than getting its own, where the reference splits them. Same domain — a playlist's own metadata — with two documents that never interact, and a second QObject is a second boot() to forget; that bridge's header already documents a missing boot() swallowing publishes silently and forever. - The folder picker hides on the offline-only arm. folders_qt::move_playlist takes a u64 and a local:<uuid> has none, so the reference shows the control and discards the value. The shortcut is deleted rather than left beside the modal: a second creation path that skips it is the fork the port rule forbids. All thirteen strings were already in the catalogues. cc	2026-08-19 23:55:25 -06:00
vicrodh	e816436fd0	feat(qt): remember where each page was scrolled, across back and forward ... The port of the block Slint repeats in 27 views (NavState.restore-scope / scroll-restore / report-scroll). A .slint file cannot hand a component a reference to a Flickable, which is why the reference inlines it; QML can, so controls/ScrollMemory.qml exists once and 31 containers mount it. Two divergences from the reference, both forced by the same fact — tabs are not history entries in this port: 1. THE SCOPE IS NAMED BY THE VIEW, not derived from the entry by a scope_for table. Slint can derive it because its entries carry the tab (Favorites { tab }); here an entry is a bare route id, so a derived scope would read "library" for all five Library tabs and pour the Albums grid's offset into whatever tab mounted. Letting the reporter name its own scope buys tab granularity for free, and the mismatch case degrades the right way: an unmatched scope restores NOTHING instead of restoring the wrong thing. 2. THE RESTORE RE-ASSERTS instead of firing once. A Qt item view resets contentY to 0 whenever its model is replaced, and several pages assign their model from a binding whose inputs arrive over the network after the mount — the album page rebuilds listCells from three deferred rails, so it hands its ListView a new array up to four times in its first seconds and snaps back to the top over a restore that already ran correctly. The offset is held and re-applied until a 2.5 s deadline, or until the user takes over (a wheel, a drag or a flick raises `moving`, and from then the position is theirs). Diagnostics are off by default: QT_LOGGING_RULES="qbz.nav.scroll.info=true" for the QML half, RUST_LOG=qbz=debug for the stamp/arm half. cc	2026-08-19 23:54:46 -06:00
vicrodh	1352e499f9	fix(qt): the hand-written RHI items now compile on macOS ... `build_rhi_items()` compiles the four QQuickRhiItems in `cxx/` with its own cc::Build, and its macOS arm had never run: those files landed in e6c058c2f on 2026-08-16 and the Mac's last binary was from the 10th. The first build there failed on all four, and the failure reads like a code error rather than a toolchain one: cxx/linebed_item.h:24:10: fatal error: 'QtCore/QByteArray' file not found cxx/plasma_item.h:16:10: fatal error: 'QtGui/QColor' file not found Homebrew ships Qt as FRAMEWORKS, and two things follow. `include_paths()` yields `<libs>/QtCore.framework/Headers`, which cannot satisfy `#include <QtCore/QByteArray>` — inside that directory `QtCore` is the umbrella HEADER FILE, not a subdirectory — so frameworks need `-F`, not `-I`. And the private tree holding `<rhi/qrhi.h>` is not under `QT_INSTALL_HEADERS` at all there (that prefix carries no `QtGui/`); it lives at `<libs>/Qt<Module>.framework/Headers/<version>/Qt<Module>`. Reproduced outside cargo with the exact flags cc-rs emits: the `-I` form fails, `-F <libs>` compiles clean. The branch keys off `CARGO_CFG_TARGET_OS` rather than `cfg!()`, because a build script runs on the HOST and the two differ under cross-compilation. Every path still comes from `qmake -query`, so nothing is hardcoded and a CI runner needs only Qt on PATH. The Linux arm is byte-for-byte unchanged. Verified both ways: `cargo check` here and a full release build on the Mac mini M2 (Qt 6.11.1, Homebrew) — 3m56s, no errors, binary produced. The header comment that claimed macOS used "the same layout" is corrected in place; it was right that the arm was never compiled and wrong about why that was safe. CI notes for the Qt track — which has no workflows yet — are in qbz-nix-docs/cicd/qt-macos-build-notes.md. cc	2026-08-19 14:27:51 -06:00
vicrodh	26ceeab828	feat(qt): mixed playlists, page fade, category filter, per-context recents ... Six parity fronts against the Slint/Tauri references, plus the applied-filters tooltip the app never had. MIXED PLAYLISTS — the bug. A mixed playlist is a QOBUZ playlist carrying local and Plex rows through library.db's playlist_local_tracks / playlist_plex_tracks sidecar tables. This port could WRITE those rows (the picker) and COUNT them (the Playlist Manager badge), but playlist_qt::load built its rows exclusively from the Qobuz API response, so a track added to a playlist never appeared on the page it was added to. Two comments elsewhere claimed the merge already happened; they were describing the reference. Ported literally: read_sidecar_rows_blocking (healing + bulk Plex resolve) and interleave_rows (absolute-slot claim, same-slot collisions all emit), merged in load, with the merged queue adopted as the open-detail snapshot. Routing had to split with it. local_playlist_qt::open_id() was the one predicate for every action, and a mixed detail adopts that same snapshot — so it now means "a local:<uuid> detail OR a mixed one", which is right for play/shuffle/row-play and wrong for the writes. Remove and reorder route on the new local_detail_open() instead; without that, removing a local row from a Qobuz playlist wrote into the local-playlist repo, found nothing, and reported success. Removal by source is a third arm: the Qobuz arm parses the display id as a u64 playlist_track_id, and a local row's display id is a library.db rowid in the same numeric space. Reorder is refused on a mixed detail for the same collision, in Rust and in the view. PAGE FADE. 300 ms OpacityAnimator on the mounted page, OutCubic, honouring reduceMotion. Zero added latency: the router's Loader is synchronous, the UI thread is frozen through the mount and no frame exists in which a fade-OUT could be shown, so the page snaps transparent in the same turn as the rebuild and only the reveal is animated. An Animator and not a NumberAnimation because it runs on the render thread — measured 0.53 vs 0.11 of progress with the GUI thread blocked — and not on the shared pulse because the pulse arrives on the very thread the mount blocks. The first cut faded a veil coloured from the pane, and that was wrong in a way that only shows in the configuration the app actually runs in: AppShell paints the pane surface-main@0.22 while the ambient background is on, so a veil at full opacity covered 22% of the page and the fade read as a flicker. Fading the page has no such failure mode and keeps the ambient art visible. SPLASH COPY. The login screen was already 1:1 (18 msgids, verified by diff). The splash was missing the legal disclaimer the reference pins to the bottom of the screen, drew "QBZ" / "QOBUZ PLAYER" as bare literals (English in all eight locales), and hardcoded the dark palette — black on the other 34 themes. CATEGORY FILTER on the Home playlists rail. Slugs now travel per card and the offered set comes from the same /discover/index response, so the filter is client-side over the cached 40 with no extra request. The selection lives in Rust because HomeView is destroyed on every navigation; the reference keeps its own for the same reason. New trigger + popup, and a `leading` slot on QbzSectionHeader to hang it off the title line. APPLIED-FILTERS TOOLTIP. A third QbzTooltip mode taking [{group, values}], below the control with an upward caret. Overflow is staged summary and never scroll — the overlay is enabled:false by construction, so a scrollable tooltip could not be scrolled. Wired where a filter is INVISIBLE (collapsed to a count or a glyph): the genre chip in four hosts, the Home tags, the Local Library and Purchases funnels, the Artist Scene genres. RECENTS BY CONTEXT. QueueTrack already carried context_kind and exactly one function threw it away: record_queue_track wrote both album histories on every track start whatever the user had put on, so one 40-track playlist filled a 24-entry album rail with that playlist's contents. album_play_events gains an additive context_kind column (the other frontend names its columns on insert, so it writes '' and '' counts as an album — no history reinterpreted), plus a new playlist_play_history.db and a "Recently Played Playlists" rail, default on. A separate file rather than a field in recently_played.json, which is a destructive round trip between frontends: serde drops what it does not know and the next write puts the truncated object back. ITEMS PER CAROUSEL, recovered from Tauri and never ported to Slint. It lives in a NEW TABLE of discover_prefs.db, not in the prefs blob: to_json rebuilds the object from the keys the running binary knows and save overwrites the whole column, so a new key would survive only until the other build's next toggle. Default is uncapped, i.e. today's behaviour. Two DiscoverySectionId arms were added to the frozen Slint tree, obliged by the shared enum's exhaustive matches — same two-line follow MostPlayedAlbums took. Not verifiable here: compiling that crate pulls qbz-ui. Also fixes two recommendations_qt tests that had been red since c02e7713d, which turned the two Weekly rows into ordering slots that deliberately do not self-hide while the assertions kept the pre-split behaviour. Verified by stash that they fail without any of this change: the code was right, the tests stale. Eight locales updated. Release build clean, offscreen smoke gate green, qbz-qt 421/421 and qbz-app 215/215. cc	2026-08-19 07:00:35 -06:00
vicrodh	b2c74c4140	feat(qt): find an available version for a track Qobuz pulled ... Reachable from a dead row's context menu, in a playlist the user owns. The reference had this and shipped it with four defects; none are ported. It was unranked -- Qobuz's raw relevance order shown to the human. The weighted matcher that already lives in qbz-playlist-import does the ranking now, and its ISRC short-circuit matters most: licensing churn usually republishes the SAME recording under a new id with the SAME ISRC, and the pulled track keeps its isrc (confirmed in the 2026-08-17 capture of album 0886443985094). That case needs no human judgement, so the ISRC lookup runs first and pins its hit to the top. It removed before it added, so a failed add lost the track outright. The order here is add, reposition, remove. It did not preserve position -- the computed index went to a console.log and the replacement landed at the end. It lands where the dead row was, through the new updateTracksPosition verb. Every failure in that step is a warning and a different success toast: the repair still stands at the end of the playlist, exactly where the reference always put it. Position is a nicety, never a reason to abort a repair. Two guards. If the ISRC lookup answers with the dead track itself -- it can, since a pulled track keeps its metadata and search still indexes it -- then "replace" would be a no_duplicate no-op followed by a remove, and the user would lose the row while being told it was repaired. And when the remove fails the playlist permanently holds both rows: that is not rolled back, because a rollback is a second write that can fail the same way and would delete the only good copy. The list is refreshed so the user SEES both, and the toast says the old one has to go by hand rather than claiming a reload will fix it. cc	2026-08-17 14:41:39 -06:00
vicrodh	dc2496e5c0	feat(qt): award pages, reachable from the album sidebar and from each other ... Ports the Slint/Tauri award pair: the landing (gold laurel hero, magazine line, follow heart, "Acclaimed Releases" with its count and See All, the preview grid and the "Other awards" rail) and the paginated listing with its client-side search. Routes "award" and "awardalbums", the label pair's shape — one controller for both, since they share the hero, the follow state and the identity. The three rules from the Tauri review are in the module header because they are the ones a re-implementation gets wrong: the grid is ALWAYS /award/getAlbums (/award/page is user-scoped and may omit releases, so it feeds the hero and nothing else); the favorite split is plural-read, singular-write, because the backend derives `award_ids` from the write kind; and getAlbums has no has_more, its `total` is a hint, so the only sound predicate is `total > loaded`. The album sidebar's AWARDS cards navigate now — with an id directly, and by NAME through the resolver when Qobuz omits it, which it does. They were also reading `album.awards` when the field lives on `album.header`, so the block had rendered EMPTY for every album since it was written: an empty Repeater draws nothing and reports nothing, and the sidebar's own gate counted the same empty list. The LABEL card beside it had a "no label view yet" note and no handler, years after the label view landed. Beyond the reference: an all-awards dropdown pinned to the page's top-right, so any award is reachable without first finding an album that won it. It costs nothing new — the /award/explore crawl already existed to resolve names to ids. The award icon was lucide's MICROPHONE under the wrong filename. Search had routed around it with `crown` and left a note; kiosk was missed and drew a mic for "Most popular". The asset is the laurel the other two frontends use, and kiosk now asks for the crown it wanted. cc	2026-08-16 18:56:20 -06:00
vicrodh	7d98ad044f	feat(purchases): the Qt frontend — list, album detail, routing and gating ... Two screens, a controller and a bridge. `QbzPurchases` publishes one JSON document per screen plus a revision counter, so QML re-parses even when the text is byte-identical. - The list: two tabs with per-type counters, a server-side search on a 300 ms debounce, and a toolbar that DIFFERS by tab — Albums gets group, sort, direction, two filters and grid/list; Tracks gets group and the filters only. Building the Albums toolbar on both would have invented two controls. - The detail: a format dropdown whose selection re-scopes every downloaded mark, the progress section and Add-to-Library together; a determinate bar counted in TRACKS, never bytes; goodies as an album-level action counted separately. - The album download is the frontend loop, not the Rust command the reference registered and never called. Sequential, concurrency 1, cancellable, and a failed track does not abort the album. - Both prefs are read at runtime, not merely written. `show_purchases` is the master gate and `nav_tb_purchases` only relocates the entry to the title bar; both default false, so Purchases still ships hidden. - Scanned local rows keep their raw `qobuz_purchase` source so the gold badge survives in list mode as well as grid, while still classifying under the Offline source filter. Remote feed rows deliberately stay `qobuz`: stamping them would badge every purchase the user merely OWNS as locally downloaded. Defects fixed after the screens were written, none of which any test could have caught: - `QbzPurchases.boot()` was called nowhere. Without the Qt-thread hop every publish is a silent no-op, so both screens would have stayed permanently empty with nothing logged. The cause was an ownership gap rather than the code: `Main.qml` belonged to no lane because the plan listed the files each lane CREATES rather than the files it TOUCHES, and "belongs to nobody" is indistinguishable from "done" until something runs. - A second download of the same album nested inside the first. The store rewrites its destination to the album subfolder after the first successful track so that Add-to-Library adds the album rather than the whole music root, and the download planner read that value first — producing `.../Album [q]/Artist/Album [q]/...`, one level deeper each time. The picked ROOT and the resolved ALBUM FOLDER are now separate fields with names that cannot be confused, with a regression test. - A tab counter could stick at zero forever with its list plainly full: the two ids calls each swallow their error, and the reference's backfill from the list response was missing. - Cancelling made the whole progress block vanish instead of showing the cancelled state, whose msgid was already translated in all eight catalogs. - Add-to-Library re-walked the entire library when the folder id it needed was already in hand. - A live language switch and a logout left the previous state behind. Deliberate divergences from the contract, each recorded with its reason: the page header is a plain `fontSection` title with no icon tile, because nothing else in this application announces itself over a large coloured square; purchase download status travels inside the album document rather than on the shared cache channel, which is keyed by track id alone and would let the two features overwrite each other on the same row. Gate: release build clean, QML audits 278 files / 37 bridges, `cargo test -p qbz-qt` 398 passing, offscreen smoke green with zero QML complaints. Not verified, and cannot be from here: every populated screen. This account owns nothing, so only the empty states have ever rendered. cc	2026-08-16 11:54:05 -06:00
vicrodh	e6c058c2f2	feat(qt): immersive shader scenes — RHI items, scene menu, GL link pairing ... Port the immersive GPU scenes: Plasma, Tunnel, Aurora, Ambient, Spectral Ribbon and Line Bed as QQuickRhiItems/ShaderEffects under a pulse-driven ShaderSceneLayer, plus the Qt-only Tunnel Flow (Tauri Canvas2D port) fed by the Viz16 stream. Scene rows live in the header view menu (no Off row); g cycles the ring. A fresh immersive open defaults to Split > Lyrics (owner ruling). OpenGL link fix (owner smoke: Tunnel black with "uniform _22 declared as type buf and type buf"): every ShaderEffect fragment with its own uniform layout now ships a paired vertex stage declaring the identical block — the shared spectrum.vert only ever linked under Vulkan. RHI hardening: render pass descriptors on the ping-pong targets (the Tunnel Flow segfault / Plasma dead window), mirrorVertically tied to the backend (!== OpenGL), ribbon sub-uploads carry setSourceSize. km	2026-08-16 08:22:57 -06:00
vicrodh	8bd02e35d3	feat(qt): custom-theme editor, artist portrait, playlist rail, About/What's New and diagnostics ... Five surfaces the Qt frontend was missing, landed together because they share five wiring files (build.rs, main.rs, shell_bridge.rs, AppShell.qml, HeaderBar.qml) and splitting them would produce commits that do not build. ARTIST PAGE - The Playlists section used a hand-rolled Rectangle delegate: a MouseArea with no onClicked, and a RoundedImage with no fit:, so the default crop blew an 800x380 playlist banner up inside a 200x200 box and showed the middle 47% at 2.1x. Replaced by the real cards/PlaylistCard.qml — already live on five other surfaces — mounted in a new views/PlaylistRail.qml modelled on SectionRail. ArtistPlaylist publishes the five roles the card reads. - The portrait gains what the album cover has: the right-click menu the Slint reference already has (Add/Change/Remove image, Open in browser, Save as…) and the lightbox this port invented for albums and playlists. Custom images are keyed by artist NAME into the same custom_artwork.json the Slint build writes, so they round-trip between the two. - CoverLightbox is now aspect-aware. It forced a square box on the premise that covers are square; artist portraits are not (1080x720 measured in the cache). - Removing an override invalidates the pipeline's resolved path for that url: artwork_qt::cached_path consults the override FIRST, so coverMap held the custom file and the header kept showing the picture the user had just deleted. - artwork_qt::local_path is the inverse of file_url. trim_start_matches("file://") is not: it leaves the percent-escapes in place, so any path holding % # or ? came back as a name that does not exist on disk. - One new msgid, "View image", in the seven non-en locales — matching its sibling "View cover", since en carries none of that family and falls back to the msgid. CUSTOM THEME - The editor, the colour picker and the swatch grid, ported 1:1 from AppearanceSettings.slint and ColorPicker.slint. The 11 editable base tokens, their expansion into the full 55-value palette and the on-disk format all stay in the shared qbz-theme crate, so a theme authored in the shipping Slint build already rendered here and now round-trips both ways. - Hue is normalised 0..1 at every Qt.hsva boundary; the reference stores 0..360, and porting the number instead of the domain would render every swatch red. - The first-selection seed is captured BEFORE set_theme persists the slug, because current_slug() re-reads it from disk — a seed taken afterwards would resolve "custom", find no file and snapshot the default it was meant to replace. - The in-memory base is dropped when the theme row enters "custom": it is memoized for the life of the process and filled at bridge construction, so a process that booted without the file would keep serving the OLED default even after the shipping Slint build wrote the user's theme. - The disk write is debounced to drag-end and atomic; the reference persists on every drag frame with a truncating write, on a file the other build has open. ABOUT + WHAT'S NEW - Both modals, with their producers. render_markdown is transcribed line for line from the reference: h1 and h2 collapse to one level, an indent-0 bullet becomes a section plus a TOC entry, bold and backticks are stripped rather than styled. Text.MarkdownText is a different subset and would have rendered a different document from the same source. Pinned by tests, including the real 2.0.2 body. - The codename is a single const, so the release checklist has one Qt-side place to bump. DIAGNOSTICS - The panel in Settings > Developer, the Report an Issue modal and its menu row. - The log bundle carried eight hand-built header fields where the reference carries about seventy, so every issue filed from a Qt build arrived with no kernel, no distro, no install method, no GPU, no exclusive-mode / DAC / sample-rate state and no playback context. The report is injected INTO qbz_log::bundle rather than replacing it, keeping the <details> wrapper that makes a pasted bundle readable. - The GTK / WebKit / GSK / GDK rows are CUT. In a Qt process those libraries are not mapped, so their runtime column can only read "—", and their saved column would come from a graphics.json this binary never reads or writes — foreign state presented as this app's configuration. SHELL - The four always-on-top overlays (toast, tooltip, art preview, immersive) relied on declaration order and carried no z, so any z-bearing modal buried them: a toast raised by a background event behind an opaque panel is never seen. They now sit in a band above the modals, keeping their relative order. - build.rs asked cargo to watch ../../.git/HEAD, which does not exist in a git worktree (.git is a file). Cargo treats a missing rerun-if-changed target as always-dirty, so the whole build script — per-shader qsb, the recursive asset sweep, cxx-qt/moc codegen — re-ran on every cargo invocation. Verified: cargo test -p qbz-qt 343 passed, cargo test -p qbz-library 83 passed, qml_singleton_xref and qml_resolution_audit clean over 35 bridges and 265 QML files, and qmlcachegen compiles every one of them. Smoke-tested by hand. Contracts, recon and adversarial reviews: qbz-nix-docs/qt-frontend/2026-08-14-six-item-round/ cc	2026-08-15 00:52:25 -06:00
vicrodh	016eb3cd23	feat(qt): artist scene, musician page and the shared scene-discovery engine ... Both views were absent from the Qt frontend, not partial. This lands them together with the core engine they need and the two entry points that reach them. - qbz-core gains scene discovery ("artists from the same place"): a cancellable run with a phase for the progress label and a typed SceneDiscoveryError, so a view can tell offline, all-upstreams-failed and an honest empty result apart. CancelToken, ScenePhase and SceneDiscoveryError are re-exported for frontends. - qbz-integrations: MusicBrainz location resolution plus its cache layer. - qbz-qt: ArtistSceneView with its three scene components, MusicianPageView and MusicianModal, backed by artist_scene_qt.rs, musician_qt.rs and the two bridges. The five-branch musician dispatcher is wired to all six of its consumers. Both scene doors are live: the sidebar location link and the overflow row that shipped grey with action: "stub". - Translations: the new msgids in all eight locales. Three defects fixed on the way, all with the same signature — a comment asserting a mechanism that does not exist: - Volume opened at 100 %. The comment claimed the poll loop mirrored it from the engine; now_playing::set_volume has two callers and neither runs in a local session. - mbAvailable was documented as "MusicBrainz enabled AND resolved to an MBID" while being assigned from the opt-in alone. Consumers now test the MBID. - Session restore could not resume from a cold cursor ("cannot resume - no audio data available") for want of a has_loaded_audio() guard. Investigation in qbz-nix-docs/qt-frontend/2026-08-14-cold-cursor-resume.md. Contract and evidence: qbz-nix-docs/qt-frontend/2026-08-14-artist-scene-musician/00-CONTRACT.md, which wins over specs 01..09 and records 20 deliberate divergences from the reference in section 6. cc	2026-08-14 19:25:11 -06:00
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	2026-08-13 13:01:32 -06:00
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	2026-08-11 13:59:24 -06:00
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	2026-08-11 11:26:50 -06:00
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	2026-08-10 20:24:25 -06:00
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	2026-08-10 17:16:18 -06:00
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	2026-08-10 17:15:53 -06:00
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	2026-08-10 17:05:56 -06:00
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	2026-08-04 09:41:37 -06:00
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	2026-08-04 08:43:02 -06:00
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	2026-08-04 04:15:09 -06:00
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	2026-08-04 02:47:56 -06:00
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	2026-08-04 02:28:57 -06:00
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	2026-08-03 23:23:24 -06:00
vicrodh	87c20fce8f	feat(qt): kiosk zone-navigation model (QbzKioskNav) ... The Qt counterpart of Slint's KioskNavState global (state.slint:3511-3536) and the five movement functions on the kiosk shell (KioskShell.slint:95-200). The state machine lives in kiosk_nav_qt.rs as a plain Rust model so cargo test can reach it: the contract names the zone model as the piece a lazy port silently degrades, and it is invisible to every static check the gate runs -- no types to resolve, no bridge members to cross-reference, and a click never sets nav_active, so the whole model can be dead while every screenshot looks right. 22 tests cover the transition table. A QML pragma Singleton was not available: the cxx-qt-build generated qmldir cannot mark singletons (theme/QbzTheme.qml:12-13), and an object rooted in the shell cannot be reached by views mounted inside a Loader without a parent-chain walk. Two departures from the Slint original, both deliberate: - columns is clamped to >= 1. Slint's Math.mod(x, 0) is NaN and the comparison quietly fails; Rust's % panics, so a view publishing 0 would take the app down. No behavioural change for any legal value. - Up from row 0 of a view with no tab strip goes to the rail. Slint runs min(tabs - 1, index - tabs), which for tabs == 0 is min(-1, 0) = -1; no item carries index -1, so the ring vanishes until a second Up. Live on KioskAlbum (:46) and KioskArtist (:24), both of which publish tabs = 0. No boot() and no CxxQtThread: nothing in Rust ever publishes into this object, so a hop would be a dead function that looks load-bearing. cc	2026-08-03 22:15:28 -06:00
vicrodh	fa433d465b	refactor(qt): extract search_bridge.rs from the QbzBridge god-object ... QbzBridge carried five domains (Settings, Search, Playlist, Genre filter, Discover config); its own boot() comment called the split "TEMP (phase 23)". TRACK-RULES section 2 requires one cxx-qt bridge per domain. This moves the Search domain out verbatim, ahead of the cortinilla parity work, so the refactor and the behaviour change stay separately reviewable. QbzSearch (search_bridge.rs) takes 7 properties and 11 invokables. Two deliberate changes ride the move: - selected_index -> cortinilla_selected_index. It is cortinilla-only state and the bare name on an app-wide singleton is a collision hazard. - cortinilla_scroll_y f32 -> f64, unifying with the immersive twin in immersive_bridge.rs, which was already f64. cortinilla_query is declared here but not yet wired; C2 wires it, which is what makes Enter carry the text the user actually typed instead of the last successfully loaded payload's query. Every Rust writer of a moving property was re-pointed BY HAND, never by regex over the multi-line ui() closures: the seven crate::ui( sites in search_qt.rs plus two that live outside it and that the QML-only xref audit cannot see - settings_qt.rs (the live Settings > Appearance path) and main.rs toggle_intelligent_search. All 48 QML consumer sites across Cortinilla.qml, HeaderBar.qml and SearchView.qml were updated, including the one Connections block, whose onSelectedIndexChanged handler was renamed with its property. A stale 6.0 base in flat_index_content_y is left in place and annotated: it mirrors a Flickable viewport margin rather than content space, so every row reports 6px low. C4 corrects it with its unit test; this commit is a move. Contract: qbz-nix-docs/qt-frontend/2026-08-03-cortinilla-parity, commit C0. Gate: build clean (no new warnings), 256/256 tests, qml_resolution_audit 214 files, qml_singleton_xref 28 bridges with QbzSearch resolving, offscreen smoke 0 complaints + home published. cc	2026-08-03 15:24:25 -06:00
vicrodh	07b0ba818e	feat(qt): keyboard shortcuts cheatsheet and customize editor (B3) ... km	2026-08-03 14:29:49 -06:00
vicrodh	0cca9abc58	feat(qt): hotkeys core, QbzHotkeys bridge, shortcut i18n catalogs (B1) ... km	2026-08-03 11:33:14 -06:00
vicrodh	c0f4d2f1b7	feat(qt): immersive player bar and search cortinilla (B5) ... km	2026-08-03 09:33:02 -06:00
vicrodh	0b6e8ed7c9	feat(qt): immersive split view, lyrics, track info, suggestions, queue tabs (B4) ... km	2026-08-03 08:07:24 -06:00
vicrodh	46c1c42408	feat(qt): immersive atmosphere and focus panels (B3) ... km	2026-08-02 22:25:19 -06:00
vicrodh	8bc255269d	feat(qt): immersive root overlay, header band, entry/exit chrome (B2) ... Root overlay self-gated on QbzImmersive.open with the load-bearing click-blocker, 6s auto-hide with the VNC hover-storm delta guard, fullscreen guard, exit paths 2-4, seek arrows, the header band (view menu in Slint order, search field on the inert B1 surface, window controls with the first FullScreen write in the Qt frontend), the ViewModeMenu Immersive row live, Shift+I in Main.qml with the text-input gate, QbzLineEdit fieldActive seam (D16). Panels are stubs; B3/B4/B5 replace them. RFB evidence in scratchpad/immersive-b2/. km	2026-08-02 20:48:40 -06:00
vicrodh	b5298b78bd	feat(qt): immersive bridge, viz two-source enable, coverflow payload (B1) ... km	2026-08-02 18:27:54 -06:00
vicrodh	ec8588687b	feat(qt): artist page parity - load more, section sort, discography ... The release-section "Load more" fetched a page and appended it to a structure no view ever re-read. The handler pushed IN PLACE into the object behind `readonly property var artist: JSON.parse(QbzArtist.artistJson)`, and the releaseSections projection returned that same array on the unfiltered arm, so both Repeaters were re-handed the identical reference and nothing was dirty. The tree's own rule, written in cards/PlaylistCollage.qml: rebind requires a NEW object reference. A second bug sat on the same path - the artist document republishes progressively (stories, then each MusicBrainz section as it resolves) and every republish re-runs the parse, wiping anything appended, so fixing only the first would have left a bug that looks random. Both pre-existing; the in-flight placeholder added earlier is what made an always-silent no-op visible. Appended pages now live in an overlay keyed by release type. It survives a republish, emits new arrays so the Repeaters rebuild, dedupes by album id, carries the reference's 4-page cap per bucket (artist.rs:718-720, which hands off to the discography page beyond it), and is guarded against a page requested on one artist landing on another's grid - releaseSectionReady carries no artist id and every artist has an "album" bucket. "See discography" was a pointer-cursor MouseArea with no onClicked under a POC-NOTE saying the page was out of scope. ArtistReleasesView.qml + artist_releases_qt.rs port ArtistReleasesView.slint: infinite scroll rather than a button, plus the loading, error-with-retry, empty and offline arms. The album page's "More from <artist>" view-all is a second door to the same page. Its paging offset counts what the SERVER returned rather than the rendered row count the reference uses: blacklist filtering and id dedupe make the rendered count smaller, so the reference re-requests seen rows and skips the tail whenever the blacklist is non-empty. The per-section sort was a dimmed Rectangle with no MouseArea, under a comment asserting no seam existed. It is now a real QbzSelect with the reference's five options and index mapping, persisted per release type in artist_prefs. Choosing "Default" after a sort does not restore the server order until the page reloads - that is the reference's behaviour (album_map.rs:262 is a bare no-op arm and resort sorts the live model), kept deliberately rather than diverged. Also, two visual fixes from the same round that share these files: Popular Tracks drew its cover at radius 8 where the shared rows/TrackRow.qml uses 4, and the album page's rail mounts said `width: parent.width` inside a Column with 32px padding - QML padding shifts children without narrowing parent.width, so the rails hung 32px off the right and the right page chevron landed outside the window. Carries scripts/qt-diag.sh, which has been sitting untracked since the rendering round: it answers "which backend is this actually running on" from a real graphical session, refusing ssh and refusing offscreen because either would answer the wrong question. That refusal is the point - the doctrine it disproved ("shader effects render nothing on this port's software path") came from an offscreen observation, and offscreen forces software by definition. cc	2026-08-02 16:34:58 -06:00
vicrodh	6f4fb72f57	feat(qt): shared QbzLoadMore with an appended-page skeleton ... Five hand-rolled "Load more" buttons existed in three visually distinct shapes. One control now carries all three arms, so the idle appearance of every site is unchanged. While a fetch is in flight it draws a QbzSkeleton composite BELOW the button - the owner asked for below - which is one animator for the whole placeholder row, with settleMs 8000 so a fetch that never returns stops shimmering instead of pulsing forever. Idle it costs nothing: the block lives behind an inactive Loader, so mounting the control changes no pixel on a page nobody has clicked. SearchView had half of this already, and the half it had was on the wrong side: a skeleton ABOVE the button, on the albums tab only. All four tabs now use the control, each with its own real cell pitch and row shape rather than the albums tab's numbers copied across. AlbumCollection gains an opt-in tail fade (armTailFade) for the arrival half of the round. It is keyed by the set of ids on screen at click time, not by an index threshold: the label page sorts its grid, and under any order but newest a fetched page interleaves, so a threshold would re-fade albums that never moved - the flicker the fade exists to avoid. It also lets grouped mode fade, where there is no flat index at all. Inert unless a host arms it, so Discover Browse and Play History are bit-for-bit unchanged. cc	2026-08-02 16:32:24 -06:00
vicrodh	c8559a68b3	feat(qt): port Qobuz Connect — service, flyout, routing and touchpoints ... Full-parity port of the Slint QConnect integration per the contract at qbz-nix-docs/qt-frontend/2026-08-01-qconnect-port/00-CONTRACT.md (three adversarial review rounds on the spec, §12 trap sign-off PASS on both halves, RFB-verified incl. a real cloud connect, live session owner-tested). The shared crates are consumed verbatim — zero backend changes. - adapter quartet: qconnect_transport_qt (credentials, identity on the shared qconnect_settings.db), qconnect_engine_qt (start_track_stream fallback chain + feeder helpers + CMAF cursor sync), qconnect_event_sink_qt, qconnect_qt (the facade: connect/disconnect recipe, controller routing, echo guards, offline parking B12, startup auto-connect) - QbzQConnect bridge singleton + on_session_entered wiring; one shared flyout for both bars (tooltip on the large bar only), Developer > Connect diagnostics modal, device-row glyphs, settings rows live - poll loop: peer-reflection branch before cast, ~2 s renderer reports, sync-on-add on every Qobuz-castable add path - routing: cast → QConnect → local (mute QConnect-first), play arms after the set_queue funnel, reorder cloud arm with no local fallback, volume/mute/seek remote-first - touchpoints: lyrics remote anchor, scrobble guarded / Discord unguarded, cast suspend/resume, volume-lock lifted when remote km	2026-08-01 20:23:38 -06:00
vicrodh	35508b5f87	fix(qt): the defects found smoking the playlist and My QBZ round ... Un-following a Qobuz playlist left it in the sidebar and in My Library. toggle_follow called unsubscribe_playlist and settled the ownership snapshot and stopped there, so the row only left at the next full refetch. Both surfaces are patched directly now, in both directions: following from a card buys the metadata with one get_playlist rather than re-reading getUserPlaylists, which lags the write. The un-follow collapses a hearted-and-followed playlist to the one row the next load will actually produce instead of dropping it, because the local heart is a library.db flag that survives the unsubscribe — removing every row made it vanish and come back, which is the original complaint wearing the other shoe. The Plex mark on album cards was a hard-drive glyph tinted accent — a blue hard drive — and the three Qobuz kinds drew no badge at all. The badge now ports discover/AlbumCard.slint:326-354 exactly: 24x24 at radius 4 pinned bottom-right with a 6px inset, plex-logo untinted at 16, qobuz-logo at 18 (22 for a download), the purchase arm gold on its amber chip, hard-drive white at 14 for local only. The brand marks are plain Images: routing them through QbzIcon floods every pixel with the tint and flattens a logo to a silhouette. SourceIcon moves to controls/ since it is no longer local-only, and every other surface drawing a hard-drive was audited against its .slint. The local album detail loses the two nav chevrons above the art. They are a Tauri-era leftover from before the app had global navigation. My QBZ used a bespoke card in the grid. MyQbzDetailCard is deleted and the standard cards/AlbumCard is mounted with its overlay. localMode bundled four separate things — action routing, the heart, the pin and Block this album — so a multi-source container had to switch all four off together; it is split, and the catalog affordances now follow the ITEM. On a Qobuz cell the heart works through the shared favourite seam; on a track, playlist, local or Plex cell it is absent rather than dead. Row covers carry two rungs: the list keeps _50, the grid gets _600. Not the _230 that would merely cover a 200px card — the complaint was that the cover reads softer than a normal AlbumCard, and a normal AlbumCard is fed image.large, which IS _600. _200 is not a rung the CDN serves at all (it answers 404). The My QBZ grid sets reuseItems, and AlbumCard assigns to its own isFavorite and isPinned when toggled, which destroys the binding that fed them. A recycled delegate therefore showed the previous row's heart and the click added the new album while the glyph said remove. Restored with the Qt.binding idiom this port already uses on TrackCard, PlaylistCard and TrackRow. The details view no longer force-opens every row on entry, and the per-row open state persists. Library > Artists showed placeholders for nearly every portrait. The side panel never reported its artwork window — the one caller of libraryArtworkWindow is LibraryView.reportWindow, and the panel had no report call at all, so no key ever reached the resolver and artMap stayed empty for its rows. The rail now reports through that same path, with the section-header sentinel reportWindow already skips. Note the reference has no portrait fallback either: an artist Qobuz serves no image for is a placeholder on both sides. cc	2026-08-01 15:29:03 -06:00
vicrodh	a16cf56c86	feat(qt): playlist manager, folders, importer and the Library parity round ... Ports the whole playlist-organisation domain, which had no counterpart in this frontend, plus the Library work the owner asked not to defer. Playlist Manager. New controller (playlist_manager_qt, _rows, _ops) over the already-ported folders_qt repository, which until now had zero consumers. Grid, list and folder-tree modes; sort, filter and search; folder cards and chips; drag reorder and up/down arrows. Reached from the sidebar's "..." menu, whose New folder / Manage playlists / Import rows had been rendering dimmed and inert behind a comment saying the seam did not exist. Folders. QbzFolderEdit plus the create/edit modals and PmFolderIcon: preset or custom-image icons, colour, hidden flag, delete. Deleting a folder nulls its LOCAL members' folder_id explicitly, because the app keeps the foreign_keys pragma off, so the schema's ON DELETE SET NULL never fires for them. QbzPlaylistEdit. One shared rename/description/delete editor replacing the inline popup in PlaylistView. Three corrections the old path had wrong: the description is carried through a rename instead of being written as NULL, a FOLLOWED playlist routes to unsubscribe (playlist/delete returns 200 and silently no-ops on a playlist you do not own), and the post-delete back navigation is conditional on actually being on that playlist's page, so deleting from the manager no longer navigates you off it. Importer. Spotify / Apple Music / Tidal / Deezer, over the shared qbz-playlist-import crate. Picker local mode. The reference's four-case matrix — target local or Qobuz, payload local refs or Qobuz ids. Local playlists list unconditionally and Qobuz ones only when online. Local refs onto a Qobuz playlist write the library.db sidecar at next_playlist_sidecar_position(pid, qobuz_count); the 0-based enumerate the reference used before collided slots and lost rows. The carried payload can no longer be parsed as a catalog id when it is a library row id. Unblocks the local bulk add-to-playlist. Library. A-Z jump strip, Albums list mode, Artists side panel, per-tab persistence and multi-select. Preferences land in the same <data-dir>/qbz/favorites_ui.json the shipping build writes, so switching between the two frontends keeps them. LibraryView is split into views/library/ on the way past 1800 lines. Local library. Group-by now persists; playback queues the order on screen rather than the SQL page order; switching album-identity mode invalidates the Artists tab; artist matching folds diacritics and compares normalized credit parts, so "Air" stops listing "Airbourne" and "Beyonce" stops being two artists. Offline. activate_offline never persisted a last-user marker, so every per-user path resolved to None and all local reads came back empty; a session that started offline saw no local playlists at all. The sidebar's load-once latch was function-local and therefore unreachable from the logout reset, so a second login never rebuilt the tree. Both are session-scoped now, and the sidebar Refresh row runs the local-safe verb instead of being dimmed with no way to recover. Also fixes, found while verifying rather than reported: artwork derivatives were written straight to their final path, so a QML Image resolving one mid-encode opened a truncated png and Qt cached that failure against the URL for the rest of the session; Library's track group separators referenced a Component declared in another delegate's scope and could never render; the genre filter was drawn on Tracks and Albums but applied only on All; an All-feed row called a player method that does not exist; and the sidebar's drop-hot highlight used Slint's #RRGGBBAA literals in Qt's #AARRGGBB slot. 17 new msgids across all 8 locales. cc	2026-07-31 22:10:19 -06:00
vicrodh	01f3819da1	fix(qt): the now-playing audio button opens the Normalization + Gapless flyout, and reads the real state ... It was not a flyout and it did not read the persisted value, which together made normalization impossible to turn off. - `shell/AudioSettingsMenu.qml` (new) ports the `audio-menu` PopupWindow both bars mount (PlayerBar.slint:686-705, PlayerBarSmall.slint:635-712): 252 wide, two 44px ToggleRows with 12px side padding and a 12px gap to the switch, label text-primary 13px over hint text-muted 10px at spacing 1 — the numbers are PlayerBar.slint's file-private ToggleRow (:80-115). - `PlayerBar.qml` had `normTouched` / `normLocal` and toggled normalization on click. `NowPlayingBarSmall.qml` was worse: `property bool normOn: false`, local state that started at false no matter what was persisted, so the FIRST click on that button always sent `normalization = true`. Both now just open the flyout. `active` mirrors normalization on the full bar and is neutral on the Small one, which is the reference's own asymmetry (PlayerBarSmall.slint:628-630 states it out loud). - Gapless had no now-playing control at all. The local shadow state existed because the document never carried the truth: `publish_settings()` ran ONLY on `navigate_to("settings")` and on a language change, and no handler in `settings_qt` ever republished. So until the user opened Settings the shell read an empty document, the control drew OFF while the backend had it ON, and the first interaction wrote the wrong value back. Slint has no equivalent hole — `SettingsState` is a global seeded at startup. So: seed the document at shell entry, and republish after every audio apply. Verified by effect, not by diff — the boot log now reports the snapshot as 5006 bytes carrying the persisted `normalization` and `gapless`, before any view is opened. Seeding at shell entry also seeds the now-playing stamp's two output LEDs, which `publish_snapshot` derives from the same audio settings. cc	2026-07-30 00:43:04 -06:00
vicrodh	acf23abc9b	feat(qt): port the My QBZ domain — mixtapes, collections and the discography builder ... The Slint reference is 3,885 lines of .slint across ten files plus 5,514 lines of Rust glue over the shared qbz-mixtape crate. None of it existed in the Qt port; the nav flyout carried a "GAP:" comment and two disabled entries. Rust (flat in src/, per QTBUG-93443): three bridges rather than one God-object — QbzMyQbz (grids + detail + edit + cover + mix), QbzMyQbzAdd (the app-wide picker, kept apart so TrackRow, PlayerBar and the Local Library bulk bars cannot couple to detail state) and QbzDisco (artist-scoped, reached from the artist page, never coexisting with the MyQBZ views). Twelve controllers behind them, ported function by function from myqbz{,_detail,_play,_edit,_cover,_mix, _add,_prefs,_view_prefs,_builder}.rs. src/toast_qt.rs finally gives the port a toast host. QML in qml/views/myqbz/ plus four global overlays. Reused rather than forked: TrackRow, TrackListHeader, QualityBadgeFull, QbzContextMenu, CardMenu, QbzCheckbox, QbzSkeleton, QbzScrollBar, RoundedImage. LocalSegToggle and LocalMultiSelectBar are PROMOTED to controls/QbzSegToggle and controls/QbzMultiSelectBar (they were ports of shared Slint primitives that MyQBZ needs too) — a move plus an import fix, with the Local metrics kept as the defaults so the four Local Library toggles are byte-unchanged and the MyQBZ call sites pass ViewToggle's own numbers. Every list is windowed at write time: GridView/ListView with reuseItems and a cacheBuffer, and expanded mode is an outer recycled ListView whose delegate is a Column + Repeater, because a nested ListView inside a recycled delegate cannot size itself. Single-row updates patch in place; replacing the array resets contentY and throws the user to the top. Shared controls gained the arms the new views need, with the numbers taken from the .slint and not guessed: SettingsButton (btnHeight / minWidth / trailingIconName), QbzEmptyState's four metrics, QbzSelect's `sm` variant (30px, r6, no outline, 12px label, 14px chevron, 40px narrower — QbzSelect.slint:74-148), QbzContextMenu.openBelowLeft, and QbzLineEdit gains a distinct `accepted` signal fired on ENTER ONLY: a modal that submits on `committed` submits TWICE, because closing it removes focus and fires `committed` again — a rename would have run twice and a create made two collections. clearSearch() no longer assigns root.text either; that JS write destroyed the call site's binding permanently, so Rust could never re-seed the field after one click on the X. SourceIcon gained the plain "qobuz" arm it was missing, which had every Qobuz row in a collection drawing itself as a local file. Two icons (turntable, image) are baked from the Slint masters into the seven full tint dirs and registered in MASTERS; three more (circle-check-big, circle-alert, triangle-alert) back the toast. A missing tint dir or glyph renders nothing and logs nothing, so this class never surfaces in a build. cc	2026-07-29 21:23:45 -06:00
vicrodh	0c159c141c	feat(qt): For You gains Qobuz Mixes pages, Artist Spotlight and Radios ... Ports the three sections the tab was missing, against the Slint implementation rather than invented: the section rails, the cards, and the mix landing page with its navigation seam so back/forward behave. The mixes reuse the shared crates for their requests -- the Slint app already makes them, so nothing new talks to Qobuz here. Also carries the qt-run.sh portability work needed for the Mac mini: `free`, `nproc`, `pgrep` and `timeout` all differ or are simply absent on BSD/macOS. Two of those bit during the first Mac build. `pgrep` exits 1 when it matches nothing -- the normal case -- and under `pipefail` that killed the script before a single line of output, which reads exactly like a build that did nothing. And `timeout` does not exist on macOS at all, so the smoke produced a one-line log over which the grep cheerfully reported "0 QML complaints": a test that never ran, rendering as a pass. The smoke now fails outright on a log that short. cc	2026-07-29 16:26:11 -06:00
vicrodh	8b26cda6f6	feat(qt): floating album-art preview on now-playing cover hover ... Port of ArtPreviewOverlay.slint: hovering the small cover floats a 220px preview above it. Missing in every bar mode except Large. Non-interactive and mounted last in AppShell, both for the reason the .slint records: the original used a PopupWindow and it stole the hover from the trigger, so the preview flickered open and shut. An overlay that cannot receive events cannot do that, and clicks pass through. The anchor rides QbzShell like the drag ghost does -- trigger and overlay are in different files with no shared id. cc	2026-07-29 00:56:12 -06:00
vicrodh	c56fab3c4e	fix(qbz-qt): covers were never actually resized, plus the adversarial parity round ... **The scaled-cover fix from the last round produced nothing.** The seam ran — 462 requests in one offscreen smoke — and wrote zero files, so the owner was right that nothing improved. The artwork cache stores files as `.img`, and `image::open` picks its decoder from the EXTENSION, so every call failed silently. Sniffing the content instead yields 101 derivatives on the same run. The header atmosphere had the identical bug and had therefore never produced an image either, which is why the flat fallback was all anyone ever saw. Reported as fixed last round without checking that it ran. Verified by effect this time, not by reading the diff. The rest came through an analyse / refute / implement / verify pipeline, and the adversarial passes earned their keep: - The sidebar mini rail: icons sat left of centre because their slot kept its fixed 24px width while the rail collapsed, so the hit target was rectangular and off-axis. The rail narrows, rows are square, and the mini state gains the folder flyout and tooltips it never had. The reviewer caught a comment claiming the width change was a one-token revert when it is two — corrected rather than left to mislead the next reader. - Playback context now travels from every producer, not the handful that happened to stamp it. - Collapsible per-tab search in Library, and label artwork. - Every View-all destination Home offers, plus the label page and its releases. - Collapsing the sidebar drops a Large bar back to New, live, without overwriting the user's persisted preference. cc	2026-07-29 00:06:34 -06:00
vicrodh	2a5b5ac16e	feat(qbz-qt): theme-following icons, the real header atmosphere, sharp covers, playback context ... **Icons follow the theme.** The bakes are frozen dark-palette hexes, so on light themes secondary, muted and accent were simply wrong, and accent was wrong on any theme whose accent is not #4285f4. Slint recolours at render time, which this path cannot do — so the tint is generated once per colour into the cache and loaded through the same Image+svg path the bakes already use. No effect, no shader, so it cannot hit the "renders nothing on software" failure. The sweep found the part the diagnosis had missed: "primary" was two meanings welded together — max-contrast-on-theme-surface, and literal white for glyphs on hosts that are dark under every theme. Remapping it globally would have painted dark glyphs on dark scrims in fourteen places. The vocabulary is split instead, with "primary" left as an alias so nothing changes until it is migrated deliberately. **The album header gradient was Slint's fallback, not its design.** Slint paints a blurred artwork field and only falls back to the flat two-band gradient when that image is unavailable; the port shipped the fallback. The field needs no shader — it is a 128x128 image, so the pipeline ports verbatim: the cover down to 8x8, back up to 128, blur, colour adjust, vignette. The 8x8 step is the look, not an optimization; everything after it works from eight pixels of colour, which is why it reads as atmosphere rather than as a blurred cover. It comes out of the same decode that already produced the flat tint. **Covers were point-sampled.** Canvas drawImage does not filter when it scales, measured at RMSE 0.000 against a nearest-neighbour reference — a 600px cover in a 200px cell throws away eight of every nine pixels, and the error is aliasing, not softness. Rust now produces a derivative at the drawn device size so the draw is 1:1 and there is no resample at all. **The now-playing context stack.** It had no Qt counterpart: the model carried context_kind and context_id, some builders stamped them, and nothing ever read them back. The album path only appeared to work by coincidence, because the glyph was hardcoded to open the album. Plus: Discover's missing rails with real play history, Recommendations on the integrations, queue drag reorder, and the playlist detail collage. cc	2026-07-28 21:12:31 -06:00
vicrodh	a1c771c39e	fix(qbz-qt): row buttons, cover triggers, light-theme contrast, flyouts, genre filter ... **Track-row buttons did nothing.** Declaration order is z-order in QML, and the row-wide MouseArea added for right-click was declared last — so it covered the heart, cloud and menu buttons and swallowed their presses. propagateComposedEvents cannot rescue that: a press is not a composed event, which is why only the row's own double-click still worked. **Covers appeared only after a scroll.** Three compounding defects, not one. The window report fired on contentY and on model change, both of which happen while the tab body is still hidden behind its loading flag, so the report that mattered hit the not-visible early return and was discarded with nothing to re-fire it. The debounce reset on every change, so a burst of mount-time reports kept pushing its trailing edge out. And a single pending slot meant that when two surfaces are mounted at once — the artist rail and that artist's grid — the second overwrote the first, so one pane was never requested at all. Eviction had the same shape: each report deleted everything outside its own array, so the two panes deleted each other's covers. **Latest release had no cover** because the artist page's collector skipped it, along with Appears On and the playlists strip. **Light themes.** The mechanism is Slint's, from 2.0.2 and issue #638: the on-surface arm on circle actions, header-light deciding the header foreground only when a dark backdrop is actually painted, and the circular backing behind the track-row play glyph. Ported as specified rather than approximated. Two icons rendered in their SVG's own colour because they pointed at the raw asset instead of a baked tint — a sweep found the rest of that class. **Navigation flyouts** exist, one component serving both the sidebar and the header nav modes. **Filter by genre and the Discover sort now work**, everywhere the control is drawn. The genre ids were already a parameter on the discover fetch that the port always passed empty. cc	2026-07-28 19:55:33 -06:00
vicrodh	9ab3d7db96	fix(qbz-qt): local albums route to the local view, and the detail-page parity round ... **The empty album view.** Opening a local album from Library "All" landed on a blank page. The mixed feed hands Qobuz and local albums to the SAME card, and the card always called the catalog open — so a local id, which is a group key or a filesystem path, went to /album/get and came back 404. It was in the owner's log before this round as `get_album(/mnt/nas/…) returned 404`; what changed is that clearing the stale document turned "shows the previous album" into "shows nothing", which is how it surfaced. Routing now happens in open_album itself, using the predicate the feed already uses to route favourites, so every call site is covered at once instead of card by card. **Header atmosphere.** Both detail pages get Slint's two-band gradient, tinted from THIS page's artwork through the ported header_tint — not the now-playing ambient triad, which is a different subject with a different algorithm. **Artist page.** The catalog/library toggle existed but was broken: a hand-rolled copy of the shared tab bar whose delegate walked the wrong parent chain, so it threw on every evaluation and never took its active colours. It now mounts the shared control. Added the JUMP TO label, the tab-strip search with the client-side filter it drives, and the year under release-section albums. The Network panel ran the full window height and never auto-opened; it is bounded below the tab strip now and opens unless the content is constrained, as Slint does. The action circles were the wrong size with the wrong glyph colour and no overlay arm — which would have left them dark-on-dark once the gradient landed. **Quality in track rows.** The column rendered a bare tier; it carries the badge now, in the one shared row component every surface mounts. playlist_qt was the only producer not emitting the bit-depth line. **Skeletons hand over instead of disappearing.** They cleared when the PATH arrived, but the image still had to load and rasterize after that, so the placeholder vanished and left an empty cell. They now wait for the image to be ready. **Local covers.** Most local covers ARE already the scanner's thumbnail, but re-hashing their path produced a different filename, so each one was decoded, resized to its own size and re-encoded into a duplicate before being shown. That was most of the wait. cc	2026-07-28 19:01:25 -06:00