e4f86d11fe8a
ui.rs
use super::keys::{handle_keys, keyboard};
use super::media::{
Pick, Under, gif_hit, media_bar_target, media_hit, on_screen, pointer_on_media_bar, run_media_cues, shapes_under_pointer, show_media,
};
use super::presenter::{PresenterTimer, format_elapsed, presenter_window};
use super::render::{below_playing_video, fit, part_textures, quad_mesh, render_frame, render_overlay, render_threads, start_prefetch};
use super::zoom::{
Zoom, grid_indices, norm_on_slide, paint_grid, see_all_hit, slide_aspect, slide_box, slide_to_screen, toggle_blank, tool_bar_rect, unit_uv,
wheel_zoom_lines,
};
use super::{
Align2, BackKey, Click, Color32, CornerRadius, Key, Layer, LinkJump, Pos2, Rect, RenderOpts, Sense, ShapeId, ShapeState, Show, ShowAction,
ShowState, SlideApp, Source, Stroke, TextureHandle, Ui, json, pos2, show_fills_screen, state_for, theme, vec2, viewport_visible,
};
use deckcraft_anim::{StepStamp, TriggerPlay};
use deckcraft_model::Presentation;
/// Per-frame values the show's draw steps share.
#[derive(Clone, Copy)]
struct Fr<'a> {
ctx: &'a egui::Context,
doc: &'a std::sync::Arc<Presentation>,
doc_uid: u64,
now: f64,
full: Rect,
srect: Rect,
clicked: bool,
secondary: bool,
pointer: Option<Pos2>,
}
/// Whether the show goes on, and the steps input asked for.
struct Out {
keep: bool,
actions: Vec<ShowAction>,
}
/// What is drawn on the current slide this frame.
struct Sl {
idx: usize,
step: usize,
animating: bool,
t: f64,
plays: Vec<TriggerPlay>,
stamps: Vec<StepStamp>,
media: Vec<(ShapeId, deckcraft_geom::Xfrm, deckcraft_model::MediaClip)>,
hidden: Vec<ShapeId>,
times: Vec<(ShapeId, f64)>,
gifs: Vec<crate::media::Gif>,
key: Key,
back_key: BackKey,
size: (u32, u32),
}
/// Draw and advance the active show, handling hidden frames, timing, input, transitions, and
/// presenter/reading presentation.
pub fn ui(app: &mut SlideApp, ui: &mut Ui) {
let ctx = ui.ctx().clone();
let Some((doc_uid, doc)) = app.session.active().map(|d| (d.uid, d.doc.clone())) else {
app.show = None;
if let Some(host) = app.services.presenter.as_mut() {
host.close();
}
return;
};
let now = ctx.input(|i| i.time);
let Some(mut show) = app.show.take() else { return };
if !viewport_visible(&ctx) {
// A forced hidden paint (for example a pending screenshot) draws the current frame;
// the show clocks are advanced by logic, not by this draw, so it must not advance them a
// second time. Keep drawing the last frame rather than returning a blank.
paint_hidden(ui, &doc, &show);
app.show = Some(show);
return;
}
show.observe_visible_frame(now, web_time::Instant::now());
begin_show(&ctx, &mut show, &doc, now, app.services.presenter.is_some());
let mut out = Out { keep: keyboard(&ctx, &mut show, &doc, now, false), actions: vec![] };
if show.presenter
&& !show.reading
&& let Some(host) = app.services.presenter.as_mut()
{
if show.remote_opened && show.presenter_grid && !host.is_open() {
// A grid left open in the closed popup would hold auto-advance for the rest of the show.
show.presenter_grid = false;
}
if !show.remote_opened {
show.remote_opened = true;
if let Err(message) = host.open() {
app.status = Some((message, crate::now_ms()));
}
}
for command in host.commands() {
match command {
crate::presenter::Command::End => out.keep = false,
crate::presenter::Command::Zoom { x, y } if x.is_finite() && y.is_finite() && show.zoom_arm => {
show.zoom = Some(Zoom::at(x.clamp(0.0, 1.0), y.clamp(0.0, 1.0)));
show.zoom_arm = false;
}
crate::presenter::Command::Key { name, command, shift, alt, ctrl } => {
if let Some(key) = egui::Key::from_name(&name) {
let modifiers = egui::Modifiers { command, shift, alt, ctrl, mac_cmd: command && !ctrl };
// The popup is the Presenter View: G opens All slides there, not on the audience screen (#1866).
out.keep &= handle_keys(&mut show, &doc, now, vec![(key, modifiers)], true).0;
}
}
crate::presenter::Command::Goto { slide } if show.presenter_grid && slide < doc.slides.len() => {
show.presenter_grid = false;
show.blank = None;
show.zoom = None;
show.zoom_arm = false;
let action = show.state.goto(&doc, slide);
out.keep &= show.apply(action, &doc, now);
}
_ => {}
}
}
}
let (clicked, secondary, moved) = ctx.input(|i| (i.pointer.primary_clicked(), i.pointer.secondary_clicked(), i.pointer.delta().length() > 0.0));
if moved {
show.last_move = now;
}
let full = ui.max_rect();
let avail = if show.reading { Rect::from_min_max(full.min, pos2(full.max.x, full.max.y - 34.0)) } else { full };
let srect = fit(avail, &doc);
let pointer = ctx.input(|i| i.pointer.interact_pos());
show.expire_goto(now);
// The clock of the triggered animations runs before anything reacts to the pointer.
show.tick_triggers(&doc, now);
let f = Fr { ctx: &ctx, doc: &doc, doc_uid, now, full, srect, clicked, secondary, pointer };
let pointing = handle_clicks(app, ui, &mut show, &f, &mut out);
handle_wheel_and_swipe(&mut show, &f, &mut out);
advance(app, &mut show, &f, &mut out);
let painter = ui.painter_at(full);
painter.rect_filled(full, CornerRadius::ZERO, Color32::BLACK);
draw_slide(app, ui, &mut show, &f, &painter);
draw_pen_and_hints(ui, &mut show, &f, &painter, pointing);
draw_bars(ui, &mut show, &f, &painter, &mut out);
draw_extras(&mut show, &f, &painter, &mut out);
if out.keep
&& show.presenter
&& !show.reading
&& let Some(host) = app.services.presenter.as_mut()
{
if now - show.remote_sent >= 0.2 {
let next = show.state.peek_next(&doc);
if let Some(n) = next
&& show.remote_next.as_ref().is_none_or(|(old, _)| *old != n)
{
let 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), 640);
let image = deckcraft_render::render_slide(
&doc,
n,
&RenderOpts { scale: size.0 as f64 / doc.slide_size.width.max(1.0), size: Some(size), ..Default::default() },
);
show.remote_next = crate::presenter::Preview::from_image(&crate::textures::to_color_image(&image, false)).map(|image| (n, image));
}
if !show.presenter_grid {
show.remote_grid.clear();
} else if show.remote_grid.len() < grid_indices(doc.slides.len()).len() {
// A few thumbnails per update keep the audience window responsive on the web.
for i in grid_indices(doc.slides.len()).into_iter().skip(show.remote_grid.len()).take(4) {
// At most 96 px on the long side: 48 thumbnails stay well under the popup's message limit.
let (w, h) = (doc.slide_size.width.max(1.0), doc.slide_size.height.max(1.0));
let scale = REMOTE_THUMB / w.max(h);
let size = (((w * scale).round() as u32).max(1), ((h * scale).round() as u32).max(1));
let image = deckcraft_render::render_slide(&doc, i, &RenderOpts { scale, size: Some(size), ..Default::default() });
let preview = crate::presenter::Preview::from_image(&crate::textures::to_color_image(&image, false));
show.remote_grid.push(preview.unwrap_or(crate::presenter::Preview { width: 1, height: 1, rgba: vec![0; 4] }));
}
}
host.update(crate::presenter::Snapshot {
slide: show.state.slide,
total: doc.slides.len(),
ended: show.ended,
notes: doc.slides.get(show.state.slide).map(|s| s.notes_text()).unwrap_or_default(),
elapsed: format_elapsed(show.timer.elapsed(now)),
paused: show.timer.paused(),
notes_px: show.notes_px,
blank: show.blank_name().map(str::to_owned),
grid: show.presenter_grid,
zoom_armed: show.zoom_arm,
// The grid replaces both previews in the popup; leaving them out keeps one message small.
current: show.remote_preview.clone().filter(|_| !show.presenter_grid),
next: show.remote_next.as_ref().filter(|(n, _)| Some(*n) == next && !show.presenter_grid).map(|(_, image)| image.clone()),
slides: show.presenter_grid.then(|| show.remote_grid.clone()),
});
show.remote_sent = now;
}
ctx.request_repaint_after(std::time::Duration::from_millis(200));
}
finish(app, show, &f, out.keep);
}
/// Longest side of an All slides thumbnail sent to the web presenter window (#1866).
const REMOTE_THUMB: f64 = 96.0;
fn paint_hidden(ui: &Ui, doc: &Presentation, show: &Show) {
if show.started {
let full = ui.max_rect();
let avail = if show.reading { Rect::from_min_max(full.min, pos2(full.max.x, full.max.y - 34.0)) } else { full };
let srect = fit(avail, doc);
let painter = ui.painter_at(full);
painter.rect_filled(full, CornerRadius::ZERO, Color32::BLACK);
if let Some((_, tex)) = &show.tex {
painter.image(tex.id(), srect, unit_uv(), Color32::WHITE);
}
}
}
fn begin_show(ctx: &egui::Context, show: &mut Show, doc: &Presentation, now: f64, remote: bool) {
if !show.started {
show.started = true;
show.slide_start = now;
show.step_start = now;
// The first step is settled at the show's own start: every clock origin is a real frame
// time, so hiding and resuming shifts all of them by the same interval.
show.step_end = now;
show.show_start = now;
show.timer = PresenterTimer::start(now);
show.last_move = now;
if show_fills_screen(show.reading, &doc.show.show_type) && !(show.presenter && remote) {
ctx.send_viewport_cmd(egui::ViewportCommand::Fullscreen(true));
}
show.after_enter(doc, now);
}
}
fn handle_clicks(app: &mut SlideApp, ui: &mut Ui, show: &mut Show, f: &Fr, out: &mut Out) -> bool {
let Fr { ctx, doc, doc_uid, now, full, srect, clicked, secondary, pointer } = *f;
let on_slide = !show.grid
&& !show.pen
&& !show.laser
&& !show.ended
&& show.blank.is_none()
&& show.zoom.is_none()
&& !show.zoom_arm
&& !show.reading_bar_hit(ctx)
&& !pointer_on_media_bar(ctx, ui, doc, show, now);
// The button is drawn only while the pointer is awake; a hidden button takes no click.
let gif_click =
if clicked && on_slide && doc.show.show_media_controls && show.pointer_awake(now) { gif_hit(ctx, ui, show, doc_uid, doc, app) } else { None };
let media_click = if clicked && on_slide && gif_click.is_none() { media_hit(ctx, ui, show, doc) } else { None };
let under = if on_slide && gif_click.is_none() && media_click.is_none() { shapes_under_pointer(ctx, ui, show, doc, now) } else { None };
let pointing = under.as_ref().is_some_and(|u| u.pick.is_some());
if let Some(id) = gif_click {
let _ = app.run("media.gifPlay", json!({"id": id}));
} else if let Some((id, clip)) = media_click {
app.media.toggle(doc_uid, doc, id, &clip, crate::media::Owner::Show);
} else if clicked && let Some(Pick::Text(l)) = under.as_ref().and_then(|u| u.pick.clone()) {
let last = show.last_viewed;
match show.state.follow_link(doc, &l, last) {
LinkJump::Show(a) => out.actions.push(a),
LinkJump::Open(url) => ctx.open_url(egui::OpenUrl::new_tab(url)),
LinkJump::Exit => out.keep = false,
LinkJump::None => {}
}
} else if show.grid && clicked {
let aspect = slide_aspect(doc);
if let Some(p) = pointer
&& let Some(n) = see_all_hit(full, grid_indices(doc.slides.len()).len(), aspect, p)
&& let Some(&i) = grid_indices(doc.slides.len()).get(n)
{
show.grid = false;
show.blank = None;
show.zoom = None;
show.zoom_arm = false;
out.actions.push(show.state.goto(doc, i));
}
} else if clicked && show.zoom_arm && !show.reading_bar_hit(ctx) {
if let Some(p) = pointer
&& let Some((nx, ny)) = norm_on_slide(srect, unit_uv(), p)
{
show.zoom = Some(Zoom::at(nx, ny));
show.zoom_arm = false;
}
} else if clicked && show.zoom.is_some() && !show.pen && !show.reading_bar_hit(ctx) {
show.dismiss_zoom();
} else if clicked && !show.pen && !show.reading_bar_hit(ctx) && !pointer_on_media_bar(ctx, ui, doc, show, now) {
if show.ended {
out.keep = false;
} else if show.blank.is_some() {
show.blank = None;
} else {
// A shape with an action or a triggered animation, or the background.
let none = Under::default();
match show.click_slide(doc, under.as_ref().unwrap_or(&none), now) {
Click::Show(a) => out.actions.push(a),
Click::Open(url) => ctx.open_url(egui::OpenUrl::new_tab(url)),
Click::Exit => out.keep = false,
Click::Animated | Click::None => {}
}
}
}
if secondary && !show.ended && !show.grid && show.zoom.is_none() && !show.zoom_arm {
out.actions.push(show.state.prev(doc));
}
pointing
}
fn handle_wheel_and_swipe(show: &mut Show, f: &Fr, out: &mut Out) {
let Fr { ctx, doc, now, srect, pointer, .. } = *f;
// Ctrl+wheel (Cmd+wheel on a Mac) zooms around the pointer, as in PowerPoint (#1286). egui
// keeps it out of `smooth_scroll_delta`, so it does not also turn the page below.
let line_points = ctx.options(|o| o.input_options.line_scroll_speed);
if !show.grid
&& !show.ended
&& show.blank.is_none()
&& let Some(p) = pointer
&& let Some(lines) = ctx.input(|i| wheel_zoom_lines(&i.events, line_points))
{
show.wheel_zoom(srect, p, lines);
}
// A trackpad swipe (and the mouse wheel) turns the page. The pen is drawing, so a flick
// there stays on the slide. Pinch zoom is not a show gesture.
if !show.pen
&& let Some(next) = crate::canvas::page_flick(ctx.input(|i| i.smooth_scroll_delta))
&& now - show.last_swipe > 0.35
{
show.last_swipe = now;
if next {
if show.ended {
out.keep = false;
} else {
out.actions.push(show.state.next(doc));
}
} else {
show.ended = false;
out.actions.push(show.state.prev(doc));
}
}
}
fn advance(app: &mut SlideApp, show: &mut Show, f: &Fr, out: &mut Out) {
let Fr { doc, doc_uid, now, .. } = *f;
// Apply input first: a step started by this click must restart the clock before it is read.
for a in out.actions.drain(..) {
if !show.apply(a, doc, now) {
out.keep = false;
}
}
// Step clock, shared with the hidden logic tick.
if !show.queue_clock_actions(doc, now, &mut out.actions) {
out.keep = false;
}
for a in std::mem::take(&mut out.actions) {
if !show.apply(a, doc, now) {
out.keep = false;
}
}
if show.state.playing {
let step = show.state.step;
show.cue_media(doc, step, now - show.step_start);
}
show_media(app, show, doc_uid, doc);
run_media_cues(app, show, doc_uid, doc);
}
fn begin_slide(app: &mut SlideApp, show: &Show, f: &Fr, size: (u32, u32)) -> Sl {
let Fr { ctx, doc, doc_uid, now, .. } = *f;
let idx = show.state.slide;
let step = show.state.step;
// A main step or a triggered animation is running: the picture changes every frame.
let animating = show.state.playing || show.state.trigger_playing();
let t = if show.state.playing { now - show.step_start } else { 0.0 };
let plays = show.state.trigger_plays();
let stamps = show.state.trigger_stamps();
let media = crate::media::slide_media(doc, idx);
let hidden: Vec<ShapeId> = media
.iter()
.filter(|(id, _, clip)| clip.hide_while_not_playing && !app.media.status(*id).is_some_and(|s| s.state != deckcraft_media::PlayState::Ended))
.map(|m| m.0)
.collect();
let gifs = app.media.gifs(doc_uid, doc, idx, now, &app.session.gif_paused);
let times: Vec<_> = gifs.iter().map(|g| (g.id, g.t)).collect();
crate::media::gif_repaint(ctx, &gifs);
let gif = crate::media::gif_key(&gifs);
let done: Vec<(ShapeId, usize)> = plays.iter().map(|p| (p.trigger, p.step)).collect();
let key = Key { slide: idx, step, size, doc: std::sync::Arc::as_ptr(doc) as usize, hidden: hidden.clone(), plays: done, gif };
let back_key = BackKey { slide: idx, size, doc: key.doc };
Sl { idx, step, animating, t, plays, stamps, media, hidden, times, gifs, key, back_key, size }
}
fn frame_texture(show: &mut Show, f: &Fr, sl: &Sl) -> Option<TextureHandle> {
let Fr { ctx, doc, .. } = *f;
let Sl { idx, step, animating, size, .. } = *sl;
if !animating && show.tex.as_ref().is_some_and(|(k, _)| *k == sl.key) {
show.tex.as_ref().map(|(_, t)| t.clone())
} else {
// The frame rendered ahead of time, when it is this one (waiting for it beats starting over).
let ready = match show.prefetch.take() {
Some(p) if p.key == sl.key && !animating => p.rx.recv().ok(),
_ => None,
};
let ci = match ready {
Some(ci) => ci,
None => {
let tl = show.timeline(doc).clone();
// Animating: the backdrop doesn't change, only the shapes over it are drawn.
let back = animating.then(|| show.backdrop(doc, sl.back_key));
render_frame(doc, idx, tl, step, sl.t, size, sl.hidden.clone(), &sl.times, render_threads(), &sl.plays, &sl.stamps, back.as_deref())
}
};
if show.remote_opened && show.presenter {
show.remote_preview = crate::presenter::Preview::from_image(&ci);
}
let tex = match show.tex.take() {
Some((_, mut h)) => {
crate::textures::replace(ctx, &mut h, ci);
h
}
None => crate::textures::upload(ctx, "show", ci),
};
show.tex = Some((sl.key.clone(), tex.clone()));
Some(tex)
}
}
fn prefetch_next(app: &mut SlideApp, show: &mut Show, f: &Fr, sl: &Sl) {
let Fr { doc, doc_uid, now, .. } = *f;
let Sl { animating, size, .. } = *sl;
// While this slide rests, render the next one's first frame (not one with GIFs, whose
// frame depends on when it is entered).
// A slide with animations gets its backdrop ready while it rests, so they start smoothly.
if !animating && !show.timeline(doc).is_empty() {
show.prefetch_backdrop(doc, sl.back_key);
}
if !animating && show.trans.is_none() && !show.preview_only {
let next = show.state.peek_next(doc);
let wanted = next.filter(|n| app.media.gifs(doc_uid, doc, *n, now, &app.session.gif_paused).is_empty());
if let Some(n) = wanted
&& show.prefetch.as_ref().is_none_or(|p| p.key.slide != n || p.key.size != size || p.key.doc != std::sync::Arc::as_ptr(doc) as usize)
{
show.prefetch = start_prefetch(doc, n, size);
}
}
}
fn draw_transition(show: &mut Show, f: &Fr, sl: &Sl, painter: &egui::Painter, tex: &Option<TextureHandle>) -> bool {
let Fr { ctx, doc, now, srect, .. } = *f;
let Sl { idx, size, .. } = *sl;
let mut drew = false;
let morphing = show.trans.as_ref().is_some_and(|tr| tr.kind == "morph" && tr.from.is_some() && now - tr.start < tr.dur);
let tl = if morphing { Some(show.timeline(doc).clone()) } else { None };
let morph = match (&show.trans, tl) {
(Some(tr), Some(tl)) => {
let p = ((now - tr.start) / tr.dur.max(0.01)).clamp(0.0, 1.0);
let hidden_b = |id: ShapeId| {
let st = state_for(&tl, id, 0, 0.0, &[], &[]);
!st.visible || st.opacity <= 0.0 || sl.hidden.contains(&id)
};
tr.from
.and_then(|i| doc.slides.get(i).map(|a| (i, a)))
.zip(doc.slides.get(idx))
.map(|((i, a), b)| (i, deckcraft_anim::morph_frame(doc, a, b, p, &hidden_b)))
}
_ => None,
};
if let (Some((from, m)), Some(tr)) = (morph, show.trans.as_mut()) {
let f = |id: ShapeId| ShapeState { opacity: m.opacity_of(id), ..Default::default() };
let threads = if cfg!(target_arch = "wasm32") { 0 } else { std::thread::available_parallelism().map(|n| n.get().min(8) as u16).unwrap_or(0) };
let opts =
RenderOpts { scale: size.0 as f64 / doc.slide_size.width.max(1.0), size: Some(size), state: Some(&f), threads, ..Default::default() };
let text: Vec<deckcraft_render::TextMorph> =
m.text.iter().map(|x| deckcraft_render::TextMorph { old: x.old, new: x.new, from: x.from, to: x.to, chars: x.chars, t: m.mix }).collect();
let paths: Vec<deckcraft_render::PathMorph> = m
.paths
.iter()
.map(|x| deckcraft_render::PathMorph { id: x.id, from: x.from.clone(), from_box: x.from_box, to_box: x.to_box, t: m.mix })
.collect();
let img = deckcraft_render::render_blend(doc, (from, idx), m.mix, &m.shapes, &text, &paths, &opts);
let ci = crate::textures::to_color_image(&img, false);
let frame = match tr.morph.take() {
Some(mut h) => {
crate::textures::replace(ctx, &mut h, ci);
h
}
None => crate::textures::upload(ctx, "morph", ci),
};
painter.image(frame.id(), srect, Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0)), Color32::WHITE);
tr.morph = Some(frame);
drew = true;
ctx.request_repaint();
} else if let (Some(tr), Some(new)) = (show.trans.as_mut(), &tex) {
let p = ((now - tr.start) / tr.dur.max(0.01)).clamp(0.0, 1.0);
if p < 1.0 {
// Slides split into background and content are rendered once per transition;
// every frame only composites cached textures.
if tr.parts.is_none() && deckcraft_anim::uses_slide_parts(&tr.kind, &tr.option) {
tr.parts = Some(part_textures(ctx, doc, tr.from, idx, size));
}
if tr.old.is_none()
&& let Some(prev) = tr.from
&& !deckcraft_anim::uses_slide_parts(&tr.kind, &tr.option)
{
let threads =
if cfg!(target_arch = "wasm32") { 0 } else { std::thread::available_parallelism().map(|n| n.get().min(8) as u16).unwrap_or(0) };
let timeline = ShowState::timeline(doc, prev);
let step = timeline.steps();
let ci = render_frame(doc, prev, timeline, step, 0.0, size, vec![], &[], threads, &[], &[], None);
tr.old = Some(crate::textures::upload(ctx, "trans-old", ci));
}
let aspect = doc.slide_size.width / doc.slide_size.height.max(1.0);
let part = |k: usize| tr.parts.as_ref().and_then(|p| p.get(k).cloned().flatten());
let parts = [part(0), part(1), part(2), part(3)];
for l in transition_layers(&tr.kind, &tr.option, tr.reverse, p, aspect) {
let old_or_black = |t: Option<&TextureHandle>| match t {
Some(o) => quad_mesh(Some(o.id()), srect, &l, Color32::WHITE),
None => quad_mesh(None, srect, &l, Color32::BLACK),
};
let mesh = match l.source {
Source::Old => old_or_black(tr.old.as_ref()),
Source::New => quad_mesh(Some(new.id()), srect, &l, Color32::WHITE),
Source::Black => quad_mesh(None, srect, &l, Color32::BLACK),
Source::White => quad_mesh(None, srect, &l, Color32::WHITE),
Source::OldBack => old_or_black(parts[0].as_ref().or(tr.old.as_ref())),
Source::NewBack => quad_mesh(Some(parts[2].as_ref().unwrap_or(new).id()), srect, &l, Color32::WHITE),
Source::OldContent => match &parts[1] {
Some(t) => quad_mesh(Some(t.id()), srect, &l, Color32::WHITE),
None => continue,
},
Source::NewContent => match &parts[3] {
Some(t) => quad_mesh(Some(t.id()), srect, &l, Color32::WHITE),
None => continue,
},
};
painter.add(egui::Shape::mesh(mesh));
}
drew = true;
ctx.request_repaint();
}
}
drew
}
/// The layers of a transition at progress `p`. A reversed transition (going back, #1531) runs
/// from its end to its start, so the slide being left plays the part of the new slide and the
/// slide coming back the part of the old one.
pub(super) fn transition_layers(kind: &str, option: &str, reverse: bool, p: f64, aspect: f64) -> Vec<Layer> {
if !reverse {
return deckcraft_anim::transition_frame(kind, option, p, aspect);
}
let mut layers = deckcraft_anim::transition_frame(kind, option, 1.0 - p, aspect);
for l in &mut layers {
l.source = swap_old_new(l.source);
}
layers
}
fn swap_old_new(s: Source) -> Source {
match s {
Source::Old => Source::New,
Source::New => Source::Old,
Source::OldBack => Source::NewBack,
Source::NewBack => Source::OldBack,
Source::OldContent => Source::NewContent,
Source::NewContent => Source::OldContent,
Source::Black | Source::White => s,
}
}
fn draw_videos(app: &mut SlideApp, show: &mut Show, f: &Fr, sl: &Sl, painter: &egui::Painter, tex: &Option<TextureHandle>) -> (Vec<ShapeId>, bool) {
let Fr { doc, full, srect, .. } = *f;
if let Some(tex) = &tex {
painter.image(tex.id(), srect, show.zoom_uv(), Color32::WHITE);
}
// Playing video: the current frame in its box, or full screen.
let (sw, sh) = (doc.slide_size.width as f32, doc.slide_size.height as f32);
let uv = show.zoom_uv();
let mut framed: Vec<ShapeId> = vec![];
let mut full_screen = false;
for (id, x, clip) in &sl.media {
if !clip.video || sl.hidden.contains(id) {
continue;
}
let r = if clip.full_screen && app.media.is_playing(*id) {
full_screen = true;
full
} else {
slide_box(srect, uv, (sw, sh), (x.x as f32, x.y as f32, x.w as f32, x.h as f32))
};
if crate::media::paint_frame(painter, &app.media, *id, r, clip.crop) {
framed.push(*id);
}
}
(framed, full_screen)
}
fn draw_overlay(show: &mut Show, f: &Fr, sl: &Sl, painter: &egui::Painter, framed: &[ShapeId], full_screen: bool) {
let Fr { ctx, doc, srect, .. } = *f;
let Sl { idx, step, animating, size, .. } = *sl;
let uv = show.zoom_uv();
// Shapes stacked above a playing video show over it, as in PowerPoint (#1005); a video
// playing full screen covers the whole slide.
let skip = if full_screen { vec![] } else { below_playing_video(doc, idx, framed) };
if skip.is_empty() {
show.overlay = None;
} else {
let fresh = !animating && show.overlay.as_ref().is_some_and(|(k, s, _)| *k == sl.key && *s == skip);
if !fresh {
let tl = show.timeline(doc).clone();
let ci = render_overlay(doc, idx, tl, step, sl.t, size, sl.hidden.clone(), &skip, &sl.times, render_threads(), &sl.plays, &sl.stamps);
let handle = match show.overlay.take() {
Some((_, _, mut h)) => {
crate::textures::replace(ctx, &mut h, ci);
h
}
None => crate::textures::upload(ctx, "show-overlay", ci),
};
show.overlay = Some((sl.key.clone(), skip, handle));
}
if let Some((_, _, h)) = &show.overlay {
painter.image(h.id(), srect, uv, Color32::WHITE);
}
}
}
fn draw_media_controls(app: &mut SlideApp, ui: &mut Ui, show: &mut Show, f: &Fr, sl: &Sl, painter: &egui::Painter) {
let Fr { ctx, doc, doc_uid, now, srect, .. } = *f;
let sw = doc.slide_size.width as f32;
// Play/pause on the animated GIF under the pointer, and the audio/video bar.
// Slide Show โธ Show Media Controls hides both (the click still sl.plays a clip).
// Not while zoomed: the controls sit where the whole slide would be.
if doc.show.show_media_controls && !show.zoom_arm && show.zoom.is_none() {
let k = srect.width() / sw.max(1.0);
if let Some(p) = ctx.input(|i| i.pointer.hover_pos()).filter(|_| !show.pen && !show.laser && show.pointer_awake(now)) {
for g in &sl.gifs {
let r = on_screen(srect, k, &g.rect);
if r.contains(p) {
let b = crate::media::gif_button_rect(r);
crate::media::paint_gif_button(painter, b, g.paused, b.contains(p));
}
}
}
if let Some((id, clip, bar)) = media_bar_target(ctx, doc, show, srect).filter(|_| show.pointer_awake(now)) {
ctx.request_repaint_after(std::time::Duration::from_millis(500));
let action = {
let status = app.media.status(id);
crate::media::control_bar(ui, bar, status.as_ref(), &clip)
};
let pos = app.media.status(id).map(|s| s.position).unwrap_or(0.0);
match action {
Some(crate::media::BarAction::Toggle) => app.media.toggle(doc_uid, doc, id, &clip, crate::media::Owner::Show),
Some(crate::media::BarAction::Seek(t)) => app.media.seek(doc_uid, doc, id, &clip, t, crate::media::Owner::Show),
Some(crate::media::BarAction::Nudge(dt)) => app.media.seek(doc_uid, doc, id, &clip, (pos + dt).max(0.0), crate::media::Owner::Show),
None => {}
}
}
}
}
fn draw_slide(app: &mut SlideApp, ui: &mut Ui, show: &mut Show, f: &Fr, painter: &egui::Painter) {
let Fr { ctx, full, srect, .. } = *f;
let ppp = ctx.pixels_per_point();
// A huge screen or DPI mustn't ask for a picture the GPU can't hold: render at most its limit
// (drawn stretched to the screen).
let size = crate::textures::fit_size(
((srect.width() * ppp).round().clamp(1.0, u32::MAX as f32) as u32, (srect.height() * ppp).round().clamp(1.0, u32::MAX as f32) as u32),
crate::textures::max_side(ctx),
);
if show.ended {
painter.text(
pos2(full.center().x, full.min.y + 40.0),
Align2::CENTER_CENTER,
"End of slide show, click to exit.",
theme::font(18.0),
Color32::from_gray(200),
);
} else {
let sl = begin_slide(app, show, f, size);
let tex = frame_texture(show, f, &sl);
prefetch_next(app, show, f, &sl);
if !draw_transition(show, f, &sl, painter, &tex) {
show.trans = None;
let (framed, full_screen) = draw_videos(app, show, f, &sl, painter, &tex);
draw_overlay(show, f, &sl, painter, &framed, full_screen);
draw_media_controls(app, ui, show, f, &sl, painter);
}
if sl.animating {
ctx.request_repaint();
}
}
}
fn draw_pen_and_hints(ui: &mut Ui, show: &mut Show, f: &Fr, painter: &egui::Painter, pointing: bool) {
let Fr { ctx, doc, now, full, srect, .. } = *f;
if let Some(c) = show.blank {
painter.rect_filled(full, CornerRadius::ZERO, c);
}
if !show.goto.is_empty() {
let label = format!("Go to slide {}", show.goto);
let w = (28.0 + label.len() as f32 * 10.0).clamp(160.0, full.width() - 32.0);
let r = Rect::from_min_size(pos2(full.min.x + 16.0, full.max.y - 96.0), vec2(w, 36.0));
painter.rect_filled(r, CornerRadius::same(6), Color32::from_black_alpha(190));
painter.text(r.center(), Align2::CENTER_CENTER, label, theme::font(18.0), Color32::WHITE);
ctx.request_repaint_after(std::time::Duration::from_millis(200));
}
// Pen.
let resp = ui.interact(full, ui.scope_id().with("show_pen"), if show.pen { Sense::drag() } else { Sense::hover() });
if show.pen {
resp.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, true, "Pen"));
}
if show.pen {
if resp.drag_started() {
show.strokes.push(vec![]);
}
let uv = show.zoom_uv();
if resp.dragged()
&& let Some(p) = resp.interact_pointer_pos()
&& let Some((nx, ny)) = norm_on_slide(srect, uv, p)
&& let Some(s) = show.strokes.last_mut()
{
s.push(pos2(nx, ny));
}
ctx.set_cursor_icon(egui::CursorIcon::Crosshair);
} else if show.laser {
ctx.set_cursor_icon(egui::CursorIcon::None);
} else if show.zoom_arm || show.grid {
ctx.set_cursor_icon(egui::CursorIcon::Crosshair);
} else if show.hides_idle_cursor(now) {
// Idle first: a still pointer hides also over a clickable shape, such as a playing clip.
ctx.set_cursor_icon(egui::CursorIcon::None);
ctx.request_repaint_after(std::time::Duration::from_millis(500));
} else if pointing {
ctx.set_cursor_icon(egui::CursorIcon::PointingHand);
ctx.request_repaint_after(std::time::Duration::from_millis(500));
}
let pen_col = theme::to_color32(doc.show.pen_color);
let uv = show.zoom_uv();
for s in &show.strokes {
let pts: Vec<Pos2> = s.iter().map(|q| slide_to_screen(srect, uv, q.x, q.y)).collect();
painter.add(egui::Shape::line(pts, Stroke::new(3.0, pen_col)));
}
if show.laser
&& !show.ended
&& let Some(p) = ctx.input(|i| i.pointer.hover_pos())
{
let c = theme::to_color32(doc.show.laser_color);
painter.circle_filled(p, 16.0, Color32::from_rgba_unmultiplied(c.r(), c.g(), c.b(), 70));
painter.circle_filled(p, 5.5, c);
}
if show.zoom_arm && !show.grid {
painter.text(
pos2(full.center().x, full.min.y + 36.0),
Align2::CENTER_CENTER,
"Click the slide to zoom in. Esc cancels.",
theme::font(16.0),
Color32::WHITE,
);
}
}
fn draw_bars(ui: &mut Ui, show: &mut Show, f: &Fr, painter: &egui::Painter, out: &mut Out) {
let Fr { ctx, doc, now, full, .. } = *f;
// Reading view bar / on-screen controls.
if show.reading {
let bar = Rect::from_min_max(pos2(full.min.x, full.max.y - 34.0), full.max);
painter.rect_filled(bar, CornerRadius::ZERO, Color32::from_gray(32));
painter.text(
pos2(bar.min.x + 14.0, bar.center().y),
Align2::LEFT_CENTER,
format!("Slide {} of {}", show.state.slide + 1, doc.slides.len()),
theme::font(12.0),
Color32::from_gray(200),
);
let mut child = ui.new_child(
egui::UiBuilder::new()
.max_rect(Rect::from_min_max(pos2(bar.max.x - 260.0, bar.min.y), bar.max))
.layout(egui::Layout::right_to_left(egui::Align::Center)),
);
if child.button("Close").clicked() {
out.keep = false;
}
if child.button("โถ").clicked() {
let a = show.state.next(doc);
if !show.apply(a, doc, now) {
out.keep = false;
}
}
if child.button("โ").clicked() {
let a = show.state.prev(doc);
show.apply(a, doc, now);
}
} else if !show.grid && (show.pointer_awake(now) || show.zoom_arm) {
let bar = tool_bar_rect(full);
painter.rect_filled(bar, CornerRadius::same(17), Color32::from_black_alpha(140));
let mut child =
ui.new_child(egui::UiBuilder::new().max_rect(bar.shrink2(vec2(10.0, 4.0))).layout(egui::Layout::left_to_right(egui::Align::Center)));
let b = |ui: &mut Ui, s: &str| ui.add(egui::Button::new(egui::RichText::new(s).color(Color32::WHITE).size(15.0)).frame(false));
if b(&mut child, "โ").clicked() {
let a = show.state.prev(doc);
show.apply(a, doc, now);
}
if b(&mut child, "โถ").clicked() {
let a = show.state.next(doc);
if !show.apply(a, doc, now) {
out.keep = false;
}
}
if b(&mut child, if show.pen { "โ on" } else { "โ" }).clicked() {
show.set_pen(!show.pen);
}
if b(&mut child, if show.laser { "โ on" } else { "โ" }).clicked() {
show.set_laser(!show.laser);
}
if b(&mut child, "Black").clicked() {
toggle_blank(show, Color32::BLACK);
}
if b(&mut child, "White").clicked() {
toggle_blank(show, Color32::WHITE);
}
if b(&mut child, "All").clicked() {
show.grid = !show.grid;
}
if b(&mut child, show.zoom_label()).clicked() {
show.zoom_key();
}
if b(&mut child, "End").clicked() {
out.keep = false;
}
ctx.request_repaint_after(std::time::Duration::from_millis(300));
}
}
fn draw_extras(show: &mut Show, f: &Fr, painter: &egui::Painter, out: &mut Out) {
let Fr { ctx, doc, now, full, .. } = *f;
if show.grid && !show.ended {
paint_grid(painter, ctx, show, doc, full);
}
if show.rehearse {
let t = now - show.slide_start;
let total = now - show.show_start;
let r = Rect::from_min_size(pos2(full.min.x + 12.0, full.min.y + 12.0), vec2(220.0, 30.0));
painter.rect_filled(r, CornerRadius::same(6), Color32::from_black_alpha(160));
painter.text(
r.center(),
Align2::CENTER_CENTER,
format!("Slide {:02}:{:04.1} Total {:02}:{:02}", (t / 60.0) as u32, t % 60.0, (total / 60.0) as u32, (total % 60.0) as u32),
theme::font(13.0),
Color32::WHITE,
);
ctx.request_repaint_after(std::time::Duration::from_millis(100));
}
// Presenter view in a second window.
if out.keep && show.presenter && !show.reading && !show.remote_opened {
presenter_window(ctx, show, doc, now, &mut out.keep);
}
}
fn finish(app: &mut SlideApp, mut show: Show, f: &Fr, keep: bool) {
let Fr { ctx, now, .. } = *f;
if keep {
app.show = Some(show);
} else {
if let Some(host) = app.services.presenter.as_mut() {
host.close();
}
app.media.stop_owned(crate::media::Owner::Show);
if !show.reading {
ctx.send_viewport_cmd(egui::ViewportCommand::Fullscreen(false));
}
if show.rehearse {
if let Some((_, tl)) = &show.timeline {
let _ = tl;
}
show.timings.push((show.state.slide, now - show.slide_start));
for (i, secs) in show.timings.clone() {
let _ = app.run("transition.timing", json!({"index": i, "after": (secs * 1000.0).round() as u64}));
}
app.set_status("Slide timings recorded.");
}
let last = show.state.slide;
let _ = app.run("slide.go", json!({"index": last}));
}
}
No file is open. Choose one in the tree, or press Ctrl+O (โO on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.