use super::{
pose::{paint_order, stack_pose, StackGeometry},
region::{safe_content, with_region},
scene::{bounds, Painted, Scene},
style::Look,
surface::paint_card,
};
use crate::{Rect, Transform, Ui, Vec2};
pub(super) fn card_rect(area: Rect, direction: Vec2, reserve: f32) -> Rect {
let mut card = area;
if direction.x > 0.0 {
card.max.x -= reserve;
} else if direction.x < 0.0 {
card.min.x += reserve;
}
if direction.y > 0.0 {
card.max.y -= reserve;
} else if direction.y < 0.0 {
card.min.y += reserve;
}
card
}
pub(super) fn geometry(area: Rect, look: &Look, axis: usize) -> StackGeometry {
let direction = look.direction().vector();
let layers = look.layers();
let step = look.offset();
StackGeometry {
card: card_rect(area, direction, step * (layers - 1) as f32),
direction,
step,
layers,
scale_step: look.scale_step(),
fade_step: look.fade_step(),
exit: look.exit(axis),
exit_rotation: look.exit_rotation(),
}
}
fn layers(scene: &Scene<'_>, depth: usize) -> Vec<(i64, usize, f32)> {
let (from, to) = (scene.from, scene.target);
if (to - from).abs() <= 1 || scene.over != 0.0 {
return scene.layers(0, depth, paint_order);
}
let step = (to - from).signum();
let progress = ((scene.position - from as f32) / (to - from) as f32).clamp(0.0, 1.0);
let at = from as f32 + step as f32 * progress;
let slot = |k: i64| -> Option<i64> {
let between = if step > 0 {
k > from && k < to
} else {
k < from && k > to
};
let beyond = if step > 0 { k > to } else { k < to };
if between {
None
} else if k == to {
Some(from + step)
} else if beyond {
Some(from + step + (k - to))
} else {
Some(k)
}
};
let first = from.min(to) - 1;
let last = from.max(to) + depth as i64;
let mut layers: Vec<_> = (first..=last)
.filter_map(|k| Some((k, scene.page(k)?, slot(k)? as f32 - at)))
.collect();
if scene.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| paint_order(a.2, b.2));
layers
}
pub(super) fn paint(
ui: &mut Ui<'_>,
scene: &Scene<'_>,
build: &mut dyn FnMut(&mut Ui<'_>, usize),
) -> Painted {
let g = geometry(scene.area, scene.look, scene.axis);
let extent = g.card.size()[scene.axis] * scene.look.travel();
let mut painted = Painted {
layers: Vec::new(),
front: g.card,
};
for (k, page, d) in layers(scene, g.layers) {
let Some(pose) = stack_pose(&g, d) else {
continue;
};
let transform = scene.overscroll(k, pose.transform, extent);
let key = scene.model.key(page);
let scope = scene.id.with(("page", key));
let front = scene.interactive(k);
let card = g.card;
with_region(ui, scope, card, scene.stage, scene.enabled, |layer| {
layer.visual_gated("layer", transform, pose.opacity, Some(front), |inner| {
let current = k == scene.target;
let node = super::access::page(inner, scope, page, scene.model.count, current);
paint_card(inner, scope.with("card"), card, scene.look, d);
if pose.content > 0.01 {
let content =
safe_content(card, scene.look.content_padding(), scene.look.rounding());
let mut run = |ui: &mut Ui<'_>| {
with_region(
ui,
scope.with("content"),
content,
content,
true,
|page_ui| build(page_ui, page),
)
};
if pose.content < 0.995 {
inner.visual_gated(
"fade",
Transform::IDENTITY,
pose.content,
Some(front),
run,
);
} else {
run(inner);
}
}
inner.a11y_end(node, Some(card));
inner.allocate_space(card.size());
});
});
let rect = bounds(transform, card);
if k == scene.target {
painted.front = rect;
}
painted.layers.push((k, rect));
}
painted
}