//! Shared native presenter state, scheduling, layout and UI actions. use crate::{ document::{DeckInfo, Frame, FrameInfo}, settings::{self, Layout, Routes, Settings}, worker::{Bridge, Request}, }; use std::{ collections::{HashMap, HashSet}, path::PathBuf, sync::Arc, time::{Duration, Instant}, }; #[derive(Clone, Debug)] pub struct Monitor { pub id: String, pub name: String, pub origin: (i32, i32), pub size: (u32, u32), } #[derive(Clone, Debug)] pub enum Action { Open(PathBuf), Pick(bool), PickNotes, PickBlankPicture, SetBlankPicture(PathBuf), ClearBlankPicture, #[cfg(target_os = "windows")] RegisterPdfAssociation, ImportNotes(PathBuf), ApplyNotesImport, Go(usize), Navigate { delta: i32, repeated: bool, }, FinishNavigation, Blank, SaveDisplayLayout { display: String, project: bool, layout: Layout, }, UseDisplayDefault(String), SaveProject, SaveGlobal, UseGlobal, ApplyRoutes, SwapRoutes, StartupSingleScreen(bool), KeepRoutes, RevertRoutes, OpenBrowser, CloseBrowser, Refresh, Exit, ConfirmExit, CancelExit, ToggleFullscreen, ToggleTimer, ResetTimer, EditNotes, ReloadNotes, SaveNotes, } pub struct NotesImport { pub preview: Option, pub busy: bool, pub error: Option, } pub struct NotesEditor { pub page: usize, pub text: String, pub saved_text: String, pub snapshot: Option, pub busy: bool, pub error: Option, } #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub enum SlideLoadState { Ready, Preparing, Cached, Queued, Failed, } pub struct RouteTrial { pub id: u64, pub deadline: Instant, previous: Routes, presenter_fullscreen: bool, presentation_fullscreen: bool, screen_modes: std::collections::BTreeMap, single_screens: Vec, } #[derive(Default)] pub struct PresenterView { pub layout: Layout, pub layout_open: bool, pub layout_target: Option, pub preferences_open: bool, pub menu_open: bool, } pub struct Studio { pub settings: Settings, pub layout: Layout, pub presenter_views: HashMap, pub presenter_views_dirty: bool, pub monitors: Vec, pub routes: Routes, pub draft_routes: Routes, pub draft_single_screens: Vec, startup_displays_observed: bool, pub startup_single_screen: Option, pub draft_screen_modes: std::collections::BTreeMap, pub draft_presenter_fullscreen: bool, pub draft_presentation_fullscreen: bool, pub route_trial: Option, pub presentation_started: bool, next_route_trial: u64, pub deck: Option, pub requested: usize, pub displayed: Option, pub blanked: bool, pub blank_picture: Option>, pub blank_busy: bool, blank_loader: Bridge, pub status: String, pub awake_status: String, pub generation: u64, pub frames: HashMap<(usize, u32), Arc>, pub prepared: HashSet, pub target_edge: u32, pub preparation_started: Instant, pub output_buffered: usize, pub ram_blocked: bool, pub cached_slides: usize, pub evicted_frames: usize, pub loading: bool, pub notes_loading: bool, pub notes_import: Option, pub notes_editor: Option, notes_io: Bridge, notes_edited: bool, pub visible_thumbs: HashSet, pub layout_open: bool, pub displays_open: bool, pub preferences_open: bool, pub menu_open: bool, pub browser_open: bool, pub browser_selected: usize, pub browser_preview: Option<(u64, usize)>, pub change_on_click: bool, pub jump: String, pub timer: crate::timer::Timer, pub actions: Vec, pub settings_path: PathBuf, pub cache_path: PathBuf, cache_io: Bridge, pub cache_busy: bool, pub cache_status: String, startup_cache_pending: bool, navigation_settle: Option, autoplay_deadline: Option, autoplay_finished: bool, pub fg: Bridge, pub bg: Bridge, pub io: Bridge, pub dialog: Bridge, pub dialog_busy: bool, pub dialog_owner: Option, fg_busy: bool, bg_busy: bool, fg_job: Option<(usize, u32)>, bg_job: Option<(usize, u32)>, notes_pending: bool, pending_open: Option, pending_save: bool, pub initialized: bool, pub open_path: Option, pub dirty_routes: bool, pub privacy_hold: bool, pub output_sequence: u64, pub zoom: crate::zoom::Sync, pub output_viewport: Option, pub new_zoom: bool, pub zoom_warning: bool, pub zoom_warning_dismissed: bool, pub toolbox: crate::tools::Toolbox, pub new_overlay: bool, pub new_output: bool, pub close_requested: bool, pub quit_confirmation: bool, failed: HashSet<(usize, u32)>, pub smoke: bool, pub startup: Instant, _smoke_dir: Option, worker_program: PathBuf, } impl Studio { pub fn new(smoke: bool, open_path: Option) -> Self { Self::with_program( smoke, open_path, std::env::current_exe().unwrap_or_default(), ) } pub fn with_program(smoke: bool, open_path: Option, worker_program: PathBuf) -> Self { let (mut settings_path, mut cache_path) = settings::paths().unwrap_or_else(|_| { ( PathBuf::from("settings.toml"), std::env::temp_dir().join("deckstride-cache"), ) }); let smoke_dir = if smoke { tempfile::tempdir().ok() } else { None }; if let Some(dir) = &smoke_dir { settings_path = dir.path().join("settings.toml"); cache_path = dir.path().join("cache"); } let io = Bridge::with_program(Duration::from_secs(10), worker_program.clone()); io.submit(0, 0, Request::LoadSettings(settings_path.clone())); Self { settings: Settings::default(), layout: Layout::default(), presenter_views: HashMap::new(), presenter_views_dirty: false, monitors: vec![], routes: Routes::default(), draft_routes: Routes::default(), draft_single_screens: Vec::new(), startup_displays_observed: false, startup_single_screen: None, draft_screen_modes: Default::default(), draft_presenter_fullscreen: true, draft_presentation_fullscreen: true, route_trial: None, presentation_started: false, next_route_trial: 0, deck: None, 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, frames: HashMap::new(), prepared: HashSet::new(), target_edge: 1920, preparation_started: Instant::now(), output_buffered: 0, ram_blocked: false, cached_slides: 0, evicted_frames: 0, loading: false, notes_loading: false, notes_import: None, notes_editor: None, notes_io: Bridge::with_program(Duration::from_secs(30), worker_program.clone()), notes_edited: false, visible_thumbs: HashSet::new(), layout_open: false, displays_open: false, preferences_open: false, menu_open: false, browser_open: false, browser_selected: 0, browser_preview: None, change_on_click: false, jump: String::new(), timer: crate::timer::Timer::default(), actions: vec![], settings_path, cache_path, cache_io: Bridge::with_program(Duration::from_secs(30), worker_program.clone()), cache_busy: false, cache_status: String::new(), startup_cache_pending: true, navigation_settle: None, autoplay_deadline: None, autoplay_finished: false, fg: Bridge::with_program(Duration::from_secs(30), worker_program.clone()), bg: Bridge::with_program(Duration::from_secs(30), worker_program.clone()), io, dialog: Bridge::with_program(Duration::from_secs(300), worker_program.clone()), dialog_busy: false, dialog_owner: None, fg_busy: false, bg_busy: false, fg_job: None, bg_job: None, notes_pending: false, pending_open: None, pending_save: false, initialized: false, open_path, dirty_routes: true, privacy_hold: false, output_sequence: 0, zoom: Default::default(), output_viewport: None, new_zoom: false, zoom_warning: false, zoom_warning_dismissed: false, toolbox: Default::default(), new_overlay: false, new_output: true, close_requested: false, quit_confirmation: false, failed: HashSet::new(), smoke, startup: Instant::now(), _smoke_dir: smoke_dir, worker_program, } } pub fn count(&self) -> usize { self.deck.as_ref().map_or(0, |d| d.names.len()) } pub fn project(&self) -> String { self.deck .as_ref() .map_or_else(|| "empty".into(), |d| d.key.clone()) } pub fn executable_path(&self) -> &std::path::Path { &self.worker_program } pub fn frame(&self, page: usize) -> Option> { [self.target_edge, 512, 1280, 320] .iter() .find_map(|&edge| self.frames.get(&(page, edge)).cloned()) } pub fn slide_load_state(&self, page: usize) -> SlideLoadState { if self.frame(page).is_some() { SlideLoadState::Ready } else if self.fg_job.is_some_and(|(job, _)| job == page) || self.bg_job.is_some_and(|(job, _)| job == page) { SlideLoadState::Preparing } else if self.failed.contains(&(page, self.target_edge)) { SlideLoadState::Failed } else if self.prepared.contains(&page) { SlideLoadState::Cached } else { SlideLoadState::Queued } } pub fn full_frame(&self, page: usize) -> Option> { [self.target_edge, 512, 1280] .iter() .find_map(|&edge| self.frames.get(&(page, edge)).cloned()) } pub fn frame_info(&self) -> Option { self.full_frame(self.requested).map(|f| f.info.clone()) } /// Called on the first native discovery, including zero displays. Never rearmed by hotplug. pub fn observe_startup_displays(&mut self, count: usize, only_id: Option<&str>) { if !self.startup_displays_observed { self.startup_displays_observed = true; self.startup_single_screen = only_id.filter(|_| count == 1).map(str::to_owned); } } pub fn is_single_screen(&self, id: &str) -> bool { self.routes.presenter.iter().any(|display| display == id) && self .route_trial .as_ref() .map_or(&self.settings.single_screens, |trial| &trial.single_screens) .iter() .any(|display| display == id) } pub fn startup_single_offer(&self) -> bool { self.initialized && self.route_trial.is_none() && !self.quit_confirmation && self.startup_single_screen.as_ref().is_some_and(|id| { self.monitors.len() == 1 && self.monitors[0].id == *id && self.routes.presenter.contains(id) && !self.is_single_screen(id) }) } pub fn swap_draft_groups(&mut self) { if self.draft_routes.presentation.is_empty() || (!self.draft_routes.presenter.is_empty() && self .draft_routes .presenter .iter() .all(|id| self.draft_single_screens.contains(id))) { return; } let singles: Vec<_> = self .draft_routes .presenter .iter() .filter(|id| self.draft_single_screens.contains(id)) .cloned() .collect(); self.draft_routes .presenter .retain(|id| !singles.contains(id)); std::mem::swap( &mut self.draft_routes.presenter, &mut self.draft_routes.presentation, ); self.draft_routes.presenter.extend(singles); } pub fn set_monitors(&mut self, monitors: Vec, primary: usize) { let ids = monitors.iter().map(|m| m.id.clone()).collect::>(); let changed = self .monitors .iter() .map(|m| (&m.id, m.origin, m.size)) .collect::>() != monitors .iter() .map(|m| (&m.id, m.origin, m.size)) .collect::>(); let previous_outputs = self.routes.presentation.clone(); let recovering = !self.monitors.is_empty(); if self .startup_single_screen .as_ref() .is_some_and(|id| monitors.len() != 1 || monitors[0].id != *id) { self.startup_single_screen = None; } self.monitors = monitors; if changed { self.execute(Action::RevertRoutes); self.routes = self.settings.routes.resolve(&ids, primary); // A lost operator screen must not turn a previously public output into a notes window. if recovering { self.routes .presenter .retain(|id| !previous_outputs.contains(id)); if self.routes.presenter.is_empty() && let Some(id) = ids.iter().find(|id| !previous_outputs.contains(id)) { self.routes.presenter.push(id.clone()); self.routes.presentation.retain(|output| output != id); } } self.privacy_hold = recovering && self.routes.presenter.is_empty(); self.draft_routes = self.routes.clone(); self.dirty_routes = true; if !recovering { self.blanked = !self.settings.auto_show; } self.new_output = true; self.status = if recovering { "Screen setup changed. Output visibility preserved; review destinations." } else { "Screen setup ready." } .into(); } } fn ensure_display_profile(&mut self, display: &str) -> bool { if display.is_empty() || display.len() > 1024 || (self.settings.display_layouts.len() >= 128 && !self.settings.display_layouts.contains_key(display)) { self.status = "Cannot save another display layout.".into(); return false; } let layout = self.settings.layout.clone(); self.settings .display_layouts .entry(display.into()) .or_insert_with(|| settings::DisplayLayouts { layout, projects: Default::default(), }); true } pub fn take_presenter_view(&mut self, display: &str) -> PresenterView { if let Some(view) = self.presenter_views.remove(display) { return view; } // Retain disconnected screens during ordinary hotplug, with bounded session state. if self.presenter_views.len() >= 128 { self.presenter_views .retain(|id, _| self.routes.presenter.contains(id)); } PresenterView { layout: self.settings.for_display(display, &self.project()), ..Default::default() } } pub fn timer_limit(&self) -> Option { (self.layout.timer_mode == settings::TimerMode::Countdown) .then(|| Duration::from_secs(self.layout.countdown_seconds as u64)) } pub fn presentation_action(&mut self) { self.timer .presentation_action(Instant::now(), self.layout.timer_autostart); self.restart_autoplay(); } fn restart_autoplay(&mut self) { self.autoplay_deadline = None; self.autoplay_finished = false; } pub fn autoplay_settings_changed(&mut self) { self.restart_autoplay(); self.save_preferences(); } fn poll_autoplay_at(&mut self, now: Instant) -> bool { let paused = !self.settings.autoplay_enabled || !self.initialized || self.loading || self.pending_open.is_some() || self.blanked || self.dialog_busy || self.route_trial.is_some() || self.startup_single_offer() || self.notes_editor.is_some() || self.notes_import.is_some() || self.quit_confirmation || self.count() == 0; if paused { self.autoplay_deadline = None; return false; } if self.autoplay_finished { return false; } let visible = self.displayed == Some(self.requested) || (self.routes.presentation.is_empty() && self.frame(self.requested).is_some()); if !visible { self.autoplay_deadline = None; return false; } let deadline = self .autoplay_deadline .get_or_insert_with(|| now + Duration::from_secs_f32(self.settings.autoplay_seconds)); if now < *deadline { return false; } let next = if self.requested + 1 < self.count() { Some(self.requested + 1) } else if self.settings.autoplay_loop && self.count() > 1 { Some(0) } else { None }; self.autoplay_deadline = None; if let Some(next) = next { self.execute(Action::Go(next)); true } else { self.autoplay_finished = true; false } } pub fn execute(&mut self, action: Action) { match action { Action::Open(path) => { if self.notes_editor.is_some() || self.notes_import.is_some() || self.dialog_busy { self.status = "Close the notes editor/import or file chooser before opening another presentation.".into(); return; } if self.fg_busy { self.fg = Bridge::with_program(Duration::from_secs(30), self.worker_program.clone()); self.fg_busy = false; self.fg_job = None; } self.navigation_settle = None; self.loading = true; 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 slides use solid black.".into(); } #[cfg(target_os = "windows")] Action::RegisterPdfAssociation => { self.status = match crate::windows_integration::register_pdf_association() { Ok(()) => "Choose Deckstride for .pdf in Windows Default Apps. PDF files will then use its icon.".into(), Err(error) => format!("Could not register Deckstride: {error}"), }; } Action::PickNotes => { if !self.dialog_busy && !self.loading && self.deck.is_some() && self.notes_editor.is_none() && self.notes_import.is_none() { self.dialog_busy = self.dialog.submit( self.generation, 1, Request::PickNotes { owner: self.dialog_owner, }, ); self.status = "Choose a TXT or Markdown notes file.".into(); } } Action::ImportNotes(import) => { if self.loading || self.notes_editor.is_some() || self.notes_import.is_some() || self.dialog_busy { self.status = "Close the notes editor/import or file chooser and wait for the presentation to load.".into(); return; } let Some(deck) = &self.deck else { self.status = "Open a presentation before importing notes.".into(); return; }; if self.notes_io.submit( self.generation, 2, Request::PreviewNotesImport { path: deck.path.clone(), cache: self.cache_path.clone(), source_sha: deck.sha256.clone(), import, }, ) { self.notes_import = Some(NotesImport { preview: None, busy: true, error: None, }); self.jump.clear(); self.status = "Reading notes for import…".into(); } } Action::ApplyNotesImport => { if let (Some(deck), Some(import)) = (&self.deck, &mut self.notes_import) && !import.busy && import.error.is_none() && let Some(preview) = &import.preview && self.notes_io.submit( self.generation, 3, Request::ApplyNotesImport { path: deck.path.clone(), cache: self.cache_path.clone(), source_sha: deck.sha256.clone(), preview: preview.clone(), }, ) { import.busy = true; self.status = "Saving imported notes…".into(); } } Action::Pick(folder) => { if !self.dialog_busy { self.dialog_busy = self.dialog.submit( 0, 0, Request::Pick { folder, owner: self.dialog_owner, }, ); self.status = if self.dialog_busy { "File chooser open — select a presentation or cancel." } else { "Could not open the file chooser. Try again." } .into(); } } Action::Navigate { delta, repeated } => { if self.notes_editor.is_some() || self.notes_import.is_some() || self.dialog_busy || self.route_trial.is_some() { return; } let page = self .requested .saturating_add_signed(delta as isize) .min(self.count().saturating_sub(1)); if page != self.requested { if !repeated { self.navigation_settle = None; } if repeated { self.navigation_settle = Some(Instant::now() + Duration::from_millis(180)); } self.execute(Action::Go(page)); } } Action::FinishNavigation => { if self.navigation_settle.take().is_some() && self.fg_job.is_some_and(|(page, _)| page != self.requested) && !self.loading { self.fg = Bridge::with_program(Duration::from_secs(30), self.worker_program.clone()); self.fg_busy = false; self.fg_job = None; } } Action::Go(page) => { if self.route_trial.is_some() { return; } if page < self.count() { self.restart_autoplay(); if page != self.requested && self.fg_busy && !self.loading && self.navigation_settle.is_none() { self.fg = Bridge::with_program( Duration::from_secs(30), self.worker_program.clone(), ); self.fg_busy = false; self.fg_job = None; } self.presentation_started = true; if self.requested != page { self.set_zoom(crate::zoom::View::default()); self.toolbox.clear(); self.new_overlay = true; self.presentation_action(); } self.requested = page; self.jump.clear(); self.new_output = true; } } Action::Blank => { self.blanked = !self.blanked; self.presentation_action(); if !self.blanked { self.presentation_started = true; } self.new_output = true; } Action::SaveDisplayLayout { display, project, mut layout, } => { if !self.ensure_display_profile(&display) { return; } let key = self.project(); // Timer behavior remains shared; only its appearance belongs to a monitor. layout.timer_mode = self.layout.timer_mode; layout.countdown_seconds = self.layout.countdown_seconds; layout.timer_autostart = self.layout.timer_autostart; if project { let total: usize = self .settings .display_layouts .values() .map(|p| p.projects.len()) .sum(); if total >= 4096 && !self.settings.display_layouts[&display] .projects .contains_key(&key) { self.status = "Too many saved display/project layouts.".into(); return; } let mut shared = self.settings.for_project(&key); shared.timer_mode = layout.timer_mode; shared.countdown_seconds = layout.countdown_seconds; shared.timer_autostart = layout.timer_autostart; self.settings.projects.insert(key.clone(), shared); self.settings .display_layouts .get_mut(&display) .unwrap() .projects .insert(key, layout); } else { self.settings.layout.timer_mode = layout.timer_mode; self.settings.layout.countdown_seconds = layout.countdown_seconds; self.settings.layout.timer_autostart = layout.timer_autostart; self.settings .display_layouts .get_mut(&display) .unwrap() .layout = layout; } self.pending_save = true; } Action::UseDisplayDefault(display) => { if !self.ensure_display_profile(&display) { return; } let key = self.project(); let profile = self.settings.display_layouts.get_mut(&display).unwrap(); profile.projects.remove(&key); let layout = profile.layout.clone(); if let Some(view) = self.presenter_views.get_mut(&display) { view.layout = layout; } self.pending_save = true; } Action::SaveProject => { let key = self.project(); self.settings.projects.insert(key, self.layout.clone()); self.pending_save = true; } Action::SaveGlobal => { self.settings.layout = self.layout.clone(); self.pending_save = true; } Action::UseGlobal => { self.settings.projects.remove(&self.project()); self.layout = self.settings.layout.clone(); self.pending_save = true; } Action::StartupSingleScreen(accept) => { if !self.startup_single_offer() { return; } let id = self.startup_single_screen.take().unwrap(); if accept { self.begin_display_edit(); self.draft_single_screens.push(id); self.execute(Action::ApplyRoutes); } } Action::SwapRoutes => { if self.route_trial.is_none() && self .routes .presenter .iter() .any(|id| !self.is_single_screen(id)) && !self.routes.presentation.is_empty() { self.begin_display_edit(); self.swap_draft_groups(); self.execute(Action::ApplyRoutes); } } Action::ApplyRoutes => { if !self.initialized { return; } if self.route_trial.is_some() { return; } if self.draft_routes.presenter.is_empty() { self.status = "Choose at least one presenter or single-screen display.".into(); } else if let Err(e) = crate::settings::validate_single_screens(&self.draft_single_screens) { self.status = e; } else if let Err(e) = crate::settings::validate_screen_modes(&self.draft_screen_modes) { self.status = e; } else if let Err(e) = self.draft_routes.validate() { self.status = e; } else if self .draft_routes .presenter .iter() .chain(&self.draft_routes.presentation) .any(|id| !self.monitors.iter().any(|m| &m.id == id)) { self.status = "A selected display is no longer connected.".into(); } else { self.startup_single_screen = None; self.next_route_trial += 1; self.route_trial = Some(RouteTrial { id: self.next_route_trial, deadline: Instant::now() + Duration::from_secs(15), previous: self.routes.clone(), presenter_fullscreen: self.draft_presenter_fullscreen, presentation_fullscreen: self.draft_presentation_fullscreen, screen_modes: self.draft_screen_modes.clone(), single_screens: self.draft_single_screens.clone(), }); self.routes = self.draft_routes.clone(); self.dirty_routes = true; self.displays_open = false; self.new_output = true; } } Action::KeepRoutes => { if let Some(trial) = self.route_trial.take() { if Instant::now() >= trial.deadline { self.route_trial = Some(trial); self.execute(Action::RevertRoutes); return; } self.settings.single_screens = trial.single_screens; self.settings.screen_modes = trial.screen_modes; self.settings.routes = self.routes.clone(); self.settings.presenter_fullscreen = trial.presenter_fullscreen; self.settings.presentation_fullscreen = trial.presentation_fullscreen; self.pending_save = true; self.new_output = true; self.status = "Display setup confirmed. Output visibility preserved.".into(); } } Action::RevertRoutes => { if let Some(trial) = self.route_trial.take() { self.routes = trial.previous; self.begin_display_edit(); self.displays_open = false; self.dirty_routes = true; self.new_output = true; self.status = "Display change reverted. Output visibility preserved.".into(); } } Action::OpenBrowser => { self.browser_open = true; self.browser_selected = self.requested; self.change_on_click = false; } Action::CloseBrowser => { self.browser_open = false; self.browser_preview = None; self.pending_save = true; } Action::Refresh => self.dirty_routes = true, Action::Exit => { self.quit_confirmation = true; } Action::CancelExit => self.quit_confirmation = false, Action::ConfirmExit => { if self.quit_confirmation { if let Some(reason) = self.quit_block_reason() { self.status = reason.into(); } else { self.quit_confirmation = false; self.close_requested = true; } } } command @ (Action::EditNotes | Action::ReloadNotes) => { if matches!(command, Action::EditNotes) && self.notes_editor.is_some() { return; } if self.loading || self.notes_import.is_some() || self.dialog_busy || self.notes_editor.as_ref().is_some_and(|e| e.busy) { return; } if let Some(deck) = &self.deck { let page = self .notes_editor .as_ref() .map_or(self.requested, |e| e.page); if page >= self.count() { return; } if self.notes_io.submit( self.generation, 0, Request::PrepareNotes { path: deck.path.clone(), cache: self.cache_path.clone(), source_sha: deck.sha256.clone(), }, ) { self.notes_editor = Some(NotesEditor { page, text: String::new(), saved_text: String::new(), snapshot: None, busy: true, error: None, }); self.jump.clear(); } } } Action::SaveNotes => { if let (Some(deck), Some(editor)) = (&self.deck, &mut self.notes_editor) && !editor.busy && let Some(snapshot) = &editor.snapshot && self.notes_io.submit( self.generation, 1, Request::SaveNotes { path: deck.path.clone(), cache: self.cache_path.clone(), source_sha: deck.sha256.clone(), revision: snapshot.revision.clone(), page: editor.page, text: editor.text.clone(), }, ) { editor.busy = true; editor.error = None; } } Action::ToggleTimer => self.timer.toggle(Instant::now(), self.timer_limit()), Action::ResetTimer => self.timer.reset(), Action::ToggleFullscreen => { if self.route_trial.is_some() { return; } let fullscreen = !(self.presenter_fullscreen() && self.presentation_fullscreen()); self.draft_routes = self.routes.clone(); self.draft_single_screens = self.settings.single_screens.clone(); self.draft_screen_modes = self.settings.screen_modes.clone(); self.draft_presenter_fullscreen = fullscreen; self.draft_presentation_fullscreen = fullscreen; self.execute(Action::ApplyRoutes); } } } pub fn display_control(&mut self, action: crate::output::DisplayAction, trial: Option) { use crate::output::DisplayAction; match action { DisplayAction::Swap if trial.is_none() && self.route_trial.is_none() && !self.presentation_started => { self.execute(Action::SwapRoutes) } DisplayAction::Keep | DisplayAction::Revert if trial.is_some() && trial == self.route_trial.as_ref().map(|t| t.id) => { self.execute(if matches!(action, DisplayAction::Keep) { Action::KeepRoutes } else { Action::RevertRoutes }); } _ => {} } } pub fn quit_block_reason(&self) -> Option<&'static str> { if self.notes_import.as_ref().is_some_and(|i| i.busy) { Some("Wait for notes import to finish before closing.") } else if self .notes_editor .as_ref() .is_some_and(|e| e.busy || e.text != e.saved_text) { Some("Save or discard notes before closing the presentation.") } else { None } } pub fn screen_fullscreen(&self, display: &str, global: bool) -> bool { self.route_trial .as_ref() .map_or(&self.settings.screen_modes, |trial| &trial.screen_modes) .get(display) .copied() .unwrap_or_default() .fullscreen(global) } pub fn begin_display_edit(&mut self) { self.draft_single_screens = self.settings.single_screens.clone(); self.draft_screen_modes = self.settings.screen_modes.clone(); self.draft_routes = self.routes.clone(); self.draft_presenter_fullscreen = self.settings.presenter_fullscreen; self.draft_presentation_fullscreen = self.settings.presentation_fullscreen; self.displays_open = true; } pub fn presenter_fullscreen(&self) -> bool { self.route_trial .as_ref() .map_or(self.settings.presenter_fullscreen, |t| { t.presenter_fullscreen }) } pub fn presentation_fullscreen(&self) -> bool { self.route_trial .as_ref() .map_or(self.settings.presentation_fullscreen, |t| { t.presentation_fullscreen }) } pub fn clean_cache(&mut self, manual: bool) { if self.cache_busy || !self.initialized || self.loading { return; } let protected = self.deck.iter().map(|d| d.key.clone()).collect(); if self.cache_io.submit( 0, 0, Request::CleanCache { path: self.cache_path.clone(), policy: self.settings.disk_cache.clone(), protected, manual, }, ) { self.startup_cache_pending = false; self.cache_busy = true; self.cache_status = "Cleaning disk cache…".into(); } } pub fn remember_cache_policy(&mut self) { self.save_preferences(); } fn load_blank_picture(&mut self, source: Option) { 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) { if self.initialized && self .startup_single_screen .as_ref() .is_some_and(|id| self.is_single_screen(id)) { self.startup_single_screen = None; } 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 slides 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 { Ok(p) => match (p.reply.error, p.reply.cleanup) { (Some(e), _) => format!("Cache cleanup: {e}"), (_, Some(r)) => format!( "Disk cache: {} MiB remaining; removed {} files ({} MiB); {} protected/changed files retained.", r.remaining_bytes.div_ceil(1024 * 1024), r.removed_files, r.removed_bytes.div_ceil(1024 * 1024), r.skipped_files ), _ => "Cache cleanup returned no report.".into(), }, Err(e) => format!("Cache cleanup: {e}"), }; } while let Ok(completion) = self.notes_io.rx.try_recv() { if completion.generation != self.generation { continue; } if completion.tag >= 2 { if let Some(import) = &mut self.notes_import { import.busy = false; match completion.result { Ok(packet) => { import.error = packet.reply.error; if let Some(preview) = packet.reply.notes_import { import.preview = Some(preview); self.status = "Review the notes import before saving.".into(); } if let Some(snapshot) = packet.reply.notes { if let Some(deck) = &mut self.deck { deck.notes = snapshot.notes; } self.notes_edited = true; self.status = format!("Notes imported: {}", snapshot.path.display()); self.notes_import = None; } } Err(error) => import.error = Some(error), } if let Some(error) = self.notes_import.as_ref().and_then(|i| i.error.as_ref()) { self.status = format!("Notes import: {error}"); } } continue; } if let Some(editor) = &mut self.notes_editor { editor.busy = false; match completion.result { Ok(packet) => { editor.error = packet.reply.error; if let Some(snapshot) = packet.reply.notes { editor.text = snapshot.notes.get(editor.page).cloned().unwrap_or_default(); editor.saved_text = editor.text.clone(); if let Some(deck) = &mut self.deck { deck.notes = snapshot.notes.clone(); } editor.snapshot = Some(snapshot); self.notes_edited = true; self.status = if completion.tag == 1 { "Notes saved." } else { "Notes editor ready." } .into(); } } Err(error) => editor.error = Some(error), } if let Some(error) = &editor.error { self.status = format!("Notes: {error}"); } } } if self .route_trial .as_ref() .is_some_and(|t| Instant::now() >= t.deadline) { self.execute(Action::RevertRoutes); } while let Ok(c) = self.io.rx.try_recv() { match c.result { Ok(packet) => { if let Some(error) = packet.reply.error { self.status = format!("Settings: {error}"); } else if let Some(settings) = packet.reply.settings { 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(); self.routes = Routes::default(); } self.dirty_routes = true; } else { self.status = "Settings saved. Project layouts override the all-project default." .into(); } } Err(e) => self.status = format!("Settings: {e}"), }; self.initialized = true; } if let Some(path) = self.open_path.take() { self.execute(Action::Open(path)); } if self.pending_save && self.io.submit( 0, 1, Request::SaveSettings { path: self.settings_path.clone(), settings: Box::new(self.settings.clone()), }, ) { self.pending_save = false; } while let Ok(c) = self.dialog.rx.try_recv() { self.dialog_busy = false; self.status = "File chooser closed.".into(); match c.result { Ok(p) => { if let Some(path) = p.reply.picked { if c.tag == 2 { self.execute(Action::SetBlankPicture(path)); } else if c.tag == 1 { if c.generation == self.generation { self.execute(Action::ImportNotes(path)); } } else { self.execute(Action::Open(path)); } } if let Some(e) = p.reply.error { self.status = e; } } Err(e) => self.status = e, } } for foreground in [true, false] { loop { let received = if foreground { self.fg.rx.try_recv() } else { self.bg.rx.try_recv() }; let Ok(c) = received else { break; }; if foreground { self.fg_busy = false; self.fg_job = None; } else { self.bg_busy = false; self.bg_job = None; } if c.generation != self.generation { continue; } match c.result { Ok(packet) => { if let Some(error) = packet.reply.error { self.status = error; if c.tag == u64::MAX { self.notes_loading = false; } else if self.loading && foreground { self.loading = false; } else { self.failed.insert(((c.tag >> 32) as usize, c.tag as u32)); } continue; } if let Some(info) = packet.reply.info { if c.tag == u64::MAX { self.notes_loading = false; if !self.notes_edited && let Some(deck) = &mut self.deck { deck.notes = info.notes; deck.warnings = info.warnings; if let Some(warning) = deck.warnings.first() { self.status = warning.clone(); } } continue; } self.loading = false; self.bg = Bridge::with_program( Duration::from_secs(30), self.worker_program.clone(), ); self.bg_busy = false; self.bg_job = None; self.notes_loading = false; self.notes_pending = true; self.notes_edited = false; self.cached_slides = 0; self.evicted_frames = 0; self.generation += 1; self.frames.clear(); self.prepared.clear(); self.preparation_started = Instant::now(); self.output_buffered = 0; self.ram_blocked = false; self.failed.clear(); self.set_zoom(crate::zoom::View::default()); self.toolbox.clear(); self.new_overlay = true; self.requested = 0; self.presentation_started = false; self.timer = crate::timer::Timer::default(); self.restart_autoplay(); self.displayed = None; self.layout = self.settings.for_project(&info.key); self.presenter_views.clear(); self.status = info.warnings.first().cloned().unwrap_or_else(|| { format!( "Opened {} slides. Preparing first slide…", info.names.len() ) }); self.deck = Some(info); self.blanked = !self.settings.auto_show; self.new_output = true; } if let Some(info) = packet.reply.frame { let key = (info.page, packet.reply.edge.unwrap_or(c.tag as u32)); if key.1 != self.target_edge && key.1 != 512 { continue; } if key.1 == self.target_edge && packet.reply.cached && !self.prepared.contains(&key.0) { self.cached_slides += 1; } let frame = Arc::new(Frame { info, rgba: packet.data, }); if key.1 == self.target_edge { self.frames.retain(|(page, edge), _| { *page != key.0 || *edge == self.target_edge }); } self.frames.insert(key, frame); if key.1 == self.target_edge { self.prepared.insert(key.0); } self.new_output = true; if key.0 == self.requested { self.new_output = true; self.status = format!("Slide {} ready", self.requested + 1); } } } Err(e) => { self.status = e; if c.tag == u64::MAX { self.notes_loading = false; } else if self.loading && foreground { self.loading = false; } else { self.failed.insert(((c.tag >> 32) as usize, c.tag as u32)); } } } } } if !self.fg_busy && let Some(path) = self.pending_open.take() { if self.fg.submit( self.generation, 0, Request::Open { epoch: self.generation + 1, path: path.clone(), cache: self.cache_path.clone(), }, ) { self.fg_busy = true; } else { self.pending_open = Some(path); } } if self .navigation_settle .is_some_and(|deadline| Instant::now() >= deadline) { self.navigation_settle = None; } if self.deck.is_some() && self.pending_open.is_none() && self.navigation_settle.is_none() { if !self.fg_busy { let edge = self.target_edge; if !self.frames.contains_key(&(self.requested, edge)) && !self.failed.contains(&(self.requested, edge)) { self.schedule(self.requested, edge, true); } } if !self.bg_busy && self.notes_pending && self.full_frame(self.requested).is_some() && self.bg.submit( self.generation, u64::MAX, Request::Notes { path: self.deck.as_ref().unwrap().path.clone(), cache: self.cache_path.clone(), }, ) { self.notes_pending = false; self.notes_loading = true; self.bg_busy = true; } // Use spare foreground capacity to prepare the tail while background fills forward. // Interactive navigation still cancels/supersedes this work immediately. if !self.fg_busy && self.prepared.len() < self.count() && let Some(page) = (0..self.count()).rev().find(|p| { let key = (*p, self.target_edge); !self.prepared.contains(p) && !self.failed.contains(&key) && Some(key) != self.bg_job }) { self.schedule(page, self.target_edge, true); } if !self.bg_busy { let mut jobs = vec![]; for page in [self.requested + 1, self.requested.saturating_sub(1)] { if page < self.count() { jobs.push((page, self.target_edge)); } } // Prepare the entire show, not just the currently visible neighbourhood. if self.prepared.len() < self.count() { jobs.retain(|(p, _)| !self.prepared.contains(p)); jobs.extend( (0..self.count()) .filter(|p| !self.prepared.contains(p)) .map(|p| (p, self.target_edge)), ); } else { if self.browser_open { jobs.extend(self.visible_thumbs.iter().map(|p| (*p, self.target_edge))); } // Refill available RAM after navigation or a budget increase. jobs.extend((0..self.count()).map(|p| (p, self.target_edge))); } if let Some((page, edge)) = jobs.into_iter().find(|key| { !self.frames.contains_key(key) && Some(*key) != self.fg_job && !self.failed.contains(key) && key.0 != self.requested }) { self.schedule(page, edge, false); } } } let edge = self .monitors .iter() .filter(|m| self.routes.presentation.contains(&m.id)) .chain( self.monitors .iter() .filter(|m| self.routes.presenter.contains(&m.id)), ) .map(|m| m.size.0.max(m.size.1)) .max() .unwrap_or(1920) .clamp(512, 4096); if edge != self.target_edge { self.target_edge = edge; self.prepared = self .frames .keys() .filter(|(_, e)| *e == edge) .map(|(p, _)| *p) .collect(); self.frames.retain(|(_, e), _| *e == edge || *e == 512); self.preparation_started = Instant::now(); self.cached_slides = 0; self.evicted_frames = 0; self.output_buffered = 0; self.ram_blocked = false; self.new_output = true; } // One startup pass, after source/notes loading and initial rendering settle. // Prepared disk artifacts count even when the deck exceeds the RAM budget. if self.startup_cache_pending && self.open_path.is_none() && self.pending_open.is_none() && !self.fg_busy && !self.bg_busy && !self.notes_pending && !self.notes_loading && self.prepared.len() == self.count() { self.clean_cache(false); } self.poll_autoplay_at(Instant::now()); } fn schedule(&mut self, page: usize, edge: u32, foreground: bool) { // Reserve both worker slots before admission, including progressive previews. let reserve = 2 * edge as usize * edge as usize * 4; let limit = self.settings.buffer_mib as usize * 1024 * 1024; while self.buffer_bytes().saturating_add(reserve) > limit { let victim = self .frames .keys() .copied() .filter(|(p, _)| { *p != self.requested && Some(*p) != self.displayed && *p != page // Once processed, speculative prefetch must improve locality rather // than continually swap two equally distant cached slides. && (!self.prepared.contains(&page) || page == self.requested || p.abs_diff(self.requested) > page.abs_diff(self.requested)) }) .max_by_key(|(p, e)| (*e != self.target_edge, p.abs_diff(self.requested), *p)); let Some(victim) = victim else { self.ram_blocked = true; return; }; self.frames.remove(&victim); self.evicted_frames += 1; self.new_output = true; } self.ram_blocked = false; let request = Request::Render { epoch: self.generation, path: self.deck.as_ref().unwrap().path.clone(), cache: self.cache_path.clone(), page, edge, }; let request = if foreground && page == self.requested && self.frame(page).is_none() { Request::Preview { epoch: self.generation, path: self.deck.as_ref().unwrap().path.clone(), cache: self.cache_path.clone(), page, edge, } } else { request }; let bridge = if foreground { &self.fg } else { &self.bg }; if bridge.submit( self.generation, ((page as u64) << 32) | u64::from(edge), request, ) { if foreground { self.fg_busy = true; self.fg_job = Some((page, edge)); } else { self.bg_busy = true; self.bg_job = Some((page, edge)); } } } pub fn buffer_generation(&self) -> u64 { (self.generation << 32) | u64::from(self.target_edge) } /// Use the first connected presentation route as the preview reference. pub fn presentation_viewport(&self) -> Option<[u32; 2]> { let monitor = self .routes .presentation .iter() .find_map(|id| self.monitors.iter().find(|m| &m.id == id))?; if let Some(viewport) = &self.output_viewport && viewport.monitor == monitor.id && viewport.fullscreen == self.screen_fullscreen(&monitor.id, self.presentation_fullscreen()) && viewport.size.iter().all(|v| *v > 0) { return Some(viewport.size); } Some([monitor.size.0.max(1), monitor.size.1.max(1)]) } pub fn set_zoom(&mut self, view: crate::zoom::View) { self.zoom.keep_fitted_area = self.settings.zoom_keep_fitted_area; self.zoom.set(self.settings.zoom_enabled, view); self.new_zoom = true; } pub fn set_zoom_from_action(&mut self, view: crate::zoom::View) { if self.settings.zoom_enabled && view.normalized() != self.zoom.view.normalized() { self.presentation_action(); } self.set_zoom(view); } pub fn enable_zoom(&mut self, enabled: bool) { self.settings.zoom_enabled = enabled; self.set_zoom(crate::zoom::View::default()); self.zoom_warning = false; self.zoom_warning_dismissed = false; self.save_preferences(); } pub fn save_preferences(&mut self) { self.pending_save = true; } pub fn remember_buffer_budget(&mut self) { let reserved: usize = self .fg_job .iter() .chain(self.bg_job.iter()) .map(|(_, edge)| *edge as usize * *edge as usize * 4) .sum(); let limit = (self.settings.buffer_mib as usize * 1024 * 1024).saturating_sub(reserved); while self.buffer_bytes() > limit { let victim = self .frames .keys() .copied() .filter(|(p, _)| *p != self.requested && Some(*p) != self.displayed) .max_by_key(|(p, _)| p.abs_diff(self.requested)); let Some(victim) = victim else { break; }; self.frames.remove(&victim); self.evicted_frames += 1; } self.pending_save = true; self.ram_blocked = false; self.new_output = true; } pub fn buffer_bytes(&self) -> usize { self.frames.values().map(|f| f.rgba.len()).sum() } pub fn resident_slides(&self) -> usize { self.frames .keys() .filter(|(_, edge)| *edge == self.target_edge) .count() } fn rolling_status(&self, french: bool) -> String { let processed = self.prepared.len(); let total = self.count(); let eta = if processed > 0 && processed < total { format!( " · ETA ~{} s", (self.preparation_started.elapsed().as_secs_f64() / processed as f64 * (total - processed) as f64) .ceil() as u64 ) } else { String::new() }; if french { format!( "Cache tournant — {processed}/{total} préparées · {}/{} en RAM ({} Mio) · {} libérées · rechargement du cache à la demande{eta}", self.resident_slides(), total, self.buffer_bytes() / (1024 * 1024), self.evicted_frames ) } else { format!( "Rolling buffer — {processed}/{total} prepared · {}/{} in RAM ({} MiB) · {} evicted · cached slides reload on demand{eta}", self.resident_slides(), total, self.buffer_bytes() / (1024 * 1024), self.evicted_frames ) } } pub fn fully_buffered(&self) -> bool { !self.loading && self.count() > 0 && self.resident_slides() == self.count() && (self.routes.presentation.is_empty() || self.output_buffered == self.count()) } fn preparation_status_fr(&self) -> String { if self.loading { return "Ouverture et vérification du cache… Estimation en cours".into(); } if self.deck.is_none() { return self.status.clone(); } let n = self.prepared.len(); let total = self.count(); let ram = self.buffer_bytes() / (1024 * 1024); if self.notes_loading { return format!("Lecture des notes · {n}/{total} en mémoire · diffusion disponible"); } if self.fully_buffered() { return format!( "PRÊT — {total} diapositives en RAM · {ram} Mio · {} px", self.target_edge ); } if self.evicted_frames > 0 { return self.rolling_status(self.settings.language.french()); } if self.ram_blocked { return format!( "Budget RAM atteint — {n}/{total} en mémoire. Mémoire insuffisante pour les images actives et les rendus en cours." ); } if !self.failed.is_empty() { return format!( "Préparation incomplète — {n}/{total} en mémoire. {}", self.status ); } let count = if n == total { self.output_buffered } else { n }; let eta = if count > 0 && count < total { format!( "~{} s restantes", (self.preparation_started.elapsed().as_secs_f64() / count as f64 * (total - count) as f64) .ceil() as u64 ) } else { "Estimation en cours…".into() }; if n == total { format!( "Chargement de la sortie — {count}/{total} · {ram} Mio dans le présentateur · {eta}" ) } else { format!( "Préparation {} px — {n}/{total} · {ram} Mio · {eta} · {} en cache", self.target_edge, self.cached_slides ) } } pub fn preparation_status(&self) -> String { if self.settings.language.french() { return self.preparation_status_fr(); } if self.loading { return "Opening source and verifying cached slide identity… ETA estimating".into(); } if self.deck.is_none() { return self.status.clone(); } let n = self.prepared.len(); let total = self.count(); let ram = self.buffer_bytes() / (1024 * 1024); if self.notes_loading { return format!( "Reading presenter notes · {n}/{total} slides buffered · playback remains available" ); } if self.fully_buffered() { return format!( "READY — all {total} slides buffered in RAM · {ram} MiB · {} px", self.target_edge ); } if self.evicted_frames > 0 { return self.rolling_status(self.settings.language.french()); } if self.ram_blocked { return format!( "RAM budget reached — {n}/{total} buffered. Cannot fit active frames and render reservations; increase the budget." ); } if !self.failed.is_empty() { return format!( "Preparation incomplete — {n}/{total} buffered; a slide failed. {}", self.status ); } let eta = if n >= 2 && n < total { format!( "~{} s remaining", (self.preparation_started.elapsed().as_secs_f64() / n as f64 * (total - n) as f64) .ceil() as u64 ) } else { "estimating…".into() }; if n == total { format!( "Buffering presentation output — {}/{total} slides · {ram} MiB in presenter RAM · {}", self.output_buffered, if self.output_buffered > 0 { format!( "~{} s remaining", (self.preparation_started.elapsed().as_secs_f64() / self.output_buffered as f64 * total.saturating_sub(self.output_buffered) as f64) .ceil() as u64 ) } else { "ETA estimating…".into() } ) } else { format!( "Preparing {} px — {n}/{total} slides · {ram} MiB · ETA {eta} · {} cached", self.target_edge, self.cached_slides ) } } } #[cfg(test)] mod tests { use super::*; #[test] fn autoplay_times_visible_slides_pauses_and_loops_safely() { let mut s = Studio::new(true, None); s.initialized = true; s.deck = Some(DeckInfo { path: "test.pdf".into(), key: "test".into(), title: "Test".into(), names: vec![String::new(); 3], notes: vec![], warnings: vec![], sha256: String::new(), }); s.settings.autoplay_enabled = true; s.settings.autoplay_seconds = 2.0; s.blanked = false; s.displayed = Some(0); let start = Instant::now(); assert!(!s.poll_autoplay_at(start)); assert!(!s.poll_autoplay_at(start + Duration::from_millis(1999))); assert!(s.poll_autoplay_at(start + Duration::from_secs(2))); assert_eq!(s.requested, 1); // A render/output delay never consumes the new slide's interval. assert!(!s.poll_autoplay_at(start + Duration::from_secs(20))); assert_eq!(s.requested, 1); s.displayed = Some(1); assert!(!s.poll_autoplay_at(start + Duration::from_secs(20))); assert!(s.poll_autoplay_at(start + Duration::from_secs(22))); assert_eq!(s.requested, 2); s.displayed = Some(2); assert!(!s.poll_autoplay_at(start + Duration::from_secs(22))); assert!(!s.poll_autoplay_at(start + Duration::from_secs(24))); assert_eq!(s.requested, 2, "autoplay stops at the final slide"); s.settings.autoplay_loop = true; s.autoplay_settings_changed(); assert!(!s.poll_autoplay_at(start + Duration::from_secs(30))); assert!(s.poll_autoplay_at(start + Duration::from_secs(32))); assert_eq!(s.requested, 0); s.displayed = Some(0); s.blanked = true; assert!(!s.poll_autoplay_at(start + Duration::from_secs(40))); s.blanked = false; assert!(!s.poll_autoplay_at(start + Duration::from_secs(50))); assert!(s.poll_autoplay_at(start + Duration::from_secs(52))); assert_eq!(s.requested, 1, "unblanking starts a fresh interval"); } #[test] fn repeated_navigation_coalesces_rendering_and_clamps_without_blanking() { let mut s = Studio::new(true, None); s.deck = Some(DeckInfo { path: "test.pdf".into(), key: "test".into(), title: "Test".into(), names: vec![String::new(); 500], notes: vec![], warnings: vec![], sha256: String::new(), }); s.blanked = false; s.fg_busy = true; s.fg_job = Some((0, s.target_edge)); for _ in 0..100 { s.execute(Action::Navigate { delta: 10, repeated: true, }); } assert_eq!(s.requested, 499); assert!(!s.blanked); assert!( s.fg_busy, "Repeats must not repeatedly replace renderer workers" ); assert_eq!(s.fg_job, Some((0, s.target_edge))); s.execute(Action::FinishNavigation); assert!(!s.fg_busy && s.fg_job.is_none()); assert!(s.navigation_settle.is_none()); s.execute(Action::Navigate { delta: -10, repeated: true, }); s.poll(); assert!( !s.fg_busy && !s.bg_busy, "Skipped slides must not start render jobs during a hold" ); assert_eq!(s.requested, 489); s.execute(Action::Navigate { delta: -1000, repeated: true, }); assert_eq!(s.requested, 0); s.execute(Action::FinishNavigation); } #[test] fn absent_frames_report_their_actual_load_state() { let mut studio = Studio::new(true, None); assert_eq!(studio.slide_load_state(7), SlideLoadState::Queued); studio.prepared.insert(7); assert_eq!(studio.slide_load_state(7), SlideLoadState::Cached); studio.fg_job = Some((7, studio.target_edge)); assert_eq!(studio.slide_load_state(7), SlideLoadState::Preparing); studio.fg_job = None; studio.failed.insert((7, studio.target_edge)); assert_eq!(studio.slide_load_state(7), SlideLoadState::Failed); } }