aura-anim-core 0.2.2

Typed animation runtime and composable animation sources.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

//! Animated visibility lifecycle management.

use crate::{
    runtime::{Motion, MotionRuntime},
    timing::Timing,
    traits::{Animatable, Animation},
};

/// Coordinates mounting and visibility around enter and exit animations.
///
/// # Examples
///
/// ```
/// use aura_anim_core::{MotionRuntime, Presence, timing::Timing};
/// use std::time::Duration;
///
/// let mut runtime = MotionRuntime::new();
/// let mut presence = Presence::new(&mut runtime, 0.0_f32, 1.0, Timing::new(100.0));
///
/// presence.show(&mut runtime);
/// assert!(presence.is_mounted());
/// runtime.tick(Duration::from_millis(100));
/// assert_eq!(*presence.value(&runtime), 1.0);
///
/// presence.hide(&mut runtime);
/// runtime.tick(Duration::from_millis(100));
/// presence.sync(&runtime);
/// assert!(!presence.is_mounted());
/// ```
pub struct Presence<T: Animatable> {
    motion: Motion<T>,
    visible: T,
    hidden: T,
    mounted: bool,
    shown: bool,
}

impl<T: Animatable> Presence<T> {
    /// Creates a hidden, unmounted presence controller.
    #[must_use]
    pub fn new(runtime: &mut MotionRuntime, hidden: T, visible: T, timing: Timing) -> Self {
        Self {
            motion: runtime.motion_with(hidden.clone(), timing),
            visible,
            hidden,
            mounted: false,
            shown: false,
        }
    }

    /// Returns the runtime motion controlled by this presence value.
    pub fn motion(&self) -> Motion<T> {
        self.motion
    }

    /// Returns the current animated value.
    #[must_use]
    pub fn value<'a>(&self, runtime: &'a MotionRuntime) -> &'a T {
        self.motion.value_ref(runtime)
    }

    /// Returns whether the associated content should be mounted.
    #[must_use]
    pub const fn is_mounted(&self) -> bool {
        self.mounted
    }

    /// Returns whether the presence target is visible.
    #[must_use]
    pub const fn is_visible(&self) -> bool {
        self.shown
    }

    /// Mounts the content and transitions toward the visible value.
    pub fn show(&mut self, runtime: &mut MotionRuntime) {
        self.mounted = true;
        self.shown = true;
        self.motion.transition_to(self.visible.clone(), runtime);
    }

    /// Transitions toward the hidden value.
    pub fn hide(&mut self, runtime: &mut MotionRuntime) {
        self.shown = false;
        self.motion.transition_to(self.hidden.clone(), runtime);
    }

    /// Mounts the content and plays a custom enter animation.
    pub fn show_with(&mut self, animation: impl Animation<T>, runtime: &mut MotionRuntime) {
        self.mounted = true;
        self.shown = true;
        self.motion.play(animation, runtime);
    }

    /// Plays a custom exit animation.
    pub fn hide_with(&mut self, animation: impl Animation<T>, runtime: &mut MotionRuntime) {
        self.shown = false;
        self.motion.play(animation, runtime);
    }

    /// Unmounts hidden content after its animation completes.
    pub fn sync(&mut self, runtime: &MotionRuntime) {
        if !self.shown && self.motion.is_completed(runtime) {
            self.mounted = false;
        }
    }
}