chiro 0.1.3

A curses-style terminal view that runs inside a pixel buffer (Rewrite of chiropterm)
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

use crate::{Event, input::{Input, TypeEvent, TypeKey}};

pub type Chiro<T> = Result<T, ChiroError>;

pub enum ChiroError { Closed }

pub trait Eventable {
    fn next_event(&mut self) -> Event;  // returns the next event. ends with an endless stream of Exits
    fn input(&self) -> &Input;

    fn is_open(&self) -> bool;
    fn next_tick(&mut self) -> Chiro<u64> {
        loop {
            match self.next_event() {
                Event::Exit => { return Err(ChiroError::Closed) }
                Event::Tick(t) => { return Ok(t) }
                Event::Mouse(_) => {},
                Event::Type(_) => {},
                Event::Press(_) => {},
            }
        }
    }

    fn next_keystroke(&mut self) -> Chiro<TypeKey> {
        loop {
            match self.next_event() {
                Event::Exit => { return Err(ChiroError::Closed) },
                Event::Tick(_) => {},
                Event::Mouse(_) => {},
                Event::Type(TypeEvent::Down(evt)) => { return Ok(evt) }
                Event::Type(_) => {},
                Event::Press(_) => {},
            }
        }
    }

    fn next_char(&mut self) -> Chiro<char> {
        loop {
            match self.next_event() {
                Event::Exit => { return Err(ChiroError::Closed) },
                Event::Tick(_) => {},
                Event::Mouse(_) => {},
                Event::Type(TypeEvent::Type(c)) => return Ok(c),
                Event::Type(_) => {},
                Event::Press(_) => {},
            }
        }
    }
}

// extension methods to Eventable trait which assume the program will terminate before a ChiroError::Closed is returned
pub trait SimpleIO {
    fn tick(&mut self) -> u64;
    fn keystroke(&mut self) -> TypeKey;
    fn char(&mut self) -> char;
}


impl <E: Eventable> SimpleIO for E {
    fn tick(&mut self) -> u64 {
        match self.next_tick() {
            Ok(n) => n,
            Err(ChiroError::Closed) => panic!("tick should have occurred or program should have terminated")
        }
    }

    fn keystroke(&mut self) -> TypeKey {
        match self.next_keystroke() {
            Ok(n) => n,
            Err(ChiroError::Closed) => panic!("keystroke should have occurred or program should have terminated")
        }
    }

    fn char(&mut self) -> char {
        match self.next_char() {
            Ok(n) => n,
            Err(ChiroError::Closed) => panic!("char should have occurred or program should have terminated")
        }
    }
}