GitCorner

Code

ossartcraftdeckcraft🌐
e4f86d11fe8a
use super::keys::keyboard;
use super::render::{fit, next_rect};
use super::zoom::{Zoom, grid_indices, paint_grid, see_all_hit, slide_aspect, toggle_blank, zoom_frame};
use super::{Align2, Color32, CornerRadius, Presentation, Rect, RenderOpts, Sense, Show, Stroke, Ui, pos2, theme, vec2};

pub(super) const NOTES_DEFAULT: f32 = 18.0;

pub(super) const NOTES_MIN: f32 = 12.0;

pub(super) const NOTES_MAX: f32 = 48.0;

pub(super) const NOTES_STEP: f32 = 4.0;

/// Presenter-view elapsed time. Pausing freezes the number; the show keeps playing.
#[derive(Clone, Copy)]
pub(super) struct PresenterTimer {
    origin: f64,
    frozen: f64,
    paused: bool,
}

impl PresenterTimer {
    pub(super) fn start(now: f64) -> Self {
        PresenterTimer { origin: finite_time(now), frozen: 0.0, paused: false }
    }

    pub(super) fn elapsed(self, now: f64) -> f64 {
        if self.paused {
            return finite_secs(self.frozen);
        }
        let dt = now - self.origin;
        finite_secs(self.frozen + if dt.is_finite() && dt > 0.0 { dt } else { 0.0 })
    }

    pub(super) fn paused(self) -> bool {
        self.paused
    }

    pub(super) fn toggle(&mut self, now: f64) {
        if self.paused {
            self.origin = finite_time(now);
            self.paused = false;
        } else {
            self.frozen = self.elapsed(now);
            self.paused = true;
        }
    }

    /// Zero the elapsed time. A paused timer stays paused at zero.
    pub(super) fn reset(&mut self, now: f64) {
        self.frozen = 0.0;
        self.origin = finite_time(now);
    }
}

fn finite_time(now: f64) -> f64 {
    if now.is_finite() { now } else { 0.0 }
}

fn finite_secs(n: f64) -> f64 {
    if n.is_finite() && n >= 0.0 { n } else { 0.0 }
}

pub(super) fn format_elapsed(secs: f64) -> String {
    let s = finite_secs(secs) as u64;
    let s = s.min(99 * 3600 + 59 * 60 + 59);
    format!("{:02}:{:02}:{:02}", s / 3600, (s / 60) % 60, s % 60)
}

/// Local wall clock for presenter view. `--:--` where there is no clock (wasm).
pub(super) fn wall_clock() -> String {
    match deckcraft_text::datetime::DateTime::now_local() {
        Some(t) if t.hour < 24 && t.minute < 60 => format!("{:02}:{:02}", t.hour, t.minute),
        _ => "--:--".to_string(),
    }
}

/// The Presenter View's preview of slide `n`, `size` pixels.
fn render_preview(doc: &Presentation, n: usize, size: (u32, u32), threads: u16) -> egui::ColorImage {
    let opts = RenderOpts { scale: size.0 as f64 / doc.slide_size.width.max(1.0), size: Some(size), threads, ..Default::default() };
    crate::textures::to_color_image(&deckcraft_render::render_slide(doc, n, &opts), false)
}

/// Render the presenter window and set `keep` false when the user ends or closes the show.
pub(super) fn presenter_window(ctx: &egui::Context, show: &mut Show, doc: &std::sync::Arc<Presentation>, now: f64, keep: &mut bool) {
    let cur = show.state.slide;
    let next = show.state.peek_next(doc);
    let cur_tex = show.tex.as_ref().map(|(_, t)| t.clone());
    // The preview wanted: slide `n` of this presentation (an edit replaces it).
    let is = |d: &std::sync::Arc<Presentation>, k: usize, n: usize| std::sync::Arc::ptr_eq(d, doc) && k == n;
    if let Some(n) = next
        && show.next_tex.as_ref().is_none_or(|(d, k, _)| !is(d, *k, n))
    {
        // A very tall slide shape would otherwise ask for a picture taller than the GPU's limit.
        let next_size = crate::textures::fit_size(
            (480, (480.0 * doc.slide_size.height / doc.slide_size.width.max(1.0)).clamp(1.0, 1e9) as u32),
            crate::textures::max_side(ctx),
        );
        // Rendered on another thread, so turning the page doesn't wait for the preview (#964). One
        // render at a time: paging faster than it renders asks for the newest preview once it is
        // done, and a finished one no longer wanted is dropped.
        if let Some((d, k, rx)) = show.next_job.take() {
            match rx.try_recv() {
                Ok(ci) if is(&d, k, n) => show.next_tex = Some((d, k, crate::textures::upload(ctx, "presenter-next", ci))),
                Ok(_) => {}
                Err(std::sync::mpsc::TryRecvError::Empty) => show.next_job = Some((d, k, rx)),
                // The worker died: render this one here, as before, rather than start another.
                Err(std::sync::mpsc::TryRecvError::Disconnected) => {
                    show.next_tex = Some((doc.clone(), n, crate::textures::upload(ctx, "presenter-next", render_preview(doc, n, next_size, 0))));
                }
            }
        }
        if show.next_job.is_none() && show.next_tex.as_ref().is_none_or(|(d, k, _)| !is(d, *k, n)) {
            let (tx, rx) = std::sync::mpsc::channel();
            let worker_doc = doc.clone();
            // The web has no threads: render it here.
            let spawned = !cfg!(target_arch = "wasm32")
                && std::thread::Builder::new()
                    .name("show-next-preview".into())
                    .spawn(move || {
                        let _ = tx.send(render_preview(&worker_doc, n, next_size, 1));
                    })
                    .is_ok();
            if spawned {
                #[cfg(test)]
                {
                    show.preview_spawns += 1;
                }
                show.next_job = Some((doc.clone(), n, rx));
            } else {
                show.next_tex = Some((doc.clone(), n, crate::textures::upload(ctx, "presenter-next", render_preview(doc, n, next_size, 0))));
            }
        }
        if show.next_job.is_some() {
            ctx.request_repaint_after(std::time::Duration::from_millis(16));
        }
    }
    let next_tex = show.next_tex.as_ref().filter(|(d, k, _)| next.is_some_and(|n| is(d, *k, n))).map(|(_, _, t)| t.clone());
    let no_notes = deckcraft_model::text::TextBody::default();
    let notes = doc.slides.get(cur).map_or(&no_notes, |s| &s.notes);
    let clock = wall_clock();
    // The presenter clock only moves when this window is drawn again.
    ctx.request_repaint_after(std::time::Duration::from_millis(500));
    let mut actions = vec![];
    // The presenter window is dark; default buttons draw dark text on it (#221).
    let button = |ui: &mut Ui, s: &str| {
        ui.add(egui::Button::new(egui::RichText::new(s).size(15.0).color(Color32::WHITE)).fill(Color32::from_gray(60)).min_size(vec2(0.0, 30.0)))
    };
    ctx.show_viewport_immediate(
        egui::ViewportId::from_hash_of("deckcraft_presenter"),
        egui::ViewportBuilder::default().with_title("Presenter View — DeckCraft").with_inner_size([1100.0, 700.0]),
        |ui, _| {
            if !keyboard(ui.ctx(), show, doc, now, true) {
                *keep = false;
            }
            ui.ctx().request_repaint_after(std::time::Duration::from_millis(500));
            let elapsed = show.timer.elapsed(now);
            let paused = show.timer.paused();
            egui::CentralPanel::default().frame(egui::Frame::NONE.fill(Color32::from_gray(24)).inner_margin(egui::Margin::same(16))).show(ui, |ui| {
                ui.horizontal(|ui| {
                    ui.label(egui::RichText::new(format_elapsed(elapsed)).size(22.0).color(if paused {
                        Color32::from_gray(160)
                    } else {
                        Color32::WHITE
                    }));
                    ui.add_space(12.0);
                    ui.label(egui::RichText::new(clock.clone()).size(16.0).color(Color32::from_gray(200)));
                    ui.add_space(20.0);
                    ui.label(egui::RichText::new(format!("Slide {} of {}", cur + 1, doc.slides.len())).size(16.0).color(Color32::from_gray(200)));
                    ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
                        if button(ui, "End Show").clicked() {
                            *keep = false;
                        }
                        if button(ui, "Next ▶").clicked() {
                            actions.push(show.state.next(doc));
                        }
                        if button(ui, "◀ Previous").clicked() {
                            actions.push(show.state.prev(doc));
                        }
                    });
                });
                ui.horizontal(|ui| {
                    if button(ui, if paused { "Resume" } else { "Pause" }).clicked() {
                        show.timer.toggle(now);
                    }
                    if button(ui, "Reset").clicked() {
                        show.timer.reset(now);
                    }
                    if button(ui, if show.blank == Some(Color32::BLACK) { "Black on" } else { "Black" }).clicked() {
                        toggle_blank(show, Color32::BLACK);
                    }
                    if button(ui, if show.blank == Some(Color32::WHITE) { "White on" } else { "White" }).clicked() {
                        toggle_blank(show, Color32::WHITE);
                    }
                    if button(ui, if show.presenter_grid { "All slides on" } else { "All slides" }).clicked() {
                        show.presenter_grid = !show.presenter_grid;
                    }
                    if button(ui, show.zoom_label()).clicked() {
                        show.zoom_key();
                    }
                });
                ui.add_space(8.0);
                let avail = ui.available_rect_before_wrap();
                if show.presenter_grid {
                    // The grid fills this window; the audience keeps seeing the current slide.
                    paint_grid(ui.painter(), ui.ctx(), show, doc, avail);
                    let hit = ui.interact(avail, ui.scope_id().with("presenter_grid"), Sense::click());
                    if hit.clicked()
                        && let Some(p) = hit.interact_pointer_pos()
                        && let Some(n) = see_all_hit(avail, grid_indices(doc.slides.len()).len(), slide_aspect(doc), p)
                        && let Some(&i) = grid_indices(doc.slides.len()).get(n)
                    {
                        show.presenter_grid = false;
                        show.blank = None;
                        show.zoom = None;
                        show.zoom_arm = false;
                        actions.push(show.state.goto(doc, i));
                    }
                    return;
                }
                let left = Rect::from_min_max(avail.min, pos2(avail.min.x + avail.width() * 0.62, avail.max.y));
                let right = Rect::from_min_max(pos2(left.max.x + 16.0, avail.min.y), avail.max);
                let cr = fit(Rect::from_min_max(left.min, pos2(left.max.x, left.min.y + left.height() * 0.8)), doc);
                let cr = Rect::from_min_size(left.min, cr.size());
                if let Some(t) = &cur_tex {
                    ui.painter().image(t.id(), cr, Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0)), Color32::WHITE);
                }
                if let Some(z) = show.zoom {
                    let mark = zoom_frame(cr, z.uv());
                    ui.painter().rect_stroke(mark, CornerRadius::ZERO, Stroke::new(2.0, Color32::WHITE), egui::StrokeKind::Inside);
                }
                if show.zoom_arm {
                    let hit = ui.interact(cr, ui.scope_id().with("presenter_zoom"), Sense::click());
                    hit.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, true, "Zoom"));
                    if hit.clicked()
                        && let Some(p) = hit.interact_pointer_pos()
                        && cr.width() > 1.0
                        && cr.height() > 1.0
                    {
                        show.zoom = Some(Zoom::at((p.x - cr.min.x) / cr.width(), (p.y - cr.min.y) / cr.height()));
                        show.zoom_arm = false;
                    }
                }
                if let Some(c) = show.blank {
                    ui.painter().rect_filled(cr, CornerRadius::ZERO, c);
                }
                let nr = next_rect(right, doc);
                ui.painter().text(right.min, Align2::LEFT_TOP, "Next", theme::font(13.0), Color32::from_gray(170));
                match &next_tex {
                    Some(t) => {
                        ui.painter().image(t.id(), nr, Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0)), Color32::WHITE);
                    }
                    None => {
                        ui.painter().rect_filled(nr, CornerRadius::ZERO, Color32::from_gray(40));
                        // A next slide whose preview is still on its way is not the end.
                        if next.is_none() {
                            ui.painter().text(nr.center(), Align2::CENTER_CENTER, "End of slide show", theme::font(13.0), Color32::from_gray(170));
                        }
                    }
                }
                let notes_head = Rect::from_min_size(pos2(right.min.x, nr.max.y + 12.0), vec2(right.width(), 28.0));
                let mut head = ui.new_child(egui::UiBuilder::new().max_rect(notes_head));
                head.horizontal(|ui| {
                    ui.label(egui::RichText::new("Notes").size(13.0).color(Color32::from_gray(170)));
                    if ui.button("A-").clicked() {
                        show.nudge_notes(-NOTES_STEP);
                    }
                    ui.label(egui::RichText::new(format!("{}", show.notes_px as i32)).size(13.0).color(Color32::from_gray(200)));
                    if ui.button("A+").clicked() {
                        show.nudge_notes(NOTES_STEP);
                    }
                });
                let notes_rect = Rect::from_min_max(pos2(right.min.x, notes_head.max.y + 4.0), right.max);
                let mut child = ui.new_child(egui::UiBuilder::new().max_rect(notes_rect));
                egui::ScrollArea::vertical().show(&mut child, |ui| {
                    presenter_notes(ui, notes, show.notes_px);
                });
            });
            if ui.input(|i| i.viewport().close_requested()) {
                show.presenter = false;
                // A grid left open in the closed window would hold auto-advance for the rest of the show.
                show.presenter_grid = false;
            }
        },
    );
    for a in actions {
        if !show.apply(a, doc, now) {
            *keep = false;
        }
    }
}

/// The current slide's notes in the presenter's notes pane, `px` for 12 pt text.
pub(super) fn presenter_notes(ui: &mut Ui, notes: &deckcraft_model::text::TextBody, px: f32) -> egui::Response {
    let color = Color32::from_gray(230);
    if notes.text().is_empty() {
        ui.label(egui::RichText::new("No notes.").size(px).color(color))
    } else {
        crate::notes::view(ui, notes, &crate::notes::Look { size: px, color: Some(color) })
    }
}