//! LabelReleasesView controller — loads the label header (name + //! image from /label/page) and the paginated album catalog (from //! /label/getAlbums), pushing them into `LabelState`. //! //! Mirrors Tauri's LabelReleasesView.svelte data flow. The rich //! sort / filter / group-by-artist controls there are deferred; this //! port covers the header, the album grid, and load-more pagination. use std::cell::RefCell; use std::collections::{HashMap, HashSet}; use std::sync::Arc; use qbz_app::shell::AppRuntime; use qbz_core::FrontendAdapter; use qbz_models::{Album, LabelExploreResponse, Track}; use serde_json::Value; use slint::{ComponentHandle, Model, ModelRc, VecModel}; use crate::album_map::{map_album, sort_album_items, tier, to_item, AlbumCard}; use crate::artwork::{ArtworkJob, ArtworkTarget}; use crate::{ AlbumCardItem, AppWindow, DiscoverSection, JumpNavTab, LabelState, SearchPlaylistItem, SlimItem, TrackItem, }; /// Page size for the album catalog. Tauri pulls 500 at a time; keep /// the same so a typical label loads in one shot. pub const PAGE_SIZE: u32 = 500; pub struct LabelData { pub id: String, pub name: String, pub image_url: String, pub albums: Vec, pub total: usize, pub has_more: bool, } /// Fetch the label page (name + image) and the first album page. pub async fn load_label( runtime: &Arc>, label_id: u64, fallback_name: &str, ) -> Result where A: FrontendAdapter + Send + Sync + 'static, { let page = runtime .core() .get_label_page(label_id) .await .map_err(|e| e.to_string())?; let albums_page = runtime .core() .get_label_albums(label_id, PAGE_SIZE, 0, None, None, None, None, None) .await .map_err(|e| e.to_string())?; let name = if page.name.is_empty() { fallback_name.to_string() } else { page.name }; let image_url = extract_label_image(page.image.as_ref()); let item_count = albums_page.items.len(); let total = albums_page .total .map(|t| t as usize) .unwrap_or(item_count); // /label/getAlbums caps each page below the full catalog; trust the // `has_more` flag, falling back to a total comparison when it's absent. let has_more = albums_page.has_more.unwrap_or(total > item_count); let albums = albums_page.items.into_iter().map(map_album).collect(); Ok(LabelData { id: label_id.to_string(), name, image_url, albums, total, has_more, }) } /// Fetch one more album page for the load-more affordance. Returns the /// new cards, the (best-known) total, and whether more pages remain. pub async fn load_more_albums( runtime: &Arc>, label_id: u64, offset: u32, ) -> Result<(Vec, usize, bool), String> where A: FrontendAdapter + Send + Sync + 'static, { let page = runtime .core() .get_label_albums(label_id, PAGE_SIZE, offset, None, None, None, None, None) .await .map_err(|e| e.to_string())?; let item_count = page.items.len(); let loaded = offset as usize + item_count; let total = page.total.map(|t| t as usize).unwrap_or(loaded); // More pages remain when the API says so, or when this page came back // full (a short page means the catalog is exhausted). let has_more = page .has_more .unwrap_or(item_count >= PAGE_SIZE as usize || total > loaded); let albums = page.items.into_iter().map(map_album).collect(); Ok((albums, total, has_more)) } /// Extract the best URL from /label/page's flexible image value. It /// can be a bare string or an object with mega/extralarge/large/... /// keys (mirrors the Svelte extraction order). Reused by the favorites /// Labels tab, whose wire `image` is a bare string per the Android DTO. pub(crate) fn extract_label_image(image: Option<&serde_json::Value>) -> String { let Some(image) = image else { return String::new(); }; if let Some(s) = image.as_str() { return s.to_string(); } for key in ["mega", "extralarge", "large", "thumbnail", "small"] { if let Some(s) = image.get(key).and_then(|v| v.as_str()) { return s.to_string(); } } String::new() } pub fn apply_label(window: &AppWindow, data: LabelData) { let items: Vec = data.albums.into_iter().map(to_item).collect(); let state = window.global::(); state.set_id(data.id.into()); state.set_name(data.name.into()); state.set_image_url(data.image_url.into()); state.set_albums(ModelRc::new(VecModel::from(items))); state.set_total(data.total as i32); state.set_has_more(data.has_more); state.set_loading(false); derive_releases(window); } /// Re-derive the releases sub-view's rendered list (`visible` / `grouped`) /// from the full loaded catalog + the toolbar state (sort / Hi-Res filter / /// search / group-by-artist). Mirrors Tauri's client-side `$derived` /// processing. Search is a local filter over the loaded catalog. Artwork /// stays live in the common case because the no-filter, default-sort path /// shares the `albums` model (the DiscoverBrowse pattern). pub fn derive_releases(window: &AppWindow) { let state = window.global::(); let albums = state.get_albums(); let count = albums.row_count(); let full: Vec = (0..count).filter_map(|i| albums.row_data(i)).collect(); let sort = state.get_sort_by().to_string(); let hires = state.get_filter_hires(); let group = state.get_group_by_artist(); let query_owned = state.get_search_query().to_lowercase(); let query = query_owned.trim(); let hires_count = full .iter() .filter(|a| a.quality_tier.as_str() == "hires") .count(); // Fast path: default order, no filter/search, flat → render the live // `albums` model directly so artwork keeps updating in place. if !hires && query.is_empty() && sort == "newest" && !group { state.set_visible(albums.clone()); state.set_grouped(ModelRc::new(VecModel::from(Vec::::new()))); state.set_shown(full.len() as i32); state.set_hires_count(hires_count as i32); return; } let mut filtered: Vec = full .into_iter() .filter(|a| { (!hires || a.quality_tier.as_str() == "hires") && (query.is_empty() || a.title.to_lowercase().contains(query) || a.artist.to_lowercase().contains(query)) }) .collect(); sort_album_items(&mut filtered, &sort); let shown = filtered.len(); if group { // One section per artist, in first-appearance (sorted) order. let mut sections: Vec = Vec::new(); let mut buckets: Vec> = Vec::new(); let mut index: HashMap = HashMap::new(); for item in filtered { let key = item.artist.to_string(); let idx = *index.entry(key.clone()).or_insert_with(|| { buckets.push(Vec::new()); sections.push(DiscoverSection { title: if key.is_empty() { "Unknown".into() } else { key.clone().into() }, endpoint: "".into(), albums: ModelRc::new(VecModel::from(Vec::::new())), }); buckets.len() - 1 }); buckets[idx].push(item); } for (i, bucket) in buckets.into_iter().enumerate() { sections[i].albums = ModelRc::new(VecModel::from(bucket)); } state.set_grouped(ModelRc::new(VecModel::from(sections))); state.set_visible(ModelRc::new(VecModel::from(Vec::::new()))); } else { state.set_visible(ModelRc::new(VecModel::from(filtered))); state.set_grouped(ModelRc::new(VecModel::from(Vec::::new()))); } state.set_shown(shown as i32); state.set_hires_count(hires_count as i32); } pub fn append_albums(window: &AppWindow, albums: Vec, total: usize, has_more: bool) { let state = window.global::(); let model = state.get_albums(); let mut combined: Vec = (0..model.row_count()) .filter_map(|i| model.row_data(i)) .collect(); combined.extend(albums.into_iter().map(to_item)); state.set_albums(ModelRc::new(VecModel::from(combined))); state.set_total(total as i32); state.set_has_more(has_more); state.set_load_more_loading(false); derive_releases(window); } /// Apply the decoded label header image. Runs on the Slint event loop. pub fn apply_image(window: &AppWindow, pixels: &[u8], width: u32, height: u32) { let mut buffer = slint::SharedPixelBuffer::::new(width, height); let dst = buffer.make_mut_bytes(); if dst.len() != pixels.len() { return; } dst.copy_from_slice(pixels); window .global::() .set_image(slint::Image::from_rgba8(buffer)); } pub fn reset_label(window: &AppWindow) { let state = window.global::(); state.set_name("".into()); state.set_image_url("".into()); state.set_albums(ModelRc::new(VecModel::from(Vec::::new()))); state.set_visible(ModelRc::new(VecModel::from(Vec::::new()))); state.set_grouped(ModelRc::new(VecModel::from(Vec::::new()))); state.set_total(0); state.set_has_more(false); state.set_loading(true); state.set_load_more_loading(false); // Reset the toolbar to defaults for the fresh label. state.set_sort_by("newest".into()); state.set_filter_hires(false); state.set_group_by_artist(false); state.set_search_query("".into()); state.set_shown(0); state.set_hires_count(0); } /// Artwork jobs for the label album grid — same pipeline the /// Discover cards use. pub fn artwork_jobs(data: &LabelData) -> Vec { data.albums .iter() .enumerate() .filter(|(_, a)| !a.artwork_url.is_empty()) .map(|(i, a)| ArtworkJob { url: a.artwork_url.clone(), target: ArtworkTarget::LabelAlbum { index: i }, }) .collect() } // ====================================================================== // Landing page (LabelPageView) — the rich label page: header + // popular tracks + releases / critics / playlists / artists / // more-labels carousels. Mirrors Tauri's LabelView.svelte. Data comes // from /label/page (top_tracks/releases/playlists/top_artists), the // first /label/getAlbums page (releases carousel), /label/explore // (more labels), and the user's favorite-labels set (follow state). // ====================================================================== /// Plain, `Send` payload for the rich label landing page. pub struct LabelPagePayload { pub id: String, pub name: String, pub image_url: String, pub description: String, pub description_short: String, pub description_truncated: bool, pub is_following: bool, pub top_tracks: Vec, pub releases: Vec, pub critics: Vec, pub playlists: Vec, pub artists: Vec, pub more_labels: Vec, /// Catalog tracks kept for "Play all" — deserialized from the page /// top_tracks and queued verbatim (mirrors Tauri's buildTopTracksQueue). pub play_tracks: Vec, } #[derive(Clone)] pub struct TopTrack { pub id: String, pub title: String, pub artist: String, pub artist_id: String, pub album_id: String, pub artwork_url: String, pub duration: String, pub quality_tier: String, pub quality_detail: String, } #[derive(Clone)] pub struct PlaylistSlim { pub id: String, pub title: String, pub subtitle: String, pub image_url: String, } #[derive(Clone)] pub struct ArtistSlim { pub id: String, pub name: String, pub image_url: String, } #[derive(Clone)] pub struct LabelSlim { pub id: String, pub name: String, pub image_url: String, pub following: bool, } // Catalog tracks for the landing's "Play all", cached on the UI thread // (set in `apply_label_page`, read by the play-top media action). thread_local! { static PLAY_TOP_TRACKS: RefCell> = const { RefCell::new(Vec::new()) }; } /// The label's popular tracks as a play-ready queue source. pub fn top_tracks_for_play() -> Vec { PLAY_TOP_TRACKS.with(|c| c.borrow().clone()) } /// Fetch + map the full label landing page. pub async fn load_label_page( runtime: &Arc>, label_id: u64, fallback_name: &str, ) -> Result where A: FrontendAdapter + Send + Sync + 'static, { let page = runtime .core() .get_label_page(label_id) .await .map_err(|e| e.to_string())?; // Favorite-label ids — seed the header + per-card follow state. let follow_ids = favorite_label_ids(runtime).await; let name = if page.name.is_empty() { fallback_name.to_string() } else { page.name.clone() }; let image_url = extract_label_image(page.image.as_ref()); // Description (HTML-stripped) + truncation for the header read-more. let description = page .description .as_deref() .map(crate::strip_html::strip_html) .unwrap_or_default(); let description_short = truncate_words(&description, 360); let description_truncated = description_short != description; // Popular tracks → display rows + play-all queue source. let raw_top = page.top_tracks.clone().unwrap_or_default(); let top_tracks: Vec = raw_top.iter().map(parse_top_track).collect(); let play_tracks: Vec = raw_top .into_iter() .filter_map(|v| serde_json::from_value::(v).ok()) .collect(); // Critics' Picks — the releases container whose id mentions // award/critic/press (mirrors LabelView.svelte:402-413). let critics: Vec = page .releases .as_ref() .and_then(|containers| { containers .iter() .find(|c| { c.id .as_deref() .map(|id| { let id = id.to_lowercase(); id.contains("award") || id.contains("critic") || id.contains("press") }) .unwrap_or(false) }) .and_then(|c| c.data.as_ref()) .and_then(|d| d.items.as_ref()) .map(|items| { items .iter() .filter_map(|v| serde_json::from_value::(v.clone()).ok()) .map(map_album) .collect() }) }) .unwrap_or_default(); let playlists: Vec = page .playlists .as_ref() .and_then(|p| p.items.as_ref()) .map(|items| items.iter().map(parse_playlist).collect()) .unwrap_or_default(); let artists: Vec = page .top_artists .as_ref() .and_then(|a| a.items.as_ref()) .map(|items| items.iter().map(parse_artist).collect()) .unwrap_or_default(); // Releases carousel — first 20 from /label/getAlbums. let releases: Vec = match runtime .core() .get_label_albums(label_id, 20, 0, None, None, None, None, None) .await { Ok(p) => p.items.into_iter().map(map_album).collect(), Err(e) => { log::warn!("[qbz-slint] label releases carousel failed: {e}"); Vec::new() } }; // More labels — /label/explore minus the current label; seed follow. let more_labels: Vec = match runtime.core().get_label_explore(20, 0).await { Ok(resp) => parse_more_labels(&resp, label_id, &follow_ids), Err(e) => { log::warn!("[qbz-slint] label explore failed: {e}"); Vec::new() } }; Ok(LabelPagePayload { id: label_id.to_string(), name, image_url, description, description_short, description_truncated, is_following: follow_ids.contains(&label_id), top_tracks, releases, critics, playlists, artists, more_labels, play_tracks, }) } /// The user's favorite-label ids (for the header + more-labels follow /// state). Best-effort: an error yields an empty set. async fn favorite_label_ids(runtime: &Arc>) -> HashSet where A: FrontendAdapter + Send + Sync + 'static, { match runtime.core().get_favorites("label", 500, 0).await { Ok(v) => v .get("labels") .and_then(|l| l.get("items")) .and_then(|i| i.as_array()) .map(|arr| { arr.iter() .filter_map(|it| it.get("id").and_then(|x| x.as_u64())) .collect() }) .unwrap_or_default(), Err(_) => HashSet::new(), } } fn parse_top_track(raw: &Value) -> TopTrack { let id = raw .get("id") .and_then(|v| v.as_u64()) .map(|n| n.to_string()) .unwrap_or_default(); let title = raw .get("title") .and_then(|v| v.as_str()) .unwrap_or_default() .to_string(); let duration = raw.get("duration").and_then(|v| v.as_u64()).unwrap_or(0); let album = raw.get("album"); let album_id = album .and_then(|a| a.get("id")) .map(value_to_string) .unwrap_or_default(); let artwork_url = album .and_then(|a| a.get("image")) .map(parse_image_value) .unwrap_or_default(); // performer OR artist (the page uses either). let perf = raw.get("performer").or_else(|| raw.get("artist")); let artist = perf .and_then(|p| p.get("name")) .map(name_display) .unwrap_or_default(); let artist_id = perf .and_then(|p| p.get("id")) .map(value_to_string) .unwrap_or_default(); let bit_depth = raw .get("audio_info") .and_then(|a| a.get("maximum_bit_depth")) .and_then(|v| v.as_u64()) .or_else(|| raw.get("maximum_bit_depth").and_then(|v| v.as_u64())); let sample_rate = raw .get("audio_info") .and_then(|a| a.get("maximum_sampling_rate")) .and_then(|v| v.as_f64()) .or_else(|| raw.get("maximum_sampling_rate").and_then(|v| v.as_f64())); let bit_depth = bit_depth.map(|b| b as u32); TopTrack { id, title, artist, artist_id, album_id, artwork_url, duration: mmss(duration as u32), quality_tier: tier(bit_depth).to_string(), quality_detail: crate::quality::detail(bit_depth, sample_rate), } } fn parse_playlist(raw: &Value) -> PlaylistSlim { let id = raw.get("id").map(value_to_string).unwrap_or_default(); let title = raw .get("name") .and_then(|v| v.as_str()) .unwrap_or_default() .to_string(); let owner = raw .get("owner") .and_then(|o| o.get("name")) .and_then(|v| v.as_str()) .filter(|s| !s.is_empty()) .unwrap_or("Qobuz") .to_string(); let track_count = raw.get("tracks_count").and_then(|v| v.as_u64()).unwrap_or(0); let subtitle = format!("{owner} · {track_count}"); PlaylistSlim { id, title, subtitle, image_url: parse_playlist_image(raw), } } fn parse_artist(raw: &Value) -> ArtistSlim { ArtistSlim { id: raw.get("id").map(value_to_string).unwrap_or_default(), name: raw.get("name").map(name_display).unwrap_or_default(), image_url: parse_artist_image(raw), } } fn parse_more_labels( resp: &LabelExploreResponse, current: u64, follow: &HashSet, ) -> Vec { let Some(items) = resp.items.as_ref() else { return Vec::new(); }; items .iter() .filter_map(|item| { let id = item.get("id").and_then(|x| x.as_u64())?; if id == current { return None; } let name = item .get("name") .and_then(|x| x.as_str()) .unwrap_or_default() .to_string(); let image_url = item .get("image") .map(parse_explore_image) .unwrap_or_default(); Some(LabelSlim { id: id.to_string(), name, image_url, following: follow.contains(&id), }) }) .collect() } // --- Value helpers (mirror the Svelte getX helpers) ---------------------- /// String for an id-ish Value (string verbatim, number stringified). fn value_to_string(v: &Value) -> String { match v { Value::String(s) => s.clone(), Value::Number(n) => n.to_string(), _ => String::new(), } } /// Display name: `{display}` object form or a bare string. fn name_display(v: &Value) -> String { if let Some(s) = v.as_str() { return s.to_string(); } v.get("display") .and_then(|d| d.as_str()) .unwrap_or_default() .to_string() } /// Best URL out of an album `image` Value (string or {large|...}). fn parse_image_value(v: &Value) -> String { if let Some(s) = v.as_str() { return s.to_string(); } for key in ["large", "extralarge", "medium", "thumbnail", "small"] { if let Some(s) = v.get(key).and_then(|x| x.as_str()) { return s.to_string(); } } String::new() } /// getArtistImageUrl: image{large|extralarge|medium|thumbnail|small} -> /// picture(string) -> images.portrait hash (medium covers). fn parse_artist_image(raw: &Value) -> String { if let Some(image) = raw.get("image") { let url = parse_image_value(image); if !url.is_empty() { return url; } } if let Some(pic) = raw.get("picture").and_then(|v| v.as_str()) { if !pic.is_empty() { return pic.to_string(); } } if let Some(portrait) = raw.get("images").and_then(|i| i.get("portrait")) { if let (Some(hash), Some(format)) = ( portrait.get("hash").and_then(|v| v.as_str()), portrait.get("format").and_then(|v| v.as_str()), ) { return format!( "https://static.qobuz.com/images/artists/covers/medium/{hash}.{format}" ); } } String::new() } /// getPlaylistImage: image.rectangle -> image.covers[0] -> /// image{large|thumbnail|small} -> images300[0] -> images150[0] -> /// images[0]. fn parse_playlist_image(raw: &Value) -> String { if let Some(image) = raw.get("image") { if let Some(rect) = image.get("rectangle").and_then(|v| v.as_str()) { if !rect.is_empty() { return rect.to_string(); } } if let Some(cover) = image .get("covers") .and_then(|c| c.as_array()) .and_then(|a| a.first()) .and_then(|v| v.as_str()) { return cover.to_string(); } for key in ["large", "thumbnail", "small"] { if let Some(s) = image.get(key).and_then(|v| v.as_str()) { return s.to_string(); } } } for key in ["images300", "images150", "images"] { if let Some(s) = raw .get(key) .and_then(|a| a.as_array()) .and_then(|a| a.first()) .and_then(|v| v.as_str()) { return s.to_string(); } } String::new() } /// parseLabelExploreImage: string or {large|thumbnail|small}. fn parse_explore_image(v: &Value) -> String { if let Some(s) = v.as_str() { return s.to_string(); } for key in ["large", "thumbnail", "small"] { if let Some(s) = v.get(key).and_then(|x| x.as_str()) { return s.to_string(); } } String::new() } fn mmss(secs: u32) -> String { format!("{}:{:02}", secs / 60, secs % 60) } /// Word-boundary truncation with an ellipsis (mirrors artist::truncate_words). fn truncate_words(text: &str, max: usize) -> String { if text.chars().count() <= max { return text.to_string(); } let truncated: String = text.chars().take(max).collect(); let cut = truncated.rfind(' ').unwrap_or(truncated.len()); format!("{}…", truncated[..cut].trim_end()) } // --- Slint mapping ------------------------------------------------------- fn top_track_to_item(t: &TopTrack) -> TrackItem { TrackItem { id: t.id.clone().into(), number: "".into(), title: t.title.clone().into(), artist: t.artist.clone().into(), album: "".into(), duration: t.duration.clone().into(), quality_tier: t.quality_tier.clone().into(), quality_detail: t.quality_detail.clone().into(), explicit: false, selected: false, artwork_url: t.artwork_url.clone().into(), artwork: slint::Image::default(), is_favorite: crate::fav_cache::is_favorite(&t.id), artist_id: t.artist_id.clone().into(), album_id: t.album_id.clone().into(), removing: false, cache_status: if crate::offline_cache::is_cached(&t.id) { 3 } else { 0 }, cache_progress: 0.0, source: "qobuz".into(), unlocking: false, } } fn playlist_to_item(p: &PlaylistSlim) -> SearchPlaylistItem { SearchPlaylistItem { id: p.id.clone().into(), title: p.title.clone().into(), subtitle: p.subtitle.clone().into(), cover_count: if p.image_url.is_empty() { 0 } else { 1 }, url1: p.image_url.clone().into(), url2: "".into(), url3: "".into(), url4: "".into(), cover1: slint::Image::default(), cover2: slint::Image::default(), cover3: slint::Image::default(), cover4: slint::Image::default(), } } fn artist_to_item(a: &ArtistSlim) -> SlimItem { SlimItem { id: a.id.clone().into(), title: a.name.clone().into(), subtitle: "".into(), rank: "".into(), artwork_url: a.image_url.clone().into(), artwork: slint::Image::default(), following: false, } } fn label_to_item(l: &LabelSlim) -> SlimItem { SlimItem { id: l.id.clone().into(), title: l.name.clone().into(), subtitle: "".into(), rank: "".into(), artwork_url: l.image_url.clone().into(), artwork: slint::Image::default(), following: l.following, } } fn section(title: &str, cards: &[AlbumCard]) -> DiscoverSection { DiscoverSection { title: title.into(), endpoint: "".into(), albums: ModelRc::new(VecModel::from( cards.iter().cloned().map(to_item).collect::>(), )), } } /// Apply the landing payload to `LabelState`. Runs on the Slint event loop. pub fn apply_label_page(window: &AppWindow, payload: LabelPagePayload) { PLAY_TOP_TRACKS.with(|c| *c.borrow_mut() = payload.play_tracks.clone()); let top_tracks: Vec = payload.top_tracks.iter().map(top_track_to_item).collect(); let playlists: Vec = payload.playlists.iter().map(playlist_to_item).collect(); let artists: Vec = payload.artists.iter().map(artist_to_item).collect(); let more_labels: Vec = payload.more_labels.iter().map(label_to_item).collect(); let releases = section("Releases", &payload.releases); let critics = section("Critics' Picks", &payload.critics); let jump_tabs = build_label_jump_tabs(&payload); let state = window.global::(); state.set_id(payload.id.into()); state.set_name(payload.name.into()); state.set_image_url(payload.image_url.into()); state.set_description(payload.description.into()); state.set_description_short(payload.description_short.into()); state.set_description_truncated(payload.description_truncated); state.set_is_following(payload.is_following); state.set_top_tracks(ModelRc::new(VecModel::from(top_tracks))); state.set_releases_section(releases); state.set_critics_section(critics); state.set_playlists(ModelRc::new(VecModel::from(playlists))); state.set_artists(ModelRc::new(VecModel::from(artists))); state.set_more_labels(ModelRc::new(VecModel::from(more_labels))); state.set_jump_tabs(ModelRc::new(VecModel::from(jump_tabs))); state.set_page_loaded(true); state.set_loading(false); } /// Build the JUMP TO tabs for the landing — only sections with content. /// anchor-y values are layout-derived estimates (variable header/grid /// heights make exact numbers impractical; the estimate lands the user /// inside the right section). Mirrors artist::build_jump_tabs. fn build_label_jump_tabs(payload: &LabelPagePayload) -> Vec { const HEADER_GUESS: f32 = 360.0; const SECTION_SPACER: f32 = 40.0; const CAROUSEL: f32 = 320.0; const POPULAR_HEADER: f32 = 46.0; const POPULAR_ROW: f32 = 50.0; const POPULAR_TAIL: f32 = 40.0; let mut tabs: Vec = Vec::new(); tabs.push(JumpNavTab { id: "about".into(), label: "About".into(), anchor_y: 0.0, }); let mut cursor = HEADER_GUESS; if !payload.top_tracks.is_empty() { tabs.push(JumpNavTab { id: "popular".into(), label: "Popular Tracks".into(), anchor_y: cursor, }); let rows = payload.top_tracks.len().min(5) as f32; cursor += POPULAR_HEADER + rows * POPULAR_ROW + POPULAR_TAIL; } let push_carousel = |tabs: &mut Vec, id: &str, label: &str, present: bool, cursor: &mut f32| { if present { tabs.push(JumpNavTab { id: id.into(), label: label.into(), anchor_y: *cursor, }); *cursor += SECTION_SPACER + CAROUSEL; } }; push_carousel(&mut tabs, "releases", "Releases", !payload.releases.is_empty(), &mut cursor); push_carousel(&mut tabs, "critics", "Critics' Picks", !payload.critics.is_empty(), &mut cursor); push_carousel(&mut tabs, "playlists", "Playlists", !payload.playlists.is_empty(), &mut cursor); push_carousel(&mut tabs, "artists", "Artists", !payload.artists.is_empty(), &mut cursor); push_carousel(&mut tabs, "labels", "More Labels", !payload.more_labels.is_empty(), &mut cursor); tabs } /// Artwork jobs for the landing sections (top-track thumbs + carousels). pub fn page_artwork_jobs(payload: &LabelPagePayload) -> Vec { let mut jobs = Vec::new(); let push = |jobs: &mut Vec, url: &str, target: ArtworkTarget| { if !url.is_empty() { jobs.push(ArtworkJob { url: url.to_string(), target, }); } }; for (i, t) in payload.top_tracks.iter().enumerate() { push(&mut jobs, &t.artwork_url, ArtworkTarget::LabelTopTrack { index: i }); } for (i, a) in payload.releases.iter().enumerate() { push(&mut jobs, &a.artwork_url, ArtworkTarget::LabelReleaseAlbum { index: i }); } for (i, a) in payload.critics.iter().enumerate() { push(&mut jobs, &a.artwork_url, ArtworkTarget::LabelCriticsAlbum { index: i }); } for (i, p) in payload.playlists.iter().enumerate() { push(&mut jobs, &p.image_url, ArtworkTarget::LabelPlaylistCover { index: i }); } for (i, a) in payload.artists.iter().enumerate() { push(&mut jobs, &a.image_url, ArtworkTarget::LabelArtist { index: i }); } for (i, l) in payload.more_labels.iter().enumerate() { push(&mut jobs, &l.image_url, ArtworkTarget::LabelMoreLabel { index: i }); } jobs } /// Current follow state for `label_id` — the header when it's the open /// label, else the matching More-Labels card. pub fn label_following_state(window: &AppWindow, label_id: &str) -> bool { let state = window.global::(); if state.get_id().as_str() == label_id { return state.get_is_following(); } let model = state.get_more_labels(); for i in 0..model.row_count() { if let Some(item) = model.row_data(i) { if item.id.as_str() == label_id { return item.following; } } } false } /// Name of a More-Labels card by id (nav-history fallback for a card click). pub fn more_label_name(window: &AppWindow, label_id: &str) -> String { let model = window.global::().get_more_labels(); for i in 0..model.row_count() { if let Some(item) = model.row_data(i) { if item.id.as_str() == label_id { return item.title.to_string(); } } } String::new() } /// Optimistically reflect a follow toggle — flips the header state when /// it's the current label, and the matching more-labels card. pub fn mark_label_followed(window: &AppWindow, label_id: &str, following: bool) { let state = window.global::(); if state.get_id().as_str() == label_id { state.set_is_following(following); } let model = state.get_more_labels(); for i in 0..model.row_count() { if let Some(mut item) = model.row_data(i) { if item.id.as_str() == label_id { item.following = following; model.set_row_data(i, item); } } } } /// Clear the landing state before loading a new label. pub fn reset_label_page(window: &AppWindow) { let state = window.global::(); state.set_name("".into()); state.set_image_url("".into()); state.set_image(slint::Image::default()); state.set_description("".into()); state.set_description_short("".into()); state.set_description_truncated(false); state.set_is_following(false); state.set_top_tracks(ModelRc::new(VecModel::from(Vec::::new()))); state.set_releases_section(DiscoverSection::default()); state.set_critics_section(DiscoverSection::default()); state.set_playlists(ModelRc::new(VecModel::from(Vec::::new()))); state.set_artists(ModelRc::new(VecModel::from(Vec::::new()))); state.set_more_labels(ModelRc::new(VecModel::from(Vec::::new()))); state.set_jump_tabs(ModelRc::new(VecModel::from(Vec::::new()))); state.set_page_loaded(false); state.set_loading(true); }