appcui 0.4.8

A feature-rich and cross-platform TUI/CUI framework for Rust, enabling modern terminal-based applications on Windows, Linux, and macOS. Includes built-in UI components like buttons, menus, list views, tree views, checkboxes, and more. Perfect for building fast and interactive CLI tools and text-based interfaces.
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

use crate::system::{SystemEvent, TimerPausedEvent, TimerStartEvent, TimerTickUpdateEvent};

use super::Command;
use std::sync::mpsc::Sender;
use std::sync::{Arc, Condvar, Mutex};

#[cfg(not(target_arch = "wasm32"))]
use std::time::Duration;

#[cfg(target_arch = "wasm32")]
use web_time::Duration;

#[derive(Copy, Clone)]
pub(crate) struct ThreadLogic {
    tick: u64,
    interval: u32,
    id: u8,
    paused: bool,
}

impl ThreadLogic {
    pub(super) fn new(id: u8, interval: u32) -> Self {
        Self {
            tick: 0,
            interval,
            id,
            paused: true,
        }
    }
    pub(crate) fn run(&mut self, sync: Arc<(Mutex<Command>, Condvar)>, sender: Sender<SystemEvent>) {
        let (mutex, cvar) = &*sync;
        let mut guard = mutex.lock().unwrap();
        if self.update_status(*guard, &sender) {
            return; // exit the thread
        }
        let mut time_to_wait = self.wait_time();
        loop {
            let (new_guard, timeout_status) = cvar.wait_timeout(guard, time_to_wait).unwrap();
            guard = new_guard;
            if timeout_status.timed_out() {
                self.tick += 1;
                if sender
                    .send(SystemEvent::TimerTickUpdate(TimerTickUpdateEvent {
                        id: self.id,
                        tick: self.tick.into(),
                    }))
                    .is_err()
                {
                    self.update_status(Command::Stop, &sender);
                    return;
                }
            } else {
                if self.update_status(*guard, &sender) {
                    return;
                }
                time_to_wait = self.wait_time();
            }
        }
    }
    /// true means thread should finish, false keep alive
    #[inline(always)]
    fn update_status(&mut self, command: Command, sender: &Sender<SystemEvent>) -> bool {
        match command {
            Command::None => false,
            Command::Start(interval) => {
                self.interval = interval;
                self.tick = 0;
                self.paused = false;
                if sender
                    .send(SystemEvent::TimerStart(TimerStartEvent { id: self.id, tick: 0.into() }))
                    .is_err()
                {
                    self.paused = true;
                    return true;
                }
                false
            }
            Command::Stop => {
                self.paused = true;
                true
            }
            Command::Resume => {
                if sender
                    .send(SystemEvent::TimerStart(TimerStartEvent {
                        id: self.id,
                        tick: self.tick.into(),
                    }))
                    .is_err()
                {
                    self.paused = true;
                    true
                } else {
                    self.paused = false;
                    false
                }
            }
            Command::SetInterval(interval) => {
                self.interval = interval;
                false
            }
            Command::Pause => {
                self.paused = true;
                sender
                    .send(SystemEvent::TimerPaused(TimerPausedEvent {
                        id: self.id,
                        tick: self.tick.into(),
                    }))
                    .is_err()
            }
        }
    }
    #[inline(always)]
    fn wait_time(&self) -> Duration {
        if self.paused {
            Duration::MAX
        } else {
            Duration::from_millis(self.interval as u64)
        }
    }
}