tfc 0.7.0

The Fat Controller. A library for simulating mouse and keyboard events.
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

use crate::{Key, linux_common};
use super::{ffi, Context, Error};

fn key_event(ctx: &Context, key: Key, down: bool) -> Result<(), Error> {
    ctx.write(ffi::EV_KEY, linux_common::to_key_code(key), i32::from(down))?;
    ctx.write_syn_report()
}

impl crate::KeyboardContext for Context {
    fn key_down(&mut self, key: Key) -> Result<(), Error> {
        key_event(self, key, true)
    }

    fn key_up(&mut self, key: Key) -> Result<(), Error> {
        key_event(self, key, false)
    }
}

#[cfg(feature = "ascii-fallback")]
use crate::{GenericError, AsciiKeyboardContext};

#[cfg(feature = "ascii-fallback")]
impl crate::UnicodeKeyboardContext for Context {
    fn unicode_char_down(&mut self, ch: char) -> Result<(), GenericError<Self::PlatformError>> {
        if !ch.is_ascii() {
            return Err(Error::UnsupportedUnicode(ch));
        }
        match self.ascii_char_down(ch as u8) {
            Err(Error::UnsupportedAscii(c)) => Err(Error::UnsupportedUnicode(c as char)),
            other => other,
        }
    }

    fn unicode_char_up(&mut self, ch: char) -> Result<(), GenericError<Self::PlatformError>> {
        if !ch.is_ascii() {
            return Err(Error::UnsupportedUnicode(ch));
        }
        match self.ascii_char_up(ch as u8) {
            Err(Error::UnsupportedAscii(c)) => Err(Error::UnsupportedUnicode(c as char)),
            other => other,
        }
    }

    fn unicode_char(&mut self, ch: char) -> Result<(), GenericError<Self::PlatformError>> {
        if !ch.is_ascii() {
            return Err(Error::UnsupportedUnicode(ch));
        }
        match self.ascii_char(ch as u8) {
            Err(Error::UnsupportedAscii(c)) => Err(Error::UnsupportedUnicode(c as char)),
            other => other,
        }
    }

    fn unicode_string(&mut self, s: &str) -> Result<(), GenericError<Self::PlatformError>> {
        match self.ascii_string(s.as_bytes()) {
            Err(Error::UnsupportedAscii(c)) => Err(Error::UnsupportedUnicode(c as char)),
            other => other,
        }
    }
}