refactor(slint): booklet button downloads the PDF instead of the in-app MuPDF reader

Not every album ships a booklet and the in-app PDF reader was clumsy. The album
booklet button now DOWNLOADS the goody PDF (native save dialog, app HTTP client)
instead of rendering it in-app, and the MuPDF rasterizer is dropped entirely:

- crates/qbz/src/booklet.rs: reduced to set/clear URL + download_booklet (fetch
  + save dialog). Removed the reader (open/render/paging/zoom/rotate/close).
- main.rs: the ("album","booklet") action now calls download_booklet; removed the
  BookletActions reader wiring block.
- Removed the qbz-booklet crate (MuPDF) from the workspace + qbz deps; Cargo.lock
  drops mupdf/mupdf-sys. ~26 MB static MuPDF (~6 MB linked) + its heavy C build
  are gone, lightening the build (more headroom under the 16 GB rustc wall).

AlbumBookletModal.slint + the BookletState/BookletActions globals are now unused
(left in place; remove in a UI cleanup pass that recompiles qbz-ui).

cc
This commit is contained in:
vicrodh committed 2026-06-26 17:20:15 -06:00
1 parent 77a476c8e7
commit 998ab9d5c0
7 files changed
+60 -764

No files matched your search

-129
View File
@@ -1331,18 +1331,6 @@ dependencies = [
"libc",
]
[[package]]
name = "core-text"
version = "20.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c9d2790b5c08465d49f8dc05c8bcae9fea467855947db39b0f8145c091aaced5"
dependencies = [
"core-foundation 0.9.4",
"core-graphics 0.23.2",
"foreign-types 0.5.0",
"libc",
]
[[package]]
name = "core_maths"
version = "0.1.1"
@@ -1817,18 +1805,6 @@ version = "1.0.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "92773504d58c093f6de2459af4af33faa518c13451eb8f2b5698ed3d36e7c813"
[[package]]
name = "dwrote"
version = "0.11.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9e1b35532432acc8b19ceed096e35dfa088d3ea037fe4f3c085f1f97f33b4d02"
dependencies = [
"lazy_static",
"libc",
"winapi",
"wio",
]
[[package]]
name = "ebur128"
version = "0.1.10"
@@ -2105,12 +2081,6 @@ dependencies = [
"num-traits",
]
[[package]]
name = "float-ord"
version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8ce81f49ae8a0482e4c55ea62ebbd7e5a686af544c00b9d090bba3ff9be97b3d"
[[package]]
name = "flume"
version = "0.11.1"
@@ -2140,31 +2110,6 @@ version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
[[package]]
name = "font-kit"
version = "0.14.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2c7e611d49285d4c4b2e1727b72cf05353558885cc5252f93707b845dfcaf3d3"
dependencies = [
"bitflags 2.11.0",
"byteorder",
"core-foundation 0.9.4",
"core-graphics 0.23.2",
"core-text",
"dirs 6.0.0",
"dwrote",
"float-ord",
"freetype-sys",
"lazy_static",
"libc",
"log",
"pathfinder_geometry",
"pathfinder_simd",
"walkdir",
"winapi",
"yeslogic-fontconfig-sys",
]
[[package]]
name = "font-types"
version = "0.11.3"
@@ -2259,17 +2204,6 @@ dependencies = [
"percent-encoding",
]
[[package]]
name = "freetype-sys"
version = "0.20.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0e7edc5b9669349acfda99533e9e0bcf26a51862ab43b08ee7745c55d28eb134"
dependencies = [
"cc",
"libc",
"pkg-config",
]
[[package]]
name = "fs_extra"
version = "1.3.0"
@@ -4209,32 +4143,6 @@ dependencies = [
"windows-sys 0.60.2",
]
[[package]]
name = "mupdf"
version = "0.6.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7a60c91abaf541e5291ca470efcb7d80d0ad834dcca7fa8f8576aa789a9813b1"
dependencies = [
"bitflags 2.11.0",
"font-kit",
"mupdf-sys",
"once_cell",
"zerocopy",
]
[[package]]
name = "mupdf-sys"
version = "0.6.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "182cb40642a37e5980a03285664c2c100f5dbde781165c137fd49ff9c06fd5c5"
dependencies = [
"bindgen",
"cc",
"pkg-config",
"regex",
"zerocopy",
]
[[package]]
name = "naga"
version = "28.0.0"
@@ -5104,25 +5012,6 @@ version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "df94ce210e5bc13cb6651479fa48d14f601d9858cfe0467f43ae157023b938d3"
[[package]]
name = "pathfinder_geometry"
version = "0.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0b7b7e7b4ea703700ce73ebf128e1450eb69c3a8329199ffbfb9b2a0418e5ad3"
dependencies = [
"log",
"pathfinder_simd",
]
[[package]]
name = "pathfinder_simd"
version = "0.5.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4500030c302e4af1d423f36f3b958d1aecb6c04184356ed5a833bf6b60435777"
dependencies = [
"rustc_version",
]
[[package]]
name = "percent-encoding"
version = "2.3.2"
@@ -5526,7 +5415,6 @@ dependencies = [
"open",
"qbz-app",
"qbz-audio",
"qbz-booklet",
"qbz-cache",
"qbz-cast",
"qbz-core",
@@ -5614,14 +5502,6 @@ dependencies = [
"zbus 4.4.0",
]
[[package]]
name = "qbz-booklet"
version = "0.1.0"
dependencies = [
"log",
"mupdf",
]
[[package]]
name = "qbz-cache"
version = "0.1.0"
@@ -9627,15 +9507,6 @@ dependencies = [
"memchr",
]
[[package]]
name = "wio"
version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5d129932f4644ac2396cb456385cbf9e63b5b30c6e8dc4820bdca4eb082037a5"
dependencies = [
"winapi",
]
[[package]]
name = "wit-bindgen"
version = "0.51.0"
-1
View File
@@ -32,7 +32,6 @@ members = [
"qbz-mixtape",
"qbz-playlist-import",
"qbz-lyrics",
"qbz-booklet",
"qbz-i18n",
"qbz-music-link",
]
-25
View File
@@ -1,25 +0,0 @@
[package]
name = "qbz-booklet"
version = "0.1.0"
edition = "2021"
description = "Album booklet (PDF) rasterization for QBZ — MuPDF page render to PNG (headless, frontend-agnostic)"
authors = ["blitzkriegfc"]
[dependencies]
log = { workspace = true }
# PDF rendering with MuPDF engine (high-quality rasterization for the booklet
# viewer). This stanza is a VERBATIM port of src-tauri/Cargo.toml — the Tauri
# booklet viewer was the proven, working build, and there were cross-distro
# rendering/build issues that the feature flags below fix. Do NOT "simplify".
#
# NOTE: On Linux, use sys-lib-* for zlib/harfbuzz/freetype to avoid symbol
# conflicts with GTK/GdkPixbuf. But NOT libjpeg — Ubuntu ships libjpeg8 while
# Debian/Fedora ship libjpeg62-turbo. Let mupdf vendor its own libjpeg to avoid
# cross-distro breakage (GitHub #161, #162).
# On macOS, let mupdf vendor everything (no GTK conflicts, and system libs
# don't support x86_64 cross-compilation from Apple Silicon).
mupdf = { version = "0.6", default-features = false, features = ["system-fonts"] }
[target.'cfg(target_os = "linux")'.dependencies]
mupdf = { version = "0.6", features = ["sys-lib-zlib", "sys-lib-harfbuzz", "sys-lib-freetype"] }
-159
View File
@@ -1,159 +0,0 @@
//! Album booklet (PDF) rasterization.
//!
//! Frontend-agnostic MuPDF wrapper: open a downloaded booklet PDF, read its
//! page count + per-page sizes, and rasterize a single page to PNG bytes at a
//! given DPI/rotation. The caller owns the download + temp-file lifecycle and
//! runs these (blocking) calls off the UI thread.
//!
//! This is a faithful port of the Tauri `src-tauri/src/pdf_viewer.rs` render
//! path — the working, shipped booklet viewer. The render call deliberately
//! uses `device_rgb()` with `alpha = false` so transparent regions in the PDF
//! composite over an opaque white background instead of rendering black (the
//! rendering bug the Tauri build had to work around).
use std::io::Cursor;
use std::path::Path;
use mupdf::{Colorspace, Document, Matrix};
/// Page size in points (1/72 inch), as MuPDF reports it.
#[derive(Debug, Clone)]
pub struct PageSize {
pub width: f32,
pub height: f32,
}
/// Metadata returned when a booklet PDF is opened.
#[derive(Debug, Clone)]
pub struct BookletInfo {
pub num_pages: u32,
pub page_sizes: Vec<PageSize>,
}
/// A single rasterized page, PNG-encoded by MuPDF's own writer.
#[derive(Debug, Clone)]
pub struct RenderedPage {
/// PNG image bytes (decode with the `image` crate on the caller side).
pub png: Vec<u8>,
/// Pixel dimensions of the rendered image.
pub width: u32,
pub height: u32,
}
/// Open a booklet PDF and read its page count + per-page sizes.
///
/// Blocking (MuPDF). Run on a worker thread.
pub fn open_info(path: &Path) -> Result<BookletInfo, String> {
// Owned String so `&path_str` is `&String` (AsRef<FilePath>), matching the
// proven Tauri call — `&Cow<str>` does NOT implement AsRef<FilePath>.
let path_str = path.to_string_lossy().to_string();
let document =
Document::open(&path_str).map_err(|e| format!("Failed to open PDF: {e:?}"))?;
let num_pages = document
.page_count()
.map_err(|e| format!("Failed to get page count: {e:?}"))? as u32;
let mut page_sizes = Vec::with_capacity(num_pages as usize);
for i in 0..num_pages {
match document.load_page(i as i32) {
Ok(page) => {
let bounds = page
.bounds()
.map_err(|e| format!("Failed to get page bounds: {e:?}"))?;
page_sizes.push(PageSize {
width: bounds.width(),
height: bounds.height(),
});
}
Err(e) => {
// Fall back to US Letter so a single bad page doesn't sink the
// whole booklet (mirrors the Tauri behaviour).
log::warn!("[qbz-booklet] failed to load page {i}: {e:?}");
page_sizes.push(PageSize {
width: 612.0,
height: 792.0,
});
}
}
}
Ok(BookletInfo {
num_pages,
page_sizes,
})
}
/// Rasterize a single 1-based page to PNG bytes.
///
/// `dpi` is clamped to 36..=600 (0.5x..8.33x). `rotation` is degrees (0/90/
/// 180/270; other values are applied verbatim but only the cardinal rotations
/// get the translate correction that keeps the page in frame). The document is
/// re-opened per call so no non-`Send` MuPDF handle ever crosses threads —
/// exactly how the Tauri viewer does it.
///
/// Blocking (MuPDF). Run on a worker thread.
pub fn render_page_png(
path: &Path,
page: u32,
dpi: u32,
rotation: u32,
) -> Result<RenderedPage, String> {
// Owned String so `&path_str` is `&String` (AsRef<FilePath>), matching the
// proven Tauri call — `&Cow<str>` does NOT implement AsRef<FilePath>.
let path_str = path.to_string_lossy().to_string();
let dpi = dpi.clamp(36, 600);
let document =
Document::open(&path_str).map_err(|e| format!("Failed to open PDF: {e:?}"))?;
let page_index = page.saturating_sub(1) as i32;
let pdf_page = document
.load_page(page_index)
.map_err(|e| format!("Failed to load page {page}: {e:?}"))?;
let scale = dpi as f32 / 72.0;
let matrix = if rotation % 360 == 0 {
Matrix::new_scale(scale, scale)
} else {
let bounds = pdf_page
.bounds()
.map_err(|e| format!("Failed to get bounds: {e:?}"))?;
let w = bounds.width() * scale;
let h = bounds.height() * scale;
let mut m = Matrix::new_scale(scale, scale);
m.concat(Matrix::new_rotate(rotation as f32));
match rotation % 360 {
90 => {
m.concat(Matrix::new_translate(h, 0.0));
}
180 => {
m.concat(Matrix::new_translate(w, h));
}
270 => {
m.concat(Matrix::new_translate(0.0, w));
}
_ => {}
};
m
};
// device_rgb + alpha=false => opaque white background (the rendering
// workaround: with alpha, transparent PDF regions rasterize black).
let pixmap = pdf_page
.to_pixmap(&matrix, &Colorspace::device_rgb(), false, true)
.map_err(|e| format!("Failed to render page: {e:?}"))?;
let width = pixmap.width() as u32;
let height = pixmap.height() as u32;
let mut png = Vec::new();
let mut cursor = Cursor::new(&mut png);
pixmap
.write_to(&mut cursor, mupdf::ImageFormat::PNG)
.map_err(|e| format!("Failed to encode PNG: {e:?}"))?;
Ok(RenderedPage { png, width, height })
}
-1
View File
@@ -83,7 +83,6 @@ qbz-mixtape = { path = "../qbz-mixtape" }
qbz-playlist-import = { path = "../qbz-playlist-import" }
qbz-qobuz = { path = "../qbz-qobuz" }
qbz-lyrics = { path = "../qbz-lyrics" }
qbz-booklet = { path = "../qbz-booklet" }
# Karaoke highlight per-visual-line measurement (lyrics_measure.rs): swash is
# the SAME shaper femtovg uses to raster glyphs, so an advance pass at the same
# font + ppem + wght axis + letter-spacing matches the rendered wrap. Already in
+51 -383
View File
@@ -1,382 +1,55 @@
//! Album booklet (digital liner-notes PDF) reader controller.
//! Album booklet download.
//!
//! 1:1 port of Tauri's BookletViewer.svelte + `src-tauri/src/pdf_viewer.rs`
//! flow, split across the frontend-agnostic `qbz-booklet` crate (the MuPDF
//! rasterizer, ADR-006) and this thin UI-thread glue:
//! Booklets (digital liner-notes PDFs) are an occasional Qobuz "goody" — not
//! every album has one. We no longer render them in-app: the in-app MuPDF reader
//! was heavy (~20 MB of static MuPDF linked into the binary, plus a slow C build)
//! and clumsy to read. Instead the album-header booklet button downloads the PDF
//! to a user-chosen location for their own viewer. The fetch uses the app's HTTP
//! client, so it works whether the goody URL is public or session-scoped.
//!
//! 1. The album controller stashes the booklet goody URL via
//! [`set_current_url`] when an album loads.
//! 2. [`open`] downloads that PDF to a temp file, reads its page count, and
//! rasterizes page 1, pushing the decoded image into `BookletState`.
//! 3. Navigation / zoom / rotate re-rasterize the current page off the UI
//! thread; [`download`] copies the temp PDF to a user-chosen location;
//! [`close`] removes the temp file and clears state.
//!
//! All network + MuPDF work runs on the tokio runtime / `spawn_blocking`; only
//! the `slint::Image` build + state writes touch the event loop. The reader's
//! mutable state lives in a `thread_local` touched exclusively on the Slint
//! event loop — every worker-thread result is funnelled back through
//! `upgrade_in_event_loop` before it reads/writes that state.
//! The `AlbumBookletModal.slint` reader UI + the `BookletState`/`BookletActions`
//! globals are now unused (left in place; remove in a UI cleanup pass that
//! recompiles qbz-ui).
use std::cell::RefCell;
use std::path::{Path, PathBuf};
use std::time::Duration;
use slint::ComponentHandle;
use crate::{AppWindow, BookletState};
use crate::AppWindow;
/// Baseline render DPI at zoom 1.0. The qbz-booklet crate clamps to 36..=600,
/// so the zoom range (0.5..4.0) maps to 75..600 DPI.
const BASE_DPI: f32 = 150.0;
/// PDF download timeout, matching the Tauri viewer's client.
/// PDF download timeout (matches the former in-app reader's client).
const DOWNLOAD_TIMEOUT: Duration = Duration::from_secs(30);
/// UI-thread reader state. `thread_local` because every field is only ever
/// touched on the Slint event loop (the goody URL is stashed there by
/// `album::apply_album`, and every render is kicked from a callback that hops
/// back to the event loop before reading it).
struct Reader {
/// The booklet goody URL of the open album ("" = no booklet).
url: String,
/// The downloaded temp PDF, once `open` has fetched it.
path: Option<PathBuf>,
num_pages: u32,
/// 1-based current page.
current_page: u32,
zoom: f32,
/// Cumulative rotation in degrees (0/90/180/270).
rotation: u32,
}
impl Reader {
const fn new() -> Self {
Self {
url: String::new(),
path: None,
num_pages: 0,
current_page: 1,
zoom: 1.0,
rotation: 0,
}
}
}
thread_local! {
static READER: RefCell<Reader> = const { RefCell::new(Reader::new()) };
/// Booklet goody URL of the currently-open album ("" = no booklet). Stashed
/// by `album::apply_album`, cleared on album reset; only ever touched on the
/// Slint event loop.
static BOOKLET_URL: RefCell<String> = const { RefCell::new(String::new()) };
}
/// Stash the booklet goody URL for the currently-open album. Called from
/// `album::apply_album`; cleared by `clear_current_url` on album reset.
/// Stash the booklet goody URL for the currently-open album.
pub fn set_current_url(url: &str) {
READER.with(|cell| cell.borrow_mut().url = url.to_string());
BOOKLET_URL.with(|cell| *cell.borrow_mut() = url.to_string());
}
/// Clear the stashed booklet URL (album reset). Does NOT remove a downloaded
/// temp file — that is `close`'s job once the reader is actually opened.
/// Clear the stashed booklet URL (album reset).
pub fn clear_current_url() {
READER.with(|cell| cell.borrow_mut().url.clear());
BOOKLET_URL.with(|cell| cell.borrow_mut().clear());
}
/// DPI for the current zoom, pre-clamp (qbz-booklet re-clamps to 36..=600).
fn dpi_for(zoom: f32) -> u32 {
(BASE_DPI * zoom).round() as u32
}
/// Temp dir for downloaded booklets (mirrors Tauri's `qbz-booklets`).
fn booklet_temp_dir() -> PathBuf {
std::env::temp_dir().join("qbz-booklets")
}
/// Open the booklet reader for the current album. No-op when no booklet URL is
/// stashed. Sets the modal open + loading, then downloads the PDF, reads its
/// page info, and renders page 1. The booklet flow is a direct PDF download
/// (no Qobuz core call), so it takes no `runtime` — unlike the other
/// media-action controllers.
pub fn open(weak: slint::Weak<AppWindow>, handle: tokio::runtime::Handle) {
// Read the stashed URL + reset the per-open view state on the UI thread.
let url = READER.with(|cell| {
let mut r = cell.borrow_mut();
r.current_page = 1;
r.zoom = 1.0;
r.rotation = 0;
r.path = None;
r.num_pages = 0;
r.url.clone()
});
/// Download the current album's booklet PDF to a user-chosen location. No-op
/// when no booklet URL is stashed. Fetches with the app's HTTP client, then
/// opens a native save dialog seeded with the album title.
pub fn download_booklet(weak: slint::Weak<AppWindow>, handle: tokio::runtime::Handle) {
let url = BOOKLET_URL.with(|cell| cell.borrow().clone());
if url.is_empty() {
return;
}
let _ = weak.upgrade_in_event_loop(|w| {
// Header title = the open album's title (the modal binds
// BookletState.title; nothing in the .slint sets it).
let title = w.global::<crate::AlbumState>().get_title();
let st = w.global::<BookletState>();
st.set_title(title);
st.set_error(false);
st.set_error_text("".into());
st.set_loading(true);
st.set_current_page(1);
st.set_num_pages(0);
st.set_zoom(1.0);
st.set_rotation(0);
st.set_open(true);
});
let render_handle = handle.clone();
handle.spawn(async move {
match download_and_open(&url).await {
Ok((path, num_pages)) => {
// Hop back to the UI thread to record the path + page count,
// then kick the first render (which itself hops off-thread to
// rasterize, then back to paint).
let render_handle = render_handle.clone();
let _ = weak.upgrade_in_event_loop(move |w| {
READER.with(|cell| {
let mut r = cell.borrow_mut();
r.path = Some(path);
r.num_pages = num_pages;
});
w.global::<BookletState>().set_num_pages(num_pages as i32);
render_current(w.as_weak(), render_handle);
});
}
Err(e) => {
log::warn!("[qbz-slint] booklet open failed: {e}");
let _ = weak.upgrade_in_event_loop(move |w| {
let st = w.global::<BookletState>();
st.set_loading(false);
st.set_error(true);
st.set_error_text(e.into());
});
}
}
});
}
/// Download the PDF at `url` to a fresh temp file, then read its page count.
/// Returns the temp path + page count. Blocking MuPDF work is on
/// `spawn_blocking`. Errors are user-facing strings (shown in the modal).
async fn download_and_open(url: &str) -> Result<(PathBuf, u32), String> {
let client = reqwest::Client::builder()
.timeout(DOWNLOAD_TIMEOUT)
.build()
.map_err(|e| format!("HTTP client error: {e}"))?;
let response = client
.get(url)
.send()
.await
.map_err(|e| qbz_i18n::t_args("Failed to fetch booklet: {}", &[&e.to_string()]))?;
if !response.status().is_success() {
return Err(format!("HTTP {}", response.status()));
}
let bytes = response
.bytes()
.await
.map_err(|e| qbz_i18n::t_args("Failed to read booklet: {}", &[&e.to_string()]))?;
let temp_dir = booklet_temp_dir();
tokio::fs::create_dir_all(&temp_dir)
.await
.map_err(|e| qbz_i18n::t_args("Failed to create temp dir: {}", &[&e.to_string()]))?;
let path = temp_dir.join(format!("{}.pdf", uuid::Uuid::new_v4()));
tokio::fs::write(&path, &bytes)
.await
.map_err(|e| qbz_i18n::t_args("Failed to write booklet: {}", &[&e.to_string()]))?;
let info_path = path.clone();
let info = tokio::task::spawn_blocking(move || qbz_booklet::open_info(&info_path))
.await
.map_err(|e| qbz_i18n::t_args("Booklet open task failed: {}", &[&e.to_string()]))??;
Ok((path, info.num_pages))
}
/// Rasterize the current page (off-thread) and paint it into `BookletState`.
/// Reads the page/zoom/rotation snapshot from `READER` on the UI thread, sets
/// `loading`, then hops off to MuPDF and back. No-op when no PDF is open.
fn render_current(weak: slint::Weak<AppWindow>, handle: tokio::runtime::Handle) {
let Some((path, page, dpi, rotation, num_pages, zoom, rot)) = READER.with(|cell| {
let r = cell.borrow();
let path = r.path.clone()?;
Some((
path,
r.current_page,
dpi_for(r.zoom),
r.rotation,
r.num_pages,
r.zoom,
r.rotation,
))
}) else {
return;
};
// Reflect the snapshot the render is for, and show the spinner.
if let Some(w) = weak.upgrade() {
let st = w.global::<BookletState>();
st.set_loading(true);
st.set_current_page(page as i32);
st.set_num_pages(num_pages as i32);
st.set_zoom(zoom);
st.set_rotation(rot as i32);
}
handle.spawn(async move {
let result = tokio::task::spawn_blocking(move || {
render_page_rgba(&path, page, dpi, rotation)
})
.await;
match result {
Ok(Ok((pixels, width, height))) => {
let _ = weak.upgrade_in_event_loop(move |w| {
let image = crate::artwork::pixels_to_image(&pixels, width, height);
let st = w.global::<BookletState>();
st.set_page_image(image);
st.set_page_pixel_width(width as i32);
st.set_page_pixel_height(height as i32);
st.set_loading(false);
st.set_error(false);
});
}
Ok(Err(e)) => {
log::warn!("[qbz-slint] booklet render failed: {e}");
let _ = weak.upgrade_in_event_loop(move |w| {
let st = w.global::<BookletState>();
st.set_loading(false);
st.set_error(true);
st.set_error_text(e.into());
});
}
Err(e) => {
log::warn!("[qbz-slint] booklet render task failed: {e}");
let _ = weak.upgrade_in_event_loop(|w| {
w.global::<BookletState>().set_loading(false);
});
}
}
});
}
/// Rasterize one page to RGBA8 pixels. Blocking (MuPDF + PNG decode); call from
/// `spawn_blocking`. The qbz-booklet crate emits PNG bytes, decoded here with
/// the `image` crate (mirrors `album::apply_artwork`'s RGBA path).
fn render_page_rgba(
path: &Path,
page: u32,
dpi: u32,
rotation: u32,
) -> Result<(Vec<u8>, u32, u32), String> {
let rendered = qbz_booklet::render_page_png(path, page, dpi, rotation)?;
let rgba = image::load_from_memory(&rendered.png)
.map_err(|e| qbz_i18n::t_args("Failed to decode booklet page: {}", &[&e.to_string()]))?
.to_rgba8();
let (width, height) = rgba.dimensions();
Ok((rgba.into_raw(), width, height))
}
/// Advance to the next page (clamped to `num_pages`) and re-render.
pub fn next_page(weak: slint::Weak<AppWindow>, handle: tokio::runtime::Handle) {
let changed = READER.with(|cell| {
let mut r = cell.borrow_mut();
if r.num_pages > 0 && r.current_page < r.num_pages {
r.current_page += 1;
true
} else {
false
}
});
if changed {
render_current(weak, handle);
}
}
/// Step back to the previous page (clamped to 1) and re-render.
pub fn prev_page(weak: slint::Weak<AppWindow>, handle: tokio::runtime::Handle) {
let changed = READER.with(|cell| {
let mut r = cell.borrow_mut();
if r.current_page > 1 {
r.current_page -= 1;
true
} else {
false
}
});
if changed {
render_current(weak, handle);
}
}
/// Zoom in (x1.25, capped at 4.0) and re-render at the higher DPI.
pub fn zoom_in(weak: slint::Weak<AppWindow>, handle: tokio::runtime::Handle) {
let changed = READER.with(|cell| {
let mut r = cell.borrow_mut();
let next = (r.zoom * 1.25).min(4.0);
if (next - r.zoom).abs() > f32::EPSILON {
r.zoom = next;
true
} else {
false
}
});
if changed {
render_current(weak, handle);
}
}
/// Zoom out (/1.25, floored at 0.5) and re-render at the lower DPI.
pub fn zoom_out(weak: slint::Weak<AppWindow>, handle: tokio::runtime::Handle) {
let changed = READER.with(|cell| {
let mut r = cell.borrow_mut();
let next = (r.zoom / 1.25).max(0.5);
if (next - r.zoom).abs() > f32::EPSILON {
r.zoom = next;
true
} else {
false
}
});
if changed {
render_current(weak, handle);
}
}
/// Reset zoom to the fit-width baseline (1.0) and re-render.
pub fn fit_width(weak: slint::Weak<AppWindow>, handle: tokio::runtime::Handle) {
let changed = READER.with(|cell| {
let mut r = cell.borrow_mut();
if (r.zoom - 1.0).abs() > f32::EPSILON {
r.zoom = 1.0;
true
} else {
false
}
});
if changed {
render_current(weak, handle);
}
}
/// Rotate the page by 90° (cumulative, mod 360) and re-render.
pub fn rotate(weak: slint::Weak<AppWindow>, handle: tokio::runtime::Handle) {
READER.with(|cell| {
let mut r = cell.borrow_mut();
r.rotation = (r.rotation + 90) % 360;
});
render_current(weak, handle);
}
/// Save the open booklet PDF to a user-chosen location (best-effort). Opens a
/// native save dialog seeded with the album title, then copies the temp file.
pub fn download(weak: slint::Weak<AppWindow>, handle: tokio::runtime::Handle) {
let path = READER.with(|cell| cell.borrow().path.clone());
let Some(path) = path else {
return;
};
let default_name = weak
.upgrade()
.map(|w| {
let title = w.global::<BookletState>().get_title().to_string();
let title = w.global::<crate::AlbumState>().get_title().to_string();
if title.is_empty() {
"booklet.pdf".to_string()
} else {
@@ -386,6 +59,29 @@ pub fn download(weak: slint::Weak<AppWindow>, handle: tokio::runtime::Handle) {
.unwrap_or_else(|| "booklet.pdf".to_string());
handle.spawn(async move {
let client = match reqwest::Client::builder().timeout(DOWNLOAD_TIMEOUT).build() {
Ok(c) => c,
Err(e) => {
log::warn!("[qbz-slint] booklet HTTP client error: {e}");
return;
}
};
let resp = match client.get(&url).send().await.and_then(|r| r.error_for_status()) {
Ok(r) => r,
Err(e) => {
log::warn!("[qbz-slint] booklet fetch failed: {e}");
return;
}
};
let bytes = match resp.bytes().await {
Ok(b) => b,
Err(e) => {
log::warn!("[qbz-slint] booklet read failed: {e}");
return;
}
};
// Native "save as" dialog seeded with the album title; cancel = no-op.
let Some(dest) = rfd::AsyncFileDialog::new()
.set_file_name(&default_name)
.add_filter("PDF", &["pdf"])
@@ -394,36 +90,8 @@ pub fn download(weak: slint::Weak<AppWindow>, handle: tokio::runtime::Handle) {
else {
return;
};
if let Err(e) = tokio::fs::copy(&path, dest.path()).await {
log::warn!("[qbz-slint] booklet download copy failed: {e}");
if let Err(e) = tokio::fs::write(dest.path(), &bytes).await {
log::warn!("[qbz-slint] booklet save failed: {e}");
}
});
}
/// Close the reader: hide the modal, remove the temp PDF (best-effort), and
/// clear the per-open view state. Runs on the UI thread (the callback site).
pub fn close(window: &AppWindow) {
let st = window.global::<BookletState>();
st.set_open(false);
st.set_loading(false);
st.set_error(false);
st.set_error_text("".into());
st.set_page_image(slint::Image::default());
st.set_page_pixel_width(0);
st.set_page_pixel_height(0);
st.set_current_page(1);
st.set_num_pages(0);
st.set_zoom(1.0);
st.set_rotation(0);
READER.with(|cell| {
let mut r = cell.borrow_mut();
if let Some(path) = r.path.take() {
let _ = std::fs::remove_file(&path);
}
r.num_pages = 0;
r.current_page = 1;
r.zoom = 1.0;
r.rotation = 0;
});
}
+9 -66
View File
@@ -7735,12 +7735,12 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
);
}
}
// Album booklet (digital liner-notes PDF) — opened from the
// album header booklet button. Downloads + rasterizes the goody
// PDF stashed by album::apply_album; the BookletState gate keeps
// it a no-op when the album bundles no booklet.
// Album booklet (digital liner-notes PDF) — the album-header
// booklet button DOWNLOADS the goody PDF (stashed by
// album::apply_album) to a user-chosen location. No-op when the
// album bundles no booklet (empty stashed URL).
("album", "booklet") => {
crate::booklet::open(weak.clone(), handle.clone());
crate::booklet::download_booklet(weak.clone(), handle.clone());
}
// "From the same artist" carousel "View all" — open the artist's
// full Albums discography page. `id` is the artist id; reuse the
@@ -10036,67 +10036,10 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
}
});
// Booklet reader controls (BookletActions) — paging / zoom / rotate
// re-rasterize the current page off-thread; close removes the temp PDF.
{
let weak = window.as_weak();
window
.global::<BookletActions>()
.on_close(move || {
if let Some(w) = weak.upgrade() {
crate::booklet::close(&w);
}
});
}
{
let weak = window.as_weak();
let handle = tokio_rt.handle().clone();
window
.global::<BookletActions>()
.on_next_page(move || crate::booklet::next_page(weak.clone(), handle.clone()));
}
{
let weak = window.as_weak();
let handle = tokio_rt.handle().clone();
window
.global::<BookletActions>()
.on_prev_page(move || crate::booklet::prev_page(weak.clone(), handle.clone()));
}
{
let weak = window.as_weak();
let handle = tokio_rt.handle().clone();
window
.global::<BookletActions>()
.on_zoom_in(move || crate::booklet::zoom_in(weak.clone(), handle.clone()));
}
{
let weak = window.as_weak();
let handle = tokio_rt.handle().clone();
window
.global::<BookletActions>()
.on_zoom_out(move || crate::booklet::zoom_out(weak.clone(), handle.clone()));
}
{
let weak = window.as_weak();
let handle = tokio_rt.handle().clone();
window
.global::<BookletActions>()
.on_fit_width(move || crate::booklet::fit_width(weak.clone(), handle.clone()));
}
{
let weak = window.as_weak();
let handle = tokio_rt.handle().clone();
window
.global::<BookletActions>()
.on_rotate(move || crate::booklet::rotate(weak.clone(), handle.clone()));
}
{
let weak = window.as_weak();
let handle = tokio_rt.handle().clone();
window
.global::<BookletActions>()
.on_download(move || crate::booklet::download(weak.clone(), handle.clone()));
}
// Booklet reader removed — the album booklet button now downloads the PDF
// (booklet::download_booklet via the ("album","booklet") media action). The
// BookletActions/BookletState globals + AlbumBookletModal.slint are unused
// now (left in place; remove in a UI cleanup pass that recompiles qbz-ui).
// Artist in-page search — client-side filter over Popular Tracks
// and every release-section album.