keybac 0.1.1

simple keyboard capturing lib
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

use std::cmp::PartialEq;
use std::io::{self, Read};
use std::os::unix::io::AsRawFd;
use std::time::Duration;
use libc::{termios, tcgetattr, tcsetattr, TCSANOW, ECHO, ICANON, fcntl, F_SETFL, O_NONBLOCK};
use crate::Keys::{Esc, Space};

pub struct KeyPress;

#[derive(Debug, PartialEq)]
pub enum Keys {
    Char(char),
    Ctrl(char),


    Esc,
    Space,
    Unknown,
}

impl Keys {
    pub fn to_string(&self) -> String {
        match self {
            Keys::Char(c) => c.to_string(),
            Keys::Ctrl(c) => format!("Ctrl+{}", c),

            Keys::Esc => "Esc".to_string(),
            Keys::Space => "Space".to_string(),
            Keys::Unknown => "Unknown".to_string(),
        }
    }

    pub fn is_escape(&self) -> bool {
        matches!(self, Keys::Esc)
    }

    pub fn is_space(&self) -> bool {
        matches!(self, Keys::Space)
    }

    pub fn is_ctrl_char(&self, ch: char) -> bool {
        matches!(self, Keys::Ctrl(c) if *c == ch)
    }
    pub fn is_char(&self, ch: char) -> bool {
        matches!(self, Keys::Char(c) if *c == ch)
    }
}

impl KeyPress {
    fn set_raw_mode(fd: i32, enable: bool) {
        let mut termios: termios = unsafe { std::mem::zeroed() };

        unsafe { tcgetattr(fd, &mut termios) };

        if enable {
            termios.c_lflag &= !(ICANON | ECHO);
        } else {
            termios.c_lflag |= ICANON | ECHO;
        }

        unsafe { tcsetattr(fd, TCSANOW, &termios) };
    }

    pub fn init() -> KeyPress {
        let stdin = io::stdin();
        let fd = stdin.as_raw_fd();
        Self::set_raw_mode(fd, true);

        unsafe {
            let flags = fcntl(fd, libc::F_GETFL);
            fcntl(fd, F_SETFL, flags | O_NONBLOCK);
        }

        KeyPress
    }

    pub fn read_key(&self) -> Option<Keys> {
        let mut stdin = io::stdin();
        let mut buffer = [0; 1];

        match stdin.read(&mut buffer) {
            Ok(1) => match buffer[0] {
                27 => Some(Keys::Esc),
                32 => Some(Keys::Space),
                c if c.is_ascii() && c.is_ascii_control() => {
                    let ctrl_char = (c+ 64) as char;
                    Some(Keys::Ctrl(c as char))
                },
                c if c.is_ascii() => Some(Keys::Char(c as char)),
                _ => Some(Keys::Unknown),
            },
            Ok(_) | Err(_) => None,
        }
    }

    pub fn get_key(&self) -> Option<String> {
        self.read_key().map(|key| key.to_string())
    }
}

impl Drop for KeyPress {
    fn drop(&mut self) {
        let stdin = io::stdin();
        let fd = stdin.as_raw_fd();
        KeyPress::set_raw_mode(fd, false);
    }
}