Deckstride/crates/deckstride/src/studio.rs

2017 lines
77 KiB
Rust

//! 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<crate::notes::ImportPreview>,
pub busy: bool,
pub error: Option<String>,
}
pub struct NotesEditor {
pub page: usize,
pub text: String,
pub saved_text: String,
pub snapshot: Option<crate::notes::Snapshot>,
pub busy: bool,
pub error: Option<String>,
}
#[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<String, crate::settings::ScreenMode>,
single_screens: Vec<String>,
}
#[derive(Default)]
pub struct PresenterView {
pub layout: Layout,
pub layout_open: bool,
pub layout_target: Option<String>,
pub preferences_open: bool,
pub menu_open: bool,
}
pub struct Studio {
pub settings: Settings,
pub layout: Layout,
pub presenter_views: HashMap<String, PresenterView>,
pub presenter_views_dirty: bool,
pub monitors: Vec<Monitor>,
pub routes: Routes,
pub draft_routes: Routes,
pub draft_single_screens: Vec<String>,
startup_displays_observed: bool,
pub startup_single_screen: Option<String>,
pub draft_screen_modes: std::collections::BTreeMap<String, crate::settings::ScreenMode>,
pub draft_presenter_fullscreen: bool,
pub draft_presentation_fullscreen: bool,
pub route_trial: Option<RouteTrial>,
pub presentation_started: bool,
next_route_trial: u64,
pub deck: Option<DeckInfo>,
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,
pub frames: HashMap<(usize, u32), Arc<Frame>>,
pub prepared: HashSet<usize>,
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<NotesImport>,
pub notes_editor: Option<NotesEditor>,
notes_io: Bridge,
notes_edited: bool,
pub visible_thumbs: HashSet<usize>,
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<Action>,
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<Instant>,
autoplay_deadline: Option<Instant>,
autoplay_finished: bool,
pub fg: Bridge,
pub bg: Bridge,
pub io: Bridge,
pub dialog: Bridge,
pub dialog_busy: bool,
pub dialog_owner: Option<isize>,
fg_busy: bool,
bg_busy: bool,
fg_job: Option<(usize, u32)>,
bg_job: Option<(usize, u32)>,
notes_pending: bool,
pending_open: Option<PathBuf>,
pending_save: bool,
pub initialized: bool,
pub open_path: Option<PathBuf>,
pub dirty_routes: bool,
pub privacy_hold: bool,
pub output_sequence: u64,
pub zoom: crate::zoom::Sync,
pub output_viewport: Option<crate::output::OutputViewport>,
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<tempfile::TempDir>,
worker_program: PathBuf,
}
impl Studio {
pub fn new(smoke: bool, open_path: Option<PathBuf>) -> Self {
Self::with_program(
smoke,
open_path,
std::env::current_exe().unwrap_or_default(),
)
}
pub fn with_program(smoke: bool, open_path: Option<PathBuf>, 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<Arc<Frame>> {
[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<Arc<Frame>> {
[self.target_edge, 512, 1280]
.iter()
.find_map(|&edge| self.frames.get(&(page, edge)).cloned())
}
pub fn frame_info(&self) -> Option<FrameInfo> {
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<Monitor>, primary: usize) {
let ids = monitors.iter().map(|m| m.id.clone()).collect::<Vec<_>>();
let changed = self
.monitors
.iter()
.map(|m| (&m.id, m.origin, m.size))
.collect::<Vec<_>>()
!= monitors
.iter()
.map(|m| (&m.id, m.origin, m.size))
.collect::<Vec<_>>();
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<Duration> {
(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<u64>) {
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<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) {
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);
}
}