feat(slint): local album homologation, Recently Played fixes, local artist nav
Album view (local/Plex): - Rebuild LocalAlbumView as a near copy of the Qobuz AlbumPageView (whole-page scroll, 224px cover, action row, toolbar with quality badge + track search, column header, source-aware rows) minus the label/awards sidebar and Qobuz context menus. Add a per-album client-side track search. Recently Played (Home) — D: - Carry the track source (qobuz|plex|local) through the recently-played store so the cards resolve source-aware artwork (PlexThumb / local file), the album-card play routes to local/Plex playback instead of the empty Qobuz path, and the card click opens the right album view. - Fix a regression from the Plex version split: local_queue_track now derives the content-hash plex_album_key for album_id (navigation) while album_group_key keeps the per-edition split key, so "go to album" and recent Plex albums open correctly. Local artist navigation — B: - Implement open_artist (was a TODO): latch the requested artist and select it once the Artists tab loads. The shared open-artist is now source-aware (numeric id -> Qobuz artist; name -> LocalLibrary Artists tab). Wire the LocalAlbum header artist link and the now-playing "Go to artist" for Plex/local. Folder delete -> Recently Played cascade: - Removing a Local Library folder now also prunes its albums/tracks from the recently-played store (album_keys_in_folder + recently::prune_albums). Covers — C: - Robust on-disk folder cover lookup (cover/folder/front/art/<album>.jpg, any image as a last resort), shared by the Folders subcards and now-playing/album rows. cc
This commit is contained in:
12 files changed
+645
-162
No files matched your search
@@ -1215,6 +1215,29 @@ impl LibraryDatabase {
|
||||
Ok(count)
|
||||
}
|
||||
|
||||
/// Distinct `album_group_key`s of the indexed tracks under `folder` — the
|
||||
/// same keys used as the playback/Recently-Played album id. Call BEFORE
|
||||
/// deleting the folder so the frontend can prune those albums from the
|
||||
/// recently-played store.
|
||||
pub fn album_keys_in_folder(&self, folder: &str) -> Result<Vec<String>, LibraryError> {
|
||||
let pattern = format!("{}/%", folder.trim_end_matches('/'));
|
||||
let mut stmt = self
|
||||
.conn
|
||||
.prepare(
|
||||
"SELECT DISTINCT album_group_key FROM local_tracks
|
||||
WHERE file_path LIKE ? AND album_group_key IS NOT NULL AND album_group_key != ''",
|
||||
)
|
||||
.map_err(|e| LibraryError::Database(e.to_string()))?;
|
||||
let rows = stmt
|
||||
.query_map(params![pattern], |row| row.get::<_, String>(0))
|
||||
.map_err(|e| LibraryError::Database(e.to_string()))?;
|
||||
let mut keys = Vec::new();
|
||||
for k in rows {
|
||||
keys.push(k.map_err(|e| LibraryError::Database(e.to_string()))?);
|
||||
}
|
||||
Ok(keys)
|
||||
}
|
||||
|
||||
/// Remove a folder and its indexed tracks (separator-safe cascade). Mirrors
|
||||
/// the Tauri remove-folder command order: drop the folder row, then the
|
||||
/// tracks under it. Returns the number of tracks removed.
|
||||
|
||||
@@ -740,7 +740,12 @@ fn playback_track_id(rating_key: &str) -> u64 {
|
||||
.unwrap_or_else(|_| synthetic_track_id(rating_key))
|
||||
}
|
||||
|
||||
fn plex_album_key(artist: &str, album: &str) -> String {
|
||||
/// Content-hash album key for a Plex album (`plex:<hash(artist::album)>`). This
|
||||
/// is the stable per-album identity the grid card carries and that
|
||||
/// `plex_cache_get_album_tracks` queries by — distinct from the per-edition
|
||||
/// `parent_rating_key`. Public so the frontend can recover it for a played
|
||||
/// track (whose `album_group_key` is the per-edition split key, not this).
|
||||
pub fn plex_album_key(artist: &str, album: &str) -> String {
|
||||
let mut hasher = DefaultHasher::new();
|
||||
artist.hash(&mut hasher);
|
||||
"::".hash(&mut hasher);
|
||||
|
||||
@@ -193,6 +193,9 @@ where
|
||||
ribbon: String::new(),
|
||||
ribbon_kind: String::new(),
|
||||
artwork_url: album.artwork_url,
|
||||
// Carry the origin so the card resolves source-aware artwork
|
||||
// (PlexThumb / local file) and the play/open route correctly.
|
||||
source: album.source,
|
||||
// Recently-played cards render in the grid only — list-row
|
||||
// extras stay default.
|
||||
..CardData::default()
|
||||
|
||||
@@ -1081,6 +1081,23 @@ fn album_versions() -> std::sync::MutexGuard<'static, Vec<(String, Vec<qbz_libra
|
||||
ALBUM_VERSIONS.lock().unwrap_or_else(|e| e.into_inner())
|
||||
}
|
||||
|
||||
/// Client-side track filter for the open local album (mirrors the Qobuz album
|
||||
/// view's track search). Applied over the current version's tracks at render.
|
||||
static ALBUM_QUERY: LazyLock<Mutex<String>> = LazyLock::new(|| Mutex::new(String::new()));
|
||||
|
||||
fn album_query() -> String {
|
||||
ALBUM_QUERY.lock().unwrap_or_else(|e| e.into_inner()).clone()
|
||||
}
|
||||
|
||||
/// Set the album track filter and re-render the current version in place.
|
||||
pub fn search_album(weak: slint::Weak<AppWindow>, query: String) {
|
||||
*ALBUM_QUERY.lock().unwrap_or_else(|e| e.into_inner()) = query;
|
||||
let _ = weak.upgrade_in_event_loop(|w| {
|
||||
let index = w.global::<crate::LocalAlbumState>().get_version_index();
|
||||
apply_album_version(&w, index);
|
||||
});
|
||||
}
|
||||
|
||||
/// Quality rank for ordering versions (hi-res first).
|
||||
fn version_rank(t: &qbz_library::LocalTrack) -> (u32, u64) {
|
||||
(t.bit_depth.unwrap_or(0), t.sample_rate as u64)
|
||||
@@ -1121,6 +1138,8 @@ pub fn open_local_album(
|
||||
image_cache: ImageCache,
|
||||
group_key: String,
|
||||
) {
|
||||
// Fresh album → clear any leftover track filter from the previous one.
|
||||
*ALBUM_QUERY.lock().unwrap_or_else(|e| e.into_inner()) = String::new();
|
||||
let _ = weak.upgrade_in_event_loop(|w| {
|
||||
let s = w.global::<crate::LocalAlbumState>();
|
||||
s.set_loading(true);
|
||||
@@ -1266,8 +1285,16 @@ pub fn apply_album_version(window: &AppWindow, index: i32) {
|
||||
}
|
||||
None => (String::new(), String::new()),
|
||||
};
|
||||
// Client-side filter (Qobuz album view parity): match title/artist; the
|
||||
// header badge/info stay album-level (computed from the full version above).
|
||||
let q = album_query().to_lowercase();
|
||||
let items: Vec<TrackItem> = tracks
|
||||
.iter()
|
||||
.filter(|t| {
|
||||
q.is_empty()
|
||||
|| t.title.to_lowercase().contains(&q)
|
||||
|| t.artist.to_lowercase().contains(&q)
|
||||
})
|
||||
.cloned()
|
||||
.map(|t| {
|
||||
let mut it = map_local_track(t);
|
||||
@@ -2177,10 +2204,35 @@ pub fn select_folder(
|
||||
db.list_folder_tracks(&path_for_fetch, false)
|
||||
})
|
||||
.unwrap_or_default();
|
||||
// Resolve a real on-disk cover for each subfolder whose indexed
|
||||
// artwork_path is empty (no embedded art / never backfilled) — the
|
||||
// image can sit under any of a dozen names (cover/folder/front/art/
|
||||
// <album>.jpg, …). Off-thread, so the fs scan is fine here.
|
||||
let children = crate::library_db::with_db(|db| {
|
||||
db.list_folder_children(&path_for_fetch, false)
|
||||
})
|
||||
.unwrap_or_default();
|
||||
.unwrap_or_default()
|
||||
.into_iter()
|
||||
.map(|e| match e {
|
||||
qbz_library::FolderTreeEntry::Folder {
|
||||
path,
|
||||
segment,
|
||||
track_count_under,
|
||||
artwork,
|
||||
} => {
|
||||
let artwork = artwork.filter(|a| !a.is_empty()).or_else(|| {
|
||||
find_folder_cover(std::path::Path::new(&path))
|
||||
});
|
||||
qbz_library::FolderTreeEntry::Folder {
|
||||
path,
|
||||
segment,
|
||||
track_count_under,
|
||||
artwork,
|
||||
}
|
||||
}
|
||||
other => other,
|
||||
})
|
||||
.collect::<Vec<_>>();
|
||||
(tracks, children)
|
||||
})
|
||||
.await
|
||||
@@ -2295,6 +2347,82 @@ pub fn set_folder_detail_subfolder_artwork(window: &AppWindow, path: &str, image
|
||||
static ARTIST_ALBUMS: std::sync::Mutex<Vec<qbz_library::LocalAlbum>> =
|
||||
std::sync::Mutex::new(Vec::new());
|
||||
|
||||
/// An artist name to auto-select once the Artists tab finishes loading — set
|
||||
/// when navigating to a local artist from outside the tab (LocalAlbum header
|
||||
/// link, now-playing "Go to artist", a track's context menu). Consumed once.
|
||||
static PENDING_ARTIST: std::sync::Mutex<Option<String>> = std::sync::Mutex::new(None);
|
||||
|
||||
/// Queue an artist to be selected as soon as the Artists tab is ready.
|
||||
pub fn set_pending_artist(name: String) {
|
||||
*PENDING_ARTIST.lock().unwrap_or_else(|e| e.into_inner()) = Some(name);
|
||||
}
|
||||
|
||||
fn take_pending_artist() -> Option<String> {
|
||||
PENDING_ARTIST.lock().unwrap_or_else(|e| e.into_inner()).take()
|
||||
}
|
||||
|
||||
/// Best-effort on-disk cover for a folder. The index often has no
|
||||
/// `artwork_path` (no embedded art + no backfill), yet a cover image sits in
|
||||
/// the folder under any of a dozen names. Priority: a known cover stem
|
||||
/// (cover/folder/front/art/album/…), then `<foldername>.<ext>` (a file named
|
||||
/// after the album), then the first image file as a last resort. Case- and
|
||||
/// extension-insensitive. Returns an absolute path; must run off the UI thread.
|
||||
pub fn find_folder_cover(folder: &std::path::Path) -> Option<String> {
|
||||
const STEMS: &[&str] = &[
|
||||
"cover",
|
||||
"folder",
|
||||
"front",
|
||||
"art",
|
||||
"album",
|
||||
"albumart",
|
||||
"albumartsmall",
|
||||
"thumb",
|
||||
"artwork",
|
||||
"scan",
|
||||
"booklet",
|
||||
"title",
|
||||
];
|
||||
const EXTS: &[&str] = &["jpg", "jpeg", "png", "webp", "bmp", "gif", "tif", "tiff"];
|
||||
let is_img = |p: &std::path::Path| {
|
||||
p.extension()
|
||||
.and_then(|e| e.to_str())
|
||||
.map(|e| EXTS.iter().any(|x| x.eq_ignore_ascii_case(e)))
|
||||
.unwrap_or(false)
|
||||
};
|
||||
let mut entries: Vec<std::path::PathBuf> = std::fs::read_dir(folder)
|
||||
.ok()?
|
||||
.flatten()
|
||||
.map(|e| e.path())
|
||||
.filter(|p| p.is_file() && is_img(p))
|
||||
.collect();
|
||||
if entries.is_empty() {
|
||||
return None;
|
||||
}
|
||||
entries.sort();
|
||||
let stem_lower = |p: &std::path::Path| {
|
||||
p.file_stem()
|
||||
.and_then(|s| s.to_str())
|
||||
.map(|s| s.to_lowercase())
|
||||
.unwrap_or_default()
|
||||
};
|
||||
let folder_name = folder
|
||||
.file_name()
|
||||
.and_then(|s| s.to_str())
|
||||
.unwrap_or("")
|
||||
.to_lowercase();
|
||||
let by_stem = entries
|
||||
.iter()
|
||||
.find(|p| STEMS.contains(&stem_lower(p).as_str()));
|
||||
let by_name = entries
|
||||
.iter()
|
||||
.find(|p| !folder_name.is_empty() && stem_lower(p) == folder_name);
|
||||
by_stem
|
||||
.or(by_name)
|
||||
.cloned()
|
||||
.or_else(|| entries.into_iter().next())
|
||||
.map(|p| p.to_string_lossy().into_owned())
|
||||
}
|
||||
|
||||
/// Fold a common Latin accented char to its ASCII base (best-effort, no
|
||||
/// `unicode-normalization` dep). Covers Spanish/European music metadata; the
|
||||
/// uncovered tail just won't merge across diacritics. Mirrors the intent of
|
||||
@@ -2642,6 +2770,12 @@ pub fn ensure_artists_loaded(
|
||||
let _ = weak.upgrade_in_event_loop(move |w| {
|
||||
let s = w.global::<LocalLibraryState>();
|
||||
if s.get_artists().row_count() != 0 || s.get_artists_loading() {
|
||||
// Already loaded → satisfy a pending open-artist immediately.
|
||||
if s.get_artists().row_count() != 0 {
|
||||
if let Some(name) = take_pending_artist() {
|
||||
select_local_artist(w.as_weak(), handle.clone(), image_cache.clone(), name);
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
s.set_artists_loading(true);
|
||||
@@ -2727,6 +2861,16 @@ pub fn ensure_artists_loaded(
|
||||
.unwrap_or_default();
|
||||
let _ = weak2.upgrade_in_event_loop(move |w| {
|
||||
apply_artists(&w, items);
|
||||
// Satisfy a pending open-artist now that the set + ARTIST_ALBUMS
|
||||
// cache are loaded (navigated here from a "Go to artist" link).
|
||||
if let Some(name) = take_pending_artist() {
|
||||
select_local_artist(
|
||||
w.as_weak(),
|
||||
handle_inner.clone(),
|
||||
image_cache.clone(),
|
||||
name,
|
||||
);
|
||||
}
|
||||
// Seed decode jobs for rows that already carry an image-path.
|
||||
// Non-http paths now split into local files vs Plex `/library/`
|
||||
// thumbs: both go through the source-aware dispatcher (which
|
||||
|
||||
@@ -278,41 +278,74 @@ pub fn add_folder(weak: Weak<AppWindow>, handle: tokio::runtime::Handle) {
|
||||
|
||||
/// Bulk-remove the selected folders (with confirm + cascade track delete).
|
||||
pub fn remove_folders(weak: Weak<AppWindow>, handle: tokio::runtime::Handle) {
|
||||
let ids: Vec<i64> = folders_lock()
|
||||
// Removes only the LocalLibrary DB entries + their indexed tracks — never
|
||||
// the files on disk. Reversible (re-add + re-scan reindexes), so we skip a
|
||||
// confirm dialog: rfd's message dialog needs `zenity`, which isn't present
|
||||
// on every Linux box, and silently fails-closed there (the original "delete
|
||||
// does nothing" bug). A Toast gives feedback instead.
|
||||
let paths: Vec<String> = folders_lock()
|
||||
.iter()
|
||||
.filter(|f| f.selected)
|
||||
.map(|f| f.id)
|
||||
.map(|f| f.path.clone())
|
||||
.collect();
|
||||
if ids.is_empty() {
|
||||
if paths.is_empty() {
|
||||
return;
|
||||
}
|
||||
let count = ids.len();
|
||||
let count = paths.len();
|
||||
let h = handle.clone();
|
||||
handle.spawn(async move {
|
||||
let ok = rfd::AsyncMessageDialog::new()
|
||||
.set_title("Remove folders")
|
||||
.set_description(format!(
|
||||
"Remove {count} selected folder(s)? Their indexed tracks will be removed. Your audio files are not deleted."
|
||||
))
|
||||
.set_buttons(rfd::MessageButtons::YesNo)
|
||||
.show()
|
||||
.await;
|
||||
if ok != rfd::MessageDialogResult::Yes {
|
||||
return;
|
||||
}
|
||||
let ids2 = ids.clone();
|
||||
tokio::task::spawn_blocking(move || {
|
||||
let paths2 = paths.clone();
|
||||
let keys = tokio::task::spawn_blocking(move || {
|
||||
crate::library_db::with_db(|db| {
|
||||
for id in &ids2 {
|
||||
if let Some(f) = db.get_folder_by_id(*id)? {
|
||||
db.remove_folder_with_tracks(&f.path)?;
|
||||
}
|
||||
let mut keys: Vec<String> = Vec::new();
|
||||
for p in &paths2 {
|
||||
keys.extend(db.album_keys_in_folder(p).unwrap_or_default());
|
||||
db.remove_folder_with_tracks(p)?;
|
||||
}
|
||||
Ok(())
|
||||
Ok(keys)
|
||||
})
|
||||
})
|
||||
.await
|
||||
.ok();
|
||||
.ok()
|
||||
.flatten()
|
||||
.unwrap_or_default();
|
||||
crate::recently::prune_albums(&keys);
|
||||
crate::toast::success_weak(&weak, format!("Removed {count} folder(s)"));
|
||||
load_folders(weak, h);
|
||||
});
|
||||
}
|
||||
|
||||
/// Remove ONE folder by id (confirm + cascade track delete). The per-row
|
||||
/// delete button; independent of the multi-select state, so a previously
|
||||
/// added folder can be removed without first selecting it + the toolbar trash.
|
||||
pub fn remove_folder(weak: Weak<AppWindow>, handle: tokio::runtime::Handle, id: i64) {
|
||||
// DB-only removal (entry + indexed tracks), never the files. No confirm
|
||||
// dialog — see remove_folders for why (zenity-less boxes fail-closed).
|
||||
let (path, name) = {
|
||||
let g = folders_lock();
|
||||
match g.iter().find(|f| f.id == id) {
|
||||
Some(f) => (f.path.clone(), display_name(f)),
|
||||
None => return,
|
||||
}
|
||||
};
|
||||
let h = handle.clone();
|
||||
handle.spawn(async move {
|
||||
let p = path.clone();
|
||||
let result = tokio::task::spawn_blocking(move || {
|
||||
crate::library_db::with_db(|db| {
|
||||
// Capture album keys BEFORE the delete so we can prune them out
|
||||
// of Recently Played too (not just the DB rows).
|
||||
let keys = db.album_keys_in_folder(&p).unwrap_or_default();
|
||||
let n = db.remove_folder_with_tracks(&p)?;
|
||||
Ok((n, keys))
|
||||
})
|
||||
})
|
||||
.await
|
||||
.ok()
|
||||
.flatten();
|
||||
let (n, keys) = result.unwrap_or((0, Vec::new()));
|
||||
crate::recently::prune_albums(&keys);
|
||||
crate::toast::success_weak(&weak, format!("Removed \"{name}\" ({n} tracks)"));
|
||||
load_folders(weak, h);
|
||||
});
|
||||
}
|
||||
|
||||
+117
-26
@@ -260,14 +260,28 @@ async fn reload_home(
|
||||
url: slim.artwork_url.clone(),
|
||||
})
|
||||
}));
|
||||
jobs.extend(data.recent_albums.iter().enumerate().filter_map(|(idx, card)| {
|
||||
(!card.artwork_url.is_empty()).then(|| artwork::ArtworkJob {
|
||||
// Recently-played album covers: Qobuz covers use the plain loader;
|
||||
// Plex/local covers need the source-aware funnel (PlexThumb
|
||||
// tokenization / local file read), else they never resolve.
|
||||
let mut plex_album_jobs: Vec<artwork::ArtworkJob> = Vec::new();
|
||||
for (idx, card) in data.recent_albums.iter().enumerate() {
|
||||
if card.artwork_url.is_empty() {
|
||||
continue;
|
||||
}
|
||||
let job = artwork::ArtworkJob {
|
||||
target: artwork::ArtworkTarget::RecentAlbum { idx },
|
||||
url: card.artwork_url.clone(),
|
||||
})
|
||||
}));
|
||||
};
|
||||
if card.source == "plex" || card.source == "local" {
|
||||
plex_album_jobs.push(job);
|
||||
} else {
|
||||
jobs.push(job);
|
||||
}
|
||||
}
|
||||
|
||||
let weak_for_artwork = weak.clone();
|
||||
let weak_for_local = weak.clone();
|
||||
let image_cache_local = image_cache.clone();
|
||||
let _ = weak.upgrade_in_event_loop(move |w| {
|
||||
home::apply_home(&w, data);
|
||||
// apply_home shows the home set; swap to the requested
|
||||
@@ -276,6 +290,16 @@ async fn reload_home(
|
||||
w.global::<HomeState>().set_loading(false);
|
||||
});
|
||||
artwork::spawn_loads(jobs, weak_for_artwork, image_cache.clone());
|
||||
if !plex_album_jobs.is_empty() {
|
||||
let plex = crate::plex_settings::get();
|
||||
artwork::spawn_local_or_plex_loads(
|
||||
plex_album_jobs,
|
||||
plex.base_url,
|
||||
plex.token,
|
||||
weak_for_local,
|
||||
image_cache_local,
|
||||
);
|
||||
}
|
||||
}
|
||||
Err(e) => {
|
||||
log::error!("[qbz-slint] discover load failed: {e}");
|
||||
@@ -1028,6 +1052,37 @@ fn navigate_favorites(
|
||||
});
|
||||
}
|
||||
|
||||
/// Navigate to the LocalLibrary Artists tab and auto-select `name`. Local/Plex
|
||||
/// artists have no id — they're keyed by NAME. The selection is latched and
|
||||
/// consumed by `ensure_artists_loaded` once the tab's data is ready (handles
|
||||
/// both the already-loaded and still-loading cases). Used by the LocalAlbum
|
||||
/// header artist link, the now-playing "Go to artist", and local track menus.
|
||||
fn open_local_artist(
|
||||
runtime: &Arc<AppRuntime<SlintAdapter>>,
|
||||
weak: &slint::Weak<AppWindow>,
|
||||
handle: &tokio::runtime::Handle,
|
||||
image_cache: &artwork::ImageCache,
|
||||
name: String,
|
||||
) {
|
||||
if name.trim().is_empty() {
|
||||
return;
|
||||
}
|
||||
local_library::set_pending_artist(name);
|
||||
nav::record(nav::NavEntry::LocalLibrary {
|
||||
tab: "artists".to_string(),
|
||||
});
|
||||
navigate_local_library(
|
||||
runtime.clone(),
|
||||
weak.clone(),
|
||||
handle,
|
||||
image_cache.clone(),
|
||||
local_library::LibTab::Artists,
|
||||
);
|
||||
if let Some(w) = weak.upgrade() {
|
||||
update_nav_flags(&w);
|
||||
}
|
||||
}
|
||||
|
||||
/// Open a Local Library browse tab (Albums / Artists / Folders / Tracks).
|
||||
///
|
||||
/// Sets the active tab + switches the view, then lazily loads the tab's data
|
||||
@@ -2029,18 +2084,26 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
|
||||
let weak = window.as_weak();
|
||||
let handle = tokio_rt.handle().clone();
|
||||
let image_cache = image_cache.clone();
|
||||
window.on_open_artist(move |artist_id| {
|
||||
let artist_id = artist_id.to_string();
|
||||
nav::record(nav::NavEntry::Artist(artist_id.clone()));
|
||||
navigate_artist(
|
||||
runtime.clone(),
|
||||
weak.clone(),
|
||||
&handle,
|
||||
image_cache.clone(),
|
||||
artist_id,
|
||||
);
|
||||
if let Some(w) = weak.upgrade() {
|
||||
update_nav_flags(&w);
|
||||
window.on_open_artist(move |artist_ref| {
|
||||
let artist_ref = artist_ref.to_string();
|
||||
// Qobuz artists are numeric ids → the Qobuz artist page. Local/Plex
|
||||
// artists have no id, so their surfaces (LocalAlbum link, now-playing
|
||||
// "Go to artist") pass the NAME instead → the LocalLibrary Artists
|
||||
// tab, focused on that artist.
|
||||
if artist_ref.parse::<u64>().is_ok() {
|
||||
nav::record(nav::NavEntry::Artist(artist_ref.clone()));
|
||||
navigate_artist(
|
||||
runtime.clone(),
|
||||
weak.clone(),
|
||||
&handle,
|
||||
image_cache.clone(),
|
||||
artist_ref,
|
||||
);
|
||||
if let Some(w) = weak.upgrade() {
|
||||
update_nav_flags(&w);
|
||||
}
|
||||
} else if !artist_ref.trim().is_empty() {
|
||||
open_local_artist(&runtime, &weak, &handle, &image_cache, artist_ref);
|
||||
}
|
||||
});
|
||||
}
|
||||
@@ -2440,13 +2503,22 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
|
||||
crate::ui_prefs::save(&prefs);
|
||||
}
|
||||
}
|
||||
("album", "play") => playback::play_album(
|
||||
runtime.clone(),
|
||||
weak.clone(),
|
||||
handle.clone(),
|
||||
id,
|
||||
0,
|
||||
),
|
||||
("album", "play") => {
|
||||
// A Plex/local id is a metadata group key, not a Qobuz id —
|
||||
// play it from the local/Plex cache (Home "Recently played",
|
||||
// etc.) instead of trying to fetch a Qobuz album.
|
||||
if is_local_album_key(&id) {
|
||||
playback::play_local_album(
|
||||
runtime.clone(),
|
||||
weak.clone(),
|
||||
handle.clone(),
|
||||
id,
|
||||
None,
|
||||
);
|
||||
} else {
|
||||
playback::play_album(runtime.clone(), weak.clone(), handle.clone(), id, 0);
|
||||
}
|
||||
}
|
||||
("track", "play") => {
|
||||
// Universal per-row play: queue the current view's VISIBLE
|
||||
// tracklist starting at the clicked track (see
|
||||
@@ -4497,6 +4569,15 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
|
||||
local_library_settings::remove_folders(weak.clone(), handle.clone())
|
||||
});
|
||||
}
|
||||
{
|
||||
let weak = window.as_weak();
|
||||
let handle = tokio_rt.handle().clone();
|
||||
window
|
||||
.global::<LibraryManageActions>()
|
||||
.on_remove_folder(move |id| {
|
||||
local_library_settings::remove_folder(weak.clone(), handle.clone(), id as i64)
|
||||
});
|
||||
}
|
||||
{
|
||||
let weak = window.as_weak();
|
||||
window
|
||||
@@ -4844,6 +4925,12 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
|
||||
}
|
||||
});
|
||||
}
|
||||
{
|
||||
let weak = window.as_weak();
|
||||
window.global::<LocalAlbumActions>().on_search(move |q| {
|
||||
local_library::search_album(weak.clone(), q.to_string());
|
||||
});
|
||||
}
|
||||
|
||||
// Local Library — Albums tab controls (search / sort re-query page 1;
|
||||
// load-more pages on scroll; retry) + the shared AlbumCollectionView's
|
||||
@@ -4940,11 +5027,15 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
|
||||
});
|
||||
}
|
||||
{
|
||||
let runtime = app_runtime.clone();
|
||||
let weak = window.as_weak();
|
||||
let handle = tokio_rt.handle().clone();
|
||||
let image_cache = image_cache.clone();
|
||||
window
|
||||
.global::<LocalLibraryActions>()
|
||||
.on_open_artist(move |id| {
|
||||
// TODO(locallibrary): open the local Artists tab / artist.
|
||||
log::debug!("[qbz-slint] local artist open (Artists slice pending): {id}");
|
||||
.on_open_artist(move |name| {
|
||||
// `name` is the artist NAME (local/Plex artists have no id).
|
||||
open_local_artist(&runtime, &weak, &handle, &image_cache, name.to_string());
|
||||
});
|
||||
}
|
||||
{
|
||||
|
||||
@@ -844,7 +844,17 @@ fn local_queue_track(track: &qbz_library::LocalTrack) -> QueueTrack {
|
||||
bit_depth: track.bit_depth,
|
||||
sample_rate: Some(sample_rate_khz),
|
||||
is_local: true,
|
||||
album_id: Some(track.album_group_key.clone()),
|
||||
// album_id is the navigation key (now-playing "go to album", Recently
|
||||
// Played, record_recent). For Plex the track's `album_group_key` is the
|
||||
// per-edition SPLIT key (plex:album:<parentRatingKey>) which the album
|
||||
// cache is NOT keyed by — recover the content-hash album key instead so
|
||||
// open-album finds it. Local files: the group key is already the right
|
||||
// navigation key.
|
||||
album_id: Some(if is_plex {
|
||||
qbz_plex::plex_album_key(&track.artist, &track.album)
|
||||
} else {
|
||||
track.album_group_key.clone()
|
||||
}),
|
||||
artist_id: None,
|
||||
streamable: true,
|
||||
source: Some(src.to_string()),
|
||||
@@ -884,13 +894,9 @@ pub fn fill_missing_covers(tracks: &mut [qbz_library::LocalTrack]) {
|
||||
let key = folder.to_string_lossy().into_owned();
|
||||
let cover = memo
|
||||
.entry(key)
|
||||
.or_insert_with(|| {
|
||||
["cover.jpg", "cover.png", "folder.jpg", "front.jpg"]
|
||||
.iter()
|
||||
.map(|n| folder.join(n))
|
||||
.find(|c| c.is_file())
|
||||
.map(|c| c.to_string_lossy().into_owned())
|
||||
})
|
||||
// Robust on-disk cover lookup (cover/folder/front/art/<album>.jpg,
|
||||
// any image as a last resort) — shared with the Folders subcards.
|
||||
.or_insert_with(|| crate::local_library::find_folder_cover(&folder))
|
||||
.clone();
|
||||
if cover.is_some() {
|
||||
t.artwork_path = cover;
|
||||
@@ -1224,6 +1230,7 @@ async fn record_recent(runtime: &Runtime) {
|
||||
genre: meta.genre,
|
||||
release_date: meta.release_date,
|
||||
artist_id: track.artist_id,
|
||||
source: track.source.clone().unwrap_or_else(|| "qobuz".to_string()),
|
||||
});
|
||||
// Per-artist play count — feeds the discovery filter "skip
|
||||
// artists I already know" (HavingCount > threshold). artist_id
|
||||
|
||||
@@ -90,6 +90,11 @@ pub struct RecentTrack {
|
||||
/// Artist id for navigation / scrobble context.
|
||||
#[serde(default)]
|
||||
pub artist_id: Option<u64>,
|
||||
/// Origin: "qobuz" | "plex" | "local". Drives source-aware artwork
|
||||
/// (PlexThumb / local file) and routing for the Recently Played cards.
|
||||
/// Empty for pre-source entries (serde default) → treated as "qobuz".
|
||||
#[serde(default)]
|
||||
pub source: String,
|
||||
}
|
||||
|
||||
/// One recently-played album, derived from the track history.
|
||||
@@ -104,6 +109,8 @@ pub struct RecentAlbum {
|
||||
pub genre: String,
|
||||
/// Raw ISO release date; localized at render time.
|
||||
pub release_date: String,
|
||||
/// "qobuz" | "plex" | "local" — see RecentTrack::source.
|
||||
pub source: String,
|
||||
}
|
||||
|
||||
fn store_path() -> Option<PathBuf> {
|
||||
@@ -139,11 +146,34 @@ pub fn load_albums() -> Vec<RecentAlbum> {
|
||||
quality_label: track.quality_label,
|
||||
genre: track.genre,
|
||||
release_date: track.release_date,
|
||||
source: track.source,
|
||||
});
|
||||
}
|
||||
albums
|
||||
}
|
||||
|
||||
/// Remove every recently-played entry whose `album_id` is in `album_ids`.
|
||||
/// Used when a Local Library folder is deleted so its albums/tracks no longer
|
||||
/// linger in Recently Played. Returns how many track entries were removed.
|
||||
pub fn prune_albums(album_ids: &[String]) -> usize {
|
||||
if album_ids.is_empty() {
|
||||
return 0;
|
||||
}
|
||||
let Some(path) = store_path() else {
|
||||
return 0;
|
||||
};
|
||||
let mut list = load();
|
||||
let before = list.len();
|
||||
list.retain(|t| !album_ids.iter().any(|k| k == &t.album_id));
|
||||
let removed = before - list.len();
|
||||
if removed > 0 {
|
||||
if let Ok(json) = serde_json::to_vec_pretty(&list) {
|
||||
let _ = std::fs::write(&path, json);
|
||||
}
|
||||
}
|
||||
removed
|
||||
}
|
||||
|
||||
/// Record a played track at the front of the list. Deduplicates by id and
|
||||
/// caps the list at [`MAX_RECENT`]. Called by the playback session when a
|
||||
/// track starts.
|
||||
|
||||
@@ -7,7 +7,7 @@
|
||||
|
||||
import { Theme } from "../foundation/semantic-colors.slint";
|
||||
import { Typography } from "../foundation/typography.slint";
|
||||
import { LocalAlbumState, LocalAlbumActions, LocalAlbumVersion, NowPlayingState, NavState } from "../state.slint";
|
||||
import { LocalAlbumState, LocalAlbumActions, LocalAlbumVersion, NowPlayingState, NavState, DragState } from "../state.slint";
|
||||
import { NavButtons } from "../shell/NavButtons.slint";
|
||||
import { CircleAction } from "../primitives/CircleAction.slint";
|
||||
import { QbzIcon } from "../primitives/QbzIcon.slint";
|
||||
@@ -39,15 +39,16 @@ component VersionPicker inherits Rectangle {
|
||||
in property <[LocalAlbumVersion]> versions;
|
||||
in property <int> current;
|
||||
callback select(int);
|
||||
height: 32px;
|
||||
width: pick-row.preferred-width + 22px;
|
||||
// Matches QbzSelect `sm` (height 30, radius 6, no outline, 10px left pad)
|
||||
// so it reads like every other small select instead of towering over them.
|
||||
height: 30px;
|
||||
width: pick-row.preferred-width;
|
||||
border-radius: 6px;
|
||||
border-width: 1px;
|
||||
border-color: Theme.border-subtle;
|
||||
background: pick-ta.has-hover ? Theme.surface-hover : Theme.surface-elevated;
|
||||
|
||||
pick-row := HorizontalLayout {
|
||||
x: Math.round((parent.width - self.width) / 2 / 1px) * 1px;
|
||||
padding-left: 10px;
|
||||
padding-right: 8px;
|
||||
spacing: 7px;
|
||||
VerticalLayout {
|
||||
alignment: center;
|
||||
@@ -94,7 +95,7 @@ component VersionPicker inherits Rectangle {
|
||||
padding: 6px;
|
||||
spacing: 1px;
|
||||
for v[i] in root.versions: Rectangle {
|
||||
height: 34px;
|
||||
height: 30px;
|
||||
border-radius: 6px;
|
||||
background: i == root.current
|
||||
? Theme.surface-elevated
|
||||
@@ -141,23 +142,55 @@ component VersionPicker inherits Rectangle {
|
||||
}
|
||||
|
||||
export component LocalAlbumView inherits Rectangle {
|
||||
// Navigate to the artist (the NAME — local/Plex artists have no id; the
|
||||
// source-aware open-artist routes a name to the LocalLibrary Artists tab).
|
||||
callback open-artist(string);
|
||||
background: Theme.surface-main;
|
||||
|
||||
VerticalLayout {
|
||||
spacing: 0px;
|
||||
// Homologated 1:1 with the Qobuz AlbumPageView: whole-page Flickable, the
|
||||
// same header proportions + action row, the toolbar (quality badge + track
|
||||
// search), the column header, and source-aware TrackRows. The only
|
||||
// intentional differences vs AlbumPageView: no label/awards right sidebar,
|
||||
// no Qobuz context menus, and the local-only version picker.
|
||||
flick := Flickable {
|
||||
interactive: !DragState.active;
|
||||
viewport-width: self.width;
|
||||
viewport-height: page.preferred-height;
|
||||
// Scroll-position restore on back/forward (see nav::scope_for).
|
||||
property <string> sr-armed: NavState.restore-scope;
|
||||
function sr-restore() {
|
||||
if (NavState.restore-scope == "local-album" && self.viewport-height > self.height) {
|
||||
self.viewport-y = NavState.scroll-restore;
|
||||
NavState.restore-scope = "";
|
||||
}
|
||||
}
|
||||
init => { self.sr-restore(); }
|
||||
changed sr-armed => { self.sr-restore(); }
|
||||
changed viewport-height => { self.sr-restore(); }
|
||||
changed viewport-y => { NavState.report-scroll(self.viewport-y); }
|
||||
|
||||
// --- History nav + header ---------------------------------------
|
||||
// padding-top 11px matches Discover/Album so the [<] [>] pair sits at
|
||||
// the same top margin across every view. vertical-stretch: 0 is
|
||||
// load-bearing (FavoritesView lesson): without it this nested layout
|
||||
// grabs the leftover height and the header balloons.
|
||||
VerticalLayout {
|
||||
vertical-stretch: 0;
|
||||
// Header band (neutral — local albums have no artwork-derived tint yet).
|
||||
Rectangle {
|
||||
x: 0;
|
||||
y: 0;
|
||||
width: parent.width;
|
||||
height: 340px;
|
||||
background: @linear-gradient(180deg,
|
||||
#181820 0%,
|
||||
#181820 16%,
|
||||
transparent 100%);
|
||||
}
|
||||
|
||||
page := VerticalLayout {
|
||||
width: parent.width;
|
||||
padding-left: 32px;
|
||||
padding-right: 32px;
|
||||
padding-top: 11px;
|
||||
padding-bottom: 100px;
|
||||
spacing: 0px;
|
||||
alignment: start;
|
||||
|
||||
// --- History navigation -------------------------------------
|
||||
HorizontalLayout {
|
||||
alignment: start;
|
||||
NavButtons { }
|
||||
@@ -165,13 +198,13 @@ export component LocalAlbumView inherits Rectangle {
|
||||
|
||||
Rectangle { height: 22px; }
|
||||
|
||||
// --- Album header -------------------------------------------
|
||||
HorizontalLayout {
|
||||
spacing: 28px;
|
||||
spacing: 32px;
|
||||
|
||||
// Cover.
|
||||
Rectangle {
|
||||
width: 200px;
|
||||
height: 200px;
|
||||
width: 224px;
|
||||
height: 224px;
|
||||
border-radius: 12px;
|
||||
background: Theme.surface-elevated;
|
||||
drop-shadow-blur: 32px;
|
||||
@@ -188,8 +221,8 @@ export component LocalAlbumView inherits Rectangle {
|
||||
|
||||
VerticalLayout {
|
||||
alignment: start;
|
||||
padding-top: 6px;
|
||||
spacing: 6px;
|
||||
padding-top: 4px;
|
||||
spacing: 0px;
|
||||
horizontal-stretch: 1;
|
||||
|
||||
Text {
|
||||
@@ -199,29 +232,38 @@ export component LocalAlbumView inherits Rectangle {
|
||||
font-weight: Typography.bold;
|
||||
overflow: elide;
|
||||
}
|
||||
Text {
|
||||
text: LocalAlbumState.artist;
|
||||
color: Theme.text-secondary;
|
||||
font-size: Typography.heading;
|
||||
font-weight: Typography.bold;
|
||||
overflow: elide;
|
||||
}
|
||||
Text {
|
||||
text: LocalAlbumState.info-line;
|
||||
color: Theme.text-muted;
|
||||
font-size: Typography.body;
|
||||
}
|
||||
if LocalAlbumState.quality-tier != "": HorizontalLayout {
|
||||
Rectangle { height: 4px; }
|
||||
HorizontalLayout {
|
||||
alignment: start;
|
||||
QualityBadgeFull {
|
||||
tier: LocalAlbumState.quality-tier;
|
||||
detail: LocalAlbumState.quality-detail;
|
||||
la-artist := TouchArea {
|
||||
width: la-artist-text.preferred-width;
|
||||
height: la-artist-text.preferred-height;
|
||||
mouse-cursor: pointer;
|
||||
clicked => {
|
||||
root.open-artist(LocalAlbumState.artist);
|
||||
}
|
||||
la-artist-text := Text {
|
||||
text: LocalAlbumState.artist;
|
||||
color: la-artist.has-hover
|
||||
? Theme.text-primary
|
||||
: Theme.text-secondary;
|
||||
font-size: Typography.heading;
|
||||
font-weight: Typography.bold;
|
||||
}
|
||||
}
|
||||
}
|
||||
Rectangle { height: 10px; }
|
||||
Text {
|
||||
text: LocalAlbumState.info-line;
|
||||
color: Theme.text-secondary;
|
||||
font-size: Typography.body;
|
||||
overflow: elide;
|
||||
}
|
||||
|
||||
Rectangle { height: 6px; }
|
||||
Rectangle { height: 20px; }
|
||||
|
||||
// Local-only action row.
|
||||
// Local action row — same chrome as AlbumPageView, only the
|
||||
// actions that apply to a local/Plex album.
|
||||
HorizontalLayout {
|
||||
alignment: start;
|
||||
spacing: 12px;
|
||||
@@ -229,8 +271,6 @@ export component LocalAlbumView inherits Rectangle {
|
||||
icon: @image-url("../assets/icons/play-fill.svg");
|
||||
primary: true;
|
||||
diameter: 44px;
|
||||
// Spin only while THIS album's first track is fetching
|
||||
// (local album-id == the now-playing track's album_id).
|
||||
loading: NowPlayingState.loading
|
||||
&& NowPlayingState.album-id == LocalAlbumState.id;
|
||||
clicked => {
|
||||
@@ -266,7 +306,8 @@ export component LocalAlbumView inherits Rectangle {
|
||||
}
|
||||
}
|
||||
|
||||
// Version picker (only when there are multiple copies).
|
||||
// Version picker (only with multiple physical copies).
|
||||
if LocalAlbumState.versions.length > 1: Rectangle { height: 16px; }
|
||||
if LocalAlbumState.versions.length > 1: HorizontalLayout {
|
||||
alignment: start;
|
||||
spacing: 8px;
|
||||
@@ -292,73 +333,165 @@ export component LocalAlbumView inherits Rectangle {
|
||||
}
|
||||
}
|
||||
|
||||
Rectangle { height: 16px; }
|
||||
}
|
||||
|
||||
Rectangle {
|
||||
height: 1px;
|
||||
background: Theme.border-subtle;
|
||||
}
|
||||
|
||||
// --- Track list -------------------------------------------------
|
||||
Rectangle {
|
||||
vertical-stretch: 1;
|
||||
clip: true;
|
||||
|
||||
if LocalAlbumState.loading: VerticalLayout {
|
||||
alignment: center;
|
||||
HorizontalLayout {
|
||||
alignment: center;
|
||||
LoadingSpinner { size: 32px; }
|
||||
}
|
||||
Rectangle { height: 20px; }
|
||||
Rectangle {
|
||||
height: 1px;
|
||||
background: Theme.border-subtle;
|
||||
}
|
||||
Rectangle { height: 8px; }
|
||||
|
||||
if !LocalAlbumState.loading && LocalAlbumState.tracks.length > 0: Rectangle {
|
||||
VerticalLayout {
|
||||
padding-left: 32px;
|
||||
padding-right: 32px;
|
||||
padding-top: 12px;
|
||||
tracks-list := ListView {
|
||||
vertical-scrollbar-policy: ScrollBarPolicy.always-off;
|
||||
// Scroll-position restore on back/forward (see nav::scope_for).
|
||||
property <string> sr-armed: NavState.restore-scope;
|
||||
function sr-restore() {
|
||||
if (NavState.restore-scope == "local-album" && self.viewport-height > self.height) {
|
||||
self.viewport-y = NavState.scroll-restore;
|
||||
NavState.restore-scope = "";
|
||||
}
|
||||
// --- Track list (no sidebar) --------------------------------
|
||||
VerticalLayout {
|
||||
spacing: 0px;
|
||||
alignment: start;
|
||||
|
||||
if LocalAlbumState.loading && LocalAlbumState.tracks.length == 0: Rectangle {
|
||||
height: 280px;
|
||||
VerticalLayout {
|
||||
alignment: center;
|
||||
HorizontalLayout {
|
||||
alignment: center;
|
||||
LoadingSpinner { size: 36px; }
|
||||
}
|
||||
init => { self.sr-restore(); }
|
||||
changed sr-armed => { self.sr-restore(); }
|
||||
changed viewport-height => { self.sr-restore(); }
|
||||
changed viewport-y => { NavState.report-scroll(self.viewport-y); }
|
||||
for track[i] in LocalAlbumState.tracks: TrackRow {
|
||||
track: track;
|
||||
index: i;
|
||||
show-artwork: false;
|
||||
show-album: false;
|
||||
show-favorite: false;
|
||||
show-download: false;
|
||||
show-source: false;
|
||||
media-action(kind, id, action) => {
|
||||
// Local-only: ignore album/artist link clicks;
|
||||
// any other row action plays the track.
|
||||
if (kind != "album" && kind != "artist") {
|
||||
LocalAlbumActions.play-track(id);
|
||||
}
|
||||
}
|
||||
|
||||
// Toolbar — album quality badge + track search.
|
||||
HorizontalLayout {
|
||||
height: 52px;
|
||||
spacing: 16px;
|
||||
VerticalLayout {
|
||||
alignment: center;
|
||||
QualityBadgeFull {
|
||||
tier: LocalAlbumState.quality-tier;
|
||||
detail: LocalAlbumState.quality-detail;
|
||||
}
|
||||
}
|
||||
Rectangle { horizontal-stretch: 1; }
|
||||
VerticalLayout {
|
||||
alignment: center;
|
||||
Rectangle {
|
||||
width: 280px;
|
||||
height: 34px;
|
||||
border-radius: 6px;
|
||||
border-width: 1px;
|
||||
border-color: Theme.border-subtle;
|
||||
background: Theme.surface-elevated;
|
||||
HorizontalLayout {
|
||||
padding-left: 10px;
|
||||
padding-right: 10px;
|
||||
spacing: 7px;
|
||||
VerticalLayout {
|
||||
alignment: center;
|
||||
QbzIcon {
|
||||
source: @image-url("../assets/icons/search.svg");
|
||||
width: 14px;
|
||||
height: 14px;
|
||||
tint: Theme.text-muted;
|
||||
}
|
||||
}
|
||||
Rectangle {
|
||||
horizontal-stretch: 1;
|
||||
track-search := TextInput {
|
||||
width: 100%;
|
||||
height: 100%;
|
||||
color: Theme.text-primary;
|
||||
font-size: 13px;
|
||||
vertical-alignment: center;
|
||||
single-line: true;
|
||||
edited => {
|
||||
LocalAlbumActions.search(self.text);
|
||||
}
|
||||
}
|
||||
Text {
|
||||
visible: track-search.text == "";
|
||||
text: @tr("Search tracks...");
|
||||
width: 100%;
|
||||
height: 100%;
|
||||
color: Theme.text-muted;
|
||||
font-size: 13px;
|
||||
vertical-alignment: center;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
ListScrollbar {
|
||||
x: parent.width - self.width - 4px;
|
||||
width: 14px;
|
||||
height: 100%;
|
||||
viewport-height: tracks-list.viewport-height;
|
||||
visible-height: tracks-list.visible-height;
|
||||
viewport-y <=> tracks-list.viewport-y;
|
||||
|
||||
// Column header.
|
||||
HorizontalLayout {
|
||||
height: 40px;
|
||||
padding-left: 12px;
|
||||
padding-right: 12px;
|
||||
spacing: 16px;
|
||||
Text {
|
||||
text: "#";
|
||||
width: 32px;
|
||||
color: Theme.text-muted;
|
||||
font-size: Typography.legal;
|
||||
letter-spacing: 0.5px;
|
||||
vertical-alignment: center;
|
||||
}
|
||||
Text {
|
||||
text: @tr("TITLE");
|
||||
horizontal-stretch: 1;
|
||||
color: Theme.text-muted;
|
||||
font-size: Typography.legal;
|
||||
letter-spacing: 0.5px;
|
||||
vertical-alignment: center;
|
||||
}
|
||||
Text {
|
||||
text: @tr("DURATION");
|
||||
width: 80px;
|
||||
color: Theme.text-muted;
|
||||
font-size: Typography.legal;
|
||||
letter-spacing: 0.5px;
|
||||
horizontal-alignment: center;
|
||||
vertical-alignment: center;
|
||||
}
|
||||
Text {
|
||||
text: @tr("QUALITY");
|
||||
width: 80px;
|
||||
color: Theme.text-muted;
|
||||
font-size: Typography.legal;
|
||||
letter-spacing: 0.5px;
|
||||
horizontal-alignment: center;
|
||||
vertical-alignment: center;
|
||||
}
|
||||
// Source column (local/Plex/qobuz indicator on each row).
|
||||
Rectangle { width: 28px; }
|
||||
// Aligns with the per-row more-button slot.
|
||||
Rectangle { width: 32px; }
|
||||
}
|
||||
|
||||
for track[index] in LocalAlbumState.tracks: TrackRow {
|
||||
track: track;
|
||||
index: index;
|
||||
show-artwork: false;
|
||||
show-album: false;
|
||||
show-favorite: false;
|
||||
show-download: false;
|
||||
// Show the per-row source glyph (local / qobuz-offline / Plex).
|
||||
show-source: true;
|
||||
media-action(kind, id, action) => {
|
||||
// Local-only: ignore album/artist link clicks; any other
|
||||
// row action plays the track.
|
||||
if (kind != "album" && kind != "artist") {
|
||||
LocalAlbumActions.play-track(id);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Shared scrollbar in the right gutter (homologated cross-view).
|
||||
ListScrollbar {
|
||||
x: parent.width - self.width - 4px;
|
||||
width: 14px;
|
||||
height: 100%;
|
||||
viewport-height: flick.viewport-height;
|
||||
visible-height: flick.height;
|
||||
viewport-y <=> flick.viewport-y;
|
||||
}
|
||||
}
|
||||
@@ -175,7 +175,11 @@ export component AppShell inherits Rectangle {
|
||||
}
|
||||
}
|
||||
// Dedicated Local Library album detail (separate from AlbumView).
|
||||
if NavState.view == ContentView.local-album: LocalAlbumView { }
|
||||
if NavState.view == ContentView.local-album: LocalAlbumView {
|
||||
open-artist(name) => {
|
||||
root.open-artist(name);
|
||||
}
|
||||
}
|
||||
if NavState.view == ContentView.artist: ArtistPageView {
|
||||
open-album(id) => {
|
||||
root.open-album(id);
|
||||
|
||||
@@ -328,8 +328,14 @@ export component SongCard inherits Rectangle {
|
||||
label: NowPlayingState.artist;
|
||||
stretch: 2.0;
|
||||
activated => {
|
||||
if (NowPlayingState.artist-id != "" && !NowPlayingState.is-ephemeral) {
|
||||
root.open-artist(NowPlayingState.artist-id);
|
||||
if (!NowPlayingState.is-ephemeral) {
|
||||
// Qobuz: numeric artist-id → Qobuz artist page. Plex/local:
|
||||
// no id, so pass the NAME → LocalLibrary Artists tab.
|
||||
if (NowPlayingState.artist-id != "") {
|
||||
root.open-artist(NowPlayingState.artist-id);
|
||||
} else if (NowPlayingState.artist != "") {
|
||||
root.open-artist(NowPlayingState.artist);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -699,6 +699,9 @@ export global LocalAlbumActions {
|
||||
callback add-to-playlist();
|
||||
callback play-track(string /* track id */);
|
||||
callback select-version(int);
|
||||
// Client-side track filter (mirrors AlbumActions.search), applied over the
|
||||
// current version's tracks.
|
||||
callback search(string /* query */);
|
||||
}
|
||||
|
||||
// ============================ Local Library management ====================
|
||||
@@ -767,6 +770,7 @@ export global LibraryManageActions {
|
||||
callback load(); // (re)load the folder list (panel init)
|
||||
callback add-folder(); // native dir picker (Rust)
|
||||
callback remove-folders(); // bulk-remove selected (confirm)
|
||||
callback remove-folder(int /* id */); // remove ONE folder directly (confirm)
|
||||
callback toggle-folder-select(int /* id */);
|
||||
callback edit-folder(int /* id */); // open the settings modal
|
||||
callback save-folder-settings(int /* id */, string /* alias */, bool /* enabled */,
|
||||
|
||||
Reference in new issue
Block a user