revue 2.71.1

A Vue-style TUI framework for Rust with CSS styling
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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163

//! Animation sequences

use crate::utils::easing::Easing;
use std::time::Duration;

use super::Timer;

/// Animation step in a sequence
#[derive(Clone)]
pub struct SequenceStep {
    /// Duration of this step
    pub duration: Duration,
    /// Easing for this step
    pub easing: Easing,
    /// Target value (normalized 0.0 to 1.0)
    pub target: f64,
}

impl SequenceStep {
    /// Create a new step
    pub fn new(duration: Duration, target: f64) -> Self {
        Self {
            duration,
            easing: Easing::Linear,
            target: target.clamp(0.0, 1.0),
        }
    }

    /// Set easing
    pub fn easing(mut self, easing: Easing) -> Self {
        self.easing = easing;
        self
    }
}

/// Sequential animation with multiple steps
#[derive(Clone)]
pub struct Sequence {
    /// Animation steps
    pub steps: Vec<SequenceStep>,
    /// Current step index
    current_step: usize,
    /// Timer for current step
    timer: Timer,
    /// Current value
    value: f64,
    /// Whether sequence has started
    started: bool,
    /// Whether to repeat the sequence
    pub repeat: bool,
}

impl Default for Sequence {
    fn default() -> Self {
        Self::new()
    }
}

impl Sequence {
    /// Create a new sequence
    pub fn new() -> Self {
        Self {
            steps: Vec::new(),
            current_step: 0,
            timer: Timer::new(Duration::ZERO),
            value: 0.0,
            started: false,
            repeat: false,
        }
    }

    /// Add a step
    pub fn then(mut self, duration: Duration, target: f64) -> Self {
        self.steps.push(SequenceStep::new(duration, target));
        self
    }

    /// Add a step with easing
    pub fn then_eased(mut self, duration: Duration, target: f64, easing: Easing) -> Self {
        self.steps
            .push(SequenceStep::new(duration, target).easing(easing));
        self
    }

    /// Add a delay (step that holds current value)
    pub fn delay(self, duration: Duration) -> Self {
        let current = self.steps.last().map(|s| s.target).unwrap_or(0.0);
        self.then(duration, current)
    }

    /// Enable looping
    pub fn repeat(mut self, repeat: bool) -> Self {
        self.repeat = repeat;
        self
    }

    /// Start the sequence
    pub fn start(&mut self) {
        self.current_step = 0;
        self.value = 0.0;
        self.started = true;
        if let Some(step) = self.steps.first() {
            self.timer = Timer::new(step.duration);
            self.timer.start();
        }
    }

    /// Reset the sequence
    pub fn reset(&mut self) {
        self.current_step = 0;
        self.value = 0.0;
        self.started = false;
        self.timer.reset();
    }

    /// Check if sequence is running
    pub fn is_running(&self) -> bool {
        self.started && self.current_step < self.steps.len()
    }

    /// Check if sequence is complete
    pub fn is_complete(&self) -> bool {
        self.started && self.current_step >= self.steps.len()
    }

    /// Get current value (and advance if needed)
    pub fn value(&mut self) -> f64 {
        if !self.started || self.steps.is_empty() {
            return self.value;
        }

        // Check if current step is complete
        while self.current_step < self.steps.len() && self.timer.is_finished() {
            // Move to next step
            self.value = self.steps[self.current_step].target;
            self.current_step += 1;

            if self.current_step < self.steps.len() {
                self.timer = Timer::new(self.steps[self.current_step].duration);
                self.timer.start();
            } else if self.repeat {
                // Loop back to start
                self.current_step = 0;
                self.timer = Timer::new(self.steps[0].duration);
                self.timer.start();
            }
        }

        // Interpolate current step
        if self.current_step < self.steps.len() {
            let step = &self.steps[self.current_step];
            let prev_value = if self.current_step == 0 {
                0.0
            } else {
                self.steps[self.current_step - 1].target
            };
            let t = self.timer.progress_eased(step.easing);
            self.value = prev_value + (step.target - prev_value) * t;
        }

        self.value
    }
}