git ssb

1
extern crate ncurses;
2
3
use ncurses::{WchResult};
4
use std::char;
5
use std::sync::mpsc::{channel, Sender, Receiver};
6
use std::thread::{sleep, spawn};
7
use std::time::{Duration};
8
9
mod clock;
10
mod control;
11
12
// https://unicode.org/charts/PDF/U0000.pdf
13
static CHAR_SPACE: u32 = 0x0020;
14
static CHAR_RETURN: u32 = 0x000D;
15
static CHAR_NEWLINE: u32 = 0x000A;
16
17
fn main () {
18
    let control = control::Control::new();
19
20
    let clock_signature = clock::ClockSignature::new(60_f64);
21
    let mut clock = clock::Clock::new(clock_signature, &control);
22
23
    clock.start();
24
25
    let terminal_interface = TerminalInterface::new(&control);
26
    
27
    terminal_interface.start();
28
29
    for control_message in control.rx {
30
        match control_message {
31
            control::ControlMessage::Time(time) => {
32
                terminal_interface.tx.send(InterfaceMessage::Time(time));
33
            }
34
        }
35
    }
36
}
37
38
#[derive(Debug)]
39
pub struct TerminalInterface {
40
    control_tx: Sender<control::ControlMessage>,
41
    tx: Sender<InterfaceMessage>,
42
    rx: Receiver<InterfaceMessage>
43
}
44
45
impl TerminalInterface {
46
    pub fn new (control: &control::Control) -> Self {
47
        let (tx, rx) = channel();
48
        
49
        Self {
50
            control_tx: control.tx.clone(),
51
            tx,
52
            rx
53
        }
54
    }
55
56
    pub fn start (&self) {
57
        let control_tx = self.control_tx.clone();
58
59
        spawn(move|| {
60
            /* Setup ncurses. */
61
            ncurses::initscr();
62
63
            let locale_conf = ncurses::LcCategory::all;
64
            ncurses::setlocale(locale_conf, "en_US.UTF-8");
65
66
            /* Enable mouse events. */
67
            ncurses::mousemask(ncurses::ALL_MOUSE_EVENTS as ncurses::mmask_t, None);
68
69
            /* Allow for extended keyboard (like F1). */
70
            ncurses::keypad(ncurses::stdscr(), true);
71
            ncurses::noecho();
72
73
            loop {
74
                let ch = ncurses::wget_wch(ncurses::stdscr());
75
76
                match ch {
77
                    Some(WchResult::KeyCode(ncurses::KEY_MOUSE)) => {
78
                        control_tx.send(control::ControlMessage::TapTempo).unwrap();
79
                    }
80
81
                    // https://github.com/jeaye/ncurses-rs/blob/master/src/constants.rs
82
                    Some(WchResult::KeyCode(_)) => {}
83
84
                    // Some(WchResult::KeyCode(KEY_ENTER)) => beat(),
85
                    Some(WchResult::Char(ch)) => {
86
                        if (ch == CHAR_SPACE || ch == CHAR_NEWLINE) {
87
                            control_tx.send(control::ControlMessage::TapTempo).unwrap();
88
                        }
89
                    }
90
91
                    None => {}
92
                }
93
94
                ncurses::refresh();
95
            }
96
97
            ncurses::endwin();
98
        });
99
100
        spawn(move|| {
101
            for interface_message in self.rx {
102
                match interface_message {
103
                    InterfaceMessage::Time(time) => {
104
                        print_time(time);
105
                    }
106
                }
107
108
            }
109
        });
110
    }
111
}
112
113
pub fn print_time (time: clock::ClockTime) {
114
    ncurses::clear();
115
    ncurses::mv(0, 0);
116
    ncurses::printw("nanos: ");
117
    ncurses::printw(format!("{}\n", time.nanos).as_ref());
118
    ncurses::printw("\nticks: ");
119
    ncurses::printw(format!("{}\n", time.ticks).as_ref());
120
}
121
122
#[derive(Clone, Copy, Debug, Hash)]
123
pub enum InterfaceMessage {
124
    Time(clock::ClockTime)
125
}
126