Merge branch 'refactor/uniform-menus'

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

.github/workflows/windows.yml

@@ -0,0 +1,49 @@
+name: Build for Windows
+
+on:
+  push:
+    branches: [ "main", "feature/cross-platform" ]
+  pull_request:
+    branches: [ "main" ]
+  workflow_dispatch:
+
+jobs:
+  build-windows:
+    runs-on: windows-latest
+    
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+
+    - name: Setup Rust toolchain
+      uses: dtolnay/rust-toolchain@stable
+      with:
+        toolchain: stable
+        target: x86_64-pc-windows-msvc
+
+    - name: Install Qt 6
+      uses: jurplel/install-qt-action@v4
+      with:
+        version: '6.5.3'
+        host: 'windows'
+        target: 'desktop'
+        arch: 'win64_msvc2019_64'
+
+    - name: Configure CMake
+      run: cmake -B build -S . -DCMAKE_BUILD_TYPE=Release
+
+    - name: Build Application
+      run: cmake --build build --config Release -j %NUMBER_OF_PROCESSORS%
+
+    - name: Bundle Executable (windeployqt)
+      run: |
+        mkdir release
+        copy build\Release\qobuz-qt.exe release\
+        windeployqt release\qobuz-qt.exe
+      shell: cmd
+
+    - name: Upload Artifact
+      uses: actions/upload-artifact@v4
+      with:
+        name: qobuz-qt-windows-x64
+        path: release/

CMakeLists.txt

@@ -38,7 +38,11 @@ else()
     set(CARGO_PROFILE_FLAG "")
 endif()
 
-set(RUST_LIB "${CMAKE_SOURCE_DIR}/target/${CARGO_PROFILE}/libqobuz_backend.a")
+if(WIN32 AND MSVC)
+    set(RUST_LIB "${CMAKE_SOURCE_DIR}/target/${CARGO_PROFILE}/qobuz_backend.lib")
+else()
+    set(RUST_LIB "${CMAKE_SOURCE_DIR}/target/${CARGO_PROFILE}/libqobuz_backend.a")
+endif()
 
 add_custom_target(rust_backend ALL
     COMMAND ${CARGO_CMD} build ${CARGO_PROFILE_FLAG}
@@ -83,23 +87,39 @@ target_link_libraries(qobuz-qt PRIVATE
     qobuz_backend_lib
 )
 
-# Platform-specific system libs needed by the Rust audio stack (cpal/ALSA)
+# Platform-specific system libs needed by the Rust audio stack (cpal/backend internals)
 if (UNIX AND NOT APPLE)
     target_link_libraries(qobuz-qt PRIVATE asound)
+elseif (APPLE)
+    find_library(COREAUDIO CoreAudio)
+    find_library(AUDIOTOOLBOX AudioToolbox)
+    find_library(SECURITY Security)
+    find_library(COREFOUNDATION CoreFoundation)
+    target_link_libraries(qobuz-qt PRIVATE ${COREAUDIO} ${AUDIOTOOLBOX} ${SECURITY} ${COREFOUNDATION})
+elseif (WIN32)
+    target_link_libraries(qobuz-qt PRIVATE ws2_32 userenv bcrypt advapi32 ntdll ole32)
 endif ()
 
 # Compiler warnings + hardening
 if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
     target_compile_options(qobuz-qt PRIVATE
         -Wall -Wextra -Wno-unused-parameter
+    )
+    if (UNIX AND NOT APPLE)
+        target_compile_options(qobuz-qt PRIVATE
             -fstack-protector-strong
-        -D_FORTIFY_SOURCE=2
             -fPIE
+            # _FORTIFY_SOURCE needs optimized builds; in Debug it causes warning spam.
+            $<$<OR:$<CONFIG:Release>,$<CONFIG:RelWithDebInfo>,$<CONFIG:MinSizeRel>>:-D_FORTIFY_SOURCE=2>
+            $<$<CONFIG:Debug>:-U_FORTIFY_SOURCE>
         )
         target_link_options(qobuz-qt PRIVATE
             -pie
             -Wl,-z,relro,-z,now
         )
+    endif ()
+elseif (MSVC)
+    target_compile_options(qobuz-qt PRIVATE /W3 /Zc:__cplusplus /permissive-)
 endif ()
 
 # D-Bus
@@ -118,7 +138,7 @@ if (USE_LTO)
 endif ()
 
 # Install
-if (UNIX)
+if (UNIX AND NOT APPLE)
     install(FILES res/logo/qobuz-qt.svg DESTINATION share/icons/hicolor/scalable/apps)
     install(FILES res/app/qobuz-qt.desktop DESTINATION share/applications)
     install(TARGETS qobuz-qt RUNTIME DESTINATION bin)

Cargo.lock

@@ -2,6 +2,17 @@
 # It is not intended for manual editing.
 version = 4
 
+[[package]]
+name = "aes"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b169f7a6d4742236a0a00c541b845991d0ac43e546831af1249753ab4c3aa3a0"
+dependencies = [
+ "cfg-if",
+ "cipher",
+ "cpufeatures",
+]
+
 [[package]]
 name = "aho-corasick"
 version = "1.1.4"
@@ -93,6 +104,24 @@ version = "2.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "843867be96c8daad0d758b57df9392b6d8d271134fce549de6ce169ff98a92af"
 
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "block-padding"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8894febbff9f758034a5b8e12d87918f56dfc64a8e1fe757d65e29041538d93"
+dependencies = [
+ "generic-array",
+]
+
 [[package]]
 name = "bumpalo"
 version = "3.20.2"
@@ -111,6 +140,15 @@ version = "1.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33"
 
+[[package]]
+name = "cbc"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26b52a9543ae338f279b96b0b9fed9c8093744685043739079ce85cd58f289a6"
+dependencies = [
+ "cipher",
+]
+
 [[package]]
 name = "cc"
 version = "1.2.57"
@@ -150,6 +188,16 @@ version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
 
+[[package]]
+name = "cipher"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad"
+dependencies = [
+ "crypto-common",
+ "inout",
+]
+
 [[package]]
 name = "clang-sys"
 version = "1.8.1"
@@ -221,12 +269,51 @@ dependencies = [
  "windows",
 ]
 
+[[package]]
+name = "cpufeatures"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "ctr"
+version = "0.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0369ee1ad671834580515889b80f2ea915f23b8be8d0daa4bbaf2ac5c7590835"
+dependencies = [
+ "cipher",
+]
+
 [[package]]
 name = "dasp_sample"
 version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0c87e182de0887fd5361989c677c4e8f5000cd9491d6d563161a8f3a5519fc7f"
 
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "crypto-common",
+ "subtle",
+]
+
 [[package]]
 name = "dirs"
 version = "5.0.1"
@@ -372,6 +459,16 @@ dependencies = [
  "slab",
 ]
 
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
 [[package]]
 name = "getrandom"
 version = "0.2.17"
@@ -411,6 +508,30 @@ version = "0.16.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
 
+[[package]]
+name = "hex"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
+
+[[package]]
+name = "hkdf"
+version = "0.12.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b5f8eb2ad728638ea2c7d47a21db23b7b58a72ed6a38256b8a1849f15fbbdf7"
+dependencies = [
+ "hmac",
+]
+
+[[package]]
+name = "hmac"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
+dependencies = [
+ "digest",
+]
+
 [[package]]
 name = "http"
 version = "1.4.0"
@@ -623,6 +744,16 @@ dependencies = [
  "hashbrown",
 ]
 
+[[package]]
+name = "inout"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01"
+dependencies = [
+ "block-padding",
+ "generic-array",
+]
+
 [[package]]
 name = "ipnet"
 version = "2.12.0"
@@ -1054,14 +1185,21 @@ dependencies = [
 name = "qobuz-backend"
 version = "0.1.0"
 dependencies = [
+ "aes",
  "anyhow",
+ "base64",
+ "cbc",
  "cpal",
+ "ctr",
  "dirs",
+ "hex",
+ "hkdf",
  "md5",
  "rb",
  "reqwest",
  "serde",
  "serde_json",
+ "sha2",
  "symphonia",
  "thiserror 2.0.18",
  "tokio",
@@ -1410,6 +1548,17 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "sha2"
+version = "0.10.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
 [[package]]
 name = "shlex"
 version = "1.3.0"
@@ -1943,6 +2092,12 @@ version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
 
+[[package]]
+name = "typenum"
+version = "1.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "562d481066bde0658276a35467c4af00bdc6ee726305698a55b86e61d7ad82bb"
+
 [[package]]
 name = "unicode-ident"
 version = "1.0.24"
@@ -1973,6 +2128,12 @@ version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
 
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
 [[package]]
 name = "walkdir"
 version = "2.5.0"

rust/Cargo.toml

@@ -28,6 +28,15 @@ md5 = "0.7"
 dirs = "5"
 toml = "0.8"
 
+# Crypto — qbz-1 key derivation + segment decryption
+aes   = "0.8"
+cbc   = { version = "0.1", features = ["alloc"] }
+ctr   = "0.9"
+hkdf  = "0.12"
+sha2  = "0.10"
+hex   = "0.4"
+base64 = "0.22"
+
 [profile.release]
 lto = "thin"
 opt-level = 3

rust/include/qobuz_backend.h

@@ -37,6 +37,15 @@ enum QobuzEvent {
     EV_USER_OK               = 23,
     EV_ARTIST_RELEASES_OK    = 24,
     EV_DEEP_SHUFFLE_OK       = 25,
+    EV_MOST_POPULAR_OK       = 26,
+    EV_GENRES_OK             = 27,
+    EV_FEATURED_ALBUMS_OK    = 28,
+    EV_DYNAMIC_SUGGEST_OK    = 29,
+    EV_FEATURED_PLAYLISTS_OK = 30,
+    EV_DISCOVER_PLAYLISTS_OK = 31,
+    EV_PLAYLIST_SEARCH_OK    = 32,
+    EV_PLAYLIST_SUBSCRIBED   = 33,
+    EV_PLAYLIST_UNSUBSCRIBED = 34,
 };
 
 // Callback signature
@@ -53,9 +62,12 @@ void qobuz_backend_get_user(QobuzBackendOpaque *backend);
 
 // Catalog
 void qobuz_backend_search(QobuzBackendOpaque *backend, const char *query, uint32_t offset, uint32_t limit);
+void qobuz_backend_most_popular_search(QobuzBackendOpaque *backend, const char *query, uint32_t limit);
+void qobuz_backend_get_dynamic_suggestions(QobuzBackendOpaque *backend, const char *listened_track_ids_json, const char *tracks_to_analyze_json, uint32_t limit);
 void qobuz_backend_get_album(QobuzBackendOpaque *backend, const char *album_id);
 void qobuz_backend_get_artist(QobuzBackendOpaque *backend, int64_t artist_id);
 void qobuz_backend_get_playlist(QobuzBackendOpaque *backend, int64_t playlist_id, uint32_t offset, uint32_t limit);
+void qobuz_backend_get_playlist_all(QobuzBackendOpaque *backend, int64_t playlist_id);
 
 // Favorites
 void qobuz_backend_get_fav_tracks(QobuzBackendOpaque *backend, uint32_t offset, uint32_t limit);
@@ -75,28 +87,33 @@ uint64_t qobuz_backend_get_duration(const QobuzBackendOpaque *backend);
 uint8_t  qobuz_backend_get_volume(const QobuzBackendOpaque *backend);
 int      qobuz_backend_get_state(const QobuzBackendOpaque *backend);
 int      qobuz_backend_take_track_finished(QobuzBackendOpaque *backend);
+int      qobuz_backend_take_track_transitioned(QobuzBackendOpaque *backend);
 
 // ReplayGain / Gapless
 void qobuz_backend_set_replaygain(QobuzBackendOpaque *backend, bool enabled);
 void qobuz_backend_set_gapless(QobuzBackendOpaque *backend, bool enabled);
 void qobuz_backend_prefetch_track(QobuzBackendOpaque *backend, int64_t track_id, int32_t format_id);
 
-// Visualizer PCM access
-uint32_t qobuz_backend_viz_read(QobuzBackendOpaque *backend, float *buf, uint32_t max_samples);
-uint32_t qobuz_backend_viz_sample_rate(const QobuzBackendOpaque *backend);
-uint32_t qobuz_backend_viz_channels(const QobuzBackendOpaque *backend);
-
 // Artist releases (auto-paginates to fetch all)
 void qobuz_backend_get_artist_releases(QobuzBackendOpaque *backend, int64_t artist_id, const char *release_type, uint32_t limit, uint32_t offset);
 
 // Deep shuffle: fetch tracks from multiple albums (album_ids_json is a JSON array of strings)
 void qobuz_backend_get_albums_tracks(QobuzBackendOpaque *backend, const char *album_ids_json);
 
+// Browse
+void qobuz_backend_get_genres(QobuzBackendOpaque *backend);
+void qobuz_backend_get_featured_albums(QobuzBackendOpaque *backend, const char *genre_ids, const char *kind, uint32_t limit, uint32_t offset);
+void qobuz_backend_get_featured_playlists(QobuzBackendOpaque *backend, const char *genre_ids, const char *kind, uint32_t limit, uint32_t offset);
+void qobuz_backend_discover_playlists(QobuzBackendOpaque *backend, const char *genre_ids, const char *tags, uint32_t limit, uint32_t offset);
+void qobuz_backend_search_playlists(QobuzBackendOpaque *backend, const char *query, uint32_t limit, uint32_t offset);
+
 // Playlist management
 void qobuz_backend_create_playlist(QobuzBackendOpaque *backend, const char *name);
 void qobuz_backend_delete_playlist(QobuzBackendOpaque *backend, int64_t playlist_id);
 void qobuz_backend_add_track_to_playlist(QobuzBackendOpaque *backend, int64_t playlist_id, int64_t track_id);
 void qobuz_backend_delete_track_from_playlist(QobuzBackendOpaque *backend, int64_t playlist_id, int64_t playlist_track_id);
+void qobuz_backend_subscribe_playlist(QobuzBackendOpaque *backend, int64_t playlist_id);
+void qobuz_backend_unsubscribe_playlist(QobuzBackendOpaque *backend, int64_t playlist_id);
 
 // Favorites modification
 void qobuz_backend_add_fav_track(QobuzBackendOpaque *backend, int64_t track_id);

rust/src/api/client.rs

@@ -1,6 +1,10 @@
 use anyhow::{bail, Result};
+use base64::{engine::general_purpose::URL_SAFE_NO_PAD, Engine};
+use cbc::cipher::{block_padding::NoPadding, BlockDecryptMut, KeyIvInit};
+use hkdf::Hkdf;
 use reqwest::Client;
 use serde_json::Value;
+use sha2::Sha256;
 use std::time::{SystemTime, UNIX_EPOCH};
 
 use super::models::*;
@@ -15,10 +19,74 @@ pub const DEFAULT_APP_SECRET: &str = "e79f8b9be485692b0e5f9dd895826368";
 pub struct QobuzClient {
     http: Client,
     pub auth_token: Option<String>,
+    /// Playback session ID from POST /session/start — sent as X-Session-Id for /file/url.
+    session_id: Option<String>,
+    session_expires_at: Option<u64>,
+    /// `infos` field from the session/start response — used to derive the KEK for track key unwrapping.
+    session_infos: Option<String>,
     app_id: String,
     app_secret: String,
 }
 
+// ── qbz-1 key derivation helpers ─────────────────────────────────────────────
+
+type Aes128CbcDec = cbc::Decryptor<aes::Aes128>;
+
+/// Decode a base64url string (with or without padding).
+fn b64url_decode(s: &str) -> Result<Vec<u8>> {
+    Ok(URL_SAFE_NO_PAD.decode(s.trim_end_matches('='))?)
+}
+
+/// Full qbz-1 key derivation:
+///   Phase 1: HKDF-SHA256(ikm=hex(app_secret), salt=b64url(infos[0]), info=b64url(infos[1])) → 16-byte KEK
+///   Phase 2: AES-128-CBC/NoPadding(key=KEK, iv=b64url(key_field[2])).decrypt(b64url(key_field[1]))[..16]
+fn derive_track_key(
+    session_infos: &str,
+    app_secret_hex: &str,
+    key_field: &str,
+) -> Result<[u8; 16]> {
+    // Phase 1: HKDF
+    let infos_parts: Vec<&str> = session_infos.splitn(2, '.').collect();
+    if infos_parts.len() != 2 {
+        bail!("session_infos must be '<salt_b64>.<info_b64>', got: {session_infos}");
+    }
+    let salt = b64url_decode(infos_parts[0])?;
+    let info = b64url_decode(infos_parts[1])?;
+    let ikm = hex::decode(app_secret_hex)?;
+
+    let hk = Hkdf::<Sha256>::new(Some(&salt), &ikm);
+    let mut kek = [0u8; 16];
+    hk.expand(&info, &mut kek)
+        .map_err(|e| anyhow::anyhow!("HKDF expand failed: {e:?}"))?;
+
+    // Phase 2: AES-128-CBC/NoPadding
+    let key_parts: Vec<&str> = key_field.splitn(3, '.').collect();
+    if key_parts.len() != 3 || key_parts[0] != "qbz-1" {
+        bail!("unexpected key field format: {key_field}");
+    }
+    let ct = b64url_decode(key_parts[1])?;
+    let iv_bytes = b64url_decode(key_parts[2])?;
+    if ct.len() < 16 || iv_bytes.len() < 16 {
+        bail!(
+            "key field ciphertext/iv too short ({} / {} bytes)",
+            ct.len(),
+            iv_bytes.len()
+        );
+    }
+
+    let iv: [u8; 16] = iv_bytes[..16].try_into()?;
+    let mut buf = ct;
+    let decrypted = Aes128CbcDec::new(&kek.into(), &iv.into())
+        .decrypt_padded_mut::<NoPadding>(&mut buf)
+        .map_err(|e| anyhow::anyhow!("AES-CBC decrypt failed: {e:?}"))?;
+
+    let mut track_key = [0u8; 16];
+    track_key.copy_from_slice(&decrypted[..16]);
+    Ok(track_key)
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+
 impl QobuzClient {
     pub fn new() -> Result<Self> {
         Self::new_with_config(None, None)
@@ -44,6 +112,9 @@ impl QobuzClient {
         Ok(Self {
             http,
             auth_token: None,
+            session_id: None,
+            session_expires_at: None,
+            session_infos: None,
             app_id,
             app_secret,
         })
@@ -106,20 +177,16 @@ impl QobuzClient {
         if let Some(token) = &self.auth_token {
             builder = builder.header("Authorization", format!("Bearer {}", token));
         }
+        if let Some(sid) = &self.session_id {
+            builder = builder.header("X-Session-Id", sid.as_str());
+        }
         builder
     }
 
     // --- Auth ---
 
-    pub async fn login(&mut self, email: &str, password: &str) -> Result<OAuthLoginResponse> {
-        match self.oauth2_login(email, password).await {
-            Ok(r) => Ok(r),
-            Err(_) => self.legacy_login(email, password).await,
-        }
-    }
-
     /// NOTE: Qobuz API requires credentials as GET query params — not our choice.
-    async fn oauth2_login(&mut self, email: &str, password: &str) -> Result<OAuthLoginResponse> {
+    pub async fn login(&mut self, email: &str, password: &str) -> Result<OAuthLoginResponse> {
         let ts = Self::ts();
         let mut sign_params: Vec<(&str, String)> = vec![
             ("password", password.to_string()),
@@ -143,45 +210,18 @@ impl QobuzClient {
         let status = resp.status();
         let body: Value = resp.json().await?;
         if !status.is_success() {
-            let msg = body.get("message").and_then(|m| m.as_str()).unwrap_or("login failed");
+            let msg = body
-            bail!("oauth2 login failed ({}): {}", status, msg);
+                .get("message")
-        }
+                .and_then(|m| m.as_str())
-
+                .unwrap_or("login failed");
-        self.extract_and_store_token(serde_json::from_value(body)?)
+            bail!("login failed ({}): {}", status, msg);
-    }
-
-    async fn legacy_login(&mut self, email: &str, password: &str) -> Result<OAuthLoginResponse> {
-        let ts = Self::ts();
-        let mut sign_params: Vec<(&str, String)> = vec![
-            ("email", email.to_string()),
-            ("password", password.to_string()),
-        ];
-        let sig = self.request_sig("userlogin", &mut sign_params, ts);
-
-        let resp = self
-            .http
-            .get(self.url("user/login"))
-            .query(&[
-                ("app_id", self.app_id.as_str()),
-                ("email", email),
-                ("password", password),
-                ("request_ts", ts.to_string().as_str()),
-                ("request_sig", sig.as_str()),
-            ])
-            .send()
-            .await?;
-
-        let status = resp.status();
-        let body: Value = resp.json().await?;
-        if !status.is_success() {
-            let msg = body.get("message").and_then(|m| m.as_str()).unwrap_or("login failed");
-            bail!("user login failed ({}): {}", status, msg);
         }
 
         self.extract_and_store_token(serde_json::from_value(body)?)
     }
 
     fn extract_and_store_token(&mut self, login: OAuthLoginResponse) -> Result<OAuthLoginResponse> {
+        // auth_token = OAuth2 bearer (preferred) or legacy session token
         if let Some(token) = login
             .oauth2
             .as_ref()
@@ -190,9 +230,63 @@ impl QobuzClient {
         {
             self.auth_token = Some(token);
         }
+        // Reset any cached playback session — it belongs to a different auth context.
+        self.session_id = None;
+        self.session_expires_at = None;
+        self.session_infos = None;
         Ok(login)
     }
 
+    /// Start a playback session via POST /session/start.
+    /// The returned session_id is required as X-Session-Id when calling /file/url.
+    /// Sessions expire; we cache and reuse until 60s before expiry.
+    async fn ensure_session(&mut self) -> Result<()> {
+        let now = Self::ts();
+        if let (Some(_), Some(exp)) = (&self.session_id, self.session_expires_at) {
+            if now + 60 < exp {
+                return Ok(()); // still valid
+            }
+        }
+
+        let ts = Self::ts();
+        let mut sign_params: Vec<(&str, String)> = vec![("profile", "qbz-1".to_string())];
+        let sig = self.request_sig("sessionstart", &mut sign_params, ts);
+
+        let resp = self
+            .http
+            .post(self.url("session/start"))
+            .query(&[
+                ("app_id", self.app_id.as_str()),
+                ("request_ts", ts.to_string().as_str()),
+                ("request_sig", sig.as_str()),
+            ])
+            .header(
+                "Authorization",
+                format!("Bearer {}", self.auth_token.as_deref().unwrap_or("")),
+            )
+            .form(&[("profile", "qbz-1")])
+            .send()
+            .await?;
+
+        let body = Self::check_response(resp).await?;
+        let session_id = body["session_id"]
+            .as_str()
+            .ok_or_else(|| anyhow::anyhow!("session/start: no session_id in response"))?
+            .to_string();
+        let expires_at = body["expires_at"].as_u64().unwrap_or(now + 3600);
+        let infos = body["infos"].as_str().map(|s| s.to_string());
+        eprintln!(
+            "[session] started session_id={}... expires_at={} infos={:?}",
+            &session_id[..session_id.len().min(8)],
+            expires_at,
+            infos
+        );
+        self.session_id = Some(session_id);
+        self.session_expires_at = Some(expires_at);
+        self.session_infos = infos;
+        Ok(())
+    }
+
     // --- User ---
 
     pub async fn get_user(&self) -> Result<UserDto> {
@@ -215,7 +309,13 @@ impl QobuzClient {
         Ok(serde_json::from_value(body)?)
     }
 
-    pub async fn get_track_url(&self, track_id: i64, format: Format) -> Result<TrackFileUrlDto> {
+    pub async fn get_track_url(
+        &mut self,
+        track_id: i64,
+        format: Format,
+    ) -> Result<TrackFileUrlDto> {
+        self.ensure_session().await?;
+
         let ts = Self::ts();
         let intent = "stream";
         let mut sign_params: Vec<(&str, String)> = vec![
@@ -223,10 +323,10 @@ impl QobuzClient {
             ("intent", intent.to_string()),
             ("track_id", track_id.to_string()),
         ];
-        let sig = self.request_sig("trackgetFileUrl", &mut sign_params, ts);
+        let sig = self.request_sig("fileurl", &mut sign_params, ts);
 
         let resp = self
-            .get_request("track/getFileUrl")
+            .get_request("file/url")
             .query(&[
                 ("track_id", track_id.to_string()),
                 ("format_id", format.id().to_string()),
@@ -238,7 +338,28 @@ impl QobuzClient {
             .await?;
 
         let body = Self::check_response(resp).await?;
-        Ok(serde_json::from_value(body)?)
+        eprintln!(
+            "[file/url] response: {}",
+            serde_json::to_string(&body).unwrap_or_default()
+        );
+        let mut url_dto: TrackFileUrlDto = serde_json::from_value(body)?;
+
+        // Unwrap the per-track key: decrypt the CBC-wrapped key using HKDF-derived KEK.
+        if let (Some(key_field), Some(infos)) = (url_dto.key.clone(), self.session_infos.as_deref())
+        {
+            match derive_track_key(infos, &self.app_secret, &key_field) {
+                Ok(track_key) => {
+                    url_dto.key = Some(hex::encode(track_key));
+                    eprintln!("[key] track key unwrapped OK");
+                }
+                Err(e) => {
+                    eprintln!("[key] track key unwrap failed: {e}");
+                    url_dto.key = None; // disable decryption rather than play garbage
+                }
+            }
+        }
+
+        Ok(url_dto)
     }
 
     // --- Album ---
@@ -286,11 +407,153 @@ impl QobuzClient {
         Self::check_response(resp).await
     }
 
+    // --- Browse ---
+
+    pub async fn get_genres(&self) -> Result<Value> {
+        let resp = self.get_request("genre/list").send().await?;
+        Self::check_response(resp).await
+    }
+
+    pub async fn get_featured_albums(
+        &self,
+        genre_ids: &str,
+        kind: &str,
+        limit: u32,
+        offset: u32,
+    ) -> Result<Value> {
+        let resp = self
+            .get_request("album/getFeatured")
+            .query(&[
+                ("type", kind.to_string()),
+                ("genre_id", genre_ids.to_string()),
+                ("limit", limit.to_string()),
+                ("offset", offset.to_string()),
+            ])
+            .send()
+            .await?;
+        Self::check_response(resp).await
+    }
+
+    pub async fn get_featured_playlists(
+        &self,
+        genre_ids: &str,
+        kind: &str,
+        limit: u32,
+        offset: u32,
+    ) -> Result<Value> {
+        let resp = self
+            .get_request("playlist/getFeatured")
+            .query(&[
+                ("type", kind.to_string()),
+                ("genre_ids", genre_ids.to_string()),
+                ("limit", limit.to_string()),
+                ("offset", offset.to_string()),
+            ])
+            .send()
+            .await?;
+        Self::check_response(resp).await
+    }
+
+    pub async fn discover_playlists(
+        &self,
+        genre_ids: &str,
+        tags: &str,
+        limit: u32,
+        offset: u32,
+    ) -> Result<Value> {
+        let mut query = vec![
+            ("genre_ids", genre_ids.to_string()),
+            ("limit", limit.to_string()),
+            ("offset", offset.to_string()),
+        ];
+        if !tags.is_empty() {
+            query.push(("tags", tags.to_string()));
+        }
+
+        let resp = self
+            .get_request("discover/playlists")
+            .query(&query)
+            .send()
+            .await?;
+        Self::check_response(resp).await
+    }
+
+    pub async fn search_playlists(&self, query: &str, limit: u32, offset: u32) -> Result<Value> {
+        let resp = self
+            .get_request("playlist/search")
+            .query(&[
+                ("query", query.to_string()),
+                ("limit", limit.to_string()),
+                ("offset", offset.to_string()),
+            ])
+            .send()
+            .await?;
+        Self::check_response(resp).await
+    }
+
     // --- Search ---
 
     pub async fn search(&self, query: &str, offset: u32, limit: u32) -> Result<SearchCatalogDto> {
+        let (tracks_res, albums_res, artists_res) = tokio::join!(
+            self.search_tracks(query, offset, limit),
+            self.search_albums(query, offset, limit),
+            self.search_artists(query, offset, limit),
+        );
+
+        // Convert successful Results into Some(value) and Errors into None
+        Ok(SearchCatalogDto {
+            query: Some(query.to_string()),
+            tracks: tracks_res.ok(),
+            albums: albums_res.ok(),
+            artists: artists_res.ok(),
+            playlists: None,
+        })
+    }
+
+    pub async fn get_most_popular(
+        &self,
+        query: &str,
+        offset: u32,
+        limit: u32,
+    ) -> Result<Value> {
         let resp = self
-            .get_request("catalog/search")
+            .get_request("most-popular/get")
+            .query(&[
+                ("query", query.to_string()),
+                ("offset", offset.to_string()),
+                ("limit", limit.to_string()),
+            ])
+            .send()
+            .await?;
+        Self::check_response(resp).await
+    }
+
+    pub async fn get_dynamic_suggestions(
+        &self,
+        limit: u32,
+        listened_tracks_ids: Value,
+        tracks_to_analyze: Value,
+    ) -> Result<Value> {
+        let resp = self
+            .post_request("dynamic/suggest")
+            .json(&serde_json::json!({
+                "limit": limit,
+                "listened_tracks_ids": listened_tracks_ids,
+                "track_to_analysed": tracks_to_analyze,
+            }))
+            .send()
+            .await?;
+        Self::check_response(resp).await
+    }
+
+    async fn search_tracks(
+        &self,
+        query: &str,
+        offset: u32,
+        limit: u32,
+    ) -> Result<SearchResultItems<TrackDto>> {
+        let resp = self
+            .get_request("track/search")
             .query(&[
                 ("query", query),
                 ("offset", &offset.to_string()),
@@ -299,22 +562,69 @@ impl QobuzClient {
             .send()
             .await?;
         let body = Self::check_response(resp).await?;
+        Ok(serde_json::from_value(body["tracks"].clone())?)
+    }
+
+    async fn search_albums(
+        &self,
+        query: &str,
+        offset: u32,
+        limit: u32,
+    ) -> Result<SearchResultItems<AlbumDto>> {
+        let resp = self
+            .get_request("album/search")
+            .query(&[
+                ("query", query),
+                ("offset", &offset.to_string()),
+                ("limit", &limit.to_string()),
+            ])
+            .send()
+            .await?;
+        let body = Self::check_response(resp).await?;
+        Ok(serde_json::from_value(body["albums"].clone())?)
+    }
+
+    async fn search_artists(
+        &self,
+        query: &str,
+        offset: u32,
+        limit: u32,
+    ) -> Result<SearchResultItems<ArtistDto>> {
+        let resp = self
+            .get_request("artist/search")
+            .query(&[
+                ("query", query),
+                ("offset", &offset.to_string()),
+                ("limit", &limit.to_string()),
+            ])
+            .send()
+            .await?;
+        let body = Self::check_response(resp).await?;
+        Ok(serde_json::from_value(body["artists"].clone())?)
+    }
+
+    // --- Favorites / Library ---
+
+    pub async fn get_user_playlists(&self, offset: u32, limit: u32) -> Result<UserPlaylistsDto> {
+        let resp = self
+            .get_request("playlist/getUserPlaylists")
+            .query(&[
+                ("filter", "owner,subscriber"),
+                ("offset", &offset.to_string()),
+                ("limit", &limit.to_string()),
+            ])
+            .send()
+            .await?;
+        let body = Self::check_response(resp).await?;
         Ok(serde_json::from_value(body)?)
     }
 
-    // --- Favorites / Library ---
+    pub async fn get_playlist(
-
+        &self,
-    pub async fn get_user_playlists(&self, offset: u32, limit: u32) -> Result<UserPlaylistsDto> {
+        playlist_id: i64,
-        let resp = self
+        offset: u32,
-            .get_request("playlist/getUserPlaylists")
+        limit: u32,
-            .query(&[("offset", &offset.to_string()), ("limit", &limit.to_string())])
+    ) -> Result<PlaylistDto> {
-            .send()
-            .await?;
-        let body = Self::check_response(resp).await?;
-        Ok(serde_json::from_value(body)?)
-    }
-
-    pub async fn get_playlist(&self, playlist_id: i64, offset: u32, limit: u32) -> Result<PlaylistDto> {
         let resp = self
             .get_request("playlist/get")
             .query(&[
@@ -329,34 +639,190 @@ impl QobuzClient {
         Ok(serde_json::from_value(body)?)
     }
 
-    pub async fn get_fav_tracks(&self, offset: u32, limit: u32) -> Result<SearchResultItems<TrackDto>> {
+    pub async fn get_playlist_all(&self, playlist_id: i64) -> Result<PlaylistDto> {
-        let resp = self
+        const PAGE_LIMIT: u32 = 500;
-            .get_request("favorite/getUserFavorites")
+
-            .query(&[("type", "tracks"), ("offset", &offset.to_string()), ("limit", &limit.to_string())])
+        let mut playlist = self.get_playlist(playlist_id, 0, PAGE_LIMIT).await?;
-            .send()
+
-            .await?;
+        let mut all_items = playlist
-        let body = Self::check_response(resp).await?;
+            .tracks
-        Ok(serde_json::from_value(body["tracks"].clone())?)
+            .as_ref()
+            .and_then(|t| t.items.clone())
+            .unwrap_or_default();
+
+        let mut total = playlist
+            .tracks
+            .as_ref()
+            .and_then(|t| t.total)
+            .unwrap_or(all_items.len() as i32);
+        if total < all_items.len() as i32 {
+            total = all_items.len() as i32;
         }
 
-    pub async fn get_fav_albums(&self, offset: u32, limit: u32) -> Result<SearchResultItems<AlbumDto>> {
+        let mut offset = all_items.len() as u32;
-        let resp = self
+        while (offset as i32) < total {
-            .get_request("favorite/getUserFavorites")
+            let page = self.get_playlist(playlist_id, offset, PAGE_LIMIT).await?;
-            .query(&[("type", "albums"), ("offset", &offset.to_string()), ("limit", &limit.to_string())])
+            let mut page_items = page
-            .send()
+                .tracks
-            .await?;
+                .as_ref()
-        let body = Self::check_response(resp).await?;
+                .and_then(|t| t.items.clone())
-        Ok(serde_json::from_value(body["albums"].clone())?)
+                .unwrap_or_default();
+            if page_items.is_empty() {
+                break;
+            }
+            all_items.append(&mut page_items);
+            offset = all_items.len() as u32;
         }
 
-    pub async fn get_fav_artists(&self, offset: u32, limit: u32) -> Result<SearchResultItems<FavArtistDto>> {
+        if let Some(tracks) = playlist.tracks.as_mut() {
+            tracks.items = Some(all_items);
+            tracks.total = Some(total);
+            tracks.offset = Some(0);
+            tracks.limit = Some(PAGE_LIMIT as i32);
+        }
+
+        Ok(playlist)
+    }
+
+    /// Fetch all favorite IDs (tracks, albums, artists) in one call.
+    async fn get_fav_ids(&self) -> Result<FavIdsDto> {
         let resp = self
-            .get_request("favorite/getUserFavorites")
+            .get_request("favorite/getUserFavoriteIds")
-            .query(&[("type", "artists"), ("offset", &offset.to_string()), ("limit", &limit.to_string())])
             .send()
             .await?;
         let body = Self::check_response(resp).await?;
-        Ok(serde_json::from_value(body["artists"].clone())?)
+        Ok(serde_json::from_value(body)?)
+    }
+
+    /// Batch-fetch tracks by ID via POST /track/getList.
+    async fn get_tracks_by_ids(&self, ids: &[i64]) -> Result<Vec<TrackDto>> {
+        if ids.is_empty() {
+            return Ok(vec![]);
+        }
+        let resp = self
+            .post_request("track/getList")
+            .json(&serde_json::json!({ "tracks_id": ids }))
+            .send()
+            .await?;
+        let body = Self::check_response(resp).await?;
+        let items: Vec<TrackDto> =
+            serde_json::from_value(body["tracks"]["items"].clone()).unwrap_or_default();
+        Ok(items)
+    }
+
+    pub async fn get_fav_tracks(
+        &self,
+        offset: u32,
+        limit: u32,
+    ) -> Result<SearchResultItems<TrackDto>> {
+        let ids = self.get_fav_ids().await?;
+        let all_ids = ids.tracks.unwrap_or_default();
+        let total = all_ids.len() as i32;
+        let page: Vec<i64> = all_ids
+            .into_iter()
+            .skip(offset as usize)
+            .take(limit as usize)
+            .collect();
+        let items = self.get_tracks_by_ids(&page).await?;
+        Ok(SearchResultItems {
+            items: Some(items),
+            total: Some(total),
+            offset: Some(offset as i32),
+            limit: Some(limit as i32),
+        })
+    }
+
+    pub async fn get_fav_albums(
+        &self,
+        offset: u32,
+        limit: u32,
+    ) -> Result<SearchResultItems<AlbumDto>> {
+        let ids = self.get_fav_ids().await?;
+        let all_ids = ids.albums.unwrap_or_default();
+        let total = all_ids.len() as i32;
+        let page: Vec<&str> = all_ids
+            .iter()
+            .skip(offset as usize)
+            .take(limit as usize)
+            .map(|s| s.as_str())
+            .collect();
+        let mut items = Vec::with_capacity(page.len());
+        for album_id in page {
+            match self.get_album(album_id).await {
+                Ok(a) => items.push(a),
+                Err(e) => eprintln!("[fav] failed to fetch album {}: {}", album_id, e),
+            }
+        }
+        Ok(SearchResultItems {
+            items: Some(items),
+            total: Some(total),
+            offset: Some(offset as i32),
+            limit: Some(limit as i32),
+        })
+    }
+
+    pub async fn get_fav_artists(
+        &self,
+        offset: u32,
+        limit: u32,
+    ) -> Result<SearchResultItems<FavArtistDto>> {
+        let ids = self.get_fav_ids().await?;
+        let all_ids = ids.artists.unwrap_or_default();
+        let total = all_ids.len() as i32;
+        let page: Vec<i64> = all_ids
+            .into_iter()
+            .skip(offset as usize)
+            .take(limit as usize)
+            .collect();
+        let mut items = Vec::with_capacity(page.len());
+        for artist_id in page {
+            match self.get_artist_page(artist_id).await {
+                Ok(v) => {
+                    let id = v.get("id").and_then(|i| i.as_i64());
+                    let name = v
+                        .get("name")
+                        .and_then(|n| n.get("display"))
+                        .and_then(|d| d.as_str())
+                        .map(|s| s.to_string());
+
+                    let mut image_dto = None;
+                    if let Some(imgs) = v.get("images") {
+                        if let Some(portrait) = imgs.get("portrait") {
+                            if let (Some(hash), Some(format)) = (
+                                portrait.get("hash").and_then(|h| h.as_str()),
+                                portrait.get("format").and_then(|f| f.as_str()),
+                            ) {
+                                image_dto = Some(ImageDto {
+                                    small: Some(format!("https://static.qobuz.com/images/artists/covers/small/{}.{}", hash, format)),
+                                    thumbnail: Some(format!("https://static.qobuz.com/images/artists/covers/small/{}.{}", hash, format)),
+                                    large: Some(format!("https://static.qobuz.com/images/artists/covers/large/{}.{}", hash, format)),
+                                    back: None,
+                                });
+                            }
+                        }
+                    }
+
+                    if id.is_some() && name.is_some() {
+                        items.push(FavArtistDto {
+                            id,
+                            name,
+                            albums_count: v
+                                .get("albums_count")
+                                .and_then(|c| c.as_i64())
+                                .map(|c| c as i32),
+                            image: image_dto,
+                        });
+                    }
+                }
+                Err(e) => eprintln!("[fav] failed to fetch artist {}: {}", artist_id, e),
+            }
+        }
+        Ok(SearchResultItems {
+            items: Some(items),
+            total: Some(total),
+            offset: Some(offset as i32),
+            limit: Some(limit as i32),
+        })
     }
 
     // --- Playlist management ---
@@ -364,7 +830,11 @@ impl QobuzClient {
     pub async fn create_playlist(&self, name: &str) -> Result<PlaylistDto> {
         let resp = self
             .post_request("playlist/create")
-            .form(&[("name", name), ("is_public", "false"), ("is_collaborative", "false")])
+            .form(&[
+                ("name", name),
+                ("is_public", "false"),
+                ("is_collaborative", "false"),
+            ])
             .send()
             .await?;
         let body = Self::check_response(resp).await?;
@@ -395,7 +865,11 @@ impl QobuzClient {
         Ok(())
     }
 
-    pub async fn delete_track_from_playlist(&self, playlist_id: i64, playlist_track_id: i64) -> Result<()> {
+    pub async fn delete_track_from_playlist(
+        &self,
+        playlist_id: i64,
+        playlist_track_id: i64,
+    ) -> Result<()> {
         let resp = self
             .post_request("playlist/deleteTracks")
             .form(&[
@@ -408,6 +882,26 @@ impl QobuzClient {
         Ok(())
     }
 
+    pub async fn subscribe_playlist(&self, playlist_id: i64) -> Result<()> {
+        let resp = self
+            .get_request("playlist/subscribe")
+            .query(&[("playlist_id", playlist_id.to_string())])
+            .send()
+            .await?;
+        Self::check_response(resp).await?;
+        Ok(())
+    }
+
+    pub async fn unsubscribe_playlist(&self, playlist_id: i64) -> Result<()> {
+        let resp = self
+            .get_request("playlist/unsubscribe")
+            .query(&[("playlist_id", playlist_id.to_string())])
+            .send()
+            .await?;
+        Self::check_response(resp).await?;
+        Ok(())
+    }
+
     pub async fn add_fav_track(&self, track_id: i64) -> Result<()> {
         let resp = self
             .get_request("favorite/create")

rust/src/api/models.rs

@@ -74,12 +74,16 @@ pub struct AudioInfoDto {
 #[derive(Debug, Deserialize, Clone, Serialize)]
 pub struct TrackFileUrlDto {
     pub track_id: Option<i64>,
-    pub duration: Option<i64>,
+    pub duration: Option<f64>,
     pub url: Option<String>,
+    pub url_template: Option<String>,
+    pub n_segments: Option<u32>,
     pub format_id: Option<i32>,
     pub mime_type: Option<String>,
     pub sampling_rate: Option<f64>,
     pub bit_depth: Option<i32>,
+    /// qbz-1 encryption key: "qbz-1.<base64url_aes_key>.<base64url_iv>"
+    pub key: Option<String>,
 }
 
 // --- Album ---
@@ -219,6 +223,15 @@ pub struct FavArtistDto {
     pub image: Option<ImageDto>,
 }
 
+// --- Favorite IDs ---
+
+#[derive(Debug, Deserialize, Serialize)]
+pub struct FavIdsDto {
+    pub tracks: Option<Vec<i64>>,
+    pub albums: Option<Vec<String>>,
+    pub artists: Option<Vec<i64>>,
+}
+
 // --- Format ---
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]

rust/src/player/mod.rs

@@ -1,33 +1,33 @@
-mod decoder;
+pub mod decoder;
 pub mod output;
 
-use rb::{SpscRb, RB};
 use std::sync::{
-    atomic::{AtomicBool, AtomicU32, AtomicU64, AtomicU8, Ordering},
+    atomic::{AtomicBool, AtomicU64, AtomicU8, Ordering},
     Arc,
 };
 use std::time::Duration;
 
 use crate::api::TrackDto;
+use decoder::NextAction;
 
-/// Size of the visualizer ring buffer in f32 samples (~180ms at 44.1kHz stereo).
+#[derive(Clone)]
-const VIZ_RING_SIZE: usize = 16 * 1024;
-
-#[derive(Debug, Clone)]
 pub enum PlayerCommand {
     Play(TrackInfo),
+    QueueNext(TrackInfo),
     Pause,
     Resume,
     Stop,
     SetVolume(u8),
 }
 
-#[derive(Debug, Clone)]
+#[derive(Clone)]
 pub struct TrackInfo {
     pub track: TrackDto,
     pub url: String,
-    /// ReplayGain track gain in dB, if enabled and available.
+    pub n_segments: u32,
+    pub encryption_key: Option<String>,
     pub replaygain_db: Option<f64>,
+    pub prefetch_data: Option<decoder::PrefetchData>,
 }
 
 #[derive(Debug, Clone, PartialEq)]
@@ -45,26 +45,16 @@ pub struct PlayerStatus {
     pub duration_secs: Arc<AtomicU64>,
     pub volume: Arc<AtomicU8>,
     pub current_track: Arc<std::sync::Mutex<Option<TrackDto>>>,
-    /// Set to true by the decode thread when a track finishes naturally.
     pub track_finished: Arc<AtomicBool>,
-    /// Set by the player loop when a seek command arrives; cleared by the decode thread.
+    pub track_transitioned: Arc<AtomicBool>,
     pub seek_requested: Arc<AtomicBool>,
     pub seek_target_secs: Arc<AtomicU64>,
-    /// Linear gain factor to apply (1.0 = unity). Updated each time a new track starts.
     pub replaygain_gain: Arc<std::sync::Mutex<f32>>,
-    /// When false the audio output is torn down after each track, producing a gap.
     pub gapless: Arc<AtomicBool>,
-    /// Visualizer ring buffer (consumer side, read by FFI).
-    pub viz_ring: Arc<SpscRb<f32>>,
-    pub viz_consumer: Arc<std::sync::Mutex<rb::Consumer<f32>>>,
-    pub viz_sample_rate: Arc<AtomicU32>,
-    pub viz_channels: Arc<AtomicU32>,
 }
 
 impl PlayerStatus {
     pub fn new() -> Self {
-        let viz_ring = Arc::new(SpscRb::new(VIZ_RING_SIZE));
-        let viz_consumer = Arc::new(std::sync::Mutex::new(viz_ring.consumer()));
         Self {
             state: Arc::new(std::sync::Mutex::new(PlayerState::Idle)),
             position_secs: Arc::new(AtomicU64::new(0)),
@@ -72,33 +62,26 @@ impl PlayerStatus {
             volume: Arc::new(AtomicU8::new(80)),
             current_track: Arc::new(std::sync::Mutex::new(None)),
             track_finished: Arc::new(AtomicBool::new(false)),
+            track_transitioned: Arc::new(AtomicBool::new(false)),
             seek_requested: Arc::new(AtomicBool::new(false)),
             seek_target_secs: Arc::new(AtomicU64::new(0)),
             replaygain_gain: Arc::new(std::sync::Mutex::new(1.0)),
             gapless: Arc::new(AtomicBool::new(false)),
-            viz_ring,
-            viz_consumer,
-            viz_sample_rate: Arc::new(AtomicU32::new(0)),
-            viz_channels: Arc::new(AtomicU32::new(0)),
         }
     }
 
     pub fn get_state(&self) -> PlayerState {
         self.state.lock().unwrap().clone()
     }
-
     pub fn get_position(&self) -> u64 {
         self.position_secs.load(Ordering::Relaxed)
     }
-
     pub fn get_duration(&self) -> u64 {
         self.duration_secs.load(Ordering::Relaxed)
     }
-
     pub fn get_volume(&self) -> u8 {
         self.volume.load(Ordering::Relaxed)
     }
-
 }
 
 pub struct Player {
@@ -122,51 +105,45 @@ impl Player {
     pub fn send(&self, cmd: PlayerCommand) {
         self.cmd_tx.send(cmd).ok();
     }
-
     pub fn pause(&self) {
         self.send(PlayerCommand::Pause);
     }
-
     pub fn resume(&self) {
         self.send(PlayerCommand::Resume);
     }
-
     pub fn stop(&self) {
         self.send(PlayerCommand::Stop);
     }
-
     pub fn set_volume(&self, vol: u8) {
         self.status.volume.store(vol, Ordering::Relaxed);
         self.send(PlayerCommand::SetVolume(vol));
     }
-
     pub fn seek(&self, secs: u64) {
         self.status.seek_target_secs.store(secs, Ordering::Relaxed);
         self.status.seek_requested.store(true, Ordering::SeqCst);
     }
 }
 
-/// The player loop runs on a single dedicated OS thread.
-/// It owns the `AudioOutput` locally so there are no Send constraints.
-/// Decoding is performed inline; the command channel is polled via try_recv
-/// inside the decode loop to handle Pause/Resume/Seek/Stop/Play without
-/// tearng down and re-opening the audio device between tracks.
 fn player_loop(rx: std::sync::mpsc::Receiver<PlayerCommand>, status: PlayerStatus) {
     use std::sync::mpsc::RecvTimeoutError;
 
     let mut audio_output: Option<output::AudioOutput> = None;
     let paused = Arc::new(AtomicBool::new(false));
-    // pending_info holds a Play command that interrupted an ongoing decode
+    let mut pending_action: Option<NextAction> = None;
-    let mut pending_info: Option<TrackInfo> = None;
 
     'outer: loop {
-        // Wait for a Play command (or use one that was interrupted)
+        let info = if let Some(action) = pending_action.take() {
-        let info = if let Some(p) = pending_info.take() {
+            match action {
-            p
+                NextAction::Play(info) | NextAction::Transition(info) => info,
+            }
         } else {
             loop {
                 match rx.recv_timeout(Duration::from_millis(100)) {
                     Ok(PlayerCommand::Play(info)) => break info,
+                    Ok(PlayerCommand::QueueNext(info)) => {
+                        // If we are completely idle and get QueueNext, treat as Play
+                        break info;
+                    }
                     Ok(PlayerCommand::Stop) => {
                         audio_output = None;
                         paused.store(false, Ordering::SeqCst);
@@ -178,15 +155,15 @@ fn player_loop(rx: std::sync::mpsc::Receiver<PlayerCommand>, status: PlayerStatu
                     Ok(PlayerCommand::SetVolume(v)) => {
                         status.volume.store(v, Ordering::Relaxed);
                     }
-                    Ok(_) => {} // Pause/Resume ignored when idle
+                    Ok(_) => {} // Ignore Pause/Resume when idle
                     Err(RecvTimeoutError::Timeout) => {}
                     Err(RecvTimeoutError::Disconnected) => break 'outer,
                 }
             }
         };
 
-        // Compute ReplayGain factor
+        let rg_factor = info
-        let rg_factor = info.replaygain_db
+            .replaygain_db
             .map(|db| 10f32.powf(db as f32 / 20.0))
             .unwrap_or(1.0);
         *status.replaygain_gain.lock().unwrap() = rg_factor;
@@ -199,13 +176,17 @@ fn player_loop(rx: std::sync::mpsc::Receiver<PlayerCommand>, status: PlayerStatu
         status.position_secs.store(0, Ordering::Relaxed);
         paused.store(false, Ordering::SeqCst);
 
-        match decoder::play_track_inline(&info.url, &status, &paused, &mut audio_output, &rx) {
+        // TrackInfo now directly passes the prefetch_data (if it exists) to the decoder
-            Ok(Some(next_info)) => {
+        match decoder::play_track_inline(info, &status, &paused, &mut audio_output, &rx) {
-                // Interrupted by a new Play — loop immediately with reused audio output
+            Ok(Some(NextAction::Play(next_track))) => {
-                pending_info = Some(next_info);
+                pending_action = Some(NextAction::Play(next_track));
+                // Interrupted by a manual play, no need to tell C++ to advance the queue
+            }
+            Ok(Some(NextAction::Transition(next_track))) => {
+                pending_action = Some(NextAction::Play(next_track));
+                status.track_transitioned.store(true, Ordering::SeqCst);
             }
             Ok(None) => {
-                // Track finished naturally — tear down audio output if gapless is off
                 if !status.gapless.load(Ordering::Relaxed) {
                     audio_output = None;
                 }
@@ -215,8 +196,6 @@ fn player_loop(rx: std::sync::mpsc::Receiver<PlayerCommand>, status: PlayerStatu
             Err(e) => {
                 eprintln!("playback error: {e}");
                 *status.state.lock().unwrap() = PlayerState::Error(e.to_string());
-                // Signal track end so the queue advances to the next track
-                // instead of stalling on an unplayable track.
                 status.track_finished.store(true, Ordering::SeqCst);
             }
         }

rust/src/player/output.rs

@@ -3,7 +3,7 @@ use cpal::{
     traits::{DeviceTrait, HostTrait, StreamTrait},
     StreamConfig,
 };
-use rb::{RbConsumer, RbProducer, SpscRb, RB};
+use rb::{RbConsumer, RbInspector, RbProducer, SpscRb, RB};
 use std::sync::{
     atomic::{AtomicBool, Ordering},
     Arc,
@@ -13,8 +13,8 @@ use symphonia::core::audio::AudioBufferRef;
 const RING_BUFFER_SIZE: usize = 32 * 1024;
 
 pub struct AudioOutput {
+    _ring: SpscRb<f32>,
     ring_buf_producer: rb::Producer<f32>,
-    viz_producer: Option<rb::Producer<f32>>,
     _stream: cpal::Stream,
     pub sample_rate: u32,
     pub channels: usize,
@@ -51,18 +51,14 @@ impl AudioOutput {
         stream.play()?;
 
         Ok(Self {
+            _ring: ring,
             ring_buf_producer: producer,
-            viz_producer: None,
             _stream: stream,
             sample_rate,
             channels,
         })
     }
 
-    pub fn set_viz_producer(&mut self, producer: rb::Producer<f32>) {
-        self.viz_producer = Some(producer);
-    }
-
     pub fn write(
         &mut self,
         decoded: AudioBufferRef<'_>,
@@ -75,13 +71,13 @@ impl AudioOutput {
         );
         sample_buf.copy_interleaved_ref(decoded);
         let samples: Vec<f32> = sample_buf.samples().iter().map(|s| s * volume).collect();
-
+        self.write_samples(&samples, stop)
-        // Best-effort copy for visualizer (non-blocking, ok to drop samples)
-        if let Some(ref mut viz) = self.viz_producer {
-            let _ = viz.write(&samples);
     }
 
-        let mut remaining = &samples[..];
+    /// Write pre-converted interleaved f32 samples directly to the ring buffer.
+    /// Returns early (without error) if `stop` is set.
+    pub fn write_samples(&mut self, samples: &[f32], stop: &Arc<AtomicBool>) -> Result<()> {
+        let mut remaining = samples;
         while !remaining.is_empty() {
             if stop.load(Ordering::SeqCst) {
                 return Ok(());
@@ -93,4 +89,14 @@ impl AudioOutput {
         }
         Ok(())
     }
+
+    #[allow(dead_code)]
+    pub fn flush(&self) {
+        // Wait until the ring buffer is fully emptied by cpal
+        while !self._ring.is_empty() {
+            std::thread::sleep(std::time::Duration::from_millis(10));
+        }
+        // Give the physical DAC an extra 100ms to output the last samples
+        std::thread::sleep(std::time::Duration::from_millis(100));
+    }
 }

src/CMakeLists.txt

@@ -6,8 +6,9 @@ target_sources(qobuz-qt PRIVATE
     mainwindow.hpp
     mainwindow.cpp
 
-    # Queue (header-only)
+    # Queue
     playqueue.hpp
+    playqueue.cpp
 
     # Backend (Qt wrapper around Rust FFI)
     backend/qobuzbackend.hpp
@@ -26,6 +27,8 @@ target_sources(qobuz-qt PRIVATE
     view/artistlistview.hpp
     view/artistview.hpp
     view/artistview.cpp
+    view/genrebrowser.hpp
+    view/genrebrowser.cpp
     view/sidepanel/view.hpp
     view/sidepanel/view.cpp
 
@@ -56,3 +59,10 @@ target_sources(qobuz-qt PRIVATE
     util/icon.hpp
     util/settings.hpp
 )
+
+if (USE_DBUS)
+    target_sources(qobuz-qt PRIVATE
+        backend/mpris.hpp
+        backend/mpris.cpp
+    )
+endif ()

src/backend/mpris.cpp

@@ -0,0 +1,29 @@
+#include "mpris.hpp"
+
+#include <QDBusConnection>
+#include <QCoreApplication>
+#include <QProcess>
+
+MprisRootAdaptor::MprisRootAdaptor(QObject *parent)
+    : QDBusAbstractAdaptor(parent)
+{
+}
+
+MprisPlayerAdaptor::MprisPlayerAdaptor(QObject *parent)
+    : QDBusAbstractAdaptor(parent)
+{
+}
+
+Mpris::Mpris(QObject *parent)
+    : QObject(parent)
+{
+    m_root = new MprisRootAdaptor(this);
+    m_player = new MprisPlayerAdaptor(this);
+
+    QDBusConnection dbus = QDBusConnection::sessionBus();
+    QString serviceName = QString("org.mpris.MediaPlayer2.qobuz_qt.instance%1").arg(QCoreApplication::applicationPid());
+    
+    dbus.registerService(serviceName);
+    dbus.registerObject("/org/mpris/MediaPlayer2", this, 
+                        QDBusConnection::ExportAdaptors);
+}

src/backend/mpris.hpp

@@ -0,0 +1,165 @@
+#pragma once
+
+#include <QObject>
+#include <QString>
+#include <QStringList>
+#include <QVariantMap>
+#include <QDBusAbstractAdaptor>
+#include <QDBusObjectPath>
+
+class MprisRootAdaptor : public QDBusAbstractAdaptor
+{
+    Q_OBJECT
+    Q_CLASSINFO("D-Bus Interface", "org.mpris.MediaPlayer2")
+    
+    Q_PROPERTY(bool CanQuit READ canQuit)
+    Q_PROPERTY(bool Fullscreen READ fullscreen WRITE setFullscreen)
+    Q_PROPERTY(bool CanSetFullscreen READ canSetFullscreen)
+    Q_PROPERTY(bool CanRaise READ canRaise)
+    Q_PROPERTY(bool HasTrackList READ hasTrackList)
+    Q_PROPERTY(QString Identity READ identity)
+    Q_PROPERTY(QString DesktopEntry READ desktopEntry)
+    Q_PROPERTY(QStringList SupportedUriSchemes READ supportedUriSchemes)
+    Q_PROPERTY(QStringList SupportedMimeTypes READ supportedMimeTypes)
+
+public:
+    explicit MprisRootAdaptor(QObject *parent);
+
+    bool canQuit() const { return true; }
+    bool fullscreen() const { return false; }
+    void setFullscreen(bool) {}
+    bool canSetFullscreen() const { return false; }
+    bool canRaise() const { return true; }
+    bool hasTrackList() const { return false; } 
+    QString identity() const { return "Qobuz"; }
+    QString desktopEntry() const { return "qobuz-qt"; }
+    QStringList supportedUriSchemes() const { return {}; }
+    QStringList supportedMimeTypes() const { return {}; }
+
+public slots:
+    void Quit() { emit quitRequested(); }
+    void Raise() { emit raiseRequested(); }
+
+signals:
+    void quitRequested();
+    void raiseRequested();
+};
+
+class MprisPlayerAdaptor : public QDBusAbstractAdaptor
+{
+    Q_OBJECT
+    Q_CLASSINFO("D-Bus Interface", "org.mpris.MediaPlayer2.Player")
+
+    Q_PROPERTY(QString PlaybackStatus READ playbackStatus NOTIFY playbackStatusChanged)
+    Q_PROPERTY(QString LoopStatus READ loopStatus WRITE setLoopStatus)
+    Q_PROPERTY(double Rate READ rate WRITE setRate)
+    Q_PROPERTY(bool Shuffle READ shuffle WRITE setShuffle)
+    Q_PROPERTY(QVariantMap Metadata READ metadata NOTIFY metadataChanged)
+    Q_PROPERTY(double Volume READ volume WRITE setVolume NOTIFY volumeChanged)
+    Q_PROPERTY(qlonglong Position READ position)
+    Q_PROPERTY(double MinimumRate READ minimumRate)
+    Q_PROPERTY(double MaximumRate READ maximumRate)
+    Q_PROPERTY(bool CanGoNext READ canGoNext)
+    Q_PROPERTY(bool CanGoPrevious READ canGoPrevious)
+    Q_PROPERTY(bool CanPlay READ canPlay)
+    Q_PROPERTY(bool CanPause READ canPause)
+    Q_PROPERTY(bool CanSeek READ canSeek)
+    Q_PROPERTY(bool CanControl READ canControl)
+
+public:
+    explicit MprisPlayerAdaptor(QObject *parent);
+
+    QString playbackStatus() const { return m_playbackStatus; }
+    void setPlaybackStatus(const QString &s) {
+        if (m_playbackStatus != s) {
+            m_playbackStatus = s;
+            emit playbackStatusChanged();
+        }
+    }
+
+    QString loopStatus() const { return "None"; }
+    void setLoopStatus(const QString &) {}
+
+    double rate() const { return 1.0; }
+    void setRate(double) {}
+
+    bool shuffle() const { return false; }
+    void setShuffle(bool) {}
+
+    QVariantMap metadata() const { return m_metadata; }
+    void setMetadata(const QVariantMap &m) { 
+        m_metadata = m; 
+        emit metadataChanged(); 
+    }
+
+    double volume() const { return m_volume; }
+    void setVolume(double v) { 
+        emit volumeChangeRequested(v); 
+    }
+    void updateVolume(double v) {
+        if (m_volume != v) {
+            m_volume = v;
+            emit volumeChanged();
+        }
+    }
+
+    qlonglong position() const { return m_positionMicro; }
+    void updatePosition(qlonglong posSecs) { m_positionMicro = posSecs * 1000000LL; }
+
+    double minimumRate() const { return 1.0; }
+    double maximumRate() const { return 1.0; }
+
+    bool canGoNext() const { return true; }
+    bool canGoPrevious() const { return true; }
+    bool canPlay() const { return true; }
+    bool canPause() const { return true; }
+    bool canSeek() const { return true; }
+    bool canControl() const { return true; }
+
+public slots:
+    void Next() { emit nextRequested(); }
+    void Previous() { emit previousRequested(); }
+    void Pause() { emit pauseRequested(); }
+    void PlayPause() { emit playPauseRequested(); }
+    void Stop() { emit stopRequested(); }
+    void Play() { emit playRequested(); }
+    void Seek(qlonglong offset) { emit seekRequested(offset); }
+    void SetPosition(const QDBusObjectPath &trackId, qlonglong position) { Q_UNUSED(trackId); emit seekToRequested(position); }
+    void OpenUri(const QString &uri) { Q_UNUSED(uri); }
+
+signals:
+    void playbackStatusChanged();
+    void metadataChanged();
+    void volumeChanged();
+
+    // Commands to MainWindow
+    void playRequested();
+    void pauseRequested();
+    void playPauseRequested();
+    void stopRequested();
+    void nextRequested();
+    void previousRequested();
+    void seekRequested(qlonglong offsetMicroseconds);
+    void seekToRequested(qlonglong positionMicroseconds);
+    void volumeChangeRequested(double volume);
+
+private:
+    QString m_playbackStatus = "Stopped";
+    QVariantMap m_metadata;
+    double m_volume = 1.0;
+    qlonglong m_positionMicro = 0;
+};
+
+class Mpris : public QObject
+{
+    Q_OBJECT
+public:
+    explicit Mpris(QObject *parent = nullptr);
+
+    MprisRootAdaptor *root() const { return m_root; }
+    MprisPlayerAdaptor *player() const { return m_player; }
+
+private:
+    MprisRootAdaptor *m_root;
+    MprisPlayerAdaptor *m_player;
+};

src/backend/qobuzbackend.cpp

@@ -51,6 +51,22 @@ void QobuzBackend::search(const QString &query, quint32 offset, quint32 limit)
     qobuz_backend_search(m_backend, query.toUtf8().constData(), offset, limit);
 }
 
+void QobuzBackend::mostPopularSearch(const QString &query, quint32 limit)
+{
+    qobuz_backend_most_popular_search(m_backend, query.toUtf8().constData(), limit);
+}
+
+void QobuzBackend::getDynamicSuggestions(const QJsonArray &listenedTrackIds, const QJsonArray &tracksToAnalyze, quint32 limit)
+{
+    const QByteArray listened = QJsonDocument(listenedTrackIds).toJson(QJsonDocument::Compact);
+    const QByteArray analyze = QJsonDocument(tracksToAnalyze).toJson(QJsonDocument::Compact);
+    qobuz_backend_get_dynamic_suggestions(
+        m_backend,
+        listened.constData(),
+        analyze.constData(),
+        limit);
+}
+
 void QobuzBackend::getAlbum(const QString &albumId)
 {
     qobuz_backend_get_album(m_backend, albumId.toUtf8().constData());
@@ -79,6 +95,41 @@ void QobuzBackend::getPlaylist(qint64 playlistId, quint32 offset, quint32 limit)
     qobuz_backend_get_playlist(m_backend, playlistId, offset, limit);
 }
 
+void QobuzBackend::getPlaylistAll(qint64 playlistId)
+{
+    qobuz_backend_get_playlist_all(m_backend, playlistId);
+}
+
+void QobuzBackend::getGenres()
+{
+    qobuz_backend_get_genres(m_backend);
+}
+
+void QobuzBackend::getFeaturedAlbums(const QString &genreIds, const QString &kind, quint32 limit, quint32 offset)
+{
+    qobuz_backend_get_featured_albums(m_backend, genreIds.toUtf8().constData(), kind.toUtf8().constData(), limit, offset);
+}
+
+void QobuzBackend::getFeaturedPlaylists(const QString &genreIds, const QString &kind, quint32 limit, quint32 offset)
+{
+    qobuz_backend_get_featured_playlists(m_backend, genreIds.toUtf8().constData(), kind.toUtf8().constData(), limit, offset);
+}
+
+void QobuzBackend::discoverPlaylists(const QString &genreIds, const QString &tags, quint32 limit, quint32 offset)
+{
+    qobuz_backend_discover_playlists(
+        m_backend,
+        genreIds.toUtf8().constData(),
+        tags.toUtf8().constData(),
+        limit,
+        offset);
+}
+
+void QobuzBackend::searchPlaylists(const QString &query, quint32 limit, quint32 offset)
+{
+    qobuz_backend_search_playlists(m_backend, query.toUtf8().constData(), limit, offset);
+}
+
 // ---- favorites ----
 
 void QobuzBackend::getFavTracks(quint32 offset, quint32 limit)
@@ -140,6 +191,16 @@ void QobuzBackend::deleteTrackFromPlaylist(qint64 playlistId, qint64 playlistTra
     qobuz_backend_delete_track_from_playlist(m_backend, playlistId, playlistTrackId);
 }
 
+void QobuzBackend::subscribePlaylist(qint64 playlistId)
+{
+    qobuz_backend_subscribe_playlist(m_backend, playlistId);
+}
+
+void QobuzBackend::unsubscribePlaylist(qint64 playlistId)
+{
+    qobuz_backend_unsubscribe_playlist(m_backend, playlistId);
+}
+
 // ---- fav modification ----
 
 void QobuzBackend::addFavTrack(qint64 trackId)
@@ -209,21 +270,6 @@ quint64 QobuzBackend::duration() const { return qobuz_backend_get_duration(m_bac
 int     QobuzBackend::volume()   const { return qobuz_backend_get_volume(m_backend); }
 int     QobuzBackend::state()    const { return qobuz_backend_get_state(m_backend); }
 
-quint32 QobuzBackend::vizRead(float *buf, quint32 maxSamples)
-{
-    return qobuz_backend_viz_read(m_backend, buf, maxSamples);
-}
-
-quint32 QobuzBackend::vizSampleRate() const
-{
-    return qobuz_backend_viz_sample_rate(m_backend);
-}
-
-quint32 QobuzBackend::vizChannels() const
-{
-    return qobuz_backend_viz_channels(m_backend);
-}
-
 // ---- private slots ----
 
 void QobuzBackend::onPositionTick()
@@ -232,6 +278,9 @@ void QobuzBackend::onPositionTick()
 
     if (qobuz_backend_take_track_finished(m_backend))
         emit trackFinished();
+        
+    if (qobuz_backend_take_track_transitioned(m_backend))
+        emit trackTransitioned();
 }
 
 void QobuzBackend::onEvent(int eventType, const QString &json)
@@ -253,6 +302,9 @@ void QobuzBackend::onEvent(int eventType, const QString &json)
     case EV_SEARCH_OK:
         emit searchResult(obj);
         break;
+    case EV_MOST_POPULAR_OK:
+        emit mostPopularResult(obj);
+        break;
     case EV_SEARCH_ERR:
         emit error(obj["error"].toString());
         break;
@@ -265,7 +317,7 @@ void QobuzBackend::onEvent(int eventType, const QString &json)
     case EV_ARTIST_OK:
         emit artistLoaded(obj);
         break;
-    case 24: // EV_ARTIST_RELEASES_OK
+    case EV_ARTIST_RELEASES_OK:
         emit artistReleasesLoaded(
             obj["release_type"].toString(),
             obj["items"].toArray(),
@@ -273,9 +325,27 @@ void QobuzBackend::onEvent(int eventType, const QString &json)
             obj["offset"].toInt()
         );
         break;
-    case 25: // EV_DEEP_SHUFFLE_OK
+    case EV_DEEP_SHUFFLE_OK:
         emit deepShuffleTracksLoaded(obj["tracks"].toArray());
         break;
+    case EV_DYNAMIC_SUGGEST_OK:
+        emit dynamicSuggestionsLoaded(obj);
+        break;
+    case EV_GENRES_OK:
+        emit genresLoaded(obj);
+        break;
+    case EV_FEATURED_ALBUMS_OK:
+        emit featuredAlbumsLoaded(obj);
+        break;
+    case EV_FEATURED_PLAYLISTS_OK:
+        emit featuredPlaylistsLoaded(obj);
+        break;
+    case EV_DISCOVER_PLAYLISTS_OK:
+        emit discoverPlaylistsLoaded(obj);
+        break;
+    case EV_PLAYLIST_SEARCH_OK:
+        emit playlistSearchLoaded(obj);
+        break;
     case EV_ARTIST_ERR:
         emit error(obj["error"].toString());
         break;
@@ -303,15 +373,21 @@ void QobuzBackend::onEvent(int eventType, const QString &json)
     case EV_STATE_CHANGED:
         emit stateChanged(obj["state"].toString());
         break;
-    case 20: // EV_PLAYLIST_CREATED
+    case EV_PLAYLIST_CREATED:
         emit playlistCreated(obj);
         break;
-    case 21: // EV_PLAYLIST_DELETED
+    case EV_PLAYLIST_DELETED:
         emit playlistDeleted(obj);
         break;
-    case 22: // EV_PLAYLIST_TRACK_ADDED
+    case EV_PLAYLIST_TRACK_ADDED:
         emit playlistTrackAdded(static_cast<qint64>(obj["playlist_id"].toDouble()));
         break;
+    case EV_PLAYLIST_SUBSCRIBED:
+        emit playlistSubscribed(static_cast<qint64>(obj["playlist_id"].toDouble()));
+        break;
+    case EV_PLAYLIST_UNSUBSCRIBED:
+        emit playlistUnsubscribed(static_cast<qint64>(obj["playlist_id"].toDouble()));
+        break;
     case EV_USER_OK:
         emit userLoaded(obj);
         break;

src/backend/qobuzbackend.hpp

@@ -28,17 +28,25 @@ public:
 
     // --- catalog ---
     void search(const QString &query, quint32 offset = 0, quint32 limit = 20);
+    void mostPopularSearch(const QString &query, quint32 limit = 8);
+    void getDynamicSuggestions(const QJsonArray &listenedTrackIds, const QJsonArray &tracksToAnalyze, quint32 limit = 50);
     void getAlbum(const QString &albumId);
     void getArtist(qint64 artistId);
     void getArtistReleases(qint64 artistId, const QString &releaseType, quint32 limit = 50, quint32 offset = 0);
     void getAlbumsTracks(const QStringList &albumIds);
     void getPlaylist(qint64 playlistId, quint32 offset = 0, quint32 limit = 500);
+    void getPlaylistAll(qint64 playlistId);
+    void getGenres();
+    void getFeaturedAlbums(const QString &genreIds, const QString &kind, quint32 limit = 50, quint32 offset = 0);
+    void getFeaturedPlaylists(const QString &genreIds, const QString &kind, quint32 limit = 25, quint32 offset = 0);
+    void discoverPlaylists(const QString &genreIds, const QString &tags = QString(), quint32 limit = 25, quint32 offset = 0);
+    void searchPlaylists(const QString &query, quint32 limit = 8, quint32 offset = 0);
 
     // --- favorites ---
     void getFavTracks(quint32 offset = 0, quint32 limit = 500);
     void getFavAlbums(quint32 offset = 0, quint32 limit = 200);
     void getFavArtists(quint32 offset = 0, quint32 limit = 200);
-    void getUserPlaylists(quint32 offset = 0, quint32 limit = 200);
+    void getUserPlaylists(quint32 offset = 0, quint32 limit = 350);
 
     // --- playback options ---
     void setReplayGain(bool enabled);
@@ -50,6 +58,8 @@ public:
     void deletePlaylist(qint64 playlistId);
     void addTrackToPlaylist(qint64 playlistId, qint64 trackId);
     void deleteTrackFromPlaylist(qint64 playlistId, qint64 playlistTrackId);
+    void subscribePlaylist(qint64 playlistId);
+    void unsubscribePlaylist(qint64 playlistId);
 
     // --- fav modification ---
     void addFavTrack(qint64 trackId);
@@ -73,11 +83,6 @@ public:
     /// 1 = playing, 2 = paused, 0 = idle
     int     state() const;
 
-    // --- visualizer PCM ---
-    quint32 vizRead(float *buf, quint32 maxSamples);
-    quint32 vizSampleRate() const;
-    quint32 vizChannels() const;
-
 signals:
     // auth
     void loginSuccess(const QString &token, const QJsonObject &user);
@@ -86,14 +91,23 @@ signals:
 
     // catalog
     void searchResult(const QJsonObject &result);
+    void mostPopularResult(const QJsonObject &result);
     void albumLoaded(const QJsonObject &album);
     void artistLoaded(const QJsonObject &artist);
     void artistReleasesLoaded(const QString &releaseType, const QJsonArray &items, bool hasMore, int offset);
     void deepShuffleTracksLoaded(const QJsonArray &tracks);
+    void dynamicSuggestionsLoaded(const QJsonObject &result);
+    void genresLoaded(const QJsonObject &result);
+    void featuredAlbumsLoaded(const QJsonObject &result);
+    void featuredPlaylistsLoaded(const QJsonObject &result);
+    void discoverPlaylistsLoaded(const QJsonObject &result);
+    void playlistSearchLoaded(const QJsonObject &result);
     void playlistLoaded(const QJsonObject &playlist);
     void playlistCreated(const QJsonObject &playlist);
     void playlistDeleted(const QJsonObject &result);
     void playlistTrackAdded(qint64 playlistId);
+    void playlistSubscribed(qint64 playlistId);
+    void playlistUnsubscribed(qint64 playlistId);
 
     // favorites
     void favTracksLoaded(const QJsonObject &result);
@@ -106,6 +120,7 @@ signals:
     void stateChanged(const QString &state);
     void positionChanged(quint64 position, quint64 duration);
     void trackFinished();
+    void trackTransitioned();
 
     // errors
     void error(const QString &message);
@@ -114,6 +129,11 @@ private slots:
     Q_INVOKABLE void onEvent(int eventType, const QString &json);
     void onPositionTick();
 
+public:
+    void manuallyEmitTrackChanged(const QJsonObject &track) {
+        emit trackChanged(track);
+    }
+
 private:
     QobuzBackendOpaque *m_backend = nullptr;
     QTimer *m_positionTimer = nullptr;

src/list/library.cpp

@@ -20,6 +20,8 @@ enum NodeType {
     NodeFavAlbums,
     NodeFavArtists,
     NodePlaylist,
+    NodeBrowseGenres,
+    NodeBrowsePlaylists,
 };
 
 Library::Library(QobuzBackend *backend, QWidget *parent)
@@ -71,6 +73,16 @@ void Library::buildStaticNodes()
     // Playlists
     m_playlistsNode = new QTreeWidgetItem(this, QStringList{tr("Playlists")});
     m_playlistsNode->setExpanded(true);
+
+    // Browse
+    m_browseNode = new QTreeWidgetItem(this, QStringList{tr("Browse")});
+    m_browseNode->setExpanded(true);
+
+    auto *genresItem = new QTreeWidgetItem(m_browseNode, QStringList{tr("Genres")});
+    genresItem->setData(0, TypeRole, NodeBrowseGenres);
+
+    auto *playlistsItem = new QTreeWidgetItem(m_browseNode, QStringList{tr("Playlists")});
+    playlistsItem->setData(0, TypeRole, NodeBrowsePlaylists);
 }
 
 void Library::refresh()
@@ -87,6 +99,7 @@ void Library::onUserPlaylistsLoaded(const QJsonObject &result)
     while (m_playlistsNode->childCount() > 0)
         delete m_playlistsNode->takeChild(0);
 
+    QSet<qint64> allPlaylistIds;
     QVector<QPair<qint64, QString>> editablePlaylists;
     const qint64 myUserId = AppSettings::instance().userId();
     const QJsonArray items = result["items"].toArray();
@@ -97,6 +110,9 @@ void Library::onUserPlaylistsLoaded(const QJsonObject &result)
         const qint64      ownId = static_cast<qint64>(pl["owner"].toObject()["id"].toDouble());
         const bool        isOwner = (myUserId > 0 && ownId == myUserId);
 
+        if (id > 0)
+            allPlaylistIds.insert(id);
+
         auto *item = new QTreeWidgetItem(m_playlistsNode, QStringList{name});
         item->setData(0, TypeRole,    NodePlaylist);
         item->setData(0, IdRole,      id);
@@ -108,6 +124,7 @@ void Library::onUserPlaylistsLoaded(const QJsonObject &result)
             editablePlaylists.append({id, name});
     }
 
+    emit userPlaylistIdsChanged(allPlaylistIds);
     emit userPlaylistsChanged(editablePlaylists);
 }
 
@@ -167,6 +184,8 @@ void Library::onItemClicked(QTreeWidgetItem *item, int)
     case NodeFavTracks:  emit favTracksRequested();  break;
     case NodeFavAlbums:  emit favAlbumsRequested();  break;
     case NodeFavArtists: emit favArtistsRequested(); break;
+    case NodeBrowseGenres: emit browseGenresRequested(); break;
+    case NodeBrowsePlaylists: emit browsePlaylistsRequested(); break;
     case NodePlaylist: {
         const qint64  id   = item->data(0, IdRole).toLongLong();
         const QString name = item->data(0, NameRole).toString();

src/list/library.hpp

@@ -7,6 +7,7 @@
 #include <QVector>
 #include <QPair>
 #include <QString>
+#include <QSet>
 
 namespace List
 {
@@ -26,9 +27,13 @@ namespace List
         void favTracksRequested();
         void favAlbumsRequested();
         void favArtistsRequested();
+        void browseGenresRequested();
+        void browsePlaylistsRequested();
         void playlistRequested(qint64 playlistId, const QString &name);
         /// Emitted after playlists are loaded so others can cache the list.
         void userPlaylistsChanged(const QVector<QPair<qint64, QString>> &playlists);
+        /// Emitted with all user playlist IDs (owned + subscribed).
+        void userPlaylistIdsChanged(const QSet<qint64> &playlistIds);
         /// Emitted when the currently open playlist was deleted.
         void openPlaylistDeleted();
 
@@ -43,6 +48,7 @@ namespace List
 
         QTreeWidgetItem *m_myLibNode     = nullptr;
         QTreeWidgetItem *m_playlistsNode = nullptr;
+        QTreeWidgetItem *m_browseNode    = nullptr;
         qint64           m_openPlaylistId = 0;
 
         void buildStaticNodes();

src/list/tracks.cpp

@@ -5,6 +5,7 @@
 #include <QHeaderView>
 #include <QMenu>
 #include <QAction>
+#include <QScrollBar>
 
 namespace List
 {
@@ -41,12 +42,45 @@ Tracks::Tracks(QobuzBackend *backend, PlayQueue *queue, QWidget *parent)
             setFirstColumnSpanned(row, {}, true);
         setSortingEnabled(!m_model->hasMultipleDiscs());
     });
+    connect(verticalScrollBar(), &QScrollBar::valueChanged,
+            this, [this](int) { maybeLoadMorePlaylistTracks(); });
+
+    connect(m_backend, &QobuzBackend::playlistLoaded, this,
+            [this](const QJsonObject &playlist) {
+        if (!m_pendingPlayAll)
+            return;
+
+        const qint64 id = static_cast<qint64>(playlist["id"].toDouble());
+        if (id != m_playlistId)
+            return;
+
+        if (!playlist["full_load"].toBool())
+            return;
+
+        m_pendingPlayAll = false;
+        const bool shuffle = m_pendingPlayAllShuffle;
+        m_pendingPlayAllShuffle = false;
+
+        const QJsonArray items = playlist["tracks"].toObject()["items"].toArray();
+        if (items.isEmpty())
+            return;
+
+        m_queue->setContext(items, 0);
+        if (shuffle && !m_queue->shuffleEnabled())
+            m_queue->shuffleNow();
+
+        const qint64 firstId = static_cast<qint64>(m_queue->current()["id"].toDouble());
+        if (firstId > 0)
+            emit playTrackRequested(firstId);
+    });
 
 }
 
 void Tracks::loadTracks(const QJsonArray &tracks)
 {
     setPlaylistContext(0);
+    m_pendingPlayAll = false;
+    m_pendingPlayAllShuffle = false;
     setColumnHidden(TrackListModel::ColAlbum, false);
     m_model->setTracks(tracks, false, /*useSequential=*/true);
 }
@@ -54,6 +88,8 @@ void Tracks::loadTracks(const QJsonArray &tracks)
 void Tracks::loadAlbum(const QJsonObject &album)
 {
     setPlaylistContext(0);
+    m_pendingPlayAll = false;
+    m_pendingPlayAllShuffle = false;
     setColumnHidden(TrackListModel::ColAlbum, true);
     const QJsonArray items = album["tracks"].toObject()["items"].toArray();
     m_model->setTracks(items); // album: use track_number
@@ -67,21 +103,72 @@ void Tracks::loadPlaylist(const QJsonObject &playlist)
     const qint64 myId   = AppSettings::instance().userId();
     const bool isOwned  = (myId > 0 && ownId == myId);
     setPlaylistContext(id, isOwned);
-    const QJsonArray items = playlist["tracks"].toObject()["items"].toArray();
+    const QJsonObject tracksObj = playlist["tracks"].toObject();
+    const QJsonArray items = tracksObj["items"].toArray();
+    const int offset = tracksObj["offset"].toInt(0);
+    m_playlistTrackTotal = tracksObj["total"].toInt(items.size());
+    m_playlistLoadedCount = offset + items.size();
+    m_playlistLoadingMore = false;
     m_model->setTracks(items, /*usePosition=*/true);
+    maybeLoadMorePlaylistTracks();
+}
+
+void Tracks::appendPlaylistPage(const QJsonObject &playlist)
+{
+    if (m_playlistId <= 0)
+        return;
+
+    const qint64 id = static_cast<qint64>(playlist["id"].toDouble());
+    if (id != m_playlistId)
+        return;
+
+    const QJsonObject tracksObj = playlist["tracks"].toObject();
+    const QJsonArray items = tracksObj["items"].toArray();
+    const int offset = tracksObj["offset"].toInt(m_playlistLoadedCount);
+    const int total = tracksObj["total"].toInt(m_playlistTrackTotal);
+
+    if (total > 0)
+        m_playlistTrackTotal = total;
+
+    // Ignore stale/duplicate pages.
+    if (offset < m_playlistLoadedCount) {
+        m_playlistLoadingMore = false;
+        return;
+    }
+
+    if (!items.isEmpty()) {
+        m_model->appendTracks(items, /*usePosition=*/true);
+        m_playlistLoadedCount = offset + items.size();
+    } else {
+        m_playlistLoadedCount = qMax(m_playlistLoadedCount, offset);
+    }
+
+    m_playlistLoadingMore = false;
+    maybeLoadMorePlaylistTracks();
 }
 
 void Tracks::loadSearchTracks(const QJsonArray &tracks)
 {
     setPlaylistContext(0);
+    m_pendingPlayAll = false;
+    m_pendingPlayAllShuffle = false;
     setColumnHidden(TrackListModel::ColAlbum, false);
     m_model->setTracks(tracks, false, /*useSequential=*/true);
 }
 
 void Tracks::setPlaylistContext(qint64 playlistId, bool isOwned)
 {
+    if (m_playlistId != playlistId) {
+        m_pendingPlayAll = false;
+        m_pendingPlayAllShuffle = false;
+        m_playlistLoadingMore = false;
+    }
     m_playlistId = playlistId;
     m_playlistIsOwned = isOwned;
+    if (playlistId <= 0) {
+        m_playlistTrackTotal = 0;
+        m_playlistLoadedCount = 0;
+    }
 }
 
 void Tracks::setUserPlaylists(const QVector<QPair<qint64, QString>> &playlists)
@@ -113,6 +200,14 @@ void Tracks::playAll(bool shuffle)
 {
     const QJsonArray tracks = m_model->currentTracksJson();
     if (tracks.isEmpty()) return;
+
+    if (m_playlistId > 0 && m_playlistTrackTotal > tracks.size()) {
+        m_pendingPlayAll = true;
+        m_pendingPlayAllShuffle = shuffle;
+        m_backend->getPlaylistAll(m_playlistId);
+        return;
+    }
+
     m_queue->setContext(tracks, 0);
     // Shuffle once without touching the global shuffle flag — so a subsequent
     // double-click on a track plays in normal order (unless global shuffle is on).
@@ -123,6 +218,30 @@ void Tracks::playAll(bool shuffle)
         emit playTrackRequested(firstId);
 }
 
+void Tracks::maybeLoadMorePlaylistTracks()
+{
+    if (m_playlistId <= 0)
+        return;
+    if (m_pendingPlayAll)
+        return;
+    if (m_playlistLoadingMore)
+        return;
+    if (m_playlistTrackTotal > 0 && m_playlistLoadedCount >= m_playlistTrackTotal)
+        return;
+
+    QScrollBar *bar = verticalScrollBar();
+    if (!bar)
+        return;
+
+    // Start prefetching before the absolute bottom so paging feels seamless.
+    constexpr int kPrefetchPx = 180;
+    if (bar->maximum() > 0 && bar->value() < (bar->maximum() - kPrefetchPx))
+        return;
+
+    m_playlistLoadingMore = true;
+    m_backend->getPlaylist(m_playlistId, static_cast<quint32>(m_playlistLoadedCount), 500);
+}
+
 
 void Tracks::onDoubleClicked(const QModelIndex &index)
 {
@@ -189,7 +308,7 @@ void Tracks::onContextMenu(const QPoint &pos)
         menu.addSeparator();
         auto *openAlbum = menu.addAction(
             QIcon(":/res/icons/view-media-album-cover.svg"),
-            tr("Open album: %1").arg(m_model->trackAt(index.row()).album));
+            tr("Open album: %1").arg(QString(m_model->trackAt(index.row()).album).replace(QLatin1Char('&'), QStringLiteral("&&"))));
         connect(openAlbum, &QAction::triggered, this, [this, albumId] {
             m_backend->getAlbum(albumId);
         });
@@ -202,7 +321,7 @@ void Tracks::onContextMenu(const QPoint &pos)
         const QString artistName = trackJson["performer"].toObject()["name"].toString();
         auto *openArtist = menu.addAction(
             QIcon(":/res/icons/view-media-artist.svg"),
-            tr("Open artist: %1").arg(artistName));
+            tr("Open artist: %1").arg(QString(artistName).replace(QLatin1Char('&'), QStringLiteral("&&"))));
         connect(openArtist, &QAction::triggered, this, [this, artistId] {
             m_backend->getArtist(artistId);
         });
@@ -216,7 +335,7 @@ void Tracks::onContextMenu(const QPoint &pos)
         for (const auto &pl : m_userPlaylists) {
             const qint64  plId   = pl.first;
             const QString plName = pl.second;
-            auto *act = addToPlMenu->addAction(plName);
+            auto *act = addToPlMenu->addAction(QString(plName).replace(QLatin1Char('&'), QStringLiteral("&&")));
             connect(act, &QAction::triggered, this, [this, id, plId] {
                 emit addToPlaylistRequested(id, plId);
             });
@@ -228,7 +347,7 @@ void Tracks::onContextMenu(const QPoint &pos)
             m_model->data(index, TrackListModel::PlaylistTrackIdRole).toLongLong();
         if (playlistTrackId > 0) {
             if (m_userPlaylists.isEmpty()) menu.addSeparator();
-            auto *remFromPl = menu.addAction(tr("Remove from this playlist"));
+            auto *remFromPl = menu.addAction(QIcon(":/res/icons/list-remove.svg"), tr("Remove from this playlist"));
             const qint64 curPlaylistId = m_playlistId;
             const int    curRow        = index.row();
             connect(remFromPl, &QAction::triggered, this, [this, curPlaylistId, playlistTrackId, curRow] {

src/list/tracks.hpp

@@ -24,6 +24,7 @@ namespace List
         void loadTracks(const QJsonArray &tracks);
         void loadAlbum(const QJsonObject &album);
         void loadPlaylist(const QJsonObject &playlist);
+        void appendPlaylistPage(const QJsonObject &playlist);
         void loadSearchTracks(const QJsonArray &tracks);
 
         /// Called when the backend fires EV_TRACK_CHANGED so the playing row is highlighted.
@@ -55,9 +56,16 @@ namespace List
         QobuzBackend   *m_backend = nullptr;
         PlayQueue      *m_queue   = nullptr;
         qint64          m_playlistId = 0;
+        int             m_playlistTrackTotal = 0;
+        int             m_playlistLoadedCount = 0;
         bool            m_playlistIsOwned = false;
+        bool            m_playlistLoadingMore = false;
+        bool            m_pendingPlayAll = false;
+        bool            m_pendingPlayAllShuffle = false;
         QVector<QPair<qint64, QString>> m_userPlaylists;
 
+        void maybeLoadMorePlaylistTracks();
+
         void onDoubleClicked(const QModelIndex &index);
         void onContextMenu(const QPoint &pos);
     };

src/main.cpp

@@ -1,5 +1,6 @@
 #include "mainwindow.hpp"
 #include "backend/qobuzbackend.hpp"
+#include "util/colors.hpp"
 
 #include <QApplication>
 #include <QStyleFactory>
@@ -15,24 +16,24 @@ int main(int argc, char *argv[])
     // Accent: #FFB232 (yellow-orange), Blue: #46B3EE, Backgrounds: #191919 / #141414
     app.setStyle(QStyleFactory::create(QStringLiteral("Fusion")));
     QPalette darkPalette;
-    darkPalette.setColor(QPalette::Window,          QColor(0x19, 0x19, 0x19));
+    darkPalette.setColor(QPalette::Window,          Colors::WindowBg);
-    darkPalette.setColor(QPalette::WindowText,      QColor(0xe8, 0xe8, 0xe8));
+    darkPalette.setColor(QPalette::WindowText,      Colors::LightText);
-    darkPalette.setColor(QPalette::Base,            QColor(0x14, 0x14, 0x14));
+    darkPalette.setColor(QPalette::Base,            Colors::BaseBg);
-    darkPalette.setColor(QPalette::AlternateBase,   QColor(0x1e, 0x1e, 0x1e));
+    darkPalette.setColor(QPalette::AlternateBase,   Colors::AlternateBaseBg);
-    darkPalette.setColor(QPalette::ToolTipBase,     QColor(0x19, 0x19, 0x19));
+    darkPalette.setColor(QPalette::ToolTipBase,     Colors::WindowBg);
-    darkPalette.setColor(QPalette::ToolTipText,     QColor(0xe8, 0xe8, 0xe8));
+    darkPalette.setColor(QPalette::ToolTipText,     Colors::LightText);
-    darkPalette.setColor(QPalette::Text,            QColor(0xe8, 0xe8, 0xe8));
+    darkPalette.setColor(QPalette::Text,            Colors::LightText);
-    darkPalette.setColor(QPalette::Button,          QColor(0x2a, 0x2a, 0x2a));
+    darkPalette.setColor(QPalette::Button,          Colors::ButtonSurface);
-    darkPalette.setColor(QPalette::ButtonText,      QColor(0xe8, 0xe8, 0xe8));
+    darkPalette.setColor(QPalette::ButtonText,      Colors::LightText);
-    darkPalette.setColor(QPalette::BrightText,      QColor(0xFF, 0xB2, 0x32));
+    darkPalette.setColor(QPalette::BrightText,      Colors::QobuzOrange);
-    darkPalette.setColor(QPalette::Link,            QColor(0x46, 0xB3, 0xEE)); // Qobuz blue
+    darkPalette.setColor(QPalette::Link,            Colors::QobuzBlue);
-    darkPalette.setColor(QPalette::Highlight,       QColor(0xFF, 0xB2, 0x32)); // Qobuz orange
+    darkPalette.setColor(QPalette::Highlight,       Colors::QobuzOrange);
-    darkPalette.setColor(QPalette::HighlightedText, QColor(0x10, 0x10, 0x10)); // dark on orange
+    darkPalette.setColor(QPalette::HighlightedText, Colors::HighlightedFg);
-    darkPalette.setColor(QPalette::PlaceholderText,                QColor(0x66, 0x66, 0x66));
+    darkPalette.setColor(QPalette::PlaceholderText,                Colors::PlaceholderText);
-    darkPalette.setColor(QPalette::Disabled, QPalette::Text,       QColor(0x55, 0x55, 0x55));
+    darkPalette.setColor(QPalette::Disabled, QPalette::Text,       Colors::DisabledText);
-    darkPalette.setColor(QPalette::Disabled, QPalette::ButtonText, QColor(0x55, 0x55, 0x55));
+    darkPalette.setColor(QPalette::Disabled, QPalette::ButtonText, Colors::DisabledText);
-    darkPalette.setColor(QPalette::Mid,             QColor(0x2f, 0x2f, 0x2f));
+    darkPalette.setColor(QPalette::Mid,             Colors::MidSurface);
-    darkPalette.setColor(QPalette::Dark,            QColor(0x0e, 0x0e, 0x0e));
+    darkPalette.setColor(QPalette::Dark,            Colors::DarkSurface);
     app.setPalette(darkPalette);
 
     // Stylesheet tweaks: orange accent on scrollbars, focus rings, etc.

src/mainwindow.cpp

@@ -4,6 +4,10 @@
 #include "util/settings.hpp"
 #include "util/icon.hpp"
 
+#ifdef USE_DBUS
+#include "backend/mpris.hpp"
+#endif
+
 #include <QApplication>
 #include <QMenuBar>
 #include <QMenu>
@@ -34,14 +38,34 @@ MainWindow::MainWindow(QobuzBackend *backend, QWidget *parent)
     m_content = new MainContent(m_backend, m_queue, this);
     setCentralWidget(m_content);
 
+    setupDocks();
+    setupMenuBar();
+    statusBar()->showMessage(tr("Ready"));
+
+    setupScrobbler();
+    setupGapless();
+    setupMpris();
+    connectBackendSignals();
+    connectLibrarySignals();
+    connectContentSignals();
+    connectToolbarSignals();
+
+    // Apply playback options from saved settings
+    m_backend->setReplayGain(AppSettings::instance().replayGainEnabled());
+    m_backend->setGapless(AppSettings::instance().gaplessEnabled());
+
+    tryRestoreSession();
+}
+
+void MainWindow::setupDocks()
+{
     // ---- Library dock (left) ----
     m_library = new List::Library(m_backend, this);
     m_libraryDock = new QDockWidget(tr("Library"), this);
     m_libraryDock->setObjectName(QStringLiteral("libraryDock"));
     m_libraryDock->setFeatures(QDockWidget::DockWidgetMovable);
     m_libraryDock->setWidget(m_library);
-    m_libraryDock->setMinimumWidth(180);
+    m_libraryDock->setMinimumWidth(150);
-    m_library->setFixedWidth(220);
     addDockWidget(Qt::LeftDockWidgetArea, m_libraryDock);
 
     // ---- Now-playing context dock (left, below library) ----
@@ -57,11 +81,10 @@ MainWindow::MainWindow(QobuzBackend *backend, QWidget *parent)
     m_sidePanel = new SidePanel::View(m_backend, m_queue, this);
     m_sidePanel->hide();
     addDockWidget(Qt::RightDockWidgetArea, m_sidePanel);
+}
 
-    setupMenuBar();
+void MainWindow::setupScrobbler()
-    statusBar()->showMessage(tr("Ready"));
+{
-
-    // ---- Scrobbler ----
     m_scrobbler = new LastFmScrobbler(this);
     connect(m_backend, &QobuzBackend::trackChanged,
             m_scrobbler, &LastFmScrobbler::onTrackStarted);
@@ -70,7 +93,83 @@ MainWindow::MainWindow(QobuzBackend *backend, QWidget *parent)
     connect(m_backend, &QobuzBackend::trackFinished,
             m_scrobbler, &LastFmScrobbler::onTrackFinished);
 
-    // ---- Backend signals ----
+    // Scrobble the finished track during a gapless transition
+    connect(m_backend, &QobuzBackend::trackTransitioned,
+            m_scrobbler, &LastFmScrobbler::onTrackFinished);
+}
+
+void MainWindow::setupGapless()
+{
+    connect(m_backend, &QobuzBackend::positionChanged, this, [this](quint64 pos, quint64 dur) {
+        if (!AppSettings::instance().gaplessEnabled() || dur == 0) return;
+
+        // Trigger prefetch if we pass the 50% mark OR are within 60 seconds of the end
+        if ((pos > dur / 2) || (dur > 60 && (dur - pos) <= 60)) {
+            if (!m_nextTrackPrefetched && m_queue->canGoNext()) {
+                m_nextTrackPrefetched = true; // Lock it so it only fires once
+
+                const auto upcoming = m_queue->upcomingTracks(1);
+                if (!upcoming.isEmpty()) {
+                    const qint64 nextId = static_cast<qint64>(upcoming.first()["id"].toDouble());
+                    if (nextId > 0) {
+                        m_backend->prefetchTrack(nextId, AppSettings::instance().preferredFormat());
+                    }
+                }
+            }
+        }
+    });
+}
+
+void MainWindow::setupMpris()
+{
+#ifdef USE_DBUS
+    m_mpris = new Mpris(this);
+    connect(m_mpris->player(), &MprisPlayerAdaptor::playRequested, m_backend, [this] {
+        if (m_backend->state() == 2) m_backend->resume();
+    });
+    connect(m_mpris->player(), &MprisPlayerAdaptor::pauseRequested, m_backend, &QobuzBackend::pause);
+    connect(m_mpris->player(), &MprisPlayerAdaptor::playPauseRequested, m_backend, [this] {
+        if (m_backend->state() == 1)
+            m_backend->pause();
+        else
+            m_backend->resume();
+    });
+    connect(m_mpris->player(), &MprisPlayerAdaptor::stopRequested, m_backend, &QobuzBackend::stop);
+    connect(m_mpris->player(), &MprisPlayerAdaptor::nextRequested, this, [this] {
+        if (!m_queue->canGoNext()) return;
+        const qint64 id = static_cast<qint64>(m_queue->advance()["id"].toDouble());
+        if (id > 0) m_backend->playTrack(id);
+    });
+    connect(m_mpris->player(), &MprisPlayerAdaptor::previousRequested, this, [this] {
+        if (!m_queue->canGoPrev()) return;
+        const qint64 id = static_cast<qint64>(m_queue->stepBack()["id"].toDouble());
+        if (id > 0) m_backend->playTrack(id);
+    });
+    connect(m_mpris->player(), &MprisPlayerAdaptor::seekRequested, m_backend, [this](qlonglong offsetMicroseconds) {
+        qint64 newPos = m_backend->position() + (offsetMicroseconds / 1000000LL);
+        if (newPos < 0) newPos = 0;
+        m_backend->seek(newPos);
+    });
+    connect(m_mpris->player(), &MprisPlayerAdaptor::seekToRequested, m_backend, [this](qlonglong positionMicroseconds) {
+        m_backend->seek(positionMicroseconds / 1000000LL);
+    });
+    connect(m_mpris->player(), &MprisPlayerAdaptor::volumeChangeRequested, m_backend, [this](double vol) {
+        m_backend->setVolume(vol * 100);
+    });
+
+    connect(m_backend, &QobuzBackend::stateChanged, this, [this](const QString &state) {
+        if (state == "playing") m_mpris->player()->setPlaybackStatus("Playing");
+        else if (state == "paused") m_mpris->player()->setPlaybackStatus("Paused");
+        else m_mpris->player()->setPlaybackStatus("Stopped");
+    });
+    connect(m_backend, &QobuzBackend::positionChanged, this, [this](quint64 pos) {
+        m_mpris->player()->updatePosition(pos);
+    });
+#endif
+}
+
+void MainWindow::connectBackendSignals()
+{
     connect(m_backend, &QobuzBackend::loginSuccess,   this, &MainWindow::onLoginSuccess);
     connect(m_backend, &QobuzBackend::loginError,     this, &MainWindow::onLoginError);
     connect(m_backend, &QobuzBackend::userLoaded, this, [this](const QJsonObject &user) {
@@ -100,12 +199,35 @@ MainWindow::MainWindow(QobuzBackend *backend, QWidget *parent)
             m_backend->getPlaylist(playlistId);
         statusBar()->showMessage(tr("Track added to playlist"), 3000);
     });
+    connect(m_backend, &QobuzBackend::playlistSubscribed, this, [this](qint64 playlistId) {
+        m_userPlaylistIds.insert(playlistId);
+        m_library->refresh();
+        if (m_content->tracksList()->playlistId() == playlistId)
+            m_content->setCurrentPlaylistFollowed(true);
+        statusBar()->showMessage(tr("Playlist followed"), 3000);
+    });
+    connect(m_backend, &QobuzBackend::playlistUnsubscribed, this, [this](qint64 playlistId) {
+        m_userPlaylistIds.remove(playlistId);
+        m_library->refresh();
+        if (m_content->tracksList()->playlistId() == playlistId)
+            m_content->setCurrentPlaylistFollowed(false);
+        statusBar()->showMessage(tr("Playlist unfollowed"), 3000);
+    });
     connect(m_backend, &QobuzBackend::trackChanged,   this, &MainWindow::onTrackChanged);
     connect(m_backend, &QobuzBackend::error, this, [this](const QString &msg) {
         statusBar()->showMessage(tr("Error: %1").arg(msg), 6000);
     });
+}
 
-    // ---- Library signals ----
+void MainWindow::connectLibrarySignals()
+{
+    connect(m_library, &List::Library::userPlaylistIdsChanged,
+            this, [this](const QSet<qint64> &playlistIds) {
+        m_userPlaylistIds = playlistIds;
+        const qint64 currentPlaylistId = m_content->tracksList()->playlistId();
+        if (currentPlaylistId > 0)
+            m_content->setCurrentPlaylistFollowed(m_userPlaylistIds.contains(currentPlaylistId));
+    });
     connect(m_library, &List::Library::userPlaylistsChanged,
             this, &MainWindow::onUserPlaylistsChanged);
     connect(m_library, &List::Library::openPlaylistDeleted,
@@ -120,6 +242,7 @@ MainWindow::MainWindow(QobuzBackend *backend, QWidget *parent)
         statusBar()->showMessage(tr("Loading favorite tracks…"));
     });
     connect(m_library, &List::Library::favAlbumsRequested, this, [this] {
+        m_showFavAlbumsOnLoad = true;
         m_backend->getFavAlbums();
         statusBar()->showMessage(tr("Loading favorite albums…"));
     });
@@ -133,7 +256,18 @@ MainWindow::MainWindow(QobuzBackend *backend, QWidget *parent)
         m_backend->getPlaylist(id);
         statusBar()->showMessage(tr("Loading playlist: %1…").arg(name));
     });
+    connect(m_library, &List::Library::browseGenresRequested, this, [this] {
+        m_content->showGenreBrowser();
+        statusBar()->showMessage(tr("Browse Genres"));
+    });
+    connect(m_library, &List::Library::browsePlaylistsRequested, this, [this] {
+        m_content->showPlaylistBrowser();
+        statusBar()->showMessage(tr("Browse Playlists"));
+    });
+}
 
+void MainWindow::connectContentSignals()
+{
     // ---- Track list → playback / playlist management ----
     connect(m_content->tracksList(), &List::Tracks::playTrackRequested,
             this, &MainWindow::onPlayTrackRequested);
@@ -166,26 +300,62 @@ MainWindow::MainWindow(QobuzBackend *backend, QWidget *parent)
             this, &MainWindow::onSearchAlbumSelected);
     connect(m_content, &MainContent::artistRequested,
             this, &MainWindow::onSearchArtistSelected);
+    connect(m_content, &MainContent::albumFavoriteToggled,
+            this, [this](const QString &albumId, bool favorite) {
+        if (favorite) {
+            m_backend->addFavAlbum(albumId);
+            m_favAlbumIds.insert(albumId);
+            statusBar()->showMessage(tr("Added album to favorites"), 3000);
+        } else {
+            m_backend->removeFavAlbum(albumId);
+            m_favAlbumIds.remove(albumId);
+            statusBar()->showMessage(tr("Removed album from favorites"), 3000);
+        }
+        m_content->setFavAlbumIds(m_favAlbumIds);
+    });
+    connect(m_content, &MainContent::playlistRequested,
+            this, [this](qint64 playlistId) {
+        m_backend->getPlaylist(playlistId);
+        statusBar()->showMessage(tr("Loading playlist…"));
+    });
+    connect(m_content, &MainContent::playlistFollowToggled,
+            this, [this](qint64 playlistId, bool follow) {
+        if (follow)
+            m_backend->subscribePlaylist(playlistId);
+        else
+            m_backend->unsubscribePlaylist(playlistId);
+    });
     connect(m_content, &MainContent::playTrackRequested,
             this, &MainWindow::onPlayTrackRequested);
 
     // ---- Queue panel ----
     connect(m_queuePanel, &QueuePanel::skipToTrackRequested,
             this, &MainWindow::onPlayTrackRequested);
+}
 
-    // ---- Toolbar toggles ----
+void MainWindow::connectToolbarSignals()
+{
     connect(m_toolBar, &MainToolBar::searchToggled, this, &MainWindow::onSearchToggled);
     connect(m_toolBar, &MainToolBar::queueToggled,
             this, [this](bool v) { m_queuePanel->setVisible(v); });
+    connect(m_queuePanel, &QDockWidget::visibilityChanged,
+            m_toolBar, &MainToolBar::setQueueToggleChecked);
+    connect(m_sidePanel, &QDockWidget::visibilityChanged,
+            m_toolBar, &MainToolBar::setSearchToggleChecked);
+    m_toolBar->setQueueToggleChecked(m_queuePanel->isVisible());
+    m_toolBar->setSearchToggleChecked(m_sidePanel->isVisible());
 
     connect(m_toolBar, &MainToolBar::albumRequested,  this, &MainWindow::onSearchAlbumSelected);
     connect(m_toolBar, &MainToolBar::artistRequested, this, &MainWindow::onSearchArtistSelected);
-
+    connect(m_toolBar, &MainToolBar::addToPlaylistRequested,
-    // Apply playback options from saved settings
+            this, [this](qint64 trackId, qint64 playlistId) {
-    m_backend->setReplayGain(AppSettings::instance().replayGainEnabled());
+        m_backend->addTrackToPlaylist(playlistId, trackId);
-    m_backend->setGapless(AppSettings::instance().gaplessEnabled());
+        statusBar()->showMessage(tr("Adding track to playlist…"), 3000);
-
+    });
-    tryRestoreSession();
+    connect(m_toolBar, &MainToolBar::favTrackRequested,
+            this, [this](qint64 trackId) {
+        m_backend->addFavTrack(trackId);
+    });
 }
 
 void MainWindow::setupMenuBar()
@@ -226,6 +396,8 @@ void MainWindow::tryRestoreSession()
             m_backend->getUser();  // userLoaded will call m_library->refresh()
         else
             m_library->refresh();
+        // Preload fav albums so the album page fav button is accurate immediately.
+        m_backend->getFavAlbums();
         // Preload fav artists so the artist page fav button works immediately
         m_backend->getFavArtists();
         const QString name = AppSettings::instance().displayName();
@@ -277,6 +449,8 @@ void MainWindow::onLoginSuccess(const QString &token, const QJsonObject &user)
     statusBar()->showMessage(tr("Signed in as %1").arg(
         displayName.isEmpty() ? email : displayName));
     m_library->refresh();
+    m_backend->getFavAlbums();
+    m_backend->getFavArtists();
 }
 
 void MainWindow::onLoginError(const QString &error)
@@ -286,6 +460,7 @@ void MainWindow::onLoginError(const QString &error)
 
 void MainWindow::onTrackChanged(const QJsonObject &track)
 {
+    m_nextTrackPrefetched = false;
     // Update playing row highlight in the track list
     const qint64 id = static_cast<qint64>(track["id"].toDouble());
     m_content->tracksList()->setPlayingTrackId(id);
@@ -298,15 +473,25 @@ void MainWindow::onTrackChanged(const QJsonObject &track)
     statusBar()->showMessage(
         artist.isEmpty() ? title : QStringLiteral("▶  %1 — %2").arg(artist, title));
 
-    // Prefetch next track URL when gapless is enabled
+#ifdef USE_DBUS
-    if (AppSettings::instance().gaplessEnabled() && m_queue->canGoNext()) {
+    QVariantMap metadata;
-        const auto upcoming = m_queue->upcomingTracks(1);
+    metadata["mpris:trackid"] = QVariant::fromValue(QDBusObjectPath(QString("/org/qobuz/track/%1").arg(id)));
-        if (!upcoming.isEmpty()) {
+    metadata["mpris:length"] = QVariant::fromValue(qlonglong(track["duration"].toDouble() * 1000000LL));
-            const qint64 nextId = static_cast<qint64>(upcoming.first()["id"].toDouble());
+    metadata["xesam:title"]  = title;
-            if (nextId > 0)
+
-                m_backend->prefetchTrack(nextId, AppSettings::instance().preferredFormat());
+    QJsonObject album = track["album"].toObject();
+    metadata["xesam:album"]  = album["title"].toString();
+
+    if (!artist.isEmpty()) {
+        metadata["xesam:artist"] = QStringList{artist};
     }
+
+    if (album.contains("image") && album["image"].toObject().contains("large")) {
+        metadata["mpris:artUrl"] = album["image"].toObject()["large"].toString();
     }
+
+    m_mpris->player()->setMetadata(metadata);
+#endif
 }
 
 void MainWindow::onFavTracksLoaded(const QJsonObject &result)
@@ -327,9 +512,26 @@ void MainWindow::onFavTracksLoaded(const QJsonObject &result)
 
 void MainWindow::onFavAlbumsLoaded(const QJsonObject &result)
 {
+    // Always cache fav album IDs (needed by the album page fav button)
+    m_favAlbumIds.clear();
+    const QJsonArray items = result["items"].toArray();
+    for (const QJsonValue &v : items) {
+        const QJsonObject album = v.toObject();
+        QString id = album["id"].toString();
+        if (id.isEmpty() && album["id"].isDouble())
+            id = QString::number(static_cast<qint64>(album["id"].toDouble()));
+        if (!id.isEmpty())
+            m_favAlbumIds.insert(id);
+    }
+    m_content->setFavAlbumIds(m_favAlbumIds);
+
+    // Only navigate to the fav albums page if the user explicitly requested it
+    if (m_showFavAlbumsOnLoad) {
+        m_showFavAlbumsOnLoad = false;
         m_content->showFavAlbums(result);
         statusBar()->showMessage(
             tr("%1 favorite albums").arg(result["total"].toInt()), 4000);
+    }
 }
 
 void MainWindow::onFavArtistsLoaded(const QJsonObject &result)
@@ -374,7 +576,27 @@ void MainWindow::onArtistLoaded(const QJsonObject &artist)
 
 void MainWindow::onPlaylistLoaded(const QJsonObject &playlist)
 {
-    m_content->showPlaylist(playlist);
+    const bool fullLoad = playlist["full_load"].toBool(false);
+    const int trackOffset = playlist["tracks"].toObject()["offset"].toInt(0);
+    if (!fullLoad && trackOffset > 0) {
+        m_content->tracksList()->appendPlaylistPage(playlist);
+        return;
+    }
+
+    const qint64 id = static_cast<qint64>(playlist["id"].toDouble());
+    const qint64 ownerId = static_cast<qint64>(playlist["owner"].toObject()["id"].toDouble());
+    const qint64 myId = AppSettings::instance().userId();
+    const bool isOwned = (myId > 0 && ownerId == myId);
+
+    bool isFollowed = isOwned || m_userPlaylistIds.contains(id);
+    if (!isFollowed) {
+        if (playlist.contains("is_subscribed"))
+            isFollowed = playlist["is_subscribed"].toBool();
+        else if (playlist.contains("subscribed_at"))
+            isFollowed = !playlist["subscribed_at"].isNull();
+    }
+
+    m_content->showPlaylist(playlist, isFollowed, isOwned);
     statusBar()->showMessage(
         tr("Playlist: %1").arg(playlist["name"].toString()), 4000);
 }
@@ -416,5 +638,5 @@ void MainWindow::onUserPlaylistsChanged(const QVector<QPair<qint64, QString>> &p
     m_userPlaylists = playlists;
     m_content->tracksList()->setUserPlaylists(playlists);
     m_sidePanel->searchTab()->setUserPlaylists(playlists);
+    m_toolBar->setUserPlaylists(playlists);
 }
-

src/mainwindow.hpp

@@ -19,6 +19,8 @@
 #include <QPair>
 #include <QString>
 
+class Mpris;
+
 class MainWindow : public QMainWindow
 {
     Q_OBJECT
@@ -53,7 +55,10 @@ private:
     QobuzBackend    *m_backend     = nullptr;
     PlayQueue       *m_queue       = nullptr;
     QVector<QPair<qint64, QString>> m_userPlaylists;
+    QSet<qint64> m_userPlaylistIds;
+    QSet<QString> m_favAlbumIds;
     QSet<qint64> m_favArtistIds;
+    bool m_showFavAlbumsOnLoad = false;
     bool m_showFavArtistsOnLoad = false;
     MainToolBar     *m_toolBar     = nullptr;
     MainContent     *m_content     = nullptr;
@@ -63,7 +68,17 @@ private:
     SidePanel::View *m_sidePanel   = nullptr;
     QDockWidget     *m_libraryDock = nullptr;
     LastFmScrobbler *m_scrobbler   = nullptr;
+    Mpris           *m_mpris       = nullptr;
+    bool m_nextTrackPrefetched = false;
 
     void setupMenuBar();
+    void setupDocks();
+    void setupScrobbler();
+    void setupGapless();
+    void setupMpris();
+    void connectBackendSignals();
+    void connectLibrarySignals();
+    void connectContentSignals();
+    void connectToolbarSignals();
     void tryRestoreSession();
 };

src/model/tracklistmodel.cpp

@@ -1,4 +1,5 @@
 #include "tracklistmodel.hpp"
+#include "../util/colors.hpp"
 
 #include <QJsonValue>
 #include <QColor>
@@ -9,21 +10,11 @@ TrackListModel::TrackListModel(QObject *parent)
     : QAbstractTableModel(parent)
 {}
 
-void TrackListModel::setTracks(const QJsonArray &tracks,
+TrackItem TrackListModel::parseTrackItem(const QJsonObject &t,
                                          bool usePosition,
-                               bool useSequential)
+                                         bool useSequential,
+                                         int &seq)
 {
-    beginResetModel();
-    m_tracks.clear();
-    m_tracks.reserve(tracks.size());
-
-    // Parse into a temporary list first so we can detect multi-disc
-    QVector<TrackItem> parsed;
-    parsed.reserve(tracks.size());
-
-    int seq = 1;
-    for (const QJsonValue &v : tracks) {
-        const QJsonObject t = v.toObject();
     TrackItem item;
     item.id               = static_cast<qint64>(t["id"].toDouble());
     item.playlistTrackId  = static_cast<qint64>(t["playlist_track_id"].toDouble());
@@ -66,8 +57,24 @@ void TrackListModel::setTracks(const QJsonArray &tracks,
     item.album   = album["title"].toString();
     item.albumId = album["id"].toString();
 
-        parsed.append(item);
+    return item;
-    }
+}
+
+void TrackListModel::setTracks(const QJsonArray &tracks,
+                               bool usePosition,
+                               bool useSequential)
+{
+    beginResetModel();
+    m_tracks.clear();
+    m_tracks.reserve(tracks.size());
+
+    // Parse into a temporary list first so we can detect multi-disc
+    QVector<TrackItem> parsed;
+    parsed.reserve(tracks.size());
+
+    int seq = 1;
+    for (const QJsonValue &v : tracks)
+        parsed.append(parseTrackItem(v.toObject(), usePosition, useSequential, seq));
 
     // Multi-disc only makes sense for album context (not playlists / fav / search)
     int maxDisc = 1;
@@ -109,6 +116,51 @@ void TrackListModel::setTracks(const QJsonArray &tracks,
         emit sortApplied();
 }
 
+void TrackListModel::appendTracks(const QJsonArray &tracks,
+                                  bool usePosition,
+                                  bool useSequential)
+{
+    if (tracks.isEmpty())
+        return;
+
+    // Keep append path simple and stable: disc-header mode is handled by reset path.
+    if (m_hasMultipleDiscs && !usePosition && !useSequential) {
+        QJsonArray all = currentTracksJson();
+        for (const QJsonValue &v : tracks)
+            all.append(v);
+        setTracks(all, usePosition, useSequential);
+        return;
+    }
+
+    int seq = 1;
+    if (useSequential || usePosition) {
+        for (const TrackItem &t : m_tracks)
+            if (!t.isDiscHeader)
+                ++seq;
+    }
+
+    QVector<TrackItem> parsed;
+    parsed.reserve(tracks.size());
+    for (const QJsonValue &v : tracks)
+        parsed.append(parseTrackItem(v.toObject(), usePosition, useSequential, seq));
+
+    if (parsed.isEmpty())
+        return;
+
+    const int first = m_tracks.size();
+    const int last  = first + parsed.size() - 1;
+    beginInsertRows({}, first, last);
+    m_tracks += parsed;
+    endInsertRows();
+
+    if (!m_hasMultipleDiscs && m_sortColumn >= 0) {
+        emit layoutAboutToBeChanged();
+        sortData(m_sortColumn, m_sortOrder);
+        emit layoutChanged();
+        emit sortApplied();
+    }
+}
+
 void TrackListModel::clear()
 {
     beginResetModel();
@@ -124,6 +176,16 @@ void TrackListModel::removeTrack(int row)
     endRemoveRows();
 }
 
+void TrackListModel::notifyFavChanged(qint64 id)
+{
+    for (int r = 0; r < m_tracks.size(); ++r) {
+        if (m_tracks[r].id == id) {
+            const auto idx = index(r, ColTitle);
+            emit dataChanged(idx, idx, {Qt::DecorationRole});
+        }
+    }
+}
+
 void TrackListModel::setFavIds(const QSet<qint64> &ids)
 {
     m_favIds = ids;
@@ -135,23 +197,13 @@ void TrackListModel::setFavIds(const QSet<qint64> &ids)
 void TrackListModel::addFavId(qint64 id)
 {
     m_favIds.insert(id);
-    for (int r = 0; r < m_tracks.size(); ++r) {
+    notifyFavChanged(id);
-        if (m_tracks[r].id == id) {
-            const auto idx = index(r, ColTitle);
-            emit dataChanged(idx, idx, {Qt::DecorationRole});
-        }
-    }
 }
 
 void TrackListModel::removeFavId(qint64 id)
 {
     m_favIds.remove(id);
-    for (int r = 0; r < m_tracks.size(); ++r) {
+    notifyFavChanged(id);
-        if (m_tracks[r].id == id) {
-            const auto idx = index(r, ColTitle);
-            emit dataChanged(idx, idx, {Qt::DecorationRole});
-        }
-    }
 }
 
 void TrackListModel::setPlayingId(qint64 id)
@@ -204,7 +256,7 @@ QVariant TrackListModel::data(const QModelIndex &index, int role) const
             QFont f; f.setBold(true); return f;
         }
         if (role == Qt::ForegroundRole)
-            return QColor(0xFF, 0xB2, 0x32);
+            return Colors::QobuzOrange;
         return {};
     }
 
@@ -227,8 +279,8 @@ QVariant TrackListModel::data(const QModelIndex &index, int role) const
     }
 
     if (role == Qt::ForegroundRole) {
-        if (!t.streamable) return QColor(0x55, 0x55, 0x55);
+        if (!t.streamable) return Colors::DisabledText;
-        if (isPlaying)     return QColor(0xFF, 0xB2, 0x32); // Qobuz orange
+        if (isPlaying)     return Colors::QobuzOrange;
     }
 
     if (role == Qt::DecorationRole && index.column() == ColNumber && isPlaying) {

src/model/tracklistmodel.hpp

@@ -51,6 +51,9 @@ public:
     void setTracks(const QJsonArray &tracks,
                    bool usePosition   = false,
                    bool useSequential = false);
+    void appendTracks(const QJsonArray &tracks,
+                      bool usePosition   = false,
+                      bool useSequential = false);
     void clear();
     void setPlayingId(qint64 id);
     qint64 playingId() const { return m_playingId; }
@@ -102,4 +105,10 @@ private:
 
     // Sort m_tracks in-place without emitting any signals.
     void sortData(int column, Qt::SortOrder order);
+
+    // Parse a single JSON track object into a TrackItem.
+    static TrackItem parseTrackItem(const QJsonObject &t, bool usePosition, bool useSequential, int &seq);
+
+    // Emit dataChanged(DecorationRole) for all rows matching id.
+    void notifyFavChanged(qint64 id);
 };

src/playqueue.cpp

@@ -0,0 +1,238 @@
+#include "playqueue.hpp"
+
+#include <algorithm>
+#include <random>
+
+PlayQueue::PlayQueue(QObject *parent) : QObject(parent) {}
+
+void PlayQueue::setContext(const QJsonArray &tracks, int startIndex)
+{
+    m_queue.clear();
+    m_playNext.clear();
+
+    // Only queue streamable tracks; find the filtered index for startIndex
+    int filteredStart = 0;
+    int filteredIdx   = 0;
+    bool found        = false;
+    for (int orig = 0; orig < tracks.size(); ++orig) {
+        const QJsonObject t = tracks[orig].toObject();
+        if (!t["streamable"].toBool(true))
+            continue;
+        if (!found && orig >= startIndex) {
+            filteredStart = filteredIdx;
+            found = true;
+        }
+        m_queue.append(t);
+        ++filteredIdx;
+    }
+    m_index = qBound(0, filteredStart, qMax(0, m_queue.size() - 1));
+
+    if (m_shuffle)
+        shuffleQueue(m_index);
+
+    emit queueChanged();
+}
+
+void PlayQueue::reorderContext(const QJsonArray &tracks, qint64 currentId)
+{
+    m_queue.clear();
+    for (const auto &v : tracks) {
+        const QJsonObject t = v.toObject();
+        if (t["streamable"].toBool(true))
+            m_queue.append(t);
+    }
+
+    m_index = 0;
+    for (int i = 0; i < m_queue.size(); ++i) {
+        if (static_cast<qint64>(m_queue[i]["id"].toDouble()) == currentId) {
+            m_index = i;
+            break;
+        }
+    }
+    emit queueChanged();
+}
+
+void PlayQueue::clearUpcoming()
+{
+    m_playNext.clear();
+    if (m_index < m_queue.size())
+        m_queue.resize(m_index + 1); // keep up to and including current
+    emit queueChanged();
+}
+
+void PlayQueue::removeUpcoming(int upcomingIndex)
+{
+    if (upcomingIndex < m_playNext.size()) {
+        m_playNext.removeAt(upcomingIndex);
+    } else {
+        const int queueIdx = m_index + 1 + (upcomingIndex - m_playNext.size());
+        if (queueIdx < m_queue.size())
+            m_queue.removeAt(queueIdx);
+    }
+    emit queueChanged();
+}
+
+void PlayQueue::setShuffle(bool enabled)
+{
+    if (m_shuffle == enabled) return;
+    m_shuffle = enabled;
+    if (enabled && !m_queue.isEmpty())
+        shuffleQueue(m_index);
+    emit queueChanged();
+}
+
+void PlayQueue::shuffleNow()
+{
+    if (m_queue.isEmpty()) return;
+    shuffleQueue(m_index);
+    emit queueChanged();
+}
+
+void PlayQueue::addToQueue(const QJsonObject &track)
+{
+    m_playNext.append(track);
+    emit queueChanged();
+}
+
+void PlayQueue::playNext(const QJsonObject &track)
+{
+    m_playNext.prepend(track);
+    emit queueChanged();
+}
+
+bool PlayQueue::hasCurrent() const
+{
+    return (!m_playNext.isEmpty()) || (!m_queue.isEmpty());
+}
+
+QJsonObject PlayQueue::current() const
+{
+    if (!m_playNext.isEmpty()) return m_playNext.first();
+    if (m_index < m_queue.size()) return m_queue.at(m_index);
+    return {};
+}
+
+qint64 PlayQueue::currentId() const
+{
+    return static_cast<qint64>(current()["id"].toDouble());
+}
+
+QJsonObject PlayQueue::advance()
+{
+    if (!m_playNext.isEmpty()) {
+        // Return the playNext item directly — do NOT call current() after
+        // removal, as that would fall back to the already-playing m_index track.
+        const QJsonObject next = m_playNext.takeFirst();
+        emit queueChanged();
+        return next;
+    }
+    ++m_index;
+    emit queueChanged();
+    return current();
+}
+
+QJsonObject PlayQueue::stepBack()
+{
+    if (m_index > 0) --m_index;
+    emit queueChanged();
+    return current();
+}
+
+bool PlayQueue::canGoNext() const
+{
+    return !m_playNext.isEmpty() || (m_index + 1 < m_queue.size());
+}
+
+void PlayQueue::setCurrentById(qint64 id)
+{
+    m_playNext.clear();
+    for (int i = 0; i < m_queue.size(); ++i) {
+        if (static_cast<qint64>(m_queue[i]["id"].toDouble()) == id) {
+            m_index = i;
+            emit queueChanged();
+            return;
+        }
+    }
+}
+
+QVector<QJsonObject> PlayQueue::upcomingTracks(int maxCount) const
+{
+    QVector<QJsonObject> result;
+    result.append(m_playNext);
+    for (int i = m_index + 1; i < m_queue.size() && result.size() < maxCount; ++i)
+        result.append(m_queue.at(i));
+    return result;
+}
+
+QJsonObject PlayQueue::skipToUpcoming(int upcomingIndex)
+{
+    // Remove items 0..upcomingIndex-1 from the front of upcoming
+    for (int i = 0; i < upcomingIndex; ++i) {
+        if (!m_playNext.isEmpty())
+            m_playNext.removeFirst();
+        else if (m_index + 1 < m_queue.size())
+            ++m_index;
+    }
+    // Pop and return the target (now at upcoming[0])
+    if (!m_playNext.isEmpty()) {
+        const QJsonObject t = m_playNext.takeFirst();
+        emit queueChanged();
+        return t;
+    }
+    if (m_index + 1 < m_queue.size()) {
+        ++m_index;
+        emit queueChanged();
+        return m_queue.at(m_index);
+    }
+    emit queueChanged();
+    return {};
+}
+
+void PlayQueue::setUpcomingOrder(const QVector<QJsonObject> &newOrder)
+{
+    m_playNext = newOrder;
+    m_queue.resize(m_index + 1); // drop old main-queue tail
+    emit queueChanged();
+}
+
+void PlayQueue::appendToContext(const QJsonArray &tracks)
+{
+    for (const auto &v : tracks) {
+        const QJsonObject t = v.toObject();
+        if (t["streamable"].toBool(true))
+            m_queue.append(t);
+    }
+    emit queueChanged();
+}
+
+void PlayQueue::moveUpcomingToTop(int upcomingIndex)
+{
+    if (upcomingIndex < 0) return;
+    QJsonObject track;
+    if (upcomingIndex < m_playNext.size()) {
+        if (upcomingIndex == 0) return; // already at top
+        track = m_playNext.takeAt(upcomingIndex);
+    } else {
+        const int queueIdx = m_index + 1 + (upcomingIndex - m_playNext.size());
+        if (queueIdx >= m_queue.size()) return;
+        track = m_queue.takeAt(queueIdx);
+    }
+    m_playNext.prepend(track);
+    emit queueChanged();
+}
+
+void PlayQueue::shuffleQueue(int keepAtFront)
+{
+    if (m_queue.isEmpty()) return;
+    // Keep the current track at index 0 of the remaining queue
+    if (keepAtFront >= 0 && keepAtFront < m_queue.size()) {
+        QJsonObject current = m_queue.takeAt(keepAtFront);
+        std::mt19937 rng(std::random_device{}());
+        std::shuffle(m_queue.begin(), m_queue.end(), rng);
+        m_queue.prepend(current);
+    } else {
+        std::mt19937 rng(std::random_device{}());
+        std::shuffle(m_queue.begin(), m_queue.end(), rng);
+    }
+    m_index = 0;
+}

src/playqueue.hpp

@@ -4,8 +4,6 @@
 #include <QVector>
 #include <QJsonObject>
 #include <QJsonArray>
-#include <algorithm>
-#include <random>
 
 /// Local playback queue.  Holds the ordered list of tracks for the current
 /// context (album / playlist / search result / favourites) plus a separate
@@ -15,248 +13,83 @@ class PlayQueue : public QObject
     Q_OBJECT
 
 public:
-    explicit PlayQueue(QObject *parent = nullptr) : QObject(parent) {}
+    explicit PlayQueue(QObject *parent = nullptr);
 
     // ---- Loading a new context ----
 
     /// Replace the queue with all tracks from an album/playlist JSON context.
     /// @param startIndex  Index of the track to start playing (-1 = first).
-    void setContext(const QJsonArray &tracks, int startIndex = 0)
+    void setContext(const QJsonArray &tracks, int startIndex = 0);
-    {
-        m_queue.clear();
-        m_playNext.clear();
-
-        // Only queue streamable tracks; find the filtered index for startIndex
-        int filteredStart = 0;
-        int filteredIdx   = 0;
-        bool found        = false;
-        for (int orig = 0; orig < tracks.size(); ++orig) {
-            const QJsonObject t = tracks[orig].toObject();
-            if (!t["streamable"].toBool(true))
-                continue;
-            if (!found && orig >= startIndex) {
-                filteredStart = filteredIdx;
-                found = true;
-            }
-            m_queue.append(t);
-            ++filteredIdx;
-        }
-        m_index = qBound(0, filteredStart, qMax(0, m_queue.size() - 1));
-
-        if (m_shuffle)
-            shuffleQueue(m_index);
-
-        emit queueChanged();
-    }
 
     // ---- Re-order after a sort (keeps m_playNext, updates m_index) ----
 
-    void reorderContext(const QJsonArray &tracks, qint64 currentId)
+    void reorderContext(const QJsonArray &tracks, qint64 currentId);
-    {
-        m_queue.clear();
-        for (const auto &v : tracks) {
-            const QJsonObject t = v.toObject();
-            if (t["streamable"].toBool(true))
-                m_queue.append(t);
-        }
-
-        m_index = 0;
-        for (int i = 0; i < m_queue.size(); ++i) {
-            if (static_cast<qint64>(m_queue[i]["id"].toDouble()) == currentId) {
-                m_index = i;
-                break;
-            }
-        }
-        emit queueChanged();
-    }
 
     // ---- Clear / remove upcoming ----
 
     /// Remove all "up next" entries (playNext + remaining main queue after current).
-    void clearUpcoming()
+    void clearUpcoming();
-    {
-        m_playNext.clear();
-        if (m_index < m_queue.size())
-            m_queue.resize(m_index + 1); // keep up to and including current
-        emit queueChanged();
-    }
 
     /// Remove one upcoming track by its index in upcomingTracks().
-    void removeUpcoming(int upcomingIndex)
+    void removeUpcoming(int upcomingIndex);
-    {
-        if (upcomingIndex < m_playNext.size()) {
-            m_playNext.removeAt(upcomingIndex);
-        } else {
-            const int queueIdx = m_index + 1 + (upcomingIndex - m_playNext.size());
-            if (queueIdx < m_queue.size())
-                m_queue.removeAt(queueIdx);
-        }
-        emit queueChanged();
-    }
 
     // ---- Shuffle ----
 
     bool shuffleEnabled() const { return m_shuffle; }
 
-    void setShuffle(bool enabled)
+    void setShuffle(bool enabled);
-    {
-        if (m_shuffle == enabled) return;
-        m_shuffle = enabled;
-        if (enabled && !m_queue.isEmpty())
-            shuffleQueue(m_index);
-        emit queueChanged();
-    }
 
     /// Shuffle the current queue once without changing the global shuffle flag.
-    void shuffleNow()
+    void shuffleNow();
-    {
-        if (m_queue.isEmpty()) return;
-        shuffleQueue(m_index);
-        emit queueChanged();
-    }
 
     // ---- Play-next prepend queue (like "Add to queue" ----
 
-    void addToQueue(const QJsonObject &track)
+    void addToQueue(const QJsonObject &track);
-    {
-        m_playNext.append(track);
-        emit queueChanged();
-    }
 
-    void playNext(const QJsonObject &track)
+    void playNext(const QJsonObject &track);
-    {
-        m_playNext.prepend(track);
-        emit queueChanged();
-    }
 
     // ---- Navigation ----
 
-    bool hasCurrent() const
+    bool hasCurrent() const;
-    {
-        return (!m_playNext.isEmpty()) || (!m_queue.isEmpty());
-    }
 
-    QJsonObject current() const
+    QJsonObject current() const;
-    {
-        if (!m_playNext.isEmpty()) return m_playNext.first();
-        if (m_index < m_queue.size()) return m_queue.at(m_index);
-        return {};
-    }
 
-    qint64 currentId() const
+    qint64 currentId() const;
-    {
-        return static_cast<qint64>(current()["id"].toDouble());
-    }
 
     /// Advance and return the track to play next.  Returns {} at end of queue.
-    QJsonObject advance()
+    QJsonObject advance();
-    {
-        if (!m_playNext.isEmpty()) {
-            // Return the playNext item directly — do NOT call current() after
-            // removal, as that would fall back to the already-playing m_index track.
-            const QJsonObject next = m_playNext.takeFirst();
-            emit queueChanged();
-            return next;
-        }
-        ++m_index;
-        emit queueChanged();
-        return current();
-    }
 
     /// Step backwards in the main queue (play-next is not affected).
-    QJsonObject stepBack()
+    QJsonObject stepBack();
-    {
-        if (m_index > 0) --m_index;
-        emit queueChanged();
-        return current();
-    }
 
-    bool canGoNext() const
+    bool canGoNext() const;
-    {
-        return !m_playNext.isEmpty() || (m_index + 1 < m_queue.size());
-    }
 
     bool canGoPrev() const { return m_index > 0; }
 
     // ---- Index lookup ----
 
     /// Set the current position by track id (after user double-clicks a row).
-    void setCurrentById(qint64 id)
+    void setCurrentById(qint64 id);
-    {
-        m_playNext.clear();
-        for (int i = 0; i < m_queue.size(); ++i) {
-            if (static_cast<qint64>(m_queue[i]["id"].toDouble()) == id) {
-                m_index = i;
-                emit queueChanged();
-                return;
-            }
-        }
-    }
 
     // ---- Accessors for queue panel ----
 
-    QVector<QJsonObject> upcomingTracks(int maxCount = 200) const
+    QVector<QJsonObject> upcomingTracks(int maxCount = 200) const;
-    {
-        QVector<QJsonObject> result;
-        result.append(m_playNext);
-        for (int i = m_index + 1; i < m_queue.size() && result.size() < maxCount; ++i)
-            result.append(m_queue.at(i));
-        return result;
-    }
 
     int playNextCount()  const { return m_playNext.size(); }
     int totalSize()      const { return m_playNext.size() + m_queue.size(); }
     int currentIndex()   const { return m_index; }
 
     /// Skip to upcoming[upcomingIndex]: removes everything before it, pops and returns it.
-    QJsonObject skipToUpcoming(int upcomingIndex)
+    QJsonObject skipToUpcoming(int upcomingIndex);
-    {
-        // Remove items 0..upcomingIndex-1 from the front of upcoming
-        for (int i = 0; i < upcomingIndex; ++i) {
-            if (!m_playNext.isEmpty())
-                m_playNext.removeFirst();
-            else if (m_index + 1 < m_queue.size())
-                ++m_index;
-        }
-        // Pop and return the target (now at upcoming[0])
-        if (!m_playNext.isEmpty()) {
-            const QJsonObject t = m_playNext.takeFirst();
-            emit queueChanged();
-            return t;
-        }
-        if (m_index + 1 < m_queue.size()) {
-            ++m_index;
-            emit queueChanged();
-            return m_queue.at(m_index);
-        }
-        emit queueChanged();
-        return {};
-    }
 
     /// Replace the upcoming list with a new order (used after drag-reorder in UI).
-    void setUpcomingOrder(const QVector<QJsonObject> &newOrder)
+    void setUpcomingOrder(const QVector<QJsonObject> &newOrder);
-    {
+
-        m_playNext = newOrder;
+    /// Append tracks to the main queue tail (autoplay/discovery).
-        m_queue.resize(m_index + 1); // drop old main-queue tail
+    void appendToContext(const QJsonArray &tracks);
-        emit queueChanged();
-    }
 
     /// Move an upcoming item (by its index in upcomingTracks()) to the front of playNext.
-    void moveUpcomingToTop(int upcomingIndex)
+    void moveUpcomingToTop(int upcomingIndex);
-    {
-        if (upcomingIndex < 0) return;
-        QJsonObject track;
-        if (upcomingIndex < m_playNext.size()) {
-            if (upcomingIndex == 0) return; // already at top
-            track = m_playNext.takeAt(upcomingIndex);
-        } else {
-            const int queueIdx = m_index + 1 + (upcomingIndex - m_playNext.size());
-            if (queueIdx >= m_queue.size()) return;
-            track = m_queue.takeAt(queueIdx);
-        }
-        m_playNext.prepend(track);
-        emit queueChanged();
-    }
 
 signals:
     void queueChanged();
@@ -267,19 +100,5 @@ private:
     int  m_index   = 0;
     bool m_shuffle = false;
 
-    void shuffleQueue(int keepAtFront)
+    void shuffleQueue(int keepAtFront);
-    {
-        if (m_queue.isEmpty()) return;
-        // Keep the current track at index 0 of the remaining queue
-        if (keepAtFront >= 0 && keepAtFront < m_queue.size()) {
-            QJsonObject current = m_queue.takeAt(keepAtFront);
-            std::mt19937 rng(std::random_device{}());
-            std::shuffle(m_queue.begin(), m_queue.end(), rng);
-            m_queue.prepend(current);
-        } else {
-            std::mt19937 rng(std::random_device{}());
-            std::shuffle(m_queue.begin(), m_queue.end(), rng);
-        }
-        m_index = 0;
-    }
 };

src/scrobbler/lastfm.hpp

@@ -80,6 +80,8 @@ public slots:
         m_duration = static_cast<qint64>(track["duration"].toDouble());
         m_startTime       = QDateTime::currentSecsSinceEpoch();
         m_playedSecs      = 0;
+        m_lastPosition    = 0;
+        m_accumulatedSecs = 0;
         m_scrobbled       = false;
 
         if (!isEnabled() || m_title.isEmpty() || m_duration < 30) return;
@@ -88,18 +90,29 @@ public slots:
 
     void onPositionChanged(quint64 positionSecs, quint64 /*duration*/)
     {
+        // Accumulate actual listening time to prevent false scrobbles from seeking
+        if (positionSecs > m_lastPosition && (positionSecs - m_lastPosition) <= 2) {
+            m_accumulatedSecs += (positionSecs - m_lastPosition);
+        }
+        m_lastPosition = positionSecs;
         m_playedSecs = positionSecs;
+
         if (!isEnabled() || m_scrobbled || m_title.isEmpty() || m_duration < 30) return;
+
         // Scrobble after 50% or 240 seconds played, whichever comes first, min 30 seconds.
         const quint64 threshold = static_cast<quint64>(qMin((qint64)240, m_duration / 2));
-        if (positionSecs >= 30 && positionSecs >= threshold)
+        if (m_accumulatedSecs >= 30 && m_accumulatedSecs >= threshold)
             scrobble();
     }
 
     void onTrackFinished()
     {
         if (!isEnabled() || m_scrobbled || m_title.isEmpty() || m_duration < 30) return;
-        if (m_playedSecs >= 30) scrobble();
+
+        const quint64 threshold = static_cast<quint64>(qMin((qint64)240, m_duration / 2));
+        if (m_accumulatedSecs >= 30 && m_accumulatedSecs >= threshold) {
+            scrobble();
+        }
     }
 
 private:
@@ -111,6 +124,8 @@ private:
     qint64  m_duration        = 0;
     qint64  m_startTime       = 0;
     quint64 m_playedSecs      = 0;
+    quint64 m_lastPosition    = 0;
+    quint64 m_accumulatedSecs = 0;
     bool    m_scrobbled       = false;
 
     void updateNowPlaying()
@@ -137,11 +152,13 @@ private:
         params["method"]       = QStringLiteral("track.scrobble");
         params["api_key"]      = AppSettings::instance().lastFmApiKey();
         params["sk"]           = AppSettings::instance().lastFmSessionKey();
-        params["artist"]    = m_artist;
+
-        params["track"]     = m_title;
+        params["artist[0]"]    = m_artist;
-        params["album"]     = m_album;
+        params["track[0]"]     = m_title;
-        params["timestamp"] = QString::number(m_startTime);
+        params["album[0]"]     = m_album;
-        params["duration"]  = QString::number(m_duration);
+        params["timestamp[0]"] = QString::number(m_startTime);
+        params["duration[0]"]  = QString::number(m_duration);
+
         params["api_sig"]      = buildSig(params, AppSettings::instance().lastFmApiSecret());
         params["format"]       = QStringLiteral("json");
 

src/util/colors.hpp

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <QColor>
+
+namespace Colors {
+
+// Brand accents
+inline const QColor QobuzOrange{0xFF, 0xB2, 0x32};
+inline const QColor QobuzBlue  {0x46, 0xB3, 0xEE};
+
+// Badge / indicator colors used in tree-view item foregrounds
+inline const QColor BadgeGreen {QStringLiteral("#2FA84F")};
+inline const QColor BadgeBlue  {QStringLiteral("#2B7CD3")};
+inline const QColor BadgeGray  {QStringLiteral("#8E8E93")};
+
+// Text
+inline const QColor LightText      {0xe8, 0xe8, 0xe8};
+inline const QColor SubduedText    {0xaa, 0xaa, 0xaa};
+inline const QColor PlaceholderText{0x66, 0x66, 0x66};
+inline const QColor DisabledText   {0x55, 0x55, 0x55};
+
+// Surfaces / backgrounds
+inline const QColor WindowBg       {0x19, 0x19, 0x19};
+inline const QColor BaseBg         {0x14, 0x14, 0x14};
+inline const QColor AlternateBaseBg{0x1e, 0x1e, 0x1e};
+inline const QColor ButtonSurface  {0x2a, 0x2a, 0x2a};
+inline const QColor ContextBg      {0x1a, 0x1a, 0x1a};
+inline const QColor MidSurface     {0x2f, 0x2f, 0x2f};
+inline const QColor DarkSurface    {0x0e, 0x0e, 0x0e};
+inline const QColor HighlightedFg  {0x10, 0x10, 0x10};
+
+} // namespace Colors

src/util/icon.hpp

@@ -24,6 +24,7 @@ namespace Icon
     inline QIcon previous()   { return get("media-skip-backward"); }
     inline QIcon shuffle()    { return get("media-playlist-shuffle"); }
     inline QIcon repeat()     { return get("media-playlist-repeat"); }
+    inline QIcon autoplay()   { return get("media-track-show-active"); }
 
     // Volume
     inline QIcon volumeHigh() { return get("audio-volume-high"); }

src/util/settings.hpp

@@ -41,6 +41,9 @@ public:
     bool gaplessEnabled() const        { return m_settings.value("playback/gapless", false).toBool(); }
     void setGaplessEnabled(bool v)     { m_settings.setValue("playback/gapless", v); }
 
+    bool autoplayEnabled() const       { return m_settings.value("playback/autoplay", false).toBool(); }
+    void setAutoplayEnabled(bool v)    { m_settings.setValue("playback/autoplay", v); }
+
     // --- Last.fm ---
     bool    lastFmEnabled()   const  { return m_settings.value("lastfm/enabled", false).toBool(); }
     void    setLastFmEnabled(bool v) { m_settings.setValue("lastfm/enabled", v); }

src/view/albumlistview.hpp

@@ -1,5 +1,7 @@
 #pragma once
 
+#include "../util/colors.hpp"
+
 #include <QTreeWidget>
 #include <QTreeWidgetItem>
 #include <QHeaderView>
@@ -80,6 +82,7 @@ public:
             const QString year = date.isEmpty()
                 ? a["dates"].toObject()["original"].toString().left(4)
                 : date.left(4);
+            const qint64 artistId = static_cast<qint64>(a["artist"].toObject()["id"].toDouble());
 
             const int tracks  = a["tracks_count"].toInt();
             const bool hiRes  = a["hires_streamable"].toBool()
@@ -88,7 +91,7 @@ public:
             auto *item = new QTreeWidgetItem(this);
             if (hiRes) {
                 item->setText(0, QStringLiteral("H"));
-                item->setForeground(0, QColor(QStringLiteral("#FFB232")));
+                item->setForeground(0, Colors::QobuzOrange);
                 item->setFont(0, hiResFont);
                 item->setTextAlignment(0, Qt::AlignCenter);
             }
@@ -97,6 +100,7 @@ public:
             item->setText(3, year);
             item->setText(4, tracks > 0 ? QString::number(tracks) : QString());
             item->setData(1, Qt::UserRole, id);
+            item->setData(2, Qt::UserRole, artistId);
         }
     }
 

src/view/context/view.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "../../backend/qobuzbackend.hpp"
+#include "../../util/colors.hpp"
 
 #include <QDockWidget>
 #include <QWidget>
@@ -32,11 +33,11 @@ namespace Context
         {
             QPainter p(this);
             if (m_pix.isNull()) {
-                p.fillRect(rect(), QColor(0x1a, 0x1a, 0x1a));
+                p.fillRect(rect(), Colors::ContextBg);
                 return;
             }
             const QPixmap scaled = m_pix.scaled(size(), Qt::KeepAspectRatio, Qt::SmoothTransformation);
-            p.fillRect(rect(), QColor(0x1a, 0x1a, 0x1a));
+            p.fillRect(rect(), Colors::ContextBg);
             p.drawPixmap((width()  - scaled.width())  / 2,
                          (height() - scaled.height()) / 2,
                          scaled);

src/view/genrebrowser.cpp

@@ -0,0 +1,808 @@
+#include "genrebrowser.hpp"
+#include "../util/colors.hpp"
+
+#include <QAction>
+#include <QDialog>
+#include <QDialogButtonBox>
+#include <QHeaderView>
+#include <QHBoxLayout>
+#include <QLabel>
+#include <QListWidget>
+#include <QMenu>
+#include <QPushButton>
+#include <QScrollBar>
+#include <QSignalBlocker>
+#include <QTimer>
+#include <QTreeWidgetItem>
+#include <QVBoxLayout>
+
+#include <algorithm>
+
+GenreBrowserView::GenreBrowserView(QobuzBackend *backend, PlayQueue *queue, QWidget *parent)
+    : QWidget(parent)
+    , m_backend(backend)
+    , m_queue(queue)
+{
+    auto *layout = new QVBoxLayout(this);
+    layout->setContentsMargins(0, 0, 0, 0);
+    layout->setSpacing(0);
+
+    auto *topBar = new QWidget(this);
+    auto *topLayout = new QHBoxLayout(topBar);
+    topLayout->setContentsMargins(8, 6, 8, 6);
+    topLayout->setSpacing(6);
+
+    QFont topFont = topBar->font();
+    if (topFont.pointSize() > 0)
+        topFont.setPointSize(topFont.pointSize() + 1);
+    static constexpr int controlHeight = 30;
+
+    m_browseLabel = new QLabel(tr("Show:"), this);
+    m_browseLabel->setFont(topFont);
+    topLayout->addWidget(m_browseLabel);
+    m_kindCombo = new QComboBox(this);
+    m_kindCombo->addItem(tr("Albums"), QStringLiteral("albums"));
+    m_kindCombo->addItem(tr("Playlists"), QStringLiteral("playlists"));
+    m_kindCombo->setFont(topFont);
+    m_kindCombo->setMinimumWidth(110);
+    m_kindCombo->setFixedHeight(controlHeight);
+    topLayout->addWidget(m_kindCombo);
+
+    m_gapAfterKind = new QWidget(this);
+    m_gapAfterKind->setFixedWidth(6);
+    topLayout->addWidget(m_gapAfterKind);
+
+    m_genreLabel = new QLabel(tr("Genre:"), this);
+    m_genreLabel->setFont(topFont);
+    topLayout->addWidget(m_genreLabel);
+    m_genreCombo = new QComboBox(this);
+    m_genreCombo->setFont(topFont);
+    m_genreCombo->setMinimumWidth(180);
+    m_genreCombo->setFixedHeight(controlHeight);
+    topLayout->addWidget(m_genreCombo);
+
+    m_gapAfterGenre = new QWidget(this);
+    m_gapAfterGenre->setFixedWidth(10);
+    topLayout->addWidget(m_gapAfterGenre);
+
+    m_typeLabel = new QLabel(tr("Type:"), this);
+    m_typeLabel->setFont(topFont);
+    topLayout->addWidget(m_typeLabel);
+    m_typeCombo = new QComboBox(this);
+    m_typeCombo->setFont(topFont);
+    m_typeCombo->setMinimumWidth(180);
+    m_typeCombo->setFixedHeight(controlHeight);
+    topLayout->addWidget(m_typeCombo);
+
+    m_playlistSearchLabel = new QLabel(tr("Search:"), this);
+    m_playlistSearchLabel->setFont(topFont);
+    m_playlistSearchLabel->setVisible(false);
+    topLayout->addWidget(m_playlistSearchLabel);
+
+    m_playlistSearchBox = new QLineEdit(this);
+    m_playlistSearchBox->setFont(topFont);
+    m_playlistSearchBox->setPlaceholderText(tr("Search playlists..."));
+    m_playlistSearchBox->setClearButtonEnabled(true);
+    m_playlistSearchBox->setVisible(false);
+    m_playlistSearchBox->setMinimumWidth(220);
+    m_playlistSearchBox->setMaximumWidth(320);
+    m_playlistSearchBox->setFixedHeight(controlHeight);
+    topLayout->addWidget(m_playlistSearchBox);
+
+    m_playlistSearchBtn = new QPushButton(tr("Go"), this);
+    m_playlistSearchBtn->setFont(topFont);
+    m_playlistSearchBtn->setVisible(false);
+    m_playlistSearchBtn->setFixedHeight(controlHeight);
+    topLayout->addWidget(m_playlistSearchBtn);
+
+    m_deepShuffleBtn = new QPushButton(tr("⇄  Deep Shuffle"), this);
+    m_deepShuffleBtn->setFont(topFont);
+    m_deepShuffleBtn->setVisible(false);
+    m_deepShuffleBtn->setFixedHeight(controlHeight);
+    topLayout->addWidget(m_deepShuffleBtn);
+
+    topLayout->addStretch();
+    layout->addWidget(topBar);
+
+    m_resultsStack = new QStackedWidget(this);
+
+    m_albumList = new AlbumListView(this);
+    m_albumList->setContextMenuPolicy(Qt::CustomContextMenu);
+
+    m_playlistList = new QTreeWidget(this);
+    m_playlistList->setColumnCount(4);
+    m_playlistList->setHeaderLabels({tr(""), tr("Playlist"), tr("Owner"), tr("Tracks")});
+    m_playlistList->setRootIsDecorated(false);
+    m_playlistList->setAlternatingRowColors(true);
+    m_playlistList->setSelectionBehavior(QAbstractItemView::SelectRows);
+    m_playlistList->setSortingEnabled(true);
+    m_playlistList->setContextMenuPolicy(Qt::CustomContextMenu);
+    m_playlistList->header()->setSectionResizeMode(0, QHeaderView::ResizeToContents);
+    m_playlistList->header()->setSectionResizeMode(1, QHeaderView::Stretch);
+    m_playlistList->header()->setSectionResizeMode(2, QHeaderView::Stretch);
+    m_playlistList->header()->setSectionResizeMode(3, QHeaderView::ResizeToContents);
+    m_playlistList->header()->setStretchLastSection(false);
+
+    auto *playlistPage = new QWidget(this);
+    auto *playlistPageLayout = new QVBoxLayout(playlistPage);
+    playlistPageLayout->setContentsMargins(0, 0, 0, 0);
+    playlistPageLayout->setSpacing(0);
+    playlistPageLayout->addWidget(m_playlistList, 1);
+
+    m_loadMorePlaylistsBtn = new QPushButton(tr("Load more playlists…"), this);
+    m_loadMorePlaylistsBtn->hide();
+    playlistPageLayout->addWidget(m_loadMorePlaylistsBtn);
+
+    m_resultsStack->addWidget(m_albumList);
+    m_resultsStack->addWidget(playlistPage);
+    layout->addWidget(m_resultsStack, 1);
+
+    connect(m_backend, &QobuzBackend::genresLoaded,
+            this, &GenreBrowserView::onGenresLoaded);
+    connect(m_backend, &QobuzBackend::featuredAlbumsLoaded,
+            this, &GenreBrowserView::onFeaturedAlbumsLoaded);
+    connect(m_backend, &QobuzBackend::featuredPlaylistsLoaded,
+            this, &GenreBrowserView::onFeaturedPlaylistsLoaded);
+    connect(m_backend, &QobuzBackend::discoverPlaylistsLoaded,
+            this, &GenreBrowserView::onDiscoverPlaylistsLoaded);
+    connect(m_backend, &QobuzBackend::playlistSearchLoaded,
+            this, &GenreBrowserView::onPlaylistSearchLoaded);
+
+    connect(m_genreCombo, QOverload<int>::of(&QComboBox::currentIndexChanged),
+            this, [this](int index) {
+        const QString data = m_genreCombo->itemData(index).toString();
+        if (data == QStringLiteral("__multi__")) {
+            if (!chooseMultiGenres()) {
+                const QSignalBlocker blocker(m_genreCombo);
+                m_genreCombo->setCurrentIndex(m_lastGenreComboIndex);
+                return;
+            }
+            m_lastGenreComboIndex = index;
+            updateMultiGenreLabel();
+        } else {
+            m_lastGenreComboIndex = index;
+            if (data == QStringLiteral("__all__")) {
+                m_multiGenreIds.clear();
+                updateMultiGenreLabel();
+            }
+        }
+        onSelectionChanged();
+    });
+    connect(m_kindCombo, QOverload<int>::of(&QComboBox::currentIndexChanged),
+            this, [this](int) {
+        refreshGenreTypeChoices();
+        onSelectionChanged();
+    });
+    connect(m_typeCombo, QOverload<int>::of(&QComboBox::currentIndexChanged),
+            this, &GenreBrowserView::onSelectionChanged);
+    connect(m_playlistSearchBox, &QLineEdit::returnPressed,
+            this, &GenreBrowserView::onSelectionChanged);
+    connect(m_playlistSearchBtn, &QPushButton::clicked,
+            this, &GenreBrowserView::onSelectionChanged);
+    connect(m_deepShuffleBtn, &QPushButton::clicked,
+            this, &GenreBrowserView::onDeepShuffleClicked);
+    connect(m_albumList, &AlbumListView::albumSelected,
+            this, &GenreBrowserView::albumSelected);
+    connect(m_albumList, &QTreeWidget::customContextMenuRequested,
+            this, &GenreBrowserView::onAlbumContextMenu);
+    connect(m_playlistList, &QTreeWidget::itemDoubleClicked,
+            this, &GenreBrowserView::onPlaylistActivated);
+    connect(m_playlistList, &QTreeWidget::customContextMenuRequested,
+            this, &GenreBrowserView::onPlaylistContextMenu);
+    connect(m_albumList->verticalScrollBar(), &QScrollBar::valueChanged,
+            this, &GenreBrowserView::onAlbumScroll);
+    connect(m_playlistList->verticalScrollBar(), &QScrollBar::valueChanged,
+            this, &GenreBrowserView::onPlaylistScroll);
+    connect(m_loadMorePlaylistsBtn, &QPushButton::clicked, this, [this] {
+        m_loadMorePlaylistsBtn->hide();
+        requestPlaylistsPage(m_lastPlaylistGenreIds, m_lastPlaylistType,
+                             m_lastPlaylistTags, m_lastPlaylistQuery,
+                             m_playlistOffset, true);
+    });
+
+    m_kindCombo->setCurrentIndex(0);
+    refreshModeUi();
+}
+
+void GenreBrowserView::ensureGenresLoaded()
+{
+    if (!m_genresLoaded)
+        m_backend->getGenres();
+}
+
+void GenreBrowserView::setBrowseMode(BrowseMode mode)
+{
+    if (m_mode == mode)
+        return;
+
+    m_mode = mode;
+    refreshModeUi();
+    onSelectionChanged();
+}
+
+void GenreBrowserView::refreshModeUi()
+{
+    const bool genreMode = (m_mode == BrowseMode::Genres);
+
+    m_browseLabel->setVisible(genreMode);
+    m_kindCombo->setVisible(genreMode);
+    m_gapAfterKind->setVisible(genreMode);
+    m_genreLabel->setVisible(genreMode);
+    m_genreCombo->setVisible(genreMode);
+    m_gapAfterGenre->setVisible(genreMode);
+    m_typeLabel->setVisible(genreMode);
+    m_typeCombo->setVisible(genreMode);
+
+    if (genreMode) {
+        m_playlistSearchBox->setVisible(false);
+        m_playlistSearchLabel->setVisible(false);
+        m_playlistSearchBtn->setVisible(false);
+        m_deepShuffleBtn->setVisible(m_kindCombo->currentData().toString() == QStringLiteral("albums"));
+        refreshGenreTypeChoices();
+        return;
+    }
+
+    m_typeCombo->blockSignals(true);
+    m_typeCombo->clear();
+    m_typeCombo->addItem(tr("Search"), QStringLiteral("search"));
+    m_typeCombo->blockSignals(false);
+    m_playlistSearchLabel->setVisible(true);
+    m_playlistSearchBox->setVisible(true);
+    m_playlistSearchBtn->setVisible(true);
+    m_deepShuffleBtn->setVisible(false);
+    m_resultsStack->setCurrentIndex(1);
+}
+
+void GenreBrowserView::refreshGenreTypeChoices()
+{
+    m_typeCombo->blockSignals(true);
+    m_typeCombo->clear();
+
+    const QString kind = m_kindCombo->currentData().toString();
+    if (kind == QStringLiteral("playlists")) {
+        m_typeCombo->addItem(tr("Featured: Last Created"), QStringLiteral("last-created"));
+        m_typeCombo->addItem(tr("Discover: New"), QStringLiteral("discover-new"));
+        m_typeCombo->addItem(tr("Discover: Hi-Res"), QStringLiteral("discover-hires"));
+        m_typeCombo->addItem(tr("Discover: Focus"), QStringLiteral("discover-focus"));
+        m_typeCombo->addItem(tr("Discover: Qobuz Digs"), QStringLiteral("discover-qobuzdigs"));
+        m_resultsStack->setCurrentIndex(1);
+        m_deepShuffleBtn->setVisible(false);
+    } else {
+        m_typeCombo->addItem(tr("New Releases"), QStringLiteral("new-releases"));
+        m_typeCombo->addItem(tr("Best Sellers"), QStringLiteral("best-sellers"));
+        m_typeCombo->addItem(tr("Most Streamed"), QStringLiteral("most-streamed"));
+        m_typeCombo->addItem(tr("Editor Picks"), QStringLiteral("editor-picks"));
+        m_typeCombo->addItem(tr("Press Awards"), QStringLiteral("press-awards"));
+        m_resultsStack->setCurrentIndex(0);
+        m_deepShuffleBtn->setVisible(m_mode == BrowseMode::Genres);
+    }
+
+    m_typeCombo->blockSignals(false);
+}
+
+QString GenreBrowserView::currentGenreIds() const
+{
+    const QString data = m_genreCombo->currentData().toString();
+    if (data == QStringLiteral("__all__"))
+        return QString();
+
+    if (data == QStringLiteral("__multi__")) {
+        if (m_multiGenreIds.isEmpty())
+            return QString();
+
+        QList<qint64> ids = m_multiGenreIds.values();
+        std::sort(ids.begin(), ids.end());
+        QStringList out;
+        out.reserve(ids.size());
+        for (qint64 id : ids)
+            out.push_back(QString::number(id));
+        return out.join(QLatin1Char(','));
+    }
+
+    return data;
+}
+
+bool GenreBrowserView::chooseMultiGenres()
+{
+    QDialog dlg(this);
+    dlg.setWindowTitle(tr("Select genres"));
+    dlg.resize(320, 420);
+
+    auto *layout = new QVBoxLayout(&dlg);
+    auto *list = new QListWidget(&dlg);
+    list->setAlternatingRowColors(true);
+    layout->addWidget(list, 1);
+
+    for (int i = 0; i < m_genreCombo->count(); ++i) {
+        const QString data = m_genreCombo->itemData(i).toString();
+        if (data == QStringLiteral("__all__") || data == QStringLiteral("__multi__"))
+            continue;
+
+        auto *item = new QListWidgetItem(m_genreCombo->itemText(i), list);
+        item->setFlags(item->flags() | Qt::ItemIsUserCheckable);
+        const qint64 id = data.toLongLong();
+        item->setData(Qt::UserRole, id);
+        item->setCheckState(m_multiGenreIds.contains(id) ? Qt::Checked : Qt::Unchecked);
+    }
+
+    auto *buttons = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, &dlg);
+    layout->addWidget(buttons);
+    connect(buttons, &QDialogButtonBox::accepted, &dlg, &QDialog::accept);
+    connect(buttons, &QDialogButtonBox::rejected, &dlg, &QDialog::reject);
+
+    if (dlg.exec() != QDialog::Accepted)
+        return false;
+
+    m_multiGenreIds.clear();
+    for (int i = 0; i < list->count(); ++i) {
+        QListWidgetItem *item = list->item(i);
+        if (item->checkState() == Qt::Checked)
+            m_multiGenreIds.insert(item->data(Qt::UserRole).toLongLong());
+    }
+    return true;
+}
+
+void GenreBrowserView::updateMultiGenreLabel()
+{
+    const int multiIndex = m_genreCombo->count() - 1;
+    if (multiIndex < 0)
+        return;
+
+    const QString text = m_multiGenreIds.isEmpty()
+        ? tr("Multiple...")
+        : tr("Multiple (%1)").arg(m_multiGenreIds.size());
+    m_genreCombo->setItemText(multiIndex, text);
+}
+
+void GenreBrowserView::onGenresLoaded(const QJsonObject &result)
+{
+    m_genresLoaded = true;
+    m_genreCombo->blockSignals(true);
+    m_genreCombo->clear();
+    m_genreCombo->addItem(tr("All genres"), QStringLiteral("__all__"));
+
+    const QJsonArray items = result["items"].toArray();
+    for (const auto &value : items) {
+        const QJsonObject genre = value.toObject();
+        m_genreCombo->addItem(
+            genre["name"].toString(),
+            static_cast<qint64>(genre["id"].toDouble()));
+    }
+
+    m_genreCombo->addItem(tr("Multiple..."), QStringLiteral("__multi__"));
+    updateMultiGenreLabel();
+    m_lastGenreComboIndex = 0;
+    m_genreCombo->setCurrentIndex(0);
+
+    m_genreCombo->blockSignals(false);
+    onSelectionChanged();
+}
+
+void GenreBrowserView::onFeaturedAlbumsLoaded(const QJsonObject &result)
+{
+    m_resultsStack->setCurrentIndex(0);
+    const QString genreIds = result["genre_ids"].toString();
+    const QString type = result["type"].toString();
+    const int offset = result["offset"].toInt();
+    if (genreIds != m_lastAlbumGenreIds || type != m_lastAlbumType)
+        return;
+
+    const QJsonArray items = result["items"].toArray();
+    if (offset <= 0)
+        m_albumList->setAlbums(items);
+    else
+        m_albumList->addAlbums(items);
+
+    m_albumTotal = result["total"].toInt();
+    m_albumOffset = offset + items.size();
+    if (items.isEmpty())
+        m_albumTotal = m_albumOffset;
+    m_loadingAlbums = false;
+
+    if (m_collectAlbumsForDeepShuffle) {
+        if (m_albumOffset < m_albumTotal) {
+            requestAlbumsPage(m_lastAlbumGenreIds, m_lastAlbumType, m_albumOffset, true);
+            return;
+        }
+        m_collectAlbumsForDeepShuffle = false;
+        startDeepShuffleFromLoadedAlbums();
+        return;
+    }
+
+    // If the viewport is not scrollable yet, eagerly fetch more pages.
+    // Deferred: the scrollbar maximum isn't updated until after layout runs.
+    QTimer::singleShot(0, this, [this] {
+        QScrollBar *bar = m_albumList->verticalScrollBar();
+        if (bar && bar->maximum() == 0 && m_albumOffset < m_albumTotal)
+            requestAlbumsPage(m_lastAlbumGenreIds, m_lastAlbumType, m_albumOffset, true);
+    });
+}
+
+void GenreBrowserView::onFeaturedPlaylistsLoaded(const QJsonObject &result)
+{
+    m_resultsStack->setCurrentIndex(1);
+    const QString genreIds = result["genre_ids"].toString();
+    const QString type = result["type"].toString();
+    const int offset = result["offset"].toInt();
+    if (genreIds != m_lastPlaylistGenreIds || type != m_lastPlaylistType)
+        return;
+
+    const QJsonArray items = result["items"].toArray();
+    setPlaylistItems(items, offset > 0);
+    m_playlistTotal = result["total"].toInt();
+    m_playlistOffset = offset + items.size();
+    if (items.isEmpty())
+        m_playlistTotal = m_playlistOffset;
+    m_loadingPlaylists = false;
+
+    QTimer::singleShot(0, this, [this] {
+        QScrollBar *bar = m_playlistList->verticalScrollBar();
+        if (bar && bar->maximum() == 0 && m_playlistOffset < m_playlistTotal)
+            requestPlaylistsPage(m_lastPlaylistGenreIds, m_lastPlaylistType, m_lastPlaylistTags, m_lastPlaylistQuery, m_playlistOffset, true);
+    });
+}
+
+void GenreBrowserView::onDiscoverPlaylistsLoaded(const QJsonObject &result)
+{
+    m_resultsStack->setCurrentIndex(1);
+    const QString genreIds = result["genre_ids"].toString();
+    const QString tags = result["tags"].toString();
+    const int offset = result["offset"].toInt();
+    if (genreIds != m_lastPlaylistGenreIds || tags != m_lastPlaylistTags)
+        return;
+
+    const QJsonArray items = result["items"].toArray();
+    setPlaylistItems(items, offset > 0);
+    m_playlistTotal = result["total"].toInt();
+    m_playlistOffset = offset + items.size();
+    if (items.isEmpty())
+        m_playlistTotal = m_playlistOffset;
+    m_loadingPlaylists = false;
+
+    QTimer::singleShot(0, this, [this] {
+        QScrollBar *bar = m_playlistList->verticalScrollBar();
+        if (bar && bar->maximum() == 0 && m_playlistOffset < m_playlistTotal)
+            requestPlaylistsPage(m_lastPlaylistGenreIds, m_lastPlaylistType, m_lastPlaylistTags, m_lastPlaylistQuery, m_playlistOffset, true);
+    });
+}
+
+void GenreBrowserView::onPlaylistSearchLoaded(const QJsonObject &result)
+{
+    m_resultsStack->setCurrentIndex(1);
+    const QString query = result["query"].toString();
+    const int offset = result["offset"].toInt();
+    if (query != m_lastPlaylistQuery)
+        return;
+
+    const QJsonArray items = result["items"].toArray();
+    setPlaylistItems(items, offset > 0);
+    m_playlistTotal = result["total"].toInt();
+    m_playlistOffset = offset + items.size();
+    if (items.isEmpty())
+        m_playlistTotal = m_playlistOffset;
+    m_loadingPlaylists = false;
+
+    // Eagerly fill the viewport, then switch to a manual "Load more" button.
+    if (m_playlistOffset >= m_playlistTotal) {
+        m_loadMorePlaylistsBtn->hide();
+        m_searchViewportFilled = true;
+    } else if (!m_searchViewportFilled) {
+        QTimer::singleShot(0, this, [this] {
+            QScrollBar *bar = m_playlistList->verticalScrollBar();
+            if (bar && bar->maximum() == 0 && m_playlistOffset < m_playlistTotal) {
+                requestPlaylistsPage(m_lastPlaylistGenreIds, m_lastPlaylistType,
+                                     m_lastPlaylistTags, m_lastPlaylistQuery,
+                                     m_playlistOffset, true);
+            } else {
+                m_searchViewportFilled = true;
+                m_loadMorePlaylistsBtn->setVisible(m_playlistOffset < m_playlistTotal);
+            }
+        });
+    } else {
+        m_loadMorePlaylistsBtn->setVisible(true);
+    }
+}
+
+void GenreBrowserView::onSelectionChanged()
+{
+    m_collectAlbumsForDeepShuffle = false;
+
+    if (m_mode == BrowseMode::PlaylistSearch) {
+        m_resultsStack->setCurrentIndex(1);
+        m_playlistSearchLabel->setVisible(true);
+        m_playlistSearchBox->setVisible(true);
+        m_playlistSearchBtn->setVisible(true);
+        m_deepShuffleBtn->setVisible(false);
+        m_deepShuffleBtn->setEnabled(true);
+        m_deepShuffleBtn->setText(tr("⇄  Deep Shuffle"));
+        const QString query = m_playlistSearchBox->text().trimmed();
+        if (query.size() < 2) {
+            m_playlistList->clear();
+            m_playlistOffset = 0;
+            m_playlistTotal = 0;
+            m_loadingPlaylists = false;
+        } else {
+            requestPlaylistsPage(QString(), QStringLiteral("search"), QString(), query, 0, false);
+        }
+        return;
+    }
+
+    if (m_genreCombo->count() == 0)
+        return;
+
+    const QString genreIds = currentGenreIds();
+    const QString type = m_typeCombo->currentData().toString();
+    const QString kind = m_kindCombo->currentData().toString();
+    m_playlistSearchLabel->setVisible(false);
+    m_playlistSearchBox->setVisible(false);
+    m_playlistSearchBtn->setVisible(false);
+
+    if (kind == QStringLiteral("playlists")) {
+        m_resultsStack->setCurrentIndex(1);
+        m_deepShuffleBtn->setVisible(false);
+        m_deepShuffleBtn->setEnabled(true);
+        m_deepShuffleBtn->setText(tr("⇄  Deep Shuffle"));
+        if (type == QStringLiteral("discover-new"))
+            requestPlaylistsPage(genreIds, type, QStringLiteral("new"), QString(), 0, false);
+        else if (type == QStringLiteral("discover-hires"))
+            requestPlaylistsPage(genreIds, type, QStringLiteral("hi-res"), QString(), 0, false);
+        else if (type == QStringLiteral("discover-focus"))
+            requestPlaylistsPage(genreIds, type, QStringLiteral("focus"), QString(), 0, false);
+        else if (type == QStringLiteral("discover-qobuzdigs"))
+            requestPlaylistsPage(genreIds, type, QStringLiteral("qobuzdigs"), QString(), 0, false);
+        else
+            requestPlaylistsPage(genreIds, type, QString(), QString(), 0, false);
+    } else {
+        m_resultsStack->setCurrentIndex(0);
+        m_deepShuffleBtn->setVisible(m_mode == BrowseMode::Genres);
+        m_deepShuffleBtn->setEnabled(true);
+        m_deepShuffleBtn->setText(tr("⇄  Deep Shuffle"));
+        requestAlbumsPage(genreIds, type, 0, false);
+    }
+}
+
+QStringList GenreBrowserView::currentAlbumIds() const
+{
+    QStringList ids;
+    for (int i = 0; i < m_albumList->topLevelItemCount(); ++i) {
+        const QString id = m_albumList->topLevelItem(i)->data(1, Qt::UserRole).toString();
+        if (!id.isEmpty())
+            ids.push_back(id);
+    }
+    return ids;
+}
+
+void GenreBrowserView::startDeepShuffleFromLoadedAlbums()
+{
+    const QStringList albumIds = currentAlbumIds();
+    if (albumIds.isEmpty()) {
+        m_deepShuffleBtn->setEnabled(true);
+        m_deepShuffleBtn->setText(tr("⇄  Deep Shuffle"));
+        return;
+    }
+
+    m_waitingDeepShuffle = true;
+    m_deepShuffleBtn->setEnabled(false);
+    m_deepShuffleBtn->setText(tr("Loading…"));
+    m_backend->getAlbumsTracks(albumIds);
+}
+
+void GenreBrowserView::requestAlbumsPage(const QString &genreIds, const QString &type, int offset, bool append)
+{
+    if (append && m_loadingAlbums)
+        return;
+
+    if (!append) {
+        m_loadingAlbums = false;
+        m_albumOffset = 0;
+        m_albumTotal = 0;
+    }
+
+    m_lastAlbumGenreIds = genreIds;
+    m_lastAlbumType = type;
+    m_loadingAlbums = true;
+    m_backend->getFeaturedAlbums(genreIds, type, 50, static_cast<quint32>(offset));
+}
+
+void GenreBrowserView::requestPlaylistsPage(const QString &genreIds, const QString &type, const QString &tags, const QString &query, int offset, bool append)
+{
+    if (append && m_loadingPlaylists)
+        return;
+
+    if (!append) {
+        m_loadingPlaylists = false;
+        m_playlistOffset = 0;
+        m_playlistTotal = 0;
+        m_loadMorePlaylistsBtn->hide();
+        if (type == QStringLiteral("search"))
+            m_searchViewportFilled = false;
+    }
+
+    m_lastPlaylistGenreIds = genreIds;
+    m_lastPlaylistType = type;
+    m_lastPlaylistTags = tags;
+    m_lastPlaylistQuery = query;
+    m_loadingPlaylists = true;
+
+    if (type == QStringLiteral("search")) {
+        m_backend->searchPlaylists(query, 25, static_cast<quint32>(offset));
+    } else if (type.startsWith(QStringLiteral("discover-"))) {
+        m_backend->discoverPlaylists(genreIds, tags, 25, static_cast<quint32>(offset));
+    } else {
+        m_backend->getFeaturedPlaylists(genreIds, type, 25, static_cast<quint32>(offset));
+    }
+}
+
+void GenreBrowserView::onAlbumScroll(int value)
+{
+    if (m_mode != BrowseMode::Genres)
+        return;
+    if (m_kindCombo->currentData().toString() != QStringLiteral("albums"))
+        return;
+    if (m_loadingAlbums)
+        return;
+    if (m_albumOffset >= m_albumTotal)
+        return;
+
+    QScrollBar *bar = m_albumList->verticalScrollBar();
+    if (!bar || value < (bar->maximum() - 12))
+        return;
+
+    requestAlbumsPage(m_lastAlbumGenreIds, m_lastAlbumType, m_albumOffset, true);
+}
+
+void GenreBrowserView::onPlaylistScroll(int value)
+{
+    // Search results use a manual "Load more" button instead of infinite scroll.
+    if (m_lastPlaylistType == QStringLiteral("search"))
+        return;
+    if (m_loadingPlaylists)
+        return;
+    if (m_playlistOffset >= m_playlistTotal)
+        return;
+
+    QScrollBar *bar = m_playlistList->verticalScrollBar();
+    if (!bar || value < (bar->maximum() - 12))
+        return;
+
+    requestPlaylistsPage(
+        m_lastPlaylistGenreIds,
+        m_lastPlaylistType,
+        m_lastPlaylistTags,
+        m_lastPlaylistQuery,
+        m_playlistOffset,
+        true);
+}
+
+void GenreBrowserView::onDeepShuffleClicked()
+{
+    m_deepShuffleBtn->setEnabled(false);
+    m_deepShuffleBtn->setText(tr("Loading…"));
+
+    if (m_loadingAlbums) {
+        m_collectAlbumsForDeepShuffle = true;
+        return;
+    }
+
+    if (m_albumOffset < m_albumTotal) {
+        m_collectAlbumsForDeepShuffle = true;
+        requestAlbumsPage(m_lastAlbumGenreIds, m_lastAlbumType, m_albumOffset, true);
+        return;
+    }
+
+    startDeepShuffleFromLoadedAlbums();
+}
+
+bool GenreBrowserView::tryHandleDeepShuffleTracks(const QJsonArray &tracks)
+{
+    if (!m_waitingDeepShuffle)
+        return false;
+
+    m_waitingDeepShuffle = false;
+    m_collectAlbumsForDeepShuffle = false;
+    m_deepShuffleBtn->setEnabled(true);
+    m_deepShuffleBtn->setText(tr("⇄  Deep Shuffle"));
+
+    if (tracks.isEmpty())
+        return true;
+
+    m_queue->setContext(tracks, 0);
+    m_queue->shuffleNow();
+    const QJsonObject first = m_queue->current();
+    const qint64 id = static_cast<qint64>(first["id"].toDouble());
+    if (id > 0)
+        emit playTrackRequested(id);
+    return true;
+}
+
+void GenreBrowserView::onAlbumContextMenu(const QPoint &pos)
+{
+    QTreeWidgetItem *item = m_albumList->itemAt(pos);
+    if (!item)
+        return;
+
+    const QString albumId = item->data(1, Qt::UserRole).toString();
+    const qint64 artistId = item->data(2, Qt::UserRole).toLongLong();
+    const QString albumTitle = item->text(1);
+    const QString artistName = item->text(2);
+
+    QMenu menu(this);
+
+    auto *openAlbum = menu.addAction(
+        QIcon(":/res/icons/view-media-album-cover.svg"),
+        tr("Open album: %1").arg(QString(albumTitle).replace(QLatin1Char('&'), QStringLiteral("&&"))));
+    connect(openAlbum, &QAction::triggered, this, [this, albumId] {
+        emit albumSelected(albumId);
+    });
+
+    auto *addFav = menu.addAction(QIcon(":/res/icons/starred-symbolic.svg"), tr("Add to favorites"));
+    connect(addFav, &QAction::triggered, this, [this, albumId] {
+        m_backend->addFavAlbum(albumId);
+    });
+
+    if (artistId > 0) {
+        menu.addSeparator();
+        auto *openArtist = menu.addAction(
+            QIcon(":/res/icons/view-media-artist.svg"),
+            tr("Open artist: %1").arg(QString(artistName).replace(QLatin1Char('&'), QStringLiteral("&&"))));
+        connect(openArtist, &QAction::triggered, this, [this, artistId] {
+            emit artistSelected(artistId);
+        });
+    }
+
+    menu.exec(m_albumList->viewport()->mapToGlobal(pos));
+}
+
+void GenreBrowserView::onPlaylistActivated(QTreeWidgetItem *item, int)
+{
+    if (!item)
+        return;
+
+    const qint64 playlistId = item->data(0, Qt::UserRole).toLongLong();
+    if (playlistId > 0)
+        emit playlistSelected(playlistId);
+}
+
+void GenreBrowserView::onPlaylistContextMenu(const QPoint &pos)
+{
+    QTreeWidgetItem *item = m_playlistList->itemAt(pos);
+    if (!item)
+        return;
+
+    const qint64 playlistId = item->data(0, Qt::UserRole).toLongLong();
+    if (playlistId <= 0)
+        return;
+
+    QMenu menu(this);
+    auto *openPlaylist = menu.addAction(
+        QIcon(":/res/icons/view-media-playlist.svg"), tr("Open playlist"));
+    connect(openPlaylist, &QAction::triggered, this, [this, playlistId] {
+        emit playlistSelected(playlistId);
+    });
+    menu.exec(m_playlistList->viewport()->mapToGlobal(pos));
+}
+
+void GenreBrowserView::setPlaylistItems(const QJsonArray &items, bool append)
+{
+    if (!append)
+        m_playlistList->clear();
+
+    QFont tagFont;
+    tagFont.setBold(true);
+    tagFont.setPointSizeF(tagFont.pointSizeF() * 0.85);
+
+    for (const auto &value : items) {
+        const QJsonObject playlist = value.toObject();
+        const qint64 playlistId = static_cast<qint64>(playlist["id"].toDouble());
+        const QString name = playlist["name"].toString();
+        const QString owner = playlist["owner"].toObject()["name"].toString();
+        const int tracksCount = playlist["tracks_count"].toInt();
+
+        auto *item = new QTreeWidgetItem(m_playlistList,
+            QStringList{QStringLiteral("P"), name, owner, tracksCount > 0 ? QString::number(tracksCount) : QString()});
+        item->setData(0, Qt::UserRole, playlistId);
+        item->setForeground(0, Colors::BadgeBlue);
+        item->setFont(0, tagFont);
+        item->setTextAlignment(0, Qt::AlignCenter);
+    }
+}

src/view/genrebrowser.hpp

@@ -0,0 +1,104 @@
+#pragma once
+
+#include "../backend/qobuzbackend.hpp"
+#include "../playqueue.hpp"
+#include "albumlistview.hpp"
+
+#include <QComboBox>
+#include <QLabel>
+#include <QLineEdit>
+#include <QJsonArray>
+#include <QJsonObject>
+#include <QSet>
+#include <QPushButton>
+#include <QStackedWidget>
+#include <QTreeWidget>
+#include <QWidget>
+#include <QScrollBar>
+
+class GenreBrowserView : public QWidget
+{
+    Q_OBJECT
+
+public:
+    enum class BrowseMode {
+        Genres,
+        PlaylistSearch,
+    };
+
+    explicit GenreBrowserView(QobuzBackend *backend, PlayQueue *queue, QWidget *parent = nullptr);
+
+    void ensureGenresLoaded();
+    void setBrowseMode(BrowseMode mode);
+    bool tryHandleDeepShuffleTracks(const QJsonArray &tracks);
+
+signals:
+    void albumSelected(const QString &albumId);
+    void artistSelected(qint64 artistId);
+    void playlistSelected(qint64 playlistId);
+    void playTrackRequested(qint64 trackId);
+
+private slots:
+    void onGenresLoaded(const QJsonObject &result);
+    void onFeaturedAlbumsLoaded(const QJsonObject &result);
+    void onFeaturedPlaylistsLoaded(const QJsonObject &result);
+    void onDiscoverPlaylistsLoaded(const QJsonObject &result);
+    void onPlaylistSearchLoaded(const QJsonObject &result);
+    void onSelectionChanged();
+    void onAlbumContextMenu(const QPoint &pos);
+    void onPlaylistActivated(QTreeWidgetItem *item, int column);
+    void onPlaylistContextMenu(const QPoint &pos);
+    void onDeepShuffleClicked();
+    void onAlbumScroll(int value);
+    void onPlaylistScroll(int value);
+
+private:
+    QobuzBackend *m_backend = nullptr;
+    PlayQueue *m_queue = nullptr;
+    QLabel *m_browseLabel = nullptr;
+    QLabel *m_genreLabel = nullptr;
+    QLabel *m_typeLabel = nullptr;
+    QLabel *m_playlistSearchLabel = nullptr;
+    QWidget *m_gapAfterKind = nullptr;
+    QWidget *m_gapAfterGenre = nullptr;
+    QComboBox *m_kindCombo = nullptr;
+    QComboBox *m_genreCombo = nullptr;
+    QComboBox *m_typeCombo = nullptr;
+    QLineEdit *m_playlistSearchBox = nullptr;
+    QPushButton *m_playlistSearchBtn = nullptr;
+    QPushButton *m_deepShuffleBtn = nullptr;
+    QStackedWidget *m_resultsStack = nullptr;
+    AlbumListView *m_albumList = nullptr;
+    QTreeWidget *m_playlistList = nullptr;
+    QPushButton *m_loadMorePlaylistsBtn = nullptr;
+    bool m_searchViewportFilled = false;
+    BrowseMode m_mode = BrowseMode::Genres;
+    bool m_genresLoaded = false;
+    int m_lastGenreComboIndex = 0;
+    QSet<qint64> m_multiGenreIds;
+    bool m_waitingDeepShuffle = false;
+    bool m_collectAlbumsForDeepShuffle = false;
+    bool m_loadingAlbums = false;
+    bool m_loadingPlaylists = false;
+    int m_albumOffset = 0;
+    int m_albumTotal = 0;
+    int m_playlistOffset = 0;
+    int m_playlistTotal = 0;
+    QString m_lastAlbumGenreIds;
+    QString m_lastAlbumType;
+    QString m_lastPlaylistGenreIds;
+    QString m_lastPlaylistType;
+    QString m_lastPlaylistTags;
+    QString m_lastPlaylistQuery;
+
+    void refreshModeUi();
+    void refreshGenreTypeChoices();
+    QString currentGenreIds() const;
+    QStringList currentAlbumIds() const;
+    void startDeepShuffleFromLoadedAlbums();
+    void requestAlbumsPage(const QString &genreIds, const QString &type, int offset, bool append);
+    void requestPlaylistsPage(const QString &genreIds, const QString &type, const QString &tags, const QString &query, int offset, bool append);
+    bool chooseMultiGenres();
+    void updateMultiGenreLabel();
+    void setPlaylistItems(const QJsonArray &items, bool append = false);
+};

src/view/maincontent.cpp

@@ -41,71 +41,94 @@ MainContent::MainContent(QobuzBackend *backend, PlayQueue *queue, QWidget *paren
         const qint64 id = m_header->artistId();
         if (id > 0) emit artistRequested(id);
     });
+    QObject::connect(m_header->followButton(), &QPushButton::clicked,
+                     [this] {
+        const qint64 id = m_header->playlistId();
+        if (id <= 0 || m_header->playlistOwned())
+            return;
+        emit playlistFollowToggled(id, !m_header->playlistFollowed());
+    });
+    QObject::connect(m_header->favButton(), &QPushButton::clicked,
+                     [this] {
+        const QString albumId = m_header->albumId();
+        if (albumId.isEmpty())
+            return;
+        emit albumFavoriteToggled(albumId, !m_header->albumFaved());
+    });
 
     m_albumList  = new AlbumListView(this);
     m_artistList = new ArtistListView(this);
     m_artistView = new ArtistView(backend, queue, this);
+    m_genreBrowser = new GenreBrowserView(backend, queue, this);
 
-    m_stack->addWidget(m_welcome);    // 0
+    m_stack->addWidget(m_welcome);      // PageWelcome
-    m_stack->addWidget(tracksPage);   // 1
+    m_stack->addWidget(tracksPage);     // PageTracks
-    m_stack->addWidget(m_albumList);  // 2
+    m_stack->addWidget(m_albumList);    // PageAlbumList
-    m_stack->addWidget(m_artistList); // 3
+    m_stack->addWidget(m_artistList);   // PageArtistList
-    m_stack->addWidget(m_artistView); // 4
+    m_stack->addWidget(m_artistView);   // PageArtistDetail
+    m_stack->addWidget(m_genreBrowser); // PageGenreBrowser
 
-    m_stack->setCurrentIndex(0);
+    m_stack->setCurrentIndex(PageWelcome);
 
     connect(m_albumList,  &AlbumListView::albumSelected,   this, &MainContent::albumRequested);
     connect(m_artistList, &ArtistListView::artistSelected, this, &MainContent::artistRequested);
     connect(m_artistView, &ArtistView::albumSelected,      this, &MainContent::albumRequested);
     connect(m_artistView, &ArtistView::playTrackRequested, this, &MainContent::playTrackRequested);
+    connect(m_genreBrowser, &GenreBrowserView::albumSelected, this, &MainContent::albumRequested);
+    connect(m_genreBrowser, &GenreBrowserView::artistSelected, this, &MainContent::artistRequested);
+    connect(m_genreBrowser, &GenreBrowserView::playlistSelected, this, &MainContent::playlistRequested);
+    connect(m_genreBrowser, &GenreBrowserView::playTrackRequested, this, &MainContent::playTrackRequested);
 }
 
-void MainContent::showWelcome()       { m_stack->setCurrentIndex(0); }
+void MainContent::showWelcome()       { m_stack->setCurrentIndex(PageWelcome); }
 
 void MainContent::showAlbum(const QJsonObject &album)
 {
-    m_header->setAlbum(album);
+    QString albumId = album["id"].toString();
+    if (albumId.isEmpty() && album["id"].isDouble())
+        albumId = QString::number(static_cast<qint64>(album["id"].toDouble()));
+    m_header->setAlbum(album, m_favAlbumIds.contains(albumId));
     m_tracks->loadAlbum(album);
-    m_stack->setCurrentIndex(1);
+    m_stack->setCurrentIndex(PageTracks);
 }
 
-void MainContent::showPlaylist(const QJsonObject &playlist)
+void MainContent::showPlaylist(const QJsonObject &playlist, bool isFollowed, bool isOwned)
 {
-    m_header->setPlaylist(playlist);
+    m_header->setPlaylist(playlist, isFollowed, isOwned);
     m_tracks->loadPlaylist(playlist);
-    m_stack->setCurrentIndex(1);
+    m_stack->setCurrentIndex(PageTracks);
 }
 
 void MainContent::showFavTracks(const QJsonObject &result)
 {
     m_header->hide();
     m_tracks->loadTracks(result["items"].toArray());
-    m_stack->setCurrentIndex(1);
+    m_stack->setCurrentIndex(PageTracks);
 }
 
 void MainContent::showSearchTracks(const QJsonArray &tracks)
 {
     m_header->hide();
     m_tracks->loadSearchTracks(tracks);
-    m_stack->setCurrentIndex(1);
+    m_stack->setCurrentIndex(PageTracks);
 }
 
 void MainContent::showFavAlbums(const QJsonObject &result)
 {
     m_albumList->setAlbums(result["items"].toArray());
-    m_stack->setCurrentIndex(2);
+    m_stack->setCurrentIndex(PageAlbumList);
 }
 
 void MainContent::showFavArtists(const QJsonObject &result)
 {
     m_artistList->setArtists(result["items"].toArray());
-    m_stack->setCurrentIndex(3);
+    m_stack->setCurrentIndex(PageArtistList);
 }
 
 void MainContent::showArtist(const QJsonObject &artist)
 {
     m_artistView->setArtist(artist);
-    m_stack->setCurrentIndex(4);
+    m_stack->setCurrentIndex(PageArtistDetail);
 }
 
 void MainContent::updateArtistReleases(const QString &releaseType, const QJsonArray &items, bool hasMore, int offset)
@@ -118,7 +141,36 @@ void MainContent::setFavArtistIds(const QSet<qint64> &ids)
     m_artistView->setFavArtistIds(ids);
 }
 
+void MainContent::setFavAlbumIds(const QSet<QString> &ids)
+{
+    m_favAlbumIds = ids;
+    const QString shownAlbumId = m_header->albumId();
+    if (!shownAlbumId.isEmpty())
+        m_header->setAlbumFaved(m_favAlbumIds.contains(shownAlbumId));
+}
+
 void MainContent::onDeepShuffleTracks(const QJsonArray &tracks)
 {
+    if (m_genreBrowser->tryHandleDeepShuffleTracks(tracks))
+        return;
     m_artistView->onDeepShuffleTracks(tracks);
 }
+
+void MainContent::showGenreBrowser()
+{
+    m_genreBrowser->ensureGenresLoaded();
+    m_genreBrowser->setBrowseMode(GenreBrowserView::BrowseMode::Genres);
+    m_stack->setCurrentIndex(PageGenreBrowser);
+}
+
+void MainContent::showPlaylistBrowser()
+{
+    m_genreBrowser->ensureGenresLoaded();
+    m_genreBrowser->setBrowseMode(GenreBrowserView::BrowseMode::PlaylistSearch);
+    m_stack->setCurrentIndex(PageGenreBrowser);
+}
+
+void MainContent::setCurrentPlaylistFollowed(bool followed)
+{
+    m_header->setPlaylistFollowed(followed);
+}

src/view/maincontent.hpp

@@ -6,6 +6,7 @@
 #include "albumlistview.hpp"
 #include "artistlistview.hpp"
 #include "artistview.hpp"
+#include "genrebrowser.hpp"
 #include "trackcontextheader.hpp"
 
 #include <QWidget>
@@ -13,6 +14,7 @@
 #include <QStackedWidget>
 #include <QJsonObject>
 #include <QJsonArray>
+#include <QSet>
 
 class MainContent : public QWidget
 {
@@ -25,24 +27,40 @@ public:
 
     void showWelcome();
     void showAlbum(const QJsonObject &album);
-    void showPlaylist(const QJsonObject &playlist);
+    void showPlaylist(const QJsonObject &playlist, bool isFollowed, bool isOwned);
     void showFavTracks(const QJsonObject &result);
     void showSearchTracks(const QJsonArray &tracks);
     void showFavAlbums(const QJsonObject &result);
     void showFavArtists(const QJsonObject &result);
     void showArtist(const QJsonObject &artist);
     void updateArtistReleases(const QString &releaseType, const QJsonArray &items, bool hasMore, int offset);
+    void setFavAlbumIds(const QSet<QString> &ids);
     void setFavArtistIds(const QSet<qint64> &ids);
     void onDeepShuffleTracks(const QJsonArray &tracks);
+    void showGenreBrowser();
+    void showPlaylistBrowser();
+    void setCurrentPlaylistFollowed(bool followed);
 
     ArtistView *artistView() const { return m_artistView; }
 
 signals:
     void albumRequested(const QString &albumId);
     void artistRequested(qint64 artistId);
+    void albumFavoriteToggled(const QString &albumId, bool favorite);
+    void playlistRequested(qint64 playlistId);
+    void playlistFollowToggled(qint64 playlistId, bool follow);
     void playTrackRequested(qint64 trackId);
 
 private:
+    enum StackPage {
+        PageWelcome      = 0,
+        PageTracks       = 1,
+        PageAlbumList    = 2,
+        PageArtistList   = 3,
+        PageArtistDetail = 4,
+        PageGenreBrowser = 5,
+    };
+
     QobuzBackend        *m_backend    = nullptr;
     QStackedWidget      *m_stack      = nullptr;
     QLabel              *m_welcome    = nullptr;
@@ -51,4 +69,6 @@ private:
     AlbumListView       *m_albumList  = nullptr;
     ArtistListView      *m_artistList = nullptr;
     ArtistView          *m_artistView = nullptr;
+    GenreBrowserView    *m_genreBrowser = nullptr;
+    QSet<QString>        m_favAlbumIds;
 };

src/view/maintoolbar.cpp

@@ -5,6 +5,8 @@
 #include <QNetworkRequest>
 #include <QResizeEvent>
 #include <QMenu>
+#include <QDateTime>
+#include <QSignalBlocker>
 
 MainToolBar::MainToolBar(QobuzBackend *backend, PlayQueue *queue, QWidget *parent)
     : QToolBar(parent)
@@ -39,15 +41,62 @@ MainToolBar::MainToolBar(QobuzBackend *backend, PlayQueue *queue, QWidget *paren
     connect(m_trackLabel, &QLabel::customContextMenuRequested,
             this, [this](const QPoint &pos) {
         if (m_currentTrack.isEmpty()) return;
-        QMenu menu(this);
+
+        const qint64 trackId = static_cast<qint64>(m_currentTrack["id"].toDouble());
         const QString albumId  = m_currentTrack["album"].toObject()["id"].toString();
+        const QString albumTitle = m_currentTrack["album"].toObject()["title"].toString();
         const qint64  artistId = static_cast<qint64>(
             m_currentTrack["performer"].toObject()["id"].toDouble());
-        if (!albumId.isEmpty())
+        const QString artistName = m_currentTrack["performer"].toObject()["name"].toString();
-            menu.addAction(tr("Go to Album"),  this, [this, albumId]  { emit albumRequested(albumId);  });
+
-        if (artistId > 0)
+        QMenu menu(this);
-            menu.addAction(tr("Go to Artist"), this, [this, artistId] { emit artistRequested(artistId); });
+
-        if (!menu.isEmpty())
+        auto *playNext = menu.addAction(QIcon(":/res/icons/media-skip-forward.svg"), tr("Play next"));
+        auto *addQueue = menu.addAction(QIcon(":/res/icons/media-playlist-append.svg"), tr("Add to queue"));
+        menu.addSeparator();
+
+        auto *addFav = menu.addAction(QIcon(":/res/icons/starred-symbolic.svg"), tr("Add to favorites"));
+        connect(addFav, &QAction::triggered, this, [this, trackId] {
+            emit favTrackRequested(trackId);
+        });
+
+        if (!albumId.isEmpty() || artistId > 0)
+            menu.addSeparator();
+        if (!albumId.isEmpty()) {
+            auto *openAlbum = menu.addAction(
+                QIcon(":/res/icons/view-media-album-cover.svg"),
+                tr("Open album: %1").arg(QString(albumTitle).replace(QLatin1Char('&'), QStringLiteral("&&"))));
+            connect(openAlbum, &QAction::triggered, this, [this, albumId] {
+                emit albumRequested(albumId);
+            });
+        }
+        if (artistId > 0) {
+            auto *openArtist = menu.addAction(
+                QIcon(":/res/icons/view-media-artist.svg"),
+                tr("Open artist: %1").arg(QString(artistName).replace(QLatin1Char('&'), QStringLiteral("&&"))));
+            connect(openArtist, &QAction::triggered, this, [this, artistId] {
+                emit artistRequested(artistId);
+            });
+        }
+
+        if (!m_userPlaylists.isEmpty()) {
+            menu.addSeparator();
+            auto *plMenu = menu.addMenu(QIcon(":/res/icons/media-playlist-append.svg"), tr("Add to playlist"));
+            for (const auto &pl : m_userPlaylists) {
+                auto *act = plMenu->addAction(QString(pl.second).replace(QLatin1Char('&'), QStringLiteral("&&")));
+                connect(act, &QAction::triggered, this, [this, trackId, plId = pl.first] {
+                    emit addToPlaylistRequested(trackId, plId);
+                });
+            }
+        }
+
+        connect(playNext, &QAction::triggered, this, [this] {
+            m_queue->playNext(m_currentTrack);
+        });
+        connect(addQueue, &QAction::triggered, this, [this] {
+            m_queue->addToQueue(m_currentTrack);
+        });
+
         menu.exec(m_trackLabel->mapToGlobal(pos));
     });
 
@@ -94,11 +143,18 @@ MainToolBar::MainToolBar(QobuzBackend *backend, PlayQueue *queue, QWidget *paren
     m_shuffle->setCheckable(true);
     connect(m_shuffle, &QAction::toggled, this, &MainToolBar::onShuffleToggled);
 
+    m_autoplay = addAction(Icon::autoplay(), tr("Autoplay"));
+    m_autoplay->setCheckable(true);
+    m_autoplay->setChecked(AppSettings::instance().autoplayEnabled());
+    connect(m_autoplay, &QAction::toggled, this, &MainToolBar::onAutoplayToggled);
+
     // ---- Volume ----
     m_volume = new VolumeButton(this);
-    m_volume->setValue(AppSettings::instance().volume());
     addWidget(m_volume);
     connect(m_volume, &VolumeButton::volumeChanged, this, &MainToolBar::onVolumeChanged);
+    // Set volume after connecting so the backend receives the initial value
+    m_volume->setValue(AppSettings::instance().volume());
+    m_backend->setVolume(AppSettings::instance().volume());
 
     // ---- Queue toggle ----
     m_queueBtn = addAction(Icon::queue(), tr("Queue"));
@@ -115,6 +171,9 @@ MainToolBar::MainToolBar(QobuzBackend *backend, PlayQueue *queue, QWidget *paren
     connect(m_backend, &QobuzBackend::trackChanged,    this, &MainToolBar::onTrackChanged);
     connect(m_backend, &QobuzBackend::positionChanged, this, &MainToolBar::onPositionChanged);
     connect(m_backend, &QobuzBackend::trackFinished,   this, &MainToolBar::onTrackFinished);
+    connect(m_backend, &QobuzBackend::trackTransitioned, this, &MainToolBar::onTrackTransitioned);
+    connect(m_backend, &QobuzBackend::dynamicSuggestionsLoaded,
+            this, &MainToolBar::onDynamicSuggestionsLoaded);
 
     // ---- Queue signals ----
     connect(m_queue, &PlayQueue::queueChanged, this, &MainToolBar::onQueueChanged);
@@ -179,6 +238,18 @@ void MainToolBar::updateProgress(quint64 position, quint64 duration)
                  TrackListModel::formatDuration(static_cast<qint64>(duration))));
 }
 
+void MainToolBar::setQueueToggleChecked(bool checked)
+{
+    const QSignalBlocker blocker(m_queueBtn);
+    m_queueBtn->setChecked(checked);
+}
+
+void MainToolBar::setSearchToggleChecked(bool checked)
+{
+    const QSignalBlocker blocker(m_search);
+    m_search->setChecked(checked);
+}
+
 // ---- private slots ----
 
 void MainToolBar::onPlayPause()
@@ -211,6 +282,10 @@ void MainToolBar::onProgressReleased()
     const quint64 dur = m_backend->duration();
     if (dur > 0) {
         const quint64 target = dur * static_cast<quint64>(m_progress->value()) / 1000;
+        m_seekPending = true;
+        m_pendingSeekTarget = target;
+        m_pendingSeekStartedMs = QDateTime::currentMSecsSinceEpoch();
+        updateProgress(target, dur);
         m_backend->seek(target);
     }
 }
@@ -228,11 +303,40 @@ void MainToolBar::onBackendStateChanged(const QString &state)
 
 void MainToolBar::onTrackChanged(const QJsonObject &track)
 {
+    m_seekPending = false;
+    m_seeking = false;
     setCurrentTrack(track);
+
+    const qint64 trackId = static_cast<qint64>(track["id"].toDouble());
+    if (trackId <= 0)
+        return;
+
+    const qint64 artistId = static_cast<qint64>(
+        track["performer"].toObject()["id"].toDouble());
+    const qint64 genreId = static_cast<qint64>(
+        track["album"].toObject()["genre"].toObject()["id"].toDouble());
+    const qint64 labelId = static_cast<qint64>(
+        track["album"].toObject()["label"].toObject()["id"].toDouble());
+
+    m_recentTracks.append(RecentTrackSeed{trackId, artistId, genreId, labelId});
+    while (m_recentTracks.size() > 32)
+        m_recentTracks.removeFirst();
 }
 
 void MainToolBar::onPositionChanged(quint64 position, quint64 duration)
 {
+    if (m_seekPending) {
+        const qint64 nowMs = QDateTime::currentMSecsSinceEpoch();
+        const quint64 delta = (position > m_pendingSeekTarget)
+            ? (position - m_pendingSeekTarget)
+            : (m_pendingSeekTarget - position);
+
+        if (delta > 2 && (nowMs - m_pendingSeekStartedMs) < 1500)
+            return;
+
+        m_seekPending = false;
+    }
+
     updateProgress(position, duration);
 }
 
@@ -240,6 +344,8 @@ void MainToolBar::onTrackFinished()
 {
     if (m_queue->canGoNext()) {
         onNext();
+    } else if (AppSettings::instance().autoplayEnabled()) {
+        requestAutoplaySuggestions();
     } else {
         setPlaying(false);
         m_progress->setValue(0);
@@ -247,6 +353,17 @@ void MainToolBar::onTrackFinished()
     }
 }
 
+void MainToolBar::onTrackTransitioned()
+{
+    if (m_queue->canGoNext()) {
+        const QJsonObject track = m_queue->advance();
+        setCurrentTrack(track);
+        m_backend->manuallyEmitTrackChanged(track);
+    } else {
+        onTrackFinished();
+    }
+}
+
 void MainToolBar::onQueueChanged()
 {
     m_previous->setEnabled(m_queue->canGoPrev());
@@ -258,6 +375,71 @@ void MainToolBar::onShuffleToggled(bool checked)
     m_queue->setShuffle(checked);
 }
 
+void MainToolBar::onAutoplayToggled(bool checked)
+{
+    AppSettings::instance().setAutoplayEnabled(checked);
+}
+
+void MainToolBar::requestAutoplaySuggestions()
+{
+    if (m_fetchingAutoplay)
+        return;
+
+    QJsonArray listenedIds;
+    QJsonArray analyze;
+
+    const int n = m_recentTracks.size();
+    for (int i = 0; i < n; ++i) {
+        const RecentTrackSeed &t = m_recentTracks.at(i);
+
+        listenedIds.append(t.trackId);
+
+        if (i < qMax(0, n - 5))
+            continue;
+
+        analyze.append(QJsonObject{
+            {"track_id", t.trackId},
+            {"artist_id", t.artistId},
+            {"genre_id", t.genreId},
+            {"label_id", t.labelId},
+        });
+    }
+
+    if (listenedIds.isEmpty() || analyze.isEmpty()) {
+        setPlaying(false);
+        m_progress->setValue(0);
+        m_position->setText(QStringLiteral("0:00 / 0:00"));
+        return;
+    }
+
+    m_fetchingAutoplay = true;
+    m_backend->getDynamicSuggestions(listenedIds, analyze, 50);
+}
+
+void MainToolBar::onDynamicSuggestionsLoaded(const QJsonObject &result)
+{
+    m_fetchingAutoplay = false;
+
+    QJsonArray items;
+    if (result["tracks"].isObject())
+        items = result["tracks"].toObject()["items"].toArray();
+    if (items.isEmpty() && result["dynamic"].isObject())
+        items = result["dynamic"].toObject()["items"].toArray();
+    if (items.isEmpty())
+        items = result["items"].toArray();
+
+    if (items.isEmpty()) {
+        setPlaying(false);
+        m_progress->setValue(0);
+        m_position->setText(QStringLiteral("0:00 / 0:00"));
+        return;
+    }
+
+    m_queue->appendToContext(items);
+    if (m_queue->canGoNext())
+        onNext();
+}
+
 void MainToolBar::fetchAlbumArt(const QString &url)
 {
     m_nam->get(QNetworkRequest(QUrl(url)));

src/view/maintoolbar.hpp

@@ -12,6 +12,8 @@
 #include <QNetworkAccessManager>
 #include <QNetworkReply>
 #include <QJsonObject>
+#include <QPair>
+#include <QVector>
 
 class MainToolBar : public QToolBar
 {
@@ -23,12 +25,18 @@ public:
     void setPlaying(bool playing);
     void setCurrentTrack(const QJsonObject &track);
     void updateProgress(quint64 position, quint64 duration);
+    void setQueueToggleChecked(bool checked);
+    void setSearchToggleChecked(bool checked);
+
+    void setUserPlaylists(const QVector<QPair<qint64, QString>> &playlists) { m_userPlaylists = playlists; }
 
 signals:
     void searchToggled(bool visible);
     void queueToggled(bool visible);
     void albumRequested(const QString &albumId);
     void artistRequested(qint64 artistId);
+    void addToPlaylistRequested(qint64 trackId, qint64 playlistId);
+    void favTrackRequested(qint64 trackId);
 
 protected:
     void resizeEvent(QResizeEvent *event) override;
@@ -44,13 +52,23 @@ private slots:
     void onTrackChanged(const QJsonObject &track);
     void onPositionChanged(quint64 position, quint64 duration);
     void onTrackFinished();
+    void onTrackTransitioned();
     void onQueueChanged();
     void onShuffleToggled(bool checked);
+    void onAutoplayToggled(bool checked);
+    void onDynamicSuggestionsLoaded(const QJsonObject &result);
 
     void fetchAlbumArt(const QString &url);
     void onAlbumArtReady(QNetworkReply *reply);
 
 private:
+    struct RecentTrackSeed {
+        qint64 trackId = 0;
+        qint64 artistId = 0;
+        qint64 genreId = 0;
+        qint64 labelId = 0;
+    };
+
     QobuzBackend *m_backend = nullptr;
     PlayQueue    *m_queue   = nullptr;
 
@@ -64,6 +82,7 @@ private:
     QLabel          *m_position    = nullptr;
     QWidget         *m_rightSpacer = nullptr;
     QAction         *m_shuffle     = nullptr;
+    QAction         *m_autoplay    = nullptr;
     VolumeButton    *m_volume      = nullptr;
     QAction         *m_queueBtn    = nullptr;
     QAction         *m_search      = nullptr;
@@ -71,6 +90,15 @@ private:
     QNetworkAccessManager *m_nam = nullptr;
     QString     m_currentArtUrl;
     QJsonObject m_currentTrack;
+    QVector<RecentTrackSeed> m_recentTracks;
     bool        m_playing = false;
     bool        m_seeking = false;
+    bool        m_seekPending = false;
+    quint64     m_pendingSeekTarget = 0;
+    qint64      m_pendingSeekStartedMs = 0;
+    bool        m_fetchingAutoplay = false;
+
+    QVector<QPair<qint64, QString>> m_userPlaylists;
+
+    void requestAutoplaySuggestions();
 };

src/view/queuepanel.cpp

@@ -10,9 +10,8 @@
 
 static constexpr int UpcomingIndexRole = Qt::UserRole + 1;
 static constexpr int IsPlayNextRole    = Qt::UserRole + 2;
-static constexpr int TrackJsonRole     = Qt::UserRole + 3;
+static constexpr int ArtistRole        = Qt::UserRole + 3;
-static constexpr int ArtistRole        = Qt::UserRole + 4;
+static constexpr int DurationRole      = Qt::UserRole + 4;
-static constexpr int DurationRole      = Qt::UserRole + 5;
 
 // ---- Custom delegate -------------------------------------------------------
 
@@ -184,7 +183,6 @@ void QueuePanel::refresh()
         auto *item = new QListWidgetItem(title, m_list);
         item->setData(UpcomingIndexRole, i);
         item->setData(IsPlayNextRole, i < playNextCount);
-        item->setData(TrackJsonRole, QVariant::fromValue(t));
         item->setData(ArtistRole, artist);
         item->setData(DurationRole, duration);
     }
@@ -205,10 +203,14 @@ void QueuePanel::onRowsMoved()
 {
     if (m_refreshing) return;
 
+    const QVector<QJsonObject> currentUpcoming = m_queue->upcomingTracks();
     QVector<QJsonObject> newOrder;
     newOrder.reserve(m_list->count());
-    for (int i = 0; i < m_list->count(); ++i)
+    for (int i = 0; i < m_list->count(); ++i) {
-        newOrder.append(m_list->item(i)->data(TrackJsonRole).value<QJsonObject>());
+        const int prevIndex = m_list->item(i)->data(UpcomingIndexRole).toInt();
+        if (prevIndex >= 0 && prevIndex < currentUpcoming.size())
+            newOrder.append(currentUpcoming.at(prevIndex));
+    }
 
     m_refreshing = true;
     m_queue->setUpcomingOrder(newOrder);
@@ -223,8 +225,8 @@ void QueuePanel::onContextMenu(const QPoint &pos)
     const int idx = item->data(UpcomingIndexRole).toInt();
 
     QMenu menu(this);
-    auto *removeAct = menu.addAction(tr("Remove from queue"));
+    auto *removeAct = menu.addAction(QIcon(":/res/icons/list-remove.svg"), tr("Remove from queue"));
-    auto *toTopAct  = menu.addAction(tr("Move to top (play next)"));
+    auto *toTopAct  = menu.addAction(QIcon(":/res/icons/go-up.svg"),      tr("Move to top (play next)"));
 
     connect(removeAct, &QAction::triggered, this, [this, idx] { m_queue->removeUpcoming(idx); });
     connect(toTopAct,  &QAction::triggered, this, [this, idx] { m_queue->moveUpcomingToTop(idx); });

src/view/sidepanel/view.cpp

@@ -1,4 +1,5 @@
 #include "view.hpp"
+#include "../../util/colors.hpp"
 #include "../../util/trackinfo.hpp"
 
 #include <QVBoxLayout>
@@ -39,6 +40,14 @@ SearchTab::SearchTab(QobuzBackend *backend, PlayQueue *queue, QWidget *parent)
     // Result tabs
     m_resultTabs = new QTabWidget(this);
 
+    m_topResults = new QTreeWidget(this);
+    m_topResults->setHeaderLabels({tr(""), tr("Top Result"), tr("Info")});
+    m_topResults->setRootIsDecorated(false);
+    m_topResults->header()->setSectionResizeMode(0, QHeaderView::ResizeToContents);
+    m_topResults->header()->setSectionResizeMode(1, QHeaderView::Stretch);
+    m_topResults->header()->setSectionResizeMode(2, QHeaderView::Stretch);
+    m_topResults->header()->setStretchLastSection(false);
+
     m_trackResults  = new QTreeWidget(this);
     m_trackResults->setHeaderLabels({tr("Title"), tr("Artist"), tr("Album")});
     m_trackResults->setRootIsDecorated(false);
@@ -57,6 +66,7 @@ SearchTab::SearchTab(QobuzBackend *backend, PlayQueue *queue, QWidget *parent)
     m_artistResults->setHeaderLabels({tr("Artist")});
     m_artistResults->setRootIsDecorated(false);
 
+    m_resultTabs->addTab(m_topResults, tr("Top Results"));
     m_resultTabs->addTab(m_trackResults,  tr("Tracks"));
     m_resultTabs->addTab(m_albumResults,  tr("Albums"));
     m_resultTabs->addTab(m_artistResults, tr("Artists"));
@@ -66,7 +76,9 @@ SearchTab::SearchTab(QobuzBackend *backend, PlayQueue *queue, QWidget *parent)
     connect(m_searchBox, &QLineEdit::returnPressed, this, &SearchTab::onSearchSubmit);
 
     connect(m_backend, &QobuzBackend::searchResult, this, &SearchTab::onSearchResult);
+    connect(m_backend, &QobuzBackend::mostPopularResult, this, &SearchTab::onMostPopularResult);
 
+    connect(m_topResults,   &QTreeWidget::itemDoubleClicked, this, &SearchTab::onItemDoubleClicked);
     connect(m_trackResults,  &QTreeWidget::itemDoubleClicked, this, &SearchTab::onItemDoubleClicked);
     connect(m_albumResults,  &QTreeWidget::itemDoubleClicked, this, &SearchTab::onItemDoubleClicked);
     connect(m_artistResults, &QTreeWidget::itemDoubleClicked, this, &SearchTab::onItemDoubleClicked);
@@ -86,8 +98,67 @@ void SearchTab::setUserPlaylists(const QVector<QPair<qint64, QString>> &playlist
 void SearchTab::onSearchSubmit()
 {
     const QString q = m_searchBox->text().trimmed();
-    if (!q.isEmpty())
+    if (!q.isEmpty()) {
+        m_backend->mostPopularSearch(q, 8);
         m_backend->search(q, 0, 20);
+        m_resultTabs->setCurrentIndex(0);
+    }
+}
+
+void SearchTab::onMostPopularResult(const QJsonObject &result)
+{
+    m_topResults->clear();
+
+    QFont badgeFont;
+    badgeFont.setBold(true);
+
+    const QJsonArray items = result["most_popular"].toObject()["items"].toArray();
+    for (const auto &value : items) {
+        const QJsonObject itemObj = value.toObject();
+        const QString type = itemObj["type"].toString();
+        const QJsonObject content = itemObj["content"].toObject();
+
+        auto *item = new QTreeWidgetItem(m_topResults);
+        item->setData(0, JsonRole, content);
+
+        if (type == QStringLiteral("tracks")) {
+            const QString title = content["title"].toString();
+            const QString artist = content["performer"].toObject()["name"].toString();
+            const QString album = content["album"].toObject()["title"].toString();
+            item->setText(0, QStringLiteral("T"));
+            item->setForeground(0, Colors::BadgeGreen);
+            item->setFont(0, badgeFont);
+            item->setTextAlignment(0, Qt::AlignCenter);
+            item->setText(1, title);
+            item->setText(2, artist.isEmpty() ? album : QStringLiteral("%1 - %2").arg(artist, album));
+            item->setData(0, TypeRole, QStringLiteral("track"));
+            item->setData(0, IdRole, static_cast<qint64>(content["id"].toDouble()));
+        } else if (type == QStringLiteral("albums")) {
+            const QString title = content["title"].toString();
+            const QString artist = content["artist"].toObject()["name"].toString();
+            const bool hiRes = content["hires_streamable"].toBool()
+                || content["rights"].toObject()["hires_streamable"].toBool();
+            item->setText(0, hiRes ? QStringLiteral("H") : QStringLiteral("A"));
+            item->setForeground(0, hiRes
+                ? Colors::QobuzOrange
+                : Colors::BadgeGray);
+            item->setFont(0, badgeFont);
+            item->setTextAlignment(0, Qt::AlignCenter);
+            item->setText(1, title);
+            item->setText(2, artist);
+            item->setData(0, TypeRole, QStringLiteral("album"));
+            item->setData(1, IdRole, content["id"].toString());
+        } else if (type == QStringLiteral("artists")) {
+            item->setText(0, QStringLiteral("A"));
+            item->setForeground(0, Colors::BadgeBlue);
+            item->setFont(0, badgeFont);
+            item->setTextAlignment(0, Qt::AlignCenter);
+            item->setText(1, content["name"].toString());
+            item->setText(2, tr("Artist"));
+            item->setData(0, TypeRole, QStringLiteral("artist"));
+            item->setData(0, IdRole, static_cast<qint64>(content["id"].toDouble()));
+        }
+    }
 }
 
 void SearchTab::onSearchResult(const QJsonObject &result)
@@ -123,7 +194,7 @@ void SearchTab::onSearchResult(const QJsonObject &result)
                 QStringList{QString(), a["title"].toString(), artist});
             if (hiRes) {
                 item->setText(0, QStringLiteral("H"));
-                item->setForeground(0, QColor(QStringLiteral("#FFB232")));
+                item->setForeground(0, Colors::QobuzOrange);
                 item->setFont(0, hiResFont);
                 item->setTextAlignment(0, Qt::AlignCenter);
             }
@@ -170,12 +241,15 @@ void SearchTab::onTrackContextMenu(const QPoint &pos)
 
     QMenu menu(this);
 
-    auto *playNow  = menu.addAction(tr("Play now"));
+    auto *playNow  = menu.addAction(QIcon(":/res/icons/media-playback-start.svg"), tr("Play now"));
-    auto *playNext = menu.addAction(tr("Play next"));
+    auto *playNext = menu.addAction(QIcon(":/res/icons/media-skip-forward.svg"),   tr("Play next"));
-    auto *addQueue = menu.addAction(tr("Add to queue"));
+    auto *addQueue = menu.addAction(QIcon(":/res/icons/media-playlist-append.svg"), tr("Add to queue"));
     menu.addSeparator();
 
-    auto *addFav = menu.addAction(tr("Add to favorites"));
+    auto *favAction = menu.addAction(QIcon(":/res/icons/starred-symbolic.svg"), tr("Add to favorites"));
+    connect(favAction, &QAction::triggered, this, [this, trackId] {
+        m_backend->addFavTrack(trackId);
+    });
 
     // Open album / artist
     const QString albumId = trackJson["album"].toObject()["id"].toString();
@@ -184,15 +258,20 @@ void SearchTab::onTrackContextMenu(const QPoint &pos)
     const QString artistName = trackJson["performer"].toObject()["name"].toString();
     const QString albumTitle = trackJson["album"].toObject()["title"].toString();
 
+    if (!albumId.isEmpty() || artistId > 0)
         menu.addSeparator();
     if (!albumId.isEmpty()) {
-        auto *openAlbum = menu.addAction(tr("Go to album: %1").arg(albumTitle));
+        auto *openAlbum = menu.addAction(
+            QIcon(":/res/icons/view-media-album-cover.svg"),
+            tr("Open album: %1").arg(QString(albumTitle).replace(QLatin1Char('&'), QStringLiteral("&&"))));
         connect(openAlbum, &QAction::triggered, this, [this, albumId] {
             emit albumSelected(albumId);
         });
     }
     if (artistId > 0) {
-        auto *openArtist = menu.addAction(tr("Go to artist: %1").arg(artistName));
+        auto *openArtist = menu.addAction(
+            QIcon(":/res/icons/view-media-artist.svg"),
+            tr("Open artist: %1").arg(QString(artistName).replace(QLatin1Char('&'), QStringLiteral("&&"))));
         connect(openArtist, &QAction::triggered, this, [this, artistId] {
             emit artistSelected(artistId);
         });
@@ -201,9 +280,9 @@ void SearchTab::onTrackContextMenu(const QPoint &pos)
     // Add to playlist submenu
     if (!m_userPlaylists.isEmpty()) {
         menu.addSeparator();
-        auto *plMenu = menu.addMenu(tr("Add to playlist"));
+        auto *plMenu = menu.addMenu(QIcon(":/res/icons/media-playlist-append.svg"), tr("Add to playlist"));
         for (const auto &pl : m_userPlaylists) {
-            auto *act = plMenu->addAction(pl.second);
+            auto *act = plMenu->addAction(QString(pl.second).replace(QLatin1Char('&'), QStringLiteral("&&")));
             connect(act, &QAction::triggered, this, [this, trackId, plId = pl.first] {
                 emit addToPlaylistRequested(trackId, plId);
             });
@@ -223,9 +302,6 @@ void SearchTab::onTrackContextMenu(const QPoint &pos)
     connect(addQueue, &QAction::triggered, this, [this, trackJson] {
         m_queue->addToQueue(trackJson);
     });
-    connect(addFav, &QAction::triggered, this, [this, trackId] {
-        m_backend->addFavTrack(trackId);
-    });
     connect(info, &QAction::triggered, this, [this, trackJson] {
         showTrackInfo(trackJson);
     });
@@ -244,15 +320,17 @@ void SearchTab::onAlbumContextMenu(const QPoint &pos)
 
     QMenu menu(this);
 
-    auto *openAlbum = menu.addAction(tr("Open album"));
+    auto *openAlbum = menu.addAction(QIcon(":/res/icons/view-media-album-cover.svg"), tr("Open album"));
-    auto *addFav    = menu.addAction(tr("Add to favorites"));
+    auto *addFav    = menu.addAction(QIcon(":/res/icons/starred-symbolic.svg"), tr("Add to favorites"));
 
     const qint64 artistId = static_cast<qint64>(
         albumJson["artist"].toObject()["id"].toDouble());
     const QString artistName = albumJson["artist"].toObject()["name"].toString();
     if (artistId > 0) {
         menu.addSeparator();
-        auto *openArtist = menu.addAction(tr("Go to artist: %1").arg(artistName));
+        auto *openArtist = menu.addAction(
+            QIcon(":/res/icons/view-media-artist.svg"),
+            tr("Open artist: %1").arg(QString(artistName).replace(QLatin1Char('&'), QStringLiteral("&&"))));
         connect(openArtist, &QAction::triggered, this, [this, artistId] {
             emit artistSelected(artistId);
         });

src/view/sidepanel/view.hpp

@@ -30,6 +30,7 @@ namespace SidePanel
 
     private slots:
         void onSearchResult(const QJsonObject &result);
+        void onMostPopularResult(const QJsonObject &result);
         void onSearchSubmit();
         void onItemDoubleClicked(QTreeWidgetItem *item, int column);
 
@@ -38,6 +39,7 @@ namespace SidePanel
         PlayQueue    *m_queue      = nullptr;
         QLineEdit    *m_searchBox  = nullptr;
         QTabWidget   *m_resultTabs = nullptr;
+        QTreeWidget  *m_topResults = nullptr;
         QTreeWidget  *m_trackResults  = nullptr;
         QTreeWidget  *m_albumResults  = nullptr;
         QTreeWidget  *m_artistResults = nullptr;

src/view/trackcontextheader.hpp

@@ -1,5 +1,7 @@
 #pragma once
 
+#include "../util/colors.hpp"
+
 #include <QWidget>
 #include <QHBoxLayout>
 #include <QVBoxLayout>
@@ -63,7 +65,7 @@ public:
 
         m_meta = new QLabel(info);
         QPalette mp = m_meta->palette();
-        mp.setColor(QPalette::WindowText, QColor(0xaa, 0xaa, 0xaa));
+        mp.setColor(QPalette::WindowText, Colors::SubduedText);
         m_meta->setPalette(mp);
         vlay->addWidget(m_meta);
 
@@ -93,6 +95,20 @@ public:
                            "QPushButton:pressed { background: #333; }"));
         btnRow->addWidget(m_shuffleBtn);
 
+        m_favBtn = new QPushButton(tr("♡  Favourite"), info);
+        m_favBtn->setStyleSheet(btnBase +
+            QStringLiteral("QPushButton { background: #2a2a2a; color: #ccc; border: 1px solid #555; }"
+                           "QPushButton:pressed { background: #333; }"));
+        m_favBtn->hide();
+        btnRow->addWidget(m_favBtn);
+
+        m_followBtn = new QPushButton(tr("Follow"), info);
+        m_followBtn->setStyleSheet(btnBase +
+            QStringLiteral("QPushButton { background: #2a2a2a; color: #ddd; border: 1px solid #666; }"
+                           "QPushButton:pressed { background: #333; }"));
+        m_followBtn->hide();
+        btnRow->addWidget(m_followBtn);
+
         btnRow->addStretch();
         vlay->addLayout(btnRow);
         vlay->addStretch(1);
@@ -113,28 +129,50 @@ public:
 
     QPushButton *playButton()    { return m_playBtn; }
     QPushButton *shuffleButton() { return m_shuffleBtn; }
+    QPushButton *favButton()     { return m_favBtn; }
+    QPushButton *followButton()  { return m_followBtn; }
 
     QPushButton *subtitleButton() { return m_subtitle; }
+    QString albumId() const      { return m_albumId; }
+    bool albumFaved() const      { return m_albumFaved; }
     qint64 artistId() const      { return m_artistId; }
+    qint64 playlistId() const    { return m_playlistId; }
+    bool playlistFollowed() const { return m_playlistFollowed; }
+    bool playlistOwned() const    { return m_playlistOwned; }
 
-    void setAlbum(const QJsonObject &album)
+    void setAlbum(const QJsonObject &album, bool isFaved)
     {
         const QString base = album["title"].toString();
         const QString ver  = album["version"].toString().trimmed();
         m_title->setText(ver.isEmpty() ? base : base + QStringLiteral(" (") + ver + QLatin1Char(')'));
+        m_albumId = album["id"].toString();
+        if (m_albumId.isEmpty() && album["id"].isDouble())
+            m_albumId = QString::number(static_cast<qint64>(album["id"].toDouble()));
         m_artistId = static_cast<qint64>(album["artist"].toObject()["id"].toDouble());
         m_subtitle->setText(album["artist"].toObject()["name"].toString());
         m_subtitle->setEnabled(m_artistId > 0);
         m_subtitle->setCursor(m_artistId > 0 ? Qt::PointingHandCursor : Qt::ArrowCursor);
         m_meta->setText(buildAlbumMeta(album));
+
+        setAlbumFaved(isFaved);
+        m_favBtn->setEnabled(!m_albumId.isEmpty());
+        m_favBtn->show();
+
+        m_followBtn->hide();
+        m_playlistId = 0;
+        m_playlistFollowed = false;
+        m_playlistOwned = false;
         fetchArt(album["image"].toObject());
         show();
     }
 
-    void setPlaylist(const QJsonObject &playlist)
+    void setPlaylist(const QJsonObject &playlist, bool isFollowed, bool isOwned)
     {
         m_title->setText(playlist["name"].toString());
         m_artistId = 0;
+        m_playlistId = static_cast<qint64>(playlist["id"].toDouble());
+        m_playlistFollowed = isFollowed;
+        m_playlistOwned = isOwned;
         const QString desc  = playlist["description"].toString();
         const QString owner = playlist["owner"].toObject()["name"].toString();
         m_subtitle->setText(desc.isEmpty() ? owner : desc);
@@ -142,6 +180,20 @@ public:
         m_subtitle->setCursor(Qt::ArrowCursor);
         m_meta->setText(buildPlaylistMeta(playlist));
 
+        m_albumId.clear();
+        m_albumFaved = false;
+        m_favBtn->hide();
+
+        if (m_playlistOwned) {
+            m_followBtn->setText(tr("Owned"));
+            m_followBtn->setEnabled(false);
+            m_followBtn->show();
+        } else {
+            m_followBtn->setText(m_playlistFollowed ? tr("Unfollow") : tr("Follow"));
+            m_followBtn->setEnabled(m_playlistId > 0);
+            m_followBtn->show();
+        }
+
         // Try images300 → images150 → images (API returns mosaic arrays, not image_rectangle)
         const QJsonArray imgs300 = playlist["images300"].toArray();
         const QJsonArray imgs150 = playlist["images150"].toArray();
@@ -156,6 +208,31 @@ public:
         show();
     }
 
+    void setPlaylistFollowed(bool followed)
+    {
+        m_playlistFollowed = followed;
+        if (!m_playlistOwned)
+            m_followBtn->setText(m_playlistFollowed ? tr("Unfollow") : tr("Follow"));
+    }
+
+    void setAlbumFaved(bool faved)
+    {
+        m_albumFaved = faved;
+        if (faved) {
+            m_favBtn->setText(tr("♥  Favourited"));
+            m_favBtn->setStyleSheet(QStringLiteral(
+                "QPushButton { padding: 5px 16px; border-radius: 4px; font-weight: bold;"
+                "  background: #2a2a2a; color: #FFB232; border: 1px solid #FFB232; }"
+                "QPushButton:pressed { background: #333; }"));
+        } else {
+            m_favBtn->setText(tr("♡  Favourite"));
+            m_favBtn->setStyleSheet(QStringLiteral(
+                "QPushButton { padding: 5px 16px; border-radius: 4px; font-weight: bold;"
+                "  background: #2a2a2a; color: #ccc; border: 1px solid #555; }"
+                "QPushButton:pressed { background: #333; }"));
+        }
+    }
+
 private:
     void fetchArt(const QJsonObject &img)
     {
@@ -221,7 +298,14 @@ private:
     QLabel                *m_meta       = nullptr;
     QPushButton           *m_playBtn    = nullptr;
     QPushButton           *m_shuffleBtn = nullptr;
+    QPushButton           *m_favBtn     = nullptr;
+    QPushButton           *m_followBtn  = nullptr;
     QNetworkAccessManager *m_nam        = nullptr;
     QString                m_currentArtUrl;
+    QString                m_albumId;
+    bool                   m_albumFaved = false;
     qint64                 m_artistId   = 0;
+    qint64                 m_playlistId = 0;
+    bool                   m_playlistFollowed = false;
+    bool                   m_playlistOwned = false;
 };