GitCorner

Code

ossartcraftdeckcraft🌐
e4f86d11fe8a
//! The slide canvas: the rendered slide, zoom and fit, pointer input routed to the engine's tools,
//! and the overlays drawn on top (selection box and handles, smart guides, marquee, drawing
//! previews, the text caret and text selection).
//!
//! As in PowerPoint's Normal view, shapes, pictures and text that sit partly or wholly off the
//! slide are drawn on the area around it (the pasteboard), where they can be selected and moved;
//! the slide show, exports and thumbnails clip to the slide.

use deckcraft_engine::tools::{Hit, box_handles};
use deckcraft_engine::{Mods, PointerEvent, PointerKind, Target, ToolKind};
use deckcraft_geom::{Point, Xfrm};
use egui::{Align2, Color32, CornerRadius, Pos2, Rect, Sense, Stroke, Ui, pos2, vec2};
use serde_json::json;

use crate::SlideApp;
use crate::theme::{self, Tokens};

mod context_menu;
mod guides;
mod ime;
mod input;
mod media;
mod overlays;
mod rulers;
mod scroll;

use context_menu::context_menu;
use guides::{draw_grid, draw_guides, grid_line_step};
pub use ime::ime_area;
use ime::ime_output;
#[cfg(test)]
use input::resize_cursor;
pub(crate) use input::{page_flick, trackpad_twist};
use input::{pointer, trackpad_scroll, wheel_slide_target};
use media::{gif_buttons, media_bar, media_frames};
use overlays::overlays;
#[cfg(test)]
pub(crate) use overlays::text_marks;
#[cfg(test)]
pub(crate) use rulers::ruler_steps;
use rulers::{ruler, ruler_markers};
use scroll::{scroll_bar, visible_region};

/// Slide-to-screen mapping.
#[derive(Clone, Copy, Debug)]
pub struct Xf {
    pub origin: Pos2,
    pub scale: f32,
}

impl Xf {
    pub fn to_screen(&self, p: Point) -> Pos2 {
        pos2(self.origin.x + p.x as f32 * self.scale, self.origin.y + p.y as f32 * self.scale)
    }
    pub fn to_slide(&self, p: Pos2) -> Point {
        Point::new(((p.x - self.origin.x) / self.scale) as f64, ((p.y - self.origin.y) / self.scale) as f64)
    }
}

fn mods(ui: &Ui) -> Mods {
    ui.input(|i| Mods { shift: i.modifiers.shift, alt: i.modifiers.alt, cmd: i.modifiers.command || i.modifiers.ctrl })
}

/// The slide's rect on screen for the current zoom.
pub fn layout(app: &SlideApp, avail: Rect) -> (Rect, f32) {
    let Some(d) = app.session.active() else { return (avail, 1.0) };
    let page = deckcraft_engine::page_size(d);
    // Loaded sizes are repaired; a zero or non-finite side would still make the fit infinite.
    let side = |v: f64| if v.is_finite() { (v as f32).max(1.0) } else { 1.0 };
    let (sw, sh) = (side(page.width), side(page.height));
    let margin = 28.0;
    let fit = ((avail.width() - margin * 2.0) / sw).min((avail.height() - margin * 2.0) / sh).max(0.05);
    // A zoom from outside the editor's own controls (settings, the control protocol) is kept in range.
    let scale = app.ui.zoom.filter(|z| z.is_finite() && *z > 0.0).map_or(fit, |z| z.clamp(*crate::ZOOM_RANGE.start(), *crate::ZOOM_RANGE.end()));
    let size = vec2(sw * scale, sh * scale);
    let mut r = Rect::from_center_size(avail.center(), size);
    if size.x > avail.width() {
        r = Rect::from_min_size(pos2(avail.min.x + margin, r.min.y), size);
    }
    if size.y > avail.height() {
        r = Rect::from_min_size(pos2(r.min.x, avail.min.y + margin), size);
    }
    (r, scale)
}

/// The mouse wheel or a trackpad flick turns slides when the canvas has nothing to scroll.
fn wheel_navigation(app: &mut SlideApp, ui: &mut Ui, carry_id: egui::Id, doc_uid: u64) {
    if app.anim_preview_active() || app.session.tool.marquee.is_some() || app.session.tool.dragging() {
        return;
    }
    let (_, mut carry): (u64, f32) = ui.data_mut(|d| d.get_temp(carry_id).unwrap_or_default());
    let wheel_step = app.session.active().and_then(|d| {
        let current = d.selection.slide;
        ui.input(|i| wheel_slide_target(&i.events, current, d.doc.slides.len(), &mut carry)).map(|target| (current, target))
    });
    ui.data_mut(|d| d.insert_temp(carry_id, (doc_uid, carry)));
    if let Some((current, index)) = wheel_step {
        if index != current {
            let _ = app.run("slide.go", json!({"index": index}));
        }
    } else if let Some(next) = page_flick(ui.input(|i| trackpad_scroll(&i.events))) {
        // Point-based trackpad gestures keep their cooldown. Raw input avoids reading
        // the smoothed tail of a discrete mouse notch as another page turn.
        let gate = ui.scope_id().with("wheel_gate");
        let last: f64 = ui.data_mut(|d| d.get_temp(gate).unwrap_or(f64::NEG_INFINITY));
        let now = ui.input(|i| i.time);
        if now - last > 0.35 {
            ui.data_mut(|d| d.insert_temp(gate, now));
            let _ = app.run(if next { "slide.next" } else { "slide.previous" }, json!({}));
        }
    }
}

fn empty_deck_prompt(app: &mut SlideApp, ui: &mut Ui, avail: Rect, t: &Tokens) {
    let resp = ui.allocate_rect(avail, Sense::click());
    ui.painter().text(avail.center(), Align2::CENTER_CENTER, "Click to add first slide", theme::font(22.0), t.text_dim);
    if resp.clicked() {
        let _ = app.run("slide.new", json!({"layout": "title"}));
    }
}

fn reset_wheel_carry(ui: &Ui, carry_id: egui::Id, doc_uid: u64) {
    ui.data_mut(|d| {
        if d.get_temp::<(u64, f32)>(carry_id).is_none_or(|(uid, _)| uid != doc_uid) {
            d.insert_temp(carry_id, (doc_uid, 0.0_f32));
        }
    });
}

/// The scroll offset that keeps the slide point under `pointer` (or the canvas middle) fixed
/// when the scale changed since the last frame.
fn anchored_offset(last: Option<(Rect, f32)>, content_rect: Rect, scale: f32, pointer: Option<Pos2>, avail: Rect) -> Option<egui::Vec2> {
    let (last_rect, last_scale) = last?;
    if (scale - last_scale).abs() <= 1e-6 {
        return None;
    }
    let anchor = pointer.unwrap_or(avail.center());
    let at = (anchor - last_rect.min) / last_scale;
    Some(content_rect.min + at * scale - anchor)
}

fn slide_gifs(app: &mut SlideApp, now: f64) -> Vec<crate::media::Gif> {
    match app.session.active() {
        Some(d) if d.selection.target == Target::Slides => app.media.gifs(d.uid, &d.doc, d.selection.slide, now, &app.session.gif_paused),
        _ => vec![],
    }
}

/// Paint the editing canvas, including rulers, selection handles, overlays, and current
/// zoom/scroll state.
pub fn show(app: &mut SlideApp, ui: &mut Ui) {
    let t = Tokens::get(ui.ctx());
    let avail = ui.available_rect_before_wrap();
    app.canvas_rect = Some(avail);
    // The notes pane and the panes beside the canvas are editor chrome over it: nothing the
    // canvas paints or hit-tests (the media bar hangs 6 pt below its clip, handles stick out of a
    // shape, scroll bars) may reach into them. The parent's clip still covers the whole central
    // area, so clip this `Ui` to the rect the canvas was given (#1922).
    ui.set_clip_rect(avail.intersect(ui.clip_rect()));
    let Some(st) = app.session.active() else { return };
    // The leftover fraction of a wheel line belongs to one presentation. Drop it whenever another
    // one is drawn here, hovered or not, so switching away and back starts from zero.
    let carry_id = ui.scope_id().with("wheel_carry");
    let doc_uid = st.uid;
    reset_wheel_carry(ui, carry_id, doc_uid);
    if st.doc.slides.is_empty() && st.selection.target == Target::Slides {
        empty_deck_prompt(app, ui, avail, &t);
        return;
    }
    // Scroll when zoomed beyond the window.
    let scroll_id = ui.scope_id().with("canvas_scroll");
    let last_id = scroll_id.with("last");
    let mut offset: egui::Vec2 = ui.data_mut(|d| d.get_temp(scroll_id).unwrap_or_default());
    let last: Option<(Rect, f32)> = ui.data_mut(|d| d.get_temp(last_id));
    let resp = ui.allocate_rect(avail, Sense::click_and_drag());
    let (wheel, zoom_delta, hover) = ui.input(|i| (i.smooth_scroll_delta, i.zoom_delta(), i.pointer.hover_pos()));
    let zooming = resp.hovered() && (zoom_delta - 1.0).abs() > 1e-3;
    if zooming {
        let cur = app.ui.zoom.unwrap_or_else(|| layout(app, avail).1);
        app.ui.zoom = Some((cur * zoom_delta).clamp(0.1, 4.0));
    }
    let (content_rect, scale) = layout(app, avail);
    // A new zoom keeps the slide point under the pointer (wheel, pinch) or under the middle of the
    // canvas (Zoom In/Out, the slider) where it was, instead of growing from the corner (#106).
    if let Some(o) = anchored_offset(last, content_rect, scale, zooming.then_some(hover).flatten(), avail) {
        offset = o;
    }
    let overflow = vec2((content_rect.width() + 56.0 - avail.width()).max(0.0), (content_rect.height() + 56.0 - avail.height()).max(0.0));
    // Scroll bars on the axes that overflow (#1157). They sit over the canvas edge and take their
    // presses before the slide does; the rulers keep their strips.
    let inset = if app.ui.ruler { 16.0 } else { 0.0 };
    let mut on_bar = false;
    let mut bar_active = [false; 2];
    for axis in 0..2 {
        let Some((track, thumb, travel)) = scroll_bar(avail, inset, overflow, offset, axis) else { continue };
        let bar_id = scroll_id.with(("bar", axis));
        let bar = ui.interact(track, bar_id, Sense::click_and_drag());
        on_bar |= bar.hovered();
        bar_active[axis] = bar.hovered() || bar.dragged();
        // Where the button went down and the offset then: egui calls a press a click until it
        // moves 6 pt, so the release point can't tell the thumb from the track, and drag_delta
        // misses those first points.
        let grab_id = bar_id.with("grab");
        if bar.is_pointer_button_down_on()
            && let Some(origin) = ui.input(|i| i.pointer.primary_pressed().then(|| i.pointer.press_origin()).flatten())
        {
            ui.data_mut(|d| d.insert_temp(grab_id, (origin, offset[axis])));
        }
        let grab: Option<(Pos2, f32)> = ui.data_mut(|d| d.get_temp(grab_id));
        if let Some((origin, start)) = grab {
            if bar.dragged_by(egui::PointerButton::Primary)
                && travel > 0.0
                && let Some(p) = bar.interact_pointer_pos()
            {
                if last.is_some_and(|(_, s)| (scale - s).abs() > 1e-6) {
                    // A zoom during the drag moved the slide about its anchor: carry on from there.
                    ui.data_mut(|d| d.insert_temp(grab_id, (p, offset[axis])));
                } else {
                    offset[axis] = start + (p[axis] - origin[axis]) * overflow[axis] / travel;
                }
            } else if bar.clicked() && !thumb.contains(origin) {
                // A click on the track beside the thumb moves one window's length toward it.
                let page = avail.size()[axis] * 0.9;
                offset[axis] += if origin[axis] < thumb.min[axis] { -page } else { page };
            }
            if bar.drag_stopped() || bar.clicked() {
                ui.data_mut(|d| d.remove_temp::<(Pos2, f32)>(grab_id));
            }
        }
    }
    if (resp.hovered() || on_bar) && !zooming {
        if overflow != egui::Vec2::ZERO {
            offset -= wheel;
        } else {
            wheel_navigation(app, ui, carry_id, doc_uid);
        }
    }
    offset.x = offset.x.clamp(0.0, overflow.x);
    offset.y = offset.y.clamp(0.0, overflow.y);
    // On the physical pixel grid, so the slide texture is one texel per device pixel (#184). The
    // zoom anchor keeps the unsnapped rect, so snapping never accumulates into drift.
    let ppp = ui.ctx().pixels_per_point();
    let exact_rect = content_rect.translate(-offset);
    let slide_rect = crate::textures::device_pixel_rect(exact_rect, ppp);
    ui.data_mut(|d| {
        d.insert_temp(scroll_id, offset);
        d.insert_temp(last_id, (exact_rect, scale));
    });
    app.slide_rect = Some(slide_rect);
    app.canvas_scale = scale;
    let xf = Xf { origin: slide_rect.min, scale };
    let painter = ui.painter_at(avail);
    // Shadow + slide.
    painter.rect_filled(slide_rect.translate(vec2(0.0, 1.5)).expand(1.0), CornerRadius::same(2), t.shadow);
    let px = ((slide_rect.width() * ppp).round().max(1.0) as u32, (slide_rect.height() * ppp).round().max(1.0) as u32);
    let now = ui.input(|i| i.time);
    let gifs = slide_gifs(app, now);
    crate::media::gif_repaint(ui.ctx(), &gifs);
    let times: Vec<_> = gifs.iter().map(|g| (g.id, g.t)).collect();
    let anim = app.anim_preview_draw();
    let st = app.session.active();
    // One texture pixel in screen points, and the canvas in pixels from the slide's corner.
    let pixel = vec2(slide_rect.width() / px.0 as f32, slide_rect.height() / px.1 as f32);
    let visible = visible_region(avail, slide_rect, pixel);
    let typing_into = st.and_then(|d| d.selection.text.as_ref()).filter(|t| !t.notes).map(|t| t.shape);
    let tex = match st.map(|d| (d.selection.target, d)) {
        Some((Target::Slides, d)) => {
            let idx = d.selection.slide;
            let doc = d.doc.clone();
            let frame = anim.as_ref().map(|(tl, t)| (tl, *t));
            app.textures.slide(ui.ctx(), &doc, idx, px, visible, true, crate::media::gif_key(&gifs), app.ui.grayscale, &times, typing_into, frame)
        }
        Some((Target::Master { master }, d)) => master_tex(ui.ctx(), &d.doc, master, None, px, visible, typing_into),
        Some((Target::Layout { master, layout }, d)) => master_tex(ui.ctx(), &d.doc, master, Some(layout), px, visible, typing_into),
        Some((t @ (Target::Handout | Target::NotesMaster), d)) => {
            deckcraft_engine::master_page(&d.doc, t).and_then(|p| master_tex(ui.ctx(), &p, 0, None, px, visible, typing_into))
        }
        None => None,
    };
    if let Some((tex, region)) = tex {
        let at = Rect::from_min_size(
            slide_rect.min + vec2(region.x as f32 * pixel.x, region.y as f32 * pixel.y),
            vec2(region.w as f32 * pixel.x, region.h as f32 * pixel.y),
        );
        app.canvas_region = Some(at);
        painter.image(tex.id(), at, Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0)), Color32::WHITE);
    }
    app.perf.render_ms = app.textures.last_render_ms;
    media_frames(app, &painter, xf);
    // Notes Master view: the current slide inside the slide-image placeholder, as in PowerPoint.
    let notes_preview = app.session.active().filter(|d| d.selection.target == Target::NotesMaster).and_then(|d| {
        let frame = d.doc.notes_master.as_ref()?.shapes.iter().find(|s| s.ph_type() == Some(deckcraft_model::PhType::SlideImage))?.xfrm?;
        Some((d.doc.clone(), d.selection.slide.min(d.doc.slides.len().saturating_sub(1)), frame))
    });
    if let Some((doc, idx, f)) = notes_preview
        && f.w > 1.0
        && f.h > 1.0
    {
        let aspect = doc.slide_size.width / doc.slide_size.height.max(1.0);
        let (w, h) = if f.w / f.h > aspect { (f.h * aspect, f.h) } else { (f.w, f.w / aspect) };
        let (x, y) = (f.x + (f.w - w) / 2.0, f.y + (f.h - h) / 2.0);
        let r = Rect::from_min_size(
            pos2(slide_rect.min.x + x as f32 * scale, slide_rect.min.y + y as f32 * scale),
            vec2(w as f32 * scale, h as f32 * scale),
        );
        let mut budget = 2;
        if let Some(tex) = app.textures.thumb(ui.ctx(), &doc, idx, (r.width() * ppp).round().max(1.0) as u32, app.ui.grayscale, &mut budget) {
            painter.image(tex.id(), r, Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0)), Color32::WHITE);
        }
    }
    if let Some(d) = app.session.active().filter(|d| d.selection.target == Target::Handout) {
        // Where the slides go on a printed handout, as in PowerPoint's preview.
        let (n, s) = (d.doc.notes_size, d.doc.slide_size);
        let aspect = s.width / s.height.max(1.0);
        for b in deckcraft_engine::pdf::handout_boxes(app.ui.handout_per_page, (n.width, n.height), aspect) {
            let r = Rect::from_min_max(
                pos2(slide_rect.min.x + b.x0 as f32 * scale, slide_rect.min.y + b.y0 as f32 * scale),
                pos2(slide_rect.min.x + b.x1 as f32 * scale, slide_rect.min.y + b.y1 as f32 * scale),
            );
            let dash = egui::Shape::dashed_line(
                &[r.left_top(), r.right_top(), r.right_bottom(), r.left_bottom(), r.left_top()],
                Stroke::new(1.0, Color32::from_gray(140)),
                4.0,
                3.0,
            );
            painter.extend(dash);
        }
    }
    if app.ui.gridlines
        && let Some(step) = grid_line_step(app.session.prefs.grid_spacing, scale)
    {
        draw_grid(&painter, slide_rect, step);
    }
    app.session.tool.guides_visible = app.ui.guides;
    if app.ui.guides {
        draw_guides(app, &painter, xf, slide_rect, &t);
    }
    if app.ui.ruler {
        ruler(&painter, avail, slide_rect, scale, app.session.prefs.units, &t);
        ruler_markers(app, ui, &painter, avail, xf, &t);
    }
    pointer(app, ui, &resp, xf);
    if !app.anim_preview_active() {
        overlays(app, ui, &painter, xf, &t);
        ime_output(app, ui, xf);
        media_bar(app, ui, xf);
        gif_buttons(app, ui, xf, &gifs);
        if resp.secondary_clicked()
            && let Some(p) = resp.interact_pointer_pos()
        {
            let word = app.session.active().and_then(|st| app.squiggles.word_at(st, xf.to_slide(p), 4.0 / xf.scale.max(0.01) as f64));
            app.squiggles.menu_word = word;
        }
        context_menu(app, &resp);
    }
    for (axis, active) in bar_active.into_iter().enumerate() {
        if let Some((track, thumb, _)) = scroll_bar(avail, inset, overflow, offset, axis) {
            painter.rect_filled(track, CornerRadius::ZERO, t.chrome);
            let fill = if active { t.text_dim } else { t.text_faint };
            painter.rect_filled(thumb.shrink(2.0), CornerRadius::same(3), fill);
        }
    }
}

/// Screen rect of a slide-space box (rotation ignored).
fn screen_rect(xf: Xf, x: &Xfrm) -> Rect {
    Rect::from_min_max(xf.to_screen(Point::new(x.x, x.y)), xf.to_screen(Point::new(x.x + x.w, x.y + x.h)))
}

fn master_tex(
    ctx: &egui::Context,
    doc: &deckcraft_model::Presentation,
    master: usize,
    layout: Option<usize>,
    px: (u32, u32),
    visible: deckcraft_render::Region,
    editing_text: Option<deckcraft_model::ShapeId>,
) -> Option<(egui::TextureHandle, deckcraft_render::Region)> {
    let scale = px.0 as f64 / doc.slide_size.width.max(1.0);
    let region = crate::textures::fit_texture(
        deckcraft_render::pasteboard_region(px, scale, deckcraft_render::layout_extent(doc, master, layout), visible),
        visible,
        crate::textures::max_side(ctx),
    );
    let img = deckcraft_render::render_layout(
        doc,
        master,
        layout,
        &deckcraft_render::RenderOpts { scale, edit: true, editing_text, offset: region.offset(), size: Some(region.size()), ..Default::default() },
    );
    Some((crate::textures::upload_editor(ctx, "master-canvas", crate::textures::to_color_image(&img, false)), region))
}

pub(super) mod preview;
pub mod squiggles;
#[cfg(test)]
mod tests;

#[cfg(test)]
mod ruler_tests;

#[cfg(test)]
mod guides_tests;

#[cfg(test)]
#[path = "media_bar_tests.rs"]
mod media_bar_tests;