twm 0.13.0

A customizable workspace manager for tmux
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

use crossterm::event::{self, Event as CrosstermEvent, KeyEvent};
use std::{
    sync::mpsc,
    thread,
    time::{Duration, Instant},
};

use anyhow::Result;

#[derive(Debug, Clone, Copy)]
pub enum Event {
    Tick,
    Key(KeyEvent),
}

pub struct EventHandler {
    receiver: mpsc::Receiver<Event>,
}

impl EventHandler {
    pub fn new(tick_rate: Duration) -> Self {
        let (sender, receiver) = mpsc::channel();
        let _ = {
            let sender = sender.clone();

            thread::spawn(move || {
                let mut last_tick = Instant::now();
                loop {
                    let timeout = tick_rate
                        .checked_sub(last_tick.elapsed())
                        .unwrap_or(tick_rate);
                    if event::poll(timeout).unwrap_or_default() {
                        let _ = match event::read() {
                            //.expect("Unable to read event") {
                            Ok(CrosstermEvent::Key(e)) => {
                                if e.kind == event::KeyEventKind::Press {
                                    sender.send(Event::Key(e))
                                } else {
                                    Ok(())
                                }
                            }
                            _ => Ok(()),
                        };
                    }

                    if last_tick.elapsed() >= tick_rate {
                        let _ = sender.send(Event::Tick);
                        last_tick = Instant::now();
                    }
                }
            })
        };
        Self { receiver }
    }

    pub fn next(&self) -> Result<Event> {
        self.receiver.recv().map_err(Into::into)
    }
}