use crate::component::ComponentId;
use crate::geometry::PointF;
use crate::prop::PropEnum;
use crate::ui::Ui;
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum Transition {
#[default]
None,
Fade,
SlideLeft,
SlideRight,
SlideUp,
SlideDown,
}
impl Transition {
pub const ALL: [Transition; 6] =
[Transition::None, Transition::Fade, Transition::SlideLeft, Transition::SlideRight, Transition::SlideUp, Transition::SlideDown];
pub fn reversed(self) -> Self {
match self {
Transition::SlideLeft => Transition::SlideRight,
Transition::SlideRight => Transition::SlideLeft,
Transition::SlideUp => Transition::SlideDown,
Transition::SlideDown => Transition::SlideUp,
other => other,
}
}
}
impl PropEnum for Transition {
const NAMES: &'static [&'static str] = &["none", "fade", "slide_left", "slide_right", "slide_up", "slide_down"];
fn from_index(index: usize) -> Option<Self> {
Transition::ALL.get(index).copied()
}
fn index(self) -> usize {
self as usize
}
}
pub const TRANSITION_MS: f32 = 250.0;
#[derive(Clone, Copy, Debug)]
pub(crate) struct Running {
from: Option<ComponentId>,
to: Option<ComponentId>,
kind: Transition,
start: f64,
duration: f64,
from_opacity: f32,
to_opacity: f32,
close_from: bool,
}
impl Ui {
pub fn transition(&mut self, from: Option<ComponentId>, to: Option<ComponentId>, kind: Transition, duration_ms: f32) {
self.start_transition(from, to, kind, duration_ms, false);
}
pub(crate) fn start_transition(&mut self, from: Option<ComponentId>, to: Option<ComponentId>, kind: Transition, duration_ms: f32, close_from: bool) {
let pending: Vec<Running> = self
.transitions
.iter()
.filter(|r| [r.from, r.to].iter().flatten().any(|c| Some(*c) == from || Some(*c) == to))
.copied()
.collect();
for r in pending {
self.finish_transition(r);
}
self.transitions.retain(|r| ![r.from, r.to].iter().flatten().any(|c| Some(*c) == from || Some(*c) == to));
if let Some(t) = to {
if let Some(cb) = self.control_mut(t) {
cb.set_visible(true);
}
}
let opacity = |ui: &Ui, id: Option<ComponentId>| id.and_then(|c| ui.control(c)).map_or(1.0, |cb| cb.opacity());
let running = Running {
from,
to,
kind,
start: self.time,
duration: (duration_ms.max(0.0) / 1000.0) as f64,
from_opacity: opacity(self, from),
to_opacity: opacity(self, to),
close_from,
};
if kind == Transition::None || running.duration <= 0.0 {
self.finish_transition(running);
return;
}
self.apply_transition(&running, 0.0);
self.transitions.push(running);
self.invalidate();
self.request_repaint();
}
pub(crate) fn transitions_entering(&self, id: ComponentId) -> bool {
self.transitions.iter().any(|r| r.to == Some(id))
}
pub fn in_transition(&self, id: ComponentId) -> bool {
self.transitions.iter().any(|r| r.from == Some(id) || r.to == Some(id))
}
pub(crate) fn tick_transitions(&mut self) {
if self.transitions.is_empty() {
return;
}
let now = self.time;
let running = std::mem::take(&mut self.transitions);
let mut keep = Vec::new();
for r in running {
let t = ((now - r.start) / r.duration).clamp(0.0, 1.0) as f32;
if t >= 1.0 {
self.finish_transition(r);
} else {
self.apply_transition(&r, crate::anim::Easing::OutCubic.apply(t));
keep.push(r);
}
}
keep.append(&mut self.transitions);
self.transitions = keep;
self.request_repaint();
}
fn slide_vector(&self, kind: Transition, id: ComponentId) -> PointF {
let size = self.control(id).map(|cb| cb.bounds().size()).unwrap_or_default();
match kind {
Transition::SlideLeft => PointF::new(size.width, 0.0),
Transition::SlideRight => PointF::new(-size.width, 0.0),
Transition::SlideUp => PointF::new(0.0, size.height),
Transition::SlideDown => PointF::new(0.0, -size.height),
_ => PointF::ZERO,
}
}
fn apply_transition(&mut self, r: &Running, p: f32) {
match r.kind {
Transition::Fade => {
if let Some(cb) = r.to.and_then(|c| self.control_mut(c)) {
cb.set_opacity(r.to_opacity * p);
}
if let Some(cb) = r.from.and_then(|c| self.control_mut(c)) {
cb.set_opacity(r.from_opacity * (1.0 - p));
}
}
Transition::None => {}
kind => {
if let Some(to) = r.to {
let v = self.slide_vector(kind, to);
if let Some(cb) = self.control_mut(to) {
cb.set_translate(PointF::new(v.x * (1.0 - p), v.y * (1.0 - p)));
}
}
if let Some(from) = r.from {
let v = self.slide_vector(kind, from);
if let Some(cb) = self.control_mut(from) {
cb.set_translate(PointF::new(-v.x * p, -v.y * p));
}
}
}
}
}
fn finish_transition(&mut self, r: Running) {
if let Some(cb) = r.to.and_then(|c| self.control_mut(c)) {
cb.set_translate(PointF::ZERO);
cb.set_opacity(r.to_opacity);
cb.set_visible(true);
}
if let Some(from) = r.from {
if let Some(cb) = self.control_mut(from) {
cb.set_translate(PointF::ZERO);
cb.set_opacity(r.from_opacity);
}
if r.close_from {
self.closing_now = Some(from);
self.close(from);
self.closing_now = None;
} else if let Some(cb) = self.control_mut(from) {
cb.set_visible(false);
}
}
self.invalidate();
self.request_repaint();
}
}