hikari-animation 0.3.14

Animation hooks, easing functions and transition utilities for the Hikari design system
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

//! Tween hook for tairitsu components

use std::{cell::RefCell, rc::Rc, time::Duration};

use tairitsu_hooks::use_signal;

use crate::{
    core::{AnimationEngine, AnimationOptions, Tween, TweenId},
    provider::try_use_animation_config,
};

#[derive(Clone)]
pub struct UseTween {
    engine: Rc<AnimationEngine>,
    tween_id: RefCell<Option<TweenId>>,
}

impl UseTween {
    fn new() -> Self {
        let engine = Rc::new(AnimationEngine::new());
        Self {
            engine,
            tween_id: RefCell::new(None),
        }
    }

    pub fn tween(&self, options: AnimationOptions) -> Tween {
        let id = self.engine.create_tween(options.clone());
        *self.tween_id.borrow_mut() = Some(id);
        Tween::new(id, options)
    }

    pub fn tween_with_config(&self, mut options: AnimationOptions) -> Tween {
        if let Some(ctx) = try_use_animation_config() {
            let cfg = ctx.config.read();
            if cfg.duration_scale != 1.0 {
                options.duration =
                    Duration::from_millis(cfg.scale_duration(options.duration.as_millis() as u64));
            }
            if !cfg.enabled || cfg.reduced_motion {
                options.duration = Duration::ZERO;
            }
        }
        self.tween(options)
    }

    pub fn play(&self) {
        if let Some(id) = *self.tween_id.borrow() {
            self.engine.play(id);
        }
    }

    pub fn pause(&self) {
        if let Some(id) = *self.tween_id.borrow() {
            self.engine.pause(id);
        }
    }

    pub fn restart(&self) {
        if let Some(id) = *self.tween_id.borrow() {
            self.engine.restart(id);
        }
    }

    pub fn reverse(&self) {
        if let Some(id) = *self.tween_id.borrow() {
            self.engine.reverse(id);
        }
    }

    pub fn seek(&self, time: Duration) {
        if let Some(id) = *self.tween_id.borrow() {
            self.engine.seek(id, time);
        }
    }

    pub fn kill(&self) {
        if let Some(id) = *self.tween_id.borrow() {
            self.engine.kill(id);
        }
    }
}

/// Create a persistent animation engine for the current component.
///
/// Uses `use_signal` so the engine is constructed once and shared across
/// re-renders (the engine is `Rc`-backed, so cloning the handle is cheap).
pub fn use_animation_engine() -> AnimationEngine {
    use_signal(AnimationEngine::new).inner().get()
}

/// Create a persistent tween controller for the current component.
///
/// Uses `use_signal` so the controller is constructed once and shared across
/// re-renders (the controller is `Rc`-backed, so cloning the handle is cheap).
pub fn use_tween() -> UseTween {
    use_signal(UseTween::new).inner().get()
}