1361 lines
51 KiB
Rust
1361 lines
51 KiB
Rust
//! Native multiwindow host using winit, egui and cached software composition.
|
|
use crate::{
|
|
document::Frame,
|
|
output::{Ack, DisplayAction, HostState, OutputLink, SleepLease},
|
|
presenter_ui::{self, UiState},
|
|
studio::{Action, Monitor, Studio},
|
|
worker::{self, Bridge, Request},
|
|
};
|
|
use egui_software_backend::{BufferMutRef, ColorFieldOrder, EguiSoftwareRender};
|
|
use std::{
|
|
collections::{HashMap, HashSet},
|
|
num::NonZeroU32,
|
|
rc::Rc,
|
|
sync::{
|
|
Arc,
|
|
mpsc::{self, Receiver, SyncSender},
|
|
},
|
|
time::{Duration, Instant},
|
|
};
|
|
use winit::{
|
|
application::ApplicationHandler,
|
|
dpi::{PhysicalPosition, PhysicalSize},
|
|
event::{ElementState, WindowEvent},
|
|
event_loop::{ActiveEventLoop, ControlFlow, EventLoop},
|
|
keyboard::{Key, NamedKey},
|
|
monitor::MonitorHandle,
|
|
window::{Fullscreen, Window, WindowId},
|
|
};
|
|
type Failure = Box<dyn std::error::Error>;
|
|
#[derive(Clone, Copy, PartialEq, Eq)]
|
|
enum Role {
|
|
Presenter,
|
|
Browser,
|
|
Presentation,
|
|
}
|
|
struct NativeWindow {
|
|
surface: softbuffer::Surface<Rc<Window>, Rc<Window>>,
|
|
window: Rc<Window>,
|
|
ctx: egui::Context,
|
|
input: egui_winit::State,
|
|
painter: EguiSoftwareRender,
|
|
ui: UiState,
|
|
role: Role,
|
|
monitor: String,
|
|
target: Option<(String, bool)>,
|
|
transition: Option<(Instant, bool)>,
|
|
frames: usize,
|
|
display_action: Option<DisplayAction>,
|
|
#[cfg(target_os = "linux")]
|
|
browser_parent: Option<WindowId>,
|
|
}
|
|
impl NativeWindow {
|
|
fn create(el: &ActiveEventLoop, role: Role, monitor: String) -> Result<Self, Failure> {
|
|
let title = match role {
|
|
Role::Presenter => "PDF Presenter — Presenter",
|
|
Role::Browser => "PDF Presenter — All slides",
|
|
Role::Presentation => "PDF Presenter — Presentation",
|
|
};
|
|
let attributes = crate::artwork::window_attributes()
|
|
.with_title(title)
|
|
.with_window_level(if role == Role::Browser {
|
|
winit::window::WindowLevel::AlwaysOnTop
|
|
} else {
|
|
winit::window::WindowLevel::Normal
|
|
})
|
|
.with_visible(false)
|
|
.with_inner_size(PhysicalSize::new(1100, 750));
|
|
#[cfg(target_os = "linux")]
|
|
let attributes = if role == Role::Browser {
|
|
use winit::platform::x11::{WindowAttributesExtX11, WindowType};
|
|
attributes.with_x11_window_type(vec![WindowType::Dialog])
|
|
} else {
|
|
attributes
|
|
};
|
|
let window = Rc::new(el.create_window(attributes)?);
|
|
let surface =
|
|
softbuffer::Surface::new(&softbuffer::Context::new(window.clone())?, window.clone())?;
|
|
let ctx = egui::Context::default();
|
|
presenter_ui::theme(&ctx);
|
|
let input = egui_winit::State::new(
|
|
ctx.clone(),
|
|
egui::ViewportId::ROOT,
|
|
&window,
|
|
Some(window.scale_factor() as f32),
|
|
None,
|
|
Some(4096),
|
|
);
|
|
Ok(Self {
|
|
surface,
|
|
window,
|
|
ctx,
|
|
input,
|
|
painter: EguiSoftwareRender::new(ColorFieldOrder::Bgra),
|
|
ui: UiState::default(),
|
|
role,
|
|
monitor,
|
|
target: None,
|
|
transition: None,
|
|
frames: 0,
|
|
display_action: None,
|
|
#[cfg(target_os = "linux")]
|
|
browser_parent: None,
|
|
})
|
|
}
|
|
fn place(&mut self, handle: &MonitorHandle, id: &str, fullscreen: bool, x11: bool) {
|
|
let target = (id.to_owned(), fullscreen);
|
|
if self.target.as_ref() == Some(&target) {
|
|
return;
|
|
}
|
|
self.target = Some(target);
|
|
self.monitor = id.into();
|
|
if x11 {
|
|
self.window.set_fullscreen(None);
|
|
self.transition = Some((Instant::now() + Duration::from_millis(120), false));
|
|
} else {
|
|
self.move_to(handle, fullscreen);
|
|
}
|
|
self.window.request_redraw();
|
|
}
|
|
fn move_to(&self, handle: &MonitorHandle, fullscreen: bool) {
|
|
if fullscreen {
|
|
self.window
|
|
.set_fullscreen(Some(Fullscreen::Borderless(Some(handle.clone()))));
|
|
} else {
|
|
self.window.set_fullscreen(None);
|
|
let p = handle.position();
|
|
let size = handle.size();
|
|
self.window
|
|
.set_outer_position(PhysicalPosition::new(p.x + 40, p.y + 40));
|
|
let _ = self.window.request_inner_size(PhysicalSize::new(
|
|
size.width.saturating_sub(80).clamp(320, 1100),
|
|
size.height.saturating_sub(80).clamp(240, 750),
|
|
));
|
|
}
|
|
self.window.set_visible(true);
|
|
if self.role == Role::Browser {
|
|
self.window.focus_window();
|
|
}
|
|
self.window
|
|
.set_cursor_visible(self.role != Role::Presentation);
|
|
}
|
|
fn transition(&mut self, handles: &[(Monitor, MonitorHandle)], now: Instant) {
|
|
if let Some((deadline, enter)) = self.transition
|
|
&& now >= deadline
|
|
{
|
|
if let Some((_, handle)) = handles.iter().find(|(m, _)| m.id == self.monitor) {
|
|
let full = self.target.as_ref().is_some_and(|(_, f)| *f);
|
|
if enter {
|
|
self.move_to(handle, full);
|
|
self.transition = None;
|
|
} else {
|
|
self.move_to(handle, false);
|
|
self.transition = full.then_some((now + Duration::from_millis(120), true));
|
|
}
|
|
self.window.request_redraw();
|
|
} else {
|
|
self.window.set_visible(false);
|
|
self.transition = None;
|
|
}
|
|
}
|
|
}
|
|
fn render(
|
|
&mut self,
|
|
mut studio: Option<&mut Studio>,
|
|
frame: Option<&Arc<Frame>>,
|
|
blank: bool,
|
|
setup: Option<&HostState>,
|
|
) -> Result<(), Failure> {
|
|
let size = self.window.inner_size();
|
|
if size.width == 0 || size.height == 0 {
|
|
return Ok(());
|
|
}
|
|
if u64::from(size.width) * u64::from(size.height) > 40_000_000 {
|
|
return Err("Display exceeds 40 megapixels".into());
|
|
}
|
|
if let Some(s) = studio.as_ref() {
|
|
s.settings.theme.apply(&self.ctx);
|
|
crate::localization::apply(&self.ctx, &s.settings.language);
|
|
}
|
|
let input = self.input.take_egui_input(&self.window);
|
|
let role = self.role;
|
|
let ui_state = &mut self.ui;
|
|
let ctx = self.ctx.clone();
|
|
let display_action = &mut self.display_action;
|
|
let output = ctx.run_ui(input, |ui| match role {
|
|
Role::Presenter => {
|
|
presenter_ui::presenter(ui, studio.as_deref_mut().unwrap(), ui_state)
|
|
}
|
|
Role::Browser => presenter_ui::browser(ui, studio.as_deref_mut().unwrap(), ui_state),
|
|
Role::Presentation => {
|
|
ui.painter()
|
|
.rect_filled(ui.max_rect(), 0., egui::Color32::BLACK);
|
|
if let Some(setup) = setup {
|
|
*display_action = presenter_ui::output_display_recovery(
|
|
ui,
|
|
setup.setup_controls,
|
|
setup.route_trial.is_some(),
|
|
);
|
|
}
|
|
if !blank && let Some(frame) = frame {
|
|
use std::hash::{Hash, Hasher};
|
|
let mut hash = std::hash::DefaultHasher::new();
|
|
frame.info.path.hash(&mut hash);
|
|
let key = (
|
|
hash.finish(),
|
|
frame.info.page,
|
|
frame.info.width.max(frame.info.height),
|
|
);
|
|
let tex = ui_state.textures.entry(key).or_insert_with(|| {
|
|
ctx.load_texture(
|
|
format!("output-{}", frame.info.path.display()),
|
|
egui::ColorImage::from_rgba_unmultiplied(
|
|
[frame.info.width as usize, frame.info.height as usize],
|
|
&frame.rgba,
|
|
),
|
|
egui::TextureOptions::LINEAR,
|
|
)
|
|
});
|
|
presenter_ui::paint_slide(
|
|
ui.painter(),
|
|
ui.max_rect(),
|
|
tex.id(),
|
|
[frame.info.width, frame.info.height],
|
|
setup.map(|s| s.slide_colors).unwrap_or_default(),
|
|
);
|
|
}
|
|
}
|
|
});
|
|
self.input
|
|
.handle_platform_output(&self.window, output.platform_output);
|
|
let primitives = ctx.tessellate(output.shapes, output.pixels_per_point);
|
|
self.surface.resize(
|
|
NonZeroU32::new(size.width).unwrap(),
|
|
NonZeroU32::new(size.height).unwrap(),
|
|
)?;
|
|
let mut buffer = self.surface.buffer_mut()?;
|
|
buffer.fill(0);
|
|
self.painter.render(
|
|
&mut BufferMutRef::new(
|
|
bytemuck::cast_slice_mut(&mut buffer),
|
|
size.width as usize,
|
|
size.height as usize,
|
|
),
|
|
&primitives,
|
|
&output.textures_delta,
|
|
output.pixels_per_point,
|
|
);
|
|
self.window.pre_present_notify();
|
|
buffer.present()?;
|
|
self.frames += 1;
|
|
Ok(())
|
|
}
|
|
}
|
|
/// Associate a separate, resizable browser with its presenter before first mapping.
|
|
/// No modal/child-window style: the operator can still use both windows.
|
|
#[cfg(target_os = "linux")]
|
|
fn linux_browser_parent(browser: &Window, parent: &Window) -> Result<(), Failure> {
|
|
use winit::raw_window_handle::{
|
|
HasDisplayHandle, HasWindowHandle, RawDisplayHandle, RawWindowHandle,
|
|
};
|
|
match browser.display_handle()?.as_raw() {
|
|
RawDisplayHandle::Wayland(display) => {
|
|
use wayland_client::{
|
|
Connection, Proxy,
|
|
backend::{Backend, ObjectId},
|
|
};
|
|
use wayland_protocols::xdg::shell::client::xdg_toplevel::XdgToplevel;
|
|
use winit::platform::wayland::WindowExtWayland;
|
|
let child = browser
|
|
.xdg_toplevel()
|
|
.ok_or("Missing browser Wayland toplevel")?;
|
|
let owner = parent
|
|
.xdg_toplevel()
|
|
.ok_or("Missing presenter Wayland toplevel")?;
|
|
// SAFETY: both live Winit windows belong to this event loop/display. These
|
|
// temporary wrappers borrow its handles; they never destroy proxies, dispatch
|
|
// events, disconnect the display, or outlive either Window. Winit flushes the
|
|
// queued request with its next surface commit; there is no roundtrip here.
|
|
unsafe {
|
|
let connection = Connection::from_backend(Backend::from_foreign_display(
|
|
display.display.as_ptr().cast(),
|
|
));
|
|
let child = XdgToplevel::from_id(
|
|
&connection,
|
|
ObjectId::from_ptr(XdgToplevel::interface(), child.as_ptr().cast())?,
|
|
)?;
|
|
let owner = XdgToplevel::from_id(
|
|
&connection,
|
|
ObjectId::from_ptr(XdgToplevel::interface(), owner.as_ptr().cast())?,
|
|
)?;
|
|
child.set_parent(Some(&owner));
|
|
}
|
|
}
|
|
RawDisplayHandle::Xlib(display) => {
|
|
let (RawWindowHandle::Xlib(child), RawWindowHandle::Xlib(owner)) = (
|
|
browser.window_handle()?.as_raw(),
|
|
parent.window_handle()?.as_raw(),
|
|
) else {
|
|
return Err("Mismatched browser/presenter window backends".into());
|
|
};
|
|
let display = display.display.ok_or("Missing X11 display")?;
|
|
let xlib = x11_dl::xlib::Xlib::open()?;
|
|
// SAFETY: borrowed Xlib connection and live window IDs from this event loop.
|
|
// This sets a WM hint only; it neither reparents nor destroys either window.
|
|
unsafe {
|
|
(xlib.XSetTransientForHint)(display.as_ptr().cast(), child.window, owner.window);
|
|
}
|
|
}
|
|
_ => return Err("Unsupported Linux window backend".into()),
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn monitors(el: &ActiveEventLoop) -> (Vec<(Monitor, MonitorHandle)>, usize) {
|
|
let primary = el.primary_monitor();
|
|
let mut names = HashMap::new();
|
|
let handles: Vec<_> = el
|
|
.available_monitors()
|
|
.map(|h| {
|
|
let name = h.name().unwrap_or_else(|| "Display".into());
|
|
let count = names.entry(name.clone()).or_insert(0);
|
|
*count += 1;
|
|
let m = Monitor {
|
|
id: format!("{name}#{}", count),
|
|
name,
|
|
origin: h.position().into(),
|
|
size: h.size().into(),
|
|
};
|
|
(m, h)
|
|
})
|
|
.collect();
|
|
let primary = primary
|
|
.and_then(|p| handles.iter().position(|(_, h)| *h == p))
|
|
.unwrap_or(0);
|
|
(handles, primary)
|
|
}
|
|
struct Host {
|
|
parent_connected: bool,
|
|
close_requested: bool,
|
|
commands: Receiver<HostState>,
|
|
acks: SyncSender<Ack>,
|
|
state: HostState,
|
|
reader: Bridge,
|
|
reading: Option<std::path::PathBuf>,
|
|
cache: HashMap<std::path::PathBuf, Arc<Frame>>,
|
|
frame: Option<Arc<Frame>>,
|
|
presented: HashSet<WindowId>,
|
|
failed_reads: HashSet<std::path::PathBuf>,
|
|
preload_cursor: usize,
|
|
}
|
|
// The last visible frame may outlive its cache entry during a working-set change.
|
|
// Count that allocation and pin it until the requested replacement is available.
|
|
fn make_output_room(
|
|
cache: &mut HashMap<std::path::PathBuf, Arc<Frame>>,
|
|
displayed: Option<&Arc<Frame>>,
|
|
state: &HostState,
|
|
incoming: usize,
|
|
limit: usize,
|
|
) -> bool {
|
|
loop {
|
|
let bytes = cache.values().map(|f| f.rgba.len()).sum::<usize>()
|
|
+ displayed
|
|
.filter(|f| !cache.contains_key(&f.info.path))
|
|
.map_or(0, |f| f.rgba.len());
|
|
if bytes.saturating_add(incoming) <= limit {
|
|
return true;
|
|
}
|
|
let victim = cache
|
|
.iter()
|
|
.filter(|(path, _)| {
|
|
state.frame.as_ref().is_none_or(|f| &f.path != *path)
|
|
&& displayed.is_none_or(|f| &f.info.path != *path)
|
|
})
|
|
.max_by_key(|(_, f)| f.info.page.abs_diff(state.page))
|
|
.map(|(p, _)| p.clone());
|
|
let Some(victim) = victim else {
|
|
return false;
|
|
};
|
|
cache.remove(&victim);
|
|
}
|
|
}
|
|
|
|
struct App {
|
|
studio: Option<Studio>,
|
|
host: Option<Host>,
|
|
output: Option<OutputLink>,
|
|
lease: Option<SleepLease>,
|
|
windows: Vec<NativeWindow>,
|
|
handles: Vec<(Monitor, MonitorHandle)>,
|
|
next_poll: Instant,
|
|
next_clock: Instant,
|
|
next_monitors: Instant,
|
|
x11: bool,
|
|
error: Option<String>,
|
|
smoke: bool,
|
|
smoke_stage: usize,
|
|
started: Instant,
|
|
windowed: bool,
|
|
override_presenter: Option<usize>,
|
|
override_output: Option<usize>,
|
|
}
|
|
impl App {
|
|
fn redraw(&self) {
|
|
for native in &self.windows {
|
|
native.window.request_redraw();
|
|
}
|
|
}
|
|
fn refresh(&mut self, el: &ActiveEventLoop) {
|
|
let (handles, primary) = monitors(el);
|
|
let changed = self
|
|
.handles
|
|
.iter()
|
|
.map(|(m, _)| (&m.id, m.origin, m.size))
|
|
.collect::<Vec<_>>()
|
|
!= handles
|
|
.iter()
|
|
.map(|(m, _)| (&m.id, m.origin, m.size))
|
|
.collect::<Vec<_>>();
|
|
self.handles = handles;
|
|
if self
|
|
.override_presenter
|
|
.is_some_and(|i| i >= self.handles.len())
|
|
|| self
|
|
.override_output
|
|
.is_some_and(|i| i >= self.handles.len())
|
|
|| (self.override_presenter.is_some()
|
|
&& self.override_presenter == self.override_output)
|
|
{
|
|
self.error =
|
|
Some("Choose distinct, connected presenter and presentation monitors".into());
|
|
el.exit();
|
|
return;
|
|
}
|
|
if let Some(s) = &mut self.studio {
|
|
if changed {
|
|
s.set_monitors(
|
|
self.handles.iter().map(|(m, _)| m.clone()).collect(),
|
|
primary,
|
|
);
|
|
}
|
|
if s.dirty_routes {
|
|
let ids = s.monitors.iter().map(|m| m.id.clone()).collect::<Vec<_>>();
|
|
if s.initialized && s.routes.presenter.is_empty() && !s.privacy_hold {
|
|
s.routes = s.settings.routes.resolve(&ids, primary);
|
|
}
|
|
if self.windowed {
|
|
s.settings.presenter_fullscreen = false;
|
|
s.settings.presentation_fullscreen = false;
|
|
self.windowed = false;
|
|
}
|
|
if let Some(index) = self.override_presenter.take()
|
|
&& let Some((m, _)) = self.handles.get(index)
|
|
{
|
|
s.routes.presenter = vec![m.id.clone()];
|
|
s.routes.presentation.retain(|id| id != &m.id);
|
|
}
|
|
if let Some(index) = self.override_output.take()
|
|
&& let Some((m, _)) = self.handles.get(index)
|
|
{
|
|
s.routes.presentation = vec![m.id.clone()];
|
|
s.routes.presenter.retain(|id| id != &m.id);
|
|
if s.routes.presenter.is_empty() {
|
|
if let Some((presenter, _)) =
|
|
self.handles.iter().find(|(p, _)| p.id != m.id)
|
|
{
|
|
s.routes.presenter.push(presenter.id.clone());
|
|
} else {
|
|
self.error = Some(
|
|
"Presentation output requires a separate presenter monitor".into(),
|
|
);
|
|
el.exit();
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
s.draft_routes = s.routes.clone();
|
|
}
|
|
}
|
|
if changed && let Some(host) = &mut self.host {
|
|
host.state.blanked = true;
|
|
host.presented.clear();
|
|
for w in &self.windows {
|
|
if !self.handles.iter().any(|(m, _)| m.id == w.monitor) {
|
|
w.window.set_visible(false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
fn sync_windows(&mut self, el: &ActiveEventLoop) -> Result<(), Failure> {
|
|
let mut desired = vec![];
|
|
if let Some(s) = &self.studio {
|
|
for id in &s.routes.presenter {
|
|
desired.push((Role::Presenter, id.clone(), s.presenter_fullscreen()));
|
|
}
|
|
if s.browser_open {
|
|
let id = s
|
|
.settings
|
|
.browser_monitor
|
|
.as_ref()
|
|
.filter(|id| self.handles.iter().any(|(m, _)| &m.id == *id))
|
|
.cloned()
|
|
.or_else(|| s.routes.presenter.first().cloned());
|
|
if let Some(id) = id {
|
|
desired.push((Role::Browser, id, false));
|
|
}
|
|
}
|
|
}
|
|
if let Some(h) = &self.host {
|
|
for id in &h.state.monitors {
|
|
if self.handles.iter().any(|(m, _)| &m.id == id) {
|
|
desired.push((Role::Presentation, id.clone(), h.state.fullscreen));
|
|
}
|
|
}
|
|
}
|
|
self.windows.retain(|w| {
|
|
desired.iter().any(|(role, id, _)| {
|
|
*role == w.role && (w.role == Role::Browser || *id == w.monitor)
|
|
})
|
|
});
|
|
for (role, id, full) in desired {
|
|
let Some((_, handle)) = self.handles.iter().find(|(m, _)| m.id == id) else {
|
|
continue;
|
|
};
|
|
let index = if let Some(index) = self
|
|
.windows
|
|
.iter()
|
|
.position(|w| w.role == role && (role == Role::Browser || w.monitor == id))
|
|
{
|
|
index
|
|
} else {
|
|
self.windows
|
|
.push(NativeWindow::create(el, role, id.clone())?);
|
|
self.windows.len() - 1
|
|
};
|
|
#[cfg(target_os = "linux")]
|
|
if role == Role::Browser {
|
|
// Prefer the presenter on the chosen monitor, never an audience window.
|
|
let parent = self
|
|
.windows
|
|
.iter()
|
|
.filter(|w| w.role == Role::Presenter)
|
|
.min_by_key(|w| w.monitor != id)
|
|
.map(|w| w.window.clone());
|
|
if let Some(parent) = parent {
|
|
let browser = &mut self.windows[index];
|
|
if browser.browser_parent != Some(parent.id()) {
|
|
if let Err(error) = linux_browser_parent(&browser.window, &parent)
|
|
&& let Some(s) = &mut self.studio
|
|
{
|
|
s.status = format!(
|
|
"Could not associate All slides with the presenter: {error}"
|
|
);
|
|
}
|
|
browser.browser_parent = Some(parent.id());
|
|
}
|
|
}
|
|
}
|
|
self.windows[index].place(handle, &id, full, self.x11);
|
|
}
|
|
if let Some(s) = &mut self.studio {
|
|
s.dirty_routes = false;
|
|
}
|
|
Ok(())
|
|
}
|
|
fn key(&mut self, role: Role, key: Key, consumed: bool, modifiers: egui::Modifiers) {
|
|
if role == Role::Presentation {
|
|
if matches!(key, Key::Named(NamedKey::Escape))
|
|
&& let Some(host) = &self.host
|
|
&& host.state.route_trial.is_some()
|
|
{
|
|
let _ = host.acks.try_send(Ack {
|
|
display_action: Some(DisplayAction::Revert),
|
|
route_trial: host.state.route_trial,
|
|
..Default::default()
|
|
});
|
|
return;
|
|
}
|
|
if matches!(key, Key::Named(NamedKey::Escape))
|
|
|| matches!(&key,Key::Character(c) if c.eq_ignore_ascii_case("b"))
|
|
{
|
|
if let Some(h) = &mut self.host {
|
|
h.state.blanked = true;
|
|
h.close_requested = matches!(key, Key::Named(NamedKey::Escape));
|
|
let _ = h.acks.try_send(Ack {
|
|
status: "Presentation blanked from output keyboard.".into(),
|
|
..Default::default()
|
|
});
|
|
}
|
|
self.redraw();
|
|
}
|
|
return;
|
|
}
|
|
let Some(s) = &mut self.studio else {
|
|
return;
|
|
};
|
|
if matches!(key, Key::Named(NamedKey::Escape)) && s.route_trial.is_some() {
|
|
s.execute(Action::RevertRoutes);
|
|
return;
|
|
}
|
|
if modifiers.ctrl || modifiers.alt || modifiers.command || consumed {
|
|
return;
|
|
}
|
|
match key {
|
|
Key::Character(c) if c.chars().all(|c| c.is_ascii_digit()) => {
|
|
if s.jump.len() < 6 {
|
|
s.jump.push_str(&c);
|
|
}
|
|
}
|
|
Key::Named(NamedKey::Enter) if !s.jump.is_empty() => {
|
|
if let Ok(number) = s.jump.parse::<usize>()
|
|
&& number > 0
|
|
&& number <= s.count()
|
|
{
|
|
s.execute(Action::Go(number - 1));
|
|
} else {
|
|
s.status = format!("Choose a slide from 1 to {}", s.count());
|
|
}
|
|
}
|
|
Key::Named(NamedKey::Backspace) if !s.jump.is_empty() => {
|
|
s.jump.pop();
|
|
}
|
|
Key::Named(NamedKey::Escape) => {
|
|
if !s.jump.is_empty() {
|
|
s.jump.clear();
|
|
} else if role == Role::Browser {
|
|
if s.browser_preview.take().is_none() {
|
|
s.execute(Action::CloseBrowser);
|
|
}
|
|
} else if s.layout_open || s.displays_open || s.menu_open {
|
|
s.layout_open = false;
|
|
s.displays_open = false;
|
|
s.menu_open = false;
|
|
}
|
|
}
|
|
Key::Named(NamedKey::Space) if role == Role::Presenter && modifiers.shift => {
|
|
s.execute(Action::Go(s.requested.saturating_sub(1)))
|
|
}
|
|
Key::Named(NamedKey::ArrowRight | NamedKey::PageDown | NamedKey::Space)
|
|
if role == Role::Presenter =>
|
|
{
|
|
s.execute(Action::Go(s.requested + 1))
|
|
}
|
|
Key::Named(NamedKey::ArrowLeft | NamedKey::PageUp) if role == Role::Presenter => {
|
|
s.execute(Action::Go(s.requested.saturating_sub(1)))
|
|
}
|
|
Key::Character(c) if c.eq_ignore_ascii_case("b") => s.execute(Action::Blank),
|
|
_ => {}
|
|
}
|
|
self.redraw();
|
|
}
|
|
fn poll(&mut self, el: &ActiveEventLoop) {
|
|
let mut repaint = false;
|
|
if let Some(s) = &mut self.studio {
|
|
let before = (
|
|
s.generation,
|
|
s.frames.len(),
|
|
s.requested,
|
|
s.blanked,
|
|
s.status.clone(),
|
|
s.layout_open,
|
|
s.browser_open,
|
|
);
|
|
let chooser_was_open = s.dialog_busy;
|
|
s.poll();
|
|
let actions = std::mem::take(&mut s.actions);
|
|
repaint |= !actions.is_empty();
|
|
for action in actions {
|
|
#[cfg(target_os = "windows")]
|
|
if matches!(action, Action::Pick(_)) && !s.dialog_busy {
|
|
use winit::raw_window_handle::{HasWindowHandle, RawWindowHandle};
|
|
s.dialog_owner = self
|
|
.windows
|
|
.iter()
|
|
.filter(|w| w.role == Role::Presenter)
|
|
.find(|w| w.window.has_focus())
|
|
.or_else(|| self.windows.iter().find(|w| w.role == Role::Presenter))
|
|
.and_then(|w| w.window.window_handle().ok())
|
|
.and_then(|h| match h.as_raw() {
|
|
RawWindowHandle::Win32(h) => Some(h.hwnd.get()),
|
|
_ => None,
|
|
});
|
|
}
|
|
if matches!(action, Action::OpenBrowser) {
|
|
for window in self.windows.iter().filter(|w| w.role == Role::Browser) {
|
|
window.window.set_minimized(false);
|
|
window.window.focus_window();
|
|
}
|
|
}
|
|
s.execute(action);
|
|
}
|
|
if chooser_was_open != s.dialog_busy {
|
|
repaint = true;
|
|
for window in &self.windows {
|
|
if window.role == Role::Browser {
|
|
window.window.set_window_level(if s.dialog_busy {
|
|
winit::window::WindowLevel::Normal
|
|
} else {
|
|
winit::window::WindowLevel::AlwaysOnTop
|
|
});
|
|
}
|
|
#[cfg(target_os = "windows")]
|
|
if !s.dialog_busy && window.role == Role::Presenter {
|
|
use winit::{
|
|
platform::windows::WindowExtWindows,
|
|
raw_window_handle::{HasWindowHandle, RawWindowHandle},
|
|
};
|
|
// The worker can time out while COM has the owner disabled.
|
|
window.window.set_enable(true);
|
|
if window.window.window_handle().ok().is_some_and(|h| matches!(h.as_raw(),RawWindowHandle::Win32(h) if Some(h.hwnd.get()) == s.dialog_owner)) {
|
|
window.window.focus_window();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if let Some(output) = &self.output {
|
|
while let Ok(ack) = output.rx.try_recv() {
|
|
if let Some(action) = ack.display_action {
|
|
s.display_control(action, ack.route_trial);
|
|
}
|
|
if ack.generation == s.buffer_generation() {
|
|
s.output_buffered = ack.buffered;
|
|
}
|
|
if !ack.awake.is_empty() {
|
|
s.awake_status = ack.awake;
|
|
}
|
|
if !ack.status.is_empty() {
|
|
s.status = ack.status;
|
|
s.output_buffered = 0;
|
|
s.blanked = true;
|
|
s.new_output = true;
|
|
}
|
|
if ack.sequence == s.output_sequence {
|
|
s.displayed = ack.page;
|
|
}
|
|
}
|
|
if s.new_output {
|
|
s.output_sequence += 1;
|
|
let state = HostState {
|
|
setup_controls: !s.presentation_started,
|
|
route_trial: s.route_trial.as_ref().map(|t| t.id),
|
|
sequence: s.output_sequence,
|
|
slide_colors: s.settings.slide_colors,
|
|
page: s.requested,
|
|
frame: if s.routes.presentation.is_empty() {
|
|
None
|
|
} else {
|
|
s.frame_info()
|
|
},
|
|
generation: s.buffer_generation(),
|
|
buffer_mib: s.settings.buffer_mib,
|
|
preload: if s.routes.presentation.is_empty() {
|
|
vec![]
|
|
} else {
|
|
(0..s.count())
|
|
.filter_map(|p| {
|
|
s.frames.get(&(p, s.target_edge)).map(|f| f.info.clone())
|
|
})
|
|
.collect()
|
|
},
|
|
monitors: s.routes.presentation.clone(),
|
|
fullscreen: s.presentation_fullscreen(),
|
|
blanked: s.blanked,
|
|
..Default::default()
|
|
};
|
|
if output.tx.try_send(state).is_ok() {
|
|
s.new_output = false;
|
|
} else {
|
|
s.output_sequence -= 1;
|
|
}
|
|
}
|
|
}
|
|
if s.close_requested {
|
|
el.exit();
|
|
}
|
|
repaint |= before
|
|
!= (
|
|
s.generation,
|
|
s.frames.len(),
|
|
s.requested,
|
|
s.blanked,
|
|
s.status.clone(),
|
|
s.layout_open,
|
|
s.browser_open,
|
|
);
|
|
}
|
|
if let Some(host) = &mut self.host {
|
|
loop {
|
|
let state = match host.commands.try_recv() {
|
|
Ok(state) => state,
|
|
Err(mpsc::TryRecvError::Empty) => break,
|
|
Err(mpsc::TryRecvError::Disconnected) => {
|
|
host.parent_connected = false;
|
|
host.state.route_trial = None;
|
|
host.state.setup_controls = false;
|
|
break;
|
|
}
|
|
};
|
|
if !state.blanked {
|
|
host.close_requested = false;
|
|
}
|
|
repaint = true;
|
|
if state.quit {
|
|
el.exit();
|
|
return;
|
|
}
|
|
if state.frame.as_ref().map(|f| &f.path)
|
|
!= host.state.frame.as_ref().map(|f| &f.path)
|
|
{
|
|
host.presented.clear();
|
|
for w in &mut self.windows {
|
|
w.ui.textures.clear();
|
|
}
|
|
}
|
|
if state.generation != host.state.generation {
|
|
host.cache.clear();
|
|
host.failed_reads.clear();
|
|
host.frame = None;
|
|
}
|
|
// Mirror the presenter working set, retiring evicted and obsolete frames.
|
|
let retained: HashSet<_> = state
|
|
.preload
|
|
.iter()
|
|
.map(|f| &f.path)
|
|
.chain(state.frame.iter().map(|f| &f.path))
|
|
.collect();
|
|
host.cache.retain(|path, _| retained.contains(path));
|
|
host.preload_cursor = 0;
|
|
if state.buffer_mib > host.state.buffer_mib {
|
|
host.failed_reads.clear();
|
|
}
|
|
if state.monitors.is_empty() {
|
|
host.frame = None;
|
|
}
|
|
host.state = state;
|
|
}
|
|
if !host.parent_connected && (host.close_requested || self.windows.is_empty()) {
|
|
el.exit();
|
|
return;
|
|
}
|
|
while let Ok(c) = host.reader.rx.try_recv() {
|
|
repaint = true;
|
|
let reading = host.reading.take();
|
|
if c.generation != host.state.generation {
|
|
continue;
|
|
}
|
|
match c.result {
|
|
Ok(packet) if packet.reply.frame.is_some() => {
|
|
let info = packet.reply.frame.unwrap();
|
|
// Ignore completed reads that the presenter has already evicted.
|
|
if !host
|
|
.state
|
|
.preload
|
|
.iter()
|
|
.chain(host.state.frame.iter())
|
|
.any(|f| f.path == info.path)
|
|
{
|
|
continue;
|
|
}
|
|
if host.cache.contains_key(&info.path) {
|
|
continue;
|
|
}
|
|
let limit = host.state.buffer_mib.max(64) as usize * 1024 * 1024;
|
|
if make_output_room(
|
|
&mut host.cache,
|
|
host.frame.as_ref(),
|
|
&host.state,
|
|
packet.data.len(),
|
|
limit,
|
|
) {
|
|
host.cache.insert(
|
|
info.path.clone(),
|
|
Arc::new(Frame {
|
|
info,
|
|
rgba: packet.data,
|
|
}),
|
|
);
|
|
} else {
|
|
let _ = host.acks.try_send(Ack {
|
|
status: "Presentation RAM cannot fit active frames; increase the budget.".into(),
|
|
..Default::default()
|
|
});
|
|
}
|
|
}
|
|
_ => {
|
|
if let Some(path) = reading {
|
|
host.failed_reads.insert(path);
|
|
let _ = host.acks.try_send(Ack {
|
|
status:
|
|
"Could not buffer an output slide; reopen the source to retry."
|
|
.into(),
|
|
..Default::default()
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if let Some(info) = &host.state.frame {
|
|
if let Some(frame) = host.cache.get(&info.path) {
|
|
host.frame = Some(frame.clone());
|
|
} else if host.reading.is_none()
|
|
&& !host.failed_reads.contains(&info.path)
|
|
&& host.reader.submit(
|
|
host.state.generation,
|
|
0,
|
|
Request::ReadFrame(info.path.clone()),
|
|
)
|
|
{
|
|
host.reading = Some(info.path.clone());
|
|
}
|
|
}
|
|
while host.reading.is_none() && host.preload_cursor < host.state.preload.len() {
|
|
let info = &host.state.preload[host.preload_cursor];
|
|
if host.cache.contains_key(&info.path) || host.failed_reads.contains(&info.path) {
|
|
host.preload_cursor += 1;
|
|
} else if host.reader.submit(
|
|
host.state.generation,
|
|
0,
|
|
Request::ReadFrame(info.path.clone()),
|
|
) {
|
|
host.reading = Some(info.path.clone());
|
|
host.preload_cursor += 1;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if let Some(lease) = &self.lease {
|
|
while let Ok(status) = lease.status.try_recv() {
|
|
if let Some(s) = &mut self.studio {
|
|
s.awake_status = status.clone();
|
|
}
|
|
if let Some(host) = &self.host {
|
|
let _ = host.acks.try_send(Ack {
|
|
sequence: host.state.sequence,
|
|
awake: status,
|
|
..Default::default()
|
|
});
|
|
}
|
|
}
|
|
}
|
|
if self.studio.as_ref().is_some_and(|s| s.dirty_routes) {
|
|
self.refresh(el);
|
|
if let Some(s) = &mut self.studio {
|
|
s.new_output = true;
|
|
}
|
|
}
|
|
if repaint {
|
|
self.redraw();
|
|
}
|
|
if let Err(e) = self.sync_windows(el) {
|
|
self.error = Some(e.to_string());
|
|
el.exit();
|
|
}
|
|
}
|
|
}
|
|
impl ApplicationHandler for App {
|
|
fn resumed(&mut self, el: &ActiveEventLoop) {
|
|
#[cfg(target_os = "linux")]
|
|
{
|
|
use winit::platform::x11::ActiveEventLoopExtX11;
|
|
self.x11 = el.is_x11();
|
|
}
|
|
self.refresh(el);
|
|
self.poll(el);
|
|
}
|
|
fn window_event(&mut self, el: &ActiveEventLoop, id: WindowId, event: WindowEvent) {
|
|
let Some(index) = self.windows.iter().position(|w| w.window.id() == id) else {
|
|
return;
|
|
};
|
|
let role = self.windows[index].role;
|
|
let response = {
|
|
let n = &mut self.windows[index];
|
|
n.input.on_window_event(&n.window, &event)
|
|
};
|
|
if response.repaint {
|
|
self.windows[index].window.request_redraw();
|
|
}
|
|
match event {
|
|
WindowEvent::CloseRequested => {
|
|
if role == Role::Presenter {
|
|
el.exit();
|
|
} else if role == Role::Browser {
|
|
if let Some(s) = &mut self.studio {
|
|
s.execute(Action::CloseBrowser);
|
|
}
|
|
} else if let Some(h) = &mut self.host {
|
|
h.close_requested = true;
|
|
h.state.blanked = true;
|
|
let _ = h.acks.try_send(Ack {
|
|
status: "Presentation blanked from output window.".into(),
|
|
..Default::default()
|
|
});
|
|
self.redraw();
|
|
}
|
|
}
|
|
WindowEvent::DroppedFile(path) => {
|
|
if let Some(s) = &mut self.studio {
|
|
s.execute(Action::Open(path));
|
|
}
|
|
}
|
|
WindowEvent::KeyboardInput { event, .. }
|
|
if event.state == ElementState::Pressed && !event.repeat =>
|
|
{
|
|
let native = &self.windows[index];
|
|
self.key(
|
|
role,
|
|
event.logical_key,
|
|
native.ctx.egui_wants_keyboard_input(),
|
|
native.input.egui_input().modifiers,
|
|
);
|
|
}
|
|
WindowEvent::Resized(_) | WindowEvent::ScaleFactorChanged { .. } => {
|
|
self.windows[index].window.request_redraw()
|
|
}
|
|
WindowEvent::RedrawRequested => {
|
|
let frame = self.host.as_ref().and_then(|h| h.frame.clone());
|
|
let blank = self.host.as_ref().is_none_or(|h| h.state.blanked);
|
|
let result = self.windows[index].render(
|
|
self.studio.as_mut(),
|
|
frame.as_ref(),
|
|
blank,
|
|
self.host.as_ref().map(|h| &h.state),
|
|
);
|
|
if let Some(action) = self.windows[index].display_action.take()
|
|
&& let Some(host) = &self.host
|
|
{
|
|
let _ = host.acks.try_send(Ack {
|
|
display_action: Some(action),
|
|
route_trial: host.state.route_trial,
|
|
..Default::default()
|
|
});
|
|
}
|
|
if let Err(e) = result {
|
|
self.error = Some(e.to_string());
|
|
el.exit();
|
|
}
|
|
if let Some(h) = &mut self.host
|
|
&& h.state.frame.as_ref().map(|f| &f.path)
|
|
== h.frame.as_ref().map(|f| &f.info.path)
|
|
{
|
|
h.presented.insert(id);
|
|
if h.presented.len() >= self.windows.len() {
|
|
let _ = h.acks.try_send(Ack {
|
|
sequence: h.state.sequence,
|
|
page: (!h.state.blanked).then_some(h.state.page),
|
|
..Default::default()
|
|
});
|
|
}
|
|
}
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
fn about_to_wait(&mut self, el: &ActiveEventLoop) {
|
|
let now = Instant::now();
|
|
if now >= self.next_monitors {
|
|
self.refresh(el);
|
|
self.next_monitors = now + Duration::from_millis(750);
|
|
}
|
|
if now >= self.next_poll {
|
|
self.poll(el);
|
|
self.next_poll = now + Duration::from_millis(8);
|
|
}
|
|
if now >= self.next_clock {
|
|
self.redraw();
|
|
self.next_clock = now + Duration::from_secs(1);
|
|
if let Some(host) = &self.host {
|
|
let shown = !host.state.blanked
|
|
&& !self.windows.is_empty()
|
|
&& host.presented.len() >= self.windows.len();
|
|
let _ = host.acks.try_send(Ack {
|
|
sequence: host.state.sequence,
|
|
generation: host.state.generation,
|
|
buffered: host
|
|
.state
|
|
.preload
|
|
.iter()
|
|
.filter(|f| host.cache.contains_key(&f.path))
|
|
.count(),
|
|
page: shown.then_some(host.state.page),
|
|
..Default::default()
|
|
});
|
|
}
|
|
}
|
|
for window in &mut self.windows {
|
|
window.transition(&self.handles, now);
|
|
}
|
|
if self.smoke
|
|
&& self.started.elapsed() > Duration::from_millis((self.smoke_stage as u64 + 1) * 300)
|
|
&& let Some(s) = &mut self.studio
|
|
{
|
|
match self.smoke_stage {
|
|
0 => s.layout_open = true,
|
|
1 => {
|
|
s.layout_open = false;
|
|
s.displays_open = true;
|
|
}
|
|
2 => {
|
|
s.displays_open = false;
|
|
s.execute(Action::OpenBrowser);
|
|
}
|
|
3 => s.execute(Action::CloseBrowser),
|
|
4 => {
|
|
s.layout.header = false;
|
|
s.layout.footer = false;
|
|
}
|
|
5 => {
|
|
s.layout = Default::default();
|
|
// Escape dismisses transient UI; fullscreen is an explicit control.
|
|
}
|
|
6 => {
|
|
if self.windows.iter().all(|w| w.frames > 0) && !self.windows.is_empty() {
|
|
println!(
|
|
"Native smoke passed: presenter frames rendered, controls and browser exercised"
|
|
);
|
|
el.exit();
|
|
} else {
|
|
self.error = Some("No native presenter frames".into());
|
|
el.exit();
|
|
}
|
|
}
|
|
_ => {}
|
|
}
|
|
self.smoke_stage += 1;
|
|
self.redraw();
|
|
}
|
|
el.set_control_flow(ControlFlow::WaitUntil(self.next_poll.min(self.next_clock)));
|
|
}
|
|
}
|
|
pub fn run(options: crate::poc::Options, path: Option<std::path::PathBuf>) -> Result<(), Failure> {
|
|
if options.list {
|
|
return crate::desktop::run(options);
|
|
}
|
|
let el = EventLoop::new()?;
|
|
let now = Instant::now();
|
|
let studio = Studio::new(options.smoke, path);
|
|
let mut app = App {
|
|
studio: Some(studio),
|
|
host: None,
|
|
output: Some(OutputLink::new()),
|
|
lease: Some(SleepLease::new()),
|
|
windows: vec![],
|
|
handles: vec![],
|
|
next_poll: now,
|
|
next_clock: now,
|
|
next_monitors: now,
|
|
x11: false,
|
|
error: None,
|
|
smoke: options.smoke,
|
|
smoke_stage: 0,
|
|
started: now,
|
|
windowed: options.windowed,
|
|
override_presenter: options.presenter,
|
|
override_output: options.audience,
|
|
};
|
|
let result = el.run_app(&mut app);
|
|
if let Some(output) = &mut app.output {
|
|
output.shutdown();
|
|
}
|
|
result?;
|
|
if let Some(e) = app.error {
|
|
return Err(e.into());
|
|
}
|
|
Ok(())
|
|
}
|
|
pub fn run_output() -> Result<(), Failure> {
|
|
let (tx, commands) = mpsc::sync_channel(4);
|
|
std::thread::spawn(move || {
|
|
let mut stdin = std::io::stdin().lock();
|
|
while let Ok(state) = worker::read_json::<HostState>(&mut stdin) {
|
|
if tx.send(state).is_err() {
|
|
break;
|
|
}
|
|
}
|
|
});
|
|
let (acks, rx) = mpsc::sync_channel(8);
|
|
std::thread::spawn(move || {
|
|
let mut stdout = std::io::stdout().lock();
|
|
while let Ok(ack) = rx.recv() {
|
|
if worker::write_json(&mut stdout, &ack).is_err() {
|
|
break;
|
|
}
|
|
}
|
|
});
|
|
let el = EventLoop::new()?;
|
|
let now = Instant::now();
|
|
let mut app = App {
|
|
studio: None,
|
|
host: Some(Host {
|
|
parent_connected: true,
|
|
close_requested: false,
|
|
commands,
|
|
acks,
|
|
state: Default::default(),
|
|
reader: Bridge::new(Duration::from_secs(10)),
|
|
reading: None,
|
|
cache: HashMap::new(),
|
|
frame: None,
|
|
presented: HashSet::new(),
|
|
failed_reads: HashSet::new(),
|
|
preload_cursor: 0,
|
|
}),
|
|
output: None,
|
|
lease: Some(SleepLease::new()),
|
|
windows: vec![],
|
|
handles: vec![],
|
|
next_poll: now,
|
|
next_clock: now,
|
|
next_monitors: now,
|
|
x11: false,
|
|
error: None,
|
|
smoke: false,
|
|
smoke_stage: 0,
|
|
started: now,
|
|
windowed: false,
|
|
override_presenter: None,
|
|
override_output: None,
|
|
};
|
|
el.run_app(&mut app)?;
|
|
Ok(())
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod buffer_tests {
|
|
use super::*;
|
|
#[test]
|
|
fn space_navigation_respects_shift_focus_roles_and_blanking() {
|
|
let now = Instant::now();
|
|
let mut studio = Studio::new(true, None);
|
|
studio.deck = Some(crate::document::DeckInfo {
|
|
path: "test.pdf".into(),
|
|
key: "test".into(),
|
|
title: "Test".into(),
|
|
names: vec!["1".into(), "2".into(), "3".into()],
|
|
notes: vec![],
|
|
warnings: vec![],
|
|
sha256: String::new(),
|
|
});
|
|
studio.blanked = true;
|
|
let mut app = App {
|
|
studio: Some(studio),
|
|
host: None,
|
|
output: None,
|
|
lease: None,
|
|
windows: vec![],
|
|
handles: vec![],
|
|
next_poll: now,
|
|
next_clock: now,
|
|
next_monitors: now,
|
|
x11: false,
|
|
error: None,
|
|
smoke: false,
|
|
smoke_stage: 0,
|
|
started: now,
|
|
windowed: true,
|
|
override_presenter: None,
|
|
override_output: None,
|
|
};
|
|
for (role, consumed, modifiers, expected) in [
|
|
(Role::Presenter, false, egui::Modifiers::NONE, 1),
|
|
(Role::Presenter, false, egui::Modifiers::SHIFT, 0),
|
|
(Role::Presenter, false, egui::Modifiers::SHIFT, 0),
|
|
(Role::Presenter, false, egui::Modifiers::NONE, 1),
|
|
(Role::Presenter, true, egui::Modifiers::SHIFT, 1),
|
|
(
|
|
Role::Presenter,
|
|
false,
|
|
egui::Modifiers::SHIFT | egui::Modifiers::CTRL,
|
|
1,
|
|
),
|
|
(
|
|
Role::Presenter,
|
|
false,
|
|
egui::Modifiers::SHIFT | egui::Modifiers::ALT,
|
|
1,
|
|
),
|
|
(Role::Browser, false, egui::Modifiers::SHIFT, 1),
|
|
(Role::Presentation, false, egui::Modifiers::SHIFT, 1),
|
|
(Role::Presenter, false, egui::Modifiers::NONE, 2),
|
|
(Role::Presenter, false, egui::Modifiers::NONE, 2),
|
|
] {
|
|
app.key(role, Key::Named(NamedKey::Space), consumed, modifiers);
|
|
assert_eq!(app.studio.as_ref().unwrap().requested, expected);
|
|
assert!(app.studio.as_ref().unwrap().blanked);
|
|
}
|
|
let s = app.studio.as_mut().unwrap();
|
|
s.settings.presenter_fullscreen = true;
|
|
s.settings.presentation_fullscreen = true;
|
|
s.blanked = false;
|
|
s.jump = "12".into();
|
|
app.key(
|
|
Role::Presenter,
|
|
Key::Named(NamedKey::Escape),
|
|
false,
|
|
egui::Modifiers::NONE,
|
|
);
|
|
assert!(app.studio.as_ref().unwrap().jump.is_empty());
|
|
app.key(
|
|
Role::Presenter,
|
|
Key::Named(NamedKey::Escape),
|
|
false,
|
|
egui::Modifiers::NONE,
|
|
);
|
|
let s = app.studio.as_ref().unwrap();
|
|
assert!(s.presenter_fullscreen() && s.presentation_fullscreen());
|
|
assert!(!s.blanked);
|
|
}
|
|
fn frame(page: usize) -> Arc<Frame> {
|
|
Arc::new(Frame {
|
|
info: crate::document::FrameInfo {
|
|
page,
|
|
width: 4,
|
|
height: 4,
|
|
path: format!("{page}.rgba").into(),
|
|
sha256: String::new(),
|
|
},
|
|
rgba: vec![0; 64],
|
|
})
|
|
}
|
|
#[test]
|
|
fn output_evicts_distant_frames_and_counts_pinned_frame_outside_cache() {
|
|
let current = frame(1);
|
|
let near = frame(2);
|
|
let far = frame(20);
|
|
let mut cache = [current.clone(), near.clone(), far.clone()]
|
|
.into_iter()
|
|
.map(|f| (f.info.path.clone(), f))
|
|
.collect();
|
|
let state = HostState {
|
|
page: 2,
|
|
frame: Some(near.info.clone()),
|
|
..Default::default()
|
|
};
|
|
assert!(make_output_room(
|
|
&mut cache,
|
|
Some(¤t),
|
|
&state,
|
|
64,
|
|
192
|
|
));
|
|
assert!(!cache.contains_key(&far.info.path));
|
|
assert!(cache.contains_key(¤t.info.path));
|
|
assert!(cache.contains_key(&near.info.path));
|
|
cache.remove(¤t.info.path);
|
|
assert!(!make_output_room(
|
|
&mut cache,
|
|
Some(¤t),
|
|
&state,
|
|
64,
|
|
128
|
|
));
|
|
assert!(make_output_room(
|
|
&mut cache,
|
|
Some(¤t),
|
|
&state,
|
|
64,
|
|
192
|
|
));
|
|
}
|
|
}
|