diff --git a/Cargo.lock b/Cargo.lock index b5d9dd7..5a85195 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2245,7 +2245,7 @@ dependencies = [ [[package]] name = "pdf-presenter" -version = "0.1.66" +version = "0.1.67" dependencies = [ "bytemuck", "chrono", diff --git a/Cargo.toml b/Cargo.toml index 2c69c86..0b5c290 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -4,7 +4,7 @@ default-members = ["crates/pdf-presenter"] resolver = "3" [workspace.package] -version = "0.1.66" +version = "0.1.67" edition = "2024" license = "MIT" repository = "https://proxy.dandaedre.com/gitea/idle-org/pdf-presenter" diff --git a/crates/pdf-presenter/src/lib.rs b/crates/pdf-presenter/src/lib.rs index 2522e9c..a25835e 100644 --- a/crates/pdf-presenter/src/lib.rs +++ b/crates/pdf-presenter/src/lib.rs @@ -88,6 +88,9 @@ mod artwork; /// Monotonic elapsed/countdown timer. pub mod timer; +/// Bounded vector pointer and presentation annotations. +pub mod tools; + /// Editable presentation notes sidecars. pub mod notes; diff --git a/crates/pdf-presenter/src/localization.rs b/crates/pdf-presenter/src/localization.rs index f0c2e43..cfe524f 100644 --- a/crates/pdf-presenter/src/localization.rs +++ b/crates/pdf-presenter/src/localization.rs @@ -96,6 +96,17 @@ pub fn tr<'a>(ctx: &egui::Context, text: &'a str) -> &'a str { "No slide" => "Aucune diapositive", "End of slides" => "Fin des diapositives", "Size" => "Taille", + "Tools" => "Outils", + "Off" => "Désactivé", + "Pointer" => "Pointeur", + "Arrow" => "Flèche", + "Highlighter" => "Surligneur", + "Color" => "Couleur", + "Undo" => "Annuler", + "Clear" => "Effacer", + "Pointer follows the current slide. Drag to place arrows or highlights. Up to 64 vector marks; slide images are never rerendered." => { + "Le pointeur suit la diapositive actuelle. Glissez pour placer des flèches ou des surlignages. Jusqu’à 64 tracés vectoriels ; les images ne sont jamais recalculées." + } "Keep header visible" => "Garder l’en-tête visible", "Keep footer visible" => "Garder le pied de page visible", "Show both" => "Afficher les deux", diff --git a/crates/pdf-presenter/src/native.rs b/crates/pdf-presenter/src/native.rs index 2eae476..54952d2 100644 --- a/crates/pdf-presenter/src/native.rs +++ b/crates/pdf-presenter/src/native.rs @@ -267,6 +267,15 @@ impl NativeWindow { ..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, + ); + crate::tools::paint(ui.painter(), target, uv, &setup.overlay); + } } } }); @@ -715,12 +724,36 @@ impl App { if s.browser_preview.take().is_none() { s.execute(Action::CloseBrowser); } - } else if s.layout_open || s.displays_open || s.menu_open { + } else if s.layout_open || s.displays_open || s.menu_open || s.toolbox.open { s.layout_open = false; s.displays_open = false; s.menu_open = false; + s.toolbox.open = false; } } + 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), _ => {} } @@ -729,7 +762,7 @@ impl App { fn poll(&mut self, el: &ActiveEventLoop) { let mut repaint = false; if let Some(s) = &mut self.studio { - repaint |= s.new_zoom; + repaint |= s.new_zoom || s.new_overlay; let before = ( s.generation, s.frames.len(), @@ -840,6 +873,7 @@ impl App { 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, @@ -869,24 +903,28 @@ impl App { 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 + if (s.new_zoom || s.new_overlay) && !s.new_output && let Some(output) = &self.output { let state = HostState { - zoom_only: true, + 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 { @@ -915,18 +953,26 @@ impl App { break; } }; - if state.zoom_only { + if state.zoom_only || state.overlay_only { if state.generation == host.state.generation && state.page == host.state.page { - 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.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; } diff --git a/crates/pdf-presenter/src/output.rs b/crates/pdf-presenter/src/output.rs index b8387da..c78d98f 100644 --- a/crates/pdf-presenter/src/output.rs +++ b/crates/pdf-presenter/src/output.rs @@ -28,6 +28,10 @@ pub struct HostState { #[serde(default)] pub zoom_only: bool, #[serde(default)] + pub overlay: crate::tools::Overlay, + #[serde(default)] + pub overlay_only: bool, + #[serde(default)] pub slide_colors: crate::settings::SlideColors, #[serde(default)] pub setup_controls: bool, @@ -77,13 +81,21 @@ pub struct Ack { #[serde(default)] pub buffered: usize, } -/// A lightweight crop update must never discard queued frame/routing state. +/// Lightweight crop/annotation updates must never discard queued frame/routing state. pub fn coalesce(latest: &mut Option, command: HostState) { - if command.zoom_only + if (command.zoom_only || command.overlay_only) && let Some(previous) = latest { if previous.generation == command.generation && previous.page == command.page { - previous.zoom.accept_presenter(command.zoom); + let previous_is_lightweight = previous.zoom_only || previous.overlay_only; + if command.zoom_only { + previous.zoom.accept_presenter(command.zoom); + previous.zoom_only |= previous_is_lightweight; + } + if command.overlay_only { + previous.overlay = command.overlay.normalized(); + previous.overlay_only |= previous_is_lightweight; + } } } else { *latest = Some(command); diff --git a/crates/pdf-presenter/src/presenter_ui.rs b/crates/pdf-presenter/src/presenter_ui.rs index d9a202d..9fe9a49 100644 --- a/crates/pdf-presenter/src/presenter_ui.rs +++ b/crates/pdf-presenter/src/presenter_ui.rs @@ -3,6 +3,7 @@ use crate::localization::tr; use crate::{ settings::{Layout, TimerMode, TimerPosition}, studio::{Action, SlideLoadState, Studio}, + tools::Tool, }; use egui::{Color32, Context, FontId, Pos2, Rect, Sense, TextureHandle, TextureOptions, Ui, Vec2}; use std::{ @@ -325,6 +326,143 @@ fn fullscreen_button(ui: &mut Ui, s: &mut Studio) { } } +fn tool_button(ui: &mut Ui, toolbox: &mut crate::tools::Toolbox, tool: Tool, label: &str) { + if ui.selectable_label(toolbox.tool == tool, label).clicked() { + toolbox.select(tool); + } +} + +fn toolbox_window(ctx: &Context, s: &mut Studio) { + if !s.toolbox.open { + return; + } + let mut open = true; + let before = (s.toolbox.overlay.pointer, s.toolbox.overlay.marks.len()); + egui::Window::new(tr(ctx, "Tools")) + .id(egui::Id::new("presentation-tools")) + .open(&mut open) + .default_pos(ctx.content_rect().right_top() + Vec2::new(-330., 72.)) + .default_width(300.) + .resizable(false) + .show(ctx, |ui| { + ui.horizontal_wrapped(|ui| { + tool_button(ui, &mut s.toolbox, Tool::Off, tr(ctx, "Off")); + tool_button(ui, &mut s.toolbox, Tool::Pointer, tr(ctx, "Pointer")); + tool_button(ui, &mut s.toolbox, Tool::Arrow, tr(ctx, "Arrow")); + tool_button( + ui, + &mut s.toolbox, + Tool::Highlighter, + tr(ctx, "Highlighter"), + ); + }); + ui.separator(); + ui.horizontal(|ui| { + ui.label(tr(ctx, "Color")); + for color in [ + [244, 67, 54], + [255, 214, 0], + [0, 210, 255], + [255, 255, 255], + ] { + let (rect, response) = ui.allocate_exact_size(Vec2::splat(28.), Sense::click()); + ui.painter().circle_filled( + rect.center(), + 9., + Color32::from_rgb(color[0], color[1], color[2]), + ); + if color == s.toolbox.color { + ui.painter().circle_stroke( + rect.center(), + 12., + egui::Stroke::new(2_f32, ui.visuals().hyperlink_color), + ); + } + if response.clicked() { + s.toolbox.color = color; + } + } + }); + ui.add(egui::Slider::new(&mut s.toolbox.size, 4. ..=32.).text(tr(ctx, "Size"))); + ui.horizontal(|ui| { + if ui + .add_enabled(!s.toolbox.overlay.marks.is_empty(), egui::Button::new(tr(ctx, "Undo"))) + .clicked() + { + s.toolbox.undo(); + } + if ui + .add_enabled( + s.toolbox.overlay.pointer.is_some() || !s.toolbox.overlay.marks.is_empty(), + egui::Button::new(tr(ctx, "Clear")), + ) + .clicked() + { + s.toolbox.clear(); + } + }); + ui.small(tr( + ctx, + "Pointer follows the current slide. Drag to place arrows or highlights. Up to 64 vector marks; slide images are never rerendered.", + )); + }); + s.toolbox.open = open; + if (s.toolbox.overlay.pointer, s.toolbox.overlay.marks.len()) != before { + s.new_overlay = true; + } +} + +fn slide_tools(ui: &mut Ui, s: &mut Studio, area: Rect, dimensions: [u32; 2]) { + let (target, uv) = zoom_geometry(area, dimensions, s.zoom.view, s.zoom.keep_fitted_area); + let sense = match s.toolbox.tool { + Tool::Arrow | Tool::Highlighter => Sense::click_and_drag(), + Tool::Pointer => Sense::hover(), + Tool::Off => Sense::hover(), + }; + let response = ui.interact(target, ui.id().with("slide-tools"), sense); + let mut changed = false; + match s.toolbox.tool { + Tool::Off => changed |= s.toolbox.set_pointer(None), + Tool::Pointer => { + let point = response + .hover_pos() + .map(|point| crate::tools::screen_to_page(target, uv, point)); + changed |= s.toolbox.set_pointer(point); + if response.hovered() { + ui.ctx().set_cursor_icon(egui::CursorIcon::Crosshair); + } + } + Tool::Arrow | Tool::Highlighter => { + changed |= s.toolbox.set_pointer(None); + if response.drag_started() + && let Some(point) = response.interact_pointer_pos() + { + changed |= s + .toolbox + .begin_mark(crate::tools::screen_to_page(target, uv, point)); + } + if response.dragged() + && let Some(point) = response.interact_pointer_pos() + { + changed |= s + .toolbox + .update_mark(crate::tools::screen_to_page(target, uv, point)); + } + if response.drag_stopped() { + s.toolbox.end_mark(); + } + if response.hovered() || response.dragged() { + ui.ctx().set_cursor_icon(egui::CursorIcon::Crosshair); + } + } + } + crate::tools::paint(ui.painter(), target, uv, &s.toolbox.overlay); + if changed { + s.presentation_action(); + s.new_overlay = true; + } +} + fn button(ui: &mut Ui, label: &str, action: Action, actions: &mut Vec) { if ui.button(label).clicked() { actions.push(action); @@ -860,7 +998,11 @@ pub fn presenter(ui: &mut Ui, s: &mut Studio, native: &mut UiState) { ); if let Some(page) = page { let area = Rect::from_min_max(rect.min + Vec2::new(0., 24.), rect.max); - if index == 1 && s.settings.zoom_enabled { + if index == 1 + && (s.settings.zoom_enabled + || s.toolbox.tool != Tool::Off + || !s.toolbox.overlay.marks.is_empty()) + { // Mirror the output aspect, not the independently sized presenter pane. // This makes the shared zoom/center produce the same visible page crop. let area = s @@ -870,20 +1012,24 @@ pub fn presenter(ui: &mut Ui, s: &mut Studio, native: &mut UiState) { if s.route_trial.is_none() && let Some(frame) = s.frame(page) { - let (view, response) = zoom_gestures_in( - ui, - area, - [frame.info.width, frame.info.height], - s.zoom.view, - s.zoom.keep_fitted_area, - ); - response.on_hover_text(tr( - &locale, - "Scroll to zoom · drag to pan · double-click to fit width / reset", - )); - if view != s.zoom.view { - s.set_zoom_from_action(view); + let dimensions = [frame.info.width, frame.info.height]; + if s.toolbox.tool == Tool::Off && s.settings.zoom_enabled { + let (view, response) = zoom_gestures_in( + ui, + area, + dimensions, + s.zoom.view, + s.zoom.keep_fitted_area, + ); + response.on_hover_text(tr( + &locale, + "Scroll to zoom · drag to pan · double-click to fit width / reset", + )); + if view != s.zoom.view { + s.set_zoom_from_action(view); + } } + slide_tools(ui, s, area, dimensions); } } else { native.image(ui, s, page, area); @@ -1033,6 +1179,9 @@ pub fn presenter(ui: &mut Ui, s: &mut Studio, native: &mut UiState) { if ui.button(tr(&locale, "Layout")).clicked() { s.layout_open = !s.layout_open; } + if ui.button(tr(&locale, "Tools")).clicked() { + s.toolbox.open = !s.toolbox.open; + } fullscreen_button(ui, s); timer_buttons(ui, s); let inactive = s.blanked || s.routes.presentation.is_empty() || s.count() == 0; @@ -1547,6 +1696,7 @@ pub fn presenter(ui: &mut Ui, s: &mut Studio, native: &mut UiState) { }); s.displays_open &= open; } + toolbox_window(&ctx, s); if s.settings.zoom_enabled && s.zoom_warning && !s.zoom_warning_dismissed { egui::Window::new(tr(&ctx, "Zoom performance")) .collapsible(false).resizable(false).show(&ctx, |ui| { diff --git a/crates/pdf-presenter/src/studio.rs b/crates/pdf-presenter/src/studio.rs index 6ecad32..d168610 100644 --- a/crates/pdf-presenter/src/studio.rs +++ b/crates/pdf-presenter/src/studio.rs @@ -140,6 +140,8 @@ pub struct Studio { pub new_zoom: bool, pub zoom_warning: bool, pub zoom_warning_dismissed: bool, + pub toolbox: crate::tools::Toolbox, + pub new_overlay: bool, pub new_output: bool, pub close_requested: bool, failed: HashSet<(usize, u32)>, @@ -242,6 +244,8 @@ impl Studio { new_zoom: false, zoom_warning: false, zoom_warning_dismissed: false, + toolbox: Default::default(), + new_overlay: false, new_output: true, close_requested: false, failed: HashSet::new(), @@ -460,6 +464,8 @@ impl Studio { self.presentation_started = true; if self.requested != page { self.set_zoom(crate::zoom::View::default()); + self.toolbox.clear(); + self.new_overlay = true; self.presentation_action(); } self.requested = page; @@ -898,6 +904,8 @@ impl Studio { self.ram_blocked = false; self.failed.clear(); self.set_zoom(crate::zoom::View::default()); + self.toolbox.clear(); + self.new_overlay = true; self.requested = 0; self.presentation_started = false; self.timer = crate::timer::Timer::default(); diff --git a/crates/pdf-presenter/src/tools.rs b/crates/pdf-presenter/src/tools.rs new file mode 100644 index 0000000..01bca06 --- /dev/null +++ b/crates/pdf-presenter/src/tools.rs @@ -0,0 +1,239 @@ +//! Bounded, resolution-independent presentation annotations. +use egui::{Color32, Pos2, Rect, Stroke, Vec2}; +use serde::{Deserialize, Serialize}; + +pub const MAX_MARKS: usize = 64; + +#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)] +pub enum Tool { + #[default] + Off, + Pointer, + Arrow, + Highlighter, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)] +pub enum MarkKind { + Arrow, + Highlighter, +} + +#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] +pub struct Mark { + pub kind: MarkKind, + pub from: [f32; 2], + pub to: [f32; 2], + pub color: [u8; 3], + pub width: f32, +} + +#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] +pub struct Overlay { + #[serde(default)] + pub pointer: Option<[f32; 2]>, + #[serde(default)] + pub pointer_color: [u8; 3], + #[serde(default)] + pub pointer_size: f32, + #[serde(default)] + pub marks: Vec, +} + +impl Overlay { + pub fn normalized(mut self) -> Self { + self.pointer = self.pointer.and_then(normalized_point); + self.pointer_size = finite_clamp(self.pointer_size, 4., 48., 12.); + self.marks.truncate(MAX_MARKS); + self.marks.retain_mut(|mark| { + let Some(from) = normalized_point(mark.from) else { + return false; + }; + let Some(to) = normalized_point(mark.to) else { + return false; + }; + mark.from = from; + mark.to = to; + mark.width = finite_clamp(mark.width, 2., 48., 8.); + true + }); + self + } +} + +fn finite_clamp(value: f32, min: f32, max: f32, fallback: f32) -> f32 { + if value.is_finite() { + value.clamp(min, max) + } else { + fallback + } +} + +fn normalized_point(point: [f32; 2]) -> Option<[f32; 2]> { + point + .iter() + .all(|value| value.is_finite()) + .then(|| point.map(|value| value.clamp(0., 1.))) +} + +pub struct Toolbox { + pub open: bool, + pub tool: Tool, + pub color: [u8; 3], + pub size: f32, + pub overlay: Overlay, + drag_mark: Option, +} + +impl Default for Toolbox { + fn default() -> Self { + Self { + open: false, + tool: Tool::Off, + color: [244, 67, 54], + size: 10., + overlay: Overlay { + pointer_color: [244, 67, 54], + pointer_size: 10., + ..Default::default() + }, + drag_mark: None, + } + } +} + +impl Toolbox { + pub fn select(&mut self, tool: Tool) -> bool { + self.tool = tool; + self.drag_mark = None; + tool != Tool::Pointer && self.overlay.pointer.take().is_some() + } + + pub fn set_pointer(&mut self, point: Option<[f32; 2]>) -> bool { + let point = point.and_then(normalized_point); + let changed = self.overlay.pointer != point + || self.overlay.pointer_color != self.color + || self.overlay.pointer_size != self.size; + self.overlay.pointer = point; + self.overlay.pointer_color = self.color; + self.overlay.pointer_size = self.size; + changed + } + + pub fn begin_mark(&mut self, point: [f32; 2]) -> bool { + let kind = match self.tool { + Tool::Arrow => MarkKind::Arrow, + Tool::Highlighter => MarkKind::Highlighter, + _ => return false, + }; + if self.overlay.marks.len() == MAX_MARKS { + self.overlay.marks.remove(0); + } + self.overlay.marks.push(Mark { + kind, + from: point, + to: point, + color: self.color, + width: self.size, + }); + self.drag_mark = Some(self.overlay.marks.len() - 1); + true + } + + pub fn update_mark(&mut self, point: [f32; 2]) -> bool { + let Some(mark) = self + .drag_mark + .and_then(|index| self.overlay.marks.get_mut(index)) + else { + return false; + }; + let Some(point) = normalized_point(point) else { + return false; + }; + if mark.to == point { + return false; + } + mark.to = point; + true + } + + pub fn end_mark(&mut self) { + self.drag_mark = None; + } + + pub fn undo(&mut self) -> bool { + self.drag_mark = None; + self.overlay.marks.pop().is_some() + } + + pub fn clear(&mut self) -> bool { + self.drag_mark = None; + let changed = self.overlay.pointer.take().is_some() || !self.overlay.marks.is_empty(); + self.overlay.marks.clear(); + changed + } +} + +pub fn screen_to_page(target: Rect, uv: Rect, point: Pos2) -> [f32; 2] { + let local = (point - target.min) / target.size().max(Vec2::splat(1.)); + let page = uv.min + local * uv.size(); + [page.x.clamp(0., 1.), page.y.clamp(0., 1.)] +} + +fn page_to_screen(target: Rect, uv: Rect, point: [f32; 2]) -> Option { + let point = Pos2::new(point[0], point[1]); + uv.contains(point).then(|| { + target.min + (point - uv.min) / uv.size().max(Vec2::splat(f32::EPSILON)) * target.size() + }) +} + +pub fn paint(painter: &egui::Painter, target: Rect, uv: Rect, overlay: &Overlay) { + for mark in overlay.marks.iter().take(MAX_MARKS) { + let (Some(from), Some(to)) = ( + page_to_screen(target, uv, mark.from), + page_to_screen(target, uv, mark.to), + ) else { + continue; + }; + let color = match mark.kind { + MarkKind::Arrow => Color32::from_rgb(mark.color[0], mark.color[1], mark.color[2]), + MarkKind::Highlighter => { + Color32::from_rgba_unmultiplied(mark.color[0], mark.color[1], mark.color[2], 105) + } + }; + let width = mark.width * painter.ctx().pixels_per_point().sqrt().clamp(1., 2.); + painter.line_segment([from, to], Stroke::new(width, color)); + if mark.kind == MarkKind::Arrow { + let direction = to - from; + if direction.length_sq() > 4. { + let direction = direction.normalized(); + let normal = Vec2::new(-direction.y, direction.x); + let length = (width * 2.8).clamp(12., 42.); + painter.line_segment( + [to, to - direction * length + normal * length * 0.45], + Stroke::new(width, color), + ); + painter.line_segment( + [to, to - direction * length - normal * length * 0.45], + Stroke::new(width, color), + ); + } + } + } + if let Some(point) = overlay + .pointer + .and_then(|point| page_to_screen(target, uv, point)) + { + let color = Color32::from_rgb( + overlay.pointer_color[0], + overlay.pointer_color[1], + overlay.pointer_color[2], + ); + painter.circle_filled(point, overlay.pointer_size, color); + painter.circle_stroke( + point, + overlay.pointer_size + 2., + Stroke::new(2_f32, Color32::WHITE), + ); + } +} diff --git a/crates/pdf-presenter/tests/tools.rs b/crates/pdf-presenter/tests/tools.rs new file mode 100644 index 0000000..ad68dbd --- /dev/null +++ b/crates/pdf-presenter/tests/tools.rs @@ -0,0 +1,102 @@ +use egui::{Pos2, Rect, Vec2}; +use pdf_presenter::{ + output::{HostState, coalesce}, + tools::{MAX_MARKS, Mark, MarkKind, Overlay, Toolbox, screen_to_page}, +}; + +#[test] +fn overlay_input_is_bounded_and_normalized() { + let marks = (0..MAX_MARKS + 10) + .map(|_| Mark { + kind: MarkKind::Arrow, + from: [-1., 0.25], + to: [2., 0.75], + color: [255, 0, 0], + width: 500., + }) + .collect(); + let overlay = Overlay { + pointer: Some([f32::NAN, 0.]), + pointer_size: f32::INFINITY, + marks, + ..Default::default() + } + .normalized(); + assert_eq!(overlay.marks.len(), MAX_MARKS); + assert_eq!(overlay.marks[0].from, [0., 0.25]); + assert_eq!(overlay.marks[0].to, [1., 0.75]); + assert_eq!(overlay.marks[0].width, 48.); + assert_eq!(overlay.pointer, None); + assert_eq!(overlay.pointer_size, 12.); +} + +#[test] +fn toolbox_discards_oldest_mark_and_maps_visible_crop() { + let mut tools = Toolbox::default(); + tools.select(pdf_presenter::tools::Tool::Arrow); + for index in 0..MAX_MARKS + 1 { + assert!(tools.begin_mark([index as f32 / 100., 0.5])); + tools.end_mark(); + } + assert_eq!(tools.overlay.marks.len(), MAX_MARKS); + assert_eq!(tools.overlay.marks[0].from[0], 0.01); + + let target = Rect::from_min_size(Pos2::new(10., 20.), Vec2::new(200., 100.)); + let uv = Rect::from_min_max(Pos2::new(0.25, 0.25), Pos2::new(0.75, 0.75)); + assert_eq!(screen_to_page(target, uv, target.center()), [0.5, 0.5]); +} + +#[test] +fn overlay_update_coalesces_without_losing_full_output_state() { + let mut pending = Some(HostState { + generation: 9, + page: 3, + sequence: 22, + monitors: vec!["projector".into()], + ..Default::default() + }); + let overlay = Overlay { + pointer: Some([0.2, 0.7]), + pointer_size: 14., + ..Default::default() + }; + coalesce( + &mut pending, + HostState { + generation: 9, + page: 3, + overlay_only: true, + overlay: overlay.clone(), + ..Default::default() + }, + ); + let pending = pending.unwrap(); + assert_eq!(pending.sequence, 22); + assert_eq!(pending.monitors, vec!["projector"]); + assert!(!pending.overlay_only); + assert_eq!(pending.overlay, overlay.clone().normalized()); + + let mut lightweight = Some(HostState { + generation: 9, + page: 3, + overlay_only: true, + overlay: overlay.clone(), + ..Default::default() + }); + coalesce( + &mut lightweight, + HostState { + generation: 9, + page: 3, + zoom_only: true, + zoom: pdf_presenter::zoom::Sync { + enabled: true, + ..Default::default() + }, + ..Default::default() + }, + ); + let lightweight = lightweight.unwrap(); + assert!(lightweight.overlay_only && lightweight.zoom_only); + assert_eq!(lightweight.overlay, overlay.normalized()); +} diff --git a/docs/changelog.md b/docs/changelog.md index 22d02cd..af36819 100644 --- a/docs/changelog.md +++ b/docs/changelog.md @@ -2,6 +2,16 @@ ## Unreleased +### 0.1.67 + +- Add a presenter toolbox with a low-latency pointer, straight arrows and + translucent highlighter strokes. Send normalized vector overlays through a + bounded, coalesced output update without rerendering slides or reading files; + cap each slide view at 64 marks and provide size, color, undo and clear controls. + Pointer/mark activity can start an armed presentation timer. Linux checks pass + with 84.30% whole-application coverage; the release binary is rebuilt. Physical + output latency and appearance remain separate acceptance checks. + ### 0.1.66 - Run the optional Linux desktop-launcher installation test only on Linux workers; diff --git a/docs/interfaces/process-protocol.md b/docs/interfaces/process-protocol.md index f3451b6..9cad3bf 100644 --- a/docs/interfaces/process-protocol.md +++ b/docs/interfaces/process-protocol.md @@ -171,6 +171,23 @@ The performance watcher counts three consecutive zoomed window draws above 33 ms including software drawing/presentation. The presenter shows the warning locally; output hosts report only a boolean. It does not alter visibility or navigation. +## Bounded presentation overlays in 0.1.67 + +HostState adds `overlay` and default-false `overlay_only`. The overlay contains an +optional normalized page-coordinate pointer and at most 64 normalized straight +arrow/highlighter marks with RGB color and bounded logical width. Invalid points are +dropped, coordinates and widths are clamped, and excess marks are discarded. No +notes, source paths or operator UI text enter this payload. + +Overlay-only messages carry page/generation identity and absolute current overlay +state. They share the two-slot presenter queue with zoom updates: coalescing merges +same-page overlay and zoom fields into a pending full state without replacing frame, +preload, routing, fullscreen or visibility data. The host rejects stale page or +generation updates. Full state carries the overlay for host recovery. Drawing uses +the existing buffered texture plus bounded vector shapes; it performs no PDF render, +image decode, texture upload or slide-file access. This remains private same-build +IPC. + Since 0.1.60, output heartbeats may include `viewport {monitor, size, fullscreen}`. `size` is the actual reference output window’s physical client size `[width, height]`. diff --git a/docs/user-guide.md b/docs/user-guide.md index d10a2d8..0b2b252 100644 --- a/docs/user-guide.md +++ b/docs/user-guide.md @@ -85,6 +85,23 @@ editors and Ctrl/Alt/Command combinations retain keyboard priority. Type a 1-bas number then Enter to jump; Backspace edits and Escape cancels. Out-of-range numbers do not navigate. Output windows accept B/Escape for emergency blanking. +## Pointer and drawing tools + +Choose **Tools** in the presenter header. **Pointer** follows the mouse over the +current-slide preview and appears at the same normalized page position on every +presentation output. **Arrow** and **Highlighter** add one straight vector mark per +drag. Choose a color and size, then use **Undo** or **Clear** as needed. P toggles the +pointer, A selects the arrow and H selects the highlighter when no text editor or +modified shortcut has priority. Marks clear when you change slides and are not saved +to the source document or settings. + +The toolbox is off by default. It keeps at most 64 marks and draws them over the +already buffered slide texture. Pointer movement uses the bounded output-state queue; +it does not rerender the PDF, decode an image or read a slide from disk. Selecting a +drawing tool temporarily gives dragging to that tool; select **Off** to pan a +zoomed slide again. A first pointer or drawing action starts an armed timer just like +navigation or zoom. + ## Layout and notes Layout independently enables and sizes previous/current/next slides, notes, elapsed