diff --git a/crates/qbz-slint/src/main.rs b/crates/qbz-slint/src/main.rs index aeea98dbc..3c9e54c53 100644 --- a/crates/qbz-slint/src/main.rs +++ b/crates/qbz-slint/src/main.rs @@ -287,6 +287,9 @@ fn main() -> Result<(), Box> { // Shared QBZ image cache for album artwork; trim it on startup. let image_cache = artwork::open_cache(); artwork::spawn_evict(image_cache.clone()); + // Publish it so the playback controller can resolve now-playing / + // queue cover art without the cache being threaded through. + artwork::set_shared_cache(image_cache.clone()); // Audio + Playback settings stores, opened once for the app lifetime. let settings_ctx = settings::SettingsCtx::open(); @@ -650,11 +653,22 @@ fn main() -> Result<(), Box> { } { let runtime = app_runtime.clone(); + let weak = window.as_weak(); let handle = tokio_rt.handle().clone(); window .global::() .on_set_volume(move |fraction| { - playback::set_volume(runtime.clone(), handle.clone(), fraction); + playback::set_volume(runtime.clone(), weak.clone(), handle.clone(), fraction); + }); + } + { + let runtime = app_runtime.clone(); + let weak = window.as_weak(); + let handle = tokio_rt.handle().clone(); + window + .global::() + .on_toggle_mute(move || { + playback::toggle_mute(runtime.clone(), weak.clone(), handle.clone()); }); } diff --git a/crates/qbz-slint/src/playback.rs b/crates/qbz-slint/src/playback.rs index eb0ace5a2..45fec97a4 100644 --- a/crates/qbz-slint/src/playback.rs +++ b/crates/qbz-slint/src/playback.rs @@ -15,7 +15,7 @@ use std::sync::Arc; use qbz_app::shell::AppRuntime; use qbz_models::{Quality, QueueTrack, RepeatMode}; -use slint::ComponentHandle; +use slint::{ComponentHandle, Model}; use crate::adapter::SlintAdapter; use crate::{AppWindow, NowPlayingState, QueueItem, QueueState}; @@ -50,6 +50,7 @@ struct QueueRowData { id: String, title: String, artist: String, + artwork_url: String, playing: bool, } @@ -73,6 +74,14 @@ async fn refresh_queue(runtime: &Runtime, weak: &slint::Weak) { rows.push(queue_row(track, false)); } + // Collect the cover jobs before the rows are moved into the closure. + let art_jobs: Vec<(usize, String)> = rows + .iter() + .enumerate() + .filter(|(_, row)| !row.artwork_url.is_empty()) + .map(|(idx, row)| (idx, row.artwork_url.clone())) + .collect(); + let _ = weak.upgrade_in_event_loop(move |w| { let items: Vec = rows .into_iter() @@ -88,6 +97,8 @@ async fn refresh_queue(runtime: &Runtime, weak: &slint::Weak) { qs.set_items(slint::ModelRc::new(slint::VecModel::from(items))); qs.set_current_index(current_index); }); + + load_queue_artwork(weak.clone(), art_jobs); } /// Map a `QueueTrack` to plain `Send` row data. @@ -100,10 +111,59 @@ fn queue_row(track: &QueueTrack, playing: bool) -> QueueRowData { id: track.id.to_string(), title, artist: track.artist.clone(), + artwork_url: track.artwork_url.clone().unwrap_or_default(), playing, } } +/// Resolve cover art for a list of queue rows and apply each decoded +/// image onto its `QueueState.items` row by index. Spawns one task per +/// cover; misses are silently skipped. +fn load_queue_artwork(weak: slint::Weak, jobs: Vec<(usize, String)>) { + let Some(cache) = crate::artwork::shared_cache() else { + return; + }; + for (idx, url) in jobs { + let weak = weak.clone(); + let cache = cache.clone(); + tokio::spawn(async move { + let Some((pixels, w, h)) = + crate::artwork::fetch_and_decode(&url, &cache, 96).await + else { + return; + }; + let _ = weak.upgrade_in_event_loop(move |win| { + let items = win.global::().get_items(); + if let Some(mut item) = items.row_data(idx) { + item.artwork = crate::artwork::pixels_to_image(&pixels, w, h); + items.set_row_data(idx, item); + } + }); + }); + } +} + +/// Resolve the now-playing cover and apply it to `NowPlayingState`. +fn load_now_playing_artwork(weak: slint::Weak, url: String) { + if url.is_empty() { + return; + } + let Some(cache) = crate::artwork::shared_cache() else { + return; + }; + tokio::spawn(async move { + let Some((pixels, w, h)) = + crate::artwork::fetch_and_decode(&url, &cache, 160).await + else { + return; + }; + let _ = weak.upgrade_in_event_loop(move |win| { + let img = crate::artwork::pixels_to_image(&pixels, w, h); + win.global::().set_artwork(img); + }); + }); +} + /// `M:SS` for the elapsed string. fn fmt_elapsed(secs: u64) -> String { format!("{}:{:02}", secs / 60, secs % 60) @@ -137,6 +197,7 @@ async fn refresh_now_playing_meta(runtime: &Runtime, weak: &slint::Weak(); @@ -154,7 +215,12 @@ async fn refresh_now_playing_meta(runtime: &Runtime, weak: &slint::Weak, + handle: tokio::runtime::Handle, + fraction: f32, +) { handle.spawn(async move { let fraction = fraction.clamp(0.0, 1.0); if let Err(e) = runtime.core().set_volume(fraction) { log::error!("[qbz-slint] playback: set_volume failed: {e}"); } + if fraction > 0.0 && MUTED.swap(false, std::sync::atomic::Ordering::Relaxed) { + let _ = weak.upgrade_in_event_loop(|w| { + w.global::().set_muted(false); + }); + } + }); +} + +/// Toggle mute: silence the player and remember the level, or restore it. +pub fn toggle_mute(runtime: Runtime, weak: slint::Weak, handle: tokio::runtime::Handle) { + use std::sync::atomic::Ordering; + handle.spawn(async move { + if MUTED.swap(false, Ordering::Relaxed) { + // Unmute — restore the stored level. + let restored = f32::from_bits(PREMUTE_VOLUME.load(Ordering::Relaxed)); + let restored = if restored > 0.0 { restored } else { 0.7 }; + let _ = runtime.core().set_volume(restored); + let _ = weak.upgrade_in_event_loop(|w| { + w.global::().set_muted(false); + }); + } else { + // Mute — stash the current level, then drop to zero. + let current = runtime.core().player().get_playback_event().volume; + let current = if current > 0.0 { current } else { 0.7 }; + PREMUTE_VOLUME.store(current.to_bits(), Ordering::Relaxed); + MUTED.store(true, Ordering::Relaxed); + let _ = runtime.core().set_volume(0.0); + let _ = weak.upgrade_in_event_loop(|w| { + w.global::().set_muted(true); + }); + } }); } diff --git a/crates/qbz-slint/ui/shell/PlayerBar.slint b/crates/qbz-slint/ui/shell/PlayerBar.slint index f9aea5957..057f2c984 100644 --- a/crates/qbz-slint/ui/shell/PlayerBar.slint +++ b/crates/qbz-slint/ui/shell/PlayerBar.slint @@ -259,7 +259,16 @@ export component PlayerBar inherits Rectangle { Rectangle { width: 6px; } - IconButton { icon: @image-url("../assets/icons/volume-2.svg"); icon-size: 16px; } + IconButton { + icon: NowPlayingState.muted + ? @image-url("../assets/icons/volume-x.svg") + : @image-url("../assets/icons/volume-2.svg"); + icon-size: 16px; + active: NowPlayingState.muted; + clicked => { + NowPlayingState.toggle-mute(); + } + } VerticalLayout { alignment: center; QbzSlider { diff --git a/crates/qbz-slint/ui/state.slint b/crates/qbz-slint/ui/state.slint index 0b5fb4bfd..d1b39a64a 100644 --- a/crates/qbz-slint/ui/state.slint +++ b/crates/qbz-slint/ui/state.slint @@ -212,6 +212,7 @@ export global NowPlayingState { in property elapsed: "0:00"; in property remaining: "0:00"; in property volume: 0.7; // 0..1 + in property muted: false; in property shuffle: false; in property repeat-mode: 0; // 0 off, 1 all, 2 one @@ -221,6 +222,7 @@ export global NowPlayingState { callback previous(); callback seek(float); // 0..1 callback set-volume(float); // 0..1 + callback toggle-mute(); callback toggle-shuffle(); callback cycle-repeat(); }