deckcraft/crates/render/src/extent.rs

//! The pasteboard: what the editor draws around the slide.
//!
//! PowerPoint's Normal view draws shapes, pictures and text that sit partly or wholly off the slide
//! on the area around it, at full strength and with their effects (master and layout graphics
//! too), so they can be seen and grabbed. Slide shows, exports and thumbnails clip to the slide.
//!
//! The editor renders only what it needs: the slide, grown to take in the drawing that spills off
//! it and is in view ([`pasteboard_region`]). A slide with nothing off it costs what it always did.

use deckcraft_geom::Xfrm;
use deckcraft_model::resolve::{self, Ctx};
use deckcraft_model::style::{Effects, Line};
use deckcraft_model::{Presentation, Shape, ShapeKind};
use kurbo::Rect;

use crate::MAX_SIDE;

/// Largest distance (points) a shape's outline or effects are taken to reach beyond its box:
/// hostile files can't blow the pasteboard up.
const MAX_SPILL: f64 = 2000.0;

/// The visible area is rounded out to tiles of this many pixels, so scrolling over a pasteboard
/// that is wider than the window re-renders only when a new tile comes into view.
pub const TILE: i64 = 256;

/// How far (points) a shape's outline and effects reach beyond its box: half the outline and its
/// arrowheads, the outer shadow (offset, blur and scale), the glow and the reflection.
pub(crate) fn spill(line: Option<&Line>, effects: Option<&Effects>, w: f64, h: f64) -> f64 {
    let fin = |v: f64| if v.is_finite() { v.abs() } else { 0.0 };
    let mut s: f64 = 0.0;
    if let Some(l) = line
        && l.fill.as_ref().is_some_and(|f| !f.is_none())
    {
        // Arrowheads reach up to a few line widths past the end point.
        s = s.max(fin(l.width.unwrap_or(0.75)) * 3.0 + 1.0);
    }
    if let Some(e) = effects {
        let big = fin(w).max(fin(h));
        if let Some(sh) = &e.outer_shadow {
            let grow = (fin(sh.sx).max(fin(sh.sy)) - 1.0).max(0.0) * big;
            s = s.max(fin(sh.dist) + fin(sh.blur) + grow);
        }
        if let Some(g) = &e.glow {
            s = s.max(fin(g.radius));
        }
        if let Some(r) = &e.reflection {
            s = s.max(fin(h) + fin(r.dist));
        }
    }
    s.min(MAX_SPILL)
}

/// Slide-space box a top-level shape draws into, its spill included.
fn shape_box(rctx: &Ctx, s: &Shape) -> Option<Rect> {
    if s.hidden {
        return None;
    }
    let x: Xfrm = resolve::xfrm(rctx, s);
    if !x.is_finite() {
        return None;
    }
    let b = match &s.kind {
        ShapeKind::Ink { strokes } => {
            let mut pts = strokes.iter().flat_map(|k| k.points.iter()).filter(|(px, py, _)| px.is_finite() && py.is_finite());
            let (px, py, _) = pts.next()?;
            let r = pts.fold(Rect::new(*px, *py, *px, *py), |r, (px, py, _)| r.union_pt(kurbo::Point::new(*px, *py)));
            let w = strokes.iter().map(|k| k.width).filter(|w| w.is_finite()).fold(0.0_f64, f64::max).min(MAX_SPILL);
            return Some(r.inflate(w, w));
        }
        _ => x.bounds(),
    };
    let (line, _) = resolve::line(rctx, s);
    let (fx, _) = resolve::effects(rctx, s);
    let d = spill(Some(&line), fx.as_ref(), x.w, x.h);
    Some(b.inflate(d, d))
}

fn union_boxes<'a>(rctx: &Ctx, shapes: impl IntoIterator<Item = &'a Shape>, into: Rect) -> Rect {
    shapes.into_iter().filter_map(|s| shape_box(rctx, s)).filter(|r| r.is_finite()).fold(into, |a, r| a.union(r))
}

fn slide_rect(pres: &Presentation) -> Rect {
    Rect::new(0.0, 0.0, pres.slide_size.width, pres.slide_size.height)
}

/// What slide `index` draws, in slide space: at least the slide, grown by every shape (and master
/// and layout graphic) that reaches off it. Estimated from the shapes' boxes, outlines and effects;
/// text spilling out of its box is found while rendering ([`crate::render_slide_drawn`]).
pub fn slide_extent(pres: &Presentation, index: usize) -> Rect {
    let page = slide_rect(pres);
    let Some(slide) = pres.slides.get(index) else { return page };
    let Some(rctx) = Ctx::for_slide(pres, slide) else { return page };
    let mut r = union_boxes(&rctx, &slide.shapes, page);
    let (show_layout, show_master) = resolve::show_master_shapes(slide, rctx.layout);
    if show_master {
        let mctx = Ctx::for_master(pres, rctx.master);
        r = union_boxes(&mctx, rctx.master.shapes.iter().filter(|s| s.ph.is_none()), r);
    }
    if show_layout && let Some(l) = rctx.layout {
        let lctx = Ctx::for_layout(pres, rctx.master, l);
        r = union_boxes(&lctx, l.shapes.iter().filter(|s| s.ph.is_none()), r);
    }
    r
}

/// What a layout (or the master, `layout: None`) draws in Slide Master view, in slide space.
pub fn layout_extent(pres: &Presentation, master: usize, layout: Option<usize>) -> Rect {
    let page = slide_rect(pres);
    let Some(m) = pres.masters.get(master) else { return page };
    match layout.and_then(|i| m.layouts.get(i)) {
        Some(l) => {
            let mut r = union_boxes(&Ctx::for_layout(pres, m, l), &l.shapes, page);
            if l.show_master_shapes {
                r = union_boxes(&Ctx::for_master(pres, m), m.shapes.iter().filter(|s| s.ph.is_none()), r);
            }
            r
        }
        None => union_boxes(&Ctx::for_master(pres, m), &m.shapes, page),
    }
}

/// A rectangle of pixels on the editor canvas, relative to the slide's top-left corner.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct Region {
    pub x: i32,
    pub y: i32,
    pub w: u32,
    pub h: u32,
}

impl Region {
    /// The slide itself, `w` × `h` pixels.
    pub fn slide(w: u32, h: u32) -> Self {
        Region { x: 0, y: 0, w: w.max(1), h: h.max(1) }
    }

    fn edges(&self) -> (i64, i64, i64, i64) {
        let (x, y) = (self.x as i64, self.y as i64);
        (x, y, x + self.w as i64, y + self.h as i64)
    }

    fn from_edges(x0: i64, y0: i64, x1: i64, y1: i64) -> Self {
        let clamp = |v: i64| v.clamp(i32::MIN as i64, i32::MAX as i64) as i32;
        let side = |a: i64, b: i64| (b - a).clamp(1, MAX_SIDE as i64) as u32;
        Region { x: clamp(x0), y: clamp(y0), w: side(x0, x1), h: side(y0, y1) }
    }

    /// Does this region cover all of `other`?
    pub fn contains(&self, other: &Region) -> bool {
        let (a, b) = (self.edges(), other.edges());
        a.0 <= b.0 && a.1 <= b.1 && a.2 >= b.2 && a.3 >= b.3
    }

    /// Is the region more than the slide (some of the pasteboard is drawn)?
    pub fn beyond(&self, slide: (u32, u32)) -> bool {
        *self != Region::slide(slide.0, slide.1)
    }

    /// Render options' `offset` that puts the slide's top-left corner where it falls in the region.
    pub fn offset(&self) -> (f64, f64) {
        (-(self.x as f64), -(self.y as f64))
    }

    /// The region's size, for render options' `size`.
    pub fn size(&self) -> (u32, u32) {
        (self.w, self.h)
    }
}

/// `r` (slide space) in pixels at `scale` pixels per point, rounded outwards; `None` when not finite.
fn to_px(r: Rect, scale: f64) -> Option<(i64, i64, i64, i64)> {
    let lim = i32::MAX as f64 / 2.0;
    let px = |v: f64| if v.is_finite() { Some(v.clamp(-lim, lim)) } else { None };
    Some((
        px((r.x0 * scale).floor())? as i64,
        px((r.y0 * scale).floor())? as i64,
        px((r.x1 * scale).ceil())? as i64,
        px((r.y1 * scale).ceil())? as i64,
    ))
}

/// The pixels the editor renders: the slide (`slide_px`, its size in pixels at `scale` pixels per
/// point) plus the part of `extent` (slide space, from [`slide_extent`] or what a render drew) that
/// falls within `visible`, the canvas's area relative to the slide's top-left corner. The visible
/// area is rounded out to whole [`TILE`]s.
pub fn pasteboard_region(slide_px: (u32, u32), scale: f64, extent: Rect, visible: Region) -> Region {
    let page = Region::slide(slide_px.0, slide_px.1);
    if !(scale.is_finite() && scale > 0.0) {
        return page;
    }
    let Some((ex0, ey0, ex1, ey1)) = to_px(extent, scale) else { return page };
    let (vx0, vy0, vx1, vy1) = visible.edges();
    let (vx0, vy0) = (vx0.div_euclid(TILE) * TILE, vy0.div_euclid(TILE) * TILE);
    let (vx1, vy1) = ((vx1 + TILE - 1).div_euclid(TILE) * TILE, (vy1 + TILE - 1).div_euclid(TILE) * TILE);
    let (cx0, cy0, cx1, cy1) = (ex0.max(vx0), ey0.max(vy0), ex1.min(vx1), ey1.min(vy1));
    if cx0 >= cx1 || cy0 >= cy1 {
        return page;
    }
    let (px0, py0, px1, py1) = page.edges();
    Region::from_edges(cx0.min(px0), cy0.min(py0), cx1.max(px1), cy1.max(py1))
}

#[cfg(test)]
mod tests {
    #![allow(clippy::unwrap_used, clippy::expect_used)]

    use super::*;
    use deckcraft_model::Shape;

    fn black() -> deckcraft_model::ColorRef {
        deckcraft_model::ColorRef::rgb(deckcraft_color::Rgba::BLACK)
    }

    fn deck_with(x: f64, y: f64, w: f64, h: f64) -> Presentation {
        let mut p = Presentation::default();
        let sl = std::sync::Arc::make_mut(&mut p.slides[0]);
        sl.shapes.push(Shape { id: deckcraft_model::ShapeId(900), xfrm: Some(Xfrm::new(x, y, w, h)), ..Default::default() });
        p
    }

    #[test]
    fn a_slide_with_nothing_off_it_extends_no_further_than_the_slide() {
        let p = deck_with(100.0, 100.0, 50.0, 50.0);
        assert_eq!(slide_extent(&p, 0), Rect::new(0.0, 0.0, p.slide_size.width, p.slide_size.height));
    }

    #[test]
    fn shapes_off_the_slide_grow_the_extent() {
        let p = deck_with(-200.0, 50.0, 100.0, 80.0);
        let e = slide_extent(&p, 0);
        assert!(e.x0 <= -200.0 && e.x0 > -220.0, "{e:?}");
        assert_eq!(e.y0, 0.0);
        assert_eq!(e.x1, p.slide_size.width);
        // Missing slides are just the page.
        assert_eq!(slide_extent(&p, 7), Rect::new(0.0, 0.0, p.slide_size.width, p.slide_size.height));
    }

    #[test]
    fn hidden_shapes_and_hostile_boxes_do_not_grow_it() {
        let mut p = deck_with(-5000.0, 0.0, 10.0, 10.0);
        std::sync::Arc::make_mut(&mut p.slides[0]).shapes.last_mut().unwrap().hidden = true;
        let page = Rect::new(0.0, 0.0, p.slide_size.width, p.slide_size.height);
        assert_eq!(slide_extent(&p, 0), page);
        let p = deck_with(f64::NAN, 0.0, 10.0, 10.0);
        assert_eq!(slide_extent(&p, 0), page);
        let p = deck_with(f64::INFINITY, 0.0, 10.0, 10.0);
        assert_eq!(slide_extent(&p, 0), page);
    }

    #[test]
    fn effects_count_towards_the_extent() {
        let mut p = deck_with(10.0, -100.0, 100.0, 50.0);
        let sh = std::sync::Arc::make_mut(&mut p.slides[0]).shapes.last_mut().unwrap();
        sh.effects = Some(Effects {
            outer_shadow: Some(deckcraft_model::style::Shadow {
                color: black(),
                blur: 10.0,
                dist: 20.0,
                dir: 270.0,
                inner: false,
                sx: 1.0,
                sy: 1.0,
                kx: 0.0,
                ky: 0.0,
                align: String::new(),
                rotate_with_shape: false,
            }),
            ..Default::default()
        });
        assert!(slide_extent(&p, 0).y0 <= -130.0);
        assert_eq!(
            spill(
                None,
                Some(&Effects { glow: Some(deckcraft_model::style::Glow { color: black(), radius: f64::MAX }), ..Default::default() }),
                1.0,
                1.0
            ),
            MAX_SPILL
        );
    }

    #[test]
    fn master_graphics_off_the_slide_count_but_not_master_placeholders() {
        let mut p = Presentation::default();
        let m = std::sync::Arc::make_mut(&mut p.masters[0]);
        m.shapes.push(Shape { id: deckcraft_model::ShapeId(901), xfrm: Some(Xfrm::new(-150.0, 10.0, 100.0, 50.0)), ..Default::default() });
        assert!(slide_extent(&p, 0).x0 <= -150.0);
        assert!(layout_extent(&p, 0, None).x0 <= -150.0);
        assert!(layout_extent(&p, 0, Some(0)).x0 <= -150.0 || !p.masters[0].layouts[0].show_master_shapes);
    }

    #[test]
    fn the_region_is_the_slide_unless_something_off_it_is_in_view() {
        let slide = (960, 540);
        let page = Region::slide(960, 540);
        let view = Region { x: -100, y: -50, w: 1160, h: 640 };
        let whole = Rect::new(0.0, 0.0, 960.0, 540.0);
        assert_eq!(pasteboard_region(slide, 1.0, whole, view), page);
        assert!(!pasteboard_region(slide, 1.0, whole, view).beyond(slide));
        // Off to the left, in view: the region reaches it.
        let r = pasteboard_region(slide, 1.0, Rect::new(-80.0, 0.0, 960.0, 540.0), view);
        assert_eq!((r.x, r.y, r.w, r.h), (-80, 0, 1040, 540));
        assert!(r.beyond(slide) && r.contains(&page));
        assert_eq!(r.offset(), (80.0, 0.0));
        // Far off and out of view (the view rounds out to tiles): only what's visible.
        let r = pasteboard_region(slide, 1.0, Rect::new(-5000.0, 0.0, 960.0, 540.0), view);
        assert_eq!(r.x, -256);
        // Wholly out of view: the slide.
        assert_eq!(pasteboard_region(slide, 1.0, Rect::new(-5000.0, 0.0, -4000.0, 540.0).union(whole), Region { x: 0, y: 0, w: 960, h: 540 }), page);
        // Scale applies; nonsense falls back to the slide.
        let r = pasteboard_region((480, 270), 0.5, Rect::new(-80.0, 0.0, 960.0, 540.0), view);
        assert_eq!(r.x, -40);
        assert_eq!(pasteboard_region(slide, f64::NAN, whole, view), page);
        assert_eq!(pasteboard_region(slide, 1.0, Rect::new(f64::NAN, 0.0, 1.0, 1.0), view), page);
        // Huge extents are capped.
        let r =
            pasteboard_region(slide, 1.0, Rect::new(-1e12, -1e12, 1e12, 1e12), Region { x: -1_000_000, y: -1_000_000, w: 2_000_000, h: 2_000_000 });
        assert!(r.w <= MAX_SIDE && r.h <= MAX_SIDE);
    }

    #[test]
    fn scrolling_within_a_tile_keeps_the_region() {
        let slide = (2000, 1125);
        let e = Rect::new(-500.0, 0.0, 960.0, 540.0);
        let a = pasteboard_region(slide, 2.0, e, Region { x: -300, y: 0, w: 1000, h: 700 });
        let b = pasteboard_region(slide, 2.0, e, Region { x: -290, y: 10, w: 1000, h: 700 });
        assert_eq!(a, b);
    }
}