Add a saved custom picture for blank presentation output
This commit is contained in:
parent
2dadf99ee0
commit
68e1d2639d
|
|
@ -2245,7 +2245,7 @@ dependencies = [
|
|||
|
||||
[[package]]
|
||||
name = "pdf-presenter"
|
||||
version = "0.1.76"
|
||||
version = "0.1.77"
|
||||
dependencies = [
|
||||
"bytemuck",
|
||||
"chrono",
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@ default-members = ["crates/pdf-presenter"]
|
|||
resolver = "3"
|
||||
|
||||
[workspace.package]
|
||||
version = "0.1.76"
|
||||
version = "0.1.77"
|
||||
edition = "2024"
|
||||
license = "MIT"
|
||||
repository = "https://proxy.dandaedre.com/gitea/idle-org/pdf-presenter"
|
||||
|
|
|
|||
|
|
@ -0,0 +1,122 @@
|
|||
//! Bounded, worker-only preparation of the optional blank-screen picture.
|
||||
use crate::{
|
||||
document::{Frame, FrameInfo},
|
||||
worker::{Bridge, Request},
|
||||
};
|
||||
use sha2::{Digest, Sha256};
|
||||
use std::{
|
||||
path::{Path, PathBuf},
|
||||
sync::Arc,
|
||||
time::Duration,
|
||||
};
|
||||
|
||||
const EDGE: u32 = 2048;
|
||||
const MAX_RGBA: usize = EDGE as usize * EDGE as usize * 4;
|
||||
|
||||
/// Copy/normalize a selected image, or load the existing managed copy.
|
||||
/// Call only in a supervised worker (or tests), never on an input/UI path.
|
||||
pub fn prepare(source: Option<&Path>, path: &Path) -> Result<Frame, String> {
|
||||
if let Some(source) = source {
|
||||
let bytes = crate::document::read_limited(source, 64 * 1024 * 1024)?;
|
||||
let mut reader = image::ImageReader::new(std::io::Cursor::new(bytes))
|
||||
.with_guessed_format()
|
||||
.map_err(|e| e.to_string())?;
|
||||
let mut limits = image::Limits::default();
|
||||
limits.max_alloc = Some(256 * 1024 * 1024);
|
||||
limits.max_image_width = Some(32768);
|
||||
limits.max_image_height = Some(32768);
|
||||
reader.limits(limits);
|
||||
let image = reader.decode().map_err(|e| e.to_string())?;
|
||||
let image = if image.width() > EDGE || image.height() > EDGE {
|
||||
image.resize(EDGE, EDGE, image::imageops::FilterType::Triangle)
|
||||
} else {
|
||||
image
|
||||
}
|
||||
.to_rgba8();
|
||||
let mut data = Vec::with_capacity(image.len() + 40);
|
||||
data.extend(image.width().to_le_bytes());
|
||||
data.extend(image.height().to_le_bytes());
|
||||
data.extend(image.as_raw());
|
||||
data.extend(Sha256::digest(&data));
|
||||
crate::settings::atomic_write(path, &data)?;
|
||||
}
|
||||
let data = crate::document::read_limited(path, (MAX_RGBA + 40) as u64)?;
|
||||
if data.len() < 40 {
|
||||
return Err("Truncated blank picture".into());
|
||||
}
|
||||
let width = u32::from_le_bytes(data[..4].try_into().unwrap());
|
||||
let height = u32::from_le_bytes(data[4..8].try_into().unwrap());
|
||||
crate::document::validate_frame(width, height, data.len() - 40)?;
|
||||
if width > EDGE || height > EDGE {
|
||||
return Err("Blank picture exceeds 2048 pixels per edge".into());
|
||||
}
|
||||
let end = data.len() - 32;
|
||||
let hash = Sha256::digest(&data[..end]);
|
||||
if hash.as_slice() != &data[end..] {
|
||||
return Err("Blank picture checksum mismatch".into());
|
||||
}
|
||||
Ok(Frame {
|
||||
info: FrameInfo {
|
||||
page: 0,
|
||||
width,
|
||||
height,
|
||||
path: path.into(),
|
||||
sha256: format!("{hash:x}"),
|
||||
},
|
||||
rgba: data[8..end].to_vec(),
|
||||
})
|
||||
}
|
||||
|
||||
/// Output-side loading is independent of slide reads and never reports a picture as a slide.
|
||||
#[derive(Default)]
|
||||
pub struct Output {
|
||||
requested: Option<FrameInfo>,
|
||||
loader: Option<Bridge>,
|
||||
pub picture: Option<Arc<Frame>>,
|
||||
}
|
||||
impl Output {
|
||||
pub fn set(&mut self, info: Option<&FrameInfo>) -> bool {
|
||||
if self.requested.as_ref().map(identity) == info.map(identity) {
|
||||
return false;
|
||||
}
|
||||
self.requested = info.cloned();
|
||||
self.picture = None;
|
||||
self.loader = info.map(|info| {
|
||||
let loader = Bridge::new(Duration::from_secs(10));
|
||||
loader.submit(
|
||||
0,
|
||||
0,
|
||||
Request::BlankPicture {
|
||||
source: None,
|
||||
path: info.path.clone(),
|
||||
},
|
||||
);
|
||||
loader
|
||||
});
|
||||
true
|
||||
}
|
||||
pub fn poll(&mut self) -> Option<Result<(), String>> {
|
||||
let completion = self.loader.as_ref()?.rx.try_recv().ok()?;
|
||||
self.loader = None;
|
||||
Some((|| {
|
||||
let packet = completion.result?;
|
||||
if let Some(error) = packet.reply.error {
|
||||
return Err(error);
|
||||
}
|
||||
let info = packet.reply.frame.ok_or("Missing blank picture")?;
|
||||
if self.requested.as_ref().map(identity) != Some(identity(&info)) {
|
||||
return Err(
|
||||
"Blank picture changed while loading; choose it again to retry.".into(),
|
||||
);
|
||||
}
|
||||
self.picture = Some(Arc::new(Frame {
|
||||
info,
|
||||
rgba: packet.data,
|
||||
}));
|
||||
Ok(())
|
||||
})())
|
||||
}
|
||||
}
|
||||
fn identity(info: &FrameInfo) -> (&PathBuf, &str, u32, u32) {
|
||||
(&info.path, &info.sha256, info.width, info.height)
|
||||
}
|
||||
|
|
@ -101,3 +101,6 @@ pub mod cache;
|
|||
|
||||
/// Bounded held-input slide navigation.
|
||||
pub mod navigation;
|
||||
|
||||
/// Optional custom blank-screen picture.
|
||||
pub mod blank;
|
||||
|
|
|
|||
|
|
@ -233,7 +233,8 @@ impl NativeWindow {
|
|||
setup.route_trial.is_some(),
|
||||
);
|
||||
}
|
||||
if !blank && let Some(frame) = frame {
|
||||
if let Some(frame) = frame {
|
||||
let setup = if blank { None } else { setup };
|
||||
use std::hash::{Hash, Hasher};
|
||||
let mut hash = std::hash::DefaultHasher::new();
|
||||
frame.info.path.hash(&mut hash);
|
||||
|
|
@ -289,7 +290,12 @@ impl NativeWindow {
|
|||
ui.max_rect(),
|
||||
tex.id(),
|
||||
[frame.info.width, frame.info.height],
|
||||
setup.map(|s| s.slide_colors).unwrap_or_default(),
|
||||
setup
|
||||
.map(|s| s.slide_colors)
|
||||
.unwrap_or(crate::settings::SlideColors {
|
||||
page_background: [0; 3],
|
||||
fit_padding: [0; 3],
|
||||
}),
|
||||
crate::zoom::Sync {
|
||||
view,
|
||||
..setup.map(|s| s.zoom).unwrap_or_default()
|
||||
|
|
@ -441,6 +447,7 @@ struct Host {
|
|||
commands: Receiver<HostState>,
|
||||
acks: SyncSender<Ack>,
|
||||
state: HostState,
|
||||
blank: crate::blank::Output,
|
||||
reader: Bridge,
|
||||
reading: Option<std::path::PathBuf>,
|
||||
cache: HashMap<std::path::PathBuf, Arc<Frame>>,
|
||||
|
|
@ -859,7 +866,11 @@ impl App {
|
|||
repaint |= !actions.is_empty();
|
||||
for action in actions {
|
||||
#[cfg(target_os = "windows")]
|
||||
if matches!(action, Action::Pick(_) | Action::PickNotes) && !s.dialog_busy {
|
||||
if matches!(
|
||||
action,
|
||||
Action::Pick(_) | Action::PickNotes | Action::PickBlankPicture
|
||||
) && !s.dialog_busy
|
||||
{
|
||||
use winit::raw_window_handle::{HasWindowHandle, RawWindowHandle};
|
||||
s.dialog_owner = self
|
||||
.windows
|
||||
|
|
@ -979,6 +990,7 @@ impl App {
|
|||
monitors: s.routes.presentation.clone(),
|
||||
fullscreen: s.presentation_fullscreen(),
|
||||
blanked: s.blanked,
|
||||
blank_picture: s.blank_picture.as_ref().map(|f| f.info.clone()),
|
||||
..Default::default()
|
||||
};
|
||||
if output.tx.try_send(state).is_ok() {
|
||||
|
|
@ -1091,8 +1103,22 @@ impl App {
|
|||
if state.monitors.is_empty() {
|
||||
host.frame = None;
|
||||
}
|
||||
if host.blank.set(state.blank_picture.as_ref()) {
|
||||
for w in &mut self.windows {
|
||||
w.ui.textures.clear();
|
||||
}
|
||||
}
|
||||
host.state = state;
|
||||
}
|
||||
if let Some(result) = host.blank.poll() {
|
||||
repaint = true;
|
||||
if let Err(error) = result {
|
||||
let _ = host.acks.try_send(Ack {
|
||||
status: format!("Blank picture: {error}"),
|
||||
..Default::default()
|
||||
});
|
||||
}
|
||||
}
|
||||
if host.zoom_pending && host.parent_connected && Instant::now() >= host.next_zoom_ack {
|
||||
let _ = host.acks.try_send(Ack {
|
||||
zoom: Some(host.state.zoom),
|
||||
|
|
@ -1374,7 +1400,13 @@ impl ApplicationHandler for App {
|
|||
self.windows[index].window.request_redraw()
|
||||
}
|
||||
WindowEvent::RedrawRequested => {
|
||||
let frame = self.host.as_ref().and_then(|h| h.frame.clone());
|
||||
let frame = self.host.as_ref().and_then(|h| {
|
||||
if h.state.blanked {
|
||||
h.blank.picture.clone()
|
||||
} else {
|
||||
h.frame.clone()
|
||||
}
|
||||
});
|
||||
let blank = self.host.as_ref().is_none_or(|h| h.state.blanked);
|
||||
let result = self.windows[index].render(
|
||||
self.studio.as_mut(),
|
||||
|
|
@ -1598,6 +1630,7 @@ pub fn run_output() -> Result<(), Failure> {
|
|||
commands,
|
||||
acks,
|
||||
state: Default::default(),
|
||||
blank: Default::default(),
|
||||
reader: Bridge::new(Duration::from_secs(10)),
|
||||
reading: None,
|
||||
cache: HashMap::new(),
|
||||
|
|
@ -1864,6 +1897,7 @@ mod buffer_tests {
|
|||
blanked: false,
|
||||
..Default::default()
|
||||
},
|
||||
blank: Default::default(),
|
||||
reader: Bridge::new(Duration::from_secs(10)),
|
||||
reading: None,
|
||||
cache: HashMap::new(),
|
||||
|
|
|
|||
|
|
@ -48,6 +48,8 @@ pub struct HostState {
|
|||
pub monitors: Vec<String>,
|
||||
pub fullscreen: bool,
|
||||
pub blanked: bool,
|
||||
#[serde(default)]
|
||||
pub blank_picture: Option<FrameInfo>,
|
||||
pub quit: bool,
|
||||
}
|
||||
/// Actual size of the reference presentation window, never presenter content.
|
||||
|
|
|
|||
|
|
@ -2409,6 +2409,20 @@ fn menu(ui: &mut Ui, s: &mut Studio) {
|
|||
ui.menu_button(tr(&locale,"Preferences"), |ui| {
|
||||
ui.with_layout(egui::Layout::top_down(egui::Align::Min), |ui| {
|
||||
ui.set_width(370.);
|
||||
ui.collapsing(if s.settings.language.french() { "Image de présentation masquée" } else { "Blank presentation" }, |ui| {
|
||||
ui.label(if s.settings.blank_picture {
|
||||
if s.settings.language.french() { "Image personnalisée sélectionnée" } else { "Custom picture selected" }
|
||||
} else if s.settings.language.french() { "Écran noir" } else { "Solid black" });
|
||||
if ui.add_enabled(s.initialized && !s.dialog_busy && !s.blank_busy, egui::Button::new(if s.settings.language.french() { "Choisir une image…" } else { "Choose picture…" })).clicked() {
|
||||
s.actions.push(Action::PickBlankPicture);
|
||||
}
|
||||
if ui.add_enabled(s.initialized && !s.dialog_busy && (s.settings.blank_picture || s.blank_busy), egui::Button::new(if s.settings.language.french() { "Utiliser un écran noir" } else { "Use solid black" })).clicked() {
|
||||
s.actions.push(Action::ClearBlankPicture);
|
||||
}
|
||||
ui.small(if s.settings.language.french() { "Une copie est conservée et ajustée à tous les écrans de présentation, sur fond noir." } else { "A copy is saved and fitted to all presentation displays against a black background." });
|
||||
if s.blank_busy { ui.spinner(); }
|
||||
});
|
||||
ui.separator();
|
||||
let mut enabled = s.settings.zoom_enabled;
|
||||
if ui.checkbox(&mut enabled, tr(&locale, "Enable page zoom")).changed() { s.enable_zoom(enabled); }
|
||||
if ui.checkbox(&mut s.settings.zoom_keep_fitted_area, tr(&locale, "Keep fitted page area when zooming")).changed() {
|
||||
|
|
|
|||
|
|
@ -234,6 +234,7 @@ pub struct Settings {
|
|||
pub buffer_mib: u32,
|
||||
pub disk_cache: crate::cache::Policy,
|
||||
pub auto_show: bool,
|
||||
pub blank_picture: bool,
|
||||
pub zoom_enabled: bool,
|
||||
pub zoom_keep_fitted_area: bool,
|
||||
pub theme: crate::theme::Theme,
|
||||
|
|
@ -279,6 +280,7 @@ impl Default for Settings {
|
|||
buffer_mib: default_buffer_mib(),
|
||||
disk_cache: Default::default(),
|
||||
auto_show: true,
|
||||
blank_picture: false,
|
||||
zoom_enabled: false,
|
||||
zoom_keep_fitted_area: false,
|
||||
theme: Default::default(),
|
||||
|
|
|
|||
|
|
@ -22,6 +22,9 @@ pub enum Action {
|
|||
Open(PathBuf),
|
||||
Pick(bool),
|
||||
PickNotes,
|
||||
PickBlankPicture,
|
||||
SetBlankPicture(PathBuf),
|
||||
ClearBlankPicture,
|
||||
ImportNotes(PathBuf),
|
||||
ApplyNotesImport,
|
||||
Go(usize),
|
||||
|
|
@ -105,6 +108,9 @@ pub struct Studio {
|
|||
pub requested: usize,
|
||||
pub displayed: Option<usize>,
|
||||
pub blanked: bool,
|
||||
pub blank_picture: Option<Arc<Frame>>,
|
||||
pub blank_busy: bool,
|
||||
blank_loader: Bridge,
|
||||
pub status: String,
|
||||
pub awake_status: String,
|
||||
pub generation: u64,
|
||||
|
|
@ -215,6 +221,9 @@ impl Studio {
|
|||
requested: 0,
|
||||
displayed: None,
|
||||
blanked: false,
|
||||
blank_picture: None,
|
||||
blank_busy: false,
|
||||
blank_loader: Bridge::with_program(Duration::from_secs(15), worker_program.clone()),
|
||||
status: "Ready — open a PDF or picture folder, or drop it here.".into(),
|
||||
awake_status: "Sleep protection starting…".into(),
|
||||
generation: 0,
|
||||
|
|
@ -424,6 +433,32 @@ impl Studio {
|
|||
self.pending_open = Some(path);
|
||||
self.status = "Opening document in an isolated worker…".into();
|
||||
}
|
||||
Action::PickBlankPicture => {
|
||||
if self.initialized && !self.dialog_busy && !self.blank_busy {
|
||||
self.dialog_busy = self.dialog.submit(
|
||||
0,
|
||||
2,
|
||||
Request::PickBlankPicture {
|
||||
owner: self.dialog_owner,
|
||||
},
|
||||
);
|
||||
}
|
||||
}
|
||||
Action::SetBlankPicture(path) => {
|
||||
if self.initialized && !self.blank_busy {
|
||||
self.load_blank_picture(Some(path));
|
||||
}
|
||||
}
|
||||
Action::ClearBlankPicture => {
|
||||
self.blank_loader =
|
||||
Bridge::with_program(Duration::from_secs(15), self.worker_program.clone());
|
||||
self.blank_busy = false;
|
||||
self.blank_picture = None;
|
||||
self.settings.blank_picture = false;
|
||||
self.new_output = true;
|
||||
self.pending_save = true;
|
||||
self.status = "Blank presentation uses solid black.".into();
|
||||
}
|
||||
Action::PickNotes => {
|
||||
if !self.dialog_busy
|
||||
&& !self.loading
|
||||
|
|
@ -895,7 +930,38 @@ impl Studio {
|
|||
pub fn remember_cache_policy(&mut self) {
|
||||
self.save_preferences();
|
||||
}
|
||||
fn load_blank_picture(&mut self, source: Option<PathBuf>) {
|
||||
let path = self.settings_path.with_file_name("blank-picture.rgba");
|
||||
self.blank_busy = self.blank_loader.submit(
|
||||
0,
|
||||
u64::from(source.is_some()),
|
||||
Request::BlankPicture { source, path },
|
||||
);
|
||||
if self.blank_busy {
|
||||
self.status = "Preparing blank presentation picture…".into();
|
||||
}
|
||||
}
|
||||
pub fn poll(&mut self) {
|
||||
while let Ok(c) = self.blank_loader.rx.try_recv() {
|
||||
self.blank_busy = false;
|
||||
let result = c.result.and_then(|p| {
|
||||
if let Some(error) = p.reply.error {
|
||||
return Err(error);
|
||||
}
|
||||
let info = p.reply.frame.ok_or("Missing blank picture")?;
|
||||
Ok(Arc::new(Frame { info, rgba: p.data }))
|
||||
});
|
||||
match result {
|
||||
Ok(frame) => {
|
||||
self.blank_picture = Some(frame);
|
||||
self.settings.blank_picture = true;
|
||||
self.pending_save |= c.tag == 1;
|
||||
self.new_output = true;
|
||||
self.status = "Blank presentation picture ready.".into();
|
||||
}
|
||||
Err(error) => self.status = format!("Blank picture: {error}"),
|
||||
}
|
||||
}
|
||||
while let Ok(c) = self.cache_io.rx.try_recv() {
|
||||
self.cache_busy = false;
|
||||
self.cache_status = match c.result {
|
||||
|
|
@ -991,6 +1057,9 @@ impl Studio {
|
|||
if !self.smoke {
|
||||
self.blanked = !settings.auto_show;
|
||||
self.settings = settings;
|
||||
if self.settings.blank_picture {
|
||||
self.load_blank_picture(None);
|
||||
}
|
||||
self.set_zoom(crate::zoom::View::default());
|
||||
self.layout = self.settings.for_project(&self.project());
|
||||
self.presenter_views.clear();
|
||||
|
|
@ -1028,7 +1097,9 @@ impl Studio {
|
|||
match c.result {
|
||||
Ok(p) => {
|
||||
if let Some(path) = p.reply.picked {
|
||||
if c.tag == 1 {
|
||||
if c.tag == 2 {
|
||||
self.execute(Action::SetBlankPicture(path));
|
||||
} else if c.tag == 1 {
|
||||
if c.generation == self.generation {
|
||||
self.execute(Action::ImportNotes(path));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -46,6 +46,13 @@ pub enum Request {
|
|||
source_sha: String,
|
||||
preview: crate::notes::ImportPreview,
|
||||
},
|
||||
PickBlankPicture {
|
||||
owner: Option<isize>,
|
||||
},
|
||||
BlankPicture {
|
||||
source: Option<PathBuf>,
|
||||
path: PathBuf,
|
||||
},
|
||||
PickNotes {
|
||||
owner: Option<isize>,
|
||||
},
|
||||
|
|
@ -252,6 +259,19 @@ pub fn run() -> Result<(), String> {
|
|||
preview,
|
||||
)?);
|
||||
}
|
||||
Request::PickBlankPicture { owner } => {
|
||||
reply.picked = picker_dialog(owner)?
|
||||
.add_filter(
|
||||
"Picture",
|
||||
&["png", "jpg", "jpeg", "webp", "bmp", "gif", "tif", "tiff"],
|
||||
)
|
||||
.pick_file();
|
||||
}
|
||||
Request::BlankPicture { source, path } => {
|
||||
let frame = crate::blank::prepare(source.as_deref(), &path)?;
|
||||
reply.frame = Some(frame.info);
|
||||
data = frame.rgba;
|
||||
}
|
||||
Request::PickNotes { owner } => {
|
||||
reply.picked = picker_dialog(owner)?
|
||||
.add_filter("Notes (TXT, Markdown)", &["txt", "md"])
|
||||
|
|
|
|||
|
|
@ -0,0 +1,71 @@
|
|||
mod common;
|
||||
use pdf_presenter::{
|
||||
blank,
|
||||
studio::{Action, Studio},
|
||||
};
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
#[test]
|
||||
fn managed_picture_is_bounded_durable_and_checked() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let source = dir.path().join("source.png");
|
||||
let target = dir.path().join("blank-picture.rgba");
|
||||
image::RgbaImage::from_pixel(3000, 1500, image::Rgba([10u8, 20, 30, 128]))
|
||||
.save(&source)
|
||||
.unwrap();
|
||||
let original = std::fs::read(&source).unwrap();
|
||||
let frame = blank::prepare(Some(&source), &target).unwrap();
|
||||
assert_eq!((frame.info.width, frame.info.height), (2048, 1024));
|
||||
assert_eq!(original, std::fs::read(&source).unwrap());
|
||||
std::fs::remove_file(&source).unwrap();
|
||||
assert_eq!(blank::prepare(None, &target).unwrap().rgba, frame.rgba);
|
||||
assert!(blank::prepare(Some(&source), &target).is_err());
|
||||
assert_eq!(
|
||||
blank::prepare(None, &target).unwrap().info.sha256,
|
||||
frame.info.sha256
|
||||
);
|
||||
let mut data = std::fs::read(&target).unwrap();
|
||||
data[8] ^= 1;
|
||||
std::fs::write(&target, data).unwrap();
|
||||
assert!(
|
||||
blank::prepare(None, &target)
|
||||
.err()
|
||||
.unwrap()
|
||||
.contains("checksum")
|
||||
);
|
||||
std::fs::write(&target, b"bad").unwrap();
|
||||
assert!(blank::prepare(None, &target).is_err());
|
||||
}
|
||||
|
||||
fn until(s: &mut Studio, done: impl Fn(&Studio) -> bool) {
|
||||
let deadline = Instant::now() + Duration::from_secs(10);
|
||||
while !done(s) {
|
||||
assert!(Instant::now() < deadline, "{}", s.status);
|
||||
s.poll();
|
||||
std::thread::sleep(Duration::from_millis(5));
|
||||
}
|
||||
}
|
||||
#[test]
|
||||
fn worker_import_failure_and_clear_preserve_blank_state() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let source = dir.path().join("picture.png");
|
||||
common::image(&source, [20, 50, 90, 255]);
|
||||
let mut s = Studio::with_program(true, None, env!("CARGO_BIN_EXE_pdf-presenter").into());
|
||||
until(&mut s, |s| s.initialized);
|
||||
s.blanked = true;
|
||||
s.execute(Action::SetBlankPicture(source.clone()));
|
||||
until(&mut s, |s| !s.blank_busy);
|
||||
assert!(s.settings.blank_picture && s.blanked);
|
||||
let hash = s.blank_picture.as_ref().unwrap().info.sha256.clone();
|
||||
std::fs::remove_file(source.clone()).unwrap();
|
||||
s.execute(Action::SetBlankPicture(source));
|
||||
until(&mut s, |s| !s.blank_busy);
|
||||
assert_eq!(s.blank_picture.as_ref().unwrap().info.sha256, hash);
|
||||
assert!(s.blanked);
|
||||
let encoded = toml::to_string(&s.settings).unwrap();
|
||||
let decoded: pdf_presenter::settings::Settings = toml::from_str(&encoded).unwrap();
|
||||
assert!(decoded.blank_picture);
|
||||
s.execute(Action::ClearBlankPicture);
|
||||
assert!(s.blanked && s.blank_picture.is_none() && !s.settings.blank_picture);
|
||||
assert!(!pdf_presenter::settings::Settings::default().blank_picture);
|
||||
}
|
||||
|
|
@ -109,6 +109,11 @@ fn independent_output_acknowledges_frames_and_blanking() {
|
|||
}
|
||||
let doc = Document::open(temp.path(), temp.path().join("cache")).unwrap();
|
||||
let frames: Vec<_> = (0..8).map(|page| doc.render(page, 320).unwrap()).collect();
|
||||
let blank_picture = pdf_presenter::blank::prepare(
|
||||
Some(&temp.path().join("slide0.png")),
|
||||
&temp.path().join("blank-picture.rgba"),
|
||||
)
|
||||
.unwrap();
|
||||
struct ChildGuard(std::process::Child);
|
||||
impl Drop for ChildGuard {
|
||||
fn drop(&mut self) {
|
||||
|
|
@ -223,6 +228,7 @@ fn independent_output_acknowledges_frames_and_blanking() {
|
|||
monitors: vec![monitor.clone()],
|
||||
fullscreen: false,
|
||||
blanked,
|
||||
blank_picture: Some(blank_picture.info.clone()),
|
||||
..Default::default()
|
||||
},
|
||||
)
|
||||
|
|
|
|||
|
|
@ -2,6 +2,19 @@
|
|||
|
||||
## Unreleased
|
||||
|
||||
### 0.1.77
|
||||
|
||||
- Add an optional custom picture for Blank presentation in Preferences, shared by
|
||||
all audience displays, with a control to restore solid black.
|
||||
- Save a bounded managed copy independently of the slide cache; load and decode
|
||||
in supervised workers. Fit it against black without slide zoom or annotations.
|
||||
Failed imports retain the previous choice; unavailable saved pictures fall back
|
||||
to black without exposing slides.
|
||||
- Linux workspace/native tests, 13 Python tests, formatting, Clippy, rustdoc and
|
||||
optimized build pass; whole-application line coverage is 84.56%. Windows and
|
||||
physical-display acceptance remain pending for this change.
|
||||
|
||||
|
||||
### 0.1.76
|
||||
|
||||
- Give every presenter display its own complete visual layout, presets, local
|
||||
|
|
|
|||
|
|
@ -0,0 +1,28 @@
|
|||
# Managed blank picture v1
|
||||
|
||||
One optional asset lives at `blank-picture.rgba` next to settings.toml. Settings v1
|
||||
`blank_picture` selects it; missing/false means solid black. It is independent of
|
||||
document caches and their cleanup. Reset disables the asset, retaining at most
|
||||
one bounded file; the next successful import atomically replaces it.
|
||||
|
||||
The v1 binary representation uses the existing frame envelope: unsigned
|
||||
little-endian u32 width, u32 height, row-major unpremultiplied RGBA8 pixels, then
|
||||
32 raw SHA256 bytes covering the header and pixels. Width and height must be
|
||||
1–2048; length must be exactly 8 + width × height × 4 + 32 bytes. Maximum file
|
||||
size is 16 MiB + 40 bytes. FrameInfo.sha256 is lowercase hex of that same digest.
|
||||
Invalid dimensions, lengths or checksum are rejected; there is no permissive
|
||||
interpretation of other versions. No source filename or operator notes are stored.
|
||||
|
||||
A killable worker reads at most 64 MiB of source data, with image decoder limits
|
||||
of 256 MiB allocation and 32768 pixels per source edge. Images are proportionally
|
||||
resized to fit 2048 × 2048 without upscaling; animated sources use a still frame.
|
||||
Import failure preserves the existing copy/selection. The original is read-only.
|
||||
|
||||
The presenter and output each retain at most 16 MiB of decoded blank pixels,
|
||||
separately from slide-cache budgets; native output textures are bounded per
|
||||
window. Loading is asynchronous and the output compares the returned digest,
|
||||
dimensions and path with its request to reject stale replacement reads.
|
||||
A missing/corrupt asset stays black; no slide is substituted. Output fits the
|
||||
whole image on black, including transparency, without zoom or annotations.
|
||||
Tests cover normalized import/load round trips, deleted sources, corruption,
|
||||
failed replacement, worker import/reset and native blank/show acknowledgements.
|
||||
|
|
@ -1,5 +1,6 @@
|
|||
version = 1
|
||||
auto_show = true
|
||||
blank_picture = false
|
||||
zoom_enabled = false
|
||||
zoom_keep_fitted_area = false
|
||||
theme = "midra"
|
||||
|
|
|
|||
|
|
@ -205,3 +205,12 @@ runs on a dedicated 30-second supervised worker, one outstanding job per present
|
|||
The reply adds optional `cleanup` with unsigned `removed_bytes`, `remaining_bytes`,
|
||||
`removed_files`, and `skipped_files`. Errors use the existing error field. No frame
|
||||
payload is transferred. The same-build private protocol requires no migration.
|
||||
|
||||
The optional full HostState field `blank_picture: FrameInfo | null` (0.1.77)
|
||||
identifies the managed blank image by path, dimensions and content SHA256.
|
||||
Lightweight updates retain it. A separate supervised worker reads it; the output
|
||||
validates identity before accepting the pixels. It is never acknowledged as a
|
||||
slide, and a failed read leaves blank output black. Worker requests
|
||||
`PickBlankPicture { owner }` and `BlankPicture { source, path }` select and
|
||||
import/load the asset; source null loads the stored copy. See
|
||||
[blank picture](blank-picture.md) for bounds.
|
||||
|
|
|
|||
|
|
@ -137,3 +137,7 @@ Transient display trials/startup recovery eligibility, reveals, blank/current/se
|
|||
Change on click and worker state are not persisted. HTML prototype localStorage is
|
||||
separate and is not automatically imported. See `examples/settings-v1.toml` and
|
||||
round-trip/invalid-version tests in `tests/settings.rs`.
|
||||
|
||||
- `blank_picture`: optional boolean (0.1.77), default false. True selects the
|
||||
managed [blank picture](blank-picture.md); false uses solid black. Missing or
|
||||
invalid assets fall back to black. Existing v1 files migrate by defaulting false.
|
||||
|
|
|
|||
|
|
@ -413,3 +413,11 @@ available immediately.
|
|||
background. Active decks are protected and may temporarily exceed either limit.
|
||||
The cleanup report shows removed and remaining data; deleted slides regenerate
|
||||
when reopened. Source documents and presenter notes are preserved.
|
||||
|
||||
Choose **Preferences → Blank presentation → Choose picture…** to replace the
|
||||
black blanking screen with your own picture on every audience display. The app
|
||||
saves a copy, fits the whole image against black, and remembers it across restarts.
|
||||
The original may then be moved or removed. Use **Use solid black** to reset.
|
||||
Pictures are resized to at most 2048 pixels per edge; animated images use a still
|
||||
frame. Slide zoom, annotations and slide background colors do not affect it.
|
||||
The existing Blank presentation button and B shortcut still hide/show slides.
|
||||
|
|
|
|||
Loading…
Reference in New Issue