use super::{state::Model, style::Look};
use crate::{ImageSource, Rect, Transform, Ui, Vec2};
pub(super) type PageFn<'a> = dyn FnMut(&mut Ui<'_>, usize) + 'a;
pub(super) enum Content<'a> {
Pages(&'a mut PageFn<'a>),
Photos {
source: &'a mut dyn FnMut(usize) -> ImageSource,
overlay: Option<&'a mut PageFn<'a>>,
},
}
pub(super) struct Scene<'a> {
pub(super) id: crate::Id,
pub(super) stage: Rect,
pub(super) area: Rect,
pub(super) position: f32,
pub(super) over: f32,
pub(super) target: i64,
pub(super) from: i64,
pub(super) model: &'a Model<'a>,
pub(super) wrap: bool,
pub(super) axis: usize,
pub(super) look: &'a Look,
pub(super) dragging: bool,
pub(super) enabled: bool,
}
impl Scene<'_> {
pub(super) fn page(&self, k: i64) -> Option<usize> {
let n = self.model.count as i64;
if self.wrap {
Some(k.rem_euclid(n) as usize)
} else {
(0..n).contains(&k).then_some(k as usize)
}
}
pub(super) fn layers(
&self,
before: usize,
after: usize,
order: fn(f32, f32) -> std::cmp::Ordering,
) -> Vec<(i64, usize, f32)> {
let first = self.position.floor() as i64 - before as i64;
let last = self.position.floor() as i64 + 1 + after as i64;
let mut layers: Vec<_> = (first..=last)
.filter_map(|k| Some((k, self.page(k)?, k as f32 - self.position)))
.collect();
if self.wrap {
layers.sort_by(|a, b| a.2.abs().total_cmp(&b.2.abs()));
let mut seen = std::collections::HashSet::new();
layers.retain(|layer| seen.insert(layer.1));
}
layers.sort_by(|a, b| order(a.2, b.2));
layers
}
pub(super) fn interactive(&self, k: i64) -> bool {
self.enabled
&& !self.dragging
&& k == self.target
&& (k as f32 - self.position).abs() < 0.15
}
pub(super) fn overscroll(&self, k: i64, transform: Transform, extent: f32) -> Transform {
let edge = if self.over < 0.0 {
0
} else {
self.model.count as i64 - 1
};
if self.over == 0.0 || k != edge {
return transform;
}
let mut shifted = transform;
shifted.translation[self.axis] += -self.over * extent;
shifted
}
}
pub(super) struct Painted {
pub(super) layers: Vec<(i64, Rect)>,
pub(super) front: Rect,
}
pub(super) fn bounds(transform: Transform, base: Rect) -> Rect {
let rect = transform.rect(base);
if rect.min.is_finite() && rect.max.is_finite() {
rect
} else {
Rect::from_min_size(base.center(), Vec2::ZERO)
}
}