Deckstride/crates/deckstride/tests/presenter_ui.rs

2476 lines
88 KiB
Rust

use deckstride::{
document::{DeckInfo, Frame, FrameInfo},
presenter_ui::{self, UiState},
studio::{Action, Monitor, Studio},
};
use egui::{Context, Pos2, RawInput, Rect, Vec2};
use std::{collections::HashMap, sync::Arc};
fn studio() -> Studio {
let mut s = Studio::new(true, None);
s.initialized = true;
s.deck = Some(DeckInfo {
path: "demo.pdf".into(),
key: "demo".into(),
title: "Demo".into(),
names: (1..=30).map(|i| format!("Slide {i}")).collect(),
notes: vec!["A long note with unbrokenwordsandUnicodeé漢字. ".repeat(80); 30],
warnings: vec![],
sha256: "test".into(),
});
s.monitors = vec![
Monitor {
id: "one".into(),
name: "Primary".into(),
origin: (0, 0),
size: (1920, 1080),
},
Monitor {
id: "two".into(),
name: "Secondary".into(),
origin: (1920, 0),
size: (1920, 1080),
},
];
s.routes.presenter = vec!["one".into()];
s.routes.presentation = vec!["two".into()];
s.draft_routes = s.routes.clone();
s.frames = HashMap::from([(
(0, 1280),
Arc::new(Frame {
info: FrameInfo {
page: 0,
width: 64,
height: 36,
path: "cached.rgba".into(),
sha256: "test".into(),
},
rgba: vec![255; 64 * 36 * 4],
}),
)]);
s
}
fn input(size: Vec2) -> RawInput {
RawInput {
screen_rect: Some(Rect::from_min_size(Pos2::ZERO, size)),
..Default::default()
}
}
#[test]
fn native_ui_renders_real_previews_notes_and_all_control_panels() {
let ctx = Context::default();
presenter_ui::theme(&ctx);
let mut s = studio();
let mut ui = UiState::default();
for size in [Vec2::new(1280., 900.), Vec2::new(800., 600.)] {
for panel in 0..5 {
s.menu_open = panel == 1;
s.layout_open = panel == 2;
s.displays_open = panel == 3;
s.preferences_open = panel == 4;
s.jump = "12".into();
let output = ctx.run_ui(input(size), |root| {
presenter_ui::presenter(root, &mut s, &mut ui)
});
assert!(!output.shapes.is_empty());
assert!(
!ctx.tessellate(output.shapes, output.pixels_per_point)
.is_empty()
);
}
}
s.menu_open = false;
s.layout_open = false;
s.displays_open = false;
s.layout.previous.show = false;
s.layout.current.show = false;
s.layout.next.show = false;
s.layout.header = false;
s.layout.footer = false;
let output = ctx.run_ui(input(Vec2::new(1000., 700.)), |root| {
presenter_ui::presenter(root, &mut s, &mut ui)
});
assert!(!output.shapes.is_empty());
s.layout.notes.show = false;
let output = ctx.run_ui(input(Vec2::new(1000., 700.)), |root| {
presenter_ui::presenter(root, &mut s, &mut ui)
});
assert!(!output.shapes.is_empty());
}
#[test]
fn browser_virtualizes_thumbnails_without_changing_presented_slide() {
let ctx = Context::default();
let mut s = studio();
let mut ui = UiState::default();
s.requested = 3;
s.browser_selected = 8;
s.deck.as_mut().unwrap().names = (0..1000).map(|i| format!("Slide {i}")).collect();
for size in [100., 220., 400.] {
s.settings.thumbnail_size = size;
let output = ctx.run_ui(input(Vec2::new(900., 650.)), |root| {
presenter_ui::browser(root, &mut s, &mut ui)
});
assert!(!output.shapes.is_empty());
assert!(!s.visible_thumbs.is_empty());
assert!(s.visible_thumbs.len() < 100);
assert_eq!(s.requested, 3);
}
}
#[test]
fn shared_actions_preserve_blanking_and_save_scope() {
let mut s = studio();
s.blanked = true;
s.execute(Action::Go(5));
assert_eq!(s.requested, 5);
assert!(s.blanked);
s.execute(Action::Go(99));
assert_eq!(s.requested, 5);
s.execute(Action::Blank);
assert!(!s.blanked);
s.layout.current.show = false;
s.execute(Action::SaveProject);
assert!(!s.settings.projects["demo"].current.show);
s.execute(Action::SaveGlobal);
assert!(!s.settings.layout.current.show);
s.execute(Action::UseGlobal);
assert!(!s.settings.projects.contains_key("demo"));
s.execute(Action::OpenBrowser);
assert_eq!(s.browser_selected, 5);
assert!(!s.change_on_click);
s.execute(Action::CloseBrowser);
assert!(!s.browser_open);
s.execute(Action::ToggleFullscreen);
assert!(!s.presenter_fullscreen());
s.execute(Action::KeepRoutes);
assert!(!s.blanked);
assert!(!s.settings.presenter_fullscreen);
s.draft_routes.presenter.clear();
s.execute(Action::ApplyRoutes);
assert!(s.status.contains("presenter"));
s.draft_routes = s.routes.clone();
s.execute(Action::ApplyRoutes);
assert!(!s.blanked);
s.execute(Action::Refresh);
assert!(s.dirty_routes);
s.execute(Action::Exit);
assert!(s.quit_confirmation && !s.close_requested);
s.execute(Action::ConfirmExit);
assert!(s.close_requested);
}
#[test]
fn lost_operator_screen_never_becomes_notes_on_previous_public_output() {
let mut s = studio();
s.settings.routes = s.routes.clone();
s.set_monitors(vec![s.monitors[1].clone()], 0);
assert!(s.routes.presenter.is_empty());
assert!(s.privacy_hold);
assert!(!s.blanked);
let monitors = studio().monitors;
s.set_monitors(monitors, 0);
assert!(!s.privacy_hold);
assert_eq!(s.routes.presenter, vec!["one"]);
}
#[test]
fn palettes_and_languages_apply_to_presenter_browser_and_popups() {
use deckstride::{
localization::{Language, apply, tr},
theme::Theme,
};
let ctx = Context::default();
let mut s = studio();
let mut ui = UiState::default();
for theme in Theme::ALL {
theme.apply(&ctx);
assert_eq!(
ctx.global_style().visuals.text_color(),
theme.palette().text
);
for language in Language::ALL {
apply(&ctx, &language);
if language == Language::Fr {
assert_eq!(tr(&ctx, "Displays"), "Écrans");
}
s.menu_open = true;
s.displays_open = true;
s.layout_open = true;
let output = ctx.run_ui(input(Vec2::new(1400., 1000.)), |root| {
presenter_ui::presenter(root, &mut s, &mut ui)
});
assert!(!output.shapes.is_empty());
let output = ctx.run_ui(input(Vec2::new(1000., 700.)), |root| {
presenter_ui::browser(root, &mut s, &mut ui)
});
assert!(!output.shapes.is_empty());
}
}
}
#[test]
fn startup_output_is_enabled_and_disconnect_preserves_visibility() {
let mut s = Studio::new(true, None);
assert!(!s.blanked);
let monitors = studio().monitors;
s.set_monitors(monitors.clone(), 0);
assert!(!s.blanked);
s.set_monitors(vec![monitors[0].clone()], 0);
assert!(!s.blanked);
let mut opt_out = Studio::new(true, None);
opt_out.settings.auto_show = false;
opt_out.set_monitors(monitors, 0);
assert!(opt_out.blanked);
}
#[test]
fn header_click_opens_slide_browser_and_menu_dropdown() {
fn text_position(shapes: &[egui::epaint::ClippedShape], label: &str) -> Pos2 {
fn find(shape: &egui::Shape, label: &str) -> Option<Pos2> {
match shape {
egui::Shape::Text(t) if t.galley.text() == label => {
Some(t.pos + t.galley.size() * 0.5)
}
egui::Shape::Vec(shapes) => shapes.iter().find_map(|s| find(s, label)),
_ => None,
}
}
shapes.iter().find_map(|s| find(&s.shape, label)).unwrap()
}
let ctx = Context::default();
let mut s = studio();
let mut native = UiState::default();
let size = Vec2::new(1920., 1080.);
for label in ["All slides", "Menu"] {
let mut output = ctx.run_ui(input(size), |ui| {
presenter_ui::presenter(ui, &mut s, &mut native)
});
for _ in 0..2 {
output = ctx.run_ui(input(size), |ui| {
presenter_ui::presenter(ui, &mut s, &mut native)
});
}
let pos = text_position(&output.shapes, label);
for pressed in [true, false] {
let mut raw = input(size);
raw.events = vec![
egui::Event::PointerMoved(pos),
egui::Event::PointerButton {
pos,
button: egui::PointerButton::Primary,
pressed,
modifiers: Default::default(),
},
];
let _ = ctx.run_ui(raw, |ui| presenter_ui::presenter(ui, &mut s, &mut native));
}
if label == "All slides" {
assert!(
s.actions.iter().any(|a| matches!(a, Action::OpenBrowser)),
"All slides click at {pos:?} must dispatch an action"
);
} else {
assert!(s.menu_open, "Menu click must open the anchored dropdown");
}
}
}
#[test]
fn display_changes_require_confirmation_and_timeout_restores_previous_setup() {
let mut s = studio();
s.settings.routes = s.routes.clone();
let original = s.routes.clone();
s.begin_display_edit();
s.draft_presenter_fullscreen = false;
s.draft_presentation_fullscreen = false;
std::mem::swap(
&mut s.draft_routes.presenter,
&mut s.draft_routes.presentation,
);
s.execute(Action::ApplyRoutes);
assert_ne!(s.routes, original);
assert_eq!(s.settings.routes, original);
assert!(s.settings.presenter_fullscreen);
assert!(!s.presenter_fullscreen());
assert!(!s.blanked);
s.execute(Action::Blank);
s.execute(Action::Go(5));
assert!(s.blanked);
assert_eq!(s.requested, 0);
// Render the modal even with the ordinary bars hidden.
s.layout.header = false;
s.layout.footer = false;
let ctx = Context::default();
let _ = ctx.run_ui(input(Vec2::new(1280., 720.)), |ui| {
presenter_ui::presenter(ui, &mut s, &mut UiState::default())
});
s.route_trial.as_mut().unwrap().deadline = std::time::Instant::now();
s.poll();
assert!(s.route_trial.is_none());
assert_eq!(s.routes, original);
assert_eq!(s.settings.routes, original);
assert!(s.presenter_fullscreen());
assert!(s.blanked);
s.execute(Action::RevertRoutes); // Idempotent recovery.
assert_eq!(s.routes, original);
s.begin_display_edit();
s.draft_presenter_fullscreen = false;
s.draft_presentation_fullscreen = false;
s.execute(Action::ApplyRoutes);
s.execute(Action::KeepRoutes);
assert!(!s.settings.presenter_fullscreen);
assert!(!s.settings.presentation_fullscreen);
}
#[test]
fn recovery_commands_are_scoped_to_the_current_trial_and_startup() {
use deckstride::output::DisplayAction;
let mut s = studio();
s.settings.routes = s.routes.clone();
let original = s.routes.clone();
s.display_control(DisplayAction::Swap, None);
let old_id = s.route_trial.as_ref().unwrap().id;
s.display_control(DisplayAction::Keep, Some(old_id + 1));
assert!(s.route_trial.is_some());
assert_eq!(s.settings.routes, original);
s.display_control(DisplayAction::Revert, Some(old_id));
assert_eq!(s.routes, original);
s.display_control(DisplayAction::Swap, None);
let new_id = s.route_trial.as_ref().unwrap().id;
assert_ne!(new_id, old_id);
s.display_control(DisplayAction::Keep, Some(old_id));
assert!(s.route_trial.is_some());
s.display_control(DisplayAction::Keep, Some(new_id));
assert!(s.route_trial.is_none());
assert_eq!(s.settings.routes, s.routes);
assert_ne!(s.routes, original);
s.execute(Action::Go(0));
let confirmed = s.routes.clone();
s.display_control(DisplayAction::Swap, None);
assert!(s.route_trial.is_none());
assert_eq!(s.routes, confirmed);
// Explicit display editing remains available after startup.
s.begin_display_edit();
s.draft_routes = original;
s.execute(Action::ApplyRoutes);
s.route_trial.as_mut().unwrap().deadline = std::time::Instant::now();
s.execute(Action::KeepRoutes); // A late click must revert, never save.
assert!(s.route_trial.is_none());
assert_eq!(s.settings.routes, confirmed);
assert_eq!(s.routes, confirmed);
}
#[test]
fn hotplug_cancels_a_display_trial_without_saving_the_proposal() {
let mut s = studio();
s.settings.routes = s.routes.clone();
let saved = s.settings.routes.clone();
s.execute(Action::SwapRoutes);
assert!(s.route_trial.is_some());
s.set_monitors(vec![s.monitors[0].clone()], 0);
assert!(s.route_trial.is_none());
assert_eq!(s.settings.routes, saved);
assert!(!s.blanked);
assert!(!s.routes.presentation.contains(&"two".to_owned()));
}
#[test]
fn output_recovery_buttons_dispatch_without_presenter_data() {
fn find(shape: &egui::Shape, label: &str) -> Option<Pos2> {
match shape {
egui::Shape::Text(t) if t.galley.text() == label => Some(t.pos + t.galley.size() * 0.5),
egui::Shape::Vec(shapes) => shapes.iter().find_map(|s| find(s, label)),
_ => None,
}
}
for (label, trial) in [
("Keep changes", true),
("Revert now", true),
("Swap Presenter and Slides screens…", false),
] {
let ctx = Context::default();
let size = Vec2::new(1280., 720.);
let mut action = None;
let mut output = ctx.run_ui(input(size), |ui| {
action = presenter_ui::output_display_recovery(ui, true, trial);
});
if !trial {
for pressed in [true, false] {
let pos = Pos2::new(300., 300.);
let mut raw = input(size);
raw.events = vec![
egui::Event::PointerMoved(pos),
egui::Event::PointerButton {
pos,
button: egui::PointerButton::Secondary,
pressed,
modifiers: Default::default(),
},
];
output = ctx.run_ui(raw, |ui| {
action = presenter_ui::output_display_recovery(ui, true, false);
});
}
}
for _ in 0..3 {
output = ctx.run_ui(input(size), |ui| {
action = presenter_ui::output_display_recovery(ui, true, trial);
});
}
let pos = output
.shapes
.iter()
.find_map(|s| find(&s.shape, label))
.expect(label);
for pressed in [true, false] {
let mut raw = input(size);
raw.events = vec![
egui::Event::PointerMoved(pos),
egui::Event::PointerButton {
pos,
button: egui::PointerButton::Primary,
pressed,
modifiers: Default::default(),
},
];
let _ = ctx.run_ui(raw, |ui| {
action = presenter_ui::output_display_recovery(ui, true, trial);
});
}
use deckstride::output::DisplayAction;
assert!(matches!(
(label, action),
("Keep changes", Some(DisplayAction::Keep))
| ("Revert now", Some(DisplayAction::Revert))
| (
"Swap Presenter and Slides screens…",
Some(DisplayAction::Swap)
)
));
let output = ctx.run_ui(input(size), |ui| {
action = presenter_ui::output_display_recovery(ui, false, false);
});
assert!(action.is_none());
assert!(
output
.shapes
.iter()
.all(|s| find(&s.shape, label).is_none())
);
}
}
#[test]
fn quick_settings_and_preferences_window_remain_interactive() {
fn position(shapes: &[egui::epaint::ClippedShape], label: &str) -> Pos2 {
fn find(shape: &egui::Shape, label: &str) -> Option<Pos2> {
match shape {
egui::Shape::Text(t) if t.galley.text() == label => {
Some(t.pos + t.galley.size() * 0.5)
}
egui::Shape::Vec(shapes) => shapes.iter().find_map(|s| find(s, label)),
_ => None,
}
}
shapes
.iter()
.find_map(|s| find(&s.shape, label))
.unwrap_or_else(|| panic!("Missing menu entry: {label}"))
}
let ctx = Context::default();
let mut s = studio();
s.settings.language = deckstride::localization::Language::En;
let mut native = UiState::default();
let mut frame = |s: &mut Studio, events| {
let mut raw = input(Vec2::new(1920., 1080.));
raw.events = events;
ctx.run_ui(raw, |ui| presenter_ui::presenter(ui, s, &mut native))
};
let mut click = |s: &mut Studio, label: &str| {
let mut output = frame(s, vec![]);
for _ in 0..3 {
output = frame(s, vec![]);
}
let pos = position(&output.shapes, label);
for pressed in [true, false] {
frame(
s,
vec![
egui::Event::PointerMoved(pos),
egui::Event::PointerButton {
pos,
button: egui::PointerButton::Primary,
pressed,
modifiers: Default::default(),
},
],
);
}
};
click(&mut s, "Menu");
click(&mut s, "Autoplay");
click(&mut s, "Play automatically");
assert!(s.settings.autoplay_enabled);
assert!(s.menu_open);
click(&mut s, "Loop");
assert!(s.settings.autoplay_loop);
assert!(s.menu_open);
click(&mut s, "Menu");
click(&mut s, "Menu");
click(&mut s, "Appearance");
click(&mut s, "Midra Dark");
assert!(
s.menu_open,
"Opening a theme selector must keep its parents open"
);
click(&mut s, "High Contrast");
assert_eq!(s.settings.theme, deckstride::theme::Theme::HighContrast);
assert!(s.menu_open);
click(&mut s, "English");
click(&mut s, "System language");
assert_eq!(
s.settings.language,
deckstride::localization::Language::System
);
assert!(s.menu_open);
let zoom_enabled = s.settings.zoom_enabled;
click(&mut s, "Enable page zoom");
assert_eq!(s.settings.zoom_enabled, !zoom_enabled);
assert!(s.menu_open);
let fitted = s.settings.zoom_keep_fitted_area;
click(&mut s, "Keep fitted page area when zooming");
assert_eq!(s.settings.zoom_keep_fitted_area, !fitted);
assert!(s.menu_open);
let auto_show = s.settings.auto_show;
click(&mut s, "Show slides automatically when opening a document");
assert_eq!(s.settings.auto_show, !auto_show);
assert!(s.menu_open);
click(&mut s, "Preferences…");
assert!(s.preferences_open);
assert!(!s.menu_open);
click(&mut s, "Expunge unused cache now");
assert!(s.cache_busy, "The Preferences window must submit cleanup");
assert!(s.preferences_open);
click(&mut s, "Close");
assert!(!s.preferences_open);
click(&mut s, "Reset timer");
assert!(!s.timer.running(std::time::Instant::now(), s.timer_limit()));
assert!(
!s.menu_open,
"Clicking the header command should dismiss the dropdown"
);
click(&mut s, "Start timer");
assert!(s.timer.running(std::time::Instant::now(), s.timer_limit()));
click(&mut s, "Pause timer");
assert!(!s.timer.running(std::time::Instant::now(), s.timer_limit()));
click(&mut s, "Menu");
click(&mut s, "demo.pdf");
assert!(!s.menu_open, "Outside click should dismiss the dropdown");
click(&mut s, "Menu");
frame(
&mut s,
vec![egui::Event::Key {
key: egui::Key::Escape,
physical_key: None,
pressed: true,
repeat: false,
modifiers: Default::default(),
}],
);
assert!(!s.menu_open, "Escape should dismiss the dropdown");
}
#[test]
fn timer_presets_reserve_space_and_progress_tracks_navigation() {
use deckstride::settings::TimerPosition;
fn text_rect(shapes: &[egui::epaint::ClippedShape], label: &str) -> Option<Rect> {
fn find(shape: &egui::Shape, label: &str) -> Option<Rect> {
match shape {
egui::Shape::Text(t) if t.galley.text() == label => {
Some(Rect::from_min_size(t.pos, t.galley.size()))
}
egui::Shape::Vec(shapes) => shapes.iter().find_map(|s| find(s, label)),
_ => None,
}
}
shapes.iter().find_map(|s| find(&s.shape, label))
}
let ctx = Context::default();
let mut s = studio();
let mut native = UiState::default();
s.layout.header = false;
s.layout.footer = false;
s.layout.elapsed_position = TimerPosition::AboveSlides;
s.layout.clock_position = TimerPosition::BelowNotes;
s.layout.elapsed.size = 72.;
s.layout.clock.size = 72.;
let mut render = |s: &mut Studio| {
let mut output = ctx.run_ui(input(Vec2::new(1280., 900.)), |ui| {
presenter_ui::presenter(ui, s, &mut native)
});
for _ in 0..3 {
output = ctx.run_ui(input(Vec2::new(1280., 900.)), |ui| {
presenter_ui::presenter(ui, s, &mut native)
});
}
output
};
let output = render(&mut s);
let elapsed = text_rect(&output.shapes, "Elapsed time").unwrap();
let clock = text_rect(&output.shapes, "Time · HH:MM").unwrap();
let current = text_rect(&output.shapes, "CURRENT 1 / 30").unwrap();
assert!(elapsed.bottom() < current.top());
assert!(clock.top() > current.bottom());
assert!(
text_rect(&output.shapes, "00:00").unwrap().height() >= 65.,
"the above-slides timer must use its configured size, not button-row height"
);
let clock_value = chrono::Local::now().format("%H:%M").to_string();
assert!(text_rect(&output.shapes, &clock_value).unwrap().height() >= 65.);
for font_size in [28., 72., 160.] {
s.layout.header = true;
s.layout.elapsed_position = TimerPosition::Header;
s.layout.clock_position = TimerPosition::Header;
s.layout.elapsed.size = font_size;
s.layout.clock.size = font_size;
let header = render(&mut s);
let elapsed = text_rect(&header.shapes, "00:00").unwrap();
assert!(
elapsed.height() >= font_size * 0.85,
"header font {font_size}: {elapsed:?}"
);
assert!(elapsed.bottom() < text_rect(&header.shapes, "CURRENT 1 / 30").unwrap().top());
}
s.layout.header = false;
s.layout.elapsed_position = TimerPosition::AboveSlides;
s.layout.clock_position = TimerPosition::BelowNotes;
s.layout.elapsed.size = 72.;
s.layout.clock.size = 72.;
assert!(text_rect(&output.shapes, "Slide 1 / 30").is_none());
s.layout.slide_progress = true;
for page in [0, 14, 29] {
s.requested = page;
let output = render(&mut s);
let progress = text_rect(&output.shapes, &format!("Slide {} / 30", page + 1)).unwrap();
assert!(progress.top() > text_rect(&output.shapes, "Time · HH:MM").unwrap().bottom());
}
s.requested = 0;
s.layout.elapsed.size = 320.;
s.layout.clock.size = 320.;
for (left, right, anchor) in [
(
TimerPosition::LeftOfSlides,
TimerPosition::RightOfSlides,
"CURRENT 1 / 30",
),
(
TimerPosition::LeftOfNotes,
TimerPosition::RightOfNotes,
"PRESENTER NOTES · AUTO-FIT",
),
] {
s.layout.elapsed_position = left;
s.layout.clock_position = right;
let output = render(&mut s);
let elapsed = text_rect(&output.shapes, "Elapsed time").unwrap();
let clock = text_rect(&output.shapes, "Time · HH:MM").unwrap();
let pane = text_rect(&output.shapes, anchor).unwrap();
assert!(elapsed.right() < pane.left());
assert!(clock.left() > pane.right());
assert!(text_rect(&output.shapes, "00:00").unwrap().height() > 72.);
// Sharing a side stacks the controls without overlapping their labels.
s.layout.clock_position = left;
let output = render(&mut s);
let elapsed = text_rect(&output.shapes, "Elapsed time").unwrap();
let clock = text_rect(&output.shapes, "Time · HH:MM").unwrap();
assert!(clock.top() > elapsed.bottom());
assert!((clock.left() - elapsed.left()).abs() < 1.);
}
s.deck = None;
assert!(text_rect(&render(&mut s).shapes, "Slide 0 / 0").is_some());
s.layout.elapsed.show = false;
s.layout.clock.show = false;
let output = render(&mut s);
assert!(text_rect(&output.shapes, "Elapsed time").is_none());
assert!(text_rect(&output.shapes, "Time · HH:MM").is_none());
}
#[test]
fn end_of_slides_is_only_a_presenter_next_preview_not_a_page() {
fn count_text(shape: &egui::Shape, label: &str) -> usize {
match shape {
egui::Shape::Text(t) => usize::from(t.galley.text() == label),
egui::Shape::Vec(shapes) => shapes.iter().map(|s| count_text(s, label)).sum(),
_ => 0,
}
}
let ctx = Context::default();
let mut s = studio();
s.settings.language = deckstride::localization::Language::En;
let mut native = UiState::default();
for (total, requested, next_visible, expected) in [
(3, 0, true, 0),
(3, 1, true, 0),
(3, 2, true, 1),
(3, 2, false, 0),
(1, 0, true, 1),
(0, 0, true, 0),
] {
s.deck.as_mut().unwrap().names = (0..total).map(|i| i.to_string()).collect();
s.requested = requested;
s.layout.next.show = next_visible;
let output = ctx.run_ui(input(Vec2::new(1280., 900.)), |ui| {
presenter_ui::presenter(ui, &mut s, &mut native);
});
assert_eq!(
output
.shapes
.iter()
.map(|s| count_text(&s.shape, "End of slides"))
.sum::<usize>(),
expected
);
assert_eq!(s.count(), total);
s.execute(Action::Go(total));
assert_eq!(
s.requested, requested,
"The placeholder cannot be navigated to"
);
let output = ctx.run_ui(input(Vec2::new(1280., 900.)), |ui| {
presenter_ui::browser(ui, &mut s, &mut native);
});
assert_eq!(
output
.shapes
.iter()
.map(|s| count_text(&s.shape, "End of slides"))
.sum::<usize>(),
0
);
}
}
#[test]
fn browser_double_click_previews_without_live_navigation() {
fn find(shape: &egui::Shape) -> Option<Pos2> {
match shape {
egui::Shape::Text(t) if t.galley.text() == "2" => Some(t.pos + Vec2::new(40., -45.)),
egui::Shape::Vec(shapes) => shapes.iter().find_map(find),
_ => None,
}
}
for live in [false, true] {
let ctx = Context::default();
let mut s = studio();
s.change_on_click = live;
s.browser_open = true;
let mut native = UiState::default();
let mut time = 0.;
let mut frame = |s: &mut Studio, events| {
time += 0.03;
let mut raw = input(Vec2::new(1280., 900.));
raw.time = Some(time);
raw.events = events;
ctx.run_ui(raw, |ui| presenter_ui::browser(ui, s, &mut native))
};
let mut output = frame(&mut s, vec![]);
for _ in 0..3 {
output = frame(&mut s, vec![]);
}
let pos = output.shapes.iter().find_map(|s| find(&s.shape)).unwrap();
for _ in 0..2 {
for pressed in [true, false] {
frame(
&mut s,
vec![
egui::Event::PointerMoved(pos),
egui::Event::PointerButton {
pos,
button: egui::PointerButton::Primary,
pressed,
modifiers: Default::default(),
},
],
);
}
}
assert_eq!(s.browser_selected, 1);
assert_eq!(s.requested, 0);
if live {
assert!(s.browser_preview.is_none());
assert!(s.actions.iter().any(|a| matches!(a, Action::Go(1))));
} else {
assert_eq!(s.browser_preview, Some((s.generation, 1)));
assert!(s.actions.is_empty());
s.generation += 1;
frame(&mut s, vec![]);
assert!(s.browser_preview.is_none());
s.browser_preview = Some((s.generation, 1));
s.change_on_click = true;
frame(&mut s, vec![]);
assert!(s.browser_preview.is_none());
s.browser_preview = Some((s.generation, 1));
s.execute(Action::CloseBrowser);
assert!(s.browser_preview.is_none());
}
}
}
#[test]
fn browser_thumbnails_fill_resized_window_without_stretching_tiles() {
fn collect(shape: &egui::Shape, rects: &mut Vec<Rect>) {
match shape {
egui::Shape::Rect(r) if r.fill == egui::Color32::from_rgb(18, 28, 31) => {
rects.push(r.rect)
}
egui::Shape::Vec(shapes) => shapes.iter().for_each(|s| collect(s, rects)),
_ => {}
}
}
let mut s = studio();
s.deck.as_mut().unwrap().names = (0..1000).map(|i| format!("Slide {i}")).collect();
for width in [500., 900., 1600.] {
let ctx = Context::default();
presenter_ui::theme(&ctx);
let mut native = UiState::default();
let mut right = 0.;
let mut output = ctx.run_ui(input(Vec2::new(width, 900.)), |ui| {
right = ui.max_rect().right();
presenter_ui::browser(ui, &mut s, &mut native);
});
for _ in 0..3 {
output = ctx.run_ui(input(Vec2::new(width, 900.)), |ui| {
right = ui.max_rect().right();
presenter_ui::browser(ui, &mut s, &mut native);
});
}
let mut rects = vec![];
for shape in &output.shapes {
collect(&shape.shape, &mut rects);
}
fn right_edge_rects(
shape: &egui::Shape,
right: f32,
found: &mut Vec<(Rect, egui::Color32)>,
) {
match shape {
egui::Shape::Rect(rect) if rect.rect.right() > right - 20. => {
found.push((rect.rect, rect.fill));
}
egui::Shape::Vec(shapes) => {
shapes
.iter()
.for_each(|shape| right_edge_rects(shape, right, found));
}
_ => {}
}
}
let mut edge = vec![];
for shape in &output.shapes {
right_edge_rects(&shape.shape, right, &mut edge);
}
let handles = edge
.iter()
.filter(|(rect, fill)| {
*fill == egui::Color32::from_rgb(70, 210, 175)
&& (rect.width() - 8.).abs() < 0.1
&& rect.height() >= 36.
})
.map(|(rect, _)| *rect)
.collect::<Vec<_>>();
assert_eq!(
handles.len(),
1,
"an explicit scrollbar handle must be painted"
);
assert!(!rects.is_empty());
let max_right = rects.iter().map(Rect::right).fold(0., f32::max);
// A wide, non-floating scrollbar owns the far-right gutter.
assert!((max_right + 16. - right).abs() < 1.);
for rect in &rects {
assert!((rect.height() / rect.width() - 0.5625).abs() < 0.001);
assert!(rect.right() <= right);
}
assert!(s.visible_thumbs.len() < s.count());
let initial_top = handles[0].top();
let mut scrolled_input = input(Vec2::new(width, 900.));
scrolled_input.events = vec![
egui::Event::PointerMoved(egui::pos2(width / 2., 400.)),
egui::Event::MouseWheel {
unit: egui::MouseWheelUnit::Point,
phase: egui::TouchPhase::Move,
delta: Vec2::new(0., -5_000.),
modifiers: egui::Modifiers::NONE,
},
];
let _ = ctx.run_ui(scrolled_input, |ui| {
presenter_ui::browser(ui, &mut s, &mut native);
});
// The scroll area's viewport reflects the new offset on the next frame.
output = ctx.run_ui(input(Vec2::new(width, 900.)), |ui| {
presenter_ui::browser(ui, &mut s, &mut native);
});
let mut scrolled_edge = vec![];
for shape in &output.shapes {
right_edge_rects(&shape.shape, right, &mut scrolled_edge);
}
let scrolled_handle = scrolled_edge
.iter()
.find(|(rect, fill)| {
*fill == egui::Color32::from_rgb(70, 210, 175) && (rect.width() - 8.).abs() < 0.1
})
.map(|(rect, _)| *rect)
.expect("scrollbar handle remains visible after scrolling");
assert!(scrolled_handle.top() > initial_top);
assert!(!s.visible_thumbs.contains(&0));
}
}
#[test]
fn floating_windows_can_grow_and_shrink_after_content_is_drawn() {
for id in ["layout-window", "displays-window", "slide-preview"] {
let ctx = Context::default();
let mut s = studio();
s.layout_open = id == "layout-window";
s.displays_open = id == "displays-window";
if id == "slide-preview" {
s.browser_preview = Some((s.generation, 0));
}
let mut native = UiState::default();
let mut frame = |events| {
let mut raw = input(Vec2::new(1920., 1200.));
raw.events = events;
let _ = ctx.run_ui(raw, |ui| {
if id == "slide-preview" {
presenter_ui::browser(ui, &mut s, &mut native);
} else {
presenter_ui::presenter(ui, &mut s, &mut native);
}
});
};
for _ in 0..4 {
frame(vec![]);
}
let rect = || ctx.memory(|m| m.area_rect(egui::Id::new(id))).unwrap();
for delta in [Vec2::new(120., 80.), Vec2::new(-180., -180.)] {
let before = rect();
let start = before.right_bottom() - Vec2::splat(2.);
frame(vec![egui::Event::PointerMoved(start)]);
frame(vec![egui::Event::PointerButton {
pos: start,
button: egui::PointerButton::Primary,
pressed: true,
modifiers: Default::default(),
}]);
let end = start + delta;
frame(vec![egui::Event::PointerMoved(end)]);
frame(vec![egui::Event::PointerButton {
pos: end,
button: egui::PointerButton::Primary,
pressed: false,
modifiers: Default::default(),
}]);
for _ in 0..4 {
frame(vec![]);
}
let after = rect();
if delta.x > 0. {
assert!(
after.width() > before.width() + 50.,
"{id}: {before:?} -> {after:?}"
);
assert!(
after.height() > before.height() + 30.,
"{id}: {before:?} -> {after:?}"
);
} else {
assert!(
after.width() < before.width() - 50.,
"{id}: {before:?} -> {after:?}"
);
assert!(
after.height() < before.height() - 50.,
"{id}: {before:?} -> {after:?}"
);
}
}
}
}
#[test]
fn fullscreen_button_trials_both_directions_and_can_revert() {
let mut s = studio();
s.execute(Action::ToggleFullscreen);
assert!(!s.presenter_fullscreen() && !s.presentation_fullscreen());
assert!(s.settings.presenter_fullscreen);
s.execute(Action::RevertRoutes);
assert!(s.presenter_fullscreen());
s.execute(Action::ToggleFullscreen);
s.execute(Action::KeepRoutes);
assert!(!s.settings.presenter_fullscreen);
s.execute(Action::ToggleFullscreen);
assert!(s.presenter_fullscreen() && s.presentation_fullscreen());
s.execute(Action::KeepRoutes);
assert!(s.settings.presenter_fullscreen && s.settings.presentation_fullscreen);
}
#[test]
fn timer_waits_for_activity_reset_rearms_and_pause_stays_paused() {
use std::time::Instant;
let mut s = studio();
s.blanked = true;
s.execute(Action::Go(1));
assert!(s.timer.running(Instant::now(), s.timer_limit()));
s.blanked = false;
assert!(s.timer.running(Instant::now(), s.timer_limit()));
s.execute(Action::ToggleTimer);
s.presentation_action();
assert!(!s.timer.running(Instant::now(), s.timer_limit()));
s.execute(Action::ResetTimer);
assert!(!s.timer.running(Instant::now(), s.timer_limit()));
s.settings.zoom_enabled = true;
s.set_zoom_from_action(deckstride::zoom::View {
scale: 2.,
center: [0.5; 2],
});
assert!(s.timer.running(Instant::now(), s.timer_limit()));
s.timer = Default::default();
s.layout.timer_autostart = false;
s.presentation_action();
assert!(!s.timer.running(Instant::now(), s.timer_limit()));
s.timer = Default::default();
s.layout.timer_autostart = true;
s.routes.presentation.clear();
s.execute(Action::Go(s.requested));
assert!(!s.timer.running(Instant::now(), s.timer_limit()));
s.execute(Action::Blank);
assert!(s.timer.running(Instant::now(), s.timer_limit()));
}
#[test]
fn progress_bar_height_changes_rendered_geometry() {
let ctx = Context::default();
let mut s = studio();
let mut native = UiState::default();
s.layout.header = false;
s.layout.footer = false;
s.layout.slide_progress = true;
for height in [8., 24., 80., 120.] {
s.layout.slide_progress_height = height;
let output = ctx.run_ui(input(Vec2::new(1280., 900.)), |ui| {
presenter_ui::presenter(ui, &mut s, &mut native)
});
fn contains_bar(shape: &egui::Shape, height: f32) -> bool {
match shape {
egui::Shape::Rect(r) => {
r.rect.width() > 1200. && (r.rect.height() - height).abs() < 1.
}
egui::Shape::Vec(shapes) => shapes.iter().any(|s| contains_bar(s, height)),
_ => false,
}
}
assert!(
output.shapes.iter().any(|s| contains_bar(&s.shape, height)),
"Missing bar at height {height}"
);
let display = format!("display-{height}");
let mut view = s.take_presenter_view(&display);
view.layout = s.layout.clone();
s.presenter_views.insert(display.clone(), view);
s.layout.slide_progress_height = 32.; // Shared fallback must not set this display's height.
let output = ctx.run_ui(input(Vec2::new(1280., 900.)), |ui| {
presenter_ui::presenter_on_display(ui, &mut s, &mut native, &display)
});
assert!(output.shapes.iter().any(|s| contains_bar(&s.shape, height)));
}
}
#[test]
fn hidden_footer_hides_routine_rolling_buffer_status() {
fn contains_text(shape: &egui::Shape, needle: &str) -> bool {
match shape {
egui::Shape::Text(text) => text.galley.text().contains(needle),
egui::Shape::Vec(shapes) => shapes.iter().any(|shape| contains_text(shape, needle)),
_ => false,
}
}
let ctx = Context::default();
let mut s = studio();
s.layout.header = false;
s.layout.footer = false;
s.evicted_frames = 1;
s.prepared.insert(0);
let mut native = UiState::default();
let hidden = ctx.run_ui(input(Vec2::new(1280., 900.)), |ui| {
presenter_ui::presenter(ui, &mut s, &mut native)
});
assert!(s.preparation_status().contains("Rolling buffer"));
assert!(
!hidden
.shapes
.iter()
.any(|shape| contains_text(&shape.shape, "Rolling buffer"))
);
s.layout.footer = true;
let visible = ctx.run_ui(input(Vec2::new(1280., 900.)), |ui| {
presenter_ui::presenter(ui, &mut s, &mut native)
});
assert!(
visible
.shapes
.iter()
.any(|shape| contains_text(&shape.shape, "Rolling buffer"))
);
}
#[test]
fn source_name_and_path_are_in_the_footer_instead_of_the_header() {
fn contains_exact(shape: &egui::Shape, expected: &str) -> bool {
match shape {
egui::Shape::Text(text) => text.galley.text() == expected,
egui::Shape::Vec(shapes) => shapes.iter().any(|shape| contains_exact(shape, expected)),
_ => false,
}
}
let ctx = Context::default();
let mut s = studio();
let path = std::path::PathBuf::from("shows").join("conference.pdf");
s.deck.as_mut().unwrap().path = path.clone();
s.layout.header = true;
s.layout.footer = true;
let mut native = UiState::default();
let visible = ctx.run_ui(input(Vec2::new(1280., 900.)), |ui| {
presenter_ui::presenter(ui, &mut s, &mut native)
});
for expected in ["conference.pdf", &path.display().to_string()] {
assert!(
visible
.shapes
.iter()
.any(|shape| contains_exact(&shape.shape, expected)),
"missing {expected}"
);
}
assert!(
!visible
.shapes
.iter()
.any(|shape| contains_exact(&shape.shape, "Demo"))
);
s.layout.footer = false;
native.footer_until = std::time::Instant::now() - std::time::Duration::from_secs(1);
let hidden = ctx.run_ui(input(Vec2::new(1280., 900.)), |ui| {
presenter_ui::presenter(ui, &mut s, &mut native)
});
assert!(
!hidden
.shapes
.iter()
.any(|shape| contains_exact(&shape.shape, &path.display().to_string()))
);
}
#[test]
fn fullscreen_and_routing_changes_preserve_explicit_output_visibility() {
for blanked in [false, true] {
for confirm in [false, true] {
let mut s = studio();
s.blanked = blanked;
for _ in 0..2 {
s.execute(Action::ToggleFullscreen);
assert_eq!(s.blanked, blanked);
s.execute(if confirm {
Action::KeepRoutes
} else {
Action::RevertRoutes
});
assert_eq!(s.blanked, blanked);
}
s.begin_display_edit();
std::mem::swap(
&mut s.draft_routes.presenter,
&mut s.draft_routes.presentation,
);
s.execute(Action::ApplyRoutes);
assert_eq!(s.blanked, blanked);
s.route_trial.as_mut().unwrap().deadline = std::time::Instant::now();
s.poll();
assert_eq!(s.blanked, blanked);
s.set_monitors(vec![s.monitors[0].clone()], 0);
assert_eq!(s.blanked, blanked);
}
}
}
#[test]
fn double_click_notes_opens_editor_and_editor_keeps_unsaved_draft() {
fn text_pos(shapes: &[egui::epaint::ClippedShape], label: &str) -> Pos2 {
fn find(s: &egui::Shape, label: &str) -> Option<Pos2> {
match s {
egui::Shape::Text(t) if t.galley.text() == label => {
Some(t.pos + t.galley.size() * 0.5)
}
egui::Shape::Vec(v) => v.iter().find_map(|s| find(s, label)),
_ => None,
}
}
shapes
.iter()
.find_map(|s| find(&s.shape, label))
.unwrap_or_else(|| panic!("missing {label}"))
}
let ctx = Context::default();
let mut s = studio();
s.layout.header = false;
s.layout.footer = false;
let mut native = UiState::default();
let mut time = 0.;
let mut render = |s: &mut Studio, events| {
time += 0.04;
let mut raw = input(Vec2::new(1280., 900.));
raw.events = events;
raw.time = Some(time);
ctx.run_ui(raw, |ui| presenter_ui::presenter(ui, s, &mut native))
};
let output = render(&mut s, vec![]);
let pos = text_pos(&output.shapes, "PRESENTER NOTES · AUTO-FIT") + Vec2::new(0., 60.);
for _ in 0..2 {
for pressed in [true, false] {
render(
&mut s,
vec![
egui::Event::PointerMoved(pos),
egui::Event::PointerButton {
pos,
button: egui::PointerButton::Primary,
pressed,
modifiers: egui::Modifiers::NONE,
},
],
);
}
}
assert!(s.actions.iter().any(|a| matches!(a, Action::EditNotes)));
s.actions.clear();
s.notes_editor = Some(deckstride::studio::NotesEditor {
page: 0,
text: "Saved".into(),
saved_text: "Saved".into(),
busy: false,
error: None,
snapshot: Some(deckstride::notes::Snapshot {
path: "demo.notes.toml".into(),
revision: "test".into(),
notes: vec!["Saved".into()],
}),
});
for _ in 0..3 {
render(&mut s, vec![]);
}
s.notes_editor.as_mut().unwrap().text = "Unsaved notes".into();
let output = render(&mut s, vec![]);
text_pos(&output.shapes, "Save notes");
text_pos(&output.shapes, "Discard changes and close");
s.execute(Action::Exit);
assert!(!s.close_requested);
assert_eq!(s.notes_editor.as_ref().unwrap().text, "Unsaved notes");
s.execute(Action::CancelExit);
let pos = text_pos(&output.shapes, "Save notes");
for pressed in [true, false] {
render(
&mut s,
vec![
egui::Event::PointerMoved(pos),
egui::Event::PointerButton {
pos,
button: egui::PointerButton::Primary,
pressed,
modifiers: egui::Modifiers::NONE,
},
],
);
}
assert!(s.actions.iter().any(|a| matches!(a, Action::SaveNotes)));
}
#[test]
fn notes_import_review_requires_explicit_save_and_cancel_discards_preview() {
fn label_pos(shape: &egui::Shape, label: &str) -> Option<Pos2> {
match shape {
egui::Shape::Text(t) if t.galley.text() == label => Some(t.pos + t.galley.size() * 0.5),
egui::Shape::Vec(shapes) => shapes.iter().find_map(|s| label_pos(s, label)),
_ => None,
}
}
for (button, apply) in [("Import and save notes", true), ("Cancel", false)] {
let ctx = Context::default();
let mut s = studio();
let original = s.deck.as_ref().unwrap().notes.clone();
s.notes_import = Some(deckstride::studio::NotesImport {
busy: false,
error: None,
preview: Some(deckstride::notes::ImportPreview {
path: "demo.notes.toml".into(),
revision: Some("revision".into()),
sections: vec!["New first note".into(), "".into()],
total: 30,
}),
});
let mut state = UiState::default();
let mut time = 0.;
let mut render = |s: &mut Studio, events| {
time += 0.04;
let mut raw = input(Vec2::new(900., 700.));
raw.time = Some(time);
raw.events = events;
ctx.run_ui(raw, |ui| presenter_ui::presenter(ui, s, &mut state))
};
for _ in 0..3 {
render(&mut s, vec![]);
}
let output = render(&mut s, vec![]);
let pos = output
.shapes
.iter()
.find_map(|s| label_pos(&s.shape, button))
.unwrap();
assert_eq!(s.deck.as_ref().unwrap().notes, original);
for pressed in [true, false] {
render(
&mut s,
vec![
egui::Event::PointerMoved(pos),
egui::Event::PointerButton {
pos,
button: egui::PointerButton::Primary,
pressed,
modifiers: egui::Modifiers::NONE,
},
],
);
}
assert_eq!(
s.actions
.iter()
.any(|a| matches!(a, Action::ApplyNotesImport)),
apply
);
assert_eq!(s.notes_import.is_some(), apply);
assert_eq!(s.deck.as_ref().unwrap().notes, original);
}
}
#[test]
fn zoom_is_opt_in_resets_on_slide_change_and_does_not_blank_output() {
let mut s = studio();
assert!(!s.settings.zoom_enabled);
s.blanked = false;
s.set_zoom(deckstride::zoom::View {
scale: 4.,
center: [0.3, 0.6],
});
assert_eq!(s.zoom.view.scale, 1.);
s.enable_zoom(true);
s.set_zoom(deckstride::zoom::View {
scale: 4.,
center: [0.3, 0.6],
});
let ctx = Context::default();
let mut state = UiState::default();
for size in [Vec2::new(1280., 900.), Vec2::new(600., 400.)] {
let _ = ctx.run_ui(input(size), |ui| {
presenter_ui::presenter(ui, &mut s, &mut state)
});
assert_eq!(s.zoom.view.scale, 4.);
}
let epoch = s.zoom.epoch;
s.execute(Action::Go(1));
assert_eq!(s.zoom.view.scale, 1.);
assert!(s.zoom.epoch > epoch);
assert!(!s.blanked);
s.set_zoom(deckstride::zoom::View {
scale: 8.,
center: [0.5; 2],
});
s.zoom_warning = true;
let _ = ctx.run_ui(input(Vec2::new(900., 700.)), |ui| {
presenter_ui::presenter(ui, &mut s, &mut state)
});
assert!(!s.zoom_warning_dismissed);
s.enable_zoom(false);
assert_eq!(s.zoom.view, Default::default());
assert!(!s.zoom_warning);
assert!(!s.blanked);
}
#[test]
fn zoom_preview_matches_reference_output_crop_and_tracks_window_shape() {
use deckstride::{output::OutputViewport, zoom::View};
let mut s = studio();
s.settings.zoom_enabled = true;
s.set_zoom(View {
scale: 2.,
center: [0.4, 0.6],
});
assert_eq!(s.presentation_viewport(), Some([1920, 1080]));
let ctx = Context::default();
let mut native = UiState::default();
for size in [[1920, 1080], [900, 1200]] {
s.output_viewport = Some(OutputViewport {
monitor: "two".into(),
size,
fullscreen: s.presentation_fullscreen(),
});
assert_eq!(s.presentation_viewport(), Some(size));
let output = ctx.run_ui(input(Vec2::new(1280., 900.)), |ui| {
presenter_ui::presenter(ui, &mut s, &mut native);
});
let texture = native.textures.values().next().unwrap().id();
let mut actual = Rect::NOTHING;
for primitive in ctx.tessellate(output.shapes, output.pixels_per_point) {
if let egui::epaint::Primitive::Mesh(mesh) = primitive.primitive
&& mesh.texture_id == texture
{
for vertex in mesh.vertices {
actual.extend_with(vertex.uv);
}
}
}
let output_rect =
Rect::from_min_size(Pos2::ZERO, Vec2::new(size[0] as f32, size[1] as f32));
let (_, expected) = presenter_ui::zoom_geometry(output_rect, [64, 36], s.zoom.view, false);
assert!(
(actual.min - expected.min).length() < 0.0001,
"{actual:?} vs {expected:?}"
);
assert!((actual.max - expected.max).length() < 0.0001);
}
// Stale route/fullscreen reports and minimized windows cannot distort the preview.
s.output_viewport.as_mut().unwrap().fullscreen = !s.presentation_fullscreen();
assert_eq!(s.presentation_viewport(), Some([1920, 1080]));
s.output_viewport.as_mut().unwrap().fullscreen = s.presentation_fullscreen();
s.output_viewport.as_mut().unwrap().size = [0, 0];
assert_eq!(s.presentation_viewport(), Some([1920, 1080]));
s.routes.presentation = vec!["missing".into(), "one".into()];
s.monitors[0].size = (1280, 1024);
assert_eq!(s.presentation_viewport(), Some([1280, 1024]));
s.routes.presentation.clear();
assert_eq!(s.presentation_viewport(), None);
}
#[test]
fn held_navigation_buttons_accelerate_and_release_without_an_extra_step() {
fn find(shape: &egui::Shape, label: &str) -> Option<Pos2> {
match shape {
egui::Shape::Text(t) if t.galley.text() == label => Some(t.pos + t.galley.size() * 0.5),
egui::Shape::Vec(v) => v.iter().find_map(|s| find(s, label)),
_ => None,
}
}
let ctx = Context::default();
let mut s = studio();
s.settings.language = deckstride::localization::Language::En;
s.layout.footer = true;
s.blanked = false;
let mut native = UiState::default();
let frame = |s: &mut Studio, native: &mut UiState, events| {
let mut raw = input(Vec2::new(1920., 1080.));
raw.events = events;
let output = ctx.run_ui(raw, |ui| presenter_ui::presenter(ui, s, native));
for action in std::mem::take(&mut s.actions) {
s.execute(action);
}
output
};
for _ in 0..3 {
frame(&mut s, &mut native, vec![]);
}
let output = frame(&mut s, &mut native, vec![]);
let pos = output
.shapes
.iter()
.find_map(|s| find(&s.shape, "Next"))
.unwrap();
frame(
&mut s,
&mut native,
vec![
egui::Event::PointerMoved(pos),
egui::Event::PointerButton {
pos,
button: egui::PointerButton::Primary,
pressed: true,
modifiers: Default::default(),
},
],
);
assert_eq!(s.requested, 1);
native.navigation_hold = Some(deckstride::navigation::Hold::new(
1,
std::time::Instant::now() - std::time::Duration::from_secs(6),
));
frame(&mut s, &mut native, vec![]);
assert_eq!(s.requested, 4); // Batches capped to 10% of this 30-slide deck.
frame(
&mut s,
&mut native,
vec![egui::Event::PointerButton {
pos,
button: egui::PointerButton::Primary,
pressed: false,
modifiers: Default::default(),
}],
);
assert_eq!(s.requested, 4);
assert!(native.navigation_hold.is_none());
assert!(!s.blanked);
}
#[test]
fn third_monitor_routes_restore_after_repeated_disconnects_without_changing_visibility() {
for third_is_presenter in [false, true] {
for blanked in [false, true] {
let mut s = studio();
s.monitors.push(Monitor {
id: "three".into(),
name: "Third".into(),
origin: (3840, 0),
size: (1920, 1080),
});
if third_is_presenter {
s.routes.presenter.push("three".into());
} else {
s.routes.presentation.push("three".into());
}
s.settings.routes = s.routes.clone();
s.blanked = blanked;
let saved = s.settings.routes.clone();
let all = s.monitors.clone();
for missing in [2, 1, 2] {
let connected = all
.iter()
.enumerate()
.filter(|(index, _)| *index != missing)
.map(|(_, monitor)| monitor.clone())
.collect();
s.set_monitors(connected, 0);
assert!(!s.routes.presenter.contains(&all[missing].id));
assert!(!s.routes.presentation.contains(&all[missing].id));
assert_eq!(s.settings.routes, saved);
assert_eq!(s.blanked, blanked);
s.new_output = false;
s.dirty_routes = false;
s.set_monitors(all.clone(), 0);
assert_eq!(s.routes, saved);
assert!(s.new_output && s.dirty_routes);
assert_eq!(s.blanked, blanked);
assert!(!s.privacy_hold);
}
}
}
}
#[test]
fn one_presenter_confirmation_dismisses_both_presenters_on_three_monitors() {
fn find(shape: &egui::Shape, label: &str) -> Option<Pos2> {
match shape {
egui::Shape::Text(t) if t.galley.text() == label => Some(t.pos + t.galley.size() * 0.5),
egui::Shape::Vec(shapes) => shapes.iter().find_map(|s| find(s, label)),
_ => None,
}
}
for confirming_presenter in 0..2 {
let mut s = studio();
s.monitors.push(Monitor {
id: "three".into(),
name: "Third".into(),
origin: (3840, 0),
size: (1920, 1080),
});
s.settings.routes = s.routes.clone();
s.begin_display_edit();
s.draft_routes.presenter.push("three".into());
s.execute(Action::ApplyRoutes);
let expected = s.routes.clone();
let mut views = [
(Context::default(), UiState::default()),
(Context::default(), UiState::default()),
];
let size = Vec2::new(1280., 720.);
let mut buttons = vec![];
for (ctx, native) in &mut views {
let mut output = ctx.run_ui(input(size), |ui| {
presenter_ui::presenter(ui, &mut s, native)
});
for _ in 0..2 {
output = ctx.run_ui(input(size), |ui| {
presenter_ui::presenter(ui, &mut s, native)
});
}
buttons.push(
output
.shapes
.iter()
.find_map(|shape| find(&shape.shape, "Keep changes"))
.unwrap(),
);
}
let pos = buttons[confirming_presenter];
let (ctx, native) = &mut views[confirming_presenter];
for pressed in [true, false] {
let mut raw = input(size);
raw.events = vec![
egui::Event::PointerMoved(pos),
egui::Event::PointerButton {
pos,
button: egui::PointerButton::Primary,
pressed,
modifiers: Default::default(),
},
];
let _ = ctx.run_ui(raw, |ui| presenter_ui::presenter(ui, &mut s, native));
}
assert_eq!(
s.actions
.iter()
.filter(|action| matches!(action, Action::KeepRoutes))
.count(),
1
);
for action in std::mem::take(&mut s.actions) {
s.execute(action);
}
assert!(s.route_trial.is_none());
assert_eq!(s.settings.routes, expected);
assert!(!s.blanked);
// Neither presenter needs another click; both consume the same confirmed state.
for (ctx, native) in &mut views {
let output = ctx.run_ui(input(size), |ui| {
presenter_ui::presenter(ui, &mut s, native)
});
assert!(
output
.shapes
.iter()
.all(|shape| find(&shape.shape, "Keep changes").is_none())
);
}
s.execute(Action::RevertRoutes); // An obsolete second dialog cannot undo confirmation.
assert_eq!(s.routes, expected);
}
}
#[test]
fn presenter_layouts_are_display_scoped_and_save_actions_keep_the_origin() {
fn find(shape: &egui::Shape, label: &str) -> Option<Pos2> {
match shape {
egui::Shape::Text(t) if t.galley.text() == label => Some(t.pos + t.galley.size() * 0.5),
egui::Shape::Vec(shapes) => shapes.iter().find_map(|s| find(s, label)),
_ => None,
}
}
let mut s = studio();
s.routes.presenter = vec!["one".into(), "two".into()];
s.routes.presentation.clear();
s.settings.routes = s.routes.clone();
let main = s.take_presenter_view("one");
let main_layout = main.layout.clone();
s.presenter_views.insert("one".into(), main);
let mut second = s.take_presenter_view("two");
second.layout_open = true;
second.layout.notes.show = false;
second.layout.current.size = 180.;
second.layout.clock_position = deckstride::settings::TimerPosition::LeftOfSlides;
s.presenter_views.insert("two".into(), second);
s.layout.timer_mode = deckstride::settings::TimerMode::Countdown;
s.layout.countdown_seconds = 99;
let contexts = [Context::default(), Context::default()];
let mut natives = [UiState::default(), UiState::default()];
let size = Vec2::new(1400., 1000.);
// Only the second presenter's Layout panel is open.
let main_output = contexts[0].run_ui(input(size), |ui| {
presenter_ui::presenter_on_display(ui, &mut s, &mut natives[0], "one")
});
assert!(
main_output
.shapes
.iter()
.all(|shape| find(&shape.shape, "Save layout · All projects").is_none())
);
let mut output = contexts[1].run_ui(input(size), |ui| {
presenter_ui::presenter_on_display(ui, &mut s, &mut natives[1], "two")
});
for _ in 0..2 {
output = contexts[1].run_ui(input(size), |ui| {
presenter_ui::presenter_on_display(ui, &mut s, &mut natives[1], "two")
});
}
let pos = output
.shapes
.iter()
.find_map(|shape| find(&shape.shape, "Save layout · All projects"))
.unwrap();
for pressed in [true, false] {
let mut raw = input(size);
raw.events = vec![
egui::Event::PointerMoved(pos),
egui::Event::PointerButton {
pos,
button: egui::PointerButton::Primary,
pressed,
modifiers: Default::default(),
},
];
let _ = contexts[1].run_ui(raw, |ui| {
presenter_ui::presenter_on_display(ui, &mut s, &mut natives[1], "two")
});
}
assert!(
s.actions
.iter()
.any(|a| matches!(a, Action::SaveDisplayLayout { display, .. } if display == "two"))
);
// Another presenter renders before the queued save: it cannot steal the save's scope.
let _ = contexts[0].run_ui(input(size), |ui| {
presenter_ui::presenter_on_display(ui, &mut s, &mut natives[0], "one")
});
for action in std::mem::take(&mut s.actions) {
s.execute(action);
}
assert_eq!(s.presenter_views["one"].layout, main_layout);
assert!(!s.settings.for_display("two", "demo").notes.show);
assert!(s.settings.for_display("one", "demo").notes.show);
assert_eq!(s.settings.layout.countdown_seconds, 99);
assert_eq!(s.timer_limit(), Some(std::time::Duration::from_secs(99)));
assert!(!s.settings.display_layouts.contains_key("one"));
let mut project_layout = s.presenter_views["two"].layout.clone();
project_layout.notes.show = true;
s.execute(Action::SaveDisplayLayout {
display: "two".into(),
project: true,
layout: project_layout.clone(),
});
assert!(s.settings.for_display("two", "demo").notes.show);
assert!(!s.settings.for_display("two", "other").notes.show);
s.execute(Action::UseDisplayDefault("two".into()));
assert!(!s.presenter_views["two"].layout.notes.show);
let all = s.monitors.clone();
s.set_monitors(vec![all[0].clone()], 0);
s.set_monitors(all, 0);
assert!(!s.presenter_views["two"].layout.notes.show);
// Restart/source change discards transient views but keeps the display profiles.
let restored = s.settings.for_display("two", "demo");
s.presenter_views.clear();
assert_eq!(s.take_presenter_view("two").layout, restored);
}
#[test]
fn preferences_window_stays_on_the_presenter_that_opened_it() {
fn contains(shape: &egui::Shape, label: &str) -> bool {
match shape {
egui::Shape::Text(text) => text.galley.text() == label,
egui::Shape::Vec(shapes) => shapes.iter().any(|shape| contains(shape, label)),
_ => false,
}
}
let mut s = studio();
s.routes.presenter = vec!["one".into(), "two".into()];
s.routes.presentation.clear();
let mut first = s.take_presenter_view("one");
first.preferences_open = true;
s.presenter_views.insert("one".into(), first);
let second = s.take_presenter_view("two");
s.presenter_views.insert("two".into(), second);
let contexts = [Context::default(), Context::default()];
let mut natives = [UiState::default(), UiState::default()];
let size = Vec2::new(1280., 900.);
let mut render = |index: usize, display: &str| {
let mut output = contexts[index].run_ui(input(size), |ui| {
presenter_ui::presenter_on_display(ui, &mut s, &mut natives[index], display)
});
for _ in 0..2 {
output = contexts[index].run_ui(input(size), |ui| {
presenter_ui::presenter_on_display(ui, &mut s, &mut natives[index], display)
});
}
output
.shapes
.iter()
.any(|shape| contains(&shape.shape, "Memory and cache"))
};
assert!(render(0, "one"));
assert!(!render(1, "two"));
}
#[test]
fn preferences_show_the_running_executable_path() {
fn contains(shape: &egui::Shape, text: &str) -> bool {
match shape {
egui::Shape::Text(label) => label.galley.text() == text,
egui::Shape::Vec(shapes) => shapes.iter().any(|shape| contains(shape, text)),
_ => false,
}
}
let ctx = Context::default();
let mut s = studio();
s.preferences_open = true;
let expected = s.executable_path().display().to_string();
let mut ui = UiState::default();
let mut output = ctx.run_ui(input(Vec2::new(1280., 900.)), |root| {
presenter_ui::presenter(root, &mut s, &mut ui)
});
for _ in 0..2 {
output = ctx.run_ui(input(Vec2::new(1280., 900.)), |root| {
presenter_ui::presenter(root, &mut s, &mut ui)
});
}
assert!(
output
.shapes
.iter()
.any(|shape| contains(&shape.shape, "Application executable"))
);
assert!(
output
.shapes
.iter()
.any(|shape| contains(&shape.shape, &expected))
);
}
#[test]
fn any_presenter_can_edit_and_save_another_presenter_layout() {
fn find(shape: &egui::Shape, label: &str) -> Option<Pos2> {
match shape {
egui::Shape::Text(text) if text.galley.text() == label => {
Some(text.pos + text.galley.size() * 0.5)
}
egui::Shape::Vec(shapes) => shapes.iter().find_map(|shape| find(shape, label)),
_ => None,
}
}
let mut s = studio();
s.routes.presenter = vec!["one".into(), "two".into()];
s.routes.presentation.clear();
let mut first = s.take_presenter_view("one");
let first_layout = first.layout.clone();
first.layout_open = true;
first.layout_target = Some("two".into());
s.presenter_views.insert("one".into(), first);
let second = s.take_presenter_view("two");
assert!(second.layout.notes.show);
s.presenter_views.insert("two".into(), second);
let ctx = Context::default();
let mut native = UiState::default();
let size = Vec2::new(1400., 1000.);
let mut initial = ctx.run_ui(input(size), |ui| {
presenter_ui::presenter_on_display(ui, &mut s, &mut native, "one")
});
for _ in 0..2 {
initial = ctx.run_ui(input(size), |ui| {
presenter_ui::presenter_on_display(ui, &mut s, &mut native, "one")
});
}
for label in ["Edit layout for", "Display 2 · Secondary", "Slide focus"] {
assert!(
initial
.shapes
.iter()
.any(|shape| find(&shape.shape, label).is_some()),
"missing layout target control: {label}"
);
}
let mut click = |label: &str| {
let mut output = ctx.run_ui(input(size), |ui| {
presenter_ui::presenter_on_display(ui, &mut s, &mut native, "one")
});
for _ in 0..2 {
output = ctx.run_ui(input(size), |ui| {
presenter_ui::presenter_on_display(ui, &mut s, &mut native, "one")
});
}
let position = output
.shapes
.iter()
.find_map(|shape| find(&shape.shape, label))
.unwrap();
for pressed in [true, false] {
let mut raw = input(size);
raw.events = vec![
egui::Event::PointerMoved(position),
egui::Event::PointerButton {
pos: position,
button: egui::PointerButton::Primary,
pressed,
modifiers: Default::default(),
},
];
let _ = ctx.run_ui(raw, |ui| {
presenter_ui::presenter_on_display(ui, &mut s, &mut native, "one")
});
}
};
click("Slide focus");
click("Save layout · All projects");
drop(click);
assert_eq!(s.presenter_views["one"].layout, first_layout);
assert!(!s.presenter_views["two"].layout.notes.show);
assert!(s.presenter_views_dirty);
assert!(s.actions.iter().any(
|action| matches!(action, Action::SaveDisplayLayout { display, .. } if display == "two")
));
}
#[test]
fn explicit_swap_during_show_preserves_visibility_and_uses_reversible_trial() {
for blanked in [false, true] {
let mut s = studio();
s.execute(Action::Go(0));
s.blanked = blanked;
let original = s.routes.clone();
s.execute(Action::SwapRoutes);
assert!(s.route_trial.is_some());
assert_eq!(s.routes.presenter, original.presentation);
assert_eq!(s.routes.presentation, original.presenter);
assert_eq!(s.blanked, blanked);
let swapped = s.routes.clone();
s.execute(Action::SwapRoutes);
assert_eq!(s.routes, swapped);
s.execute(Action::RevertRoutes);
assert_eq!(s.routes, original);
assert_eq!(s.blanked, blanked);
}
}
#[test]
fn screen_overrides_survive_global_commands_swap_and_hotplug_and_require_confirmation() {
use deckstride::settings::ScreenMode::{AlwaysFullscreen, AlwaysWindowed};
for blanked in [false, true] {
let mut s = studio();
s.blanked = blanked;
s.begin_display_edit();
s.draft_screen_modes = [
("one".into(), AlwaysWindowed),
("two".into(), AlwaysFullscreen),
]
.into();
s.execute(Action::ApplyRoutes);
assert!(!s.screen_fullscreen("one", true));
assert!(s.screen_fullscreen("two", false));
assert!(s.settings.screen_modes.is_empty());
s.execute(Action::RevertRoutes);
assert!(s.screen_fullscreen("one", true));
s.begin_display_edit();
s.draft_screen_modes = [
("one".into(), AlwaysWindowed),
("two".into(), AlwaysFullscreen),
]
.into();
s.execute(Action::ApplyRoutes);
s.execute(Action::KeepRoutes);
let saved = s.settings.screen_modes.clone();
for global in [false, true] {
s.execute(Action::ToggleFullscreen);
assert_eq!(s.presenter_fullscreen(), global);
assert_eq!(s.presentation_fullscreen(), global);
assert!(!s.screen_fullscreen("one", global));
assert!(s.screen_fullscreen("two", global));
assert_eq!(s.screen_fullscreen("other", global), global);
assert_eq!(s.blanked, blanked);
s.execute(Action::KeepRoutes);
assert_eq!(s.settings.screen_modes, saved);
}
s.execute(Action::SwapRoutes);
assert!(!s.screen_fullscreen("one", s.presentation_fullscreen()));
assert!(s.screen_fullscreen("two", s.presenter_fullscreen()));
s.execute(Action::RevertRoutes);
s.begin_display_edit();
s.draft_screen_modes.clear();
s.execute(Action::ApplyRoutes);
s.set_monitors(vec![s.monitors[0].clone()], 0);
assert!(s.route_trial.is_none());
assert_eq!(s.settings.screen_modes, saved);
assert!(!s.screen_fullscreen("one", true));
assert_eq!(s.blanked, blanked);
}
}
#[test]
fn displays_dropdown_edits_only_selected_screen_until_applied() {
fn find(shape: &egui::Shape, label: &str) -> Option<Pos2> {
match shape {
egui::Shape::Text(t) if t.galley.text() == label => Some(t.pos + t.galley.size() * 0.5),
egui::Shape::Vec(shapes) => shapes.iter().find_map(|s| find(s, label)),
_ => None,
}
}
let ctx = Context::default();
let mut s = studio();
s.settings.language = deckstride::localization::Language::En;
s.begin_display_edit();
let mut native = UiState::default();
let mut frame = |s: &mut Studio, events| {
let mut raw = input(Vec2::new(1920., 1080.));
raw.events = events;
ctx.run_ui(raw, |ui| presenter_ui::presenter(ui, s, &mut native))
};
for label in ["Follow global", "Always windowed"] {
let mut output = frame(&mut s, vec![]);
for _ in 0..3 {
output = frame(&mut s, vec![]);
}
let pos = output
.shapes
.iter()
.find_map(|shape| find(&shape.shape, label))
.unwrap_or_else(|| panic!("Missing {label}"));
for pressed in [true, false] {
frame(
&mut s,
vec![
egui::Event::PointerMoved(pos),
egui::Event::PointerButton {
pos,
button: egui::PointerButton::Primary,
pressed,
modifiers: Default::default(),
},
],
);
}
}
assert_eq!(
s.draft_screen_modes.get("one"),
Some(&deckstride::settings::ScreenMode::AlwaysWindowed)
);
assert!(!s.draft_screen_modes.contains_key("two"));
assert!(s.settings.screen_modes.is_empty());
assert!(s.screen_fullscreen("one", true));
s.execute(Action::ApplyRoutes);
assert!(!s.screen_fullscreen("one", true));
}
#[test]
fn output_viewport_accepts_screen_override_instead_of_global_mode() {
let mut s = studio();
s.settings.screen_modes.insert(
"two".into(),
deckstride::settings::ScreenMode::AlwaysWindowed,
);
s.output_viewport = Some(deckstride::output::OutputViewport {
monitor: "two".into(),
fullscreen: false,
size: [800, 600],
});
assert_eq!(s.presentation_viewport(), Some([800, 600]));
s.output_viewport.as_mut().unwrap().fullscreen = true;
assert_eq!(s.presentation_viewport(), Some([1920, 1080]));
}
#[test]
fn quit_confirmation_requires_explicit_confirmation_and_protects_notes() {
let mut s = studio();
s.execute(Action::ConfirmExit);
assert!(!s.close_requested);
s.execute(Action::Exit);
assert!(s.quit_confirmation && !s.close_requested && !s.blanked);
s.execute(Action::CancelExit);
s.execute(Action::ConfirmExit);
assert!(!s.quit_confirmation && !s.close_requested);
s.notes_editor = Some(deckstride::studio::NotesEditor {
page: 0,
text: "Unsaved".into(),
saved_text: "Saved".into(),
busy: false,
error: None,
snapshot: None,
});
s.execute(Action::Exit);
s.execute(Action::ConfirmExit);
assert!(s.quit_confirmation && !s.close_requested);
assert_eq!(s.notes_editor.as_ref().unwrap().text, "Unsaved");
s.notes_editor.as_mut().unwrap().text = "Saved".into();
s.notes_editor.as_mut().unwrap().busy = true;
s.execute(Action::ConfirmExit);
assert!(!s.close_requested);
s.notes_editor = None;
s.notes_import = Some(deckstride::studio::NotesImport {
preview: None,
busy: true,
error: None,
});
s.execute(Action::ConfirmExit);
assert!(!s.close_requested);
s.notes_import = None;
s.execute(Action::ConfirmExit);
assert!(s.close_requested && !s.quit_confirmation);
}
#[test]
fn quit_modal_buttons_work_in_presenter_and_browser() {
fn find(shape: &egui::Shape, label: &str) -> Option<Pos2> {
match shape {
egui::Shape::Text(t) if t.galley.text() == label => Some(t.pos + t.galley.size() * 0.5),
egui::Shape::Vec(shapes) => shapes.iter().find_map(|s| find(s, label)),
_ => None,
}
}
for browser in [false, true] {
for label in ["Cancel", "Quit presentation"] {
let ctx = Context::default();
let mut s = studio();
s.settings.language = deckstride::localization::Language::En;
s.execute(Action::Exit);
let mut native = UiState::default();
let mut frame = |s: &mut Studio, events| {
let mut raw = input(Vec2::new(1920., 1080.));
raw.events = events;
ctx.run_ui(raw, |ui| {
if browser {
presenter_ui::browser(ui, s, &mut native);
} else {
presenter_ui::presenter(ui, s, &mut native);
}
})
};
let mut output = frame(&mut s, vec![]);
for _ in 0..3 {
output = frame(&mut s, vec![]);
}
let pos = output
.shapes
.iter()
.find_map(|shape| find(&shape.shape, label))
.unwrap();
for pressed in [true, false] {
frame(
&mut s,
vec![
egui::Event::PointerMoved(pos),
egui::Event::PointerButton {
pos,
button: egui::PointerButton::Primary,
pressed,
modifiers: Default::default(),
},
],
);
}
for action in std::mem::take(&mut s.actions) {
s.execute(action);
}
assert!(!s.quit_confirmation);
assert_eq!(s.close_requested, label == "Quit presentation");
assert!(!s.blanked);
}
}
}
#[test]
fn single_screen_offer_is_startup_only_and_never_rearmed_by_disconnects() {
for initial_count in [0, 1, 2] {
for accept in [false, true] {
let mut s = studio();
let one = s.monitors[0].clone();
s.observe_startup_displays(initial_count, (initial_count == 1).then_some("one"));
s.set_monitors(vec![one.clone()], 0);
s.initialized = false;
assert!(!s.startup_single_offer());
s.initialized = true;
assert_eq!(s.startup_single_offer(), initial_count == 1);
s.execute(Action::StartupSingleScreen(accept));
assert!(!s.startup_single_offer());
if initial_count == 1 && accept {
assert!(s.is_single_screen("one"));
assert!(s.settings.single_screens.is_empty());
assert!(s.routes.presentation.is_empty());
s.execute(Action::KeepRoutes);
assert_eq!(s.settings.single_screens, ["one"]);
} else {
assert!(!s.is_single_screen("one"));
}
s.set_monitors(vec![], 0);
s.observe_startup_displays(1, Some("one"));
s.set_monitors(vec![one], 0);
assert!(!s.startup_single_offer());
}
}
// A pending offer is withdrawn when the startup topology changes, too.
let mut s = studio();
let one = s.monitors[0].clone();
s.observe_startup_displays(1, Some("one"));
s.set_monitors(vec![one.clone()], 0);
assert!(s.startup_single_offer());
s.set_monitors(vec![], 0);
s.set_monitors(vec![one], 0);
assert!(!s.startup_single_offer());
}
#[test]
fn single_screen_trials_preserve_roles_privacy_and_visibility() {
for blanked in [false, true] {
let mut s = studio();
s.blanked = blanked;
s.settings.routes = s.routes.clone();
s.begin_display_edit();
s.draft_single_screens = vec!["one".into()];
s.execute(Action::ApplyRoutes);
assert!(s.is_single_screen("one"));
assert!(!s.is_single_screen("two"));
assert_eq!(s.routes.presentation, ["two"]);
assert_eq!(s.blanked, blanked);
s.execute(Action::RevertRoutes);
assert!(!s.is_single_screen("one"));
s.begin_display_edit();
s.draft_single_screens = vec!["one".into()];
s.execute(Action::ApplyRoutes);
s.execute(Action::KeepRoutes);
let routes = s.routes.clone();
s.execute(Action::SwapRoutes); // Single screen is not a group-swap destination.
assert_eq!(s.routes, routes);
s.set_monitors(vec![s.monitors[1].clone()], 0);
assert!(s.routes.presenter.is_empty());
assert!(!s.is_single_screen("two"));
assert!(!s.startup_single_offer());
assert_eq!(s.blanked, blanked);
}
}
#[test]
fn single_screen_renders_only_slide_reuses_texture_and_keeps_geometry_under_menus() {
fn text(shape: &egui::Shape, labels: &mut Vec<String>) {
match shape {
egui::Shape::Text(t) => labels.push(t.galley.text().to_owned()),
egui::Shape::Vec(shapes) => {
for s in shapes {
text(s, labels);
}
}
_ => {}
}
}
fn image_rect(shape: &egui::Shape) -> Option<Rect> {
match shape {
egui::Shape::Mesh(mesh) if matches!(mesh.texture_id, egui::TextureId::Managed(id) if id > 0) => {
Some(mesh.calc_bounds())
}
egui::Shape::Vec(shapes) => shapes.iter().find_map(image_rect),
_ => None,
}
}
let ctx = Context::default();
let mut s = studio();
s.settings.language = deckstride::localization::Language::En;
s.settings.single_screens = vec!["one".into()];
let original = s.settings.for_display("one", &s.project());
let mut native = UiState::default();
let mut render = |s: &mut Studio, events| {
let mut raw = input(Vec2::new(1280., 720.));
raw.events = events;
ctx.run_ui(raw, |ui| {
presenter_ui::presenter_on_display(ui, s, &mut native, "one")
})
};
let first = render(&mut s, vec![]);
let mut labels = vec![];
for shape in &first.shapes {
text(&shape.shape, &mut labels);
}
assert!(
labels.is_empty(),
"Single screen must hide notes/status/controls: {labels:?}"
);
let slide = first
.shapes
.iter()
.find_map(|s| image_rect(&s.shape))
.unwrap();
assert_eq!(slide.size(), Vec2::new(1280., 720.));
assert_eq!(s.presenter_views["one"].layout, original);
let second = render(&mut s, vec![]);
assert!(
second.textures_delta.set.is_empty(),
"Idle repaint must reuse the slide texture"
);
let revealed = render(&mut s, vec![egui::Event::PointerMoved(Pos2::new(600., 1.))]);
assert_eq!(
revealed.shapes.iter().find_map(|s| image_rect(&s.shape)),
Some(slide)
);
labels.clear();
for shape in &revealed.shapes {
text(&shape.shape, &mut labels);
}
assert!(labels.iter().any(|label| label == "Menu"));
assert!(!labels.iter().any(|label| label.contains("A long note")));
s.execute(Action::Go(8)); // Not prepared: retain the last ready image.
let pending = render(&mut s, vec![]);
assert_eq!(
pending.shapes.iter().find_map(|s| image_rect(&s.shape)),
Some(slide)
);
assert!(
pending
.textures_delta
.set
.iter()
.all(|(id, _)| *id == egui::TextureId::Managed(0)),
"Pending navigation must not upload a new slide texture"
);
s.blanked = true;
let blank = render(&mut s, vec![]);
assert!(
blank
.shapes
.iter()
.find_map(|s| image_rect(&s.shape))
.is_none()
);
s.blanked = false;
s.generation += 1;
let changed = render(&mut s, vec![]);
assert!(
changed
.shapes
.iter()
.find_map(|s| image_rect(&s.shape))
.is_none()
);
}
#[test]
fn displays_can_select_single_screen_without_changing_audience_role() {
fn find(shape: &egui::Shape, label: &str) -> Option<Pos2> {
match shape {
egui::Shape::Text(t) if t.galley.text() == label => Some(t.pos + t.galley.size() * 0.5),
egui::Shape::Vec(shapes) => shapes.iter().find_map(|s| find(s, label)),
_ => None,
}
}
let ctx = Context::default();
let mut s = studio();
s.settings.language = deckstride::localization::Language::En;
s.begin_display_edit();
let mut native = UiState::default();
let mut frame = |s: &mut Studio, events| {
let mut raw = input(Vec2::new(1920., 1080.));
raw.events = events;
ctx.run_ui(raw, |ui| presenter_ui::presenter(ui, s, &mut native))
};
let mut output = frame(&mut s, vec![]);
for _ in 0..3 {
output = frame(&mut s, vec![]);
}
let pos = output
.shapes
.iter()
.find_map(|shape| find(&shape.shape, "Single screen"))
.unwrap();
for pressed in [true, false] {
frame(
&mut s,
vec![
egui::Event::PointerMoved(pos),
egui::Event::PointerButton {
pos,
button: egui::PointerButton::Primary,
pressed,
modifiers: Default::default(),
},
],
);
}
assert_eq!(s.draft_single_screens, ["one"]);
assert!(!s.is_single_screen("one"));
s.execute(Action::ApplyRoutes);
assert!(s.is_single_screen("one"));
assert_eq!(s.routes.presentation, ["two"]);
s.execute(Action::KeepRoutes);
s.begin_display_edit();
s.draft_single_screens.clear();
s.execute(Action::ApplyRoutes);
assert!(!s.is_single_screen("one"));
s.execute(Action::RevertRoutes);
assert!(s.is_single_screen("one"));
}
#[test]
fn startup_single_prompt_explains_presenter_intent_and_saved_mode_does_not_reoffer() {
let ctx = Context::default();
let mut s = studio();
s.settings.language = deckstride::localization::Language::En;
let one = s.monitors[0].clone();
s.observe_startup_displays(1, Some("one"));
s.set_monitors(vec![one], 0);
let mut native = UiState::default();
fn has_text(shape: &egui::Shape, text: &str) -> bool {
match shape {
egui::Shape::Text(t) => t.galley.text() == text,
egui::Shape::Vec(shapes) => shapes.iter().any(|s| has_text(s, text)),
_ => false,
}
}
let mut result = ctx.run_ui(input(Vec2::new(1280., 720.)), |ui| {
presenter_ui::presenter(ui, &mut s, &mut native)
});
for _ in 0..3 {
result = ctx.run_ui(input(Vec2::new(1280., 720.)), |ui| {
presenter_ui::presenter(ui, &mut s, &mut native)
});
}
assert!(result.shapes.iter().any(|shape| has_text(
&shape.shape,
"Deckstride is intended for a presenter setup with separate Presenter and Slides screens."
)));
s.settings.single_screens = vec!["one".into()];
assert!(!s.startup_single_offer());
s.poll();
assert!(s.startup_single_screen.is_none());
}
#[test]
fn single_screen_bottom_controls_reveal_and_hide_without_pinning_layout() {
fn contains(shape: &egui::Shape, label: &str) -> bool {
match shape {
egui::Shape::Text(t) => t.galley.text() == label,
egui::Shape::Vec(shapes) => shapes.iter().any(|s| contains(s, label)),
_ => false,
}
}
let ctx = Context::default();
let mut s = studio();
s.settings.language = deckstride::localization::Language::En;
s.settings.single_screens = vec!["one".into()];
let mut native = UiState::default();
let render = |s: &mut Studio, native: &mut UiState, pos| {
let mut raw = input(Vec2::new(1280., 720.));
raw.events = vec![egui::Event::PointerMoved(pos)];
ctx.run_ui(raw, |ui| {
presenter_ui::presenter_on_display(ui, s, native, "one")
})
};
let revealed = render(&mut s, &mut native, Pos2::new(640., 719.));
assert!(
revealed
.shapes
.iter()
.any(|shape| contains(&shape.shape, "Next"))
);
native.header_until = std::time::Instant::now();
native.footer_until = std::time::Instant::now();
let hidden = render(&mut s, &mut native, Pos2::new(640., 360.));
assert!(
!hidden
.shapes
.iter()
.any(|shape| contains(&shape.shape, "Next") || contains(&shape.shape, "Menu"))
);
// The original Presenter preferences have not been rewritten to hide its bars.
assert!(s.presenter_views["one"].layout.header);
assert!(s.presenter_views["one"].layout.footer);
}