2406 lines
91 KiB
Rust
2406 lines
91 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,
|
|
path::PathBuf,
|
|
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},
|
|
};
|
|
fn navigation_direction(key: &Key, modifiers: egui::Modifiers) -> Option<i32> {
|
|
if modifiers.ctrl || modifiers.alt || modifiers.command {
|
|
return None;
|
|
}
|
|
match key {
|
|
Key::Named(NamedKey::Space) if modifiers.shift => Some(-1),
|
|
Key::Named(NamedKey::ArrowRight | NamedKey::PageDown | NamedKey::Space) => Some(1),
|
|
Key::Named(NamedKey::ArrowLeft | NamedKey::PageUp) => Some(-1),
|
|
_ => None,
|
|
}
|
|
}
|
|
// Bound zero-delay animation requests; idle windows have no repaint deadline.
|
|
fn repaint_deadline(now: Instant, delay: Duration) -> Option<Instant> {
|
|
(delay != Duration::MAX)
|
|
.then(|| now.checked_add(delay.max(Duration::from_millis(16))))
|
|
.flatten()
|
|
}
|
|
type Failure = Box<dyn std::error::Error>;
|
|
#[derive(Clone, Copy, PartialEq, Eq)]
|
|
enum Role {
|
|
Presenter,
|
|
Browser,
|
|
Presentation,
|
|
}
|
|
const OUTPUT_BASE_CACHE_MAX_PIXELS: usize = 4096 * 4096;
|
|
|
|
#[cfg(target_os = "windows")]
|
|
const PRESENTER_FOCUS_RETRY_DELAYS: [Duration; 5] = [
|
|
Duration::from_millis(80),
|
|
Duration::from_millis(150),
|
|
Duration::from_millis(250),
|
|
Duration::from_millis(400),
|
|
Duration::from_millis(650),
|
|
];
|
|
|
|
#[cfg(target_os = "windows")]
|
|
struct PresenterFocusRetry {
|
|
window: WindowId,
|
|
next: Instant,
|
|
attempt: usize,
|
|
}
|
|
|
|
#[cfg(target_os = "windows")]
|
|
impl PresenterFocusRetry {
|
|
fn new(window: WindowId, now: Instant) -> Self {
|
|
Self {
|
|
window,
|
|
next: now + PRESENTER_FOCUS_RETRY_DELAYS[0],
|
|
attempt: 0,
|
|
}
|
|
}
|
|
|
|
fn take_attempt(&mut self, now: Instant) -> bool {
|
|
if now < self.next {
|
|
return false;
|
|
}
|
|
self.attempt += 1;
|
|
if let Some(delay) = PRESENTER_FOCUS_RETRY_DELAYS.get(self.attempt) {
|
|
self.next = now + *delay;
|
|
}
|
|
true
|
|
}
|
|
|
|
fn finished(&self) -> bool {
|
|
self.attempt >= PRESENTER_FOCUS_RETRY_DELAYS.len()
|
|
}
|
|
}
|
|
|
|
#[cfg(target_os = "windows")]
|
|
fn activate_presenter(window: &Window) {
|
|
use std::ffi::c_void;
|
|
use winit::raw_window_handle::{HasWindowHandle, RawWindowHandle};
|
|
|
|
type Hwnd = *mut c_void;
|
|
#[link(name = "user32")]
|
|
unsafe extern "system" {
|
|
fn GetForegroundWindow() -> Hwnd;
|
|
fn GetWindowThreadProcessId(window: Hwnd, process: *mut u32) -> u32;
|
|
fn GetCurrentThreadId() -> u32;
|
|
fn AttachThreadInput(thread: u32, foreground: u32, attach: i32) -> i32;
|
|
fn BringWindowToTop(window: Hwnd) -> i32;
|
|
fn SetForegroundWindow(window: Hwnd) -> i32;
|
|
fn SetActiveWindow(window: Hwnd) -> Hwnd;
|
|
fn SetFocus(window: Hwnd) -> Hwnd;
|
|
}
|
|
|
|
window.set_minimized(false);
|
|
window.focus_window();
|
|
let Some(hwnd) = window
|
|
.window_handle()
|
|
.ok()
|
|
.and_then(|handle| match handle.as_raw() {
|
|
RawWindowHandle::Win32(handle) => Some(handle.hwnd.get() as Hwnd),
|
|
_ => None,
|
|
})
|
|
else {
|
|
return;
|
|
};
|
|
// SetForegroundWindow is timing-sensitive while fullscreen windows are mapping.
|
|
// Temporarily sharing the foreground input queue lets Windows apply activation
|
|
// to this already-visible Presenter. Calls are bounded to startup retries.
|
|
unsafe {
|
|
let foreground = GetForegroundWindow();
|
|
let current_thread = GetCurrentThreadId();
|
|
let foreground_thread = if foreground.is_null() {
|
|
0
|
|
} else {
|
|
GetWindowThreadProcessId(foreground, std::ptr::null_mut())
|
|
};
|
|
let attached = foreground_thread != 0
|
|
&& foreground_thread != current_thread
|
|
&& AttachThreadInput(current_thread, foreground_thread, 1) != 0;
|
|
BringWindowToTop(hwnd);
|
|
SetForegroundWindow(hwnd);
|
|
SetActiveWindow(hwnd);
|
|
SetFocus(hwnd);
|
|
if attached {
|
|
AttachThreadInput(current_thread, foreground_thread, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
struct PresentationBaseKey {
|
|
size: [u32; 2],
|
|
pixels_per_point: f32,
|
|
frame: Option<(PathBuf, String, u32, u32)>,
|
|
blank: bool,
|
|
colors: crate::settings::SlideColors,
|
|
zoom: crate::zoom::Sync,
|
|
}
|
|
|
|
struct PresentationBase {
|
|
key: PresentationBaseKey,
|
|
pixels: Vec<u32>,
|
|
}
|
|
|
|
impl PresentationBase {
|
|
fn restore(&self, key: &PresentationBaseKey, pixels: &mut [u32]) -> bool {
|
|
if self.key != *key || self.pixels.len() != pixels.len() {
|
|
return false;
|
|
}
|
|
pixels.copy_from_slice(&self.pixels);
|
|
true
|
|
}
|
|
}
|
|
|
|
struct NativeWindow {
|
|
surface: softbuffer::Surface<Rc<Window>, Rc<Window>>,
|
|
window: Rc<Window>,
|
|
ctx: egui::Context,
|
|
overlay_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,
|
|
repaint_at: Option<Instant>,
|
|
display_action: Option<DisplayAction>,
|
|
zoom_change: Option<crate::zoom::View>,
|
|
zoom_watch: crate::zoom::PerformanceWatch,
|
|
zoom_slow: bool,
|
|
presentation_base: Option<PresentationBase>,
|
|
applied_theme: Option<crate::theme::Theme>,
|
|
applied_theme_pack: Option<Option<String>>,
|
|
applied_language: Option<crate::localization::Language>,
|
|
applied_language_pack: Option<Option<String>>,
|
|
#[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 => "Deckstride — Presenter",
|
|
Role::Browser => "Deckstride — All slides",
|
|
Role::Presentation => "Deckstride — Slides",
|
|
};
|
|
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_active(role != Role::Presentation)
|
|
.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();
|
|
let overlay_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,
|
|
overlay_ctx,
|
|
input,
|
|
painter: EguiSoftwareRender::new(ColorFieldOrder::Bgra),
|
|
ui: UiState::default(),
|
|
role,
|
|
monitor,
|
|
target: None,
|
|
transition: None,
|
|
frames: 0,
|
|
repaint_at: None,
|
|
display_action: None,
|
|
zoom_change: None,
|
|
zoom_watch: Default::default(),
|
|
zoom_slow: false,
|
|
presentation_base: None,
|
|
applied_theme: None,
|
|
applied_theme_pack: None,
|
|
applied_language: None,
|
|
applied_language_pack: None,
|
|
#[cfg(target_os = "linux")]
|
|
browser_parent: None,
|
|
})
|
|
}
|
|
fn repaint_if_due(&mut self, now: Instant) {
|
|
if self.repaint_at.is_some_and(|deadline| now >= deadline) {
|
|
self.repaint_at = None;
|
|
self.window.request_redraw();
|
|
}
|
|
}
|
|
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::Presentation {
|
|
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 render_started = Instant::now();
|
|
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() {
|
|
if self.applied_theme != Some(s.settings.theme)
|
|
|| self.applied_theme_pack.as_ref() != Some(&s.settings.theme_pack)
|
|
{
|
|
crate::theme::apply_selected(
|
|
&self.ctx,
|
|
s.settings.theme,
|
|
s.settings.theme_pack.as_deref(),
|
|
);
|
|
self.applied_theme = Some(s.settings.theme);
|
|
self.applied_theme_pack = Some(s.settings.theme_pack.clone());
|
|
}
|
|
if self.applied_language != Some(s.settings.language)
|
|
|| self.applied_language_pack.as_ref() != Some(&s.settings.language_pack)
|
|
{
|
|
crate::localization::apply_selected(
|
|
&self.ctx,
|
|
&s.settings.language,
|
|
s.settings.language_pack.as_deref(),
|
|
);
|
|
self.applied_language = Some(s.settings.language);
|
|
self.applied_language_pack = Some(s.settings.language_pack.clone());
|
|
}
|
|
}
|
|
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 zoom_change = &mut self.zoom_change;
|
|
let mut presentation_view = setup.map(|s| s.zoom.view).unwrap_or_default();
|
|
let mut overlay_rects = None;
|
|
let output = ctx.run_ui(input, |ui| match role {
|
|
Role::Presenter => presenter_ui::presenter_on_display(
|
|
ui,
|
|
studio.as_deref_mut().unwrap(),
|
|
ui_state,
|
|
&self.monitor,
|
|
),
|
|
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.zoom.enabled,
|
|
setup.route_trial.is_some(),
|
|
);
|
|
}
|
|
if let Some(frame) = frame {
|
|
let setup = if blank { None } else { setup };
|
|
use std::hash::{Hash, Hasher};
|
|
let mut hash = std::hash::DefaultHasher::new();
|
|
frame.info.path.hash(&mut hash);
|
|
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,
|
|
)
|
|
});
|
|
let mut view = presentation_view;
|
|
if let Some(setup) = setup
|
|
&& setup.zoom.enabled
|
|
&& setup.route_trial.is_none()
|
|
&& setup
|
|
.frame
|
|
.as_ref()
|
|
.is_some_and(|f| f.path == frame.info.path)
|
|
{
|
|
let (next, response) = presenter_ui::zoom_gestures_in(
|
|
ui,
|
|
ui.max_rect(),
|
|
[frame.info.width, frame.info.height],
|
|
view,
|
|
setup.zoom.keep_fitted_area,
|
|
);
|
|
if setup.setup_controls {
|
|
response.context_menu(|ui| {
|
|
if ui.button("Swap Presenter and Slides screens…").clicked() {
|
|
*display_action = Some(DisplayAction::Swap);
|
|
ui.close();
|
|
}
|
|
});
|
|
}
|
|
if next != view {
|
|
*zoom_change = Some(next);
|
|
view = next;
|
|
}
|
|
}
|
|
presentation_view = view;
|
|
presenter_ui::paint_slide_adapted(
|
|
ui.painter(),
|
|
ui.max_rect(),
|
|
tex.id(),
|
|
[frame.info.width, frame.info.height],
|
|
setup
|
|
.map(|s| s.slide_colors)
|
|
.unwrap_or(crate::settings::SlideColors {
|
|
page_background: [0; 3],
|
|
fit_padding: [0; 3],
|
|
}),
|
|
crate::zoom::Sync {
|
|
view,
|
|
..setup.map(|s| s.zoom).unwrap_or_default()
|
|
},
|
|
);
|
|
if let Some(setup) = setup {
|
|
let (target, uv) = presenter_ui::zoom_geometry(
|
|
ui.max_rect(),
|
|
[frame.info.width, frame.info.height],
|
|
view,
|
|
setup.zoom.keep_fitted_area,
|
|
);
|
|
overlay_rects = Some((ui.max_rect(), target, uv));
|
|
}
|
|
}
|
|
}
|
|
});
|
|
self.repaint_at = repaint_deadline(
|
|
Instant::now(),
|
|
output
|
|
.viewport_output
|
|
.get(&egui::ViewportId::ROOT)
|
|
.map_or(Duration::MAX, |viewport| viewport.repaint_delay),
|
|
);
|
|
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()?;
|
|
let pixel_count = size.width as usize * size.height as usize;
|
|
let cache_key = (role == Role::Presentation
|
|
&& pixel_count <= OUTPUT_BASE_CACHE_MAX_PIXELS
|
|
&& setup.is_some_and(|s| !s.setup_controls && s.route_trial.is_none()))
|
|
.then(|| PresentationBaseKey {
|
|
size: [size.width, size.height],
|
|
pixels_per_point: output.pixels_per_point,
|
|
frame: frame.map(|frame| {
|
|
(
|
|
frame.info.path.clone(),
|
|
frame.info.sha256.clone(),
|
|
frame.info.width,
|
|
frame.info.height,
|
|
)
|
|
}),
|
|
blank,
|
|
colors: setup.map(|s| s.slide_colors).unwrap_or_default(),
|
|
zoom: crate::zoom::Sync {
|
|
view: presentation_view,
|
|
..setup.map(|s| s.zoom).unwrap_or_default()
|
|
},
|
|
});
|
|
let restored = cache_key.as_ref().is_some_and(|key| {
|
|
self.presentation_base
|
|
.as_ref()
|
|
.is_some_and(|cached| cached.restore(key, &mut buffer))
|
|
});
|
|
if !restored {
|
|
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.presentation_base = cache_key.map(|key| PresentationBase {
|
|
key,
|
|
pixels: buffer.to_vec(),
|
|
});
|
|
} else if !output.textures_delta.is_empty() {
|
|
self.painter.render(
|
|
&mut BufferMutRef::new(
|
|
bytemuck::cast_slice_mut(&mut buffer),
|
|
size.width as usize,
|
|
size.height as usize,
|
|
),
|
|
&[],
|
|
&output.textures_delta,
|
|
output.pixels_per_point,
|
|
);
|
|
}
|
|
if let (Some(setup), Some((screen, target, uv))) = (setup, overlay_rects)
|
|
&& (setup.overlay.pointer.is_some() || !setup.overlay.marks.is_empty())
|
|
{
|
|
let overlay = self.overlay_ctx.run_ui(
|
|
egui::RawInput {
|
|
screen_rect: Some(screen),
|
|
..Default::default()
|
|
},
|
|
|ui| {
|
|
crate::tools::paint_scaled(
|
|
ui.painter(),
|
|
target,
|
|
uv,
|
|
&setup.overlay,
|
|
crate::tools::slide_paint_scale(target),
|
|
)
|
|
},
|
|
);
|
|
let overlay_primitives = self
|
|
.overlay_ctx
|
|
.tessellate(overlay.shapes, output.pixels_per_point);
|
|
self.painter.render(
|
|
&mut BufferMutRef::new(
|
|
bytemuck::cast_slice_mut(&mut buffer),
|
|
size.width as usize,
|
|
size.height as usize,
|
|
),
|
|
&overlay_primitives,
|
|
&overlay.textures_delta,
|
|
output.pixels_per_point,
|
|
);
|
|
}
|
|
self.window.pre_present_notify();
|
|
buffer.present()?;
|
|
self.frames += 1;
|
|
let zoomed = if role == Role::Presenter {
|
|
studio
|
|
.as_ref()
|
|
.is_some_and(|s| s.zoom.enabled && s.zoom.view.scale > 1.)
|
|
} else {
|
|
!blank && setup.is_some_and(|s| s.zoom.enabled && s.zoom.view.scale > 1.)
|
|
};
|
|
if self.zoom_watch.observe(zoomed, render_started.elapsed()) {
|
|
self.zoom_slow = true;
|
|
if let Some(s) = studio {
|
|
s.zoom_warning = true;
|
|
}
|
|
}
|
|
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,
|
|
blank: crate::blank::Output,
|
|
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,
|
|
zoom_pending: bool,
|
|
zoom_slow: bool,
|
|
next_zoom_ack: Instant,
|
|
}
|
|
// 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>,
|
|
navigation_hold: Option<(WindowId, Key, crate::navigation::Hold)>,
|
|
swap_hold: Option<(WindowId, Instant)>,
|
|
#[cfg(target_os = "windows")]
|
|
presenter_focus: Option<PresenterFocusRetry>,
|
|
}
|
|
impl App {
|
|
fn redraw(&self) {
|
|
for native in &self.windows {
|
|
native.window.request_redraw();
|
|
}
|
|
}
|
|
#[cfg(target_os = "windows")]
|
|
fn retry_presenter_focus(&mut self, now: Instant) {
|
|
let Some(retry) = &mut self.presenter_focus else {
|
|
return;
|
|
};
|
|
if self
|
|
.windows
|
|
.iter()
|
|
.any(|window| window.role == Role::Browser && window.window.has_focus())
|
|
{
|
|
self.presenter_focus = None;
|
|
return;
|
|
}
|
|
if !retry.take_attempt(now) {
|
|
return;
|
|
}
|
|
if !self
|
|
.windows
|
|
.iter()
|
|
.any(|window| window.role == Role::Presenter && window.window.has_focus())
|
|
&& let Some(window) = self
|
|
.windows
|
|
.iter()
|
|
.find(|window| window.window.id() == retry.window)
|
|
{
|
|
activate_presenter(&window.window);
|
|
}
|
|
if retry.finished() {
|
|
self.presenter_focus = None;
|
|
}
|
|
}
|
|
fn refresh(&mut self, el: &ActiveEventLoop) {
|
|
let (handles, primary) = monitors(el);
|
|
if let Some(s) = &mut self.studio {
|
|
s.observe_startup_displays(handles.len(), handles.first().map(|(m, _)| m.id.as_str()));
|
|
}
|
|
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 Slides screens".into());
|
|
el.exit();
|
|
return;
|
|
}
|
|
if let Some(s) = &mut self.studio {
|
|
if changed {
|
|
self.swap_hold = None;
|
|
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("Slides output requires a separate Presenter screen".into());
|
|
el.exit();
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
s.draft_routes = s.routes.clone();
|
|
}
|
|
}
|
|
if changed {
|
|
if let Some(host) = &mut self.host {
|
|
host.presented.clear();
|
|
}
|
|
for w in &mut self.windows {
|
|
// The OS may move a surviving window when another display is
|
|
// removed. Its route ID/fullscreen flag can remain unchanged,
|
|
// so discard placement cached for the old desktop topology.
|
|
w.target = None;
|
|
w.transition = None;
|
|
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.screen_fullscreen(
|
|
id,
|
|
if s.is_single_screen(id) {
|
|
s.presentation_fullscreen()
|
|
} else {
|
|
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_on(id)));
|
|
}
|
|
}
|
|
}
|
|
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 {
|
|
#[cfg(target_os = "windows")]
|
|
let first_presenter = role == Role::Presenter
|
|
&& !self
|
|
.windows
|
|
.iter()
|
|
.any(|window| window.role == Role::Presenter);
|
|
self.windows
|
|
.push(NativeWindow::create(el, role, id.clone())?);
|
|
#[cfg(target_os = "windows")]
|
|
if first_presenter {
|
|
self.presenter_focus = Some(PresenterFocusRetry::new(
|
|
self.windows.last().unwrap().window.id(),
|
|
Instant::now(),
|
|
));
|
|
}
|
|
self.windows.len() - 1
|
|
};
|
|
#[cfg(target_os = "linux")]
|
|
if role == Role::Browser {
|
|
// Prefer the Presenter on the chosen monitor, never a Slides 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) {
|
|
let escape = matches!(key, Key::Named(NamedKey::Escape)) && modifiers.is_none();
|
|
let quit = escape
|
|
|| (matches!(&key, Key::Character(c) if c.eq_ignore_ascii_case("q"))
|
|
&& modifiers.ctrl
|
|
&& !modifiers.alt
|
|
&& !modifiers.shift);
|
|
if role == Role::Presentation {
|
|
if 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 quit {
|
|
if let Some(h) = &self.host
|
|
&& h.parent_connected
|
|
{
|
|
let _ = h.acks.try_send(Ack {
|
|
request_quit: true,
|
|
..Default::default()
|
|
});
|
|
return;
|
|
}
|
|
// Focus may move here as All slides closes. Escape must never blank
|
|
// a connected show; an orphan can still be dismissed safely.
|
|
if let Some(h) = &mut self.host {
|
|
h.close_requested = !h.parent_connected;
|
|
}
|
|
} else if matches!(&key, Key::Character(c) if c.eq_ignore_ascii_case("b")) {
|
|
if let Some(h) = &mut self.host {
|
|
h.state.blanked = true;
|
|
let _ = h.acks.try_send(Ack {
|
|
request_blank: true,
|
|
status: "Slides blanked from output keyboard.".into(),
|
|
..Default::default()
|
|
});
|
|
}
|
|
self.redraw();
|
|
}
|
|
return;
|
|
}
|
|
let Some(s) = &mut self.studio else {
|
|
return;
|
|
};
|
|
if s.quit_confirmation {
|
|
if escape {
|
|
s.execute(Action::CancelExit);
|
|
}
|
|
self.redraw();
|
|
return;
|
|
}
|
|
if escape && s.route_trial.is_some() {
|
|
s.execute(Action::RevertRoutes);
|
|
return;
|
|
}
|
|
if quit {
|
|
s.execute(Action::Exit);
|
|
self.redraw();
|
|
return;
|
|
}
|
|
if s.startup_single_offer() {
|
|
return;
|
|
}
|
|
// Notes editing must never turn typing or Escape into presentation commands.
|
|
// Unsaved text is only discarded through the explicit editor control.
|
|
if s.notes_editor.is_some() || s.notes_import.is_some() {
|
|
return;
|
|
}
|
|
if modifiers.ctrl || modifiers.alt || modifiers.command {
|
|
return;
|
|
}
|
|
// Keep the live show responsive while an operator is using All slides or
|
|
// has a presenter menu open. Text editors and modified shortcuts above
|
|
// retain priority; focused controls may still consume all other keys.
|
|
if let Some(delta) = navigation_direction(&key, modifiers) {
|
|
s.execute(Action::Navigate {
|
|
delta,
|
|
repeated: false,
|
|
});
|
|
self.redraw();
|
|
return;
|
|
}
|
|
if 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::Character(c) if c.eq_ignore_ascii_case("p") => {
|
|
let tool = if s.toolbox.tool == crate::tools::Tool::Pointer {
|
|
crate::tools::Tool::Off
|
|
} else {
|
|
crate::tools::Tool::Pointer
|
|
};
|
|
if s.toolbox.select(tool) {
|
|
s.new_overlay = true;
|
|
}
|
|
s.toolbox.open = true;
|
|
}
|
|
Key::Character(c) if c.eq_ignore_ascii_case("a") => {
|
|
if s.toolbox.select(crate::tools::Tool::Arrow) {
|
|
s.new_overlay = true;
|
|
}
|
|
s.toolbox.open = true;
|
|
}
|
|
Key::Character(c) if c.eq_ignore_ascii_case("h") => {
|
|
if s.toolbox.select(crate::tools::Tool::Highlighter) {
|
|
s.new_overlay = true;
|
|
}
|
|
s.toolbox.open = true;
|
|
}
|
|
Key::Character(c) if c.eq_ignore_ascii_case("b") => s.execute(Action::Blank),
|
|
_ => {}
|
|
}
|
|
self.redraw();
|
|
}
|
|
fn stop_navigation(&mut self) {
|
|
self.navigation_hold = None;
|
|
if let Some(s) = &mut self.studio {
|
|
s.execute(Action::FinishNavigation);
|
|
}
|
|
}
|
|
fn poll_swap(&mut self, now: Instant) {
|
|
let Some((owner, _)) = self.swap_hold else {
|
|
return;
|
|
};
|
|
let allowed = self.windows.iter().any(|w| {
|
|
w.window.id() == owner && w.window.has_focus() && !w.ctx.egui_wants_keyboard_input()
|
|
}) && self.studio.as_ref().is_some_and(swap_allowed);
|
|
if take_due_swap(&mut self.swap_hold, now, allowed) {
|
|
self.studio.as_mut().unwrap().execute(Action::SwapRoutes);
|
|
self.redraw();
|
|
}
|
|
}
|
|
fn repeat_navigation(&mut self, now: Instant) {
|
|
let Some((id, _, _)) = &self.navigation_hold else {
|
|
return;
|
|
};
|
|
let valid = self
|
|
.windows
|
|
.iter()
|
|
.any(|w| w.window.id() == *id && w.window.has_focus())
|
|
&& self.studio.as_ref().is_some_and(|s| {
|
|
!s.quit_confirmation
|
|
&& !s.startup_single_offer()
|
|
&& s.notes_editor.is_none()
|
|
&& s.notes_import.is_none()
|
|
&& !s.dialog_busy
|
|
&& !s.loading
|
|
&& s.route_trial.is_none()
|
|
});
|
|
if !valid {
|
|
self.stop_navigation();
|
|
return;
|
|
}
|
|
let s = self.studio.as_mut().unwrap();
|
|
if let Some(delta) = self
|
|
.navigation_hold
|
|
.as_mut()
|
|
.unwrap()
|
|
.2
|
|
.tick(now, s.count())
|
|
{
|
|
s.execute(Action::Navigate {
|
|
delta,
|
|
repeated: true,
|
|
});
|
|
self.redraw();
|
|
}
|
|
}
|
|
fn poll(&mut self, el: &ActiveEventLoop) {
|
|
let mut repaint = false;
|
|
if let Some(s) = &mut self.studio {
|
|
repaint |= s.new_zoom || s.new_overlay || std::mem::take(&mut s.presenter_views_dirty);
|
|
let before = (
|
|
s.generation,
|
|
s.frames.len(),
|
|
s.requested,
|
|
s.blanked,
|
|
s.status.clone(),
|
|
s.layout_open,
|
|
s.browser_open,
|
|
s.quit_confirmation,
|
|
s.route_trial.as_ref().map(|trial| trial.id),
|
|
);
|
|
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(_)
|
|
| Action::PickNotes
|
|
| Action::PickBlankPicture
|
|
| Action::PickLanguagePack
|
|
| Action::PickThemePack
|
|
) && !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(viewport) = ack.viewport {
|
|
let before = s.presentation_viewport();
|
|
s.output_viewport = Some(viewport);
|
|
repaint |= before != s.presentation_viewport();
|
|
}
|
|
if let Some(zoom) = ack.zoom {
|
|
if ack.generation == s.buffer_generation() && ack.page == Some(s.requested)
|
|
{
|
|
if s.zoom.accept_output(zoom) {
|
|
s.presentation_action();
|
|
repaint = true;
|
|
}
|
|
if zoom.epoch == s.zoom.epoch {
|
|
s.zoom_warning |= ack.zoom_slow;
|
|
s.new_zoom = true; // Echo newest serial so output can stop retrying.
|
|
repaint |= ack.zoom_slow;
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
if ack.request_quit {
|
|
s.execute(Action::Exit);
|
|
}
|
|
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.new_output = true;
|
|
}
|
|
if ack.request_blank {
|
|
s.presentation_action();
|
|
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 {
|
|
zoom: s.zoom,
|
|
overlay: s.toolbox.overlay.clone(),
|
|
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(),
|
|
screen_fullscreen: s
|
|
.routes
|
|
.presentation
|
|
.iter()
|
|
.map(|id| {
|
|
(
|
|
id.clone(),
|
|
s.screen_fullscreen(id, s.presentation_fullscreen()),
|
|
)
|
|
})
|
|
.collect(),
|
|
blanked: s.blanked,
|
|
blank_picture: s.blank_picture.as_ref().map(|f| f.info.clone()),
|
|
..Default::default()
|
|
};
|
|
if output.tx.try_send(state).is_ok() {
|
|
s.new_output = false;
|
|
s.new_zoom = false;
|
|
s.new_overlay = false;
|
|
} else {
|
|
s.output_sequence -= 1;
|
|
}
|
|
}
|
|
}
|
|
if (s.new_zoom || s.new_overlay)
|
|
&& !s.new_output
|
|
&& let Some(output) = &self.output
|
|
{
|
|
let state = HostState {
|
|
zoom_only: s.new_zoom,
|
|
zoom: s.zoom,
|
|
overlay_only: s.new_overlay,
|
|
overlay: s.toolbox.overlay.clone(),
|
|
generation: s.buffer_generation(),
|
|
page: s.requested,
|
|
..Default::default()
|
|
};
|
|
if output.tx.try_send(state).is_ok() {
|
|
s.new_zoom = false;
|
|
s.new_overlay = false;
|
|
}
|
|
}
|
|
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,
|
|
s.quit_confirmation,
|
|
s.route_trial.as_ref().map(|trial| trial.id),
|
|
);
|
|
}
|
|
if let Some(host) = &mut self.host {
|
|
loop {
|
|
let mut 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.zoom_only || state.overlay_only {
|
|
if state.generation == host.state.generation && state.page == host.state.page {
|
|
if state.zoom_only {
|
|
let before = host.state.zoom;
|
|
host.state.zoom.accept_presenter(state.zoom);
|
|
host.zoom_pending = host.state.zoom != state.zoom.normalized();
|
|
repaint |= before != host.state.zoom;
|
|
}
|
|
if state.overlay_only {
|
|
let overlay = state.overlay.normalized();
|
|
repaint |= host.state.overlay != overlay;
|
|
host.state.overlay = overlay;
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
host.state.zoom.accept_presenter(state.zoom);
|
|
host.zoom_pending = host.state.zoom != state.zoom.normalized();
|
|
state.zoom = host.state.zoom;
|
|
state.overlay = state.overlay.normalized();
|
|
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;
|
|
}
|
|
if host.blank.set(state.blank_picture.as_ref()) {
|
|
for w in &mut self.windows {
|
|
w.ui.textures.clear();
|
|
}
|
|
}
|
|
host.state = state;
|
|
}
|
|
if let Some(result) = host.blank.poll() {
|
|
repaint = true;
|
|
if let Err(error) = result {
|
|
let _ = host.acks.try_send(Ack {
|
|
status: format!("Blank picture: {error}"),
|
|
..Default::default()
|
|
});
|
|
}
|
|
}
|
|
if host.zoom_pending && host.parent_connected && Instant::now() >= host.next_zoom_ack {
|
|
let _ = host.acks.try_send(Ack {
|
|
zoom: Some(host.state.zoom),
|
|
zoom_slow: host.zoom_slow,
|
|
generation: host.state.generation,
|
|
page: Some(host.state.page),
|
|
..Default::default()
|
|
});
|
|
host.next_zoom_ack = Instant::now() + Duration::from_millis(33);
|
|
}
|
|
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: "Slides 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 let Err(e) = self.sync_windows(el) {
|
|
self.error = Some(e.to_string());
|
|
el.exit();
|
|
}
|
|
// Include newly created mirrors in the same state update.
|
|
if repaint {
|
|
self.redraw();
|
|
}
|
|
}
|
|
}
|
|
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;
|
|
if matches!(&event, WindowEvent::KeyboardInput { event, is_synthetic: true, .. } if event.state == ElementState::Pressed)
|
|
{
|
|
return;
|
|
}
|
|
// Navigation belongs to the bounded native hold controller, not also to
|
|
// egui's focused button activation or the OS repeat stream.
|
|
let navigation_event = role != Role::Presentation
|
|
&& self.studio.as_ref().is_some_and(|s| {
|
|
!s.quit_confirmation
|
|
&& !s.startup_single_offer()
|
|
&& s.notes_editor.is_none()
|
|
&& s.notes_import.is_none()
|
|
&& !s.dialog_busy
|
|
&& s.route_trial.is_none()
|
|
})
|
|
&& matches!(&event, WindowEvent::KeyboardInput { event, .. } if navigation_direction(&event.logical_key, self.windows[index].input.egui_input().modifiers).is_some());
|
|
let repaint = if navigation_event {
|
|
false
|
|
} else {
|
|
let n = &mut self.windows[index];
|
|
n.input.on_window_event(&n.window, &event).repaint
|
|
};
|
|
// egui-winit reports repaint=true for RedrawRequested itself. The
|
|
// current render satisfies that request: requeueing it creates an idle
|
|
// paint loop and can starve later Windows WM_PAINT messages.
|
|
if repaint && !matches!(event, WindowEvent::RedrawRequested) {
|
|
self.windows[index].window.request_redraw();
|
|
}
|
|
match event {
|
|
WindowEvent::CloseRequested => {
|
|
if role == Role::Presenter {
|
|
if let Some(s) = &mut self.studio {
|
|
s.execute(Action::Exit);
|
|
if s.close_requested {
|
|
el.exit();
|
|
} else {
|
|
self.redraw();
|
|
}
|
|
}
|
|
} 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 {
|
|
request_blank: true,
|
|
status: "Slides blanked from output window.".into(),
|
|
..Default::default()
|
|
});
|
|
self.redraw();
|
|
}
|
|
}
|
|
WindowEvent::DroppedFile(path) => {
|
|
if role == Role::Presenter
|
|
&& let Some(s) = &mut self.studio
|
|
{
|
|
s.execute(if crate::notes::is_import(&path) {
|
|
Action::ImportNotes(path)
|
|
} else {
|
|
Action::Open(path)
|
|
});
|
|
}
|
|
}
|
|
WindowEvent::Focused(false) => {
|
|
self.swap_hold = None;
|
|
self.stop_navigation();
|
|
self.windows[index].ui.navigation_hold = None;
|
|
}
|
|
WindowEvent::ModifiersChanged(_) => {
|
|
self.swap_hold = None;
|
|
self.stop_navigation();
|
|
}
|
|
WindowEvent::KeyboardInput {
|
|
event,
|
|
is_synthetic,
|
|
..
|
|
} => {
|
|
if event.state == ElementState::Released {
|
|
if matches!(&event.logical_key, Key::Character(c) if c.eq_ignore_ascii_case("s"))
|
|
{
|
|
self.swap_hold = None;
|
|
}
|
|
if self
|
|
.navigation_hold
|
|
.as_ref()
|
|
.is_some_and(|(owner, key, _)| *owner == id && *key == event.logical_key)
|
|
{
|
|
self.stop_navigation();
|
|
}
|
|
} else if !event.repeat && !is_synthetic {
|
|
self.swap_hold = None;
|
|
self.stop_navigation();
|
|
let native = &self.windows[index];
|
|
let modifiers = native.input.egui_input().modifiers;
|
|
let consumed = native.ctx.egui_wants_keyboard_input();
|
|
if role != Role::Presentation
|
|
&& !consumed
|
|
&& modifiers.is_none()
|
|
&& matches!(&event.logical_key, Key::Character(c) if c.eq_ignore_ascii_case("s"))
|
|
&& self.studio.as_ref().is_some_and(swap_allowed)
|
|
{
|
|
self.swap_hold = Some((id, Instant::now()));
|
|
}
|
|
let direction = navigation_direction(&event.logical_key, modifiers);
|
|
let allowed = role != Role::Presentation
|
|
&& self.studio.as_ref().is_some_and(|s| {
|
|
!s.quit_confirmation
|
|
&& !s.startup_single_offer()
|
|
&& s.notes_editor.is_none()
|
|
&& s.notes_import.is_none()
|
|
&& !s.dialog_busy
|
|
&& s.route_trial.is_none()
|
|
});
|
|
if allowed && let Some(direction) = direction {
|
|
self.navigation_hold = Some((
|
|
id,
|
|
event.logical_key.clone(),
|
|
crate::navigation::Hold::new(direction, Instant::now()),
|
|
));
|
|
}
|
|
self.key(role, event.logical_key, consumed, modifiers);
|
|
}
|
|
}
|
|
WindowEvent::Resized(_) | WindowEvent::ScaleFactorChanged { .. } => {
|
|
self.windows[index].window.request_redraw()
|
|
}
|
|
WindowEvent::RedrawRequested => {
|
|
let frame = self.host.as_ref().and_then(|h| {
|
|
if h.state.blanked {
|
|
h.blank.picture.clone()
|
|
} else {
|
|
h.frame.clone()
|
|
}
|
|
});
|
|
let blank = self.host.as_ref().is_none_or(|h| h.state.blanked);
|
|
let result = self.windows[index].render(
|
|
self.studio.as_mut(),
|
|
frame.as_ref(),
|
|
blank,
|
|
self.host.as_ref().map(|h| &h.state),
|
|
);
|
|
if let Some(host) = &mut self.host {
|
|
if let Some(view) = self.windows[index].zoom_change.take() {
|
|
host.state.zoom.gesture(view);
|
|
host.zoom_pending = true;
|
|
self.windows.iter().for_each(|w| w.window.request_redraw());
|
|
}
|
|
if self.windows[index].zoom_slow && !host.zoom_slow {
|
|
host.zoom_slow = true;
|
|
host.zoom_pending = true;
|
|
}
|
|
}
|
|
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_swap(now);
|
|
self.repeat_navigation(now);
|
|
// egui repaint timers alone do not wake this custom native host.
|
|
// Redraw held mouse controls at their repeat deadline, not at frame rate.
|
|
for window in &self.windows {
|
|
if window.ui.navigation_hold.is_some_and(|hold| hold.due(now)) {
|
|
window.window.request_redraw();
|
|
}
|
|
}
|
|
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 viewport = host.state.monitors.iter().find_map(|id| {
|
|
self.windows
|
|
.iter()
|
|
.find(|w| w.role == Role::Presentation && &w.monitor == id)
|
|
.map(|w| {
|
|
let size = w.window.inner_size();
|
|
crate::output::OutputViewport {
|
|
monitor: id.clone(),
|
|
size: [size.width, size.height],
|
|
fullscreen: host.state.fullscreen_on(id),
|
|
}
|
|
})
|
|
});
|
|
let _ = host.acks.try_send(Ack {
|
|
viewport,
|
|
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.repaint_if_due(now);
|
|
window.transition(&self.handles, now);
|
|
}
|
|
#[cfg(target_os = "windows")]
|
|
self.retry_presenter_focus(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 => {
|
|
for view in s.presenter_views.values_mut() {
|
|
view.layout_open = true;
|
|
}
|
|
}
|
|
1 => {
|
|
for view in s.presenter_views.values_mut() {
|
|
view.layout_open = false;
|
|
}
|
|
s.displays_open = true;
|
|
}
|
|
2 => {
|
|
s.displays_open = false;
|
|
s.execute(Action::OpenBrowser);
|
|
}
|
|
3 => s.execute(Action::CloseBrowser),
|
|
4 => {
|
|
for view in s.presenter_views.values_mut() {
|
|
view.layout.header = false;
|
|
view.layout.footer = false;
|
|
}
|
|
}
|
|
5 => {
|
|
for view in s.presenter_views.values_mut() {
|
|
view.layout = Default::default();
|
|
}
|
|
// Fullscreen remains an explicit control; Escape requests quit confirmation.
|
|
}
|
|
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,
|
|
navigation_hold: None,
|
|
swap_hold: None,
|
|
#[cfg(target_os = "windows")]
|
|
presenter_focus: None,
|
|
};
|
|
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(),
|
|
blank: 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,
|
|
zoom_pending: false,
|
|
zoom_slow: false,
|
|
next_zoom_ack: now,
|
|
}),
|
|
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,
|
|
navigation_hold: None,
|
|
swap_hold: None,
|
|
#[cfg(target_os = "windows")]
|
|
presenter_focus: None,
|
|
};
|
|
el.run_app(&mut app)?;
|
|
Ok(())
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod buffer_tests {
|
|
use super::*;
|
|
#[test]
|
|
fn presentation_base_restores_only_an_exact_frame() {
|
|
let key = PresentationBaseKey {
|
|
size: [2, 2],
|
|
pixels_per_point: 1.,
|
|
frame: Some(("slide.rgba".into(), "sha".into(), 2, 2)),
|
|
blank: false,
|
|
colors: Default::default(),
|
|
zoom: Default::default(),
|
|
};
|
|
let cached = PresentationBase {
|
|
key: key.clone(),
|
|
pixels: vec![1, 2, 3, 4],
|
|
};
|
|
let mut pixels = vec![0; 4];
|
|
assert!(cached.restore(&key, &mut pixels));
|
|
assert_eq!(pixels, [1, 2, 3, 4]);
|
|
let changed = PresentationBaseKey { blank: true, ..key };
|
|
assert!(!cached.restore(&changed, &mut pixels));
|
|
assert!(!cached.restore(&cached.key, &mut [0; 3]));
|
|
}
|
|
#[test]
|
|
fn repaint_deadlines_bound_animation_and_leave_idle_windows_asleep() {
|
|
let now = Instant::now();
|
|
assert_eq!(repaint_deadline(now, Duration::MAX), None);
|
|
assert_eq!(
|
|
repaint_deadline(now, Duration::ZERO),
|
|
Some(now + Duration::from_millis(16))
|
|
);
|
|
assert_eq!(
|
|
repaint_deadline(now, Duration::from_secs(2)),
|
|
Some(now + Duration::from_secs(2))
|
|
);
|
|
}
|
|
|
|
#[cfg(target_os = "linux")]
|
|
#[test]
|
|
fn three_native_windows_render_without_clicks_and_reset_placement_on_topology_change() {
|
|
if std::env::var_os("DECKSTRIDE_GUI_TESTS").is_none() {
|
|
return;
|
|
}
|
|
use winit::platform::x11::EventLoopBuilderExtX11;
|
|
struct Harness {
|
|
app: App,
|
|
started: Instant,
|
|
topology_checked: bool,
|
|
}
|
|
impl ApplicationHandler for Harness {
|
|
fn resumed(&mut self, el: &ActiveEventLoop) {
|
|
self.app.handles = monitors(el).0;
|
|
let id = self.app.handles[0].0.id.clone();
|
|
for index in 0..3 {
|
|
let mut window =
|
|
NativeWindow::create(el, Role::Presentation, id.clone()).unwrap();
|
|
window.target = Some((id.clone(), false));
|
|
let _ = window
|
|
.window
|
|
.request_inner_size(PhysicalSize::new(180, 120));
|
|
window
|
|
.window
|
|
.set_outer_position(PhysicalPosition::new(20 + index * 200, 20));
|
|
window.window.set_visible(true);
|
|
window.window.request_redraw();
|
|
self.app.windows.push(window);
|
|
}
|
|
}
|
|
fn window_event(&mut self, el: &ActiveEventLoop, id: WindowId, event: WindowEvent) {
|
|
self.app.window_event(el, id, event);
|
|
}
|
|
fn about_to_wait(&mut self, el: &ActiveEventLoop) {
|
|
let now = Instant::now();
|
|
for window in &mut self.app.windows {
|
|
window.repaint_if_due(now);
|
|
}
|
|
if !self.topology_checked
|
|
&& now.duration_since(self.started) >= Duration::from_millis(200)
|
|
{
|
|
// Simulate a previous desktop layout. Route IDs and fullscreen
|
|
// are unchanged, but all three placements must be invalidated.
|
|
self.app.handles[0].0.origin.0 += 1;
|
|
self.app.refresh(el);
|
|
for window in &self.app.windows {
|
|
assert!(window.target.is_none());
|
|
assert!(window.transition.is_none());
|
|
}
|
|
self.topology_checked = true;
|
|
}
|
|
if now.duration_since(self.started) >= Duration::from_secs(1) {
|
|
el.exit();
|
|
}
|
|
el.set_control_flow(ControlFlow::WaitUntil(now + Duration::from_millis(8)));
|
|
}
|
|
}
|
|
let now = Instant::now();
|
|
let mut harness = Harness {
|
|
started: now,
|
|
topology_checked: false,
|
|
app: App {
|
|
studio: None,
|
|
host: None,
|
|
output: None,
|
|
lease: None,
|
|
windows: vec![],
|
|
handles: vec![],
|
|
next_poll: now,
|
|
next_clock: now,
|
|
next_monitors: now,
|
|
x11: true,
|
|
error: None,
|
|
smoke: false,
|
|
smoke_stage: 0,
|
|
started: now,
|
|
windowed: true,
|
|
override_presenter: None,
|
|
override_output: None,
|
|
navigation_hold: None,
|
|
swap_hold: None,
|
|
#[cfg(target_os = "windows")]
|
|
presenter_focus: None,
|
|
},
|
|
};
|
|
EventLoop::builder()
|
|
.with_x11()
|
|
.with_any_thread(true)
|
|
.build()
|
|
.unwrap()
|
|
.run_app(&mut harness)
|
|
.unwrap();
|
|
assert!(harness.app.error.is_none(), "{:?}", harness.app.error);
|
|
assert!(harness.topology_checked);
|
|
assert_eq!(harness.app.windows.len(), 3);
|
|
for window in &harness.app.windows {
|
|
assert!(window.frames > 0, "Every mirror must paint without a click");
|
|
assert!(
|
|
window.frames < 30,
|
|
"Idle window repainted {} times",
|
|
window.frames
|
|
);
|
|
}
|
|
}
|
|
|
|
#[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,
|
|
navigation_hold: None,
|
|
swap_hold: None,
|
|
#[cfg(target_os = "windows")]
|
|
presenter_focus: None,
|
|
};
|
|
for (role, consumed, modifiers, expected) in [
|
|
(Role::Presenter, false, egui::Modifiers::NONE, 1),
|
|
(Role::Presenter, false, egui::Modifiers::SHIFT, 0),
|
|
(Role::Browser, false, egui::Modifiers::NONE, 1),
|
|
(Role::Browser, false, egui::Modifiers::SHIFT, 0),
|
|
(Role::Presenter, true, egui::Modifiers::NONE, 1),
|
|
(Role::Presenter, true, egui::Modifiers::SHIFT, 0),
|
|
(
|
|
Role::Presenter,
|
|
false,
|
|
egui::Modifiers::SHIFT | egui::Modifiers::CTRL,
|
|
0,
|
|
),
|
|
(
|
|
Role::Presenter,
|
|
false,
|
|
egui::Modifiers::SHIFT | egui::Modifiers::ALT,
|
|
0,
|
|
),
|
|
(Role::Presentation, false, egui::Modifiers::NONE, 0),
|
|
(Role::Presenter, false, egui::Modifiers::NONE, 1),
|
|
(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;
|
|
for (key, modifiers) in [
|
|
(Key::Named(NamedKey::Escape), egui::Modifiers::NONE),
|
|
(Key::Character("q".into()), egui::Modifiers::CTRL),
|
|
] {
|
|
for role in [Role::Presenter, Role::Browser] {
|
|
app.key(role, key.clone(), true, modifiers);
|
|
let s = app.studio.as_ref().unwrap();
|
|
assert!(s.quit_confirmation && !s.close_requested && !s.blanked);
|
|
app.key(
|
|
role,
|
|
Key::Named(NamedKey::Space),
|
|
false,
|
|
egui::Modifiers::NONE,
|
|
);
|
|
assert!(app.studio.as_ref().unwrap().quit_confirmation);
|
|
app.key(
|
|
role,
|
|
Key::Named(NamedKey::Escape),
|
|
true,
|
|
egui::Modifiers::NONE,
|
|
);
|
|
assert!(!app.studio.as_ref().unwrap().quit_confirmation);
|
|
}
|
|
}
|
|
let (_tx, commands) = mpsc::sync_channel(4);
|
|
let (acks, rx) = mpsc::sync_channel(8);
|
|
app.host = Some(Host {
|
|
parent_connected: true,
|
|
close_requested: false,
|
|
commands,
|
|
acks,
|
|
state: HostState {
|
|
blanked: false,
|
|
..Default::default()
|
|
},
|
|
blank: 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,
|
|
zoom_pending: false,
|
|
zoom_slow: false,
|
|
next_zoom_ack: now,
|
|
});
|
|
app.key(
|
|
Role::Presentation,
|
|
Key::Named(NamedKey::Escape),
|
|
false,
|
|
egui::Modifiers::NONE,
|
|
);
|
|
assert!(!app.host.as_ref().unwrap().state.blanked);
|
|
assert!(!app.host.as_ref().unwrap().close_requested);
|
|
let ack = rx.try_recv().unwrap();
|
|
assert!(ack.request_quit && !ack.request_blank);
|
|
app.key(
|
|
Role::Presentation,
|
|
Key::Character("b".into()),
|
|
false,
|
|
egui::Modifiers::NONE,
|
|
);
|
|
assert!(rx.try_recv().unwrap().request_blank);
|
|
app.host.as_mut().unwrap().parent_connected = false;
|
|
app.key(
|
|
Role::Presentation,
|
|
Key::Named(NamedKey::Escape),
|
|
false,
|
|
egui::Modifiers::NONE,
|
|
);
|
|
assert!(app.host.as_ref().unwrap().close_requested);
|
|
}
|
|
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
|
|
));
|
|
}
|
|
}
|
|
|
|
fn swap_allowed(s: &Studio) -> bool {
|
|
s.initialized
|
|
&& !s.quit_confirmation
|
|
&& !s.startup_single_offer()
|
|
&& s.notes_editor.is_none()
|
|
&& s.notes_import.is_none()
|
|
&& !s.dialog_busy
|
|
&& !s.loading
|
|
&& s.route_trial.is_none()
|
|
&& !s.routes.presenter.is_empty()
|
|
&& !s.routes.presentation.is_empty()
|
|
}
|
|
|
|
fn take_due_swap(hold: &mut Option<(WindowId, Instant)>, now: Instant, allowed: bool) -> bool {
|
|
if !allowed {
|
|
*hold = None;
|
|
return false;
|
|
}
|
|
if hold.is_some_and(|(_, start)| now.saturating_duration_since(start) >= Duration::from_secs(1))
|
|
{
|
|
*hold = None;
|
|
return true;
|
|
}
|
|
false
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod swap_tests {
|
|
use super::*;
|
|
#[test]
|
|
fn hold_requires_one_second_fires_once_and_cancels_when_disallowed() {
|
|
let now = Instant::now();
|
|
let mut hold = Some((WindowId::dummy(), now));
|
|
assert!(!take_due_swap(
|
|
&mut hold,
|
|
now + Duration::from_millis(999),
|
|
true
|
|
));
|
|
assert!(take_due_swap(&mut hold, now + Duration::from_secs(1), true));
|
|
assert!(!take_due_swap(
|
|
&mut hold,
|
|
now + Duration::from_secs(20),
|
|
true
|
|
));
|
|
hold = Some((WindowId::dummy(), now));
|
|
assert!(!take_due_swap(
|
|
&mut hold,
|
|
now + Duration::from_millis(500),
|
|
false
|
|
));
|
|
assert!(!take_due_swap(
|
|
&mut hold,
|
|
now + Duration::from_secs(2),
|
|
true
|
|
));
|
|
}
|
|
}
|