Joren/qbz
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
a16cf56c86f128f2d53c6f15f2ed14fd3d4aa0c1
qbz/crates/qbz-qt/qml/rows/TrackRow.qml
T
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

1014 lines
50 KiB
QML
Raw Blame History

// TrackRow — THE track list row (primitives/TrackRow.slint, POC arm
// subset), consolidated in phase 22 from FOUR copies (AlbumView
// .AlbumTrackRow, PlaylistView.PlTrackRow, LibraryView.TrackListRow,
// SearchView.SearchTrackRow). 50px, radius 8: number→play cell (pause
// swap + accent pill when it is the now-playing row — Slint-universal),
// optional 36px art cell, title+explicit / artist column, optional 220px
// album link, duration, quality (BARE QualityBadgeFull — the tier label over
// the exact bit-depth / sample-rate line), optional
// heart, optional download slot (offline column — glyph stub or reserved
// spacer until the offline cache lands, POC-NOTE), ⋯ CardMenu.
//
// item contract: { id, title, artist, artistId, album, albumId, number?,
// duration, qualityTier, qualityDetail, explicit, isFavorite, artPath? }
// (plus playlistTrackId for the remove-from-playlist arm, and the OPTIONAL
// `source` / `unavailable` a mixed-source producer carries — the Add to
// playlist gate below is the one arm that reads them). `qualityDetail`
// is the bare exact-quality string ("16-bit / 44.1 kHz"); when a producer
// does not carry it yet the badge degrades to the tier label alone rather
// than to a blank cell. `item.isFavorite` SEEDS the row's own `favorite`
// property and is never written back — see the heart block below for why a
// plain-JS-object field cannot be the live state.
//
// Arms: showArtwork / showAlbum / showFavorite / showDownload /
// downloadGlyph / showMenu / zebra / artistLink / clickPlays /
// menuShowLater / menuShowGoTo / menuShowFavorite / menuShowRemove.
// (`qualityStyle` is RETIRED — kept declared, inert, see below.)
// Signals: playRequested() (per-site play: album-scoped, playlist-scoped
// or plain), enqueueRequested(mode) ("next"|"later"|"queue"),
// removeRequested(), bodyDragStarted(index) (fired BEFORE the shared
// dragStart — the #589 reorder pre-hook), mixtapeRequested() (the host
// builds the MyQBZ AddItem payload), goToRequested(kind) (only when
// `routeGoToExternally` is set), playlistAddRequested() (only when
// `routePlaylistAddExternally` is set — the local-mode "Add to playlist").
// Favorite toggling, Go-to-artist/album, Share and Track info are
// identical on every site — handled internally. The row BODY is the drag
// source (6px threshold, ghost + sidebar drops in main.rs) and its RIGHT
// press opens the very same menu the ⋯ button does.
//
// --- Menu inventory vs primitives/TrackContextMenu.slint ----------------
// The .slint menu is FLAT (no separators) in this order: Play now · Play
// next · Play later · Add to queue · Create QBZ radio · Create Qobuz radio ·
// Add to library · Add to mixtape · Add to playlist · Remove from
// playlist(danger) · Share Qobuz link · Share Song.link · Make available
// offline | Refresh + Remove offline copy(danger) · Go to album · Go to
// artist · Track info. Everything the Qt bridge has a seam for is here, in
// that order; the rest is gated OFF by the `has*Seam` constants below
// rather than rendered as a row that silently does nothing.
//
// Deliberately NOT consolidated here (Slint-distinct): QueuePanel.QueueRow
// (QueueItem data + queue-op menu + press-and-hold reorder) and
// LibraryView.FeedListRow (mixed-kind feed row — inline in Slint too).
//
// --- COLUMN GEOMETRY LIVES IN rows/TrackCols.qml ------------------------
// Not in this file. rows/TrackListHeader.qml reads the same object, so the
// header of a list and the rows in it cannot disagree. If you change a
// column width, change it THERE — a literal typed back into this file is
// the exact defect the owner reported (the header laid out only the
// labelled columns, so every label sat right of the column it named).
import QtQuick
import com.blitzfc.qbz
import "../controls"
import "../shell"
import "../theme"
Rectangle {
id: root
property var item: ({})
property int number: 0
property bool showArtwork: false
property bool showAlbum: false
property bool showFavorite: true
property bool showDownload: false
property bool downloadGlyph: false
property bool showMenu: true
property bool zebra: false
property bool artistLink: false
property bool clickPlays: true
/// RETIRED and INERT. primitives/TrackRow.slint has exactly ONE quality
/// form (the bare QualityBadgeFull below) — there was never an icon/text
/// split to arm. Kept declared ONLY so the two existing call sites that
/// still assign it (AlbumView.qml `"text"`, local/LocalTrackRow.qml
/// `"icon"`) keep loading; assigning a non-existent property is a hard
/// QML instantiation error. Both assignments are listed for removal.
property string qualityStyle: "icon"
property bool menuShowLater: true
property bool menuShowGoTo: true
property bool menuShowFavorite: true
property bool menuShowRemove: false
/// Reorder arm (primitives/TrackRow.slint:87 `show-reorder`): a leading
/// 22px gutter with an up/down chevron stack. ON = this list is in an
/// order the user OWNS and can rewrite (the playlist detail under custom
/// sort; a LOCAL playlist under its natural order, whose repo `position`
/// IS that order). Default off, so no existing call site grows a gutter.
///
/// It is also the gate for `preventStealing` on the row-body drag — see
/// the DRAG vs. DRAG-TO-SCROLL block at the bottom of this file.
property bool showReorder: false
/// Ends of the list: the reference dims nothing, but a chevron that
/// renders and no-ops is the defect class this round is fixing, so the
/// first row's ↑ and the last row's ↓ are drawn disabled instead.
property bool canMoveUp: true
property bool canMoveDown: true
// Drag source arm (additive; default = the existing behaviour). The
// Local Library rows set this false: their `item.id` is a local DB row
// id, and the sidebar drop handler forwards whatever it receives to
// `playlist add-tracks` as a QOBUZ catalog id — a local row dropped on a
// playlist would silently add an unrelated catalog track.
property bool draggable: true
/// Multi-select arm (primitives/TrackRow.slint:58 `multi-select-mode`):
/// the leading play/number cell becomes a selection checkbox, the WHOLE
/// row body is a selection target, and the row's own gestures (play,
/// double-click, drag, right-click menu) stand down. Default off, so every
/// existing call site is untouched.
property bool selectMode: false
property bool checked: false
signal toggleSelect()
// Per-row artwork placeholder (see the 36px cell below). The host view
// owns the phase clock so one timer drives every row.
property bool artPending: false
property bool skelPhase: false
property int artSettleMs: 0
// Catalog-backed row? `draggable` is ALREADY the "item.id is a Qobuz
// catalog track id" predicate (the Local Library / ephemeral rows set it
// false because their id is a local DB row id — see the note above), so
// the two entries that hit the Qobuz catalog by id ride it instead of
// asking every host to pass a new arm.
readonly property bool catalogRow: root.draggable
property bool menuShowShare: root.catalogRow
property bool menuShowTrackInfo: root.catalogRow
// --- Seams the Qt bridge does NOT have yet (menu-parity round) -------
// Each maps to a TrackContextMenu.slint entry. OFF = the row is not
// built at all, never rendered-and-inert. Flip the constant AND fill the
// matching `menuAction` branch when the invokable lands; the entry then
// appears in its .slint-correct slot. Why each is missing:
// radio no radio invokable on any Qt bridge object
// songlink needs the ISRC -> Deezer -> Odesli round-trip (backend)
// offlineCache no per-track cache bridge (the download cell is a stub)
readonly property bool hasRadioSeam: false
readonly property bool hasSonglinkSeam: false
readonly property bool hasOfflineCacheSeam: false
// --- Add to playlist -------------------------------------------------
// LIVE since QbzPlaylistPicker landed. It is NOT a flat constant, because
// the entry's correctness depends on WHICH ID SPACE this row's `item.id`
// lives in — the one thing the picker's whole design exists to keep
// unmistakable (playlist_picker_qt.rs's four-case matrix):
//
// catalogRow `item.id` is a Qobuz catalog id -> openForTrack.
// localSourceRow the row carries its own source word and it says
// local/plex -> `item.id` is a library.db row id or
// a Plex synthetic id. Sending it to the Qobuz arm
// adds an UNRELATED track, so the entry is only
// offered when the HOST takes the routing
// (`routePlaylistAddExternally`, below), and is
// ABSENT otherwise rather than wrong.
// item.unavailable a stored ref that cannot resolve at all
// (playlist_qt.rs PlaylistTrackRow.unavailable);
// there is no track to copy anywhere.
//
// Ephemeral rows never reach this decision: their surface sets
// `showMenu: false`, so the whole menu is absent (LocalEphemeralPane).
readonly property bool localSourceRow:
root.item.source === "local" || root.item.source === "plex"
/// Hand "Add to playlist" to the HOST (the `routeGoToExternally` idiom):
/// the host answers `playlistAddRequested()` with the LOCAL-mode call its
/// surface can make. The local playlist detail is the one that needs it —
/// only Rust can turn a detail row's display id into a source-aware ref
/// (`local_playlist_qt::local_picker_ref_for_row`).
property bool routePlaylistAddExternally: false
signal playlistAddRequested()
property bool hasPlaylistAddSeam: root.item.unavailable === true
? false
: (root.routePlaylistAddExternally
|| (root.catalogRow && !root.localSourceRow))
// LIVE since the MyQBZ domain landed: QbzMyQbzAdd.open() takes a JSON
// array of AddItem, so the row only has to ASK — it does not know its own
// itemType/source, which is why the payload is built by the host (see
// `mixtapeRequested` below). Not `readonly`: a host whose ids are not
// Qobuz/local mixtape-addressable can turn it back off.
property bool hasMixtapeSeam: true
signal playRequested()
signal enqueueRequested(string mode)
signal removeRequested()
signal bodyDragStarted(int index)
/// Reorder gutter (`showReorder`). The HOST answers — only it knows the
/// row's id and which playlist is open (TrackRow.slint routes the same
/// pair through `media-action("track", id, "move-up"/"move-down")`).
signal moveUpRequested()
signal moveDownRequested()
/// "Add to mixtape" — the HOST answers, because only the host knows the
/// row's `itemType` / `source` (a MyQBZ AddItem needs both) and building
/// the array here would hardcode `("track", "qobuz")` for every surface.
signal mixtapeRequested()
// --- Go-to routing: internal by default, host-routed on request -------
// The go-to actions (menu AND the artist-column link) navigate through
// QbzArtist.openArtist / QbzAlbum.openAlbum here, which is right on every
// catalog surface. It is WRONG where the row is a child of another entity
// whose host must resolve the target — MyQBZ's expanded detail rows, where
// Slint routes both paths through the SAME shared handler
// (`media-action("artist", id, "open")`, TrackRow.slint:530). Flipping
// `routeGoToExternally` hands both sites to the host as
// `goToRequested(kind)`; it defaults false, so no existing call site moves.
property bool routeGoToExternally: false
signal goToRequested(string kind) // "artist" | "album"
// --- THE heart state (a real QML property, never `item.isFavorite`) ---
// The row used to flip its glyph with `root.item.isFavorite = !…`. That is
// a write into a plain JS object and it does nothing at all here, twice
// over — both halves measured under qml6 6.11.1 in this exact delegate
// shape (`Repeater { model: JSON.parse(...) }` + `required property var
// modelData` + `item: modelData`):
//
// 1. QML does not re-evaluate a binding when a plain JS object's
// property is mutated — there is no notifier to fire. The glyph
// binding kept its old value on the same tick AND on the next.
// 2. `item: modelData` does not even alias the row: assigning a `var`
// property from `modelData` yields an object that compares `!==` to
// both `modelData` and the source array element (Qt round-trips it
// through QVariant). So the write did not reach the model either —
// not the delegate's `modelData`, not the host's array.
//
// A DECLARED property has a notifier, so the optimistic flip repaints
// immediately. The binding below keeps the document authoritative: it is
// re-established whenever the host hands over a new row object, so a
// republished document (or a page re-open) overrides a stale local flip.
property bool favorite: root.item.isFavorite === true
onItemChanged: root.favorite = Qt.binding(function () {
return root.item.isFavorite === true
})
/// The heart click and the menu's "Add to / Remove from Library" row —
/// ONE implementation, because they used to diverge silently.
function toggleFavorite() {
root.favorite = !root.favorite
QbzLibrary.libraryToggleFavorite("track", root.item.id)
}
// Settle. `libraryFavoriteChanged` (key `{kind}:{id}`, emitted by
// main.rs::emit_library_favorite) carries the value the WRITE produced:
// the flipped one when it landed, the UNCHANGED one when it failed. This
// is the favourite twin of the pin fan-out the cards already have
// (cards/AlbumCard.qml) and it is what rolls a 404'd un-favorite back —
// and what keeps the OTHER surfaces showing this same track honest
// (the album page's row, the queue, a search result) without anybody
// republishing a document.
Connections {
target: QbzLibrary
function onLibraryFavoriteChanged(key, value) {
var tid = (root.item && root.item.id !== undefined) ? root.item.id : ""
if (tid !== "" && key === "track:" + tid)
root.favorite = value
}
}
QbzTheme { id: theme }
// --- Polarity-baked tokens for the play cell (#638) -------------------
// `theme.alphaTier(pct)` IS Slint's `Theme.alpha-N`: one ramp per theme,
// white-based on dark, black-based on light. The `.length` guard covers
// the pre-publish frame QbzTheme documents (its baked fallback carries no
// ramp) — without it the disc would render fill-less AND ring-less, which
// is the exact failure this block exists to prevent. The literals are the
// Slint dark values and their light-polarity mirrors.
readonly property color playCellFill: theme.alphaTiers.length > 0
? theme.alphaTier(10) : (theme.isDark ? "#1affffff" : "#1a000000")
readonly property color playCellRing: theme.alphaTiers.length > 0
? theme.alphaTier(15) : (theme.isDark ? "#26ffffff" : "#26000000")
/// Slint's `Theme.text-primary` icon tint, runtime-tinted (QbzIcon.qml /
/// src/icon_tint_qt.rs) so it is the live token under all 36 themes. Every
/// host it lands on is a THEME surface — the play cell's polarity-baked
/// alpha disc, and `surface-elevated` for the row's trailing controls.
readonly property string playGlyphTint: "textPrimary"
/// TrackRow.slint:123-125 — the row hover is `Theme.alpha-8`, not
/// surface-hover, and the .slint says why: "Hover uses the polarity-baked
/// alpha ramp so the hover state is visible on light themes too". The
/// zebra stripe stays the literal, per the same comment ("Zebra kept
/// as-is to avoid a visible dark-theme stripe shift").
readonly property color rowHoverBg: theme.alphaTiers.length > 0
? theme.alphaTier(8) : (theme.isDark ? "#14ffffff" : "#14000000")
width: parent ? parent.width : 0
height: 50
radius: 8
color: hovered ? rowHoverBg : (zebra && number % 2 === 0 ? "#07ffffff" : "transparent")
// `playArea` is in here for the reason TrackPlayCell.slint:76-79 spells
// out: the cell owns a hover-enabled area of its own, and "Slint's
// has-hover does not propagate to ancestor TouchAreas" — Qt's does not
// either, so without this the row (and the play circle with it) would go
// un-hovered exactly while the pointer sits on the play button.
// The reorder chevrons are in the same set for the same reason: they are
// hover-enabled areas ON the row, and the row must not un-hover under
// them. Their ids resolve whether or not the gutter is `visible` — the
// objects always exist (no Loader / no `if`), only their painting is off.
readonly property bool hovered: trArea.containsMouse || favArea.containsMouse
|| moreArea.containsMouse || playArea.containsMouse
|| chevUp.hovered || chevDown.hovered
readonly property bool isActive: QbzPlayer.npTrackId === (item.id || "")
// --- Column geometry: rows/TrackCols.qml, NOT literals ---------------
// Every width, the padding and the gap come from the one file that
// rows/TrackListHeader.qml also reads, so the header above a list of
// these rows lines up with them by construction. The title column's
// arithmetic lives there too (`titleWidth`) — the header asks the same
// function the same question and gets the same answer.
TrackCols { id: cols }
/// One chevron of the reorder gutter. Declared at the file's top level
/// (an inline component must be — the same rule TrackListHeader's
/// `ColLabel` follows), not inside the Row.
///
/// It reads NOTHING off an outer id: `width` is set by the two call
/// sites, which are in the outer scope and can reach `cols` there. An
/// inline component that reaches for an enclosing id is legal only under
/// the default (unbound) ComponentBehavior, and this file does not
/// declare the pragma either way — so it simply does not depend on it.
component ReorderChevron: Item {
id: chev
property string glyph: "chevron-up"
property bool armed: true
/// Read by the row's own `hovered` (see it): a hover-enabled MouseArea
/// on top BLOCKS hover to the areas below it, so without republishing
/// it here the row un-hovers the moment the pointer enters the gutter
/// — the same defect this file already documents for the play cell.
readonly property bool hovered: chevArea.containsMouse
signal activated()
height: 18
QbzIcon {
name: chev.glyph
width: 14
height: 14
anchors.centerIn: parent
opacity: chev.armed ? 1.0 : 0.35
tintName: (chev.armed && chevArea.containsMouse) ? "textPrimary" : "muted"
}
MouseArea {
id: chevArea
anchors.fill: parent
// ENABLED even when the chevron is not armed, and the click is
// swallowed instead. A DISABLED MouseArea does not accept the
// press at all, so it fell through to the row body underneath
// (`trArea`, z:-1) — and this surface has `clickPlays: true`, so
// clicking the greyed-out ↑ on the first row STARTED PLAYBACK.
// The reference has no disabled state at all (its chevrons are
// always armed and the Rust arm no-ops at the ends), so a dead
// click there is genuinely dead; ours has to make it dead too.
hoverEnabled: true
cursorShape: chev.armed ? Qt.PointingHandCursor : Qt.ArrowCursor
onClicked: {
if (chev.armed)
chev.activated()
}
}
}
readonly property int titleColWidth: cols.titleWidth(root.width,
root.showArtwork, root.showAlbum, root.showFavorite,
root.showDownload, root.showMenu, root.showReorder)
// Static now-playing mark: 3px accent pill on the left edge.
Rectangle {
visible: root.isActive
x: 2
y: 7
width: 3
height: parent.height - 14
radius: 1.5
color: theme.accent
}
Row {
anchors.fill: parent
anchors.leftMargin: cols.padH
anchors.rightMargin: cols.padH
spacing: cols.gap
// --- Reorder gutter (primitives/TrackRow.slint:270-311) ----------
// The LEADING cell on a reorderable list: a 22px column with an
// up/down chevron stack, 18px each. It is the affordance a user who
// cannot (or does not want to) drag reorders with — the reference
// ships it and the port had only the drag, which is half of owner
// finding 8.
//
// Reuse note: the Playlist Manager's equivalent is
// views/playlistmanager/PmGridCard.qml's 22px header (chevron-up ·
// grip-vertical · chevron-down through PmActionButton). That one is
// a GRID card with 140px of width to spend; this is a 50px table row
// whose gutter is 22px wide, so the same three-across header does not
// fit and PmActionButton's 22px disc would leave no room for the
// second chevron. The geometry here is the reference row's own.
Item {
visible: root.showReorder
width: cols.colReorder
height: parent.height
Column {
anchors.verticalCenter: parent.verticalCenter
spacing: 0
ReorderChevron {
id: chevUp
width: cols.colReorder
glyph: "chevron-up"
armed: root.canMoveUp
onActivated: root.moveUpRequested()
}
ReorderChevron {
id: chevDown
width: cols.colReorder
glyph: "chevron-down"
armed: root.canMoveDown
onActivated: root.moveDownRequested()
}
}
}
// Number cell — the number-variant of primitives/TrackPlayCell.slint
// (:172-232), the play affordance shared by every track row.
//
// --- LIGHT-THEME LEGIBILITY (Slint 2.0.2 / #638, "Track-row play
// --- glyph … legible on light themes") ---------------------------
// TrackPlayCell.slint:201-207 states the defect and the fix in its
// own words: "Circular backing so the play/pause glyph is legible on
// EVERY theme (the old bare #ffffff glyph vanished on light themes —
// white-on-white, no scrim like the artwork variant has). Fill/border/
// shadow use the polarity-baked alpha ramp (black-alpha on light,
// white-alpha on dark) and the glyph uses text-primary."
//
// The port had the pre-fix shape: a hardcoded `#3dffffff` disc, no
// ring, and the "primary" icon bake — which is a literal #ffffff, not
// text-primary. Both halves are now theme-correct: theme.alphaTier()
// is white-based on dark themes and black-based on light (qbz-theme
// colors.rs:125-129, republished per theme by theme_qt.rs), and
// `playGlyphTint` is the real text-primary token, runtime-tinted.
//
// Numbers off the .slint: 24px disc, 1.5px ring ("a 1px stroked circle
// aliases badly in femtovg", :215), 16px glyph.
// The accent-ring arm (:208-229) is the playing row: transparent fill,
// accent circumference, accent glyph.
// POC-NOTE: the .slint also drops a 6px `card-shadow` under the disc.
// Qt's DropShadow is a Qt5Compat graphical effect and renders NOTHING
// on this port's software path (the finding that killed ColorOverlay
// in QbzIcon), so the shadow is dropped rather than faked; the ring
// carries the separation on its own.
Item {
id: playCell
width: cols.colNumber
height: 40
anchors.verticalCenter: parent.verticalCenter
// `show-overlay: row-hovered || is-active` (TrackPlayCell.slint
// :93) — the playing row keeps the affordance at rest, which is
// what the accent ring is FOR. The port showed it on hover only,
// so the ring never appeared.
readonly property bool showOverlay: root.hovered || root.isActive
// `accent-ring` (:108): the playing row, static form.
readonly property bool accentRing: root.isActive && QbzPlayer.npPlaying
// Selection checkbox — TrackRow.slint:392-419: a 13px disc, accent
// when selected, muted/text-primary ring when not. It REPLACES the
// number and the play disc (both gate on !selectMode below), so
// the leading column keeps its width and nothing else shifts.
Rectangle {
visible: root.selectMode
anchors.centerIn: parent
width: 14
height: 14
radius: 7
color: root.checked ? theme.accent : "transparent"
border.width: root.checked ? 0 : 1.5
border.color: selArea.containsMouse ? theme.textPrimary : theme.textMuted
Behavior on color { ColorAnimation { duration: 120 } }
QbzIcon {
visible: root.checked
name: "check"
width: 8
height: 8
anchors.centerIn: parent
// The glyph sits ON the accent fill — the same selector
// controls/QbzCheckbox.qml routes through, not a literal
// #ffffff (which is under 2.6:1 on 16 of the 35 palettes).
tintName: theme.accentGlyphTint
}
MouseArea {
id: selArea
anchors.fill: parent
hoverEnabled: true
cursorShape: Qt.PointingHandCursor
onClicked: root.toggleSelect()
}
}
Text {
visible: !playCell.showOverlay && !root.selectMode
anchors.centerIn: parent
text: root.number
color: theme.textMuted
font.pixelSize: 13
}
Rectangle {
visible: playCell.showOverlay && !root.selectMode
anchors.centerIn: parent
width: 24
height: 24
radius: 12
color: playCell.accentRing ? "transparent" : root.playCellFill
border.width: 1.5
border.color: playCell.accentRing ? theme.accent : root.playCellRing
QbzIcon {
anchors.centerIn: parent
// `show-pause` (:101-104): PAUSE only while the playing
// row is hovered — at rest the playing row shows PLAY,
// "an affordance, not a state badge: the accent ring +
// the row's edge mark carry the state".
name: playCell.accentRing && root.hovered ? "pause" : "play-fill"
width: 16
height: 16
tintName: playCell.accentRing ? "accent" : root.playGlyphTint
}
}
// TrackPlayCell.slint:234-243 — the cell is its OWN click target:
// a non-current cell plays the track, the current cell toggles
// play/pause. Without it the circle was a control that rendered
// and did nothing on the album view (clickPlays:false there, so
// the press fell through to the row body, which only reacts to a
// double-click). Declared LAST so it sits ABOVE the glyph, and it
// is above the row-body area regardless (that one is pinned z:-1).
MouseArea {
id: playArea
anchors.fill: parent
// Declared BEFORE the checkbox in z-order terms? No — the
// checkbox is declared FIRST and this fills the same cell, so
// it would swallow the checkbox's press. Disabling it in
// select mode is what hands the cell over (the play
// affordance is invisible there anyway).
enabled: !root.selectMode
hoverEnabled: true
cursorShape: Qt.PointingHandCursor
onClicked: {
if (root.isActive) QbzPlayer.togglePlay()
else root.playRequested()
}
}
}
// 36px artwork cell (showArtwork arm).
Rectangle {
visible: root.showArtwork
width: cols.colArt
height: cols.colArt
anchors.verticalCenter: parent.verticalCenter
radius: 4
color: theme.surfaceElevated
clip: true
RoundedImage {
anchors.fill: parent
source: root.item.artPath || ""
radius: 4
}
// Per-item cover placeholder — clears when THIS row's cover lands,
// which is what makes a long list read as progressive instead of
// filling in one lump. Host views drive the three properties;
// default-off, so no existing call site changes.
QbzSkeleton {
variant: "art"
anchors.fill: parent
blockRadius: 4
visible: root.artPending
phase: root.skelPhase
settleMs: root.artSettleMs
}
}
// Title (+ explicit) / artist.
Column {
width: root.titleColWidth
anchors.verticalCenter: parent.verticalCenter
spacing: 2
Row {
spacing: 6
Text {
text: root.item.title || ""
color: theme.textPrimary
font.pixelSize: 14
font.weight: theme.weightMedium
elide: Text.ElideRight
width: Math.min(implicitWidth, parent.parent.width - (root.item.explicit ? 22 : 0))
}
Rectangle {
visible: root.item.explicit === true
width: 16
height: 16
radius: 3
anchors.verticalCenter: parent.verticalCenter
color: theme.surfaceElevated
Text {
anchors.centerIn: parent
text: "E"
color: theme.textMuted
font.pixelSize: 10
font.weight: theme.weightSemibold
}
}
}
Text {
width: parent.width
visible: (root.item.artist || "") !== ""
text: root.item.artist || ""
color: root.artistLink && root.item.artistId && artistLinkArea.containsMouse
? theme.textPrimary : theme.textMuted
font.pixelSize: 12
elide: Text.ElideRight
MouseArea {
id: artistLinkArea
anchors.fill: parent
enabled: root.artistLink && !!root.item.artistId
hoverEnabled: true
cursorShape: enabled ? Qt.PointingHandCursor : Qt.ArrowCursor
// Same routing as the menu's "Go to artist" — Slint drives
// both through one handler, so gating only the menu would
// leave the LINK navigating to the track's own artist.
onClicked: {
if (root.routeGoToExternally) root.goToRequested("artist")
else QbzArtist.openArtist(root.item.artistId)
}
}
}
}
// Album (link) column (showAlbum arm).
Text {
visible: root.showAlbum
width: cols.colAlbum
anchors.verticalCenter: parent.verticalCenter
text: root.item.album || ""
color: albumArea.containsMouse ? theme.accent : theme.textMuted
font.pixelSize: 12
elide: Text.ElideRight
MouseArea {
id: albumArea
anchors.fill: parent
hoverEnabled: true
cursorShape: root.item.albumId ? Qt.PointingHandCursor : Qt.ArrowCursor
onClicked: if (root.item.albumId) QbzAlbum.openAlbum(root.item.albumId)
}
}
// Duration.
Text {
width: cols.colDuration
anchors.verticalCenter: parent.verticalCenter
text: root.item.duration || ""
color: theme.textMuted
font.pixelSize: 12
horizontalAlignment: Text.AlignHCenter
}
// Quality (92px) — the BARE badge, 1:1 with primitives/TrackRow.slint
// 578-592: a 92px cell, `alignment: center` on both axes, holding a
// QualityBadgeFull with `show-icon: false` + `bare: true`. That is the
// tier label ("CD"/"HI-RES"/"MP3"/"LOSSLESS") stacked over the exact
// bit-depth / sample-rate line, with no chip background or border, so
// it blends into the row instead of reading as a contained badge.
// The .slint has ONE form here — no icon variant, no bare-text
// variant — which is why `qualityStyle` above is inert.
//
// The cell keeps its FIXED 92px. That number is a term of
// `cellsRight`, which is what sizes the title column, so a wider badge
// MUST NOT widen the cell or the title would be pushed into the
// trailing controls. The badge is centred and the cell clips; at 8/9px
// the longest real detail ("24-bit / 352.8 kHz") measures ~80px, so
// the clip is a guard, never the normal path.
//
// Cheaper than what it replaces, too: QualityMini resolves to
// QualityBadge, which carries a ToolTip popup and a hover MouseArea
// per row; this one is two Texts.
Item {
width: cols.colQuality
height: parent.height
clip: true
QualityBadgeFull {
anchors.centerIn: parent
tier: root.item.qualityTier || ""
detail: root.item.qualityDetail || ""
showIcon: false
bare: true
}
}
// Favorite (showFavorite arm).
Rectangle {
visible: root.showFavorite
width: cols.colFavorite
height: cols.colFavorite
radius: theme.radiusSm
anchors.verticalCenter: parent.verticalCenter
color: favArea.containsMouse ? theme.surfaceElevated : "transparent"
QbzIcon {
anchors.centerIn: parent
name: root.favorite ? "heart-filled" : "heart"
width: 16
height: 16
// TrackRow.slint:619 — hover raises the glyph to
// Theme.text-primary, NOT to white (same #638 hole).
tintName: root.favorite
? "favorite"
: (favArea.containsMouse ? root.playGlyphTint : "muted")
}
MouseArea {
id: favArea
anchors.fill: parent
// TrackRow.slint:527/558/623/688 — the in-row controls stand
// down in select mode so their click reaches the row body.
// Without it, aiming at a row and hitting the heart
// un-favourites a track the user meant to tick.
enabled: !root.selectMode
hoverEnabled: true
cursorShape: Qt.PointingHandCursor
onClicked: root.toggleFavorite()
}
}
// Download slot (showDownload arm): inert glyph stub or reserved
// spacer (the offline-cache column — not ported, POC-NOTE; the
// Slint reserves the slot so the grid stays aligned).
Item {
visible: root.showDownload
width: cols.colDownload
height: cols.colDownload
anchors.verticalCenter: parent.verticalCenter
QbzIcon {
visible: root.downloadGlyph
anchors.centerIn: parent
name: "cloud-download"
width: 16
height: 16
tintName: "muted"
}
}
// ⋯ menu (showMenu arm).
Rectangle {
visible: root.showMenu
width: cols.colMenu
height: cols.colMenu
radius: theme.radiusSm
anchors.verticalCenter: parent.verticalCenter
color: moreArea.containsMouse ? theme.surfaceElevated : "transparent"
QbzIcon {
anchors.centerIn: parent
name: "ellipsis"
width: 16
height: 16
// TrackRow.slint:750 — Theme.text-primary on hover.
tintName: moreArea.containsMouse ? root.playGlyphTint : "muted"
}
MouseArea {
id: moreArea
anchors.fill: parent
hoverEnabled: true
cursorShape: Qt.PointingHandCursor
onClicked: function (mouse) { rowMenu.openAtCursor(moreArea, mouse.x, mouse.y) }
}
}
}
CardMenu {
id: rowMenu
menuWidth: 224
entries: root.menuModel()
onPicked: function (a) { root.menuAction(a) }
}
// TrackContextMenu.slint, in its order. Every row here reaches a live
// seam; the seamless ones are gated off above.
function menuModel() {
var t = QbzSession.tr
var r = QbzSession.trRev
var m = [
{ "label": t("Play now", r), "icon": "play-fill", "action": "play" },
{ "label": t("Play next", r), "icon": "list-start", "action": "next" },
]
// #442 "Play later" — the end of the MANUAL block (after everything
// already queued by hand, before the source resumes).
if (root.menuShowLater)
m.push({ "label": t("Play later", r), "icon": "list-plus", "action": "later" })
m.push({ "label": t("Add to queue", r), "icon": "list-end", "action": "queue" })
if (root.hasRadioSeam) {
m.push({ "label": t("Create QBZ radio", r), "icon": "radio", "action": "radio-qbz" })
m.push({ "label": t("Create Qobuz radio", r), "icon": "radio", "action": "radio-qobuz" })
}
if (root.menuShowFavorite)
m.push({ "label": root.favorite ? t("Remove from Library", r) : t("Add to Library", r),
"icon": root.favorite ? "heart-filled" : "heart", "action": "favorite" })
if (root.hasMixtapeSeam)
m.push({ "label": t("Add to mixtape", r), "icon": "cassette-tape", "action": "mixtape" })
if (root.hasPlaylistAddSeam)
m.push({ "label": t("Add to playlist", r), "icon": "list-music", "action": "add-to-playlist" })
if (root.menuShowRemove)
m.push({ "label": t("Remove from playlist", r), "icon": "trash-2",
"action": "remove", "danger": true })
if (root.menuShowShare)
m.push({ "label": t("Share Qobuz link", r), "icon": "link", "action": "share-qobuz" })
if (root.hasSonglinkSeam)
m.push({ "label": t("Share Song.link", r), "icon": "link", "action": "share-songlink" })
if (root.hasOfflineCacheSeam)
m.push({ "label": t("Make available offline", r), "icon": "cloud-download", "action": "cache" })
if (root.menuShowGoTo && root.item.albumId)
m.push({ "label": t("Go to album", r), "icon": "disc-3", "action": "go-album" })
if (root.menuShowGoTo && root.item.artistId)
m.push({ "label": t("Go to artist", r), "icon": "user", "action": "go-artist" })
if (root.menuShowTrackInfo)
m.push({ "label": t("Track info", r), "icon": "info", "action": "track-info" })
return m
}
function menuAction(a) {
if (a === "play") root.playRequested()
else if (a === "next") root.enqueueRequested("next")
else if (a === "later") root.enqueueRequested("later")
else if (a === "queue") root.enqueueRequested("queue")
else if (a === "go-artist") {
if (root.routeGoToExternally) root.goToRequested("artist")
else QbzArtist.openArtist(root.item.artistId)
}
else if (a === "go-album") {
if (root.routeGoToExternally) root.goToRequested("album")
else QbzAlbum.openAlbum(root.item.albumId)
}
else if (a === "favorite") root.toggleFavorite()
else if (a === "mixtape") root.mixtapeRequested()
// Add to playlist. The internal arm is the CATALOG one and nothing
// else can reach it: `hasPlaylistAddSeam` only builds the entry for a
// `catalogRow` that is not a local/plex row, or when the host has
// taken the routing. Belt and braces on the dispatch too, so a host
// that sets `routePlaylistAddExternally` and forgets the handler
// cannot fall through into the Qobuz call with a local id.
else if (a === "add-to-playlist") {
if (root.routePlaylistAddExternally) root.playlistAddRequested()
else if (root.catalogRow && !root.localSourceRow)
QbzPlaylistPicker.openForTrack(root.item.id)
}
else if (a === "remove") root.removeRequested()
else if (a === "share-qobuz") root.copyToClipboard(
"https://open.qobuz.com/track/" + (root.item.id || ""))
else if (a === "track-info") root.openTrackInfo()
}
// --- Share (share.rs::qobuz_track_url + copy_to_clipboard) -----------
// The .slint arm copies the link and raises a toast; the Qt port has no
// toast seam yet (GLUE NEEDED), so the copy is silent — but it IS a real
// clipboard write. QtQuick exposes no Clipboard type; TextEdit.copy() is
// the supported route, kept in an INACTIVE Loader so a 16K-row list does
// not carry one TextEdit per row.
Loader {
id: clipLoader
active: false
sourceComponent: TextEdit { visible: false }
}
function copyToClipboard(text) {
if (!text || text === "")
return
clipLoader.active = true
clipLoader.item.text = text
clipLoader.item.selectAll()
clipLoader.item.copy()
clipLoader.active = false
}
// --- Track info (QbzAlbum.openTrackInfo + shell/TrackInfoModal) ------
// Same lazy-Loader reason: the modal is a full Popup tree and a list row
// must not instantiate one per delegate. Activated on demand, torn down
// on close (Qt.callLater so the Popup is not destroyed mid-signal).
Loader {
id: trackInfoLoader
active: false
sourceComponent: TrackInfoModal { }
}
Connections {
target: trackInfoLoader.item
ignoreUnknownSignals: true
function onClosed() { Qt.callLater(function () { trackInfoLoader.active = false }) }
}
function openTrackInfo() {
if (!root.item.id)
return
trackInfoLoader.active = true
trackInfoLoader.item.openFor(root.item.id)
}
// Shared drag (the row BODY is the source — TrackRow.slint): press-drag
// >6px starts it (bodyDragStarted fires FIRST, the #589 pre-hook);
// release plays (clickPlays) or ignores (album view: double-click).
property bool dragging: false
property point downPos: Qt.point(0, 0)
// --- DRAG vs. DRAG-TO-SCROLL (owner finding 8) -----------------------
// The reference does not solve this because it does not HAVE it: Slint's
// ListView is not mouse-drag-scrollable, so its row-body drag has no
// competitor. Qt's is — every one of these rows lives in a Flickable, and
// a Flickable filters its children's mouse events and takes the grab once
// the press travels past `QStyleHints.startDragDistance` (~10px). Our
// drag arms at 6px, so BOTH fire: the ghost appears, the list then takes
// the grab, this area gets `canceled` and never `released`, `dragging`
// stays true and the ghost never ends.
//
// The resolution is the one this port ALREADY made for the same collision
// in shell/QueuePanel.qml:479-491 — `preventStealing` scoped to the rows
// that are actually reorderable, described there as "the Qt equivalent of
// QueueSidebar.slint's `interactive: false` on the queue Flickable, but
// without that side effect: Qt's Flickable also drops WHEEL events when
// it is non-interactive, so wheel + scrollbar keep working, and only a
// press that starts ON a reorderable row is denied to the flick." Same
// trade here, same shape, so the two reorderable lists in the app behave
// identically: while a list is reorderable it is not drag-scrollable, and
// the wheel and the scrollbar carry scrolling.
//
// Scoped to `showReorder` on purpose: on every OTHER surface the row-body
// drag is the add-to-a-sidebar-playlist gesture, which shipped with the
// >6px arm and drag-scroll both live, and re-timing it is not this
// round's job. `onCanceled` below is the universal half — it costs no
// gesture change and it is what stops a stolen drag from stranding the
// ghost anywhere.
//
// Rejected: constraining the drag AXIS (a reorder drag is vertical, i.e.
// the same axis as the scroll — it separates nothing), and moving the
// drag source onto a grip handle (see the gutter above: 22 x 50 leaves no
// room beside the two chevrons, and the chevrons already are the non-drag
// affordance a grip would duplicate).
/// Release / cancel teardown — ONE implementation, because the two used
/// to be able to disagree about whether the shared drag had ended.
function endBodyDrag() {
if (root.dragging) {
QbzShell.dragEnd()
root.dragging = false
return true
}
return false
}
MouseArea {
id: trArea
anchors.fill: parent
// BEHIND the row's own controls. Declaration order is z-order in QML,
// and this fills the whole row from the LAST declaration — so it sat on
// top of the heart / cloud / menu buttons and swallowed their presses.
// propagateComposedEvents does not save them: `pressed` is not a
// composed event, so only the row's own double-click still worked.
z: -1
hoverEnabled: true
propagateComposedEvents: true
// Right press opens the SAME menu as ⋯ (rowMenu), at the pointer.
acceptedButtons: Qt.LeftButton | Qt.RightButton
cursorShape: (root.clickPlays || root.selectMode) ? Qt.PointingHandCursor : Qt.ArrowCursor
// Keep the grab on a reorderable row so the enclosing Flickable
// cannot turn a reorder drag into a scroll — see the block above.
preventStealing: root.showReorder && root.draggable && !root.selectMode
onPressed: function (mouse) {
if (mouse.button === Qt.RightButton) {
// TrackRow.slint:201 — the row menu is suppressed in
// multi-select mode (a right-click toggles nothing there).
if (root.showMenu && !root.selectMode)
rowMenu.openAtCursor(trArea, mouse.x, mouse.y)
mouse.accepted = true
return
}
root.downPos = Qt.point(mouse.x, mouse.y)
}
onPositionChanged: function (mouse) {
// Only a LEFT press drags — a right press is the context gesture.
// Dragging a row onto a sidebar playlist is off in select mode
// (TrackRow.slint keeps the whole body as a selection target).
if (!pressed || !(pressedButtons & Qt.LeftButton) || !root.draggable
|| root.selectMode) return
const g = mapToItem(null, mouse.x, mouse.y)
if (!root.dragging
&& (Math.abs(mouse.x - root.downPos.x) > 6
|| Math.abs(mouse.y - root.downPos.y) > 6)) {
root.dragging = true
root.bodyDragStarted(root.number)
QbzShell.dragStart(root.item.id, root.item.title || "",
(root.item.artist || "") + " · " + (root.item.album || ""), g.x, g.y)
}
if (root.dragging) QbzShell.dragMove(g.x, g.y)
}
onReleased: function (mouse) {
if (mouse.button === Qt.RightButton)
return
const wasDragging = root.endBodyDrag()
// In select mode the WHOLE row body is a selection target
// (TrackRow.slint:174) — never a play.
if (root.selectMode) {
root.toggleSelect()
mouse.accepted = true
return
}
if (wasDragging) {
mouse.accepted = true
} else if (root.clickPlays) {
root.playRequested()
} else {
mouse.accepted = false
}
}
// Grab lost (the Flickable stole it, the delegate was recycled, the
// window lost focus). Without this the shared drag stayed "active"
// with no way to end it and the ghost never disappeared.
onCanceled: root.endBodyDrag()
onDoubleClicked: function (mouse) {
// ":156 — In select mode a double-click just selects (via
// `clicked`); no play." The single-click release above has already
// toggled twice by then, which lands back where it started, so the
// double-click must not add a third.
if (root.selectMode)
return
if (mouse.button === Qt.LeftButton)
root.playRequested()
}
}
}
Reference in new issue View Git Blame Copy Permalink